test: add missing test cases

tests/test_app.py

@@ -0,0 +1,111 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from fastapi.testclient import TestClient
+
+from my_ghost_writer.app import app
+
+
+class TestAppEndpoints(unittest.TestCase):
+    def setUp(self):
+        self.client = TestClient(app)
+
+    def test_health(self):
+        response = self.client.get("/health")
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("Still alive", response.text)
+
+    @patch("my_ghost_writer.app.mongodb_health_check")
+    @patch("my_ghost_writer.app.pymongo_version", "8.0.0")
+    def test_health_mongo_ok(self, mock_health_check):
+        mock_health_check.return_value = True
+        response = self.client.get("/health-mongo")
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("Mongodb: still alive", response.text)
+
+    @patch("my_ghost_writer.app.mongodb_health_check", side_effect=Exception("mongo error"))
+    def test_health_mongo_fail(self, mock_health_check):
+        mock_health_check.side_effect = Exception("mongo error")
+        response = self.client.get("/health-mongo")
+        self.assertNotEqual(response.status_code, 200)
+        self.assertEqual(response.status_code, 500)
+
+    @patch("my_ghost_writer.app.text_stemming")
+    def test_words_frequency(self, mock_stemming):
+        mock_stemming.return_value = (1, {"word": 2})
+        body = '{"text": "test test"}'
+        response = self.client.post("/words-frequency", json=body)
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("words_frequency", response.json())
+
+    def test_words_frequency_fail_request(self):
+        body = '{}'
+        response = self.client.post("/words-frequency", json=body)
+        self.assertEqual(response.status_code, 500)
+
+    @patch("my_ghost_writer.app.text_stemming")
+    def test_words_frequency_fail2(self, mock_stemming):
+        mock_stemming.side_effect = ValueError("stemming error")
+        body = '{"text": "test test"}'
+        response = self.client.post("/words-frequency", json=body)
+        self.assertEqual(response.status_code, 500)
+
+    @patch("my_ghost_writer.app.pymongo_operations_rw.get_document_by_word")
+    def test_thesaurus_wordsapi_local(self, mock_get_doc):
+        mock_get_doc.return_value = {"word": "test"}
+        with patch("my_ghost_writer.app.db_ok", {"mongo_ok": True}):
+            body = '{"query": "test"}'
+            response = self.client.post("/thesaurus-wordsapi", json=body)
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response.json()["source"], "local")
+
+    @patch("my_ghost_writer.app.WORDSAPI_URL", "http://mocked-url.com")
+    @patch("my_ghost_writer.app.RAPIDAPI_HOST", "mocked-rapidapi-host.com")
+    @patch("my_ghost_writer.app.WORDSAPI_KEY", "WORDSAPI_KEY")
+    @patch("my_ghost_writer.app.requests.get")
+    @patch("my_ghost_writer.app.pymongo_operations_rw.get_document_by_word", side_effect=AssertionError)
+    @patch("my_ghost_writer.app.pymongo_operations_rw.insert_document")
+    def test_thesaurus_wordsapi_remote_mongo_ok(self, mock_insert, mock_get_doc, mock_requests_get):
+        mock_get_doc.return_value = None
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"word": "test", "_id": "_id"}
+        mock_requests_get.return_value = mock_response
+        with patch("my_ghost_writer.app.db_ok", {"mongo_ok": True}):
+            body = '{"query": "test"}'
+            response = self.client.post("/thesaurus-wordsapi", json=body)
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response.json()["source"], "wordsapi")
+
+    @patch("my_ghost_writer.app.WORDSAPI_URL", "http://mocked-url.com")
+    @patch("my_ghost_writer.app.RAPIDAPI_HOST", "mocked-rapidapi-host.com")
+    @patch("my_ghost_writer.app.WORDSAPI_KEY", "WORDSAPI_KEY")
+    @patch("my_ghost_writer.app.requests.get")
+    def test_thesaurus_wordsapi_remote_mongo_disabled(self, mock_requests_get):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"word": "test", "_id": "_id"}
+        mock_requests_get.return_value = mock_response
+        with patch("my_ghost_writer.app.db_ok", {"mongo_ok": False}):
+            body = '{"query": "test"}'
+            response = self.client.post("/thesaurus-wordsapi", json=body)
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response.json()["source"], "wordsapi")
+
+    @patch("my_ghost_writer.app.WORDSAPI_URL", "http://mocked-url.com")
+    @patch("my_ghost_writer.app.RAPIDAPI_HOST", "mocked-rapidapi-host.com")
+    @patch("my_ghost_writer.app.WORDSAPI_KEY", "WORDSAPI_KEY")
+    @patch("my_ghost_writer.app.requests.get")
+    def test_thesaurus_wordsapi_remote_mongo_disabled_fail(self, mock_requests_get):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"word": "test", "_id": "_id"}
+        mock_requests_get.side_effect = IOError("io error")
+        with patch("my_ghost_writer.app.db_ok", {"mongo_ok": False}):
+            body = '{"query": "test"}'
+            response = self.client.post("/thesaurus-wordsapi", json=body)
+            self.assertEqual(response.status_code, 500)
+            self.assertEqual(response.text, "")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_pymongo_operations_rw.py

@@ -0,0 +1,61 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from my_ghost_writer import pymongo_operations_rw
+
+
+class TestPymongoOperationsRW(unittest.TestCase):
+    @patch('my_ghost_writer.pymongo_operations_rw.pymongo_utils.get_thesaurus_collection')
+    def test_get_document_by_word_found(self, mock_get_collection):
+        mock_collection = MagicMock()
+        mock_collection.find_one.return_value = {"word": "example", "meaning": "test", "_id": "someid"}
+        mock_get_collection.return_value = mock_collection
+
+        result = pymongo_operations_rw.get_document_by_word("example")
+        self.assertEqual(result, {"word": "example", "meaning": "test"})
+        mock_collection.find_one.assert_called_with({"word": "example"})
+
+    @patch('my_ghost_writer.pymongo_operations_rw.pymongo_utils.get_thesaurus_collection')
+    def test_get_document_by_word_not_found(self, mock_get_collection):
+        mock_collection = MagicMock()
+        mock_collection.find_one.return_value = None
+        mock_get_collection.return_value = mock_collection
+
+        with self.assertRaises(AssertionError):
+            try:
+                pymongo_operations_rw.get_document_by_word("notfound")
+            except AssertionError as ae:
+                self.assertEqual(str(ae), "word 'notfound' not found in thesaurus collection")
+                raise ae
+
+    @patch('my_ghost_writer.pymongo_operations_rw.app_logger')
+    @patch('my_ghost_writer.pymongo_operations_rw.pymongo_utils.get_thesaurus_collection')
+    def test_insert_document_success(self, mock_get_collection, mock_logger):
+        mock_collection = MagicMock()
+        mock_result = MagicMock()
+        mock_result.inserted_id = "someid"
+        mock_collection.insert_one.return_value = mock_result
+        mock_get_collection.return_value = mock_collection
+
+        pymongo_operations_rw.insert_document({"word": "example"})
+        mock_collection.insert_one.assert_called_with({"word": "example"})
+        mock_logger.info.assert_called()
+
+    @patch('my_ghost_writer.pymongo_operations_rw.app_logger')
+    @patch('my_ghost_writer.pymongo_operations_rw.pymongo_utils.get_thesaurus_collection')
+    def test_insert_document_failure(self, mock_get_collection, mock_logger):
+        mock_collection = MagicMock()
+        mock_result = MagicMock()
+        mock_result.inserted_id = None
+        mock_collection.insert_one.return_value = mock_result
+        mock_get_collection.return_value = mock_collection
+
+        with self.assertRaises(IOError):
+            try:
+                pymongo_operations_rw.insert_document({"word": "fail"})
+            except IOError as e:
+                self.assertEqual(str(e), """failed insert of document '{"word": "fail"}'""")
+                raise e
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_pymongo_utils.py

@@ -0,0 +1,59 @@
+import unittest
+from unittest.mock import patch, MagicMock
+
+from my_ghost_writer import pymongo_utils
+
+
+class TestPymongoUtils(unittest.TestCase):
+    @patch('my_ghost_writer.pymongo_utils.MongoClient')
+    def test_get_client(self, mock_mongo_client):
+        client = pymongo_utils.get_client()
+        mock_mongo_client.assert_called_with(
+            pymongo_utils.MONGO_CONNECTION_STRING,
+            timeoutMS=pymongo_utils.MONGO_CONNECTION_TIMEOUT
+        )
+        self.assertEqual(client, mock_mongo_client.return_value)
+
+    @patch('my_ghost_writer.pymongo_utils.get_client')
+    def test_get_database(self, mock_get_client):
+        mock_client = MagicMock()
+        mock_get_client.return_value = mock_client
+        db = pymongo_utils.get_database('testdb')
+        mock_get_client.assert_called_once()
+        mock_client.__getitem__.assert_called_with('testdb')
+        self.assertEqual(db, mock_client.__getitem__.return_value)
+
+    @patch('my_ghost_writer.pymongo_utils.get_database')
+    def test_get_thesaurus_collection(self, mock_get_database):
+        mock_db = MagicMock()
+        mock_get_database.return_value = mock_db
+        collection = pymongo_utils.get_thesaurus_collection('testdb', 'testcol')
+        mock_get_database.assert_called_with(db_name='testdb')
+        mock_db.__getitem__.assert_called_with('testcol')
+        self.assertEqual(collection, mock_db.__getitem__.return_value)
+
+    @patch('my_ghost_writer.pymongo_utils.get_client')
+    @patch('my_ghost_writer.pymongo_utils.app_logger')
+    def test_mongodb_health_check(self, mock_logger, mock_get_client):
+        mock_client = MagicMock()
+        mock_get_client.return_value = mock_client
+        mock_client.admin.command.return_value = {'ok': 1}
+        mock_client.server_info.return_value = {'version': '8.0.0'}
+        mock_db = MagicMock()
+        mock_collection = MagicMock()
+        mock_client.__getitem__.return_value = mock_db
+        mock_db.__getitem__.return_value = mock_collection
+        mock_collection.find_one.return_value = {}
+
+        result = pymongo_utils.mongodb_health_check('testdb', 'testcol')
+        mock_client.admin.command.assert_called_with('ping', check=True)
+        mock_client.server_info.assert_called_once()
+        mock_db.__getitem__.assert_called_with('testcol')
+        mock_collection.find_one.assert_called_once()
+        self.assertTrue(result)
+        mock_logger.info.assert_any_call("mongodb server_version:8.0.0!")
+        mock_logger.info.assert_any_call("mongodb: still alive...")
+
+
+if __name__ == '__main__':
+    unittest.main()