feat: add in-memory database usage with mongomock-motor

.env.sample

@@ -7,10 +7,8 @@ SECRET_KEY="1234"
 API_KEY="sk-lokumai=="
 BASE_URL="http://0.0.0.0:7860"
 
-# mongodb, mongita_memory, mongita_disk
-DB_DATABASE_TYPE=mongita_memory
-# when type is disk
-DB_MONGITA_DB_PATH="./local_dev.db" 
+# mongodb, embedded
+DB_DATABASE_TYPE=embedded
 
 DB_DATABASE_NAME=lokumai
 DB_MONGO_URI=mongodb://localhost:27017

app/config/db.py

@@ -11,9 +11,8 @@ class DBConfig(BaseSettings):
     )
 
 
-    DATABASE_TYPE: Literal["mongodb", "mongita_disk", "mongita_memory"] = "mongodb"
+    DATABASE_TYPE: str = "mongodb"
     DATABASE_NAME: str = "openai_chatbot_api"
-    MONGITA_DB_PATH: Optional[str] = None
 
     MONGO_USER: str = "root"
     MONGO_PASSWORD: str = "rootPass"

app/core/db_client.py

@@ -0,0 +1,110 @@
+from abc import ABC, abstractmethod
+from typing import Optional, Dict, Any
+from motor.motor_asyncio import AsyncIOMotorClient
+from unittest.mock import AsyncMock
+
+class DatabaseClient(ABC):
+    """Abstract base class for database clients"""
+    
+    @abstractmethod
+    async def connect(self) -> None:
+        """Connect to the database"""
+        pass
+    
+    @abstractmethod
+    async def disconnect(self) -> None:
+        """Disconnect from the database"""
+        pass
+    
+    @abstractmethod
+    async def get_database(self) -> Any:
+        """Get database instance"""
+        pass
+
+class MongoClient(DatabaseClient):
+    """Real MongoDB client implementation"""
+    
+    def __init__(self, connection_string: str):
+        self.connection_string = connection_string
+        self._client: Optional[AsyncIOMotorClient] = None
+    
+    async def connect(self) -> None:
+        self._client = AsyncIOMotorClient(self.connection_string)
+    
+    async def disconnect(self) -> None:
+        if self._client:
+            self._client.close()
+    
+    async def get_database(self) -> AsyncIOMotorClient:
+        if not self._client:
+            await self.connect()
+        return self._client
+
+class MockMongoClient(DatabaseClient):
+    """Mock MongoDB client for testing"""
+    
+    def __init__(self):
+        self._client = AsyncMock()
+    
+    async def connect(self) -> None:
+        pass
+    
+    async def disconnect(self) -> None:
+        pass
+    
+    async def get_database(self) -> AsyncMock:
+        return self._client
+
+class DatabaseClientFactory:
+    """Factory for creating database clients"""
+    
+    _instance: Optional['DatabaseClientFactory'] = None
+    _client: Optional[DatabaseClient] = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    @classmethod
+    def create_client(cls, db_type: str, connection_string: Optional[str] = None) -> DatabaseClient:
+        """
+        Create a database client based on the database type
+        
+        Args:
+            db_type: Type of database ('mongodb' or 'mock')
+            connection_string: Connection string for the database
+            
+        Returns:
+            DatabaseClient: Instance of the appropriate database client
+        """
+        if cls._client is None:
+            if db_type.lower() == 'mongodb':
+                if not connection_string:
+                    raise ValueError("Connection string is required for MongoDB")
+                cls._client = MongoClient(connection_string)
+            elif db_type.lower() == 'mock':
+                cls._client = MockMongoClient()
+            else:
+                raise ValueError(f"Unsupported database type: {db_type}")
+        
+        return cls._client
+    
+    @classmethod
+    async def get_client(cls) -> DatabaseClient:
+        """
+        Get the current database client instance
+        
+        Returns:
+            DatabaseClient: Current database client instance
+        """
+        if cls._client is None:
+            raise RuntimeError("Database client not initialized")
+        return cls._client
+    
+    @classmethod
+    async def reset_client(cls) -> None:
+        """Reset the current database client instance"""
+        if cls._client:
+            await cls._client.disconnect()
+        cls._client = None 

app/db/client.py

@@ -1,6 +1,8 @@
 # mongodb client with motor and pymongo
 
+from abc import ABC, abstractmethod
 from motor.motor_asyncio import AsyncIOMotorClient
+from mongomock_motor import AsyncMongoMockClient
 from app.config.db import db_config
 from loguru import logger
 from typing import Optional
@@ -12,37 +14,64 @@ env.read_env()
 DB_DATABASE_TYPE = env.str("DB_DATABASE_TYPE", "mongodb")
 
 
-class MongoDBClient:
-    _instance: Optional["MongoDBClient"] = None
-    _client: Optional[AsyncIOMotorClient] = None
-    _db = None
-    _is_connected: bool = False
+class DatabaseClient(ABC):
+    """Abstract base class for database clients"""
 
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-        return cls._instance
+    @abstractmethod
+    async def connect(self) -> None:
+        """Connect to the database"""
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Close the database connection"""
+        pass
+
+    @property
+    @abstractmethod
+    def client(self):
+        """Get the database client"""
+        pass
+
+    @property
+    @abstractmethod
+    def db(self):
+        """Get the database instance"""
+        pass
+
+
+class PersistentMongoClient(DatabaseClient):
+    """Real MongoDB client implementation"""
 
     def __init__(self):
-        if self._client is None:
-            self._client = AsyncIOMotorClient(db_config.get_mongo_uri())
-            self._db = self._client[db_config.DATABASE_NAME]
+        self._client: Optional[AsyncIOMotorClient] = None
+        self._db = None
+        self._is_connected: bool = False
 
     @property
     def client(self) -> AsyncIOMotorClient:
+        logger.info("Getting PersistentMongoClient")
+        if not self._client:
+            logger.info("Generating PersistentMongoClient")
+            self._client = AsyncIOMotorClient(db_config.get_mongo_uri())
+            self._db = self._client[db_config.DATABASE_NAME]
+        logger.info(f"Returning PersistentMongoClient. Host: {self._client.host}")
         return self._client
 
     @property
     def db(self):
+        logger.info("Getting PersistentMongoClient.db")
+        if not self._db:
+            logger.info("Generating PersistentMongoClient.db")
+            self._db = self.client[db_config.DATABASE_NAME]
+        logger.info(f"Returning PersistentMongoClient.db. Host: {self._db.host}")
         return self._db
 
-    async def connect(self):
+    async def connect(self) -> None:
         try:
             if not self._is_connected:
-                if self._client is None:
-                    self._client = AsyncIOMotorClient(db_config.get_mongo_uri())
-                    self._db = self._client[db_config.DATABASE_NAME]
-                await self._client.server_info()
+                logger.info("Connecting to MongoDB")
+                await self.client.server_info()
                 self._is_connected = True
                 logger.info("Connected to MongoDB")
         except Exception as e:
@@ -50,9 +79,10 @@ class MongoDBClient:
             logger.error(f"Failed to connect to MongoDB: {e}")
             raise
 
-    async def close(self):
+    async def close(self) -> None:
         try:
             if self._is_connected and self._client is not None:
+                logger.info("Closing MongoDB connection")
                 self._client.close()
                 self._client = None
                 self._db = None
@@ -65,5 +95,90 @@ class MongoDBClient:
             self._is_connected = False
 
 
+class EmbeddedMongoClient(DatabaseClient):
+    """Mock MongoDB client implementation for testing"""
+
+    def __init__(self):
+        logger.info("Initializing EmbeddedMongoClient")
+        self._client: Optional[AsyncMongoMockClient] = None
+        self._db = None
+        self._is_connected: bool = False
+        logger.info("EmbeddedMongoClient initialized")
+
+    @property
+    def client(self) -> AsyncMongoMockClient:
+        logger.info("Getting EmbeddedMongoClient")
+        if not self._client:
+            logger.info("Generating EmbeddedMongoClient")
+            self._client = AsyncMongoMockClient()
+            self._db = self._client[db_config.DATABASE_NAME]
+        logger.info(f"Returning EmbeddedMongoClient. Host: {self._client.host}")
+        return self._client
+
+    @property
+    def db(self):
+        logger.info("Getting EmbeddedMongoClient.db")
+        if not self._db:
+            logger.info("Generating EmbeddedMongoClient.db")
+            self._db = self.client[db_config.DATABASE_NAME]
+        logger.info(f"Returning EmbeddedMongoClient.db. Host: {self._db.host}")
+        return self._db
+
+    async def connect(self) -> None:
+        try:
+            if not self._is_connected:
+                logger.info("Connecting to EmbeddedMongoClient")
+                self._is_connected = True
+                logger.info("Connected to EmbeddedMongoClient")
+        except Exception as e:
+            self._is_connected = False
+            logger.error(f"Failed to connect to EmbeddedMongoClient: {e}")
+            raise
+
+    async def close(self) -> None:
+        try:
+            if self._is_connected and self._client is not None:
+                logger.info("Closing EmbeddedMongoClient connection")
+                self._client = None
+                self._db = None
+                self._is_connected = False
+                logger.info("Disconnected from EmbeddedMongoClient")
+        except Exception as e:
+            logger.warning(f"Error while closing EmbeddedMongoClient connection: {e}")
+            self._client = None
+            self._db = None
+            self._is_connected = False
+
+
+class DatabaseClientFactory:
+    """Factory class for creating database clients"""
+
+    _instance: Optional["DatabaseClientFactory"] = None
+    _client: Optional[DatabaseClient] = None
+
+    def __new__(cls):
+        logger.info("Creating DatabaseClientFactory")
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            logger.info("DatabaseClientFactory created")
+        logger.info(f"Returning DatabaseClientFactory. Host: {cls._instance.client.host}")
+        return cls._instance
+
+    @classmethod
+    def get_client(cls) -> DatabaseClient:
+        """Get the appropriate database client based on configuration"""
+        logger.info(f"Getting DatabaseClientFactory.client with DB_DATABASE_TYPE: {DB_DATABASE_TYPE}")
+        logger.info(f"mongodb uri: {db_config.get_mongo_uri()}")
+        if cls._client is None:
+            if DB_DATABASE_TYPE == "mongodb":
+                logger.info("Creating PersistentMongoClient")
+                cls._client = PersistentMongoClient()
+            else:
+                logger.info("Creating EmbeddedMongoClient")
+                cls._client = EmbeddedMongoClient()
+        logger.info(f"Returning DatabaseClientFactory.client. Host: {cls._client.client.host}")
+        return cls._client
+
+
 # Global instance
-mongodb = MongoDBClient()
+db_client = DatabaseClientFactory.get_client()

app/repository/chat_repository.py

@@ -1,11 +1,11 @@
 from typing import List
-from app.db.client import MongoDBClient
+from app.db.client import db_client
 from app.model.chat_model import ChatMessage, ChatCompletion
 
 
 class ChatRepository:
     def __init__(self):
-        self.db = MongoDBClient().db
+        self.db = db_client.db
         self.collection = "chat_completion"
 
     def save(self, entity: ChatCompletion) -> ChatCompletion:

main.py

@@ -8,7 +8,7 @@ from app.config.log import log_config
 from loguru import logger
 from environs import Env
 from contextlib import asynccontextmanager
-from app.db.client import mongodb
+from app.db.client import db_client
 from gradio_chatbot import build_gradio_app, app_auth
 import gradio as gr
 import os
@@ -33,14 +33,12 @@ async def lifespan(app: FastAPI):
     """
     # Startup
     logger.info("Starting up application...")
-    if DB_DATABASE_TYPE == "mongodb":
-        await mongodb.connect()
+    await db_client.connect()
     yield
 
     # Shutdown
     logger.info("Shutting down application...")
-    if DB_DATABASE_TYPE == "mongodb":
-        await mongodb.close()
+    await db_client.close()
 
 
 VERSION = "0.3.0"

pyproject.toml

@@ -11,6 +11,7 @@ dependencies = [
     "httpx>=0.28.1",
     "loguru>=0.7.3",
     "mongita>=1.2.0",
+    "mongomock-motor>=0.0.36",
     "motor>=3.7.1",
     "plotly>=6.1.1",
     "pydantic>=2.11.4",

uv.lock

@@ -439,6 +439,33 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/a4/b6/9159dca5e74e497b19ab8e68c369f789dc2167d2c8cccb5fbd21377ba040/mongita-1.2.0.tar.gz", hash = "sha256:27487d1deb40d83e4ecb107c3d9d732d369a83cc5f10599ba86fc024e2ce9cda", size = 54582 }
 
+[[package]]
+name = "mongomock"
+version = "4.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
+    { name = "pytz" },
+    { name = "sentinels" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4d/a4/4a560a9f2a0bec43d5f63104f55bc48666d619ca74825c8ae156b08547cf/mongomock-4.3.0.tar.gz", hash = "sha256:32667b79066fabc12d4f17f16a8fd7361b5f4435208b3ba32c226e52212a8c30", size = 135862 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/4d/8bea712978e3aff017a2ab50f262c620e9239cc36f348aae45e48d6a4786/mongomock-4.3.0-py2.py3-none-any.whl", hash = "sha256:5ef86bd12fc8806c6e7af32f21266c61b6c4ba96096f85129852d1c4fec1327e", size = 64891 },
+]
+
+[[package]]
+name = "mongomock-motor"
+version = "0.0.36"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mongomock" },
+    { name = "motor" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/18/9f/38e42a34ebad323addaf6296d6b5d83eaf2c423adf206b757c68315e196a/mongomock_motor-0.0.36.tar.gz", hash = "sha256:3cf62352ece5af2f02e04d2f252393f88b5fe0487997da00584020cee4b8efba", size = 5754 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d6/99/f5fdbbdc96bfd03e5f9c36339547a9076f5dbb5882900b7621526d41a38d/mongomock_motor-0.0.36-py3-none-any.whl", hash = "sha256:3ecb7949662b8986ff9c267fa0b1402b5b75a6afd57f03850cd6e13a067e3691", size = 7334 },
+]
+
 [[package]]
 name = "motor"
 version = "3.7.1"
@@ -509,6 +536,7 @@ dependencies = [
     { name = "httpx" },
     { name = "loguru" },
     { name = "mongita" },
+    { name = "mongomock-motor" },
     { name = "motor" },
     { name = "plotly" },
     { name = "pydantic" },
@@ -526,6 +554,7 @@ requires-dist = [
     { name = "httpx", specifier = ">=0.28.1" },
     { name = "loguru", specifier = ">=0.7.3" },
     { name = "mongita", specifier = ">=1.2.0" },
+    { name = "mongomock-motor", specifier = ">=0.0.36" },
     { name = "motor", specifier = ">=3.7.1" },
     { name = "plotly", specifier = ">=6.1.1" },
     { name = "pydantic", specifier = ">=2.11.4" },
@@ -936,6 +965,12 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6a/23/8146aad7d88f4fcb3a6218f41a60f6c2d4e3a72de72da1825dc7c8f7877c/semantic_version-2.10.0-py2.py3-none-any.whl", hash = "sha256:de78a3b8e0feda74cabc54aab2da702113e33ac9d9eb9d2389bcf1f58b7d9177", size = 15552 },
 ]
 
+[[package]]
+name = "sentinels"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ac/b7/1af07a98390aba07da31807f3723e7bbd003d6441b4b3d67b20d97702b23/sentinels-1.0.0.tar.gz", hash = "sha256:7be0704d7fe1925e397e92d18669ace2f619c92b5d4eb21a89f31e026f9ff4b1", size = 4074 }
+
 [[package]]
 name = "shellingham"
 version = "1.5.4"