feat: initial import (exclude templates and runtime temp files)

app/tests/test_generation_strategy.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import unittest
+
+from server import (
+    resolve_build_workers,
+    resolve_extract_workers,
+    resolve_generation_strategy,
+    resolve_image_delivery_options,
+    resolve_memory_reclaim_options,
+    resolve_single_generation_mode,
+)
+
+
+class TestGenerationStrategy(unittest.TestCase):
+    def test_default_without_performance_uses_page_template_cache(self) -> None:
+        self.assertEqual(resolve_generation_strategy({}, total_records=1), "legacy")
+        self.assertEqual(resolve_generation_strategy({}, total_records=5), "page_template_cache")
+
+    def test_page_template_cache_requires_min_records(self) -> None:
+        cfg = {
+            "performance": {
+                "generation_strategy": "page_template_cache",
+                "template_cache_min_records": 2,
+                "single_slide_output": True,
+            }
+        }
+        self.assertEqual(resolve_generation_strategy(cfg, total_records=1), "legacy")
+        self.assertEqual(resolve_generation_strategy(cfg, total_records=2), "page_template_cache")
+
+    def test_page_template_cache_respects_single_slide_output(self) -> None:
+        cfg = {
+            "performance": {
+                "generation_strategy": "page_template_cache",
+                "template_cache_min_records": 1,
+                "single_slide_output": False,
+            }
+        }
+        self.assertEqual(resolve_generation_strategy(cfg, total_records=3), "legacy")
+
+    def test_legacy_strategy_always_returns_legacy(self) -> None:
+        cfg = {
+            "performance": {
+                "generation_strategy": "legacy",
+                "template_cache_min_records": 1,
+                "single_slide_output": True,
+            }
+        }
+        self.assertEqual(resolve_generation_strategy(cfg, total_records=20), "legacy")
+
+    def test_image_delivery_defaults(self) -> None:
+        opts = resolve_image_delivery_options({})
+        self.assertEqual(int(opts.get("max_kbps", 0)), 300)
+        self.assertEqual(int(opts.get("chunk_size", 0)), 16 * 1024)
+
+    def test_image_delivery_disable_limit(self) -> None:
+        cfg = {"performance": {"image_delivery": {"enabled": False, "max_kbps": 999}}}
+        opts = resolve_image_delivery_options(cfg)
+        self.assertEqual(int(opts.get("max_kbps", -1)), 0)
+
+    def test_single_generation_mode_defaults_enabled(self) -> None:
+        self.assertTrue(resolve_single_generation_mode({}))
+        self.assertFalse(resolve_single_generation_mode({"performance": {"single_generation_mode": False}}))
+
+    def test_build_workers_default_single(self) -> None:
+        self.assertEqual(resolve_build_workers({}, total_records=10), 1)
+        cfg = {"performance": {"max_build_workers": 3}}
+        self.assertEqual(resolve_build_workers(cfg, total_records=2), 2)
+
+    def test_extract_workers_default_single(self) -> None:
+        self.assertEqual(resolve_extract_workers({}), 1)
+        cfg = {"performance": {"max_extract_workers": 4}}
+        self.assertGreaterEqual(resolve_extract_workers(cfg), 1)
+
+    def test_memory_reclaim_defaults_enabled(self) -> None:
+        opts = resolve_memory_reclaim_options({})
+        self.assertTrue(opts["enabled"])
+        self.assertTrue(opts["gc_collect"])
+        self.assertTrue(opts["malloc_trim"])
+
+    def test_memory_reclaim_can_disable(self) -> None:
+        opts = resolve_memory_reclaim_options({"performance": {"memory_reclaim": {"enabled": False}}})
+        self.assertFalse(opts["enabled"])
+        self.assertFalse(opts["gc_collect"])
+        self.assertFalse(opts["malloc_trim"])
+
+
+if __name__ == "__main__":
+    unittest.main()