gabriel / muse public
test_core_snapshot.py python
553 lines 22.5 KB
Raw
sha256:51ce277f663e01a43eaffbe77509b1de7ac2d4251b55d23306304bcdeb92c90d feat(pack): delta-encode snapshots in MPackBundle wire format Sonnet 4.6 minor ⚠ breaking 123 days ago
1 """Tests for muse.core.snapshot — content-addressed snapshot computation.
2
3 Test categories
4 ---------------
5 - TestHashFile — unit: SHA-256 hash_file
6 - TestBuildSnapshotManifest — unit: full manifest walks
7 - TestNestedRepoWalk — unit/integration: nested .muse repos are excluded
8 - TestComputeSnapshotId — unit: snapshot id derivation
9 - TestComputeCommitId — unit: commit id derivation
10 - TestDiffWorkdirVsSnapshot — unit: diff logic
11 """
12
13 import os
14 import pathlib
15 import threading
16 import time
17
18 import pytest
19
20 from muse.core.types import fake_id
21 from muse.core.snapshot import (
22 build_snapshot_manifest,
23 compute_commit_id,
24 compute_snapshot_id,
25 diff_workdir_vs_snapshot,
26 hash_file,
27 walk_workdir,
28 walk_workdir_with_dirs,
29 )
30 from muse.core.paths import muse_dir, repo_json_path
31
32
33 @pytest.fixture
34 def workdir(tmp_path: pathlib.Path) -> pathlib.Path:
35 return tmp_path
36
37
38 class TestHashFile:
39 def test_consistent(self, tmp_path: pathlib.Path) -> None:
40 f = tmp_path / "file.mid"
41 f.write_bytes(b"hello world")
42 assert hash_file(f) == hash_file(f)
43
44 def test_different_content_different_hash(self, tmp_path: pathlib.Path) -> None:
45 a = tmp_path / "a.mid"
46 b = tmp_path / "b.mid"
47 a.write_bytes(b"aaa")
48 b.write_bytes(b"bbb")
49 assert hash_file(a) != hash_file(b)
50
51 def test_known_hash(self, tmp_path: pathlib.Path) -> None:
52 from muse.core.types import blob_id
53 content = b"muse"
54 f = tmp_path / "f.mid"
55 f.write_bytes(content)
56 expected = blob_id(content)
57 assert hash_file(f) == expected
58
59
60 class TestBuildSnapshotManifest:
61 def test_empty_workdir(self, workdir: pathlib.Path) -> None:
62 assert build_snapshot_manifest(workdir) == {}
63
64 def test_single_file(self, workdir: pathlib.Path) -> None:
65 (workdir / "beat.mid").write_bytes(b"drums")
66 manifest = build_snapshot_manifest(workdir)
67 assert "beat.mid" in manifest
68 assert len(manifest["beat.mid"]) == 71 # sha256:<64 hex>
69
70 def test_nested_file(self, workdir: pathlib.Path) -> None:
71 (workdir / "tracks").mkdir()
72 (workdir / "tracks" / "bass.mid").write_bytes(b"bass")
73 manifest = build_snapshot_manifest(workdir)
74 assert "tracks/bass.mid" in manifest
75
76 def test_secrets_excluded_by_builtin_blocklist(self, workdir: pathlib.Path) -> None:
77 """Built-in secrets blocklist protects even without a .museignore file."""
78 (workdir / ".env").write_bytes(b"SECRET=abc")
79 (workdir / ".DS_Store").write_bytes(b"junk")
80 (workdir / "beat.mid").write_bytes(b"drums")
81 manifest = build_snapshot_manifest(workdir)
82 assert ".env" not in manifest
83 assert ".DS_Store" not in manifest
84 assert "beat.mid" in manifest
85
86 def test_dotfiles_tracked_when_not_ignored(self, workdir: pathlib.Path) -> None:
87 """Non-secret dotfiles like .cursorrules are tracked by default."""
88 (workdir / ".cursorrules").write_bytes(b"# rules")
89 (workdir / ".editorconfig").write_bytes(b"[*]\nindent_size=4")
90 manifest = build_snapshot_manifest(workdir)
91 assert ".cursorrules" in manifest
92 assert ".editorconfig" in manifest
93
94 def test_museignore_excludes_custom_pattern(self, workdir: pathlib.Path) -> None:
95 """A pattern in .museignore excludes the matched file."""
96 (workdir / ".museignore").write_bytes(b'[global]\npatterns = ["*.secret"]\n')
97 (workdir / "api.secret").write_bytes(b"token")
98 (workdir / "beat.mid").write_bytes(b"drums")
99 manifest = build_snapshot_manifest(workdir)
100 assert "api.secret" not in manifest
101 assert "beat.mid" in manifest
102
103 def test_deterministic_order(self, workdir: pathlib.Path) -> None:
104 for name in ["c.mid", "a.mid", "b.mid"]:
105 (workdir / name).write_bytes(name.encode())
106 m1 = build_snapshot_manifest(workdir)
107 m2 = build_snapshot_manifest(workdir)
108 assert m1 == m2
109
110
111 class TestComputeSnapshotId:
112 def test_empty_manifest(self) -> None:
113 sid = compute_snapshot_id({})
114 assert len(sid) == 71
115
116 def test_deterministic(self) -> None:
117 manifest = {"a.mid": fake_id("hash1"), "b.mid": fake_id("hash2")}
118 assert compute_snapshot_id(manifest) == compute_snapshot_id(manifest)
119
120 def test_order_independent(self) -> None:
121 m1 = {"a.mid": fake_id("h1"), "b.mid": fake_id("h2")}
122 m2 = {"b.mid": fake_id("h2"), "a.mid": fake_id("h1")}
123 assert compute_snapshot_id(m1) == compute_snapshot_id(m2)
124
125 def test_different_content_different_id(self) -> None:
126 m1 = {"a.mid": fake_id("h1")}
127 m2 = {"a.mid": fake_id("h2")}
128 assert compute_snapshot_id(m1) != compute_snapshot_id(m2)
129
130
131 class TestSnapshotIdentityBytes:
132 """snapshot_identity_bytes — the preimage extracted from compute_snapshot_id."""
133
134 def test_importable(self) -> None:
135 from muse.core.snapshot import snapshot_identity_bytes # noqa: F401
136
137 def test_returns_bytes(self) -> None:
138 from muse.core.snapshot import snapshot_identity_bytes
139 result = snapshot_identity_bytes({"a.py": fake_id("h1")})
140 assert isinstance(result, bytes)
141
142 def test_sha256_of_bytes_equals_compute_snapshot_id(self) -> None:
143 from muse.core.snapshot import snapshot_identity_bytes
144 from muse.core.types import blob_id
145 manifest = {"a.py": fake_id("h1"), "b.py": fake_id("h2")}
146 payload = snapshot_identity_bytes(manifest)
147 assert blob_id(payload) == compute_snapshot_id(manifest)
148
149 def test_with_directories(self) -> None:
150 from muse.core.snapshot import snapshot_identity_bytes
151 from muse.core.types import blob_id
152 manifest = {"src/a.py": fake_id("h1")}
153 dirs = ["src"]
154 payload = snapshot_identity_bytes(manifest, directories=dirs)
155 assert blob_id(payload) == compute_snapshot_id(manifest, directories=dirs)
156
157 def test_order_independent(self) -> None:
158 from muse.core.snapshot import snapshot_identity_bytes
159 m1 = {"a.py": fake_id("h1"), "b.py": fake_id("h2")}
160 m2 = {"b.py": fake_id("h2"), "a.py": fake_id("h1")}
161 assert snapshot_identity_bytes(m1) == snapshot_identity_bytes(m2)
162
163 def test_different_manifests_different_bytes(self) -> None:
164 from muse.core.snapshot import snapshot_identity_bytes
165 a = snapshot_identity_bytes({"a.py": fake_id("h1")})
166 b = snapshot_identity_bytes({"a.py": fake_id("h2")})
167 assert a != b
168
169 def test_empty_manifest(self) -> None:
170 from muse.core.snapshot import snapshot_identity_bytes
171 from muse.core.types import blob_id
172 payload = snapshot_identity_bytes({})
173 assert blob_id(payload) == compute_snapshot_id({})
174
175
176 class TestComputeCommitId:
177 _BASE = dict(
178 parent_ids=[fake_id("p1")],
179 snapshot_id=fake_id("snap"),
180 message="msg",
181 committed_at_iso="2026-01-01T00:00:00+00:00",
182 author="gabriel",
183 signer_public_key="ed25519:AAAA",
184 )
185
186 def test_deterministic(self) -> None:
187 assert compute_commit_id(**self._BASE) == compute_commit_id(**self._BASE)
188
189 def test_parent_order_independent(self) -> None:
190 a = compute_commit_id(**{**self._BASE, "parent_ids": [fake_id("p1"), fake_id("p2")]})
191 b = compute_commit_id(**{**self._BASE, "parent_ids": [fake_id("p2"), fake_id("p1")]})
192 assert a == b
193
194 def test_different_messages_different_ids(self) -> None:
195 a = compute_commit_id(**{**self._BASE, "message": "msg1"})
196 b = compute_commit_id(**{**self._BASE, "message": "msg2"})
197 assert a != b
198
199 def test_different_authors_different_commit_ids(self) -> None:
200 a = compute_commit_id(**{**self._BASE, "author": "alice"})
201 b = compute_commit_id(**{**self._BASE, "author": "bob"})
202 assert a != b
203
204 def test_different_signer_keys_different_commit_ids(self) -> None:
205 a = compute_commit_id(**{**self._BASE, "signer_public_key": "ed25519:AAAA"})
206 b = compute_commit_id(**{**self._BASE, "signer_public_key": "ed25519:BBBB"})
207 assert a != b
208
209 def test_empty_author_and_key_still_deterministic(self) -> None:
210 kwargs = {**self._BASE, "author": "", "signer_public_key": ""}
211 assert compute_commit_id(**kwargs) == compute_commit_id(**kwargs)
212
213 def test_result_has_sha256_prefix(self) -> None:
214 result = compute_commit_id(**self._BASE)
215 assert result.startswith("sha256:")
216
217
218 class TestCommitIdentityBytes:
219 """commit_identity_bytes — the preimage extracted from compute_commit_id.
220
221 Red: commit_identity_bytes is not yet exported from muse.core.snapshot.
222 Green: after extraction, compute_commit_id becomes a thin wrapper over it.
223 """
224
225 _BASE = dict(
226 parent_ids=[fake_id("p1")],
227 snapshot_id=fake_id("snap"),
228 message="msg",
229 committed_at_iso="2026-01-01T00:00:00+00:00",
230 author="gabriel",
231 signer_public_key="ed25519:AAAA",
232 )
233
234 def test_importable(self) -> None:
235 from muse.core.snapshot import commit_identity_bytes # noqa: F401
236
237 def test_returns_bytes(self) -> None:
238 from muse.core.snapshot import commit_identity_bytes
239 result = commit_identity_bytes(**self._BASE)
240 assert isinstance(result, bytes)
241
242 def test_sha256_of_bytes_equals_compute_commit_id(self) -> None:
243 """The bytes are the exact preimage: sha256(bytes) == compute_commit_id."""
244 from muse.core.snapshot import commit_identity_bytes
245 from muse.core.types import blob_id
246 result = commit_identity_bytes(**self._BASE)
247 assert blob_id(result) == compute_commit_id(**self._BASE)
248
249 def test_parent_order_independent(self) -> None:
250 from muse.core.snapshot import commit_identity_bytes
251 a = commit_identity_bytes(**{**self._BASE, "parent_ids": [fake_id("p1"), fake_id("p2")]})
252 b = commit_identity_bytes(**{**self._BASE, "parent_ids": [fake_id("p2"), fake_id("p1")]})
253 assert a == b
254
255 def test_different_fields_different_bytes(self) -> None:
256 from muse.core.snapshot import commit_identity_bytes
257 a = commit_identity_bytes(**self._BASE)
258 b = commit_identity_bytes(**{**self._BASE, "message": "different"})
259 assert a != b
260
261
262 class TestDiffWorkdirVsSnapshot:
263 def test_new_repo_all_untracked(self, workdir: pathlib.Path) -> None:
264 (workdir / "beat.mid").write_bytes(b"x")
265 added, modified, deleted, untracked, added_dirs, deleted_dirs = diff_workdir_vs_snapshot(workdir, {})
266 assert added == set()
267 assert untracked == {"beat.mid"}
268
269 def test_added_file(self, workdir: pathlib.Path) -> None:
270 (workdir / "beat.mid").write_bytes(b"x")
271 last = {"other.mid": "abc"}
272 added, modified, deleted, untracked, added_dirs, deleted_dirs = diff_workdir_vs_snapshot(workdir, last)
273 assert "beat.mid" in added
274 assert "other.mid" in deleted
275
276 def test_modified_file(self, workdir: pathlib.Path) -> None:
277 f = workdir / "beat.mid"
278 f.write_bytes(b"new content")
279 last = {"beat.mid": "oldhash"}
280 added, modified, deleted, untracked, added_dirs, deleted_dirs = diff_workdir_vs_snapshot(workdir, last)
281 assert "beat.mid" in modified
282
283 def test_clean_workdir(self, workdir: pathlib.Path) -> None:
284 f = workdir / "beat.mid"
285 f.write_bytes(b"content")
286 from muse.core.snapshot import hash_file
287 h = hash_file(f)
288 added, modified, deleted, untracked, added_dirs, deleted_dirs = diff_workdir_vs_snapshot(workdir, {"beat.mid": h})
289 assert not added and not modified and not deleted and not untracked
290
291 def test_ignored_extant_file_not_reported_as_deleted(
292 self, workdir: pathlib.Path
293 ) -> None:
294 """A file that was tracked, is now in .museignore, and still exists on
295 disk must NOT appear in ``deleted``. It was intentionally moved out of
296 tracking — reporting it as deleted would block checkout and cause shelf
297 pop to unlink it."""
298 (workdir / ".museignore").write_bytes(
299 b'[global]\npatterns = ["app.js"]\n'
300 )
301 (workdir / "app.js").write_bytes(b"// build artifact")
302 (workdir / "src.py").write_bytes(b"# source")
303 from muse.core.snapshot import hash_file
304 # Pretend HEAD tracked both files.
305 last = {
306 "app.js": hash_file(workdir / "app.js"),
307 "src.py": hash_file(workdir / "src.py"),
308 }
309 added, modified, deleted, _, _, _ = diff_workdir_vs_snapshot(workdir, last)
310 assert "app.js" not in deleted, (
311 "ignored-and-extant file must not appear in deleted"
312 )
313 assert "src.py" not in deleted
314
315 def test_ignored_absent_file_is_reported_as_deleted(
316 self, workdir: pathlib.Path
317 ) -> None:
318 """A file that is in .museignore but is genuinely absent from disk IS
319 deleted and must appear in ``deleted``."""
320 (workdir / ".museignore").write_bytes(
321 b'[global]\npatterns = ["app.js"]\n'
322 )
323 # app.js is in .museignore but does NOT exist on disk.
324 (workdir / "src.py").write_bytes(b"# source")
325 from muse.core.snapshot import hash_file
326 last = {
327 "app.js": "a" * 64, # was in HEAD but is gone from disk
328 "src.py": hash_file(workdir / "src.py"),
329 }
330 added, modified, deleted, _, _, _ = diff_workdir_vs_snapshot(workdir, last)
331 assert "app.js" in deleted, (
332 "ignored file that is genuinely absent from disk must still be deleted"
333 )
334
335
336 # ---------------------------------------------------------------------------
337 # Nested repo boundary — unit / integration
338 # ---------------------------------------------------------------------------
339
340 def _make_nested_repo(parent: pathlib.Path, name: str) -> pathlib.Path:
341 """Create a child directory that looks like a muse repo (.muse/ present)."""
342 child = parent / name
343 child.mkdir(parents=True, exist_ok=True)
344 muse_dir(child).mkdir()
345 (repo_json_path(child)).write_text('{"repo_id": "child"}')
346 return child
347
348
349 class TestNestedRepoWalk:
350 """Nested muse repos must be excluded from the parent's walk.
351
352 The parent repo's ``os.walk`` must prune any subdirectory that contains
353 its own ``.muse/`` directory. This mirrors git submodule behaviour —
354 child repo files belong to the child snapshot, not the parent.
355 """
356
357 # --- walk_workdir -------------------------------------------------------
358
359 def test_nested_repo_files_excluded(self, tmp_path: pathlib.Path) -> None:
360 """Files inside a nested repo do not appear in the parent manifest."""
361 (tmp_path / "parent.py").write_bytes(b"# parent")
362 child = _make_nested_repo(tmp_path, "child_repo")
363 (child / "child.py").write_bytes(b"# child")
364
365 manifest = walk_workdir(tmp_path)
366 assert "parent.py" in manifest
367 assert "child_repo/child.py" not in manifest
368
369 def test_nested_repo_root_dir_excluded(self, tmp_path: pathlib.Path) -> None:
370 """The child root directory itself is not descended into."""
371 _make_nested_repo(tmp_path, "child_repo")
372 manifest = walk_workdir(tmp_path)
373 # No key should start with child_repo/
374 assert not any(k.startswith("child_repo/") for k in manifest)
375
376 def test_sibling_dirs_still_walked(self, tmp_path: pathlib.Path) -> None:
377 """Normal subdirs next to a nested repo are still walked."""
378 _make_nested_repo(tmp_path, "child_repo")
379 sibling = tmp_path / "src"
380 sibling.mkdir()
381 (sibling / "main.py").write_bytes(b"# main")
382
383 manifest = walk_workdir(tmp_path)
384 assert "src/main.py" in manifest
385
386 def test_deeply_nested_repo_excluded(self, tmp_path: pathlib.Path) -> None:
387 """Nested repos two levels deep are also excluded."""
388 mid = tmp_path / "packages"
389 mid.mkdir()
390 (mid / "shared.py").write_bytes(b"# shared")
391 child = _make_nested_repo(mid, "plugin")
392 (child / "plugin.py").write_bytes(b"# plugin")
393
394 manifest = walk_workdir(tmp_path)
395 assert "packages/shared.py" in manifest
396 assert "packages/plugin/plugin.py" not in manifest
397
398 def test_multiple_nested_repos_all_excluded(self, tmp_path: pathlib.Path) -> None:
399 """Multiple sibling nested repos are all pruned."""
400 _make_nested_repo(tmp_path, "repo_a")
401 _make_nested_repo(tmp_path, "repo_b")
402 _make_nested_repo(tmp_path, "repo_c")
403 (tmp_path / "root.py").write_bytes(b"# root")
404 for repo in ("repo_a", "repo_b", "repo_c"):
405 ((tmp_path / repo) / "file.py").write_bytes(b"# file")
406
407 manifest = walk_workdir(tmp_path)
408 assert "root.py" in manifest
409 for repo in ("repo_a", "repo_b", "repo_c"):
410 assert f"{repo}/file.py" not in manifest
411
412 # --- walk_workdir_with_dirs ---------------------------------------------
413
414 def test_dirs_output_excludes_nested_repo(self, tmp_path: pathlib.Path) -> None:
415 """walk_workdir_with_dirs must not list the nested repo as a directory."""
416 _make_nested_repo(tmp_path, "child_repo")
417 src = tmp_path / "src"
418 src.mkdir()
419 (src / "a.py").write_bytes(b"a")
420
421 _, dirs = walk_workdir_with_dirs(tmp_path)
422 assert "src" in dirs
423 assert "child_repo" not in dirs
424
425 # --- build_snapshot_manifest (public API) --------------------------------
426
427 def test_build_snapshot_manifest_excludes_nested(self, tmp_path: pathlib.Path) -> None:
428 """build_snapshot_manifest is the public wrapper — same boundary."""
429 (tmp_path / "root.py").write_bytes(b"# root")
430 child = _make_nested_repo(tmp_path, "nested")
431 (child / "nested.py").write_bytes(b"# nested")
432
433 manifest = build_snapshot_manifest(tmp_path)
434 assert "root.py" in manifest
435 assert "nested/nested.py" not in manifest
436
437 # --- diff_workdir_vs_snapshot integration --------------------------------
438
439 def test_diff_does_not_report_nested_files_as_added(
440 self, tmp_path: pathlib.Path
441 ) -> None:
442 """diff sees an empty last-snapshot: nested files must not appear as untracked."""
443 (tmp_path / "root.py").write_bytes(b"# root")
444 child = _make_nested_repo(tmp_path, "sub")
445 (child / "sub.py").write_bytes(b"# sub")
446
447 added, modified, deleted, untracked, _, _ = diff_workdir_vs_snapshot(
448 tmp_path, {}
449 )
450 assert "root.py" in untracked
451 assert not any(k.startswith("sub/") for k in untracked)
452 assert not any(k.startswith("sub/") for k in added)
453
454 # --- data integrity -----------------------------------------------------
455
456 def test_manifest_keys_posix_separators(self, tmp_path: pathlib.Path) -> None:
457 """Manifest keys always use '/' regardless of OS."""
458 sub = tmp_path / "a" / "b"
459 sub.mkdir(parents=True)
460 (sub / "file.py").write_bytes(b"x")
461 manifest = walk_workdir(tmp_path)
462 assert "a/b/file.py" in manifest
463 assert all("/" in k or "/" not in k for k in manifest) # no backslash keys
464 assert not any("\\" in k for k in manifest)
465
466 def test_nested_muse_dir_itself_not_tracked(self, tmp_path: pathlib.Path) -> None:
467 """The .muse/ directory of a nested repo is not tracked as a file."""
468 child = _make_nested_repo(tmp_path, "child")
469 (child / "real.py").write_bytes(b"x")
470 manifest = walk_workdir(tmp_path)
471 assert not any(".muse" in k for k in manifest)
472
473 # --- security -----------------------------------------------------------
474
475 def test_symlink_to_nested_repo_not_followed(self, tmp_path: pathlib.Path) -> None:
476 """A symlink pointing at a directory that has .muse/ is not followed.
477 walk_workdir uses followlinks=False so symlinks are excluded by design."""
478 real = _make_nested_repo(tmp_path, "real_repo")
479 (real / "secret.py").write_bytes(b"# secret")
480 link = tmp_path / "link_to_repo"
481 link.symlink_to(real)
482
483 manifest = walk_workdir(tmp_path)
484 assert "link_to_repo/secret.py" not in manifest
485
486 def test_symlink_to_regular_dir_not_followed(self, tmp_path: pathlib.Path) -> None:
487 """Symlinks to any directory are never followed — followlinks=False."""
488 real = tmp_path / "outside"
489 real.mkdir()
490 (real / "file.py").write_bytes(b"x")
491 link = tmp_path / "link_to_dir"
492 link.symlink_to(real)
493
494 manifest = walk_workdir(tmp_path)
495 assert "link_to_dir/file.py" not in manifest
496
497 def test_nested_repo_with_unusual_name(self, tmp_path: pathlib.Path) -> None:
498 """Nested repos with names containing spaces or dots are excluded."""
499 for name in ("my.repo", "repo name", ".hidden_repo"):
500 child = tmp_path / name
501 child.mkdir()
502 muse_dir(child).mkdir()
503 (child / "file.py").write_bytes(b"x")
504
505 (tmp_path / "root.py").write_bytes(b"r")
506 manifest = walk_workdir(tmp_path)
507 assert "root.py" in manifest
508 assert not any("file.py" in k for k in manifest)
509
510 # --- performance --------------------------------------------------------
511
512 def test_large_parent_with_nested_repo_fast(self, tmp_path: pathlib.Path) -> None:
513 """Walking 500-file parent with a nested repo completes in < 2 s."""
514 for i in range(500):
515 (tmp_path / f"file_{i:04d}.py").write_bytes(b"x" * 100)
516 child = _make_nested_repo(tmp_path, "child")
517 for i in range(200):
518 (child / f"child_{i:04d}.py").write_bytes(b"x" * 100)
519
520 start = time.monotonic()
521 manifest = walk_workdir(tmp_path)
522 elapsed = time.monotonic() - start
523
524 assert elapsed < 2.0, f"walk took {elapsed:.2f}s — too slow"
525 # Parent files included, child files excluded.
526 assert len(manifest) == 500
527 assert not any(k.startswith("child/") for k in manifest)
528
529 def test_concurrent_walks_consistent(self, tmp_path: pathlib.Path) -> None:
530 """Concurrent walks of the same tree return identical manifests."""
531 (tmp_path / "a.py").write_bytes(b"a")
532 (tmp_path / "b.py").write_bytes(b"b")
533 _make_nested_repo(tmp_path, "child")
534 (tmp_path / "child" / "c.py").write_bytes(b"c")
535
536 results: list[dict] = []
537 errors: list[Exception] = []
538
539 def _walk() -> None:
540 try:
541 results.append(walk_workdir(tmp_path))
542 except Exception as exc:
543 errors.append(exc)
544
545 threads = [threading.Thread(target=_walk) for _ in range(8)]
546 for t in threads:
547 t.start()
548 for t in threads:
549 t.join()
550
551 assert not errors
552 assert len(results) == 8
553 assert all(r == results[0] for r in results), "concurrent walks diverged"
File History 1 commit
sha256:51ce277f663e01a43eaffbe77509b1de7ac2d4251b55d23306304bcdeb92c90d feat(pack): delta-encode snapshots in MPackBundle wire format Sonnet 4.6 minor ⚠ 123 days ago