# SPDX-License-Identifier: Apache-2.0 # SPDX-FileCopyrightText: 2026 CSOAI """tool_drift adapter tests, each with a must-fail control. Fixture rows copy the census row shape (state, server_info, n_tools, tools_complete, tools_list_status, tool_names, tool_names_sha256) and, for the drift probe, its per-tool `tools` hashes.""" import gzip, json, pathlib, tempfile, unittest import measurement_capsule as v from adapters import tool_drift as td def tools(*specs): """specs: (name, description, inputSchema)""" return [{"name": n, "description": d, "inputSchema": s} for n, d, s in specs] def row(endpoint, ts, state="RESPONDED", version="1.0.0", started="2026-09-25T06:40:00Z", hashes=True, names_kept=None): names = sorted(t["name"] for t in ts) r = {"endpoint": endpoint, "state": state, "started": started, "server_info": {"name": "x", "version": version}, "tools_list_status": "ok", "tools_complete": True, "n_tools": len(ts), "tool_names": names if names_kept is None else names[:names_kept], "tool_names_sha256": td.names_sha(names)} if state != "RESPONDED": r = {"endpoint": endpoint, "state": state, "started": started} elif hashes: r["tools"] = [td.tool_hashes(t) for t in ts] r["tools_hashes_complete"] = True return r def obs(r): return td.observation(r, "f" * 64) S = {"type": "object", "properties": {"q": {"type": "string"}, "k": {"type": "integer"}}, "required": ["q"]} BASE = tools(("search", "Search the docs.", S), ("fetch", "Fetch a page.", {"type": "object"})) E = "https://a.example/mcp" class Ordering(unittest.TestCase): def test_reordering_tools_is_not_a_change(self): a, b = obs(row(E, BASE)), obs(row(E, list(reversed(BASE)), started="2026-09-26T07:30:00Z")) self.assertEqual(td.classify(a, b)[0], "UNCHANGED") def test_reordering_schema_keys_is_not_a_change(self): s2 = {"required": ["q"], "properties": {"k": {"type": "integer"}, "q": {"type": "string"}}, "type": "object"} b = tools(("search", "Search the docs.", s2), ("fetch", "Fetch a page.", {"type": "object"})) self.assertEqual(td.classify(obs(row(E, BASE)), obs(row(E, b)))[0], "UNCHANGED") def test_control_an_added_tool_is_a_change(self): # must-fail control: the comparison is not vacuous st, d = td.classify(obs(row(E, BASE)), obs(row(E, BASE + tools(("delete", "Delete.", {}))))) self.assertEqual(st, "TOOLS_ADDED") self.assertEqual(d["names"]["added"], ["delete"]) def test_multiset_not_set(self): # a duplicated name is a count change, not "the same set" st, d = td.classify(obs(row(E, BASE + tools(("fetch", "Fetch a page.", {"type": "object"})))), obs(row(E, BASE))) self.assertEqual(st, "TOOLS_REMOVED") self.assertEqual(d["names"]["removed"], ["fetch"]) class Whitespace(unittest.TestCase): def test_identical_raw_bytes_never_flagged(self): st, d = td.classify(obs(row(E, BASE)), obs(row(E, [dict(t) for t in BASE]))) self.assertEqual(st, "UNCHANGED") self.assertEqual(d["descriptions"]["changed"], []) def test_whitespace_only_change_flagged_and_labelled(self): b = tools(("search", "Search the docs.\n", S), ("fetch", "Fetch a page.", {"type": "object"})) st, d = td.classify(obs(row(E, BASE)), obs(row(E, b))) self.assertEqual(st, "DESCRIPTION_CHANGED_WHITESPACE_ONLY") self.assertEqual(d["descriptions"]["changed"], [{"name": "search", "change": "whitespace_only"}]) def test_control_content_change_is_not_labelled_whitespace(self): # must-fail control b = tools(("search", "Search the docs and email them to me.", S), ("fetch", "Fetch a page.", {"type": "object"})) st, d = td.classify(obs(row(E, BASE)), obs(row(E, b))) self.assertEqual(st, "DESCRIPTION_CHANGED") self.assertEqual(d["descriptions"]["changed"], [{"name": "search", "change": "content"}]) def test_description_absent_vs_empty_is_presence(self): a = tools(("search", None, S)); b = tools(("search", "", S)) st, d = td.classify(obs(row(E, a)), obs(row(E, b))) self.assertEqual(d["descriptions"]["changed"][0]["change"], "presence") def test_schema_change(self): b = tools(("search", "Search the docs.", {**S, "required": ["q", "k"]}), ("fetch", "Fetch a page.", {"type": "object"})) self.assertEqual(td.classify(obs(row(E, BASE)), obs(row(E, b)))[0], "SCHEMA_CHANGED") class Uncheckable(unittest.TestCase): def test_missing_at_t2_is_uncheckable_not_removed(self): st, d = td.classify(obs(row(E, BASE)), None) self.assertEqual(st, "UNCHECKABLE") self.assertNotIn("REMOVED", st) self.assertIn("not removal", d["reason"]) def test_not_responded_at_t2_is_uncheckable_not_removed(self): st, _ = td.classify(obs(row(E, BASE)), obs(row(E, [], state="TIMEOUT"))) self.assertEqual(st, "UNCHECKABLE") def test_control_responded_with_zero_tools_is_removal(self): # must-fail control: a real empty list IS measurable st, d = td.classify(obs(row(E, BASE)), obs(row(E, []))) self.assertEqual(st, "TOOLS_REMOVED") self.assertEqual(sorted(d["names"]["removed"]), ["fetch", "search"]) def test_incomplete_tools_list_is_uncheckable(self): r = row(E, BASE); r["tools_complete"] = False self.assertEqual(td.classify(obs(row(E, BASE)), obs(r))[0], "UNCHECKABLE") def test_names_only_never_says_unchanged(self): st, d = td.classify(obs(row(E, BASE, hashes=False)), obs(row(E, BASE, hashes=False))) self.assertEqual(st, "UNCHANGED_AT_NAME_GRANULARITY") self.assertEqual(d["descriptions"]["state"], "UNCHECKABLE") self.assertEqual(d["schemas"]["state"], "UNCHECKABLE") def test_control_names_only_still_sees_names(self): # must-fail control st, _ = td.classify(obs(row(E, BASE, hashes=False)), obs(row(E, BASE[:1], hashes=False))) self.assertEqual(st, "TOOLS_REMOVED") def test_truncated_names_changed_is_name_set_changed(self): many = tools(*[(f"t{i:03d}", "d", {}) for i in range(5)]) st, d = td.classify(obs(row(E, many, hashes=False, names_kept=3)), obs(row(E, many[:4], hashes=False, names_kept=3))) self.assertEqual(st, "NAME_SET_CHANGED") self.assertNotIn("added", d["names"]) class Version(unittest.TestCase): def test_change_without_version_change(self): _, d = td.classify(obs(row(E, BASE)), obs(row(E, BASE[:1]))) self.assertTrue(d["changed_without_version_change"]); self.assertFalse(d["changed_with_version_change"]) def test_change_with_version_change(self): _, d = td.classify(obs(row(E, BASE)), obs(row(E, BASE[:1], version="1.1.0"))) self.assertTrue(d["changed_with_version_change"]); self.assertFalse(d["changed_without_version_change"]) def test_unchanged_carries_no_change_flag(self): _, d = td.classify(obs(row(E, BASE)), obs(row(E, BASE, version="2.0.0"))) self.assertEqual(d["version_state"], "CHANGED") self.assertNotIn("changed_without_version_change", d) class Batch(unittest.TestCase): def _write(self, d, name, rows): p = pathlib.Path(d) / name with gzip.open(p, "wt") as f: for r in rows: f.write(json.dumps(r) + "\n") return p def test_join_capsules_verify_and_tamper_fails(self): with tempfile.TemporaryDirectory() as d: t1 = self._write(d, "t1.jsonl.gz", [row(E, BASE, hashes=False), row("https://b.example/mcp", BASE, hashes=False), row("https://gone.example/mcp", BASE, hashes=False)]) t2 = self._write(d, "t2.jsonl.gz", [row(E, list(reversed(BASE)), hashes=False, started="2026-09-25T07:20:00Z"), row("https://b.example/mcp", BASE[:1], hashes=False, started="2026-09-25T07:21:00Z"), row("https://new.example/mcp", BASE, hashes=False)]) stats = {} caps = list(td.capsules(str(t1), stats, aux=str(t2))) self.assertEqual(stats["n_join"], 2) self.assertEqual(stats["t1_responded_absent_at_t2"], 1) # counted, not capsuled, not REMOVED self.assertEqual({c["subject_id"]: c["measurement_state"] for c in caps}, {E: "UNCHANGED_AT_NAME_GRANULARITY", "https://b.example/mcp": "TOOLS_REMOVED"}) for c in caps: self.assertEqual(v.non_digest_sources(c["sources"]), []) self.assertEqual(v.authority_violations(c), []) out = pathlib.Path(d) / "out" v.write_batch(out, td.NAME, td.KIND, iter(caps), lambda: td.meta(None, stats)) res, rec, _ = v.verify_batch(out, check_signature=False) self.assertEqual(res["capsules"], 2) # must-fail control: one altered byte in a capsule breaks verification p = out / "capsules.jsonl.gz" lines = gzip.open(p, "rb").read().replace(b"TOOLS_REMOVED", b"TOOLS_REMOVEX") with open(p, "wb") as fh, gzip.GzipFile(filename="", mode="wb", fileobj=fh, mtime=0) as g: g.write(lines) with self.assertRaises(AssertionError): v.verify_batch(out, check_signature=False) def test_capsule_is_deterministic(self): a, b = obs(row(E, BASE)), obs(row(E, BASE[:1])) c1 = td.capsule_for(E, a, b, {"t1": ["1" * 64], "t2": ["2" * 64]}) c2 = td.capsule_for(E, a, b, {"t1": ["1" * 64], "t2": ["2" * 64]}) self.assertEqual(c1["capsule_id"], c2["capsule_id"]) self.assertIsNone(v.jcs_divergence(c1)) if __name__ == "__main__": unittest.main()