solokit 0.1.1__py3-none-any.whl

solokit/templates/ml_ai_fastapi/tier-1-essential/tests/conftest.py

@@ -0,0 +1,72 @@
+"""
+Pytest fixtures for testing
+"""
+
+from collections.abc import AsyncGenerator
+from typing import Any
+
+import pytest
+from httpx import ASGITransport, AsyncClient  # type: ignore[import-not-found]
+from sqlalchemy.ext.asyncio import create_async_engine  # type: ignore[import-not-found]
+from sqlalchemy.orm import sessionmaker  # type: ignore[import-not-found]
+from sqlmodel import SQLModel  # type: ignore[import-not-found]
+from sqlmodel.ext.asyncio.session import AsyncSession  # type: ignore[import-not-found]
+
+from src.api.dependencies import get_db  # type: ignore[import-not-found]
+from src.main import app  # type: ignore[import-not-found]
+
+
+# Test database URL (use in-memory SQLite for testing)
+TEST_DATABASE_URL = "sqlite+aiosqlite:///:memory:"
+
+
+@pytest.fixture
+async def db_engine() -> AsyncGenerator[Any, None]:
+    """Create a test database engine."""
+    engine = create_async_engine(
+        TEST_DATABASE_URL,
+        echo=False,
+        future=True,
+    )
+
+    async with engine.begin() as conn:
+        await conn.run_sync(SQLModel.metadata.create_all)
+
+    yield engine
+
+    async with engine.begin() as conn:
+        await conn.run_sync(SQLModel.metadata.drop_all)
+
+    await engine.dispose()
+
+
+@pytest.fixture
+async def db_session(db_engine: Any) -> AsyncGenerator[AsyncSession, None]:
+    """Create a test database session."""
+    async_session_maker = sessionmaker(
+        db_engine,
+        class_=AsyncSession,
+        expire_on_commit=False,
+    )
+
+    async with async_session_maker() as session:
+        yield session
+
+
+@pytest.fixture
+async def client(db_session: AsyncSession) -> AsyncGenerator[AsyncClient, None]:
+    """
+    Create a test client with database session override.
+    """
+
+    async def override_get_db() -> AsyncGenerator[AsyncSession, None]:
+        yield db_session
+
+    app.dependency_overrides[get_db] = override_get_db
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test", timeout=30.0
+    ) as ac:  # nosec B113 - Test client timeout is set to 30 seconds
+        yield ac
+
+    app.dependency_overrides.clear()

solokit/templates/ml_ai_fastapi/tier-1-essential/tests/test_main.py

@@ -0,0 +1,49 @@
+"""
+Tests for main FastAPI application
+"""
+
+import pytest
+from httpx import AsyncClient  # type: ignore[import-not-found]
+
+
+@pytest.mark.unit
+class TestMainApp:
+    """Test cases for main application endpoints."""
+
+    async def test_root_endpoint(self, client: AsyncClient) -> None:
+        """Test root endpoint returns correct information."""
+        response = await client.get("/")
+
+        assert response.status_code == 200
+        data = response.json()
+        assert "name" in data
+        assert "version" in data
+        assert "status" in data
+        assert data["status"] == "running"
+
+    async def test_health_check(self, client: AsyncClient) -> None:
+        """Test health check endpoint."""
+        response = await client.get("/health")
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["status"] == "healthy"
+        assert "service" in data
+        assert "version" in data
+
+    async def test_liveness_check(self, client: AsyncClient) -> None:
+        """Test liveness check endpoint."""
+        response = await client.get("/health/live")
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["status"] == "alive"
+
+    async def test_readiness_check(self, client: AsyncClient) -> None:
+        """Test readiness check endpoint."""
+        response = await client.get("/health/ready")
+
+        assert response.status_code == 200
+        data = response.json()
+        assert "status" in data
+        assert "database" in data

solokit/templates/ml_ai_fastapi/tier-1-essential/tests/unit/__init__.py

@@ -0,0 +1,3 @@
+"""
+Unit tests package
+"""

solokit/templates/ml_ai_fastapi/tier-1-essential/tests/unit/test_example.py

@@ -0,0 +1,113 @@
+"""
+Unit tests for example service
+"""
+
+import pytest
+from sqlmodel.ext.asyncio.session import AsyncSession  # type: ignore[import-not-found]
+
+from src.models.example import ItemCreate, ItemUpdate  # type: ignore[import-not-found]
+from src.services.example import ItemService  # type: ignore[import-not-found]
+
+
+@pytest.mark.unit
+class TestItemService:
+    """Test cases for ItemService."""
+
+    async def test_create_item(self, db_session: AsyncSession) -> None:
+        """Test creating an item."""
+        service = ItemService(db_session)
+        item_data = ItemCreate(
+            name="Test Item",
+            description="A test item",
+            price=9.99,
+        )
+
+        item = await service.create_item(item_data)
+
+        assert item.id is not None
+        assert item.name == "Test Item"
+        assert item.description == "A test item"
+        assert item.price == 9.99
+        assert item.is_active is True
+
+    async def test_get_item(self, db_session: AsyncSession) -> None:
+        """Test retrieving an item."""
+        service = ItemService(db_session)
+
+        # Create an item first
+        item_data = ItemCreate(name="Test Item", price=9.99)
+        created_item = await service.create_item(item_data)
+
+        # Retrieve the item
+        retrieved_item = await service.get_item(created_item.id)
+
+        assert retrieved_item is not None
+        assert retrieved_item.id == created_item.id
+        assert retrieved_item.name == created_item.name
+
+    async def test_get_nonexistent_item(self, db_session: AsyncSession) -> None:
+        """Test retrieving a non-existent item."""
+        service = ItemService(db_session)
+        item = await service.get_item(999)
+        assert item is None
+
+    async def test_get_items_pagination(self, db_session: AsyncSession) -> None:
+        """Test listing items with pagination."""
+        service = ItemService(db_session)
+
+        # Create multiple items (starting from 1 to avoid price=0 validation error)
+        for i in range(1, 6):
+            item_data = ItemCreate(name=f"Item {i}", price=float(i))
+            await service.create_item(item_data)
+
+        # Test pagination
+        items = await service.get_items(skip=0, limit=3)
+        assert len(items) == 3
+
+        items = await service.get_items(skip=3, limit=3)
+        assert len(items) == 2
+
+    async def test_update_item(self, db_session: AsyncSession) -> None:
+        """Test updating an item."""
+        service = ItemService(db_session)
+
+        # Create an item
+        item_data = ItemCreate(name="Original Name", price=10.0)
+        created_item = await service.create_item(item_data)
+
+        # Update the item
+        update_data = ItemUpdate(name="Updated Name", price=15.0)
+        updated_item = await service.update_item(created_item.id, update_data)
+
+        assert updated_item is not None
+        assert updated_item.name == "Updated Name"
+        assert updated_item.price == 15.0
+
+    async def test_update_nonexistent_item(self, db_session: AsyncSession) -> None:
+        """Test updating a non-existent item."""
+        service = ItemService(db_session)
+        update_data = ItemUpdate(name="Updated Name")
+        result = await service.update_item(999, update_data)
+        assert result is None
+
+    async def test_delete_item(self, db_session: AsyncSession) -> None:
+        """Test deleting an item."""
+        service = ItemService(db_session)
+
+        # Create an item
+        item_data = ItemCreate(name="To Delete", price=10.0)
+        created_item = await service.create_item(item_data)
+
+        # Delete the item
+        success = await service.delete_item(created_item.id)
+        assert success is True
+
+        # Verify deletion
+        deleted_item = await service.get_item(created_item.id)
+        assert deleted_item is None
+
+    async def test_delete_nonexistent_item(self, db_session: AsyncSession) -> None:
+        """Test deleting a non-existent item."""
+        service = ItemService(db_session)
+        success = await service.delete_item(999)
+        assert success is False

solokit/templates/ml_ai_fastapi/tier-2-standard/pyproject.toml.tier2.template

@@ -0,0 +1,130 @@
+[project]
+name = "{project_name}"
+version = "0.1.0"
+description = "{project_description}"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi==0.115.6",
+    "uvicorn[standard]==0.34.0",
+    "pydantic==2.12.4",
+    "pydantic-core==2.41.5",
+    "pydantic-settings==2.11.0",
+    "sqlmodel==0.0.25",
+    "sqlalchemy==2.0.37",
+    "psycopg2-binary==2.9.10",
+    "alembic==1.14.0",
+    "python-dotenv==1.2.1",
+    "asyncpg==0.30.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest==8.3.4",
+    "pytest-cov==6.0.0",
+    "pytest-asyncio==0.25.2",
+    "httpx==0.28.1",
+    "aiosqlite==0.20.0",
+    "ruff==0.9.2",
+    "pyright==1.1.396",
+]
+
+security = [
+    "detect-secrets==1.5.0",
+    "pip-audit==2.7.3",
+    "bandit[toml]==1.8.0",
+    "pre-commit==4.0.1",
+]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["src"]
+
+# Ruff configuration
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+select = [
+    "E",  # pycodestyle errors
+    "W",  # pycodestyle warnings
+    "F",  # pyflakes
+    "I",  # isort
+    "N",  # pep8-naming
+    "UP", # pyupgrade
+    "B",  # flake8-bugbear
+    "S",  # bandit security checks
+]
+
+ignore = [
+    "E501",  # line too long (handled by formatter)
+    "S101",  # assert used (we use asserts in tests)
+]
+
+exclude = [
+    ".git",
+    ".venv",
+    "__pycache__",
+    "alembic/versions",
+    ".pytest_cache",
+]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+[tool.ruff.isort]
+known-first-party = ["src"]
+
+[tool.ruff.per-file-ignores]
+"tests/*" = ["S101"]
+
+# Pytest configuration
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+python_files = ["test_*.py", "*_test.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = [
+    "-v",
+    "--strict-markers",
+    "--tb=short",
+    "--cov=src",
+    "--cov-report=term-missing",
+    "--cov-fail-under=80",
+]
+
+# Coverage configuration
+[tool.coverage.run]
+source = ["src"]
+omit = [
+    "tests/*",
+    "alembic/*",
+    "*/__init__.py",
+]
+
+[tool.coverage.report]
+precision = 2
+show_missing = true
+skip_covered = false
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+    "@abstractmethod",
+]
+
+# Bandit security configuration
+[tool.bandit]
+exclude_dirs = ["tests", ".venv", "venv", "alembic/versions"]
+skips = ["B101"]
+
+# Scripts
+[project.scripts]
+dev = "uvicorn src.main:app --reload --host 0.0.0.0 --port 8000"

solokit/templates/ml_ai_fastapi/tier-3-comprehensive/locustfile.py

@@ -0,0 +1,99 @@
+"""
+Locust load testing configuration for FastAPI application
+https://docs.locust.io/
+"""
+
+from locust import HttpUser, between, task  # type: ignore[import-not-found]
+
+
+class FastAPIUser(HttpUser):
+    """
+    Simulated user for load testing the FastAPI application.
+    """
+
+    # Wait time between tasks (in seconds)
+    wait_time = between(1, 3)
+
+    # Base host will be set via command line: locust --host=http://localhost:8000
+
+    @task(3)
+    def get_root(self) -> None:
+        """Test the root endpoint (higher weight = 3)."""
+        self.client.get("/")
+
+    @task(5)
+    def health_check(self) -> None:
+        """Test the health check endpoint (higher weight = 5)."""
+        self.client.get("/health")
+
+    @task(2)
+    def list_items(self) -> None:
+        """Test listing items."""
+        self.client.get("/api/v1/items")
+
+    @task(1)
+    def create_item(self) -> None:
+        """Test creating an item."""
+        self.client.post(
+            "/api/v1/items",
+            json={
+                "name": "Load Test Item",
+                "description": "Created during load testing",
+                "price": 99.99,
+            },
+        )
+
+    @task(1)
+    def get_item(self) -> None:
+        """Test getting a specific item."""
+        # Note: This assumes item with ID 1 exists
+        # In production, you'd create items first
+        with self.client.get("/api/v1/items/1", catch_response=True) as response:
+            if response.status_code == 404:
+                response.success()  # Mark as success even if not found
+
+    def on_start(self) -> None:
+        """
+        Called when a simulated user starts.
+        Use this to set up test data or authenticate.
+        """
+        # Example: Create test items
+        for i in range(3):
+            self.client.post(
+                "/api/v1/items",
+                json={
+                    "name": f"Test Item {i}",
+                    "description": f"Description {i}",
+                    "price": 10.0 * (i + 1),
+                },
+            )
+
+    def on_stop(self) -> None:
+        """
+        Called when a simulated user stops.
+        Use this to clean up test data.
+        """
+        pass
+
+
+class AdminUser(HttpUser):
+    """
+    Simulated admin user with different behavior patterns.
+    """
+
+    wait_time = between(2, 5)
+
+    @task(1)
+    def check_readiness(self) -> None:
+        """Test the readiness check endpoint."""
+        self.client.get("/health/ready")
+
+    @task(1)
+    def check_liveness(self) -> None:
+        """Test the liveness check endpoint."""
+        self.client.get("/health/live")
+
+
+# Run with:
+# locust --host=http://localhost:8000
+# locust --host=http://localhost:8000 --users 100 --spawn-rate 10 --run-time 1m

solokit/templates/ml_ai_fastapi/tier-3-comprehensive/mutmut_config.py

@@ -0,0 +1,53 @@
+"""
+Mutation testing configuration for mutmut
+https://mutmut.readthedocs.io/
+"""
+
+from typing import Any
+
+
+def pre_mutation(context: Any) -> None:
+    """
+    Called before each mutation is tested.
+    Can be used to skip certain mutations.
+    """
+    # Skip mutations in test files
+    if "test_" in context.filename:
+        context.skip = True
+
+    # Skip mutations in migration files
+    if "alembic/versions" in context.filename:
+        context.skip = True
+
+
+def post_mutation(context: Any) -> None:
+    """
+    Called after each mutation is tested.
+    Can be used for custom reporting.
+    """
+    pass
+
+
+# Paths to mutate
+paths_to_mutate = "src/"
+
+# Paths to exclude from mutation
+paths_to_exclude = [
+    "tests/",
+    "alembic/",
+    "__pycache__/",
+    ".venv/",
+]
+
+# Test command
+tests_dir = "tests/"
+test_command = "pytest -x --tb=short"
+
+# Runner configuration
+runner = "python"
+
+# Coverage threshold (percentage)
+coverage_threshold = 80
+
+# Mutation operators to use
+dict_synonyms = ["dict", "OrderedDict", "defaultdict"]

solokit/templates/ml_ai_fastapi/tier-3-comprehensive/pyproject.toml.tier3.template

@@ -0,0 +1,150 @@
+[project]
+name = "{project_name}"
+version = "0.1.0"
+description = "{project_description}"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi==0.115.6",
+    "uvicorn[standard]==0.34.0",
+    "pydantic==2.12.4",
+    "pydantic-core==2.41.5",
+    "pydantic-settings==2.11.0",
+    "sqlmodel==0.0.25",
+    "sqlalchemy==2.0.37",
+    "psycopg2-binary==2.9.10",
+    "alembic==1.14.0",
+    "python-dotenv==1.2.1",
+    "asyncpg==0.30.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest==8.3.4",
+    "pytest-cov==6.0.0",
+    "pytest-asyncio==0.25.2",
+    "httpx==0.28.1",
+    "aiosqlite==0.20.0",
+    "ruff==0.9.2",
+    "pyright==1.1.396",
+]
+
+security = [
+    "detect-secrets==1.5.0",
+    "pip-audit==2.7.3",
+    "bandit[toml]==1.8.0",
+    "pre-commit==4.0.1",
+]
+
+quality = [
+    "radon==6.0.1",
+    "vulture==2.14",
+    "mutmut==3.3.1",
+    "locust==2.42.2",
+    "semgrep==1.142.1",
+    "coverage[toml]==7.11.1",
+]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["src"]
+
+# Ruff configuration
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+select = [
+    "E",  # pycodestyle errors
+    "W",  # pycodestyle warnings
+    "F",  # pyflakes
+    "I",  # isort
+    "N",  # pep8-naming
+    "UP", # pyupgrade
+    "B",  # flake8-bugbear
+    "S",  # bandit security checks
+]
+
+ignore = [
+    "E501",  # line too long (handled by formatter)
+    "S101",  # assert used (we use asserts in tests)
+]
+
+exclude = [
+    ".git",
+    ".venv",
+    "__pycache__",
+    "alembic/versions",
+    ".pytest_cache",
+]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+[tool.ruff.isort]
+known-first-party = ["src"]
+
+[tool.ruff.per-file-ignores]
+"tests/*" = ["S101"]
+
+# Pytest configuration
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+python_files = ["test_*.py", "*_test.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+markers = [
+    "unit: Unit tests",
+    "integration: Integration tests",
+    "slow: Slow running tests",
+    "api: API tests",
+    "db: Database tests",
+]
+addopts = [
+    "-v",
+    "--strict-markers",
+    "--tb=short",
+    "--cov=src",
+    "--cov-report=term-missing",
+    "--cov-report=html",
+    "--cov-report=xml",
+    "--cov-fail-under=80",
+]
+
+# Coverage configuration
+[tool.coverage.run]
+source = ["src"]
+omit = [
+    "tests/*",
+    "alembic/*",
+    "*/__init__.py",
+]
+branch = true
+
+[tool.coverage.report]
+precision = 2
+show_missing = true
+skip_covered = false
+fail_under = 80
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+    "@abstractmethod",
+]
+
+# Bandit security configuration
+[tool.bandit]
+exclude_dirs = ["tests", ".venv", "venv", "alembic/versions"]
+skips = ["B101"]
+
+# Scripts
+[project.scripts]
+dev = "uvicorn src.main:app --reload --host 0.0.0.0 --port 8000"

solokit/templates/ml_ai_fastapi/tier-3-comprehensive/tests/integration/__init__.py

@@ -0,0 +1,3 @@
+"""
+Integration tests package
+"""