Typing tests

Author: Евгений Блинов

tests/typing/test_benchmark_result_types.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from microbenchmark import BenchmarkResult, Scenario
+
+
+def make_result() -> BenchmarkResult:
+    return Scenario(lambda: None, name='s', number=10).run()
+
+
+class TestBenchmarkResultPositiveTypes:
+    def test_percentile_returns_benchmark_result(self) -> None:
+        result = make_result()
+        trimmed = result.percentile(50)
+        assert isinstance(trimmed, BenchmarkResult)
+
+    def test_p95_returns_benchmark_result(self) -> None:
+        result = make_result()
+        assert isinstance(result.p95, BenchmarkResult)
+
+    def test_p99_returns_benchmark_result(self) -> None:
+        result = make_result()
+        assert isinstance(result.p99, BenchmarkResult)
+
+    def test_to_json_returns_str(self) -> None:
+        result = make_result()
+        assert isinstance(result.to_json(), str)
+
+    def test_from_json_returns_benchmark_result(self) -> None:
+        result = make_result()
+        restored = BenchmarkResult.from_json(result.to_json())
+        assert isinstance(restored, BenchmarkResult)
+
+    def test_mean_is_float(self) -> None:
+        result = make_result()
+        assert isinstance(result.mean, float)
+
+    def test_best_is_float(self) -> None:
+        result = make_result()
+        assert isinstance(result.best, float)
+
+    def test_worst_is_float(self) -> None:
+        result = make_result()
+        assert isinstance(result.worst, float)
+
+    def test_is_primary_is_bool(self) -> None:
+        result = make_result()
+        assert isinstance(result.is_primary, bool)
+
+    def test_durations_is_tuple(self) -> None:
+        result = make_result()
+        assert isinstance(result.durations, tuple)
+
+
+class TestBenchmarkResultNegativeTypes:
+    def test_percentile_zero_raises(self) -> None:
+        result = make_result()
+        with pytest.raises(ValueError):
+            result.percentile(0)
+
+    def test_percentile_negative_raises(self) -> None:
+        result = make_result()
+        with pytest.raises(ValueError):
+            result.percentile(-1)
+
+    def test_percentile_above_100_raises(self) -> None:
+        result = make_result()
+        with pytest.raises(ValueError):
+            result.percentile(101)
+
+    def test_from_json_invalid_raises(self) -> None:
+        with pytest.raises(Exception):
+            BenchmarkResult.from_json('{not valid}')
+
+    def test_from_json_empty_object_raises(self) -> None:
+        with pytest.raises(Exception):
+            BenchmarkResult.from_json('{}')

tests/typing/test_scenario_group_types.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from microbenchmark import BenchmarkResult, Scenario, ScenarioGroup
+
+
+class TestScenarioGroupPositiveTypes:
+    def test_empty_construction(self) -> None:
+        g = ScenarioGroup()
+        assert isinstance(g, ScenarioGroup)
+
+    def test_single_scenario(self) -> None:
+        s = Scenario(lambda: None, name='s')
+        g = ScenarioGroup(s)
+        assert isinstance(g, ScenarioGroup)
+
+    def test_multiple_scenarios(self) -> None:
+        s1 = Scenario(lambda: None, name='s1')
+        s2 = Scenario(lambda: None, name='s2')
+        g = ScenarioGroup(s1, s2)
+        assert isinstance(g, ScenarioGroup)
+
+    def test_run_returns_list(self) -> None:
+        g = ScenarioGroup()
+        result = g.run()
+        assert isinstance(result, list)
+
+    def test_run_returns_list_of_benchmark_results(self) -> None:
+        s = Scenario(lambda: None, name='s', number=1)
+        g = ScenarioGroup(s)
+        results = g.run()
+        for r in results:
+            assert isinstance(r, BenchmarkResult)
+
+    def test_add_scenario_returns_group(self) -> None:
+        g = ScenarioGroup()
+        s = Scenario(lambda: None, name='s')
+        result = g + s
+        assert isinstance(result, ScenarioGroup)
+
+    def test_add_group_returns_group(self) -> None:
+        g1 = ScenarioGroup()
+        g2 = ScenarioGroup()
+        result = g1 + g2
+        assert isinstance(result, ScenarioGroup)
+
+
+class TestScenarioGroupNegativeTypes:
+    def test_add_int_returns_not_implemented(self) -> None:
+        g = ScenarioGroup()
+        result = g.__add__(42)  # type: ignore[arg-type]
+        assert result is NotImplemented

tests/typing/test_scenario_types.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import time
+
+import pytest
+
+from microbenchmark import BenchmarkResult, Scenario, ScenarioGroup
+
+
+# ---------------------------------------------------------------------------
+# Positive type checks (runtime — confirm valid usage works)
+# ---------------------------------------------------------------------------
+
+class TestScenarioPositiveTypes:
+    def test_callable_function(self) -> None:
+        s = Scenario(lambda: None, name='s')
+        assert isinstance(s, Scenario)
+
+    def test_args_none(self) -> None:
+        s = Scenario(lambda: None, args=None, name='s')
+        assert isinstance(s, Scenario)
+
+    def test_args_list(self) -> None:
+        s = Scenario(sum, args=[[1, 2, 3]], name='s')
+        assert isinstance(s, Scenario)
+
+    def test_number_int(self) -> None:
+        s = Scenario(lambda: None, name='s', number=100)
+        assert isinstance(s, Scenario)
+
+    def test_timer_callable(self) -> None:
+        s = Scenario(lambda: None, name='s', timer=time.perf_counter)
+        assert isinstance(s, Scenario)
+
+    def test_run_returns_benchmark_result(self) -> None:
+        result = Scenario(lambda: None, name='s', number=1).run()
+        assert isinstance(result, BenchmarkResult)
+
+    def test_run_with_warmup_returns_benchmark_result(self) -> None:
+        result = Scenario(lambda: None, name='s', number=1).run(warmup=0)
+        assert isinstance(result, BenchmarkResult)
+
+    def test_add_scenario_returns_group(self) -> None:
+        s1 = Scenario(lambda: None, name='s1')
+        s2 = Scenario(lambda: None, name='s2')
+        group = s1 + s2
+        assert isinstance(group, ScenarioGroup)
+
+    def test_add_group_returns_group(self) -> None:
+        s1 = Scenario(lambda: None, name='s1')
+        g = ScenarioGroup()
+        group = s1 + g
+        assert isinstance(group, ScenarioGroup)
+
+
+# ---------------------------------------------------------------------------
+# Negative type checks (runtime ValueError/TypeError for invalid inputs)
+# ---------------------------------------------------------------------------
+
+class TestScenarioNegativeTypes:
+    def test_number_zero_raises(self) -> None:
+        with pytest.raises(ValueError):
+            Scenario(lambda: None, name='s', number=0)
+
+    def test_number_negative_raises(self) -> None:
+        with pytest.raises(ValueError):
+            Scenario(lambda: None, name='s', number=-5)
+
+    def test_add_int_returns_not_implemented(self) -> None:
+        s = Scenario(lambda: None, name='s')
+        result = s.__add__(42)  # type: ignore[arg-type]
+        assert result is NotImplemented