rad:z3gqcJUoA1n9HaHKufZs5FCSGazv5 heartwoodfb80d58af750d525fc2bd8081e5612a3c2726d4c
{
"request": "trigger",
"version": 1,
"event_type": "patch",
"repository": {
"id": "rad:z3gqcJUoA1n9HaHKufZs5FCSGazv5",
"name": "heartwood",
"description": "Radicle Heartwood Protocol & Stack",
"private": false,
"default_branch": "master",
"delegates": [
"did:key:z6MksFqXN3Yhqk8pTJdUGLwATkRfQvwZXPqR2qMEhbS9wzpT",
"did:key:z6MktaNvN1KVFMkSRAiN4qK5yvX1zuEEaseeX5sffhzPZRZW",
"did:key:z6MkireRatUThvd3qzfKht1S44wpm4FEWSSa4PRMTSQZ3voM",
"did:key:z6MkgFq6z5fkF2hioLLSNu1zP2qEL1aHXHZzGH1FLFGAnBGz",
"did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz"
]
},
"action": "Updated",
"patch": {
"id": "712a995a282fd544b081ea02dae7ff246810a20c",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"title": "radicle/cob/identity: Rewrite Evaluation",
"state": {
"status": "open",
"conflicts": []
},
"before": "ee17109501428319311d18f9bfc339a2a6dec88b",
"after": "fb80d58af750d525fc2bd8081e5612a3c2726d4c",
"commits": [
"fb80d58af750d525fc2bd8081e5612a3c2726d4c",
"2f1aaa45b2657d51ef5683f2acc86e050c268d51",
"a63f91885f91de789e4aa7c5a053b777eed03343",
"b6f07074d9198bdbf60f49af61ac6416397edb46",
"7daeb3135b9a264e71b631b6896339bea7784590",
"654218e6a56251a09de0f8924119645d62030232",
"82dc3fe20c5328b606031ed186b9fea2dad81ddc",
"8e677a9d90f10f916b6424c57b450222ed8f5ac6",
"62f64744ad1e0b5c0198e1ebe1e602f6344dac11",
"f720526fc9fd457461d6d440b2742355b9df0020",
"21700e4962c0541043ceba7ee37a777eeaceafed",
"ebf0f417f74558fe974fd72dc2ead38e600639b2",
"97f279fe41be6cc48b462a59b45b7de062029460",
"e0e231813fc5bd521941fadf6a0e9c54c03fb9f4",
"108686e299edebec253e1d2e50e1d939947e4208",
"da2c523d411e21bb74ef18f3469d2f8c03658528",
"aae8938c013149de94bd36d76cfa20e59fd4def6",
"94a24a7283c3a65a0ae02cd7de22fd02f07d96bd",
"2768fe79d2b77ff6688fa26fe3c330d3e524e859",
"c174efccb95d1887483c596cab9166c40dd52d2b",
"2349eebf5da5052f546e9e419cf8a5081de6bb8b",
"39972b0c46303a9f0781dd673022780d40888753",
"489360d0e5d92495af49b495e5c443f0245b688f",
"ba4a79af9060548f85106a78eb90625c8d27fea2",
"d8c14222a26750b8153235a7c97b42c6738fabfd",
"b145b95ee4205a1d18fbe6fb912f11c3dd864526",
"442df34be72a0d4e01ef7e10b7afcc4aa0ee949b"
],
"target": "ee17109501428319311d18f9bfc339a2a6dec88b",
"labels": [],
"assignees": [],
"revisions": [
{
"id": "712a995a282fd544b081ea02dae7ff246810a20c",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "### Use verdicts to count votes\n\nEvaluation of this COB is implemented under the assumption that\ndelegates accept at most one revision.\n\nThis can lead to issues, if some delegates create new revisions eagerly,\nwithout waiting for the others to vote on earlier revisions. As the\neager delegates start accepting newer and newer revisions, this shadows\ntheir acceptance of earlier revisions, which leads to failure to\nrecognize that these earlier revisions were actually accepted by a\nmajority.\n\nTo avoid such situations, remove `heads`, and always count the number of\n\"accept\" verdicts explicitly.\n\n### Rewrite Evaluation\n\nEvaluation of the COB `xyz.radicle.id` is rewritten to remove the\nvariant `State::Stale`.\n\nSince we require the history of accepted revisions to be linear, we may\nas well interpret all siblings of adopted revisions to be rejected.\nThis gives a nice symmetry between accepted and rejected revisions.\n\nIntroduce `State::Redacted`, as handling redacted revisions with their\nown state is easier to reason about compared to having to maintain\ninvariants for `revisions: BTreeMap<RevisionId, Option<Revision>>`.",
"base": "998ff91e2c25f1432de007c90fb447849ada37d2",
"oid": "7f92cfda0ac5572854bc564f60071f6e17371c62",
"timestamp": 1779442165
},
{
"id": "52e5ed2946f3c207f5de086af788253f76a1fb70",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Adds 3 additional tests. The last is failing.",
"base": "998ff91e2c25f1432de007c90fb447849ada37d2",
"oid": "22ce2ce70609009d3be6a6403aca07106383e262",
"timestamp": 1779457796
},
{
"id": "94d842c0f46d63e77be28cf0bef6557c5bb56b41",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Add fix and update existing tests",
"base": "998ff91e2c25f1432de007c90fb447849ada37d2",
"oid": "9d89a2e35c36290e320ffd18d341c0df9c333fa3",
"timestamp": 1779462080
},
{
"id": "528a25f8667d2cdb8388777d428e1a1924df5c1b",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Adds property tests for identity COB",
"base": "998ff91e2c25f1432de007c90fb447849ada37d2",
"oid": "6fe9842ed421f3cc5b1671c916d439d27c94bf59",
"timestamp": 1779902132
},
{
"id": "83fbe2b387974e4fa592ad1866f3dcc9cd201559",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Fixes threshold assumptions",
"base": "998ff91e2c25f1432de007c90fb447849ada37d2",
"oid": "b3beea8f837f67624d2b33bc6dd0a8c06be8a381",
"timestamp": 1779969863
},
{
"id": "fbc6da86326be94fde4906ea3311b831567a0144",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Removes more references to `threshold` and updates diagrams",
"base": "998ff91e2c25f1432de007c90fb447849ada37d2",
"oid": "8e46599111307315e6f51534dfbb28599516f1dd",
"timestamp": 1780054002
},
{
"id": "03e6eeeb7af3e71d0e3ea0fee99d79328e8bced5",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "- Add causal reasons to Rejected and Redacted states\n- Fix rejection threshold calculation\n- Fix sibling resolution for late-arriving forks",
"base": "998ff91e2c25f1432de007c90fb447849ada37d2",
"oid": "7d971f19bab96137e2032f9d6524335b4277e708",
"timestamp": 1780390774
},
{
"id": "39cbe88e23edf6352677f8cc8a8e3f143d008322",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Rework Patch\n\nThe majority of this revision keeps the improved evaluation of the repository\nidentity. To make the changes more coherent, it squashes these improvements into\na single commit, re-describing the changes.\n\nThe test cases are then added as individual commits, followed by the property tests.\n\nThe additions I do provide in this revision are some extra test cases, and\ncatching a bug in the adoption logic that allowed rescinded delegates to count\ntheir votes in child revisions.",
"base": "998ff91e2c25f1432de007c90fb447849ada37d2",
"oid": "a706c99b8f6c2b27048df78f4f3c05dfe2f27cba",
"timestamp": 1781281164
},
{
"id": "6ddba384d56b3d5e7063122cdab7062d2fed3609",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Changes:\n- cargo fmt",
"base": "998ff91e2c25f1432de007c90fb447849ada37d2",
"oid": "87a09c733b636d6bd2b628e1fafec2fb452addfc",
"timestamp": 1781281279
},
{
"id": "cd80cb5ae8db5ec2c4daae8e7b5708e25d698193",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Rebase and review.",
"base": "88bf2a9648750365d4565e32deae35b18808a391",
"oid": "e97fb436bf93a65fb3e18a2e4f2c797959288b26",
"timestamp": 1781903994
},
{
"id": "b0133884d308d27153302067102dad6bbe06e254",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Review",
"base": "88bf2a9648750365d4565e32deae35b18808a391",
"oid": "ccde4dfd7f2a0eab5c300c31413e227707543c7b",
"timestamp": 1781962655
},
{
"id": "8ff7c16bcdb67027ae869490fd3c6361eb1efd4a",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Another round of polishing.",
"base": "88bf2a9648750365d4565e32deae35b18808a391",
"oid": "fe4b01138d58cd122dfe5af483718c719d69f3af",
"timestamp": 1782252269
},
{
"id": "432f8d7a19045a11354ae98d6e594e157eaf10c7",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Refactor property tests and existing unit to incorporate new authorisation rules dictated by the parent revision.",
"base": "88bf2a9648750365d4565e32deae35b18808a391",
"oid": "5326910464131de4ecf99c1d343f57d2edfc5ddc",
"timestamp": 1782313654
},
{
"id": "51d685da41a4298859a2cde289f86e168e4e44a1",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Work in review, reword commit messages.",
"base": "88bf2a9648750365d4565e32deae35b18808a391",
"oid": "411c73948a9857eb083a2fc8330ffae822e20efd",
"timestamp": 1782338152
},
{
"id": "9b4da63fe2b61fdc77517c31f665fba144f0f7f4",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "- Minor fix for broken unit test\n- Reduced identity cob prop test count to speed up tests",
"base": "88bf2a9648750365d4565e32deae35b18808a391",
"oid": "a08e438e17307a2803dee3e53ff295002c685955",
"timestamp": 1782472970
},
{
"id": "10b20f0af4340d2dc1f300bc04f44c5823f07064",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Changes:\n- Fix the cascading rejection test scenario\n- Provide more test scenarios to protect for regression\n- Introduce new invariant that a delegate cannot accept more than one active,\n sibling revision. This prevents, previously possible, cases where two\n revisions can be concurrently accepted and, at first, appear adopted, until\n the operations converge and an arbitrary revision would be adopted.",
"base": "ee17109501428319311d18f9bfc339a2a6dec88b",
"oid": "a9331fded4cdf89a8f966b0fee4345a73d2f316d",
"timestamp": 1783089596
},
{
"id": "051d0294ce0234e0bfff830d42f68fbcb1e7d9b3",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Changes:\n- Added CHANGELOG",
"base": "ee17109501428319311d18f9bfc339a2a6dec88b",
"oid": "4e542eb3bdd421f5d394574cd2e7bd9d810cece3",
"timestamp": 1783102320
},
{
"id": "ac58e4a00a84a0ec5cb62cba7701102718389b9b",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Introduce `rad id` rejected reasons",
"base": "ee17109501428319311d18f9bfc339a2a6dec88b",
"oid": "a986a29661957216e5bbc74e7c6c17a734d6b584",
"timestamp": 1783523274
},
{
"id": "a7788e511a22dbc1d3c8980db519bf0f7290e636",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Take Adrian's revision, remove changes that belong in a separate patch, reword changelog with Fintan.",
"base": "ee17109501428319311d18f9bfc339a2a6dec88b",
"oid": "fb80d58af750d525fc2bd8081e5612a3c2726d4c",
"timestamp": 1783590052
}
]
}
}
{
"response": "triggered",
"run_id": {
"id": "14e70052-96f5-4ea4-b33c-245ca967bbbf"
},
"info_url": "https://cci.rad.levitte.org//14e70052-96f5-4ea4-b33c-245ca967bbbf.html"
}
Started at: 2026-07-09 11:41:34.592888+02:00
Commands:
$ rad clone rad:z3gqcJUoA1n9HaHKufZs5FCSGazv5 .
✓ Creating checkout in ./...
✓ Remote cloudhead@z6MksFqXN3Yhqk8pTJdUGLwATkRfQvwZXPqR2qMEhbS9wzpT added
✓ Remote-tracking branch cloudhead@z6MksFqXN3Yhqk8pTJdUGLwATkRfQvwZXPqR2qMEhbS9wzpT/master created for z6MksFqXN3Yhqk8pTJdUGLwATkRfQvwZXPqR2qMEhbS9wzpT
✓ Remote cloudhead@z6MktaNvN1KVFMkSRAiN4qK5yvX1zuEEaseeX5sffhzPZRZW added
✓ Remote-tracking branch cloudhead@z6MktaNvN1KVFMkSRAiN4qK5yvX1zuEEaseeX5sffhzPZRZW/master created for z6MktaNvN1KVFMkSRAiN4qK5yvX1zuEEaseeX5sffhzPZRZW
✓ Remote fintohaps@z6MkireRatUThvd3qzfKht1S44wpm4FEWSSa4PRMTSQZ3voM added
✓ Remote-tracking branch fintohaps@z6MkireRatUThvd3qzfKht1S44wpm4FEWSSa4PRMTSQZ3voM/master created for z6MkireRatUThvd3qzfKht1S44wpm4FEWSSa4PRMTSQZ3voM
✓ Remote erikli@z6MkgFq6z5fkF2hioLLSNu1zP2qEL1aHXHZzGH1FLFGAnBGz added
✓ Remote-tracking branch erikli@z6MkgFq6z5fkF2hioLLSNu1zP2qEL1aHXHZzGH1FLFGAnBGz/master created for z6MkgFq6z5fkF2hioLLSNu1zP2qEL1aHXHZzGH1FLFGAnBGz
✓ Remote lorenz@z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz added
✓ Remote-tracking branch lorenz@z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz/master created for z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz
✓ Repository successfully cloned under /opt/radcis/ci.rad.levitte.org/cci/state/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/
╭────────────────────────────────────╮
│ heartwood │
│ Radicle Heartwood Protocol & Stack │
│ 187 issues · 41 patches │
╰────────────────────────────────────╯
Run `cd ./.` to go to the repository directory.
Exit code: 0
$ rad patch checkout 712a995a282fd544b081ea02dae7ff246810a20c
✓ Switched to branch patch/712a995 at revision a7788e5
✓ Branch patch/712a995 setup to track rad/patches/712a995a282fd544b081ea02dae7ff246810a20c
Exit code: 0
$ git config advice.detachedHead false
Exit code: 0
$ git checkout fb80d58af750d525fc2bd8081e5612a3c2726d4c
HEAD is now at fb80d58a CHANGELOG: Describe the changes to repository identity evaluation
Exit code: 0
$ rad patch show 712a995a282fd544b081ea02dae7ff246810a20c -p
╭─────────────────────────────────────────────────────────────────────────────────────────────────╮
│ Title radicle/cob/identity: Rewrite Evaluation │
│ Patch 712a995a282fd544b081ea02dae7ff246810a20c │
│ Author lorenz z6MkkPv…WX5sTEz │
│ Head fb80d58af750d525fc2bd8081e5612a3c2726d4c │
│ Base ee17109501428319311d18f9bfc339a2a6dec88b │
│ Branches patch/712a995 │
│ Commits ahead 27, behind 0 │
│ Status open │
│ │
│ ### Use verdicts to count votes │
│ │
│ Evaluation of this COB is implemented under the assumption that │
│ delegates accept at most one revision. │
│ │
│ This can lead to issues, if some delegates create new revisions eagerly, │
│ without waiting for the others to vote on earlier revisions. As the │
│ eager delegates start accepting newer and newer revisions, this shadows │
│ their acceptance of earlier revisions, which leads to failure to │
│ recognize that these earlier revisions were actually accepted by a │
│ majority. │
│ │
│ To avoid such situations, remove `heads`, and always count the number of │
│ "accept" verdicts explicitly. │
│ │
│ ### Rewrite Evaluation │
│ │
│ Evaluation of the COB `xyz.radicle.id` is rewritten to remove the │
│ variant `State::Stale`. │
│ │
│ Since we require the history of accepted revisions to be linear, we may │
│ as well interpret all siblings of adopted revisions to be rejected. │
│ This gives a nice symmetry between accepted and rejected revisions. │
│ │
│ Introduce `State::Redacted`, as handling redacted revisions with their │
│ own state is easier to reason about compared to having to maintain │
│ invariants for `revisions: BTreeMap<RevisionId, Option<Revision>>`. │
├─────────────────────────────────────────────────────────────────────────────────────────────────┤
│ fb80d58 CHANGELOG: Describe the changes to repository identity evaluation │
│ 2f1aaa4 radicle/cob/identity: Add sibling-accept invariant to property tests │
│ a63f918 radicle/cob/identity: Guard `IdentityMut::update` against sibling proposals │
│ b6f0707 radicle/cob/identity: Guard `IdentityMut::accept` against sibling accepts │
│ 7daeb31 radicle/cob/identity: Add SiblingAccepted error variant │
│ 654218e radicle/cob/identity: Strip implicit author accept for sibling revisions in `action` │
│ 82dc3fe radicle/cob/identity: Enforce sibling-accept invariant for `RevisionAccept` in `action` │
│ 8e677a9 radicle/cob/identity: Add has_active_sibling_accept helper │
│ 62f6474 radicle/cob/identity: Test accept-before-redact convergence │
│ f720526 radicle/cob/identity: Test concurrent redact-vs-accept convergence │
│ 21700e4 radicle/cob/identity: Fix cascading_rejections test to test actual cascading │
│ ebf0f41 radicle/cob/identity: Deprecate `Identity::id` │
│ 97f279f radicle/cob/identity: Test redacting accepted revisions │
│ e0e2318 radicle/cob/identity: Test `authorization_based_on_parent_not_current` │
│ 108686e radicle/cob/identity: Test queued children with delegate change │
│ da2c523 radicle/cob/identity: Add Property Tests │
│ aae8938 radicle/test/arbitrary: Make BoundedVec shared │
│ 94a24a7 radicle/cob/identity: Fix comments in test `reject_concurrent` │
│ 2768fe7 radicle/cob/identity: Test evaluating children of accepted revision │
│ c174efc radicle/cob/identity: Test cascading of redaction │
│ 2349eeb radicle/cob/identity: Test cascading rejection │
│ 39972b0 radicle/cob/identity: Test terminal states │
│ 489360d radicle/cob/identity: Add concurrent terminal state test │
│ ba4a79a radicle/cob/identity: Test rejected sibling │
│ d8c1422 radicle/cob/identity: Rewrite Evaluation │
│ b145b95 radicle/cob/identity: Use verdicts to count votes │
│ 442df34 radicle/cob/identity: Strengthen test assumptions │
├─────────────────────────────────────────────────────────────────────────────────────────────────┤
│ ● Revision 712a995 @ 998ff91..7f92cfd by lorenz z6MkkPv…WX5sTEz 1 month ago │
│ ↑ Revision 52e5ed2 @ 998ff91..22ce2ce by ade z6MkwGo…yS2aagA 1 month ago │
│ ↑ Revision 94d842c @ 998ff91..9d89a2e by ade z6MkwGo…yS2aagA 1 month ago │
│ ↑ Revision 528a25f @ 998ff91..6fe9842 by ade z6MkwGo…yS2aagA 1 month ago │
│ ↑ Revision 83fbe2b @ 998ff91..b3beea8 by ade z6MkwGo…yS2aagA 1 month ago │
│ ↑ Revision fbc6da8 @ 998ff91..8e46599 by ade z6MkwGo…yS2aagA 1 month ago │
│ ↑ Revision 03e6eee @ 998ff91..7d971f1 by ade z6MkwGo…yS2aagA 1 month ago │
│ ↑ Revision 39cbe88 @ 998ff91..a706c99 by fintohaps z6Mkire…SQZ3voM 3 weeks ago │
│ ↑ Revision 6ddba38 @ 998ff91..87a09c7 by fintohaps z6Mkire…SQZ3voM 3 weeks ago │
│ ↑ Revision cd80cb5 @ 88bf2a9..e97fb43 by lorenz z6MkkPv…WX5sTEz 2 weeks ago │
│ ↑ Revision b013388 @ 88bf2a9..ccde4df by lorenz z6MkkPv…WX5sTEz 2 weeks ago │
│ ↑ Revision 8ff7c16 @ 88bf2a9..fe4b011 by lorenz z6MkkPv…WX5sTEz 2 weeks ago │
│ ↑ Revision 432f8d7 @ 88bf2a9..5326910 by ade z6MkwGo…yS2aagA 2 weeks ago │
│ ↑ Revision 51d685d @ 88bf2a9..411c739 by lorenz z6MkkPv…WX5sTEz 2 weeks ago │
│ ↑ Revision 9b4da63 @ 88bf2a9..a08e438 by ade z6MkwGo…yS2aagA 1 week ago │
│ ↑ Revision 10b20f0 @ ee17109..a9331fd by fintohaps z6Mkire…SQZ3voM 5 days ago │
│ ↑ Revision 051d029 @ ee17109..4e542eb by fintohaps z6Mkire…SQZ3voM 5 days ago │
│ ↑ Revision ac58e4a @ ee17109..a986a29 by ade z6MkwGo…yS2aagA 18 hours ago │
│ ↑ Revision a7788e5 @ ee17109..fb80d58 by lorenz z6MkkPv…WX5sTEz 45 seconds ago │
╰─────────────────────────────────────────────────────────────────────────────────────────────────╯
commit fb80d58af750d525fc2bd8081e5612a3c2726d4c
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Fri Jul 3 19:10:46 2026 +0100
CHANGELOG: Describe the changes to repository identity evaluation
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 58f151582..621da8679 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,67 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
## [Unreleased]
+## Repository Identity Evaluation
+
+The limitations of evaluating repository identities were found on multiple
+repositories, including the `heartwood` repository. This prompted a review of
+the evaluation logic, which resulted in several improvements.
+
+The bulk of the improvements come from two aspects in the evaluation. The first
+is keeping track of the parent and children relationship of revisions. The
+second is having a richer model of a revision's state.
+
+Every revision (except the initial revision which is created during `rad init`)
+explicitly refers to a parent revision. This is similar to Git commits, which
+usually refer to one parent. Similarly, root commits do not refer to any parent,
+and merge commits refer to multiple parents. For repository identity, merges
+are not possible. This gives the first relation of interest: We say that two
+revisions `A` and `B` are in relation "parent" if `A` refers to `B` explicitly
+as its parent. The inverse relation is called "child". The transitive closure
+of "parent" is called "ancestor" and the transitive closure of "child" is called
+"descendant". Further, we say that two revisions `A` and `B` are in relation
+"sibling" if they are both in relation "parent" with the same revision `C`.
+
+With these relationships in mind, a revision can now be in one of four states:
+1. *Active*: this is the initial state of any revision when it is proposed. The
+ proposal is waiting for delegates to accept or reject it. Or alternatively,
+ the revision can be redacted.
+ A revision will remain active, even if it has a majority of accepted votes,
+ if its parent is still active.
+2. *Accepted*: the revision was accepted by a majority of delegates. The
+ revision can no longer be rejected nor redacted.
+ When a revision is accepted, its children are also evaluated, recursively, to
+ see if they also have reached a majority.
+3. *Rejected*: there are now three variants of rejection for a revision:
+ a. The revision was directly rejected by a majority of the delegates, by them
+ casting their rejection votes.
+ b. The parent of the revision was rejected, and thus this revision was
+ transitively rejected.
+ c. A sibling of the revision was accepted, and thus this revision (and all
+ other siblings) are rejected.
+4. *Redacted*: there are two variants of redaction for a revision:
+ a. The author explicitly redacted (withdrew) the revision.
+ b. The parent of the revision was redacted, and thus this revision was
+ transitively redacted.
+
+This modeling of revisions ensures that the evaluation of the state remains
+consistent, and accounts for the previous cases we had come across in the wild.
+
+The final ingredient that was added ensures that the evaluation remains
+consistent when it involves delegates accepting a revision. A delegate can only
+accept a revision if they have not accepted any other active revision that is a
+sibling of the revision they are voting on.
+This prevents scenarios such as Alice creating and accepting two revisions `A`
+and `B`, and Bob and Eve accepting each respectively. Both revisions would then
+reach majority, but the evaluation would pick one arbitrarily based on the
+topological sort of the COB graph. However, with the above condition in place,
+this cannot happen.
+
+We will note that we found an inconsistency where the concurrent operations
+"redact" and "accept" will produce a different identity document depending on
+which is ordered first. Further analysis of the ordering of pairs of actions is
+required, but is left to future work.
+
## Improvements
- `rad patch list` includes a `Labels` column, showing any assigned labels to
commit 2f1aaa45b2657d51ef5683f2acc86e050c268d51
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Thu Jul 2 16:43:09 2026 +0000
radicle/cob/identity: Add sibling-accept invariant to property tests
diff --git a/crates/radicle/src/cob/identity/test/property.rs b/crates/radicle/src/cob/identity/test/property.rs
index 7d313c263..3e79d0965 100644
--- a/crates/radicle/src/cob/identity/test/property.rs
+++ b/crates/radicle/src/cob/identity/test/property.rs
@@ -540,6 +540,7 @@ impl Harness {
self.assert_failed_parents_have_failed_children(identity);
self.assert_rejection_reasons_are_accurate(identity);
self.assert_verdicts_match_parent_delegates(identity);
+ self.assert_no_duplicate_sibling_accepts(identity);
}
/// Strong eventual consistency.
@@ -962,4 +963,60 @@ impl Harness {
}
}
}
+
+ /// No delegate has Accept verdicts on two Active siblings.
+ ///
+ /// A delegate may hold at most one Accept across all Active children of
+ /// the same parent. If two siblings both accumulate majority accepts, the
+ /// `adopt()` function could encounter an already-rejected revision during
+ /// re-evaluation, which would violate internal assumptions.
+ ///
+ /// PASS:
+ /// [Parent] → [Child A: Alice accepts] [Child B: Bob accepts]
+ ///
+ /// FAIL:
+ /// [Parent] → [Child A: Alice accepts] [Child B: Alice accepts]
+ fn assert_no_duplicate_sibling_accepts(&self, identity: &Identity) {
+ for id in &identity.timeline {
+ let Some(rev) = identity.revision(id) else {
+ continue;
+ };
+ if !rev.is_active() {
+ continue;
+ }
+ let Some(parent_id) = rev.parent else {
+ continue;
+ };
+
+ for (voter_key, verdict) in rev.verdicts() {
+ if !matches!(verdict, cob::identity::Verdict::Accept(_)) {
+ continue;
+ }
+ let voter_did = Did::from(*voter_key);
+
+ // Check that no Active sibling also has an accept from this voter.
+ for sibling_id in identity
+ .revision(&parent_id)
+ .map(|p| &p.children)
+ .into_iter()
+ .flatten()
+ {
+ if sibling_id == id {
+ continue;
+ }
+ if let Some(sibling) = identity.revision(sibling_id)
+ && sibling.is_active()
+ {
+ assert!(
+ !sibling.accepted().any(|did| did == voter_did),
+ "Delegate {} has Accept verdicts on two active siblings: {} and {}",
+ voter_did,
+ id,
+ sibling_id,
+ );
+ }
+ }
+ }
+ }
+ }
}
commit a63f91885f91de789e4aa7c5a053b777eed03343
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Thu Jul 2 16:40:51 2026 +0000
radicle/cob/identity: Guard `IdentityMut::update` against sibling proposals
Ensure that the `IdentityMut::update` API returns an error when it encounters an
active, sibling revision by the same delegate.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 9817144d4..b083564fb 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1226,13 +1226,29 @@ where
}
/// Update the identity by proposing a new revision.
- /// If the signer is the only delegate, the revision is accepted automatically.
+ ///
+ /// If the signer is the only delegate, the revision is adopted automatically.
+ ///
+ /// # Errors
+ ///
+ /// [`SiblingAccepted`]: If the delegate has already accepted an active
+ /// revision that shares the same parent as the provided `revision`.
+ ///
+ /// [`SiblingAccepted`]: ApplyError::SiblingAccepted
pub fn update(
&mut self,
title: cob::Title,
description: impl ToString,
doc: &Doc,
) -> Result<RevisionId, Error> {
+ #[allow(deprecated)]
+ let did: Did = self.store.signer().verifying_key().into();
+ if let Some(revision_id) = self.has_active_sibling_accept(&self.current, &did) {
+ return Err(Error::Apply(ApplyError::SiblingAccepted {
+ revision: revision_id,
+ }));
+ }
+
let parent = Some(self.current);
#[allow(deprecated)]
@@ -1440,6 +1456,10 @@ mod test {
let r2 = bob_identity.revision(&r2).unwrap();
assert_eq!(r2.state, State::Rejected(RejectedBy::Vote));
+ // Reload so Alice sees r2 is rejected (no longer Active).
+ // This allows her to propose a new sibling.
+ identity.reload().unwrap();
+
// Now let's add another delegate.
doc.delegate(eve.public_key().into());
let r3 = identity
@@ -3168,4 +3188,53 @@ mod test {
"Expected SiblingAccepted error, got: {err:?}"
);
}
+
+ /// The `update()` API rejects a second proposal if the delegate already
+ /// has an accept on an Active sibling (child of current).
+ #[test]
+ fn update_rejects_second_sibling_proposal() {
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ let _a1 = alice_identity
+ .update(
+ cob::Title::new("Add Bob").unwrap(),
+ "",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ // Alice proposes first child.
+ let mut doc1 = alice_identity.doc().clone().edit();
+ doc1.visibility = Visibility::private([]);
+ let _child1 = alice_identity
+ .update(
+ cob::Title::new("Child 1").unwrap(),
+ "",
+ &doc1.verified().unwrap(),
+ )
+ .unwrap();
+
+ // Alice tries to propose a second child (sibling) — should fail.
+ let mut doc2 = alice_identity.doc().clone().edit();
+ doc2.visibility = Visibility::private([alice.signer.public_key().into()]);
+ let err = alice_identity
+ .update(
+ cob::Title::new("Child 2").unwrap(),
+ "",
+ &doc2.verified().unwrap(),
+ )
+ .unwrap_err();
+
+ assert!(
+ std::iter::successors(Some(&err as &dyn std::error::Error), |e| e.source())
+ .filter_map(|e| e.downcast_ref::<ApplyError>())
+ .any(|e| matches!(e, ApplyError::SiblingAccepted { .. })),
+ "Expected SiblingAccepted error, got: {err:?}"
+ );
+ }
}
diff --git a/crates/radicle/src/cob/identity/test/property.rs b/crates/radicle/src/cob/identity/test/property.rs
index 792229982..7d313c263 100644
--- a/crates/radicle/src/cob/identity/test/property.rs
+++ b/crates/radicle/src/cob/identity/test/property.rs
@@ -223,7 +223,14 @@ impl Harness {
Ok(rev) => self.revisions.push(rev),
Err(e)
if Self::has_apply_error(&e, |err| {
- matches!(err, cob::identity::ApplyError::DocUnchanged)
+ matches!(
+ err,
+ cob::identity::ApplyError::DocUnchanged
+ // An `actor` for the above `update` could attempt
+ // to create active, sibling revisions which is
+ // disallowed.
+ | cob::identity::ApplyError::SiblingAccepted { .. }
+ )
}) => {}
Err(e) => {
panic!("Delegate action should succeed, but failed with: {:?}", e)
commit b6f07074d9198bdbf60f49af61ac6416397edb46
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Thu Jul 2 16:37:41 2026 +0000
radicle/cob/identity: Guard `IdentityMut::accept` against sibling accepts
Ensure that the `IdentityMut::accept` API returns an error when it encounters an
active, sibling revision by the same delegate.
diff --git a/crates/radicle-cli/src/commands/id.rs b/crates/radicle-cli/src/commands/id.rs
index 27fc3f139..5af4fb60b 100644
--- a/crates/radicle-cli/src/commands/id.rs
+++ b/crates/radicle-cli/src/commands/id.rs
@@ -501,7 +501,7 @@ fn on_apply_err(e: &identity::ApplyError, profile: &Profile) -> anyhow::Error {
| e @ radicle::cob::identity::ApplyError::MissingParent
| e @ radicle::cob::identity::ApplyError::DuplicateVerdict
| e @ radicle::cob::identity::ApplyError::UnexpectedState
- | e @ radicle::cob::identity::ApplyError::SiblingAccepted
+ | e @ radicle::cob::identity::ApplyError::SiblingAccepted { .. }
| e @ radicle::cob::identity::ApplyError::DocUnchanged
| e @ radicle::cob::identity::ApplyError::Git(_)
| e @ radicle::cob::identity::ApplyError::Doc(_)
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index aec695750..9817144d4 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1248,10 +1248,27 @@ where
}
/// Accept an active revision.
+ ///
+ /// # Errors
+ ///
+ /// [`SiblingAccepted`]: If the delegate has already accepted an active
+ /// revision that shares the same parent as the provided `revision`.
+ ///
+ /// [`SiblingAccepted`]: ApplyError::SiblingAccepted
pub fn accept(&mut self, revision: &RevisionId) -> Result<EntryId, Error> {
let id = *revision;
let revision = self.revision(revision).ok_or(Error::NotFound(id))?;
+ if let Some(parent_id) = revision.parent {
+ #[allow(deprecated)]
+ let did: Did = self.store.signer().verifying_key().into();
+ if let Some(revision_id) = self.has_active_sibling_accept(&parent_id, &did) {
+ return Err(Error::Apply(ApplyError::SiblingAccepted {
+ revision: revision_id,
+ }));
+ }
+ }
+
#[allow(deprecated)]
let signature = revision.sign(self.store.signer())?;
@@ -3079,4 +3096,76 @@ mod test {
State::Active
);
}
+
+ /// The `accept()` API rejects an accept if the delegate already
+ /// accepted an Active sibling.
+ #[test]
+ fn accept_rejects_sibling_accept() {
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+ let eve = &network.eve;
+ let dave = &network.dave;
+
+ // 4 delegates, majority = 3. This ensures Alice's accept of child_a
+ // doesn't immediately adopt it (Bob + Alice = 2 < 3).
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ alice_doc.delegate(eve.signer.public_key().into());
+ alice_doc.delegate(dave.signer.public_key().into());
+ let _a0 = alice_identity
+ .update(
+ cob::Title::new("Add delegates").unwrap(),
+ "",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ // Bob proposes child_a.
+ bob.repo.fetch(alice);
+ let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
+ let mut bob_doc = bob_identity.doc().clone().edit();
+ bob_doc.visibility = Visibility::private([]);
+ let child_a = bob_identity
+ .update(
+ cob::Title::new("Child A").unwrap(),
+ "",
+ &bob_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ // Eve proposes child_b (sibling of child_a).
+ eve.repo.fetch(alice);
+ let mut eve_identity = Identity::load_mut(&*eve.repo, &eve.signer).unwrap();
+ let mut eve_doc = eve_identity.doc().clone().edit();
+ eve_doc.visibility = Visibility::private([eve.signer.public_key().into()]);
+ let child_b = eve_identity
+ .update(
+ cob::Title::new("Child B").unwrap(),
+ "",
+ &eve_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ // Alice fetches both and accepts child_a.
+ // child_a stays Active (Bob + Alice = 2/3, needs 3).
+ alice.repo.fetch(bob);
+ alice.repo.fetch(eve);
+ alice_identity.reload().unwrap();
+ alice_identity.accept(&child_a).unwrap();
+ assert_eq!(
+ alice_identity.revision(&child_a).unwrap().state,
+ State::Active
+ );
+
+ // Alice tries to accept child_b — should fail.
+ let err = alice_identity.accept(&child_b).unwrap_err();
+ assert!(
+ std::iter::successors(Some(&err as &dyn std::error::Error), |e| e.source())
+ .filter_map(|e| e.downcast_ref::<ApplyError>())
+ .any(|e| matches!(e, ApplyError::SiblingAccepted { .. })),
+ "Expected SiblingAccepted error, got: {err:?}"
+ );
+ }
}
diff --git a/crates/radicle/src/cob/identity/test/property.rs b/crates/radicle/src/cob/identity/test/property.rs
index 15821f367..792229982 100644
--- a/crates/radicle/src/cob/identity/test/property.rs
+++ b/crates/radicle/src/cob/identity/test/property.rs
@@ -313,6 +313,10 @@ impl Harness {
Self::has_apply_error(&e, |err| matches!(
err,
cob::identity::ApplyError::DuplicateVerdict
+ // An `actor` for the above `accept` could have
+ // accepted an already active, sibling revision
+ // which is disallowed.
+ | cob::identity::ApplyError::SiblingAccepted { .. }
)),
"Delegate accept failed with unexpected error: {e:?}"
),
commit 7daeb3135b9a264e71b631b6896339bea7784590
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Thu Jul 2 16:27:06 2026 +0000
radicle/cob/identity: Add SiblingAccepted error variant
Add an `ApplyError` for variant, `SiblingAccepted`, to use to enforce the new
invariant: delegates must not accept active, sibling revisions.
diff --git a/crates/radicle-cli/src/commands/id.rs b/crates/radicle-cli/src/commands/id.rs
index 3fc9df01f..27fc3f139 100644
--- a/crates/radicle-cli/src/commands/id.rs
+++ b/crates/radicle-cli/src/commands/id.rs
@@ -501,6 +501,7 @@ fn on_apply_err(e: &identity::ApplyError, profile: &Profile) -> anyhow::Error {
| e @ radicle::cob::identity::ApplyError::MissingParent
| e @ radicle::cob::identity::ApplyError::DuplicateVerdict
| e @ radicle::cob::identity::ApplyError::UnexpectedState
+ | e @ radicle::cob::identity::ApplyError::SiblingAccepted
| e @ radicle::cob::identity::ApplyError::DocUnchanged
| e @ radicle::cob::identity::ApplyError::Git(_)
| e @ radicle::cob::identity::ApplyError::Doc(_)
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index a833bb075..aec695750 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -122,6 +122,8 @@ pub enum ApplyError {
DuplicateVerdict,
#[error("revision is in an unexpected state")]
UnexpectedState,
+ #[error("delegate already accepted a sibling revision '{revision}'")]
+ SiblingAccepted { revision: RevisionId },
#[error("document does not contain any changes to current identity")]
DocUnchanged,
#[error("git: {0}")]
commit 654218e6a56251a09de0f8924119645d62030232
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Thu Jul 2 17:16:18 2026 +0100
radicle/cob/identity: Strip implicit author accept for sibling revisions in `action`
When a delegate creates a new `Revision`, their signature is implicitly added to the revision.
Prevent the delegate from an accept verdict on two active, sibling revisions by:
1. Checking that the `state` is `Active`, and then checking `has_active_sibling_accept`
2. If there is an existing verdict, then it the verdict from the new revision is stripped.
The creation of the `Revision` must still happen, as opposed to throwing an
error, in case of existing histories.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 0e290ba97..a833bb075 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -696,6 +696,14 @@ impl Identity {
State::Active => State::Active,
};
+ // Check BEFORE inserting the new revision, so it doesn't count
+ // as its own sibling. If the author already has an accept on an
+ // Active sibling, their implicit author accept will be stripped
+ // after creation.
+ let should_strip_author_accept = matches!(state, State::Active)
+ .then(|| self.has_active_sibling_accept(&parent_id, &did))
+ .flatten();
+
let revision = Revision::new(
id,
title,
@@ -712,6 +720,14 @@ impl Identity {
self.revisions.insert(id, revision);
self.revision_mut(&parent_id)?.children.push(id);
+ if let Some(revision_id) = should_strip_author_accept {
+ log::debug!(
+ "Stripping implicit accept from revision {id} by {did}: \
+ already accepted the active revision {revision_id}.",
+ );
+ self.revision_mut(&id)?.verdicts.remove(&author);
+ }
+
if state == State::Active {
self.adopt(id);
}
@@ -2986,4 +3002,79 @@ mod test {
"Alice's accept on child_a should have been skipped (she already accepted sibling child_b)"
);
}
+
+ /// When replaying an old history where a delegate created two sibling
+ /// revisions, the second revision's implicit author accept is stripped.
+ #[test]
+ fn evaluation_strips_author_accept_for_sibling_creation() {
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ let _a1 = alice_identity
+ .update(
+ cob::Title::new("Add Bob").unwrap(),
+ "",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ // Alice proposes first child (gets implicit accept).
+ let mut doc1 = alice_identity.doc().clone().edit();
+ doc1.visibility = Visibility::private([]);
+ let child1 = alice_identity
+ .update(
+ cob::Title::new("Child 1").unwrap(),
+ "",
+ &doc1.clone().verified().unwrap(),
+ )
+ .unwrap();
+
+ // Alice proposes second child via transaction (simulating old history).
+ let mut doc2 = doc1.clone();
+ doc2.visibility = Visibility::private([alice.signer.public_key().into()]);
+ let current = alice_identity.current;
+ let child2 = alice_identity
+ .transaction("Child 2", |tx, repo| {
+ *tx = Transaction::new_revision(
+ cob::Title::new("Child 2").unwrap(),
+ "",
+ &doc2.verified().unwrap(),
+ Some(current),
+ repo,
+ &alice.signer,
+ )?;
+ Ok(())
+ })
+ .unwrap();
+
+ let alice_did: Did = alice.signer.public_key().into();
+
+ // child1 has Alice's accept (she was the first to propose under this parent).
+ assert!(
+ alice_identity
+ .revision(&child1)
+ .unwrap()
+ .accepted()
+ .any(|did| did == alice_did),
+ "child1 should have Alice's accept"
+ );
+ // child2's implicit accept was stripped because Alice already accepted child1.
+ assert!(
+ !alice_identity
+ .revision(&child2)
+ .unwrap()
+ .accepted()
+ .any(|did| did == alice_did),
+ "child2 should NOT have Alice's accept"
+ );
+ // child2 still exists and is Active (just has 0 accept votes).
+ assert_eq!(
+ alice_identity.revision(&child2).unwrap().state,
+ State::Active
+ );
+ }
}
commit 82dc3fe20c5328b606031ed186b9fea2dad81ddc
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Thu Jul 2 16:08:45 2026 +0000
radicle/cob/identity: Enforce sibling-accept invariant for `RevisionAccept` in `action`
On `Action::RevisionAccept` use `has_active_sibling_accept` to check for a sibling accept.
If one is found, the `RevisionAccept` is logged and skipped.
This preserves the invariant of a single accept per delegate on active, sibling
revisions without throwing an error on existing histories.
diff --git a/crates/radicle-cli/examples/rad-id-conflict.md b/crates/radicle-cli/examples/rad-id-conflict.md
index b43fe5915..94c06057d 100644
--- a/crates/radicle-cli/examples/rad-id-conflict.md
+++ b/crates/radicle-cli/examples/rad-id-conflict.md
@@ -43,24 +43,24 @@ $ rad id list
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
```
-This isn't a problem as long as we don't try to accept both. So let's accept
-Bob's:
+This isn't a problem as long as we don't try to accept both. Alice decides to
+go with Bob's proposal, so she redacts her own first and then accepts his:
``` ~alice
+$ rad id redact 12d7300 -q
$ rad id accept 89b2623 -q
$ rad id list
╭────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ● ID Title Author Status Created Parent │
├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ ● 89b2623 Edit project name bob z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk accepted now 0ca42d3 │
-│ ● 12d7300 Edit project name alice (you) rejected now 0ca42d3 │
│ ● 0ca42d3 Add Bob alice (you) accepted now 0656c21 │
│ ● 0656c21 Initial revision alice (you) accepted now none │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
```
-Doing so voided the other conflicting revision, and it can no longer be
-accepted now.
+Alice's revision was redacted and is no longer visible. Bob syncs and sees
+that the conflict is resolved:
``` ~bob
$ rad sync --fetch rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji
@@ -69,40 +69,6 @@ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from the network, found 1 potential s
🌱 Fetched from z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi
```
``` ~bob (fail)
-$ rad id accept 12d7300 -q
-✗ Error: cannot vote on revision that is rejected
-$ rad id reject 12d7300 -q
-✗ Error: cannot vote on revision that is rejected
-```
-``` ~bob
$ rad id show 12d7300
-╭────────────────────────────────────────────────────────────────────────╮
-│ Title Edit project name │
-│ Revision 12d7300d1bbba84e4e5760c8c61999bf5fefb81a │
-│ Parent 0ca42d376bd566631083c8913cf86bec722da392 │
-│ Blob e93aa3e3c5c448bacd3537a81daf1437eccd046a │
-│ Author did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi │
-│ State rejected │
-│ Quorum no │
-├────────────────────────────────────────────────────────────────────────┤
-│ ✓ did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi alice │
-│ ? did:key:z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk bob (you) │
-╰────────────────────────────────────────────────────────────────────────╯
-
-@@ -1,14 +1,14 @@
- {
- "payload": {
- "xyz.radicle.project": {
- "defaultBranch": "master",
- "description": "Radicle Heartwood Protocol & Stack",
-- "name": "heartwood"
-+ "name": "heart"
- }
- },
- "delegates": [
- "did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi",
- "did:key:z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk"
- ],
- "threshold": 2
- }
+✗ Error: revision `12d7300d1bbba84e4e5760c8c61999bf5fefb81a` not found
```
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 43b5090cd..0e290ba97 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -522,8 +522,10 @@ impl Identity {
);
}
State::Active => {
- let parent = revision.parent.ok_or(ApplyError::MissingParent)?;
- let parent = self.revision(&parent).ok_or(ApplyError::Missing(parent))?;
+ let parent_id = revision.parent.ok_or(ApplyError::MissingParent)?;
+ let parent = self
+ .revision(&parent_id)
+ .ok_or(ApplyError::Missing(parent_id))?;
if !parent.is_delegate(&did) {
return Err(ApplyError::non_delegate_unauthorized(did, &action));
@@ -533,6 +535,21 @@ impl Identity {
match action {
Action::RevisionAccept { signature, .. } => {
+ // A delegate may only accept one Active child
+ // of a given parent. If they already accepted a
+ // sibling, silently skip this vote.
+ // This handles old histories where the
+ // invariant was not enforced.
+ if let Some(revision_id) =
+ self.has_active_sibling_accept(&parent_id, &did)
+ {
+ log::debug!(
+ "Skipping accept of {id} by {did}: \
+ already accepted an active revision '{revision_id}'.",
+ );
+ return Ok(());
+ }
+
parent
.verify_signature(&author, &signature, revision.blob)
.map_err(|_source| {
@@ -1486,14 +1503,15 @@ mod test {
assert_eq!(bob_identity.revision(&a2).unwrap().state, State::Active);
assert_eq!(bob_identity.revision(&b1).unwrap().state, State::Active);
- // Now Bob accepts Alice's proposal. This voids his own.
+ // Bob must redact his revision, before he accepts Alice's proposal.
+ bob_identity.redact(b1).unwrap();
bob_identity.accept(&a2).unwrap();
assert_eq!(bob_identity.current, a2);
assert_eq!(bob_identity.revision(&a1).unwrap().state, State::Accepted);
assert_eq!(bob_identity.revision(&a2).unwrap().state, State::Accepted);
assert_eq!(
bob_identity.revision(&b1).unwrap().state,
- State::Rejected(RejectedBy::Sibling(a2))
+ State::Redacted(RedactedBy::Author)
);
}
@@ -2895,4 +2913,77 @@ mod test {
None
);
}
+
+ /// Old histories may contain a delegate explicitly accepting two
+ /// siblings. The evaluation layer must handle this gracefully by
+ /// silently skipping the second accept — the vote must not be recorded.
+ #[test]
+ fn evaluation_skips_sibling_accept_in_old_history() {
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ let _a1 = alice_identity
+ .update(
+ cob::Title::new("Add Bob").unwrap(),
+ "",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ // Bob proposes child_a (gets implicit accept).
+ bob.repo.fetch(alice);
+ let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
+ let mut bob_doc = bob_identity.doc().clone().edit();
+ bob_doc.visibility = Visibility::private([]);
+ let child_a = bob_identity
+ .update(
+ cob::Title::new("Child A").unwrap(),
+ "",
+ &bob_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ // Alice proposes child_b (sibling, gets implicit accept).
+ let mut alice_doc2 = alice_identity.doc().clone().edit();
+ alice_doc2.visibility = Visibility::private([alice.signer.public_key().into()]);
+ let _child_b = alice_identity
+ .update(
+ cob::Title::new("Child B").unwrap(),
+ "",
+ &alice_doc2.verified().unwrap(),
+ )
+ .unwrap();
+
+ // Alice fetches Bob's child_a and explicitly accepts it
+ // (simulating old history — she already has an accept on child_b).
+ alice.repo.fetch(bob);
+ alice_identity.reload().unwrap();
+
+ // Use transaction to bypass the API guard (simulating old history).
+ let sig = alice_identity
+ .revision(&child_a)
+ .unwrap()
+ .sign(&alice.signer)
+ .unwrap();
+ alice_identity
+ .transaction("Accept child_a", |tx, _| tx.accept(child_a, sig))
+ .unwrap();
+
+ let alice_did: Did = alice.signer.public_key().into();
+
+ // Alice's accept on child_a should be skipped because she already
+ // has an accept on the Active sibling child_b.
+ assert!(
+ !alice_identity
+ .revision(&child_a)
+ .unwrap()
+ .accepted()
+ .any(|did| did == alice_did),
+ "Alice's accept on child_a should have been skipped (she already accepted sibling child_b)"
+ );
+ }
}
commit 8e677a9d90f10f916b6424c57b450222ed8f5ac6
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Thu Jul 2 10:37:41 2026 +0100
radicle/cob/identity: Add has_active_sibling_accept helper
Add a helper method to check if a delegate has already voted on a sibling
revision.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index bb3bb7afa..43b5090cd 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -363,6 +363,32 @@ impl Identity {
.into_iter()
.flatten()
}
+
+ /// Checks if the `delegate` has already accepted any child of the provided
+ /// `parent`.
+ ///
+ /// The [`RevisionId`] is returned if one was found.
+ ///
+ /// Used to enforce the invariant that no two sibling, active [`Revision`]s
+ /// should have an accepted vote from the same delegate.
+ pub(crate) fn has_active_sibling_accept(
+ &self,
+ parent: &RevisionId,
+ delegate: &Did,
+ ) -> Option<RevisionId> {
+ self.children_of(parent).find_map(|child_id| {
+ self.revision(child_id).and_then(|child| {
+ if child.is_active() {
+ child
+ .accepted()
+ .any(|did| did == *delegate)
+ .then_some(*child_id)
+ } else {
+ None
+ }
+ })
+ })
+ }
}
impl store::Cob for Identity {
@@ -2825,4 +2851,48 @@ mod test {
"Dave should be unauthorized because he was removed in the parent (A₂). Actual error: {err:?}"
);
}
+
+ #[test]
+ fn has_active_sibling_accept_returns_true_when_sibling_accepted() {
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+
+ // Setup: Alice adds Bob as delegate.
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ let _a1 = alice_identity
+ .update(
+ cob::Title::new("Add Bob").unwrap(),
+ "",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ // Alice proposes a revision (child of current). Alice has an implicit accept.
+ let mut doc1 = alice_identity.doc().clone().edit();
+ doc1.visibility = Visibility::private([]);
+ let child = alice_identity
+ .update(
+ cob::Title::new("Child 1").unwrap(),
+ "",
+ &doc1.verified().unwrap(),
+ )
+ .unwrap();
+
+ let alice_did: Did = alice.signer.public_key().into();
+
+ // Alice has an accept on an Active child of current → true.
+ assert_eq!(
+ alice_identity.has_active_sibling_accept(&alice_identity.current, &alice_did),
+ Some(child)
+ );
+ // Bob does not → false.
+ let bob_did: Did = bob.signer.public_key().into();
+ assert_eq!(
+ alice_identity.has_active_sibling_accept(&alice_identity.current, &bob_did),
+ None
+ );
+ }
}
commit 62f64744ad1e0b5c0198e1ebe1e602f6344dac11
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Thu Jun 25 13:17:23 2026 +0000
radicle/cob/identity: Test accept-before-redact convergence
Companion to the redact-vs-accept test, with reversed timestamp ordering so
accept wins.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index a558ead24..bb3bb7afa 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -2365,6 +2365,70 @@ mod test {
assert_eq!(alice_identity.current, a1);
}
+ /// Companion to `concurrent_redact_and_accept_converge`: here Bob
+ /// acts first (earlier timestamp) and Alice redacts second (later
+ /// timestamp). The accept is processed first and wins.
+ #[test]
+ fn concurrent_accept_before_redact_converge() {
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ let _a1 = alice_identity
+ .update(
+ cob::Title::new("A₁").unwrap(),
+ "Add Bob",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ let mut alice_doc2 = alice_identity.doc().clone().edit();
+ alice_doc2.visibility = Visibility::private([]);
+ let a2 = alice_identity
+ .update(
+ cob::Title::new("A₂").unwrap(),
+ "",
+ &alice_doc2.verified().unwrap(),
+ )
+ .unwrap();
+
+ bob.repo.fetch(alice);
+
+ // Bob accepts FIRST (earlier timestamp).
+ let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
+ let _b1 = cob::stable::with_advanced_timestamp(|| bob_identity.accept(&a2).unwrap());
+
+ // Alice redacts SECOND (later timestamp).
+ let _a3 = cob::stable::with_advanced_timestamp(|| alice_identity.redact(a2).unwrap());
+
+ // Sync both directions.
+ bob.repo.fetch(alice);
+ bob_identity.reload().unwrap();
+
+ alice.repo.fetch(bob);
+ alice_identity.reload().unwrap();
+
+ // Both must agree.
+ assert_eq!(
+ alice_identity.revision(&a2).unwrap().state,
+ bob_identity.revision(&a2).unwrap().state,
+ "Alice and Bob must agree on A₂'s state"
+ );
+ assert_eq!(
+ alice_identity.current, bob_identity.current,
+ "Alice and Bob must agree on the current revision"
+ );
+
+ // The accept (earlier timestamp) is processed first.
+ // A₂ reaches 2/2 votes → Accepted. Current becomes A₂.
+ // Then the redaction is processed: A₂ is Accepted (not Active) → skipped.
+ assert_eq!(alice_identity.revision(&a2).unwrap().state, State::Accepted);
+ assert_eq!(alice_identity.current, a2);
+ }
+
#[test]
fn test_valid_identity() {
let tempdir = tempfile::tempdir().unwrap();
commit f720526fc9fd457461d6d440b2742355b9df0020
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Thu Jun 25 13:14:16 2026 +0000
radicle/cob/identity: Test concurrent redact-vs-accept convergence
Verifies that when Alice redacts a revision and Bob concurrently
accepts it, both nodes converge after sync. The CRDT evaluation
order (timestamp-based) determines which operation takes effect.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index b0fe37f83..a558ead24 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -2281,6 +2281,90 @@ mod test {
assert_eq!(alice_identity.current, a2);
}
+ /// When Alice redacts a revision and Bob concurrently accepts it,
+ /// the outcome depends on CRDT evaluation order (timestamp-based).
+ /// Regardless of which node syncs first, both must converge.
+ #[test]
+ fn concurrent_redact_and_accept_converge() {
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+
+ // Setup: Alice adds Bob as delegate. A₁ is auto-accepted (1/1 votes).
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ let a1 = alice_identity
+ .update(
+ cob::Title::new("A₁").unwrap(),
+ "Add Bob",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+ assert_eq!(alice_identity.current, a1);
+
+ // Alice proposes A₂. With 2 delegates, needs 2/2 votes. Stays Active.
+ let mut alice_doc2 = alice_identity.doc().clone().edit();
+ alice_doc2.visibility = Visibility::private([]);
+ let a2 = alice_identity
+ .update(
+ cob::Title::new("A₂").unwrap(),
+ "",
+ &alice_doc2.verified().unwrap(),
+ )
+ .unwrap();
+
+ // Bob fetches and sees A₂.
+ bob.repo.fetch(alice);
+
+ // Concurrent actions (no sync between them):
+ // Alice redacts A₂ (timestamp T).
+ let _a3 = cob::stable::with_advanced_timestamp(|| alice_identity.redact(a2).unwrap());
+
+ // Bob accepts A₂ (timestamp T+1, later than Alice's redaction).
+ let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
+ let _b1 = cob::stable::with_advanced_timestamp(|| bob_identity.accept(&a2).unwrap());
+
+ // Before sync: each node has a different local view.
+ // Alice: A₂ is Redacted(Author), current = A₁.
+ assert_eq!(
+ alice_identity.revision(&a2).unwrap().state,
+ State::Redacted(RedactedBy::Author)
+ );
+ assert_eq!(alice_identity.current, a1);
+
+ // Bob: A₂ is Accepted (2/2 votes locally), current = A₂.
+ assert_eq!(bob_identity.revision(&a2).unwrap().state, State::Accepted);
+ assert_eq!(bob_identity.current, a2);
+
+ // Now sync: Bob fetches Alice, Alice fetches Bob.
+ bob.repo.fetch(alice);
+ bob_identity.reload().unwrap();
+
+ alice.repo.fetch(bob);
+ alice_identity.reload().unwrap();
+
+ // After sync: both must agree.
+ // The redaction (earlier timestamp) is processed before the accept.
+ // When the accept is processed, A₂ is already Redacted → accept is skipped.
+ assert_eq!(
+ alice_identity.revision(&a2).unwrap().state,
+ bob_identity.revision(&a2).unwrap().state,
+ "Alice and Bob must agree on A₂'s state"
+ );
+ assert_eq!(
+ alice_identity.current, bob_identity.current,
+ "Alice and Bob must agree on the current revision"
+ );
+
+ // The redaction wins (earlier timestamp), so current reverts to A₁.
+ assert_eq!(
+ alice_identity.revision(&a2).unwrap().state,
+ State::Redacted(RedactedBy::Author)
+ );
+ assert_eq!(alice_identity.current, a1);
+ }
+
#[test]
fn test_valid_identity() {
let tempdir = tempfile::tempdir().unwrap();
commit 21700e4962c0541043ceba7ee37a777eeaceafed
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Thu Jun 25 13:11:11 2026 +0000
radicle/cob/identity: Fix cascading_rejections test to test actual cascading
The test previously had B2 as a sibling of B1 (both children of A1),
because update() always uses self.current as parent. This meant
the test was testing multi-sibling rejection, not cascading.
Now B2 is a child of B1 via a manual transaction, so when B1 is
rejected (sibling E1 accepted), B2 is rejected via RejectedBy::Parent
(cascade), which is what the test name promises.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 4e663a80c..b0fe37f83 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1931,6 +1931,7 @@ mod test {
bob.repo.fetch(alice);
eve.repo.fetch(alice);
+ // Bob proposes B1 (child of A1, the current revision).
let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
let mut bob_doc = bob_identity.doc().clone().edit();
bob_doc.visibility = Visibility::private([]);
@@ -1942,16 +1943,26 @@ mod test {
)
.unwrap();
- let bob_doc2 = bob_doc.clone();
- bob_doc.visibility = Visibility::Public;
+ // Bob proposes B2 as a **child of B1** (not A1).
+ // We use a manual transaction to set B1 as the parent, since `update()`
+ // always uses `self.current` (= A1, because B1 hasn't been accepted).
+ let mut bob_doc2 = bob_doc.clone();
+ bob_doc2.visibility = Visibility::private([bob.signer.public_key().into()]);
let b2 = bob_identity
- .update(
- cob::Title::new("B2").unwrap(),
- "",
- &bob_doc2.verified().unwrap(),
- )
+ .transaction("B2", |tx, repo| {
+ *tx = Transaction::new_revision(
+ cob::Title::new("B2").unwrap(),
+ "",
+ &bob_doc2.verified().unwrap(),
+ Some(b1),
+ repo,
+ &bob.signer,
+ )?;
+ Ok(())
+ })
.unwrap();
+ // Eve proposes E1 (child of A1, sibling of B1).
let mut eve_identity = Identity::load_mut(&*eve.repo, &eve.signer).unwrap();
let mut eve_doc = eve_identity.doc().clone().edit();
eve_doc.visibility = Visibility::private([eve.signer.public_key().into()]);
@@ -1963,18 +1974,20 @@ mod test {
)
.unwrap();
+ // Alice accepts E1 → E1 reaches 2/3 → adopted.
alice.repo.fetch(eve);
alice_identity.reload().unwrap();
alice_identity.accept(&e1).unwrap();
+ // Eve syncs with everyone.
eve.repo.fetch(bob);
eve.repo.fetch(alice);
eve_identity.reload().unwrap();
- // b2 (Propose "B2")
+ // b2 (Propose "B2") [Rejected(Parent) — cascaded from B1]
// |
- // b1 (Propose "B1")
- // e1 | (Propose "E1") 2/3 (Accepted)
+ // b1 (Propose "B1") [Rejected(Sibling(E1)) — sibling E1 accepted]
+ // e1 | (Propose "E1") [Accepted, 2/3]
// | /
// a1 (Add Bob and Eve)
// |
@@ -1982,15 +1995,18 @@ mod test {
assert_eq!(eve_identity.current, e1);
assert_eq!(eve_identity.revision(&e1).unwrap().state, State::Accepted);
+ // B1 is rejected because its sibling E1 was accepted.
assert_eq!(
eve_identity.revision(&b1).unwrap().state,
State::Rejected(RejectedBy::Sibling(e1))
);
+ // B2 is rejected because its **parent** B1 was rejected (cascading).
assert_eq!(
eve_identity.revision(&b2).unwrap().state,
- State::Rejected(RejectedBy::Sibling(e1))
+ State::Rejected(RejectedBy::Parent)
);
+ // Verify convergence across all nodes.
alice.repo.fetch(bob);
bob.repo.fetch(alice);
bob.repo.fetch(eve);
@@ -2005,7 +2021,7 @@ mod test {
);
assert_eq!(
alice_identity.revision(&b2).unwrap().state,
- State::Rejected(RejectedBy::Sibling(e1))
+ State::Rejected(RejectedBy::Parent)
);
assert_eq!(bob_identity.current, e1);
@@ -2015,7 +2031,7 @@ mod test {
);
assert_eq!(
bob_identity.revision(&b2).unwrap().state,
- State::Rejected(RejectedBy::Sibling(e1))
+ State::Rejected(RejectedBy::Parent)
);
}
commit ebf0f417f74558fe974fd72dc2ead38e600639b2
Author: Lorenz Leutgeb <lorenz.leutgeb@radicle.dev>
Date: Tue Jun 23 22:23:07 2026 +0200
radicle/cob/identity: Deprecate `Identity::id`
In the heartwood workspace, there is just a single use of this function.
Also, the repository ID can be computed on demand, saving memory.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index bac3058dd..4e663a80c 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -167,9 +167,6 @@ pub enum Error {
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Identity {
- /// The canonical identifier for this identity.
- /// This is the object id of the initial document blob.
- pub id: RepoId,
/// The current revision of the document.
/// Equal to the head of the identity branch.
pub current: RevisionId,
@@ -201,7 +198,6 @@ impl Identity {
let root_id = root.id;
Self {
- id: root.blob.into(),
root: root_id,
current: root_id,
revisions: HashMap::from_iter([(root_id, root)]),
@@ -300,8 +296,9 @@ impl Identity {
impl Identity {
/// The repository identifier.
+ #[deprecated]
pub fn id(&self) -> RepoId {
- self.id
+ self.root().blob.into()
}
/// The current document.
@@ -2350,7 +2347,7 @@ mod test {
assert_eq!(identity.signatures().count(), 2);
assert_eq!(identity.revisions().count(), 5);
- assert_eq!(identity.id(), id);
+ assert_eq!(RepoId::from(identity.root().blob), id);
assert_eq!(identity.root().id, root);
assert_eq!(identity.current().blob, doc.blob);
assert_eq!(identity.current().description.as_str(), "Bob's repository");
commit 97f279fe41be6cc48b462a59b45b7de062029460
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Thu Jun 11 15:18:35 2026 +0100
radicle/cob/identity: Test redacting accepted revisions
Add a test to ensure that a previously accepted revision cannot be redacted.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 93a1f5f31..bac3058dd 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -2204,6 +2204,70 @@ mod test {
);
}
+ /// A previously accepted revision that is no longer the current revision
+ /// cannot be redacted. It was part of the canonical history and its state
+ /// should be immutable.
+ #[test]
+ fn cannot_redact_previously_accepted_revision() {
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ let a1 = alice_identity
+ .update(
+ cob::Title::new("A₁").unwrap(),
+ "Add Bob",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ // A₁ is accepted by Bob, thus reaches 2/2 votes, is accepted
+ // and becomes the current revision.
+ bob.repo.fetch(alice);
+ let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
+ bob_identity.accept(&a1).unwrap();
+ alice.repo.fetch(bob);
+ alice_identity.reload().unwrap();
+ assert_eq!(alice_identity.current, a1);
+ assert_eq!(alice_identity.revision(&a1).unwrap().state, State::Accepted);
+
+ // A₂ is proposed and accepted, is acceptedy by Bob, thus reaches 2/2 votes,
+ // is accepted, and becomes the current revision, superseding A₁.
+ let mut alice_doc2 = alice_identity.doc().clone().edit();
+ alice_doc2.visibility = Visibility::private([]);
+ let a2 = alice_identity
+ .update(
+ cob::Title::new("A₂").unwrap(),
+ "",
+ &alice_doc2.verified().unwrap(),
+ )
+ .unwrap();
+ bob.repo.fetch(alice);
+ bob_identity.reload().unwrap();
+ bob_identity.accept(&a2).unwrap();
+ alice.repo.fetch(bob);
+ alice_identity.reload().unwrap();
+ assert_eq!(alice_identity.current, a2);
+
+ // A₁ is now previously accepted but not current anymore.
+ //
+ // A₂ [Accepted, current]
+ // |
+ // A₁ [Accepted, previously current]
+ // |
+ // A₀
+ assert_eq!(alice_identity.revision(&a1).unwrap().state, State::Accepted);
+ assert_ne!(alice_identity.current, a1);
+
+ // Attempting to redact A₁ should be silently ignored.
+ alice_identity.redact(a1).unwrap();
+ assert_eq!(alice_identity.revision(&a1).unwrap().state, State::Accepted);
+ assert_eq!(alice_identity.current, a2);
+ }
+
#[test]
fn test_valid_identity() {
let tempdir = tempfile::tempdir().unwrap();
commit e0e231813fc5bd521941fadf6a0e9c54c03fb9f4
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Thu Jun 11 08:51:31 2026 +0100
radicle/cob/identity: Test `authorization_based_on_parent_not_current`
To reflect that autorization is governed by the causal parent of a
revision, not the currently accepted revision.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 2f2421630..93a1f5f31 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -2502,4 +2502,102 @@ mod test {
assert_eq!(eve_identity.revision(&b1).unwrap().state, State::Accepted);
assert_eq!(eve_identity.current, b1);
}
+
+ /// Demonstrates that authorization to vote on a revision is strictly governed
+ /// by its parent, not by the currently accepted identity document.
+ #[test]
+ fn authorization_based_on_parent_not_current() {
+ use crate::crypto::test::signer::MockSigner;
+ use crate::test::setup::{Node, NodeRepo};
+ use tempfile::tempdir;
+
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+ let eve = &network.eve;
+
+ // Create Dave as a 4th participant.
+ let mut dave_node = Node::new(tempdir().unwrap(), MockSigner::from_seed([!3; 32]), "dave");
+ dave_node.clone(network.rid, alice);
+ let dave_repo = NodeRepo {
+ repo: dave_node.storage.repository(network.rid).unwrap(),
+ checkout: None,
+ };
+
+ // Revision A₁ lists 4 delegates: Alice, Bob, Eve, and Dave.
+ // Since alice is the only delegate initially, A₁ is immediately accepted
+ // and becomes the current revision.
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ alice_doc.delegate(eve.signer.public_key().into());
+ alice_doc.delegate(dave_node.signer.public_key().into());
+ let _a1 = alice_identity
+ .update(
+ cob::Title::new("A₁").unwrap(),
+ "Add Bob, Eve, and Dave",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ bob.repo.fetch(alice);
+ eve.repo.fetch(alice);
+ dave_repo.fetch(alice);
+
+ // Revision A₂ lists 3 delegates: Alice, Bob, and Eve.
+ // Dave is removed in this proposal.
+ let mut doc_a2 = alice_identity.doc().clone().edit();
+ doc_a2
+ .rescind(&dave_node.signer.public_key().into())
+ .unwrap();
+ let a2 = alice_identity
+ .update(
+ cob::Title::new("A₂").unwrap(),
+ "Remove Dave",
+ &doc_a2.clone().verified().unwrap(),
+ )
+ .unwrap();
+
+ // Revision A₃ is a child of A₂.
+ // Note that at this point, A₁ is still the currently accepted revision,
+ // meaning Dave is a delegate according to the currently accepted revision.
+ let mut doc_a3 = doc_a2.clone();
+ doc_a3.visibility = Visibility::private([]);
+ let a3 = alice_identity
+ .transaction("A₃", |tx, repo| {
+ *tx = Transaction::new_revision(
+ cob::Title::new("A₃").unwrap(),
+ "Set visibility to private",
+ &doc_a3.verified().unwrap(),
+ Some(a2),
+ repo,
+ &alice.signer,
+ )?;
+ Ok(())
+ })
+ .unwrap();
+
+ // Dave fetches and attempts to accept A₃.
+ // Even though Dave is a delegate in the currently accepted revision (A₁),
+ // authorization is governed by the parent of A₃, which is A₂.
+ // Because A₂ removed Dave, this action must error.
+ dave_repo.fetch(alice);
+ let mut dave_identity = Identity::load_mut(&*dave_repo, &dave_node.signer).unwrap();
+
+ let err = dave_identity.accept(&a3).unwrap_err();
+ let is_unauthorized =
+ std::iter::successors::<&dyn std::error::Error, _>(Some(&err), |err| err.source()).any(
+ |source| {
+ matches!(
+ source.downcast_ref::<ApplyError>(),
+ Some(ApplyError::NonDelegateUnauthorized { .. })
+ )
+ },
+ );
+
+ assert!(
+ is_unauthorized,
+ "Dave should be unauthorized because he was removed in the parent (A₂). Actual error: {err:?}"
+ );
+ }
}
commit 108686e299edebec253e1d2e50e1d939947e4208
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Thu Jun 11 08:51:31 2026 +0100
radicle/cob/identity: Test queued children with delegate change
Ensure that adopting queued children takes into account that the delegate set
can change.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 5da2d88c2..2f2421630 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -2385,4 +2385,121 @@ mod test {
assert_eq!(bob_identity.revision(&b1).unwrap().state, State::Accepted);
assert_eq!(bob_identity.current, b1);
}
+
+ /// When a revision is adopted that changes the delegate set, the majority
+ /// threshold may change. Queued children should be re-evaluated under the
+ /// new quorum rules.
+ ///
+ /// This test exercises the case where a delegate is removed, lowering
+ /// the majority from 3 (for 4 delegates) to 2 (for 3 delegates), which
+ /// enables a queued child to be automatically adopted.
+ #[test]
+ fn evaluates_queued_children_with_new_delegate() {
+ use crate::crypto::test::signer::MockSigner;
+ use crate::test::setup::{Node, NodeRepo};
+ use tempfile::tempdir;
+
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+ let eve = &network.eve;
+
+ // Create Dave as a 4th participant.
+ let mut dave_node = Node::new(tempdir().unwrap(), MockSigner::from_seed([!3; 32]), "dave");
+ dave_node.clone(network.rid, alice);
+ let dave_repo = NodeRepo {
+ repo: dave_node.storage.repository(network.rid).unwrap(),
+ checkout: None,
+ };
+
+ // A1: Alice adds Bob, Eve, and Dave as delegates.
+ // Alice is the sole delegate, so this is auto-accepted.
+ // Result: 4 delegates {Alice, Bob, Eve, Dave}, majority = 3.
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ alice_doc.delegate(eve.signer.public_key().into());
+ alice_doc.delegate(dave_node.signer.public_key().into());
+ let a1 = alice_identity
+ .update(
+ cob::Title::new("Add Bob, Eve, and Dave").unwrap(),
+ "",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+ assert_eq!(alice_identity.current, a1);
+ assert_eq!(alice_identity.doc().delegates().len(), 4);
+
+ // Sync everyone.
+ bob.repo.fetch(alice);
+ eve.repo.fetch(alice);
+ dave_repo.fetch(alice);
+
+ // A2: Alice proposes removing Dave.
+ // Under A1's rules (4 delegates), majority = 3. Alice has 1 vote. Active.
+ let mut doc_a2 = alice_identity.doc().clone().edit();
+ doc_a2
+ .rescind(&dave_node.signer.public_key().into())
+ .unwrap();
+ let a2 = alice_identity
+ .update(
+ cob::Title::new("Remove Dave").unwrap(),
+ "",
+ &doc_a2.clone().verified().unwrap(),
+ )
+ .unwrap();
+ assert_eq!(alice_identity.revision(&a2).unwrap().state, State::Active);
+
+ // B1: Alice proposes a child of A2 (changes visibility).
+ // B1's parent is A2 (Active, not current), so we use a manual transaction.
+ let mut doc_b1 = doc_a2.clone();
+ doc_b1.visibility = Visibility::private([]);
+ let b1 = alice_identity
+ .transaction("B1", |tx, repo| {
+ *tx = Transaction::new_revision(
+ cob::Title::new("B1: Change visibility").unwrap(),
+ "",
+ &doc_b1.verified().unwrap(),
+ Some(a2),
+ repo,
+ &alice.signer,
+ )?;
+ Ok(())
+ })
+ .unwrap();
+
+ // Bob fetches Alice's changes and accepts B1.
+ // B1 now has 2 votes (Alice + Bob). Both are delegates in A2's doc.
+ // But B1's parent A2 is not yet current, so B1 stays Active.
+ bob.repo.fetch(alice);
+ let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
+ bob_identity.accept(&b1).unwrap();
+ assert_eq!(bob_identity.revision(&b1).unwrap().state, State::Active);
+
+ // Bob accepts A2. A2 now has 2/4 votes. Still needs 3.
+ bob_identity.accept(&a2).unwrap();
+ assert_eq!(bob_identity.revision(&a2).unwrap().state, State::Active);
+
+ // Eve fetches from Alice and Bob, then accepts A2.
+ // A2 reaches 3/4 votes (Alice + Bob + Eve) → adopted!
+ // A2's doc has 3 delegates {Alice, Bob, Eve}, majority = 2.
+ // Re-evaluate children: B1 has 2 votes (Alice + Bob), 2 >= 2 → adopted!
+ //
+ // b1 [Accepted, 2 votes (Alice + Bob), majority 2 under A2's doc]
+ // |
+ // a2 [Accepted, 3 votes (Alice + Bob + Eve), majority 3 under A1's doc]
+ // |
+ // a1 [Accepted, 4 delegates]
+ // |
+ // a0
+ eve.repo.fetch(alice);
+ eve.repo.fetch(bob);
+ let mut eve_identity = Identity::load_mut(&*eve.repo, &eve.signer).unwrap();
+ eve_identity.accept(&a2).unwrap();
+
+ assert_eq!(eve_identity.revision(&a2).unwrap().state, State::Accepted);
+ assert_eq!(eve_identity.doc().delegates().len(), 3);
+ assert_eq!(eve_identity.revision(&b1).unwrap().state, State::Accepted);
+ assert_eq!(eve_identity.current, b1);
+ }
}
commit da2c523d411e21bb74ef18f3469d2f8c03658528
Author: Adrian Duke <adrian.duke@gmail.com>
Date: Wed May 27 18:00:31 2026 +0100
radicle/cob/identity: Add Property Tests
Introduce a property testing harness for asserting a set of properties expected
of the repository identity.
The harness uses the `Network` fixture for providing four nodes that can
interact with the repository identity. The state of the harness is advanced by
providing an actor and operation on the identity document. Invariants are then
asserted about the identity.
The current invariants are:
- The `current` revision is the one and only `Accepted` revision.
- The chain of revisions is valid. That is, `Active` revisions only have a
parent that is `Accepted`, and not `Rejected` or `Redacted`.
- `Active` revisions do not contain a majority approval.
- `Accepted` revisions contain a majority approval.
- `Rejected` revisions do not contain a majority approval.
- For each revision, at most one child is `Accepted`.
- For each revision, if any of its children is `Accepted`, all other
children are `Rejected`.
- A revision which is `Rejected(RejectedBy::Parent)` has a parent that
is `Rejected`.
- A revision which is `Redacted(RedactedBy::Parent)` has a parent that
is `Redacted`.
- For each revision that is `Rejected` or `Redacted`, none of its
children is `Active`.
- A sibling or ancestor revision's rejected state applies to its sibling or
descendant.
- The repository identity documents converge when all nodes have applied all
operations.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 54480bc0c..5da2d88c2 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1234,6 +1234,8 @@ impl<Repo, Signer> Deref for IdentityMut<'_, '_, Repo, Signer> {
#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod test {
+ mod property;
+
use qcheck_macros::quickcheck;
use crate::cob::{self, Title};
diff --git a/crates/radicle/src/cob/identity/test/property.rs b/crates/radicle/src/cob/identity/test/property.rs
new file mode 100644
index 000000000..15821f367
--- /dev/null
+++ b/crates/radicle/src/cob/identity/test/property.rs
@@ -0,0 +1,954 @@
+use qcheck::{Arbitrary, QuickCheck, TestResult};
+
+use crate::assert_matches;
+use crate::cob;
+use crate::cob::identity::{Did, Identity, RedactedBy, RejectedBy, RevisionId, State};
+use crate::cob::store::Transaction;
+use crate::identity::doc::PayloadId;
+use crate::test::arbitrary::BoundedVec;
+use crate::test::setup::Network;
+
+// NOTE: If these tests take too much time to run, consider lowering the
+// second argument (`const N: usize`) of the `ops: BoundedVec` argument.
+// Additionally you can reduce `.tests(X)` or set `QUICKCHECK_TESTS=X`
+// environment variable to a lower number, which reduces the number of
+// passing tests quickcheck requires before returning green.
+#[test]
+fn prop_invariants() {
+ fn prop(ops: BoundedVec<TestOp, 8>) -> TestResult {
+ if ops.is_empty() {
+ return TestResult::discard();
+ }
+
+ let mut harness = Harness::new();
+ for op in ops {
+ harness.apply(&op);
+ }
+
+ harness.assert_local_invariants();
+ harness.converge();
+ harness.assert_local_invariants();
+ harness.assert_convergence();
+
+ TestResult::passed()
+ }
+
+ QuickCheck::new()
+ .tests(10)
+ .quickcheck(prop as fn(BoundedVec<TestOp, 8>) -> TestResult);
+}
+
+/// The property tests keep track of 3 actors interacting with the repository
+/// identity.
+#[derive(Clone, Copy, Debug)]
+enum Actor {
+ Alice,
+ Bob,
+ Eve,
+ Dave,
+}
+
+/// Enumerate all the actors in an array.
+const ACTORS: [Actor; 4] = [Actor::Alice, Actor::Bob, Actor::Eve, Actor::Dave];
+
+/// [`OpAction`] describes a given action that can be made when emulating
+/// interactions with the repository identity document.
+#[derive(Clone, Debug)]
+enum OpAction {
+ /// The repository identity is updated with a new description and given
+ /// [`Actor`]'s delegate status is updated in the identity document.
+ ///
+ /// If they were previously a delegate then their delegate status is
+ /// rescinded.
+ ///
+ /// Otherwise, they are added as a delegate.
+ Update { toggle_delegate: Actor },
+ /// The repository identity is updated with a new description and given
+ /// [`Actor`]'s delegate status is updated in the identity document.
+ /// The given `parent_idx` chooses a random revision to use as the parent.
+ /// This ensures that sibling operations are created.
+ ///
+ /// If they were previously a delegate then their delegate status is
+ /// rescinded.
+ ///
+ /// Otherwise, they are added as a delegate.
+ UpdateRandom {
+ toggle_delegate: Actor,
+ parent_idx: usize,
+ },
+ /// The revision found at the given index is accepted.
+ Accept(usize),
+ /// The revision found at the given index is rejected.
+ Reject(usize),
+ /// The revision found at the given index is redacted.
+ Redact(usize),
+ /// The [`Actor`] paired with this operation synchronizes with all other
+ /// actors.
+ Sync,
+}
+
+/// Combine an [`OpAction`] with an [`Actor`], where the [`Actor`] performs the
+/// action on the repository identity.
+#[derive(Clone, Debug)]
+struct TestOp {
+ actor: Actor,
+ action: OpAction,
+}
+
+impl Arbitrary for TestOp {
+ fn arbitrary(g: &mut qcheck::Gen) -> Self {
+ let actor = *g.choose(&ACTORS).unwrap();
+
+ let action = match u8::arbitrary(g) % 6 {
+ 0 => OpAction::Update {
+ toggle_delegate: *g.choose(&ACTORS).unwrap(),
+ },
+ 1 => OpAction::UpdateRandom {
+ toggle_delegate: *g.choose(&ACTORS).unwrap(),
+ parent_idx: usize::arbitrary(g),
+ },
+ 2 => OpAction::Accept(usize::arbitrary(g)),
+ 3 => OpAction::Reject(usize::arbitrary(g)),
+ 4 => OpAction::Redact(usize::arbitrary(g)),
+ _ => OpAction::Sync,
+ };
+
+ Self { actor, action }
+ }
+}
+
+/// A test harness that contains a [`Network`] of nodes that interact with a
+/// shared repository [`Identity`].
+///
+/// These interactions are then verified to hold against a set of properties
+/// expected of the [`Identity`].
+struct Harness {
+ network: Network,
+ revisions: Vec<RevisionId>,
+}
+
+impl Harness {
+ fn new() -> Self {
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+ let eve = &network.eve;
+
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ alice_doc.delegate(eve.signer.public_key().into());
+ alice_doc.threshold = 2;
+
+ let a1 = alice_identity
+ .update(
+ cob::Title::new("Init").unwrap(),
+ "",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ bob.repo.fetch(alice);
+ eve.repo.fetch(alice);
+
+ let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
+ let mut eve_identity = Identity::load_mut(&*eve.repo, &eve.signer).unwrap();
+
+ bob_identity.accept(&a1).unwrap();
+ eve_identity.accept(&a1).unwrap();
+
+ alice.repo.fetch(bob);
+ alice.repo.fetch(eve);
+
+ Self {
+ network,
+ revisions: vec![a1],
+ }
+ }
+
+ /// The parent document always dictates the active delegate set
+ fn is_delegate(&self, actor: Actor, parent_id: RevisionId) -> bool {
+ let identity = self.identity_for(&actor);
+ let parent_doc = &identity.revision(&parent_id).unwrap().doc;
+
+ parent_doc.is_delegate(&self.did_for(&actor))
+ }
+
+ fn has_apply_error<E, F>(err: &E, predicate: F) -> bool
+ where
+ E: std::error::Error + 'static,
+ F: Fn(&cob::identity::ApplyError) -> bool,
+ {
+ std::iter::successors(Some(err as &dyn std::error::Error), |e| e.source())
+ .filter_map(|e| e.downcast_ref::<cob::identity::ApplyError>())
+ .any(predicate)
+ }
+
+ fn execute<F, T>(&self, actor: Actor, action: F) -> Result<T, cob::identity::Error>
+ where
+ T: std::fmt::Debug,
+ F: FnOnce(
+ &mut cob::identity::IdentityMut<
+ '_,
+ '_,
+ crate::storage::git::Repository,
+ crate::node::device::Device<crypto::test::signer::MockSigner>,
+ >,
+ ) -> Result<T, cob::identity::Error>,
+ {
+ let mut identity = self.identity_for(&actor);
+ cob::stable::with_advanced_timestamp(|| action(&mut identity))
+ }
+
+ fn apply(&mut self, op: &TestOp) {
+ match &op.action {
+ OpAction::Update { toggle_delegate } => {
+ let current_id = self.identity_for(&op.actor).current;
+ let is_delegate = self.is_delegate(op.actor, current_id);
+ let (_, _, mut doc) = self.signer_identity_doc_for(&op.actor);
+
+ self.toggle_delegate(toggle_delegate, &mut doc);
+ self.update_description(&mut doc, "Fuzz");
+
+ let result = self.execute(op.actor, |id| {
+ id.update(
+ cob::Title::new("Update").unwrap(),
+ "",
+ &doc.verified().unwrap(),
+ )
+ });
+
+ if is_delegate {
+ match result {
+ Ok(rev) => self.revisions.push(rev),
+ Err(e)
+ if Self::has_apply_error(&e, |err| {
+ matches!(err, cob::identity::ApplyError::DocUnchanged)
+ }) => {}
+ Err(e) => {
+ panic!("Delegate action should succeed, but failed with: {:?}", e)
+ }
+ }
+ } else {
+ let e = result.expect_err("Non-delegate action must fail");
+ assert!(Self::has_apply_error(&e, |err| matches!(
+ err,
+ cob::identity::ApplyError::NonDelegateUnauthorized { .. }
+ )));
+ }
+ }
+ OpAction::UpdateRandom {
+ toggle_delegate,
+ parent_idx,
+ } => {
+ if self.revisions.is_empty() {
+ return;
+ }
+ let parent_rev = self.revisions[*parent_idx % self.revisions.len()];
+
+ if self.identity_for(&op.actor).revision(&parent_rev).is_none() {
+ return;
+ }
+
+ let is_delegate = self.is_delegate(op.actor, parent_rev);
+ let (signer, _, mut doc) = self.signer_identity_doc_for(&op.actor);
+
+ self.toggle_delegate(toggle_delegate, &mut doc);
+ self.update_description(&mut doc, "Fuzz Child");
+
+ let result = self.execute(op.actor, |id| {
+ id.transaction("Update Child", |tx, r| {
+ *tx = Transaction::new_revision(
+ cob::Title::new("Update Child").unwrap(),
+ "",
+ &doc.verified().unwrap(),
+ Some(parent_rev),
+ r,
+ signer,
+ )?;
+ Ok(())
+ })
+ });
+
+ if is_delegate {
+ match result {
+ Ok(rev) => self.revisions.push(rev),
+ Err(e)
+ if Self::has_apply_error(&e, |err| {
+ matches!(err, cob::identity::ApplyError::DocUnchanged)
+ }) => {}
+ Err(e) => {
+ panic!("Delegate action should succeed, but failed with: {:?}", e)
+ }
+ }
+ } else {
+ let e = result.expect_err("Non-delegate action must fail");
+ assert!(Self::has_apply_error(&e, |err| matches!(
+ err,
+ cob::identity::ApplyError::NonDelegateUnauthorized { .. }
+ )));
+ }
+ }
+ OpAction::Accept(idx) => {
+ if self.revisions.is_empty() {
+ return;
+ }
+ let rev = self.revisions[*idx % self.revisions.len()];
+ let identity = self.identity_for(&op.actor);
+ let Some(revision) = identity.revision(&rev) else {
+ return;
+ };
+ let parent_id = revision.parent.unwrap();
+ let is_delegate = self.is_delegate(op.actor, parent_id);
+ let is_terminal = !revision.is_active();
+
+ let result = self.execute(op.actor, |id| id.accept(&rev));
+
+ if is_terminal {
+ assert!(result.is_ok(), "Terminal accept should be a no-op");
+ } else if is_delegate {
+ match result {
+ Ok(_) => {}
+ Err(e) => assert!(
+ Self::has_apply_error(&e, |err| matches!(
+ err,
+ cob::identity::ApplyError::DuplicateVerdict
+ )),
+ "Delegate accept failed with unexpected error: {e:?}"
+ ),
+ }
+ } else {
+ let e = result.expect_err("Non-delegate must fail on active revision");
+ assert!(
+ Self::has_apply_error(&e, |err| matches!(
+ err,
+ cob::identity::ApplyError::NonDelegateUnauthorized { .. }
+ )),
+ "Expected NonDelegateUnauthorized, got: {e:?}"
+ );
+ }
+ }
+ OpAction::Reject(idx) => {
+ if self.revisions.is_empty() {
+ return;
+ }
+ let rev = self.revisions[*idx % self.revisions.len()];
+ let identity = self.identity_for(&op.actor);
+ let Some(revision) = identity.revision(&rev) else {
+ return;
+ };
+ let parent_id = revision.parent.unwrap();
+ let is_delegate = self.is_delegate(op.actor, parent_id);
+ let is_terminal = !revision.is_active();
+
+ let result = self.execute(op.actor, |id| id.reject(rev));
+
+ if is_terminal {
+ assert!(result.is_ok(), "Terminal reject should be a no-op");
+ } else if is_delegate {
+ match result {
+ Ok(_) => {}
+ Err(e) => assert!(
+ Self::has_apply_error(&e, |err| matches!(
+ err,
+ cob::identity::ApplyError::DuplicateVerdict
+ )),
+ "Delegate reject failed with unexpected error: {e:?}"
+ ),
+ }
+ } else {
+ let e = result.expect_err("Non-delegate must fail on active revision");
+ assert!(
+ Self::has_apply_error(&e, |err| matches!(
+ err,
+ cob::identity::ApplyError::NonDelegateUnauthorized { .. }
+ )),
+ "Expected NonDelegateUnauthorized, got: {e:?}"
+ );
+ }
+ }
+ OpAction::Redact(idx) => {
+ if self.revisions.is_empty() {
+ return;
+ }
+ let rev = self.revisions[*idx % self.revisions.len()];
+ let identity = self.identity_for(&op.actor);
+ let Some(revision) = identity.revision(&rev) else {
+ return;
+ };
+ let is_author = revision.author.id() == &self.did_for(&op.actor);
+
+ let result = self.execute(op.actor, |id| id.redact(rev));
+
+ if is_author {
+ assert!(result.is_ok(), "Author should be able to redact");
+ } else {
+ let e = result.expect_err("Non-author must fail to redact");
+ assert!(
+ Self::has_apply_error(&e, |err| matches!(
+ err,
+ cob::identity::ApplyError::NotAuthorized
+ )),
+ "Expected NotAuthorized, got: {e:?}"
+ );
+ }
+ }
+ OpAction::Sync => match op.actor {
+ Actor::Alice => {
+ self.network.alice.repo.fetch(&self.network.bob);
+ self.network.alice.repo.fetch(&self.network.eve);
+ self.network.alice.repo.fetch(&self.network.dave);
+ }
+ Actor::Bob => {
+ self.network.bob.repo.fetch(&self.network.alice);
+ self.network.bob.repo.fetch(&self.network.eve);
+ self.network.bob.repo.fetch(&self.network.dave);
+ }
+ Actor::Eve => {
+ self.network.eve.repo.fetch(&self.network.alice);
+ self.network.eve.repo.fetch(&self.network.bob);
+ self.network.eve.repo.fetch(&self.network.dave);
+ }
+ Actor::Dave => {
+ self.network.dave.repo.fetch(&self.network.alice);
+ self.network.dave.repo.fetch(&self.network.bob);
+ self.network.dave.repo.fetch(&self.network.eve);
+ }
+ },
+ }
+ }
+
+ fn update_description(&self, doc: &mut crate::prelude::RawDoc, msg: &str) {
+ let prj = doc.project().unwrap();
+ let desc = format!("{} {}", msg, self.revisions.len());
+ let prj = prj.update(None, desc, None).unwrap();
+ doc.payload.insert(PayloadId::project(), prj.into());
+ }
+
+ fn did_for(&self, actor: &Actor) -> Did {
+ match actor {
+ Actor::Alice => self.network.alice.signer.public_key().into(),
+ Actor::Bob => self.network.bob.signer.public_key().into(),
+ Actor::Eve => self.network.eve.signer.public_key().into(),
+ Actor::Dave => self.network.dave.signer.public_key().into(),
+ }
+ }
+
+ fn toggle_delegate(&self, delegate: &Actor, doc: &mut crate::prelude::RawDoc) {
+ let target_delegate: Did = self.did_for(delegate);
+
+ if doc.delegates.contains(&target_delegate) {
+ if doc.delegates.len() > 1 {
+ doc.rescind(&target_delegate).unwrap();
+
+ // Ensure threshold never exceeds new delegate count
+ if doc.threshold > doc.delegates.len() {
+ doc.threshold = doc.delegates.len();
+ }
+ }
+ } else {
+ doc.delegate(target_delegate);
+ }
+ }
+
+ fn identity_for(
+ &self,
+ actor: &Actor,
+ ) -> cob::identity::IdentityMut<
+ '_,
+ '_,
+ crate::storage::git::Repository,
+ crate::node::device::Device<crypto::test::signer::MockSigner>,
+ > {
+ let (_, identity, _) = self.signer_identity_doc_for(actor);
+
+ identity
+ }
+
+ fn signer_identity_doc_for(
+ &self,
+ actor: &Actor,
+ ) -> (
+ &crate::node::device::Device<crypto::test::signer::MockSigner>,
+ cob::identity::IdentityMut<
+ '_,
+ '_,
+ crate::storage::git::Repository,
+ crate::node::device::Device<crypto::test::signer::MockSigner>,
+ >,
+ crate::prelude::RawDoc,
+ ) {
+ let (repo, signer) = match actor {
+ Actor::Alice => (&*self.network.alice.repo, &self.network.alice.signer),
+ Actor::Bob => (&*self.network.bob.repo, &self.network.bob.signer),
+ Actor::Eve => (&*self.network.eve.repo, &self.network.eve.signer),
+ Actor::Dave => (&*self.network.dave.repo, &self.network.dave.signer),
+ };
+ let identity = Identity::load_mut(repo, signer).unwrap();
+ let doc = identity.doc().clone().edit();
+ (signer, identity, doc)
+ }
+
+ fn converge(&mut self) {
+ let alice = &self.network.alice;
+ let bob = &self.network.bob;
+ let eve = &self.network.eve;
+ let dave = &self.network.dave;
+
+ // Hub and spoke sync
+ alice.repo.fetch(bob);
+ alice.repo.fetch(eve);
+ alice.repo.fetch(dave);
+
+ bob.repo.fetch(alice);
+ eve.repo.fetch(alice);
+ dave.repo.fetch(alice);
+ }
+
+ fn assert_local_invariants(&self) {
+ let alice_diverged_id = Identity::load(&*self.network.alice.repo).unwrap();
+ let bob_diverged_id = Identity::load(&*self.network.bob.repo).unwrap();
+ let eve_diverged_id = Identity::load(&*self.network.eve.repo).unwrap();
+ let dave_diverged_id = Identity::load(&*self.network.dave.repo).unwrap();
+
+ self.assert_local_invariants_for(&alice_diverged_id);
+ self.assert_local_invariants_for(&bob_diverged_id);
+ self.assert_local_invariants_for(&eve_diverged_id);
+ self.assert_local_invariants_for(&dave_diverged_id);
+ }
+
+ fn assert_local_invariants_for(&self, identity: &Identity) {
+ self.assert_single_accepted_head(identity);
+ self.assert_linear_history(identity);
+ self.assert_active_quorum(identity);
+ self.assert_accepted_quorum(identity);
+ self.assert_rejected_quorum(identity);
+ self.assert_sibling_rejection(identity);
+ self.assert_ancestor_redacted_from_redacted_parent(identity);
+ self.assert_ancestor_rejected_from_rejected_parent(identity);
+ self.assert_failed_parents_have_failed_children(identity);
+ self.assert_rejection_reasons_are_accurate(identity);
+ self.assert_verdicts_match_parent_delegates(identity);
+ }
+
+ /// Strong eventual consistency.
+ ///
+ /// Nodes can receive operations in different orders. Regardless of the path taken,
+ /// once nodes sync the same data, their state machines must compute the exact same
+ /// state.
+ ///
+ /// PASS:
+ /// Alice (Ops: 1, 2, 3) => State A
+ /// Bob (Ops: 3, 1, 2) => State A
+ ///
+ /// FAIL:
+ /// Alice (Ops: 1, 2, 3) => State A
+ /// Bob (Ops: 2, 1, 3) => State B (non-commutative)
+ fn assert_convergence(&self) {
+ let alice = Identity::load(&*self.network.alice.repo).unwrap();
+ let bob = Identity::load(&*self.network.bob.repo).unwrap();
+ let eve = Identity::load(&*self.network.eve.repo).unwrap();
+ let dave = Identity::load(&*self.network.dave.repo).unwrap();
+
+ assert_eq!(alice.current, bob.current, "Alice and Bob must converge");
+ assert_eq!(bob.current, eve.current, "Bob and Eve must converge");
+ assert_eq!(eve.current, dave.current, "Eve and Dave must converge");
+ assert_eq!(dave.current, alice.current, "Dave and Alice must converge");
+ }
+
+ /// The `current` pointer always points to a valid, `Accepted` revision.
+ ///
+ /// The repository must have a single, unambiguous canonical identity document.
+ /// The head of the identity cannot be a pending, rejected, or redacted proposal.
+ ///
+ /// PASS:
+ /// current == [Accepted]
+ ///
+ /// FAIL:
+ /// current == [Active] (Pointer moved before quorum was reached)
+ /// current == [Redacted] (The canonical head was illegally redacted)
+ fn assert_single_accepted_head(&self, identity: &Identity) {
+ let accepted_count = identity
+ .revisions()
+ .filter(|r| r.state == State::Accepted && r.id == identity.current)
+ .count();
+ assert_eq!(
+ accepted_count, 1,
+ "Exactly one accepted revision must match current"
+ );
+ }
+
+ /// The causal chain is unbroken and valid.
+ ///
+ /// 1. We cannot have "zombie" children (Active revisions whose parents are redacted/rejected).
+ /// 2. The canonical history must be a straight line of accepted states back to the root.
+ ///
+ /// PASS:
+ /// [Accepted] <-- [Accepted] <-- [Active] (Valid pending proposal)
+ ///
+ /// FAIL:
+ /// [Rejected] <-- [Active] (Zombie child, parent is dead but child is pending)
+ /// [Active] <-- [Accepted] (Broken chain, an accepted state has an unaccepted parent)
+ fn assert_linear_history(&self, identity: &Identity) {
+ // No active revision has a rejected/redacted parent
+ for rev in identity.revisions() {
+ if rev.state == State::Active
+ && let Some(parent_id) = rev.parent
+ && let Some(parent) = identity.revision(&parent_id)
+ {
+ assert!(
+ !matches!(parent.state, State::Rejected(_) | State::Redacted(_)),
+ "Active revision {} has invalid parent state {:?}",
+ rev.id,
+ parent.state
+ );
+ }
+ }
+
+ // All ancestors of the current revision must be Accepted.
+ let mut curr_id = identity.current;
+ while let Some(rev) = identity.revision(&curr_id) {
+ assert_eq!(
+ rev.state,
+ State::Accepted,
+ "Parent {} in the canonical chain must be Accepted",
+ rev.id
+ );
+ if let Some(parent_id) = rev.parent {
+ curr_id = parent_id;
+ } else {
+ break;
+ }
+ }
+ }
+
+ /// No `Active` revision has met the required majority.
+ ///
+ /// If an active revision gathers enough votes, the state machine should
+ /// have automatically transitioned it to `Accepted`. If it is still `Active`,
+ /// the `adopt()` trigger failed to fire.
+ ///
+ /// PASS:
+ /// [Active, 1/2 votes]
+ ///
+ /// FAIL:
+ /// [Active, 2/2 votes] (Should have been Accepted)
+ fn assert_active_quorum(&self, identity: &Identity) {
+ for rev in identity.revisions() {
+ if rev.state == State::Active {
+ let parent_id = rev.parent.expect("Active revision must have a parent");
+
+ // If the parent is not the current document, it is perfectly valid for this
+ // revision to have reached a majority while still being `Active`.
+ // It is queued and waiting for its parent to be adopted first.
+ if parent_id != identity.current {
+ continue;
+ }
+
+ let parent = identity.revision(&parent_id).unwrap();
+ let majority = parent.doc.majority();
+
+ assert!(
+ rev.accepted().count() < majority,
+ "Active revision {} has {} votes but majority is {}. It should have been adopted!",
+ rev.id,
+ rev.accepted().count(),
+ majority
+ );
+ }
+ }
+ }
+
+ /// Every `Accepted` revision actually met the required majority.
+ ///
+ /// Prevents illegally accepted revisions. A revision cannot bypass the voting
+ /// rules to become accepted.
+ ///
+ /// PASS:
+ /// [Accepted, 2/2 votes]
+ ///
+ /// FAIL:
+ /// [Accepted, 1/2 votes] (Accepted without reaching quorum)
+ fn assert_accepted_quorum(&self, identity: &Identity) {
+ for rev in identity.revisions() {
+ if rev.state == State::Accepted && rev.id != identity.root {
+ let parent_id = rev.parent.expect("Accepted revision must have a parent");
+ let parent = identity.revision(&parent_id).unwrap();
+ let majority = parent.doc.majority();
+
+ assert!(
+ rev.accepted().count() >= majority,
+ "Accepted revision {} only has {} votes, but needed {}!",
+ rev.id,
+ rev.accepted().count(),
+ majority
+ );
+ }
+ }
+ }
+
+ /// Every `Rejected(Vote)` revision actually met the required majority.
+ ///
+ /// Prevents illegally rejected revisions. A revision cannot bypass the voting
+ /// rules to become rejected.
+ ///
+ /// PASS (3 delegates, majority 2):
+ /// [Rejected(Vote), 2/3 reject votes] (Only 1 delegate left, impossible to reach 2 accepts)
+ ///
+ /// FAIL (3 delegates, majority 2):
+ /// [Rejected(Vote), 1/3 reject votes] (2 delegates left, still possible to reach 2 accepts)
+ fn assert_rejected_quorum(&self, identity: &Identity) {
+ for rev in identity.revisions() {
+ if rev.state == State::Rejected(RejectedBy::Vote) && rev.id != identity.root {
+ let parent_id = rev.parent.expect("Rejected revision must have a parent");
+ let parent = identity.revision(&parent_id).unwrap();
+
+ let rejection_threshold = parent.doc.delegates().len() - parent.doc.majority();
+ let needed_majority = rejection_threshold + 1;
+
+ assert!(
+ rev.rejected().count() >= needed_majority,
+ "RejectedBy::Vote revision {} only has {} votes, but needed {}!",
+ rev.id,
+ rev.rejected().count(),
+ needed_majority
+ );
+ }
+ }
+ }
+
+ /// There can be only one accepted sibling.
+ ///
+ /// When a revision is accepted, all competing forks must be explicitly
+ /// rejected to prevent split-brain scenarios and enforce a linear history.
+ ///
+ /// PASS:
+ /// /-- [Accepted]
+ /// [Parent]<
+ /// \-- [Rejected]
+ ///
+ /// FAIL:
+ /// /-- [Accepted]
+ /// [Parent]<
+ /// \-- [Active] (Sibling was not rejected)
+ fn assert_sibling_rejection(&self, identity: &Identity) {
+ for rev in identity.revisions() {
+ if rev.state == State::Accepted {
+ for sibling in identity.revisions() {
+ // If they share the same parent but have different IDs, they are siblings
+ if sibling.id != rev.id && sibling.parent == rev.parent {
+ assert!(
+ matches!(sibling.state, State::Rejected(_) | State::Redacted(_)),
+ "Sibling {} of accepted revision {} must be rejected or redacted, but is {:?}",
+ sibling.id,
+ rev.id,
+ sibling.state
+ );
+ }
+ }
+ }
+ }
+ }
+
+ /// A revision can only be `Rejected(RejedtedBy::Parent)` if its parent was rejected.
+ ///
+ /// Ensures that the `RejectedBy::Parent` state is causally linked to a parent's rejection.
+ ///
+ /// PASS:
+ /// [Rejected] <-- [Rejected(RejectedBy::Parent)]
+ ///
+ /// FAIL:
+ /// [Active] <-- [Rejected(RejectedBy::Parent)] (Parent is not rejected)
+ fn assert_ancestor_rejected_from_rejected_parent(&self, identity: &Identity) {
+ for id in &identity.timeline {
+ if let Some(rev) = identity.revision(id)
+ && matches!(rev.state, State::Rejected(RejectedBy::Parent))
+ {
+ let parent_id = rev
+ .parent
+ .expect("a revision in `RejectedBy::Parent` must have a parent");
+ let parent = identity.revision(&parent_id).unwrap();
+ assert!(
+ matches!(
+ parent.state,
+ State::Rejected(RejectedBy::Vote)
+ | State::Rejected(RejectedBy::Sibling(_))
+ | State::Rejected(RejectedBy::Parent)
+ ),
+ "RejectedBy::Parent revision {} has invalid parent state {:?}",
+ rev.id,
+ parent.state
+ );
+ }
+ }
+ }
+
+ /// A revision can only be `Redacted(RedactedBy::Parent)` if its parent was redacted.
+ ///
+ /// Ensures that the `RedactedBy::Parent` state is causally linked to a parent's redaction.
+ ///
+ /// PASS:
+ /// [Redacted] <-- [Redacted(RedactedBy::Parent)]
+ ///
+ /// FAIL:
+ /// [Accepted] <-- [Redacted(RedactedBy::Parent)] (Parent is not redacted)
+ fn assert_ancestor_redacted_from_redacted_parent(&self, identity: &Identity) {
+ for id in &identity.timeline {
+ if let Some(rev) = identity.revision(id)
+ && matches!(rev.state, State::Redacted(RedactedBy::Parent))
+ {
+ let parent_id = rev
+ .parent
+ .expect("a revision in `RedactedBy::Parent` must have a parent");
+ let parent = identity.revision(&parent_id).unwrap();
+ assert!(
+ matches!(
+ parent.state,
+ State::Redacted(RedactedBy::Author) | State::Redacted(RedactedBy::Parent)
+ ),
+ "RedactedBy::Parent revision {} has invalid parent state {:?}",
+ rev.id,
+ parent.state
+ );
+ }
+ }
+ }
+
+ /// If a parent is in a failed state, it cannot have any `Active` or `Accepted` children.
+ ///
+ /// Enforces the "cascade" rule. When a branch dies (via rejection or redaction),
+ /// all of its pending children must also die. A dead branch cannot produce canonical history.
+ /// Note that a child can still be explicitly `Rejected(Vote)` or `Redacted(Author)` on its
+ /// own merits.
+ ///
+ /// PASS:
+ /// [Rejected] <-- [Rejected(RejectedBy::Parent)]
+ /// [Rejected] <-- [Rejected(Vote)] (Child was explicitly voted down before parent died)
+ ///
+ /// FAIL:
+ /// [Rejected] <-- [Active] (Zombie child)
+ fn assert_failed_parents_have_failed_children(&self, identity: &Identity) {
+ for id in &identity.timeline {
+ if let Some(rev) = identity.revision(id)
+ && let Some(parent_id) = rev.parent
+ && let Some(parent) = identity.revision(&parent_id)
+ {
+ let parent_is_failed = matches!(
+ parent.state,
+ State::Rejected(RejectedBy::Vote)
+ | State::Rejected(RejectedBy::Parent)
+ | State::Rejected(RejectedBy::Sibling(_))
+ | State::Redacted(RedactedBy::Author)
+ | State::Redacted(RedactedBy::Parent)
+ );
+
+ if parent_is_failed {
+ assert!(
+ !matches!(rev.state, State::Active | State::Accepted),
+ "Child {} is {:?} but parent {} has failed ({:?})",
+ rev.id,
+ rev.state,
+ parent.id,
+ parent.state
+ );
+ }
+ }
+ }
+ }
+
+ /// Validates that the [`Oid`]s inside terminal states point to the correct revisions.
+ ///
+ /// Ensures that `RejectedBy::Sibling` points to a true sibling that actually won (`Accepted`),
+ /// and that `RejectedBy::Parent` variants point to a true parent in a failed state. Prevents broken
+ /// causal links like pointing to an "uncle" or a revision on a completely different branch.
+ ///
+ /// PASS:
+ /// [Accepted (A)] and [RejectedBy::Sibling(A)] share the same parent.
+ ///
+ /// FAIL:
+ /// [RejectedBy::Sibling(B)] where B does not share the same parent.
+ /// [RejectedBy::Parent] without a rejedted parent.
+ fn assert_rejection_reasons_are_accurate(&self, identity: &Identity) {
+ for id in &identity.timeline {
+ let Some(rev) = identity.revision(id) else {
+ continue;
+ };
+
+ match rev.state {
+ State::Rejected(RejectedBy::Sibling(sibling_id)) => {
+ let sibling = identity.revision(&sibling_id).expect("Sibling must exist");
+
+ assert_eq!(
+ sibling.state,
+ State::Accepted,
+ "The winning sibling {} must be Accepted",
+ sibling_id
+ );
+ assert_eq!(
+ sibling.parent, rev.parent,
+ "Revision {} and {} must share the same parent",
+ rev.id, sibling_id
+ );
+ assert_ne!(
+ sibling.id, rev.id,
+ "A revision cannot be rejected by itself"
+ );
+ }
+ State::Rejected(RejectedBy::Parent) => {
+ let parent_id = rev.parent.expect("revision is not the root revision");
+ let parent = identity.revision(&parent_id).expect("parent exists");
+
+ assert_matches!(
+ parent.state,
+ State::Rejected(_),
+ "Parent {parent_id} must be rejected state",
+ );
+ }
+ State::Redacted(RedactedBy::Parent) => {
+ let parent_id = rev.parent.expect("revision is not the root revision");
+ let parent = identity.revision(&parent_id).expect("parent exists");
+
+ assert_matches!(
+ parent.state,
+ State::Redacted(_),
+ "Parent {parent_id} must be redacted",
+ );
+ }
+ _ => {}
+ }
+ }
+ }
+
+ /// Every vote on a revision must be cast by an authorized delegate according to its causal parent.
+ ///
+ /// Ensures that authorization is strictly governed by the causal history of the document,
+ /// rather than the network's currently accepted state. A user cannot cast a verdict on a
+ /// revision if they are not a delegate in that specific revision's parent.
+ ///
+ /// PASS:
+ /// [Parent: Alice, Bob are delegates] <-- [Child: Bob votes Accept]
+ ///
+ /// FAIL:
+ /// [Parent: Alice is sole delegate] <-- [Child: Bob votes Accept] (Unauthorized)
+ /// [Parent: Removes Bob] <-- [Child: Bob votes Accept] (Bob is no longer a delegate)
+ fn assert_verdicts_match_parent_delegates(&self, identity: &Identity) {
+ for id in &identity.timeline {
+ let Some(rev) = identity.revision(id) else {
+ continue;
+ };
+ if let Some(parent_id) = rev.parent {
+ let parent = identity.revision(&parent_id).unwrap();
+ for (voter_key, _) in rev.verdicts() {
+ let voter_did = Did::from(*voter_key);
+ assert!(
+ parent.doc.is_delegate(&voter_did),
+ "Voter {} cast a verdict on revision {} but is not a delegate in parent {}",
+ voter_did,
+ rev.id,
+ parent_id
+ );
+ }
+ }
+ }
+ }
+}
diff --git a/crates/radicle/src/test.rs b/crates/radicle/src/test.rs
index 3fc9dc0da..d21c3d95d 100644
--- a/crates/radicle/src/test.rs
+++ b/crates/radicle/src/test.rs
@@ -245,6 +245,7 @@ pub mod setup {
pub alice: NodeWithRepo,
pub bob: NodeWithRepo,
pub eve: NodeWithRepo,
+ pub dave: NodeWithRepo,
pub rid: RepoId,
}
@@ -253,11 +254,13 @@ pub mod setup {
let alice = Node::new(tempdir().unwrap(), MockSigner::from_seed([!0; 32]), "alice");
let mut bob = Node::new(tempdir().unwrap(), MockSigner::from_seed([!1; 32]), "bob");
let mut eve = Node::new(tempdir().unwrap(), MockSigner::from_seed([!2; 32]), "eve");
+ let mut dave = Node::new(tempdir().unwrap(), MockSigner::from_seed([!3; 32]), "dave");
let repo = alice.project();
let rid = repo.id;
bob.clone(repo.id, &alice);
eve.clone(repo.id, &alice);
+ dave.clone(repo.id, &alice);
let alice = NodeWithRepo { node: alice, repo };
let repo = bob.storage.repository(rid).unwrap();
@@ -276,11 +279,20 @@ pub mod setup {
checkout: None,
},
};
+ let repo = dave.storage.repository(rid).unwrap();
+ let dave = NodeWithRepo {
+ node: dave,
+ repo: NodeRepo {
+ repo,
+ checkout: None,
+ },
+ };
Self {
alice,
bob,
eve,
+ dave,
rid,
}
}
commit aae8938c013149de94bd36d76cfa20e59fd4def6
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Fri Jun 12 10:40:22 2026 +0100
radicle/test/arbitrary: Make BoundedVec shared
A `BoundedVec` that implements `Arbitrary` is useful for all property testing.
Move it from the `sigrefs` module so that it can be reused by other components.
diff --git a/crates/radicle/src/storage/refs/sigrefs/git/properties.rs b/crates/radicle/src/storage/refs/sigrefs/git/properties.rs
index 70db07002..5c3d636b4 100644
--- a/crates/radicle/src/storage/refs/sigrefs/git/properties.rs
+++ b/crates/radicle/src/storage/refs/sigrefs/git/properties.rs
@@ -14,24 +14,11 @@ use crate::storage::refs::sigrefs::VerifiedCommit;
use crate::storage::refs::sigrefs::read::{SignedRefsReader, Tip};
use crate::storage::refs::sigrefs::write::{SignedRefsWriter, Update};
use crate::storage::refs::{IDENTITY_ROOT, Refs};
+use crate::test::arbitrary;
use super::Committer;
-/// Newtype wrapper around [`Vec`] to keep the [`Arbitrary`] implementation
-/// bounded to a smaller size.
-#[derive(Clone, Debug)]
-struct BoundedVec<T>(Vec<T>);
-
-impl<T: qcheck::Arbitrary> qcheck::Arbitrary for BoundedVec<T> {
- fn arbitrary(g: &mut qcheck::Gen) -> Self {
- let size = usize::arbitrary(g) % 24;
- BoundedVec((0..size).map(|_| T::arbitrary(g)).collect())
- }
-
- fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
- Box::new(self.0.shrink().map(BoundedVec))
- }
-}
+type BoundedVec<T> = arbitrary::BoundedVec<T, 24>;
struct Verifier {
key: PublicKey,
@@ -176,7 +163,7 @@ fn initial_commit_roundtrip(mut refs: Refs) -> bool {
#[quickcheck]
fn chain_roundtrip(chain: BoundedVec<Refs>) -> TestResult {
- let chain = chain.0;
+ let chain = chain.to_vec();
if chain.is_empty() {
return TestResult::discard();
}
diff --git a/crates/radicle/src/test/arbitrary.rs b/crates/radicle/src/test/arbitrary.rs
index a5c2fbe79..903e1d43c 100644
--- a/crates/radicle/src/test/arbitrary.rs
+++ b/crates/radicle/src/test/arbitrary.rs
@@ -322,3 +322,55 @@ impl Arbitrary for UserAgent {
.unwrap()
}
}
+
+/// Newtype wrapper around [`Vec`] to keep the [`Arbitrary`] implementation
+/// bounded to a smaller size.
+#[derive(Clone, Debug)]
+pub struct BoundedVec<T, const N: usize> {
+ inner: Vec<T>,
+}
+
+impl<T, const N: usize> BoundedVec<T, N> {
+ pub fn to_vec(self) -> Vec<T> {
+ self.inner
+ }
+
+ pub fn is_empty(&self) -> bool {
+ self.inner.is_empty()
+ }
+
+ pub fn len(&self) -> usize {
+ self.inner.len()
+ }
+}
+
+impl<T, const N: usize> IntoIterator for BoundedVec<T, N> {
+ type Item = T;
+ type IntoIter = std::vec::IntoIter<T>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.inner.into_iter()
+ }
+}
+
+impl<'a, T, const N: usize> IntoIterator for &'a BoundedVec<T, N> {
+ type Item = &'a T;
+ type IntoIter = std::slice::Iter<'a, T>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.inner.iter()
+ }
+}
+
+impl<T: qcheck::Arbitrary, const N: usize> qcheck::Arbitrary for BoundedVec<T, N> {
+ fn arbitrary(g: &mut qcheck::Gen) -> Self {
+ let size = usize::arbitrary(g) % N;
+ Self {
+ inner: (0..size).map(|_| T::arbitrary(g)).collect(),
+ }
+ }
+
+ fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
+ Box::new(self.inner.shrink().map(|inner| Self { inner }))
+ }
+}
commit 94a24a7283c3a65a0ae02cd7de22fd02f07d96bd
Author: Adrian Duke <adrian.duke@gmail.com>
Date: Fri May 29 19:43:44 2026 +0100
radicle/cob/identity: Fix comments in test `reject_concurrent`
This incorrectly listed the number of votes and delegates.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 41924d4ac..54480bc0c 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1749,7 +1749,7 @@ mod test {
}
#[test]
- fn test_identity_reject_concurrent() {
+ fn reject_concurrent() {
let network = Network::default();
let alice = &network.alice;
let bob = &network.bob;
@@ -1806,14 +1806,14 @@ mod test {
assert_eq!(eve_revision.state, State::Active);
assert_eq!(eve_revision.parent, Some(a1));
- // e2 (Propose "Change visibility") 1/2
+ // e2 (Propose "Change visibility") 1/3
// |
- // e1 (Reject "Change visibility") 1/2
- // b1 | (Accept "Change visibility") 2/2
+ // e1 (Reject "Change visibility") 1/3
+ // b1 | (Accept "Change visibility") 2/3
// | /
- // a2 (Propose "Change visibility") 1/2
+ // a2 (Propose "Change visibility") 1/3
// |
- // a1 (Add Bob and Eve)
+ // a1 (Add Bob and Eve) 1/1
// |
// a0
commit 2768fe79d2b77ff6688fa26fe3c330d3e524e859
Author: Adrian Duke <adrian.duke@gmail.com>
Date: Wed May 27 17:34:31 2026 +0100
radicle/cob/identity: Test evaluating children of accepted revision
Add a test case to show that when a revision becomes accepted that its children,
which reach a majority vote, are also marked as accepted.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 316e55a8f..41924d4ac 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -2297,4 +2297,90 @@ mod test {
assert_eq!(doc.project().unwrap().description(), "Acme's repository!?");
}
+
+ #[test]
+ fn evaluates_queued_children() {
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+ let eve = &network.eve;
+
+ // Setup. Alice, Bob, and Eve are delegates. Majority required is 2.
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ alice_doc.delegate(eve.signer.public_key().into());
+ let a0 = alice_identity
+ .update(
+ cob::Title::new("Add Bob and Eve").unwrap(),
+ "",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ bob.repo.fetch(alice);
+ eve.repo.fetch(alice);
+ let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
+ let mut eve_identity = Identity::load_mut(&*eve.repo, &eve.signer).unwrap();
+ bob_identity.accept(&a0).unwrap();
+ eve_identity.accept(&a0).unwrap();
+
+ alice.repo.fetch(bob);
+ alice_identity.reload().unwrap();
+ assert_eq!(alice_identity.current, a0);
+
+ // Alice proposes A1 and B1
+ let mut doc_a1 = alice_identity.doc().clone().edit();
+ doc_a1.visibility = Visibility::private([]);
+ let a1 = alice_identity
+ .update(
+ cob::Title::new("A1").unwrap(),
+ "",
+ &doc_a1.clone().verified().unwrap(),
+ )
+ .unwrap();
+
+ let mut doc_b1 = doc_a1.clone();
+ doc_b1.visibility = Visibility::private([bob.signer.public_key().into()]);
+ let b1 = alice_identity
+ .transaction("B1", |tx, repo| {
+ *tx = Transaction::new_revision(
+ cob::Title::new("B1").unwrap(),
+ "",
+ &doc_b1.verified().unwrap(),
+ Some(a1),
+ repo,
+ &alice.signer,
+ )?;
+ Ok(())
+ })
+ .unwrap();
+
+ // Bob fetches and accepts B1.
+ // B1 now has 2 votes (Alice + Bob). The majority required is 2.
+ // However, B1's parent (A1) is not yet accepted.
+ bob.repo.fetch(alice);
+ bob_identity.reload().unwrap();
+ bob_identity.accept(&b1).unwrap();
+
+ // B1 is queued and not yet accepted
+ assert_eq!(bob_identity.revision(&b1).unwrap().state, State::Active);
+
+ // Bob accepts A1.
+ // A1 reaches 2 votes and is Accepted.
+ // B1 already has 2 votes, so it should be
+ // automatically accepted.
+ //
+ // b1 [Accepted, 2/2 votes]
+ // |
+ // a1 [Accepted, 2/2 votes]
+ // |
+ // a0 [Accepted]
+ bob_identity.accept(&a1).unwrap();
+
+ assert_eq!(bob_identity.revision(&a1).unwrap().state, State::Accepted);
+
+ assert_eq!(bob_identity.revision(&b1).unwrap().state, State::Accepted);
+ assert_eq!(bob_identity.current, b1);
+ }
}
commit c174efccb95d1887483c596cab9166c40dd52d2b
Author: Adrian Duke <adrian.duke@gmail.com>
Date: Fri May 22 15:35:02 2026 +0100
radicle/cob/identity: Test cascading of redaction
Add a test case to show that when a revision is redacted that its children also
become redacted, tracking `RedactedBy::Parent`.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 11c966a08..316e55a8f 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1522,6 +1522,85 @@ mod test {
assert_eq!(bob_identity.current, a1);
}
+ #[test]
+ fn redact_parent_cascades() {
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+
+ // Alice adds Bob.
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ let _a1 = alice_identity
+ .update(
+ cob::Title::new("Add Bob").unwrap(),
+ "",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ // Alice proposes A₂. Since there are 2 delegates now, it stays Active.
+ let mut alice_doc2 = alice_identity.doc().clone().edit();
+ alice_doc2.visibility = Visibility::private([]);
+ let a2 = alice_identity
+ .update(
+ cob::Title::new("A₂").unwrap(),
+ "",
+ &alice_doc2.verified().unwrap(),
+ )
+ .unwrap();
+
+ // Bob fetches and proposes B₁ as a child of A₂.
+ bob.repo.fetch(alice);
+ let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
+
+ let mut bob_doc = bob_identity.doc().clone().edit();
+ bob_doc.visibility = Visibility::private([alice.signer.public_key().into()]);
+
+ // We use a manual transaction to force B₁ to be a child of the Active A₂,
+ // rather than the Accepted A₁.
+ let b1 = bob_identity
+ .transaction("B₁", |tx, repo| {
+ *tx = Transaction::new_revision(
+ cob::Title::new("B₁").unwrap(),
+ "",
+ &bob_doc.verified().unwrap(),
+ Some(a2),
+ repo,
+ &bob.signer,
+ )?;
+ Ok(())
+ })
+ .unwrap();
+
+ // Alice redacts A₂.
+ alice_identity.redact(a2).unwrap();
+
+ // Bob fetches Alice's redaction.
+ bob.repo.fetch(alice);
+ bob_identity.reload().unwrap();
+
+ // b1 (Propose "B₁") 1/2 (RedactedBy::Parent due to parent A₂ being redacted)
+ // |
+ // a2 (Propose "A₂") 1/2 (RedactedBy::Author by Alice)
+ // |
+ // a1 (Add Bob) 1/1 (Accepted)
+ // |
+ // a0
+
+ assert_eq!(
+ bob_identity.revision(&a2).unwrap().state,
+ State::Redacted(RedactedBy::Author)
+ );
+ assert_eq!(
+ bob_identity.revision(&b1).unwrap().state,
+ State::Redacted(RedactedBy::Parent)
+ );
+ }
+
+ /// When a sibling revision is accepted, competing siblings from other
+ /// delegates are rejected with `Rejected(Sibling)`.
#[test]
fn accepted_sibling_causes_rejection() {
let network = Network::default();
commit 2349eebf5da5052f546e9e419cf8a5081de6bb8b
Author: Adrian Duke <adrian.duke@gmail.com>
Date: Fri May 22 14:39:18 2026 +0100
radicle/cob/identity: Test cascading rejection
When a revision reaches qourum and is adopted, the state all competing sibling
revisions as `Rejected`.
However, the test suite lacked coverage for deeper proposal branches,
specifically testing that this rejection correctly cascades to the
children of those rejected siblings.
Introduces a test to simulate the scenario where a delegate eagerly
proposes a chain of revisions (a child branching off a sibling) while
others concurrently accept a competing branch.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index ba34158a9..11c966a08 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1831,6 +1831,116 @@ mod test {
);
}
+ #[test]
+ fn cascading_rejections() {
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+ let eve = &network.eve;
+
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ alice_doc.delegate(eve.signer.public_key().into());
+ let _a1 = alice_identity
+ .update(
+ cob::Title::new("Add Bob and Eve").unwrap(),
+ "",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ bob.repo.fetch(alice);
+ eve.repo.fetch(alice);
+
+ let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
+ let mut bob_doc = bob_identity.doc().clone().edit();
+ bob_doc.visibility = Visibility::private([]);
+ let b1 = bob_identity
+ .update(
+ cob::Title::new("B1").unwrap(),
+ "",
+ &bob_doc.clone().verified().unwrap(),
+ )
+ .unwrap();
+
+ let bob_doc2 = bob_doc.clone();
+ bob_doc.visibility = Visibility::Public;
+ let b2 = bob_identity
+ .update(
+ cob::Title::new("B2").unwrap(),
+ "",
+ &bob_doc2.verified().unwrap(),
+ )
+ .unwrap();
+
+ let mut eve_identity = Identity::load_mut(&*eve.repo, &eve.signer).unwrap();
+ let mut eve_doc = eve_identity.doc().clone().edit();
+ eve_doc.visibility = Visibility::private([eve.signer.public_key().into()]);
+ let e1 = eve_identity
+ .update(
+ cob::Title::new("E1").unwrap(),
+ "",
+ &eve_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ alice.repo.fetch(eve);
+ alice_identity.reload().unwrap();
+ alice_identity.accept(&e1).unwrap();
+
+ eve.repo.fetch(bob);
+ eve.repo.fetch(alice);
+ eve_identity.reload().unwrap();
+
+ // b2 (Propose "B2")
+ // |
+ // b1 (Propose "B1")
+ // e1 | (Propose "E1") 2/3 (Accepted)
+ // | /
+ // a1 (Add Bob and Eve)
+ // |
+ // a0
+
+ assert_eq!(eve_identity.current, e1);
+ assert_eq!(eve_identity.revision(&e1).unwrap().state, State::Accepted);
+ assert_eq!(
+ eve_identity.revision(&b1).unwrap().state,
+ State::Rejected(RejectedBy::Sibling(e1))
+ );
+ assert_eq!(
+ eve_identity.revision(&b2).unwrap().state,
+ State::Rejected(RejectedBy::Sibling(e1))
+ );
+
+ alice.repo.fetch(bob);
+ bob.repo.fetch(alice);
+ bob.repo.fetch(eve);
+
+ alice_identity.reload().unwrap();
+ bob_identity.reload().unwrap();
+
+ assert_eq!(alice_identity.current, e1);
+ assert_eq!(
+ alice_identity.revision(&b1).unwrap().state,
+ State::Rejected(RejectedBy::Sibling(e1))
+ );
+ assert_eq!(
+ alice_identity.revision(&b2).unwrap().state,
+ State::Rejected(RejectedBy::Sibling(e1))
+ );
+
+ assert_eq!(bob_identity.current, e1);
+ assert_eq!(
+ bob_identity.revision(&b1).unwrap().state,
+ State::Rejected(RejectedBy::Sibling(e1))
+ );
+ assert_eq!(
+ bob_identity.revision(&b2).unwrap().state,
+ State::Rejected(RejectedBy::Sibling(e1))
+ );
+ }
+
#[test]
fn terminal_states_concurrent() {
let network = Network::default();
commit 39972b0c46303a9f0781dd673022780d40888753
Author: Adrian Duke <adrian.duke@gmail.com>
Date: Fri May 22 14:24:33 2026 +0100
radicle/cob/identity: Test terminal states
The identity evaluation rewrite changed how revision redactions are
handled. Instead of removing the revision entirely, it explicitly
transitions the revision to `State::Redacted`.
Add a test to cover two redaction scenarios:
- Attempting to redact a revision that has already been `Accepted`.
- Attempting to redact a revision that has already been `Rejected`.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index e91bc8d2d..ba34158a9 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1907,6 +1907,112 @@ mod test {
);
}
+ #[test]
+ fn test_identity_cannot_redact_terminal_states() {
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ let a1 = alice_identity
+ .update(
+ cob::Title::new("Add Bob").unwrap(),
+ "",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ bob.repo.fetch(alice);
+ let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
+ bob_identity.accept(&a1).unwrap();
+ alice.repo.fetch(bob);
+ alice_identity.reload().unwrap();
+
+ let mut alice_doc2 = alice_identity.doc().clone().edit();
+ alice_doc2.visibility = Visibility::private([]);
+ let a2 = alice_identity
+ .update(
+ cob::Title::new("A2").unwrap(),
+ "",
+ &alice_doc2.verified().unwrap(),
+ )
+ .unwrap();
+
+ bob.repo.fetch(alice);
+ bob_identity.reload().unwrap();
+
+ bob_identity.accept(&a2).unwrap();
+ alice_identity.redact(a2).unwrap();
+
+ alice.repo.fetch(bob);
+ alice_identity.reload().unwrap();
+
+ assert_eq!(
+ alice_identity.revision(&a2).unwrap().state,
+ State::Redacted(RedactedBy::Author)
+ );
+
+ let mut alice_doc3 = alice_identity.doc().clone().edit();
+ alice_doc3.visibility = Visibility::private([alice.signer.public_key().into()]);
+ let a3 = alice_identity
+ .update(
+ cob::Title::new("A3").unwrap(),
+ "",
+ &alice_doc3.verified().unwrap(),
+ )
+ .unwrap();
+
+ bob.repo.fetch(alice);
+ bob_identity.reload().unwrap();
+ bob_identity.accept(&a3).unwrap();
+
+ alice.repo.fetch(bob);
+ alice_identity.reload().unwrap();
+ assert_eq!(alice_identity.revision(&a3).unwrap().state, State::Accepted);
+
+ alice_identity.redact(a3).unwrap();
+ assert_eq!(alice_identity.revision(&a3).unwrap().state, State::Accepted);
+
+ let mut alice_doc4 = alice_identity.doc().clone().edit();
+ alice_doc4.visibility = Visibility::private([]);
+ let a4 = alice_identity
+ .update(
+ cob::Title::new("A4").unwrap(),
+ "",
+ &alice_doc4.verified().unwrap(),
+ )
+ .unwrap();
+
+ bob.repo.fetch(alice);
+ bob_identity.reload().unwrap();
+ bob_identity.reject(a4).unwrap();
+
+ alice.repo.fetch(bob);
+ alice_identity.reload().unwrap();
+ assert_eq!(
+ alice_identity.revision(&a4).unwrap().state,
+ State::Rejected(RejectedBy::Vote)
+ );
+
+ // a4 (Propose "A4") 1/2 (Rejected by Bob) -> Redact attempt ignored
+ // |
+ // a3 (Propose "A3") 2/2 (Accepted by Alice, Bob) -> Redact attempt ignored
+ // | \
+ // | a2 (Propose "A2") 1/2 (Redacted by Alice concurrently with Bob's Accept)
+ // | /
+ // a1 (Add Bob) 2/2 (Accepted by Alice, Bob)
+ // |
+ // a0
+
+ alice_identity.redact(a4).unwrap();
+ assert_eq!(
+ alice_identity.revision(&a4).unwrap().state,
+ State::Rejected(RejectedBy::Vote)
+ );
+ }
+
#[test]
fn test_valid_identity() {
let tempdir = tempfile::tempdir().unwrap();
commit 489360d0e5d92495af49b495e5c443f0245b688f
Author: Adrian Duke <adrian.duke@gmail.com>
Date: Fri May 22 14:15:03 2026 +0100
radicle/cob/identity: Add concurrent terminal state test
The new identity evaluation logic was updated to ignore `Accept` or `Reject`
actions if the revision has already reached a terminal state (`Accepted` or
`Rejected`), however this handling was not explicitly covered by the test suite.
This test ensures that the state machine correctly short-circuits the
late-arriving vote, proving that the new logic succesfully ensures
terminal states remain immutable under concurrent network conditions.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index d081c180d..e91bc8d2d 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1831,6 +1831,82 @@ mod test {
);
}
+ #[test]
+ fn terminal_states_concurrent() {
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+ let eve = &network.eve;
+
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ alice_doc.delegate(eve.signer.public_key().into());
+ let a1 = alice_identity
+ .update(
+ cob::Title::new("Add Bob and Eve").unwrap(),
+ "",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ bob.repo.fetch(alice);
+ eve.repo.fetch(alice);
+
+ let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
+ let mut eve_identity = Identity::load_mut(&*eve.repo, &eve.signer).unwrap();
+
+ bob_identity.accept(&a1).unwrap();
+ eve_identity.accept(&a1).unwrap();
+
+ alice.repo.fetch(bob);
+ alice_identity.reload().unwrap();
+ assert_eq!(alice_identity.revision(&a1).unwrap().state, State::Accepted);
+
+ alice.repo.fetch(eve);
+ alice_identity.reload().unwrap();
+ assert_eq!(alice_identity.revision(&a1).unwrap().state, State::Accepted);
+
+ let mut alice_doc2 = alice_identity.doc().clone().edit();
+ alice_doc2.visibility = Visibility::private([]);
+ let a2 = alice_identity
+ .update(
+ cob::Title::new("A2").unwrap(),
+ "",
+ &alice_doc2.verified().unwrap(),
+ )
+ .unwrap();
+
+ bob.repo.fetch(alice);
+ eve.repo.fetch(alice);
+ bob_identity.reload().unwrap();
+ eve_identity.reload().unwrap();
+
+ bob_identity.reject(a2).unwrap();
+ eve_identity.reject(a2).unwrap();
+
+ alice.repo.fetch(bob);
+ alice.repo.fetch(eve);
+ alice_identity.reload().unwrap();
+ assert_eq!(
+ alice_identity.revision(&a2).unwrap().state,
+ State::Rejected(RejectedBy::Vote)
+ );
+
+ // a2 (Propose "A2") 1/3 (Rejected by Bob and Eve)
+ // |
+ // a1 (Add Bob and Eve) 3/3 (Accepted by Alice, Bob, Eve)
+ // |
+ // a0
+
+ // Alice tries to accept the rejected revision
+ alice_identity.accept(&a2).unwrap();
+ assert_eq!(
+ alice_identity.revision(&a2).unwrap().state,
+ State::Rejected(RejectedBy::Vote)
+ );
+ }
+
#[test]
fn test_valid_identity() {
let tempdir = tempfile::tempdir().unwrap();
commit ba4a79af9060548f85106a78eb90625c8d27fea2
Author: Lorenz Leutgeb <lorenz.leutgeb@radicle.xyz>
Date: Mon Mar 30 17:57:28 2026 +0200
radicle/cob/identity: Test rejected sibling
Add a test case to show that when Bob creates two sibling changes `b1` and `b2`,
that the acceptance of one means the other gets rejected.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 385b82742..d081c180d 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1522,6 +1522,74 @@ mod test {
assert_eq!(bob_identity.current, a1);
}
+ #[test]
+ fn accepted_sibling_causes_rejection() {
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+ let eve = &network.eve;
+
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+
+ alice_doc.delegate(bob.signer.public_key().into());
+ alice_doc.delegate(eve.signer.public_key().into());
+
+ let _a1 = alice_identity
+ .update(
+ cob::Title::new("Add Bob and Eve").unwrap(),
+ "Eh#!",
+ &alice_doc.clone().verified().unwrap(),
+ )
+ .unwrap();
+
+ bob.repo.fetch(alice);
+ eve.repo.fetch(alice);
+
+ // Bob proposes b1.
+ let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
+ let mut bob_doc = bob_identity.doc().clone().edit();
+ bob_doc.visibility = Visibility::private([]);
+ let b1 = cob::stable::with_advanced_timestamp(|| {
+ bob_identity
+ .update(
+ cob::Title::new("Make private").unwrap(),
+ "",
+ &bob_doc.verified().unwrap(),
+ )
+ .unwrap()
+ });
+
+ // Eve proposes e1 (a competing sibling from a different delegate).
+ let mut eve_identity = Identity::load_mut(&*eve.repo, &eve.signer).unwrap();
+ let mut eve_doc = eve_identity.doc().clone().edit();
+ eve_doc.visibility = Visibility::private([eve.signer.public_key().into()]);
+ let e1 = cob::stable::with_advanced_timestamp(|| {
+ eve_identity
+ .update(
+ cob::Title::new("Change visibility").unwrap(),
+ "",
+ &eve_doc.verified().unwrap(),
+ )
+ .unwrap()
+ });
+
+ // Eve fetches Bob's proposal. She redacts her own proposal e1
+ // before accepting Bob's b1 (sibling-accept invariant).
+ eve.repo.fetch(bob);
+ eve_identity.reload().unwrap();
+ cob::stable::with_advanced_timestamp(|| eve_identity.redact(e1).unwrap());
+ cob::stable::with_advanced_timestamp(|| eve_identity.accept(&b1).unwrap());
+
+ // b1 is accepted (Bob + Eve = 2/3), becomes current.
+ assert_eq!(eve_identity.current, b1);
+ // e1 was redacted by Eve.
+ assert_eq!(
+ eve_identity.revision(&e1).unwrap().state,
+ State::Redacted(RedactedBy::Author)
+ );
+ }
+
#[test]
fn remove_delegate_concurrent() {
let network = Network::default();
commit d8c14222a26750b8153235a7c97b42c6738fabfd
Author: Lorenz Leutgeb <lorenz.leutgeb@radicle.xyz>
Date: Mon Mar 30 17:57:28 2026 +0200
radicle/cob/identity: Rewrite Evaluation
The evaluation of the reposioty identity is rewritten to better handle cases
where there are child and sibling revisions that are active at the same time.
In particular, `fn Identity::action` is now free of any references to
`self.current`.
This is achieved through two main improvements. The first is that the `State`
of revisions changes to improve clarity:
1. `Active` and `Accepted` remain, and their meanings also remain the same.
2. `Stale` is removed entirely.
3. `Rejected` is improved to also contain `RejectedBy`, to keep track of the
reason for rejection.
4. `Redacted` is promoted to a state. Similarly, the reason for
redaction is tracked by `RedactedBy`.
The transition of a revision from `Active` to one of the other states now
influences siblings and children.
If a revision transitions to `Accepted`, then the sibling revisions can no
longer transition to `Accepted`. They are considered `Rejected` where the reason
is `Sibling`. This cascades: Children of siblings are `Rejected`
recursively, tracking `RejectedBy::Parent`.
Any children of the `Accepted` revision are also evaluated to see if they can be
similarly transitioned to the `Accepted` state; since they may have already been
voted on.
If a revision was rejected by a majority, then the it transitions to `Rejected`
with `RejectedBy::Vote`. Dually to acceptance, the children of this revision
are also rejected with the reason of `Ancestor`.
Finally, when the author of a revision redacts a revision, it transitions
to `Redacted`, tracking `RedactedBy::Author`, and its children are redacted
tracking `RedactedBy::Parent`.
The test is adjusted to `remove_delegate_concurrent` reflect that concurrently
proposed revisions are retained in the timeline and explicitly marked as rejected,
rather than being dropped entirely (as before).
diff --git a/crates/radicle-cli/examples/rad-id-conflict.md b/crates/radicle-cli/examples/rad-id-conflict.md
index 495dc6f70..b43fe5915 100644
--- a/crates/radicle-cli/examples/rad-id-conflict.md
+++ b/crates/radicle-cli/examples/rad-id-conflict.md
@@ -53,7 +53,7 @@ $ rad id list
│ ● ID Title Author Status Created Parent │
├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ ● 89b2623 Edit project name bob z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk accepted now 0ca42d3 │
-│ ● 12d7300 Edit project name alice (you) stale now 0ca42d3 │
+│ ● 12d7300 Edit project name alice (you) rejected now 0ca42d3 │
│ ● 0ca42d3 Add Bob alice (you) accepted now 0656c21 │
│ ● 0656c21 Initial revision alice (you) accepted now none │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
@@ -70,9 +70,9 @@ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from the network, found 1 potential s
```
``` ~bob (fail)
$ rad id accept 12d7300 -q
-✗ Error: cannot vote on revision that is stale
+✗ Error: cannot vote on revision that is rejected
$ rad id reject 12d7300 -q
-✗ Error: cannot vote on revision that is stale
+✗ Error: cannot vote on revision that is rejected
```
``` ~bob
$ rad id show 12d7300
@@ -82,7 +82,7 @@ $ rad id show 12d7300
│ Parent 0ca42d376bd566631083c8913cf86bec722da392 │
│ Blob e93aa3e3c5c448bacd3537a81daf1437eccd046a │
│ Author did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi │
-│ State stale │
+│ State rejected │
│ Quorum no │
├────────────────────────────────────────────────────────────────────────┤
│ ✓ did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi alice │
diff --git a/crates/radicle-cli/src/commands/id.rs b/crates/radicle-cli/src/commands/id.rs
index c7b2b0356..3fc9df01f 100644
--- a/crates/radicle-cli/src/commands/id.rs
+++ b/crates/radicle-cli/src/commands/id.rs
@@ -222,8 +222,8 @@ pub fn run(args: Args, ctx: impl term::Context) -> anyhow::Result<()> {
let icon = match r.state {
identity::State::Active => term::format::tertiary("●"),
identity::State::Accepted => term::format::positive("●"),
- identity::State::Rejected => term::format::negative("●"),
- identity::State::Stale => term::format::dim("●"),
+ identity::State::Rejected(_) => term::format::negative("●"),
+ identity::State::Redacted(_) => continue,
}
.into();
let state = r.state.to_string().into();
@@ -288,6 +288,7 @@ fn get<'a>(
let id = revision.resolve(&repo.backend)?;
let revision = identity
.revision(&id)
+ .filter(|revision| !matches!(revision.state, identity::State::Redacted(_)))
.ok_or(anyhow!("revision `{id}` not found"))?;
Ok(revision)
@@ -344,13 +345,28 @@ fn print_meta(revision: &Revision, previous: &Doc, profile: &Profile) -> anyhow:
})
.divider();
- let accepted = revision.accepted().collect::<Vec<_>>();
- let rejected = revision.rejected().collect::<Vec<_>>();
- let unknown = previous
- .delegates()
- .iter()
- .filter(|id| !accepted.contains(id) && !rejected.contains(id))
- .collect::<Vec<_>>();
+ let accepted = {
+ let mut accepted = revision.accepted().collect::<Vec<_>>();
+ accepted.sort();
+ accepted
+ };
+
+ let rejected = {
+ let mut rejected = revision.rejected().collect::<Vec<_>>();
+ rejected.sort();
+ rejected
+ };
+
+ let unknown = {
+ let mut unknown = previous
+ .delegates()
+ .iter()
+ .filter(|id| !accepted.contains(id) && !rejected.contains(id))
+ .collect::<Vec<_>>();
+ unknown.sort();
+ unknown
+ };
+
let mut signatures = term::Table::<4, _>::default();
for id in accepted {
@@ -485,7 +501,6 @@ fn on_apply_err(e: &identity::ApplyError, profile: &Profile) -> anyhow::Error {
| e @ radicle::cob::identity::ApplyError::MissingParent
| e @ radicle::cob::identity::ApplyError::DuplicateVerdict
| e @ radicle::cob::identity::ApplyError::UnexpectedState
- | e @ radicle::cob::identity::ApplyError::Redacted
| e @ radicle::cob::identity::ApplyError::DocUnchanged
| e @ radicle::cob::identity::ApplyError::Git(_)
| e @ radicle::cob::identity::ApplyError::Doc(_)
diff --git a/crates/radicle-cli/src/terminal/format.rs b/crates/radicle-cli/src/terminal/format.rs
index 78a42390c..e12029a3f 100644
--- a/crates/radicle-cli/src/terminal/format.rs
+++ b/crates/radicle-cli/src/terminal/format.rs
@@ -405,8 +405,7 @@ pub mod identity {
match s {
State::Active => term::format::tertiary(s.to_string()),
State::Accepted => term::format::positive(s.to_string()),
- State::Rejected => term::format::negative(s.to_string()),
- State::Stale => term::format::dim(s.to_string()),
+ State::Rejected(_) | State::Redacted(_) => term::format::negative(s.to_string()),
}
}
}
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 368e85d49..385b82742 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1,4 +1,4 @@
-use std::collections::BTreeMap;
+use std::collections::HashMap;
use std::sync::LazyLock;
use std::{fmt, ops::Deref, str::FromStr};
@@ -122,8 +122,6 @@ pub enum ApplyError {
DuplicateVerdict,
#[error("revision is in an unexpected state")]
UnexpectedState,
- #[error("revision has been redacted")]
- Redacted,
#[error("document does not contain any changes to current identity")]
DocUnchanged,
#[error("git: {0}")]
@@ -179,7 +177,7 @@ pub struct Identity {
pub root: RevisionId,
/// Revisions.
- revisions: BTreeMap<RevisionId, Option<Revision>>,
+ revisions: HashMap<RevisionId, Revision>,
/// Timeline of events.
timeline: Vec<EntryId>,
}
@@ -199,15 +197,15 @@ impl std::ops::Deref for Identity {
}
impl Identity {
- pub fn new(revision: Revision) -> Self {
- let root = revision.id;
+ pub fn new(root: Revision) -> Self {
+ let root_id = root.id;
Self {
- id: revision.blob.into(),
- root,
- current: root,
- revisions: BTreeMap::from_iter([(root, Some(revision))]),
- timeline: vec![root],
+ id: root.blob.into(),
+ root: root_id,
+ current: root_id,
+ revisions: HashMap::from_iter([(root_id, root)]),
+ timeline: vec![root_id],
}
}
@@ -331,19 +329,43 @@ impl Identity {
/// A specific [`Revision`], that may be redacted.
pub fn revision(&self, revision: &RevisionId) -> Option<&Revision> {
- self.revisions.get(revision).and_then(|r| r.as_ref())
+ let result = self.revisions.get(revision);
+ debug_assert!(result.is_none_or(|result| &result.id == revision));
+ result
}
/// All the [`Revision`]s that have not been redacted.
pub fn revisions(&self) -> impl DoubleEndedIterator<Item = &Revision> {
- self.timeline
- .iter()
- .filter_map(|id| self.revisions.get(id).and_then(|o| o.as_ref()))
+ self.timeline.iter().filter_map(|id| {
+ self.revisions
+ .get(id)
+ .filter(|revision| !matches!(revision.state, State::Redacted(_)))
+ })
}
pub fn latest_by(&self, who: &Did) -> Option<&Revision> {
self.revisions().rev().find(|r| r.author.id() == who)
}
+
+ #[inline]
+ fn children_of(&self, id: &RevisionId) -> impl Iterator<Item = &RevisionId> {
+ self.revision(id)
+ .map(|revision| &revision.children)
+ .into_iter()
+ .flatten()
+ }
+
+ #[inline]
+ fn siblings_of(&self, id: &RevisionId) -> impl Iterator<Item = &RevisionId> {
+ self.revision(id)
+ .and_then(|revision| revision.parent.as_ref())
+ .map(|parent_id| {
+ self.children_of(parent_id)
+ .filter(move |child| *child != id)
+ })
+ .into_iter()
+ .flatten()
+ }
}
impl store::Cob for Identity {
@@ -422,19 +444,14 @@ impl store::Cob for Identity {
let concurrent = concurrent.into_iter().collect::<Vec<_>>();
for action in op.actions {
- match self.action(action, id, op.author, op.timestamp, &concurrent, repo) {
+ match self.action(action, id, op.author, op.timestamp, repo) {
Ok(()) => {}
// This particular error is returned when there is a mismatch between the expected
// and the actual state of a revision, which can happen concurrently. Therefore
// if there are other concurrent ops, it is not fatal and we simply ignore it.
- Err(ApplyError::UnexpectedState) => {
- if concurrent.is_empty() {
- return Err(ApplyError::UnexpectedState);
- }
- }
- // It's not a user error if the revision happens to be redacted by
+ Err(ApplyError::UnexpectedState) if !concurrent.is_empty() => {}
+ // It is not a user error if the revision happens to be redacted by
// the time this action is processed.
- Err(ApplyError::Redacted) => {}
Err(other) => return Err(other),
}
debug_assert!(!self.timeline.contains(&id));
@@ -452,138 +469,195 @@ impl Identity {
/// * There is only ever one accepted revision; this is the "current" revision.
/// * There can be zero or more active revisions, up to the number of delegates.
/// * An active revision is one that can be "voted" on.
- /// * An active revision always has the current revision as parent.
- /// * Only the active revision can be accepted, rejected or edited.
+ /// * Only an active revision can be accepted, rejected or edited.
fn action<R: ReadRepository>(
&mut self,
action: Action,
- entry: EntryId,
+ id: EntryId,
author: ActorId,
timestamp: Timestamp,
- _concurrent: &[&cob::Entry],
repo: &R,
) -> Result<(), ApplyError> {
- let current = self.current().clone();
-
let did = author.into();
- if !current.is_delegate(&did) {
- return Err(ApplyError::non_delegate_unauthorized(did, &action));
- }
+
match action {
- Action::RevisionAccept {
- revision,
- signature,
- } => {
- let id = revision;
- let Some(revision) = lookup::revision_mut(&mut self.revisions, &id)? else {
- return Err(ApplyError::Redacted);
+ action @ (Action::RevisionAccept { revision: id, .. }
+ | Action::RevisionReject { revision: id }) => {
+ let noun = match action {
+ Action::RevisionAccept { .. } => "acceptance",
+ Action::RevisionReject { .. } => "rejection",
+ _ => unreachable!(),
};
- if !revision.is_active() {
- // You can't vote on an inactive revision.
- return Err(ApplyError::UnexpectedState);
- }
- assert_eq!(revision.parent, Some(current.id));
- revision.accept(author, signature, ¤t)?;
+ let revision = self.revision(&id).ok_or(ApplyError::Missing(id))?;
- self.adopt(id);
- }
- Action::RevisionReject { revision } => {
- let Some(revision) = lookup::revision_mut(&mut self.revisions, &revision)? else {
- return Err(ApplyError::Redacted);
- };
- if !revision.is_active() {
- // You can't vote on an inactive revision.
- return Err(ApplyError::UnexpectedState);
- }
- assert_eq!(revision.parent, Some(current.id));
+ match revision.state {
+ state @ (State::Accepted | State::Rejected(_) | State::Redacted(_)) => {
+ log::debug!(
+ "Skipping {noun} of revision {id} by {did} because it already is {}.",
+ state.display_with_reason()
+ );
+ }
+ State::Active => {
+ let parent = revision.parent.ok_or(ApplyError::MissingParent)?;
+ let parent = self.revision(&parent).ok_or(ApplyError::Missing(parent))?;
- revision.reject(author)?;
+ if !parent.is_delegate(&did) {
+ return Err(ApplyError::non_delegate_unauthorized(did, &action));
+ }
+
+ log::trace!("Applying {noun} of active revision {id} by {did}.");
+
+ match action {
+ Action::RevisionAccept { signature, .. } => {
+ parent
+ .verify_signature(&author, &signature, revision.blob)
+ .map_err(|_source| {
+ ApplyError::InvalidSignature(author, revision.blob)
+ })?;
+
+ if self
+ .revision_mut(&id)?
+ .verdicts
+ .insert(author, Verdict::Accept(signature))
+ .is_some()
+ {
+ return Err(ApplyError::DuplicateVerdict);
+ }
+
+ self.adopt(id);
+ }
+ Action::RevisionReject { .. } => {
+ let rejection_threshold =
+ parent.delegates().len() - parent.majority();
+
+ let revision = self.revision_mut(&id)?;
+ if revision.verdicts.insert(author, Verdict::Reject).is_some() {
+ return Err(ApplyError::DuplicateVerdict);
+ }
+
+ if revision.rejected().count() > rejection_threshold {
+ revision.state = State::Rejected(RejectedBy::Vote);
+ self.cascade(id, State::Rejected(RejectedBy::Parent))
+ }
+ }
+ _ => unreachable!(),
+ }
+ }
+ }
}
Action::RevisionEdit {
title,
description,
- revision,
+ revision: id,
} => {
- if revision == self.current {
- return Err(ApplyError::NotAuthorized);
- }
- let Some(revision) = lookup::revision_mut(&mut self.revisions, &revision)? else {
- return Err(ApplyError::Redacted);
- };
+ let revision = self.revision_mut(&id)?;
if !revision.is_active() {
- // You can't edit an inactive revision.
+ log::debug!("Cannot edit revision {id} because it is not active.",);
return Err(ApplyError::UnexpectedState);
}
if revision.author.public_key() != &author {
- // Can't edit someone else's revision.
+ log::debug!(
+ "{} cannot edit revision created by {}.",
+ author,
+ revision.author.public_key()
+ );
// Since the author never changes, we can safely mark this as invalid.
return Err(ApplyError::NotAuthorized);
}
- assert_eq!(revision.parent, Some(current.id));
revision.title = title;
revision.description = description;
}
- Action::RevisionRedact { revision } => {
- if revision == self.current {
- // Can't redact the current revision.
- return Err(ApplyError::UnexpectedState);
+ Action::RevisionRedact { revision: id } => {
+ let revision = self.revision_mut(&id)?;
+
+ if revision.author.public_key() != &author {
+ log::debug!(
+ "{author} cannot redact revision created by {}.",
+ revision.author.public_key()
+ );
+ // Since the author never changes, we can safely mark this as invalid.
+ return Err(ApplyError::NotAuthorized);
}
- if let Some(revision) = self.revisions.get_mut(&revision) {
- if let Some(r) = revision {
- if r.is_accepted() {
- // You can't redact an accepted revision.
- return Err(ApplyError::UnexpectedState);
- }
- if r.author.public_key() != &author {
- // Can't redact someone else's revision.
- // Since the author never changes, we can safely mark this as invalid.
- return Err(ApplyError::NotAuthorized);
- }
- *revision = None;
- }
- } else {
- return Err(ApplyError::Missing(revision));
+
+ if !revision.is_active() {
+ log::debug!("Cannot redact inactive revision {id}.");
+ return Ok(());
}
+
+ log::debug!("Redacting revision {id}.");
+ revision.state = State::Redacted(RedactedBy::Author);
+
+ self.cascade(id, State::Redacted(RedactedBy::Parent));
}
Action::Revision {
title,
description,
blob,
signature,
- parent,
+ parent: parent_id,
} => {
- debug_assert!(!self.revisions.contains_key(&entry));
+ debug_assert_eq!(self.revisions.get(&id), None, "revision visited twice");
+
+ let doc = Doc::from_blob(&repo.blob(blob)?)?;
- let doc = repo.blob(blob)?;
- let doc = Doc::from_blob(&doc)?;
// All revisions but the first one must have a parent.
- let Some(parent) = parent else {
- return Err(ApplyError::MissingParent);
- };
- let Some(parent) = lookup::revision(&self.revisions, &parent)? else {
- return Err(ApplyError::Redacted);
- };
- // If the parent of this revision is no longer the current document, this
- // revision can be marked as outdated.
- let state = if parent.id == current.id {
- // If the revision is not outdated, we expect it to make a change to the
- // current version.
- if doc == parent.doc {
- return Err(ApplyError::DocUnchanged);
- }
- State::Active
- } else {
- State::Stale
- };
+ let parent_id = parent_id.ok_or(ApplyError::MissingParent)?;
+ let parent = self.revision(&parent_id).ok_or(ApplyError::MissingParent)?;
+
+ if !parent.is_delegate(&did) {
+ return Err(ApplyError::NonDelegateUnauthorized {
+ author: author.into(),
+ action: "create a revision".to_string(),
+ });
+ }
+
+ // We expect the revision to make a change compared to its parent.
+ if doc == parent.doc {
+ return Err(ApplyError::DocUnchanged);
+ }
// Verify signature over new blob, using trusted delegates.
if parent.verify_signature(&author, &signature, blob).is_err() {
return Err(ApplyError::InvalidSignature(author, blob));
}
+
+ // If the parent is already rejected or redacted, this revision is dead on arrival.
+ // Furthermore, if the parent is accepted but is NO LONGER the current revision,
+ // it means a sibling was already adopted and this is a late-arriving fork.
+ let state = match parent.state {
+ state @ (State::Rejected(RejectedBy::Parent)
+ | State::Redacted(RedactedBy::Parent)) => state,
+ State::Rejected(RejectedBy::Vote | RejectedBy::Sibling(_)) => {
+ State::Rejected(RejectedBy::Parent)
+ }
+ State::Redacted(RedactedBy::Author) => State::Redacted(RedactedBy::Parent),
+ State::Accepted => {
+ match parent
+ .children
+ .iter()
+ .find(|id| {
+ self.revisions
+ .get(id)
+ .is_some_and(|r| r.state == State::Accepted)
+ })
+ .copied()
+ {
+ Some(sibling) => {
+ log::debug!(
+ "Revision {id} is rejected because sibling {sibling} was already accepted.",
+ );
+ State::Rejected(RejectedBy::Sibling(sibling))
+ }
+ None => State::Active,
+ }
+ }
+ State::Active => State::Active,
+ };
+
let revision = Revision::new(
- entry,
+ id,
title,
description,
author.into(),
@@ -591,12 +665,12 @@ impl Identity {
doc,
state,
signature,
- Some(parent.id),
+ Some(parent_id),
timestamp,
);
- let id = revision.id;
- self.revisions.insert(id, Some(revision));
+ self.revisions.insert(id, revision);
+ self.revision_mut(&parent_id)?.children.push(id);
if state == State::Active {
self.adopt(id);
@@ -606,41 +680,134 @@ impl Identity {
Ok(())
}
- /// Try to adopt a revision as the current one.
+ /// Try to adopt an active revision as the current one.
+ ///
+ /// # Panics
+ ///
+ /// If the revision with the given ID is not active or lookup from
+ /// `self.revisions` returns a revision with a different ID.
+ ///
+ /// If the parent revision of the revision with given ID does not exist.
fn adopt(&mut self, id: RevisionId) {
if self.current == id {
return;
}
- let votes = self
- .revision(&id)
- .map(|revision| revision.accepted().count())
- .unwrap_or_default();
- if self.is_majority(votes) {
- self.current = id;
- self.current_mut().state = State::Accepted;
-
- // Void all other active revisions.
- for r in self
- .revisions
- .iter_mut()
- .filter_map(|(_, r)| r.as_mut())
- .filter(|r| r.state == State::Active)
- {
- r.state = State::Stale;
+
+ let candidate = self.revision(&id).expect("revision exists");
+
+ assert_eq!(candidate.state, State::Active);
+
+ let parent = candidate.parent.expect("revision has parent");
+ if parent != self.current {
+ log::debug!(
+ "Cannot adopt revision {} because its parent {} is not the current revision {}.",
+ id,
+ parent,
+ self.current
+ );
+ return;
+ }
+
+ let votes = candidate.accepted().count();
+ if !self.is_majority(votes) {
+ log::trace!(
+ "Revision {} has {} votes, but needs {} to be adopted.",
+ id,
+ votes,
+ self.majority()
+ );
+ return;
+ }
+
+ for sibling in self.siblings_of(&id).copied().collect::<Vec<_>>() {
+ let Some(revision) = self.revisions.get_mut(&sibling) else {
+ continue;
+ };
+
+ if revision.state != State::Active {
+ continue;
}
+
+ log::debug!(
+ "Adoption of {} causes {} (a sibling) to be rejected.",
+ id,
+ sibling
+ );
+
+ revision.state = State::Rejected(RejectedBy::Sibling(id));
+
+ self.cascade(sibling, State::Rejected(RejectedBy::Parent));
+ }
+
+ self.current = id;
+ self.revision_mut(&id)
+ .expect("current revision exists")
+ .state = State::Accepted;
+
+ // Re-evaluate active children under the new quorum rules.
+ // Because `self.current` just changed, the delegate list
+ // might have changed, thus `self.majority()` might have changed.
+ let children_to_adopt = self
+ .children_of(&id)
+ .filter(|child| {
+ self.revisions.get(child).is_some_and(|r| {
+ r.state == State::Active
+ && self
+ .is_majority(r.accepted().filter(|did| self.is_delegate(did)).count())
+ })
+ })
+ .copied()
+ .collect::<Vec<_>>();
+
+ // Recursively adopt any children that now meet the quorum.
+ for child in children_to_adopt {
+ self.adopt(child);
}
}
- /// A specific [`Revision`], mutably.
- fn revision_mut(&mut self, revision: &RevisionId) -> Option<&mut Revision> {
- self.revisions.get_mut(revision).and_then(|r| r.as_mut())
+ /// Apply state to all active children of the given revision, recursively.
+ fn cascade(&mut self, parent: RevisionId, state: State) {
+ debug_assert!(matches!(
+ state,
+ State::Rejected(RejectedBy::Parent) | State::Redacted(RedactedBy::Parent)
+ ));
+
+ let mut descendants = self.children_of(&parent).copied().collect::<Vec<_>>();
+
+ while let Some(next) = descendants.pop() {
+ let Some(revision) = self.revisions.get_mut(&next) else {
+ continue;
+ };
+
+ if revision.state != State::Active {
+ continue;
+ }
+
+ log::trace!(
+ "Cascading state from {} causes {} to be {}.",
+ parent,
+ next,
+ state,
+ );
+ revision.state = state;
+ descendants.extend(self.children_of(&next));
+ }
}
- /// The current revision, mutably.
- fn current_mut(&mut self) -> &mut Revision {
- let current = self.current;
- self.revision_mut(¤t)
- .expect("Identity::current_mut: the current revision must always exist")
+ /// A specific [`Revision`], mutably.
+ ///
+ /// # Errors
+ ///
+ /// Returns `ApplyError::Missing` if the revision is not found.
+ fn revision_mut(&mut self, id: &RevisionId) -> Result<&mut Revision, ApplyError> {
+ let revision = self.revisions.get_mut(id).ok_or(ApplyError::Missing(*id));
+
+ #[cfg(debug_assertions)]
+ if let Some(actual_id) = revision.as_ref().ok().map(|r| r.id) {
+ debug_assert_eq!(actual_id, *id)
+ }
+
+ revision
}
}
@@ -680,18 +847,49 @@ pub enum Verdict {
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum State {
- /// The revision is actively being voted on. From here, it can go into any of the
- /// other states.
+ /// The initial state of any revision.
+ ///
+ /// If a revision receives a majority of accepting votes, it is adopted and
+ /// transitions to [`Self::Accepted`]. Also, all its sibling revisions
+ /// transition to [`Self::Rejected`].
+ ///
+ /// If a revision receives a majority of rejecting votes,
+ /// it transitions to [`Self::Rejected`]. This has no impact on sibling
+ /// revisions.
+ ///
+ /// If a revision is redacted (this can only be done by its authoring
+ /// delegate), it transitions to [`Self::Redacted`]. From there, no further
+ /// state transitions are possible. This can be viewed as a form of
+ /// withdrawal of the revision.
Active,
- /// The revision has been accepted by a majority of delegates. Once accepted,
- /// a revision doesn't change state.
+ /// The revision was accepted by a majority of delegates.
+ /// Accepted revisions cannot be redacted or rejected.
Accepted,
- /// The revision was rejected by a majority of delegates. Once rejected,
- /// a revision doesn't change state.
- Rejected,
- /// The revision was active, but has been replaced by another revision,
- /// and is now outdated. Once stale, a revision doesn't change state.
- Stale,
+ /// The revision was rejected by a majority of delegates, or
+ /// a sibling revision was accepted by a majority of delegates or
+ /// an ancestor was rejected.
+ Rejected(RejectedBy),
+ /// The author decided to redact/withdraw the revision, or
+ /// an ancestor was redacted.
+ Redacted(RedactedBy),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+pub enum RejectedBy {
+ /// Rejected due to majority of delegates rejecting this revision.
+ Vote,
+ /// Rejected due to the parent revision being rejected.
+ Parent,
+ /// Rejected due to a sibling revision being accepted.
+ Sibling(RevisionId),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+pub enum RedactedBy {
+ /// Redacted by the author.
+ Author,
+ /// Redacted due to the parent revision being redacted.
+ Parent,
}
impl std::fmt::Display for State {
@@ -699,8 +897,43 @@ impl std::fmt::Display for State {
match self {
Self::Active => write!(f, "active"),
Self::Accepted => write!(f, "accepted"),
- Self::Rejected => write!(f, "rejected"),
- Self::Stale => write!(f, "stale"),
+ Self::Rejected(_) => write!(f, "rejected"),
+ Self::Redacted(_) => write!(f, "redacted"),
+ }
+ }
+}
+
+impl std::fmt::Display for RejectedBy {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ RejectedBy::Vote => write!(f, "vote"),
+ RejectedBy::Parent => write!(f, "parent"),
+ RejectedBy::Sibling(oid) => write!(f, "sibling '{oid}'"),
+ }
+ }
+}
+
+impl std::fmt::Display for RedactedBy {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ RedactedBy::Author => write!(f, "author"),
+ RedactedBy::Parent => write!(f, "parent"),
+ }
+ }
+}
+
+impl State {
+ /// The implementation of [`std::fmt::Display`] for [`State`] only displays
+ /// the state itself, but in some contexts it is useful to also display the
+ /// reason for rejection or redaction, if applicable.
+ /// This function returns a [`std::fmt::Display`] implementation that
+ /// includes the reason for [`Self::Rejected`] or [`Self::Redacted`].
+ pub fn display_with_reason(&self) -> impl std::fmt::Display {
+ const BY: &str = "by";
+ match self {
+ Self::Active | Self::Accepted => self.to_string(),
+ Self::Rejected(by) => format!("{self} {BY} {by}"),
+ Self::Redacted(by) => format!("{self} {BY} {by}"),
}
}
}
@@ -733,7 +966,10 @@ pub struct Revision {
pub parent: Option<RevisionId>,
/// Signatures and rejections given by the delegates.
- verdicts: BTreeMap<PublicKey, Verdict>,
+ verdicts: HashMap<PublicKey, Verdict>,
+
+ /// Children of this revision.
+ children: Vec<RevisionId>,
}
impl std::ops::Deref for Revision {
@@ -797,7 +1033,7 @@ impl Revision {
parent: Option<RevisionId>,
timestamp: Timestamp,
) -> Self {
- let verdicts = BTreeMap::from_iter([(*author.public_key(), Verdict::Accept(signature))]);
+ let verdicts = HashMap::from_iter([(*author.public_key(), Verdict::Accept(signature))]);
Self {
id,
@@ -809,45 +1045,10 @@ impl Revision {
state,
verdicts,
parent,
+ children: Vec::new(),
timestamp,
}
}
-
- fn accept(
- &mut self,
- author: PublicKey,
- signature: Signature,
- current: &Revision,
- ) -> Result<(), ApplyError> {
- // Check that this is a valid signature over the new document blob id.
- if current
- .verify_signature(&author, &signature, self.blob)
- .is_err()
- {
- return Err(ApplyError::InvalidSignature(author, self.blob));
- }
- if self
- .verdicts
- .insert(author, Verdict::Accept(signature))
- .is_some()
- {
- return Err(ApplyError::DuplicateVerdict);
- }
- Ok(())
- }
-
- fn reject(&mut self, key: PublicKey) -> Result<(), ApplyError> {
- if self.verdicts.insert(key, Verdict::Reject).is_some() {
- return Err(ApplyError::DuplicateVerdict);
- }
- // Mark as rejected if it's impossible for this revision to be accepted
- // with the current delegate set. Note that if the delegate set changes,
- // this proposal will be marked as `stale` anyway.
- if self.is_active() && self.rejected().count() > self.delegates().len() - self.majority() {
- self.state = State::Rejected;
- }
- Ok(())
- }
}
impl<R: ReadRepository> store::Transaction<Identity, R> {
@@ -1030,36 +1231,6 @@ impl<Repo, Signer> Deref for IdentityMut<'_, '_, Repo, Signer> {
}
}
-mod lookup {
- use super::*;
-
- pub fn revision_mut<'a>(
- revisions: &'a mut BTreeMap<RevisionId, Option<Revision>>,
- revision: &RevisionId,
- ) -> Result<Option<&'a mut Revision>, ApplyError> {
- match revisions.get_mut(revision) {
- Some(Some(revision)) => Ok(Some(revision)),
- // Redacted.
- Some(None) => Ok(None),
- // Missing. Causal error.
- None => Err(ApplyError::Missing(*revision)),
- }
- }
-
- pub fn revision<'a>(
- revisions: &'a BTreeMap<RevisionId, Option<Revision>>,
- revision: &RevisionId,
- ) -> Result<Option<&'a Revision>, ApplyError> {
- match revisions.get(revision) {
- Some(Some(revision)) => Ok(Some(revision)),
- // Redacted.
- Some(None) => Ok(None),
- // Missing. Causal error.
- None => Err(ApplyError::Missing(*revision)),
- }
- }
-}
-
#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod test {
@@ -1072,7 +1243,7 @@ mod test {
use crate::identity::doc::PayloadId;
use crate::node::device::Device;
use crate::rad;
- use crate::storage::ReadStorage;
+ use crate::storage::ReadStorage as _;
use crate::storage::git::Storage;
use crate::test::fixtures;
use crate::test::setup::{Network, NodeWithRepo};
@@ -1190,7 +1361,7 @@ mod test {
// 1/2 rejected means that we can never reach the required 2/2 votes.
bob_identity.reject(r2).unwrap();
let r2 = bob_identity.revision(&r2).unwrap();
- assert_eq!(r2.state, State::Rejected);
+ assert_eq!(r2.state, State::Rejected(RejectedBy::Vote));
// Now let's add another delegate.
doc.delegate(eve.public_key().into());
@@ -1227,7 +1398,7 @@ mod test {
// 2/3 rejected means that we can no longer reach the 2/3 required votes.
eve_identity.reject(r3.id).unwrap();
let r3 = eve_identity.revision(&r3.id).unwrap();
- assert_eq!(r3.state, State::Rejected);
+ assert_eq!(r3.state, State::Rejected(RejectedBy::Vote));
}
#[test]
@@ -1295,7 +1466,10 @@ mod test {
assert_eq!(bob_identity.current, a2);
assert_eq!(bob_identity.revision(&a1).unwrap().state, State::Accepted);
assert_eq!(bob_identity.revision(&a2).unwrap().state, State::Accepted);
- assert_eq!(bob_identity.revision(&b1).unwrap().state, State::Stale);
+ assert_eq!(
+ bob_identity.revision(&b1).unwrap().state,
+ State::Rejected(RejectedBy::Sibling(a2))
+ );
}
#[test]
@@ -1341,12 +1515,15 @@ mod test {
bob_identity.reload().unwrap();
assert_eq!(bob_identity.timeline, vec![a0, a1, a2, a3, b1]);
- assert_eq!(bob_identity.revision(&a2), None);
+ assert_eq!(
+ bob_identity.revision(&a2).unwrap().state,
+ State::Redacted(RedactedBy::Author)
+ );
assert_eq!(bob_identity.current, a1);
}
#[test]
- fn test_identity_remove_delegate_concurrent() {
+ fn remove_delegate_concurrent() {
let network = Network::default();
let alice = &network.alice;
let bob = &network.bob;
@@ -1357,6 +1534,8 @@ mod test {
alice_doc.delegate(bob.signer.public_key().into());
alice_doc.delegate(eve.signer.public_key().into());
+ assert_eq!(alice_doc.delegates.len(), 3);
+
let a0 = alice_identity.root;
let a1 = alice_identity // Change description to change traversal order.
.update(
@@ -1367,6 +1546,8 @@ mod test {
.unwrap();
alice_doc.rescind(&eve.signer.public_key().into()).unwrap();
+ assert_eq!(alice_doc.delegates.len(), 2);
+
let a2 = alice_identity
.update(
cob::Title::new("Remove Eve").unwrap(),
@@ -1412,8 +1593,11 @@ mod test {
eve_identity.reload().unwrap();
// Now that Eve reloaded, since Bob's vote to remove Eve went through first (b1 < e1),
// her revision is no longer valid.
- assert_eq!(eve_identity.timeline, vec![a0, a1, a2, b1]);
- assert_eq!(eve_identity.revision(&e1), None);
+ assert_eq!(eve_identity.timeline, vec![a0, a1, a2, b1, e1]);
+ assert_eq!(
+ eve_identity.revision(&e1).unwrap().state,
+ State::Rejected(RejectedBy::Sibling(a2))
+ );
assert!(!eve_identity.is_delegate(&eve.signer.public_key().into()));
}
@@ -1494,10 +1678,9 @@ mod test {
eve_identity.reload().unwrap();
assert_eq!(eve_identity.timeline, vec![a0, a1, a2, b1, e1, e2]);
- // Her revision is there, although stale, since another revision was accepted since.
- // However, it wasn't pruned, even though rejecting an accepted revision is an error.
+ // Her revision is there, but rejected, since a sibling revision was already accepted.
let e2 = eve_identity.revision(&e2).unwrap();
- assert_eq!(e2.state, State::Stale);
+ assert_eq!(e2.state, State::Rejected(RejectedBy::Sibling(a2)));
assert!(eve_identity.revision(&a2).unwrap().is_accepted());
}
@@ -1574,7 +1757,10 @@ mod test {
eve_identity.reload().unwrap();
assert_eq!(eve_identity.timeline, vec![a0, a1, b1, e1, a2]);
- assert_eq!(eve_identity.revision(&e1).unwrap().state, State::Stale);
+ assert_eq!(
+ eve_identity.revision(&e1).unwrap().state,
+ State::Rejected(RejectedBy::Sibling(b1))
+ );
}
#[test]
commit b145b95ee4205a1d18fbe6fb912f11c3dd864526
Author: Lorenz Leutgeb <lorenz.leutgeb@radicle.xyz>
Date: Mon Mar 30 17:57:28 2026 +0200
radicle/cob/identity: Use verdicts to count votes
Evaluation of this COB is implemented under the assumption that
delegates accept at most one revision.
This can lead to issues, if some delegates create new revisions eagerly,
without waiting for the others to vote on earlier revisions. As the
eager delegates start accepting newer and newer revisions, this shadows
their acceptance of earlier revisions, which leads to failure to
recognize that these earlier revisions were actually accepted by a
majority.
To avoid such situations, remove `heads`, and always count the number of
"accept" verdicts explicitly.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index bf037e90b..368e85d49 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -177,9 +177,6 @@ pub struct Identity {
pub current: RevisionId,
/// The initial revision of the document.
pub root: RevisionId,
- /// The latest revision that each delegate has accepted.
- /// Delegates can only accept one revision at a time.
- pub heads: BTreeMap<Did, RevisionId>,
/// Revisions.
revisions: BTreeMap<RevisionId, Option<Revision>>,
@@ -209,12 +206,6 @@ impl Identity {
id: revision.blob.into(),
root,
current: root,
- heads: revision
- .delegates()
- .iter()
- .copied()
- .map(|did| (did, root))
- .collect(),
revisions: BTreeMap::from_iter([(root, Some(revision))]),
timeline: vec![root],
}
@@ -493,7 +484,6 @@ impl Identity {
}
assert_eq!(revision.parent, Some(current.id));
- self.heads.insert(author.into(), id);
revision.accept(author, signature, ¤t)?;
self.adopt(id);
@@ -606,7 +596,6 @@ impl Identity {
);
let id = revision.id;
- self.heads.insert(author.into(), id);
self.revisions.insert(id, Some(revision));
if state == State::Active {
@@ -623,10 +612,9 @@ impl Identity {
return;
}
let votes = self
- .heads
- .values()
- .filter(|revision| **revision == id)
- .count();
+ .revision(&id)
+ .map(|revision| revision.accepted().count())
+ .unwrap_or_default();
if self.is_majority(votes) {
self.current = id;
self.current_mut().state = State::Accepted;
commit 442df34be72a0d4e01ef7e10b7afcc4aa0ee949b
Author: Lorenz Leutgeb <lorenz.leutgeb@radicle.xyz>
Date: Tue Mar 31 23:35:59 2026 +0200
radicle/cob/identity: Strengthen test assumptions
Not only assert that the revision is active, but
also its parent.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 31d8aab28..bf037e90b 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1482,7 +1482,10 @@ mod test {
&eve_doc.verified().unwrap(),
)
.unwrap();
- assert!(eve_identity.revision(&e2).unwrap().is_active());
+
+ let eve_revision = eve_identity.revision(&e2).unwrap();
+ assert_eq!(eve_revision.state, State::Active);
+ assert_eq!(eve_revision.parent, Some(a1));
// e2 (Propose "Change visibility") 1/2
// |
Exit code: 0
shell: 'export RUSTDOCFLAGS=''-D warnings'' cargo --version rustc --version cargo fmt --check cargo clippy --all-targets --workspace -- --deny warnings cargo build --all-targets --workspace cargo doc --workspace --no-deps --all-features cargo test --workspace --no-fail-fast '
Commands:
$ podman run --name 14e70052-96f5-4ea4-b33c-245ca967bbbf -v /opt/radcis/ci.rad.levitte.org/cci/state/14e70052-96f5-4ea4-b33c-245ca967bbbf/s:/14e70052-96f5-4ea4-b33c-245ca967bbbf/s:ro -v /opt/radcis/ci.rad.levitte.org/cci/state/14e70052-96f5-4ea4-b33c-245ca967bbbf/w:/14e70052-96f5-4ea4-b33c-245ca967bbbf/w -w /14e70052-96f5-4ea4-b33c-245ca967bbbf/w -v /opt/radcis/ci.rad.levitte.org/.radicle:/${id}/.radicle:ro -e RAD_HOME=/${id}/.radicle rust:trixie bash /14e70052-96f5-4ea4-b33c-245ca967bbbf/s/script.sh
+ export 'RUSTDOCFLAGS=-D warnings'
+ RUSTDOCFLAGS='-D warnings'
+ cargo --version
info: syncing channel updates for '1.95-x86_64-unknown-linux-gnu'
info: latest update on 2026-04-16, rust version 1.95.0 (59807616e 2026-04-14)
info: downloading component 'cargo'
info: downloading component 'clippy'
info: downloading component 'rust-docs'
info: downloading component 'rust-src'
info: downloading component 'rust-std'
info: downloading component 'rustc'
info: downloading component 'rustfmt'
info: installing component 'cargo'
info: installing component 'clippy'
info: installing component 'rust-docs'
info: installing component 'rust-src'
info: installing component 'rust-std'
info: installing component 'rustc'
info: installing component 'rustfmt'
cargo 1.95.0 (f2d3ce0bd 2026-03-21)
+ rustc --version
rustc 1.95.0 (59807616e 2026-04-14)
+ cargo fmt --check
+ cargo clippy --all-targets --workspace -- --deny warnings
Updating crates.io index
Downloading crates ...
Downloaded aead v0.5.2
Downloaded byteorder v1.5.0
Downloaded aho-corasick v1.1.4
Downloaded colorchoice v1.0.5
Downloaded aes-gcm v0.10.3
Downloaded heck v0.5.0
Downloaded gix-pack v0.70.0
Downloaded escargot v0.5.15
Downloaded dunce v1.0.5
Downloaded gix-diff v0.63.0
Downloaded gix-tempfile v23.0.0
Downloaded gix-validate v0.11.1
Downloaded getrandom v0.4.2
Downloaded human-panic v2.0.6
Downloaded hmac v0.12.1
Downloaded log v0.4.29
Downloaded gix-refspec v0.41.0
Downloaded gix-utils v0.3.2
Downloaded gix-shallow v0.12.0
Downloaded match-lookup v0.1.2
Downloaded gix-hash v0.25.0
Downloaded pem-rfc7468 v0.7.0
Downloaded data-encoding v2.10.0
Downloaded group v0.13.0
Downloaded crossbeam-channel v0.5.15
Downloaded parking_lot v0.12.5
Downloaded gix-url v0.36.0
Downloaded radicle-git-ext v0.12.0
Downloaded matchers v0.2.0
Downloaded nonempty v0.12.0
Downloaded once_cell v1.21.4
Downloaded lazy_static v1.5.0
Downloaded num v0.4.3
Downloaded hash32 v0.3.1
Downloaded inout v0.1.4
Downloaded pbkdf2 v0.12.2
Downloaded pkcs8 v0.10.2
Downloaded proc-macro-error2 v2.0.1
Downloaded outref v0.5.2
Downloaded phf_shared v0.11.3
Downloaded percent-encoding v2.3.2
Downloaded same-file v1.0.6
Downloaded qcheck v1.0.0
Downloaded jobserver v0.1.34
Downloaded quote v1.0.45
Downloaded sec1 v0.7.3
Downloaded salsa20 v0.10.2
Downloaded serde_spanned v1.0.4
Downloaded scopeguard v1.2.0
Downloaded gix-credentials v0.38.0
Downloaded semver v1.0.27
Downloaded rand_chacha v0.9.0
Downloaded signature v1.6.4
Downloaded shell-words v1.1.1
Downloaded serde-untagged v0.1.9
Downloaded radicle-std-ext v0.2.0
Downloaded num-integer v0.1.46
Downloaded siphasher v1.0.2
Downloaded stable_deref_trait v1.2.1
Downloaded siphasher v0.3.11
Downloaded shlex v1.3.0
Downloaded subtle v2.6.1
Downloaded test-log v0.2.19
Downloaded scrypt v0.11.0
Downloaded serde_core v1.0.228
Downloaded sval_serde v2.17.0
Downloaded serde_derive v1.0.228
Downloaded test-log-macros v0.2.19
Downloaded memmap2 v0.9.10
Downloaded thiserror v1.0.69
Downloaded synstructure v0.13.2
Downloaded timeago v0.4.2
Downloaded tree-sitter-language v0.1.7
Downloaded tinyvec_macros v0.1.1
Downloaded tree-sitter-html v0.23.2
Downloaded unicode-display-width v0.3.0
Downloaded sval_buffer v2.17.0
Downloaded unarray v0.1.4
Downloaded schemars v1.2.1
Downloaded zerofrom-derive v0.1.6
Downloaded zmij v1.0.21
Downloaded xattr v1.6.1
Downloaded version_check v0.9.5
Downloaded toml_writer v1.0.7+spec-1.1.0
Downloaded sqlite3-sys v0.18.0
Downloaded tree-sitter-go v0.23.4
Downloaded zerotrie v0.2.3
Downloaded typenum v1.19.0
Downloaded proptest v1.10.0
Downloaded zerovec-derive v0.11.2
Downloaded unicode-normalization v0.1.25
Downloaded zerovec v0.11.5
Downloaded tree-sitter v0.24.7
Downloaded tracing-core v0.1.36
Downloaded prodash v31.0.0
Downloaded zlib-rs v0.6.3
Downloaded vcpkg v0.2.15
Downloaded yansi v1.0.1
Downloaded zerocopy v0.8.42
Downloaded unicode-segmentation v1.12.0
Downloaded tree-sitter-md v0.3.2
Downloaded serde_json v1.0.149
Downloaded tree-sitter-rust v0.23.3
Downloaded tree-sitter-python v0.23.6
Downloaded portable-atomic v1.13.1
Downloaded syn v1.0.109
Downloaded tree-sitter-c v0.23.4
Downloaded git2 v0.20.4
Downloaded unicode-width v0.2.2
Downloaded syn v2.0.117
Downloaded gimli v0.32.3
Downloaded regex-syntax v0.8.10
Downloaded itertools v0.14.0
Downloaded regex-automata v0.4.14
Downloaded icu_properties_data v2.1.2
Downloaded rustix v1.1.4
Downloaded tree-sitter-bash v0.23.3
Downloaded url v2.5.8
Downloaded mio v1.1.1
Downloaded tracing v0.1.44
Downloaded sha1-checked v0.10.0
Downloaded tree-sitter-ruby v0.23.1
Downloaded jsonschema v0.30.0
Downloaded inquire v0.9.4
Downloaded idna v1.1.0
Downloaded hashbrown v0.16.1
Downloaded tree-sitter-typescript v0.23.2
Downloaded sval v2.17.0
Downloaded similar v3.1.1
Downloaded tokio v1.50.0
Downloaded object v0.37.3
Downloaded tar v0.4.45
Downloaded jiff v0.2.23
Downloaded rsa v0.9.10
Downloaded bstr v1.12.1
Downloaded tinyvec v1.11.0
Downloaded libc v0.2.183
Downloaded tracing-subscriber v0.3.23
Downloaded libz-sys v1.1.25
Downloaded sha3 v0.10.8
Downloaded sysinfo v0.37.2
Downloaded miniz_oxide v0.8.9
Downloaded memchr v2.8.0
Downloaded pretty_assertions v1.4.1
Downloaded indexmap v2.13.0
Downloaded flate2 v1.1.9
Downloaded fancy-regex v0.14.0
Downloaded yoke-derive v0.8.1
Downloaded yoke v0.8.1
Downloaded sharded-slab v0.1.7
Downloaded icu_properties v2.1.2
Downloaded gix-transport v0.57.0
Downloaded tree-sitter-toml-ng v0.6.0
Downloaded tempfile v3.27.0
Downloaded icu_locale_core v2.1.1
Downloaded gix-ref v0.63.0
Downloaded poly1305 v0.8.0
Downloaded value-bag v1.12.0
Downloaded uuid v1.22.0
Downloaded unicode-ident v1.0.24
Downloaded toml_datetime v0.7.5+spec-1.1.0
Downloaded ssh-key v0.6.7
Downloaded signals_receipts v0.2.5
Downloaded radicle-surf v0.27.1
Downloaded zeroize v1.8.2
Downloaded writeable v0.6.2
Downloaded walkdir v2.5.0
Downloaded vsimd v0.8.0
Downloaded toml v0.9.12+spec-1.1.0
Downloaded libm v0.2.16
Downloaded jiff-static v0.2.23
Downloaded indicatif v0.18.4
Downloaded icu_provider v2.1.1
Downloaded icu_collections v2.1.1
Downloaded cyphernet v0.5.4
Downloaded crossterm v0.29.0
Downloaded zerofrom v0.1.6
Downloaded wait-timeout v0.2.1
Downloaded value-bag-sval2 v1.12.0
Downloaded value-bag-serde1 v1.12.0
Downloaded uuid-simd v0.8.0
Downloaded utf8parse v0.2.2
Downloaded utf8_iter v1.0.4
Downloaded universal-hash v0.5.1
Downloaded unit-prefix v0.5.2
Downloaded typeid v1.0.3
Downloaded tree-sitter-highlight v0.24.7
Downloaded libgit2-sys v0.18.3+1.9.2
Downloaded tree-sitter-css v0.23.2
Downloaded thiserror-impl v2.0.18
Downloaded systemd-journal-logger v2.2.2
Downloaded structured-logger v1.0.5
Downloaded ssh-agent-lib v0.6.0
Downloaded serde v1.0.228
Downloaded p256 v0.13.2
Downloaded bloomy v1.2.0
Downloaded regex v1.12.3
Downloaded p521 v0.13.3
Downloaded rand v0.9.2
Downloaded fraction v0.15.3
Downloaded proc-macro2 v1.0.106
Downloaded ppv-lite86 v0.2.21
Downloaded num-bigint-dig v0.8.6
Downloaded tree-sitter-json v0.24.8
Downloaded tracing-log v0.2.0
Downloaded tinystr v0.8.2
Downloaded thread_local v1.1.9
Downloaded thiserror v2.0.18
Downloaded socket2 v0.5.10
Downloaded signal-hook-registry v1.4.8
Downloaded signal-hook v0.3.18
Downloaded sha2 v0.10.9
Downloaded thiserror-impl v1.0.69
Downloaded spin v0.9.8
Downloaded snapbox v1.2.2
Downloaded icu_normalizer v2.1.1
Downloaded sval_nested v2.17.0
Downloaded smallvec v1.15.1
Downloaded parking_lot_core v0.9.12
Downloaded litemap v0.8.1
Downloaded sval_json v2.17.0
Downloaded sval_fmt v2.17.0
Downloaded ssh-cipher v0.2.0
Downloaded sqlite v0.37.0
Downloaded simd-adler32 v0.3.8
Downloaded rand v0.8.5
Downloaded getrandom v0.2.17
Downloaded curve25519-dalek v4.1.3
Downloaded sval_ref v2.17.0
Downloaded sval_dynamic v2.17.0
Downloaded strsim v0.11.1
Downloaded streaming-iterator v0.1.9
Downloaded spki v0.7.3
Downloaded linux-raw-sys v0.12.1
Downloaded signature v2.2.0
Downloaded serde_derive_internals v0.29.1
Downloaded rusty-fork v0.3.1
Downloaded rustversion v1.0.22
Downloaded secrecy v0.10.3
Downloaded rustc-demangle v0.1.27
Downloaded pkg-config v0.3.32
Downloaded clap v4.6.0
Downloaded num-bigint v0.4.6
Downloaded ssh-encoding v0.2.0
Downloaded ryu v1.0.23
Downloaded rustc_version v0.4.1
Downloaded num-rational v0.4.2
Downloaded signal-hook-mio v0.2.5
Downloaded rand_core v0.9.5
Downloaded socks5-client v0.4.3
Downloaded snapbox-macros v1.1.0
Downloaded sha1 v0.10.6
Downloaded serde_fmt v1.1.0
Downloaded schemars_derive v1.2.1
Downloaded pin-project-lite v0.2.17
Downloaded ref-cast-impl v1.0.25
Downloaded phf v0.11.3
Downloaded iana-time-zone v0.1.65
Downloaded quick-error v1.2.3
Downloaded proc-macro-error-attr2 v2.0.0
Downloaded polyval v0.6.2
Downloaded num-iter v0.1.45
Downloaded lexopt v0.3.2
Downloaded sem_safe v0.2.1
Downloaded referencing v0.30.0
Downloaded crypto-bigint v0.5.5
Downloaded erased-serde v0.4.10
Downloaded qcheck-macros v1.0.0
Downloaded base64 v0.21.7
Downloaded keccak v0.1.6
Downloaded sqlite3-src v0.7.0
Downloaded rfc6979 v0.4.0
Downloaded ref-cast v1.0.25
Downloaded potential_utf v0.1.4
Downloaded rand_core v0.6.4
Downloaded rand_chacha v0.3.1
Downloaded pkcs1 v0.7.5
Downloaded opaque-debug v0.3.1
Downloaded num-cmp v0.1.0
Downloaded icu_normalizer_data v2.1.1
Downloaded filetime v0.2.27
Downloaded gix-protocol v0.61.0
Downloaded derive_more-impl v2.1.1
Downloaded num-traits v0.2.19
Downloaded maybe-async v0.2.10
Downloaded humantime v2.3.0
Downloaded gix-lock v23.0.0
Downloaded rand_xorshift v0.4.0
Downloaded emojis v0.6.4
Downloaded normalize-line-endings v0.3.0
Downloaded chacha20 v0.9.1
Downloaded base64ct v1.8.3
Downloaded anstyle-parse v0.2.7
Downloaded is_terminal_polyfill v1.70.2
Downloaded gix-quote v0.7.1
Downloaded fast-glob v0.3.3
Downloaded block-padding v0.3.3
Downloaded autocfg v1.5.0
Downloaded primeorder v0.13.6
Downloaded itoa v1.0.17
Downloaded gix-glob v0.26.0
Downloaded cc v1.2.57
Downloaded form_urlencoded v1.2.2
Downloaded pastey v0.2.1
Downloaded nu-ansi-term v0.50.3
Downloaded either v1.15.0
Downloaded gix-revision v0.45.0
Downloaded ghash v0.5.1
Downloaded block-buffer v0.10.4
Downloaded bit-set v0.8.0
Downloaded gix-prompt v0.15.0
Downloaded gix-hashtable v0.15.0
Downloaded git-ref-format-core v0.6.0
Downloaded ctr v0.9.2
Downloaded anstyle v1.0.14
Downloaded idna_adapter v1.2.1
Downloaded gix-traverse v0.57.0
Downloaded gix-fs v0.21.1
Downloaded git-ref-format v0.6.0
Downloaded num-complex v0.4.6
Downloaded faster-hex v0.10.0
Downloaded blowfish v0.9.1
Downloaded multibase v0.9.2
Downloaded document-features v0.2.12
Downloaded lock_api v0.4.14
Downloaded litrs v1.0.0
Downloaded gix-features v0.48.0
Downloaded env_logger v0.11.9
Downloaded crossbeam-utils v0.8.21
Downloaded chrono v0.4.44
Downloaded chacha20poly1305 v0.10.1
Downloaded bytecount v0.6.9
Downloaded anstream v0.6.21
Downloaded nonempty v0.9.0
Downloaded noise-framework v0.4.1
Downloaded gix-trace v0.1.19
Downloaded gix-actor v0.41.0
Downloaded bytes v1.11.1
Downloaded gix-odb v0.80.0
Downloaded gix-commitgraph v0.37.0
Downloaded env_filter v1.0.0
Downloaded ecdsa v0.16.9
Downloaded cyphergraphy v0.3.1
Downloaded p384 v0.13.1
Downloaded heapless v0.8.0
Downloaded gix-command v0.9.0
Downloaded amplify_num v0.5.3
Downloaded gix-packetline v0.21.3
Downloaded ed25519 v2.2.3
Downloaded data-encoding-macro v0.1.19
Downloaded bitflags v2.11.0
Downloaded base16ct v0.2.0
Downloaded bytesize v2.3.1
Downloaded amplify_syn v2.0.1
Downloaded gix-date v0.15.3
Downloaded derive_more v2.1.1
Downloaded curve25519-dalek-derive v0.1.1
Downloaded ct-codecs v1.1.6
Downloaded bit-vec v0.8.0
Downloaded base32 v0.4.0
Downloaded data-encoding-macro-internal v0.1.17
Downloaded gix-negotiate v0.31.0
Downloaded gix-chunk v0.7.1
Downloaded fastrand v2.3.0
Downloaded gix-sec v0.14.0
Downloaded gix-config-value v0.18.0
Downloaded equivalent v1.0.2
Downloaded ed25519-dalek v2.2.0
Downloaded cbc v0.1.2
Downloaded bcrypt-pbkdf v0.10.0
Downloaded adler2 v2.0.1
Downloaded clap_derive v4.6.0
Downloaded clap_builder v4.6.0
Downloaded ascii v1.1.0
Downloaded fnv v1.0.7
Downloaded ed25519 v1.5.3
Downloaded diff v0.1.13
Downloaded der v0.7.10
Downloaded base64 v0.22.1
Downloaded base256emoji v1.0.2
Downloaded base-x v0.2.11
Downloaded amplify_derive v4.0.1
Downloaded ec25519 v0.1.0
Downloaded digest v0.10.7
Downloaded email_address v0.2.9
Downloaded borrow-or-share v0.2.4
Downloaded anyhow v1.0.102
Downloaded amplify v4.9.0
Downloaded gix-path v0.12.0
Downloaded gix-object v0.60.0
Downloaded gix-error v0.2.3
Downloaded generic-array v0.14.7
Downloaded find-msvc-tools v0.1.9
Downloaded ff v0.13.1
Downloaded cipher v0.4.4
Downloaded anstyle-parse v1.0.0
Downloaded anstream v1.0.0
Downloaded cypheraddr v0.4.1
Downloaded backtrace v0.3.76
Downloaded arc-swap v1.9.1
Downloaded anstyle-query v1.1.5
Downloaded aes v0.8.4
Downloaded git-ref-format-macro v0.6.0
Downloaded cpufeatures v0.2.17
Downloaded clap_complete v4.6.0
Downloaded getrandom v0.3.4
Downloaded elliptic-curve v0.13.8
Downloaded dyn-clone v1.0.20
Downloaded crc32fast v1.5.0
Downloaded convert_case v0.10.0
Downloaded console v0.16.3
Downloaded crypto-common v0.1.7
Downloaded const-oid v0.9.6
Downloaded cfg-if v1.0.4
Downloaded ahash v0.8.12
Downloaded const-str v0.4.3
Downloaded addr2line v0.25.1
Downloaded displaydoc v0.2.5
Downloaded colored v2.2.0
Downloaded clap_lex v1.1.0
Downloaded gix-revwalk v0.31.0
Downloaded fluent-uri v0.3.2
Downloaded errno v0.3.14
Compiling libc v0.2.183
Compiling proc-macro2 v1.0.106
Compiling quote v1.0.45
Compiling unicode-ident v1.0.24
Checking cfg-if v1.0.4
Checking zeroize v1.8.2
Compiling version_check v0.9.5
Compiling typenum v1.19.0
Compiling generic-array v0.14.7
Checking getrandom v0.2.17
Checking rand_core v0.6.4
Compiling syn v2.0.117
Checking memchr v2.8.0
Compiling jobserver v0.1.34
Compiling find-msvc-tools v0.1.9
Compiling shlex v1.3.0
Checking crypto-common v0.1.7
Compiling cc v1.2.57
Checking subtle v2.6.1
Compiling serde_core v1.0.228
Checking regex-syntax v0.8.10
Checking aho-corasick v1.1.4
Checking const-oid v0.9.6
Checking smallvec v1.15.1
Checking block-buffer v0.10.4
Checking digest v0.10.7
Checking cpufeatures v0.2.17
Checking stable_deref_trait v1.2.1
Compiling thiserror v2.0.18
Checking fastrand v2.3.0
Compiling parking_lot_core v0.9.12
Checking regex-automata v0.4.14
Checking scopeguard v1.2.0
Checking lock_api v0.4.14
Checking bitflags v2.11.0
Checking parking_lot v0.12.5
Compiling typeid v1.0.3
Checking tinyvec_macros v0.1.1
Checking gix-trace v0.1.19
Compiling erased-serde v0.4.10
Compiling crc32fast v1.5.0
Checking tinyvec v1.11.0
Compiling serde v1.0.228
Checking unicode-normalization v0.1.25
Checking byteorder v1.5.0
Checking itoa v1.0.17
Checking gix-utils v0.3.2
Checking serde_fmt v1.1.0
Checking hashbrown v0.16.1
Checking value-bag-serde1 v1.12.0
Compiling synstructure v0.13.2
Compiling thiserror-impl v2.0.18
Checking bstr v1.12.1
Compiling serde_derive v1.0.228
Checking value-bag v1.12.0
Checking gix-validate v0.11.1
Compiling zerofrom-derive v0.1.6
Checking log v0.4.29
Checking same-file v1.0.6
Checking walkdir v2.5.0
Compiling yoke-derive v0.8.1
Checking gix-path v0.12.0
Checking prodash v31.0.0
Checking zerofrom v0.1.6
Checking zlib-rs v0.6.3
Compiling pkg-config v0.3.32
Checking yoke v0.8.1
Compiling heapless v0.8.0
Compiling rustix v1.1.4
Compiling zerovec-derive v0.11.2
Checking hash32 v0.3.1
Compiling autocfg v1.5.0
Checking gix-features v0.48.0
Checking linux-raw-sys v0.12.1
Compiling libm v0.2.16
Compiling num-traits v0.2.19
Checking zerovec v0.11.5
Compiling displaydoc v0.2.5
Compiling getrandom v0.4.2
Checking faster-hex v0.10.0
Checking block-padding v0.3.3
Compiling zerocopy v0.8.42
Checking inout v0.1.4
Checking sha1 v0.10.6
Checking sha2 v0.10.9
Checking sha1-checked v0.10.0
Checking cipher v0.4.4
Checking tinystr v0.8.2
Checking litemap v0.8.1
Checking once_cell v1.21.4
Checking writeable v0.6.2
Checking percent-encoding v2.3.2
Checking icu_locale_core v2.1.1
Checking gix-hash v0.25.0
Checking zerotrie v0.2.3
Checking potential_utf v0.1.4
Compiling zmij v1.0.21
Compiling icu_properties_data v2.1.2
Compiling icu_normalizer_data v2.1.1
Checking icu_provider v2.1.1
Checking icu_collections v2.1.1
Checking der v0.7.10
Compiling serde_json v1.0.149
Checking equivalent v1.0.2
Checking indexmap v2.13.0
Compiling ref-cast v1.0.25
Compiling syn v1.0.109
Compiling thiserror v1.0.69
Compiling vcpkg v0.2.15
Checking icu_properties v2.1.2
Compiling libz-sys v1.1.25
Checking icu_normalizer v2.1.1
Checking tempfile v3.27.0
Checking ppv-lite86 v0.2.21
Compiling ref-cast-impl v1.0.25
Compiling thiserror-impl v1.0.69
Checking spin v0.9.8
Checking lazy_static v1.5.0
Checking idna_adapter v1.2.1
Checking num-integer v0.1.46
Checking hmac v0.12.1
Checking universal-hash v0.5.1
Compiling tree-sitter-language v0.1.7
Checking dyn-clone v1.0.20
Checking utf8_iter v1.0.4
Checking opaque-debug v0.3.1
Checking idna v1.1.0
Checking spki v0.7.3
Compiling libgit2-sys v0.18.3+1.9.2
Checking signature v2.2.0
Checking ff v0.13.1
Checking base16ct v0.2.0
Checking group v0.13.0
Checking sec1 v0.7.3
Checking rand_chacha v0.3.1
Checking form_urlencoded v1.2.2
Compiling serde_derive_internals v0.29.1
Checking crypto-bigint v0.5.5
Compiling schemars_derive v1.2.1
Checking elliptic-curve v0.13.8
Compiling amplify_syn v2.0.1
Checking url v2.5.8
Checking rand v0.8.5
Checking num-iter v0.1.45
Checking aead v0.5.2
Checking signature v1.6.4
Compiling semver v1.0.27
Checking ed25519 v1.5.3
Compiling amplify_derive v4.0.1
Compiling rustc_version v0.4.1
Checking schemars v1.2.1
Checking poly1305 v0.8.0
Checking rfc6979 v0.4.0
Checking chacha20 v0.9.1
Checking ct-codecs v1.1.6
Checking ascii v1.1.0
Checking amplify_num v0.5.3
Checking ec25519 v0.1.0
Checking ecdsa v0.16.9
Compiling curve25519-dalek v4.1.3
Checking git-ref-format-core v0.6.0
Checking primeorder v0.13.6
Checking amplify v4.9.0
Checking polyval v0.6.2
Checking base64ct v1.8.3
Compiling num-bigint-dig v0.8.6
Checking pem-rfc7468 v0.7.0
Checking cyphergraphy v0.3.1
Checking ghash v0.5.1
Checking pkcs8 v0.10.2
Checking pbkdf2 v0.12.2
Checking ctr v0.9.2
Checking aes v0.8.4
Compiling sqlite3-src v0.7.0
Checking gix-error v0.2.3
Compiling curve25519-dalek-derive v0.1.1
Checking keccak v0.1.6
Checking sha3 v0.10.8
Checking aes-gcm v0.10.3
Checking pkcs1 v0.7.5
Checking ssh-encoding v0.2.0
Checking ed25519 v2.2.3
Checking cbc v0.1.2
Checking blowfish v0.9.1
Compiling crossbeam-utils v0.8.21
Checking base32 v0.4.0
Compiling data-encoding v2.10.0
Checking cypheraddr v0.4.1
Checking rsa v0.9.10
Compiling data-encoding-macro-internal v0.1.17
Checking bcrypt-pbkdf v0.10.0
Checking ssh-cipher v0.2.0
Checking ed25519-dalek v2.2.0
Checking p256 v0.13.2
Checking p384 v0.13.1
Checking p521 v0.13.3
Checking chacha20poly1305 v0.10.1
Checking qcheck v1.0.0
Compiling match-lookup v0.1.2
Checking const-str v0.4.3
Checking data-encoding-macro v0.1.19
Checking ssh-key v0.6.7
Checking base256emoji v1.0.2
Checking noise-framework v0.4.1
Checking socks5-client v0.4.3
Checking secrecy v0.10.3
Checking base-x v0.2.11
Checking multibase v0.9.2
Checking crossbeam-channel v0.5.15
Checking ssh-agent-lib v0.6.0
Checking cyphernet v0.5.4
Checking anstyle-query v1.1.5
Checking errno v0.3.14
Checking jiff v0.2.23
Checking utf8parse v0.2.2
Checking nonempty v0.9.0
Checking siphasher v1.0.2
Checking radicle-localtime v0.1.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-localtime)
Checking radicle-git-metadata v0.2.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-git-metadata)
Checking radicle-dag v0.10.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-dag)
Checking anstyle v1.0.14
Checking colorchoice v1.0.5
Checking is_terminal_polyfill v1.70.2
Checking radicle-git-ref-format v0.1.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-git-ref-format)
Checking gix-hashtable v0.15.0
Checking base64 v0.21.7
Compiling radicle v0.24.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle)
Compiling signal-hook v0.3.18
Compiling unicode-segmentation v1.12.0
Compiling convert_case v0.10.0
Checking signal-hook-registry v1.4.8
Checking gix-date v0.15.3
Checking gix-actor v0.41.0
Checking serde-untagged v0.1.9
Checking gix-object v0.60.0
Checking bytesize v2.3.1
Checking memmap2 v0.9.10
Checking fast-glob v0.3.3
Checking nonempty v0.12.0
Checking dunce v1.0.5
Compiling derive_more-impl v2.1.1
Checking gix-chunk v0.7.1
Checking mio v1.1.1
Checking regex v1.12.3
Checking sem_safe v0.2.1
Compiling portable-atomic v1.13.1
Compiling litrs v1.0.0
Checking unicode-width v0.2.2
Compiling document-features v0.2.12
Checking signals_receipts v0.2.5
Checking derive_more v2.1.1
Checking signal-hook-mio v0.2.5
Checking gix-commitgraph v0.37.0
Checking anstyle-parse v1.0.0
Checking anstream v1.0.0
Checking gix-revwalk v0.31.0
Checking crossterm v0.29.0
Checking console v0.16.3
Checking gix-fs v0.21.1
Checking unit-prefix v0.5.2
Checking gix-tempfile v23.0.0
Checking indicatif v0.18.4
Checking inquire v0.9.4
Checking unicode-display-width v0.3.0
Checking radicle-signals v0.11.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-signals)
Checking gix-quote v0.7.1
Checking iana-time-zone v0.1.65
Checking either v1.15.0
Checking shell-words v1.1.1
Checking gix-command v0.9.0
Checking chrono v0.4.44
Checking colored v2.2.0
Compiling object v0.37.3
Compiling rustversion v1.0.22
Checking gix-lock v23.0.0
Checking gix-url v0.36.0
Checking gix-config-value v0.18.0
Checking gix-sec v0.14.0
Checking adler2 v2.0.1
Checking gimli v0.32.3
Checking miniz_oxide v0.8.9
Checking gix-prompt v0.15.0
Checking addr2line v0.25.1
Checking gix-revision v0.45.0
Checking gix-traverse v0.57.0
Checking gix-diff v0.63.0
Checking anstyle-parse v0.2.7
Checking gix-packetline v0.21.3
Checking gix-glob v0.26.0
Compiling tree-sitter v0.24.7
Checking rustc-demangle v0.1.27
Compiling anyhow v1.0.102
Checking backtrace v0.3.76
Checking gix-refspec v0.41.0
Checking gix-transport v0.57.0
Checking anstream v0.6.21
Checking gix-pack v0.70.0
Checking arc-swap v1.9.1
Checking gix-credentials v0.38.0
Checking gix-ref v0.63.0
Checking gix-shallow v0.12.0
Checking gix-negotiate v0.31.0
Compiling maybe-async v0.2.10
Compiling proc-macro-error-attr2 v2.0.0
Compiling getrandom v0.3.4
Compiling simd-adler32 v0.3.8
Checking gix-protocol v0.61.0
Compiling proc-macro-error2 v2.0.1
Checking gix-odb v0.80.0
Compiling xattr v1.6.1
Compiling filetime v0.2.27
Checking uuid v1.22.0
Checking bytes v1.11.1
Compiling flate2 v1.1.9
Compiling tar v0.4.45
Compiling git-ref-format-macro v0.6.0
Checking snapbox-macros v1.1.0
Checking salsa20 v0.10.2
Checking similar v3.1.1
Checking siphasher v0.3.11
Checking clap_lex v1.1.0
Checking streaming-iterator v0.1.9
Compiling heck v0.5.0
Checking strsim v0.11.1
Checking normalize-line-endings v0.3.0
Checking clap_builder v4.6.0
Checking snapbox v1.2.2
Compiling clap_derive v4.6.0
Checking bloomy v1.2.0
Checking scrypt v0.11.0
Compiling radicle-surf v0.27.1
Checking git-ref-format v0.6.0
Checking systemd-journal-logger v2.2.2
Checking toml_datetime v0.7.5+spec-1.1.0
Checking serde_spanned v1.0.4
Compiling tree-sitter-python v0.23.6
Compiling tree-sitter-md v0.3.2
Compiling tree-sitter-ruby v0.23.1
Compiling tree-sitter-c v0.23.4
Compiling tree-sitter-json v0.24.8
Compiling tree-sitter-rust v0.23.3
Compiling tree-sitter-typescript v0.23.2
Compiling tree-sitter-toml-ng v0.6.0
Compiling tree-sitter-css v0.23.2
Compiling tree-sitter-go v0.23.4
Compiling tree-sitter-html v0.23.2
Compiling tree-sitter-bash v0.23.3
Checking pin-project-lite v0.2.17
Checking radicle-std-ext v0.2.0
Checking toml_writer v1.0.7+spec-1.1.0
Checking toml v0.9.12+spec-1.1.0
Checking tokio v1.50.0
Checking sqlite3-sys v0.18.0
Checking sqlite v0.37.0
Checking radicle-crypto v0.17.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-crypto)
Checking clap v4.6.0
Checking sysinfo v0.37.2
Checking yansi v1.0.1
Compiling radicle-node v0.20.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-node)
Checking diff v0.1.13
Compiling radicle-cli v0.21.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-cli)
Checking pretty_assertions v1.4.1
Checking human-panic v2.0.6
Checking clap_complete v4.6.0
Checking structured-logger v1.0.5
Checking radicle-systemd v0.13.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-systemd)
Checking tree-sitter-highlight v0.24.7
Checking itertools v0.14.0
Compiling qcheck-macros v1.0.0
Checking socket2 v0.5.10
Checking humantime v2.3.0
Compiling escargot v0.5.15
Checking timeago v0.4.2
Checking lexopt v0.3.2
Checking bit-vec v0.8.0
Checking bit-set v0.8.0
Checking rand_core v0.9.5
Checking num-bigint v0.4.6
Compiling ahash v0.8.12
Checking num-complex v0.4.6
Checking env_filter v1.0.0
Checking borrow-or-share v0.2.4
Checking fluent-uri v0.3.2
Checking env_logger v0.11.9
Checking phf_shared v0.11.3
Compiling test-log-macros v0.2.19
Checking num-rational v0.4.2
Checking wait-timeout v0.2.1
Compiling radicle-remote-helper v0.17.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-remote-helper)
Checking num v0.4.3
Checking outref v0.5.2
Checking quick-error v1.2.3
Checking fnv v1.0.7
Checking vsimd v0.8.0
Checking rusty-fork v0.3.1
Checking test-log v0.2.19
Checking fraction v0.15.3
Checking phf v0.11.3
Checking uuid-simd v0.8.0
Checking referencing v0.30.0
Checking rand_chacha v0.9.0
Checking rand_xorshift v0.4.0
Checking rand v0.9.2
Checking fancy-regex v0.14.0
Checking email_address v0.2.9
Checking base64 v0.22.1
Checking num-cmp v0.1.0
Checking bytecount v0.6.9
Checking unarray v0.1.4
Checking emojis v0.6.4
Checking proptest v1.10.0
Checking jsonschema v0.30.0
Compiling pastey v0.2.1
Checking radicle-windows v0.1.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-windows)
Checking git2 v0.20.4
Checking radicle-oid v0.2.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-oid)
Checking radicle-term v0.18.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-term)
Checking radicle-git-ext v0.12.0
Checking radicle-core v0.3.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-core)
Checking radicle-cob v0.20.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-cob)
Checking radicle-log v0.1.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-log)
Checking radicle-fetch v0.20.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-fetch)
Checking radicle-cli-test v0.13.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-cli-test)
Checking radicle-protocol v0.8.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-protocol)
Checking radicle-schemars v0.8.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-schemars)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 40.10s
+ cargo build --all-targets --workspace
Compiling libc v0.2.183
Compiling cfg-if v1.0.4
Compiling zeroize v1.8.2
Compiling typenum v1.19.0
Compiling memchr v2.8.0
Compiling shlex v1.3.0
Compiling subtle v2.6.1
Compiling regex-syntax v0.8.10
Compiling generic-array v0.14.7
Compiling getrandom v0.2.17
Compiling jobserver v0.1.34
Compiling rand_core v0.6.4
Compiling cc v1.2.57
Compiling crypto-common v0.1.7
Compiling aho-corasick v1.1.4
Compiling serde_core v1.0.228
Compiling const-oid v0.9.6
Compiling regex-automata v0.4.14
Compiling smallvec v1.15.1
Compiling block-buffer v0.10.4
Compiling digest v0.10.7
Compiling cpufeatures v0.2.17
Compiling stable_deref_trait v1.2.1
Compiling bitflags v2.11.0
Compiling fastrand v2.3.0
Compiling thiserror v2.0.18
Compiling scopeguard v1.2.0
Compiling lock_api v0.4.14
Compiling parking_lot_core v0.9.12
Compiling gix-trace v0.1.19
Compiling tinyvec_macros v0.1.1
Compiling parking_lot v0.12.5
Compiling tinyvec v1.11.0
Compiling typeid v1.0.3
Compiling erased-serde v0.4.10
Compiling itoa v1.0.17
Compiling unicode-normalization v0.1.25
Compiling byteorder v1.5.0
Compiling serde v1.0.228
Compiling crc32fast v1.5.0
Compiling gix-utils v0.3.2
Compiling serde_fmt v1.1.0
Compiling hashbrown v0.16.1
Compiling value-bag-serde1 v1.12.0
Compiling same-file v1.0.6
Compiling value-bag v1.12.0
Compiling walkdir v2.5.0
Compiling log v0.4.29
Compiling zerofrom v0.1.6
Compiling prodash v31.0.0
Compiling zlib-rs v0.6.3
Compiling bstr v1.12.1
Compiling yoke v0.8.1
Compiling gix-validate v0.11.1
Compiling gix-path v0.12.0
Compiling hash32 v0.3.1
Compiling linux-raw-sys v0.12.1
Compiling zerovec v0.11.5
Compiling heapless v0.8.0
Compiling rustix v1.1.4
Compiling faster-hex v0.10.0
Compiling libm v0.2.16
Compiling block-padding v0.3.3
Compiling inout v0.1.4
Compiling getrandom v0.4.2
Compiling sha2 v0.10.9
Compiling num-traits v0.2.19
Compiling sha1 v0.10.6
Compiling sha1-checked v0.10.0
Compiling cipher v0.4.4
Compiling zerocopy v0.8.42
Compiling gix-features v0.48.0
Compiling tinystr v0.8.2
Compiling once_cell v1.21.4
Compiling percent-encoding v2.3.2
Compiling litemap v0.8.1
Compiling writeable v0.6.2
Compiling gix-hash v0.25.0
Compiling icu_locale_core v2.1.1
Compiling zerotrie v0.2.3
Compiling potential_utf v0.1.4
Compiling icu_collections v2.1.1
Compiling der v0.7.10
Compiling icu_provider v2.1.1
Compiling equivalent v1.0.2
Compiling indexmap v2.13.0
Compiling icu_properties_data v2.1.2
Compiling icu_normalizer_data v2.1.1
Compiling zmij v1.0.21
Compiling libz-sys v1.1.25
Compiling serde_json v1.0.149
Compiling icu_normalizer v2.1.1
Compiling icu_properties v2.1.2
Compiling ppv-lite86 v0.2.21
Compiling tempfile v3.27.0
Compiling spin v0.9.8
Compiling lazy_static v1.5.0
Compiling ref-cast v1.0.25
Compiling idna_adapter v1.2.1
Compiling num-integer v0.1.46
Compiling hmac v0.12.1
Compiling universal-hash v0.5.1
Compiling utf8_iter v1.0.4
Compiling opaque-debug v0.3.1
Compiling dyn-clone v1.0.20
Compiling thiserror v1.0.69
Compiling idna v1.1.0
Compiling spki v0.7.3
Compiling libgit2-sys v0.18.3+1.9.2
Compiling signature v2.2.0
Compiling ff v0.13.1
Compiling base16ct v0.2.0
Compiling group v0.13.0
Compiling sec1 v0.7.3
Compiling rand_chacha v0.3.1
Compiling form_urlencoded v1.2.2
Compiling crypto-bigint v0.5.5
Compiling url v2.5.8
Compiling rand v0.8.5
Compiling num-iter v0.1.45
Compiling aead v0.5.2
Compiling signature v1.6.4
Compiling elliptic-curve v0.13.8
Compiling ed25519 v1.5.3
Compiling schemars v1.2.1
Compiling poly1305 v0.8.0
Compiling rfc6979 v0.4.0
Compiling chacha20 v0.9.1
Compiling ct-codecs v1.1.6
Compiling amplify_num v0.5.3
Compiling ascii v1.1.0
Compiling ec25519 v0.1.0
Compiling ecdsa v0.16.9
Compiling amplify v4.9.0
Compiling primeorder v0.13.6
Compiling git-ref-format-core v0.6.0
Compiling polyval v0.6.2
Compiling base64ct v1.8.3
Compiling ghash v0.5.1
Compiling cyphergraphy v0.3.1
Compiling pem-rfc7468 v0.7.0
Compiling pkcs8 v0.10.2
Compiling pbkdf2 v0.12.2
Compiling aes v0.8.4
Compiling ctr v0.9.2
Compiling sqlite3-src v0.7.0
Compiling gix-error v0.2.3
Compiling keccak v0.1.6
Compiling sha3 v0.10.8
Compiling aes-gcm v0.10.3
Compiling curve25519-dalek v4.1.3
Compiling pkcs1 v0.7.5
Compiling ssh-encoding v0.2.0
Compiling num-bigint-dig v0.8.6
Compiling ed25519 v2.2.3
Compiling cbc v0.1.2
Compiling blowfish v0.9.1
Compiling base32 v0.4.0
Compiling cypheraddr v0.4.1
Compiling rsa v0.9.10
Compiling bcrypt-pbkdf v0.10.0
Compiling ssh-cipher v0.2.0
Compiling ed25519-dalek v2.2.0
Compiling p384 v0.13.1
Compiling p256 v0.13.2
Compiling p521 v0.13.3
Compiling chacha20poly1305 v0.10.1
Compiling qcheck v1.0.0
Compiling const-str v0.4.3
Compiling data-encoding v2.10.0
Compiling data-encoding-macro v0.1.19
Compiling base256emoji v1.0.2
Compiling ssh-key v0.6.7
Compiling noise-framework v0.4.1
Compiling socks5-client v0.4.3
Compiling crossbeam-utils v0.8.21
Compiling secrecy v0.10.3
Compiling base-x v0.2.11
Compiling multibase v0.9.2
Compiling ssh-agent-lib v0.6.0
Compiling crossbeam-channel v0.5.15
Compiling cyphernet v0.5.4
Compiling anstyle-query v1.1.5
Compiling errno v0.3.14
Compiling utf8parse v0.2.2
Compiling jiff v0.2.23
Compiling nonempty v0.9.0
Compiling siphasher v1.0.2
Compiling radicle-localtime v0.1.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-localtime)
Compiling radicle-dag v0.10.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-dag)
Compiling radicle-git-metadata v0.2.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-git-metadata)
Compiling colorchoice v1.0.5
Compiling anstyle v1.0.14
Compiling unicode-segmentation v1.12.0
Compiling is_terminal_polyfill v1.70.2
Compiling radicle-git-ref-format v0.1.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-git-ref-format)
Compiling gix-hashtable v0.15.0
Compiling base64 v0.21.7
Compiling radicle v0.24.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle)
Compiling convert_case v0.10.0
Compiling signal-hook-registry v1.4.8
Compiling gix-date v0.15.3
Compiling gix-actor v0.41.0
Compiling gix-object v0.60.0
Compiling tree-sitter-language v0.1.7
Compiling serde-untagged v0.1.9
Compiling bytesize v2.3.1
Compiling memmap2 v0.9.10
Compiling nonempty v0.12.0
Compiling dunce v1.0.5
Compiling fast-glob v0.3.3
Compiling signal-hook v0.3.18
Compiling derive_more-impl v2.1.1
Compiling gix-chunk v0.7.1
Compiling mio v1.1.1
Compiling regex v1.12.3
Compiling sem_safe v0.2.1
Compiling unicode-width v0.2.2
Compiling signals_receipts v0.2.5
Compiling signal-hook-mio v0.2.5
Compiling derive_more v2.1.1
Compiling gix-commitgraph v0.37.0
Compiling anstyle-parse v1.0.0
Compiling adler2 v2.0.1
Compiling gix-revwalk v0.31.0
Compiling anstream v1.0.0
Compiling crossterm v0.29.0
Compiling console v0.16.3
Compiling portable-atomic v1.13.1
Compiling gix-fs v0.21.1
Compiling unit-prefix v0.5.2
Compiling gix-tempfile v23.0.0
Compiling indicatif v0.18.4
Compiling inquire v0.9.4
Compiling radicle-signals v0.11.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-signals)
Compiling unicode-display-width v0.3.0
Compiling gix-quote v0.7.1
Compiling either v1.15.0
Compiling iana-time-zone v0.1.65
Compiling shell-words v1.1.1
Compiling gix-command v0.9.0
Compiling chrono v0.4.44
Compiling colored v2.2.0
Compiling gix-lock v23.0.0
Compiling gix-url v0.36.0
Compiling gix-config-value v0.18.0
Compiling gix-sec v0.14.0
Compiling gimli v0.32.3
Compiling gix-prompt v0.15.0
Compiling object v0.37.3
Compiling addr2line v0.25.1
Compiling gix-revision v0.45.0
Compiling gix-traverse v0.57.0
Compiling miniz_oxide v0.8.9
Compiling gix-diff v0.63.0
Compiling anstyle-parse v0.2.7
Compiling gix-glob v0.26.0
Compiling gix-packetline v0.21.3
Compiling tree-sitter v0.24.7
Compiling rustc-demangle v0.1.27
Compiling backtrace v0.3.76
Compiling gix-refspec v0.41.0
Compiling gix-transport v0.57.0
Compiling gix-pack v0.70.0
Compiling sqlite3-sys v0.18.0
Compiling sqlite v0.37.0
Compiling radicle-crypto v0.17.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-crypto)
Compiling anstream v0.6.21
Compiling arc-swap v1.9.1
Compiling gix-credentials v0.38.0
Compiling gix-shallow v0.12.0
Compiling gix-ref v0.63.0
Compiling gix-negotiate v0.31.0
Compiling gix-odb v0.80.0
Compiling xattr v1.6.1
Compiling gix-protocol v0.61.0
Compiling uuid v1.22.0
Compiling filetime v0.2.27
Compiling bytes v1.11.1
Compiling tar v0.4.45
Compiling git-ref-format-macro v0.6.0
Compiling flate2 v1.1.9
Compiling getrandom v0.3.4
Compiling anyhow v1.0.102
Compiling snapbox-macros v1.1.0
Compiling salsa20 v0.10.2
Compiling similar v3.1.1
Compiling strsim v0.11.1
Compiling clap_lex v1.1.0
Compiling streaming-iterator v0.1.9
Compiling normalize-line-endings v0.3.0
Compiling siphasher v0.3.11
Compiling bloomy v1.2.0
Compiling snapbox v1.2.2
Compiling clap_builder v4.6.0
Compiling radicle-surf v0.27.1
Compiling scrypt v0.11.0
Compiling git-ref-format v0.6.0
Compiling systemd-journal-logger v2.2.2
Compiling serde_spanned v1.0.4
Compiling toml_datetime v0.7.5+spec-1.1.0
Compiling tree-sitter-css v0.23.2
Compiling tree-sitter-ruby v0.23.1
Compiling tree-sitter-python v0.23.6
Compiling tree-sitter-bash v0.23.3
Compiling tree-sitter-go v0.23.4
Compiling tree-sitter-md v0.3.2
Compiling tree-sitter-c v0.23.4
Compiling tree-sitter-rust v0.23.3
Compiling tree-sitter-html v0.23.2
Compiling tree-sitter-toml-ng v0.6.0
Compiling tree-sitter-json v0.24.8
Compiling tree-sitter-typescript v0.23.2
Compiling toml_writer v1.0.7+spec-1.1.0
Compiling pin-project-lite v0.2.17
Compiling radicle-std-ext v0.2.0
Compiling tokio v1.50.0
Compiling toml v0.9.12+spec-1.1.0
Compiling clap v4.6.0
Compiling sysinfo v0.37.2
Compiling radicle-node v0.20.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-node)
Compiling yansi v1.0.1
Compiling radicle-cli v0.21.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-cli)
Compiling diff v0.1.13
Compiling pretty_assertions v1.4.1
Compiling human-panic v2.0.6
Compiling clap_complete v4.6.0
Compiling structured-logger v1.0.5
Compiling radicle-systemd v0.13.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-systemd)
Compiling tree-sitter-highlight v0.24.7
Compiling itertools v0.14.0
Compiling socket2 v0.5.10
Compiling humantime v2.3.0
Compiling lexopt v0.3.2
Compiling timeago v0.4.2
Compiling bit-vec v0.8.0
Compiling escargot v0.5.15
Compiling bit-set v0.8.0
Compiling rand_core v0.9.5
Compiling num-bigint v0.4.6
Compiling num-complex v0.4.6
Compiling env_filter v1.0.0
Compiling borrow-or-share v0.2.4
Compiling fluent-uri v0.3.2
Compiling num-rational v0.4.2
Compiling num v0.4.3
Compiling env_logger v0.11.9
Compiling ahash v0.8.12
Compiling phf_shared v0.11.3
Compiling wait-timeout v0.2.1
Compiling outref v0.5.2
Compiling radicle-remote-helper v0.17.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-remote-helper)
Compiling quick-error v1.2.3
Compiling vsimd v0.8.0
Compiling fnv v1.0.7
Compiling rusty-fork v0.3.1
Compiling test-log v0.2.19
Compiling uuid-simd v0.8.0
Compiling phf v0.11.3
Compiling referencing v0.30.0
Compiling fraction v0.15.3
Compiling git2 v0.20.4
Compiling rand_chacha v0.9.0
Compiling rand v0.9.2
Compiling rand_xorshift v0.4.0
Compiling fancy-regex v0.14.0
Compiling email_address v0.2.9
Compiling num-cmp v0.1.0
Compiling base64 v0.22.1
Compiling bytecount v0.6.9
Compiling unarray v0.1.4
Compiling jsonschema v0.30.0
Compiling proptest v1.10.0
Compiling emojis v0.6.4
Compiling radicle-oid v0.2.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-oid)
Compiling radicle-term v0.18.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-term)
Compiling radicle-cob v0.20.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-cob)
Compiling radicle-core v0.3.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-core)
Compiling radicle-log v0.1.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-log)
Compiling radicle-git-ext v0.12.0
Compiling radicle-windows v0.1.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-windows)
Compiling radicle-fetch v0.20.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-fetch)
Compiling radicle-protocol v0.8.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-protocol)
Compiling radicle-cli-test v0.13.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-cli-test)
Compiling radicle-schemars v0.8.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-schemars)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 58.47s
+ cargo doc --workspace --no-deps --all-features
Downloading crates ...
Downloaded dhat v0.3.3
Downloaded thousands v0.2.0
Downloaded mintex v0.1.4
Downloaded rustc-hash v1.1.0
Checking regex-automata v0.4.14
Compiling num-traits v0.2.19
Checking once_cell v1.21.4
Compiling syn v1.0.109
Checking tempfile v3.27.0
Checking idna v1.1.0
Checking url v2.5.8
Checking git2 v0.20.4
Checking num-integer v0.1.46
Checking num-iter v0.1.45
Checking num-bigint-dig v0.8.6
Compiling amplify_syn v2.0.1
Checking bstr v1.12.1
Checking gix-validate v0.11.1
Checking git-ref-format-core v0.6.0
Checking gix-path v0.12.0
Checking gix-error v0.2.3
Compiling amplify_derive v4.0.1
Checking gix-features v0.48.0
Checking rsa v0.9.10
Checking gix-hash v0.25.0
Checking radicle-git-ref-format v0.1.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-git-ref-format)
Checking gix-date v0.15.3
Checking ssh-key v0.6.7
Checking radicle-oid v0.2.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-oid)
Checking rusty-fork v0.3.1
Checking gix-actor v0.41.0
Checking gix-hashtable v0.15.0
Checking proptest v1.10.0
Checking gix-object v0.60.0
Checking ssh-agent-lib v0.6.0
Checking radicle-localtime v0.1.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-localtime)
Checking radicle-git-metadata v0.2.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-git-metadata)
Checking radicle-dag v0.10.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-dag)
Checking gix-chunk v0.7.1
Checking gix-fs v0.21.1
Checking amplify v4.9.0
Checking gix-commitgraph v0.37.0
Checking gix-tempfile v23.0.0
Checking gix-revwalk v0.31.0
Checking gix-quote v0.7.1
Checking cyphergraphy v0.3.1
Checking regex v1.12.3
Checking inquire v0.9.4
Checking cypheraddr v0.4.1
Checking noise-framework v0.4.1
Checking radicle-signals v0.11.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-signals)
Checking gix-command v0.9.0
Checking chrono v0.4.44
Checking socks5-client v0.4.3
Checking radicle-term v0.18.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-term)
Checking gix-lock v23.0.0
Checking gix-config-value v0.18.0
Checking cyphernet v0.5.4
Checking radicle-crypto v0.17.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-crypto)
Checking gix-url v0.36.0
Checking gix-prompt v0.15.0
Checking radicle-core v0.3.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-core)
Checking radicle-cob v0.20.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-cob)
Checking gix-traverse v0.57.0
Checking gix-revision v0.45.0
Checking gix-diff v0.63.0
Checking gix-glob v0.26.0
Checking gix-packetline v0.21.3
Checking tree-sitter v0.24.7
Checking gix-refspec v0.41.0
Checking gix-transport v0.57.0
Checking radicle v0.24.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle)
Checking gix-pack v0.70.0
Checking radicle-log v0.1.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-log)
Checking git-ref-format v0.6.0
Checking gix-credentials v0.38.0
Checking gix-shallow v0.12.0
Checking gix-ref v0.63.0
Checking gix-negotiate v0.31.0
Checking radicle-git-ext v0.12.0
Checking uuid v1.22.0
Checking gix-protocol v0.61.0
Compiling radicle-cli v0.21.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-cli)
Checking human-panic v2.0.6
Checking gix-odb v0.80.0
Checking radicle-surf v0.27.1
Checking tree-sitter-toml-ng v0.6.0
Checking tree-sitter-highlight v0.24.7
Checking rustc-hash v1.1.0
Checking thousands v0.2.0
Checking mintex v0.1.4
Compiling radicle-node v0.20.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-node)
Checking radicle-systemd v0.13.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-systemd)
Checking dhat v0.3.3
Documenting radicle-systemd v0.13.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-systemd)
Documenting radicle v0.24.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle)
Documenting radicle-log v0.1.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-log)
Documenting radicle-cob v0.20.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-cob)
Documenting radicle-core v0.3.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-core)
Documenting radicle-crypto v0.17.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-crypto)
Documenting radicle-term v0.18.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-term)
Documenting radicle-signals v0.11.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-signals)
Documenting radicle-oid v0.2.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-oid)
Documenting radicle-git-ref-format v0.1.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-git-ref-format)
Documenting radicle-localtime v0.1.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-localtime)
Documenting radicle-git-metadata v0.2.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-git-metadata)
Documenting radicle-dag v0.10.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-dag)
Documenting radicle-windows v0.1.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-windows)
Checking radicle-fetch v0.20.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-fetch)
Documenting radicle-cli v0.21.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-cli)
Documenting radicle-cli-test v0.13.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-cli-test)
Checking radicle-protocol v0.8.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-protocol)
Documenting radicle-protocol v0.8.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-protocol)
Documenting radicle-node v0.20.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-node)
Documenting radicle-schemars v0.8.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-schemars)
Documenting radicle-remote-helper v0.17.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-remote-helper)
Documenting radicle-fetch v0.20.0 (/14e70052-96f5-4ea4-b33c-245ca967bbbf/w/crates/radicle-fetch)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 11.11s
Generated /14e70052-96f5-4ea4-b33c-245ca967bbbf/w/target/doc/radicle/index.html and 21 other files
+ cargo test --workspace --no-fail-fast
Finished `test` profile [unoptimized + debuginfo] target(s) in 0.24s
Running unittests src/lib.rs (target/debug/deps/radicle-f47a7c2ba456ab00)
running 400 tests
test canonical::formatter::test::ascii_control_characters ... ok
test canonical::formatter::test::ordered_nested_object ... ok
test canonical::formatter::test::securesystemslib_asserts ... ok
test cob::cache::migrations::_2::tests::test_migration_2 ... ok
test cob::cache::migrations::_2::tests::test_patch_json_deserialization ... ok
test cob::common::test::test_color ... ok
test cob::common::test::test_title ... ok
test cob::common::test::test_emojis ... ok
test cob::cache::tests::test_check_version ... ok
test cob::cache::tests::test_migrate_to ... ok
test cob::identity::test::accept_rejects_sibling_accept ... ok
test cob::identity::test::accepted_sibling_causes_rejection ... ok
test cob::identity::test::cannot_redact_previously_accepted_revision ... ok
test cob::identity::test::authorization_based_on_parent_not_current ... ok
test cob::identity::test::concurrent_accept_before_redact_converge ... ok
test cob::identity::test::concurrent_redact_and_accept_converge ... ok
test cob::identity::test::evaluates_queued_children ... ok
test cob::identity::test::cascading_rejections ... ok
test cob::identity::test::evaluation_skips_sibling_accept_in_old_history ... ok
test cob::identity::test::evaluation_strips_author_accept_for_sibling_creation ... ok
test cob::identity::test::has_active_sibling_accept_returns_true_when_sibling_accepted ... ok
test cob::identity::test::evaluates_queued_children_with_new_delegate ... ok
test cob::identity::test::prop_json_eq_str ... ok
test cob::identity::test::redact_parent_cascades ... ok
test cob::identity::test::reject_concurrent ... ok
test cob::identity::test::remove_delegate_concurrent ... ok
test cob::identity::test::test_identity_redact_revision ... ok
test cob::identity::test::terminal_states_concurrent ... ok
test cob::identity::test::test_identity_update_rejected ... ok
test cob::identity::test::test_identity_updates ... ok
test cob::identity::test::test_identity_cannot_redact_terminal_states ... ok
test cob::identity::test::test_valid_identity ... ok
test cob::identity::test::test_identity_updates_concurrent ... ok
test cob::issue::cache::tests::test_counts ... ok
test cob::issue::cache::tests::test_get ... ok
test cob::issue::cache::tests::test_is_empty ... ok
test cob::issue::cache::tests::test_list ... ok
test cob::issue::cache::tests::test_list_by_status ... ok
test cob::issue::cache::tests::test_remove ... ok
test cob::identity::test::update_rejects_second_sibling_proposal ... ok
test cob::identity::test::test_identity_updates_concurrent_outdated ... ok
test cob::issue::test::test_embeds ... ok
test cob::issue::test::test_embeds_edit ... ok
test cob::issue::test::test_invalid_actions ... ok
test cob::issue::test::test_invalid_cob ... ok
test cob::issue::test::test_invalid_tx ... ok
test cob::issue::test::test_invalid_tx_reference ... ok
test cob::issue::test::test_concurrency ... ok
test cob::issue::test::test_issue_all ... ok
test cob::issue::test::test_issue_comment ... ok
test cob::issue::test::test_issue_comment_redact ... ok
test cob::issue::test::test_issue_create_and_assign ... ok
test cob::issue::test::test_issue_create_and_get ... ok
test cob::issue::test::test_issue_create_and_change_state ... ok
test cob::issue::test::test_issue_create_and_reassign ... ok
test cob::issue::test::test_issue_edit ... ok
test cob::issue::test::test_issue_create_and_unassign ... ok
test cob::issue::test::test_issue_edit_description ... ok
test cob::issue::test::test_issue_multilines ... ok
test cob::issue::test::test_issue_label ... ok
test cob::issue::test::test_issue_state_serde ... ok
test cob::issue::test::test_ordering ... ok
test cob::patch::actions::test::test_review_edit ... ok
test cob::issue::test::test_issue_react ... ok
test cob::issue::test::test_issue_reply ... ok
test cob::patch::cache::tests::test_get ... ok
test cob::patch::cache::tests::test_is_empty ... ok
test cob::patch::cache::tests::test_list ... ok
test cob::patch::cache::tests::test_list_by_status ... ok
test cob::patch::cache::tests::test_find_by_revision ... ok
test cob::patch::encoding::review::test::test_review_deserialize_summary_migration_null_summary ... ok
test cob::patch::encoding::review::test::test_review_deserialize_summary_migration_with_summary ... ok
test cob::patch::encoding::review::test::test_review_deserialize_summary_migration_without_summary ... ok
test cob::patch::encoding::review::test::test_review_deserialize_summary_v2 ... ok
test cob::patch::encoding::review::test::test_review_summary ... ok
test cob::patch::test::test_json ... ok
test cob::patch::test::test_json_serialisation_target ... ok
test cob::patch::test::test_json_serialization ... ok
test cob::patch::test::test_merge_target_resolution ... ok
test cob::patch::cache::tests::test_counts ... ok
test cob::patch::test::test_patch_create_and_get ... ok
test cob::patch::cache::tests::test_remove ... ok
test cob::patch::test::test_patch_merge_authorization_ref_formats ... ok
test cob::patch::test::test_patch_merge_custom_destination_authorized ... ok
test cob::patch::test::test_patch_merge_custom_destination_unauthorized ... ok
test cob::patch::test::test_patch_discussion ... ok
test cob::patch::test::test_patch_merge ... ok
test cob::patch::test::test_patch_redact ... ok
test cob::patch::test::test_patch_review ... ok
test cob::patch::test::test_patch_review_comment ... ok
test cob::patch::test::test_patch_review_edit ... ok
test cob::patch::test::test_patch_review_duplicate ... ok
test cob::patch::test::test_patch_review_remove_summary ... ok
test cob::patch::test::test_patch_review_edit_comment ... ok
test cob::patch::test::test_reactions_json_serialization ... ok
test cob::patch::test::test_revision_edit_redact ... ok
test cob::patch::test::test_revision_reaction ... ok
test cob::patch::test::test_revision_review_merge_redacted ... ok
test cob::patch::test::test_target_branch ... ok
test cob::stream::tests::test_all_from ... ok
test cob::patch::test::test_patch_review_revision_redact ... ok
test cob::stream::tests::test_all_from_until ... ok
test cob::stream::tests::test_all_until ... ok
test cob::stream::tests::test_regression_from_until ... ok
test cob::stream::tests::test_from_until ... ok
test cob::thread::tests::test_comment_edit_missing ... ok
test cob::thread::tests::test_comment_edit_redacted ... ok
test cob::thread::tests::test_comment_redact_missing ... ok
test cob::thread::tests::test_duplicate_comments ... ok
test cob::thread::tests::test_edit_comment ... ok
test cob::thread::tests::test_redact_comment ... ok
test cob::thread::tests::test_timeline ... ok
test git::canonical::protect::tests::refs_rad ... ok
test git::canonical::protect::tests::refs_rad_id ... ok
test git::canonical::protect::tests::refs_radieschen ... ok
test git::canonical::quorum::test::merge_base_commutative ... ok
test git::canonical::quorum::test::test_merge_bases ... ok
test cob::patch::test::test_patch_update ... ok
test git::canonical::rules::test::deserialization ... ok
test git::canonical::rules::test::deserialize_extensions ... ok
test git::canonical::rules::test::matches_exactly_curly_braces ... ok
test git::canonical::rules::test::matches_expands_globs_appropriately ... ok
test git::canonical::rules::test::ordering ... ok
test git::canonical::rules::test::property::identity ... ok
test git::canonical::rules::test::property::prefix ... ok
test git::canonical::rules::test::property::prefix_negative ... ok
test git::canonical::rules::test::property::suffix ... ok
test git::canonical::rules::test::canonical ... ok
test git::canonical::rules::test::property::suffix_negative ... ok
test git::canonical::rules::test::roundtrip ... ok
test git::canonical::rules::test::property::trailing_asterisk_partial_component ... ok
test git::canonical::rules::test::rule_validate_success ... ok
test git::canonical::rules::test::special_branches ... ok
test git::canonical::symbolic::test::deserialize_infinite ... ok
test git::canonical::symbolic::test::deserialize_order ... ok
test git::canonical::symbolic::test::deserialize_valid ... ok
test git::canonical::symbolic::test::infinite_extend ... ok
test git::canonical::symbolic::test::infinite_multi ... ok
test git::canonical::symbolic::test::infinite_single ... ok
test git::canonical::symbolic::test::reclassification_combine ... ok
test git::canonical::symbolic::test::reclassification_combine_reverse ... ok
test git::canonical::symbolic::test::reclassification_diamond ... ok
test git::canonical::symbolic::test::reclassification_order_invariant ... ok
test git::canonical::symbolic::test::reclassification_reverse_chain ... ok
test git::canonical::symbolic::test::resolve_two_hop_chain ... ok
test git::canonical::symbolic::test::target_classification ... ok
test git::canonical::symbolic::test::target_classification_symbolic ... ok
test git::canonical::symbolic::test::target_reclassification ... ok
test git::canonical::symbolic::test::target_reclassification_commutative ... ok
test git::canonical::tests::test_commit_quorum_fork_of_a_fork ... ok
test git::canonical::tests::test_commit_quorum_forked_merge_commits ... ok
test git::canonical::tests::test_commit_quorum_groups ... ok
test git::canonical::tests::test_commit_quorum_linear ... ok
test git::canonical::tests::test_commit_quorum_merges ... ok
test git::canonical::tests::test_commit_quorum_single ... ok
test git::canonical::tests::test_commit_quorum_three_way_fork ... ok
test git::canonical::tests::test_commit_quorum_two_way_fork ... ok
test git::canonical::tests::test_quorum_different_types ... ok
test git::canonical::rules::test::rule_validate_failures ... ok
test git::canonical::tests::test_tag_quorum ... ok
test git::test::test_version_from_str ... ok
test git::test::test_version_ord ... ok
test identity::crefs::tests::invalid_clash ... ok
test identity::crefs::tests::invalid_clash_asterisk_name ... ok
test identity::crefs::tests::invalid_dangling ... ok
test identity::crefs::tests::omit_symbolic ... ok
test identity::crefs::tests::valid ... ok
test identity::crefs::tests::valid_asterisk_target ... ok
test identity::did::test::test_did_encode_decode ... ok
test identity::did::test::test_did_vectors ... ok
test identity::doc::test::default_branch_clash ... ok
test identity::doc::test::default_branch_without_project ... ok
test git::canonical::tests::test_quorum_properties ... ok
test identity::doc::test::test_canonical_doc ... ok
test identity::doc::test::test_canonical_example ... ok
test identity::doc::test::test_duplicate_dids ... ok
test identity::doc::test::test_future_version_error ... ok
test identity::doc::test::test_is_valid_version ... ok
test cob::thread::tests::prop_ordering ... ok
test identity::doc::test::test_not_found ... ok
test identity::doc::test::test_parse_version ... ok
test identity::doc::test::test_visibility_json ... ok
test identity::doc::update::test::test_can_update_crefs ... ok
test identity::doc::update::test::test_cannot_include_default_branch_rule ... ok
test identity::doc::update::test::test_default_branch_rule_exists_after_verification ... ok
test identity::project::test::test_project_name ... ok
test node::address::store::test::skip_invalid_address_type ... ok
test node::address::store::test::skip_mismatched_address_type ... ok
test node::address::store::test::test_alias ... ok
test node::address::store::test::test_disconnected ... ok
test node::address::store::test::test_disconnected_ban ... ok
test identity::doc::test::test_max_delegates ... ok
test node::address::store::test::test_entries ... ok
test node::address::store::test::test_entries_skips_unparsable_address ... ok
test node::address::store::test::test_empty ... ok
test node::address::store::test::test_get_none ... ok
test node::address::store::test::test_insert_and_get ... ok
test node::address::store::test::test_insert_and_remove ... ok
test node::address::store::test::test_insert_and_update ... ok
test node::address::store::test::test_insert_duplicate ... ok
test node::address::store::test::test_remove_nothing ... ok
test node::command::test::command_result ... ok
test node::config::test::deserialize_migrating_scope ... ok
test node::config::test::fetch_level_min ... ok
test node::config::test::onion_absent ... ok
test node::config::test::onion_null ... ok
test node::config::test::partial ... ok
test node::address::store::test::test_node_aliases ... ok
test node::config::test::regression_ipv6_address_brackets ... ok
test node::config::test::regression_ipv6_address_no_brackets ... ok
test node::config::test::serialize_migrating_scope ... ok
test node::config::test::user_agent_custom ... ok
test node::config::test::user_agent_default ... ok
test node::config::test::user_agent_default_explicit ... ok
test node::config::test::user_agent_opt_out ... ok
test node::db::config::test::invalid ... ok
test node::db::config::test::database_config_valid_combinations ... ok
test node::db::test::migration_8::dns_address_starting_with_bracket_but_missing_closing_bracket_colon_is_unaffected ... ok
test node::db::test::migration_8::all_ipv6_formatted_dns_addresses_are_retyped ... ok
test node::db::test::migration_8::dns_address_with_bracket_not_at_start_is_unaffected ... ok
test node::db::test::migration_8::ipv4_address_is_unaffected ... ok
test node::db::test::migration_8::ipv6_formatted_dns_address_is_deleted_when_correct_ipv6_row_already_exists ... ok
test node::db::test::migration_8::ipv6_formatted_dns_address_is_retyped_to_ipv6 ... ok
test node::db::test::migration_8::migration_applies_to_all_nodes ... ok
test node::db::test::migration_8::plain_dns_hostname_without_brackets_is_unaffected ... ok
test node::db::test::migration_8::retype_preserves_address_metadata ... ok
test node::db::test::migration_9::bracketed_non_ipv6_garbage_is_deleted ... ok
test node::db::test::migration_9::dns_row_is_unaffected_even_when_inner_part_has_no_colon ... ok
test node::db::test::migration_9::empty_brackets_ipv6_row_is_deleted ... ok
test node::db::test::migration_9::full_ipv6_address_is_kept ... ok
test node::db::test::migration_9::loopback_address_is_kept ... ok
test node::db::test::migration_9::ipv4_row_is_unaffected ... ok
test node::db::test::migration_9::unspecified_address_is_kept ... ok
test node::features::test::test_operations ... ok
test node::notifications::store::test::test_branch_notifications ... ok
test node::notifications::store::test::test_clear ... ok
test node::notifications::store::test::test_cob_notifications ... ok
test node::db::test::test_version ... ok
test node::notifications::store::test::test_duplicate_notifications ... ok
test node::notifications::store::test::test_counts_by_repo ... ok
test node::notifications::store::test::test_notification_status ... ok
test node::policy::store::test::test_follow_and_unfollow_node ... ok
test node::policy::store::test::test_node_policies ... ok
test node::policy::store::test::test_node_policy ... ok
test node::policy::store::test::test_node_aliases ... ok
test node::policy::store::test::test_repo_policies ... ok
test node::policy::store::test::test_repo_policy ... ok
test node::policy::store::test::test_seed_and_unseed_repo ... ok
test node::policy::store::test::test_update_scope ... ok
test node::policy::store::test::test_update_alias ... ok
test node::refs::store::test::test_count ... ok
test node::refs::store::test::test_set_and_delete ... ok
test node::refs::store::test::test_set_and_get ... ok
test node::routing::test::test_count ... ok
test node::routing::test::test_entries ... ok
test node::routing::test::test_insert_and_get ... ok
test node::routing::test::test_insert_and_get_resources ... ok
test node::routing::test::test_insert_and_remove ... ok
test node::routing::test::test_insert_duplicate ... ok
test node::routing::test::test_len ... ok
test node::routing::test::test_insert_existing_updated_time ... ok
test node::routing::test::test_remove_many ... ok
test node::routing::test::test_remove_redundant ... ok
test node::routing::test::test_update_existing_multi ... ok
test node::sync::announce::test::all_synced_nodes_are_preferred_seeds ... ok
test node::sync::announce::test::announcer_adapts_target_to_reach ... ok
test node::sync::announce::test::announcer_preferred_seeds_or_replica_factor ... ok
test node::routing::test::test_prune ... ok
test node::sync::announce::test::announcer_reached_max_replication_target ... ok
test node::sync::announce::test::announcer_reached_min_replication_target ... ok
test node::sync::announce::test::announcer_synced_with_unknown_node ... ok
test node::sync::announce::test::announcer_reached_preferred_seeds ... ok
test node::sync::announce::test::announcer_with_replication_factor_zero_and_preferred_seeds ... ok
test node::sync::announce::test::announcer_timed_out ... ok
test node::sync::announce::test::construct_node_appears_in_multiple_input_sets ... ok
test node::sync::announce::test::cannot_construct_announcer ... ok
test node::sync::announce::test::construct_only_preferred_seeds_provided ... ok
test node::sync::announce::test::local_node_in_multiple_sets ... ok
test node::sync::announce::test::invariant_progress_should_match_state ... ok
test node::sync::announce::test::local_node_in_preferred_seeds ... ok
test node::sync::announce::test::local_node_in_synced_set ... ok
test node::sync::announce::test::local_node_only_in_all_sets_results_in_no_seeds_error ... ok
test node::sync::announce::test::local_node_in_unsynced_set ... ok
test node::sync::announce::test::preferred_seeds_already_synced ... ok
test node::sync::announce::test::synced_with_local_node_is_ignored ... ok
test node::sync::announce::test::synced_with_same_node_multiple_times ... ok
test node::sync::fetch::test::all_nodes_are_candidates ... ok
test node::sync::announce::test::timed_out_after_reaching_success ... ok
test node::sync::fetch::test::could_not_reach_target ... ok
test node::sync::fetch::test::ignores_duplicates_and_local_node ... ok
test node::sync::fetch::test::preferred_seeds_target_returned_over_replicas ... ok
test node::sync::fetch::test::all_nodes_are_fetchable ... ok
test node::sync::fetch::test::reaches_target_of_max_replicas ... ok
test node::sync::fetch::test::reaches_target_of_preferred_seeds ... ok
test node::sync::test::ensure_replicas_construction ... ok
test node::sync::test::replicas_constrain_to ... ok
test node::test::test_address ... ok
test node::test::test_alias ... ok
test node::test::test_command_result ... ok
test node::test::test_user_agent ... ok
test node::timestamp::tests::test_timestamp_max ... ok
test node::sync::fetch::test::reaches_target_of_replicas ... ok
test profile::test::canonicalize_home ... ok
test profile::test::test_config ... ok
test rad::tests::test_checkout ... ok
test rad::tests::test_fork ... ok
test profile::config::test::schema ... ok
test rad::tests::test_init ... ok
test storage::git::tests::test_references_of ... ok
test storage::git::transport::local::url::test::test_url_parse ... ok
test storage::git::transport::local::url::test::test_url_to_string ... ok
test storage::git::transport::remote::url::test::test_url_parse ... ok
test storage::git::tests::test_sign_refs ... ok
test identity::doc::test::prop_encode_decode ... ok
test storage::refs::sigrefs::git::properties::idempotent_write ... ok
test storage::refs::sigrefs::git::properties::initial_commit_roundtrip ... ok
test storage::refs::sigrefs::property::idempotent ... ok
test storage::refs::sigrefs::read::test::commit_reader::identity_root_error ... ok
test storage::refs::sigrefs::read::test::commit_reader::missing_commit ... ok
test storage::refs::sigrefs::read::test::commit_reader::read_ok ... ok
test storage::refs::sigrefs::read::test::commit_reader::too_many_parents ... ok
test storage::refs::sigrefs::read::test::commit_reader::tree_error ... ok
test storage::refs::sigrefs::read::test::identity_root_reader::doc_blob_error ... ok
test storage::refs::sigrefs::read::test::identity_root_reader::missing_identity ... ok
test storage::refs::sigrefs::read::test::identity_root_reader::read_ok_none ... ok
test storage::refs::sigrefs::read::test::identity_root_reader::read_ok_some ... ok
test storage::refs::sigrefs::read::test::resolve_tip::find_reference_error ... ok
test storage::refs::sigrefs::read::test::resolve_tip::missing_sigrefs ... ok
test storage::refs::sigrefs::read::test::resolve_tip::resolve_tip_ok ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::detect_parent::root_without_parent ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::detect_parent::root_without_root ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::downgrade::parent ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::downgrade::restore ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::downgrade::root ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::downgrade::root_with_parent ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::head_commit_error ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::head_verify_mismatched_identity_error ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::head_verify_signature_error ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::invalid_parent ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::read_ok_no_parent ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::read_ok_parent ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::read_ok_root ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::replay::alternating ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::replay::chain ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::replay::multiple ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::replay::root_at_head ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::single_commit ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::two_commits ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::walk_commit_error ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::walk_verify_error ... ok
test storage::refs::sigrefs::read::test::tree_reader::missing_both ... ok
test storage::refs::sigrefs::read::test::tree_reader::missing_refs ... ok
test storage::refs::sigrefs::read::test::tree_reader::missing_signature ... ok
test storage::refs::sigrefs::read::test::tree_reader::parse_refs_error ... ok
test storage::refs::sigrefs::read::test::tree_reader::parse_signature_error ... ok
test storage::refs::sigrefs::read::test::tree_reader::read_ok ... ok
test storage::refs::sigrefs::read::test::tree_reader::read_refs_error ... ok
test storage::refs::sigrefs::read::test::tree_reader::read_signature_error ... ok
test storage::refs::sigrefs::write::test::commit_writer::tree_error ... ok
test storage::refs::sigrefs::write::test::commit_writer::write_commit_error ... ok
test storage::refs::sigrefs::write::test::commit_writer::write_empty_refs ... ok
test storage::refs::sigrefs::write::test::commit_writer::write_root_ok ... ok
test storage::refs::sigrefs::write::test::commit_writer::write_with_parent_ok ... ok
test storage::refs::sigrefs::write::test::head_reader::no_head ... ok
test storage::refs::sigrefs::write::test::head_reader::read_ok ... ok
test storage::refs::sigrefs::write::test::head_reader::reference_error ... ok
test storage::refs::sigrefs::write::test::head_reader::refs_blob_error ... ok
test storage::refs::sigrefs::write::test::head_reader::refs_blob_missing ... ok
test storage::refs::sigrefs::write::test::head_reader::refs_parse_error ... ok
test storage::refs::sigrefs::write::test::head_reader::signature_blob_error ... ok
test storage::refs::sigrefs::write::test::head_reader::signature_blob_missing ... ok
test storage::refs::sigrefs::write::test::head_reader::signature_parse_error ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::commit_error ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::head_error ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::never_write_rad_sigrefs ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::reference_error ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::unchanged ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::unchanged_force_writes_new_commit ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::write_empty_refs ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::write_root_ok ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::write_with_parent_ok ... ok
test storage::refs::sigrefs::write::test::tree_writer::sign_error ... ok
test storage::refs::sigrefs::write::test::tree_writer::write_ok ... ok
test storage::refs::sigrefs::write::test::tree_writer::write_tree_error ... ok
test storage::refs::tests::prop_canonical_roundtrip ... ok
test cob::identity::test::property::prop_invariants ... ok
test storage::tests::test_storage ... ok
test test::assert::test::assert_with_message ... ok
test test::assert::test::test_assert_no_move ... ok
test test::assert::test::test_assert_panic_0 - should panic ... ok
test test::assert::test::test_assert_panic_1 - should panic ... ok
test test::assert::test::test_assert_panic_2 - should panic ... ok
test test::assert::test::test_assert_succeed ... ok
test test::assert::test::test_panic_message ... ok
test version::test::test_version ... ok
test web::test::description_only ... ok
test web::test::pinned_empty ... ok
test storage::refs::tests::test_rid_verification ... ok
test storage::refs::sigrefs::property::roundtrip ... ok
test storage::refs::sigrefs::git::properties::chain_roundtrip ... ok
test result: ok. 400 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 5.86s
Running unittests src/lib.rs (target/debug/deps/radicle_cli-6bfba036d8f69ef1)
running 46 tests
test commands::block::args::test::should_not_parse ... ok
test commands::block::args::test::should_parse_nid ... ok
test commands::block::args::test::should_parse_rid ... ok
test commands::clone::args::test::should_parse_rid_non_urn ... ok
test commands::clone::args::test::should_parse_rid_urn ... ok
test commands::clone::args::test::should_parse_rid_url ... ok
test commands::cob::args::test::should_allow_log_json_format ... ok
test commands::cob::args::test::should_allow_show_json_format ... ok
test commands::cob::args::test::should_allow_log_pretty_format ... ok
test commands::cob::args::test::should_not_allow_show_pretty_format ... ok
test commands::cob::args::test::should_not_allow_update_pretty_format ... ok
test commands::cob::args::test::should_allow_update_json_format ... ok
test commands::fork::args::test::should_parse_rid_urn ... ok
test commands::fork::args::test::should_parse_rid_non_urn ... ok
test commands::fork::args::test::should_not_parse_rid_url ... ok
test commands::id::args::test::should_not_parse_into_payload - should panic ... ok
test commands::id::args::test::should_parse_into_payload ... ok
test commands::id::args::test::should_not_clobber_payload_args ... ok
test commands::id::args::test::should_not_parse_single_payload ... ok
test commands::id::args::test::should_parse_multiple_payloads ... ok
test commands::init::args::test::should_not_parse_rid_url ... ok
test commands::id::args::test::should_not_parse_single_payloads ... ok
test commands::id::args::test::should_parse_single_payload ... ok
test commands::init::args::test::should_parse_rid_non_urn ... ok
test commands::inspect::test::test_tree ... ok
test commands::init::args::test::should_parse_rid_urn ... ok
test commands::patch::review::builder::tests::test_review_comments_basic ... ok
test commands::patch::review::builder::tests::test_review_comments_before ... ok
test commands::patch::review::builder::tests::test_review_comments_split_hunk ... ok
test commands::publish::args::test::should_not_parse_rid_url ... ok
test commands::publish::args::test::should_parse_rid_non_urn ... ok
test commands::publish::args::test::should_parse_rid_urn ... ok
test commands::patch::review::builder::tests::test_review_comments_multiline ... ok
test git::ddiff::tests::diff_encode_decode_ddiff_hunk ... ok
test commands::watch::args::test::should_parse_ref_str ... ok
test git::pretty_diff::test::test_pretty ... ignored
test git::unified_diff::test::test_diff_content_encode_decode_content ... ok
test git::unified_diff::test::test_diff_encode_decode_diff ... ok
test terminal::args::test::should_not_parse ... ok
test terminal::format::test::test_bytes ... ok
test terminal::format::test::test_strip_comments ... ok
test terminal::args::test::should_parse_nid ... ok
test terminal::args::test::should_parse_rid ... ok
test terminal::patch::test::test_edit_display_message ... ok
test terminal::patch::test::test_create_display_message ... ok
test terminal::patch::test::test_update_display_message ... ok
test result: ok. 45 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out; finished in 0.01s
Running unittests src/main.rs (target/debug/deps/rad-9617691c862a9839)
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running tests/commands.rs (target/debug/deps/commands-f88e037b1bdbeca7)
running 126 tests
test commands::clone::rad_clone_bare ... ok
test commands::clone::rad_clone ... ok
test commands::checkout::rad_checkout ... ok
test commands::clone::rad_clone_all ... ok
test commands::clone::rad_clone_scope ... ok
test commands::clone::rad_clone_directory ... ok
test commands::clone::rad_clone_connect ... ok
test commands::clone::rad_clone_unknown ... ok
test commands::clone::rad_clone_partial_fail ... ok
test commands::cob::rad_cob_multiset ... ok
test commands::clone::test_clone_without_seeds ... ok
test commands::cob::rad_cob_log ... ok
test commands::cob::rad_cob_migrate ... ok
test commands::cob::rad_cob_operations ... ok
test commands::cob::rad_cob_show ... ok
test commands::cob::rad_cob_update_identity ... ok
test commands::cob::rad_cob_update ... ok
test commands::cob::test_cob_deletion ... ok
test commands::cob::test_cob_replication ... ok
test commands::git::git_push_amend ... ok
test commands::git::git_push_and_fetch ... ok
test commands::git::git_push_canonical_lightweight_tags ... ok
test commands::git::git_push_diverge ... ok
test commands::git::git_push_force_with_lease ... ok
test commands::git::git_push_canonical ... ok
test commands::git::git_push_converge ... ok
test commands::id::rad_id_collaboration ... ignored, slow
test commands::git::git_push_rollback ... ok
test commands::id::rad_id ... ok
test commands::git::git_tag ... ok
test commands::id::rad_id_private ... ok
test commands::id::rad_id_conflict ... ok
test commands::id::rad_id_threshold_soft_fork ... ok
test commands::id::rad_id_threshold ... ok
test commands::id::rad_id_unknown_field ... ok
test commands::id::rad_id_update_delete_field ... ok
test commands::init::rad_init ... ignored, part of many other tests
test commands::id::rad_id_unauthorized_delegate ... ok
test commands::init::rad_init_detached_head ... ok
test commands::id::rad_id_multi_delegate ... ok
test commands::init::rad_init_bare ... ok
test commands::init::rad_init_existing ... ok
test commands::init::rad_init_no_git ... ok
test commands::init::rad_init_existing_bare ... ok
test commands::init::rad_init_no_seed ... ok
test commands::init::rad_init_private ... ok
test commands::init::rad_init_private_no_seed ... ok
test commands::init::rad_init_private_clone ... ok
test commands::inbox::rad_inbox ... ok
test commands::init::rad_init_private_clone_seed ... ok
test commands::init::rad_init_private_seed ... ok
test commands::init::rad_init_sync_not_connected ... ok
test commands::init::rad_init_sync_preferred ... ok
test commands::init::rad_init_with_existing_remote ... ok
test commands::init::rad_publish ... ok
test commands::issue::rad_issue ... ok
test commands::jj::rad_jj_bare ... ignored, the bare repository does not have a `rad` remote, and so it cannot determine the RID of the repository
test commands::jj::rad_jj_colocated_patch ... ok
test commands::issue::rad_issue_list ... ok
test commands::node::rad_node_connect ... ok
test commands::node::rad_node_connect_without_address ... ok
test commands::patch::rad_merge_after_update ... ok
test commands::node::rad_node ... ok
test commands::patch::rad_merge_no_ff ... ok
test commands::patch::rad_merge_via_push ... ok
test commands::patch::rad_patch ... ok
test commands::patch::rad_patch_ahead_behind ... ok
test commands::patch::rad_patch_change_base ... ok
test commands::patch::rad_patch_checkout ... ok
test commands::init::rad_init_sync_and_clone ... ok
test commands::init::rad_init_sync_timeout ... ok
test commands::patch::rad_patch_checkout_revision ... ok
test commands::patch::rad_patch_detached_head ... ok
test commands::patch::rad_patch_checkout_force ... ok
test commands::patch::rad_patch_diff ... ok
test commands::patch::rad_patch_draft ... ok
test commands::patch::rad_patch_edit ... ok
test commands::patch::rad_patch_fetch_2 ... ok
test commands::patch::rad_patch_merge_draft ... ok
test commands::patch::rad_patch_fetch_1 ... ok
test commands::patch::rad_patch_magic_push ... ok
test commands::patch::rad_patch_delete ... ok
test commands::patch::rad_patch_merge_into_canonical_ref_branch ... ok
test commands::patch::rad_patch_merge_wrong_branch ... ok
test commands::patch::rad_patch_merge_on_first_push ... ok
test commands::patch::rad_patch_merge_unauthorized_branch ... ok
test commands::patch::rad_patch_open_explore ... ok
test commands::patch::rad_patch_revert_custom_branch ... ok
test commands::patch::rad_patch_revert_merge ... ok
test commands::patch::rad_patch_update ... ok
test commands::patch::rad_patch_review_no_options ... ok
test commands::patch::rad_patch_via_push ... ok
test commands::patch::rad_review_by_hunk ... ok
test commands::policy::rad_block ... ok
test commands::policy::rad_seed_and_follow ... ok
test commands::policy::rad_seed_policy_allow_no_scope ... ok
test commands::policy::rad_seed_scope ... ok
test commands::policy::rad_unseed ... ok
test commands::policy::rad_seed_many ... ok
test commands::policy::rad_unseed_many ... ok
test commands::sigpipe::config ... ok
test commands::sigpipe::help ... ok
test commands::sigpipe::rad_self ... ok
test commands::patch::rad_push_and_pull_patches ... ok
test commands::remote::rad_remote ... ok
test commands::sync::rad_sync_without_node ... ok
test commands::sync::rad_sync ... ok
test commands::utility::framework_home ... ok
test commands::utility::rad_auth ... ok
test commands::utility::rad_auth_errors ... ok
test commands::patch::rad_patch_pull_update ... ok
test commands::utility::rad_config ... ok
test commands::utility::rad_diff ... ok
test commands::utility::rad_clean ... ok
test commands::utility::rad_help ... ok
test commands::utility::rad_inspect ... ok
test commands::utility::rad_key_mismatch ... ok
test commands::utility::rad_self ... ok
test commands::utility::rad_warn_ipv6 ... ok
test commands::utility::rad_warn_old_nodes ... ok
test commands::watch::rad_watch ... ok
test commands::sync::rad_fetch ... ok
test rad_remote ... ok
test commands::sync::test_replication_via_seed ... ok
test commands::workflow::rad_workflow ... ok
test commands::utility::rad_fork ... ok
test result: ok. 123 passed; 0 failed; 3 ignored; 0 measured; 0 filtered out; finished in 76.01s
Running unittests src/lib.rs (target/debug/deps/radicle_cli_test-39ff3967fcfd38a1)
running 3 tests
test tests::test_parse ... ok
test tests::test_run ... ok
test tests::test_example_spaced_brackets ... ok
test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s
Running unittests src/lib.rs (target/debug/deps/radicle_cob-1ff8ee99f73a113c)
running 9 tests
test object::tests::test_serde ... ok
test tests::git::roundtrip ... ok
test tests::invalid_parse_refstr ... ok
test tests::git::list_cobs ... ok
test type_name::test::invalid_typenames ... ok
test type_name::test::valid_typenames ... ok
test tests::git::update_cob ... ok
test tests::git::traverse_cobs ... ok
test tests::parse_refstr ... ok
test result: ok. 9 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s
Running unittests src/lib.rs (target/debug/deps/radicle_core-f9d12dcddf722a8f)
running 4 tests
test repo::test::valid ... ok
test repo::test::invalid ... ok
test repo::serde_impls::test::assert_prop_roundtrip_serde_json ... ok
test repo::test::assert_prop_roundtrip_parse ... ok
test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s
Running unittests src/lib.rs (target/debug/deps/radicle_crypto-296ceac40b7fe69b)
running 11 tests
test ssh::agent::test::test_agent_encoding_remove ... ok
test ssh::agent::test::test_agent_encoding_sign ... ok
test ssh::fmt::test::test_key ... ok
test ssh::fmt::test::test_fingerprint ... ok
test ssh::keystore::tests::test_init_no_passphrase ... ok
test tests::prop_encode_decode ... ok
test tests::test_e25519_dh ... ok
test tests::test_encode_decode ... ok
test tests::prop_key_equality ... ok
test ssh::keystore::tests::test_signer ... ok
test ssh::keystore::tests::test_init_passphrase ... ok
test result: ok. 11 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.84s
Running unittests src/lib.rs (target/debug/deps/radicle_dag-e10cdde88570a8e0)
running 20 tests
test tests::test_contains ... ok
test tests::test_cycle ... ok
test tests::test_dependencies ... ok
test tests::test_diamond ... ok
test tests::test_fold_diamond ... ok
test tests::test_fold_multiple_roots ... ok
test tests::test_fold_sorting_1 ... ok
test tests::test_fold_reject ... ok
test tests::test_fold_sorting_2 ... ok
test tests::test_get ... ok
test tests::test_complex ... ok
test tests::test_is_empty ... ok
test tests::test_len ... ok
test tests::test_merge_1 ... ok
test tests::test_merge_2 ... ok
test tests::test_prune_1 ... ok
test tests::test_prune_2 ... ok
test tests::test_prune_by_sorting ... ok
test tests::test_remove ... ok
test tests::test_siblings ... ok
test result: ok. 20 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/lib.rs (target/debug/deps/radicle_fetch-92b111a684cd2a9a)
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/lib.rs (target/debug/deps/radicle_git_metadata-41b02b9ef3e2236d)
running 24 tests
test commit::parse::test::error::invalid_author ... ok
test commit::parse::test::error::invalid_committer ... ok
test commit::parse::test::error::invalid_format_continuation_without_preceding_header ... ok
test commit::parse::test::error::invalid_parent ... ok
test commit::parse::test::error::invalid_tree ... ok
test commit::parse::test::error::missing_author ... ok
test commit::parse::test::error::missing_committer ... ok
test commit::parse::test::error::missing_header_body_separator ... ok
test commit::parse::test::error::missing_tree_empty_header ... ok
test commit::parse::test::error::missing_tree_wrong_first_line ... ok
test commit::parse::test::success::commit_last_paragraph_kept_in_message_when_not_all_trailers ... ok
test commit::parse::test::success::commit_with_extra_headers ... ok
test commit::parse::test::success::commit_gpgsig_is_preserved_and_strip_removes_it ... ok
test commit::parse::test::success::commit_with_multiline_gpgsig ... ok
test commit::parse::test::success::commit_with_single_parent ... ok
test commit::parse::test::success::commit_with_trailers ... ok
test commit::parse::test::unit::body_last_paragraph_not_trailers_stays_in_message ... ok
test commit::parse::test::success::merge_commit ... ok
test commit::parse::test::success::roundtrip ... ok
test commit::parse::test::success::root_commit ... ok
test commit::parse::test::unit::body_no_paragraph_separator_means_no_trailers ... ok
test commit::parse::test::unit::trailers_accepts_empty_input ... ok
test commit::parse::test::unit::trailers_rejects_invalid_token_chars ... ok
test commit::parse::test::unit::trailers_rejects_line_without_separator ... ok
test result: ok. 24 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/lib.rs (target/debug/deps/radicle_git_ref_format-2868a65b3ff2c590)
running 9 tests
test test::component ... ok
test test::component_invalid - should panic ... ok
test test::qualified ... ok
test test::qualified_invalid - should panic ... ok
test test::pattern ... ok
test test::qualified_pattern ... ok
test test::qualified_pattern_invalid - should panic ... ok
test test::refname_invalid - should panic ... ok
test test::refname ... ok
test result: ok. 9 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/lib.rs (target/debug/deps/radicle_localtime-ec55a7767b981c91)
running 1 test
test serde_impls::test::test_localtime ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/lib.rs (target/debug/deps/radicle_log-aa8a5607eeb05b0d)
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/lib.rs (target/debug/deps/radicle_node-aaa9e54e49654ece)
running 84 tests
test reactor::timer::tests::test_next ... ok
test reactor::timer::tests::test_wake ... ok
test reactor::timer::tests::test_wake_exact ... ok
test control::tests::test_control_socket ... ok
test control::tests::test_seed_unseed ... ok
test fingerprint::tests::matching ... ok
test tests::e2e::fetch_does_not_contain_rad_sigrefs_parent ... ok
test tests::e2e::missing_default_branch ... ok
test tests::e2e::missing_delegate_default_branch ... ok
test tests::e2e::test_background_foreground_fetch ... ok
test tests::e2e::test_block_active_connection ... ok
test tests::e2e::test_block_prevents_connection ... ok
test tests::e2e::test_block_prevents_fetch ... ok
test tests::e2e::test_channel_reader_limit ... ok
test tests::e2e::test_catchup_on_refs_announcements ... ok
test tests::e2e::test_clone ... ok
test tests::e2e::test_connection_crossing ... ok
test tests::e2e::test_dont_fetch_owned_refs ... ok
test tests::e2e::test_fetch_emits_canonical_ref_update_partial_glob ... ok
test tests::e2e::test_concurrent_fetches ... ok
test tests::e2e::test_fetch_followed_remotes ... ok
test tests::e2e::test_fetch_preserve_owned_refs ... ok
test tests::e2e::test_fetch_unseeded ... ok
test tests::e2e::test_inventory_sync_basic ... ok
test tests::e2e::test_fetch_up_to_date ... ok
test tests::e2e::test_fetch_emits_canonical_ref_update ... ok
test tests::e2e::test_large_fetch ... ok
test tests::e2e::test_migrated_clone ... ok
test tests::e2e::test_missing_remote ... ok
test tests::e2e::test_multiple_offline_inits ... ok
test tests::e2e::test_non_fast_forward_identity_doc ... ok
test tests::e2e::test_non_fast_forward_sigrefs ... ok
test tests::e2e::test_outdated_delegate_sigrefs ... ok
test tests::e2e::test_outdated_sigrefs ... ok
test tests::e2e::test_replication ... ok
test tests::e2e::test_inventory_sync_bridge ... ok
test tests::e2e::test_inventory_sync_ring ... ok
test tests::e2e::test_inventory_sync_star ... ok
test tests::e2e::test_replication_invalid ... ok
test tests::e2e::test_replication_ref_in_sigrefs ... ok
test tests::test_announcement_rebroadcast ... ok
test tests::test_announcement_rebroadcast_duplicates ... ok
test tests::test_announcement_rebroadcast_timestamp_filtered ... ok
test tests::test_announcement_relay ... ok
test tests::test_connection_kept_alive ... ok
test tests::test_disconnecting_unresponsive_peer ... ok
test tests::test_fetch_missing_inventory_on_gossip ... ok
test tests::test_fetch_missing_inventory_on_schedule ... ok
test tests::test_inbound_connection ... ok
test tests::test_inventory_decode ... ok
test tests::test_init_and_seed ... ok
test tests::test_inventory_relay ... ok
test tests::test_inventory_relay_bad_timestamp ... ok
test tests::test_inventory_sync ... ok
test tests::test_maintain_connections ... ok
test tests::test_maintain_connections_failed_attempt ... ok
test tests::test_maintain_connections_same_second_loop ... ok
test tests::test_maintain_connections_transient ... ok
test tests::test_inventory_pruning ... ok
test tests::test_orphaned_fetch_blocks_repo_from_all_nodes ... ok
test tests::test_outbound_connection ... ok
test tests::test_persistent_peer_connect ... ok
test tests::test_persistent_peer_reconnect_attempt ... ok
test tests::test_persistent_peer_reconnect_success ... ok
test tests::test_ping_response ... ok
test tests::test_queued_fetch_from_ann_same_rid ... ok
test tests::test_queued_fetch_max_capacity ... ok
test tests::test_queued_fetch_from_command_same_rid ... ok
test tests::test_redundant_connect ... ok
test tests::test_refs_announcement_followed ... ok
test tests::test_refs_announcement_fetch_trusted_no_inventory ... ok
test tests::test_refs_announcement_no_subscribe ... ok
test tests::test_refs_announcement_offline ... ok
test tests::test_refs_announcement_relay_private ... ok
test tests::prop_inventory_exchange_dense ... ok
test tests::test_announcement_message_amplification ... ok
test tests::test_refs_announcement_relay_public ... ok
test wire::test::test_inventory_ann_with_extension ... ok
test wire::test::test_pong_message_with_extension ... ok
test tests::test_seeding ... ok
test wire::test::worker_result_clears_active_when_peer_connected ... ok
test tests::test_seed_repo_subscribe ... ok
test wire::test::worker_result_clears_active_when_peer_disconnecting ... ok
test tests::test_refs_synced_event ... ok
test result: ok. 84 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 15.57s
Running unittests src/main.rs (target/debug/deps/radicle_node-388c037e59b06fbe)
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/lib.rs (target/debug/deps/radicle_oid-f350725ba9f62eb5)
running 10 tests
test fmt::test::zero ... ok
test fmt::test::fixture ... ok
test git2::test::zero ... ok
test fmt::test::gix ... ok
test gix::test::zero ... ok
test str::test::fixture ... ok
test fmt::test::git2 ... ok
test str::test::git2_roundtrip ... ok
test str::test::gix_roundtrip ... ok
test str::test::zero ... ok
test result: ok. 10 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/lib.rs (target/debug/deps/radicle_protocol-d984e15bcd2f38e3)
running 100 tests
test deserializer::test::test_decode_next ... ok
test deserializer::test::test_unparsed ... ok
test deserializer::test::prop_decode_next ... ok
test fetcher::service::tests::test_fetch_coalescing_different_refs ... ok
test fetcher::test::queue::properties::capacity::rejection ... ok
test fetcher::test::queue::properties::capacity::bounded ... ok
test fetcher::test::queue::properties::dequeue::empty_queue_returns_none ... ok
test fetcher::test::queue::properties::dequeue::enables_reenqueue ... ok
test fetcher::test::queue::properties::dequeue::drained_queue_returns_none ... ok
test fetcher::test::queue::properties::capacity::capacity_reached_returns_same_item ... ok
test fetcher::test::queue::properties::capacity::restored_after_dequeue ... ok
test fetcher::test::queue::properties::fifo::interleaved_operations ... ok
test fetcher::test::queue::properties::fifo::ordering ... ok
test fetcher::test::queue::properties::equality::reflexive ... ok
test fetcher::test::queue::properties::merge::different_rid_accepted ... ok
test fetcher::test::queue::properties::equality::symmetric ... ok
test fetcher::test::queue::properties::merge::does_not_increase_queue_length ... ok
test fetcher::test::queue::properties::merge::longer_timeout_preserved ... ok
test fetcher::test::queue::properties::merge::combines_refs ... ok
test fetcher::test::queue::properties::equality::transitive ... ok
test fetcher::test::queue::unit::capacity_takes_precedence_over_merge_for_new_items ... ok
test fetcher::test::queue::unit::empty_refs_items_can_be_equal ... ok
test fetcher::test::queue::unit::max_timeout_accepted ... ok
test fetcher::test::queue::unit::merge_preserves_position_in_queue ... ok
test fetcher::test::queue::unit::zero_timeout_accepted ... ok
test fetcher::test::state::command::cancel::cancellation_is_isolated ... ok
test fetcher::test::state::command::cancel::non_existent_returns_unexpected ... ok
test fetcher::test::state::command::cancel::ongoing_and_queued ... ok
test fetcher::test::state::command::cancel::single_ongoing ... ok
test fetcher::test::state::command::fetch::fetch_after_previous_completed ... ok
test fetcher::test::state::command::fetch::fetch_at_capacity_enqueues ... ok
test fetcher::test::state::command::fetch::fetch_different_repo_same_node_within_capacity ... ok
test fetcher::test::state::command::fetch::fetch_duplicate_returns_already_fetching ... ok
test fetcher::test::state::command::fetch::fetch_queue_merge_empty_refs_fetches_all ... ok
test fetcher::test::state::command::fetch::fetch_queue_merge_takes_longer_timeout ... ok
test fetcher::test::state::command::fetch::fetch_queue_merges_already_queued ... ok
test fetcher::test::state::command::fetch::fetch_queue_rejected_capacity_reached ... ok
test fetcher::test::state::command::fetch::fetch_same_repo_different_nodes_queues_second ... ok
test fetcher::test::state::command::fetch::fetch_same_repo_different_refs_enqueues ... ok
test fetcher::test::state::command::fetch::fetch_start_first_fetch_for_node ... ok
test fetcher::test::state::command::fetched::complete_one_of_multiple ... ok
test fetcher::test::state::command::fetched::complete_single_ongoing ... ok
test fetcher::test::state::command::fetched::complete_then_dequeue_fifo ... ok
test fetcher::test::state::command::fetched::non_existent_returns_not_found ... ok
test fetcher::test::queue::properties::merge::empty_refs_fetches_all ... ok
test fetcher::test::state::command::fetched::stale_from_does_not_clear_active ... ok
test fetcher::test::state::concurrent::fetched_then_cancel ... ok
test fetcher::test::state::concurrent::interleaved_operations ... ok
test fetcher::test::state::config::min_queue_size ... ok
test fetcher::test::state::dequeue::cannot_dequeue_while_node_at_capacity ... ok
test fetcher::test::state::dequeue::empty_queue_returns_none ... ok
test fetcher::test::queue::properties::merge::succeed_when_at_capacity ... ok
test fetcher::test::state::invariant::queue_integrity_after_merge ... ok
test fetcher::test::state::dequeue::maintains_fifo_order ... ok
test fetcher::test::state::multinode::independent_queues ... ok
test service::filter::test::compatible ... ok
test service::filter::test::test_parameters ... ok
test service::filter::test::test_sizes ... ok
test service::gossip::store::test::test_announced ... ok
test service::limiter::test::test_limiter_different_rates ... ok
test service::limiter::test::test_limiter_multi ... ok
test service::limiter::test::test_limiter_refill ... ok
test fetcher::test::state::config::high_concurrency ... ok
test fetcher::test::queue::properties::merge::same_rid_merges_anywhere_in_queue ... ok
test service::message::tests::test_inventory_limit ... ok
test service::message::tests::test_ref_remote_limit ... ok
test wire::frame::test::test_encode_git_large ... ok
test wire::frame::test::test_stream_id ... ok
test fetcher::test::state::multinode::high_count ... ok
test wire::message::tests::prop_roundtrip_address ... ok
test service::message::tests::prop_refs_announcement_signing ... ok
test wire::message::tests::prop_zero_bytes_encode_decode ... ok
test wire::message::tests::test_inv_ann_max_size ... ok
test wire::message::tests::test_node_ann_max_size ... ok
test wire::message::tests::test_ping_encode_size_overflow - should panic ... ok
test wire::message::tests::test_pingpong_encode_max_size ... ok
test wire::message::tests::test_pong_encode_size_overflow - should panic ... ok
test service::message::tests::test_node_announcement_validate ... ok
test wire::tests::prop_oid ... ok
test wire::tests::prop_roundtrip_filter ... ok
test wire::message::tests::prop_roundtrip_message ... ok
test wire::tests::prop_roundtrip_refs ... ok
test wire::tests::prop_roundtrip_repoid ... ok
test wire::tests::prop_roundtrip_publickey ... ok
test wire::tests::prop_roundtrip_u16 ... ok
test wire::tests::prop_roundtrip_u32 ... ok
test wire::tests::prop_roundtrip_u64 ... ok
test wire::tests::prop_roundtrip_vec ... ok
test wire::tests::prop_signature ... ok
test wire::tests::prop_roundtrip_tuple ... ok
test wire::tests::prop_string ... ok
test wire::tests::test_alias ... ok
test wire::tests::test_bounded_vec_limit ... ok
test wire::tests::test_filter_invalid ... ok
test wire::tests::test_string ... ok
test wire::varint::test::prop_roundtrip_varint ... ok
test wire::varint::test::test_encoding ... ok
test wire::varint::test::test_encode_overflow - should panic ... ok
test wire::message::tests::test_refs_ann_max_size ... ok
test wire::message::tests::prop_message_decoder ... ok
test result: ok. 100 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.93s
Running unittests src/main.rs (target/debug/deps/git_remote_rad-ec460ed6e139fb1e)
running 12 tests
test protocol::tests::test_capabilities ... ok
test protocol::tests::test_empty ... ok
test protocol::tests::test_fetch ... ok
test protocol::tests::test_fetch_whitespace ... ok
test protocol::tests::test_invalid ... ok
test protocol::tests::test_option ... ok
test protocol::tests::test_option_whitespace_preservation ... ok
test protocol::tests::test_list_for_push ... ok
test protocol::tests::test_list ... ok
test protocol::tests::test_push_delete ... ok
test protocol::tests::test_push ... ok
test protocol::tests::test_push_force ... ok
test result: ok. 12 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/main.rs (target/debug/deps/radicle_schemars-dd3c5e3b8cead261)
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/lib.rs (target/debug/deps/radicle_signals-e91beff5378165d8)
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/lib.rs (target/debug/deps/radicle_systemd-77e26f6a607513aa)
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/lib.rs (target/debug/deps/radicle_term-afa03b1828121040)
running 22 tests
test ansi::tests::colors_disabled ... ok
test ansi::tests::wrapping ... ok
test ansi::tests::no_color_disables_colors_not_styles ... ok
test ansi::tests::colors_enabled ... ok
test cell::test::test_width ... ok
test element::test::test_spaced ... ok
test table::test::test_table ... ok
test element::test::test_truncate ... ok
test element::test::test_width ... ok
test table::test::test_table_border_truncated ... ok
test table::test::test_table_border_maximized ... ok
test table::test::test_table_border ... ok
test table::test::test_table_truncate ... ok
test table::test::test_table_unicode ... ok
test textarea::test::test_wrapping ... ok
test table::test::test_table_unicode_truncate ... ok
test table::test::test_truncate ... ok
test textarea::test::test_wrapping_code_block ... ok
test textarea::test::test_wrapping_fenced_block ... ok
test textarea::test::test_wrapping_paragraphs ... ok
test vstack::test::test_vstack ... ok
test vstack::test::test_vstack_maximize ... ok
test result: ok. 22 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/lib.rs (target/debug/deps/radicle_windows-942926f7348a8563)
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle
running 1 test
test crates/radicle/src/cob/patch/encoding/review.rs - cob::patch::encoding::review::Review (line 23) ... ignored
test result: ok. 0 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_cli
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_cli_test
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_cob
running 1 test
test crates/radicle-cob/src/backend/stable.rs - backend::stable::with_advanced_timestamp (line 56) ... ignored
test result: ok. 0 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out; finished in 0.00s
all doctests ran in 0.08s; merged doctests compilation took 0.08s
Doc-tests radicle_core
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_crypto
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_dag
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_fetch
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_git_metadata
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_git_ref_format
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_localtime
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_log
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_node
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_oid
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_protocol
running 6 tests
test crates/radicle-protocol/src/bounded.rs - bounded::BoundedVec<T,N>::collect_from (line 30) ... ok
test crates/radicle-protocol/src/bounded.rs - bounded::BoundedVec<T,N>::push (line 122) ... ok
test crates/radicle-protocol/src/bounded.rs - bounded::BoundedVec<T,N>::truncate (line 50) ... ok
test crates/radicle-protocol/src/bounded.rs - bounded::BoundedVec<T,N>::unbound (line 149) ... ok
test crates/radicle-protocol/src/bounded.rs - bounded::BoundedVec<T,N>::max (line 96) ... ok
test crates/radicle-protocol/src/bounded.rs - bounded::BoundedVec<T,N>::with_capacity (line 66) ... ok
test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
all doctests ran in 0.46s; merged doctests compilation took 0.45s
Doc-tests radicle_signals
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_systemd
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_term
running 1 test
test crates/radicle-term/src/table.rs - table (line 4) ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
all doctests ran in 0.19s; merged doctests compilation took 0.18s
Doc-tests radicle_windows
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Exit code: 0
{
"response": "finished",
"result": "success"
}