Refactor tests

dokumentaatio/tyoaikakirjanpito.md

@@ -25,5 +25,5 @@
 |5.5.|6 tuntia|Säädetty käyttöliittymää, lisätty periodien määrä ympäristömuuttujaksi, lisätty alustava tiedoston käsittelijä|
 |6.5.|7 tuntia|Refaktoroitu luokkia, lajiteltu uudestaan|
 |7.5.|7 tuntia|Toteutettu kurssien vienti ja tuonti, hienosäädetty käyttöliittymää, päivitetty dokumentaatiota|
-|11.5.|1 tunti|Täydennetty ja refaktoroitu testejä|
-|Yht.|78 tuntia 0 min||
+|11.5.|1 tunti 30 min|Täydennetty ja refaktoroitu testejä|
+|Yht.|78 tuntia 30 min||

src/tests/services/test_planner_service.py

@@ -3,6 +3,7 @@
 
 from services.planner_service import *
 from services.scheduler_service import *
+from tests.services.test_scheduler_service import TestSchedulerService
 
 
 class FakeCourseRepository:
@@ -52,20 +53,6 @@ def setUp(self) -> None:
 
         self.data_directory = os.path.join(dirname, "..", "data")
 
-    def validate_schedule(self, schedule: list[list[Course]]) -> bool:
-        seen = set()
-
-        for period in schedule:
-            seen = seen.union(map(lambda x: x.id, period))
-
-            for course in period:
-                if not course.requirements.issubset(seen):
-                    return False
-
-                seen.add(course.id)
-
-        return True
-
     def test_setting_negative_starting_year_raises_error(self):
         with self.assertRaises(ValueError):
             self.planner_service.starting_year = -1
@@ -152,26 +139,6 @@ def test_delete_all_courses(self):
 
         self.assertEqual(self.planner_service.get_all_courses(), [])
 
-    def test_get_schedule(self):
-        course_ohpe = Course("Ohpe", 5, {1, 3}, course_id=1)
-        course_ohja = Course("Ohja", 5, {2, 4}, {1}, course_id=2)
-        course_jym = Course("Jym", 5, {1}, course_id=3)
-        course_tito = Course("Tito", 5, {2, 3}, {1}, course_id=4)
-        course_tira = Course("Tira", 10, {3}, {3, 4}, course_id=5)
-        course_tilpe = Course("Tilpe", 5, {4}, {4, 5}, course_id=6)
-
-        self.planner_service.create_course(course_ohpe)
-        self.planner_service.create_course(course_ohja)
-        self.planner_service.create_course(course_jym)
-        self.planner_service.create_course(course_tito)
-        self.planner_service.create_course(course_tira)
-        self.planner_service.create_course(course_tilpe)
-
-        self.planner_service.initialize(0, 1, 15)
-        schedule = self.planner_service.get_schedule()
-
-        self.assertTrue(self.validate_schedule(schedule))
-
     def test_initialize(self):
         scheduler = SchedulerService([])
         planner = PlannerService(scheduler, FakeCourseRepository())
@@ -217,11 +184,11 @@ def test_export_courses(self):
         self.assertIn(self.course_ohpe, courses)
         self.assertIn(self.course_ohja, courses)
 
-    def test_import_courses_and_get_schedule(self):
+    def test_get_schedule(self):
         file = os.path.join(self.data_directory, "sample_realistic.json")
 
         self.planner_service.import_courses(file)
         self.planner_service.initialize(2023, 1, 15)
         schedule = self.planner_service.get_schedule()
 
-        self.assertTrue(self.validate_schedule(schedule))
+        self.assertTrue(TestSchedulerService.check_schedule(schedule, 15))

src/tests/services/test_scheduler_service.py

@@ -5,9 +5,63 @@
 
 
 class TestSchedulerService(unittest.TestCase):
+    @classmethod
+    def check_course_timing(cls, schedule: list[list[Course]]) -> bool:
+        for i, period in enumerate(schedule):
+            period_number = i % 4 + 1
+
+            for course in period:
+                if period_number not in course.timing:
+                    return False
+
+        return True
+
+    @classmethod
+    def check_credits_below_limit(
+        cls, schedule: list[list[Course]], max_credits: int
+    ) -> bool:
+        for period in schedule:
+            total_credits = sum(map(lambda x: x.credits, period))
+
+            if total_credits > max_credits:
+                return False
+
+        return True
+
+    @classmethod
+    def check_topological_order(cls, schedule: list[list[Course]]) -> bool:
+        seen = set()
+
+        for period in schedule:
+            seen = seen.union(map(lambda x: x.id, period))
+
+            for course in period:
+                if not course.requirements.issubset(seen):
+                    return False
+
+                seen.add(course.id)
+
+        return True
+
+    @classmethod
+    def check_schedule(cls, schedule: list[list[Course]], max_credits: int) -> bool:
+        return (
+            cls.check_course_timing(schedule)
+            and cls.check_credits_below_limit(schedule, max_credits)
+            and cls.check_topological_order(schedule)
+        )
+
     def setUp(self) -> None:
         self.scheduler = SchedulerService([])
 
+    def test_max_credits(self):
+        courses = [Course("A", 5, {2}, course_id=10), Course("B", 3, {2}, course_id=10)]
+
+        scheduler = SchedulerService(courses)
+
+        scheduler.max_credits = 3
+        scheduler.max_credits = 2
+
     def test_negative_max_credits_raises_error(self):
         with self.assertRaises(MaxCreditError):
             self.scheduler.max_credits = -10
@@ -115,9 +169,9 @@ def test_get_schedule_period_credits_within_limit(self):
 
         self.scheduler.initialize([a, b, c, d, e], 1, 10)
 
-        for period in self.scheduler.get_schedule():
-            total_credits = sum(map(lambda x: x.credits, period))
-            self.assertLessEqual(total_credits, 10)
+        self.assertTrue(
+            self.check_credits_below_limit(self.scheduler.get_schedule(), 10)
+        )
 
     def test_get_schedule_courses_available_in_period(self):
         a = Course("A", 7, {1, 2}, course_id=1)
@@ -128,8 +182,19 @@ def test_get_schedule_courses_available_in_period(self):
 
         self.scheduler.initialize([a, b, c, d, e], 1, 10)
 
-        for i, period in enumerate(self.scheduler.get_schedule()):
-            period_number = i % 4 + 1
+        self.assertTrue(self.check_course_timing(self.scheduler.get_schedule()))
 
-            for course in period:
-                self.assertIn(period_number, course.timing)
+    def test_get_schedule_with_realistic_case(self):
+        courses = [
+            Course("Ohpe", 5, {1, 3}, course_id=1),
+            Course("Ohja", 5, {2, 4}, {1}, course_id=2),
+            Course("Jym", 5, {1}, course_id=3),
+            Course("Tito", 5, {2, 3}, {1}, course_id=4),
+            Course("Tira", 10, {3}, {3, 4}, course_id=5),
+            Course("Tilpe", 5, {4}, {4, 5}, course_id=6),
+        ]
+
+        self.scheduler.initialize(courses, 1, 15)
+        schedule = self.scheduler.get_schedule()
+
+        self.assertTrue(self.check_schedule(schedule, 15))