test: improve unit test coverage ratio to 95%

Author: lpm0073

.gitignore

@@ -1,3 +1,7 @@
+# my own homegrown file to store coverage report output from Docker.
+coverage.out
+
+
 # Jupyter Notebook
 .ipynb_checkpoints
 build

Makefile

@@ -120,7 +120,7 @@ docker-coverage:
 		-e LOGGING_LEVEL=${LOGGING_LEVEL} \
 		-e LLM_TOOL_CHOICE=${LLM_TOOL_CHOICE} \
 		${DOCKERHUB_USERNAME}/${REPO_NAME}:latest \
-		/bin/bash -c "python -m coverage run --source=app -m unittest discover -s app/tests && python -m coverage report && python -m coverage xml"
+		/bin/bash -c "python -m coverage run --source=app --omit='app/tests/*' -m unittest discover -s app/tests && python -m coverage report -m --omit='app/tests/*' && python -m coverage xml --omit='app/tests/*'"
 
 docker-prune:
 	@if [ "`docker ps -aq`" ]; then \

app/structured_outputs.py

@@ -119,7 +119,7 @@ def register_course_with_structured_output(course_code: str, email: str, full_na
 
 # Example of using OpenAI's beta structured outputs (requires openai>=1.0.0)
 # pylint: disable=unused-argument
-def completion_with_structured_output(prompt: str, response_model: type):
+def completion_with_structured_output(prompt: str, response_model: type) -> None:
     """
     Example of using OpenAI's structured output parsing.
 
@@ -143,4 +143,4 @@ def completion_with_structured_output(prompt: str, response_model: type):
     # pylint: disable=broad-except
     except Exception as e:
         logger.error("Structured completion error: %s", e)
-        return None
+        raise e

app/tests/test_agent.py

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=wrong-import-position
+# pylint: disable=R0801,C0115,W0613
+"""Test application."""
+
+# python stuff
+import os
+import sys
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from app import agent
+from app.agent import main  # noqa: E402
+
+
+HERE = os.path.abspath(os.path.dirname(__file__))
+PROJECT_ROOT = str(Path(HERE).parent.parent)
+PYTHON_ROOT = str(Path(PROJECT_ROOT).parent)
+if PYTHON_ROOT not in sys.path:
+    sys.path.append(PYTHON_ROOT)  # noqa: E402
+
+
+class TestApplication(unittest.TestCase):
+    """Test application."""
+
+    def test_application_does_not_crash(self):
+        """Test that the application returns a value."""
+
+        # pylint: disable=broad-exception-caught
+        prompts = (
+            "Show me a list of available courses.",
+            "I would like to register for the CS107 Algorithms course. My name is John Doe and my email is john.doe@example.com",
+            "Thank you, that's all for now. Goodbye!",
+            "Goodbye!",
+            "Go away!",
+        )
+        try:
+            main(prompts=prompts)
+        except Exception as e:
+            self.fail(f"main raised an exception: {e}")
+
+    @patch("app.agent.completion")
+    @patch("builtins.input", return_value="no")
+    def test_main_goodbye(self, mock_input, mock_completion):
+        """Test that the application exits on "Goodbye!"."""
+        mock_completion.return_value = (None, [])
+        agent.main(prompts=("no",))
+
+    @patch("app.agent.completion")
+    @patch("builtins.input", side_effect=["yes", "no"])
+    def test_main_followup_question(self, mock_input, mock_completion):
+        """Test that the application handles a follow-up question."""
+
+        class MockMessage:
+            content = "Some info\nQUESTION: What would you like to do next?"
+
+        class MockResponse:
+            choices = [type("obj", (), {"message": MockMessage})]
+
+        mock_completion.side_effect = [
+            (MockResponse(), ["get_courses"]),
+            (MockResponse(), ["register_course"]),
+            (None, []),
+        ]
+        agent.main(prompts=None)
+
+    @patch("app.agent.completion")
+    @patch("builtins.input", side_effect=["something", "no"])
+    def test_main_default_prompt(self, mock_input, mock_completion):
+        """Test that the application handles a default prompt."""
+
+        class MockMessage:
+            content = "Just a message"
+
+        class MockResponse:
+            choices = [type("obj", (), {"message": MockMessage})]
+
+        mock_completion.side_effect = [(MockResponse(), []), (None, [])]
+        agent.main(prompts=None)

app/tests/test_application.py

@@ -0,0 +1,140 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=wrong-import-position
+# pylint: disable=R0801,W0613,W0719,W0718
+"""Test database connectivity."""
+
+# python stuff
+import os
+import sys
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pymysql
+
+from app.database import ConfigurationException, DatabaseConnection
+from app.logging_config import get_logger
+
+
+HERE = os.path.abspath(os.path.dirname(__file__))
+PROJECT_ROOT = str(Path(HERE).parent.parent)
+PYTHON_ROOT = str(Path(PROJECT_ROOT).parent)
+if PYTHON_ROOT not in sys.path:
+    sys.path.append(PYTHON_ROOT)  # noqa: E402
+
+
+logger = get_logger(__name__)
+
+
+class TestDatabase(unittest.TestCase):
+    """Test database."""
+
+    def test_connection_string(self):
+        """Test that the connection string is formed correctly."""
+        db = DatabaseConnection()
+        conn_str = db.connection_string
+        self.assertIn("@", conn_str)
+        self.assertIn("/", conn_str)
+
+    @patch("app.database.pymysql.connect")
+    def test_get_connection_success(self, mock_connect):
+        """Test that a connection is returned on success."""
+        db = DatabaseConnection()
+        mock_connect.return_value = MagicMock()
+        conn = db.get_connection()
+        self.assertIsNotNone(conn)
+        mock_connect.assert_called_once()
+
+    @patch("app.database.pymysql.connect", side_effect=Exception("fail"))
+    def test_get_connection_failure(self, mock_connect):
+        """Test that an exception is raised on connection failure."""
+        db = DatabaseConnection()
+        with self.assertRaises(Exception):
+            db.get_connection()
+
+    @patch("app.database.DatabaseConnection.get_connection")
+    def test_get_cursor_success(self, mock_get_conn):
+        """Test that a cursor is returned on success."""
+        db = DatabaseConnection()
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_conn.cursor.return_value = mock_cursor
+        mock_get_conn.return_value = mock_conn
+        with db.get_cursor() as cursor:
+            self.assertEqual(cursor, mock_cursor)
+        mock_conn.commit.assert_called_once()
+        mock_conn.close.assert_called_once()
+
+    @patch("app.database.DatabaseConnection.get_connection")
+    def test_get_cursor_exception(self, mock_get_conn):
+        """Test that an exception during cursor usage rolls back and closes."""
+        db = DatabaseConnection()
+        mock_conn = MagicMock()
+        mock_cursor = MagicMock()
+        mock_conn.cursor.return_value = mock_cursor
+        mock_get_conn.return_value = mock_conn
+
+        def raise_exc(*args, **kwargs):
+            raise Exception("fail")
+
+        mock_cursor.execute.side_effect = raise_exc
+        try:
+            with db.get_cursor() as cursor:
+                cursor.execute("SELECT 1")
+        except Exception:
+            mock_conn.rollback.assert_called_once()
+            mock_conn.close.assert_called_once()
+
+    @patch("app.database.DatabaseConnection.get_cursor")
+    def test_execute_query(self, mock_get_cursor):
+        """Test that a query returns results."""
+        db = DatabaseConnection()
+        mock_cursor = MagicMock()
+        mock_cursor.fetchall.return_value = [{"a": 1}]
+        mock_get_cursor.return_value.__enter__.return_value = mock_cursor
+        result = db.execute_query("SELECT * FROM test")
+        self.assertEqual(result, [{"a": 1}])
+
+    @patch("app.database.DatabaseConnection.get_cursor")
+    def test_execute_update(self, mock_get_cursor):
+        """Test that an update returns affected row count."""
+        db = DatabaseConnection()
+        mock_cursor = MagicMock()
+        mock_cursor.rowcount = 2
+        mock_get_cursor.return_value.__enter__.return_value = mock_cursor
+        result = db.execute_update("UPDATE test SET a=1")
+        self.assertEqual(result, 2)
+
+    @patch("app.database.DatabaseConnection.get_cursor")
+    def test_test_connection_success(self, mock_get_cursor):
+        """Test that the database connection is successful."""
+        db = DatabaseConnection()
+        mock_cursor = MagicMock()
+        mock_get_cursor.return_value.__enter__.return_value = mock_cursor
+        mock_cursor.execute.return_value = None
+        self.assertTrue(db.test_connection())
+
+    @patch("app.database.DatabaseConnection.get_cursor", side_effect=Exception("fail"))
+    def test_test_connection_failure(self, mock_get_cursor):
+        """Test that the database connection failure is handled."""
+        db = DatabaseConnection()
+        self.assertFalse(db.test_connection())
+
+    def test_missing_config_raises(self):
+        """Test that missing configuration raises ConfigurationException."""
+        with (
+            patch("app.database.MYSQL_HOST", ""),
+            patch("app.database.MYSQL_USER", ""),
+            patch("app.database.MYSQL_PASSWORD", ""),
+            patch("app.database.MYSQL_DATABASE", ""),
+        ):
+            with self.assertRaises(ConfigurationException):
+                DatabaseConnection()
+
+    @patch("app.database.pymysql.connect", side_effect=pymysql.Error("connection failed"))
+    def test_get_connection_raises(self, mock_connect):
+        """Test that a pymysql.Error during connection raises the appropriate exception."""
+        db = DatabaseConnection()
+        with self.assertRaises(pymysql.Error) as ctx:
+            db.get_connection()
+        self.assertIn("Failed to connect to MySQL database", str(ctx.exception))