bug fixed

Author: GioeleB00

.gitattributes

@@ -0,0 +1,12 @@
+# Unix-style line endings (LF) 
+*.sh      text eol=lf
+*.py      text eol=lf
+*.yml     text eol=lf
+*.yaml    text eol=lf
+*.toml    text eol=lf
+*.cfg     text eol=lf
+*.ini     text eol=lf
+Makefile  text eol=lf
+
+# PowerShell 
+*.ps1     text eol=crlf

simulation_base.png

@@ -8,7 +8,7 @@
     srv-2 → client
 
 Each server endpoint: CPU(2 ms) → RAM(128 MB) → IO(12 ms)
-Edges: exponential latency ~2–3 ms.
+Edges: exponential latency ~2-3 ms.
 We check:
 - latency stats / throughput sanity vs nominal λ (~40 rps);
 - balanced traffic across srv-1 / srv-2 via edge concurrency and RAM means.
@@ -18,19 +18,23 @@
 
 import os
 import random
-from typing import Dict, List
+from typing import TYPE_CHECKING
 
 import numpy as np
 import pytest
 import simpy
 
 from asyncflow import AsyncFlow
 from asyncflow.components import Client, Edge, Endpoint, LoadBalancer, Server
-from asyncflow.metrics.analyzer import ResultsAnalyzer
+from asyncflow.config.constants import LatencyKey
 from asyncflow.runtime.simulation_runner import SimulationRunner
 from asyncflow.settings import SimulationSettings
 from asyncflow.workload import RqsGenerator
-from asyncflow.config.constants import LatencyKey
+
+if TYPE_CHECKING:
+    # Imported only for type checking (ruff: TC001)
+    from asyncflow.metrics.analyzer import ResultsAnalyzer
+    from asyncflow.schemas.payload import SimulationPayload
 
 pytestmark = [
     pytest.mark.system,
@@ -41,17 +45,17 @@
 ]
 
 SEED = 4242
-REL_TOL = 0.30   # 30% for λ/latency
-BAL_TOL = 0.25   # 25% imbalance tolerated between the two backends
+REL_TOL = 0.30  # 30% for λ/latency
+BAL_TOL = 0.25  # 25% imbalance tolerated between the two backends
 
 
 def _seed_all(seed: int = SEED) -> None:
     random.seed(seed)
-    np.random.seed(seed)
+    np.random.seed(seed)  # noqa: NPY002
     os.environ["PYTHONHASHSEED"] = str(seed)
 
 
-def _build_payload():
+def _build_payload() -> SimulationPayload:
     gen = RqsGenerator(
         id="rqs-1",
         avg_active_users={"mean": 120},
@@ -68,10 +72,22 @@ def _build_payload():
             {"kind": "io_wait", "step_operation": {"io_waiting_time": 0.012}},
         ],
     )
-    srv1 = Server(id="srv-1", server_resources={"cpu_cores": 1, "ram_mb": 2048}, endpoints=[endpoint])
-    srv2 = Server(id="srv-2", server_resources={"cpu_cores": 1, "ram_mb": 2048}, endpoints=[endpoint])
+    srv1 = Server(
+        id="srv-1",
+        server_resources={"cpu_cores": 1, "ram_mb": 2048},
+        endpoints=[endpoint],
+    )
+    srv2 = Server(
+        id="srv-2",
+        server_resources={"cpu_cores": 1, "ram_mb": 2048},
+        endpoints=[endpoint],
+    )
 
-    lb = LoadBalancer(id="lb-1", algorithms="round_robin", server_covered={"srv-1", "srv-2"})
+    lb = LoadBalancer(
+        id="lb-1",
+        algorithms="round_robin",
+        server_covered={"srv-1", "srv-2"},
+    )
 
     edges = [
         Edge(
@@ -151,7 +167,8 @@ def test_system_lb_two_servers_balanced_and_sane() -> None:
 
     # Latency sanity
     stats = res.get_latency_stats()
-    assert stats and LatencyKey.TOTAL_REQUESTS in stats
+    assert stats, "Expected non-empty stats."
+    assert LatencyKey.TOTAL_REQUESTS in stats
     mean_lat = float(stats.get(LatencyKey.MEAN, 0.0))
     assert 0.020 <= mean_lat <= 0.060
 
@@ -164,15 +181,22 @@ def test_system_lb_two_servers_balanced_and_sane() -> None:
 
     # Load balance check: edge concurrency lb→srv1 vs lb→srv2 close
     sampled = res.get_sampled_metrics()
-    edge_cc: Dict[str, List[float]] = sampled.get("edge_concurrent_connection", {})
-    assert "lb-srv1" in edge_cc and "lb-srv2" in edge_cc
-    m1, m2 = float(np.mean(edge_cc["lb-srv1"])), float(np.mean(edge_cc["lb-srv2"]))
+    edge_cc: dict[str, list[float]] = sampled.get(
+        "edge_concurrent_connection",
+        {},
+    )
+    assert "lb-srv1" in edge_cc
+    assert "lb-srv2" in edge_cc
+    m1 = float(np.mean(edge_cc["lb-srv1"]))
+    m2 = float(np.mean(edge_cc["lb-srv2"]))
     assert _rel_diff(m1, m2) <= BAL_TOL
 
     # Server metrics present and broadly similar (RAM means close-ish)
-    ram_map: Dict[str, List[float]] = sampled.get("ram_in_use", {})
-    assert "srv-1" in ram_map and "srv-2" in ram_map
-    ram1, ram2 = float(np.mean(ram_map["srv-1"])), float(np.mean(ram_map["srv-2"]))
+    ram_map: dict[str, list[float]] = sampled.get("ram_in_use", {})
+    assert "srv-1" in ram_map
+    assert "srv-2" in ram_map
+    ram1 = float(np.mean(ram_map["srv-1"]))
+    ram2 = float(np.mean(ram_map["srv-2"]))
     assert _rel_diff(ram1, ram2) <= BAL_TOL
 
     # IDs reported by analyzer

tests/system/test_sys_lb_two_servers.py

@@ -1,37 +1,40 @@
-"""System test: single-server scenario (deterministic-seeded, reproducible).
-
-Runs a compact but realistic topology:
+"""System test: single server (seeded, reproducible).
 
+Topology:
     generator → client → srv-1 → client
 
-Endpoint on srv-1: CPU(1.5 ms) → RAM(96 MB) → IO(10 ms)
-Edges: exponential latency ~3 ms each way.
+Endpoint:
+    CPU(1 ms) → RAM(64 MB) → IO(10 ms)
+Edges: exponential latency ~2-3 ms.
 
-Assertions (with sensible tolerances):
-- non-empty latency stats; mean latency in a plausible band;
-- mean throughput close to the nominal λ (±30%);
-- sampled metrics exist for srv-1 and are non-empty.
+Checks:
+- latency stats present and plausible (broad bounds);
+- throughput roughly consistent with nominal λ;
+- basic sampled metrics present for srv-1.
 """
 
 from __future__ import annotations
 
 import os
 import random
-from typing import Dict, List
+from typing import TYPE_CHECKING
 
 import numpy as np
 import pytest
 import simpy
 
 from asyncflow import AsyncFlow
 from asyncflow.components import Client, Edge, Endpoint, Server
-from asyncflow.metrics.analyzer import ResultsAnalyzer
+from asyncflow.config.constants import LatencyKey
 from asyncflow.runtime.simulation_runner import SimulationRunner
 from asyncflow.settings import SimulationSettings
 from asyncflow.workload import RqsGenerator
-from asyncflow.config.constants import LatencyKey
 
-# Mark as system and skip unless explicitly enabled in CI (or locally)
+if TYPE_CHECKING:
+    # Imported only for type checking (ruff: TC001)
+    from asyncflow.metrics.analyzer import ResultsAnalyzer
+    from asyncflow.schemas.payload import SimulationPayload
+
 pytestmark = [
     pytest.mark.system,
     pytest.mark.skipif(
@@ -41,16 +44,16 @@
 ]
 
 SEED = 1337
-REL_TOL = 0.30  # 30% tolerance for stochastic expectations
+REL_TOL = 0.35  # generous bound for simple sanity
 
 
 def _seed_all(seed: int = SEED) -> None:
     random.seed(seed)
-    np.random.seed(seed)
+    np.random.seed(seed)  # noqa: NPY002
     os.environ["PYTHONHASHSEED"] = str(seed)
 
 
-def _build_payload():
+def _build_payload() -> SimulationPayload:
     # Workload: ~26.7 rps (80 users * 20 rpm / 60)
     gen = RqsGenerator(
         id="rqs-1",
@@ -63,12 +66,16 @@ def _build_payload():
     ep = Endpoint(
         endpoint_name="/api",
         steps=[
-            {"kind": "initial_parsing", "step_operation": {"cpu_time": 0.0015}},
-            {"kind": "ram", "step_operation": {"necessary_ram": 96}},
+            {"kind": "initial_parsing", "step_operation": {"cpu_time": 0.001}},
+            {"kind": "ram", "step_operation": {"necessary_ram": 64}},
             {"kind": "io_wait", "step_operation": {"io_waiting_time": 0.010}},
         ],
     )
-    srv = Server(id="srv-1", server_resources={"cpu_cores": 1, "ram_mb": 2048}, endpoints=[ep])
+    srv = Server(
+        id="srv-1",
+        server_resources={"cpu_cores": 1, "ram_mb": 2048},
+        endpoints=[ep],
+    )
 
     edges = [
         Edge(
@@ -81,7 +88,7 @@ def _build_payload():
             id="client-srv",
             source="client-1",
             target="srv-1",
-            latency={"mean": 0.003, "distribution": "exponential"},
+            latency={"mean": 0.002, "distribution": "exponential"},
         ),
         Edge(
             id="srv-client",
@@ -92,7 +99,7 @@ def _build_payload():
     ]
 
     settings = SimulationSettings(
-        total_simulation_time=180,  # virtual time; keeps wall time fast
+        total_simulation_time=400,
         sample_period_s=0.05,
         enabled_sample_metrics=[
             "ready_queue_len",
@@ -103,13 +110,19 @@ def _build_payload():
         enabled_event_metrics=["rqs_clock"],
     )
 
-    flow = AsyncFlow().add_generator(gen).add_client(client).add_servers(srv).add_edges(*edges)
+    flow = (
+        AsyncFlow()
+        .add_generator(gen)
+        .add_client(client)
+        .add_servers(srv)
+        .add_edges(*edges)
+    )
     flow = flow.add_simulation_settings(settings)
     return flow.build_payload()
 
 
-def test_system_single_server_end_to_end() -> None:
-    """End-to-end single-server check with tolerances and seeded RNGs."""
+def test_system_single_server_sane() -> None:
+    """End-to-end single-server scenario: sanity checks with seeded RNGs."""
     _seed_all()
 
     env = simpy.Environment()
@@ -118,19 +131,21 @@ def test_system_single_server_end_to_end() -> None:
 
     # Latency stats present and plausible
     stats = res.get_latency_stats()
-    assert stats and LatencyKey.TOTAL_REQUESTS in stats
+    assert stats, "Expected non-empty stats."
+    assert LatencyKey.TOTAL_REQUESTS in stats
     mean_lat = float(stats.get(LatencyKey.MEAN, 0.0))
     assert 0.015 <= mean_lat <= 0.060
 
-    # Throughput close to nominal lambda
-    timestamps, rps = res.get_throughput_series()
-    assert timestamps, "No throughput series produced."
+    # Throughput sanity vs nominal λ
+    _, rps = res.get_throughput_series()
+    assert rps, "No throughput series produced."
     rps_mean = float(np.mean(rps))
     lam = 80 * 20 / 60.0
     assert abs(rps_mean - lam) / lam <= REL_TOL
 
-    # Sampled metrics exist for srv-1
-    sampled: Dict[str, Dict[str, List[float]]] = res.get_sampled_metrics()
+    # Sampled metrics present for srv-1
+    sampled: dict[str, dict[str, list[float]]] = res.get_sampled_metrics()
     for key in ("ready_queue_len", "event_loop_io_sleep", "ram_in_use"):
-        assert key in sampled and "srv-1" in sampled[key]
+        assert key in sampled
+        assert "srv-1" in sampled[key]
         assert len(sampled[key]["srv-1"]) > 0