@hybridlabor-api/aos 4.2.0 → 4.4.0

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

@@ -1,386 +0,0 @@
-"""Contract tests for the Resolve 21.0 scripting-API additions.
-
-Covers the consolidated-server actions added in v2.29.0:
-  - folder / media_pool_item: perform_audio_classification, clear_audio_classification,
-    analyze_for_intellisearch, analyze_for_slate, remove_motion_blur (confirm-gated),
-    transcribe_audio use_speaker_detection passthrough
-  - resolve_control: disable_background_tasks_for_current_session
-  - project_settings: generate_speech (confirm-gated)
-  - capability detection (_transcription_capabilities) reports the new method flags
-  - version guarding: legacy objects (no 21.0 method) return a "requires 21.0" error
-"""
-import tempfile
-import unittest
-
-import src.server as compound
-from src.utils import resolve_ai_ledger as _ledger
-
-
-# ── Stubs ────────────────────────────────────────────────────────────────────
-
-
-class Clip21:
-    """A MediaPoolItem exposing the Resolve 21.0 methods."""
-
-    def __init__(self, name="clip.mov", cid="c1"):
-        self._name = name
-        self._id = cid
-        self.calls = []
-
-    def GetName(self):
-        return self._name
-
-    def GetUniqueId(self):
-        return self._id
-
-    def TranscribeAudio(self, *args):
-        self.calls.append(("TranscribeAudio", args))
-        return True
-
-    def ClearTranscription(self):
-        return True
-
-    def PerformAudioClassification(self):
-        self.calls.append(("PerformAudioClassification", ()))
-        return True
-
-    def ClearAudioClassification(self):
-        self.calls.append(("ClearAudioClassification", ()))
-        return True
-
-    def AnalyzeForIntellisearch(self, identify_faces, is_better_mode):
-        self.calls.append(("AnalyzeForIntellisearch", (identify_faces, is_better_mode)))
-        return True
-
-    def AnalyzeForSlate(self, marker_color):
-        self.calls.append(("AnalyzeForSlate", (marker_color,)))
-        return True
-
-    def RemoveMotionBlur(self, deblur_option):
-        self.calls.append(("RemoveMotionBlur", (deblur_option,)))
-        return Clip21(name="clip_deblurred.mov", cid="c1-deblur")
-
-
-class LegacyClip:
-    """A MediaPoolItem from a pre-21 Resolve build (no 21.0 methods)."""
-
-    def __init__(self, name="legacy.mov", cid="L1"):
-        self._name = name
-        self._id = cid
-
-    def GetName(self):
-        return self._name
-
-    def GetUniqueId(self):
-        return self._id
-
-    def TranscribeAudio(self, *args):
-        return True
-
-    def ClearTranscription(self):
-        return True
-
-
-class Folder21:
-    def __init__(self, name="Master"):
-        self._name = name
-        self.calls = []
-
-    def GetName(self):
-        return self._name
-
-    def TranscribeAudio(self, *args):
-        self.calls.append(("TranscribeAudio", args))
-        return True
-
-    def ClearTranscription(self):
-        return True
-
-    def PerformAudioClassification(self):
-        self.calls.append(("PerformAudioClassification", ()))
-        return True
-
-    def ClearAudioClassification(self):
-        return True
-
-    def AnalyzeForIntellisearch(self, identify_faces, is_better_mode):
-        self.calls.append(("AnalyzeForIntellisearch", (identify_faces, is_better_mode)))
-        return True
-
-    def AnalyzeForSlate(self, marker_color):
-        self.calls.append(("AnalyzeForSlate", (marker_color,)))
-        return True
-
-    def RemoveMotionBlur(self, deblur_option):
-        self.calls.append(("RemoveMotionBlur", (deblur_option,)))
-        orig = Clip21(name="a.mov", cid="a")
-        new = Clip21(name="a_deblurred.mov", cid="a-deblur")
-        return [[orig, new]]
-
-
-class MediaPoolStub:
-    def __init__(self, folder=None, clip=None):
-        self._folder = folder or Folder21()
-        self._clip = clip or Clip21()
-
-    def GetRootFolder(self):
-        return self._folder
-
-    def GetCurrentFolder(self):
-        return self._folder
-
-    def GetSelectedClips(self):
-        return [self._clip]
-
-
-class Project21:
-    def __init__(self):
-        self.calls = []
-
-    def GetName(self):
-        return "Proj"
-
-    def GenerateSpeech(self, settings, timecode):
-        self.calls.append((settings, timecode))
-        return Clip21(name="speech.wav", cid="vo-1")
-
-
-class LegacyProject:
-    def GetName(self):
-        return "Proj"
-
-
-class Resolve21:
-    def __init__(self):
-        self.disabled = False
-
-    def DisableBackgroundTasksForCurrentResolveSession(self):
-        self.disabled = True
-
-
-class LegacyResolve:
-    pass
-
-
-# ── Tests ────────────────────────────────────────────────────────────────────
-
-
-class Resolve21FolderActionsTest(unittest.TestCase):
-    def setUp(self):
-        compound._CONFIRM_TOKENS.clear()
-        self.folder = Folder21()
-        self.mp = MediaPoolStub(folder=self.folder)
-        self._orig_get_mp = compound._get_mp
-        compound._get_mp = lambda: (None, None, self.mp, None)
-        # Isolate the AI-ops ledger to a temp project root (also avoids the real
-        # _destructive_versioning_provider hitting a live Resolve during tests).
-        self._tmp = tempfile.TemporaryDirectory()
-        self._orig_root = compound._ai_ledger_root
-        compound._ai_ledger_root = lambda: self._tmp.name
-
-    def tearDown(self):
-        compound._get_mp = self._orig_get_mp
-        compound._ai_ledger_root = self._orig_root
-        self._tmp.cleanup()
-
-    def test_op_is_recorded_in_ledger(self):
-        compound.folder("analyze_for_slate", {"marker_color": "Sky"})
-        rows = _ledger.get_usage(project_root=self._tmp.name)
-        self.assertEqual(len(rows), 1)
-        self.assertEqual(rows[0]["op"], "analyze_for_slate")
-        self.assertEqual(rows[0]["success"], 1)
-
-    def test_perform_audio_classification(self):
-        out = compound.folder("perform_audio_classification", {})
-        self.assertTrue(out["success"])
-        self.assertIn(("PerformAudioClassification", ()), self.folder.calls)
-
-    def test_analyze_for_intellisearch_passes_flags(self):
-        out = compound.folder("analyze_for_intellisearch", {"identify_faces": True, "is_better_mode": True})
-        self.assertTrue(out["success"])
-        self.assertIn(("AnalyzeForIntellisearch", (True, True)), self.folder.calls)
-
-    def test_analyze_for_slate_valid_color(self):
-        out = compound.folder("analyze_for_slate", {"marker_color": "Lavender"})
-        self.assertTrue(out["success"])
-        self.assertIn(("AnalyzeForSlate", ("Lavender",)), self.folder.calls)
-
-    def test_analyze_for_slate_invalid_color_rejected(self):
-        out = compound.folder("analyze_for_slate", {"marker_color": "Chartreuse"})
-        self.assertIn("error", out)
-        self.assertEqual(self.folder.calls, [])
-
-    def test_analyze_for_slate_default_color(self):
-        out = compound.folder("analyze_for_slate", {})
-        self.assertTrue(out["success"])
-        self.assertIn(("AnalyzeForSlate", ("Blue",)), self.folder.calls)
-
-    def test_transcribe_audio_speaker_detection_passthrough(self):
-        compound.folder("transcribe_audio", {"use_speaker_detection": True})
-        self.assertIn(("TranscribeAudio", (True,)), self.folder.calls)
-
-    def test_transcribe_audio_no_arg_when_unset(self):
-        compound.folder("transcribe_audio", {})
-        self.assertIn(("TranscribeAudio", ()), self.folder.calls)
-
-    def test_remove_motion_blur_requires_confirm_then_runs(self):
-        # First call (no token) → confirmation required, nothing rendered.
-        pending = compound.folder("remove_motion_blur", {"deblur_option": {"UseExtremeMode": True}})
-        self.assertEqual(pending.get("status"), "confirmation_required")
-        self.assertEqual(self.folder.calls, [])
-        token = pending["confirm_token"]
-        # Second call (with token) → runs and reports created pairs.
-        out = compound.folder("remove_motion_blur", {"deblur_option": {"UseExtremeMode": True}, "confirm_token": token})
-        self.assertTrue(out["success"])
-        self.assertEqual(len(out["created"]), 1)
-        self.assertEqual(out["created"][0]["new"], "a_deblurred.mov")
-
-    def test_unknown_action_lists_new_actions(self):
-        out = compound.folder("bogus", {})
-        self.assertIn("analyze_for_slate", str(out))
-
-
-class Resolve21ClipActionsTest(unittest.TestCase):
-    def setUp(self):
-        compound._CONFIRM_TOKENS.clear()
-        self.clip = Clip21()
-        self.mp = MediaPoolStub(clip=self.clip)
-        self._orig_get_mp = compound._get_mp
-        self._orig_find_clip = compound._find_clip
-        compound._get_mp = lambda: (None, None, self.mp, None)
-        compound._find_clip = lambda root, cid: self.clip
-        self._tmp = tempfile.TemporaryDirectory()
-        self._orig_root = compound._ai_ledger_root
-        compound._ai_ledger_root = lambda: self._tmp.name
-
-    def tearDown(self):
-        compound._get_mp = self._orig_get_mp
-        compound._find_clip = self._orig_find_clip
-        compound._ai_ledger_root = self._orig_root
-        self._tmp.cleanup()
-
-    def test_remove_motion_blur_records_clip_id_in_ledger(self):
-        pending = compound.media_pool_item("remove_motion_blur", {"clip_id": "c1"})
-        out = compound.media_pool_item("remove_motion_blur", {"clip_id": "c1", "confirm_token": pending["confirm_token"]})
-        self.assertTrue(out["success"])
-        rows = _ledger.get_usage(project_root=self._tmp.name, op="remove_motion_blur")
-        self.assertEqual(len(rows), 1)
-        self.assertEqual(rows[0]["clip_id"], "c1")
-        self.assertEqual(rows[0]["op_class"], "render")
-
-    def test_perform_audio_classification(self):
-        out = compound.media_pool_item("perform_audio_classification", {"clip_id": "c1"})
-        self.assertTrue(out["success"])
-        self.assertIn(("PerformAudioClassification", ()), self.clip.calls)
-
-    def test_analyze_for_slate_invalid_color_rejected(self):
-        out = compound.media_pool_item("analyze_for_slate", {"clip_id": "c1", "marker_color": "Neon"})
-        self.assertIn("error", out)
-        self.assertEqual(self.clip.calls, [])
-
-    def test_remove_motion_blur_confirm_flow(self):
-        pending = compound.media_pool_item("remove_motion_blur", {"clip_id": "c1"})
-        self.assertEqual(pending.get("status"), "confirmation_required")
-        token = pending["confirm_token"]
-        out = compound.media_pool_item("remove_motion_blur", {"clip_id": "c1", "confirm_token": token})
-        self.assertTrue(out["success"])
-        self.assertEqual(out["new_id"], "c1-deblur")
-
-    def test_speaker_detection_passthrough(self):
-        compound.media_pool_item("transcribe_audio", {"clip_id": "c1", "use_speaker_detection": False})
-        self.assertIn(("TranscribeAudio", (False,)), self.clip.calls)
-
-    def test_legacy_clip_version_guarded(self):
-        self.clip = LegacyClip()
-        compound._find_clip = lambda root, cid: self.clip
-        out = compound.media_pool_item("perform_audio_classification", {"clip_id": "L1"})
-        self.assertIn("error", out)
-        self.assertIn("21.0", str(out))
-
-
-class Resolve21ResolveControlTest(unittest.TestCase):
-    def setUp(self):
-        self._orig = compound.get_resolve
-
-    def tearDown(self):
-        compound.get_resolve = self._orig
-
-    def test_disable_background_tasks(self):
-        r = Resolve21()
-        compound.get_resolve = lambda: r
-        out = compound.resolve_control("disable_background_tasks_for_current_session", {})
-        self.assertTrue(out["success"])
-        self.assertTrue(r.disabled)
-
-    def test_disable_background_tasks_legacy_guarded(self):
-        compound.get_resolve = lambda: LegacyResolve()
-        out = compound.resolve_control("disable_background_tasks_for_current_session", {})
-        self.assertIn("error", out)
-        self.assertIn("21.0", str(out))
-
-
-class Resolve21GenerateSpeechTest(unittest.TestCase):
-    def setUp(self):
-        compound._CONFIRM_TOKENS.clear()
-        self.proj = Project21()
-        self._orig_check = compound._check
-        compound._check = lambda: (None, self.proj, None)
-        self._tmp = tempfile.TemporaryDirectory()
-        self._orig_root = compound._ai_ledger_root
-        compound._ai_ledger_root = lambda: self._tmp.name
-
-    def tearDown(self):
-        compound._check = self._orig_check
-        compound._ai_ledger_root = self._orig_root
-        self._tmp.cleanup()
-
-    def test_requires_text_input(self):
-        out = compound.project_settings("generate_speech", {"speech_generation_settings": {"VoiceModel": "Female 1"}})
-        self.assertIn("error", out)
-        self.assertEqual(self.proj.calls, [])
-
-    def test_confirm_flow_and_settings_passthrough(self):
-        params = {"speech_generation_settings": {"TextInput": "Hello world", "AddToTimeline": True}, "timecode": "01:00:00:00"}
-        pending = compound.project_settings("generate_speech", params)
-        self.assertEqual(pending.get("status"), "confirmation_required")
-        self.assertTrue(pending["preview"]["add_to_timeline"])
-        self.assertEqual(self.proj.calls, [])
-        params_with_token = dict(params, confirm_token=pending["confirm_token"])
-        out = compound.project_settings("generate_speech", params_with_token)
-        self.assertTrue(out["success"])
-        self.assertEqual(out["new_id"], "vo-1")
-        self.assertEqual(self.proj.calls[0][0]["TextInput"], "Hello world")
-        self.assertEqual(self.proj.calls[0][1], "01:00:00:00")
-
-    def test_legacy_project_guarded(self):
-        compound._check = lambda: (None, LegacyProject(), None)
-        out = compound.project_settings("generate_speech", {"speech_generation_settings": {"TextInput": "x"}})
-        self.assertIn("error", out)
-        self.assertIn("21.0", str(out))
-
-
-class Resolve21CapabilityDetectionTest(unittest.TestCase):
-    def test_capability_block_reports_new_flags(self):
-        clip = Clip21()
-        folder = Folder21()
-        mp = MediaPoolStub(folder=folder, clip=clip)
-        caps = compound._transcription_capabilities(mp, {"selected": True})
-        cm = caps["clip_methods"][0]
-        for key in ("perform_audio_classification", "clear_audio_classification",
-                    "analyze_for_intellisearch", "analyze_for_slate", "remove_motion_blur"):
-            self.assertTrue(cm[key], msg=f"clip flag {key} should be True")
-            self.assertTrue(caps["folder"][key], msg=f"folder flag {key} should be True")
-
-    def test_capability_block_false_for_legacy(self):
-        clip = LegacyClip()
-        # Folder21 has the methods; use a legacy-style folder by reusing LegacyClip shape.
-        folder = LegacyClip(name="Legacy")
-        mp = MediaPoolStub(folder=folder, clip=clip)
-        caps = compound._transcription_capabilities(mp, {"selected": True})
-        cm = caps["clip_methods"][0]
-        self.assertFalse(cm["perform_audio_classification"])
-        self.assertTrue(cm["transcribe_audio"])  # legacy still has transcription
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,92 +0,0 @@
-"""Tests for the Resolve 21 AI-ops governance tiers (advisory soft limits)."""
-import tempfile
-import unittest
-
-from src.utils import resolve_ai_governance as G
-from src.utils import resolve_ai_ledger as L
-
-
-class GovernanceTierResolutionTest(unittest.TestCase):
-    def test_known_tiers_present(self):
-        self.assertEqual(G.VALID_TIERS, frozenset({"off", "lenient", "standard", "strict"}))
-        self.assertEqual(G.DEFAULT_TIER, "standard")
-
-    def test_resolve_unknown_falls_back_to_default(self):
-        self.assertEqual(G.resolve_tier("bogus")["preset"], "standard")
-
-    def test_overrides_applied(self):
-        r = G.resolve_tier("standard", {"deblur_runs": 3, "render_bytes": "unlimited"})
-        self.assertEqual(r["thresholds"]["deblur_runs"], 3)
-        self.assertIsNone(r["thresholds"]["render_bytes"])
-
-    def test_off_tier_is_all_uncapped(self):
-        th = G.resolve_tier("off")["thresholds"]
-        self.assertTrue(all(v is None for v in th.values()))
-
-
-class GovernanceCheckTest(unittest.TestCase):
-    def setUp(self):
-        self._tmp = tempfile.TemporaryDirectory()
-        self.root = self._tmp.name
-
-    def tearDown(self):
-        self._tmp.cleanup()
-
-    def _record_deblur(self, n, *, bytes_each=0, ms_each=0, session="s1"):
-        for i in range(n):
-            L.record_op(project_root=self.root, op="remove_motion_blur", session_id=session,
-                        success=True, wall_clock_ms=ms_each, output_path=f"/d{i}.mov", output_bytes=bytes_each)
-
-    def test_analysis_op_not_governed(self):
-        out = G.check(project_root=self.root, session_id="s1", op="analyze_for_slate", preset="strict")
-        self.assertFalse(out["applies"])
-        self.assertEqual(out["warnings"], [])
-
-    def test_within_tier_no_warnings(self):
-        self._record_deblur(1)
-        out = G.check(project_root=self.root, session_id="s1", op="remove_motion_blur", preset="standard")
-        self.assertTrue(out["applies"])
-        self.assertFalse(out["exceeded"])
-        self.assertEqual(out["projected"]["deblur_runs"], 2)
-
-    def test_exceeds_run_cap(self):
-        self._record_deblur(5)  # strict cap = 5; next run projects to 6
-        out = G.check(project_root=self.root, session_id="s1", op="remove_motion_blur", preset="strict")
-        self.assertTrue(out["exceeded"])
-        self.assertTrue(any("Runs this session" in w for w in out["warnings"]))
-
-    def test_near_threshold_warns(self):
-        self._record_deblur(11)  # standard cap 15; 12 projected = 80%
-        out = G.check(project_root=self.root, session_id="s1", op="remove_motion_blur", preset="standard")
-        self.assertTrue(out["near"] or out["exceeded"])
-
-    def test_off_tier_never_warns(self):
-        self._record_deblur(100, bytes_each=10**9, ms_each=10**6)
-        out = G.check(project_root=self.root, session_id="s1", op="remove_motion_blur", preset="off")
-        self.assertFalse(out["exceeded"])
-        self.assertEqual(out["warnings"], [])
-
-    def test_bytes_and_time_dimensions(self):
-        self._record_deblur(2, bytes_each=2 * (1024 ** 3), ms_each=4 * 60 * 1000)  # 4 GB, 8 min
-        out = G.check(project_root=self.root, session_id="s1", op="remove_motion_blur", preset="strict")
-        # strict: render_bytes 2GB, render_wall_clock_ms 5min — both exceeded
-        self.assertTrue(out["exceeded"])
-        joined = " ".join(out["warnings"])
-        self.assertIn("Media created this session", joined)
-        self.assertIn("Render time this session", joined)
-
-    def test_no_project_root_does_not_apply(self):
-        out = G.check(project_root=None, session_id="s1", op="remove_motion_blur", preset="strict")
-        self.assertFalse(out["applies"])
-
-    def test_status_reports_usage_and_thresholds(self):
-        self._record_deblur(3, bytes_each=1024 ** 3)
-        st = G.status(project_root=self.root, session_id="s1", preset="standard")
-        self.assertEqual(st["tier"], "standard")
-        self.assertEqual(st["usage"]["deblur_runs"], 3)
-        self.assertEqual(st["thresholds"]["deblur_runs"], 15)
-        self.assertIn("strict", st["tiers_available"])
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,89 +0,0 @@
-"""Tests for the Resolve 21 AI-ops ledger (src/utils/resolve_ai_ledger.py)."""
-import tempfile
-import unittest
-
-from src.utils import resolve_ai_ledger as L
-
-
-class LedgerRecordQueryTest(unittest.TestCase):
-    def setUp(self):
-        self._tmp = tempfile.TemporaryDirectory()
-        self.root = self._tmp.name
-
-    def tearDown(self):
-        self._tmp.cleanup()
-
-    def test_op_meta_classification(self):
-        self.assertEqual(L.op_meta("remove_motion_blur")["op_class"], L.OP_CLASS_RENDER)
-        self.assertEqual(L.op_meta("generate_speech")["op_class"], L.OP_CLASS_RENDER)
-        self.assertEqual(L.op_meta("analyze_for_slate")["op_class"], L.OP_CLASS_ANALYSIS)
-        self.assertEqual(L.op_meta("analyze_for_slate")["extra_required"], "AI Slate ID")
-        self.assertEqual(L.op_meta("perform_audio_classification")["extra_required"], None)
-        # Unknown op falls back to analysis/no-extra.
-        self.assertEqual(L.op_meta("nope")["op_class"], L.OP_CLASS_ANALYSIS)
-
-    def test_record_and_get_usage(self):
-        rid = L.record_op(project_root=self.root, op="analyze_for_slate", clip_id="c1",
-                          session_id="s1", success=True, wall_clock_ms=120)
-        self.assertIsNotNone(rid)
-        rows = L.get_usage(project_root=self.root)
-        self.assertEqual(len(rows), 1)
-        self.assertEqual(rows[0]["op"], "analyze_for_slate")
-        self.assertEqual(rows[0]["success"], 1)
-        self.assertEqual(rows[0]["op_class"], "analysis")
-        self.assertEqual(rows[0]["extra_required"], "AI Slate ID")
-
-    def test_no_project_root_is_noop(self):
-        self.assertIsNone(L.record_op(project_root="", op="analyze_for_slate"))
-        self.assertEqual(L.get_usage(project_root=""), [])
-        self.assertEqual(L.get_summary(project_root="")["totals"]["runs"], 0)
-
-    def test_timed_context_manager_records(self):
-        with L.timed(self.root, "perform_audio_classification", clip_id="c1", session_id="s1") as rec:
-            rec.success = True
-        rows = L.get_usage(project_root=self.root, op="perform_audio_classification")
-        self.assertEqual(len(rows), 1)
-        self.assertEqual(rows[0]["success"], 1)
-
-    def test_timed_records_exception_and_reraises(self):
-        with self.assertRaises(ValueError):
-            with L.timed(self.root, "analyze_for_slate", session_id="s1") as rec:
-                raise ValueError("boom")
-        rows = L.get_usage(project_root=self.root)
-        self.assertEqual(len(rows), 1)
-        self.assertEqual(rows[0]["success"], 0)
-        self.assertIn("boom", rows[0]["error"])
-
-    def test_timed_none_root_is_noop(self):
-        # Should not raise and should record nothing.
-        with L.timed(None, "analyze_for_slate") as rec:
-            rec.success = True
-        self.assertEqual(L.get_usage(project_root=self.root), [])
-
-    def test_summary_aggregates_files_and_bytes(self):
-        L.record_op(project_root=self.root, op="remove_motion_blur", session_id="s1",
-                    success=True, wall_clock_ms=5000, output_path="/tmp/a_deblur.mov", output_bytes=2_000_000)
-        L.record_op(project_root=self.root, op="remove_motion_blur", session_id="s1",
-                    success=True, wall_clock_ms=3000, output_path="/tmp/b_deblur.mov", output_bytes=1_000_000)
-        L.record_op(project_root=self.root, op="analyze_for_slate", session_id="s1", success=False, error="no Extra")
-        summary = L.get_summary(project_root=self.root)
-        totals = summary["totals"]
-        self.assertEqual(totals["runs"], 3)
-        self.assertEqual(totals["successes"], 2)
-        self.assertEqual(totals["failures"], 1)
-        self.assertEqual(totals["files_created"], 2)
-        self.assertEqual(totals["bytes_created"], 3_000_000)
-        self.assertEqual(totals["wall_clock_ms"], 8000)
-        deblur = summary["by_op"]["remove_motion_blur"]
-        self.assertEqual(deblur["op_class"], "render")
-        self.assertEqual(deblur["files_created"], 2)
-
-    def test_session_scoping(self):
-        L.record_op(project_root=self.root, op="analyze_for_slate", session_id="s1", success=True)
-        L.record_op(project_root=self.root, op="analyze_for_slate", session_id="s2", success=True)
-        self.assertEqual(L.get_summary(project_root=self.root, session_id="s1")["totals"]["runs"], 1)
-        self.assertEqual(L.get_summary(project_root=self.root)["totals"]["runs"], 2)
-
-
-if __name__ == "__main__":
-    unittest.main()