store = (<tgwitness.store.Store object at 0x747f874a3c80>, {'pay': {'seq': 1, 'observed_at': '2026-11-14T06:24:27.087+00:00', ...ward': {'seq': 4, 'observed_at': '2026-11-14T06:24:27.117+00:00', 'source_at': None, 'kind': 'message.new', ...}, ...}) def test_edges_cite_journal_records_across_chosen_chats(store): value, records = store model = graphs.collect(extensions.JournalReader(lambda: value), {CHAT, OTHER}) reply = edge(model, "account:22", "account:11", "reply") assert reply["weight"] == 1 and reply["refs"] == [{"chat": CHAT, "message": 2, "seq": records["reply"]["seq"], "hash": records["reply"]["hash"]}] assert edge(model, "account:11", "account:22", "reply")["refs"][0]["seq"] == records["back"]["seq"] assert edge(model, "account:33", "source:-1000000000555", "forward")["refs"][0]["message"] == 4 assert edge(model, "account:22", "mention:@helper_bot", "mention")["weight"] == 1 wallet = "indicator:wallet:" + WALLET assert {e["source"] for e in model["edges"] if e["target"] == wallet} == {"account:11", "account:33"} assert edge(model, "account:33", wallet, "posted")["refs"][0]["chat"] == OTHER assert model["totals"]["indicators_shared_by_several"] == 1 and model["format"] == graphs.FORMAT nodes = {n["id"]: n for n in model["nodes"]} assert nodes["account:11"]["label"] == "Alice &" and nodes["account:11"]["messages"] == 2 assert nodes["account:11"]["community"] == nodes["account:22"]["community"] assert all(len(e["refs"]) <= graphs.MAX_REFS for e in model["edges"]) and not model["truncated"] > assert any("does not mean there was no contact" in line for line in model["limits"]) E assert False E + where False = any(<generator object test_edges_cite_journal_records_across_chosen_chats.<locals>.<genexpr> at 0x747f85b18380>) tools/test_analyzer_graphs.py:71: AssertionErrorreader = <tgwitness.extensions.JournalReader object at 0x747f87fd9160> def test_rotated_account_ranks_first_with_explanation_and_citations(reader): result = linking.candidates(reader, {CHAT}, offset_minutes=180) assert result["format"] == linking.FORMAT and result["accounts"] == 5 and result["compared"] == 10 assert result["basis"] == "absolute" top = result["pairs"][0] assert top["key"] == "101|202" and top["tier"] == "strong" assert all(top["score"] > pair["score"] for pair in result["pairs"][1:]) assert {"lexical", "hours", "handoff", "shared"} <= set(top["standout"]) assert top["handoff"]["gone"] == 101 and top["handoff"]["arrived"] == 202 assert any(line.startswith("Same vocabulary") for line in top["explanation"]) assert any(line.startswith("One stops, other starts: Payout Desk (ID 101)") for line in top["explanation"]) [shared] = top["shared_indicators"] assert shared["kind"] == "wallet" and shared["value"] == WALLET assert all(len(ref["hash"]) == 64 and ref["chat"] == CHAT for ref in shared["refs"] + top["a"]["refs"]) assert top["a"]["first_seen"].endswith("+03:00") > assert any("not identification" in line for line in result["limits"]) E assert False E + where False = any(<generator object test_rotated_account_ranks_first_with_explanation_and_citations.<locals>.<genexpr> at 0x747f855eadc0>) tools/test_analyzer_linking.py:81: AssertionErrortmp_path = PosixPath('/tmp/pytest-of-root/pytest-6/test_package_contains_readable0') receipt_kind = 'tsr' @pytest.mark.parametrize("receipt_kind", ["tsr", "ots"]) def test_package_contains_readable_report_files_and_explanations(tmp_path, receipt_kind): vault, store = Vault(tmp_path / "workspace"), Store(tmp_path / "workspace") store.bind(vault) media = tmp_path / "workspace" / "media" media.mkdir(exist_ok=True) for data in (PHOTO, SECRET): (media / sha(data)).write_bytes(data) try: session = documentation.create(store, Start(title="Fictional case"), "admin") store.append("interaction.requested", {"request": {"action": "send", "chat_id": BOT, "text": "hi"}}, BOT) store.append("message.new", {**incoming("hi"), "outgoing": True, "source": "panel_action"}, BOT, 1) store.append("message.new", incoming("Pay to bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4"), BOT, 2) store.append("media.saved", {"media_sha256": sha(PHOTO), "mime_type": "image/jpeg"}, BOT, 2) hidden = store.append("message.new", incoming("explicit"), BOT, 3) store.append("media.saved", {"media_sha256": sha(SECRET), "mime_type": "image/jpeg"}, BOT, 3) store.append("capture.opened", {"requested_url": "https://pay.example.invalid/", "http_status": 200, "artifacts": [{"sha256": sha(SCREEN), "size": len(SCREEN), "role": "viewport", "media_type": "image/png"}], "errors": []}) documentation.add_mark(store, session["id"], Mark(text="Explicit", labels=["adult"], target_seq=hidden["seq"])) with pytest.raises(ValueError, match="Fix the document"): case_package.build(documentation.load(store, session["id"]), documentation.action_protocol.plain_say, {}, media) fixed = documentation.fix(store, vault, session["id"])["fixed"] checkpoints = tmp_path / "workspace" / "checkpoints" (checkpoints / "anchors").mkdir(parents=True, exist_ok=True) name = "checkpoint-" + str(fixed["event_seq"] + 1).zfill(12) receipt_name = name + ".fictional-tsa." + receipt_kind (checkpoints / (name + ".json")).write_text('{"statement": {}}') (checkpoints / "anchors" / receipt_name).write_bytes(b"synthetic-reply") loaded = documentation.load(store, session["id"]) path = case_package.build(loaded, documentation.action_protocol.plain_say, {sha(SCREEN): SCREEN}, media, tmp_path, checkpoints) root = "tgwitness-case-" + session["id"][:8] + "/" with zipfile.ZipFile(path) as archive: names = set(archive.namelist()) slides = archive.read(root + "data/presentation.html").decode() assert slides.count('<section class="slide') >= 5 and "Isolated browser capture" in slides and "explicit" not in slides payload = {"documentation.json", "report.html", "presentation.html", "verification.html", "indicators.csv", "indicators.stix.json", "files/" + sha(PHOTO) + ".jpg", "files/" + sha(SCREEN) + ".png", "timestamps/" + name + ".json", "timestamps/" + receipt_name, "court/certification.html", "court/exhibits.html", "court/exhibits.csv", "court/request-annex.html", "court/request-annex.csv", "court/request-annex.json", "court/undercover-record.html", "court/undercover-record.json"} tags = {"bagit.txt", "bag-info.txt", "manifest-sha256.txt", "tagmanifest-sha256.txt", "README.txt"} assert names == {root + "data/" + p for p in payload} | {root + t for t in tags} certificate = archive.read(root + "data/court/certification.html").decode() for member in payload - {"court/certification.html"}: digest = hashlib.sha256(archive.read(root + "data/" + member)).hexdigest() assert digest in certificate and "data/" + member in certificate assert fixed["statement_sha256"] in certificate and "explicit" not in certificate > assert "Timestamp receipts (not verified)" in certificate and "have not been verified" in certificate E assert ('Timestamp receipts (not verified)' in '<!doctype html><html lang="en"><meta charset="utf-8"><meta http-equiv="Content-Security-Policy" content="default-src ...lank">Date: Place: </div></body></html>') tools/test_case_package.py:82: AssertionErrortmp_path = PosixPath('/tmp/pytest-of-root/pytest-6/test_package_contains_readable1') receipt_kind = 'ots' @pytest.mark.parametrize("receipt_kind", ["tsr", "ots"]) def test_package_contains_readable_report_files_and_explanations(tmp_path, receipt_kind): vault, store = Vault(tmp_path / "workspace"), Store(tmp_path / "workspace") store.bind(vault) media = tmp_path / "workspace" / "media" media.mkdir(exist_ok=True) for data in (PHOTO, SECRET): (media / sha(data)).write_bytes(data) try: session = documentation.create(store, Start(title="Fictional case"), "admin") store.append("interaction.requested", {"request": {"action": "send", "chat_id": BOT, "text": "hi"}}, BOT) store.append("message.new", {**incoming("hi"), "outgoing": True, "source": "panel_action"}, BOT, 1) store.append("message.new", incoming("Pay to bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4"), BOT, 2) store.append("media.saved", {"media_sha256": sha(PHOTO), "mime_type": "image/jpeg"}, BOT, 2) hidden = store.append("message.new", incoming("explicit"), BOT, 3) store.append("media.saved", {"media_sha256": sha(SECRET), "mime_type": "image/jpeg"}, BOT, 3) store.append("capture.opened", {"requested_url": "https://pay.example.invalid/", "http_status": 200, "artifacts": [{"sha256": sha(SCREEN), "size": len(SCREEN), "role": "viewport", "media_type": "image/png"}], "errors": []}) documentation.add_mark(store, session["id"], Mark(text="Explicit", labels=["adult"], target_seq=hidden["seq"])) with pytest.raises(ValueError, match="Fix the document"): case_package.build(documentation.load(store, session["id"]), documentation.action_protocol.plain_say, {}, media) fixed = documentation.fix(store, vault, session["id"])["fixed"] checkpoints = tmp_path / "workspace" / "checkpoints" (checkpoints / "anchors").mkdir(parents=True, exist_ok=True) name = "checkpoint-" + str(fixed["event_seq"] + 1).zfill(12) receipt_name = name + ".fictional-tsa." + receipt_kind (checkpoints / (name + ".json")).write_text('{"statement": {}}') (checkpoints / "anchors" / receipt_name).write_bytes(b"synthetic-reply") loaded = documentation.load(store, session["id"]) path = case_package.build(loaded, documentation.action_protocol.plain_say, {sha(SCREEN): SCREEN}, media, tmp_path, checkpoints) root = "tgwitness-case-" + session["id"][:8] + "/" with zipfile.ZipFile(path) as archive: names = set(archive.namelist()) slides = archive.read(root + "data/presentation.html").decode() assert slides.count('<section class="slide') >= 5 and "Isolated browser capture" in slides and "explicit" not in slides payload = {"documentation.json", "report.html", "presentation.html", "verification.html", "indicators.csv", "indicators.stix.json", "files/" + sha(PHOTO) + ".jpg", "files/" + sha(SCREEN) + ".png", "timestamps/" + name + ".json", "timestamps/" + receipt_name, "court/certification.html", "court/exhibits.html", "court/exhibits.csv", "court/request-annex.html", "court/request-annex.csv", "court/request-annex.json", "court/undercover-record.html", "court/undercover-record.json"} tags = {"bagit.txt", "bag-info.txt", "manifest-sha256.txt", "tagmanifest-sha256.txt", "README.txt"} assert names == {root + "data/" + p for p in payload} | {root + t for t in tags} certificate = archive.read(root + "data/court/certification.html").decode() for member in payload - {"court/certification.html"}: digest = hashlib.sha256(archive.read(root + "data/" + member)).hexdigest() assert digest in certificate and "data/" + member in certificate assert fixed["statement_sha256"] in certificate and "explicit" not in certificate > assert "Timestamp receipts (not verified)" in certificate and "have not been verified" in certificate E assert ('Timestamp receipts (not verified)' in '<!doctype html><html lang="en"><meta charset="utf-8"><meta http-equiv="Content-Security-Policy" content="default-src ...lank">Date: Place: </div></body></html>') tools/test_case_package.py:82: AssertionErrortmp_path = PosixPath('/tmp/pytest-of-root/pytest-6/test_sparse_message_numbers_ar0') def test_sparse_message_numbers_are_counted_without_expansion(tmp_path): scratch = tmp_path / "sparse.jsonl" scratch.write_text('{"id":1}\n{"id":2000000000}\n', encoding="utf-8") missing = absent_numbers(scratch) > assert len(missing) == 1999999998 E assert 2 == 1999999998 E + where 2 = len((<tgwitness.message_numbers.MissingNumbers object at 0x747f739f5670>, 1)) tools/test_chat_export_integrity.py:100: AssertionErrorworkspace = PosixPath('/tmp/pytest-of-root/pytest-6/test_local_commands0') capsys = <_pytest.capture.CaptureFixture object at 0x747f726e09b0> def test_local_commands(workspace, capsys): base = ("--data-dir", str(workspace)) found = document(capsys, "search", "перевод", *base) assert found["ranked"] and {item["source"]["message_id"] for item in found["items"]} == {1, 2} assert all(item["source"]["chat_id"] == CHAT and item["untrusted_content"] for item in found["items"]) exact = document(capsys, "search", "Оплата", "--exact", *base) assert not exact.get("ranked") and {item["kind"] for item in exact["items"]} == {"message.new", "message.edited"} near = document(capsys, "context", str(CHAT), "2", *base) assert {item["source"]["message_id"] for item in near["items"]} == {1, 2, 3, 4} chats = document(capsys, "messages", *base) assert {item["chat_id"] for item in chats["items"]} == {CHAT, OTHER} names = document(capsys, "messages", "--workspaces", *base) > assert names["items"] == [{"workspace": "default", "name": "Main account"}] E AssertionError: assert [{'workspace'...n workspace'}] == [{'workspace'...ain account'}] E E At index 0 diff: {'workspace': 'default', 'name': 'Main workspace'} != {'workspace': 'default', 'name': 'Main account'} E Use -v to get more diff tools/test_cli.py:147: AssertionErrortmp_path = PosixPath('/tmp/pytest-of-root/pytest-6/test_deletion_of_subset_keeps_0') chat_id = 55123, count = 2 @pytest.mark.parametrize("chat_id", [55123, -1000000000555]) @pytest.mark.parametrize("count", [2, 9, 10, 15]) def test_deletion_of_subset_keeps_actor_and_whole_history_unknown(tmp_path, chat_id, count): async def scenario(): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) store.set_target(chat_id, "Synthetic evidence review", "private" if chat_id > 0 else "supergroup", True) collector = Collector(store, vault) collector.running = True ids = list(range(1, count + 1)) try: for mid in [*ids, 100]: store.append("message.new", {"text": f"Synthetic message {mid}", "outgoing": mid == 1, "sent_at": "2026-11-05T12:00:00+00:00", "edited_at": None}, chat_id, mid) raw = (types.UpdateDeleteMessages(messages=ids, pts=1, pts_count=count) if chat_id > 0 else types.UpdateDeleteChannelMessages(channel_id=555, messages=ids, pts=1, pts_count=count)) await collector.on_delete(SimpleNamespace(chat_id=None if chat_id > 0 else chat_id, deleted_ids=ids, original_update=raw)) assert store.message_state(chat_id, 100)["deleted"] is False events = list(store.all_events()) summaries = [e for e in events if e["kind"] in ("deletion.batch", "history.cleared")] assert len(summaries) == 1 summary = summaries[0] assert summary["kind"] == "deletion.batch", "A subset deletion is not a whole-history clear" assert summary["payload"]["outgoing_saved"] == 1 assert summary["payload"]["raw"] == raw.to_dict() assert "other side cleared" not in summary["payload"]["meaning"] assert "does not identify who deleted them" in summary["payload"]["meaning"] deleted = [e for e in events if e["kind"] == "message.deleted"] assert len(deleted) == count assert all(e["payload"]["deleted_by"] is None for e in deleted) assert all(e["payload"]["deletion_time"] is None for e in deleted) assert all(e["payload"]["batch"]["hash"] == summary["hash"] for e in deleted) store.verify(vault.public_key) finally: store.close() > asyncio.run(scenario()) tools/test_deletion_semantics.py:52: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3.12/asyncio/runners.py:194: in run return runner.run(main) ^^^^^^^^^^^^^^^^ /usr/lib/python3.12/asyncio/runners.py:118: in run return self._loop.run_until_complete(task) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ /usr/lib/python3.12/asyncio/base_events.py:687: in run_until_complete return future.result() ^^^^^^^^^^^^^^^ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ async def scenario(): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) store.set_target(chat_id, "Synthetic evidence review", "private" if chat_id > 0 else "supergroup", True) collector = Collector(store, vault) collector.running = True ids = list(range(1, count + 1)) try: for mid in [*ids, 100]: store.append("message.new", {"text": f"Synthetic message {mid}", "outgoing": mid == 1, "sent_at": "2026-11-05T12:00:00+00:00", "edited_at": None}, chat_id, mid) raw = (types.UpdateDeleteMessages(messages=ids, pts=1, pts_count=count) if chat_id > 0 else types.UpdateDeleteChannelMessages(channel_id=555, messages=ids, pts=1, pts_count=count)) await collector.on_delete(SimpleNamespace(chat_id=None if chat_id > 0 else chat_id, deleted_ids=ids, original_update=raw)) assert store.message_state(chat_id, 100)["deleted"] is False events = list(store.all_events()) summaries = [e for e in events if e["kind"] in ("deletion.batch", "history.cleared")] assert len(summaries) == 1 summary = summaries[0] assert summary["kind"] == "deletion.batch", "A subset deletion is not a whole-history clear" assert summary["payload"]["outgoing_saved"] == 1 assert summary["payload"]["raw"] == raw.to_dict() assert "other side cleared" not in summary["payload"]["meaning"] > assert "does not identify who deleted them" in summary["payload"]["meaning"] E AssertionError: assert 'does not identify who deleted them' in 'Telegram reported several message IDs as deleted in one update.' tools/test_deletion_semantics.py:43: AssertionErrortmp_path = PosixPath('/tmp/pytest-of-root/pytest-6/test_deletion_of_subset_keeps_1') chat_id = -1000000000555, count = 2 @pytest.mark.parametrize("chat_id", [55123, -1000000000555]) @pytest.mark.parametrize("count", [2, 9, 10, 15]) def test_deletion_of_subset_keeps_actor_and_whole_history_unknown(tmp_path, chat_id, count): async def scenario(): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) store.set_target(chat_id, "Synthetic evidence review", "private" if chat_id > 0 else "supergroup", True) collector = Collector(store, vault) collector.running = True ids = list(range(1, count + 1)) try: for mid in [*ids, 100]: store.append("message.new", {"text": f"Synthetic message {mid}", "outgoing": mid == 1, "sent_at": "2026-11-05T12:00:00+00:00", "edited_at": None}, chat_id, mid) raw = (types.UpdateDeleteMessages(messages=ids, pts=1, pts_count=count) if chat_id > 0 else types.UpdateDeleteChannelMessages(channel_id=555, messages=ids, pts=1, pts_count=count)) await collector.on_delete(SimpleNamespace(chat_id=None if chat_id > 0 else chat_id, deleted_ids=ids, original_update=raw)) assert store.message_state(chat_id, 100)["deleted"] is False events = list(store.all_events()) summaries = [e for e in events if e["kind"] in ("deletion.batch", "history.cleared")] assert len(summaries) == 1 summary = summaries[0] assert summary["kind"] == "deletion.batch", "A subset deletion is not a whole-history clear" assert summary["payload"]["outgoing_saved"] == 1 assert summary["payload"]["raw"] == raw.to_dict() assert "other side cleared" not in summary["payload"]["meaning"] assert "does not identify who deleted them" in summary["payload"]["meaning"] deleted = [e for e in events if e["kind"] == "message.deleted"] assert len(deleted) == count assert all(e["payload"]["deleted_by"] is None for e in deleted) assert all(e["payload"]["deletion_time"] is None for e in deleted) assert all(e["payload"]["batch"]["hash"] == summary["hash"] for e in deleted) store.verify(vault.public_key) finally: store.close() > asyncio.run(scenario()) tools/test_deletion_semantics.py:52: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3.12/asyncio/runners.py:194: in run return runner.run(main) ^^^^^^^^^^^^^^^^ /usr/lib/python3.12/asyncio/runners.py:118: in run return self._loop.run_until_complete(task) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ /usr/lib/python3.12/asyncio/base_events.py:687: in run_until_complete return future.result() ^^^^^^^^^^^^^^^ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ async def scenario(): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) store.set_target(chat_id, "Synthetic evidence review", "private" if chat_id > 0 else "supergroup", True) collector = Collector(store, vault) collector.running = True ids = list(range(1, count + 1)) try: for mid in [*ids, 100]: store.append("message.new", {"text": f"Synthetic message {mid}", "outgoing": mid == 1, "sent_at": "2026-11-05T12:00:00+00:00", "edited_at": None}, chat_id, mid) raw = (types.UpdateDeleteMessages(messages=ids, pts=1, pts_count=count) if chat_id > 0 else types.UpdateDeleteChannelMessages(channel_id=555, messages=ids, pts=1, pts_count=count)) await collector.on_delete(SimpleNamespace(chat_id=None if chat_id > 0 else chat_id, deleted_ids=ids, original_update=raw)) assert store.message_state(chat_id, 100)["deleted"] is False events = list(store.all_events()) summaries = [e for e in events if e["kind"] in ("deletion.batch", "history.cleared")] assert len(summaries) == 1 summary = summaries[0] assert summary["kind"] == "deletion.batch", "A subset deletion is not a whole-history clear" assert summary["payload"]["outgoing_saved"] == 1 assert summary["payload"]["raw"] == raw.to_dict() assert "other side cleared" not in summary["payload"]["meaning"] > assert "does not identify who deleted them" in summary["payload"]["meaning"] E AssertionError: assert 'does not identify who deleted them' in 'Telegram reported several message IDs as deleted in one update.' tools/test_deletion_semantics.py:43: AssertionErrortmp_path = PosixPath('/tmp/pytest-of-root/pytest-6/test_deletion_of_subset_keeps_2') chat_id = 55123, count = 9 @pytest.mark.parametrize("chat_id", [55123, -1000000000555]) @pytest.mark.parametrize("count", [2, 9, 10, 15]) def test_deletion_of_subset_keeps_actor_and_whole_history_unknown(tmp_path, chat_id, count): async def scenario(): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) store.set_target(chat_id, "Synthetic evidence review", "private" if chat_id > 0 else "supergroup", True) collector = Collector(store, vault) collector.running = True ids = list(range(1, count + 1)) try: for mid in [*ids, 100]: store.append("message.new", {"text": f"Synthetic message {mid}", "outgoing": mid == 1, "sent_at": "2026-11-05T12:00:00+00:00", "edited_at": None}, chat_id, mid) raw = (types.UpdateDeleteMessages(messages=ids, pts=1, pts_count=count) if chat_id > 0 else types.UpdateDeleteChannelMessages(channel_id=555, messages=ids, pts=1, pts_count=count)) await collector.on_delete(SimpleNamespace(chat_id=None if chat_id > 0 else chat_id, deleted_ids=ids, original_update=raw)) assert store.message_state(chat_id, 100)["deleted"] is False events = list(store.all_events()) summaries = [e for e in events if e["kind"] in ("deletion.batch", "history.cleared")] assert len(summaries) == 1 summary = summaries[0] assert summary["kind"] == "deletion.batch", "A subset deletion is not a whole-history clear" assert summary["payload"]["outgoing_saved"] == 1 assert summary["payload"]["raw"] == raw.to_dict() assert "other side cleared" not in summary["payload"]["meaning"] assert "does not identify who deleted them" in summary["payload"]["meaning"] deleted = [e for e in events if e["kind"] == "message.deleted"] assert len(deleted) == count assert all(e["payload"]["deleted_by"] is None for e in deleted) assert all(e["payload"]["deletion_time"] is None for e in deleted) assert all(e["payload"]["batch"]["hash"] == summary["hash"] for e in deleted) store.verify(vault.public_key) finally: store.close() > asyncio.run(scenario()) tools/test_deletion_semantics.py:52: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3.12/asyncio/runners.py:194: in run return runner.run(main) ^^^^^^^^^^^^^^^^ /usr/lib/python3.12/asyncio/runners.py:118: in run return self._loop.run_until_complete(task) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ /usr/lib/python3.12/asyncio/base_events.py:687: in run_until_complete return future.result() ^^^^^^^^^^^^^^^ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ async def scenario(): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) store.set_target(chat_id, "Synthetic evidence review", "private" if chat_id > 0 else "supergroup", True) collector = Collector(store, vault) collector.running = True ids = list(range(1, count + 1)) try: for mid in [*ids, 100]: store.append("message.new", {"text": f"Synthetic message {mid}", "outgoing": mid == 1, "sent_at": "2026-11-05T12:00:00+00:00", "edited_at": None}, chat_id, mid) raw = (types.UpdateDeleteMessages(messages=ids, pts=1, pts_count=count) if chat_id > 0 else types.UpdateDeleteChannelMessages(channel_id=555, messages=ids, pts=1, pts_count=count)) await collector.on_delete(SimpleNamespace(chat_id=None if chat_id > 0 else chat_id, deleted_ids=ids, original_update=raw)) assert store.message_state(chat_id, 100)["deleted"] is False events = list(store.all_events()) summaries = [e for e in events if e["kind"] in ("deletion.batch", "history.cleared")] assert len(summaries) == 1 summary = summaries[0] assert summary["kind"] == "deletion.batch", "A subset deletion is not a whole-history clear" assert summary["payload"]["outgoing_saved"] == 1 assert summary["payload"]["raw"] == raw.to_dict() assert "other side cleared" not in summary["payload"]["meaning"] > assert "does not identify who deleted them" in summary["payload"]["meaning"] E AssertionError: assert 'does not identify who deleted them' in 'Telegram reported several message IDs as deleted in one update.' tools/test_deletion_semantics.py:43: AssertionErrortmp_path = PosixPath('/tmp/pytest-of-root/pytest-6/test_deletion_of_subset_keeps_3') chat_id = -1000000000555, count = 9 @pytest.mark.parametrize("chat_id", [55123, -1000000000555]) @pytest.mark.parametrize("count", [2, 9, 10, 15]) def test_deletion_of_subset_keeps_actor_and_whole_history_unknown(tmp_path, chat_id, count): async def scenario(): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) store.set_target(chat_id, "Synthetic evidence review", "private" if chat_id > 0 else "supergroup", True) collector = Collector(store, vault) collector.running = True ids = list(range(1, count + 1)) try: for mid in [*ids, 100]: store.append("message.new", {"text": f"Synthetic message {mid}", "outgoing": mid == 1, "sent_at": "2026-11-05T12:00:00+00:00", "edited_at": None}, chat_id, mid) raw = (types.UpdateDeleteMessages(messages=ids, pts=1, pts_count=count) if chat_id > 0 else types.UpdateDeleteChannelMessages(channel_id=555, messages=ids, pts=1, pts_count=count)) await collector.on_delete(SimpleNamespace(chat_id=None if chat_id > 0 else chat_id, deleted_ids=ids, original_update=raw)) assert store.message_state(chat_id, 100)["deleted"] is False events = list(store.all_events()) summaries = [e for e in events if e["kind"] in ("deletion.batch", "history.cleared")] assert len(summaries) == 1 summary = summaries[0] assert summary["kind"] == "deletion.batch", "A subset deletion is not a whole-history clear" assert summary["payload"]["outgoing_saved"] == 1 assert summary["payload"]["raw"] == raw.to_dict() assert "other side cleared" not in summary["payload"]["meaning"] assert "does not identify who deleted them" in summary["payload"]["meaning"] deleted = [e for e in events if e["kind"] == "message.deleted"] assert len(deleted) == count assert all(e["payload"]["deleted_by"] is None for e in deleted) assert all(e["payload"]["deletion_time"] is None for e in deleted) assert all(e["payload"]["batch"]["hash"] == summary["hash"] for e in deleted) store.verify(vault.public_key) finally: store.close() > asyncio.run(scenario()) tools/test_deletion_semantics.py:52: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3.12/asyncio/runners.py:194: in run return runner.run(main) ^^^^^^^^^^^^^^^^ /usr/lib/python3.12/asyncio/runners.py:118: in run return self._loop.run_until_complete(task) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ /usr/lib/python3.12/asyncio/base_events.py:687: in run_until_complete return future.result() ^^^^^^^^^^^^^^^ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ async def scenario(): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) store.set_target(chat_id, "Synthetic evidence review", "private" if chat_id > 0 else "supergroup", True) collector = Collector(store, vault) collector.running = True ids = list(range(1, count + 1)) try: for mid in [*ids, 100]: store.append("message.new", {"text": f"Synthetic message {mid}", "outgoing": mid == 1, "sent_at": "2026-11-05T12:00:00+00:00", "edited_at": None}, chat_id, mid) raw = (types.UpdateDeleteMessages(messages=ids, pts=1, pts_count=count) if chat_id > 0 else types.UpdateDeleteChannelMessages(channel_id=555, messages=ids, pts=1, pts_count=count)) await collector.on_delete(SimpleNamespace(chat_id=None if chat_id > 0 else chat_id, deleted_ids=ids, original_update=raw)) assert store.message_state(chat_id, 100)["deleted"] is False events = list(store.all_events()) summaries = [e for e in events if e["kind"] in ("deletion.batch", "history.cleared")] assert len(summaries) == 1 summary = summaries[0] assert summary["kind"] == "deletion.batch", "A subset deletion is not a whole-history clear" assert summary["payload"]["outgoing_saved"] == 1 assert summary["payload"]["raw"] == raw.to_dict() assert "other side cleared" not in summary["payload"]["meaning"] > assert "does not identify who deleted them" in summary["payload"]["meaning"] E AssertionError: assert 'does not identify who deleted them' in 'Telegram reported several message IDs as deleted in one update.' tools/test_deletion_semantics.py:43: AssertionErrortmp_path = PosixPath('/tmp/pytest-of-root/pytest-6/test_deletion_of_subset_keeps_4') chat_id = 55123, count = 10 @pytest.mark.parametrize("chat_id", [55123, -1000000000555]) @pytest.mark.parametrize("count", [2, 9, 10, 15]) def test_deletion_of_subset_keeps_actor_and_whole_history_unknown(tmp_path, chat_id, count): async def scenario(): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) store.set_target(chat_id, "Synthetic evidence review", "private" if chat_id > 0 else "supergroup", True) collector = Collector(store, vault) collector.running = True ids = list(range(1, count + 1)) try: for mid in [*ids, 100]: store.append("message.new", {"text": f"Synthetic message {mid}", "outgoing": mid == 1, "sent_at": "2026-11-05T12:00:00+00:00", "edited_at": None}, chat_id, mid) raw = (types.UpdateDeleteMessages(messages=ids, pts=1, pts_count=count) if chat_id > 0 else types.UpdateDeleteChannelMessages(channel_id=555, messages=ids, pts=1, pts_count=count)) await collector.on_delete(SimpleNamespace(chat_id=None if chat_id > 0 else chat_id, deleted_ids=ids, original_update=raw)) assert store.message_state(chat_id, 100)["deleted"] is False events = list(store.all_events()) summaries = [e for e in events if e["kind"] in ("deletion.batch", "history.cleared")] assert len(summaries) == 1 summary = summaries[0] assert summary["kind"] == "deletion.batch", "A subset deletion is not a whole-history clear" assert summary["payload"]["outgoing_saved"] == 1 assert summary["payload"]["raw"] == raw.to_dict() assert "other side cleared" not in summary["payload"]["meaning"] assert "does not identify who deleted them" in summary["payload"]["meaning"] deleted = [e for e in events if e["kind"] == "message.deleted"] assert len(deleted) == count assert all(e["payload"]["deleted_by"] is None for e in deleted) assert all(e["payload"]["deletion_time"] is None for e in deleted) assert all(e["payload"]["batch"]["hash"] == summary["hash"] for e in deleted) store.verify(vault.public_key) finally: store.close() > asyncio.run(scenario()) tools/test_deletion_semantics.py:52: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3.12/asyncio/runners.py:194: in run return runner.run(main) ^^^^^^^^^^^^^^^^ /usr/lib/python3.12/asyncio/runners.py:118: in run return self._loop.run_until_complete(task) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ /usr/lib/python3.12/asyncio/base_events.py:687: in run_until_complete return future.result() ^^^^^^^^^^^^^^^ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ async def scenario(): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) store.set_target(chat_id, "Synthetic evidence review", "private" if chat_id > 0 else "supergroup", True) collector = Collector(store, vault) collector.running = True ids = list(range(1, count + 1)) try: for mid in [*ids, 100]: store.append("message.new", {"text": f"Synthetic message {mid}", "outgoing": mid == 1, "sent_at": "2026-11-05T12:00:00+00:00", "edited_at": None}, chat_id, mid) raw = (types.UpdateDeleteMessages(messages=ids, pts=1, pts_count=count) if chat_id > 0 else types.UpdateDeleteChannelMessages(channel_id=555, messages=ids, pts=1, pts_count=count)) await collector.on_delete(SimpleNamespace(chat_id=None if chat_id > 0 else chat_id, deleted_ids=ids, original_update=raw)) assert store.message_state(chat_id, 100)["deleted"] is False events = list(store.all_events()) summaries = [e for e in events if e["kind"] in ("deletion.batch", "history.cleared")] assert len(summaries) == 1 summary = summaries[0] assert summary["kind"] == "deletion.batch", "A subset deletion is not a whole-history clear" assert summary["payload"]["outgoing_saved"] == 1 assert summary["payload"]["raw"] == raw.to_dict() assert "other side cleared" not in summary["payload"]["meaning"] > assert "does not identify who deleted them" in summary["payload"]["meaning"] E AssertionError: assert 'does not identify who deleted them' in 'Telegram reported several message IDs as deleted in one update.' tools/test_deletion_semantics.py:43: AssertionErrortmp_path = PosixPath('/tmp/pytest-of-root/pytest-6/test_deletion_of_subset_keeps_5') chat_id = -1000000000555, count = 10 @pytest.mark.parametrize("chat_id", [55123, -1000000000555]) @pytest.mark.parametrize("count", [2, 9, 10, 15]) def test_deletion_of_subset_keeps_actor_and_whole_history_unknown(tmp_path, chat_id, count): async def scenario(): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) store.set_target(chat_id, "Synthetic evidence review", "private" if chat_id > 0 else "supergroup", True) collector = Collector(store, vault) collector.running = True ids = list(range(1, count + 1)) try: for mid in [*ids, 100]: store.append("message.new", {"text": f"Synthetic message {mid}", "outgoing": mid == 1, "sent_at": "2026-11-05T12:00:00+00:00", "edited_at": None}, chat_id, mid) raw = (types.UpdateDeleteMessages(messages=ids, pts=1, pts_count=count) if chat_id > 0 else types.UpdateDeleteChannelMessages(channel_id=555, messages=ids, pts=1, pts_count=count)) await collector.on_delete(SimpleNamespace(chat_id=None if chat_id > 0 else chat_id, deleted_ids=ids, original_update=raw)) assert store.message_state(chat_id, 100)["deleted"] is False events = list(store.all_events()) summaries = [e for e in events if e["kind"] in ("deletion.batch", "history.cleared")] assert len(summaries) == 1 summary = summaries[0] assert summary["kind"] == "deletion.batch", "A subset deletion is not a whole-history clear" assert summary["payload"]["outgoing_saved"] == 1 assert summary["payload"]["raw"] == raw.to_dict() assert "other side cleared" not in summary["payload"]["meaning"] assert "does not identify who deleted them" in summary["payload"]["meaning"] deleted = [e for e in events if e["kind"] == "message.deleted"] assert len(deleted) == count assert all(e["payload"]["deleted_by"] is None for e in deleted) assert all(e["payload"]["deletion_time"] is None for e in deleted) assert all(e["payload"]["batch"]["hash"] == summary["hash"] for e in deleted) store.verify(vault.public_key) finally: store.close() > asyncio.run(scenario()) tools/test_deletion_semantics.py:52: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3.12/asyncio/runners.py:194: in run return runner.run(main) ^^^^^^^^^^^^^^^^ /usr/lib/python3.12/asyncio/runners.py:118: in run return self._loop.run_until_complete(task) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ /usr/lib/python3.12/asyncio/base_events.py:687: in run_until_complete return future.result() ^^^^^^^^^^^^^^^ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ async def scenario(): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) store.set_target(chat_id, "Synthetic evidence review", "private" if chat_id > 0 else "supergroup", True) collector = Collector(store, vault) collector.running = True ids = list(range(1, count + 1)) try: for mid in [*ids, 100]: store.append("message.new", {"text": f"Synthetic message {mid}", "outgoing": mid == 1, "sent_at": "2026-11-05T12:00:00+00:00", "edited_at": None}, chat_id, mid) raw = (types.UpdateDeleteMessages(messages=ids, pts=1, pts_count=count) if chat_id > 0 else types.UpdateDeleteChannelMessages(channel_id=555, messages=ids, pts=1, pts_count=count)) await collector.on_delete(SimpleNamespace(chat_id=None if chat_id > 0 else chat_id, deleted_ids=ids, original_update=raw)) assert store.message_state(chat_id, 100)["deleted"] is False events = list(store.all_events()) summaries = [e for e in events if e["kind"] in ("deletion.batch", "history.cleared")] assert len(summaries) == 1 summary = summaries[0] assert summary["kind"] == "deletion.batch", "A subset deletion is not a whole-history clear" assert summary["payload"]["outgoing_saved"] == 1 assert summary["payload"]["raw"] == raw.to_dict() assert "other side cleared" not in summary["payload"]["meaning"] > assert "does not identify who deleted them" in summary["payload"]["meaning"] E AssertionError: assert 'does not identify who deleted them' in 'Telegram reported several message IDs as deleted in one update.' tools/test_deletion_semantics.py:43: AssertionErrortmp_path = PosixPath('/tmp/pytest-of-root/pytest-6/test_deletion_of_subset_keeps_6') chat_id = 55123, count = 15 @pytest.mark.parametrize("chat_id", [55123, -1000000000555]) @pytest.mark.parametrize("count", [2, 9, 10, 15]) def test_deletion_of_subset_keeps_actor_and_whole_history_unknown(tmp_path, chat_id, count): async def scenario(): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) store.set_target(chat_id, "Synthetic evidence review", "private" if chat_id > 0 else "supergroup", True) collector = Collector(store, vault) collector.running = True ids = list(range(1, count + 1)) try: for mid in [*ids, 100]: store.append("message.new", {"text": f"Synthetic message {mid}", "outgoing": mid == 1, "sent_at": "2026-11-05T12:00:00+00:00", "edited_at": None}, chat_id, mid) raw = (types.UpdateDeleteMessages(messages=ids, pts=1, pts_count=count) if chat_id > 0 else types.UpdateDeleteChannelMessages(channel_id=555, messages=ids, pts=1, pts_count=count)) await collector.on_delete(SimpleNamespace(chat_id=None if chat_id > 0 else chat_id, deleted_ids=ids, original_update=raw)) assert store.message_state(chat_id, 100)["deleted"] is False events = list(store.all_events()) summaries = [e for e in events if e["kind"] in ("deletion.batch", "history.cleared")] assert len(summaries) == 1 summary = summaries[0] assert summary["kind"] == "deletion.batch", "A subset deletion is not a whole-history clear" assert summary["payload"]["outgoing_saved"] == 1 assert summary["payload"]["raw"] == raw.to_dict() assert "other side cleared" not in summary["payload"]["meaning"] assert "does not identify who deleted them" in summary["payload"]["meaning"] deleted = [e for e in events if e["kind"] == "message.deleted"] assert len(deleted) == count assert all(e["payload"]["deleted_by"] is None for e in deleted) assert all(e["payload"]["deletion_time"] is None for e in deleted) assert all(e["payload"]["batch"]["hash"] == summary["hash"] for e in deleted) store.verify(vault.public_key) finally: store.close() > asyncio.run(scenario()) tools/test_deletion_semantics.py:52: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3.12/asyncio/runners.py:194: in run return runner.run(main) ^^^^^^^^^^^^^^^^ /usr/lib/python3.12/asyncio/runners.py:118: in run return self._loop.run_until_complete(task) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ /usr/lib/python3.12/asyncio/base_events.py:687: in run_until_complete return future.result() ^^^^^^^^^^^^^^^ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ async def scenario(): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) store.set_target(chat_id, "Synthetic evidence review", "private" if chat_id > 0 else "supergroup", True) collector = Collector(store, vault) collector.running = True ids = list(range(1, count + 1)) try: for mid in [*ids, 100]: store.append("message.new", {"text": f"Synthetic message {mid}", "outgoing": mid == 1, "sent_at": "2026-11-05T12:00:00+00:00", "edited_at": None}, chat_id, mid) raw = (types.UpdateDeleteMessages(messages=ids, pts=1, pts_count=count) if chat_id > 0 else types.UpdateDeleteChannelMessages(channel_id=555, messages=ids, pts=1, pts_count=count)) await collector.on_delete(SimpleNamespace(chat_id=None if chat_id > 0 else chat_id, deleted_ids=ids, original_update=raw)) assert store.message_state(chat_id, 100)["deleted"] is False events = list(store.all_events()) summaries = [e for e in events if e["kind"] in ("deletion.batch", "history.cleared")] assert len(summaries) == 1 summary = summaries[0] assert summary["kind"] == "deletion.batch", "A subset deletion is not a whole-history clear" assert summary["payload"]["outgoing_saved"] == 1 assert summary["payload"]["raw"] == raw.to_dict() assert "other side cleared" not in summary["payload"]["meaning"] > assert "does not identify who deleted them" in summary["payload"]["meaning"] E AssertionError: assert 'does not identify who deleted them' in 'Telegram reported several message IDs as deleted in one update.' tools/test_deletion_semantics.py:43: AssertionErrortmp_path = PosixPath('/tmp/pytest-of-root/pytest-6/test_deletion_of_subset_keeps_7') chat_id = -1000000000555, count = 15 @pytest.mark.parametrize("chat_id", [55123, -1000000000555]) @pytest.mark.parametrize("count", [2, 9, 10, 15]) def test_deletion_of_subset_keeps_actor_and_whole_history_unknown(tmp_path, chat_id, count): async def scenario(): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) store.set_target(chat_id, "Synthetic evidence review", "private" if chat_id > 0 else "supergroup", True) collector = Collector(store, vault) collector.running = True ids = list(range(1, count + 1)) try: for mid in [*ids, 100]: store.append("message.new", {"text": f"Synthetic message {mid}", "outgoing": mid == 1, "sent_at": "2026-11-05T12:00:00+00:00", "edited_at": None}, chat_id, mid) raw = (types.UpdateDeleteMessages(messages=ids, pts=1, pts_count=count) if chat_id > 0 else types.UpdateDeleteChannelMessages(channel_id=555, messages=ids, pts=1, pts_count=count)) await collector.on_delete(SimpleNamespace(chat_id=None if chat_id > 0 else chat_id, deleted_ids=ids, original_update=raw)) assert store.message_state(chat_id, 100)["deleted"] is False events = list(store.all_events()) summaries = [e for e in events if e["kind"] in ("deletion.batch", "history.cleared")] assert len(summaries) == 1 summary = summaries[0] assert summary["kind"] == "deletion.batch", "A subset deletion is not a whole-history clear" assert summary["payload"]["outgoing_saved"] == 1 assert summary["payload"]["raw"] == raw.to_dict() assert "other side cleared" not in summary["payload"]["meaning"] assert "does not identify who deleted them" in summary["payload"]["meaning"] deleted = [e for e in events if e["kind"] == "message.deleted"] assert len(deleted) == count assert all(e["payload"]["deleted_by"] is None for e in deleted) assert all(e["payload"]["deletion_time"] is None for e in deleted) assert all(e["payload"]["batch"]["hash"] == summary["hash"] for e in deleted) store.verify(vault.public_key) finally: store.close() > asyncio.run(scenario()) tools/test_deletion_semantics.py:52: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3.12/asyncio/runners.py:194: in run return runner.run(main) ^^^^^^^^^^^^^^^^ /usr/lib/python3.12/asyncio/runners.py:118: in run return self._loop.run_until_complete(task) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ /usr/lib/python3.12/asyncio/base_events.py:687: in run_until_complete return future.result() ^^^^^^^^^^^^^^^ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ async def scenario(): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) store.set_target(chat_id, "Synthetic evidence review", "private" if chat_id > 0 else "supergroup", True) collector = Collector(store, vault) collector.running = True ids = list(range(1, count + 1)) try: for mid in [*ids, 100]: store.append("message.new", {"text": f"Synthetic message {mid}", "outgoing": mid == 1, "sent_at": "2026-11-05T12:00:00+00:00", "edited_at": None}, chat_id, mid) raw = (types.UpdateDeleteMessages(messages=ids, pts=1, pts_count=count) if chat_id > 0 else types.UpdateDeleteChannelMessages(channel_id=555, messages=ids, pts=1, pts_count=count)) await collector.on_delete(SimpleNamespace(chat_id=None if chat_id > 0 else chat_id, deleted_ids=ids, original_update=raw)) assert store.message_state(chat_id, 100)["deleted"] is False events = list(store.all_events()) summaries = [e for e in events if e["kind"] in ("deletion.batch", "history.cleared")] assert len(summaries) == 1 summary = summaries[0] assert summary["kind"] == "deletion.batch", "A subset deletion is not a whole-history clear" assert summary["payload"]["outgoing_saved"] == 1 assert summary["payload"]["raw"] == raw.to_dict() assert "other side cleared" not in summary["payload"]["meaning"] > assert "does not identify who deleted them" in summary["payload"]["meaning"] E AssertionError: assert 'does not identify who deleted them' in 'Telegram reported several message IDs as deleted in one update.' tools/test_deletion_semantics.py:43: AssertionErrortmp_path = PosixPath('/tmp/pytest-of-root/pytest-6/test_the_dossier_counts_client0') def test_the_dossier_counts_clients_sticker_sets_and_prepared_media(tmp_path): vault, store = Vault(tmp_path), Store(tmp_path) store.bind(vault) try: store.set_target(CHAT, "Fictional payouts", "group", True) for number, raw in enumerate([video("round_1.mp4", (384, 384)), video(None, (384, 384)), video(None, (384, 384), sent="2026-11-02T12:00:00+00:00", uploaded="2026-11-02T06:00:00+00:00")], 1): store.append("message.new", {"text": "", "sender_id": PERSON, "sent_at": raw["date"], "sender_observation": {"id": PERSON, "display_name": "Admin"}, "raw": raw}, CHAT, number) built = dossier.build(store, CHAT) person = next(p for p in built["people"] if p["id"] == PERSON) assert {item["value"] for item in person["clients"]["observed"]} == {"Telegram Desktop", "Telegram for Android"} > assert "Metadata hypothesis about the client that encoded the file" in person["clients"]["meaning"] E assert 'Metadata hypothesis about the client that encoded the file' in "Client that encoded the file, read from the file's own metadata. A forwarded or re-uploaded file carries the encoder of whoever made it first." tools/test_device_attribution.py:104: AssertionError