zwarm 2.3.5__py3-none-any.whl

zwarm/core/test_config.py

@@ -0,0 +1,160 @@
+"""Tests for the config system."""
+
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from zwarm.core.config import (
+    ZwarmConfig,
+    apply_overrides,
+    deep_merge,
+    load_config,
+    load_yaml_config,
+)
+
+
+def test_default_config():
+    """Test default configuration values."""
+    config = ZwarmConfig()
+    assert config.executor.adapter == "codex_mcp"
+    assert config.executor.sandbox == "workspace-write"
+    assert config.orchestrator.lm == "gpt-5-mini"
+    assert config.orchestrator.sync_first is True
+    assert config.state_dir == ".zwarm"
+
+
+def test_config_from_dict():
+    """Test creating config from dictionary."""
+    data = {
+        "executor": {"adapter": "claude_code", "model": "claude-sonnet"},
+        "orchestrator": {"lm": "gpt-5", "max_steps": 100},
+        "state_dir": ".my_state",
+    }
+    config = ZwarmConfig.from_dict(data)
+    assert config.executor.adapter == "claude_code"
+    assert config.executor.model == "claude-sonnet"
+    assert config.orchestrator.lm == "gpt-5"
+    assert config.orchestrator.max_steps == 100
+    assert config.state_dir == ".my_state"
+
+
+def test_config_to_dict():
+    """Test converting config to dictionary."""
+    config = ZwarmConfig()
+    data = config.to_dict()
+    assert data["executor"]["adapter"] == "codex_mcp"
+    assert data["orchestrator"]["lm"] == "gpt-5-mini"
+
+
+def test_deep_merge():
+    """Test deep merging of dictionaries."""
+    base = {"a": 1, "b": {"c": 2, "d": 3}}
+    override = {"b": {"c": 99}, "e": 4}
+    result = deep_merge(base, override)
+    assert result == {"a": 1, "b": {"c": 99, "d": 3}, "e": 4}
+
+
+def test_apply_overrides():
+    """Test CLI override application."""
+    config = {"executor": {"adapter": "codex"}, "orchestrator": {"max_steps": 10}}
+
+    # Override nested value
+    result = apply_overrides(config, ["orchestrator.max_steps=50"])
+    assert result["orchestrator"]["max_steps"] == 50
+
+    # Override with string
+    result = apply_overrides(config, ["executor.adapter=claude_code"])
+    assert result["executor"]["adapter"] == "claude_code"
+
+    # Override with boolean
+    result = apply_overrides(config, ["orchestrator.sync_first=false"])
+    assert result["orchestrator"]["sync_first"] is False
+
+    # Create new nested path
+    result = apply_overrides(config, ["weave.project=my-project"])
+    assert result["weave"]["project"] == "my-project"
+
+
+def test_yaml_inheritance():
+    """Test YAML config inheritance via extends."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        base_path = Path(tmpdir) / "base.yaml"
+        child_path = Path(tmpdir) / "child.yaml"
+
+        # Write base config
+        base_path.write_text("""
+executor:
+  adapter: codex_mcp
+  timeout: 3600
+orchestrator:
+  lm: gpt-5-mini
+  max_steps: 30
+""")
+
+        # Write child config that extends base
+        child_path.write_text("""
+extends: base.yaml
+orchestrator:
+  lm: gpt-5
+  prompt: prompts/aggressive.yaml
+""")
+
+        config = load_yaml_config(child_path)
+        assert config["executor"]["adapter"] == "codex_mcp"
+        assert config["executor"]["timeout"] == 3600
+        assert config["orchestrator"]["lm"] == "gpt-5"  # overridden
+        assert config["orchestrator"]["max_steps"] == 30  # inherited
+        assert config["orchestrator"]["prompt"] == "prompts/aggressive.yaml"  # new
+
+
+def test_load_config_full_chain():
+    """Test full config loading with precedence."""
+    import os
+
+    # Save and clear WEAVE_PROJECT to test config precedence
+    orig_weave = os.environ.pop("WEAVE_PROJECT", None)
+
+    try:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = Path(tmpdir)
+
+            # Write config.toml
+            toml_path = tmpdir / "config.toml"
+            toml_path.write_text("""
+[weave]
+project = "my-weave-project"
+
+[executor]
+adapter = "codex_mcp"
+""")
+
+            # Write yaml config
+            yaml_path = tmpdir / "experiment.yaml"
+            yaml_path.write_text("""
+orchestrator:
+  lm: claude-sonnet
+  max_steps: 100
+""")
+
+            # Load with override (use non-existent env_path to prevent loading cwd's .env)
+            config = load_config(
+                config_path=yaml_path,
+                toml_path=toml_path,
+                env_path=tmpdir / ".env.nonexistent",
+                overrides=["orchestrator.max_steps=200"],
+            )
+
+            # Check precedence: override > yaml > toml > default
+            assert config.weave.project == "my-weave-project"  # from toml
+            assert config.executor.adapter == "codex_mcp"  # from toml
+            assert config.orchestrator.lm == "claude-sonnet"  # from yaml
+            assert config.orchestrator.max_steps == 200  # from override
+    finally:
+        # Restore WEAVE_PROJECT
+        if orig_weave is not None:
+            os.environ["WEAVE_PROJECT"] = orig_weave
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

zwarm/core/test_models.py

@@ -0,0 +1,265 @@
+"""Tests for core models and state management."""
+
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from zwarm.core.models import (
+    ConversationSession,
+    Event,
+    Message,
+    SessionMode,
+    SessionStatus,
+    Task,
+    TaskStatus,
+    event_session_completed,
+    event_session_started,
+    event_task_created,
+)
+from zwarm.core.state import StateManager
+
+
+class TestMessage:
+    def test_create_message(self):
+        msg = Message(role="user", content="Hello")
+        assert msg.role == "user"
+        assert msg.content == "Hello"
+        assert msg.timestamp is not None
+
+    def test_message_serialization(self):
+        msg = Message(role="assistant", content="Hi there")
+        data = msg.to_dict()
+        restored = Message.from_dict(data)
+        assert restored.role == msg.role
+        assert restored.content == msg.content
+
+
+class TestConversationSession:
+    def test_create_session(self):
+        session = ConversationSession(
+            adapter="codex_mcp",
+            mode=SessionMode.SYNC,
+            task_description="Test task",
+        )
+        assert session.id is not None
+        assert session.adapter == "codex_mcp"
+        assert session.mode == SessionMode.SYNC
+        assert session.status == SessionStatus.ACTIVE
+
+    def test_add_message(self):
+        session = ConversationSession()
+        session.add_message("user", "Hello")
+        session.add_message("assistant", "Hi there")
+        assert len(session.messages) == 2
+        assert session.messages[0].role == "user"
+        assert session.messages[1].role == "assistant"
+
+    def test_complete_session(self):
+        session = ConversationSession()
+        session.complete("Done!")
+        assert session.status == SessionStatus.COMPLETED
+        assert session.completed_at is not None
+        assert session.exit_message == "Done!"
+
+    def test_fail_session(self):
+        session = ConversationSession()
+        session.fail("Error occurred")
+        assert session.status == SessionStatus.FAILED
+        assert session.exit_message == "Error occurred"
+
+    def test_session_serialization(self):
+        session = ConversationSession(
+            adapter="claude_code",
+            mode=SessionMode.ASYNC,
+            task_description="Build feature",
+            model="claude-sonnet",
+        )
+        session.add_message("user", "Start")
+        session.conversation_id = "conv-123"
+
+        data = session.to_dict()
+        restored = ConversationSession.from_dict(data)
+
+        assert restored.id == session.id
+        assert restored.adapter == "claude_code"
+        assert restored.mode == SessionMode.ASYNC
+        assert restored.conversation_id == "conv-123"
+        assert len(restored.messages) == 1
+
+
+class TestTask:
+    def test_create_task(self):
+        task = Task(description="Fix the bug")
+        assert task.id is not None
+        assert task.status == TaskStatus.PENDING
+
+    def test_task_lifecycle(self):
+        task = Task(description="Implement feature")
+
+        # Start
+        task.start("session-123")
+        assert task.status == TaskStatus.IN_PROGRESS
+        assert task.session_id == "session-123"
+
+        # Complete
+        task.complete("Feature implemented")
+        assert task.status == TaskStatus.COMPLETED
+        assert task.result == "Feature implemented"
+
+    def test_task_serialization(self):
+        task = Task(description="Test task", parent_task_id="parent-123")
+        task.start("session-456")
+
+        data = task.to_dict()
+        restored = Task.from_dict(data)
+
+        assert restored.id == task.id
+        assert restored.description == "Test task"
+        assert restored.parent_task_id == "parent-123"
+        assert restored.session_id == "session-456"
+
+
+class TestEvent:
+    def test_create_event(self):
+        event = Event(
+            kind="test_event",
+            session_id="session-123",
+            payload={"key": "value"},
+        )
+        assert event.id is not None
+        assert event.kind == "test_event"
+
+    def test_event_factories(self):
+        session = ConversationSession(task_description="Test")
+        event = event_session_started(session)
+        assert event.kind == "session_started"
+        assert event.session_id == session.id
+
+        task = Task(description="Do something")
+        event = event_task_created(task)
+        assert event.kind == "task_created"
+        assert event.task_id == task.id
+
+
+class TestStateManager:
+    def test_init_creates_directories(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            state_dir = Path(tmpdir) / ".zwarm"
+            manager = StateManager(state_dir)
+            manager.init()
+
+            assert state_dir.exists()
+            assert (state_dir / "sessions").exists()
+            assert (state_dir / "orchestrator").exists()
+            assert (state_dir / "events.jsonl").exists()
+
+    def test_session_crud(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = StateManager(Path(tmpdir) / ".zwarm")
+            manager.init()
+
+            # Add
+            session = ConversationSession(task_description="Test")
+            manager.add_session(session)
+
+            # Get
+            retrieved = manager.get_session(session.id)
+            assert retrieved is not None
+            assert retrieved.task_description == "Test"
+
+            # Update
+            session.add_message("user", "Hello")
+            manager.update_session(session)
+
+            # List
+            sessions = manager.list_sessions()
+            assert len(sessions) == 1
+
+            # Filter by status
+            active = manager.list_sessions(status="active")
+            assert len(active) == 1
+
+    def test_task_crud(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = StateManager(Path(tmpdir) / ".zwarm")
+            manager.init()
+
+            # Add
+            task = Task(description="Build feature")
+            manager.add_task(task)
+
+            # Get
+            retrieved = manager.get_task(task.id)
+            assert retrieved is not None
+
+            # Update
+            task.start("session-123")
+            manager.update_task(task)
+
+            # List
+            tasks = manager.list_tasks(status="in_progress")
+            assert len(tasks) == 1
+
+    def test_event_logging(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = StateManager(Path(tmpdir) / ".zwarm")
+            manager.init()
+
+            # Log events
+            session = ConversationSession()
+            manager.log_event(event_session_started(session))
+            manager.log_event(event_session_completed(session))
+
+            # Read events
+            events = manager.get_events()
+            assert len(events) == 2
+            assert events[0].kind == "session_completed"  # Most recent first
+
+            # Filter by session
+            events = manager.get_events(session_id=session.id)
+            assert len(events) == 2
+
+            # Filter by kind
+            events = manager.get_events(kind="session_started")
+            assert len(events) == 1
+
+    def test_orchestrator_messages(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            manager = StateManager(Path(tmpdir) / ".zwarm")
+            manager.init()
+
+            messages = [
+                {"role": "system", "content": "You are an orchestrator"},
+                {"role": "user", "content": "Build a feature"},
+            ]
+            manager.save_orchestrator_messages(messages)
+
+            loaded = manager.load_orchestrator_messages()
+            assert len(loaded) == 2
+            assert loaded[0]["role"] == "system"
+
+    def test_state_persistence(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            state_dir = Path(tmpdir) / ".zwarm"
+
+            # Create and save state
+            manager1 = StateManager(state_dir)
+            manager1.init()
+
+            session = ConversationSession(task_description="Persistent session")
+            manager1.add_session(session)
+
+            task = Task(description="Persistent task")
+            manager1.add_task(task)
+
+            # Load in new manager
+            manager2 = StateManager(state_dir)
+            manager2.load()
+
+            assert manager2.get_session(session.id) is not None
+            assert manager2.get_task(task.id) is not None
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])