UPD: dav_registration: added tests.

dav_base/tests/generic.py

@@ -57,6 +57,13 @@ class EmailTestMixin(object):
     def assertSender(self, mail):
         self.assertEqual(mail.from_email, self.email_sender)
 
+    def assertReplyTo(self, mail, addresses):
+        self.assertEqual(len(mail.reply_to), len(addresses))
+        for expected_address in addresses:
+            if isinstance(expected_address, AbstractUser):
+                expected_address = u'"%s" <%s>' % (expected_address.get_full_name(), expected_address.email)
+            self.assertIn(expected_address, mail.reply_to)
+
     def assertRecipients(self, mail, recipients):
         self.assertEqual(len(mail.recipients()), len(recipients))
         for expected_recipient in recipients:

dav_events/tests/generic.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
+import datetime
 from django.apps import apps
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import Group
@@ -31,7 +32,21 @@ class EventMixin(object):
     def get_status_label(self, status_code):
         return EventStatus.objects.get(code=status_code).label
 
-    def create_event(self, data):
+    def create_event(self, data=None):
+        if data is None:
+            data = {
+                'title': 'Daytrip',
+                'description': 'Testevent',
+                'mode': 'joint',
+                'sport': 'W',
+                'level': 'beginner',
+                'first_day': datetime.date.today(),
+                'country': 'DE',
+                'trainer_firstname': 'Trainer',
+                'trainer_familyname': 'One',
+                'trainer_email': 'trainer@localhost',
+            }
+
         event = Event(**data)
         event.save()
         return event
@@ -40,6 +55,14 @@ class EventMixin(object):
         event.workflow.update_status('submitted', event.owner)
         return event
 
-    def accept_event(self, event, user):
+    def accept_event(self, event, user=None):
+        if user is None:
+            user = event.owner
         event.workflow.update_status('accepted', user)
         return event
+
+    def confirm_publication_event(self, event, user=None):
+        if user is None:
+            user = event.owner
+        event.workflow.update_status('published', user)
+        return event

dav_registration/tests/generic.py

@@ -0,0 +1,8 @@
+from ..models import Registration
+
+
+class RegistrationMixin(object):
+    def create_registration(self, data):
+        r = Registration(**data)
+        r.save()
+        return r

dav_registration/tests/test_apps.py

@@ -0,0 +1,12 @@
+from django.apps import apps
+from six import string_types
+
+from dav_base.tests.generic import AppSetting, AppsTestCase
+
+
+class TestCase(AppsTestCase):
+    app_config = apps.get_app_config('dav_registration')
+
+    settings = (
+        AppSetting('privacy_policy', string_types),
+    )

dav_registration/tests/test_emails.py

@@ -0,0 +1,172 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+from babel.dates import format_datetime
+from django.apps import apps
+from django.core import mail as django_mail
+from django.test import TestCase
+from django.utils.translation import get_language
+
+from dav_base.tests.generic import EmailTestMixin
+from dav_events.tests.generic import EventMixin
+
+from .generic import RegistrationMixin
+
+MAIL_SELF_TEMPLATE = """Hallo {participant_full_name},
+
+wir haben deine Anmeldung zur Veranstaltung
+  {event_number} - {event_title}
+an den/die Tourenleiter/in {trainer_full_name} weitergegeben.
+{trainer_first_name} wird sich bei dir melden und dir mitteilen,
+ob du teilnehmen kannst oder nicht.
+
+========================================================================
+Veranstaltung: {event_number} - {event_title}
+Datum: {event_formated_date}
+Tourenleitung: {trainer_full_name}
+Anmeldezeitpunkt: {registration_at}
+Referenz-Nr: {registration_id}
+
+Personendaten
+-------------
+{participant_full_name}
+
+ 
+Telefon: 
+E-Mail: {participant_email}
+DAV Mitgliedsnummer: 
+
+Notfall-Kontakt
+---------------
+-
+
+Erfahrung
+---------
+-
+
+Anmerkung
+---------
+-
+
+Erklärung zur Datenspeicherung
+------------------------------
+-
+Zeitpunkt der Datenlöschung: {purge_at}
+"""
+
+MAIL_TRAINER_TEMPLATE = """Hallo {trainer_first_name},
+
+Anmeldung zu deiner Veranstaltung
+{event_number} - {event_title}
+========================================================================
+Anmeldezeitpunkt: {registration_at}
+Referenz-Nr: {registration_id}
+
+Teilnehmer*in:
+{participant_full_name}
+, 
+
+{participant_email}
+
+
+Notfall-Kontakt:
+-
+
+Erfahrung:
+-
+
+Anmerkung:
+-
+
+------------------------------
+Erklärung zur Datenspeicherung
+------------------------------
+-
+Zeitpunkt der Datenlöschung: {purge_at}
+"""
+
+
+class EmailsTestCase(EmailTestMixin, EventMixin, RegistrationMixin, TestCase):
+    def setUp(self):
+        super(EmailsTestCase, self).setUp()
+
+        app_config = apps.get_app_config('dav_events')
+        app_config.settings.enable_email_on_status_update = False
+
+        self.event = self.create_event()
+        self.submit_event(self.event)
+        self.accept_event(self.event)
+        self.confirm_publication_event(self.event)
+
+    def test_email_self(self):
+        event = self.event
+        trainer = event.owner
+        registration_data = {
+            'event': event,
+            'personal_names': 'Participant',
+            'family_names': 'One',
+            'email_address': 'participant@localhost',
+        }
+        registration = self.create_registration(registration_data)
+
+        recipient = '"{full_name}" <{email}>'.format(full_name=registration.get_full_name(),
+                                                     email=registration.email_address)
+        reply_to = '"{full_name}" <{email}>'.format(full_name=trainer.get_full_name(),
+                                                    email=trainer.email)
+
+        mail = django_mail.outbox[1]
+        self.assertRecipients(mail, [recipient])
+        self.assertReplyTo(mail, [reply_to])
+        subject = '{number}: Deine Anmeldung'.format(number=event.get_number())
+        self.assertSubject(mail, subject)
+
+        locale = get_language()[0:2]
+        body = MAIL_SELF_TEMPLATE.format(
+            participant_full_name=registration.get_full_name(),
+            participant_email=registration.email_address,
+            event_number=event.get_number(),
+            event_title=event.title,
+            event_formated_date=event.get_formated_date(),
+            trainer_full_name=trainer.get_full_name(),
+            trainer_first_name=trainer.first_name,
+            registration_id=registration.id,
+            registration_at=format_datetime(registration.created_at, 'EEEE, dd. MMMM yyyy, HH:mm', locale=locale),
+            purge_at=format_datetime(registration.purge_at, 'EEEE, dd. MMMM yyyy', locale=locale),
+        )
+        self.assertBody(mail, body)
+
+    def test_email_trainer(self):
+        event = self.event
+        trainer = event.owner
+        registration_data = {
+            'event': event,
+            'personal_names': 'Participant',
+            'family_names': 'One',
+            'email_address': 'participant@localhost',
+        }
+        registration = self.create_registration(registration_data)
+
+        reply_to = '"{full_name}" <{email}>'.format(full_name=registration.get_full_name(),
+                                                    email=registration.email_address)
+        recipient = '"{full_name}" <{email}>'.format(full_name=trainer.get_full_name(),
+                                                     email=trainer.email)
+
+        mail = django_mail.outbox[0]
+        self.assertRecipients(mail, [recipient])
+        self.assertReplyTo(mail, [reply_to])
+        subject = '{number}: Anmeldung {full_name}'.format(number=event.get_number(),
+                                                           full_name=registration.get_full_name())
+        self.assertSubject(mail, subject)
+
+        locale = get_language()[0:2]
+        body = MAIL_TRAINER_TEMPLATE.format(
+            participant_full_name=registration.get_full_name(),
+            participant_email=registration.email_address,
+            event_number=event.get_number(),
+            event_title=event.title,
+            event_formated_date=event.get_formated_date(),
+            trainer_first_name=trainer.first_name,
+            registration_id=registration.id,
+            registration_at=format_datetime(registration.created_at, 'EEEE, dd. MMMM yyyy, HH:mm', locale=locale),
+            purge_at=format_datetime(registration.purge_at, 'EEEE, dd. MMMM yyyy', locale=locale),
+        )
+        self.assertBody(mail, body)

dav_registration/tests/test_utils.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+import datetime
+from django.test import TestCase
+
+from dav_events.tests.generic import EventMixin
+
+from ..models import Registration
+from ..utils import purge_registrations
+
+from .generic import RegistrationMixin
+
+
+class UtilsTestCase(RegistrationMixin, EventMixin, TestCase):
+    def test_purge(self):
+        today = datetime.date.today()
+        one_day = datetime.timedelta(1)
+        purge_after_days = 7
+        common_event_data = {
+            'title': 'Daytrip',
+            'description': 'Test',
+            'mode': 'joint',
+            'sport': 'W',
+            'level': 'beginner',
+            'country': 'DE',
+            'trainer_firstname': 'Trainer',
+            'trainer_familyname': 'One',
+            'trainer_email': 'trainer@localhost',
+        }
+
+        # We will create 4 events with different dates in the past
+        # 1. an event, that is happening right now -> we would still need the participants data
+        # 2. an event that will be finished few days ago, but the grace period were we have to keep
+        #    the participants data is not over right now -> do not purge registrations
+        # 3. an event that will be finished long enough, so that we can purge the registrations
+        # 4. event will be finished even longer ago
+        # To all events, we will create some registrations
+        event_data = (
+            (True, today),
+            (True, today - one_day * (purge_after_days - 1)),
+            (False, today - one_day * purge_after_days),
+            (False, today - one_day * (purge_after_days + 1)),
+        )
+        events = []
+        for registrations_still_needed, first_day in event_data:
+            data = common_event_data.copy()
+            data['first_day'] = first_day
+
+            event = self.create_event(data)
+            self.submit_event(event)
+            self.accept_event(event)
+
+            self.create_registration({'event': event})
+            self.create_registration({'event': event})
+            self.create_registration({'event': event})
+
+            events.append((event, registrations_still_needed))
+
+        # Now we purge obsolete registrations
+        purge_registrations()
+
+        # Now we test for all 4 events, if there are still registrations
+        for event, registrations_still_needed in events:
+            self.assertEqual(Registration.objects.filter(event=event).exists(), registrations_still_needed)

dav_registration/tests/test_validators.py

@@ -0,0 +1,46 @@
+from django.core.exceptions import ValidationError
+from django.test import SimpleTestCase
+
+from ..validators import DAVNumberValidator
+
+
+class TestCase(SimpleTestCase):
+    def test_dav_number_validator(self):
+        valid_data = (
+            '131/00/1',
+            '1',
+            '22',
+            '333',
+            '1/22/22',
+            '54321/54321/54321*54321',
+            '54321/54321/54321*54321*4321*4321',
+            '54321/54321/54321*54321*4321*4321*87654321',
+            '54321*54321',
+            '54321*54321*4321*4321',
+            '54321*54321*4321*4321*87654321',
+        )
+        invalid_data = (
+            '131/00/',
+            '1/1/1',
+            '1/1',
+            'abc',
+            '131/00/abc',
+            'abc/00/131',
+            '131/ab/131',
+        )
+
+        v = DAVNumberValidator
+
+        for val in valid_data:
+            try:
+                v(val)
+            except ValidationError as e:  # pragma: no cover
+                self.fail('%s: %s' % (val, e))
+
+        for val in invalid_data:
+            try:
+                v(val)
+            except ValidationError:
+                pass
+            else:  # pragma: no cover
+                self.fail('%s: no ValidationError was raised' % val)