@flisk-sh/flisk 0.0.0-stage → 1.3.190

package/discovery/test_resource_snapshot.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 Flisk contributors
+# SPDX-License-Identifier: MIT
+"""
+🧪 Tests for resource_snapshot.py
+
+Run with: python3 -m pytest test_resource_snapshot.py -v
+Or: python3 test_resource_snapshot.py
+"""
+
+import json
+import os
+import sys
+import tempfile
+import shutil
+from pathlib import Path
+import pytest
+
+# Add parent directory to path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from resource_snapshot import (
+    save_snapshot,
+    load_snapshot,
+    diff_snapshots,
+    get_current_services,
+)
+
+
+@pytest.fixture
+def temp_workspace(tmp_path):
+    """Provide a temporary workspace with automatic cleanup."""
+    original_dir = os.getcwd()
+    os.chdir(tmp_path)
+    yield tmp_path
+    os.chdir(original_dir)
+
+
+class TestSaveSnapshot:
+    """Tests for save_snapshot function."""
+    
+    def test_save_creates_file(self, temp_workspace):
+        """Test that save_snapshot creates the snapshot file."""
+        services = ["services/a/service.json", "services/b/service.json"]
+        save_snapshot(services)
+        
+        snapshot_file = Path(".tdk/.tdk-out/snapshots/resource-snapshot.json")
+        assert snapshot_file.exists(), "Snapshot file should be created"
+        
+        # Verify content
+        with open(snapshot_file) as f:
+            data = json.load(f)
+            assert data["count"] == 2
+            assert data["services"] == services
+            assert "timestamp" in data
+    
+    def test_save_creates_directory(self, temp_workspace):
+        """Test that save_snapshot creates the .flisk directory if needed."""
+        services = ["services/test/service.json"]
+        save_snapshot(services)
+        
+        assert Path(".tdk/.tdk-out/snapshots").exists(), ".tdk/.tdk-out/snapshots directory should be created"
+
+
+class TestLoadSnapshot:
+    """Tests for load_snapshot function."""
+    
+    def test_load_existing(self, temp_workspace):
+        """Test loading an existing snapshot."""
+        # Create a snapshot first
+        services = ["services/a/service.json"]
+        save_snapshot(services)
+        
+        # Load it
+        snapshot = load_snapshot()
+        
+        assert snapshot["count"] == 1
+        assert snapshot["services"] == services
+        assert "timestamp" in snapshot
+    
+    def test_load_nonexistent(self, temp_workspace):
+        """Test loading when snapshot doesn't exist."""
+        snapshot = load_snapshot()
+        
+        assert snapshot["count"] == 0
+        assert snapshot["services"] == []
+        assert snapshot["timestamp"] is None
+    
+    def test_load_invalid_json(self, temp_workspace):
+        """Test loading when snapshot has invalid JSON."""
+        # Create invalid snapshot
+        Path(".tdk/.tdk-out/snapshots").mkdir(parents=True, exist_ok=True)
+        with open(".tdk/.tdk-out/snapshots/resource-snapshot.json", "w") as f:
+            f.write("not valid json")
+        
+        snapshot = load_snapshot()
+        
+        # Should return empty snapshot on error
+        assert snapshot["count"] == 0
+        assert snapshot["services"] == []
+
+
+class TestDiffSnapshots:
+    """Tests for diff_snapshots function."""
+    
+    def test_detect_added(self):
+        """Test detecting added services."""
+        old = {"services": ["a/service.json", "b/service.json"]}
+        new = ["a/service.json", "b/service.json", "c/service.json"]
+        
+        added, removed, modified = diff_snapshots(old, new)
+        
+        assert added == {"c/service.json"}
+        assert removed == set()
+        assert modified == set()
+    
+    def test_detect_removed(self):
+        """Test detecting removed services."""
+        old = {"services": ["a/service.json", "b/service.json", "c/service.json"]}
+        new = ["a/service.json", "b/service.json"]
+        
+        added, removed, modified = diff_snapshots(old, new)
+        
+        assert added == set()
+        assert removed == {"c/service.json"}
+        assert modified == set()
+    
+    def test_detect_both(self):
+        """Test detecting both added and removed."""
+        old = {"services": ["a/service.json", "b/service.json"]}
+        new = ["b/service.json", "c/service.json"]
+        
+        added, removed, modified = diff_snapshots(old, new)
+        
+        assert added == {"c/service.json"}
+        assert removed == {"a/service.json"}
+        assert modified == set()
+    
+    def test_no_changes(self):
+        """Test when nothing changed."""
+        old = {"services": ["a/service.json", "b/service.json"]}
+        new = ["a/service.json", "b/service.json"]
+        
+        added, removed, modified = diff_snapshots(old, new)
+        
+        assert added == set()
+        assert removed == set()
+        assert modified == set()
+    
+    def test_empty_old(self):
+        """Test when old snapshot is empty."""
+        old = {"services": []}
+        new = ["a/service.json", "b/service.json"]
+        
+        added, removed, modified = diff_snapshots(old, new)
+        
+        assert added == {"a/service.json", "b/service.json"}
+        assert removed == set()
+        assert modified == set()
+
+
+class TestGetCurrentServices:
+    """Tests for get_current_services function."""
+    
+    def test_finds_services(self, temp_workspace):
+        """Test finding service.json files."""
+        # Create test directory structure
+        (Path("services/product/a") / "a-backend").mkdir(parents=True)
+        (Path("services/product/a") / "a-backend" / "service.json").touch()
+        
+        (Path("services/product/b") / "b-backend").mkdir(parents=True)
+        (Path("services/product/b") / "b-backend" / "service.json").touch()
+        
+        services = get_current_services("services/product")
+        
+        assert len(services) == 2
+        assert all("service.json" in s for s in services)
+    
+    def test_empty_result(self, temp_workspace):
+        """Test when no services exist."""
+        # Create empty directory
+        Path("services/product").mkdir(parents=True)
+        
+        services = get_current_services("services/product")
+        
+        assert services == []
+    
+    def test_nonexistent_root(self, temp_workspace):
+        """Test when scan root doesn't exist."""
+        services = get_current_services("nonexistent/path")
+        
+        assert services == []
+
+
+def run_tests():
+    """Run all tests with basic output."""
+    import tempfile
+    import inspect
+    
+    print("🧪 Running resource_snapshot tests...")
+    print("=" * 50)
+    
+    passed = 0
+    failed = 0
+    
+    test_classes = [
+        TestSaveSnapshot,
+        TestLoadSnapshot,
+        TestDiffSnapshots,
+        TestGetCurrentServices,
+    ]
+    
+    for test_class in test_classes:
+        print(f"\n📦 {test_class.__name__}")
+        
+        # Get all test methods
+        for method_name in dir(test_class):
+            if method_name.startswith("test_"):
+                test_method = getattr(test_class(), method_name)
+                
+                # Check if method needs tmp_path parameter
+                sig = inspect.signature(test_method)
+                needs_tmp_path = len(sig.parameters) > 0
+                
+                # Create temp directory for test
+                with tempfile.TemporaryDirectory() as tmp_dir:
+                    try:
+                        if needs_tmp_path:
+                            test_method(Path(tmp_dir))
+                        else:
+                            test_method()
+                        print(f"  ✓ {method_name}")
+                        passed += 1
+                    except AssertionError as e:
+                        print(f"  ✗ {method_name}: {e}")
+                        failed += 1
+                    except Exception as e:
+                        print(f"  ✗ {method_name}: Exception - {e}")
+                        failed += 1
+    
+    print("\n" + "=" * 50)
+    print(f"📊 Results: {passed} passed, {failed} failed")
+    
+    if failed == 0:
+        print("🎉 All tests passed!")
+        return 0
+    else:
+        print(f"⚠️  {failed} test(s) failed")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(run_tests())

package/discovery/validation.star

@@ -0,0 +1,80 @@
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+load("./TILT_DISCOVERY.star",
+    "VALID_STACKS",
+    "VALID_RESOURCE_FEATURES",
+    "PORT_RANGES",
+)
+load("../engine/topologies/tilt/manifest/constants.star", "VALID_APP_TYPES")
+
+
+def validate(manifest):
+    issues = []
+
+    app_name = manifest.get("appName")
+    if not app_name:
+        issues.append("Missing required field: appName")
+    elif type(app_name) != "string":
+        issues.append("appName must be a string")
+    elif len(app_name) < 3:
+        issues.append("appName too short: '" + app_name + "'. Minimum 3 characters")
+    elif len(app_name) > 64:
+        issues.append("appName too long: '" + app_name + "'. Maximum 64 characters")
+
+    for i in range(len(app_name or "")):
+        char = app_name[i]
+        if not (char.islower() or char.isdigit() or char == "-"):
+            issues.append("Invalid character in appName: '" + char + "'. Must be kebab-case")
+            break
+    if app_name and (app_name.startswith("-") or app_name.endswith("-")):
+        issues.append("appName cannot start or end with a hyphen")
+
+    app_type = manifest.get("appType")
+    if not app_type:
+        issues.append("Missing required field: appType")
+    elif app_type not in VALID_APP_TYPES:
+        issues.append("Invalid appType: " + str(app_type) + ". Must be one of: " + ", ".join(VALID_APP_TYPES))
+
+    stack = manifest.get("stack")
+    if not stack:
+        issues.append("Missing required field: stack")
+    elif len(VALID_STACKS) > 0 and stack not in VALID_STACKS:
+        # Only validate against list if VALID_STACKS is not empty
+        issues.append("Invalid stack: " + str(stack) + ". Must be one of: " + ", ".join(VALID_STACKS))
+
+    port = manifest.get("port")
+    if port == None:
+        if app_type != "infra":
+            issues.append("Missing required field: port")
+    elif type(port) != "int":
+        issues.append("Invalid port: " + str(port) + ". Must be an integer")
+    elif app_type != "infra":
+        if port < 3000 or port > 9999:
+            issues.append("Invalid port: " + str(port) + ". Must be integer 3000-9999")
+        elif app_type and app_type in PORT_RANGES:
+            port_range = PORT_RANGES[app_type]
+            if port < port_range["min"] or port > port_range["max"]:
+                issues.append("Port " + str(port) + " out of range for " + app_type)
+
+    features = manifest.get("featuresEnabled", [])
+    if type(features) != "list":
+        issues.append("Invalid features: must be an array")
+    else:
+        for feature in features:
+            if feature not in VALID_RESOURCE_FEATURES:
+                issues.append("Invalid feature: " + str(feature))
+
+    deps = manifest.get("dependsOn", [])
+    if type(deps) != "list":
+        issues.append("Invalid dependsOn: must be an array")
+
+    replicas = manifest.get("replicas")
+    if replicas != None:
+        if type(replicas) != "int":
+            issues.append("Invalid replicas: must be an integer")
+        elif replicas < 1:
+            issues.append("Invalid replicas: " + str(replicas) + ". Minimum is 1")
+        elif replicas > 10:
+            issues.append("Invalid replicas: " + str(replicas) + ". Maximum is 10")
+
+    return issues

package/discovery/versioning.star

@@ -0,0 +1,3 @@
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+MANIFEST_DISCOVERY_VERSION = "1.0"