@hybridlabor-api/aos 4.2.0 → 4.4.0

package/mcps/davinci-resolve-mcp/tests/test_tool_registration.py

@@ -1,91 +0,0 @@
-"""Regression guard for the MCP tool registry in ``src/server.py``.
-
-A misplaced ``@mcp.tool()`` decorator is silent: in v2.33.0 (commit 32be0ec) a
-new ``_parse_pos`` helper was inserted between the decorator and
-``def fusion_comp``. The decorator landed on the private helper, so
-``_parse_pos`` was exposed as a tool while every ``fusion_comp`` node-graph
-operation vanished from the tool list. It shipped undetected because nothing
-asserted the registered tool set (reported + fixed in PR #57, v2.36.1).
-
-These tests run fully offline — importing ``src.server`` does not connect to
-Resolve, and enumerating tools via ``mcp.list_tools()`` touches no live handle.
-"""
-import asyncio
-import unittest
-
-from tests.test_import import PROJECT_ROOT, _count_mcp_tools
-
-
-def _registered_tool_names():
-    import src.server as server
-
-    tools = asyncio.run(server.mcp.list_tools())
-    return sorted(t.name for t in tools)
-
-
-# Stable, public compound tools that must always be registered. Not exhaustive —
-# a representative spread so an accidental mass-unregister fails loudly.
-KNOWN_GOOD_TOOLS = {
-    "fusion_comp",  # the exact tool the 32be0ec regression unregistered
-    "timeline",
-    "timeline_item",
-    "media_pool",
-    "media_pool_item",
-    "render",
-    "project_manager",
-    "resolve_control",
-    "timeline_versioning",
-}
-
-# Floor for the registered tool count. Lives below the current count (33) so
-# adding tools never breaks this; a large accidental drop trips it.
-MIN_TOOL_COUNT = 33
-
-
-class ToolRegistrationTest(unittest.TestCase):
-    def setUp(self):
-        self.names = _registered_tool_names()
-
-    def test_no_private_helpers_registered_as_tools(self):
-        """No registered tool name starts with ``_`` — directly catches the
-        ``_parse_pos`` regression class (a private helper grabbing the
-        decorator)."""
-        private = [n for n in self.names if n.startswith("_")]
-        self.assertEqual(
-            private,
-            [],
-            f"private helper(s) exposed as MCP tools: {private} — a @mcp.tool() "
-            "decorator likely slid onto an internal function",
-        )
-
-    def test_known_good_tools_are_registered(self):
-        missing = sorted(KNOWN_GOOD_TOOLS - set(self.names))
-        self.assertEqual(
-            missing,
-            [],
-            f"expected MCP tool(s) missing from the registry: {missing}",
-        )
-
-    def test_tool_count_at_or_above_floor(self):
-        self.assertGreaterEqual(
-            len(self.names),
-            MIN_TOOL_COUNT,
-            f"registered tool count {len(self.names)} fell below floor "
-            f"{MIN_TOOL_COUNT} — tools were unregistered. Registered: {self.names}",
-        )
-
-    def test_runtime_registry_matches_source_decorators(self):
-        """The number of tools the server registers at runtime must equal the
-        number of ``@mcp.tool()`` decorators in the source. A mismatch means a
-        decorator is decorating the wrong thing (or not taking effect)."""
-        static_count = _count_mcp_tools(PROJECT_ROOT / "src" / "server.py")
-        self.assertEqual(
-            len(self.names),
-            static_count,
-            f"runtime registered tools ({len(self.names)}) != @mcp.tool() "
-            f"decorators in src/server.py ({static_count})",
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()

package/mcps/davinci-resolve-mcp/tests/test_transcript_read.py

@@ -1,74 +0,0 @@
-"""Tests for clip transcription read-back and the _is_truncated helper."""
-import unittest
-from unittest import mock
-
-import src.server as s
-
-
-class IsTruncatedTest(unittest.TestCase):
-    def test_ellipsis_unicode(self):
-        self.assertTrue(s._is_truncated("hello world…"))
-
-    def test_ellipsis_ascii(self):
-        self.assertTrue(s._is_truncated("hello world..."))
-
-    def test_trailing_space_then_ellipsis(self):
-        self.assertTrue(s._is_truncated("hello…   "))
-
-    def test_not_truncated(self):
-        self.assertFalse(s._is_truncated("a complete sentence."))
-
-    def test_non_string(self):
-        self.assertFalse(s._is_truncated(None))
-        self.assertFalse(s._is_truncated(42))
-
-
-class FakeClip:
-    def __init__(self, transcription="", status="Transcribed"):
-        self._t = transcription
-        self._s = status
-
-    def GetClipProperty(self, key):
-        if key == "Transcription":
-            return self._t
-        if key == "Transcription Status":
-            return self._s
-        return ""
-
-
-class GetTranscriptionTest(unittest.TestCase):
-    def _call(self, clip):
-        mp = mock.Mock()
-        with mock.patch.object(s, "_get_mp", return_value=(None, None, mp, None)), \
-             mock.patch.object(s, "_find_clip", return_value=clip):
-            return s.media_pool_item("get_transcription", {"clip_id": "x"})
-
-    def test_full_text(self):
-        out = self._call(FakeClip("A complete transcript."))
-        self.assertEqual(out["text"], "A complete transcript.")
-        self.assertFalse(out["truncated"])
-        self.assertTrue(out["has_transcription"])
-        self.assertEqual(out["status"], "Transcribed")
-
-    def test_truncated(self):
-        out = self._call(FakeClip("This goes on and on…"))
-        self.assertTrue(out["truncated"])
-        self.assertTrue(out["has_transcription"])
-
-    def test_empty(self):
-        out = self._call(FakeClip("", status=""))
-        self.assertFalse(out["has_transcription"])
-        self.assertFalse(out["truncated"])
-        self.assertIsNone(out["status"])
-
-    def test_non_string_property(self):
-        # GetClipProperty may return a non-str; handler must not crash.
-        clip = FakeClip()
-        clip._t = None
-        out = self._call(clip)
-        self.assertEqual(out["text"], "")
-        self.assertFalse(out["has_transcription"])
-
-
-if __name__ == "__main__":
-    unittest.main()

package/mcps/davinci-resolve-mcp/tests/test_update_check.py

@@ -1,171 +0,0 @@
-import json
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-PROJECT_ROOT = Path(__file__).resolve().parent.parent
-if str(PROJECT_ROOT) not in sys.path:
-    sys.path.insert(0, str(PROJECT_ROOT))
-
-from src.utils import update_check
-
-
-class _FakeResponse:
-    def __init__(self, payload):
-        self._payload = json.dumps(payload).encode("utf-8")
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc, tb):
-        return False
-
-    def read(self):
-        return self._payload
-
-
-class UpdateCheckTests(unittest.TestCase):
-    def test_compare_versions_handles_release_tags(self):
-        self.assertEqual(update_check.compare_versions("2.20.0", "v2.21.0"), -1)
-        self.assertEqual(update_check.compare_versions("2.20", "2.20.0"), 0)
-        self.assertEqual(update_check.compare_versions("2.21.0", "v2.20.0"), 1)
-        self.assertIsNone(update_check.compare_versions("dev", "v2.20.0"))
-
-    def test_check_for_updates_detects_new_release_and_caches(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            state_path = Path(tmp) / "update.json"
-            env = {
-                update_check.ENV_URL: "https://example.test/latest",
-                update_check.ENV_STATE_PATH: str(state_path),
-            }
-            payload = {
-                "tag_name": "v2.21.0",
-                "html_url": "https://github.com/example/releases/tag/v2.21.0",
-            }
-
-            with patch.object(
-                update_check.urllib.request,
-                "urlopen",
-                return_value=_FakeResponse(payload),
-            ) as urlopen:
-                result = update_check.check_for_updates(
-                    "2.20.0",
-                    tmp,
-                    env=env,
-                    now=1000,
-                )
-                cached = update_check.check_for_updates(
-                    "2.20.0",
-                    tmp,
-                    env=env,
-                    now=1001,
-                )
-
-            self.assertEqual(result["status"], "update_available")
-            self.assertEqual(result["latest_version"], "2.21.0")
-            self.assertEqual(cached["status"], "update_available")
-            self.assertTrue(cached["cached"])
-            self.assertEqual(urlopen.call_count, 1)
-            self.assertEqual(json.loads(state_path.read_text())["status"], "update_available")
-
-    def test_check_for_updates_can_be_disabled(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            state_path = Path(tmp) / "update.json"
-            result = update_check.check_for_updates(
-                "2.20.0",
-                tmp,
-                env={
-                    update_check.ENV_ENABLED: "false",
-                    update_check.ENV_STATE_PATH: str(state_path),
-                },
-                now=1000,
-            )
-
-            self.assertEqual(result["status"], "disabled")
-            self.assertFalse(state_path.exists())
-
-    def test_persisted_never_mode_disables_update_checks(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            state_path = Path(tmp) / "update.json"
-            env = {update_check.ENV_STATE_PATH: str(state_path)}
-            update_check.set_update_mode(tmp, "never", env=env, now=1000)
-
-            result = update_check.check_for_updates(
-                "2.20.0",
-                tmp,
-                env=env,
-                now=1001,
-            )
-
-            self.assertEqual(result["status"], "disabled")
-            self.assertEqual(result["update_mode"], "never")
-            self.assertEqual(json.loads(state_path.read_text())["update_mode"], "never")
-
-    def test_update_prompt_decision_respects_ignore_snooze_and_auto(self):
-        base = {
-            "status": "update_available",
-            "current_version": "2.20.0",
-            "latest_version": "2.21.0",
-            "latest_tag": "v2.21.0",
-            "update_mode": "prompt",
-        }
-
-        self.assertEqual(update_check.update_prompt_decision(base, now=1000)["action"], "prompt")
-        self.assertEqual(
-            update_check.update_prompt_decision(
-                {**base, "ignored_version": "2.21.0"},
-                now=1000,
-            )["reason"],
-            "ignored",
-        )
-        self.assertEqual(
-            update_check.update_prompt_decision(
-                {**base, "snooze_until": 2000},
-                now=1000,
-            )["reason"],
-            "snoozed",
-        )
-        self.assertEqual(
-            update_check.update_prompt_decision({**base, "update_mode": "auto"}, now=1000)["action"],
-            "auto",
-        )
-
-    def test_network_error_preserves_last_success(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            state_path = Path(tmp) / "update.json"
-            env = {update_check.ENV_STATE_PATH: str(state_path)}
-            state_path.write_text(
-                json.dumps(
-                    {
-                        "status": "up_to_date",
-                        "current_version": "2.20.0",
-                        "latest_version": "2.20.0",
-                        "latest_tag": "v2.20.0",
-                        "release_url": "https://github.com/example/releases/tag/v2.20.0",
-                        "checked_at": 1000,
-                        "checked_at_iso": "1970-01-01T00:16:40Z",
-                    }
-                ),
-                encoding="utf-8",
-            )
-
-            with patch.object(
-                update_check.urllib.request,
-                "urlopen",
-                side_effect=OSError("offline"),
-            ):
-                result = update_check.check_for_updates(
-                    "2.20.0",
-                    tmp,
-                    env=env,
-                    now=100000,
-                )
-
-        self.assertEqual(result["status"], "error")
-        self.assertEqual(result["last_success"]["status"], "up_to_date")
-
-
-if __name__ == "__main__":
-    unittest.main()

package/mcps/davinci-resolve-mcp/tests/test_update_hardening.py

@@ -1,171 +0,0 @@
-"""Unit tests for the six update-process improvements (active-job lock, auto-
-stash strategy, restart marker, channels, preview/breaking-change scan,
-integrity helper).
-
-No real git or GitHub I/O — we test the local helpers + the scanning/URL
-resolution functions directly.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import shutil
-import sys
-import tempfile
-import unittest
-
-REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-sys.path.insert(0, REPO_ROOT)
-import install  # noqa: E402
-from src.utils import update_check  # noqa: E402
-
-
-class BreakingChangeScanner(unittest.TestCase):
-    def test_picks_up_breaking_prefix(self) -> None:
-        body = "## Highlights\n- new thing\n- BREAKING: schema bump v5\n- regular fix"
-        out = update_check._scan_for_breaking_changes(body)
-        self.assertEqual(out, ["schema bump v5"])
-
-    def test_picks_up_warning_emoji(self) -> None:
-        body = "Changes:\n- ⚠️ remove deprecated tool foo\n- normal change"
-        out = update_check._scan_for_breaking_changes(body)
-        self.assertEqual(out, ["remove deprecated tool foo"])
-
-    def test_handles_breaking_change_phrase(self) -> None:
-        body = "BREAKING CHANGE: dropped Python 3.10 support"
-        out = update_check._scan_for_breaking_changes(body)
-        self.assertEqual(out, ["dropped Python 3.10 support"])
-
-    def test_no_breaking_returns_empty(self) -> None:
-        body = "## Highlights\n- regular fix\n- another tweak"
-        out = update_check._scan_for_breaking_changes(body)
-        self.assertEqual(out, [])
-
-    def test_empty_body(self) -> None:
-        self.assertEqual(update_check._scan_for_breaking_changes(""), [])
-
-
-class UpdateChannel(unittest.TestCase):
-    def test_default_is_stable(self) -> None:
-        self.assertEqual(update_check.get_update_channel({}), "stable")
-
-    def test_env_override(self) -> None:
-        for ch in ("stable", "beta", "dev"):
-            self.assertEqual(
-                update_check.get_update_channel({update_check.ENV_CHANNEL: ch}),
-                ch,
-            )
-
-    def test_unknown_falls_back_to_stable(self) -> None:
-        self.assertEqual(
-            update_check.get_update_channel({update_check.ENV_CHANNEL: "nightly"}),
-            "stable",
-        )
-
-    def test_stable_uses_latest_endpoint(self) -> None:
-        url = update_check._release_api_url({update_check.ENV_REPO: "x/y"}, channel="stable")
-        self.assertTrue(url.endswith("/releases/latest"))
-
-    def test_beta_uses_list_endpoint(self) -> None:
-        url = update_check._release_api_url({update_check.ENV_REPO: "x/y"}, channel="beta")
-        self.assertIn("/releases?", url)
-
-    def test_url_override_wins(self) -> None:
-        url = update_check._release_api_url(
-            {update_check.ENV_URL: "https://example.com/custom"}, channel="dev",
-        )
-        self.assertEqual(url, "https://example.com/custom")
-
-
-class StashStrategy(unittest.TestCase):
-    """Verify the install.py code paths around stash_if_needed without running git."""
-
-    def test_strategy_arg_exists(self) -> None:
-        import inspect
-        sig = inspect.signature(install.apply_safe_self_update)
-        self.assertIn("strategy", sig.parameters)
-        self.assertEqual(sig.parameters["strategy"].default, "refuse_on_dirty")
-
-
-class RestartMarker(unittest.TestCase):
-    """The dashboard's restart-marker helpers are simple file I/O — test directly."""
-
-    def setUp(self) -> None:
-        self.tmp = tempfile.mkdtemp(prefix="restart_marker_test_")
-
-    def tearDown(self) -> None:
-        shutil.rmtree(self.tmp, ignore_errors=True)
-
-    def test_no_marker_means_not_needed(self) -> None:
-        from src.analysis_dashboard import _read_restart_marker
-        self.assertEqual(_read_restart_marker(self.tmp), {"needed": False})
-
-    def test_write_and_read_marker(self) -> None:
-        from src.analysis_dashboard import _write_restart_marker, _read_restart_marker
-        _write_restart_marker(self.tmp, {
-            "from_version": "1.0", "to_version": "1.1",
-            "from_sha": "aaa", "to_sha": "bbb",
-        })
-        marker = _read_restart_marker(self.tmp)
-        self.assertTrue(marker["needed"])
-        self.assertEqual(marker["from_version"], "1.0")
-        self.assertEqual(marker["to_version"], "1.1")
-
-    def test_clear_marker(self) -> None:
-        from src.analysis_dashboard import _write_restart_marker, _read_restart_marker, _clear_restart_marker
-        _write_restart_marker(self.tmp, {"from_version": "x", "to_version": "y"})
-        self.assertTrue(_read_restart_marker(self.tmp)["needed"])
-        clear_result = _clear_restart_marker(self.tmp)
-        self.assertTrue(clear_result["success"])
-        self.assertEqual(_read_restart_marker(self.tmp), {"needed": False})
-
-    def test_clear_when_not_present(self) -> None:
-        from src.analysis_dashboard import _clear_restart_marker
-        result = _clear_restart_marker(self.tmp)
-        self.assertFalse(result["success"])
-
-    def test_marker_handles_corrupt_json(self) -> None:
-        from src.analysis_dashboard import _read_restart_marker
-        os.makedirs(os.path.join(self.tmp, "logs"), exist_ok=True)
-        with open(os.path.join(self.tmp, "logs", ".mcp_restart_needed"), "w") as fh:
-            fh.write("not json")
-        marker = _read_restart_marker(self.tmp)
-        # File exists → marker still reads as needed even when corrupt.
-        self.assertTrue(marker["needed"])
-
-
-class ActiveJobLockHelper(unittest.TestCase):
-    """The dashboard helper that lists running batch jobs."""
-
-    def setUp(self) -> None:
-        self.tmp = tempfile.mkdtemp(prefix="active_job_test_")
-
-    def tearDown(self) -> None:
-        shutil.rmtree(self.tmp, ignore_errors=True)
-
-    def test_no_base_root_returns_empty(self) -> None:
-        from src.analysis_dashboard import _list_active_batch_jobs
-        # project_root with no sibling directories under its base → no jobs.
-        empty_project = os.path.join(self.tmp, "isolated_project")
-        os.makedirs(empty_project, exist_ok=True)
-        active = _list_active_batch_jobs(empty_project)
-        self.assertEqual(active, [])
-
-    def test_none_project_root_returns_empty(self) -> None:
-        from src.analysis_dashboard import _list_active_batch_jobs
-        self.assertEqual(_list_active_batch_jobs(""), [])
-
-
-class PreviewUpdateHelper(unittest.TestCase):
-    """preview_update gracefully degrades when the network helper is unavailable."""
-
-    def test_missing_helper_returns_clean_error(self) -> None:
-        # If update_check import fails, preview_update returns a clean error
-        # dict — but in normal test runs it's importable, so we just verify
-        # the function exists and is callable.
-        self.assertTrue(callable(install.preview_update))
-
-
-if __name__ == "__main__":
-    unittest.main()

package/mcps/davinci-resolve-mcp/tests/test_update_history.py

@@ -1,116 +0,0 @@
-"""Unit tests for install.py update history + rollback helpers.
-
-No git operations performed — we test the JSON-recorder helpers directly.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import shutil
-import sys
-import tempfile
-import unittest
-
-REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-sys.path.insert(0, REPO_ROOT)
-import install  # noqa: E402
-
-
-class UpdateHistoryRecording(unittest.TestCase):
-    def setUp(self) -> None:
-        self.tmp = tempfile.mkdtemp(prefix="update_history_test_")
-
-    def tearDown(self) -> None:
-        shutil.rmtree(self.tmp, ignore_errors=True)
-
-    def _history_path(self) -> str:
-        return os.path.join(self.tmp, "logs", "update_history.json")
-
-    def test_record_attempt_creates_file(self) -> None:
-        install._record_attempt(
-            self.tmp, kind="update", success=True,
-            from_version="1.0", to_version="1.1",
-            from_sha="aaa", to_sha="bbb", initiator="test",
-        )
-        path = self._history_path()
-        self.assertTrue(os.path.isfile(path))
-        with open(path, "r") as fh:
-            payload = json.load(fh)
-        self.assertEqual(len(payload["entries"]), 1)
-        entry = payload["entries"][0]
-        self.assertEqual(entry["from_version"], "1.0")
-        self.assertEqual(entry["to_version"], "1.1")
-        self.assertTrue(entry["success"])
-        self.assertEqual(entry["initiator"], "test")
-
-    def test_read_update_history_returns_newest_first(self) -> None:
-        for i in range(3):
-            install._record_attempt(
-                self.tmp, kind="update", success=True,
-                from_version=f"1.{i}", to_version=f"1.{i+1}",
-                from_sha=f"sha{i}", to_sha=f"sha{i+1}", initiator="test",
-            )
-        result = install.read_update_history(self.tmp, limit=10)
-        self.assertTrue(result["success"])
-        self.assertEqual(len(result["entries"]), 3)
-        # newest first → 1.3 / 1.2 / 1.1
-        self.assertEqual(result["entries"][0]["to_version"], "1.3")
-        self.assertEqual(result["entries"][2]["to_version"], "1.1")
-
-    def test_history_trims_at_200_entries(self) -> None:
-        for i in range(220):
-            install._record_attempt(
-                self.tmp, kind="update", success=True,
-                from_version="x", to_version=str(i), initiator="test",
-            )
-        with open(self._history_path(), "r") as fh:
-            payload = json.load(fh)
-        self.assertEqual(len(payload["entries"]), 200)
-        # Oldest should be entry 20 (220 - 200), newest 219
-        self.assertEqual(payload["entries"][0]["to_version"], "20")
-        self.assertEqual(payload["entries"][-1]["to_version"], "219")
-
-    def test_history_survives_corrupt_file(self) -> None:
-        os.makedirs(os.path.join(self.tmp, "logs"), exist_ok=True)
-        with open(self._history_path(), "w") as fh:
-            fh.write("{not json")
-        # Should not crash; corrupted file is replaced with a fresh history.
-        install._record_attempt(
-            self.tmp, kind="update", success=True,
-            from_version="x", to_version="y", initiator="test",
-        )
-        with open(self._history_path(), "r") as fh:
-            payload = json.load(fh)
-        self.assertEqual(len(payload["entries"]), 1)
-
-    def test_read_handles_missing_file(self) -> None:
-        result = install.read_update_history(self.tmp)
-        self.assertTrue(result["success"])
-        self.assertEqual(result["entries"], [])
-
-
-class RollbackContractGuards(unittest.TestCase):
-    """Verify rollback's pre-conditions surface clean error reasons."""
-
-    def setUp(self) -> None:
-        self.tmp = tempfile.mkdtemp(prefix="rollback_test_")
-
-    def tearDown(self) -> None:
-        shutil.rmtree(self.tmp, ignore_errors=True)
-
-    def test_no_history_returns_clear_reason(self) -> None:
-        result = install.rollback_to_previous_build(self.tmp)
-        self.assertFalse(result["success"])
-        self.assertEqual(result["reason"], "no_history")
-
-    def test_no_successful_update_in_history(self) -> None:
-        # Record only failed attempts.
-        install._record_attempt(self.tmp, kind="update", success=False, reason="local_changes")
-        result = install.rollback_to_previous_build(self.tmp)
-        self.assertFalse(result["success"])
-        self.assertEqual(result["reason"], "no_target")
-
-
-if __name__ == "__main__":
-    unittest.main()