Python features.FeatureProfile类代码示例

 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