Updated unit tests to be independent of Mongo database

Author: Mike Storey

docker-compose.yaml

@@ -1,4 +1,4 @@
-version: '3.1'
+# docker-compose.yaml for stage0_mongodb_api testing
 
 services:
   mongodb-server:

stage0_mongodb_api/managers/config_manager.py

@@ -25,7 +25,7 @@ class ConfigManager:
     def __init__(self):
         """Initialize the config manager."""
         self.config = Config.get_instance()
-        self.mongo_io = MongoIO()
+        self.mongo_io = MongoIO.get_instance()
         self.collection_configs: Dict[str, Dict] = {}
         self.load_errors: List[Dict] = []
         self.version_manager = VersionManager()

tests/managers/test_config_manager.py

@@ -4,9 +4,19 @@
 import tempfile
 from stage0_mongodb_api.managers.config_manager import ConfigManager
 from stage0_py_utils import Config
-from unittest.mock import patch
+from unittest.mock import patch, MagicMock
 
 class TestConfigManager(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.mongoio_patcher = patch('stage0_py_utils.mongo_utils.mongo_io.MongoIO.get_instance')
+        cls.mock_mongoio_get_instance = cls.mongoio_patcher.start()
+        cls.mock_mongoio_get_instance.return_value = MagicMock()
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.mongoio_patcher.stop()
+
     def setUp(self):
         self.test_cases_dir = os.path.join(os.path.dirname(__file__), '..', 'test_cases')
         self.config = Config.get_instance()
@@ -16,38 +26,26 @@ def tearDown(self):
 
     def test_load_minimum_valid(self):
         """Test loading empty Collections directory structure."""
-
-        # Initialize SchemaManager 
         test_case_dir = os.path.join(self.test_cases_dir, "minimum_valid")
         self.config.INPUT_FOLDER = test_case_dir        
         manager = ConfigManager()
-        
-        # Verify no load errors
         self.assertEqual(manager.load_errors, [], "Unexpected load errors in simple_valid test case")
         self.assertEqual(len(manager.collection_configs), 0, f"Unexpected number of collection configs {len(manager.collection_configs)}")
 
     def test_load_small_sample(self):
         """Test loading Small configuration."""
-
-        # Initialize SchemaManager 
         test_case_dir = os.path.join(self.test_cases_dir, "small_sample")
         self.config.INPUT_FOLDER = test_case_dir        
         manager = ConfigManager()
-        
-        # Verify no load errors
         self.assertEqual(manager.load_errors, [], "Unexpected load errors in simple_valid test case")
         self.assertEqual(len(manager.collection_configs), 1, f"Unexpected number of collection configs {len(manager.collection_configs)}")
         self.assertIn("simple", manager.collection_configs)
 
     def test_load_large_sample(self):
         """Test loading large config"""
-
-        # Initialize SchemaManager 
         test_case_dir = os.path.join(self.test_cases_dir, "large_sample")
         self.config.INPUT_FOLDER = test_case_dir        
         manager = ConfigManager()
-        
-        # Verify no load errors
         self.assertEqual(manager.load_errors, [], "Unexpected load errors in simple_valid test case")
         self.assertEqual(len(manager.collection_configs), 4, f"Unexpected number of collection configs {len(manager.collection_configs)}")
         self.assertIn("media", manager.collection_configs)
@@ -57,75 +55,56 @@ def test_load_large_sample(self):
 
     def test_non_parsable(self):
         """Test loading with non-parsable files"""
-
-        # Initialize SchemaManager 
         test_case_dir = os.path.join(self.test_cases_dir, "non_parsable")
         self.config.INPUT_FOLDER = test_case_dir        
         manager = ConfigManager()
-        
-        # Verify no load errors
         self.assertEqual(len(manager.load_errors), 1, f"Unexpected load errors {manager.load_errors}")
 
     def test_validation_errors(self):
         """Test loading with validation errors"""
-
-        # Initialize SchemaManager 
         test_case_dir = os.path.join(self.test_cases_dir, "validation_errors")
         self.config.INPUT_FOLDER = test_case_dir        
         manager = ConfigManager()
         errors = manager.validate_configs()
-        
-        # Verify no load errors
         self.assertEqual(len(manager.load_errors), 0, f"Unexpected load errors {manager.load_errors}")
         self.assertEqual(len(errors), 6, f"Unexpected number of validation errors {errors}")
 
-    @patch('stage0_mongodb_api.managers.config_manager.MongoIO')
-    def test_load_test_data_bulk_write_error(self, mock_mongo):
+    def test_load_test_data_bulk_write_error(self):
         """Test that _load_test_data properly handles bulk write errors."""
-        # Arrange
         from stage0_py_utils.mongo_utils.mongo_io import TestDataLoadError
         mock_details = {'writeErrors': [{'index': 0, 'code': 121, 'errmsg': 'Document failed validation'}]}
-        mock_mongo.return_value.load_test_data.side_effect = TestDataLoadError("Schema validation failed during test data load", details=mock_details)
-        
+        self.mock_mongoio_get_instance.return_value.load_test_data.side_effect = TestDataLoadError(
+            "Schema validation failed during test data load", details=mock_details
+        )
         config_manager = ConfigManager()
         collection_name = "test_collection"
         test_data_file = "test.json"
-        
-        # Act
         result = config_manager._load_test_data(collection_name, test_data_file)
-        
-        # Assert
         self.assertEqual(result["status"], "error")
         self.assertEqual(result["operation"], "load_test_data")
         self.assertEqual(result["collection"], collection_name)
         self.assertIn("test.json", result["test_data"])
         self.assertEqual(result["error"], "Schema validation failed during test data load")
         self.assertEqual(result["details"], mock_details)
 
-    @patch('stage0_mongodb_api.managers.config_manager.MongoIO')
-    def test_load_test_data_generic_error(self, mock_mongo):
+    def test_load_test_data_generic_error(self):
         """Test that _load_test_data properly handles generic errors."""
-        # Arrange
-        mock_mongo.return_value.load_test_data.side_effect = Exception("File not found")
-        
+        self.mock_mongoio_get_instance.return_value.load_test_data.side_effect = Exception("File not found")
         config_manager = ConfigManager()
         collection_name = "test_collection"
         test_data_file = "test.json"
-        
-        # Act
         result = config_manager._load_test_data(collection_name, test_data_file)
-        
-        # Assert
         self.assertEqual(result["status"], "error")
         self.assertEqual(result["operation"], "load_test_data")
         self.assertEqual(result["collection"], collection_name)
         self.assertIn("test.json", result["test_data"])
         self.assertEqual(result["error"], "File not found")
 
-    @patch('stage0_mongodb_api.managers.config_manager.MongoIO')
-    def test_load_test_data_success(self, mock_mongo):
+    def test_load_test_data_success(self):
         """Test that _load_test_data properly handles successful loads."""
-        # Arrange
+        # Reset any previous side effects or return values
+        self.mock_mongoio_get_instance.return_value.load_test_data.reset_mock()
+        self.mock_mongoio_get_instance.return_value.load_test_data.side_effect = None
         mock_results = {
             "status": "success",
             "operation": "load_test_data",
@@ -134,16 +113,11 @@ def test_load_test_data_success(self, mock_mongo):
             "inserted_ids": ["id1", "id2", "id3", "id4", "id5"],
             "acknowledged": True
         }
-        mock_mongo.return_value.load_test_data.return_value = mock_results
-        
+        self.mock_mongoio_get_instance.return_value.load_test_data.return_value = mock_results
         config_manager = ConfigManager()
         collection_name = "test_collection"
         test_data_file = "test.json"
-        
-        # Act
         result = config_manager._load_test_data(collection_name, test_data_file)
-        
-        # Assert
         self.assertEqual(result["status"], "success")
         self.assertEqual(result["operation"], "load_test_data")
         self.assertEqual(result["collection"], collection_name)

tests/services/test_render_service.py

@@ -74,13 +74,16 @@ def test_render_openapi_not_implemented(self, mock_config_manager_class):
         # Assert
         self.assertEqual(result, expected_message)
 
+    @patch('stage0_mongodb_api.managers.schema_manager.MongoIO')
     @patch('stage0_mongodb_api.services.render_service.ConfigManager')
-    def test_render_json_schema_load_errors(self, mock_config_manager_class):
-        """Test JSON schema rendering with load errors."""
+    def test_render_json_schema_load_errors(self, mock_config_manager_class, mock_mongoio_class):
+        # This ensures that any call to MongoIO.get_instance() returns a mock
+        mock_mongoio_class.get_instance.return_value = MagicMock()
+
         # Arrange
         schema_name = "test_collection.1.0.0.1"
         load_errors = [{"error": "load_error", "message": "Failed to load config"}]
-        
+
         mock_config_manager = MagicMock()
         mock_config_manager.load_errors = load_errors
         mock_config_manager_class.return_value = mock_config_manager
@@ -92,13 +95,16 @@ def test_render_json_schema_load_errors(self, mock_config_manager_class):
         self.assertEqual(context.exception.schema_name, schema_name)
         self.assertEqual(context.exception.errors, load_errors)
 
+    @patch('stage0_mongodb_api.managers.schema_manager.MongoIO')
     @patch('stage0_mongodb_api.services.render_service.ConfigManager')
-    def test_render_bson_schema_validation_errors(self, mock_config_manager_class):
-        """Test BSON schema rendering with validation errors."""
+    def test_render_bson_schema_validation_errors(self, mock_config_manager_class, mock_mongoio_class):
+        # This ensures that any call to MongoIO.get_instance() returns a mock
+        mock_mongoio_class.get_instance.return_value = MagicMock()
+
         # Arrange
         schema_name = "test_collection.1.0.0.1"
         validation_errors = [{"error": "validation_error", "message": "Invalid schema"}]
-        
+
         mock_config_manager = MagicMock()
         mock_config_manager.load_errors = []
         mock_config_manager.validate_configs.return_value = validation_errors