anvil-dev-framework 0.1.6

package/global/tests/test_issue_models.py

@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+"""
+Unit tests for issue_models.py
+
+Run with: python3 -m pytest global/tests/test_issue_models.py -v
+Or:       python3 global/tests/test_issue_models.py
+"""
+
+import sys
+from pathlib import Path
+import json
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent / "lib"))
+
+from issue_models import Issue, IssueStatus, Priority
+
+
+class TestIssueStatus:
+    """Tests for IssueStatus enum."""
+
+    def test_from_linear_state_todo(self):
+        assert IssueStatus.from_linear_state("Todo") == IssueStatus.TODO
+        assert IssueStatus.from_linear_state("todo") == IssueStatus.TODO
+
+    def test_from_linear_state_in_progress(self):
+        assert IssueStatus.from_linear_state("In Progress") == IssueStatus.IN_PROGRESS
+        assert IssueStatus.from_linear_state("in progress") == IssueStatus.IN_PROGRESS
+
+    def test_from_linear_state_done(self):
+        assert IssueStatus.from_linear_state("Done") == IssueStatus.DONE
+        assert IssueStatus.from_linear_state("done") == IssueStatus.DONE
+
+    def test_from_linear_state_cancelled(self):
+        assert IssueStatus.from_linear_state("Canceled") == IssueStatus.CANCELLED
+        assert IssueStatus.from_linear_state("Cancelled") == IssueStatus.CANCELLED
+        assert IssueStatus.from_linear_state("Duplicate") == IssueStatus.CANCELLED
+
+    def test_from_linear_state_unknown_defaults_to_backlog(self):
+        assert IssueStatus.from_linear_state("Unknown State") == IssueStatus.BACKLOG
+
+    def test_to_display(self):
+        assert IssueStatus.TODO.to_display() == "Todo"
+        assert IssueStatus.IN_PROGRESS.to_display() == "In Progress"
+        assert IssueStatus.IN_REVIEW.to_display() == "In Review"
+
+
+class TestPriority:
+    """Tests for Priority enum."""
+
+    def test_from_linear_priority(self):
+        assert Priority.from_linear_priority(0) == Priority.URGENT
+        assert Priority.from_linear_priority(1) == Priority.HIGH
+        assert Priority.from_linear_priority(2) == Priority.MEDIUM
+        assert Priority.from_linear_priority(3) == Priority.LOW
+        assert Priority.from_linear_priority(4) == Priority.NONE
+
+    def test_from_linear_priority_invalid_defaults_to_none(self):
+        assert Priority.from_linear_priority(99) == Priority.NONE
+        assert Priority.from_linear_priority(-1) == Priority.NONE
+
+    def test_to_display(self):
+        assert Priority.URGENT.to_display() == "P0"
+        assert Priority.HIGH.to_display() == "P1"
+        assert Priority.MEDIUM.to_display() == "P2"
+        assert Priority.LOW.to_display() == "P3"
+        assert Priority.NONE.to_display() == "—"
+
+
+class TestIssue:
+    """Tests for Issue dataclass."""
+
+    def test_create_minimal_issue(self):
+        issue = Issue(
+            id="test-001",
+            identifier="TEST-001",
+            title="Test issue"
+        )
+        assert issue.id == "test-001"
+        assert issue.identifier == "TEST-001"
+        assert issue.title == "Test issue"
+        assert issue.status == IssueStatus.TODO
+        assert issue.priority == Priority.MEDIUM
+        assert issue.provider == "local"
+
+    def test_create_full_issue(self):
+        issue = Issue(
+            id="test-002",
+            identifier="TEST-002",
+            title="Full test issue",
+            description="Detailed description",
+            status=IssueStatus.IN_PROGRESS,
+            priority=Priority.HIGH,
+            parent_id="parent-001",
+            labels=["bug", "urgent"],
+            assigned_agent="agent-xyz",
+            estimate="2h",
+            provider="linear",
+            external_id="linear-uuid-123"
+        )
+        assert issue.description == "Detailed description"
+        assert issue.status == IssueStatus.IN_PROGRESS
+        assert issue.priority == Priority.HIGH
+        assert issue.parent_id == "parent-001"
+        assert issue.labels == ["bug", "urgent"]
+        assert issue.assigned_agent == "agent-xyz"
+        assert issue.estimate == "2h"
+        assert issue.provider == "linear"
+        assert issue.external_id == "linear-uuid-123"
+
+    def test_to_dict(self):
+        issue = Issue(
+            id="test-003",
+            identifier="TEST-003",
+            title="Dict test"
+        )
+        data = issue.to_dict()
+        assert data["id"] == "test-003"
+        assert data["identifier"] == "TEST-003"
+        assert data["title"] == "Dict test"
+        assert data["status"] == "todo"
+        assert data["priority"] == 2
+        assert isinstance(data["created_at"], str)
+        assert isinstance(data["updated_at"], str)
+
+    def test_to_json(self):
+        issue = Issue(
+            id="test-004",
+            identifier="TEST-004",
+            title="JSON test"
+        )
+        json_str = issue.to_json()
+        parsed = json.loads(json_str)
+        assert parsed["identifier"] == "TEST-004"
+
+    def test_from_dict(self):
+        data = {
+            "id": "test-005",
+            "identifier": "TEST-005",
+            "title": "From dict test",
+            "status": "in_progress",
+            "priority": 1,
+            "labels": ["feature"]
+        }
+        issue = Issue.from_dict(data)
+        assert issue.id == "test-005"
+        assert issue.identifier == "TEST-005"
+        assert issue.status == IssueStatus.IN_PROGRESS
+        assert issue.priority == Priority.HIGH
+        assert issue.labels == ["feature"]
+
+    def test_from_json(self):
+        json_str = '{"id": "test-006", "identifier": "TEST-006", "title": "From JSON"}'
+        issue = Issue.from_json(json_str)
+        assert issue.identifier == "TEST-006"
+        assert issue.title == "From JSON"
+
+    def test_roundtrip_serialization(self):
+        original = Issue(
+            id="test-007",
+            identifier="TEST-007",
+            title="Roundtrip test",
+            description="Test description",
+            status=IssueStatus.IN_REVIEW,
+            priority=Priority.URGENT,
+            labels=["test", "roundtrip"]
+        )
+        json_str = original.to_json()
+        restored = Issue.from_json(json_str)
+        assert restored.id == original.id
+        assert restored.identifier == original.identifier
+        assert restored.title == original.title
+        assert restored.description == original.description
+        assert restored.status == original.status
+        assert restored.priority == original.priority
+        assert restored.labels == original.labels
+
+    def test_from_linear(self):
+        linear_data = {
+            "id": "linear-uuid-123",
+            "identifier": "ANV-72",
+            "title": "HUD Kanban",
+            "description": "Implement Kanban board",
+            "state": {"name": "In Progress"},
+            "priority": 1,
+            "labels": {"nodes": [{"name": "feature"}, {"name": "hud"}]},
+            "createdAt": "2026-01-03T00:00:00Z",
+            "updatedAt": "2026-01-03T01:00:00Z"
+        }
+        issue = Issue.from_linear(linear_data)
+        assert issue.id == "linear-uuid-123"
+        assert issue.identifier == "ANV-72"
+        assert issue.title == "HUD Kanban"
+        assert issue.status == IssueStatus.IN_PROGRESS
+        assert issue.priority == Priority.HIGH
+        assert issue.labels == ["feature", "hud"]
+        assert issue.provider == "linear"
+        assert issue.external_id == "linear-uuid-123"
+
+    def test_is_ready(self):
+        todo_issue = Issue(id="1", identifier="T-1", title="Todo", status=IssueStatus.TODO)
+        wip_issue = Issue(id="2", identifier="T-2", title="WIP", status=IssueStatus.IN_PROGRESS)
+        assert todo_issue.is_ready() is True
+        assert wip_issue.is_ready() is False
+
+    def test_is_active(self):
+        todo = Issue(id="1", identifier="T-1", title="Todo", status=IssueStatus.TODO)
+        wip = Issue(id="2", identifier="T-2", title="WIP", status=IssueStatus.IN_PROGRESS)
+        review = Issue(id="3", identifier="T-3", title="Review", status=IssueStatus.IN_REVIEW)
+        done = Issue(id="4", identifier="T-4", title="Done", status=IssueStatus.DONE)
+        assert todo.is_active() is False
+        assert wip.is_active() is True
+        assert review.is_active() is True
+        assert done.is_active() is False
+
+    def test_is_complete(self):
+        wip = Issue(id="1", identifier="T-1", title="WIP", status=IssueStatus.IN_PROGRESS)
+        done = Issue(id="2", identifier="T-2", title="Done", status=IssueStatus.DONE)
+        cancelled = Issue(id="3", identifier="T-3", title="Cancelled", status=IssueStatus.CANCELLED)
+        assert wip.is_complete() is False
+        assert done.is_complete() is True
+        assert cancelled.is_complete() is True
+
+    def test_claim_and_unclaim(self):
+        issue = Issue(id="1", identifier="T-1", title="Test")
+        assert issue.assigned_agent is None
+
+        issue.claim("agent-123")
+        assert issue.assigned_agent == "agent-123"
+
+        issue.unclaim()
+        assert issue.assigned_agent is None
+
+    def test_transition_to(self):
+        issue = Issue(id="1", identifier="T-1", title="Test", status=IssueStatus.TODO)
+
+        issue.transition_to(IssueStatus.IN_PROGRESS)
+        assert issue.status == IssueStatus.IN_PROGRESS
+        assert issue.completed_at is None
+
+        issue.transition_to(IssueStatus.DONE)
+        assert issue.status == IssueStatus.DONE
+        assert issue.completed_at is not None
+
+        # Reopen clears completed_at
+        issue.transition_to(IssueStatus.TODO)
+        assert issue.status == IssueStatus.TODO
+        assert issue.completed_at is None
+
+    def test_str_representation(self):
+        issue = Issue(
+            id="1",
+            identifier="TEST-001",
+            title="Sample issue",
+            status=IssueStatus.IN_PROGRESS
+        )
+        assert "TEST-001" in str(issue)
+        assert "Sample issue" in str(issue)
+        assert "In Progress" in str(issue)
+
+    def test_str_with_agent(self):
+        issue = Issue(
+            id="1",
+            identifier="TEST-001",
+            title="Sample",
+            assigned_agent="agent-xyz"
+        )
+        assert "[agent-xyz]" in str(issue)
+
+
+def run_tests():
+    """Run all tests manually if pytest not available."""
+    test_classes = [TestIssueStatus, TestPriority, TestIssue]
+    passed = 0
+    failed = 0
+
+    for test_class in test_classes:
+        instance = test_class()
+        for method_name in dir(instance):
+            if method_name.startswith("test_"):
+                try:
+                    getattr(instance, method_name)()
+                    print(f"  ✓ {test_class.__name__}.{method_name}")
+                    passed += 1
+                except AssertionError as e:
+                    print(f"  ✗ {test_class.__name__}.{method_name}: {e}")
+                    failed += 1
+                except Exception as e:
+                    print(f"  ✗ {test_class.__name__}.{method_name}: {type(e).__name__}: {e}")
+                    failed += 1
+
+    print(f"\nResults: {passed} passed, {failed} failed")
+    return failed == 0
+
+
+if __name__ == "__main__":
+    print("Running issue_models tests...\n")
+    success = run_tests()
+    sys.exit(0 if success else 1)

package/global/tests/test_local_provider.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+"""
+Integration tests for LocalJsonProvider.
+
+Run with: python3 -m pytest global/tests/test_local_provider.py -v
+Or:       python3 global/tests/test_local_provider.py
+"""
+
+import sys
+import tempfile
+import shutil
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent / "lib"))
+
+from issue_models import Issue, IssueStatus, Priority
+from local_provider import LocalJsonProvider
+
+
+class TestLocalJsonProvider:
+    """Integration tests for LocalJsonProvider."""
+
+    def setup_method(self):
+        """Create temporary storage directory for each test."""
+        self.temp_dir = Path(tempfile.mkdtemp())
+        self.provider = LocalJsonProvider(
+            storage_path=self.temp_dir,
+            prefix="TEST"
+        )
+
+    def teardown_method(self):
+        """Clean up temporary directory after each test."""
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+
+    def test_provider_name(self):
+        assert self.provider.name == "local"
+
+    def test_provider_available(self):
+        assert self.provider.is_available is True
+
+    def test_create_issue(self):
+        issue = self.provider.create_issue(
+            title="Test issue",
+            description="Test description",
+            priority=Priority.HIGH
+        )
+        assert issue.identifier == "TEST-001"
+        assert issue.title == "Test issue"
+        assert issue.description == "Test description"
+        assert issue.priority == Priority.HIGH
+        assert issue.status == IssueStatus.TODO
+        assert issue.provider == "local"
+
+    def test_create_multiple_issues(self):
+        issue1 = self.provider.create_issue(title="First")
+        issue2 = self.provider.create_issue(title="Second")
+        issue3 = self.provider.create_issue(title="Third")
+
+        assert issue1.identifier == "TEST-001"
+        assert issue2.identifier == "TEST-002"
+        assert issue3.identifier == "TEST-003"
+
+    def test_list_issues(self):
+        self.provider.create_issue(title="Issue 1")
+        self.provider.create_issue(title="Issue 2")
+        self.provider.create_issue(title="Issue 3")
+
+        issues = self.provider.list_issues()
+        assert len(issues) == 3
+
+    def test_list_issues_by_status(self):
+        self.provider.create_issue(title="Todo 1", status=IssueStatus.TODO)
+        self.provider.create_issue(title="Todo 2", status=IssueStatus.TODO)
+        self.provider.create_issue(title="In Progress", status=IssueStatus.IN_PROGRESS)
+
+        todo_issues = self.provider.list_issues(status=IssueStatus.TODO)
+        wip_issues = self.provider.list_issues(status=IssueStatus.IN_PROGRESS)
+
+        assert len(todo_issues) == 2
+        assert len(wip_issues) == 1
+
+    def test_list_issues_with_limit(self):
+        for i in range(10):
+            self.provider.create_issue(title=f"Issue {i}")
+
+        issues = self.provider.list_issues(limit=5)
+        assert len(issues) == 5
+
+    def test_get_issue(self):
+        created = self.provider.create_issue(title="Find me")
+        found = self.provider.get_issue(created.identifier)
+
+        assert found is not None
+        assert found.identifier == created.identifier
+        assert found.title == "Find me"
+
+    def test_get_issue_case_insensitive(self):
+        created = self.provider.create_issue(title="Case test")
+        found = self.provider.get_issue(created.identifier.lower())
+
+        assert found is not None
+        assert found.identifier == created.identifier
+
+    def test_get_issue_not_found(self):
+        found = self.provider.get_issue("NONEXISTENT-999")
+        assert found is None
+
+    def test_get_ready_issues(self):
+        self.provider.create_issue(title="Ready 1", priority=Priority.LOW)
+        self.provider.create_issue(title="Ready 2", priority=Priority.HIGH)
+        self.provider.create_issue(title="Not ready", status=IssueStatus.IN_PROGRESS)
+
+        ready = self.provider.get_ready_issues()
+        assert len(ready) == 2
+        # Should be sorted by priority (HIGH first)
+        assert ready[0].priority == Priority.HIGH
+
+    def test_get_in_progress_issues(self):
+        self.provider.create_issue(title="Todo", status=IssueStatus.TODO)
+        self.provider.create_issue(title="WIP", status=IssueStatus.IN_PROGRESS)
+        self.provider.create_issue(title="Review", status=IssueStatus.IN_REVIEW)
+
+        active = self.provider.get_in_progress_issues()
+        assert len(active) == 2
+
+    def test_update_issue_title(self):
+        issue = self.provider.create_issue(title="Original title")
+        updated = self.provider.update_issue(issue.identifier, title="New title")
+
+        assert updated.title == "New title"
+
+        # Verify persistence
+        fetched = self.provider.get_issue(issue.identifier)
+        assert fetched.title == "New title"
+
+    def test_update_issue_status(self):
+        issue = self.provider.create_issue(title="Status test")
+        assert issue.status == IssueStatus.TODO
+
+        updated = self.provider.update_issue(
+            issue.identifier,
+            status=IssueStatus.IN_PROGRESS
+        )
+        assert updated.status == IssueStatus.IN_PROGRESS
+
+    def test_update_issue_priority(self):
+        issue = self.provider.create_issue(title="Priority test")
+        updated = self.provider.update_issue(
+            issue.identifier,
+            priority=Priority.URGENT
+        )
+        assert updated.priority == Priority.URGENT
+
+    def test_update_issue_labels(self):
+        issue = self.provider.create_issue(title="Labels test")
+        updated = self.provider.update_issue(
+            issue.identifier,
+            labels=["bug", "urgent"]
+        )
+        assert updated.labels == ["bug", "urgent"]
+
+    def test_update_issue_not_found(self):
+        try:
+            self.provider.update_issue("NONEXISTENT-999", title="New")
+            assert False, "Should have raised KeyError"
+        except KeyError:
+            pass
+
+    def test_delete_issue_soft(self):
+        issue = self.provider.create_issue(title="Delete me")
+        result = self.provider.delete_issue(issue.identifier)
+
+        assert result is True
+        fetched = self.provider.get_issue(issue.identifier)
+        assert fetched.status == IssueStatus.CANCELLED
+
+    def test_delete_issue_not_found(self):
+        result = self.provider.delete_issue("NONEXISTENT-999")
+        assert result is False
+
+    def test_hard_delete_issue(self):
+        issue = self.provider.create_issue(title="Hard delete me")
+        result = self.provider.hard_delete_issue(issue.identifier)
+
+        assert result is True
+        fetched = self.provider.get_issue(issue.identifier)
+        assert fetched is None
+
+    def test_assign_to_agent(self):
+        issue = self.provider.create_issue(title="Assign test")
+        updated = self.provider.assign_to_agent(issue.identifier, "agent-123")
+
+        assert updated.assigned_agent == "agent-123"
+
+        # Verify persistence
+        fetched = self.provider.get_issue(issue.identifier)
+        assert fetched.assigned_agent == "agent-123"
+
+    def test_unassign_agent(self):
+        issue = self.provider.create_issue(title="Unassign test")
+        self.provider.assign_to_agent(issue.identifier, "agent-123")
+        updated = self.provider.unassign_agent(issue.identifier)
+
+        assert updated.assigned_agent is None
+
+    def test_get_agent_issues(self):
+        self.provider.create_issue(title="Issue 1")
+        issue2 = self.provider.create_issue(title="Issue 2")
+        issue3 = self.provider.create_issue(title="Issue 3")
+
+        self.provider.assign_to_agent(issue2.identifier, "agent-xyz")
+        self.provider.assign_to_agent(issue3.identifier, "agent-xyz")
+
+        agent_issues = self.provider.get_agent_issues("agent-xyz")
+        assert len(agent_issues) == 2
+
+    def test_import_issues(self):
+        issues = [
+            Issue(id="imp-1", identifier="IMP-001", title="Imported 1"),
+            Issue(id="imp-2", identifier="IMP-002", title="Imported 2"),
+        ]
+        count = self.provider.import_issues(issues)
+
+        assert count == 2
+        assert self.provider.get_issue("IMP-001") is not None
+        assert self.provider.get_issue("IMP-002") is not None
+
+    def test_export_issues(self):
+        self.provider.create_issue(title="Export 1")
+        self.provider.create_issue(title="Export 2")
+
+        exported = self.provider.export_issues()
+        assert len(exported) == 2
+        assert all(isinstance(e, dict) for e in exported)
+        assert exported[0]["title"] in ["Export 1", "Export 2"]
+
+    def test_get_statistics(self):
+        self.provider.create_issue(title="T1", status=IssueStatus.TODO, priority=Priority.HIGH)
+        self.provider.create_issue(title="T2", status=IssueStatus.TODO, priority=Priority.LOW)
+        self.provider.create_issue(title="T3", status=IssueStatus.IN_PROGRESS)
+        issue = self.provider.create_issue(title="T4", status=IssueStatus.DONE)
+        self.provider.assign_to_agent(issue.identifier, "agent-1")
+
+        stats = self.provider.get_statistics()
+
+        assert stats["total"] == 4
+        assert stats["by_status"]["todo"] == 2
+        assert stats["by_status"]["in_progress"] == 1
+        assert stats["by_status"]["done"] == 1
+        assert stats["assigned"] == 1
+        assert stats["unassigned"] == 3
+
+    def test_persistence_across_instances(self):
+        # Create issue with first instance
+        self.provider.create_issue(title="Persistent issue")
+
+        # Create new provider instance pointing to same storage
+        new_provider = LocalJsonProvider(
+            storage_path=self.temp_dir,
+            prefix="TEST"
+        )
+
+        issues = new_provider.list_issues()
+        assert len(issues) == 1
+        assert issues[0].title == "Persistent issue"
+
+    def test_issue_with_parent(self):
+        parent = self.provider.create_issue(title="Parent issue")
+        child = self.provider.create_issue(
+            title="Child issue",
+            parent_id=parent.identifier
+        )
+
+        assert child.parent_id == parent.identifier
+
+        # Verify persistence
+        fetched = self.provider.get_issue(child.identifier)
+        assert fetched.parent_id == parent.identifier
+
+    def test_priority_sorting(self):
+        self.provider.create_issue(title="Low", priority=Priority.LOW)
+        self.provider.create_issue(title="Urgent", priority=Priority.URGENT)
+        self.provider.create_issue(title="Medium", priority=Priority.MEDIUM)
+
+        issues = self.provider.list_issues()
+
+        # Should be sorted: Urgent (0), Medium (2), Low (3)
+        assert issues[0].priority == Priority.URGENT
+        assert issues[1].priority == Priority.MEDIUM
+        assert issues[2].priority == Priority.LOW
+
+
+def run_tests():
+    """Run all tests manually if pytest not available."""
+    test_instance = TestLocalJsonProvider()
+    passed = 0
+    failed = 0
+
+    for method_name in sorted(dir(test_instance)):
+        if method_name.startswith("test_"):
+            test_instance.setup_method()
+            try:
+                getattr(test_instance, method_name)()
+                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}: {type(e).__name__}: {e}")
+                failed += 1
+            finally:
+                test_instance.teardown_method()
+
+    print(f"\nResults: {passed} passed, {failed} failed")
+    return failed == 0
+
+
+if __name__ == "__main__":
+    print("Running LocalJsonProvider tests...\n")
+    success = run_tests()
+    sys.exit(0 if success else 1)