text: """Tests for Review Board features."""
  
  from django.contrib.auth.models import AnonymousUser, User
  from django.test.client import RequestFactory
  from djblets.features import Feature, get_features_registry
  from djblets.testing.decorators import add_fixtures
  
  from reviewboard.features.checkers import RBFeatureChecker
  from reviewboard.site.models import LocalSite
  from reviewboard.testing import TestCase
  
  
  class DummyFeature(Feature):
      """A dummy feature for testing."""
  
      feature_id = 'dummy.feature'
      name = 'Dummy feature'
      summary = 'A dummy feature for testing.'
  
  
  class RBFeatureCheckerTests(TestCase):
      """Tests for the RBFeatureChecker."""
  
      fixtures = ['test_site']
  
      FEATURE_ENABLED_SETTINGS = {
          DummyFeature.feature_id: True,
      }
  
      FEATURE_DISABLED_SETTINGS = {
          DummyFeature.feature_id: False,
      }
  
      @classmethod
      def setUpClass(cls):
          super(RBFeatureCheckerTests, cls).setUpClass()
  
          cls.request_factory = RequestFactory()
  
      def setUp(self):
          super(RBFeatureCheckerTests, self).setUp()
          self.feature = DummyFeature()
          self.local_site = LocalSite.objects.get(name='local-site-1')
  
      def tearDown(self):
          super(RBFeatureCheckerTests, self).tearDown()
          registry = get_features_registry()
          registry.unregister(self.feature)
  
      def test_local_site_feature_enabled(self):
          """Testing RBFeatureChecker.is_feature_enabled for a feature enabled on
          a local site
          """
          self.local_site.extra_data = {
              RBFeatureChecker.EXTRA_DATA_KEY: self.FEATURE_ENABLED_SETTINGS,
          }
  
          with self.settings(ENABLED_FEATURES=self.FEATURE_DISABLED_SETTINGS):
              self.assertTrue(RBFeatureChecker().is_feature_enabled(
                  DummyFeature.feature_id, local_site=self.local_site))
  
      def test_local_site_feature_disabled(self):
          """Testing RBFeatureChecker.is_feature_enabled for a feature disabled
          on a local site
          """
          self.local_site.extra_data = {
              RBFeatureChecker.EXTRA_DATA_KEY: self.FEATURE_DISABLED_SETTINGS,
          }
  
          with self.settings(ENABLED_FEATURES=self.FEATURE_ENABLED_SETTINGS):
              self.assertTrue(RBFeatureChecker().is_feature_enabled(
                  DummyFeature.feature_id, local_site=self.local_site))
  
      def test_local_site_feature_fallback_enabled(self):
          """Testing RBFeatureChecker.is_feature_enabled for an unconfigured
          feature on a LocalSite that is enabled globally
          """
          self.local_site.extra_data = {
              RBFeatureChecker.EXTRA_DATA_KEY: {},
          }
  
          with self.settings(ENABLED_FEATURES=self.FEATURE_ENABLED_SETTINGS):
              self.assertTrue(RBFeatureChecker().is_feature_enabled(
                  DummyFeature.feature_id, local_site=self.local_site))
  
      def test_local_site_feature_fallback_disabled(self):
          """Testing RBFeatureChecker.is_feature_enabled for an unconfigured
          feature on a LocalSite that is disabled globally
          """
          self.local_site.extra_data = {
              RBFeatureChecker.EXTRA_DATA_KEY: {},
          }
  
          with self.settings(ENABLED_FEATURES=self.FEATURE_DISABLED_SETTINGS):
              self.assertFalse(RBFeatureChecker().is_feature_enabled(
                  DummyFeature.feature_id, local_site=self.local_site))
  
      @add_fixtures(['test_users'])
      def test_local_site_feature_enabled_on_global(self):
          """Testing RBFeatureChecker.is_feature_enabled for a feature enabled on
          a local site while not on a site
          """
          self.local_site.extra_data = {
              RBFeatureChecker.EXTRA_DATA_KEY: self.FEATURE_ENABLED_SETTINGS,
          }
          self.local_site.save()
  
          request = self.request_factory.get('/')
          request.user = User.objects.get(username='doc')
          request.local_site = None
  
          with self.settings(ENABLED_FEATURES=self.FEATURE_DISABLED_SETTINGS):
              self.assertTrue(RBFeatureChecker().is_feature_enabled(
                  DummyFeature.feature_id,
                  request=request,
                  force_check_user_local_sites=True))
  
      @add_fixtures(['test_users'])
      def test_local_site_feature_disabled_on_global(self):
          """Testing RBFeatureChecker.is_feature_enabled for a feature disabled
          on a local site while not on a site
          """
          self.local_site.extra_data = {
              RBFeatureChecker.EXTRA_DATA_KEY: self.FEATURE_DISABLED_SETTINGS,
          }
          self.local_site.save()
  
          request = self.request_factory.get('/')
          request.user = User.objects.get(username='doc')
          request.local_site = None
  
          with self.settings(ENABLED_FEATURES=self.FEATURE_ENABLED_SETTINGS):
              self.assertTrue(RBFeatureChecker().is_feature_enabled(
                  DummyFeature.feature_id,
                  request=request))
  
      @add_fixtures(['test_users'])
      def test_cache_localsite_queries(self):
          """Testing RBFeatureChecker.is_feature_enabled caches LocalSite
          membership to reduce query count
          """
          self.local_site.extra_data = {
              RBFeatureChecker.EXTRA_DATA_KEY: self.FEATURE_ENABLED_SETTINGS,
          }
          self.local_site.save()
  
          request = self.request_factory.get('/')
          request.user = User.objects.get(username='doc')
  
          with self.assertNumQueries(1):
              for i in range(3):
                  self.assertTrue(RBFeatureChecker().is_feature_enabled(
                      DummyFeature.feature_id,
                      request=request,
                      force_check_user_local_sites=True))
  
      def test_no_queries_anonymous(self):
          """Testing RBFeatureChecker.is_feature_enabled does not query when the
          user is anonymous
          """
          self.local_site.extra_data = {
              RBFeatureChecker.EXTRA_DATA_KEY: self.FEATURE_ENABLED_SETTINGS,
          }
          self.local_site.save()
  
          request = self.request_factory.get('/')
          request.user = AnonymousUser()
  
          with self.assertNumQueries(0):
              for i in range(3):
                  self.assertFalse(RBFeatureChecker().is_feature_enabled(
                      DummyFeature.feature_id,
                      request=request))
  