Pipeline

Author: tonybenoy

pyproject.toml

@@ -24,33 +24,28 @@ dependencies = [
     "fastapi>=0.115.0",
     "pydantic>=2.10.0",
     "pydantic-settings>=2.6.0",
-    
     # Database
     "sqlalchemy>=2.0.36",
     "alembic>=1.14.0",
-    "asyncpg>=0.30.0",        # Better async PostgreSQL driver
+    "asyncpg>=0.30.0", # Better async PostgreSQL driver
     "psycopg2-binary>=2.9.10", # Keep for compatibility
-    
     # Server
     "gunicorn>=23.0.0",
     "uvicorn[standard]>=0.32.0",
-    
     # Utilities
     "python-dotenv>=1.0.1",
     "jinja2>=3.1.5",
     "python-multipart>=0.0.20",
-    
     # S3/Storage
     "boto3>=1.35.0",
-    
     # Background Tasks
     "celery>=5.4.0",
     "redis>=5.2.0",
-    
     # Authentication & Security
     "python-jose[cryptography]>=3.3.0",
     "passlib[bcrypt]>=1.7.4",
-    "python-multipart>=0.0.20",  # For form data
+    "python-multipart>=0.0.20", # For form data
+    "email-validator>=2.2.0",
 ]
 
 [project.optional-dependencies]
@@ -175,6 +170,7 @@ exclude_lines = [
 
 [dependency-groups]
 dev = [
+    "aiosqlite>=0.21.0",
     "freezegun>=1.5.4",
     "httpx>=0.28.1",
     "mypy>=1.17.1",

src/cache.py

@@ -24,6 +24,13 @@ def __init__(self):
 
     def _connect(self):
         """Connect to Redis."""
+        # Skip Redis connection in testing environment
+        import os
+        if os.environ.get("TESTING") == "true" or os.environ.get("ENVIRONMENT") == "testing":
+            logger.info("Skipping Redis connection in test environment")
+            self.redis_client = None
+            return
+            
         try:
             self.redis_client = redis.from_url(
                 self.settings.redis_url,

src/exceptions.py

@@ -178,7 +178,13 @@ def __init__(
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary."""
-        result = {"message": self.message, "errors": [error.to_dict() for error in self.errors]}
+        errors_list = []
+        for error in self.errors:
+            if hasattr(error, 'to_dict'):
+                errors_list.append(error.to_dict())
+            else:
+                errors_list.append(error)  # Already a dict
+        result = {"message": self.message, "errors": errors_list}
 
         if self.error_code:
             result["error_code"] = self.error_code

src/main.py

@@ -46,40 +46,36 @@ def create_app() -> FastAPI:
     # Set up error handlers
     setup_error_handlers(app)
 
+    # Mount static files
+    app.mount("/static", StaticFiles(directory="src/static"), name="static")
+
+    # Include routers
+    app.include_router(auth.router, prefix="/api")
+    app.include_router(index.router, prefix="/web")
+    app.include_router(s3.router)
+
+    # Health check endpoints
+    @app.get("/health")
+    async def health_check() -> Dict[str, str]:
+        """Health check endpoint for monitoring."""
+        return {"status": "healthy", "timestamp": get_current_date_time(), "version": "0.1.0"}
+
+    @app.get("/test", response_model=Dict[str, str])
+    async def test() -> Dict[str, str]:
+        """Test endpoint to verify the application is working."""
+        return {
+            "result": "success",
+            "msg": f"It works! {get_current_date_time()}",
+        }
+
+    # Root endpoint
+    @app.get("/")
+    async def root() -> Dict[str, str]:
+        """Root endpoint with basic application information."""
+        return {"message": "Web Service Template API", "version": "0.1.0", "docs": "/docs", "health": "/health"}
+
     return app
 
 
 # Create the application
 app = create_app()
-
-
-# Mount static files
-app.mount("/static", StaticFiles(directory="src/static"), name="static")
-
-# Include routers
-app.include_router(auth.router, prefix="/api")
-app.include_router(index.router, prefix="/web")
-app.include_router(s3.router)
-
-
-# Health check endpoints
-@app.get("/health")
-async def health_check() -> Dict[str, str]:
-    """Health check endpoint for monitoring."""
-    return {"status": "healthy", "timestamp": get_current_date_time(), "version": "0.1.0"}
-
-
-@app.get("/test", response_model=Dict[str, str])
-async def test() -> Dict[str, str]:
-    """Test endpoint to verify the application is working."""
-    return {
-        "result": "success",
-        "msg": f"It works! {get_current_date_time()}",
-    }
-
-
-# Root endpoint
-@app.get("/")
-async def root() -> Dict[str, str]:
-    """Root endpoint with basic application information."""
-    return {"message": "Web Service Template API", "version": "0.1.0", "docs": "/docs", "health": "/health"}

src/models/base.py

@@ -12,10 +12,9 @@
 
 from src.database import Base
 
-T = TypeVar("T", bound="AsyncBaseModel")
+T = TypeVar("T")
 
 
-@as_declarative()
 class AsyncBaseModel(Base):
     """Enhanced base model with async CRUD operations and utility methods."""
 
@@ -210,6 +209,8 @@ def get_offset(self) -> int:
 
 class PaginatedResponse(BaseModel, Generic[T]):
     """Generic paginated response model."""
+    
+    model_config = {"arbitrary_types_allowed": True}
 
     items: List[T]
     page: int

src/routes/auth.py

@@ -265,7 +265,7 @@ async def list_api_keys(current_user: User = Depends(get_current_user), db: Asyn
     """List user's API keys."""
     api_keys = await APIKey.get_multi(db, filters={"user_id": current_user.id}, order_by="created_at")
 
-    return [APIKeyResponse(**api_key.to_dict(), scopes=api_key.get_scopes()) for api_key in api_keys]
+    return [APIKeyResponse(**{**api_key.to_dict(), "scopes": api_key.get_scopes()}) for api_key in api_keys]
 
 
 @router.delete("/api-keys/{key_id}")

src/s3.py

@@ -31,7 +31,7 @@ def upload_object_to_s3(file_name: str, file, bucket: str | None = None):
     if not s3_client:
         return
     s3_client.upload_fileobj(file, bucket, filename)
-    logger.info("Uploaded %s to %s", filename, bucket)
+    logger.info(f"Uploaded {filename} to {bucket}")
     return filename
 
 
@@ -48,7 +48,7 @@ def download_object_from_s3(bucket_name, object_name, file_name):
     try:
         s3_client.download_file(bucket_name, object_name, file_name)
     except Exception as e:
-        logger.error(e)
+        logger.error(f"S3 operation failed: {str(e)}")
         return False
     return True
 
@@ -65,6 +65,6 @@ def get_object_url(bucket_name, object_name):
     try:
         url = s3_client.generate_presigned_url("get_object", Params={"Bucket": bucket_name, "Key": object_name})
     except Exception as e:
-        logger.error(e)
+        logger.error(f"S3 operation failed: {str(e)}")
         return None
     return url

src/tests/conftest.py

@@ -41,6 +41,11 @@
 from src.models.s3 import S3Object
 from src.models.user import APIKey, User
 
+# Import all models to ensure they're registered with Base metadata
+# This is needed for table creation in tests
+import src.models.user  # noqa: F401
+import src.models.s3  # noqa: F401
+
 
 # Test database setup
 @pytest.fixture(scope="session")
@@ -87,11 +92,17 @@ async def async_db_session(async_test_engine) -> AsyncGenerator[AsyncSession, No
     """Create async database session for testing."""
     async_session_maker = async_sessionmaker(async_test_engine, class_=AsyncSession, expire_on_commit=False)
 
+    # Clear all tables before starting test
+    async with async_test_engine.begin() as conn:
+        await conn.run_sync(Base.metadata.drop_all)
+        await conn.run_sync(Base.metadata.create_all)
+
     async with async_session_maker() as session:
         try:
             yield session
         finally:
             await session.rollback()
+            await session.close()
 
 
 @pytest.fixture
@@ -126,7 +137,9 @@ def client(app) -> TestClient:
 @pytest.fixture
 async def async_client(app) -> AsyncGenerator[AsyncClient, None]:
     """Create async test client."""
-    async with AsyncClient(app=app, base_url="http://test") as ac:
+    from httpx import ASGITransport
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as ac:
         yield ac
 
 

src/tests/test_auth.py

@@ -117,7 +117,7 @@ async def test_get_current_user_unauthorized(self, async_client: AsyncClient):
         """Test getting current user without auth fails."""
         response = await async_client.get("/api/auth/me")
 
-        assert response.status_code == status.HTTP_401_UNAUTHORIZED
+        assert response.status_code == status.HTTP_403_FORBIDDEN
 
     async def test_update_profile(self, async_client: AsyncClient, auth_headers: dict):
         """Test updating user profile."""
@@ -132,18 +132,18 @@ async def test_update_profile(self, async_client: AsyncClient, auth_headers: dic
 
     async def test_change_password(self, async_client: AsyncClient, auth_headers: dict):
         """Test changing password."""
-        change_data = {"current_password": "testpass123", "new_password": "newtestpass456"}
+        params = {"current_password": "testpass123", "new_password": "newtestpass456"}
 
-        response = await async_client.post("/api/auth/change-password", json=change_data, headers=auth_headers)
+        response = await async_client.post("/api/auth/change-password", params=params, headers=auth_headers)
 
         assert response.status_code == status.HTTP_200_OK
         assert "successfully" in response.json()["message"]
 
     async def test_change_password_wrong_current(self, async_client: AsyncClient, auth_headers: dict):
         """Test changing password with wrong current password fails."""
-        change_data = {"current_password": "wrongpass", "new_password": "newtestpass456"}
+        params = {"current_password": "wrongpass", "new_password": "newtestpass456"}
 
-        response = await async_client.post("/api/auth/change-password", json=change_data, headers=auth_headers)
+        response = await async_client.post("/api/auth/change-password", params=params, headers=auth_headers)
 
         assert response.status_code == status.HTTP_400_BAD_REQUEST
 

src/tests/test_config.py

@@ -34,7 +34,8 @@ def test_settings_default_values(self):
             assert settings.postgres_db in ["webapp", "test_db"]
             assert settings.redis_host == "localhost"
             assert settings.redis_port == 6379
-            assert settings.redis_db == 0
+            # redis_db will be 1 in testing environment (set in conftest.py)
+            assert settings.redis_db in [0, 1]
             assert settings.s3_host == "http://127.0.0.1"
             assert settings.s3_port == 9002
             # s3_bucket will be "test-bucket" because it's set in the test module