Import L1 (celery) as l1/

2026-02-24 23:07:19 +00:00
parent 3ca1c14432 80c94ebea7
commit 4dff4cfafb
225 changed files with 57298 additions and 0 deletions
--- a/l1/tests/test_item_visibility.py
+++ b/l1/tests/test_item_visibility.py
@@ -0,0 +1,272 @@
+"""
+Tests for item visibility in L1 web UI.
+
+Bug found 2026-01-12: L1 run succeeded but web UI not showing:
+- Runs
+- Recipes
+- Created media
+
+Root causes identified:
+1. Recipes: owner field filtering but owner never set in loaded recipes
+2. Media: item_types table entries not created on upload/import
+3. Run outputs: outputs not registered in item_types table
+"""
+
+import pytest
+from pathlib import Path
+from unittest.mock import MagicMock, AsyncMock, patch
+import tempfile
+
+
+class TestRecipeVisibility:
+    """Tests for recipe listing visibility."""
+
+    def test_recipe_filter_allows_none_owner(self) -> None:
+        """
+        Regression test: The recipe filter should allow recipes where owner is None.
+
+        Bug: recipe_service.list_recipes() filtered by owner == actor_id,
+        but owner field is None in recipes loaded from S-expression files.
+        This caused ALL recipes to be filtered out.
+
+        Fix: The filter is now: actor_id is None or owner is None or owner == actor_id
+        """
+        # Simulate the filter logic from recipe_service.list_recipes
+        # OLD (broken): if actor_id is None or owner == actor_id
+        # NEW (fixed): if actor_id is None or owner is None or owner == actor_id
+
+        test_cases = [
+            # (actor_id, owner, expected_visible, description)
+            (None, None, True, "No filter, no owner -> visible"),
+            (None, "@someone@example.com", True, "No filter, has owner -> visible"),
+            ("@testuser@example.com", None, True, "Has filter, no owner -> visible (shared)"),
+            ("@testuser@example.com", "@testuser@example.com", True, "Filter matches owner -> visible"),
+            ("@testuser@example.com", "@other@example.com", False, "Filter doesn't match -> hidden"),
+        ]
+
+        for actor_id, owner, expected_visible, description in test_cases:
+            # This is the FIXED filter logic from recipe_service.py line 86
+            is_visible = actor_id is None or owner is None or owner == actor_id
+
+            assert is_visible == expected_visible, f"Failed: {description}"
+
+    def test_recipe_filter_old_logic_was_broken(self) -> None:
+        """Document that the old filter logic excluded all recipes with owner=None."""
+        # OLD filter: actor_id is None or owner == actor_id
+        # This broke when owner=None and actor_id was provided
+
+        actor_id = "@testuser@example.com"
+        owner = None  # This is what compiled sexp produces
+
+        # OLD logic (broken):
+        old_logic_visible = actor_id is None or owner == actor_id
+        assert old_logic_visible is False, "Old logic incorrectly hid owner=None recipes"
+
+        # NEW logic (fixed):
+        new_logic_visible = actor_id is None or owner is None or owner == actor_id
+        assert new_logic_visible is True, "New logic should show owner=None recipes"
+
+
+class TestMediaVisibility:
+    """Tests for media visibility after upload."""
+
+    @pytest.mark.asyncio
+    async def test_upload_content_creates_item_type_record(self) -> None:
+        """
+        Test: Uploaded media must be registered in item_types table via save_item_metadata.
+
+        The save_item_metadata function creates entries in item_types table,
+        enabling the media to appear in list_media queries.
+        """
+        import importlib.util
+        spec = importlib.util.spec_from_file_location(
+            "cache_service",
+            "/home/giles/art/art-celery/app/services/cache_service.py"
+        )
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        CacheService = module.CacheService
+
+        # Create mocks
+        mock_db = AsyncMock()
+        mock_db.create_cache_item = AsyncMock()
+        mock_db.save_item_metadata = AsyncMock()
+
+        mock_cache = MagicMock()
+        cached_result = MagicMock()
+        cached_result.cid = "QmUploadedContent123"
+        mock_cache.put.return_value = (cached_result, "QmIPFSCid123")
+
+        service = CacheService(database=mock_db, cache_manager=mock_cache)
+
+        # Upload content
+        cid, ipfs_cid, error = await service.upload_content(
+            content=b"test video content",
+            filename="test.mp4",
+            actor_id="@testuser@example.com",
+        )
+
+        assert error is None, f"Upload failed: {error}"
+        assert cid is not None
+
+        # Verify save_item_metadata was called (which creates item_types entry)
+        mock_db.save_item_metadata.assert_called_once()
+
+        # Verify it was called with correct actor_id and a media type (not mime type)
+        call_kwargs = mock_db.save_item_metadata.call_args[1]
+        assert call_kwargs.get('actor_id') == "@testuser@example.com", \
+            "save_item_metadata must be called with the uploading user's actor_id"
+        # item_type should be media category like "video", "image", "audio", "unknown"
+        # NOT mime type like "video/mp4"
+        item_type = call_kwargs.get('item_type')
+        assert item_type in ("video", "image", "audio", "unknown"), \
+            f"item_type should be media category, got '{item_type}'"
+
+    @pytest.mark.asyncio
+    async def test_import_from_ipfs_creates_item_type_record(self) -> None:
+        """
+        Test: Imported media must be registered in item_types table via save_item_metadata.
+
+        The save_item_metadata function creates entries in item_types table with
+        detected media type, enabling the media to appear in list_media queries.
+        """
+        import importlib.util
+        spec = importlib.util.spec_from_file_location(
+            "cache_service",
+            "/home/giles/art/art-celery/app/services/cache_service.py"
+        )
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        CacheService = module.CacheService
+
+        mock_db = AsyncMock()
+        mock_db.create_cache_item = AsyncMock()
+        mock_db.save_item_metadata = AsyncMock()
+
+        mock_cache = MagicMock()
+        cached_result = MagicMock()
+        cached_result.cid = "QmImportedContent123"
+        mock_cache.put.return_value = (cached_result, "QmIPFSCid456")
+
+        service = CacheService(database=mock_db, cache_manager=mock_cache)
+        service.cache_dir = Path(tempfile.gettempdir())
+
+        # We need to mock the ipfs_client module at the right location
+        import importlib
+        ipfs_module = MagicMock()
+        ipfs_module.get_file = MagicMock(return_value=True)
+
+        # Patch at module level
+        with patch.dict('sys.modules', {'ipfs_client': ipfs_module}):
+            # Import from IPFS
+            cid, error = await service.import_from_ipfs(
+                ipfs_cid="QmSourceIPFSCid",
+                actor_id="@testuser@example.com",
+            )
+
+        # Verify save_item_metadata was called (which creates item_types entry)
+        mock_db.save_item_metadata.assert_called_once()
+
+        # Verify it was called with detected media type (not hardcoded "media")
+        call_kwargs = mock_db.save_item_metadata.call_args[1]
+        item_type = call_kwargs.get('item_type')
+        assert item_type in ("video", "image", "audio", "unknown"), \
+            f"item_type should be detected media category, got '{item_type}'"
+
+
+class TestRunOutputVisibility:
+    """Tests for run output visibility."""
+
+    @pytest.mark.asyncio
+    async def test_completed_run_output_visible_in_media_list(self) -> None:
+        """
+        Run outputs should be accessible in media listings.
+
+        When a run completes, its output should be registered in item_types
+        so it appears in the user's media gallery.
+        """
+        # This test documents the expected behavior
+        # Run outputs are stored in run_cache but should also be in item_types
+        # for the media gallery to show them
+
+        # The fix should either:
+        # 1. Add item_types entry when run completes, OR
+        # 2. Modify list_media to also check run_cache outputs
+        pass  # Placeholder for implementation test
+
+
+class TestDatabaseItemTypes:
+    """Tests for item_types database operations."""
+
+    @pytest.mark.asyncio
+    async def test_add_item_type_function_exists(self) -> None:
+        """Verify add_item_type function exists and has correct signature."""
+        import database
+
+        assert hasattr(database, 'add_item_type'), \
+            "database.add_item_type function should exist"
+
+        # Check it's an async function
+        import inspect
+        assert inspect.iscoroutinefunction(database.add_item_type), \
+            "add_item_type should be an async function"
+
+    @pytest.mark.asyncio
+    async def test_get_user_items_returns_items_from_item_types(self) -> None:
+        """
+        Verify get_user_items queries item_types table.
+
+        If item_types has no entries for a user, they see no media.
+        """
+        # This is a documentation test showing the data flow:
+        # 1. User uploads content -> should create item_types entry
+        # 2. list_media -> calls get_user_items -> queries item_types
+        # 3. If step 1 didn't create item_types entry, step 2 returns empty
+        pass
+
+
+class TestTemplateRendering:
+    """Tests for template variable passing."""
+
+    def test_cache_not_found_template_receives_content_hash(self) -> None:
+        """
+        Regression test: cache/not_found.html template requires content_hash.
+
+        Bug: The template uses {{ content_hash[:24] }} but the route
+        doesn't pass content_hash to the render context.
+
+        Error: jinja2.exceptions.UndefinedError: 'content_hash' is undefined
+        """
+        # This test documents the bug - the template expects content_hash
+        # but the route at /app/app/routers/cache.py line 57 doesn't provide it
+        pass  # Will verify fix by checking route code
+
+
+class TestOwnerFieldInRecipes:
+    """Tests for owner field handling in recipes."""
+
+    def test_sexp_recipe_has_none_owner_by_default(self) -> None:
+        """
+        S-expression recipes have owner=None by default.
+
+        The compiled recipe includes owner field but it's None,
+        so the list_recipes filter must allow owner=None to show
+        shared/public recipes.
+        """
+        sample_sexp = """
+        (recipe "test"
+          (-> (source :input true :name "video")
+              (fx identity)))
+        """
+
+        from artdag.sexp import compile_string
+
+        compiled = compile_string(sample_sexp)
+        recipe_dict = compiled.to_dict()
+
+        # The compiled recipe has owner field but it's None
+        assert recipe_dict.get("owner") is None, \
+            "Compiled S-expression should have owner=None"
+
+        # This means the filter must allow owner=None for recipes to be visible
+        # The fix: if actor_id is None or owner is None or owner == actor_id