test: update test cases, optimize some imports

my_ghost_writer/jsonpath_comparator.py

@@ -1,4 +1,3 @@
-from jsonpath_ng import parse
 from jsonpath_ng.ext import parse as parse_ext
 from typing import Dict, Set, Any, List
 

tests/my_ghost_writer/test_custom_synonym_handler.py

@@ -5,75 +5,96 @@ from my_ghost_writer.type_hints import RelatedEntry, TermRelationships
 
 
 class TestCustomSynonymHandler(unittest.TestCase):
-    def test_custom_synonym_handler_add_entry_ok1(self):
-        word_input = "happy"
-        related_input = []
-        for rel in [
-                    {'definition': 'definition of happy', 'type': 'synonym', 'words': ['joy', 'cheer']},
-                    {'definition': 'definition of sad', 'type': 'antonym', 'words': ['sad', 'sadness']},
-                    {'definition': 'another definition of happy', 'type': 'synonym', 'words': ['content', 'cheerful', 'joyful']}
-                ]:
-            tmp = RelatedEntry(**rel)
-            related_input.append(tmp)
-        test_custom_synonym_handler = CustomSynonymHandler()
-        self.assertEqual(test_custom_synonym_handler.inverted_index, {})
-        self.assertEqual(test_custom_synonym_handler.lexicon, {})
-
-        test_custom_synonym_handler.add_entry(word_input, related_input)
+    def setUp(self):
+        """Set up a fresh handler and test data for each test."""
+        self.handler = CustomSynonymHandler()
+        self.happy_related_data = [
+            {'definition': 'definition of happy', 'type': 'synonym', 'words': ['joy', 'cheer']},
+            {'definition': 'definition of sad', 'type': 'antonym', 'words': ['sad', 'sadness']},
+            {'definition': 'another definition of happy', 'type': 'synonym', 'words': ['content', 'cheerful', 'joyful']}
+        ]
+        self.happy_related_entries = [RelatedEntry(**rel) for rel in self.happy_related_data]
+
+    def test_initial_state(self):
+        """Tests that a new handler is empty."""
+        self.assertEqual(self.handler.lexicon, {})
+        self.assertEqual(self.handler.inverted_index, {})
+
+    def test_add_entry_populates_lexicon_and_index(self):
+        """Tests that add_entry correctly populates the lexicon and inverted index."""
+        # Act
+        self.handler.add_entry("happy", self.happy_related_entries)
+
+        # Assert
         expected_lexicon = {
             "happy": {
-                "synonym": [
-                    {
-                        "words": ["joy", "cheer"],
-                        "definition": "definition of happy"
-                    },
-                    {
-                        "words": ["content", "cheerful", "joyful"],
-                        "definition": "another definition of happy"
-                    }
+                TermRelationships.SYNONYM: [
+                    {"words": ["joy", "cheer"], "definition": "definition of happy"},
+                    {"words": ["content", "cheerful", "joyful"], "definition": "another definition of happy"}
                 ],
-                "antonym": [
-                    {
-                        "words": ["sad", "sadness"],
-                        "definition": "definition of sad"
-                    }
+                TermRelationships.ANTONYM: [
+                    {"words": ["sad", "sadness"], "definition": "definition of sad"}
                 ]
             }
         }
         expected_inverted_index = {
-            "joy":      { "happy" },
-            "cheer":    { "happy" },
-            "sad":      { "happy" },
-            "sadness":  { "happy" },
-            "content":  { "happy" },
-            "cheerful": { "happy" },
-            "joyful":   { "happy" }
+            "joy": {"happy"}, "cheer": {"happy"}, "sad": {"happy"},
+            "sadness": {"happy"}, "content": {"happy"}, "cheerful": {"happy"},
+            "joyful": {"happy"}
         }
-        self.assertEqual(test_custom_synonym_handler.lexicon, expected_lexicon)
-        self.assertEqual(test_custom_synonym_handler.inverted_index, expected_inverted_index)
+        self.assertEqual(self.handler.lexicon, expected_lexicon)
+        self.assertEqual(self.handler.inverted_index, expected_inverted_index)
 
-        synonyms_related = test_custom_synonym_handler.get_related("happy", TermRelationships.SYNONYM)
-        self.assertListEqual(synonyms_related, [
-            {'definition': 'definition of happy', 'words': ['joy', 'cheer']},
-            {'definition': 'another definition of happy', 'words': ['content', 'cheerful', 'joyful']}
-        ])
-        antonyms_related = test_custom_synonym_handler.get_related("happy", TermRelationships.ANTONYM)
-        self.assertListEqual(antonyms_related, [{'definition': 'definition of sad', 'words': ['sad', 'sadness']}])
+    def test_get_related_retrieves_correct_data(self):
+        """Tests that get_related returns the correct entries for a given relationship type."""
+        # Add a new entry
+        self.handler.add_entry("happy", self.happy_related_entries)
+
+        # get synonyms and antonyms
+        synonyms = self.handler.get_related("happy", TermRelationships.SYNONYM)
+        antonyms = self.handler.get_related("happy", TermRelationships.ANTONYM)
 
-        test_custom_synonym_handler.add_entry("text", [
-            RelatedEntry(**{'definition': 'definition of text', 'type': 'synonym', 'words': ['word', 'sentence']})
+        # Assert
+        self.assertCountEqual(synonyms, [
+            {'words': ['joy', 'cheer'], 'definition': 'definition of happy'},
+            {'words': ['content', 'cheerful', 'joyful'], 'definition': 'another definition of happy'}
         ])
-        self.assertEqual(test_custom_synonym_handler.lexicon, {
-            **{"text": {'synonym': [{'definition': 'definition of text', 'words': ['word', 'sentence']}]}},
-            **expected_lexicon
-        })
-        self.assertEqual(test_custom_synonym_handler.inverted_index, {
-            "word": {"text"}, "sentence": {"text"}, **expected_inverted_index
-        })
-
-        test_custom_synonym_handler.delete_entry("text")
-        self.assertEqual(test_custom_synonym_handler.lexicon, expected_lexicon)
-        self.assertEqual(test_custom_synonym_handler.inverted_index, expected_inverted_index)
+        self.assertCountEqual(antonyms, [{'words': ['sad', 'sadness'], 'definition': 'definition of sad'}])
+
+    def test_get_related_returns_empty_for_no_match(self):
+        """Tests that get_related returns an empty list for non-existent words or types."""
+        # Add a new entry
+        self.handler.add_entry("happy", self.happy_related_entries)
+
+        # get hypernyms and synonyms
+        empty_result_for_type = self.handler.get_related("happy", TermRelationships.HYPERNYM)
+        empty_result_for_word = self.handler.get_related("sad", TermRelationships.SYNONYM)
+
+        # Assert
+        self.assertEqual(empty_result_for_type, [])
+        self.assertEqual(empty_result_for_word, [])
+
+    def test_delete_entry_removes_from_lexicon_and_index(self):
+        """Tests that delete_entry correctly removes a word and its associations."""
+        # Add a new entry
+        self.handler.add_entry("happy", self.happy_related_entries)
+        text_entry = RelatedEntry(**{'definition': 'text def', 'type': 'synonym', 'words': ['word']})
+        self.handler.add_entry("text", [text_entry])
+
+        # delete
+        self.handler.delete_entry("text")
+
+        # Assert
+        self.assertNotIn("text", self.handler.lexicon)
+        self.assertNotIn("word", self.handler.inverted_index)
+        # Ensure other entries are unaffected
+        self.assertIn("happy", self.handler.lexicon)
+        self.assertIn("joy", self.handler.inverted_index)
+
+    def test_delete_nonexistent_entry_raises_key_error(self):
+        """Tests that deleting a word not in the lexicon raises a KeyError."""
+        with self.assertRaises(KeyError):
+            self.handler.delete_entry("nonexistent")
 
 
 if __name__ == '__main__':

tests/my_ghost_writer/test_text_parsers2.py

@@ -4,11 +4,11 @@ from unittest.mock import patch, MagicMock
 
 from fastapi import HTTPException
 
+from my_ghost_writer.custom_synonym_handler import CustomSynonymHandler
 from my_ghost_writer.text_parsers2 import (extract_contextual_info_by_indices, get_wordnet_synonyms, inflect_synonym,
     is_nlp_available, process_synonym_groups)
-from my_ghost_writer.jsonpath_comparator import JSONPathComparator
-from my_ghost_writer.jsonpath_extractor import JSONPathStructureAnalyzer, analyze_dict_list_simple
-from my_ghost_writer.type_hints import TermRelationships
+from my_ghost_writer.jsonpath_extractor import JSONPathStructureAnalyzer
+from my_ghost_writer.type_hints import TermRelationships, RelatedEntry
 from tests import EVENTS_FOLDER
 from tests.my_ghost_writer.helpers_tests import analyze_detailed_report_lists
 
@@ -256,6 +256,41 @@ class TestTextParsers2(unittest.TestCase):
         # Test with a regular verb
         self.assertEqual(inflect_synonym("look", original_token_info), "look")
 
+    def test_inflect_synonym_verbs(self):
+        """Tests various verb inflections using subtests."""
+        test_cases = [
+            # (tag, synonym, expected_inflection)
+            ("VBD", "write", "wrote"),  # Past tense
+            ("VBD", "look", "looked"),
+            ("VBG", "write", "writing"),  # Present participle
+            ("VBG", "look", "looking"),
+            ("VBZ", "write", "writes"),  # 3rd person singular
+            ("VBZ", "look", "looks"),
+        ]
+
+        for tag, synonym, expected in test_cases:
+            with self.subTest(tag=tag, synonym=synonym):
+                original_token_info = {
+                    'pos': 'VERB', 'tag': tag, 'is_lower': True, 'is_title': False, 'is_upper': False
+                }
+                self.assertEqual(inflect_synonym(synonym, original_token_info), expected)
+
+    def test_inflect_synonym_casing(self):
+        """Tests that casing is correctly applied during inflection."""
+        test_cases = [
+            # (is_title, is_upper, synonym, expected)
+            (True, False, "write", "Wrote"),
+            (False, True, "write", "WROTE"),
+            (False, False, "look", "looked"),
+        ]
+        for is_title, is_upper, synonym, expected in test_cases:
+            with self.subTest(is_title=is_title, is_upper=is_upper):
+                original_token_info = {
+                    'pos': 'VERB', 'tag': 'VBD', 'is_lower': not (is_title or is_upper),
+                    'is_title': is_title, 'is_upper': is_upper
+                }
+                self.assertEqual(inflect_synonym(synonym, original_token_info), expected)
+
     def test_process_synonym_groups(self):
         """Tests the full processing pipeline for a verb."""
         word = "look"
@@ -318,6 +353,41 @@ class TestTextParsers2(unittest.TestCase):
         result = process_synonym_groups("look", context_info)
         self.assertListEqual(result, [])
 
+    @patch("my_ghost_writer.text_parsers2.custom_synonym_handler", new_callable=CustomSynonymHandler)
+    def test_process_synonym_groups_includes_custom_entries(self, mock_handler):
+        """Tests that custom synonyms are correctly processed and included in the results."""
+        # Arrange
+        # 1. Add a custom synonym to our mocked handler
+        custom_entry = RelatedEntry(
+            type=TermRelationships.SYNONYM,
+            words=["gleeful", "elated"],
+            definition="A custom definition for happy"
+        )
+        mock_handler.add_entry("happy", [custom_entry])
+
+        # 2. Define the context for the word "happy"
+        word = "happy"
+        context_info = {
+            'lemma': 'happy', 'pos': 'ADJ', 'tag': 'JJ', 'is_lower': True,
+            'is_title': False, 'is_upper': False
+        }
+
+        # Act
+        result_groups = process_synonym_groups(word, context_info)
+
+        # Assert
+        # 1. Find the group that came from our custom source
+        custom_group = next((g for g in result_groups if g.related_words and g.related_words[0].is_custom), None)
+
+        # 2. Assert that the custom group was found and has the correct data
+        self.assertIsNotNone(custom_group, "A custom synonym group should have been found in the results.")
+        self.assertEqual(custom_group.definition, "A custom definition for happy")
+        self.assertEqual(custom_group.relation_type, TermRelationships.SYNONYM)
+
+        # 3. Check that the custom words are present
+        custom_base_forms = {word.base_form for word in custom_group.related_words}
+        self.assertEqual(custom_base_forms, {"gleeful", "elated"})
+
 
 if __name__ == '__main__':
     unittest.main()