@hybridlabor-api/aos 4.3.0 → 4.4.0

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

@@ -1,178 +0,0 @@
-import unittest
-
-from src.server import _setup_multicam_timeline
-from src.utils.multicam import build_multicam_setup_plan
-
-
-class MediaPoolItemStub:
-    def __init__(self, item_id, name, props=None):
-        self.item_id = item_id
-        self.name = name
-        self.props = props or {}
-
-    def GetUniqueId(self):
-        return self.item_id
-
-    def GetName(self):
-        return self.name
-
-    def GetClipProperty(self, key=""):
-        if not key:
-            return dict(self.props)
-        return self.props.get(key, "")
-
-
-class FolderStub:
-    def __init__(self, clips=None, subfolders=None):
-        self.clips = clips or []
-        self.subfolders = subfolders or []
-
-    def GetClipList(self):
-        return self.clips
-
-    def GetSubFolderList(self):
-        return self.subfolders
-
-
-def find_clip(folder, clip_id):
-    for clip in folder.GetClipList():
-        if clip.GetUniqueId() == clip_id:
-            return clip
-    for subfolder in folder.GetSubFolderList():
-        found = find_clip(subfolder, clip_id)
-        if found:
-            return found
-    return None
-
-
-class TimelineItemStub:
-    def __init__(self, item_id, name):
-        self.item_id = item_id
-        self.name = name
-
-    def GetUniqueId(self):
-        return self.item_id
-
-    def GetName(self):
-        return self.name
-
-
-class TimelineStub:
-    def __init__(self, name):
-        self.name = name
-        self.track_counts = {"video": 1, "audio": 1, "subtitle": 0}
-        self.track_names = {}
-        self.start_timecode = None
-
-    def GetName(self):
-        return self.name
-
-    def GetUniqueId(self):
-        return "timeline-1"
-
-    def GetStartFrame(self):
-        return 108000
-
-    def SetStartTimecode(self, timecode):
-        self.start_timecode = timecode
-        return True
-
-    def GetTrackCount(self, track_type):
-        return self.track_counts.get(track_type, 0)
-
-    def AddTrack(self, track_type, options=None):
-        self.track_counts[track_type] = self.track_counts.get(track_type, 0) + 1
-        return True
-
-    def SetTrackName(self, track_type, track_index, name):
-        self.track_names[(track_type, track_index)] = name
-        return True
-
-
-class MediaPoolStub:
-    def __init__(self, root):
-        self.root = root
-        self.timeline = None
-        self.appended = []
-
-    def GetRootFolder(self):
-        return self.root
-
-    def CreateEmptyTimeline(self, name):
-        self.timeline = TimelineStub(name)
-        return self.timeline
-
-    def AppendToTimeline(self, clip_infos):
-        self.appended = list(clip_infos)
-        return [
-            TimelineItemStub(f"item-{index + 1}", row["mediaPoolItem"].GetName())
-            for index, row in enumerate(clip_infos)
-        ]
-
-
-class ProjectStub:
-    def __init__(self):
-        self.current_timeline = None
-
-    def SetCurrentTimeline(self, timeline):
-        self.current_timeline = timeline
-        return True
-
-
-class MulticamSetupTests(unittest.TestCase):
-    def setUp(self):
-        self.clip_a = MediaPoolItemStub("a", "A001.mov", {"Frames": "48", "FPS": "24", "Start TC": "01:00:05:00"})
-        self.clip_b = MediaPoolItemStub("b", "B001.mov", {"Frames": "72", "FPS": "24", "Start TC": "01:00:10:00"})
-        self.root = FolderStub([self.clip_a, self.clip_b])
-
-    def test_plan_stacks_clip_ids_one_angle_per_video_track(self):
-        plan, err = build_multicam_setup_plan(
-            self.root,
-            {"name": "MC Prep", "clip_ids": ["a", "b"]},
-            find_clip,
-        )
-
-        self.assertIsNone(err)
-        self.assertTrue(plan["success"])
-        self.assertEqual(plan["max_video_track"], 2)
-        self.assertEqual([row["track_index"] for row in plan["append_rows"]], [1, 2])
-        self.assertEqual([row["media_type"] for row in plan["append_rows"]], [1, 1])
-        self.assertEqual(plan["append_rows"][0]["end_frame"], 48)
-
-    def test_source_timecode_sync_offsets_from_timeline_start_timecode(self):
-        plan, err = build_multicam_setup_plan(
-            self.root,
-            {
-                "clip_ids": ["a", "b"],
-                "sync_mode": "source_timecode",
-                "timeline_start_timecode": "01:00:00:00",
-            },
-            find_clip,
-        )
-
-        self.assertIsNone(err)
-        self.assertEqual([row["record_frame"] for row in plan["append_rows"]], [120, 240])
-
-    def test_setup_multicam_timeline_creates_tracks_and_appends_audio_when_requested(self):
-        project = ProjectStub()
-        pool = MediaPoolStub(self.root)
-
-        result = _setup_multicam_timeline(
-            project,
-            pool,
-            {"name": "MC Prep", "clip_ids": ["a", "b"], "include_audio": True, "start_timecode": "01:00:00:00"},
-        )
-
-        self.assertTrue(result["success"])
-        self.assertEqual(result["timeline_name"], "MC Prep")
-        self.assertIs(project.current_timeline, pool.timeline)
-        self.assertEqual(pool.timeline.track_counts["video"], 2)
-        self.assertEqual(pool.timeline.track_counts["audio"], 2)
-        self.assertEqual(len(pool.appended), 4)
-        self.assertEqual([row["mediaType"] for row in pool.appended], [1, 2, 1, 2])
-        self.assertEqual([row["trackIndex"] for row in pool.appended], [1, 1, 2, 2])
-        self.assertEqual(pool.appended[0]["recordFrame"], 108000)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,140 +0,0 @@
-"""Unit tests for src/utils/object_inspection.py.
-
-Covers the single-pass member walk, the C-extension signature guard, the
-__doc__-based docstring read, and back-compat of the thin wrappers.
-"""
-import unittest
-
-import src.utils.object_inspection as oi
-
-
-class _Fake:
-    """A fake Resolve-ish object."""
-
-    attr_prop = 42
-
-    def GetName(self):
-        """Return the name."""
-        return "x"
-
-    def GetClipProperty(self, key):
-        return key
-
-
-class _CExtMethod:
-    """Method-like object that is callable but not a function/method.
-
-    Mimics a Resolve C-extension bound method: inspect.signature() raises and
-    inspect.isfunction/ismethod are both False, so the signature guard must
-    short-circuit to "()" without calling inspect.signature.
-    """
-
-    def __init__(self):
-        self.signature_called = False
-
-    def __call__(self, *args, **kwargs):  # pragma: no cover - never invoked
-        return None
-
-
-class _FakeWithCExt:
-    def __init__(self, cext):
-        self.NativeCall = cext
-        self.value = 7
-
-
-class GetObjectMembersTest(unittest.TestCase):
-    def test_classifies_methods_and_properties_single_pass(self):
-        m = oi.get_object_members(_Fake())
-        self.assertIn("GetName", m["methods"])
-        self.assertIn("GetClipProperty", m["methods"])
-        self.assertIn("attr_prop", m["properties"])
-        # private attrs skipped
-        self.assertNotIn("__init__", m["methods"])
-
-    def test_include_flags_limit_work(self):
-        only_methods = oi.get_object_members(_Fake(), include_properties=False)
-        self.assertIn("methods", only_methods)
-        self.assertNotIn("properties", only_methods)
-
-        only_props = oi.get_object_members(_Fake(), include_methods=False)
-        self.assertIn("properties", only_props)
-        self.assertNotIn("methods", only_props)
-
-    def test_bound_method_signature_resolved(self):
-        m = oi.get_object_members(_Fake())
-        # GetName(self) -> "()" once self is bound; GetClipProperty(self, key) -> "(key)"
-        self.assertEqual(m["methods"]["GetName"]["signature"], "()")
-        self.assertEqual(m["methods"]["GetClipProperty"]["signature"], "(key)")
-        self.assertEqual(m["methods"]["GetName"]["doc"], "Return the name.")
-
-    def test_signature_guard_skips_inspect_signature_for_c_ext(self):
-        # A callable that is neither a function nor a method must NOT trigger
-        # inspect.signature (the slow/raising path) and must default to "()".
-        import inspect as _inspect
-
-        calls = {"n": 0}
-        real_signature = _inspect.signature
-
-        def counting_signature(x):
-            calls["n"] += 1
-            return real_signature(x)
-
-        cext = _CExtMethod()
-        obj = _FakeWithCExt(cext)
-        try:
-            _inspect.signature = counting_signature
-            m = oi.get_object_members(obj)
-        finally:
-            _inspect.signature = real_signature
-
-        self.assertIn("NativeCall", m["methods"])
-        self.assertEqual(m["methods"]["NativeCall"]["signature"], "()")
-        self.assertIn("value", m["properties"])
-        # The C-ext callable must not have hit inspect.signature.
-        self.assertEqual(calls["n"], 0)
-
-    def test_none_returns_error(self):
-        self.assertIn("error", oi.get_object_members(None))
-
-
-class BackCompatWrapperTest(unittest.TestCase):
-    def test_get_object_methods_wrapper(self):
-        methods = oi.get_object_methods(_Fake())
-        self.assertIn("GetName", methods)
-        self.assertNotIn("attr_prop", methods)
-
-    def test_get_object_properties_wrapper(self):
-        props = oi.get_object_properties(_Fake())
-        self.assertIn("attr_prop", props)
-        self.assertNotIn("GetName", props)
-
-    def test_wrappers_preserve_none_error(self):
-        self.assertIn("error", oi.get_object_methods(None))
-        self.assertIn("error", oi.get_object_properties(None))
-
-
-class InspectObjectTest(unittest.TestCase):
-    def test_shape(self):
-        out = oi.inspect_object(_Fake())
-        self.assertEqual(out["type"], "_Fake")
-        self.assertIn("GetName", out["methods"])
-        self.assertIn("attr_prop", out["properties"])
-        self.assertIn("str", out)
-
-    def test_none(self):
-        self.assertIn("error", oi.inspect_object(None))
-
-
-class PrintObjectHelpTest(unittest.TestCase):
-    def test_renders_methods_and_properties(self):
-        h = oi.print_object_help(_Fake())
-        self.assertIn("GetName", h)
-        self.assertIn("attr_prop", h)
-        self.assertIn("Return the name.", h)
-
-    def test_none(self):
-        self.assertEqual(oi.print_object_help(None), "Cannot provide help for None object")
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,172 +0,0 @@
-"""Unit tests for the open_control_panel hardening: port-collision guard,
-stale-version detection (tracked and untracked), and force_restart path.
-
-No Resolve required; the dashboard launch itself is stubbed.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import tempfile
-import unittest
-from unittest import mock
-
-from src import server
-
-
-class ControlPanelStaleDetection(unittest.TestCase):
-    """When a dashboard is listening on the target port and reports a
-    different mcp_version than the live one (or no version at all),
-    open_control_panel must surface ``stale_running`` with a remediation
-    rather than silently using the stale instance.
-    """
-
-    def setUp(self) -> None:
-        self.tmp = tempfile.TemporaryDirectory()
-        self.addCleanup(self.tmp.cleanup)
-        self.pidfile = os.path.join(self.tmp.name, "control_panel.pid")
-        self._patches = [
-            mock.patch.object(server, "_control_panel_pidfile", return_value=self.pidfile),
-        ]
-        for p in self._patches:
-            p.start()
-            self.addCleanup(p.stop)
-
-    def _write_state(self, pid: int) -> None:
-        with open(self.pidfile, "w", encoding="utf-8") as fh:
-            json.dump({
-                "pid": pid, "port": 8765, "host": "127.0.0.1",
-                "url": "http://127.0.0.1:8765",
-            }, fh)
-
-    def test_stale_running_when_remote_version_differs(self) -> None:
-        self._write_state(99999)
-        with mock.patch.object(server, "_control_panel_pid_alive", return_value=True), \
-             mock.patch.object(server, "_port_owner_pid", return_value=99999), \
-             mock.patch.object(server, "_control_panel_probe",
-                               return_value={"is_dashboard": True, "version": "2.20.0"}), \
-             mock.patch.object(server, "VERSION", "2.24.1"):
-            result = server._open_control_panel({})
-        self.assertTrue(result["success"])
-        self.assertEqual(result["status"], "stale_running")
-        self.assertEqual(result["running_version"], "2.20.0")
-        self.assertEqual(result["live_version"], "2.24.1")
-        self.assertIn("force_restart=true", result["remediation"])
-
-    def test_already_running_when_versions_match(self) -> None:
-        self._write_state(99999)
-        with mock.patch.object(server, "_control_panel_pid_alive", return_value=True), \
-             mock.patch.object(server, "_port_owner_pid", return_value=99999), \
-             mock.patch.object(server, "_control_panel_probe",
-                               return_value={"is_dashboard": True, "version": "2.24.1"}), \
-             mock.patch.object(server, "VERSION", "2.24.1"):
-            result = server._open_control_panel({})
-        self.assertEqual(result["status"], "already_running")
-        self.assertEqual(result["running_version"], "2.24.1")
-
-    def test_stale_running_when_remote_version_missing(self) -> None:
-        # Older dashboards that predate the mcp_version field are stale too —
-        # they can't honor newer surfaces, and the caller needs to know.
-        self._write_state(99999)
-        with mock.patch.object(server, "_control_panel_pid_alive", return_value=True), \
-             mock.patch.object(server, "_port_owner_pid", return_value=99999), \
-             mock.patch.object(server, "_control_panel_probe",
-                               return_value={"is_dashboard": True, "version": None}), \
-             mock.patch.object(server, "VERSION", "2.24.1"):
-            result = server._open_control_panel({})
-        self.assertEqual(result["status"], "stale_running")
-        self.assertIsNone(result["running_version"])
-        self.assertEqual(result["live_version"], "2.24.1")
-        self.assertIn("predates", result["remediation"])
-
-    def test_stale_running_when_untracked_dashboard_owns_port(self) -> None:
-        # The real-world bug: pidfile missing (this MCP didn't spawn the
-        # listener) but a dashboard from a prior MCP session survived a
-        # restart. The freshness check must still fire on the basis of the
-        # port-owner probe alone.
-        # No _write_state() — pidfile intentionally absent.
-        with mock.patch.object(server, "_port_owner_pid", return_value=97877), \
-             mock.patch.object(server, "_control_panel_probe",
-                               return_value={"is_dashboard": True, "version": "2.24.0"}), \
-             mock.patch.object(server, "VERSION", "2.24.1"):
-            result = server._open_control_panel({})
-        self.assertTrue(result["success"])
-        self.assertEqual(result["status"], "stale_running")
-        self.assertEqual(result["pid"], 97877)
-        self.assertEqual(result["running_version"], "2.24.0")
-        self.assertEqual(result["live_version"], "2.24.1")
-
-
-class PortCollisionGuard(unittest.TestCase):
-    """When the target port is held by a non-dashboard process,
-    open_control_panel must refuse rather than spawn a child that will
-    crash silently with `Address already in use`.
-    """
-
-    def setUp(self) -> None:
-        self.tmp = tempfile.TemporaryDirectory()
-        self.addCleanup(self.tmp.cleanup)
-        self.pidfile = os.path.join(self.tmp.name, "control_panel.pid")
-        self._patches = [
-            mock.patch.object(server, "_control_panel_pidfile", return_value=self.pidfile),
-        ]
-        for p in self._patches:
-            p.start()
-            self.addCleanup(p.stop)
-
-    def test_refuses_when_non_dashboard_process_owns_port(self) -> None:
-        with mock.patch.object(server, "_port_owner_pid", return_value=12345), \
-             mock.patch.object(server, "_control_panel_probe",
-                               return_value={"is_dashboard": False, "version": None}):
-            result = server._open_control_panel({})
-        self.assertFalse(result.get("success"))
-        err = result.get("error")
-        msg = err.get("message") if isinstance(err, dict) else str(err)
-        self.assertIn("12345", msg)
-        self.assertIn("not a control panel", msg)
-        self.assertIn("force_restart=true", msg)
-
-
-class ControlPanelProbe(unittest.TestCase):
-    """`_control_panel_probe` is the new helper that distinguishes a
-    dashboard listener from a non-dashboard squatter, regardless of whether
-    the listener exposes the ``mcp_version`` field.
-    """
-
-    def test_recognizes_dashboard_with_version(self) -> None:
-        payload = {
-            "success": True,
-            "project_name": "CKY",
-            "capabilities": {"mcp_version": "2.24.1"},
-        }
-        with mock.patch("urllib.request.urlopen") as m:
-            ctx = m.return_value.__enter__.return_value
-            ctx.read.return_value = json.dumps(payload).encode("utf-8")
-            result = server._control_panel_probe("127.0.0.1", 8765)
-        self.assertEqual(result, {"is_dashboard": True, "version": "2.24.1"})
-
-    def test_recognizes_dashboard_without_version(self) -> None:
-        payload = {"success": True, "project_name": "CKY"}
-        with mock.patch("urllib.request.urlopen") as m:
-            ctx = m.return_value.__enter__.return_value
-            ctx.read.return_value = json.dumps(payload).encode("utf-8")
-            result = server._control_panel_probe("127.0.0.1", 8765)
-        self.assertEqual(result, {"is_dashboard": True, "version": None})
-
-    def test_non_dashboard_response(self) -> None:
-        # Some other HTTP server happens to be on the port.
-        with mock.patch("urllib.request.urlopen") as m:
-            ctx = m.return_value.__enter__.return_value
-            ctx.read.return_value = b'{"some": "other-server"}'
-            result = server._control_panel_probe("127.0.0.1", 8765)
-        self.assertEqual(result, {"is_dashboard": False, "version": None})
-
-    def test_connection_failure(self) -> None:
-        with mock.patch("urllib.request.urlopen", side_effect=OSError("connection refused")):
-            result = server._control_panel_probe("127.0.0.1", 8765)
-        self.assertEqual(result, {"is_dashboard": False, "version": None})
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,57 +0,0 @@
-"""Tests for deep-QC P1 1b: required-param validation returns structured errors
-instead of crashing with KeyError on omitted params."""
-import unittest
-from unittest import mock
-
-import src.server as s
-
-
-class TimelineParamValidationTest(unittest.TestCase):
-    def test_set_current_missing_index_errors(self):
-        with mock.patch.object(s, "_check", return_value=(mock.Mock(), mock.Mock(), None)):
-            out = s.timeline("set_current", {})
-        self.assertIn("error", out)
-        self.assertNotIn("success", out)  # did not crash / did not proceed
-
-    def test_set_current_valid_index_proceeds(self):
-        fake_proj = mock.Mock()
-        fake_tl = mock.Mock()
-        fake_proj.GetTimelineByIndex.return_value = fake_tl
-        fake_proj.SetCurrentTimeline.return_value = True
-        with mock.patch.object(s, "_check", return_value=(mock.Mock(), fake_proj, None)):
-            out = s.timeline("set_current", {"index": 2})
-        self.assertTrue(out.get("success"))
-        fake_proj.GetTimelineByIndex.assert_called_once_with(2)
-
-    def test_add_track_missing_track_type_errors(self):
-        fake_proj = mock.Mock()
-        fake_proj.GetCurrentTimeline.return_value = mock.Mock()
-        with mock.patch.object(s, "_check", return_value=(mock.Mock(), fake_proj, None)):
-            out = s.timeline("add_track", {})
-        self.assertIn("error", out)
-
-
-class ProjectManagerParamValidationTest(unittest.TestCase):
-    def _fake_resolve(self):
-        r = mock.Mock()
-        r.GetProjectManager.return_value = mock.Mock()
-        return r
-
-    def test_create_missing_name_errors(self):
-        with mock.patch.object(s, "get_resolve", return_value=self._fake_resolve()):
-            out = s.project_manager("create", {})
-        self.assertIn("error", out)
-
-    def test_export_project_missing_path_errors(self):
-        with mock.patch.object(s, "get_resolve", return_value=self._fake_resolve()):
-            out = s.project_manager("export_project", {"name": "X"})
-        self.assertIn("error", out)
-
-    def test_archive_missing_both_errors(self):
-        with mock.patch.object(s, "get_resolve", return_value=self._fake_resolve()):
-            out = s.project_manager("archive", {})
-        self.assertIn("error", out)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,81 +0,0 @@
-"""Tests for deep-QC P1: settings/options whitelist + DeleteProject routing."""
-import unittest
-from unittest import mock
-
-import src.server as s
-
-
-class FilterToKeysTest(unittest.TestCase):
-    def test_drops_unknown_keys_and_reports(self):
-        filtered, ignored = s._filter_to_keys(
-            {"timelineName": "x", "bogus": 1, "importSourceClips": True},
-            s._IMPORT_TIMELINE_OPTION_KEYS,
-        )
-        self.assertEqual(filtered, {"timelineName": "x", "importSourceClips": True})
-        self.assertEqual(ignored, ["bogus"])
-
-    def test_non_dict_returns_empty(self):
-        self.assertEqual(s._filter_to_keys(None, {"a"}), ({}, []))
-        self.assertEqual(s._filter_to_keys("x", {"a"}), ({}, []))
-
-    def test_voice_isolation_keys(self):
-        filtered, ignored = s._filter_to_keys(
-            {"isEnabled": True, "amount": 50, "typo": 9}, s._VOICE_ISOLATION_STATE_KEYS
-        )
-        self.assertEqual(filtered, {"isEnabled": True, "amount": 50})
-        self.assertEqual(ignored, ["typo"])
-
-
-class ImportTimelineWhitelistTest(unittest.TestCase):
-    def test_import_timeline_filters_options(self):
-        captured = {}
-        fake_tl = mock.Mock()
-        fake_tl.GetName.return_value = "T"
-        fake_mp = mock.Mock()
-        fake_mp.ImportTimelineFromFile.side_effect = lambda path, opts: captured.update(opts=opts) or fake_tl
-        fake_proj = mock.Mock()
-        with mock.patch.object(s, "_check", return_value=(mock.Mock(), fake_proj, None)), \
-             mock.patch.object(s, "_get_mp", return_value=(mock.Mock(), fake_proj, fake_mp, None)):
-            fake_mp.GetRootFolder.return_value = mock.Mock()
-            out = s.media_pool("import_timeline", {"path": "/tmp/x.aaf",
-                                                   "options": {"timelineName": "Cut", "junk": 1}})
-        self.assertEqual(captured["opts"], {"timelineName": "Cut"})  # junk dropped
-        self.assertEqual(out.get("ignored_options"), ["junk"])
-
-
-class RenderSettingsWhitelistTest(unittest.TestCase):
-    def test_set_settings_filters_unknown_keys(self):
-        captured = {}
-        fake_proj = mock.Mock()
-        fake_proj.SetRenderSettings.side_effect = lambda s_: captured.update(s=s_) or True
-        with mock.patch.object(s, "_check", return_value=(mock.Mock(), fake_proj, None)):
-            out = s.render("set_settings", {"settings": {"TargetDir": "/tmp", "Nonsense": 9}})
-        self.assertEqual(captured["s"], {"TargetDir": "/tmp"})
-        self.assertEqual(out.get("ignored_settings"), ["Nonsense"])
-
-    def test_set_settings_requires_dict(self):
-        fake_proj = mock.Mock()
-        with mock.patch.object(s, "_check", return_value=(mock.Mock(), fake_proj, None)):
-            out = s.render("set_settings", {})
-        self.assertIn("error", out)
-
-
-class DeleteProjectRoutingTest(unittest.TestCase):
-    def test_raw_delete_routes_through_safe_helper(self):
-        fake_pm = mock.Mock()
-        with mock.patch.object(s, "_check", return_value=(fake_pm, mock.Mock(), None)), \
-             mock.patch("src.utils.project_cleanup.delete_project_safely",
-                        return_value={"success": True, "attempts": 1, "leftover": None, "detail": ""}) as safe:
-            out = s.project_manager("delete", {"name": "Disposable"})
-        safe.assert_called_once()
-        self.assertTrue(out["success"])
-        self.assertIn("delete_detail", out)
-
-    def test_raw_delete_requires_name(self):
-        with mock.patch.object(s, "_check", return_value=(mock.Mock(), mock.Mock(), None)):
-            out = s.project_manager("delete", {})
-        self.assertIn("error", out)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,52 +0,0 @@
-"""Tests for the page-switch serialization lock."""
-import threading
-import time
-import unittest
-from unittest import mock
-
-from src.utils import page_lock
-from src.utils.page_lock import page_lock as plock, open_page_serialized
-
-
-class PageLockTest(unittest.TestCase):
-    def test_reentrant_no_deadlock(self):
-        # Nested page_lock() in the same thread must not deadlock (the fcntl
-        # lock is only taken at the outermost level).
-        with plock():
-            with plock():
-                self.assertEqual(page_lock._depth, 2)
-        self.assertEqual(page_lock._depth, 0)
-
-    def test_open_page_serialized_calls_openpage(self):
-        r = mock.Mock()
-        r.OpenPage.return_value = True
-        self.assertTrue(open_page_serialized(r, "color"))
-        r.OpenPage.assert_called_once_with("color")
-
-    def test_serializes_across_threads(self):
-        order = []
-
-        def worker():
-            with plock():
-                order.append("worker")
-
-        with plock():
-            t = threading.Thread(target=worker)
-            t.start()
-            time.sleep(0.05)  # give the worker a chance to (try to) acquire
-            order.append("main")
-        t.join()
-        # The worker must have waited until main released the lock.
-        self.assertEqual(order, ["main", "worker"])
-
-    def test_depth_resets_on_exception(self):
-        try:
-            with plock():
-                raise ValueError("boom")
-        except ValueError:
-            pass
-        self.assertEqual(page_lock._depth, 0)
-
-
-if __name__ == "__main__":
-    unittest.main()