From: Christian Heller Date: Thu, 2 May 2024 01:36:12 +0000 (+0200) Subject: Some tests refactoring. X-Git-Url: https://plomlompom.com/repos/%7B%7B%20web_path%20%7D%7D/static/%7B%7Bdb.prefix%7D%7D/template?a=commitdiff_plain;h=f8148a40996d64878431ac59d47650741e1d79c5;p=plomtask Some tests refactoring. --- diff --git a/tests/conditions.py b/tests/conditions.py index 51f7cc2..f825ba4 100644 --- a/tests/conditions.py +++ b/tests/conditions.py @@ -4,7 +4,7 @@ from tests.utils import TestCaseWithDB, TestCaseWithServer from plomtask.conditions import Condition from plomtask.processes import Process from plomtask.todos import Todo -from plomtask.exceptions import NotFoundException, HandledException +from plomtask.exceptions import HandledException class TestsSansDB(TestCase): @@ -20,36 +20,26 @@ class TestsSansDB(TestCase): class TestsWithDB(TestCaseWithDB): """Tests requiring DB, but not server setup.""" + checked_class = Condition + default_ids = (1, 2, 3) - def check_storage(self, content: list[Condition]) -> None: - """Test cache and DB equal content.""" - expected_cache = {} - for item in content: - expected_cache[item.id_] = item - self.assertEqual(Condition.get_cache(), expected_cache) - db_found: list[Condition] = [] - for item in content: - assert isinstance(item.id_, int) - for row in self.db_conn.row_where(Condition.table_name, 'id', - item.id_): - db_found += [Condition.from_table_row(self.db_conn, row)] - self.assertEqual(sorted(content), sorted(db_found)) - - def test_Condition_saving_and_caching(self) -> None: - """Test .save/.save_core.""" - c = Condition(None, False) + def versioned_condition(self) -> Condition: + """Create Condition with some VersionedAttribute values.""" + c = Condition(None) c.title.set('title1') c.title.set('title2') c.description.set('desc1') c.description.set('desc2') - # check object init itself doesn't store anything yet - self.check_storage([]) - # check saving stores in cache and DB + return c + + def test_Condition_saving_and_caching(self) -> None: + """Test .save/.save_core.""" + kwargs = {'id_': 1, 'is_active': False} + self.check_saving_and_caching(**kwargs) + # check .id_ set if None, and versioned attributes too + c = self.versioned_condition() c.save(self.db_conn) - self.check_storage([c]) - # check attributes set properly (and not unset by saving) - self.assertEqual(c.id_, 1) - self.assertEqual(c.is_active, False) + self.assertEqual(c.id_, 2) self.assertEqual(sorted(c.title.history.values()), ['title1', 'title2']) self.assertEqual(sorted(c.description.history.values()), @@ -57,18 +47,12 @@ class TestsWithDB(TestCaseWithDB): def test_Condition_from_table_row(self) -> None: """Test .from_table_row() properly reads in class from DB""" - c = Condition(1, True) - c.title.set('title1') - c.title.set('title2') - c.description.set('desc1') - c.description.set('desc2') + self.check_from_table_row(1) + c = self.versioned_condition() c.save(self.db_conn) assert isinstance(c.id_, int) for row in self.db_conn.row_where(Condition.table_name, 'id', c.id_): retrieved = Condition.from_table_row(self.db_conn, row) - assert isinstance(retrieved, Condition) - self.assertEqual(c, retrieved) - self.assertEqual({c.id_: c}, Condition.get_cache()) # pylint: disable=no-member self.assertEqual(sorted(retrieved.title.history.values()), ['title1', 'title2']) @@ -78,49 +62,20 @@ class TestsWithDB(TestCaseWithDB): def test_Condition_by_id(self) -> None: """Test .by_id(), including creation.""" - # check failure if not yet saved - c = Condition(3, False) - with self.assertRaises(NotFoundException): - Condition.by_id(self.db_conn, 3) - # check identity of saved and retrieved - c.save(self.db_conn) - self.assertEqual(c, Condition.by_id(self.db_conn, 3)) - # check create=True acts like normal instantiation (sans saving) - by_id_created = Condition.by_id(self.db_conn, 4, create=True) - self.assertEqual(Condition(4), by_id_created) - self.check_storage([c]) + self.check_by_id() def test_Condition_all(self) -> None: """Test .all().""" - c_1 = Condition(None, False) - # check pre-save .all() returns empty list - self.assertEqual(Condition.all(self.db_conn), []) - # check .save() fills .all() result - c_1.save(self.db_conn) - self.assertEqual(Condition.all(self.db_conn), [c_1]) - c_2 = Condition(None, True) - c_2.save(self.db_conn) - self.assertEqual(sorted(Condition.all(self.db_conn)), - sorted([c_1, c_2])) + self.check_all() def test_Condition_singularity(self) -> None: """Test pointers made for single object keep pointing to it.""" - c = Condition(None, False) - c.save(self.db_conn) - c.is_active = True - retrieved = Condition.by_id(self.db_conn, 1) - self.assertEqual(True, retrieved.is_active) + self.check_singularity('is_active', True) def test_Condition_remove(self) -> None: """Test .remove() effects on DB and cache.""" - # check only saved item can be removed - c = Condition(None, False) - with self.assertRaises(HandledException): - c.remove(self.db_conn) - c.save(self.db_conn) - c.remove(self.db_conn) - self.check_storage([]) - # check guard against deleting dependencies of other classes + self.check_remove() + c = Condition(None) proc = Process(None) todo = Todo(None, proc, False, '2024-01-01') for depender in (proc, todo): diff --git a/tests/days.py b/tests/days.py index ffc2ab2..c143f98 100644 --- a/tests/days.py +++ b/tests/days.py @@ -3,8 +3,7 @@ from unittest import TestCase from datetime import datetime from tests.utils import TestCaseWithDB, TestCaseWithServer from plomtask.days import Day, todays_date -from plomtask.exceptions import (BadFormatException, NotFoundException, - HandledException) +from plomtask.exceptions import BadFormatException class TestsSansDB(TestCase): @@ -40,79 +39,26 @@ class TestsSansDB(TestCase): class TestsWithDB(TestCaseWithDB): """Tests requiring DB, but not server setup.""" - - def check_storage(self, content: list[Day]) -> None: - """Test cache and DB equal content.""" - expected_cache = {} - for item in content: - expected_cache[item.id_] = item - self.assertEqual(Day.get_cache(), expected_cache) - db_found: list[Day] = [] - for item in content: - assert isinstance(item.id_, str) - for row in self.db_conn.row_where(Day.table_name, 'id', item.id_): - db_found += [Day.from_table_row(self.db_conn, row)] - self.assertEqual(sorted(content), sorted(db_found)) + checked_class = Day + default_ids = ('2024-01-01', '2024-01-02', '2024-01-03') def test_Day_saving_and_caching(self) -> None: """Test .save/.save_core.""" - date = '2024-01-01' - comment = 'comment' - day = Day(date, comment) - # check object init itself doesn't store anything yet - self.check_storage([]) - # check saving stores in cache and DB - day.save(self.db_conn) - self.check_storage([day]) - # check attributes set properly (and not unset by saving) - self.assertEqual(day.id_, date) - self.assertEqual(day.comment, comment) + kwargs = {'date': '2024-01-01', 'comment': 'foo'} + self.check_saving_and_caching(**kwargs) def test_Day_from_table_row(self) -> None: """Test .from_table_row() properly reads in class from DB""" - day = Day('2024-01-01') - day.save(self.db_conn) - assert isinstance(day.id_, str) - for row in self.db_conn.row_where(Day.table_name, 'id', day.id_): - retrieved = Day.from_table_row(self.db_conn, row) - self.assertEqual(day, retrieved) - self.assertEqual({day.id_: day}, Day.get_cache()) + self.check_from_table_row('2024-01-01') def test_Day_by_id(self) -> None: """Test .by_id().""" - date1 = '2024-01-01' - date2 = '2024-01-02' - # check failure if not yet saved - day1 = Day(date1) - with self.assertRaises(NotFoundException): - Day.by_id(self.db_conn, date1) - # check identity of saved and retrieved - day1.save(self.db_conn) - self.assertEqual(day1, Day.by_id(self.db_conn, date1)) - # check create=True acts like normal instantiation (sans saving) - by_id_created = Day.by_id(self.db_conn, date2, create=True) - self.assertEqual(Day(date2), by_id_created) - self.check_storage([day1]) + self.check_by_id() def test_Day_all(self) -> None: """Test Day.all(), especially in regards to date range filtering.""" - date1 = '2024-01-01' - date2 = '2024-01-02' - date3 = '2024-01-03' - day1 = Day(date1) - day2 = Day(date2) - day3 = Day(date3) - # check pre-save .all() returns empty list - self.assertEqual(Day.all(self.db_conn), []) - # check that all() shows all saved, but no unsaved items - day1.save(self.db_conn) - day3.save(self.db_conn) - self.assertEqual(Day.all(self.db_conn), - [day1, day3]) - day2.save(self.db_conn) - self.assertEqual(Day.all(self.db_conn), - [day1, day2, day3]) - # check empty date range values show everything + date1, date2, date3 = self.default_ids + day1, day2, day3 = self.check_all() self.assertEqual(Day.all(self.db_conn, ('', '')), [day1, day2, day3]) # check date range is a closed interval @@ -146,21 +92,11 @@ class TestsWithDB(TestCaseWithDB): def test_Day_remove(self) -> None: """Test .remove() effects on DB and cache.""" - date = '2024-01-01' - day = Day(date) - with self.assertRaises(HandledException): - day.remove(self.db_conn) - day.save(self.db_conn) - day.remove(self.db_conn) - self.check_storage([]) + self.check_remove() def test_Day_singularity(self) -> None: """Test pointers made for single object keep pointing to it.""" - day = Day('2024-01-01') - day.save(self.db_conn) - retrieved_day = Day.by_id(self.db_conn, '2024-01-01') - day.comment = 'foo' - self.assertEqual(retrieved_day.comment, 'foo') + self.check_singularity('comment', 'boo') class TestsWithServer(TestCaseWithServer): diff --git a/tests/utils.py b/tests/utils.py index b7d1269..a826c16 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -12,10 +12,13 @@ from plomtask.processes import Process, ProcessStep from plomtask.conditions import Condition from plomtask.days import Day from plomtask.todos import Todo +from plomtask.exceptions import NotFoundException, HandledException class TestCaseWithDB(TestCase): """Module tests not requiring DB setup.""" + checked_class: Any + default_ids: tuple[int | str, int | str, int | str] def setUp(self) -> None: Condition.empty_cache() @@ -32,6 +35,100 @@ class TestCaseWithDB(TestCase): self.db_conn.close() remove_file(self.db_file.path) + def check_storage(self, content: list[Any]) -> None: + """Test cache and DB equal content.""" + expected_cache = {} + for item in content: + expected_cache[item.id_] = item + self.assertEqual(self.checked_class.get_cache(), expected_cache) + db_found: list[Any] = [] + for item in content: + assert isinstance(item.id_, (str, int)) + for row in self.db_conn.row_where(self.checked_class.table_name, + 'id', item.id_): + db_found += [self.checked_class.from_table_row(self.db_conn, + row)] + self.assertEqual(sorted(content), sorted(db_found)) + + def check_saving_and_caching(self, **kwargs: Any) -> Any: + """Test instance.save in its core without relations.""" + obj = self.checked_class(**kwargs) # pylint: disable=not-callable + # check object init itself doesn't store anything yet + self.check_storage([]) + # check saving stores in cache and DB + obj.save(self.db_conn) + self.check_storage([obj]) + # check core attributes set properly (and not unset by saving) + for key, value in kwargs.items(): + self.assertEqual(getattr(obj, key), value) + + def check_by_id(self) -> None: + """Test .by_id(), including creation.""" + # check failure if not yet saved + id1, id2 = self.default_ids[0], self.default_ids[1] + obj = self.checked_class(id1) # pylint: disable=not-callable + with self.assertRaises(NotFoundException): + self.checked_class.by_id(self.db_conn, id1) + # check identity of saved and retrieved + obj.save(self.db_conn) + self.assertEqual(obj, self.checked_class.by_id(self.db_conn, id1)) + # check create=True acts like normal instantiation (sans saving) + by_id_created = self.checked_class.by_id(self.db_conn, id2, + create=True) + # pylint: disable=not-callable + self.assertEqual(self.checked_class(id2), by_id_created) + self.check_storage([obj]) + + def check_from_table_row(self, id_: int | str) -> None: + """Test .from_table_row() properly reads in class from DB""" + obj = self.checked_class(id_) # pylint: disable=not-callable + obj.save(self.db_conn) + assert isinstance(obj.id_, (str, int)) + for row in self.db_conn.row_where(self.checked_class.table_name, + 'id', obj.id_): + retrieved = self.checked_class.from_table_row(self.db_conn, row) + self.assertEqual(obj, retrieved) + self.assertEqual({obj.id_: obj}, self.checked_class.get_cache()) + + def check_all(self) -> tuple[Any, Any, Any]: + """Test .all().""" + # pylint: disable=not-callable + item1 = self.checked_class(self.default_ids[0]) + item2 = self.checked_class(self.default_ids[1]) + item3 = self.checked_class(self.default_ids[2]) + # check pre-save .all() returns empty list + self.assertEqual(self.checked_class.all(self.db_conn), []) + # check that all() shows all saved, but no unsaved items + item1.save(self.db_conn) + item3.save(self.db_conn) + self.assertEqual(sorted(self.checked_class.all(self.db_conn)), + sorted([item1, item3])) + item2.save(self.db_conn) + self.assertEqual(sorted(self.checked_class.all(self.db_conn)), + sorted([item1, item2, item3])) + return item1, item2, item3 + + def check_singularity(self, defaulting_field: str, + non_default_value: Any) -> None: + """Test pointers made for single object keep pointing to it.""" + id1 = self.default_ids[0] + obj = self.checked_class(id1) # pylint: disable=not-callable + obj.save(self.db_conn) + setattr(obj, defaulting_field, non_default_value) + retrieved = self.checked_class.by_id(self.db_conn, id1) + self.assertEqual(non_default_value, + getattr(retrieved, defaulting_field)) + + def check_remove(self) -> None: + """Test .remove() effects on DB and cache.""" + id_ = self.default_ids[0] + obj = self.checked_class(id_) # pylint: disable=not-callable + with self.assertRaises(HandledException): + obj.remove(self.db_conn) + obj.save(self.db_conn) + obj.remove(self.db_conn) + self.check_storage([]) + class TestCaseWithServer(TestCaseWithDB): """Module tests against our HTTP server/handler (and database)."""