def test_feature_compatibility_no_current_version(self):
     self.app._current_version = None
     feature_profile = FeatureProfile(apps=True, nfc=True, mobileid=True)
     self.request = RequestFactory().get(
         '/?dev=firefoxos&pro=%s' % feature_profile.to_signature())
     res = self.serialize(self.app)
     eq_(res['feature_compatibility'], None)

 def test_from_old_signature(self):
     profile = FeatureProfile.from_signature(self.signature)
     self._test_profile_values(profile)
     new_signature = profile.to_signature()
     ok_(new_signature != self.signature)
     profile = FeatureProfile.from_signature(new_signature)
     self._test_profile_values(profile)

 def profile_qs(self, disabled_features=None):
     if disabled_features is None:
         disabled_features = {}
     profile = FeatureProfile().fromkeys(FeatureProfile(), True)
     for feature in disabled_features:
         profile[feature] = False
     return {'pro': profile.to_signature(), 'dev': 'firefoxos'}

 def test_feature_compatibility_false(self):
     self.app.current_version.features.update(has_apps=True, has_nfc=True)
     feature_profile = FeatureProfile(apps=False, nfc=True, mobileid=True)
     self.request = RequestFactory().get(
         '/?dev=firefoxos&pro=%s' % feature_profile.to_signature())
     res = self.serialize(self.app)
     eq_(res['feature_compatibility'], False)

 def test_feature_compatibility_always_none(self):
     # ES is already filtering by feature profile for us, so it does not
     # make much sense to check for feature compatibility in ES serializer.
     self.app.current_version.features.update(has_apps=True, has_nfc=True)
     self.reindex(Webapp)
     feature_profile = FeatureProfile(apps=False, nfc=True, mobileid=True)
     self.request = RequestFactory().get(
         '/?dev=firefoxos&pro=%s' % feature_profile.to_signature())
     self.request.REGION = mkt.regions.USA
     self.request.user = self.profile
     res = self.serialize()
     eq_(res['feature_compatibility'], None)

class TestLoadFeatureProfile(mkt.site.tests.TestCase):
    def setUp(self):
        super(TestLoadFeatureProfile, self).setUp()
        self.profile = FeatureProfile(apps=True)
        self.signature = self.profile.to_signature()

    def test_does_nothing_on_desktop(self):
        request = RequestFactory().get('/?dev=desktop&pro=%s' % self.signature)
        load_feature_profile(request)
        eq_(request.feature_profile, None)

    def test_does_nothing_without_dev_param(self):
        request = RequestFactory().get('/?pro=%s' % self.signature)
        load_feature_profile(request)
        eq_(request.feature_profile, None)
        request = RequestFactory().get(
            '/?device=mobilepro=%s' % self.signature)
        load_feature_profile(request)
        eq_(request.feature_profile, None)

    def test_does_nothing_without_profile_signature(self):
        request = RequestFactory().get('/?dev=firefoxos')
        load_feature_profile(request)
        eq_(request.feature_profile, None)

    def test_does_nothing_if_invalid_profile_signature_is_passed(self):
        request = RequestFactory().get('/?dev=firefoxos&pro=whatever')
        load_feature_profile(request)
        eq_(request.feature_profile, None)

    def test_works(self):
        request = RequestFactory().get(
            '/?dev=firefoxos&pro=%s' % self.signature)
        load_feature_profile(request)
        eq_(request.feature_profile.to_list(), self.profile.to_list())

    @mock.patch('mkt.features.utils.FeatureProfile.from_signature')
    def test_caching_on_request_property(self, from_signature_mock):
        fake_feature_profile = object()
        from_signature_mock.return_value = fake_feature_profile
        request = RequestFactory().get(
            '/?dev=firefoxos&pro=%s' % self.signature)
        load_feature_profile(request)
        eq_(request.feature_profile, fake_feature_profile)

        from_signature_mock.return_value = None
        load_feature_profile(request)
        # Should not be None thanks to the property caching.
        eq_(request.feature_profile, fake_feature_profile)

    def _test_kwargs(self, prefix):
        profile = FeatureProfile.from_int(self.features)
        kwargs = profile.to_kwargs(prefix=prefix)

        ok_(all([k.startswith(prefix) for k in kwargs.keys()]))
        eq_(kwargs.values().count(False), bin(self.features)[2:].count('0'))
        eq_(len(kwargs.values()), len(APP_FEATURES) - len(self.truths))

 def get_feature_profile(self, request):
     profile = None
     if request.GET.get('dev') in ('firefoxos', 'android'):
         sig = request.GET.get('pro')
         if sig:
             profile = FeatureProfile.from_signature(sig)
     return profile

 def test_from_list(self):
     bools = [False] * MOCK_APP_FEATURES_LIMIT
     bools[0] = True  # apps
     bools[4] = True  # light events
     bools[15] = True  # proximity
     bools[19] = True  # vibrate
     profile = FeatureProfile.from_list(bools)
     self._test_profile(profile)

 def get(self, request, *args, **kwargs):
     if 'pro' in request.GET:
         self.profile = FeatureProfile.from_signature(request.GET['pro'])
     else:
         self.profile = None
     features = OrderedDict(self._feature(i, slug) for i, slug in
                            enumerate(APP_FEATURES.keys()))
     return Response(features, status=status.HTTP_200_OK)

    def test_all_good_features_with_category(self):
        """Enable app features so they exactly match our device profile."""
        fp = FeatureProfile.from_signature(self.profile)
        self.app.current_version.features.update(**dict(("has_%s" % k, v) for k, v in fp.items()))
        self.reindex(Webapp, "webapp")

        res = self.client.get(self.list_url + (self.qs,))
        eq_(res.status_code, 200)
        eq_(len(res.json["featured"]), 1)
        eq_(int(res.json["featured"][0]["id"]), self.app.pk)

    def _test_kwargs(self, prefix, only_true):
        profile = FeatureProfile.from_binary(self.binary)
        kwargs = profile.to_kwargs(prefix=prefix, only_true=only_true)

        ok_(all([k.startswith(prefix) for k in kwargs.keys()]))
        eq_(kwargs.values().count(True), self.binary.count('1'))
        if only_true:
            eq_(kwargs.values().count(False), 0)
        else:
            eq_(kwargs.values().count(False), self.binary.count('0'))

    def test_all_good_features(self):
        # Enable app features so they exactly match our device profile.
        fp = FeatureProfile.from_signature(self.profile)
        self.webapp.current_version.features.update(**dict(("has_%s" % k, v) for k, v in fp.items()))
        self.webapp.save()
        self.refresh("webapp")

        res = self.client.get(self.url + (self.qs,))
        eq_(res.status_code, 200)
        obj = json.loads(res.content)["objects"][0]
        eq_(obj["slug"], self.webapp.app_slug)

    def test_all_good_features(self):
        # Enable app features so they exactly match our device profile.
        fp = FeatureProfile.from_signature(self.features)
        self.webapp.current_version.features.update(
            **dict(('has_%s' % k, v) for k, v in fp.items()))
        self.webapp.save()
        self.refresh('webapp')

        res = self.client.get(self.url, data=self.qs)
        eq_(res.status_code, 200)
        obj = json.loads(res.content)['objects'][0]
        eq_(obj['slug'], self.webapp.app_slug)

def get_feature_profile(request):
    profile = None
    platforms = ('firefoxos', 'android')
    if (request.GET.get('dev') in platforms or
        request.GET.get('platform') in platforms):
        sig = request.GET.get('pro')
        if sig:
            try:
                profile = FeatureProfile.from_signature(sig)
            except ValueError:
                pass
    return profile

    def field_to_native(self, obj, field_name):
        value = get_component(obj, self.source)

        # Filter apps based on feature profiles.
        if hasattr(self, 'context') and 'request' in self.context:
            sig = self.context['request'].GET.get('pro')
            if sig:
                try:
                    profile = FeatureProfile.from_signature(sig)
                except ValueError:
                    pass
                else:
                    value = value.filter(**profile.to_kwargs(
                        prefix='app___current_version__features__has_'))

        return [self.to_native(item) for item in value.all()]

def device_queue_search(request):
    """
    Returns a queryset that can be used as a base for searching the device
    specific queue.
    """
    filters = {
        'status': amo.STATUS_PENDING,
        'disabled_by_user': False,
    }
    sig = request.GET.get('pro')
    if sig:
        profile = FeatureProfile.from_signature(sig)
        filters.update(dict(
            **profile.to_kwargs(prefix='_latest_version__features__has_')
        ))
    return Webapp.version_and_file_transformer(
        Webapp.objects.filter(**filters))

def load_feature_profile(request):
    """
    Adds a `feature_profile` on the request object if one is present and the
    dev parameter is either firefoxos or android.

    Does nothing if one was already set.
    """
    if hasattr(request, 'feature_profile'):
        return
    profile = None
    if request.GET.get('dev') in ('firefoxos', 'android'):
        sig = request.GET.get('pro')
        if sig:
            try:
                profile = FeatureProfile.from_signature(sig)
            except ValueError:
                pass
    request.feature_profile = profile

    def alter_list_data_to_serialize(self, request, data):
        form_data = self.search_form(request)
        region = getattr(request, 'REGION', mkt.regions.WORLDWIDE)
        if form_data['cat']:
            category = Category.objects.get(pk=form_data['cat'])
        else:
            category = None

        # Filter by device feature profile.
        profile = None
        if request.GET.get('dev') in ('firefoxos', 'android'):
            sig = request.GET.get('pro')
            if sig:
                profile = FeatureProfile.from_signature(sig)

        qs = Webapp.featured(cat=category, region=region, profile=profile)

        bundles = [self.build_bundle(obj=obj, request=request) for obj in qs]
        data['featured'] = [AppResource().full_dehydrate(bundle)
                            for bundle in bundles]
        return data

    def alter_list_data_to_serialize(self, request, data):
        form_data = self.search_form(request)
        region = getattr(request, 'REGION', mkt.regions.WORLDWIDE)
        cat_slug = form_data.get('cat')
        if cat_slug:
            cat_slug = [cat_slug]

        # Filter by device feature profile.
        profile = None
        if request.GET.get('dev') in ('firefoxos', 'android'):
            sig = request.GET.get('pro')
            if sig:
                profile = FeatureProfile.from_signature(sig)

        qs = Webapp.featured(cat=cat_slug, region=region, profile=profile)

        bundles = [self.build_bundle(obj=obj, request=request) for obj in qs]
        data['featured'] = [AppResource().full_dehydrate(bundle)
                            for bundle in bundles]
        # Alter the _view_name so that statsd logs seperately from search.
        request._view_name = 'featured'
        return data