Example #1
0
    def test_normal(self):
        addon = addon_factory()
        author = user_factory(username=u'Authør')
        AddonUser.objects.create(addon=addon, user=author)
        # Add a pending info request expiring soon.
        flags = AddonReviewerFlags.objects.create(
            addon=addon,
            pending_info_request=datetime.now() + timedelta(hours=23),
            notified_about_expiring_info_request=False)
        # Create reviewer and staff users, and create the request for info
        # activity. Neither the reviewer nor the staff user should be cc'ed.
        reviewer = user_factory(username=u'Revièwer')
        self.grant_permission(reviewer, 'Addons:Review')
        ActivityLog.create(
            amo.LOG.REQUEST_INFORMATION, addon, addon.current_version,
            user=reviewer, details={'comments': u'Fly you fôöls!'})
        staff = user_factory(username=u'Staff Ûser')
        self.grant_permission(staff, 'Some:Perm', name=ACTIVITY_MAIL_GROUP)

        # Fire the command.
        call_command('send_info_request_last_warning_notifications')

        assert len(mail.outbox) == 1
        msg = mail.outbox[0]
        assert msg.to == [author.email]
        assert msg.subject == u'Mozilla Add-ons: Action Required for %s %s' % (
            addon.name, addon.current_version.version)
        assert 'an issue when reviewing ' in msg.body
        assert 'within one (1) day' in msg.body

        flags.reload()
        assert flags.notified_about_expiring_info_request is True
Example #2
0
    def test_list(self):
        addon = Addon.objects.get(pk=3615)
        user = UserProfile.objects.get(pk=999)

        # Create a few abuse reports
        AbuseReport.objects.create(addon=addon, message='Foo')
        AbuseReport.objects.create(
            addon=addon, reporter=user_factory(), message='Bar')
        # This is a report for an addon not in the database
        AbuseReport.objects.create(guid='@guid', message='Foo')
        AbuseReport.objects.create(user=user_factory(), message='Eheheheh')

        url = reverse('admin:abuse_abusereport_changelist')
        self.grant_permission(user, '*:*')
        self.client.login(email=user.email)
        response = self.client.get(url, follow=True)
        assert response.status_code == 200
        doc = pq(response.content)
        assert doc('#result_list tbody tr').length == 4

        response = self.client.get(url, {'type': 'addon'}, follow=True)
        assert response.status_code == 200
        doc = pq(response.content)
        assert doc('#result_list tbody tr').length == 3

        response = self.client.get(url, {'type': 'user'}, follow=True)
        assert response.status_code == 200
        doc = pq(response.content)
        assert doc('#result_list tbody tr').length == 1
Example #3
0
 def setUp(self):
     user_factory(
         id=settings.TASK_USER_ID, username='******',
         email='*****@*****.**')
     self.addons = [
         addon_factory(average_daily_users=666, users=[user_factory()]),
         addon_factory(average_daily_users=999, users=[user_factory()]),
     ]
     self.versions = [
         version_factory(
             addon=self.addons[0], file_kw={
                 'status': amo.STATUS_AWAITING_REVIEW,
                 'is_webextension': True}),
         version_factory(
             addon=self.addons[1], file_kw={
                 'status': amo.STATUS_AWAITING_REVIEW,
                 'is_webextension': True}),
     ]
     self.files = [
         self.versions[0].all_files[0],
         self.versions[1].all_files[0],
     ]
     self.versions[0].update(nomination=days_ago(1))
     FileValidation.objects.create(
         file=self.versions[0].all_files[0], validation=u'{}')
     FileValidation.objects.create(
         file=self.versions[1].all_files[0], validation=u'{}')
     super(TestAutoApproveCommandTransactions, self).setUp()
Example #4
0
    def test_creation_triggers_email_and_logging(self):
        addon = Addon.objects.get(pk=4)
        addon_author = user_factory()
        addon.addonuser_set.create(user=addon_author)
        review_user = user_factory()
        review = Review.objects.create(
            user=review_user, addon=addon,
            body=u'Rêviiiiiiew', user_responsible=review_user)

        activity_log = ActivityLog.objects.latest('pk')
        assert activity_log.user == review_user
        assert activity_log.arguments == [addon, review]
        assert activity_log.action == amo.LOG.ADD_REVIEW.id

        assert len(mail.outbox) == 1
        email = mail.outbox[0]
        reply_url = helpers.absolutify(
            helpers.url('addons.reviews.reply', addon.slug,
                        review.pk, add_prefix=False))
        assert email.subject == 'Mozilla Add-on User Review: my addon name'
        assert 'A user has left a review for your add-on,' in email.body
        assert 'my addon name' in email.body
        assert reply_url in email.body
        assert email.to == [addon_author.email]
        assert email.from_email == 'Mozilla Add-ons <*****@*****.**>'
Example #5
0
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
Example #6
0
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='******' % user_id, email='%s@e' % 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='******' % user_id_resp,
                email='%s@e' % 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()
Example #7
0
def test_repack_themes_for_69():
    user_factory(id=settings.TASK_USER_ID)
    broken_theme = addon_factory(name='broken')
    already_theme = addon_factory(name='already')
    deprecated_theme = addon_factory(
        name='deprecated', version_kw={'version': '1.0'})

    to_mock = 'olympia.addons.tasks.new_theme_version_with_69_properties'
    with mock.patch(to_mock) as new_theme_version_with_69_properties_mock:
        with mock.patch('olympia.addons.tasks.parse_addon') as parse_mock:
            parse_mock.configure_mock(side_effect=[
                IOError(),
                {'theme': {'colors': {'frame': '#baa'}}},
                {'theme': {'colors': {'accentcolor': '#f00'}}},
            ])
            # call the task, as the command would:
            repack_themes_for_69([
                broken_theme.id,
                already_theme.id,
                deprecated_theme.id,
            ])

        new_theme_version_with_69_properties_mock.assert_called_once()
        new_theme_version_with_69_properties_mock.assert_called_with(
            deprecated_theme.current_version)
Example #8
0
    def test_add_static_theme_from_lwt(self):
        author = user_factory()
        persona = addon_factory(
            type=amo.ADDON_PERSONA, users=[author], name='Firefox Theme')
        persona.update(
            created=self.create_date, modified=self.modify_date,
            last_updated=self.update_date)
        persona.persona.license = licenses.LICENSE_CC_BY_ND.id
        Tag.objects.create(tag_text='themey').save_tag(persona)
        License.objects.create(builtin=licenses.LICENSE_CC_BY_ND.builtin)
        rating_user = user_factory()
        rating = Rating.objects.create(
            addon=persona, version=persona.current_version, user=rating_user,
            rating=2, body=u'fooooo', user_responsible=rating_user)
        ThemeUpdateCount.objects.create(
            addon_id=persona.id, date=datetime(2018, 1, 1), count=123)
        ThemeUpdateCount.objects.create(
            addon_id=persona.id, date=datetime(2018, 2, 1), count=456)
        # Create a count for an addon that shouldn't be migrated too.
        ThemeUpdateCount.objects.create(
            addon_id=addon_factory().id, date=datetime(2018, 2, 1), count=45)
        # And add it to a collection
        collection = collection_factory()
        collection.add_addon(persona)
        collection.add_addon(addon_factory())

        static_theme = add_static_theme_from_lwt(persona)

        self._check_result(
            static_theme, [author], list(persona.tags.all()),
            persona.all_categories, licenses.LICENSE_CC_BY_ND.builtin,
            [rating], collection)
    def test_can_not_delete_with_admin_curation_permission(self):
        collection = Collection.objects.create(slug='floob')
        self.delete_url = reverse(
            'admin:bandwagon_collection_delete', args=(collection.pk,)
        )
        user = user_factory()
        self.grant_permission(user, 'Admin:Tools')
        self.grant_permission(user, 'Admin:Curation')
        self.client.login(email=user.email)
        response = self.client.get(self.delete_url, follow=True)
        assert response.status_code == 403
        response = self.client.post(
            self.delete_url, data={'post': 'yes'}, follow=True)
        assert response.status_code == 403
        assert Collection.objects.filter(pk=collection.pk).exists()

        # Even a mozilla one.
        mozilla = user_factory(username='******', id=settings.TASK_USER_ID)
        collection.update(author=mozilla)
        response = self.client.get(self.delete_url, follow=True)
        assert response.status_code == 403
        response = self.client.post(
            self.delete_url, data={'post': 'yes'}, follow=True)
        assert response.status_code == 403
        assert Collection.objects.filter(pk=collection.pk).exists()
Example #10
0
    def test_list(self):
        self.addons = {}
        for item in discopane_items:
            type_ = amo.ADDON_EXTENSION
            if not item.heading and not item.description:
                type_ = amo.ADDON_PERSONA
                author = user_factory()
            self.addons[item.addon_id] = addon_factory(
                id=item.addon_id, type=type_)
            if type_ == amo.ADDON_PERSONA:
                self.addons[item.addon_id].addonuser_set.create(user=author)
                self.addons[item.addon_id].addonuser_set.create(
                    user=user_factory())

        response = self.client.get(self.url, {'lang': 'en-US'})
        assert response.data

        assert response.data['count'] == len(discopane_items)
        assert response.data['next'] is None
        assert response.data['previous'] is None
        assert response.data['results']

        for i, result in enumerate(response.data['results']):
            if 'theme_data' in result['addon']:
                self._check_disco_theme(result, discopane_items[i])
            else:
                self._check_disco_addon(result, discopane_items[i])
Example #11
0
 def setUpTestData(cls):
     cls.addon1 = addon_factory(guid='@guid1')
     cls.addon2 = addon_factory(guid='@guid2')
     cls.addon3 = addon_factory(guid='@guid3')
     cls.user = user_factory()
     grant_permission(cls.user, 'Admin:Tools', 'Admin Group')
     grant_permission(cls.user, 'AbuseReports:Edit', 'Abuse Report Triage')
     # Create a few abuse reports.
     AbuseReport.objects.create(
         addon=cls.addon1, guid='@guid1', message='Foo',
         state=AbuseReport.STATES.VALID,
         created=days_ago(98))
     AbuseReport.objects.create(
         addon=cls.addon2, guid='@guid2', message='Bar',
         state=AbuseReport.STATES.VALID)
     AbuseReport.objects.create(
         addon=cls.addon3, guid='@guid3', message='Soap',
         reason=AbuseReport.REASONS.OTHER,
         created=days_ago(100))
     AbuseReport.objects.create(
         addon=cls.addon1, guid='@guid1', message='',
         reporter=user_factory())
     # This is a report for an addon not in the database.
     AbuseReport.objects.create(
         guid='@unknown_guid', addon_name='Mysterious Addon', message='Doo')
     # This is one against a user.
     AbuseReport.objects.create(
         user=user_factory(), message='Eheheheh')
Example #12
0
    def test_queries(self):
        addon = Addon.objects.get(pk=3615)
        user = UserProfile.objects.get(pk=999)

        # Create a few more ratings.
        Rating.objects.create(
            addon=addon, user=user_factory(), rating=4,
            body=u'Lôrem ipsum dolor sit amet, per at melius fuisset '
                 u'invidunt, ea facete aperiam his. Et cum iusto detracto, '
                 u'nam atqui nostrum no, eum altera indoctum ad. Has ut duis '
                 u'tractatos laboramus, cum sale primis ei. Ius inimicus '
                 u'intellegebat ea, mollis expetendis usu ei. Cetero aeterno '
                 u'nostrud eu për.')
        Rating.objects.create(
            addon=addon, body=None, rating=5, user=user_factory())
        # Create a reply.
        Rating.objects.create(
            addon=addon, user=user, body=u'Réply', reply_to=self.rating)

        self.grant_permission(user, 'Admin:Tools')
        self.grant_permission(user, 'Ratings:Moderate')

        self.client.login(email=user.email)
        with self.assertNumQueries(10):
            # - 2 Savepoint/release
            # - 2 user and its groups
            # - 2 COUNT(*) (duplicated because of django)
            # - 1 ratings themselves
            # - 1 related add-ons
            # - 1 related add-ons translations
            response = self.client.get(self.list_url, follow=True)
        assert response.status_code == 200
        doc = pq(response.content)
        assert doc('#result_list tbody tr').length == 4
Example #13
0
 def test_authors(self):
     addon = self.new_file()['addon']
     bert = user_factory(username='******')
     ernie = user_factory(username='******')
     AddonUser.objects.create(addon=addon, user=bert)
     AddonUser.objects.create(addon=addon, user=ernie)
     row = self.Queue.objects.all()[0]
     self.assertSetEqual(row.authors,
                         [(ernie.id, 'ernie'), (bert.id, 'bert')])
Example #14
0
    def test_blocked_subdomain(self):
        EmailUserRestriction.objects.create(email_pattern='*@faz.bar.com')

        request = RequestFactory().get('/')
        request.user = user_factory(email='*****@*****.**')
        assert not EmailUserRestriction.allow_request(request)

        request.user = user_factory(email='*****@*****.**')
        assert EmailUserRestriction.allow_request(request)
Example #15
0
 def setUp(self):
     super(TestAddStaticThemeFromLwt, self).setUp()
     self.call_signing_mock = self.patch(
         'olympia.lib.crypto.signing.call_signing')
     self.build_mock = self.patch(
         'olympia.addons.tasks.build_static_theme_xpi_from_lwt')
     self.build_mock.side_effect = self._mock_xpi_side_effect
     self.call_signing_mock.return_value = 'abcdefg1234'
     user_factory(id=settings.TASK_USER_ID, email='*****@*****.**')
Example #16
0
def addon(transactional_db, create_superuser, pytestconfig):
    """Creates a custom addon named 'Ui-Addon'.

    This addon will be a featured addon and will have a featured collecton
    attatched to it. It will belong to the user created by the
    'create_superuser' fixture.

    It has 1 preview, 5 reviews, and 2 authors. The second author is named
    'ui-tester2'. It has a version number as well as a beta version.
    """
    if not pytestconfig.option.usingliveserver:
        return

    default_icons = [x[0] for x in icons() if x[0].startswith('icon/')]
    addon = addon_factory(
        status=STATUS_PUBLIC,
        type=ADDON_EXTENSION,
        average_daily_users=5567,
        users=[UserProfile.objects.get(username='******')],
        average_rating=5,
        description=u'My Addon description',
        file_kw={
            'hash': 'fakehash',
            'platform': amo.PLATFORM_ALL.id,
            'size': 42,
        },
        guid=generate_addon_guid(),
        homepage=u'https://www.example.org/',
        icon_type=random.choice(default_icons),
        name=u'Ui-Addon',
        public_stats=True,
        slug='ui-test',
        summary=u'My Addon summary',
        support_email=u'*****@*****.**',
        support_url=u'https://support.example.org/support/ui-test-addon/',
        tags=['some_tag', 'another_tag', 'ui-testing',
              'selenium', 'python'],
        total_reviews=888,
        weekly_downloads=2147483647,
        developer_comments='This is a testing addon, used within pytest.',
        is_experimental=True,
    )
    Preview.objects.create(addon=addon, position=1)
    Review.objects.create(addon=addon, rating=5, user=user_factory())
    Review.objects.create(addon=addon, rating=3, user=user_factory())
    Review.objects.create(addon=addon, rating=2, user=user_factory())
    Review.objects.create(addon=addon, rating=1, user=user_factory())
    addon.reload()
    AddonUser.objects.create(user=user_factory(username='******'),
                             addon=addon, listed=True)
    version_factory(addon=addon, file_kw={'status': amo.STATUS_BETA},
                    version='1.1beta')
    addon.save()
    generate_collection(addon, app=FIREFOX)
    print('Created addon {0} for testing successfully'.format(addon.name))
    return addon
Example #17
0
    def test_can_delete_with_related_objects_with_admin_advanced_permission(
            self):
        # Add related instances...
        addon = addon_factory()
        addon_with_other_authors = addon_factory()
        AddonUser.objects.create(
            addon=addon_with_other_authors, user=user_factory())
        relations_that_should_be_deleted = [
            AddonUser.objects.create(
                addon=addon_with_other_authors, user=self.user),
            Rating.objects.create(
                addon=addon_factory(), rating=5, user=self.user),
            addon,  # Has no other author, should be deleted.
            collection_factory(author=self.user)
        ]
        relations_that_should_survive = [
            AbuseReport.objects.create(reporter=self.user),
            AbuseReport.objects.create(user=self.user),
            ActivityLog.create(user=self.user, action=amo.LOG.USER_EDITED),
            ReviewerScore.objects.create(user=self.user, score=42),
            addon_with_other_authors,  # Has other authors, should be kept.

            # Bit of a weird case, but because the user was the only author of
            # this add-on, the addonuser relation is kept, and both the add-on
            # and the user are soft-deleted. This is in contrast with the case
            # where the user is *not* the only author, in which case the
            # addonuser relation is deleted, but the add-on is left intact.
            AddonUser.objects.create(addon=addon, user=self.user),
        ]

        # Now test as normal.
        user = user_factory()
        assert not self.user.deleted
        self.grant_permission(user, 'Admin:Tools')
        self.grant_permission(user, 'Admin:Advanced')
        self.client.login(email=user.email)
        core.set_user(user)
        response = self.client.get(self.delete_url, follow=True)
        assert response.status_code == 200
        assert b'Cannot delete user' not in response.content
        response = self.client.post(self.delete_url, {'post': 'yes'},
                                    follow=True)
        assert response.status_code == 200
        self.user.reload()
        assert self.user.deleted
        assert self.user.email is None
        alog = ActivityLog.objects.filter(
            action=amo.LOG.ADMIN_USER_ANONYMIZED.id).get()
        assert alog.arguments == [self.user]

        # Test the related instances we created earlier.
        for obj in relations_that_should_be_deleted:
            assert not obj.__class__.objects.filter(pk=obj.pk).exists()

        for obj in relations_that_should_survive:
            assert obj.__class__.objects.filter(pk=obj.pk).exists()
 def setUp(self):
     super(TestAddStaticThemeFromLwt, self).setUp()
     self.call_signing_mock = self.patch(
         'olympia.lib.crypto.packaged.call_signing')
     self.build_mock = self.patch(
         'olympia.addons.tasks.build_static_theme_xpi_from_lwt')
     self.build_mock.side_effect = self._mock_xpi_side_effect
     self.call_signing_mock.return_value = 'abcdefg1234'
     AppVersion.objects.get_or_create(
         application=amo.FIREFOX.id, version='53.0')
     AppVersion.objects.get_or_create(
         application=amo.FIREFOX.id, version='*')
     user_factory(id=settings.TASK_USER_ID, email='*****@*****.**')
Example #19
0
    def setUp(self):
        self.developer = user_factory()
        self.developer2 = user_factory()
        self.reviewer = user_factory()
        self.grant_permission(self.reviewer, 'Addons:Review',
                              'Addon Reviewers')

        self.addon = addon_factory()
        self.version = self.addon.find_latest_version(
            channel=amo.RELEASE_CHANNEL_LISTED)
        self.addon.addonuser_set.create(user=self.developer)
        self.addon.addonuser_set.create(user=self.developer2)
        self.task_user = user_factory(id=settings.TASK_USER_ID)
Example #20
0
    def test_ban_and_disable_related_content_bulk(self, hide_disabled_mock):
        user_sole = user_factory(email='*****@*****.**', fxa_id='13579')
        addon_sole = addon_factory(users=[user_sole])
        self.setup_user_to_be_have_content_disabled(user_sole)
        user_multi = user_factory(email='*****@*****.**', fxa_id='24680')
        innocent_user = user_factory()
        addon_multi = addon_factory(
            users=UserProfile.objects.filter(
                id__in=[user_multi.id, innocent_user.id]))
        self.setup_user_to_be_have_content_disabled(user_multi)

        # Now that everything is set up, disable/delete related content.
        UserProfile.ban_and_disable_related_content_bulk(
            [user_sole, user_multi])

        addon_sole.reload()
        addon_multi.reload()
        # if sole dev should have been disabled, but the author retained
        assert addon_sole.status == amo.STATUS_DISABLED
        assert list(addon_sole.authors.all()) == [user_sole]
        # shouldn't have been disabled as it has another author
        assert addon_multi.status != amo.STATUS_DISABLED
        assert list(addon_multi.authors.all()) == [innocent_user]

        # the File objects have been disabled
        assert not File.objects.filter(version__addon=addon_sole).exclude(
            status=amo.STATUS_DISABLED).exists()
        # But not for the Add-on that wasn't disabled
        assert File.objects.filter(version__addon=addon_multi).exclude(
            status=amo.STATUS_DISABLED).exists()

        assert not user_sole._ratings_all.exists()  # Even replies.
        assert not user_sole.collections.exists()
        assert not user_multi._ratings_all.exists()  # Even replies.
        assert not user_multi.collections.exists()

        assert not storage.exists(user_sole.picture_path)
        assert not storage.exists(user_sole.picture_path_original)
        assert not storage.exists(user_multi.picture_path)
        assert not storage.exists(user_multi.picture_path_original)

        assert user_sole.deleted
        assert user_sole.email == '*****@*****.**'
        assert user_sole.auth_id
        assert user_sole.fxa_id == '13579'
        assert user_multi.deleted
        assert user_multi.email == '*****@*****.**'
        assert user_multi.auth_id
        assert user_multi.fxa_id == '24680'

        hide_disabled_mock.assert_not_called()
Example #21
0
 def test_search_for_multiple_users(self):
     user = user_factory()
     another_user = user_factory()
     self.grant_permission(user, 'Admin:Tools')
     self.grant_permission(user, 'Users:Edit')
     self.client.login(email=user.email)
     response = self.client.get(
         self.list_url,
         {'q': '%s,%s,foobaa' % (self.user.pk, another_user.pk)},
         follow=True)
     assert response.status_code == 200
     doc = pq(response.content)
     assert str(self.user.pk) in doc('#result_list').text()
     assert str(another_user.pk) in doc('#result_list').text()
Example #22
0
    def test_list(self):
        addon = Addon.objects.get(pk=3615)
        user = UserProfile.objects.get(pk=999)

        # Create a few more ratings.
        Rating.objects.create(
            addon=addon, user=user_factory(), rating=4,
            body=u'Lôrem ipsum dolor sit amet, per at melius fuisset '
                 u'invidunt, ea facete aperiam his. Et cum iusto detracto, '
                 u'nam atqui nostrum no, eum altera indoctum ad. Has ut duis '
                 u'tractatos laboramus, cum sale primis ei. Ius inimicus '
                 u'intellegebat ea, mollis expetendis usu ei. Cetero aeterno '
                 u'nostrud eu për.')
        Rating.objects.create(
            addon=addon, body=None, rating=5, user=user_factory())
        # Create a reply.
        Rating.objects.create(
            addon=addon, user=user, body=u'Réply', reply_to=self.rating)

        self.grant_permission(user, 'Admin:Tools')
        self.grant_permission(user, 'Ratings:Moderate')

        self.client.login(email=user.email)
        response = self.client.get(self.list_url, follow=True)
        assert response.status_code == 200
        doc = pq(response.content)
        assert doc('#result_list tbody tr').length == 4

        # Test truncated text while we're at it...
        content = response.content.decode('utf-8')
        assert (
            u'Lôrem ipsum dolor sit amet, per at melius fuisset invidunt, ea '
            u'facete aperiam his. Et cum iusto detracto, nam atqui nostrum no,'
            u' eum altera...'
            in content)
        # ... And add-on name display.
        assert str(self.addon.name) in content

        response = self.client.get(
            self.list_url, {'type': 'rating'}, follow=True)
        assert response.status_code == 200
        doc = pq(response.content)
        assert doc('#result_list tbody tr').length == 3

        response = self.client.get(
            self.list_url, {'type': 'reply'}, follow=True)
        assert response.status_code == 200
        doc = pq(response.content)
        assert doc('#result_list tbody tr').length == 1
Example #23
0
    def test_blocked_subdomain_but_allow_parent(self):
        EmailUserRestriction.objects.create(
            email_pattern='*.mail.com')

        request = RequestFactory().get('/')
        request.user = user_factory(email='*****@*****.**')
        assert not EmailUserRestriction.allow_request(request)

        # We only block a subdomain pattern
        request.user = user_factory(email='*****@*****.**')
        assert EmailUserRestriction.allow_request(request)

        # Which also allows similar domains to work
        request.user = user_factory(email='*****@*****.**')
        assert EmailUserRestriction.allow_request(request)
Example #24
0
    def create_featured_addon_with_version(self):
        """Creates a custom addon named 'Ui-Addon'.

        This addon will be a featured addon and will have a featured collecton
        attatched to it. It will belong to the user uitest.

        It has 1 preview, 5 reviews, and 2 authors. The second author is named
        'ui-tester2'. It has a version number as well as a beta version.

        """
        default_icons = [x[0] for x in icons() if x[0].startswith('icon/')]
        addon = addon_factory(
            status=STATUS_PUBLIC,
            type=ADDON_EXTENSION,
            average_daily_users=5000,
            users=[UserProfile.objects.get(username='******')],
            average_rating=5,
            description=u'My Addon description',
            file_kw={
                'hash': 'fakehash',
                'platform': amo.PLATFORM_ALL.id,
                'size': 42,
            },
            guid=generate_addon_guid(),
            icon_type=random.choice(default_icons),
            name=u'Ui-Addon',
            public_stats=True,
            slug='ui-test-2',
            summary=u'My Addon summary',
            tags=['some_tag', 'another_tag', 'ui-testing',
                  'selenium', 'python'],
            total_ratings=500,
            weekly_downloads=9999999,
            developer_comments='This is a testing addon.',
        )
        Preview.objects.create(addon=addon, position=1)
        Rating.objects.create(addon=addon, rating=5, user=user_factory())
        Rating.objects.create(addon=addon, rating=5, user=user_factory())
        Rating.objects.create(addon=addon, rating=5, user=user_factory())
        Rating.objects.create(addon=addon, rating=5, user=user_factory())
        Rating.objects.create(addon=addon, rating=5, user=user_factory())
        Rating.objects.create(addon=addon, rating=5, user=user_factory())
        Rating.objects.create(addon=addon, rating=5, user=user_factory())
        Rating.objects.create(addon=addon, rating=5, user=user_factory())
        AddonUser.objects.create(user=user_factory(username='******'),
                                 addon=addon, listed=True)
        version_factory(addon=addon, file_kw={'status': amo.STATUS_BETA},
                        version='1.1beta')
        addon.save()
        generate_collection(addon, app=FIREFOX)
        print(
            'Created addon {0} for testing successfully'
            .format(addon.name))
Example #25
0
    def test_total_reviews(self):
        addon = addon_factory()
        addon2 = addon_factory()

        # Add a purely unlisted add-on. It should not be considered when
        # calculating bayesian rating for the other add-ons.
        addon3 = addon_factory(total_reviews=3, average_rating=4)
        self.make_addon_unlisted(addon3)

        # Create a few reviews with various ratings.
        review = Review.objects.create(
            addon=addon, rating=3, user=user_factory())
        Review.objects.create(addon=addon, rating=3, user=user_factory())
        Review.objects.create(addon=addon, rating=2, user=user_factory())
        Review.objects.create(addon=addon, rating=1, user=user_factory())

        # On another addon as well.
        Review.objects.create(addon=addon2, rating=1, user=user_factory())
        Review.objects.create(addon=addon2, rating=1, user=user_factory())

        # addon_review_aggregates should ignore replies, so let's add one.
        Review.objects.create(
            addon=addon, rating=5, user=user_factory(), reply_to=review)

        # Make sure total_reviews hasn't been updated yet (because we are
        # mocking Review.refresh()).
        addon.reload()
        addon2.reload()
        assert addon.total_reviews == 0
        assert addon2.total_reviews == 0
        assert addon.bayesian_rating == 0
        assert addon.average_rating == 0
        assert addon2.bayesian_rating == 0
        assert addon2.average_rating == 0

        # Trigger the task and test results.
        addon_review_aggregates([addon.pk, addon2.pk])
        addon.reload()
        addon2.reload()
        assert addon.total_reviews == 4
        assert addon2.total_reviews == 2
        assert addon.bayesian_rating == 1.9821428571428572
        assert addon.average_rating == 2.25
        assert addon2.bayesian_rating == 1.375
        assert addon2.average_rating == 1.0

        # Trigger the task with a single add-on.
        Review.objects.create(addon=addon2, rating=5, user=user_factory())
        addon2.reload()
        assert addon2.total_reviews == 2

        addon_review_aggregates(addon2.pk)
        addon2.reload()
        assert addon2.total_reviews == 3
        assert addon.bayesian_rating == 1.9821428571428572
        assert addon.average_rating == 2.25
        assert addon2.bayesian_rating == 1.97915
        assert addon2.average_rating == 2.3333
Example #26
0
    def test_moderator_delete(self, log_mock):
        moderator = user_factory()
        rating = Rating.objects.get(pk=1)
        rating.update(editorreview=True)
        rating.ratingflag_set.create()
        rating.delete(user_responsible=moderator)

        rating.reload()
        assert ActivityLog.objects.count() == 1
        assert not rating.ratingflag_set.exists()

        activity_log = ActivityLog.objects.latest('pk')
        assert activity_log.details == {
            'body': 'r1 body',
            'is_flagged': True,
            'addon_title': 'my addon name',
            'addon_id': 4,
        }
        assert activity_log.user == moderator
        assert activity_log.action == amo.LOG.DELETE_RATING.id
        assert activity_log.arguments == [rating.addon, rating]

        assert log_mock.info.call_count == 1
        assert (log_mock.info.call_args[0][0] ==
                'Rating deleted: %s deleted id:%s by %s ("%s")')
        assert log_mock.info.call_args[0][1] == moderator.name
        assert log_mock.info.call_args[0][2] == rating.pk
        assert log_mock.info.call_args[0][3] == rating.user.name
        assert log_mock.info.call_args[0][4] == six.text_type(rating.body)
Example #27
0
    def test_can_edit_with_addons_edit_permission(self):
        addon = addon_factory(guid='@foo')
        self.detail_url = reverse(
            'admin:addons_addon_change', args=(addon.pk,)
        )
        user = user_factory()
        self.grant_permission(user, 'Admin:Tools')
        self.grant_permission(user, 'Addons:Edit')
        self.client.login(email=user.email)
        response = self.client.get(self.detail_url, follow=True)
        assert response.status_code == 200
        assert addon.guid in response.content.decode('utf-8')

        post_data = {
            # Django wants the whole form to be submitted, unfortunately.
            'total_ratings': addon.total_ratings,
            'text_ratings_count': addon.text_ratings_count,
            'default_locale': addon.default_locale,
            'weekly_downloads': addon.weekly_downloads,
            'total_downloads': addon.total_downloads,
            'average_rating': addon.average_rating,
            'average_daily_users': addon.average_daily_users,
            'bayesian_rating': addon.bayesian_rating,
            'reputation': addon.reputation,
            'type': addon.type,
            'slug': addon.slug
        }
        post_data['guid'] = '@bar'
        response = self.client.post(self.detail_url, post_data, follow=True)
        assert response.status_code == 200
        addon.reload()
        assert addon.guid == '@bar'
Example #28
0
    def test_creation_triggers_email_and_logging(self):
        addon = Addon.objects.get(pk=4)
        addon_author = addon.authors.first()
        review_user = user_factory()
        rating = Rating.objects.create(
            user=review_user, addon=addon,
            body=u'Rêviiiiiiew', user_responsible=review_user)

        activity_log = ActivityLog.objects.latest('pk')
        assert activity_log.user == review_user
        assert activity_log.arguments == [addon, rating]
        assert activity_log.action == amo.LOG.ADD_RATING.id

        assert len(mail.outbox) == 1
        email = mail.outbox[0]
        rating_url = jinja_helpers.absolutify(
            jinja_helpers.url(
                'addons.ratings.detail', addon.slug, rating.pk,
                add_prefix=False))
        assert email.subject == 'Mozilla Add-on User Rating: my addon name'
        assert 'A user has rated your add-on,' in email.body
        assert 'my addon name' in email.body
        assert rating_url in email.body
        assert email.to == [addon_author.email]
        assert email.from_email == 'Mozilla Add-ons <*****@*****.**>'
Example #29
0
    def test_can_not_edit_without_discovery_edit_permission(self):
        addon = addon_factory(name=u'BarFöo')
        item = DiscoveryItem.objects.create(addon=addon)
        self.detail_url = reverse(
            'admin:discovery_discoveryitem_change', args=(item.pk,)
        )
        user = user_factory()
        self.grant_permission(user, 'Admin:Tools')
        self.client.login(email=user.email)
        response = self.client.get(self.detail_url, follow=True)
        assert response.status_code == 403

        response = self.client.post(
            self.detail_url, {
                'addon': six.text_type(addon.pk),
                'custom_addon_name': u'Noooooô !',
                'custom_heading': u'I should not be able to do this.',
                'custom_description': u'This is wrong.',
            }, follow=True)
        assert response.status_code == 403
        item.reload()
        assert DiscoveryItem.objects.count() == 1
        assert item.addon == addon
        assert item.custom_addon_name == u''
        assert item.custom_heading == u''
        assert item.custom_description == u''
Example #30
0
    def test_can_edit_with_discovery_edit_permission(self):
        addon = addon_factory(name=u'BarFöo')
        item = DiscoveryItem.objects.create(addon=addon)
        self.detail_url = reverse(
            'admin:discovery_discoveryitem_change', args=(item.pk,)
        )
        user = user_factory()
        self.grant_permission(user, 'Admin:Tools')
        self.grant_permission(user, 'Discovery:Edit')
        self.client.login(email=user.email)
        response = self.client.get(self.detail_url, follow=True)
        assert response.status_code == 200
        content = response.content.decode('utf-8')
        assert u'BarFöo' in content
        assert DiscoveryItem._meta.get_field('addon').help_text in content

        response = self.client.post(
            self.detail_url, {
                'addon': six.text_type(addon.pk),
                'custom_addon_name': u'Xäxâxàxaxaxa !',
                'custom_heading': u'This heading is totally custom.',
                'custom_description': u'This description is as well!',
            }, follow=True)
        assert response.status_code == 200
        item.reload()
        assert DiscoveryItem.objects.count() == 1
        assert item.addon == addon
        assert item.custom_addon_name == u'Xäxâxàxaxaxa !'
        assert item.custom_heading == u'This heading is totally custom.'
        assert item.custom_description == u'This description is as well!'
    def test_basic(self):
        cat1 = Category.from_static_category(
            CATEGORIES[amo.FIREFOX.id][amo.ADDON_EXTENSION]['bookmarks'])
        cat1.save()
        license = License.objects.create(
            name={
                'en-US': u'My License',
                'fr': u'Mä Licence',
            },
            text={
                'en-US': u'Lorem ipsum dolor sit amet, has nemore patrioqué',
            },
            url='http://license.example.com/'

        )
        self.addon = addon_factory(
            average_daily_users=4242,
            average_rating=4.21,
            bayesian_rating=4.22,
            category=cat1,
            contributions=u'https://paypal.me/foobar/',
            description=u'My Addôn description',
            developer_comments=u'Dévelopers Addôn comments',
            file_kw={
                'hash': 'fakehash',
                'is_restart_required': False,
                'is_webextension': True,
                'platform': amo.PLATFORM_WIN.id,
                'size': 42,
            },
            guid=generate_addon_guid(),
            homepage=u'https://www.example.org/',
            icon_type='image/png',
            name=u'My Addôn',
            public_stats=True,
            slug='my-addon',
            summary=u'My Addôn summary',
            support_email=u'*****@*****.**',
            support_url=u'https://support.example.org/support/my-addon/',
            tags=['some_tag', 'some_other_tag'],
            total_reviews=666,
            text_reviews_count=555,
            version_kw={
                'license': license,
                'releasenotes': {
                    'en-US': u'Release notes in english',
                    'fr': u'Notes de version en français',
                },
            },
            weekly_downloads=2147483647,
        )
        AddonUser.objects.create(user=user_factory(username='******'),
                                 addon=self.addon, listed=False)
        second_author = user_factory(
            username='******', display_name=u'Secönd Author')
        first_author = user_factory(
            username='******', display_name=u'First Authôr')
        AddonUser.objects.create(
            user=second_author, addon=self.addon, position=2)
        AddonUser.objects.create(
            user=first_author, addon=self.addon, position=1)
        second_preview = Preview.objects.create(
            addon=self.addon, position=2,
            caption={'en-US': u'My câption', 'fr': u'Mön tîtré'})
        first_preview = Preview.objects.create(addon=self.addon, position=1)

        av_min = AppVersion.objects.get_or_create(
            application=amo.THUNDERBIRD.id, version='2.0.99')[0]
        av_max = AppVersion.objects.get_or_create(
            application=amo.THUNDERBIRD.id, version='3.0.99')[0]
        ApplicationsVersions.objects.get_or_create(
            application=amo.THUNDERBIRD.id, version=self.addon.current_version,
            min=av_min, max=av_max)
        # Reset current_version.compatible_apps now that we've added an app.
        del self.addon.current_version.compatible_apps

        cat2 = Category.from_static_category(
            CATEGORIES[amo.FIREFOX.id][amo.ADDON_EXTENSION]['alerts-updates'])
        cat2.save()
        AddonCategory.objects.create(addon=self.addon, category=cat2)
        cat3 = Category.from_static_category(
            CATEGORIES[amo.THUNDERBIRD.id][amo.ADDON_EXTENSION]['calendar'])
        cat3.save()
        AddonCategory.objects.create(addon=self.addon, category=cat3)

        result = self.serialize()

        assert result['id'] == self.addon.pk

        assert result['average_daily_users'] == self.addon.average_daily_users
        assert result['categories'] == {
            'firefox': ['alerts-updates', 'bookmarks'],
            'thunderbird': ['calendar']}

        assert result['current_beta_version'] is None

        # In this serializer latest_unlisted_version is omitted.
        assert 'latest_unlisted_version' not in result

        assert result['current_version']
        self._test_version(
            self.addon.current_version, result['current_version'])
        assert result['current_version']['url'] == absolutify(
            reverse('addons.versions',
                    args=[self.addon.slug, self.addon.current_version.version])
        )
        self._test_version_license_and_release_notes(
            self.addon.current_version, result['current_version'])

        assert result['authors']
        assert len(result['authors']) == 2
        self._test_author(first_author, result['authors'][0])
        self._test_author(second_author, result['authors'][1])

        assert result['contributions_url'] == self.addon.contributions
        assert result['edit_url'] == absolutify(self.addon.get_dev_url())
        assert result['default_locale'] == self.addon.default_locale
        assert result['description'] == {'en-US': self.addon.description}
        assert result['developer_comments'] == {
            'en-US': self.addon.developer_comments}
        assert result['guid'] == self.addon.guid
        assert result['has_eula'] is False
        assert result['has_privacy_policy'] is False
        assert result['homepage'] == {
            'en-US': get_outgoing_url(unicode(self.addon.homepage))
        }
        assert result['icon_url'] == absolutify(self.addon.get_icon_url(64))
        assert result['is_disabled'] == self.addon.is_disabled
        assert result['is_experimental'] == self.addon.is_experimental is False
        assert result['is_featured'] == self.addon.is_featured() is False
        assert result['is_source_public'] == self.addon.view_source
        assert result['last_updated'] == (
            self.addon.last_updated.replace(microsecond=0).isoformat() + 'Z')
        assert result['name'] == {'en-US': self.addon.name}
        assert result['previews']
        assert len(result['previews']) == 2

        result_preview = result['previews'][0]
        assert result_preview['id'] == first_preview.pk
        assert result_preview['caption'] is None
        assert result_preview['image_url'] == absolutify(
            first_preview.image_url)
        assert result_preview['thumbnail_url'] == absolutify(
            first_preview.thumbnail_url)

        result_preview = result['previews'][1]
        assert result_preview['id'] == second_preview.pk
        assert result_preview['caption'] == {
            'en-US': u'My câption',
            'fr': u'Mön tîtré'
        }
        assert result_preview['image_url'] == absolutify(
            second_preview.image_url)
        assert result_preview['thumbnail_url'] == absolutify(
            second_preview.thumbnail_url)

        assert result['ratings'] == {
            'average': self.addon.average_rating,
            'bayesian_average': self.addon.bayesian_rating,
            'count': self.addon.total_reviews,
            'text_count': self.addon.text_reviews_count,
        }
        assert result['public_stats'] == self.addon.public_stats
        assert result['requires_payment'] == self.addon.requires_payment
        assert result['review_url'] == absolutify(
            reverse('editors.review', args=[self.addon.pk]))
        assert result['slug'] == self.addon.slug
        assert result['status'] == 'public'
        assert result['summary'] == {'en-US': self.addon.summary}
        assert result['support_email'] == {'en-US': self.addon.support_email}
        assert result['support_url'] == {
            'en-US': get_outgoing_url(unicode(self.addon.support_url))
        }
        assert 'theme_data' not in result
        assert set(result['tags']) == set(['some_tag', 'some_other_tag'])
        assert result['type'] == 'extension'
        assert result['url'] == absolutify(self.addon.get_url_path())
        assert result['weekly_downloads'] == self.addon.weekly_downloads

        return result
Example #32
0
    def setUp(self):
        self.user = user_factory(email='*****@*****.**')
        self.grant_permission(self.user, 'Admin:Advanced')

        self.client.login(email=self.user.email)
        self.list_url = reverse('admin:users_emailuserrestriction_changelist')
Example #33
0
 def test_does_not_require_a_restart(self):
     upload = self.upload('webextension.xpi')
     parsed_data = parse_addon(upload.path, addon=self.addon, user=user_factory())
     file_ = File.from_upload(upload, self.version, parsed_data=parsed_data)
     assert not file_.is_restart_required
 def setUp(self):
     self.request = APIRequestFactory().get('/')
     self.view = Mock(spec=['get_addon_object', 'should_include_flags'])
     self.view.get_addon_object.return_value = None
     self.view.should_include_flags.return_value = False
     self.user = user_factory()
Example #35
0
    def test_addon_devs(self):
        old_date = self.days_ago((365 * 7) + 1)

        # Old but not deleted
        old_not_deleted = user_factory(last_login_ip='127.0.0.1',
                                       fxa_id='12345')
        old_not_deleted.update(modified=old_date)
        old_not_deleted_addon = addon_factory(users=[old_not_deleted],
                                              status=amo.STATUS_DELETED)

        # Deleted but not old enough
        recent_user = user_factory(last_login_ip='127.0.0.1',
                                   deleted=True,
                                   fxa_id='67890')
        recent_user.update(modified=self.days_ago(365))
        recent_user_addon = addon_factory(users=[recent_user],
                                          status=amo.STATUS_DELETED)

        old_user = user_factory(deleted=True, fxa_id='dfdf')
        old_user.update(modified=old_date)
        old_user_addon = addon_factory(users=[old_user],
                                       status=amo.STATUS_DELETED)
        # Include an add-on that old_user _was_ an owner of, but now isn't.
        # Even if the addon is now deleted it shouldn't be hard-deleted with
        # old_user.
        no_longer_owner_addon = addon_factory(
            users=[old_user, old_not_deleted])
        no_longer_owner_addon.addonuser_set.get(user=old_user).delete()
        assert old_user not in list(no_longer_owner_addon.authors.all())
        assert UserProfile.objects.filter(addons=no_longer_owner_addon,
                                          id=old_user.id).exists()
        no_longer_owner_addon.delete()

        # Old, has addons, but already has other data cleared
        old_data_cleared = user_factory(deleted=True,
                                        last_login_ip='',
                                        email=None,
                                        fxa_id=None)
        old_data_cleared.update(modified=old_date)
        old_data_cleared_addon = addon_factory(users=[old_data_cleared],
                                               status=amo.STATUS_DELETED)

        old_banned_user = user_factory(last_login_ip='127.0.0.1',
                                       deleted=True,
                                       fxa_id='abcde',
                                       banned=old_date)
        old_banned_user.update(modified=old_date)
        old_banned_user_addon = addon_factory(users=[old_banned_user],
                                              status=amo.STATUS_DISABLED)

        call_command('clear_old_user_data')

        old_not_deleted.reload()
        assert old_not_deleted.last_login_ip == '127.0.0.1'
        assert old_not_deleted.deleted is False
        assert old_not_deleted.email
        assert old_not_deleted.fxa_id
        assert old_not_deleted.modified == old_date
        assert old_not_deleted_addon.reload()

        recent_user.reload()
        assert recent_user.last_login_ip == '127.0.0.1'
        assert recent_user.deleted is True
        assert recent_user.email
        assert recent_user.fxa_id
        assert recent_user_addon.reload()

        old_user.reload()
        assert old_user.last_login_ip == ''
        assert old_user.deleted is True
        assert not old_user.email
        assert not old_user.fxa_id
        assert old_user.modified == old_date
        assert not Addon.unfiltered.filter(id=old_user_addon.id).exists()
        assert no_longer_owner_addon.reload()

        assert not Addon.unfiltered.filter(
            id=old_data_cleared_addon.id).exists()

        old_banned_user.reload()
        assert old_banned_user.last_login_ip == ''
        assert old_banned_user.deleted is True
        assert not old_banned_user.email
        assert not old_banned_user.fxa_id
        assert old_banned_user.modified == old_date
        assert old_banned_user.banned
        assert not Addon.unfiltered.filter(
            id=old_banned_user_addon.id).exists()

        # But check that no_longer_owner_addon is deleted eventually
        old_not_deleted.update(deleted=True)
        call_command('clear_old_user_data')
        old_not_deleted.reload()
        assert not old_not_deleted.email
        assert not Addon.unfiltered.filter(
            id=old_not_deleted_addon.id).exists()
        assert not Addon.unfiltered.filter(
            id=no_longer_owner_addon.id).exists()
 def setUp(self):
     self.permission = AllowOwner()
     self.anonymous = AnonymousUser()
     self.user = user_factory()
     self.request = RequestFactory().get('/')
     self.request.user = self.anonymous
 def test_has_object_permission_different_user(self):
     self.request.user = user_factory()
     assert self.request.user not in self.addon.authors.all()
     assert not self.permission.has_object_permission(
         self.request, myview, self.addon)
 def test_has_permission_any_authenticated_user(self):
     self.request.user = user_factory()
     assert self.request.user not in self.addon.authors.all()
     assert self.permission.has_permission(self.request, myview)
Example #39
0
def test_system_addon_submission_allowed_not_mozilla_not_allowed(guid):
    user = user_factory()
    data = {'guid': guid}
    assert not system_addon_submission_allowed(user, data)
Example #40
0
 def test_random_user_is_403(self):
     self.user = user_factory()
     self.client.login_api(self.user)
     response = self._post_reply()
     assert response.status_code == 403
     assert not self.get_review_activity_queryset().exists()
Example #41
0
 def test_list_view_is_restricted(self):
     user = user_factory()
     self.grant_permission(user, 'Admin:Curation')
     self.client.login(email=user.email)
     response = self.client.get(self.list_url)
     assert response.status_code == 403
Example #42
0
 def setUp(self):
     self.user = user_factory()
     self.url = reverse('account-detail', kwargs={'pk': self.user.pk})
     super(TestAccountViewSet, self).setUp()
Example #43
0
 def test_endpoint_requires_permissions(self):
     self.user = user_factory()
     self.client.login_api(self.user)
     response = self.client.get(self.url)
     assert response.status_code == 403
 def test_has_object_permission_different_user(self):
     self.request.user = self.user
     obj = Mock(spec=[])
     obj.user = user_factory()
     assert not self.permission.has_object_permission(
         self.request, 'myview', obj)
Example #45
0
    def test_no_addons(self):
        recent_date = self.days_ago(2)
        old_date = self.days_ago((365 * 7) + 1)

        # old enough but not deleted
        recent_not_deleted = user_factory(last_login_ip='127.0.0.1',
                                          fxa_id='12345')
        recent_not_deleted.update(modified=recent_date)

        # Deleted but new
        new_user = user_factory(last_login_ip='127.0.0.1',
                                deleted=True,
                                fxa_id='67890')

        # Deleted and recent: last_login_ip, email, fxa_id must be cleared.
        recent_deleted_user = user_factory(last_login_ip='127.0.0.1',
                                           deleted=True,
                                           fxa_id='abcde')
        recent_deleted_user.update(modified=recent_date)

        # Deleted and recent but with some cleared data already null.
        recent_deleted_user_part = user_factory(last_login_ip='127.0.0.1',
                                                deleted=True,
                                                fxa_id=None)
        recent_deleted_user_part.update(modified=recent_date)

        # recent and banned
        recent_banned_user = user_factory(last_login_ip='127.0.0.1',
                                          deleted=True,
                                          fxa_id='abcde',
                                          banned=recent_date)
        recent_banned_user.update(modified=recent_date)

        old_banned_user = user_factory(last_login_ip='127.0.0.1',
                                       deleted=True,
                                       fxa_id='abcde',
                                       banned=recent_date)
        old_banned_user.update(modified=old_date)

        call_command('clear_old_user_data')

        recent_not_deleted.reload()
        assert recent_not_deleted.last_login_ip == '127.0.0.1'
        assert recent_not_deleted.deleted is False
        assert recent_not_deleted.email
        assert recent_not_deleted.fxa_id
        assert recent_not_deleted.modified == recent_date

        new_user.reload()
        assert new_user.last_login_ip == '127.0.0.1'
        assert new_user.deleted is True
        assert new_user.email
        assert new_user.fxa_id

        recent_deleted_user.reload()
        assert recent_deleted_user.last_login_ip == ''
        assert recent_deleted_user.deleted is True
        assert not recent_deleted_user.email
        assert not recent_deleted_user.fxa_id
        assert recent_deleted_user.modified == recent_date

        recent_deleted_user_part.reload()
        assert recent_deleted_user_part.last_login_ip == ''
        assert recent_deleted_user_part.deleted is True
        assert not recent_deleted_user_part.email
        assert not recent_deleted_user_part.fxa_id
        assert recent_deleted_user_part.modified == recent_date

        recent_banned_user.reload()
        assert recent_banned_user.last_login_ip == '127.0.0.1'
        assert recent_banned_user.deleted is True
        assert recent_banned_user.email
        assert recent_banned_user.fxa_id
        assert recent_banned_user.banned

        old_banned_user.reload()
        assert old_banned_user.last_login_ip == ''
        assert old_banned_user.deleted is True
        assert not old_banned_user.email
        assert not old_banned_user.fxa_id
        assert old_banned_user.modified == old_date
        assert old_banned_user.banned
 def test_authenticated_but_not_reviewer(self):
     self.request.user = user_factory()
     obj = Mock(spec=[])
     assert not self.permission.has_permission(self.request, myview)
     assert not self.permission.has_object_permission(
         self.request, myview, obj)
Example #47
0
 def setUp(self):
     super(TestUserProfileAdmin, self).setUp()
     self.user = user_factory(email='*****@*****.**')
     self.grant_permission(self.user, '*:*')
     self.login(self.user)
Example #48
0
 def setUp(self):
     self.user = user_factory(**self.user_kwargs)
Example #49
0
 def setUp(self):
     self.user = user_factory()
Example #50
0
 def setUp(self):
     super(TestUserAbuseViewSetLoggedIn, self).setUp()
     self.user = user_factory()
     self.client.login_api(self.user)
Example #51
0
 def test_list_no_permission(self):
     user = user_factory(email='*****@*****.**')
     self.client.login(email=user.email)
     response = self.client.get(self.list_url)
     assert response.status_code == 403
Example #52
0
 def setUp(self):
     self.request = APIRequestFactory().get('/')
     self.user = user_factory()
    def generate_review_data(self):
        with freeze_time(self.last_week_begin):
            self.reviewer1 = user_factory(display_name='Volunteer A')
            self.reviewer2 = user_factory(display_name='Staff B')
            self.reviewer3 = user_factory(display_name=None)
            self.reviewer4 = user_factory(display_name='Staff Content D')
            self.reviewer5 = user_factory(display_name='Deleted')
            grant_permission(self.reviewer2, '', name='No Reviewer Incentives')
            grant_permission(self.reviewer4, '', name='No Reviewer Incentives')

            data = [
                (self.reviewer1, 178, amo.AUTO_APPROVED, False),
                (self.reviewer1, 95, amo.AUTO_APPROVED, False),
                (self.reviewer1, 123, amo.NOT_AUTO_APPROVED, False),
                (self.reviewer1, 328, amo.AUTO_APPROVED, False),
                (self.reviewer1, 450, amo.AUTO_APPROVED, False),
                (self.reviewer1, 999, amo.NOT_AUTO_APPROVED, False),
                (self.reviewer1, 131, amo.AUTO_APPROVED, False),
                (self.reviewer1, 74, amo.NOT_AUTO_APPROVED, False),
                (self.reviewer1, 15, amo.AUTO_APPROVED, False),
                (self.reviewer2, 951, amo.NOT_AUTO_APPROVED, False),
                (self.reviewer2, 8421, amo.AUTO_APPROVED, False),
                (self.reviewer2, 281, amo.AUTO_APPROVED, False),
                (self.reviewer2, 54, amo.NOT_AUTO_APPROVED, False),
                (self.reviewer2, 91, amo.NOT_AUTO_APPROVED, False),
                (self.reviewer2, 192, amo.AUTO_APPROVED, False),
                (self.reviewer2, 222, amo.NOT_AUTO_APPROVED, False),
                (self.reviewer3, 178, amo.AUTO_APPROVED, True),
                (self.reviewer3, 95, amo.AUTO_APPROVED, True),
                (self.reviewer3, 123, amo.NOT_AUTO_APPROVED, True),
                (self.reviewer3, 328, amo.AUTO_APPROVED, True),
                (self.reviewer3, 450, amo.AUTO_APPROVED, True),
                (self.reviewer3, 999, amo.NOT_AUTO_APPROVED, True),
                (self.reviewer3, 131, amo.AUTO_APPROVED, True),
                (self.reviewer3, 74, amo.NOT_AUTO_APPROVED, True),
                (self.reviewer3, 15, amo.AUTO_APPROVED, True),
                (self.reviewer3, 48, amo.AUTO_APPROVED, True),
                (self.reviewer3, 87, amo.NOT_AUTO_APPROVED, True),
                (self.reviewer3, 265, amo.AUTO_APPROVED, True),
                (self.reviewer4, 951, amo.NOT_AUTO_APPROVED, True),
                (self.reviewer4, 8421, amo.AUTO_APPROVED, True),
                (self.reviewer4, 281, amo.AUTO_APPROVED, True),
                (self.reviewer4, 54, amo.NOT_AUTO_APPROVED, True),
                (self.reviewer4, 91, amo.NOT_AUTO_APPROVED, True),
                (self.reviewer4, 192, amo.AUTO_APPROVED, True),
                (self.reviewer4, 222, amo.NOT_AUTO_APPROVED, True),
                (self.reviewer4, 192, amo.AUTO_APPROVED, True),
                (self.reviewer4, 444, amo.NOT_AUTO_APPROVED, True),
                (self.reviewer4, 749, amo.AUTO_APPROVED, True),
                (self.reviewer5, 523, amo.NOT_AUTO_APPROVED, True),
                (self.reviewer5, 126, amo.AUTO_APPROVED, True),
                (self.reviewer5, 246, amo.AUTO_APPROVED, False),
                (self.reviewer5, 8740, amo.NOT_AUTO_APPROVED, True),
                (self.reviewer5, 346, amo.NOT_AUTO_APPROVED, False),
                (self.reviewer5, 985, amo.AUTO_APPROVED, False),
                (self.reviewer5, 123, amo.NOT_AUTO_APPROVED, True),
                (self.reviewer5, 93, amo.AUTO_APPROVED, True),
                (self.reviewer5, 22, amo.NOT_AUTO_APPROVED, False),
                (self.reviewer5, 165, amo.AUTO_APPROVED, True),
            ]
            for review_action in data:
                self.create_and_review_addon(review_action[0],
                                             review_action[1],
                                             review_action[2],
                                             review_action[3])

            self.reviewer5.delete()
            mail.outbox = []

            # Search plugin (submitted before auto-approval was implemented)
            search_plugin = addon_factory(type=4)
            ReviewerScore.award_points(self.reviewer3,
                                       search_plugin,
                                       amo.STATUS_APPROVED,
                                       version=search_plugin.versions.all()[0],
                                       post_review=False,
                                       content_review=True)

            # Dictionary (submitted before auto-approval was implemented)
            dictionary = addon_factory(type=3)
            ReviewerScore.award_points(self.reviewer3,
                                       dictionary,
                                       amo.STATUS_APPROVED,
                                       version=dictionary.versions.all()[0],
                                       post_review=False,
                                       content_review=True)
Example #54
0
 def test_allowed_ip4_28_subnet(self):
     request = RequestFactory(REMOTE_ADDR='192.168.0.254').get('/')
     request.user = user_factory(last_login_ip='192.168.1.1')
     IPNetworkUserRestriction.objects.create(network='192.168.0.0/28')
     assert IPNetworkUserRestriction.allow_request(request)
Example #55
0
 def test_blocked_user_login_ip(self):
     request = RequestFactory(REMOTE_ADDR='192.168.0.8').get('/')
     request.user = user_factory(last_login_ip='192.168.1.1')
     IPNetworkUserRestriction.objects.create(network='192.168.1.1/32')
     assert not IPNetworkUserRestriction.allow_request(request)
Example #56
0
 def test_email_domain_blocked(self):
     DisposableEmailDomainRestriction.objects.create(domain='bar.com')
     request = RequestFactory().get('/')
     request.user = user_factory(email='*****@*****.**')
     assert not DisposableEmailDomainRestriction.allow_request(request)
Example #57
0
def mock_request(rf, db):  # rf is a RequestFactory provided by pytest-django.
    request = rf.get('/')
    request.user = user_factory()
    return request
Example #58
0
 def test_email_allowed(self):
     EmailUserRestriction.objects.create(email_pattern='*****@*****.**')
     request = RequestFactory().get('/')
     request.user = user_factory(email='*****@*****.**')
     assert EmailUserRestriction.allow_request(request)
     assert EmailUserRestriction.allow_email(request.user.email)
Example #59
0
def test_system_addon_submission_allowed_mozilla_allowed(guid):
    user = user_factory()
    group = Group.objects.create(name='Blah', rules='SystemAddon:Submit')
    GroupUser.objects.create(group=group, user=user)
    data = {'guid': guid}
    assert system_addon_submission_allowed(user, data)
Example #60
0
 def setUp(self):
     self.request = APIRequestFactory().get('/')
     self.user = user_factory(**self.user_kwargs,
                              **self.user_private_kwargs)