def setUpClass(cls): super(GraphsTestCase, cls).setUpClass() cls.factory = RequestFactory() Request(path="/admin/", ip="127.0.0.1").save() Request(path="/admin/", ip="127.0.0.1").save() Request(path="/admin/login/", ip="127.0.0.1").save() staff_user = User.objects.create_user(username="******", password="******") staff_user.is_staff = True staff_user.save() cls.staff_user = staff_user cls.coordinator = EditorFactory(user__email="*****@*****.**").user coordinators = get_coordinators() coordinators.user_set.add(cls.coordinator) user = UserFactory() cls.user = user cls.partner = PartnerFactory() cls.app = ApplicationFactory(partner=cls.partner) cls.app.status = Application.APPROVED cls.app.save() cls.dashboard_url = reverse("dashboard")
def test_user_renewal_notice_future_date(self): """ If we have multiple authorizations to send emails for, let's make sure we send distinct emails to the right places. """ editor2 = EditorFactory(user__email='*****@*****.**') authorization2 = Authorization() authorization2.authorized_user = editor2.user authorization2.authorizer = self.coordinator authorization2.partner = self.partner authorization2.date_expires = datetime.today() + timedelta(weeks=1) authorization2.save() call_command('user_renewal_notice') self.assertEqual(len(mail.outbox), 2) # Make sure that the two emails went to the two expected # email addresses. # This looks a little complicated because mail.outbox[0].to is a # (one element) list, and we need to compare sets to ensure we've # got 1 of each email. self.assertEqual(set([mail.outbox[0].to[0], mail.outbox[1].to[0]]), set(['*****@*****.**', '*****@*****.**']))
def setUp(self): super(ApplicationCommentTest, self).setUp() self.editor = EditorFactory(user__email="*****@*****.**").user coordinators = get_coordinators() self.coordinator1 = EditorFactory( user__email="*****@*****.**", user__username="******" ).user self.coordinator2 = EditorFactory( user__email="*****@*****.**", user__username="******" ).user coordinators.user_set.add(self.coordinator1) coordinators.user_set.add(self.coordinator2) self.partner = PartnerFactory()
def setUpTestData(cls): super().setUpTestData() editor = EditorFactory(user__email="*****@*****.**") cls.user = editor.user cls.coordinator = EditorFactory().user coordinators = get_coordinators() coordinators.user_set.add(cls.coordinator) cls.partner = PartnerFactory() cls.authorization = Authorization() cls.authorization.user = cls.user cls.authorization.authorizer = cls.coordinator cls.authorization.date_expires = datetime.today() + timedelta(weeks=1) cls.authorization.save() cls.authorization.partners.add(cls.partner)
def test_project_page_2021_launch_email_2(self): """ Adding an inactive user shouldn't send another email. """ _ = EditorFactory(user__email="*****@*****.**") call_command("project_page_2021_launch") self.assertEqual(len(mail.outbox), 1)
def setUp(self): super(UserRenewalNoticeTest, self).setUp() editor = EditorFactory(user__email="*****@*****.**") self.user = editor.user self.coordinator = EditorFactory().user coordinators = get_coordinators() coordinators.user_set.add(self.coordinator) self.partner = PartnerFactory() self.authorization = Authorization() self.authorization.user = self.user self.authorization.authorizer = self.coordinator self.authorization.partner = self.partner self.authorization.date_expires = datetime.today() + timedelta(weeks=2) self.authorization.save()
def test_proxy_bundle_launch_email_2(self): """ Adding another user should result in two sent emails. """ _ = EditorFactory(user__email="*****@*****.**") call_command("proxy_bundle_launch") self.assertEqual(len(mail.outbox), 2)
def handle(self, *args, **options): num_editors = options['num'][0] fake = Faker() existing_users = User.objects.all() # Superuser the only user, per twlight_vagrant README instructions. if existing_users.count() == 0: raise CommandError('No users present to Superuser. ' 'Please login first.') elif existing_users.count() > 1: raise CommandError('More than one user present. ' 'Please ensure that only one user is present.') else: user = existing_users[0] user.is_superuser = True user.is_staff = True user.save() for _ in range(num_editors): user = UserFactory(email=fake.word() + "@example.com") editor = EditorFactory( user=user, real_name=fake.name(), country_of_residence=fake.country(), occupation=fake.job(), affiliation=fake.company(), wp_editcount=random.randint(50, 2000), wp_registered=fake.date_time_between(start_date="-10y", end_date="now", tzinfo=None), contributions=fake.paragraph(nb_sentences=4)) # All users who aren't the superuser all_users = User.objects.exclude(is_superuser=True) # Flag wp_valid correctly if user is valid for user in all_users: date_valid = datetime.today().date() - timedelta( days=182) >= user.editor.wp_registered if user.editor.wp_editcount > 500 and date_valid: user.editor.wp_valid = True user.editor.save() # Make 5 random users coordinators coordinators = get_coordinators() for user in random.sample(all_users, 5): user.groups.add(coordinators) user.save() # Set 5 random non-coordinator users to have restricted data processing restricted = get_restricted() non_coordinators = all_users.exclude(groups__name='coordinators') for user in random.sample(non_coordinators, 5): user.groups.add(restricted) user.save()
def test_editors_only_1(self): """ EditorsOnly allows editors. """ user = UserFactory() _ = EditorFactory(user=user) req = RequestFactory() req.user = user test = TestEditorsOnly() test.dispatch(req)
def test_visibility_of_not_available_1(self): """Regular users shouldn't see NOT_AVAILABLE partner pages.""" partner = PartnerFactory(status=Partner.NOT_AVAILABLE) detail_url = partner.get_absolute_url() editor = EditorFactory() request = RequestFactory().get(detail_url) request.user = editor.user with self.assertRaises(Http404): # We must explicitly pass kwargs to the view even though they are # implied by the URL. _ = PartnersDetailView.as_view()(request, pk=partner.pk)
def test_self_only_2(self): """ SelfOnly allows users who own the object returned by get_object. """ user = UserFactory() editor = EditorFactory(user=user) req = RequestFactory() req.user = user test = TestSelfOnly(obj=editor) test.dispatch(req)
def test_coordinators_or_self_4(self): """ CoordinatorOrSelf should users who own the object returned by the view's get_object. """ user = UserFactory() editor = EditorFactory(user=user) req = RequestFactory() req.user = user test = TestCoordinatorOrSelf(obj=editor) test.dispatch(req)
def setUpTestData(cls): super().setUpTestData() editor = EditorFactory(user__email="*****@*****.**") cls.user = editor.user # The user logged in: request = RequestFactory().get("/login") signals.user_logged_in.send(sender=cls.user.__class__, request=request, user=cls.user) cls.coordinator = EditorFactory().user coordinators = get_coordinators() coordinators.user_set.add(cls.coordinator) cls.partner = PartnerFactory() cls.authorization = Authorization() cls.authorization.user = cls.user cls.authorization.authorizer = cls.coordinator cls.authorization.date_expires = datetime.today() + timedelta(weeks=1) cls.authorization.save() cls.authorization.partners.add(cls.partner)
def setUp(self): super(ProjectPage2021LaunchTest, self).setUp() editor = EditorFactory(user__email="*****@*****.**") self.user = editor.user # The user logged in: request = RequestFactory().get("/login") signals.user_logged_in.send(sender=self.user.__class__, request=request, user=self.user) self.coordinator = EditorFactory().user coordinators = get_coordinators() coordinators.user_set.add(self.coordinator) self.partner = PartnerFactory() self.authorization = Authorization() self.authorization.user = self.user self.authorization.authorizer = self.coordinator self.authorization.date_expires = datetime.today() + timedelta(weeks=1) self.authorization.save() self.authorization.partners.add(self.partner)
def test_proxy_auth_renewals_csv(self): """ Test that the CSVProxyAuthAndRenewals csv download works """ partner1 = PartnerFactory(authorization_method=Partner.PROXY) partner2 = PartnerFactory(authorization_method=Partner.PROXY) editor1 = EditorFactory() editor2 = EditorFactory() parent_app = ApplicationFactory( status=Application.SENT, partner=partner1, editor=editor1, sent_by=self.coordinator, ) ApplicationFactory( status=Application.SENT, partner=partner1, editor=editor1, parent=parent_app, sent_by=self.coordinator, ) ApplicationFactory( status=Application.SENT, partner=partner2, editor=editor2, sent_by=self.coordinator, ) request = self.factory.get(reverse("csv:proxy_authorizations")) request.user = self.user response = views.CSVProxyAuthRenewalRate.as_view()(request) expected_data = [[str(date.today()), "2", "1", "50.0%"]] self._verify_equal(response, expected_data)
def test_visibility_of_not_available_2(self): """ Regular users shouldn't be able to see NOT_AVAILABLE partners in the listview. """ partner = PartnerFactory(status=Partner.NOT_AVAILABLE) list_url = reverse('partners:list') editor = EditorFactory() request = RequestFactory().get(list_url) request.user = editor.user response = PartnersListView.as_view()(request) self.assertNotContains(response, partner.get_absolute_url())
def test_visibility_of_not_available_4(self): """ Staff users *should* see NOT_AVAILABLE partner pages in the list view. """ partner = PartnerFactory(status=Partner.NOT_AVAILABLE) list_url = reverse('partners:list') editor = EditorFactory() editor.user.is_staff = True editor.user.save() request = RequestFactory().get(list_url) request.user = editor.user response = PartnersListView.as_view()(request) self.assertContains(response, partner.get_absolute_url())
def setUpClass(cls): super(PartnerModelTests, cls).setUpClass() cls.lang_en, _ = Language.objects.get_or_create(language='en') cls.lang_fr, _ = Language.objects.get_or_create(language='fr') editor = EditorFactory() coordinators = get_coordinators() coordinators.user_set.add(editor.user) UserProfileFactory(user=editor.user, terms_of_use=True) cls.coordinator = editor.user # We should mock out any call to messages call in the view, since # RequestFactory (unlike Client) doesn't run middleware. If you # actually want to test that messages are displayed, use Client(), # and stop/restart the patcher. cls.message_patcher = patch('TWLight.applications.views.messages.add_message') cls.message_patcher.start()
def test_request_application_view_context_1(self): """ The any_waitlisted context on RequestApplicationView should True if there are waitlisted Partners. """ # Set up request. req_url = reverse('applications:request') editor = EditorFactory() request = RequestFactory().get(req_url) request.user = editor.user # Ensure there is at least one waitlisted partner. partner = PartnerFactory(status=Partner.WAITLIST) # Test response. resp = RequestApplicationView.as_view()(request) self.assertEqual(resp.context_data['any_waitlisted'], True)
def test_contact_us_emails(self, mock_email): factory = RequestFactory() request = factory.post(get_form_target()) request.user = UserFactory() editor = EditorFactory() reply_to = ['*****@*****.**'] cc = ['*****@*****.**'] self.assertEqual(len(mail.outbox), 0) mail_instance = MagicMailBuilder(template_mail_cls=InlineCSSTemplateMail) email = mail_instance.contact_us_email('*****@*****.**', {'editor_wp_username': editor.wp_username, 'body': 'This is a test email'}) email.extra_headers["Reply-To"] = ", ".join(reply_to) email.extra_headers["Cc"] = ", ".join(cc) email.send() self.assertEqual(len(mail.outbox), 1)
def test_request_application_view_context_2(self): """ The any_waitlisted context on RequestApplicationView should False if there are not waitlisted Partners. """ # Set up request. req_url = reverse('applications:request') editor = EditorFactory() request = RequestFactory().get(req_url) request.user = editor.user # Ensure there are no waitlisted partners. for partner in Partner.objects.filter(status=Partner.WAITLIST): partner.delete() # Test response. resp = RequestApplicationView.as_view()(request) self.assertEqual(resp.context_data['any_waitlisted'], False)
def test_visibility_of_not_available_3(self): """ Staff users *should* see NOT_AVAILABLE partner pages. We won't test to see if they include the message, because RequestFactory doesn't include message middleware, but we can't use the Django test client to log in users without passwords (which is our normal user). """ partner = PartnerFactory(status=Partner.NOT_AVAILABLE) detail_url = partner.get_absolute_url() editor = EditorFactory() editor.user.is_staff = True editor.user.save() request = RequestFactory().get(detail_url) request.user = editor.user # This should not raise Http404. response = PartnersDetailView.as_view()(request, pk=partner.pk) self.assertEqual(response.status_code, 200)
def test_toggle_waitlist_2(self): """ Posting to the toggle waitlist view sets a WAITLIST partner to AVAILABLE. """ # Create needed objects. editor = EditorFactory() coordinators = get_coordinators() coordinators.user_set.add(editor.user) UserProfileFactory(user=editor.user, terms_of_use=True) partner = PartnerFactory(status=Partner.WAITLIST) # Set up request. url = reverse('partners:toggle_waitlist', kwargs={'pk': partner.pk}) request = RequestFactory().post(url) request.user = editor.user _ = PartnersToggleWaitlistView.as_view()(request, pk=partner.pk) partner.refresh_from_db() self.assertEqual(partner.status, Partner.AVAILABLE)
def test_toggle_waitlist_access(self): """ Only coordinators can post to the toggle waitlist view. """ # Create needed objects. editor = EditorFactory() coordinators = get_coordinators() coordinators.user_set.add(editor.user) UserProfileFactory(user=editor.user, terms_of_use=True) partner = PartnerFactory(status=Partner.AVAILABLE) # Set up request. url = reverse('partners:toggle_waitlist', kwargs={'pk': partner.pk}) request = RequestFactory().post(url) request.user = editor.user # This should work and not throw an error. resp = PartnersToggleWaitlistView.as_view()(request, pk=partner.pk) coordinators.user_set.remove(editor.user) with self.assertRaises(PermissionDenied): _ = PartnersToggleWaitlistView.as_view()(request, pk=partner.pk)
def setUpTestData(cls): super().setUpTestData() cls.partner1 = PartnerFactory( authorization_method=Partner.PROXY, status=Partner.AVAILABLE, featured=True, new_tags={"tags": ["music_tag"]}, ) cls.partner2 = PartnerFactory( authorization_method=Partner.PROXY, status=Partner.AVAILABLE, requested_access_duration=True, new_tags={"tags": ["art_tag"]}, ) cls.partner3 = PartnerFactory( authorization_method=Partner.CODES, status=Partner.AVAILABLE, featured=True, new_tags={"tags": ["music_tag"]}, ) cls.partner4 = PartnerFactory( authorization_method=Partner.PROXY, status=Partner.AVAILABLE, featured=True, new_tags={"tags": ["art_tag"]}, ) cls.partner5 = PartnerFactory( authorization_method=Partner.PROXY, status=Partner.AVAILABLE, specific_stream=True, new_tags={"tags": ["multidisciplinary_tag"]}, ) cls.user_editor = UserFactory(username="******") cls.editor1 = EditorFactory(user=cls.user_editor) cls.editor1.wp_bundle_eligible = True cls.editor1.save()
def setUpTestData(cls): super().setUpTestData() editor1 = EditorFactory(user__email="*****@*****.**") editor2 = EditorFactory(user__email="*****@*****.**")
def setUp(self): super(ProxyBundleLaunchTest, self).setUp() editor = EditorFactory(user__email="*****@*****.**") self.user = editor.user
def setUp(self): super(ContactUsTest, self).setUp() self.editor = EditorFactory(user__email="*****@*****.**").user
def setUp(self): super(ApplicationStatusTest, self).setUp() self.coordinator = EditorFactory().user coordinators = get_coordinators() coordinators.user_set.add(self.coordinator)
def setUpTestData(cls): super().setUpTestData() cls.editor = EditorFactory(user__email="*****@*****.**").user