setting up the generator

Author: GioeleB00

pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
-name = "project-backend"
+name = "FastSim-backend"
 version = "0.1.0"
-description = "solo professional project"
+description = "Simulate fastapi event loop to manage resources"
 authors = ["Gioele Botta"]
 readme = "README.md"
 

scripts/quality-check.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Lint & format with ruff, automatic corrections applied (--fix)
+poetry run ruff check src tests --fix
+
+# Type‐check with mypy
+poetry run mypy src tests
+
+echo "✅ Linting e type‐checking completed SUCCESSFULLY"

src/app/api/simulation.py

@@ -0,0 +1,22 @@
+""""Api to simulate the process"""
+
+from fastapi import APIRouter
+
+from app.schemas.simulation_input import SimulationInput
+from app.schemas.simulation_output import SimulationOutput
+
+router = APIRouter()
+
+@router.post("/simulation")
+async def event_loop_simulation(
+    generator_input: SimulationInput,
+) -> SimulationOutput:
+    """Endpoint to handle the simulation."""
+    # simple map to pass the quality assurance
+    return SimulationOutput(
+        metric_1=generator_input.avg_active_users.mean,
+        metric_2=str(generator_input.avg_request_per_minute_per_user.mean),
+        metric_n=str(generator_input.total_simulation_time),
+    )
+
+

src/app/core/auth_helpers.py

@@ -5,7 +5,6 @@
 
 from fastapi import FastAPI
 
-
 from app.api.health_check import router as health_router
 from app.config.settings import settings
 from app.db.init_db import close_engine, init_models

src/app/main.py

@@ -0,0 +1,39 @@
+"""Define the schemas for the simulator"""
+
+from typing import Literal
+
+from pydantic import BaseModel, field_validator, model_validator
+
+
+class RVConfig(BaseModel):
+    """class to configure random variables"""
+
+    mean: int | float
+    distribution: Literal["poisson", "normal"] = "poisson"
+    variance: float | None = None
+
+    @field_validator("mean", mode="before")
+    def check_mean_is_number(
+        cls, # noqa: N805
+        v: object,
+        ) -> float:
+        """Ensure `mean` is numeric, then coerce to float."""
+        err_msg = "mean must be a number (int or float)"
+        if not isinstance(v, (int, float)):
+            raise ValueError(err_msg)  # noqa: TRY004
+        return float(v)
+
+    @model_validator(mode="after")  # type: ignore[arg-type]
+    def default_variance(cls, model: "RVConfig") -> "RVConfig":  # noqa: N805
+        """Set variance = mean when distribution == 'normal' and variance is missing."""
+        if model.variance is None and model.distribution == "normal":
+            model.variance = model.mean
+        return model
+
+class SimulationInput(BaseModel):
+    """Define the expected variables for the simulation"""
+
+    avg_active_users: RVConfig
+    avg_request_per_minute_per_user: RVConfig
+    total_simulation_time: int
+

src/app/schemas/simulation_input.py

@@ -0,0 +1,12 @@
+"""Define the output of the simulation"""
+
+from pydantic import BaseModel
+
+
+class SimulationOutput(BaseModel):
+    """Define the output of the simulation"""
+
+    metric_1: str | int
+    metric_2: str
+    #......
+    metric_n: str

src/app/schemas/simulation_output.py

@@ -1,7 +1,7 @@
 import pytest
 from sqlalchemy import text
-from sqlalchemy.ext.asyncio import create_async_engine
 from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.asyncio import create_async_engine
 
 from app.config.settings import settings
 
@@ -14,4 +14,4 @@ async def test_users_table_exists_after_migrations() -> None:
            await conn.execute(text("SELECT 1"))
     except SQLAlchemyError:
         pytest.fail("Database connection or Alembic setup failed.")
-       
+

tests/integration/db_initialization/test_init_models.py

@@ -0,0 +1,51 @@
+import pytest
+from pydantic import ValidationError
+
+from app.schemas.simulation_input import RVConfig
+
+# --------------------------------------------------------------------------- #
+# Positive cases                                                              #
+# --------------------------------------------------------------------------- #
+
+def test_normal_sets_variance_to_mean() -> None:
+    """When distribution='normal' and variance is omitted, variance == mean."""
+    cfg = RVConfig(mean=10, distribution="normal")
+    assert cfg.variance == 10.0
+
+
+def test_poisson_keeps_variance_none() -> None:
+    """When distribution='poisson' and variance is omitted, variance stays None."""
+    cfg = RVConfig(mean=5, distribution="poisson")
+    assert cfg.variance is None
+
+
+def test_explicit_variance_is_preserved() -> None:
+    """If the user supplies variance explicitly, it is preserved unchanged."""
+    cfg = RVConfig(mean=8, distribution="normal", variance=4)
+    assert cfg.variance == 4.0
+
+
+# --------------------------------------------------------------------------- #
+# Validation errors                                                           #
+# --------------------------------------------------------------------------- #
+
+def test_mean_must_be_numeric() -> None:
+    """A non-numeric mean raises a ValidationError with our custom message."""
+    with pytest.raises(ValidationError) as excinfo:
+        RVConfig(mean="not a number", distribution="poisson")
+
+    # Check that at least one error refers to the 'mean' field
+    assert any(err["loc"] == ("mean",) for err in excinfo.value.errors())
+    assert "mean must be a number" in excinfo.value.errors()[0]["msg"]
+
+
+def test_missing_mean_field() -> None:
+    """Omitting the mean field raises a 'field required' ValidationError."""
+    with pytest.raises(ValidationError) as excinfo:
+        # Using model_validate avoids the constructor signature check
+        RVConfig.model_validate({"distribution": "normal"})
+
+    assert any(
+        err["loc"] == ("mean",) and err["type"] == "missing"
+        for err in excinfo.value.errors()
+    )