question_cmd: added testclass for the 'question_cmd()' function

chatmastermind/message.py

@@ -222,36 +222,12 @@ class Message():
     ai_yaml_key: ClassVar[str] = 'ai'
     model_yaml_key: ClassVar[str] = 'model'
 
-    def __post_init__(self) -> None:
-        # convert some types that are often set wrong
-        if self.tags is not None and not isinstance(self.tags, set):
-            self.tags = set(self.tags)
-        if self.file_path is not None and not isinstance(self.file_path, pathlib.Path):
-            self.file_path = pathlib.Path(self.file_path)
-
     def __hash__(self) -> int:
         """
         The hash value is computed based on immutable members.
         """
         return hash((self.question, self.answer))
 
-    def equals(self, other: MessageInst, tags: bool = True, ai: bool = True,
-               model: bool = True, file_path: bool = True, verbose: bool = False) -> bool:
-        """
-        Compare this message with another one, including the metadata.
-        Return True if everything is identical, False otherwise.
-        """
-        equal: bool = ((not tags or (self.tags == other.tags))
-                       and (not ai or (self.ai == other.ai))  # noqa: W503
-                       and (not model or (self.model == other.model))  # noqa: W503
-                       and (not file_path or (self.file_path == other.file_path))  # noqa: W503
-                       and (self == other))  # noqa: W503
-        if not equal and verbose:
-            print("Messages not equal:")
-            print(self)
-            print(other)
-        return equal
-
     @classmethod
     def from_dict(cls: Type[MessageInst], data: dict[str, Any]) -> MessageInst:
         """
@@ -442,6 +418,9 @@ class Message():
             output.append(self.answer)
         return '\n'.join(output)
 
+    def __str__(self) -> str:
+        return self.to_str(True, True, False)
+
     def to_file(self, file_path: Optional[pathlib.Path]=None) -> None:  # noqa: 11
         """
         Write a Message to the given file. Type is determined based on the suffix.

tests/test_chat.py

@@ -10,18 +10,7 @@ from chatmastermind.message import Message, Question, Answer, Tag, MessageFilter
 from chatmastermind.chat import Chat, ChatDB, ChatError
 
 
-class TestChatBase(unittest.TestCase):
-    def assert_messages_equal(self, msg1: list[Message], msg2: list[Message]) -> None:
-        """
-        Compare messages using more than just Question and Answer.
-        """
-        self.assertEqual(len(msg1), len(msg2))
-        for m1, m2 in zip(msg1, msg2):
-            # exclude the file_path, compare only Q, A and metadata
-            self.assertTrue(m1.equals(m2, file_path=False, verbose=True))
-
-
-class TestChat(TestChatBase):
+class TestChat(unittest.TestCase):
     def setUp(self) -> None:
         self.chat = Chat([])
         self.message1 = Message(Question('Question 1'),
@@ -37,24 +26,24 @@ class TestChat(TestChatBase):
     def test_unique_id(self) -> None:
         # test with two identical messages
         self.chat.msg_add([self.message1, self.message1])
-        self.assert_messages_equal(self.chat.messages, [self.message1, self.message1])
+        self.assertSequenceEqual(self.chat.messages, [self.message1, self.message1])
         self.chat.msg_unique_id()
-        self.assert_messages_equal(self.chat.messages, [self.message1])
+        self.assertSequenceEqual(self.chat.messages, [self.message1])
         # test with two different messages
         self.chat.msg_add([self.message2])
         self.chat.msg_unique_id()
-        self.assert_messages_equal(self.chat.messages, [self.message1, self.message2])
+        self.assertSequenceEqual(self.chat.messages, [self.message1, self.message2])
 
     def test_unique_content(self) -> None:
         # test with two identical messages
         self.chat.msg_add([self.message1, self.message1])
-        self.assert_messages_equal(self.chat.messages, [self.message1, self.message1])
+        self.assertSequenceEqual(self.chat.messages, [self.message1, self.message1])
         self.chat.msg_unique_content()
-        self.assert_messages_equal(self.chat.messages, [self.message1])
+        self.assertSequenceEqual(self.chat.messages, [self.message1])
         # test with two different messages
         self.chat.msg_add([self.message2])
         self.chat.msg_unique_content()
-        self.assert_messages_equal(self.chat.messages, [self.message1, self.message2])
+        self.assertSequenceEqual(self.chat.messages, [self.message1, self.message2])
 
     def test_filter(self) -> None:
         self.chat.msg_add([self.message1, self.message2])
@@ -161,7 +150,7 @@ Answer 2
         self.assertEqual(mock_stdout.getvalue(), expected_output)
 
 
-class TestChatDB(TestChatBase):
+class TestChatDB(unittest.TestCase):
     def setUp(self) -> None:
         self.db_path = tempfile.TemporaryDirectory()
         self.cache_path = tempfile.TemporaryDirectory()
@@ -580,7 +569,7 @@ class TestChatDB(TestChatBase):
         search_names = ['0001', '0002.yaml', self.message3.msg_id(), str(self.message3.file_path)]
         expected_result = [self.message1, self.message2, self.message3]
         result = chat_db.msg_find(search_names, loc='all')
-        self.assert_messages_equal(result, expected_result)
+        self.assertSequenceEqual(result, expected_result)
 
     def test_msg_latest(self) -> None:
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
@@ -606,47 +595,47 @@ class TestChatDB(TestChatBase):
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name))
         all_messages = [self.message1, self.message2, self.message3, self.message4]
-        self.assert_messages_equal(chat_db.msg_gather(loc='all'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='db'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='mem'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='disk'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='cache'), [])
+        self.assertSequenceEqual(chat_db.msg_gather(loc='all'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='db'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='mem'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='disk'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='cache'), [])
         # add a new message, but only to the internal list
         new_message = Message(Question("What?"))
         all_messages_mem = all_messages + [new_message]
         chat_db.msg_add([new_message])
-        self.assert_messages_equal(chat_db.msg_gather(loc='mem'), all_messages_mem)
-        self.assert_messages_equal(chat_db.msg_gather(loc='all'), all_messages_mem)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='mem'), all_messages_mem)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='all'), all_messages_mem)
         # the nr. of messages on disk did not change -> expect old result
-        self.assert_messages_equal(chat_db.msg_gather(loc='db'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='disk'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='cache'), [])
+        self.assertSequenceEqual(chat_db.msg_gather(loc='db'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='disk'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='cache'), [])
         # test with MessageFilter
-        self.assert_messages_equal(chat_db.msg_gather(loc='all', mfilter=MessageFilter(tags_or={Tag('tag1')})),
-                                   [self.message1])
-        self.assert_messages_equal(chat_db.msg_gather(loc='disk', mfilter=MessageFilter(tags_or={Tag('tag2')})),
-                                   [self.message2])
-        self.assert_messages_equal(chat_db.msg_gather(loc='cache', mfilter=MessageFilter(tags_or={Tag('tag3')})),
-                                   [])
-        self.assert_messages_equal(chat_db.msg_gather(loc='mem', mfilter=MessageFilter(question_contains="What")),
-                                   [new_message])
+        self.assertSequenceEqual(chat_db.msg_gather(loc='all', mfilter=MessageFilter(tags_or={Tag('tag1')})),
+                                 [self.message1])
+        self.assertSequenceEqual(chat_db.msg_gather(loc='disk', mfilter=MessageFilter(tags_or={Tag('tag2')})),
+                                 [self.message2])
+        self.assertSequenceEqual(chat_db.msg_gather(loc='cache', mfilter=MessageFilter(tags_or={Tag('tag3')})),
+                                 [])
+        self.assertSequenceEqual(chat_db.msg_gather(loc='mem', mfilter=MessageFilter(question_contains="What")),
+                                 [new_message])
 
     def test_msg_move_and_gather(self) -> None:
         chat_db = ChatDB.from_dir(pathlib.Path(self.cache_path.name),
                                   pathlib.Path(self.db_path.name))
         all_messages = [self.message1, self.message2, self.message3, self.message4]
-        self.assert_messages_equal(chat_db.msg_gather(loc='db'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='cache'), [])
+        self.assertSequenceEqual(chat_db.msg_gather(loc='db'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='cache'), [])
         # move first message to the cache
         chat_db.cache_move(self.message1)
-        self.assert_messages_equal(chat_db.msg_gather(loc='cache'), [self.message1])
+        self.assertSequenceEqual(chat_db.msg_gather(loc='cache'), [self.message1])
         self.assertEqual(self.message1.file_path.parent, pathlib.Path(self.cache_path.name))  # type: ignore [union-attr]
-        self.assert_messages_equal(chat_db.msg_gather(loc='db'), [self.message2, self.message3, self.message4])
-        self.assert_messages_equal(chat_db.msg_gather(loc='all'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='disk'), all_messages)
-        self.assert_messages_equal(chat_db.msg_gather(loc='mem'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='db'), [self.message2, self.message3, self.message4])
+        self.assertSequenceEqual(chat_db.msg_gather(loc='all'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='disk'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='mem'), all_messages)
         # now move first message back to the DB
         chat_db.db_move(self.message1)
-        self.assert_messages_equal(chat_db.msg_gather(loc='cache'), [])
+        self.assertSequenceEqual(chat_db.msg_gather(loc='cache'), [])
         self.assertEqual(self.message1.file_path.parent, pathlib.Path(self.db_path.name))  # type: ignore [union-attr]
-        self.assert_messages_equal(chat_db.msg_gather(loc='db'), all_messages)
+        self.assertSequenceEqual(chat_db.msg_gather(loc='db'), all_messages)

tests/test_question_cmd.py

@@ -11,21 +11,10 @@ from chatmastermind.commands.question import create_message, question_cmd
 from chatmastermind.tags import Tag
 from chatmastermind.message import Message, Question, Answer
 from chatmastermind.chat import Chat, ChatDB
-from chatmastermind.ai import AI, AIResponse, Tokens, AIError
+from chatmastermind.ai import AI, AIResponse, Tokens
 
 
-class TestQuestionCmdBase(unittest.TestCase):
-    def assert_messages_equal(self, msg1: list[Message], msg2: list[Message]) -> None:
-        """
-        Compare messages using more than just Question and Answer.
-        """
-        self.assertEqual(len(msg1), len(msg2))
-        for m1, m2 in zip(msg1, msg2):
-            # exclude the file_path, compare only Q, A and metadata
-            self.assertTrue(m1.equals(m2, file_path=False, verbose=True))
-
-
-class TestMessageCreate(TestQuestionCmdBase):
+class TestMessageCreate(unittest.TestCase):
     """
     Test if messages created by the 'question' command have
     the correct format.
@@ -212,7 +201,7 @@ It is embedded code
 """))
 
 
-class TestQuestionCmd(TestQuestionCmdBase):
+class TestQuestionCmd(unittest.TestCase):
 
     def setUp(self) -> None:
         # create DB and cache
@@ -236,8 +225,7 @@ class TestQuestionCmd(TestQuestionCmdBase):
             source_code=None,
             create=None,
             repeat=None,
-            process=None,
-            overwrite=None
+            process=None
         )
         # create a mock AI instance
         self.ai = MagicMock(spec=AI)
@@ -266,7 +254,7 @@ class TestQuestionCmd(TestQuestionCmdBase):
         Mock the 'ai.request()' function
         """
         question.answer = Answer("Answer 0")
-        question.tags = set(otags) if otags else None
+        question.tags = otags
         question.ai = 'FakeAI'
         question.model = 'FakeModel'
         answers: list[Message] = [question]
@@ -285,7 +273,7 @@ class TestQuestionCmd(TestQuestionCmdBase):
     @mock.patch('chatmastermind.commands.question.create_ai')
     def test_ask_single_answer(self, mock_create_ai: MagicMock) -> None:
         """
-        Test single answer with no errors.
+        Test single answer with no errors
         """
         mock_create_ai.return_value = self.ai
         expected_question = self.input_message(self.args)
@@ -307,13 +295,13 @@ class TestQuestionCmd(TestQuestionCmdBase):
                                Path(self.db_dir.name))
         cached_msg = chat.msg_gather(loc='cache')
         self.assertEqual(len(self.message_list(self.cache_dir)), 1)
-        self.assert_messages_equal(cached_msg, expected_responses)
+        self.assertSequenceEqual(cached_msg, expected_responses)
 
     @mock.patch('chatmastermind.commands.question.ChatDB.from_dir')
     @mock.patch('chatmastermind.commands.question.create_ai')
     def test_ask_single_answer_mocked(self, mock_create_ai: MagicMock, mock_from_dir: MagicMock) -> None:
         """
-        Test single answer with no errors (mocked ChatDB version).
+        Test single answer with no errors (mocked ChatDB version)
         """
         chat = MagicMock(spec=ChatDB)
         mock_from_dir.return_value = chat
@@ -343,134 +331,3 @@ class TestQuestionCmd(TestQuestionCmdBase):
 
         # check that the messages have not been added to the internal message list
         chat.cache_add.assert_not_called()
-
-    @mock.patch('chatmastermind.commands.question.create_ai')
-    def test_ask_with_error(self, mock_create_ai: MagicMock) -> None:
-        """
-        Provoke an error during the AI request and verify that the question
-        has been correctly stored in the cache.
-        """
-        mock_create_ai.return_value = self.ai
-        expected_question = self.input_message(self.args)
-        self.ai.request.side_effect = AIError
-
-        # execute the command
-        with self.assertRaises(AIError):
-            question_cmd(self.args, self.config)
-
-        # check for correct request call
-        self.ai.request.assert_called_once_with(expected_question,
-                                                ANY,
-                                                self.args.num_answers,
-                                                self.args.output_tags)
-        # check for the expected message files
-        chat = ChatDB.from_dir(Path(self.cache_dir.name),
-                               Path(self.db_dir.name))
-        cached_msg = chat.msg_gather(loc='cache')
-        self.assertEqual(len(self.message_list(self.cache_dir)), 1)
-        self.assert_messages_equal(cached_msg, [expected_question])
-
-    @mock.patch('chatmastermind.commands.question.create_ai')
-    def test_repeat_single_question(self, mock_create_ai: MagicMock) -> None:
-        """
-        Repeat a single question.
-        """
-        # 1. ask a question
-        mock_create_ai.return_value = self.ai
-        expected_question = self.input_message(self.args)
-        expected_responses = self.mock_request(expected_question,
-                                               Chat([]),
-                                               self.args.num_answers,
-                                               self.args.output_tags).messages
-        question_cmd(self.args, self.config)
-        chat = ChatDB.from_dir(Path(self.cache_dir.name),
-                               Path(self.db_dir.name))
-        cached_msg = chat.msg_gather(loc='cache')
-        self.assertEqual(len(self.message_list(self.cache_dir)), 1)
-        self.assert_messages_equal(cached_msg, expected_responses)
-
-        # 2. repeat the last question (without overwriting)
-        # -> expect two identical messages (except for the file_path)
-        self.args.ask = None
-        self.args.repeat = []
-        self.args.overwrite = False
-        expected_responses += expected_responses
-        question_cmd(self.args, self.config)
-        cached_msg = chat.msg_gather(loc='cache')
-        self.assertEqual(len(self.message_list(self.cache_dir)), 2)
-        self.assert_messages_equal(cached_msg, expected_responses)
-
-    @mock.patch('chatmastermind.commands.question.create_ai')
-    def test_repeat_single_question_overwrite(self, mock_create_ai: MagicMock) -> None:
-        """
-        Repeat a single question and overwrite the old one.
-        """
-        # 1. ask a question
-        mock_create_ai.return_value = self.ai
-        expected_question = self.input_message(self.args)
-        expected_responses = self.mock_request(expected_question,
-                                               Chat([]),
-                                               self.args.num_answers,
-                                               self.args.output_tags).messages
-        question_cmd(self.args, self.config)
-        chat = ChatDB.from_dir(Path(self.cache_dir.name),
-                               Path(self.db_dir.name))
-        cached_msg = chat.msg_gather(loc='cache')
-        assert cached_msg[0].file_path
-        cached_msg_file_id = cached_msg[0].file_path.stem
-        self.assertEqual(len(self.message_list(self.cache_dir)), 1)
-        self.assert_messages_equal(cached_msg, expected_responses)
-
-        # 2. repeat the last question (WITH overwriting)
-        # -> expect a single message afterwards
-        self.args.ask = None
-        self.args.repeat = []
-        self.args.overwrite = True
-        question_cmd(self.args, self.config)
-        cached_msg = chat.msg_gather(loc='cache')
-        self.assertEqual(len(self.message_list(self.cache_dir)), 1)
-        self.assert_messages_equal(cached_msg, expected_responses)
-        # also check that the file ID has not been changed
-        assert cached_msg[0].file_path
-        self.assertEqual(cached_msg_file_id, cached_msg[0].file_path.stem)
-
-    @mock.patch('chatmastermind.commands.question.create_ai')
-    def test_repeat_single_question_after_error(self, mock_create_ai: MagicMock) -> None:
-        """
-        Repeat a single question after an error.
-        """
-        # 1. ask a question
-        mock_create_ai.return_value = self.ai
-        expected_question = self.input_message(self.args)
-        self.ai.request.side_effect = AIError
-
-        # execute the command
-        with self.assertRaises(AIError):
-            question_cmd(self.args, self.config)
-
-        chat = ChatDB.from_dir(Path(self.cache_dir.name),
-                               Path(self.db_dir.name))
-        cached_msg = chat.msg_gather(loc='cache')
-        assert cached_msg[0].file_path
-        cached_msg_file_id = cached_msg[0].file_path.stem
-        self.assertEqual(len(self.message_list(self.cache_dir)), 1)
-        self.assert_messages_equal(cached_msg, [expected_question])
-
-        # 2. repeat the last question (without overwriting)
-        # -> expect a single message because if the original has
-        #    no answer, it should be overwritten by default
-        self.args.ask = None
-        self.args.repeat = []
-        self.args.overwrite = False
-        self.ai.request.side_effect = self.mock_request
-        expected_responses = self.mock_request(expected_question,
-                                               Chat([]),
-                                               self.args.num_answers,
-                                               self.args.output_tags).messages
-        question_cmd(self.args, self.config)
-        cached_msg = chat.msg_gather(loc='cache')
-        self.assertEqual(len(self.message_list(self.cache_dir)), 1)
-        self.assert_messages_equal(cached_msg, expected_responses)
-        # also check that the file ID has not been changed
-        assert cached_msg[0].file_path
-        self.assertEqual(cached_msg_file_id, cached_msg[0].file_path.stem)