Initial commit: Javis project

tests/test_fixes.py

@@ -0,0 +1,404 @@
+"""Regression tests for the correctness fixes applied to Javis.
+
+These target concrete, previously-broken behaviours and use only
+dependency-light modules (no torch / audio / MCP) so they run fast.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from javis.core.config import Config, PathsConfig, find_project_root
+from javis.llm.conversation import Conversation, count_tokens
+from javis.voices.profile import VoiceProfile
+
+
+class FindProjectRootTests(unittest.TestCase):
+    def test_finds_pyproject_marker(self) -> None:
+        root = find_project_root()
+        # The repository root holds pyproject.toml.
+        self.assertTrue((root / "pyproject.toml").is_file())
+
+    def test_falls_back_to_cwd_without_marker(self) -> None:
+        with tempfile.TemporaryDirectory() as td:
+            deep = Path(td) / "a" / "b"
+            deep.mkdir(parents=True)
+            # No pyproject.toml anywhere up the temp tree → cwd fallback, no raise.
+            result = find_project_root(deep)
+            self.assertIsInstance(result, Path)
+
+
+class VoiceProfileCorruptionTests(unittest.TestCase):
+    def test_corrupt_profile_json_does_not_raise(self) -> None:
+        with tempfile.TemporaryDirectory() as td:
+            d = Path(td)
+            (d / "profile.json").write_text("{ this is not valid json", encoding="utf-8")
+            prof = VoiceProfile.from_dir(d)  # must not raise
+            self.assertEqual(prof.name, d.name)
+            self.assertIsNone(prof.speed)
+
+    def test_non_numeric_speed_falls_back_to_none(self) -> None:
+        with tempfile.TemporaryDirectory() as td:
+            d = Path(td)
+            (d / "profile.json").write_text(
+                json.dumps({"name": "x", "speed": "fast"}), encoding="utf-8"
+            )
+            prof = VoiceProfile.from_dir(d)
+            self.assertIsNone(prof.speed)
+
+    def test_valid_speed_is_parsed(self) -> None:
+        with tempfile.TemporaryDirectory() as td:
+            d = Path(td)
+            (d / "profile.json").write_text(
+                json.dumps({"name": "x", "speed": 1.25}), encoding="utf-8"
+            )
+            prof = VoiceProfile.from_dir(d)
+            self.assertEqual(prof.speed, 1.25)
+
+
+class ConversationTests(unittest.TestCase):
+    def test_history_property_is_a_readonly_snapshot(self) -> None:
+        conv = Conversation(system_prompt="sys", max_turns=20)
+        conv.add_user("hello")
+        snap = conv.history
+        snap.append({"role": "user", "content": "mutated"})
+        # Mutating the snapshot must not affect the real history.
+        self.assertEqual(len(conv.history), 1)
+
+    def test_trim_keeps_tool_pairs_and_bounds_size(self) -> None:
+        conv = Conversation(system_prompt="sys", max_turns=2, max_chars=200)
+        for i in range(10):
+            conv.add_user("u" * 50)
+            conv.add_assistant("a" * 50)
+        total = sum(len(m.get("content") or "") for m in conv.history)
+        self.assertLessEqual(total, 200)
+        # History must never start with an orphaned tool/assistant message.
+        if conv.history:
+            self.assertEqual(conv.history[0]["role"], "user")
+
+    def test_count_tokens_fallback_is_nonzero_for_text(self) -> None:
+        self.assertEqual(count_tokens(""), 0)
+        self.assertGreater(count_tokens("hello world this is text"), 0)
+
+
+class QuickEngineTests(unittest.TestCase):
+    def test_load_skips_malformed_command_but_keeps_valid(self) -> None:
+        from javis.agent.quick_engine import QuickEngine
+
+        with tempfile.TemporaryDirectory() as td:
+            path = Path(td) / "quick_commands.json"
+            path.write_text(json.dumps({
+                "version": 1,
+                "commands": {
+                    "good": {
+                        "id": "good", "trigger": "lights on", "match_mode": "exact",
+                        "actions": [{"tool": "homey__x", "args": {}}],
+                    },
+                    "bad": {
+                        "id": "bad", "trigger": "broken", "match_mode": "exact",
+                        "actions": [{"not_a_valid_field": 1}],
+                    },
+                },
+            }), encoding="utf-8")
+            eng = QuickEngine(path)
+            eng.load()  # must not raise
+            ids = {c.id for c in eng.list_all()}
+            self.assertIn("good", ids)
+            self.assertNotIn("bad", ids)
+
+
+class DeviceStoreDebounceTests(unittest.TestCase):
+    def test_touch_last_seen_debounces_disk_writes(self) -> None:
+        from javis.api.devices import SlaveDeviceStore
+
+        with tempfile.TemporaryDirectory() as td:
+            store = SlaveDeviceStore(Path(td) / "slaves.json")
+            store.register("dev1", "Device One")
+            with patch.object(store, "_save", wraps=store._save) as spy:
+                # Same IP, rapid calls → at most one flush within the interval.
+                for _ in range(5):
+                    store.touch_last_seen("dev1", ip_address="10.0.0.1")
+                self.assertLessEqual(spy.call_count, 1)
+
+    def test_touch_last_seen_flushes_on_ip_change(self) -> None:
+        from javis.api.devices import SlaveDeviceStore
+
+        with tempfile.TemporaryDirectory() as td:
+            store = SlaveDeviceStore(Path(td) / "slaves.json")
+            store.register("dev1", "Device One")
+            store.touch_last_seen("dev1", ip_address="10.0.0.1")
+            with patch.object(store, "_save", wraps=store._save) as spy:
+                store.touch_last_seen("dev1", ip_address="10.0.0.2")  # IP changed
+                self.assertEqual(spy.call_count, 1)
+
+
+class TimerPersistenceTests(unittest.IsolatedAsyncioTestCase):
+    async def asyncNoop(self, timer_id: str, label: str) -> None:
+        return None
+
+    async def test_set_persists_and_cancel_updates_file(self) -> None:
+        from javis.core.timer import TimerService
+
+        with tempfile.TemporaryDirectory() as td:
+            path = Path(td) / "timers.json"
+            svc = TimerService(self.asyncNoop, persist_path=path)
+            tid = svc.set_timer("test", 3600)
+            try:
+                self.assertTrue(path.exists())
+                data = json.loads(path.read_text(encoding="utf-8"))
+                self.assertEqual(len(data["timers"]), 1)
+                self.assertTrue(svc.cancel_timer(tid))
+                data = json.loads(path.read_text(encoding="utf-8"))
+                self.assertEqual(len(data["timers"]), 0)
+            finally:
+                svc.stop()
+
+    async def test_restore_reschedules_pending_and_drops_expired(self) -> None:
+        import time as _time
+        from javis.core.timer import TimerService
+
+        with tempfile.TemporaryDirectory() as td:
+            path = Path(td) / "timers.json"
+            now = _time.time()
+            path.write_text(json.dumps({
+                "version": 1,
+                "timers": [
+                    {"id": "pending", "label": "future", "duration_s": 3600,
+                     "fire_at": now + 3600},
+                    {"id": "expired", "label": "past", "duration_s": 60,
+                     "fire_at": now - 10},
+                ],
+            }), encoding="utf-8")
+            svc = TimerService(self.asyncNoop, persist_path=path)
+            await svc.restore()
+            try:
+                active = svc.list_timers()
+                self.assertEqual(len(active), 1)
+                self.assertEqual(active[0]["id"], "pending")
+            finally:
+                svc.stop()
+
+
+class FinetuneSignatureTests(unittest.IsolatedAsyncioTestCase):
+    async def test_run_pipeline_receives_profile_dir_not_config(self) -> None:
+        from javis.voices.manager import VoiceManager
+        import javis.voices.piper_train as pt
+
+        with tempfile.TemporaryDirectory() as td:
+            config = Config()
+            config.paths = PathsConfig(base_dir=Path(td))
+            config.paths.ensure()
+            mgr = VoiceManager(config)
+            prof = mgr.create("tv")
+            assert prof.dir is not None
+            (prof.dir / "training").mkdir(parents=True, exist_ok=True)
+            (prof.dir / "training" / "metadata.csv").write_text(
+                "clip_0|hallo|hallo\n", encoding="utf-8")
+
+            captured: dict = {}
+
+            def fake_run_pipeline(voice_dir, **kwargs):
+                captured["voice_dir"] = voice_dir
+                captured["kwargs"] = kwargs
+                return 0
+
+            from javis.voices import finetune
+            with patch.object(pt, "run_pipeline", fake_run_pipeline):
+                rc = await finetune.finetune_voice(config, "tv", language="de")
+
+            self.assertEqual(rc, 0)
+            self.assertEqual(captured["voice_dir"], prof.dir)
+            # The old bug passed the Config as voice_dir and voice_name as language.
+            self.assertNotIsInstance(captured["voice_dir"], Config)
+            self.assertEqual(captured["kwargs"].get("language"), "de")
+
+
+# ── wake-word barge-in (interrupt TTS playback with the wake phrase) ──────
+
+
+class BargeInConfigTests(unittest.TestCase):
+    """The new WakeWordConfig.barge_in_enabled flag defaults to True."""
+
+    def test_barge_in_enabled_defaults_true(self) -> None:
+        from javis.core.config import WakeWordConfig
+
+        self.assertTrue(WakeWordConfig().barge_in_enabled)
+
+
+class BargeInListenerTests(unittest.IsolatedAsyncioTestCase):
+    """_barge_in_listener: on wake-word trigger it cancels playback, resets
+    the detector, sets the barge-in flag, and publishes the event."""
+
+    async def test_trigger_cancels_playback_and_sets_flag(self) -> None:
+        from javis.agent.orchestrator import Orchestrator
+        from javis.core.state import AgentState
+
+        orch = object.__new__(Orchestrator)
+
+        class FakeWake:
+            def __init__(self) -> None:
+                self.feed_calls = 0
+                self.reset_calls = 0
+
+            def feed(self, chunk):
+                self.feed_calls += 1
+                return 0.9 if self.feed_calls == 1 else 0.1
+
+            def triggered(self, score):
+                return score >= 0.5
+
+            def reset(self):
+                self.reset_calls += 1
+
+        class FakeMic:
+            def __init__(self) -> None:
+                self.drain_calls = 0
+
+            def drain(self):
+                self.drain_calls += 1
+
+            async def chunks(self, stale_timeout=None):
+                yield b"\x00"
+
+        class FakeBus:
+            def __init__(self) -> None:
+                self.events = []
+
+            async def publish(self, name, payload=None):
+                self.events.append((name, payload))
+
+        orch.wake = FakeWake()
+        orch.mic = FakeMic()
+        orch.bus = FakeBus()
+        orch._stop = asyncio.Event()
+        orch._barge_in_requested = False
+        orch._barge_in_task = None
+
+        interrupt_calls = []
+        state_calls = []
+        with patch.object(Orchestrator, "interrupt",
+                          lambda self: interrupt_calls.append(1)), \
+             patch.object(Orchestrator, "set_state",
+                          lambda self, s: state_calls.append(s) or asyncio.sleep(0)), \
+             patch.object(Orchestrator, "_play_wake_chime",
+                          lambda self: asyncio.sleep(0)):
+            await orch._barge_in_listener()
+
+        # Trigger fired on the first chunk: listener must have exited.
+        self.assertTrue(orch._barge_in_requested)
+        self.assertEqual(len(interrupt_calls), 1)
+        self.assertEqual(state_calls, [AgentState.WAKE])
+        # reset() is called once at arming and once after the trigger.
+        self.assertEqual(orch.wake.reset_calls, 2)
+        self.assertEqual(orch.mic.drain_calls, 1)
+        self.assertIn(("barge_in", 0.9), orch.bus.events)
+        # Chime was scheduled via ensure_future — let it finish.
+        await asyncio.sleep(0)
+
+
+class BargeInRunConsumptionTests(unittest.IsolatedAsyncioTestCase):
+    """run(): when _barge_in_requested is set, the main loop must skip
+    _wait_for_wake, drain the mic tail, and start the turn with followup
+    grace instead of the default 1500 ms."""
+
+    async def test_run_consumes_barge_in_flag(self) -> None:
+        from javis.agent.orchestrator import Orchestrator
+
+        orch = object.__new__(Orchestrator)
+        orch.stt = object()
+        orch.mic = object()
+        orch.wake = object()
+        orch._stop = asyncio.Event()
+        orch._turn_lock = asyncio.Lock()
+        orch._barge_in_requested = True
+        orch._barge_in_task = None
+        orch._followup_pending = False
+        orch.config = Config()
+        orch.profiler = None
+
+        class FakeMic:
+            def __init__(self) -> None:
+                self.drain_calls = 0
+
+            def drain(self):
+                self.drain_calls += 1
+
+        orch.mic = FakeMic()
+
+        class FakeBus:
+            def __init__(self) -> None:
+                self.events = []
+
+            async def publish(self, name, payload=None):
+                self.events.append((name, payload))
+
+        orch.bus = FakeBus()
+
+        wake_calls = []
+        turn_calls = []
+
+        async def fake_handle_turn(self, initial_grace_ms=1500):
+            turn_calls.append(initial_grace_ms)
+            self._stop.set()  # end the run() loop after the first turn
+
+        with patch.object(Orchestrator, "_wait_for_wake",
+                          lambda self: wake_calls.append(1)), \
+             patch.object(Orchestrator, "_handle_turn", fake_handle_turn), \
+             patch.object(Orchestrator, "stop",
+                          lambda self: asyncio.sleep(0)), \
+             patch.object(Orchestrator, "set_state",
+                          lambda self, s: asyncio.sleep(0)):
+            await orch.run()
+
+        self.assertFalse(orch._barge_in_requested)
+        self.assertEqual(orch.mic.drain_calls, 1)
+        self.assertEqual(wake_calls, [])
+        self.assertEqual(turn_calls, [int(orch.config.wake_word.followup_grace_s * 1000)])
+        self.assertIn(("barge_in_listen", {}), orch.bus.events)
+
+
+class BargeInEmptyUtteranceTests(unittest.IsolatedAsyncioTestCase):
+    """_handle_turn: an empty capture must publish stt_done(empty) + stt_empty
+    and reset the state to IDLE (previously the GUI stayed stuck on
+    'listening')."""
+
+    async def test_empty_utterance_resets_to_idle(self) -> None:
+        from javis.agent.orchestrator import Orchestrator
+        from javis.core.state import AgentState
+
+        orch = object.__new__(Orchestrator)
+        orch.stt = object()
+        orch.mic = object()
+        orch.vad = object()
+        orch.config = Config()
+        orch._last_response_is_question = False
+        orch.profiler = None
+
+        class FakeBus:
+            def __init__(self) -> None:
+                self.events = []
+
+            async def publish(self, name, payload=None):
+                self.events.append((name, payload))
+
+        orch.bus = FakeBus()
+
+        state_calls = []
+        with patch("javis.agent.orchestrator.record_utterance",
+                   new=lambda *a, **kw: asyncio.sleep(0, result=None)), \
+             patch.object(Orchestrator, "set_state",
+                          lambda self, s: state_calls.append(s) or asyncio.sleep(0)):
+            await orch._handle_turn(initial_grace_ms=1500)
+
+        self.assertIn(("stt_done", {"text": "", "audio_s": 0.0, "latency_s": 0.0, "empty": True}),
+                      orch.bus.events)
+        self.assertIn(("stt_empty", {}), orch.bus.events)
+        self.assertEqual(state_calls, [AgentState.LISTENING, AgentState.IDLE])
+
+
+if __name__ == "__main__":
+    unittest.main()