UPD: more/better tests.

dav_auth/tests/test_emails.py

@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
-from django.apps import apps
 from django.contrib.auth import get_user_model
 from django.core import mail as django_mail
-from django.test import TestCase
+
+from dav_base.tests.generic import EmailTestCase
 
 from ..emails import PasswordSetEmail
 
@@ -11,18 +11,21 @@ TEST_USERNAME = 'user'
 TEST_PASSWORD = u'me||ön 2'
 TEST_EMAIL = 'root@localhost'
 
+PASSWORD_EMAIL_TEMPLATE = u"""Hallo {fullname},
 
-class EmailsTestCase(TestCase):
+Benutzername: {username}
+Passwort:     {password}
+
+URL:          {base_url}/
+"""
+
+
+class TestCase(EmailTestCase):
     def setUp(self):
+        super(TestCase, self).setUp()
         model = get_user_model()
         self.user = model.objects.create_user(username=TEST_USERNAME, password=TEST_PASSWORD, email=TEST_EMAIL)
 
-        self.email_sender = 'Automatic Software Test <root@localhost>'
-        self.email_subject_prefix = '[Test]'
-        app_config = apps.get_app_config('dav_base')
-        app_config.settings.email_sender = self.email_sender
-        app_config.settings.email_subject_prefix = self.email_subject_prefix
-
     def test_send(self):
         password = TEST_PASSWORD[::-1]
 
@@ -32,15 +35,14 @@ class EmailsTestCase(TestCase):
         self.assertEqual(len(django_mail.outbox), 1)
         mail = django_mail.outbox[0]
 
-        recipient = u'"%s" <%s>' % (self.user.get_full_name(), self.user.email)
+        self.assertSender(mail)
-        recipients = mail.recipients()
+        self.assertRecipients(mail, [self.user])
-        self.assertIn(recipient, recipients)
+        self.assertSubject(mail, u'Zugangsdaten')
-        self.assertEqual(len(recipients), 1)
 
-        self.assertEqual(mail.from_email, self.email_sender)
+        expected_body = PASSWORD_EMAIL_TEMPLATE.format(
-
+            fullname=self.user.get_full_name(),
-        subject = u'Zugangsdaten'
+            username=self.user.username,
-        subject = u'{} {}'.format(self.email_subject_prefix, subject)
+            password=password,
-        self.assertEqual(mail.subject, subject)
+            base_url=self.email_base_url,
-
+        )
-        self.assertIn(password, mail.body)
+        self.assertBody(mail, expected_body)

dav_base/tests/generic.py

@@ -3,6 +3,7 @@ import os
 import sys
 import urllib
 from unittest import skip, SkipTest
+from django.apps import apps
 from django.contrib.staticfiles.testing import StaticLiveServerTestCase
 from django.test import SimpleTestCase, TestCase, tag
 from django.urls import reverse
@@ -46,50 +47,47 @@ class AppsTestCase(SimpleTestCase):
                 self.assertIsInstance(value, of)
 
 
-class Url(object):
+class EmailTestCase(TestCase):
-    def __init__(self, location, name=None, func=None, **kwargs):
+    email_sender = 'Automatic Software Test <root@localhost>'
-        self.location = location
+    email_base_url = 'http://localhost'
-        self.name = name
+    email_subject_prefix = '[Test]'
-        self.func = func
-        self.redirect = kwargs.get('redirect', False)
-        self.status_code = kwargs.get('status_code', 200)
-        self.follow = kwargs.get('follow', False)
 
+    def assertSender(self, mail):
+        self.assertEqual(mail.from_email, self.email_sender)
 
-class UrlsTestCase(SimpleTestCase):
+    def assertRecipients(self, mail, recipients):
-    urls = ()
+        self.assertEqual(len(mail.recipients()), len(recipients))
+        for recipient in recipients:
+            expected_recipient = u'"%s" <%s>' % (recipient.get_full_name(), recipient.email)
+            recipients = mail.recipients()
+            self.assertIn(expected_recipient, recipients)
 
-    def test_locations(self):
+    def assertSubject(self, mail, subject):
-        for url in self.urls:
+        expected_subject = u'{} {}'.format(self.email_subject_prefix, subject)
-            if url.location:
+        self.assertEqual(mail.subject, expected_subject)
-                response = self.client.get(url.location, follow=url.follow)
 
-                if url.redirect:
+    def assertBody(self, mail, body):
-                    self.assertRedirects(response, url.redirect)
+        expected_lines = body.splitlines()
-                else:
+        lines = mail.body.splitlines()
-                    self.assertEqual(response.status_code, url.status_code,
+        i = 0
-                                     'Getting \'{}\' is not OK'.format(url.location))
+        for expected_line in expected_lines:
+            try:
+                line = lines[i]
+            except IndexError:
+                self.fail('line %d: no such line: %s' % (i, expected_line))
+            i += 1
+            try:
+                self.assertEqual(line, expected_line)
+            except AssertionError as e:
+                self.fail('line %d: %s' % (i, e.message))
+        self.assertEqual(mail.body, body)
 
-                if url.func:
+    def setUp(self):
-                    self.assertEqual(response.resolver_match.func.__name__,
+        super(EmailTestCase, self).setUp()
-                                     url.func.__name__,
+        app_config = apps.get_app_config('dav_base')
-                                     'Getting \'{}\' resolve to wrong function'.format(url.location))
+        app_config.settings.email_sender = self.email_sender
-
+        app_config.settings.email_base_url = self.email_base_url
-    def test_names(self):
+        app_config.settings.email_subject_prefix = self.email_subject_prefix
-        for url in self.urls:
-            if url.name:
-                response = self.client.get(reverse(url.name), follow=url.follow)
-
-                if url.redirect:
-                    self.assertRedirects(response, url.redirect)
-                else:
-                    self.assertEqual(response.status_code, url.status_code,
-                                     'Getting url named \'{}\' is not OK'.format(url.name))
-
-                if url.func:
-                    self.assertEqual(response.resolver_match.func.__name__,
-                                     url.func.__name__,
-                                     'Getting url named \'{}\' resolve to wrong function'.format(url.name))
 
 
 class FormDataSet(object):
@@ -156,6 +154,52 @@ class FormsTestCase(TestCase):
                     self.assertIn(code, error_codes)
 
 
+class Url(object):
+    def __init__(self, location, name=None, func=None, **kwargs):
+        self.location = location
+        self.name = name
+        self.func = func
+        self.redirect = kwargs.get('redirect', False)
+        self.status_code = kwargs.get('status_code', 200)
+        self.follow = kwargs.get('follow', False)
+
+
+class UrlsTestCase(SimpleTestCase):
+    urls = ()
+
+    def test_locations(self):
+        for url in self.urls:
+            if url.location:
+                response = self.client.get(url.location, follow=url.follow)
+
+                if url.redirect:
+                    self.assertRedirects(response, url.redirect)
+                else:
+                    self.assertEqual(response.status_code, url.status_code,
+                                     'Getting \'{}\' is not OK'.format(url.location))
+
+                if url.func:
+                    self.assertEqual(response.resolver_match.func.__name__,
+                                     url.func.__name__,
+                                     'Getting \'{}\' resolve to wrong function'.format(url.location))
+
+    def test_names(self):
+        for url in self.urls:
+            if url.name:
+                response = self.client.get(reverse(url.name), follow=url.follow)
+
+                if url.redirect:
+                    self.assertRedirects(response, url.redirect)
+                else:
+                    self.assertEqual(response.status_code, url.status_code,
+                                     'Getting url named \'{}\' is not OK'.format(url.name))
+
+                if url.func:
+                    self.assertEqual(response.resolver_match.func.__name__,
+                                     url.func.__name__,
+                                     'Getting url named \'{}\' resolve to wrong function'.format(url.name))
+
+
 class SeleniumTestCase(StaticLiveServerTestCase):
     window_width = 1024
     window_height = 768

dav_events/templates/dav_events/emails/event_accepted.txt

@@ -13,4 +13,4 @@ Ausschreibung:
 {{ event.render_as_text }}{% if internal_note %}
 Bearbeitungshinweis:
 ====================
-{{ internal_note }}{% endif %}
+{{ internal_note }}{% endif %}

dav_events/templates/dav_events/emails/event_to_accept.txt

@@ -15,4 +15,4 @@ Bearbeitungshinweis:
 {% endif %}
 Ausschreibung:
 ==============
-{{ event.render_as_text }}
+{{ event.render_as_text }}

dav_events/templates/dav_events/emails/event_to_publish_web.txt

@@ -70,4 +70,4 @@ Joomla HTML
 {% endif %}{% if trainer_familyname %}<strong>{% trans 'Leitung' %}:</strong> {{ trainer_firstname }} {{ trainer_familyname }}{% if trainer_email or trainer_phone %} ({% if trainer_email %}<a href="mailto:{{ trainer_email }}">{{ trainer_email }}</a>{% endif %}{% if trainer_email and trainer_phone %}, {% endif %}{% if trainer_phone %}{{ trainer_phone }}{% endif %}){% endif %}
 {% endif %}</p>
 {% if registration_required and registration_howto %}<p>{{ registration_howto|urlize }}</p>
-{% endif %}
+{% endif %}

dav_events/tests/generic.py

@@ -0,0 +1,22 @@
+from django.apps import apps
+from django.contrib.auth import get_user_model
+from django.contrib.auth.models import Group
+
+
+class RoleMixin(object):
+    def create_user_for_role(self, role_name, password, first_name, last_name):
+        group = Group(name=role_name)
+        group.save()
+
+        user_model = get_user_model()
+        email = '{}@localhost'.format(role_name)
+        user_name = email
+        user = user_model.objects.create_user(username=user_name, password=password, email=user_name,
+                                              first_name=first_name, last_name=last_name)
+        user.groups.add(group)
+
+        setting_name = 'groups_{}'.format(role_name)
+        app_config = apps.get_app_config('dav_events')
+        setattr(app_config.settings, setting_name, [role_name])
+
+        return user

dav_events/tests/test_emails.py

@@ -1,21 +1,179 @@
 # -*- coding: utf-8 -*-
+import datetime
 from django.apps import apps
 from django.contrib.auth import get_user_model
 from django.core import mail as django_mail
-from django.test import TestCase
 from django.utils import timezone
 
+from dav_base.tests.generic import EmailTestCase
+
 from ..models.event import Event
+from ..models.oneclickaction import OneClickAction
 from .. import emails
 
+from .generic import RoleMixin
 
-class EmailsTestCase(TestCase):
+TEST_EVENT_DATA = {
+    'title': u'Täst',
+    'description': u'Teßt',
+    'mode': 'joint',
+    'sport': 'W',
+    'level': 'beginner',
+    'first_day': datetime.date(2019, 3, 1),
+    'country': 'DE',
+    'trainer_firstname': u'Übungsleiter',
+    'trainer_familyname': u'Weißalles',
+    'trainer_email': 'trainer@localhost',
+}
+
+EVENT_UPDATED_EMAIL_TEMPLATE = u"""Hallo {recipient_first_name},
+
+{editor_full_name} hat die folgende Veranstaltung geändert:
+  {event}
+
+Link zur Veranstaltung:
+  {base_url}{event_url}
+
+ Ausschreibung:
+ ==============
+ W**/19 - Täst
+ 
+ Freitag, 01. März 2019
+ 
+-Teßt
++Teßt Gößweinstein
+ 
+ Leitung: Übungsleiter Weißalles (trainer@localhost)
+ 
+ Nichtöffentliche Daten:
+ =======================
+ Veranstaltungsart: gemeinschaftliche Tour
+ Schwierigkeitsnivau: Anfänger
+ Gelände: Kletterhalle
+ Anreise des Kurs-/Tourenleiters am Vortag: Nein
+ Veröffentlichung: sofort
+ """
+
+EVENT_SUBMITTED_EMAIL_TEMPLATE = u"""Hallo {recipient_first_name},
+
+eine Veranstaltung wurde in deinem Namen eingereicht.
+Die entsprechenden Referenten wurden informiert, um deine Veranstaltung frei zu geben.
+
+Link zur Veranstaltung:
+  {base_url}{event_url}
+
+Voraussichtliche Veröffentlichung: In wenigen Tagen
+
+Ausschreibung:
+==============
+{event_text}"""
+
+EVENT_TO_ACCEPT_EMAIL_TEMPLATE = u"""Hallo {recipient_first_name},
+
+{trainer_firstname} {trainer_familyname} hat eine Veranstaltung eingereicht.
+
+Der folgende Link führt zur Veranstaltung:
+  {base_url}{event_url}
+Über den folgenden Link kannst du die Veranstaltung unmittelbar freigeben:
+  {base_url}{accept_url}
+
+Veröffentlichung: sofort
+
+Ausschreibung:
+==============
+{event_text}"""
+
+EVENT_ACCEPTED_EMAIL_TEMPLATE=u"""Hallo {recipient_first_name},
+
+deine Veranstaltung wurde von {editor_full_name} freigegeben.
+Die Redaktion wurde informiert, um deine Veranstaltung zu veröffentlichen.
+
+Link zur Veranstaltung:
+  {base_url}{event_url}
+
+Voraussichtliche Veröffentlichung: {planned_publication_date}
+
+Ausschreibung:
+==============
+{event_text}
+Bearbeitungshinweis:
+====================
+{internal_note}"""
+
+EVENT_TO_PUBLISH_WEB_EMAIL_TEMPLATE = u"""Hallo {recipient_first_name},
+
+{trainer_firstname} {trainer_familyname} hat eine neue Veranstaltung eingereicht.
+Die Veranstaltung wurde von {editor_full_name} zur Veröffentlichung
+auf der Webseite frei gegeben.
+
+Der folgende Link führt zur Veranstaltung:
+  {base_url}{event_url}
+Über den folgenden Link kannst du die Veröffentlichung auf der Webseite unmittelbar bestätigen:
+  {base_url}{confirm_publication_url}
+
+Veröffentlichung: ({planned_publication_date})
+=================
+Veröffentlichung starten: {planned_publication_date_short} 00:00:00
+Veröffentlichung beenden: {day_after_short} 00:00:00
+Erstellungsdatum: {first_day_short} 00:00:00
+Titel: {number} - {title}
+
+Bearbeitungshinweis:
+====================
+{internal_note}
+
+Joomla HTML
+===========
+<h6>{normalized_long_date}</h6>
+<p>{description}</p>
+<hr id="system-readmore" />
+
+<p>
+<strong>Leitung:</strong> {trainer_firstname} {trainer_familyname} (<a href="mailto:trainer@localhost">trainer@localhost</a>)
+</p>
+"""
+
+EVENT_TO_PUBLISH_FACEBOOK_EMAIL_TEMPLATE = u"""Hallo {recipient_first_name},
+
+{trainer_firstname} {trainer_familyname} hat eine neue Veranstaltung eingereicht.
+Die Veranstaltung wurde von {editor_full_name} zur Veröffentlichung
+auf Facebook frei gegeben.
+
+Der folgende Link führt zur Veranstaltung:
+  {base_url}{event_url}
+Über den folgenden Link kannst du die Veröffentlichung auf Facebook unmittelbar bestätigen:
+  {base_url}{confirm_publication_url}
+
+Veröffentlichung: (sofort)
+=================
+Veröffentlichung beenden: {day_after_short} 00:00:00
+Erstellungsdatum: {first_day_short} 00:00:00
+Titel: {number} - {title}
+
+Ausschreibung:
+==============
+{event_text}"""
+
+
+class TestCase(RoleMixin, EmailTestCase):
     def setUp(self):
-        self.email_sender = 'Automatic Software Test <root@localhost>'
+        super(TestCase, self).setUp()
-        self.email_subject_prefix = '[Test]'
+
-        app_config = apps.get_app_config('dav_base')
+        app_config = apps.get_containing_app_config(__package__)
-        app_config.settings.email_sender = self.email_sender
+        app_config.settings.enable_email_on_update = False
-        app_config.settings.email_subject_prefix = self.email_subject_prefix
+        app_config.settings.enable_email_on_status_update = False
+        self.app_settings = app_config.settings
+
+        event_data = TEST_EVENT_DATA
+        self.event = Event(**event_data)
+        self.event.save()
+        self.trainer = self.event.owner
+
+        self.manager_super = self.create_user_for_role('manager_super', 'password', 'Touren', 'Referent')
+        self.manager_w = self.create_user_for_role('manager_w', 'password', 'Bereichsleiter', 'Wandern')
+        self.manager_s = self.create_user_for_role('manager_s', 'password', 'Bereichsleiter', 'Ski')
+        self.publisher_web = self.create_user_for_role('publisher_web', 'password', 'Joomla', 'Redakteur')
+        self.publisher_facebook = self.create_user_for_role('publisher_facebook', 'password', 'Facebook', 'Redakteur')
 
         model = get_user_model()
         self.recipient = model.objects.create_user(username='recipient@example.com',
@@ -30,66 +188,189 @@ class EmailsTestCase(TestCase):
                                                 first_name=u'Ed Ü.',
                                                 last_name=u'Itor',
                                                 )
-        event_data = {
+
-            'title': u'Täst',
+    def test_disabled_mail(self):
-            'description': u'Teßt',
+        self.event.workflow.update_status('submitted', self.trainer)
-            'mode': 'joint',
+        self.event.description += u' Gößweinstein'
-            'sport': 'W',
-            'level': 'beginner',
-            'first_day': timezone.now(),
-            'country': 'DE',
-            'owner': self.editor,
-        }
-        self.event = Event(**event_data)
         self.event.save()
-        self.diff = u"""--- 
+        self.event.workflow.update_status('accepted', self.editor)
-+++ 
+        self.event.first_day += datetime.timedelta(1)
-@@ -1,3 +1,3 @@
+        self.event.save()
- Line 1 ä
+        self.assertEqual(len(django_mail.outbox), 0)
--Line2
-+Line 2
-Line 3 END"""
 
     def test_event_updated_mail(self):
-        email = emails.EventUpdatedMail(recipient=self.recipient, event=self.event, editor=self.editor,
+        expected_recipient = self.manager_super
-                                        diff=self.diff)
+        editor = self.trainer
-        email.send()
+
+        self.app_settings.enable_email_on_update = True
+        self.event.workflow.update_status('submitted', self.trainer)
+        self.event.description += u' Gößweinstein'
+        self.event.save()
+        self.assertEqual(len(django_mail.outbox), 2)
 
-        self.assertEqual(len(django_mail.outbox), 1)
         mail = django_mail.outbox[0]
+        self.assertSender(mail)
+        self.assertRecipients(mail, [expected_recipient])
+        self.assertSubject(mail, u'Veranstaltung geändert')
 
-        recipient = u'"%s" <%s>' % (self.recipient.get_full_name(), self.recipient.email)
+        expected_body = EVENT_UPDATED_EMAIL_TEMPLATE.format(
-        recipients = mail.recipients()
+            recipient_first_name=expected_recipient.first_name,
-        self.assertIn(recipient, recipients)
+            editor_full_name=editor.get_full_name(),
-        self.assertEqual(len(recipients), 1)
+            event=unicode(self.event),
-
+            base_url=self.email_base_url,
-        self.assertEqual(mail.from_email, self.email_sender)
+            event_url=self.event.get_absolute_url(),
-
+        )
-        subject = u'Veranstaltung geändert'
+        self.assertBody(mail, expected_body)
-        subject = u'{} {}'.format(self.email_subject_prefix, subject)
-        self.assertEqual(mail.subject, subject)
-
-        self.assertIn(self.recipient.first_name, mail.body)
-        self.assertIn(self.editor.get_full_name(), mail.body)
-        self.assertIn(unicode(self.event), mail.body)
-        self.assertIn(self.diff, mail.body)
 
     def test_event_submitted_mail(self):
-        # TODO
+        expected_recipient = self.trainer
-        pass
+
+        self.app_settings.enable_email_on_status_update = True
+        self.event.workflow.update_status('submitted', self.trainer)
+        self.assertEqual(len(django_mail.outbox), 3)
+
+        mail = django_mail.outbox[0]
+        self.assertSender(mail)
+        self.assertRecipients(mail, [expected_recipient])
+        self.assertSubject(mail, u'Veranstaltung eingereicht')
+
+        expected_body = EVENT_SUBMITTED_EMAIL_TEMPLATE.format(
+            recipient_first_name=expected_recipient.first_name,
+            base_url=self.email_base_url,
+            event_url=self.event.get_absolute_url(),
+            event_text=self.event.render_as_text(),
+        )
+        self.assertBody(mail, expected_body)
 
     def test_event_to_accept_mail(self):
-        # TODO
+        expected_recipient = self.manager_super
-        pass
+
+        self.app_settings.enable_email_on_status_update = True
+        self.event.workflow.update_status('submitted', self.trainer)
+        self.assertEqual(len(django_mail.outbox), 3)
+
+        mail = django_mail.outbox[1]
+        self.assertSender(mail)
+        self.assertRecipients(mail, [expected_recipient])
+        self.assertSubject(mail, u'Veranstaltung freigeben')
+
+        action_parameters = '{},{},{}'.format(self.event.id, 'accepted', expected_recipient.id)
+        action = OneClickAction.objects.get(parameters=action_parameters)
+
+        expected_body = EVENT_TO_ACCEPT_EMAIL_TEMPLATE.format(
+            recipient_first_name=expected_recipient.first_name,
+            trainer_firstname=self.event.trainer_firstname,
+            trainer_familyname=self.event.trainer_familyname,
+            base_url=self.email_base_url,
+            event_url=self.event.get_absolute_url(),
+            accept_url=action.get_absolute_url(),
+            event_text=self.event.render_as_text(),
+        )
+        self.assertBody(mail, expected_body)
 
     def test_accepted_mail(self):
-        # TODO
+        expected_recipient = self.trainer
-        pass
+        editor = self.manager_w
+
+        self.event.workflow.update_status('submitted', self.trainer)
+        self.event.internal_note = u'Automatischer Software Test.'
+        self.event.planned_publication_date = datetime.date(2019, 3, 24)
+        ppd_string = u'Sonntag, 24. März 2019'
+        self.event.save()
+
+        self.app_settings.enable_email_on_status_update = True
+        self.event.workflow.update_status('accepted', editor)
+        self.assertEqual(len(django_mail.outbox), 3)
+
+        mail = django_mail.outbox[0]
+        self.assertSender(mail)
+        self.assertRecipients(mail, [expected_recipient])
+        self.assertSubject(mail, u'{}: Veranstaltung freigegeben'.format(self.event.number))
+
+        expected_body = EVENT_ACCEPTED_EMAIL_TEMPLATE.format(
+            recipient_first_name=expected_recipient.first_name,
+            editor_full_name=editor.get_full_name(),
+            base_url=self.email_base_url,
+            event_url=self.event.get_absolute_url(),
+            planned_publication_date=ppd_string,
+            event_text=self.event.render_as_text(),
+            internal_note=self.event.internal_note,
+        )
+        self.assertBody(mail, expected_body)
 
     def test_event_to_publish_web_mail(self):
-        # TODO
+        expected_recipient = self.publisher_web
-        pass
+        editor = self.manager_w
+
+        self.event.workflow.update_status('submitted', self.trainer)
+        self.event.internal_note = u'Automatischer Software Test.'
+        self.event.planned_publication_date = datetime.date(2019, 3, 24)
+        ppd_string = u'Sonntag, 24. März 2019'
+        self.event.save()
+
+        self.app_settings.enable_email_on_status_update = True
+        self.event.workflow.update_status('accepted', editor)
+        self.assertEqual(len(django_mail.outbox), 3)
+
+        mail = django_mail.outbox[1]
+        self.assertSender(mail)
+        self.assertRecipients(mail, [expected_recipient])
+        self.assertSubject(mail, u'{}: Veranstaltung veröffentlichen'.format(self.event.number))
+
+        action_parameters = '{},{},{}'.format(self.event.id, 'publishing_web', expected_recipient.id)
+        action = OneClickAction.objects.get(parameters=action_parameters)
+
+        expected_body = EVENT_TO_PUBLISH_WEB_EMAIL_TEMPLATE.format(
+            recipient_first_name=expected_recipient.first_name,
+            trainer_firstname=self.event.trainer_firstname,
+            trainer_familyname=self.event.trainer_familyname,
+            editor_full_name=editor.get_full_name(),
+            base_url=self.email_base_url,
+            event_url=self.event.get_absolute_url(),
+            confirm_publication_url=action.get_absolute_url(),
+            planned_publication_date=ppd_string,
+            internal_note=self.event.internal_note,
+            number=self.event.number,
+            title=self.event.title,
+            description=self.event.description,
+            planned_publication_date_short=self.event.planned_publication_date.strftime('%d.%m.%Y'),
+            first_day_short=self.event.first_day.strftime('%d.%m.%Y'),
+            day_after_short=(self.event.first_day + datetime.timedelta(1)).strftime('%d.%m.%Y'),
+            normalized_long_date=self.event.get_formated_date(format='normalized_long'),
+        )
+        self.assertBody(mail, expected_body)
 
     def test_event_to_publish_facebook_mail(self):
-        # TODO
+        expected_recipient = self.publisher_facebook
-        pass
+        editor = self.manager_super
+
+        self.event.workflow.update_status('submitted', self.trainer)
+
+        self.app_settings.enable_email_on_status_update = True
+        self.event.workflow.update_status('accepted', editor)
+        self.assertEqual(len(django_mail.outbox), 3)
+
+        mail = django_mail.outbox[2]
+        self.assertSender(mail)
+        self.assertRecipients(mail, [expected_recipient])
+        self.assertSubject(mail, u'{}: Veranstaltung veröffentlichen'.format(self.event.number))
+
+        action_parameters = '{},{},{}'.format(self.event.id, 'publishing_facebook', expected_recipient.id)
+        action = OneClickAction.objects.get(parameters=action_parameters)
+
+        expected_body = EVENT_TO_PUBLISH_FACEBOOK_EMAIL_TEMPLATE.format(
+            recipient_first_name=expected_recipient.first_name,
+            trainer_firstname=self.event.trainer_firstname,
+            trainer_familyname=self.event.trainer_familyname,
+            editor_full_name=editor.get_full_name(),
+            base_url=self.email_base_url,
+            event_url=self.event.get_absolute_url(),
+            confirm_publication_url=action.get_absolute_url(),
+            number=self.event.number,
+            title=self.event.title,
+            description=self.event.description,
+            first_day_short=self.event.first_day.strftime('%d.%m.%Y'),
+            day_after_short=(self.event.first_day + datetime.timedelta(1)).strftime('%d.%m.%Y'),
+            event_text=self.event.render_as_text(),
+        )
+        self.assertBody(mail, expected_body)

dav_events/tests/test_screenshots.py

@@ -1,8 +1,5 @@
 # -*- coding: utf-8 -*-
 import time
-from django.apps import apps
-from django.contrib.auth import get_user_model
-from django.contrib.auth.models import Group
 from django.test import tag
 from django.urls import reverse
 from django.utils.translation import ugettext
@@ -14,6 +11,8 @@ from selenium.webdriver.support.ui import Select
 from dav_base.tests.generic import ScreenshotTestCase
 from dav_auth.tests.generic import SeleniumAuthMixin
 
+from .generic import RoleMixin
+
 TEST_TRAINER_EMAIL = 'trainer@localhost'
 TEST_PASSWORD = u'me||ön 2'
 TEST_EVENT_DATA_S = {
@@ -109,27 +108,9 @@ TEST_EVENT_DATA_M = {
 
 
 @tag('screenshots', 'browser')
-class TestCase(SeleniumAuthMixin, ScreenshotTestCase):
+class TestCase(SeleniumAuthMixin, RoleMixin, ScreenshotTestCase):
     screenshot_prefix = 'dav_events-'
 
-    def create_user_for_role(self, role_name, first_name, last_name):
-        group = Group(name=role_name)
-        group.save()
-
-        user_model = get_user_model()
-        email = '{}@localhost'.format(role_name)
-        user_name = email
-        password = TEST_PASSWORD
-        user = user_model.objects.create_user(username=user_name, password=password, email=user_name,
-                                              first_name=first_name, last_name=last_name)
-        user.groups.add(group)
-
-        setting_name = 'groups_{}'.format(role_name)
-        app_config = apps.get_app_config('dav_events')
-        setattr(app_config.settings, setting_name, [role_name])
-
-        return user
-
     def create_event(self, event_data, auth=False, screenshots=True):
         data = event_data
         c = self.selenium
@@ -610,12 +591,19 @@ class TestCase(SeleniumAuthMixin, ScreenshotTestCase):
     def setUp(self):
         super(TestCase, self).setUp()
 
-        self.manager_super = self.create_user_for_role('manager_super', 'Manager Super', 'Tourenreferent')
+        password = TEST_PASSWORD
-        self.manager_w = self.create_user_for_role('manager_w', 'Manager W', 'BereichsleiterWandern')
+        self.manager_super = self.create_user_for_role('manager_super', password,
-        self.manager_s = self.create_user_for_role('manager_s', 'Manager S', 'BereichsleiterSki')
+                                                       'Manager Super', 'Tourenreferent')
-        self.publisher_print = self.create_user_for_role('publisher_print', 'Publisher Print', 'RedaktionPrint')
+        self.manager_w = self.create_user_for_role('manager_w', password,
-        self.publisher_web = self.create_user_for_role('publisher_web', 'Publisher Web', 'RedaktionWeb')
+                                                   'Manager W', 'BereichsleiterWandern')
-        self.publisher_facebook = self.create_user_for_role('publisher_facebook', 'Publisher Facebook', 'RedaktionFacebook')
+        self.manager_s = self.create_user_for_role('manager_s', password,
+                                                   'Manager S', 'BereichsleiterSki')
+        self.publisher_print = self.create_user_for_role('publisher_print', password,
+                                                         'Publisher Print', 'RedaktionPrint')
+        self.publisher_web = self.create_user_for_role('publisher_web', password,
+                                                       'Publisher Web', 'RedaktionWeb')
+        self.publisher_facebook = self.create_user_for_role('publisher_facebook', password,
+                                                            'Publisher Facebook', 'RedaktionFacebook')
 
     def test_screenshots(self):
         #self.quit_selenium = False