class MessageTest(TestCase): def setUp(self): self.author = User.objects.all()[:1].get() self.subject = "Let's talk" self.body = "Will you please help me out with Portuguese trans?" self.user = User.objects.exclude(pk=self.author.pk)[:1].get() def _create_message(self, to_user): self.message = Message(user=to_user, author=self.author, subject=self.subject, content=self.body) self.message.save() def test_send_email_to_allowed_user(self): self.user.changes_notification = True self.user.save() assert self.user.is_active and self.user.email self._create_message(self.user) self.assertEqual(len(mail.outbox), 1) def test_send_email_to_optout_user(self): self.user.changes_notification = False self.user.save() assert self.user.is_active and self.user.email self._create_message(self.user) self.assertEquals(len(mail.outbox), 0)
def new(request): selected_user = None if request.POST: form = NewMessageForm(request.user, request.POST) if form.is_valid(): if form.cleaned_data['user']: m = Message(user=form.cleaned_data['user'], author=request.user, content=form.cleaned_data['content'], subject=form.cleaned_data['subject']) m.save() send_new_message_notification.delay(m.pk) elif form.cleaned_data['team']: now = datetime.now() # TODO: Move this into a task for performance? language = form.cleaned_data['language'] # We create messages using bulk_create, so that only one transaction is needed # But that means that we need to sort out the pk of newly created messages to # be able to send the notifications message_list = [] for member in form.cleaned_data['team'].members.all(): if member.user != request.user: if (len(language) == 0) or (language in set( UserLanguage.objects.filter( user__exact=member.user).values_list( 'language', flat=True))): message_list.append( Message(user=member.user, author=request.user, content=form.cleaned_data['content'], subject=form.cleaned_data['subject'])) Message.objects.bulk_create(message_list) new_messages_ids = Message.objects.filter( created__gt=now).values_list('pk', flat=True) for pk in new_messages_ids: send_new_message_notification.delay(pk) messages.success(request, _(u'Message sent.')) return HttpResponseRedirect(reverse('messages:inbox')) else: if request.GET.get('user'): selected_user = User.objects.get(username=request.GET['user']) else: form = NewMessageForm(request.user) if request.GET.get('user'): selected_user = User.objects.get(username=request.GET['user']) return { 'selected_user': selected_user, 'user_info': request.user, 'form': form, }
def new(request): selected_user = None if request.POST: form = NewMessageForm(request.user, request.POST) if form.is_valid(): if form.cleaned_data['user']: m = Message(user=form.cleaned_data['user'], author=request.user, content=form.cleaned_data['content'], subject=form.cleaned_data['subject']) m.save() send_new_message_notification.delay(m.pk) elif form.cleaned_data['team']: # TODO: Move this into a task for performance? # Once we switch to Django 1.4, this should be replaced with # `bulk_create`. for member in form.cleaned_data['team'].members.all(): if member.user != request.user: m = Message(user=member.user, author=request.user, content=form.cleaned_data['content'], subject=form.cleaned_data['subject']) m.save() send_new_message_notification.delay(m.pk) messages.success(request, _(u'Message sent.')) return HttpResponseRedirect(reverse('messages:inbox')) else: if request.GET.get('user'): selected_user = User.objects.get(username=request.GET['user']) else: form = NewMessageForm(request.user) if request.GET.get('user'): selected_user = User.objects.get(username=request.GET['user']) return { 'selected_user': selected_user, 'user_info': request.user, 'form': form, }
class MessageTest(TestCase): def setUp(self): self.author = User.objects.all()[:1].get() self.subject = "Let's talk" self.body = "Will you please help me out with Portuguese trans?" self.user = User.objects.exclude(pk=self.author.pk)[:1].get() def _create_message(self, to_user): self.message = Message(user=to_user, author=self.author, subject=self.subject, content=self.body) self.message.save() def _send_email(self, to_user): send_templated_email(to_user, "test email", "messages/email/email-confirmed.html", {}) def test_send_email_to_allowed_user(self): self.user.notify_by_email = True self.user.save() assert self.user.is_active and self.user.email self._send_email(self.user) self.assertEqual(len(mail.outbox), 1) def test_send_email_to_optout_user(self): self.user.notify_by_email = False self.user.save() assert self.user.is_active and self.user.email self._send_email(self.user) self.assertEquals(len(mail.outbox), 0) def test_message_to_optout_user(self): self.user.notify_by_message = False self.user.notify_by_email = False self.user.save() self._send_email(self.user) self._create_message(self.user) self.assertEquals(len(mail.outbox), 0) self.assertEquals( Message.objects.unread().filter(user=self.user).count(), 0) self.assertEquals(Message.objects.filter(user=self.user).count(), 1) def test_member_join(self): def _get_counts(member): email_to = "%s" % (member.user.email) return Message.objects.filter(user=member.user).count() , \ len([x for x in mail.outbox if email_to in x.recipients()]) team, created = Team.objects.get_or_create(name='test', slug='test') # creates dummy users: for x in xrange(0, 5): user, member = User.objects.get_or_create( username="******" % x, email="*****@*****.**" % x, ) tm = TeamMember(team=team, user=user) if x == 0: tm.role = TeamMember.ROLE_OWNER owner = tm elif x == 1: tm.role = TeamMember.ROLE_ADMIN admin = tm elif x == 2: tm.role = TeamMember.ROLE_MANAGER manager = tm elif x == 3: tm.role = TeamMember.ROLE_CONTRIBUTOR contributor = tm if x < 4: # don't save the last role until we have counts tm.save() else: tm.role = TeamMember.ROLE_CONTRIBUTOR # now make sure we count previsou messages owner_messge_count_1, owner_email_count_1 = _get_counts(owner) admin_messge_count_1, admin_email_count_1 = _get_counts(admin) manager_messge_count_1, manager_email_count_1 = _get_counts(manager) contributor_messge_count_1, contributor_email_count_1 = _get_counts( contributor) # save the last team member and check that each group has appropriate counts tm.save() notifier.team_member_new(tm.pk) # owner and admins should receive email + message owner_messge_count_2, owner_email_count_2 = _get_counts(owner) self.assertEqual(owner_messge_count_1 + 1, owner_messge_count_2) self.assertEqual(owner_email_count_1 + 1, owner_email_count_2) admin_messge_count_2, admin_email_count_2 = _get_counts(admin) self.assertEqual(admin_messge_count_1 + 1, admin_messge_count_2) self.assertEqual(admin_email_count_1 + 1, admin_email_count_2) # manager shoud not manager_messge_count_2, manager_email_count_2 = _get_counts(manager) self.assertEqual(manager_messge_count_1, manager_messge_count_2) self.assertEqual(manager_email_count_1, manager_email_count_2) # contributor shoud not contributor_messge_count_2, contributor_email_count_2 = _get_counts( contributor) self.assertEqual(contributor_messge_count_1, contributor_messge_count_2) self.assertEqual(contributor_email_count_1, contributor_email_count_2) # now, this has to show up on everybody activitis fed action = Action.objects.get(team=team, user=tm.user, action_type=Action.MEMBER_JOINED) self.assertTrue( Action.objects.for_user(tm.user).filter(pk=action.pk).exists()) self.assertTrue( Action.objects.for_user(owner.user).filter(pk=action.pk).exists()) self.assertTrue( Action.objects.for_user( manager.user).filter(pk=action.pk).exists()) self.assertTrue( Action.objects.for_user( contributor.user).filter(pk=action.pk).exists()) self.assertTrue( Action.objects.for_user(admin.user).filter(pk=action.pk).exists()) def test_member_leave(self): return # fix me now def _get_counts(member): email_to = "%s" % (member.user.email) return Message.objects.filter(user=member.user).count() , \ len([x for x in mail.outbox if email_to in x.recipients()]) team, created = Team.objects.get_or_create(name='test', slug='test') # creates dummy users: for x in xrange(0, 5): user, member = User.objects.get_or_create( username="******" % x, email="*****@*****.**" % x, notify_by_email=True, ) tm = TeamMember(team=team, user=user) if x == 0: tm.role = TeamMember.ROLE_OWNER owner = tm elif x == 1: tm.role = TeamMember.ROLE_ADMIN admin = tm elif x == 2: tm.role = TeamMember.ROLE_MANAGER manager = tm elif x == 3: tm.role = TeamMember.ROLE_CONTRIBUTOR contributor = tm if x < 4: # don't save the last role until we have counts tm.save() else: tm.role = TeamMember.ROLE_CONTRIBUTOR tm.save() # now make sure we count previsou messages owner_messge_count_1, owner_email_count_1 = _get_counts(owner) admin_messge_count_1, admin_email_count_1 = _get_counts(admin) manager_messge_count_1, manager_email_count_1 = _get_counts(manager) contributor_messge_count_1, contributor_email_count_1 = _get_counts( contributor) # now delete and check numers tm_user = tm.user tm_user_pk = tm.user.pk team_pk = tm.team.pk tm.delete() notifier.team_member_leave(team_pk, tm_user_pk) # save the last team member and check that each group has appropriate counts # owner and admins should receive email + message owner_messge_count_2, owner_email_count_2 = _get_counts(owner) self.assertEqual(owner_messge_count_1 + 1, owner_messge_count_2) self.assertEqual(owner_email_count_1 + 1, owner_email_count_2) admin_messge_count_2, admin_email_count_2 = _get_counts(admin) self.assertEqual(admin_messge_count_1 + 1, admin_messge_count_2) self.assertEqual(admin_email_count_1 + 1, admin_email_count_2) # manager shoud not manager_messge_count_2, manager_email_count_2 = _get_counts(manager) self.assertEqual(manager_messge_count_1, manager_messge_count_2) self.assertEqual(manager_email_count_1, manager_email_count_2) # contributor shoud not contributor_messge_count_2, contributor_email_count_2 = _get_counts( contributor) self.assertEqual(contributor_messge_count_1, contributor_messge_count_2) self.assertEqual(contributor_email_count_1, contributor_email_count_2) # now, this has to show up on everybody activitis fed action = Action.objects.get(team=team, user=tm_user, action_type=Action.MEMBER_LEFT) self.assertTrue( Action.objects.for_user(tm.user).filter(pk=action.pk).exists()) self.assertTrue( Action.objects.for_user(owner.user).filter(pk=action.pk).exists()) self.assertTrue( Action.objects.for_user( manager.user).filter(pk=action.pk).exists()) self.assertTrue( Action.objects.for_user( contributor.user).filter(pk=action.pk).exists()) self.assertTrue( Action.objects.for_user(admin.user).filter(pk=action.pk).exists()) def test_application_new(self): def _get_counts(member): email_to = "%s" % (member.user.email) return Message.objects.filter(user=member.user).count() , \ len([x for x in mail.outbox if email_to in x.recipients()]) team, created = Team.objects.get_or_create(name='test', slug='test') applying_user = User.objects.all()[0] # creates dummy users: for x in xrange(0, 4): user, member = User.objects.get_or_create( username="******" % x, email="*****@*****.**" % x, notify_by_email=True, notify_by_message=True, ) tm = TeamMember(team=team, user=user) if x == 0: tm.role = TeamMember.ROLE_OWNER owner = tm elif x == 1: tm.role = TeamMember.ROLE_ADMIN admin = tm elif x == 2: tm.role = TeamMember.ROLE_MANAGER manager = tm elif x == 3: tm.role = TeamMember.ROLE_CONTRIBUTOR contributor = tm tm.save() # now make sure we count previsou messages owner_messge_count_1, owner_email_count_1 = _get_counts(owner) admin_messge_count_1, admin_email_count_1 = _get_counts(admin) manager_messge_count_1, manager_email_count_1 = _get_counts(manager) contributor_messge_count_1, contributor_email_count_1 = _get_counts( contributor) # now delete and check numers app = Application.objects.create(team=team, user=applying_user) app.save() notifier.application_sent.run(app.pk) # owner and admins should receive email + message owner_messge_count_2, owner_email_count_2 = _get_counts(owner) self.assertEqual(owner_messge_count_1 + 1, owner_messge_count_2) self.assertEqual(owner_email_count_1 + 1, owner_email_count_2) admin_messge_count_2, admin_email_count_2 = _get_counts(admin) self.assertEqual(admin_messge_count_1 + 1, admin_messge_count_2) self.assertEqual(admin_email_count_1 + 1, admin_email_count_2) # manager shoud not manager_messge_count_2, manager_email_count_2 = _get_counts(manager) self.assertEqual(manager_messge_count_1, manager_messge_count_2) self.assertEqual(manager_email_count_1, manager_email_count_2) # contributor shoud not contributor_messge_count_2, contributor_email_count_2 = _get_counts( contributor) self.assertEqual(contributor_messge_count_1, contributor_messge_count_2) self.assertEqual(contributor_email_count_1, contributor_email_count_2) def test_account_verified(self): user = User.objects.filter(notify_by_email=True, email__isnull=False)[0] c = EmailConfirmation.objects.send_confirmation(user) num_emails = len(mail.outbox) num_messages = Message.objects.filter(user=user).count() EmailConfirmation.objects.confirm_email(c.confirmation_key) self.assertEqual(num_emails + 1, len(mail.outbox)) self.assertEqual(num_messages + 1, Message.objects.filter(user=user).count()) def test_team_inviation_sent(self): team, created = Team.objects.get_or_create(name='test', slug='test') owner, created = TeamMember.objects.get_or_create( team=team, user=User.objects.all()[2], role='owner') applying_user = User.objects.all()[0] applying_user.notify_by_email = True applying_user.save() mail.outbox = [] message = "Will you be my valentine?" f = InviteForm(user=owner.user, team=team, data={ "user_id": applying_user.id, "role": "admin", "message": message, }) f.is_valid() f.save() self.assertEqual(len(mail.outbox), 1) msg = mail.outbox[0] self.assertIn(applying_user.email, msg.to[0]) self.assertIn( message, msg.body, ) def test_moderated_notifies_only_when_published(self): """ Set up a public team, add new video and new version. Notification should be sent. Setup a team with moderated videos """ from teams.moderation_const import WAITING_MODERATION, APPROVED def video_with_two_followers(): v, c = Video.get_or_create_for_url( "http://blip.tv/file/get/Miropcf-AboutUniversalSubtitles847.ogv" ) f1 = User.objects.all()[0] f2 = User.objects.all()[1] f1.notify_by_email = f2.notify_by_email = True f1.save() f2.save() v.followers.add(f1, f2) return v def new_version(v): language, created = SubtitleLanguage.objects.get_or_create( video=v, language='en', is_original=True) prev = language.version(public_only=False) version_no = 0 if prev: version_no = prev.version_no + 1 sv = SubtitleVersion(language=language, user=User.objects.all()[2], version_no=version_no, datetime_started=datetime.now()) sv.save() s = Subtitle(version=sv, subtitle_text=str(version_no + random.random()), subtitle_order=1, subtitle_id=str(version_no), start_time=random.random()) s.save() return sv v = video_with_two_followers() mail.outbox = [] from videos.tasks import video_changed_tasks v = video_with_two_followers() sv = new_version(v) video_changed_tasks(v.pk, sv.pk) # notifications are only sent on the second version of a video # as optimization sv = new_version(v) video_changed_tasks(v.pk, sv.pk) # video is public , followers should be notified self.assertEquals(len(mail.outbox), 2) mail.outbox = [] # add to a moderated video team = Team.objects.create(slug='my-team', name='myteam', workflow_enabled=True) workflow = Workflow(team=team, review_allowed=20, approve_allowed=20) workflow.save() tv = TeamVideo(team=team, video=v, added_by=User.objects.all()[2]) tv.save() sv = new_version(v) # with the widget, this would set up correctly sv.moderation_status = WAITING_MODERATION sv.save() video_changed_tasks(v.pk, sv.pk) sv = SubtitleVersion.objects.get(pk=sv.pk) self.assertFalse(sv.is_public) # approve video t = Task(type=40, approved=20, team_video=tv, team=team, language='en', subtitle_version=sv) t.save() t.complete() video_changed_tasks(v.pk, sv.pk) self.assertEqual(len(mail.outbox), 2) def test_send_message_view(self): to_user = User.objects.filter(notify_by_email=True)[0] user, c = User.objects.get_or_create(username='******') user.notify_by_email = True user.set_password('username') user.save() mail.outbox = [] self.client.login(username='******', password='******') self.client.post(reverse('messages:new'), { "user": to_user.pk, "subject": "hey", 'content': 'test' }) self.assertEqual(len(mail.outbox), 1) m = mail.outbox[0] self.assertTrue(to_user.email in m.to)
class MessageTest(TestCase): def setUp(self): self.author = User.objects.all()[:1].get() self.subject = "Let's talk" self.body = "Will you please help me out with Portuguese trans?" self.user = User.objects.exclude(pk=self.author.pk)[:1].get() def _create_message(self, to_user): self.message = Message(user=to_user, author=self.author, subject=self.subject, content=self.body) self.message.save() def _send_email(self, to_user): send_templated_email(to_user, "test email", "messages/email/email-confirmed.html", {}) def test_send_email_to_allowed_user(self): self.user.notify_by_email = True self.user.save() assert self.user.is_active and self.user.email self._send_email(self.user) self.assertEqual(len(mail.outbox), 1) def test_send_email_to_optout_user(self): self.user.notify_by_email = False self.user.save() assert self.user.is_active and self.user.email self._send_email(self.user) self.assertEquals(len(mail.outbox), 0) def test_message_to_optout_user(self): self.user.notify_by_message = False self.user.notify_by_email = False self.user.save() self._send_email(self.user) self._create_message(self.user) self.assertEquals(len(mail.outbox), 0) self.assertEquals( Message.objects.unread().filter(user=self.user).count(), 0) self.assertEquals(Message.objects.filter(user=self.user).count(), 1) def test_member_join(self): def _get_counts(member): email_to = "%s" % (member.user.email) return Message.objects.filter(user=member.user).count() , \ len([x for x in mail.outbox if email_to in x.recipients()]) team, created = Team.objects.get_or_create(name='test', slug='test') # creates dummy users: for x in xrange(0, 5): user, member = User.objects.get_or_create( username="******" % x, email="*****@*****.**" % x, ) tm = TeamMember(team=team, user=user) if x == 0: tm.role = TeamMember.ROLE_OWNER owner = tm elif x == 1: tm.role = TeamMember.ROLE_ADMIN admin = tm elif x == 2: tm.role = TeamMember.ROLE_MANAGER manager = tm elif x == 3: tm.role = TeamMember.ROLE_CONTRIBUTOR contributor = tm if x < 4: # don't save the last role until we have counts tm.save() else: tm.role = TeamMember.ROLE_CONTRIBUTOR # now make sure we count previsou messages owner_messge_count_1, owner_email_count_1 = _get_counts(owner) admin_messge_count_1, admin_email_count_1 = _get_counts(admin) manager_messge_count_1, manager_email_count_1 = _get_counts(manager) contributor_messge_count_1, contributor_email_count_1 = _get_counts( contributor) # save the last team member and check that each group has appropriate counts tm.save() notifier.team_member_new(tm.pk) # owner and admins should receive email + message owner_messge_count_2, owner_email_count_2 = _get_counts(owner) self.assertEqual(owner_messge_count_1 + 1, owner_messge_count_2) self.assertEqual(owner_email_count_1 + 1, owner_email_count_2) admin_messge_count_2, admin_email_count_2 = _get_counts(admin) self.assertEqual(admin_messge_count_1 + 1, admin_messge_count_2) self.assertEqual(admin_email_count_1 + 1, admin_email_count_2) # manager shoud not manager_messge_count_2, manager_email_count_2 = _get_counts(manager) self.assertEqual(manager_messge_count_1, manager_messge_count_2) self.assertEqual(manager_email_count_1, manager_email_count_2) # contributor shoud not contributor_messge_count_2, contributor_email_count_2 = _get_counts( contributor) self.assertEqual(contributor_messge_count_1, contributor_messge_count_2) self.assertEqual(contributor_email_count_1, contributor_email_count_2) # now, this has to show up on everybody activitis fed action = Action.objects.get(team=team, user=tm.user, action_type=Action.MEMBER_JOINED) self.assertTrue( Action.objects.for_user(tm.user).filter(pk=action.pk).exists()) self.assertTrue( Action.objects.for_user(owner.user).filter(pk=action.pk).exists()) self.assertTrue( Action.objects.for_user( manager.user).filter(pk=action.pk).exists()) self.assertTrue( Action.objects.for_user( contributor.user).filter(pk=action.pk).exists()) self.assertTrue( Action.objects.for_user(admin.user).filter(pk=action.pk).exists()) def test_member_leave(self): return # fix me now def _get_counts(member): email_to = "%s" % (member.user.email) return Message.objects.filter(user=member.user).count() , \ len([x for x in mail.outbox if email_to in x.recipients()]) team, created = Team.objects.get_or_create(name='test', slug='test') # creates dummy users: for x in xrange(0, 5): user, member = User.objects.get_or_create( username="******" % x, email="*****@*****.**" % x, notify_by_email=True, ) tm = TeamMember(team=team, user=user) if x == 0: tm.role = TeamMember.ROLE_OWNER owner = tm elif x == 1: tm.role = TeamMember.ROLE_ADMIN admin = tm elif x == 2: tm.role = TeamMember.ROLE_MANAGER manager = tm elif x == 3: tm.role = TeamMember.ROLE_CONTRIBUTOR contributor = tm if x < 4: # don't save the last role until we have counts tm.save() else: tm.role = TeamMember.ROLE_CONTRIBUTOR tm.save() # now make sure we count previsou messages owner_messge_count_1, owner_email_count_1 = _get_counts(owner) admin_messge_count_1, admin_email_count_1 = _get_counts(admin) manager_messge_count_1, manager_email_count_1 = _get_counts(manager) contributor_messge_count_1, contributor_email_count_1 = _get_counts( contributor) # now delete and check numers tm_user = tm.user tm_user_pk = tm.user.pk team_pk = tm.team.pk tm.delete() notifier.team_member_leave(team_pk, tm_user_pk) # save the last team member and check that each group has appropriate counts # owner and admins should receive email + message owner_messge_count_2, owner_email_count_2 = _get_counts(owner) self.assertEqual(owner_messge_count_1 + 1, owner_messge_count_2) self.assertEqual(owner_email_count_1 + 1, owner_email_count_2) admin_messge_count_2, admin_email_count_2 = _get_counts(admin) self.assertEqual(admin_messge_count_1 + 1, admin_messge_count_2) self.assertEqual(admin_email_count_1 + 1, admin_email_count_2) # manager shoud not manager_messge_count_2, manager_email_count_2 = _get_counts(manager) self.assertEqual(manager_messge_count_1, manager_messge_count_2) self.assertEqual(manager_email_count_1, manager_email_count_2) # contributor shoud not contributor_messge_count_2, contributor_email_count_2 = _get_counts( contributor) self.assertEqual(contributor_messge_count_1, contributor_messge_count_2) self.assertEqual(contributor_email_count_1, contributor_email_count_2) # now, this has to show up on everybody activitis fed action = Action.objects.get(team=team, user=tm_user, action_type=Action.MEMBER_LEFT) self.assertTrue( Action.objects.for_user(tm.user).filter(pk=action.pk).exists()) self.assertTrue( Action.objects.for_user(owner.user).filter(pk=action.pk).exists()) self.assertTrue( Action.objects.for_user( manager.user).filter(pk=action.pk).exists()) self.assertTrue( Action.objects.for_user( contributor.user).filter(pk=action.pk).exists()) self.assertTrue( Action.objects.for_user(admin.user).filter(pk=action.pk).exists()) def test_application_new(self): def _get_counts(member): email_to = "%s" % (member.user.email) return Message.objects.filter(user=member.user).count() , \ len([x for x in mail.outbox if email_to in x.recipients()]) team, created = Team.objects.get_or_create(name='test', slug='test') applying_user = User.objects.all()[0] # creates dummy users: for x in xrange(0, 4): user, member = User.objects.get_or_create( username="******" % x, email="*****@*****.**" % x, notify_by_email=True, notify_by_message=True, ) tm = TeamMember(team=team, user=user) if x == 0: tm.role = TeamMember.ROLE_OWNER owner = tm elif x == 1: tm.role = TeamMember.ROLE_ADMIN admin = tm elif x == 2: tm.role = TeamMember.ROLE_MANAGER manager = tm elif x == 3: tm.role = TeamMember.ROLE_CONTRIBUTOR contributor = tm tm.save() # now make sure we count previsou messages owner_messge_count_1, owner_email_count_1 = _get_counts(owner) admin_messge_count_1, admin_email_count_1 = _get_counts(admin) manager_messge_count_1, manager_email_count_1 = _get_counts(manager) contributor_messge_count_1, contributor_email_count_1 = _get_counts( contributor) # now delete and check numers app = Application.objects.create(team=team, user=applying_user) app.save() notifier.application_sent.run(app.pk) # owner and admins should receive email + message owner_messge_count_2, owner_email_count_2 = _get_counts(owner) self.assertEqual(owner_messge_count_1 + 1, owner_messge_count_2) self.assertEqual(owner_email_count_1 + 1, owner_email_count_2) admin_messge_count_2, admin_email_count_2 = _get_counts(admin) self.assertEqual(admin_messge_count_1 + 1, admin_messge_count_2) self.assertEqual(admin_email_count_1 + 1, admin_email_count_2) # manager shoud not manager_messge_count_2, manager_email_count_2 = _get_counts(manager) self.assertEqual(manager_messge_count_1, manager_messge_count_2) self.assertEqual(manager_email_count_1, manager_email_count_2) # contributor shoud not contributor_messge_count_2, contributor_email_count_2 = _get_counts( contributor) self.assertEqual(contributor_messge_count_1, contributor_messge_count_2) self.assertEqual(contributor_email_count_1, contributor_email_count_2) def test_account_verified(self): user = User.objects.filter(notify_by_email=True, email__isnull=False)[0] c = EmailConfirmation.objects.send_confirmation(user) num_emails = len(mail.outbox) num_messages = Message.objects.filter(user=user).count() EmailConfirmation.objects.confirm_email(c.confirmation_key) self.assertEqual(num_emails + 1, len(mail.outbox)) self.assertEqual(num_messages + 1, Message.objects.filter(user=user).count()) def test_team_inviation_sent(self): team, created = Team.objects.get_or_create(name='test', slug='test') owner, created = TeamMember.objects.get_or_create( team=team, user=User.objects.all()[2], role='owner') applying_user = User.objects.all()[0] applying_user.notify_by_email = True applying_user.save() mail.outbox = [] message = "Will you be my valentine?" f = InviteForm(user=owner.user, team=team, data={ "user_id": applying_user.id, "role": "admin", "message": message, }) f.is_valid() f.save() self.assertEqual(len(mail.outbox), 1) msg = mail.outbox[0] self.assertIn(applying_user.email, msg.to[0]) self.assertIn( message, msg.body, ) def test_moderated_notifies_only_when_published(self): # TODO: should this use the new visibility settings instead of the old # moderation stuff? """ Set up a public team, add new video and new version. Notification should be sent. Setup a team with moderated videos """ from teams.moderation_const import WAITING_MODERATION def video_with_two_followers(): v, c = Video.get_or_create_for_url( "http://blip.tv/file/get/Miropcf-AboutUniversalSubtitles847.ogv" ) f1 = User.objects.all()[0] f2 = User.objects.all()[1] f1.notify_by_email = f2.notify_by_email = True f1.save() f2.save() v.followers.add(f1, f2) return v def new_version(v): subs = [(0, 1000, 'Hello', {}), (2000, 5000, 'world.', {})] add_subtitles(v, 'en', subs, author=self.author, committer=self.author) subs = [(0, 1000, 'Hello', {}), (3000, 5000, 'world.', {})] return add_subtitles(v, 'en', subs, author=self.author, committer=self.author) v = video_with_two_followers() mail.outbox = [] from videos.tasks import video_changed_tasks v = video_with_two_followers() sv = new_version(v) video_changed_tasks(v.pk, sv.pk) # notifications are only sent on the second version of a video # as optimization sv = new_version(v) video_changed_tasks(v.pk, sv.pk) # video is public , followers should be notified self.assertEquals(len(mail.outbox), 2) mail.outbox = [] # add to a moderated video team = Team.objects.create(slug='my-team', name='myteam', workflow_enabled=True) workflow = Workflow(team=team, review_allowed=20, approve_allowed=20) workflow.save() tv = TeamVideo(team=team, video=v, added_by=User.objects.all()[2]) tv.save() sv = new_version(v) # with the widget, this would set up correctly sv.moderation_status = WAITING_MODERATION sv.save() video_changed_tasks(v.pk, sv.pk) sv = sub_models.SubtitleVersion.objects.get(pk=sv.pk) self.assertFalse(sv.is_public()) # no emails should be sent before the video is approved self.assertEqual(len(mail.outbox), 0) # approve video t = Task(type=40, approved=20, team_video=tv, team=team, language='en', new_subtitle_version=sv, assignee=self.author) t.save() t.complete() self.assertTrue(sv.is_public()) video_changed_tasks(v.pk, sv.pk) # Once the video is approved, we should send out the # team-task-approved-published.html email and the # email_notification_non_editors.html to the author self.assertEqual(len(mail.outbox), 2) def test_send_message_view(self): to_user = User.objects.filter(notify_by_email=True)[0] user, c = User.objects.get_or_create(username='******') user.notify_by_email = True user.set_password('username') user.save() mail.outbox = [] self.client.login(username='******', password='******') self.client.post(reverse('messages:new'), { "user": to_user.pk, "subject": "hey", 'content': 'test' }) self.assertEqual(len(mail.outbox), 1) m = mail.outbox[0] self.assertTrue(to_user.email in m.to) def test_messages_remain_after_team_membership(self): # Here's the scenario: # User is invited to a team # - User accepts invitation # - Message for the invitation gets deleted -> wrong! user = User.objects.filter(notify_by_message=True)[0] owner = User.objects.filter(notify_by_message=True)[1] team = Team.objects.create(name='test-team', slug='test-team', membership_policy=Team.APPLICATION) invite_form = InviteForm( team, owner, { 'user_id': user.pk, 'message': 'Subtitle ALL the things!', 'role': 'contributor', }) invite_form.is_valid() self.assertFalse(invite_form.errors) self.assertEquals(Message.objects.for_user(user).count(), 0) invite = invite_form.save() # user has the invitation message on their inbox now self.assertEquals(Message.objects.for_user(user).count(), 1) invite_message = Message.objects.for_user(user)[0] # now user accepts invite invite.accept() # he should be a team memebr self.assertTrue(team.members.filter(user=user).exists()) # message should be still on their inbos self.assertIn(invite_message, Message.objects.for_user(user))