fix(min-demo): decouple app import from mongo setup

Author: 1mpossible-code

data/models.py

@@ -1,15 +1,14 @@
 import os
 from enum import StrEnum
 from typing import Any
-from .db_connect import connect_db
+
 from dotenv import load_dotenv
 
+from .db_connect import connect_db
+
 load_dotenv()
 
 db_name = os.environ.get("DB_NAME", "seDB")
-client = connect_db()
-
-db = client[db_name]
 
 
 class CONTINENT_ENUM(StrEnum):
@@ -125,18 +124,38 @@ class CONTINENT_ENUM(StrEnum):
     }
 }
 
+continents_validator = {
+    "$jsonSchema": {
+        "bsonType": "object",
+        "required": ["continent_name"],
+        "additionalProperties": False,
+        "properties": {
+            "_id": {"bsonType": ["objectId", "string"]},
+            "continent_name": {"enum": [m.value for m in CONTINENT_ENUM]},
+            "created_at": {"bsonType": ["date"], "description": "Creation timestamp"},
+            "updated_at": {"bsonType": ["date"], "description": "Last update timestamp"},
+        },
+    }
+}
 
-def ensure_collection(name: str, validator: dict[str, Any]):
-    exists = name in db.list_collection_names()
+
+def get_db():
+    client = connect_db()
+    return client[db_name]
+
+
+def ensure_collection(name: str, validator: dict[str, Any], db=None):
+    database = db or get_db()
+    exists = name in database.list_collection_names()
     if not exists:
-        db.create_collection(
+        database.create_collection(
             name,
             validator=validator,
             validationAction="error",
             validationLevel="strict",
         )
     else:
-        db.command(
+        database.command(
             "collMod",
             name,
             validator=validator,
@@ -145,36 +164,30 @@ def ensure_collection(name: str, validator: dict[str, Any]):
         )
 
 
-continents_validator = {
-    "$jsonSchema": {
-        "bsonType": "object",
-        "required": ["continent_name"],
-        "additionalProperties": False,
-        "properties": {
-            "_id": {"bsonType": ["objectId", "string"]},
-            "continent_name": {"enum": [m.value for m in CONTINENT_ENUM]},
-            "created_at": {"bsonType": ["date"], "description": "Creation timestamp"},
-            "updated_at": {"bsonType": ["date"], "description": "Last update timestamp"},
-        },
-    }
-}
+def ensure_indexes(db=None):
+    database = db or get_db()
+    database.get_collection("continents").create_index(
+        "continent_name", unique=True, name="uniq_continent_name"
+    )
+    database.get_collection("countries").create_index(
+        "country_code", unique=True, name="uniq_country_code"
+    )
+    database.get_collection("states").create_index(
+        [("country_code", 1), ("state_code", 1)],
+        unique=True,
+        name="uniq_state_in_country",
+    )
+    database.get_collection("cities").create_index(
+        [("country_code", 1), ("state_code", 1), ("city_name", 1)],
+        unique=True,
+        name="uniq_city_name_in_state",
+    )
+
 
-ensure_collection("continents", continents_validator)
-ensure_collection("countries", countries_validator)
-ensure_collection("states", states_validator)
-ensure_collection("cities", cities_validator)
-
-db.get_collection("continents").create_index(
-    "continent_name", unique=True, name="uniq_continent_name"
-)
-db.get_collection("countries").create_index(
-    "country_code", unique=True, name="uniq_country_code"
-)
-db.get_collection("states").create_index(
-    [("country_code", 1), ("state_code", 1)], unique=True, name="uniq_state_in_country"
-)
-db.get_collection("cities").create_index(
-    [("country_code", 1), ("state_code", 1), ("city_name", 1)],
-    unique=True,
-    name="uniq_city_name_in_state",
-)
+def initialize_database_schema(db=None):
+    database = db or get_db()
+    ensure_collection("continents", continents_validator, db=database)
+    ensure_collection("countries", countries_validator, db=database)
+    ensure_collection("states", states_validator, db=database)
+    ensure_collection("cities", cities_validator, db=database)
+    ensure_indexes(db=database)

data/tests/test_models.py

@@ -4,10 +4,12 @@
 from data import models
 from data.models import (
     CONTINENT_ENUM,
-    countries_validator,
-    states_validator,
     cities_validator,
+    countries_validator,
     ensure_collection,
+    ensure_indexes,
+    initialize_database_schema,
+    states_validator,
 )
 
 
@@ -39,9 +41,9 @@ def mock_collection(self):
     @pytest.fixture(autouse=True)
     def setup_patches(self, mock_client, mock_db, mock_collection):
         """Set up patches for all database-related operations."""
-        with patch("data.models.connect_db", return_value=mock_client), patch(
-            "data.models.db", mock_db
-        ), patch.dict(os.environ, {"DB_NAME": "test_db"}):
+        with patch("data.models.connect_db", return_value=mock_client), patch.dict(
+            os.environ, {"DB_NAME": "test_db"}
+        ):
             mock_client.__getitem__.return_value = mock_db
             mock_db.get_collection.return_value = mock_collection
             yield
@@ -158,57 +160,46 @@ def test_ensure_collection_updates_existing_collection(self, mock_db):
             validationLevel="strict",
         )
 
-    def test_collections_are_ensured_on_import(self, mock_db):
-        """Test that collections are ensured when module is imported."""
-        # Test the ensure_collection function directly since it's called during import
-        # We can verify the function works correctly with our mocked database
-
-        # Test creating a new collection
+    def test_collections_are_initialized_explicitly(self, mock_db):
+        """Test that schema setup only happens when explicitly requested."""
         mock_db.list_collection_names.return_value = []
-        ensure_collection("test_collection", {"test": "validator"})
-        mock_db.create_collection.assert_called_with(
-            "test_collection",
-            validator={"test": "validator"},
+
+        initialize_database_schema(db=mock_db)
+
+        assert mock_db.create_collection.call_count == 4
+        mock_db.create_collection.assert_any_call(
+            "continents",
+            validator=models.continents_validator,
             validationAction="error",
             validationLevel="strict",
         )
-
-        # Test updating an existing collection
-        mock_db.reset_mock()
-        mock_db.list_collection_names.return_value = ["test_collection"]
-        ensure_collection("test_collection", {"test": "validator"})
-        mock_db.command.assert_called_with(
-            "collMod",
-            "test_collection",
-            validator={"test": "validator"},
+        mock_db.create_collection.assert_any_call(
+            "countries",
+            validator=countries_validator,
+            validationAction="error",
+            validationLevel="strict",
+        )
+        mock_db.create_collection.assert_any_call(
+            "states",
+            validator=states_validator,
+            validationAction="error",
+            validationLevel="strict",
+        )
+        mock_db.create_collection.assert_any_call(
+            "cities",
+            validator=cities_validator,
             validationAction="error",
             validationLevel="strict",
         )
-
-        # Verify that the validators are properly defined
-        assert countries_validator is not None
-        assert states_validator is not None
-        assert cities_validator is not None
 
     def test_database_indexes_creation(self, mock_db, mock_collection):
         """Test that database indexes are created properly."""
-        # Test that get_collection returns a mock collection that can create indexes
         mock_db.get_collection.return_value = mock_collection
 
-        # Test that we can get collections for each expected collection type
-        expected_collections = ["countries", "states", "cities"]
+        ensure_indexes(db=mock_db)
 
-        for collection_name in expected_collections:
-            collection = mock_db.get_collection(collection_name)
-            assert collection is not None
-            # Verify the collection can create indexes
-            collection.create_index("test_field", unique=True, name="test_index")
-            collection.create_index.assert_called_with(
-                "test_field", unique=True, name="test_index"
-            )
-
-        # Verify get_collection was called for each collection
-        assert mock_db.get_collection.call_count >= len(expected_collections)
+        assert mock_db.get_collection.call_count == 4
+        assert mock_collection.create_index.call_count == 4
 
     @pytest.mark.parametrize(
         "validator,expected_required",
@@ -277,6 +268,20 @@ def test_ensure_collection_command_error(self, mock_db):
         with pytest.raises(Exception, match="Command error"):
             ensure_collection("test_collection", {"test": "validator"})
 
+    def test_module_import_does_not_touch_database(self, mock_db):
+        """Importing the module should not trigger DB schema setup."""
+        mock_db.reset_mock()
+
+        with patch("data.models.connect_db") as mock_connect:
+            assert countries_validator is not None
+            assert states_validator is not None
+            assert cities_validator is not None
+            mock_connect.assert_not_called()
+
+        mock_db.create_collection.assert_not_called()
+        mock_db.command.assert_not_called()
+        mock_db.get_collection.assert_not_called()
+
     def test_database_name_from_environment(self):
         """Test that database name is read from environment variable."""
         # Test the logic for getting database name from environment

server/app.py

@@ -115,6 +115,24 @@ def get_health_payload() -> tuple[dict, HTTPStatus]:
     return payload, status_code
 
 
+def should_initialize_db_schema_on_startup() -> bool:
+    return os.getenv("INIT_DB_SCHEMA_ON_STARTUP", "false").lower() in {
+        "1",
+        "true",
+        "yes",
+        "on",
+    }
+
+
+def initialize_db_schema_if_enabled() -> None:
+    if not should_initialize_db_schema_on_startup():
+        return
+
+    from data.models import initialize_database_schema
+
+    initialize_database_schema()
+
+
 def register_namespaces(api: Api) -> None:
     """
     Central place to register all Flask-RESTX namespaces.
@@ -159,6 +177,8 @@ def create_app():
         description=APP_DESCRIPTION,
     )
 
+    initialize_db_schema_if_enabled()
+
     # Register API namespaces in one place
     register_namespaces(api)
 

server/endpoints.py

@@ -9,16 +9,6 @@
 import data.countries as countries_db
 import data.states as states_db
 from data.db_connect import CLOUD, LOCAL, SE_DB
-from server.app import (
-    APP_NAME,
-    get_cache_enabled,
-    get_health_payload,
-    get_recent_logs,
-    get_runtime_environment,
-    get_runtime_log_level,
-    get_runtime_port,
-    get_runtime_version,
-)
 
 # Create namespace for each resource
 general_ns = Namespace(
@@ -139,6 +129,15 @@ class DevConfig(Resource):
     """Return curated runtime configuration that is safe to expose."""
 
     def get(self):
+        from server.app import (
+            APP_NAME,
+            get_cache_enabled,
+            get_runtime_environment,
+            get_runtime_log_level,
+            get_runtime_port,
+            get_runtime_version,
+        )
+
         payload = {
             "app_name": APP_NAME,
             "environment": get_runtime_environment(),
@@ -160,6 +159,8 @@ class Health(Resource):
     """Return application and dependency health details."""
 
     def get(self):
+        from server.app import get_health_payload
+
         payload, status = get_health_payload()
         return payload, status
 
@@ -169,6 +170,8 @@ class DevLogs(Resource):
     """Return recent application logs for developers only."""
 
     def get(self):
+        from server.app import get_recent_logs
+
         if not _has_dev_logs_access():
             return {"message": "forbidden"}, HTTPStatus.FORBIDDEN
 

server/tests/test_health.py

@@ -12,6 +12,28 @@ def test_health():
         assert r.get_json() == {"status": "ok"}
 
 
+def test_create_app_does_not_initialize_db_schema_by_default(monkeypatch):
+    monkeypatch.delenv("INIT_DB_SCHEMA_ON_STARTUP", raising=False)
+
+    with patch("server.app.register_namespaces"), patch(
+        "data.models.initialize_database_schema"
+    ) as mock_initialize:
+        create_app()
+
+    mock_initialize.assert_not_called()
+
+
+def test_create_app_initializes_db_schema_when_enabled(monkeypatch):
+    monkeypatch.setenv("INIT_DB_SCHEMA_ON_STARTUP", "true")
+
+    with patch("server.app.register_namespaces"), patch(
+        "data.models.initialize_database_schema"
+    ) as mock_initialize:
+        create_app()
+
+    mock_initialize.assert_called_once_with()
+
+
 def test_structured_health_ok():
     with patch("server.app.db_connect.connect_db") as mock_connect:
         mock_client = MagicMock()