Update db logic and behavior in development environment

src/database/__init__.py

@@ -1,11 +1,9 @@
 from .crud import create_vote
 from .database import Base, SessionLocal, engine
-from .models import VoteResult
 
 __all__ = [
     "Base",
     "SessionLocal",
-    "VoteResult",
     "create_vote",
     "engine"
 ]

src/database/database.py

@@ -4,23 +4,70 @@ database.py
 This module sets up the SQLAlchemy database connection for the Expressive TTS Arena project.
 It initializes the PostgreSQL engine, creates a session factory for handling database transactions,
 and defines a declarative base class for ORM models.
+
+If no DATABASE_URL environment variable is set, then create a dummy database to fail gracefully
 """
 
+# Standard Library Imports
+import os
+
 # Third-Party Library Imports
 from sqlalchemy import create_engine
 from sqlalchemy.orm import declarative_base, sessionmaker
 
 # Local Application Imports
-from src.config import validate_env_var
+from src.config import APP_ENV
+
+DATABASE_URL = os.getenv("DATABASE_URL")
+
+if APP_ENV == "prod":
+    # In production, a valid DATABASE_URL is required.
+    if not DATABASE_URL:
+        raise ValueError("DATABASE_URL must be set in production!")
+
+    engine = create_engine(DATABASE_URL)
+    SessionLocal = sessionmaker(bind=engine)
+# In development, if a DATABASE_URL is provided, use it.
+elif DATABASE_URL:
+    engine = create_engine(DATABASE_URL)
+    SessionLocal = sessionmaker(bind=engine)
+else:
+    # No DATABASE_URL is provided; use a DummySession that does nothing.
+    engine = None
+
+    class DummySession:
+        is_dummy = True  # Flag to indicate this is a dummy session.
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc_value, traceback):
+            pass
+
+        def add(self, _instance, _warn=True):
+            # No-op: simply ignore adding the instance.
+            pass
+
+        def commit(self):
+            # Raise an exception to simulate failure when attempting a write.
+            raise RuntimeError("DummySession does not support commit operations.")
+
+        def refresh(self, _instance):
+            # Raise an exception to simulate failure when attempting to refresh.
+            raise RuntimeError("DummySession does not support refresh operations.")
+
+        def rollback(self):
+            # No-op: there's nothing to roll back.
+            pass
 
-# Validate and retrieve the database URL from environment variables
-DATABASE_URL = validate_env_var("DATABASE_URL")
+        def close(self):
+            # No-op: nothing to close.
+            pass
 
-# Create the database engine using the validated URL
-engine = create_engine(DATABASE_URL)
+    def dummy_session_factory():
+        return DummySession()
 
-# Create a session factory for database transactions
-SessionLocal = sessionmaker(bind=engine)
+    SessionLocal = dummy_session_factory
 
-# Declarative base class for ORM models
+# Declarative base class for ORM models.
 Base = declarative_base()

src/utils.py

@@ -15,7 +15,7 @@ from typing import Tuple
 
 # Local Application Imports
 from src import constants
-from src.config import AUDIO_DIR, logger
+from src.config import APP_ENV, AUDIO_DIR, logger
 from src.custom_types import (
     ComparisonType,
     Option,
@@ -24,7 +24,7 @@ from src.custom_types import (
     TTSProviderName,
     VotingResults,
 )
-from src.database import SessionLocal, VoteResult, crud
+from src.database import SessionLocal, crud
 
 
 def truncate_text(text: str, max_length: int = 50) -> str:
@@ -306,13 +306,39 @@ def determine_comparison_type(
     raise ValueError(f"Invalid provider combination: {provider_a}, {provider_b}")
 
 
+def log_voting_results(voting_results: VotingResults) -> None:
+    """Log the full voting results."""
+    logger.info("Voting results:\n%s", json.dumps(voting_results, indent=4))
+
+
+def handle_vote_failure(e: Exception, voting_results: VotingResults, is_dummy_db_session: bool) -> None:
+    """
+    Handles logging when creating a vote record fails.
+
+    In production (or in dev with a real session):
+      - Logs the error (with full traceback in prod) and the voting results.
+      - In production, re-raises the exception.
+
+    In development with a dummy session:
+      - Only logs the voting results.
+    """
+    if APP_ENV == "prod" or (APP_ENV == "dev" and not is_dummy_db_session):
+        logger.error("Failed to create vote record: %s", e, exc_info=(APP_ENV == "prod"))
+        log_voting_results(voting_results)
+        if APP_ENV == "prod":
+            raise e
+    else:
+        # Dev mode with a dummy session: only log the voting results.
+        log_voting_results(voting_results)
+
+
 def submit_voting_results(
     option_map: OptionMap,
     selected_option: str,
     text_modified: bool,
     character_description: str,
     text: str,
-) -> VoteResult:
+) -> None:
     """
     Constructs the voting results dictionary from the provided inputs,
     logs it, persists a new vote record in the database, and returns the record.
@@ -323,9 +349,6 @@ def submit_voting_results(
         text_modified (bool): Indicates whether the text was modified.
         character_description (str): Description of the voice/character.
         text (str): The text associated with the TTS generation.
-
-    Returns:
-        VoteResult: The newly created vote record from the database.
     """
     provider_a: TTSProviderName = option_map[constants.OPTION_A_KEY]["provider"]
     provider_b: TTSProviderName = option_map[constants.OPTION_B_KEY]["provider"]
@@ -344,14 +367,17 @@ def submit_voting_results(
         "is_custom_text": text_modified,
     }
 
-    logger.info("Voting results:\n%s", json.dumps(voting_results, indent=4))
-
-    # Create a new database session, persist the vote record, and then close the session.
     db = SessionLocal()
+    is_dummy_db_session = getattr(db, "is_dummy", False)
     try:
-        vote_record = crud.create_vote(db, voting_results)
-        logger.info("Vote record created successfully")
+        crud.create_vote(db, voting_results)
+    except Exception as e:
+        handle_vote_failure(e, voting_results, is_dummy_db_session)
+    else:
+        logger.info("Vote record created successfully.")
+        if APP_ENV == "dev":
+            log_voting_results(voting_results)
     finally:
         db.close()
 
-    return vote_record
+