def test_is_feature_enabled(self):
        request = RequestFactory().get('/')
        request.user = AnonymousUser()

        # Return True if no switch or flag are provided
        self.assertTrue(utils.is_feature_enabled({'switch': None, 'flag': None}, request))

        name = 'test-waffle'
        item = {'switch': 'test-waffle'}
        # Return False if switch inactive
        with override_switch(name, active=False):
            self.assertFalse(utils.is_feature_enabled(item, request))

        # Return True if switch active
        with override_switch(name, active=True):
            self.assertTrue(utils.is_feature_enabled(item, request))

        item = {'flag': 'test-waffle'}
        # Return False if flag inactive
        with override_flag(name, active=False):
            self.assertFalse(utils.is_feature_enabled(item, request))

        # Return True if flag active
        with override_flag(name, active=True):
            self.assertTrue(utils.is_feature_enabled(item, request))

    def test_description_optional(self):
        delicious = Addon.objects.get()
        assert delicious.type == amo.ADDON_EXTENSION

        with override_switch('content-optimization', active=False):
            form = forms.DescribeForm(
                {'name': u'Delicious for everyone', 'summary': u'foo',
                 'slug': u'bar'},
                request=self.request, instance=delicious)
            assert form.is_valid(), form.errors

        with override_switch('content-optimization', active=True):
            form = forms.DescribeForm(
                {'name': u'Delicious for everyone', 'summary': u'foo',
                 'slug': u'bar'},
                request=self.request, instance=delicious)
            assert not form.is_valid()

            # But only extensions are required to have a description
            delicious.update(type=amo.ADDON_STATICTHEME)
            form = forms.DescribeForm(
                {'name': u'Delicious for everyone', 'summary': u'foo',
                 'slug': u'bar'},
                request=self.request, instance=delicious)
            assert form.is_valid(), form.errors

            #  Do it again, but this time with a description
            delicious.update(type=amo.ADDON_EXTENSION)
            form = forms.DescribeForm(
                {'name': u'Delicious for everyone', 'summary': u'foo',
                 'slug': u'bar', 'description': u'its a description'},
                request=self.request,
                instance=delicious)
            assert form.is_valid(), form.errors

    def test_summary_min_length(self):
        delicious = Addon.objects.get()
        assert delicious.type == amo.ADDON_EXTENSION

        with override_switch('content-optimization', active=False):
            form = forms.DescribeForm(
                {'name': 'Delicious for everyone', 'summary': 'foo',
                 'slug': 'bar', 'description': '123456789'},
                request=self.request, instance=delicious)
            assert form.is_valid(), form.errors

        with override_switch('content-optimization', active=True):
            form = forms.DescribeForm(
                {'name': 'Delicious for everyone', 'summary': 'foo',
                 'slug': 'bar', 'description': '123456789'},
                request=self.request, instance=delicious)
            assert not form.is_valid()

            # But only extensions have a minimum length
            delicious.update(type=amo.ADDON_STATICTHEME)
            form = forms.DescribeForm(
                {'name': 'Delicious for everyone', 'summary': 'foo',
                 'slug': 'bar', 'description': '123456789'},
                request=self.request, instance=delicious)
            assert form.is_valid()

            #  Do it again, but this time with a description
            delicious.update(type=amo.ADDON_EXTENSION)
            form = forms.DescribeForm(
                {'name': 'Delicious for everyone', 'summary': 'foo',
                 'slug': 'bar', 'description': '1234567890'},
                request=self.request,
                instance=delicious)
            assert form.is_valid(), form.errors

    def test_new_switch(self):
        assert not Switch.objects.filter(name='foo').exists()

        with override_switch('foo', active=True):
            assert waffle.switch_is_active('foo')

        with override_switch('foo', active=False):
            assert not waffle.switch_is_active('foo')

        assert not Switch.objects.filter(name='foo').exists()

    def test_new_switch(self):
        assert not Switch.objects.filter(name="foo").exists()

        with override_switch("foo", active=True):
            assert waffle.switch_is_active(req(), "foo")

        with override_switch("foo", active=False):
            assert not waffle.switch_is_active(req(), "foo")

        assert not Switch.objects.filter(name="foo").exists()

    def test_switch_existed_and_was_NOT_active(self):
        Switch.objects.create(name='foo', active=False)

        with override_switch('foo', active=True):
            assert waffle.switch_is_active('foo')

        with override_switch('foo', active=False):
            assert not waffle.switch_is_active('foo')

        # make sure it didn't change 'active' value
        assert not Switch.objects.get(name='foo').active

    def test_cache_is_flushed_by_testutils_even_in_transaction(self):
        Switch.objects.create(name='foo', active=True)

        with transaction.atomic():
            with override_switch('foo', active=True):
                assert waffle.switch_is_active('foo')

            with override_switch('foo', active=False):
                assert not waffle.switch_is_active('foo')

        assert waffle.switch_is_active('foo')

    def test_switch_existed_and_was_active(self):
        Switch.objects.create(name="foo", active=True)

        with override_switch("foo", active=True):
            assert waffle.switch_is_active(req(), "foo")

        with override_switch("foo", active=False):
            assert not waffle.switch_is_active(req(), "foo")

        # make sure it didn't change 'active' value
        assert Switch.objects.get(name="foo").active

def test_maybe_check_with_akismet(body, pre_save_body, user_id,
                                  user_id_resp, waffle_enabled, is_checked):
    user = user_factory(
        id=user_id, username='u%s' % user_id, email='%[email protected]' % user_id)
    rating_kw = {
        'addon': addon_factory(),
        'user': user,
        'rating': 4,
        'body': body,
        'ip_address': '1.2.3.4'}

    if user_id_resp:
        rating_kw['user_responsible'] = (
            user if user_id_resp == user_id
            else user_factory(
                id=user_id_resp, username='u%s' % user_id_resp,
                email='%[email protected]' % user_id_resp))

    rating = Rating.objects.create(**rating_kw)
    request = RequestFactory().get('/')

    to_patch = 'olympia.ratings.utils.check_akismet_reports.delay'
    with mock.patch(to_patch) as check_akismet_reports_mock:
        with override_switch('akismet-spam-check', active=waffle_enabled):
            result = maybe_check_with_akismet(request, rating, pre_save_body)
            assert result == is_checked
            if is_checked:
                assert AkismetReport.objects.count() == 1
                check_akismet_reports_mock.assert_called()
            else:
                assert AkismetReport.objects.count() == 0
                check_akismet_reports_mock.assert_not_called()

def test_translate_template(client):
    url = reverse('pontoon.translate.next')

    with override_switch('translate_next', active=True):
        response = client.get(url)
        assert response.status_code == 200
        assert 'Translate.Next' in response.content

    def test_has_project_and_draft_registration(self):
        prereg_schema = RegistrationSchema.objects.get(name='Prereg Challenge')
        factories.DraftRegistrationFactory(
            initiator=self.user,
            registration_schema=prereg_schema
        )

        assert_equal(
            landing_page(user=self.user),
            {
                'has_projects': True,
                'has_draft_registrations': True,
                'campaign_long': 'Prereg Challenge',
                'campaign_short': 'prereg_challenge',
                'is_logged_in': True,
            }
        )

        with override_switch(name=OSF_PREREGISTRATION, active=True):
            prereg_schema = RegistrationSchema.objects.get(name='OSF Preregistration')
            factories.DraftRegistrationFactory(
                initiator=self.user,
                registration_schema=prereg_schema
            )
            assert_equal(
                landing_page(user=self.user),
                {
                    'has_projects': True,
                    'has_draft_registrations': True,
                    'campaign_long': 'OSF Preregistration',
                    'campaign_short': 'prereg',
                    'is_logged_in': True,
                }
            )

def test_check_akismet_reports(return_value, headers, waffle_on, flag_count):
    task_user = user_factory(id=settings.TASK_USER_ID)
    assert RatingFlag.objects.count() == 0
    rating = Rating.objects.create(
        addon=addon_factory(), user=user_factory(), rating=4, body=u'spám?',
        ip_address='1.2.3.4')
    akismet_report = AkismetReport.create_for_rating(rating, 'foo/baa', '')

    with mock.patch('olympia.lib.akismet.models.requests.post') as post_mock:
        # Mock a definitely spam response - same outcome
        post_mock.return_value.json.return_value = return_value
        post_mock.return_value.headers = headers
        with override_switch('akismet-rating-action', active=waffle_on):
            check_akismet_reports([akismet_report.id])

    RatingFlag.objects.count() == flag_count
    rating = rating.reload()
    if flag_count > 0:
        flag = RatingFlag.objects.get()
        assert flag.rating == rating
        assert flag.user == task_user
        assert flag.flag == RatingFlag.SPAM
        assert rating.editorreview
    else:
        assert not rating.editorreview

    def test_has_project(self):
        factories.ProjectFactory(creator=self.user)

        assert_equal(
            landing_page(user=self.user),
            {
                'has_projects': True,
                'has_draft_registrations': False,
                'campaign_long': 'Prereg Challenge',
                'campaign_short': 'prereg_challenge',
                'is_logged_in': True,
            }
        )

        with override_switch(name=OSF_PREREGISTRATION, active=True):
            assert_equal(
                landing_page(user=self.user),
                {
                    'has_projects': True,
                    'has_draft_registrations': False,
                    'campaign_long': 'OSF Preregistration',
                    'campaign_short': 'prereg',
                    'is_logged_in': True,
                }
            )

    def test_try_new_frontend_banner_presence(self):
        response = self.client.get(self.url)
        assert b'AMO is getting a new look.' not in response.content

        with override_switch('try-new-frontend', active=True):
            response = self.client.get(self.url)
            assert b'AMO is getting a new look.' in response.content

 def test_waffle_switch_inactive_does_not_enforce_csrf(self, app, url, payload):
     with override_switch('enforce_csrf', active=False):
         res = app.post_json_api(
             url,
             payload,
             expect_errors=True
         )
     assert res.status_code == 201

 def test_post_no_csrf_cookie(self, app, url, payload):
     with override_switch('enforce_csrf', active=True):
         res = app.post_json_api(
             url,
             payload,
             expect_errors=True
         )
     assert res.status_code == 403
     assert csrf.REASON_NO_CSRF_COOKIE in res.json['errors'][0]['detail']

def test_translate_behind_switch(client):
    url = reverse('pontoon.translate.next')

    response = client.get(url)
    assert response.status_code == 404

    with override_switch('translate_next', active=True):
        response = client.get(url)
        assert response.status_code == 200

def test_revisions_show_ips_button(switch, is_admin, root_doc, user_client,
                                   admin_client):
    """Toggle IPs button appears for admins when the switch is active."""
    client = admin_client if is_admin else user_client
    with override_switch('store_revision_ips', active=switch):
        response = client.get(reverse('dashboards.revisions'))
    assert response.status_code == 200
    page = pq(response.content)
    ip_button = page.find('button#show_ips_btn')
    assert len(ip_button) == (1 if (switch and is_admin) else 0)

 def test_send_csrf_cookie_and_headers(self, app, csrf_token, url, payload):
     app.set_cookie(CSRF_COOKIE_NAME, csrf_token)
     with override_switch('enforce_csrf', active=True):
         res = app.post_json_api(
             url,
             payload,
             headers={'X-CSRFToken': csrf_token},
             expect_errors=True
         )
     assert res.status_code == 201

 def test_post_without_csrf_in_headers(self, app, csrf_token, url, payload):
     app.set_cookie(CSRF_COOKIE_NAME, csrf_token)
     with override_switch('enforce_csrf', active=True):
         res = app.post_json_api(
             url,
             payload,
             expect_errors=True
         )
     assert res.status_code == 403
     assert csrf.REASON_BAD_TOKEN in res.json['errors'][0]['detail']