For Todos, on Save check for auto-deletion by .effort < 0, and on removal check if...

[plomtask] / tests / todos.py

diff --git a/tests/todos.py b/tests/todos.py
index a90f466cb99a201d353ea5434d5ea9c336dae0da..6ce5d6955be068355285c1532e12cd3ffb9e4204 100644 (file)
--- a/tests/todos.py
+++ b/tests/todos.py
@@ -1,6 +1,6 @@
 """Test Todos module."""
 from tests.utils import TestCaseWithDB, TestCaseWithServer
 """Test Todos module."""
 from tests.utils import TestCaseWithDB, TestCaseWithServer

-from plomtask.todos import Todo
+from plomtask.todos import Todo, TodoNode

 from plomtask.processes import Process
 from plomtask.conditions import Condition
 from plomtask.exceptions import (NotFoundException, BadFormatException,
 from plomtask.processes import Process
 from plomtask.conditions import Condition
 from plomtask.exceptions import (NotFoundException, BadFormatException,


@@ -9,6 +9,9 @@ from plomtask.exceptions import (NotFoundException, BadFormatException,
 
 class TestsWithDB(TestCaseWithDB):
     """Tests requiring DB, but not server setup."""
 
 class TestsWithDB(TestCaseWithDB):
     """Tests requiring DB, but not server setup."""

+    checked_class = Todo
+    default_init_kwargs = {'process': None, 'is_done': False,
+                           'date': '2024-01-01'}

 
     def setUp(self) -> None:
         super().setUp()
 
     def setUp(self) -> None:
         super().setUp()


@@ -20,20 +23,37 @@ class TestsWithDB(TestCaseWithDB):
         self.cond1.save(self.db_conn)
         self.cond2 = Condition(None)
         self.cond2.save(self.db_conn)
         self.cond1.save(self.db_conn)
         self.cond2 = Condition(None)
         self.cond2.save(self.db_conn)

+        self.default_init_kwargs['process'] = self.proc

 
 

-    def test_Todo_by_id(self) -> None:
-        """Test creation and findability of Todos."""
-        process_unsaved = Process(None)
-        todo = Todo(None, process_unsaved, False, self.date1)
+    def test_Todo_init(self) -> None:
+        """Test creation of Todo and what they default to."""
+        process = Process(None)

         with self.assertRaises(NotFoundException):
         with self.assertRaises(NotFoundException):

-            todo.save(self.db_conn)
-        process_unsaved.save(self.db_conn)
+            Todo(None, process, False, self.date1)
+        process.save(self.db_conn)
+        assert isinstance(self.cond1.id_, int)
+        assert isinstance(self.cond2.id_, int)
+        process.set_conditions(self.db_conn, [self.cond1.id_, self.cond2.id_])
+        process.set_enables(self.db_conn, [self.cond1.id_])
+        process.set_disables(self.db_conn, [self.cond2.id_])
+        todo_no_id = Todo(None, process, False, self.date1)
+        self.assertEqual(todo_no_id.conditions, [self.cond1, self.cond2])
+        self.assertEqual(todo_no_id.enables, [self.cond1])
+        self.assertEqual(todo_no_id.disables, [self.cond2])
+        todo_yes_id = Todo(5, process, False, self.date1)
+        self.assertEqual(todo_yes_id.conditions, [])
+        self.assertEqual(todo_yes_id.enables, [])
+        self.assertEqual(todo_yes_id.disables, [])
+
+    def test_Todo_by_id(self) -> None:
+        """Test findability of Todos."""
+        todo = Todo(1, self.proc, False, self.date1)

         todo.save(self.db_conn)
         self.assertEqual(Todo.by_id(self.db_conn, 1), todo)
         with self.assertRaises(NotFoundException):
         todo.save(self.db_conn)
         self.assertEqual(Todo.by_id(self.db_conn, 1), todo)
         with self.assertRaises(NotFoundException):

-            self.assertEqual(Todo.by_id(self.db_conn, 0), todo)
+            Todo.by_id(self.db_conn, 0)

         with self.assertRaises(NotFoundException):
         with self.assertRaises(NotFoundException):

-            self.assertEqual(Todo.by_id(self.db_conn, 2), todo)
+            Todo.by_id(self.db_conn, 2)

 
     def test_Todo_by_date(self) -> None:
         """Test findability of Todos by date."""
 
     def test_Todo_by_date(self) -> None:
         """Test findability of Todos by date."""


@@ -45,37 +65,14 @@ class TestsWithDB(TestCaseWithDB):
         self.assertEqual(Todo.by_date(self.db_conn, self.date2), [])
         self.assertEqual(Todo.by_date(self.db_conn, 'foo'), [])
 
         self.assertEqual(Todo.by_date(self.db_conn, self.date2), [])
         self.assertEqual(Todo.by_date(self.db_conn, 'foo'), [])
 

-    def test_Todo_from_process(self) -> None:
-        """Test spawning of Todo attributes from Process."""
-        assert isinstance(self.cond1.id_, int)
-        assert isinstance(self.cond2.id_, int)
-        self.proc.set_conditions(self.db_conn, [self.cond1.id_])
-        todo = Todo(None, self.proc, False, self.date1)
-        self.assertEqual(todo.conditions, [self.cond1])
-        todo.set_conditions(self.db_conn, [self.cond2.id_])
-        self.assertEqual(todo.conditions, [self.cond2])
-        self.assertEqual(self.proc.conditions, [self.cond1])
-        self.proc.set_fulfills(self.db_conn, [self.cond1.id_])
-        todo = Todo(None, self.proc, False, self.date1)
-        self.assertEqual(todo.fulfills, [self.cond1])
-        todo.set_fulfills(self.db_conn, [self.cond2.id_])
-        self.assertEqual(todo.fulfills, [self.cond2])
-        self.assertEqual(self.proc.fulfills, [self.cond1])
-        self.proc.set_undoes(self.db_conn, [self.cond1.id_])
-        todo = Todo(None, self.proc, False, self.date1)
-        self.assertEqual(todo.undoes, [self.cond1])
-        todo.set_undoes(self.db_conn, [self.cond2.id_])
-        self.assertEqual(todo.undoes, [self.cond2])
-        self.assertEqual(self.proc.undoes, [self.cond1])
-

     def test_Todo_on_conditions(self) -> None:
         """Test effect of Todos on Conditions."""
         assert isinstance(self.cond1.id_, int)
         assert isinstance(self.cond2.id_, int)
         todo = Todo(None, self.proc, False, self.date1)
         todo.save(self.db_conn)
     def test_Todo_on_conditions(self) -> None:
         """Test effect of Todos on Conditions."""
         assert isinstance(self.cond1.id_, int)
         assert isinstance(self.cond2.id_, int)
         todo = Todo(None, self.proc, False, self.date1)
         todo.save(self.db_conn)

-        todo.set_fulfills(self.db_conn, [self.cond1.id_])
-        todo.set_undoes(self.db_conn, [self.cond2.id_])
+        todo.set_enables(self.db_conn, [self.cond1.id_])
+        todo.set_disables(self.db_conn, [self.cond2.id_])

         todo.is_done = True
         self.assertEqual(self.cond1.is_active, True)
         self.assertEqual(self.cond2.is_active, False)
         todo.is_done = True
         self.assertEqual(self.cond1.is_active, True)
         self.assertEqual(self.cond2.is_active, False)


@@ -83,57 +80,25 @@ class TestsWithDB(TestCaseWithDB):
         self.assertEqual(self.cond1.is_active, True)
         self.assertEqual(self.cond2.is_active, False)
 
         self.assertEqual(self.cond1.is_active, True)
         self.assertEqual(self.cond2.is_active, False)
 

-    def test_Todo_enablers_disablers(self) -> None:
-        """Test Todo.enablers_for_at/disablers_for_at."""
-        assert isinstance(self.cond1.id_, int)
-        assert isinstance(self.cond2.id_, int)
-        todo1 = Todo(None, self.proc, False, self.date1)
-        todo1.save(self.db_conn)
-        todo1.set_fulfills(self.db_conn, [self.cond1.id_])
-        todo1.set_undoes(self.db_conn, [self.cond2.id_])
-        todo1.save(self.db_conn)
-        todo2 = Todo(None, self.proc, False, self.date1)
-        todo2.save(self.db_conn)
-        todo2.set_fulfills(self.db_conn, [self.cond2.id_])
-        todo2.save(self.db_conn)
-        todo3 = Todo(None, self.proc, False, self.date2)
-        todo3.save(self.db_conn)
-        todo3.set_fulfills(self.db_conn, [self.cond2.id_])
-        todo3.save(self.db_conn)
-        enablers = Todo.enablers_for_at(self.db_conn, self.cond1, self.date1)
-        self.assertEqual(enablers, [todo1])
-        enablers = Todo.enablers_for_at(self.db_conn, self.cond1, self.date2)
-        self.assertEqual(enablers, [])
-        disablers = Todo.disablers_for_at(self.db_conn, self.cond1, self.date1)
-        self.assertEqual(disablers, [])
-        disablers = Todo.disablers_for_at(self.db_conn, self.cond1, self.date2)
-        self.assertEqual(disablers, [])
-        enablers = Todo.enablers_for_at(self.db_conn, self.cond2, self.date1)
-        self.assertEqual(enablers, [todo2])
-        enablers = Todo.enablers_for_at(self.db_conn, self.cond2, self.date2)
-        self.assertEqual(enablers, [todo3])
-        disablers = Todo.disablers_for_at(self.db_conn, self.cond2, self.date1)
-        self.assertEqual(disablers, [todo1])
-        disablers = Todo.disablers_for_at(self.db_conn, self.cond2, self.date2)
-        self.assertEqual(disablers, [])
-

     def test_Todo_children(self) -> None:
         """Test Todo.children relations."""
         todo_1 = Todo(None, self.proc, False, self.date1)
         todo_2 = Todo(None, self.proc, False, self.date1)
     def test_Todo_children(self) -> None:
         """Test Todo.children relations."""
         todo_1 = Todo(None, self.proc, False, self.date1)
         todo_2 = Todo(None, self.proc, False, self.date1)

+        todo_2.save(self.db_conn)

         with self.assertRaises(HandledException):
             todo_1.add_child(todo_2)
         todo_1.save(self.db_conn)
         with self.assertRaises(HandledException):
             todo_1.add_child(todo_2)
         todo_1.save(self.db_conn)

+        todo_3 = Todo(None, self.proc, False, self.date1)

         with self.assertRaises(HandledException):
         with self.assertRaises(HandledException):

-            todo_1.add_child(todo_2)
-        todo_2.save(self.db_conn)
-        todo_1.add_child(todo_2)
+            todo_1.add_child(todo_3)
+        todo_3.save(self.db_conn)
+        todo_1.add_child(todo_3)

         todo_1.save(self.db_conn)
         assert isinstance(todo_1.id_, int)
         todo_retrieved = Todo.by_id(self.db_conn, todo_1.id_)
         todo_1.save(self.db_conn)
         assert isinstance(todo_1.id_, int)
         todo_retrieved = Todo.by_id(self.db_conn, todo_1.id_)

-        self.assertEqual(todo_retrieved.children, [todo_2])
+        self.assertEqual(todo_retrieved.children, [todo_3])

         with self.assertRaises(BadFormatException):
         with self.assertRaises(BadFormatException):

-            todo_2.add_child(todo_1)
+            todo_3.add_child(todo_1)

 
     def test_Todo_conditioning(self) -> None:
         """Test Todo.doability conditions."""
 
     def test_Todo_conditioning(self) -> None:
         """Test Todo.doability conditions."""


@@ -154,16 +119,125 @@ class TestsWithDB(TestCaseWithDB):
         self.cond1.is_active = True
         todo_2.is_done = True
 
         self.cond1.is_active = True
         todo_2.is_done = True
 

+    def test_Todo_step_tree(self) -> None:
+        """Test self-configuration of TodoStepsNode tree for Day view."""
+        todo_1 = Todo(None, self.proc, False, self.date1)
+        todo_1.save(self.db_conn)
+        assert isinstance(todo_1.id_, int)
+        # test minimum
+        node_0 = TodoNode(todo_1, False, [])
+        self.assertEqual(todo_1.get_step_tree(set()), node_0)
+        # test non_emtpy seen_todo does something
+        node_0.seen = True
+        self.assertEqual(todo_1.get_step_tree({todo_1.id_}), node_0)
+        # test child shows up
+        todo_2 = Todo(None, self.proc, False, self.date1)
+        todo_2.save(self.db_conn)
+        assert isinstance(todo_2.id_, int)
+        todo_1.add_child(todo_2)
+        node_2 = TodoNode(todo_2, False, [])
+        node_0.children = [node_2]
+        node_0.seen = False
+        self.assertEqual(todo_1.get_step_tree(set()), node_0)
+        # test child shows up with child
+        todo_3 = Todo(None, self.proc, False, self.date1)
+        todo_3.save(self.db_conn)
+        assert isinstance(todo_3.id_, int)
+        todo_2.add_child(todo_3)
+        node_3 = TodoNode(todo_3, False, [])
+        node_2.children = [node_3]
+        self.assertEqual(todo_1.get_step_tree(set()), node_0)
+        # test same todo can be child-ed multiple times at different locations
+        todo_1.add_child(todo_3)
+        node_4 = TodoNode(todo_3, True, [])
+        node_0.children += [node_4]
+        self.assertEqual(todo_1.get_step_tree(set()), node_0)
+
+    def test_Todo_unsatisfied_steps(self) -> None:
+        """Test options of satisfying unfulfilled Process.explicit_steps."""
+        assert isinstance(self.proc.id_, int)
+        todo_1 = Todo(None, self.proc, False, self.date1)
+        todo_1.save(self.db_conn)
+        proc2 = Process(None)
+        proc2.save(self.db_conn)
+        assert isinstance(proc2.id_, int)
+        proc3 = Process(None)
+        proc3.save(self.db_conn)
+        assert isinstance(proc3.id_, int)
+        proc4 = Process(None)
+        proc4.save(self.db_conn)
+        assert isinstance(proc4.id_, int)
+        proc3.set_steps(self.db_conn, [(None, proc4.id_, None)])
+        proc2.set_steps(self.db_conn, [(None, self.proc.id_, None),
+                                       (None, self.proc.id_, None),
+                                       (None, proc3.id_, None)])
+        todo_2 = Todo(None, proc2, False, self.date1)
+        todo_2.save(self.db_conn)
+        # test empty adoption does nothing
+        todo_2.adopt_from([])
+        self.assertEqual(todo_2.children, [])
+        # test basic adoption
+        todo_2.adopt_from([todo_1])
+        self.assertEqual(todo_2.children, [todo_1])
+        self.assertEqual(todo_1.parents, [todo_2])
+        # test making missing children
+        todo_2.make_missing_children(self.db_conn)
+        todo_3 = Todo.by_id(self.db_conn, 3)
+        todo_4 = Todo.by_id(self.db_conn, 4)
+        self.assertEqual(todo_2.children, [todo_1, todo_3, todo_4])
+        self.assertEqual(todo_3.process, self.proc)
+        self.assertEqual(todo_3.parents, [todo_2])
+        self.assertEqual(todo_3.children, [])
+        self.assertEqual(todo_4.process, proc3)
+        self.assertEqual(todo_4.parents, [todo_2])
+        # test .make_missing_children doesn't further than top-level
+        self.assertEqual(todo_4.children, [])
+        # test .make_missing_children lower down the tree
+        todo_4.make_missing_children(self.db_conn)
+        todo_5 = Todo.by_id(self.db_conn, 5)
+        self.assertEqual(todo_5.process, proc4)
+        self.assertEqual(todo_4.children, [todo_5])
+        self.assertEqual(todo_5.parents, [todo_4])
+

     def test_Todo_singularity(self) -> None:
         """Test pointers made for single object keep pointing to it."""
     def test_Todo_singularity(self) -> None:
         """Test pointers made for single object keep pointing to it."""

-        todo = Todo(None, self.proc, False, self.date1)
-        todo.save(self.db_conn)
-        retrieved_todo = Todo.by_id(self.db_conn, 1)
-        todo.is_done = True
-        self.assertEqual(retrieved_todo.is_done, True)
-        retrieved_todo = Todo.by_date(self.db_conn, self.date1)[0]
-        retrieved_todo.is_done = False
-        self.assertEqual(todo.is_done, False)
+        self.check_singularity('is_done', True, self.proc, False, self.date1)
+
+    def test_Todo_remove(self) -> None:
+        """Test removal."""
+        todo_1 = Todo(None, self.proc, False, self.date1)
+        todo_1.save(self.db_conn)
+        todo_0 = Todo(None, self.proc, False, self.date1)
+        todo_0.save(self.db_conn)
+        todo_0.add_child(todo_1)
+        todo_2 = Todo(None, self.proc, False, self.date1)
+        todo_2.save(self.db_conn)
+        todo_1.add_child(todo_2)
+        todo_1.remove(self.db_conn)
+        with self.assertRaises(NotFoundException):
+            Todo.by_id(self.db_conn, todo_1.id_)
+        self.assertEqual(todo_0.children, [])
+        self.assertEqual(todo_2.parents, [])
+        todo_2.comment = 'foo'
+        with self.assertRaises(HandledException):
+            todo_2.remove(self.db_conn)
+        todo_2.comment = ''
+        todo_2.effort = 5
+        with self.assertRaises(HandledException):
+            todo_2.remove(self.db_conn)
+
+    def test_Todo_autoremoval(self) -> None:
+        """"Test automatic removal for Todo.effort < 0."""
+        todo_1 = Todo(None, self.proc, False, self.date1)
+        todo_1.save(self.db_conn)
+        todo_1.comment = 'foo'
+        todo_1.effort = -0.1
+        todo_1.save(self.db_conn)
+        Todo.by_id(self.db_conn, todo_1.id_)
+        todo_1.comment = ''
+        todo_1.save(self.db_conn)
+        with self.assertRaises(NotFoundException):
+            Todo.by_id(self.db_conn, todo_1.id_)

 
 
 class TestsWithServer(TestCaseWithServer):
 
 
 class TestsWithServer(TestCaseWithServer):


@@ -171,16 +245,15 @@ class TestsWithServer(TestCaseWithServer):
 
     def test_do_POST_day(self) -> None:
         """Test Todo posting of POST /day."""
 
     def test_do_POST_day(self) -> None:
         """Test Todo posting of POST /day."""

-        form_data = {'title': '', 'description': '', 'effort': 1}
-        self.check_post(form_data, '/process?id=', 302, '/')
-        self.check_post(form_data, '/process?id=', 302, '/')
+        self.post_process()
+        self.post_process(2)

         proc = Process.by_id(self.db_conn, 1)
         proc2 = Process.by_id(self.db_conn, 2)
         proc = Process.by_id(self.db_conn, 1)
         proc2 = Process.by_id(self.db_conn, 2)

-        form_data = {'comment': ''}
-        self.check_post(form_data, '/day?date=2024-01-01', 302, '/')
+        form_data = {'day_comment': ''}
+        self.check_post(form_data, '/day?date=2024-01-01', 302)

         self.assertEqual(Todo.by_date(self.db_conn, '2024-01-01'), [])
         form_data['new_todo'] = str(proc.id_)
         self.assertEqual(Todo.by_date(self.db_conn, '2024-01-01'), [])
         form_data['new_todo'] = str(proc.id_)

-        self.check_post(form_data, '/day?date=2024-01-01', 302, '/')
+        self.check_post(form_data, '/day?date=2024-01-01', 302)

         todos = Todo.by_date(self.db_conn, '2024-01-01')
         self.assertEqual(1, len(todos))
         todo1 = todos[0]
         todos = Todo.by_date(self.db_conn, '2024-01-01')
         self.assertEqual(1, len(todos))
         todo1 = todos[0]


@@ -188,7 +261,7 @@ class TestsWithServer(TestCaseWithServer):
         self.assertEqual(todo1.process.id_, proc.id_)
         self.assertEqual(todo1.is_done, False)
         form_data['new_todo'] = str(proc2.id_)
         self.assertEqual(todo1.process.id_, proc.id_)
         self.assertEqual(todo1.is_done, False)
         form_data['new_todo'] = str(proc2.id_)

-        self.check_post(form_data, '/day?date=2024-01-01', 302, '/')
+        self.check_post(form_data, '/day?date=2024-01-01', 302)

         todos = Todo.by_date(self.db_conn, '2024-01-01')
         todo1 = todos[1]
         self.assertEqual(todo1.id_, 2)
         todos = Todo.by_date(self.db_conn, '2024-01-01')
         todo1 = todos[1]
         self.assertEqual(todo1.id_, 2)


@@ -197,58 +270,125 @@ class TestsWithServer(TestCaseWithServer):
 
     def test_do_POST_todo(self) -> None:
         """Test POST /todo."""
 
     def test_do_POST_todo(self) -> None:
         """Test POST /todo."""

-        def post_and_reload(form_data: dict[str, object],
-                            status: int = 302) -> Todo:
-            self.check_post(form_data, '/todo?id=1', status, '/')
-            self.db_conn.cached_todos = {}
+        def post_and_reload(form_data: dict[str, object], status: int = 302,
+                            redir_url: str = '/todo?id=1') -> Todo:
+            self.check_post(form_data, '/todo?id=1', status, redir_url)

             return Todo.by_date(self.db_conn, '2024-01-01')[0]
             return Todo.by_date(self.db_conn, '2024-01-01')[0]

-        form_data = {'title': '', 'description': '', 'effort': 1}
-        self.check_post(form_data, '/process', 302, '/')
-        form_data = {'comment': '', 'new_todo': 1}
-        self.check_post(form_data, '/day?date=2024-01-01', 302, '/')
-        form_data = {}
-        self.check_post(form_data, '/todo=', 404)
-        self.check_post(form_data, '/todo?id=', 404)
-        self.check_post(form_data, '/todo?id=FOO', 400)
-        self.check_post(form_data, '/todo?id=0', 404)
-        todo1 = post_and_reload(form_data)
+        # test minimum
+        self.post_process()
+        self.check_post({'day_comment': '', 'new_todo': 1},
+                        '/day?date=2024-01-01', 302)
+        # test posting to bad URLs
+        self.check_post({}, '/todo=', 404)
+        self.check_post({}, '/todo?id=', 400)
+        self.check_post({}, '/todo?id=FOO', 400)
+        self.check_post({}, '/todo?id=0', 404)
+        # test posting naked entity
+        todo1 = post_and_reload({})

         self.assertEqual(todo1.children, [])
         self.assertEqual(todo1.parents, [])
         self.assertEqual(todo1.is_done, False)
         self.assertEqual(todo1.children, [])
         self.assertEqual(todo1.parents, [])
         self.assertEqual(todo1.is_done, False)

-        form_data = {'done': ''}
-        todo1 = post_and_reload(form_data)
+        # test posting doneness
+        todo1 = post_and_reload({'done': ''})

         self.assertEqual(todo1.is_done, True)
         self.assertEqual(todo1.is_done, True)

-        form_data = {}
-        todo1 = post_and_reload(form_data)
+        # test implicitly posting non-doneness
+        todo1 = post_and_reload({})

         self.assertEqual(todo1.is_done, False)
         self.assertEqual(todo1.is_done, False)

-        form_data = {'adopt': 'foo'}
-        self.check_post(form_data, '/todo?id=1', 400)
-        form_data = {'adopt': 1}
-        self.check_post(form_data, '/todo?id=1', 400)
-        form_data = {'adopt': 2}
-        self.check_post(form_data, '/todo?id=1', 404)
-        form_data = {'comment': '', 'new_todo': 1}
-        self.check_post(form_data, '/day?date=2024-01-01', 302, '/')
-        form_data = {'adopt': 2}
-        todo1 = post_and_reload(form_data)
+        # test malformed adoptions
+        self.check_post({'adopt': 'foo'}, '/todo?id=1', 400)
+        self.check_post({'adopt': 1}, '/todo?id=1', 400)
+        self.check_post({'adopt': 2}, '/todo?id=1', 404)
+        # test posting second todo of same process
+        self.check_post({'day_comment': '', 'new_todo': 1},
+                        '/day?date=2024-01-01', 302)
+        # test todo 1 adopting todo 2
+        todo1 = post_and_reload({'adopt': 2})

         todo2 = Todo.by_date(self.db_conn, '2024-01-01')[1]
         self.assertEqual(todo1.children, [todo2])
         self.assertEqual(todo1.parents, [])
         self.assertEqual(todo2.children, [])
         self.assertEqual(todo2.parents, [todo1])
         todo2 = Todo.by_date(self.db_conn, '2024-01-01')[1]
         self.assertEqual(todo1.children, [todo2])
         self.assertEqual(todo1.parents, [])
         self.assertEqual(todo2.children, [])
         self.assertEqual(todo2.parents, [todo1])

-        self.check_post(form_data, '/todo?id=1', 400, '/')
-        form_data = {'done': ''}
-        todo1 = post_and_reload(form_data, 400)
+        # test todo1 cannot be set done with todo2 not done yet
+        todo1 = post_and_reload({'done': '', 'adopt': 2}, 400)

         self.assertEqual(todo1.is_done, False)
         self.assertEqual(todo1.is_done, False)

+        # test todo1 un-adopting todo 2 by just not sending an adopt
+        todo1 = post_and_reload({}, 302)
+        todo2 = Todo.by_date(self.db_conn, '2024-01-01')[1]
+        self.assertEqual(todo1.children, [])
+        self.assertEqual(todo1.parents, [])
+        self.assertEqual(todo2.children, [])
+        self.assertEqual(todo2.parents, [])
+        # test todo1 deletion
+        todo1 = post_and_reload({'delete': ''}, 302, '/')
+
+    def test_do_POST_day_todo_adoption(self) -> None:
+        """Test Todos posted to Day view may adopt existing Todos."""
+        form_data = self.post_process()
+        form_data = self.post_process(2, form_data | {'new_top_step': 1})
+        form_data = {'day_comment': '', 'new_todo': 1}
+        self.check_post(form_data, '/day?date=2024-01-01', 302)
+        form_data['new_todo'] = 2
+        self.check_post(form_data, '/day?date=2024-01-01', 302)
+        todo1 = Todo.by_date(self.db_conn, '2024-01-01')[0]
+        todo2 = Todo.by_date(self.db_conn, '2024-01-01')[1]
+        self.assertEqual(todo1.children, [])
+        self.assertEqual(todo1.parents, [todo2])
+        self.assertEqual(todo2.children, [todo1])
+        self.assertEqual(todo2.parents, [])
+
+    def test_do_POST_day_todo_multiple(self) -> None:
+        """Test multiple Todos can be posted to Day view."""
+        form_data = self.post_process()
+        form_data = self.post_process(2)
+        form_data = {'day_comment': '', 'new_todo': [1, 2]}
+        self.check_post(form_data, '/day?date=2024-01-01', 302)
+        todo1 = Todo.by_date(self.db_conn, '2024-01-01')[0]
+        todo2 = Todo.by_date(self.db_conn, '2024-01-01')[1]
+        self.assertEqual(todo1.process.id_, 1)
+        self.assertEqual(todo2.process.id_, 2)
+
+    def test_do_POST_day_todo_multiple_inner_adoption(self) -> None:
+        """Test multiple Todos can be posted to Day view w. inner adoption."""
+        form_data = self.post_process()
+        form_data = self.post_process(2, form_data | {'new_top_step': 1})
+        form_data = {'day_comment': '', 'new_todo': [1, 2]}
+        self.check_post(form_data, '/day?date=2024-01-01', 302)
+        todo1 = Todo.by_date(self.db_conn, '2024-01-01')[0]
+        todo2 = Todo.by_date(self.db_conn, '2024-01-01')[1]
+        self.assertEqual(todo1.children, [])
+        self.assertEqual(todo1.parents, [todo2])
+        self.assertEqual(todo2.children, [todo1])
+        self.assertEqual(todo2.parents, [])
+        # check process ID order does not affect end result
+        form_data = {'day_comment': '', 'new_todo': [2, 1]}
+        self.check_post(form_data, '/day?date=2024-01-02', 302)
+        todo1 = Todo.by_date(self.db_conn, '2024-01-02')[1]
+        todo2 = Todo.by_date(self.db_conn, '2024-01-02')[0]
+        self.assertEqual(todo1.children, [])
+        self.assertEqual(todo1.parents, [todo2])
+        self.assertEqual(todo2.children, [todo1])
+        self.assertEqual(todo2.parents, [])
+
+    def test_do_POST_day_todo_doneness(self) -> None:
+        """Test Todo doneness can be posted to Day view."""
+        form_data = self.post_process()
+        form_data = {'day_comment': '', 'new_todo': [1]}
+        self.check_post(form_data, '/day?date=2024-01-01', 302)
+        todo = Todo.by_date(self.db_conn, '2024-01-01')[0]
+        form_data = {'day_comment': '', 'todo_id': [1]}
+        self.check_post(form_data, '/day?date=2024-01-01', 302)
+        self.assertEqual(todo.is_done, False)
+        form_data = {'day_comment': '', 'todo_id': [1], 'done': [1]}
+        self.check_post(form_data, '/day?date=2024-01-01', 302)
+        self.assertEqual(todo.is_done, True)

 
     def test_do_GET_todo(self) -> None:
         """Test GET /todo response codes."""
 
     def test_do_GET_todo(self) -> None:
         """Test GET /todo response codes."""

-        form_data = {'title': '', 'description': '', 'effort': 1}
-        self.check_post(form_data, '/process?id=', 302, '/')
-        form_data = {'comment': '', 'new_todo': 1}
-        self.check_post(form_data, '/day?date=2024-01-01', 302, '/')
-        self.check_get('/todo', 404)
-        self.check_get('/todo?id=', 404)
+        self.post_process()
+        form_data = {'day_comment': '', 'new_todo': 1}
+        self.check_post(form_data, '/day?date=2024-01-01', 302)
+        self.check_get('/todo', 400)
+        self.check_get('/todo?id=', 400)

         self.check_get('/todo?id=foo', 400)
         self.check_get('/todo?id=0', 404)
         self.check_get('/todo?id=1', 200)
         self.check_get('/todo?id=foo', 400)
         self.check_get('/todo?id=0', 404)
         self.check_get('/todo?id=1', 200)