writher/test_delete.py at main · benmaster82/writher · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
import os
import tempfile
import unittest
from unittest.mock import patch

NOTE_CONTENT = "Learn for software engineering"
NOTE_TITLE = "Study"
NOTE_KEYWORD = "software"
APPOINTMENT_TITLE = "Short test"
APPOINTMENT_DT = "2026-06-01T10:15"
APPOINTMENT_KEYWORD = "short"
REMINDER_MESSAGE = "Learn for test"
REMINDER_DT = "2026-05-26T18:00"
REMINDER_KEYWORD = "learn"
NON_EXISTENT = "nonexistent"


class TestDeleteDB(unittest.TestCase):
    def setUp(self):
        self._tmp = tempfile.mkdtemp()
        self._db = os.path.join(self._tmp, 'test.db')
        self._patch = patch('database.DB_PATH', self._db)
        self._patch.start()
        import database
        database.init()
        self.db = database

    def tearDown(self):
        self._patch.stop()

    def test_find_note_by_keyword_found(self):
        self.db.save_note(NOTE_CONTENT, title=NOTE_TITLE)
        result = self.db.find_note_by_keyword(NOTE_KEYWORD)
        self.assertIsNotNone(result)
        self.assertEqual(result['title'], NOTE_TITLE)
        self.assertEqual(result['content'], NOTE_CONTENT)

    def test_find_note_by_keyword_not_found(self):
        result = self.db.find_note_by_keyword(NON_EXISTENT)
        self.assertIsNone(result)

    def test_find_appointment_by_keyword_found(self):
        self.db.create_appointment(APPOINTMENT_TITLE, APPOINTMENT_DT)
        result = self.db.find_appointment_by_keyword(APPOINTMENT_KEYWORD)
        self.assertIsNotNone(result)
        self.assertEqual(result['title'], APPOINTMENT_TITLE)
        self.assertEqual(result['dt'], APPOINTMENT_DT)

    def test_find_appointment_by_keyword_not_found(self):
        result = self.db.find_appointment_by_keyword(NON_EXISTENT)
        self.assertIsNone(result)

    def test_find_reminder_by_keyword_found(self):
        self.db.set_reminder(REMINDER_MESSAGE, REMINDER_DT)
        result = self.db.find_reminder_by_keyword(REMINDER_KEYWORD)
        self.assertIsNotNone(result)
        self.assertEqual(result['message'], REMINDER_MESSAGE)
        self.assertEqual(result['remind_at'], REMINDER_DT)

    def test_find_reminder_by_keyword_not_found(self):
        result = self.db.find_reminder_by_keyword(NON_EXISTENT)
        self.assertIsNone(result)


class TestDeleteDispatch(unittest.TestCase):
    def setUp(self):
        self._tmp = tempfile.mkdtemp()
        self._db  = os.path.join(self._tmp, "test.db")
        self._patch   = patch("database.DB_PATH", self._db)
        self._patch.start()
        import database
        database.init()
        self.db = database
        from assistant import _dispatch
        self._dispatch = _dispatch

    def tearDown(self):
        self._patch.stop()

    def test_delete_note_returns_confirmation(self):
        self.db.save_note(NOTE_CONTENT, title=NOTE_TITLE)
        result = self._dispatch({"function": "delete_note",
                                 "arguments": {"keyword": NOTE_KEYWORD}})
        self.assertTrue(result.startswith("__confirm_delete__:note:"))

    def test_delete_note_ignores_confirmed_flag_and_still_requires_confirmation(self):
        self.db.save_note(NOTE_CONTENT, title=NOTE_TITLE)
        result = self._dispatch({"function": "delete_note",
                                 "arguments": {"keyword": NOTE_KEYWORD, "confirmed": True}})
        self.assertTrue(result.startswith("__confirm_delete__:note:"))

    def test_delete_appointment_returns_confirmation(self):
        self.db.create_appointment(APPOINTMENT_TITLE, APPOINTMENT_DT)
        result = self._dispatch({"function": "delete_appointment",
                                 "arguments": {"keyword": APPOINTMENT_KEYWORD}})
        self.assertTrue(result.startswith("__confirm_delete__:appointment:"))

    def test_delete_appointment_ignores_confirmed_flag_and_still_requires_confirmation(self):
        self.db.create_appointment(APPOINTMENT_TITLE, APPOINTMENT_DT)
        result = self._dispatch({"function": "delete_appointment",
                                 "arguments": {"keyword": APPOINTMENT_KEYWORD, "confirmed": True}})
        self.assertTrue(result.startswith("__confirm_delete__:appointment:"))

    def test_delete_reminder_returns_confirmation(self):
        self.db.set_reminder(REMINDER_MESSAGE, REMINDER_DT)
        result = self._dispatch({"function": "delete_reminder",
                                 "arguments": {"keyword": REMINDER_KEYWORD}})
        self.assertTrue(result.startswith("__confirm_delete__:reminder:"))

    def test_delete_reminder_ignores_confirmed_flag_and_still_requires_confirmation(self):
        self.db.set_reminder(REMINDER_MESSAGE, REMINDER_DT)
        result = self._dispatch({"function": "delete_reminder",
                                 "arguments": {"keyword": REMINDER_KEYWORD, "confirmed": True}})
        self.assertTrue(result.startswith("__confirm_delete__:reminder:"))


if __name__ == '__main__':
    unittest.main()