Github_actions_updated

Author: RobuRishabh

.github/workflows/test.yml

@@ -22,7 +22,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.11'  # Specify your Python version
+          python-version: '3.10'  # Specify your Python version
 
       # Step 3: Install dependencies
       - name: Install dependencies

requirements.txt

@@ -42,4 +42,5 @@ tenacity
 tqdm
 typing_extensions
 urllib3
+unittest-mock
 watchdog

tests/test_app.py

@@ -1,14 +1,48 @@
 import unittest
-from mock_database import flights
+from mock_database import flights, search_flights, check_ollama_availability
 
 class TestMockDatabase(unittest.TestCase):
     def test_flight_data_exists(self):
         self.assertGreater(len(flights), 0, "Flight database should not be empty")
 
     def test_flight_structure(self):
         flight = flights[0]
-        expected_keys = {"flight_number", "origin", "destination", "time"}
+        expected_keys = {"flight_number", "origin", "destination", "time", "airline"}
         self.assertEqual(set(flight.keys()), expected_keys, "Flight data has incorrect structure")
 
+    def test_search_flights_by_flight_number(self):
+        results = search_flights(flight_number="NY100")  # Use keyword arg for flight_number
+        self.assertGreater(len(results), 0, "Should find at least one matching flight")
+        self.assertIn("NY100", [f["flight_number"] for f in results], "Flight NY100 should be found")
+        self.assertEqual(len(results), 1, "Should find exactly one flight for NY100")
+
+    def test_search_flights_by_origin(self):
+        results = search_flights(origin="New York")
+        self.assertGreater(len(results), 0, "Should find flights from New York")
+        self.assertTrue(all(f["origin"] == "New York" for f in results), "All results should have origin New York")
+
+    def test_search_flights_by_destination(self):
+        results = search_flights(destination="London")
+        self.assertGreater(len(results), 0, "Should find flights to London")
+        self.assertTrue(all(f["destination"] == "London" for f in results), "All results should have destination London")
+
+    def test_search_flights_by_airline(self):
+        results = search_flights(airline="Global Airways")
+        self.assertGreater(len(results), 0, "Should find flights by Global Airways")
+        self.assertTrue(all(f["airline"] == "Global Airways" for f in results), "All results should have airline Global Airways")
+
+    def test_search_flights_no_results(self):
+        results = search_flights(flight_number="XYZ999")
+        self.assertEqual(len(results), 0, "Should return no results for invalid flight number")
+
+    def test_search_flights_no_parameters(self):
+        results = search_flights()
+        self.assertEqual(len(results), 0, "Should return no results when no parameters provided")
+
+    def test_search_flights_case_insensitivity(self):
+        results = search_flights(flight_number="ny100")
+        self.assertGreater(len(results), 0, "Should find NY100 regardless of case")
+        self.assertIn("NY100", [f["flight_number"] for f in results], "Flight NY100 should be found")
+
 if __name__ == "__main__":
     unittest.main()

tests/test_mock_databse.py

@@ -1,24 +1,93 @@
 import unittest
-from unittest.mock import patch
-from ollama_api import call_ollama_api
+from unittest.mock import patch, Mock
+from ollama_api import initialize_ollama, check_ollama_availability, generate_response, generate_fallback_response
 
 class TestOllamaAPI(unittest.TestCase):
-    @patch("ollama_api.requests.post")
-    def test_call_ollama_api_success(self, mock_post):
-        mock_post.return_value.status_code = 200
-        mock_post.return_value.json.return_value = {"response": "Flight NY100 departs at 08:00."}
-        query = "What are flights from New York to London?"
-        flight_data = [{"flight_number": "NY100", "origin": "New York", "destination": "London", "time": "2025-05-01 08:00"}]
-        response = call_ollama_api(query, flight_data)
-        self.assertEqual(response, "Flight NY100 departs at 08:00.")
-
-    @patch("ollama_api.requests.post")
-    def test_call_ollama_api_failure(self, mock_post):
-        mock_post.return_value.status_code = 500
-        query = "What are flights from New York to London?"
-        flight_data = [{"flight_number": "NY100", "origin": "New York", "destination": "London", "time": "2025-05-01 08:00"}]
-        with self.assertRaises(Exception):
-            call_ollama_api(query, flight_data)
+    def setUp(self):
+        # Reset global ollama_llm for each test
+        global ollama_llm
+        ollama_llm = None
+
+    @patch("ollama_api.OllamaLLM")
+    def test_initialize_ollama_success(self, mock_ollama_llm):
+        mock_llm_instance = Mock()
+        mock_ollama_llm.return_value = mock_llm_instance
+        result = initialize_ollama()
+        self.assertIsNotNone(result, "Ollama LLM should initialize successfully")
+        self.assertEqual(result, mock_llm_instance)
+
+    @patch("ollama_api.OllamaLLM", side_effect=Exception("Initialization failed"))
+    def test_initialize_ollama_failure(self, mock_ollama_llm):
+        result = initialize_ollama()
+        self.assertIsNone(result, "Ollama LLM should return None on failure")
+
+    @patch("ollama_api.requests.get")
+    def test_check_ollama_availability_success(self, mock_get):
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_get.return_value = mock_response
+        is_available, message = check_ollama_availability()
+        self.assertTrue(is_available, "Ollama should be available")
+        self.assertIn("available", message)
+
+    @patch("ollama_api.requests.get", side_effect=requests.RequestException("Connection error"))
+    def test_check_ollama_availability_failure(self, mock_get):
+        is_available, message = check_ollama_availability()
+        self.assertFalse(is_available, "Ollama should not be available")
+        self.assertIn("not available", message)
+
+    def test_generate_fallback_response_with_flights(self):
+        flights = [
+            {"flight_number": "NY100", "origin": "New York", "destination": "London", "time": "2025-05-01 08:00", "airline": "Global Airways"}
+        ]
+        response = generate_fallback_response("test query", flights)
+        self.assertIn("NY100", response)
+        self.assertIn("New York", response)
+        self.assertIn("London", response)
+        self.assertIn("2025-05-01 08:00", response)
+        self.assertIn("Global Airways", response)
+
+    def test_generate_fallback_response_no_flights(self):
+        response = generate_fallback_response("test query", [])
+        self.assertEqual(response, "I couldn't find any flights matching your criteria. Please try again.")
+
+    @patch("ollama_api.check_ollama_availability")
+    @patch("ollama_api.ollama_llm", new=Mock(invoke=lambda x: "Flight NY100 departs at 08:00 from New York to London with Global Airways"))
+    def test_generate_response_success(self, mock_check_availability):
+        mock_check_availability.return_value = (True, "Ollama available")
+        query = "Show me flight NY100"
+        flight_data = [
+            {"flight_number": "NY100", "origin": "New York", "destination": "London", "time": "2025-05-01 08:00", "airline": "Global Airways"}
+        ]
+        response = generate_response(query, flight_data)
+        self.assertIn("NY100", response)
+        self.assertIn("08:00", response)
+        self.assertIn("New York", response)
+        self.assertIn("London", response)
+        self.assertIn("Global Airways", response)
+
+    @patch("ollama_api.check_ollama_availability")
+    def test_generate_response_no_flights(self, mock_check_availability):
+        mock_check_availability.return_value = (True, "Ollama available")
+        # Ensure ollama_llm is initialized (mock it globally)
+        global ollama_llm
+        ollama_llm = Mock(invoke=lambda x: "No flights found.")
+        query = "Show me flight XYZ999"
+        flight_data = []
+        response = generate_response(query, flight_data)
+        self.assertEqual(response, "I couldn't find any flights matching your criteria. Please try again.")
+
+    @patch("ollama_api.check_ollama_availability")
+    def test_generate_response_ollama_unavailable(self, mock_check_availability):
+        mock_check_availability.return_value = (False, "Ollama not available")
+        query = "Show me flight NY100"
+        flight_data = [
+            {"flight_number": "NY100", "origin": "New York", "destination": "London", "time": "2025-05-01 08:00", "airline": "Global Airways"}
+        ]
+        response = generate_response(query, flight_data)
+        self.assertIn("NY100", response)
+        self.assertIn("New York", response)
+        self.assertIn("London", response)
 
 if __name__ == "__main__":
     unittest.main()

tests/test_ollama_api.py

@@ -1,23 +1,84 @@
 import unittest
-from query_handler import parse_query, search_flights
+from unittest.mock import patch, Mock
+from query_handler import process_query, extract_entities_ollama, extract_flight_number, extract_entities_from_keywords, OLLAMA_AVAILABLE
 
 class TestQueryHandler(unittest.TestCase):
-    def test_parse_query(self):
-        query = "What flights are from New York to London?"
-        result = parse_query(query)
-        self.assertEqual(result["origin"], "New York")
-        self.assertEqual(result["destination"], "London")
-
-    def test_search_flights(self):
-        query = {"origin": "New York", "destination": "London"}
-        results = search_flights(query)
-        self.assertGreater(len(results), 0, "Should find at least one matching flight")
-        self.assertIn("NY100", [f["flight_number"] for f in results])
-
-    def test_no_results(self):
-        query = {"origin": "Mars", "destination": "Jupiter"}
-        results = search_flights(query)
-        self.assertEqual(len(results), 0, "Should return no results for invalid query")
+    def setUp(self):
+        # Reset global ollama_llm for each test
+        global ollama_llm
+        ollama_llm = None
+
+    @patch("query_handler.OllamaLLM")
+    def test_extract_entities_ollama_success(self, mock_ollama_llm):
+        mock_llm_instance = Mock()
+        mock_llm_instance.invoke.return_value = '''
+        {"origin": "New York", "destination": "London", "flight_number": "NY100", "date": "2025-05-01", "airline": "Global Airways"}
+        '''
+        mock_ollama_llm.return_value = mock_llm_instance
+        global ollama_llm
+        ollama_llm = mock_llm_instance  # Set global for OLLAMA_AVAILABLE check
+
+        if OLLAMA_AVAILABLE:
+            result = extract_entities_ollama("Show me flight NY100")
+            self.assertEqual(result["origin"], "New York")
+            self.assertEqual(result["flight_number"], "NY100")
+            self.assertEqual(result["destination"], "London")
+            self.assertEqual(result["date"], "2025-05-01")
+            self.assertEqual(result["airline"], "Global Airways")
+
+    @patch("query_handler.OllamaLLM")
+    def test_extract_entities_ollama_fallback(self, mock_ollama_llm):
+        mock_llm_instance = Mock()
+        mock_llm_instance.invoke.side_effect = Exception("Ollama error")
+        mock_ollama_llm.return_value = mock_llm_instance
+        global ollama_llm
+        ollama_llm = mock_llm_instance
+
+        result = extract_entities_ollama("Show me flights from New York")
+        self.assertEqual(result["origin"], "new york")  # From keyword fallback
+        self.assertNotIn("destination", result)  # No destination in simple keyword match
+
+    def test_extract_flight_number(self):
+        self.assertEqual(extract_flight_number("Show me flight NY100"), "NY100")
+        self.assertIsNone(extract_flight_number("Show me flights from New York"))
+
+    def test_extract_entities_from_keywords(self):
+        result = extract_entities_from_keywords("Flights from New York with Global Airways")
+        self.assertEqual(result["origin"], "new york")
+        self.assertEqual(result["airline"], "global airways")
+        self.assertNotIn("destination", result)
+
+        result = extract_entities_from_keywords("Flight NY100")
+        self.assertEqual(result["flight_number"], "NY100")
+
+        result = extract_entities_from_keywords("Random text")
+        self.assertEqual(result, {})
+
+    def test_process_query_success(self):
+        success, message, flights = process_query("Show me flight NY100")
+        self.assertTrue(success, "Query should succeed")
+        self.assertEqual(message, "Here are the flights that match your criteria:")
+        self.assertGreater(len(flights), 0, "Should return at least one flight")
+        self.assertIn("NY100", [f["flight_number"] for f in flights])
+
+    def test_process_query_no_results(self):
+        success, message, flights = process_query("Show me flight XYZ999")
+        self.assertFalse(success, "Query should fail for invalid flight")
+        self.assertEqual(message, "⚠️ No flights found matching your criteria. Please try again with different details.")
+        self.assertEqual(len(flights), 0, "Should return no flights")
+
+    @patch("query_handler.OllamaLLM")
+    def test_process_query_ollama_unavailable(self, mock_ollama_llm):
+        mock_llm_instance = Mock()
+        mock_llm_instance.invoke.side_effect = Exception("Ollama unavailable")
+        mock_ollama_llm.return_value = mock_llm_instance
+        global ollama_llm
+        ollama_llm = mock_llm_instance
+
+        success, message, flights = process_query("Flights from New York")
+        self.assertTrue(success, "Query should succeed with keyword fallback")
+        self.assertEqual(message, "Here are the flights that match your criteria:")
+        self.assertGreater(len(flights), 0, "Should return flights from New York")
 
 if __name__ == "__main__":
     unittest.main()