Add tests for rosters services

Author: martin056

styleguide_example/test_examples/services/__init__.py

@@ -0,0 +1,5 @@
+# flake8: noqa
+
+from .rosters import *
+from .school_courses import *
+from .students import *

styleguide_example/test_examples/services/rosters.py

@@ -0,0 +1,62 @@
+from datetime import date
+from typing import Optional
+
+from django.core.exceptions import ValidationError
+
+from styleguide_example.test_examples.models import Student, SchoolCourse, Roster
+
+
+ROSTER_VALIDATE_PERIOD_OUTSIDE_COURSE_PERIOD = 'Roster period cannot be outside {school_course} period'
+ROSTER_CREATE_DIFFERENT_SCHOOLS = 'Cannot roster {student} in {school_course}'
+
+
+def roster_validate_period(
+    *,
+    start_date: date,
+    end_date: date,
+    school_course: SchoolCourse
+) -> None:
+    start_date_validation = start_date >= school_course.start_date and\
+        start_date < school_course.end_date
+
+    end_date_validation = end_date <= school_course.end_date and\
+        end_date > school_course.start_date and\
+        end_date > start_date
+
+    if not start_date_validation or not end_date_validation:
+        raise ValidationError(ROSTER_VALIDATE_PERIOD_OUTSIDE_COURSE_PERIOD.format(
+            school_course=school_course
+        ))
+
+
+def roster_create(
+    *,
+    student: Student,
+    school_course: SchoolCourse,
+    start_date: Optional[date] = None,
+    end_date: Optional[date] = None
+) -> Roster:
+    if student.school != school_course.school:
+        raise ValidationError(
+            ROSTER_CREATE_DIFFERENT_SCHOOLS.format(student=student, school_course=school_course)
+        )
+
+    start_date = start_date or school_course.start_date
+    end_date = end_date or school_course.end_date
+
+    roster_validate_period(
+        start_date=start_date,
+        end_date=end_date,
+        school_course=school_course
+    )
+
+    roster = Roster(
+        student=student,
+        school_course=school_course,
+        start_date=start_date,
+        end_date=end_date
+    )
+    roster.full_clean()
+    roster.save()
+
+    return roster

styleguide_example/test_examples/services/school_courses.py

@@ -0,0 +1,50 @@
+from typing import Optional, Iterable
+from datetime import date
+
+from django.db import transaction
+from django.utils.text import slugify
+
+from styleguide_example.test_examples.models import (
+    SchoolCourse,
+    School,
+    Student,
+    Roster
+)
+
+
+@transaction.atomic
+def school_course_create(
+    *,
+    name: str,
+    slug: Optional[str] = None,
+    school: School,
+    students: Iterable[Student],
+    start_date: date,
+    end_date: date
+) -> SchoolCourse:
+    slug = slug or slugify(name)
+
+    school_course = SchoolCourse(
+        name=name,
+        slug=slug,
+        start_date=start_date,
+        end_date=end_date,
+        school=school
+    )
+    school_course.full_clean()
+    school_course.save()
+
+    rosters = []
+    for student in students:
+        roster = Roster(
+            student=student,
+            school_course=school_course,
+            start_date=start_date,
+            end_date=end_date
+        )
+        roster.full_clean()
+        rosters.append(roster)
+
+    Roster.objects.bulk_create(rosters, batch_size=50)
+
+    return school_course

styleguide_example/test_examples/services/students.py

@@ -0,0 +1,40 @@
+from datetime import date
+from typing import Optional
+
+from django.utils import timezone
+from django.db import transaction
+
+from styleguide_example.test_examples.models import Student, School
+from styleguide_example.test_examples.services.rosters import roster_create
+from styleguide_example.test_examples.selectors.schools import school_list_school_courses
+
+
+@transaction.atomic
+def student_create(
+    *,
+    email: str,
+    school: School,
+    start_date: Optional[date] = None
+) -> Student:
+    student = Student(
+        email=email,
+        school=school
+    )
+    student.full_clean()
+    student.save()
+
+    start_date = start_date or timezone.now()
+
+    school_courses = school_list_school_courses(
+        school=school,
+        start_date=start_date
+    ).select_related('school_course__school')
+
+    for school_course in school_courses:
+        roster_create(
+            student=student,
+            school_course=school_course,
+            start_date=None
+        )
+
+    return student

styleguide_example/test_examples/tests/services/__init__.py

@@ -0,0 +1,71 @@
+from unittest.mock import patch
+from datetime import timedelta
+
+from django.test import TestCase
+from django.core.exceptions import ValidationError
+from django.utils import timezone
+
+from styleguide_example.test_examples.tests.factories import (
+    StudentFactory,
+    SchoolCourseFactory
+)
+
+from styleguide_example.test_examples.models import Roster
+from styleguide_example.test_examples.services import (
+    roster_create,
+    ROSTER_CREATE_DIFFERENT_SCHOOLS
+)
+
+
+class RosterCreateTests(TestCase):
+    def test_service_raises_error_if_different_schools(self):
+        school_course = SchoolCourseFactory.build()
+        student = StudentFactory.build()
+
+        with self.assertRaisesMessage(
+            ValidationError,
+            ROSTER_CREATE_DIFFERENT_SCHOOLS.format(student=student, school_course=school_course)
+        ):
+            roster_create(student=student, school_course=school_course)
+
+        self.assertEqual(Roster.objects.count(), 0)
+
+    @patch('styleguide_example.test_examples.services.rosters.roster_validate_period')
+    def test_service_does_not_create_roster_if_period_is_not_valid(self, roster_validate_period_mock):
+        roster_validate_period_mock.side_effect = ValidationError('')
+
+        school_course = SchoolCourseFactory.build()
+        student = StudentFactory.build()
+
+        with self.assertRaises(ValidationError):
+            roster_create(student=student, school_course=school_course)
+
+        self.assertEqual(Roster.objects.count(), 0)
+
+    @patch('styleguide_example.test_examples.services.rosters.roster_validate_period')
+    def test_service_uses_school_course_period_for_default_period(self, roster_validate_period_mock):
+        school_course = SchoolCourseFactory()
+        student = StudentFactory(school=school_course.school)
+
+        roster = roster_create(student=student, school_course=school_course)
+
+        self.assertEqual(roster.start_date, school_course.start_date)
+        self.assertEqual(roster.end_date, school_course.end_date)
+
+    @patch('styleguide_example.test_examples.services.rosters.roster_validate_period')
+    def test_service_doesn_not_school_course_period_if_dates_are_passed(self, roster_validate_period_mock):
+        school_course = SchoolCourseFactory()
+        student = StudentFactory(school=school_course.school)
+
+        start_date = timezone.now().date()
+        end_date = school_course.end_date - timedelta(days=1)
+
+        roster = roster_create(
+            student=student,
+            school_course=school_course,
+            start_date=start_date,
+            end_date=end_date
+        )
+
+        self.assertEqual(roster.start_date, start_date)
+        self.assertEqual(roster.end_date, end_date)

styleguide_example/test_examples/tests/services/test_roster_create.py

@@ -0,0 +1,69 @@
+from datetime import timedelta
+
+from django.test import TestCase
+from django.core.exceptions import ValidationError
+
+from styleguide_example.test_examples.tests.factories import SchoolCourseFactory
+from styleguide_example.test_examples.services import (
+    roster_validate_period,
+    ROSTER_VALIDATE_PERIOD_OUTSIDE_COURSE_PERIOD
+)
+
+
+class RosterValidatePeriodTests(TestCase):
+    def test_service_does_not_raise_error_if_valid_period(self):
+        course = SchoolCourseFactory.build()
+
+        roster_period_equal_to_course_period = {
+            'start_date': course.start_date,
+            'end_date': course.end_date
+        }
+        roster_period_inside_course_period = {
+            'start_date': course.start_date + timedelta(days=1),
+            'end_date': course.end_date - timedelta(days=1)
+        }
+        roster_period_end_inside_course_period = {
+            'start_date': course.start_date,
+            'end_date': course.end_date - timedelta(days=1)
+        }
+        roster_period_start_inside_course_period = {
+            'start_date': course.start_date + timedelta(days=1),
+            'end_date': course.end_date
+        }
+
+        roster_validate_period(school_course=course, **roster_period_equal_to_course_period)
+        roster_validate_period(school_course=course, **roster_period_inside_course_period)
+        roster_validate_period(school_course=course, **roster_period_end_inside_course_period)
+        roster_validate_period(school_course=course, **roster_period_start_inside_course_period)
+
+    def test_services_raises_error_for_rosters_outside_period(self):
+        course = SchoolCourseFactory.build()
+
+        roster_period_end_before_course_start = {
+            'start_date': course.start_date - timedelta(days=10),
+            'end_date': course.start_date - timedelta(days=5)
+        }
+        roster_period_start_before_course_start = {
+            'start_date': course.start_date - timedelta(days=10),
+            'end_date': course.start_date + timedelta(days=1)
+        }
+        roster_period_start_after_course_end = {
+            'start_date': course.end_date + timedelta(days=5),
+            'end_date': course.end_date + timedelta(days=10)
+        }
+        roster_period_end_after_course_end = {
+            'start_date': course.end_date - timedelta(days=1),
+            'end_date': course.end_date + timedelta(days=10)
+        }
+
+        for roster_period in [
+            roster_period_end_before_course_start,
+            roster_period_start_before_course_start,
+            roster_period_start_after_course_end,
+            roster_period_end_after_course_end
+        ]:
+            with self.assertRaisesMessage(
+                ValidationError,
+                ROSTER_VALIDATE_PERIOD_OUTSIDE_COURSE_PERIOD.format(school_course=course)
+            ):
+                roster_validate_period(school_course=course, **roster_period)