Add MongoDB test scripts and documentation (no credentials exposed)

MONGODB_DATA_STRUCTURE.md

@@ -0,0 +1,197 @@
+# MongoDB Data Storage Structure
+
+This document describes exactly what data is stored in MongoDB when you use the Image Colorization API.
+
+## Database: `colorization_db`
+
+### Collection 1: `api_calls`
+
+Stores every API endpoint call with timestamp.
+
+**Data Structure:**
+```json
+{
+    "_id": ObjectId("..."),                    // MongoDB auto-generated ID
+    "endpoint": "/health",                      // API endpoint path
+    "method": "GET",                            // HTTP method (GET, POST)
+    "status_code": 200,                        // HTTP status code
+    "timestamp": ISODate("2025-11-27T04:22:27.823Z"),  // UTC timestamp when API was called
+    "request_data": {                          // Request parameters/data
+        "filename": "Descratch.png",
+        "content_type": "image/png"
+    },
+    "response_data": {                         // Response data returned
+        "status": "healthy",
+        "model_loaded": true
+    },
+    "error": null,                             // Error message if any
+    "user_id": null,                           // User ID if authenticated
+    "ip_address": "127.0.0.1"                 // Client IP address
+}
+```
+
+**Example for `/upload` endpoint:**
+```json
+{
+    "endpoint": "/upload",
+    "method": "POST",
+    "status_code": 200,
+    "timestamp": ISODate("2025-11-27T10:00:00.000Z"),
+    "request_data": {
+        "filename": "Descratch.png",
+        "content_type": "image/png"
+    },
+    "response_data": {
+        "success": true,
+        "image_id": "abc123-def456-ghi789",
+        "image_url": "https://.../uploads/abc123.jpg",
+        "filename": "abc123.jpg"
+    },
+    "error": null,
+    "user_id": null,
+    "ip_address": "192.168.1.100"
+}
+```
+
+**Example for `/colorize` endpoint:**
+```json
+{
+    "endpoint": "/colorize",
+    "method": "POST",
+    "status_code": 200,
+    "timestamp": ISODate("2025-11-27T10:00:05.000Z"),
+    "request_data": {
+        "filename": "Descratch.png",
+        "content_type": "image/png",
+        "positive_prompt": "colorize this image",
+        "negative_prompt": "low quality",
+        "seed": 123,
+        "num_inference_steps": 8
+    },
+    "response_data": {
+        "success": true,
+        "result_id": "xyz789-abc123-def456",
+        "download_url": "https://.../results/xyz789.png",
+        "api_download_url": "https://.../download/xyz789",
+        "filename": "xyz789.png",
+        "caption": "colorized image"
+    },
+    "error": null,
+    "user_id": null,
+    "ip_address": "192.168.1.100"
+}
+```
+
+---
+
+### Collection 2: `image_uploads`
+
+Stores information about every image upload.
+
+**Data Structure:**
+```json
+{
+    "_id": ObjectId("..."),                    // MongoDB auto-generated ID
+    "image_id": "abc123-def456-ghi789",        // Unique image identifier (UUID)
+    "filename": "Descratch.png",               // Original filename
+    "file_size": 245678,                       // File size in bytes
+    "content_type": "image/png",               // MIME type
+    "uploaded_at": ISODate("2025-11-27T10:00:00.000Z"),  // UTC timestamp
+    "user_id": null,                           // User ID if authenticated
+    "ip_address": "192.168.1.100"              // Client IP address
+}
+```
+
+**Example with Descratch.png:**
+```json
+{
+    "image_id": "abc123-def456-ghi789",
+    "filename": "Descratch.png",
+    "file_size": 245678,
+    "content_type": "image/png",
+    "uploaded_at": ISODate("2025-11-27T10:00:00.000Z"),
+    "user_id": null,
+    "ip_address": "192.168.1.100"
+}
+```
+
+---
+
+### Collection 3: `colorizations`
+
+Stores information about every colorization request.
+
+**Data Structure:**
+```json
+{
+    "_id": ObjectId("..."),                    // MongoDB auto-generated ID
+    "result_id": "xyz789-abc123-def456",       // Unique result identifier (UUID)
+    "image_id": "abc123-def456-ghi789",        // Original image identifier
+    "prompt": "colorize this image",           // Text prompt used (if any)
+    "model_type": "sdxl",                      // Model type: "fastai", "pytorch", "sdxl", "gan"
+    "processing_time": 3.45,                  // Time taken to process in seconds
+    "created_at": ISODate("2025-11-27T10:00:05.000Z"),  // UTC timestamp
+    "user_id": null,                           // User ID if authenticated
+    "ip_address": "192.168.1.100"              // Client IP address
+}
+```
+
+**Example with Descratch.png:**
+```json
+{
+    "result_id": "xyz789-abc123-def456",
+    "image_id": "abc123-def456-ghi789",
+    "prompt": "colorize this image with vibrant natural colors",
+    "model_type": "sdxl",
+    "processing_time": 3.45,
+    "created_at": ISODate("2025-11-27T10:00:05.000Z"),
+    "user_id": null,
+    "ip_address": "192.168.1.100"
+}
+```
+
+---
+
+## What Gets Stored When You Use Descratch.png
+
+When you upload and colorize `Descratch.png`, the following data will be stored:
+
+1. **API Call Logs** (`api_calls` collection):
+   - `/health` - Health check call
+   - `/upload` - Image upload call with request/response data
+   - `/colorize` - Colorization call with processing parameters
+   - `/download` - Download result call (if you download the result)
+   - `/results` - Public result access call (if accessed)
+
+2. **Image Upload Record** (`image_uploads` collection):
+   - Image ID (UUID)
+   - Filename: "Descratch.png"
+   - File size in bytes
+   - Content type: "image/png"
+   - Upload timestamp
+   - IP address
+
+3. **Colorization Record** (`colorizations` collection):
+   - Result ID (UUID)
+   - Image ID reference
+   - Model type used
+   - Processing time
+   - Creation timestamp
+   - IP address
+
+## All Data Includes Timestamps
+
+Every record includes a UTC timestamp:
+- `api_calls.timestamp` - When the API endpoint was called
+- `image_uploads.uploaded_at` - When the image was uploaded
+- `colorizations.created_at` - When the colorization was created
+
+## Querying the Data
+
+You can query MongoDB to:
+- Find all API calls in the last 24 hours
+- Track which images were uploaded
+- Monitor colorization processing times
+- Analyze API usage patterns
+- Track errors and status codes
+

show_stored_data.py

@@ -0,0 +1,178 @@
+"""
+Show what data is stored in MongoDB collections
+"""
+import os
+import sys
+import json
+import logging
+from datetime import datetime, timedelta
+from pymongo import MongoClient
+from pymongo.errors import ConnectionFailure, ServerSelectionTimeoutError
+from bson import ObjectId
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+class JSONEncoder(json.JSONEncoder):
+    """Custom JSON encoder for MongoDB documents"""
+    def default(self, obj):
+        if isinstance(obj, ObjectId):
+            return str(obj)
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        return super().default(obj)
+
+
+def show_stored_data():
+    """Show all data stored in MongoDB collections"""
+    mongodb_uri = os.getenv("MONGODB_URI")
+    if not mongodb_uri:
+        logger.error("❌ MONGODB_URI environment variable not set!")
+        return False
+    
+    db_name = os.getenv("MONGODB_DB_NAME", "colorization_db")
+    
+    try:
+        client = MongoClient(mongodb_uri, serverSelectionTimeoutMS=5000)
+        client.admin.command('ping')
+        logger.info("✅ Connected to MongoDB\n")
+        
+        db = client[db_name]
+        
+        # Collection 1: api_calls
+        logger.info("=" * 80)
+        logger.info("COLLECTION 1: api_calls")
+        logger.info("=" * 80)
+        logger.info("\n📋 Data Structure:")
+        logger.info("""
+{
+    "_id": ObjectId,                    # MongoDB auto-generated ID
+    "endpoint": str,                     # API endpoint path (e.g., "/health", "/colorize")
+    "method": str,                       # HTTP method ("GET", "POST", etc.)
+    "status_code": int,                  # HTTP status code (200, 400, 500, etc.)
+    "timestamp": datetime,               # UTC timestamp when API was called
+    "request_data": dict,                # Request parameters/data
+    "response_data": dict,               # Response data returned
+    "error": str or None,                # Error message if any
+    "user_id": str or None,             # User ID if authenticated
+    "ip_address": str or None            # Client IP address
+}
+        """)
+        
+        api_calls = db["api_calls"]
+        total = api_calls.count_documents({})
+        logger.info(f"\n📊 Total documents: {total}")
+        
+        if total > 0:
+            logger.info("\n📄 Sample Documents:")
+            samples = list(api_calls.find().sort("timestamp", -1).limit(3))
+            for i, doc in enumerate(samples, 1):
+                logger.info(f"\n   Document {i}:")
+                logger.info(f"   {json.dumps(doc, cls=JSONEncoder, indent=4)}")
+        
+        # Collection 2: image_uploads
+        logger.info("\n" + "=" * 80)
+        logger.info("COLLECTION 2: image_uploads")
+        logger.info("=" * 80)
+        logger.info("\n📋 Data Structure:")
+        logger.info("""
+{
+    "_id": ObjectId,                    # MongoDB auto-generated ID
+    "image_id": str,                    # Unique image identifier (UUID)
+    "filename": str,                     # Original filename
+    "file_size": int,                    # File size in bytes
+    "content_type": str,                 # MIME type (e.g., "image/jpeg")
+    "uploaded_at": datetime,             # UTC timestamp when image was uploaded
+    "user_id": str or None,             # User ID if authenticated
+    "ip_address": str or None            # Client IP address
+}
+        """)
+        
+        image_uploads = db["image_uploads"]
+        total = image_uploads.count_documents({})
+        logger.info(f"\n📊 Total documents: {total}")
+        
+        if total > 0:
+            logger.info("\n📄 Sample Documents:")
+            samples = list(image_uploads.find().sort("uploaded_at", -1).limit(3))
+            for i, doc in enumerate(samples, 1):
+                logger.info(f"\n   Document {i}:")
+                logger.info(f"   {json.dumps(doc, cls=JSONEncoder, indent=4)}")
+        
+        # Collection 3: colorizations
+        logger.info("\n" + "=" * 80)
+        logger.info("COLLECTION 3: colorizations")
+        logger.info("=" * 80)
+        logger.info("\n📋 Data Structure:")
+        logger.info("""
+{
+    "_id": ObjectId,                    # MongoDB auto-generated ID
+    "result_id": str,                    # Unique result identifier (UUID)
+    "image_id": str or None,             # Original image identifier
+    "prompt": str or None,               # Text prompt used (if any)
+    "model_type": str or None,           # Model type ("fastai", "pytorch", "sdxl", "gan")
+    "processing_time": float or None,    # Time taken to process in seconds
+    "created_at": datetime,               # UTC timestamp when colorization was created
+    "user_id": str or None,              # User ID if authenticated
+    "ip_address": str or None            # Client IP address
+}
+        """)
+        
+        colorizations = db["colorizations"]
+        total = colorizations.count_documents({})
+        logger.info(f"\n📊 Total documents: {total}")
+        
+        if total > 0:
+            logger.info("\n📄 Sample Documents:")
+            samples = list(colorizations.find().sort("created_at", -1).limit(3))
+            for i, doc in enumerate(samples, 1):
+                logger.info(f"\n   Document {i}:")
+                logger.info(f"   {json.dumps(doc, cls=JSONEncoder, indent=4)}")
+        
+        # Summary
+        logger.info("\n" + "=" * 80)
+        logger.info("SUMMARY")
+        logger.info("=" * 80)
+        logger.info(f"\nDatabase: {db_name}")
+        logger.info(f"Total API calls logged: {api_calls.count_documents({})}")
+        logger.info(f"Total image uploads logged: {image_uploads.count_documents({})}")
+        logger.info(f"Total colorizations logged: {colorizations.count_documents({})}")
+        
+        # Recent activity (last 24 hours)
+        recent_api = api_calls.count_documents({
+            "timestamp": {"$gte": datetime.utcnow() - timedelta(hours=24)}
+        })
+        recent_uploads = image_uploads.count_documents({
+            "uploaded_at": {"$gte": datetime.utcnow() - timedelta(hours=24)}
+        })
+        recent_colorizations = colorizations.count_documents({
+            "created_at": {"$gte": datetime.utcnow() - timedelta(hours=24)}
+        })
+        
+        logger.info(f"\n📈 Activity in last 24 hours:")
+        logger.info(f"   API calls: {recent_api}")
+        logger.info(f"   Image uploads: {recent_uploads}")
+        logger.info(f"   Colorizations: {recent_colorizations}")
+        
+        client.close()
+        return True
+        
+    except (ConnectionFailure, ServerSelectionTimeoutError) as e:
+        logger.error(f"❌ Failed to connect to MongoDB: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    success = show_stored_data()
+    sys.exit(0 if success else 1)
+

test_api_mongodb.py

@@ -0,0 +1,128 @@
+"""
+Test script to make API calls and verify MongoDB storage
+This script makes a simple health check API call and verifies it's stored in MongoDB
+"""
+import os
+import sys
+import time
+import logging
+import requests
+from datetime import datetime, timedelta
+from pymongo import MongoClient
+from pymongo.errors import ConnectionFailure, ServerSelectionTimeoutError
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def test_api_and_mongodb(base_url: str = "http://localhost:7860", mongodb_uri: str = None):
+    """Make API calls and verify they're stored in MongoDB"""
+    
+    if not mongodb_uri:
+        mongodb_uri = os.getenv("MONGODB_URI")
+        if not mongodb_uri:
+            logger.error("❌ MONGODB_URI not provided!")
+            return False
+    
+    db_name = os.getenv("MONGODB_DB_NAME", "colorization_db")
+    
+    logger.info("=" * 60)
+    logger.info("Testing API calls and MongoDB storage")
+    logger.info("=" * 60)
+    
+    # Step 1: Make a health check API call
+    logger.info(f"\n1. Making health check API call to {base_url}/health")
+    try:
+        response = requests.get(f"{base_url}/health", timeout=10)
+        logger.info(f"   Status Code: {response.status_code}")
+        if response.ok:
+            logger.info(f"   Response: {response.json()}")
+        else:
+            logger.warning(f"   API returned error: {response.text}")
+    except requests.exceptions.RequestException as e:
+        logger.error(f"   ❌ Failed to connect to API: {e}")
+        logger.info("   Note: Make sure the API server is running")
+        logger.info("   You can start it with: uvicorn app.main_sdxl:app --reload")
+        return False
+    
+    # Step 2: Wait a bit for MongoDB write
+    logger.info("\n2. Waiting 3 seconds for MongoDB write to complete...")
+    time.sleep(3)
+    
+    # Step 3: Verify MongoDB storage
+    logger.info("\n3. Verifying MongoDB storage...")
+    try:
+        client = MongoClient(mongodb_uri, serverSelectionTimeoutMS=5000)
+        client.admin.command('ping')
+        logger.info("   ✅ Connected to MongoDB")
+        
+        db = client[db_name]
+        
+        # Check api_calls collection
+        api_calls = db["api_calls"]
+        
+        # Count total calls
+        total_calls = api_calls.count_documents({})
+        logger.info(f"   Total API calls in database: {total_calls}")
+        
+        # Check recent calls (last 5 minutes)
+        recent_calls = list(api_calls.find({
+            "timestamp": {"$gte": datetime.utcnow() - timedelta(minutes=5)}
+        }).sort("timestamp", -1).limit(10))
+        
+        logger.info(f"   Recent API calls (last 5 minutes): {len(recent_calls)}")
+        
+        if recent_calls:
+            logger.info("\n   Recent API call details:")
+            for call in recent_calls[:5]:
+                logger.info(f"      - {call.get('method')} {call.get('endpoint')}")
+                logger.info(f"        Status: {call.get('status_code')}")
+                logger.info(f"        Timestamp: {call.get('timestamp')}")
+                logger.info(f"        IP: {call.get('ip_address')}")
+                logger.info("")
+            
+            logger.info("   ✅ MongoDB storage verification PASSED!")
+            logger.info("   ✅ API calls are being stored in MongoDB with timestamps!")
+            client.close()
+            return True
+        else:
+            logger.warning("   ⚠️ No recent API calls found in MongoDB")
+            logger.info("   This might mean:")
+            logger.info("     1. The API server is not logging to MongoDB")
+            logger.info("     2. MONGODB_URI is not set in the API server environment")
+            logger.info("     3. The write hasn't completed yet (try waiting longer)")
+            client.close()
+            return False
+            
+    except (ConnectionFailure, ServerSelectionTimeoutError) as e:
+        logger.error(f"   ❌ Failed to connect to MongoDB: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"   ❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Test API calls and MongoDB storage")
+    parser.add_argument("--base-url", type=str, default="http://localhost:7860",
+                       help="API base URL (default: http://localhost:7860)")
+    parser.add_argument("--mongodb-uri", type=str, default=os.getenv("MONGODB_URI", ""),
+                       help="MongoDB connection string")
+    
+    args = parser.parse_args()
+    
+    if not args.mongodb_uri:
+        logger.error("MongoDB URI required! Set MONGODB_URI environment variable or use --mongodb-uri")
+        sys.exit(1)
+    
+    success = test_api_and_mongodb(args.base_url, args.mongodb_uri)
+    sys.exit(0 if success else 1)
+

test_mongodb.py

@@ -0,0 +1,105 @@
+"""
+Simple MongoDB verification test script
+This script tests if data is being stored in MongoDB after API calls.
+"""
+import os
+import sys
+import logging
+from datetime import datetime, timedelta
+from pymongo import MongoClient
+from pymongo.errors import ConnectionFailure, ServerSelectionTimeoutError
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def test_mongodb_connection():
+    """Test MongoDB connection and verify collections exist"""
+    mongodb_uri = os.getenv("MONGODB_URI")
+    if not mongodb_uri:
+        logger.error("❌ MONGODB_URI environment variable not set!")
+        logger.info("Please set MONGODB_URI environment variable")
+        return False
+    
+    db_name = os.getenv("MONGODB_DB_NAME", "colorization_db")
+    
+    try:
+        logger.info("Connecting to MongoDB...")
+        client = MongoClient(mongodb_uri, serverSelectionTimeoutMS=5000)
+        
+        # Test connection
+        client.admin.command('ping')
+        logger.info("✅ Connected to MongoDB successfully!")
+        
+        db = client[db_name]
+        logger.info(f"Using database: {db_name}")
+        
+        # List all collections
+        collections = db.list_collection_names()
+        logger.info(f"Collections found: {collections}")
+        
+        # Check each collection
+        collections_to_check = ["api_calls", "image_uploads", "colorizations"]
+        
+        for collection_name in collections_to_check:
+            collection = db[collection_name]
+            total_count = collection.count_documents({})
+            recent_count = collection.count_documents({
+                "timestamp" if collection_name == "api_calls" else 
+                ("uploaded_at" if collection_name == "image_uploads" else "created_at"): {
+                    "$gte": datetime.utcnow() - timedelta(hours=24)
+                }
+            })
+            
+            logger.info(f"\n📊 Collection: {collection_name}")
+            logger.info(f"   Total documents: {total_count}")
+            logger.info(f"   Documents in last 24 hours: {recent_count}")
+            
+            # Show sample document
+            sample = collection.find_one(sort=[("_id", -1)])
+            if sample:
+                logger.info(f"   Latest document ID: {sample.get('_id')}")
+                if collection_name == "api_calls":
+                    logger.info(f"   Latest endpoint: {sample.get('endpoint')} at {sample.get('timestamp')}")
+                elif collection_name == "image_uploads":
+                    logger.info(f"   Latest image: {sample.get('image_id')} at {sample.get('uploaded_at')}")
+                elif collection_name == "colorizations":
+                    logger.info(f"   Latest result: {sample.get('result_id')} at {sample.get('created_at')}")
+        
+        # Show recent API calls
+        api_calls = db["api_calls"]
+        recent_calls = list(api_calls.find({
+            "timestamp": {"$gte": datetime.utcnow() - timedelta(minutes=30)}
+        }).sort("timestamp", -1).limit(10))
+        
+        if recent_calls:
+            logger.info("\n📝 Recent API calls (last 30 minutes):")
+            for call in recent_calls:
+                logger.info(f"   {call.get('method')} {call.get('endpoint')} - "
+                          f"Status: {call.get('status_code')} - "
+                          f"Time: {call.get('timestamp')}")
+        else:
+            logger.info("\n📝 No API calls in the last 30 minutes")
+        
+        client.close()
+        logger.info("\n✅ MongoDB test completed successfully!")
+        return True
+        
+    except (ConnectionFailure, ServerSelectionTimeoutError) as e:
+        logger.error(f"❌ Failed to connect to MongoDB: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    success = test_mongodb_connection()
+    sys.exit(0 if success else 1)
+

test_mongodb_direct.py

@@ -0,0 +1,168 @@
+"""
+Direct MongoDB test - Insert test data and verify storage
+This test directly writes to MongoDB to verify the connection and storage works
+"""
+import os
+import sys
+import logging
+from datetime import datetime
+from pymongo import MongoClient
+from pymongo.errors import ConnectionFailure, ServerSelectionTimeoutError
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def test_mongodb_direct():
+    """Test MongoDB by directly inserting test data"""
+    mongodb_uri = os.getenv("MONGODB_URI")
+    if not mongodb_uri:
+        logger.error("❌ MONGODB_URI environment variable not set!")
+        logger.info("Set it with: $env:MONGODB_URI='your_connection_string'")
+        return False
+    
+    db_name = os.getenv("MONGODB_DB_NAME", "colorization_db")
+    
+    logger.info("=" * 60)
+    logger.info("Direct MongoDB Storage Test")
+    logger.info("=" * 60)
+    
+    try:
+        # Connect to MongoDB
+        logger.info("\n1. Connecting to MongoDB...")
+        client = MongoClient(mongodb_uri, serverSelectionTimeoutMS=10000)
+        client.admin.command('ping')
+        logger.info("   ✅ Connected successfully!")
+        
+        db = client[db_name]
+        logger.info(f"   Using database: {db_name}")
+        
+        # Test 1: Insert into api_calls collection
+        logger.info("\n2. Testing api_calls collection...")
+        api_calls = db["api_calls"]
+        
+        test_api_call = {
+            "endpoint": "/health",
+            "method": "GET",
+            "status_code": 200,
+            "timestamp": datetime.utcnow(),
+            "request_data": {},
+            "response_data": {"status": "healthy", "model_loaded": True},
+            "error": None,
+            "user_id": None,
+            "ip_address": "127.0.0.1",
+            "test": True  # Mark as test data
+        }
+        
+        result = api_calls.insert_one(test_api_call)
+        logger.info(f"   ✅ Inserted test API call with ID: {result.inserted_id}")
+        
+        # Verify it was stored
+        stored = api_calls.find_one({"_id": result.inserted_id})
+        if stored:
+            logger.info(f"   ✅ Verified: API call stored successfully")
+            logger.info(f"      Endpoint: {stored.get('endpoint')}")
+            logger.info(f"      Timestamp: {stored.get('timestamp')}")
+        else:
+            logger.error("   ❌ Failed to retrieve stored document")
+            return False
+        
+        # Test 2: Insert into image_uploads collection
+        logger.info("\n3. Testing image_uploads collection...")
+        image_uploads = db["image_uploads"]
+        
+        test_upload = {
+            "image_id": "test-image-123",
+            "filename": "test_image.jpg",
+            "file_size": 102400,
+            "content_type": "image/jpeg",
+            "uploaded_at": datetime.utcnow(),
+            "user_id": None,
+            "ip_address": "127.0.0.1",
+            "test": True
+        }
+        
+        result = image_uploads.insert_one(test_upload)
+        logger.info(f"   ✅ Inserted test upload with ID: {result.inserted_id}")
+        
+        stored = image_uploads.find_one({"_id": result.inserted_id})
+        if stored:
+            logger.info(f"   ✅ Verified: Image upload stored successfully")
+            logger.info(f"      Image ID: {stored.get('image_id')}")
+            logger.info(f"      Uploaded at: {stored.get('uploaded_at')}")
+        
+        # Test 3: Insert into colorizations collection
+        logger.info("\n4. Testing colorizations collection...")
+        colorizations = db["colorizations"]
+        
+        test_colorization = {
+            "result_id": "test-result-456",
+            "image_id": "test-image-123",
+            "prompt": "Test colorization",
+            "model_type": "test",
+            "processing_time": 1.23,
+            "created_at": datetime.utcnow(),
+            "user_id": None,
+            "ip_address": "127.0.0.1",
+            "test": True
+        }
+        
+        result = colorizations.insert_one(test_colorization)
+        logger.info(f"   ✅ Inserted test colorization with ID: {result.inserted_id}")
+        
+        stored = colorizations.find_one({"_id": result.inserted_id})
+        if stored:
+            logger.info(f"   ✅ Verified: Colorization stored successfully")
+            logger.info(f"      Result ID: {stored.get('result_id')}")
+            logger.info(f"      Created at: {stored.get('created_at')}")
+        
+        # Summary
+        logger.info("\n" + "=" * 60)
+        logger.info("Test Summary")
+        logger.info("=" * 60)
+        
+        total_api_calls = api_calls.count_documents({})
+        total_uploads = image_uploads.count_documents({})
+        total_colorizations = colorizations.count_documents({})
+        
+        logger.info(f"Total documents in api_calls: {total_api_calls}")
+        logger.info(f"Total documents in image_uploads: {total_uploads}")
+        logger.info(f"Total documents in colorizations: {total_colorizations}")
+        
+        logger.info("\n✅ All MongoDB storage tests PASSED!")
+        logger.info("✅ Collections are created automatically")
+        logger.info("✅ Data is being stored with timestamps")
+        logger.info("✅ MongoDB integration is working correctly!")
+        
+        # Optional: Clean up test data
+        logger.info("\n5. Cleaning up test data...")
+        api_calls.delete_many({"test": True})
+        image_uploads.delete_many({"test": True})
+        colorizations.delete_many({"test": True})
+        logger.info("   ✅ Test data cleaned up")
+        
+        client.close()
+        return True
+        
+    except (ConnectionFailure, ServerSelectionTimeoutError) as e:
+        logger.error(f"❌ Failed to connect to MongoDB: {e}")
+        logger.info("\nTroubleshooting:")
+        logger.info("1. Check your MongoDB connection string")
+        logger.info("2. Verify network connectivity")
+        logger.info("3. Check if MongoDB allows connections from your IP")
+        return False
+    except Exception as e:
+        logger.error(f"❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    success = test_mongodb_direct()
+    sys.exit(0 if success else 1)
+

test_with_image.py

@@ -0,0 +1,208 @@
+"""
+Test script to test API with Descratch.png image and verify MongoDB storage
+"""
+import os
+import sys
+import time
+import logging
+import requests
+from datetime import datetime, timedelta
+from pymongo import MongoClient
+from pymongo.errors import ConnectionFailure, ServerSelectionTimeoutError
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def test_api_with_image_and_mongodb(image_path: str, base_url: str = "http://localhost:7860", 
+                                    mongodb_uri: str = None, app_check_token: str = None):
+    """Test API with image and verify MongoDB storage"""
+    
+    if not mongodb_uri:
+        mongodb_uri = os.getenv("MONGODB_URI")
+        if not mongodb_uri:
+            logger.error("❌ MONGODB_URI not provided!")
+            return False
+    
+    if not os.path.exists(image_path):
+        logger.error(f"❌ Image not found: {image_path}")
+        return False
+    
+    db_name = os.getenv("MONGODB_DB_NAME", "colorization_db")
+    
+    logger.info("=" * 80)
+    logger.info("Testing API with Image and MongoDB Storage")
+    logger.info("=" * 80)
+    logger.info(f"Image: {image_path}")
+    logger.info(f"API URL: {base_url}")
+    logger.info(f"Database: {db_name}\n")
+    
+    # Step 1: Health check
+    logger.info("1. Testing /health endpoint...")
+    try:
+        response = requests.get(f"{base_url}/health", timeout=10)
+        if response.ok:
+            logger.info(f"   ✅ Health check passed: {response.json()}")
+        else:
+            logger.warning(f"   ⚠️ Health check returned: {response.status_code}")
+    except requests.exceptions.RequestException as e:
+        logger.error(f"   ❌ Failed to connect to API: {e}")
+        logger.info("   Note: Make sure the API server is running")
+        logger.info("   Start with: uvicorn app.main_sdxl:app --reload")
+        return False
+    
+    # Step 2: Upload image
+    logger.info("\n2. Uploading image...")
+    upload_url = f"{base_url}/upload"
+    headers = {}
+    if app_check_token:
+        headers["X-Firebase-AppCheck"] = app_check_token
+    
+    try:
+        with open(image_path, "rb") as f:
+            files = {"file": (os.path.basename(image_path), f, "image/png")}
+            response = requests.post(upload_url, files=files, headers=headers, timeout=120)
+        
+        if response.ok:
+            upload_data = response.json()
+            logger.info(f"   ✅ Upload successful!")
+            logger.info(f"   Image ID: {upload_data.get('image_id')}")
+            image_id = upload_data.get('image_id')
+        else:
+            logger.error(f"   ❌ Upload failed: {response.status_code} - {response.text}")
+            return False
+    except Exception as e:
+        logger.error(f"   ❌ Upload error: {e}")
+        return False
+    
+    # Step 3: Colorize image
+    logger.info("\n3. Colorizing image...")
+    colorize_url = f"{base_url}/colorize"
+    
+    try:
+        with open(image_path, "rb") as f:
+            files = {"file": (os.path.basename(image_path), f, "image/png")}
+            response = requests.post(colorize_url, files=files, headers=headers, timeout=900)
+        
+        if response.ok:
+            colorize_data = response.json()
+            logger.info(f"   ✅ Colorization successful!")
+            logger.info(f"   Result ID: {colorize_data.get('result_id')}")
+            result_id = colorize_data.get('result_id')
+        else:
+            logger.error(f"   ❌ Colorization failed: {response.status_code} - {response.text}")
+            return False
+    except Exception as e:
+        logger.error(f"   ❌ Colorization error: {e}")
+        return False
+    
+    # Step 4: Wait for MongoDB writes
+    logger.info("\n4. Waiting 5 seconds for MongoDB writes to complete...")
+    time.sleep(5)
+    
+    # Step 5: Verify MongoDB storage
+    logger.info("\n5. Verifying MongoDB storage...")
+    try:
+        client = MongoClient(mongodb_uri, serverSelectionTimeoutMS=5000)
+        client.admin.command('ping')
+        logger.info("   ✅ Connected to MongoDB")
+        
+        db = client[db_name]
+        
+        # Check api_calls collection
+        api_calls = db["api_calls"]
+        recent_calls = list(api_calls.find({
+            "timestamp": {"$gte": datetime.utcnow() - timedelta(minutes=10)}
+        }).sort("timestamp", -1))
+        
+        logger.info(f"\n   📊 Found {len(recent_calls)} API calls in last 10 minutes:")
+        for call in recent_calls[:5]:
+            logger.info(f"      - {call.get('method')} {call.get('endpoint')} "
+                      f"(Status: {call.get('status_code')}) at {call.get('timestamp')}")
+        
+        # Check image_uploads collection
+        image_uploads = db["image_uploads"]
+        recent_uploads = list(image_uploads.find({
+            "uploaded_at": {"$gte": datetime.utcnow() - timedelta(minutes=10)}
+        }).sort("uploaded_at", -1))
+        
+        logger.info(f"\n   📊 Found {len(recent_uploads)} image uploads in last 10 minutes:")
+        for upload in recent_uploads[:3]:
+            logger.info(f"      - Image ID: {upload.get('image_id')}")
+            logger.info(f"        Filename: {upload.get('filename')}")
+            logger.info(f"        Size: {upload.get('file_size')} bytes")
+            logger.info(f"        Uploaded at: {upload.get('uploaded_at')}")
+        
+        # Check colorizations collection
+        colorizations = db["colorizations"]
+        recent_colorizations = list(colorizations.find({
+            "created_at": {"$gte": datetime.utcnow() - timedelta(minutes=10)}
+        }).sort("created_at", -1))
+        
+        logger.info(f"\n   📊 Found {len(recent_colorizations)} colorizations in last 10 minutes:")
+        for colorization in recent_colorizations[:3]:
+            logger.info(f"      - Result ID: {colorization.get('result_id')}")
+            logger.info(f"        Model: {colorization.get('model_type')}")
+            logger.info(f"        Processing time: {colorization.get('processing_time')}s")
+            logger.info(f"        Created at: {colorization.get('created_at')}")
+        
+        # Summary
+        logger.info("\n" + "=" * 80)
+        logger.info("TEST SUMMARY")
+        logger.info("=" * 80)
+        
+        if len(recent_calls) > 0 and len(recent_uploads) > 0 and len(recent_colorizations) > 0:
+            logger.info("✅ SUCCESS: All data is being stored in MongoDB!")
+            logger.info("✅ API calls are logged with timestamps")
+            logger.info("✅ Image uploads are logged with metadata")
+            logger.info("✅ Colorizations are logged with processing details")
+        else:
+            logger.warning("⚠️ Some data might be missing:")
+            logger.warning(f"   API calls: {len(recent_calls)}")
+            logger.warning(f"   Image uploads: {len(recent_uploads)}")
+            logger.warning(f"   Colorizations: {len(recent_colorizations)}")
+        
+        client.close()
+        return True
+        
+    except (ConnectionFailure, ServerSelectionTimeoutError) as e:
+        logger.error(f"   ❌ Failed to connect to MongoDB: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"   ❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Test API with image and verify MongoDB")
+    parser.add_argument("--image", type=str, default="../Descratch.png",
+                       help="Path to image file")
+    parser.add_argument("--base-url", type=str, default="http://localhost:7860",
+                       help="API base URL")
+    parser.add_argument("--mongodb-uri", type=str, default=os.getenv("MONGODB_URI", ""),
+                       help="MongoDB connection string")
+    parser.add_argument("--app-check", type=str, default=os.getenv("APP_CHECK_TOKEN", ""),
+                       help="Firebase App Check token (optional)")
+    
+    args = parser.parse_args()
+    
+    if not args.mongodb_uri:
+        logger.error("MongoDB URI required! Set MONGODB_URI environment variable or use --mongodb-uri")
+        sys.exit(1)
+    
+    success = test_api_with_image_and_mongodb(
+        args.image, 
+        args.base_url, 
+        args.mongodb_uri,
+        args.app_check if args.app_check else None
+    )
+    sys.exit(0 if success else 1)
+