rad:z3gqcJUoA1n9HaHKufZs5FCSGazv5 heartwoodfe4b01138d58cd122dfe5af483718c719d69f3af
{
"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": "88bf2a9648750365d4565e32deae35b18808a391",
"after": "fe4b01138d58cd122dfe5af483718c719d69f3af",
"commits": [
"fe4b01138d58cd122dfe5af483718c719d69f3af",
"5bc44b1843ce0d8bda6b27fa7b893ae0f6e6b679",
"fef38aff53c6f0608df8dc580923802250378b24",
"06a715e29d1063fb0300d0c922e3403ea3c25e54",
"405a7e08c77a94e919304f7958f2aa41609a789a",
"019a84537d244a67dd6d551fe7f5dda207eeb7ea",
"40fb03b7d787f34a6d330670b5089db52039c4a1",
"cf4cb9c8529cc0b23dce05c3b5a43c5907cf7fe0",
"a5c8e43a88817d1c30b3f96bf1242132e254509e",
"7c60b774f9c5e658bcd362a41daf9d0fa60656d7",
"af6c71b5d6227f2ffbf5741a6e2322fb43e01ebf",
"517578a656977ed52e83de280afa94fa88bae422",
"f9654bc77fa398204091f237fd3af9412a335b8b",
"892b593c3f8335a455bd915bf4fa2dbaeead26b6",
"284ffc1705748fab303b79fd3b7ac1d2e91ef8eb",
"ad2181a8deffee18982e8bd61843df54c04d9b52",
"eb7d8169e1f53d597caa53cdae60d8bf437700f2"
],
"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
}
]
}
}
{
"response": "triggered",
"run_id": {
"id": "a72cde70-f01d-4c56-bd4b-228dadf0a041"
},
"info_url": "https://cci.rad.levitte.org//a72cde70-f01d-4c56-bd4b-228dadf0a041.html"
}
Started at: 2026-06-24 00:04:33.632728+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/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/
╭────────────────────────────────────╮
│ heartwood │
│ Radicle Heartwood Protocol & Stack │
│ 186 issues · 40 patches │
╰────────────────────────────────────╯
Run `cd ./.` to go to the repository directory.
Exit code: 0
$ rad patch checkout 712a995a282fd544b081ea02dae7ff246810a20c
✓ Switched to branch patch/712a995 at revision 8ff7c16
✓ Branch patch/712a995 setup to track rad/patches/712a995a282fd544b081ea02dae7ff246810a20c
Exit code: 0
$ git config advice.detachedHead false
Exit code: 0
$ git checkout fe4b01138d58cd122dfe5af483718c719d69f3af
HEAD is now at fe4b0113 WIP: Fix test
Exit code: 0
$ rad patch show 712a995a282fd544b081ea02dae7ff246810a20c -p
╭───────────────────────────────────────────────────────────────────────────────╮
│ Title radicle/cob/identity: Rewrite Evaluation │
│ Patch 712a995a282fd544b081ea02dae7ff246810a20c │
│ Author lorenz z6MkkPv…WX5sTEz │
│ Head fe4b01138d58cd122dfe5af483718c719d69f3af │
│ Base 88bf2a9648750365d4565e32deae35b18808a391 │
│ Branches patch/712a995 │
│ Commits ahead 17, behind 12 │
│ 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>>`. │
├───────────────────────────────────────────────────────────────────────────────┤
│ fe4b011 WIP: Fix test │
│ 5bc44b1 radicle/cob/identity: Deprecate `Identity::id` │
│ fef38af radicle/cob/identity: Test redacting accepted revisions │
│ 06a715e radicle/cob/identity: Test queued children's votes │
│ 405a7e0 radicle/cob/identity: Test queued children with delegate change │
│ 019a845 radicle/cob/identity: Add Property Tests │
│ 40fb03b radicle/test/arbitrary: Make BoundedVec shared │
│ cf4cb9c radicle/cob/identity: Fix the documentation in test │
│ a5c8e43 radicle/cob/identity: Test evaluating children of accepted revision │
│ 7c60b77 radicle/cob/identity: Add test for cascading redaction │
│ af6c71b radicle/cob/identity: Add cascading rejections test for identity │
│ 517578a radicle/cob/identity: Verify terminal states cannot be redacted test │
│ f9654bc radicle/cob/identity: Add concurrent terminal state test │
│ 892b593 radicle/cob/identity: Test rejected sibling │
│ 284ffc1 radicle/cob/identity: Rewrite Evaluation │
│ ad2181a radicle/cob/identity: Use verdicts to count votes │
│ eb7d816 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 3 weeks ago │
│ ↑ Revision 83fbe2b @ 998ff91..b3beea8 by ade z6MkwGo…yS2aagA 3 weeks ago │
│ ↑ Revision fbc6da8 @ 998ff91..8e46599 by ade z6MkwGo…yS2aagA 3 weeks ago │
│ ↑ Revision 03e6eee @ 998ff91..7d971f1 by ade z6MkwGo…yS2aagA 3 weeks ago │
│ ↑ Revision 39cbe88 @ 998ff91..a706c99 by fintohaps z6Mkire…SQZ3voM 1 week ago │
│ ↑ Revision 6ddba38 @ 998ff91..87a09c7 by fintohaps z6Mkire…SQZ3voM 1 week ago │
│ ↑ Revision cd80cb5 @ 88bf2a9..e97fb43 by lorenz z6MkkPv…WX5sTEz 4 days ago │
│ ↑ Revision b013388 @ 88bf2a9..ccde4df by lorenz z6MkkPv…WX5sTEz 3 days ago │
│ ↑ Revision 8ff7c16 @ 88bf2a9..fe4b011 by lorenz z6MkkPv…WX5sTEz 6 seconds ago │
╰───────────────────────────────────────────────────────────────────────────────╯
commit fe4b01138d58cd122dfe5af483718c719d69f3af
Author: Lorenz Leutgeb <lorenz.leutgeb@radicle.dev>
Date: Wed Jun 24 00:01:05 2026 +0200
WIP: Fix test
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index c1ed1caed..5e8789579 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1683,6 +1683,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(
@@ -1693,6 +1695,7 @@ 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(),
@@ -1738,8 +1741,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()));
}
commit 5bc44b1843ce0d8bda6b27fa7b893ae0f6e6b679
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 fa8be6507..c1ed1caed 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.
@@ -2346,7 +2343,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 fef38aff53c6f0608df8dc580923802250378b24
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 5549b31fd..fa8be6507 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -2200,6 +2200,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 06a715e29d1063fb0300d0c922e3403ea3c25e54
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Thu Jun 11 08:51:31 2026 +0100
radicle/cob/identity: Test queued children's votes
When a child is being queued for adoption, it needs to account for removed
delegates. The accepted counts for the given child are filtered so that the
correct delegate count is given to `self.is_majority`.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index cd4da82e5..5549b31fd 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -2498,4 +2498,143 @@ mod test {
assert_eq!(eve_identity.revision(&b1).unwrap().state, State::Accepted);
assert_eq!(eve_identity.current, b1);
}
+
+ /// Demonstrates that the re-evaluation of queued children by [`Identity::adopt`]
+ /// does not count votes from delegates who are no longer in the current delegate
+ /// set.
+ #[test]
+ fn queued_child_counts_non_delegate_votes() {
+ use crate::crypto::test::signer::MockSigner;
+ use crate::test::setup::{Node, NodeRepo};
+ use tempfile::tempdir;
+
+ // let majority: ℕ → ℕ = n ↦ (n / 2) + 1;
+
+ 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.
+ // Note that majority(4) = 3.
+ // Since alice is the only delegate, 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. Compared to A₁
+ // (which had 4 delegates), Dave is not a delegate anymore.
+ // Note that majority(3) = 2, which is lower than for A₁.
+ 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₃ only changes visibility.
+ // Note that at this point, A₁ still is the current revision, not
+ // A₂. Therefore, the majority threshold of the current revision is
+ // still 3 (for 4 delegates in A₁) not 2 (for 3 delegates in A₂).
+ 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 accepts A₃.
+ // Dave is a delegate in A₁, which is the current revision,
+ // so this is allowed.
+ dave_repo.fetch(alice);
+ let mut dave_identity = Identity::load_mut(&*dave_repo, &dave_node.signer).unwrap();
+ dave_identity.accept(&a3).unwrap();
+
+ // A₃ now has 2 accepting votes:
+ // 1. Alice (voted implicitly, since they created the revision)
+ // 2. Dave (voted explicitly)
+
+ // Bob accepts A₂.
+ bob.repo.fetch(alice);
+ let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
+ bob_identity.accept(&a2).unwrap();
+
+ // Eve fetches from everyone and accepts A₂.
+ // A₂ reaches 3 accepting votes (by Alice, Bob, and Eve),
+ // thus is adopted and becomes the current revision.
+ //
+ // A₂'s doc: {Alice, Bob, Eve}, majority = 2.
+ //
+ // Re-evaluate A₃: accepted().count() = 2 (Alice + Dave).
+ // is_majority(2) with 3 delegates → 2 >= 2 → true. B1 adopted!
+ //
+ // BUG: Dave is NOT a delegate in A2's doc. His vote should not
+ // count towards the new quorum. Only Alice's vote is legitimate
+ // → 1 vote. 1 < 2. B1 should NOT be adopted.
+ //
+ // A₃ [Accepted — but only 1 valid delegate vote!]
+ // |
+ // A₂ [Accepted, removes Dave]
+ // |
+ // A₁ [Accepted, 4 delegates]
+ // |
+ // A₀
+ eve.repo.fetch(alice);
+ eve.repo.fetch(bob);
+ eve.repo.fetch(&dave_node);
+ 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);
+
+ // Verify Dave is not a delegate in the adopted revision doc.
+ assert!(
+ !eve_identity
+ .doc()
+ .is_delegate(&dave_node.signer.public_key().into())
+ );
+
+ // A₃ has 2 accepting votes (by Alice and Dave), but Dave is no longer
+ // a delegate according to A₂ doc. Only Alice's vote is counted, which
+ // leaves 1 vote.
+ // However, 1 < majority(2), so A₃ should not be adopted.
+ assert_eq!(eve_identity.revision(&a3).unwrap().state, State::Active);
+ assert_eq!(eve_identity.current, a2);
+ }
}
commit 405a7e08c77a94e919304f7958f2aa41609a789a
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 bfad9f79e..cd4da82e5 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -2381,4 +2381,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 019a84537d244a67dd6d551fe7f5dda207eeb7ea
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 three 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 must only have a
parent that is `Accepted`, and not `Rejected` or `Redacted`.
- `Active` revisions never contain a majority approval.
- `Accepted` revisions always contain a majority approval.
- `Rejected` revisions can never meet a majority approval.
- There can only be one `Accepted` sibling, i.e. all other siblings are in the
`Rejected` state.
- A revision which is `Rejected(RejectedBy::Parent)` must have a parent that
is `Rejected`.
- A revision which is `Redacted(RedactedBy::Parent)` must have a parent that
is `Redacted`.
- A revision cannot be `Active` if its parent is `Rejected` or `Redacted`.
- 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 77bc0f126..bfad9f79e 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1235,6 +1235,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..6e022e3ab
--- /dev/null
+++ b/crates/radicle/src/cob/identity/test/property.rs
@@ -0,0 +1,735 @@
+use qcheck::{Arbitrary, TestResult};
+use qcheck_macros::quickcheck;
+
+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.
+#[quickcheck]
+fn prop_invariants(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()
+}
+
+/// The property tests keep track of 3 actors interacting with the repository
+/// identity.
+#[derive(Clone, Copy, Debug)]
+enum Actor {
+ Alice,
+ Bob,
+ Eve,
+}
+
+/// Enumerate all the actors in an array.
+const ACTORS: [Actor; 3] = [Actor::Alice, Actor::Bob, Actor::Eve];
+
+/// [`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],
+ }
+ }
+
+ fn apply(&mut self, op: &TestOp) {
+ match &op.action {
+ OpAction::Update { toggle_delegate } => {
+ let (_, mut identity, mut doc) = self.signer_identity_doc_for(&op.actor);
+
+ self.toggle_delegate(toggle_delegate, &mut doc);
+ self.update_description(&mut doc, "Fuzz");
+
+ if let Ok(rev) = cob::stable::with_advanced_timestamp(|| {
+ identity.update(
+ cob::Title::new("Update").unwrap(),
+ "",
+ &doc.verified().unwrap(),
+ )
+ }) {
+ self.revisions.push(rev);
+ }
+ }
+ OpAction::UpdateRandom {
+ toggle_delegate,
+ parent_idx,
+ } => {
+ if self.revisions.is_empty() {
+ return;
+ }
+ let parent_rev = self.revisions[*parent_idx % self.revisions.len()];
+
+ let (signer, mut identity, mut doc) = self.signer_identity_doc_for(&op.actor);
+ self.toggle_delegate(toggle_delegate, &mut doc);
+ self.update_description(&mut doc, "Fuzz Child");
+
+ // Use a manual transaction to force the parent to be `parent_rev`
+ if let Ok(rev) = cob::stable::with_advanced_timestamp(|| {
+ identity.transaction("Update Child", |tx, r| {
+ *tx = Transaction::new_revision(
+ cob::Title::new("Update Child").unwrap(),
+ "",
+ &doc.verified().unwrap(),
+ Some(parent_rev),
+ r,
+ signer,
+ )?;
+ Ok(())
+ })
+ }) {
+ self.revisions.push(rev);
+ }
+ }
+ OpAction::Accept(idx) => {
+ if self.revisions.is_empty() {
+ return;
+ }
+ let rev = self.revisions[*idx % self.revisions.len()];
+ let mut identity = self.identity_for(&op.actor);
+ let _ = cob::stable::with_advanced_timestamp(|| identity.accept(&rev));
+ }
+ OpAction::Reject(idx) => {
+ if self.revisions.is_empty() {
+ return;
+ }
+ let rev = self.revisions[*idx % self.revisions.len()];
+ let mut identity = self.identity_for(&op.actor);
+ let _ = cob::stable::with_advanced_timestamp(|| identity.reject(rev));
+ }
+ OpAction::Redact(idx) => {
+ if self.revisions.is_empty() {
+ return;
+ }
+ let rev = self.revisions[*idx % self.revisions.len()];
+ let mut identity = self.identity_for(&op.actor);
+ let _ = cob::stable::with_advanced_timestamp(|| identity.redact(rev));
+ }
+ OpAction::Sync => match op.actor {
+ Actor::Alice => {
+ self.network.alice.repo.fetch(&self.network.bob);
+ self.network.alice.repo.fetch(&self.network.eve);
+ }
+ Actor::Bob => {
+ self.network.bob.repo.fetch(&self.network.alice);
+ self.network.bob.repo.fetch(&self.network.eve);
+ }
+ Actor::Eve => {
+ self.network.eve.repo.fetch(&self.network.alice);
+ self.network.eve.repo.fetch(&self.network.bob);
+ }
+ },
+ }
+ }
+
+ 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 toggle_delegate(&self, delegate: &Actor, doc: &mut crate::prelude::RawDoc) {
+ let target_delegate: Did = match delegate {
+ 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(),
+ };
+
+ 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),
+ };
+ 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;
+
+ // Hub and spoke sync
+ alice.repo.fetch(bob);
+ alice.repo.fetch(eve);
+
+ bob.repo.fetch(alice);
+ eve.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();
+
+ self.assert_local_invariants_for(&alice_diverged_id);
+ self.assert_local_invariants_for(&bob_diverged_id);
+ self.assert_local_invariants_for(&eve_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);
+ }
+
+ /// 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();
+
+ 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, alice.current, "Eve 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",
+ );
+ }
+ _ => {}
+ }
+ }
+ }
+}
commit 40fb03b7d787f34a6d330670b5089db52039c4a1
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 has an `Abritrary` implementation is useful for all property testing.
Move it from the `sigrefs` module so that it can be reused by other components.
It also improved so that it uses `const`, which allows callers to determine the
size at compile time.
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 cf4cb9c8529cc0b23dce05c3b5a43c5907cf7fe0
Author: Adrian Duke <adrian.duke@gmail.com>
Date: Fri May 29 19:43:44 2026 +0100
radicle/cob/identity: Fix the documentation in test
The test `test_identity_reject_concurrent` incorrectly listed the number of
votes and delegates.
radicle/cob/identity: Introduce ancestor failure states
This introduces `AncestorRejected` and `AncestorRedacted` to the `State`
enum. These new states explicitly track when a revision is implicitly
doomed because its parent or older ancestor reached a terminal failure
state, distinguishing them from revisions that were explicitly voted
down or withdrawn.
Additionally, this refactors the complex, nested `loop` logic previously
used in `adopt` and `reject_children`. By leveraging the `children_of`
map, the code now uses a clean, stack-based depth-first traversal
(`reject_descendants`) to efficiently cascade terminal states down the
revision tree.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 9fb1ed1a2..77bc0f126 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1802,14 +1802,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 a5c8e43a88817d1c30b3f96bf1242132e254509e
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 441ad2d4d..9fb1ed1a2 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -2293,4 +2293,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 7c60b774f9c5e658bcd362a41daf9d0fa60656d7
Author: Adrian Duke <adrian.duke@gmail.com>
Date: Fri May 22 15:35:02 2026 +0100
radicle/cob/identity: Add test for cascading redaction
Add a test case to show that when a revision is redacted that its children also
become redacted, through the `Ancestor` reason.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 850805eb4..441ad2d4d 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1523,6 +1523,83 @@ 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)
+ );
+ }
+
#[test]
fn accepted_sibling_causes_rejection() {
let network = Network::default();
commit af6c71b5d6227f2ffbf5741a6e2322fb43e01ebf
Author: Adrian Duke <adrian.duke@gmail.com>
Date: Fri May 22 14:39:18 2026 +0100
radicle/cob/identity: Add cascading rejections test for identity
The identity evaluation rewrite added a strict linear history
requirement. When a revision reaches qourum and is adopted, the state
machine sweeps the graph and explicitly marks all competing sibling
revisions as `Rejected`.
However, the test suite lacked coverage for deeper proposal branches,
specifically verifying that this rejection correctly cascades to the
children of those rejected siblings.
This commit introduces a test to simulate the scenario where a
delegate eagerly proposes a chain of revisions (a child branching off a
sibling) while the network concurrently accepts a competing branch.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 6024e8d73..850805eb4 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1829,6 +1829,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 517578a656977ed52e83de280afa94fa88bae422
Author: Adrian Duke <adrian.duke@gmail.com>
Date: Fri May 22 14:24:33 2026 +0100
radicle/cob/identity: Verify terminal states cannot be redacted test
The identity evaluation rewrite changed how revision redactions are
handled. Instead of removing the revision entirely, it explicitly
transitions the revision to `State::Redacted`. Alongside this, guards we
added to ensure only `Active` revisions can be redacted.
Adds a test to cover for the specific redaction boundaries:
- 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 291fe8e28..6024e8d73 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1905,6 +1905,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 f9654bc77fa398204091f237fd3af9412a335b8b
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 e71df04f2..291fe8e28 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1829,6 +1829,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 892b593c3f8335a455bd915bf4fa2dbaeead26b6
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 2e5cac46d..e71df04f2 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1523,6 +1523,78 @@ 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 // Change description to change traversal order.
+ .update(
+ cob::Title::new("Add Bob and Eve").unwrap(),
+ "Eh#!",
+ &alice_doc.clone().verified().unwrap(),
+ )
+ .unwrap();
+
+ bob.repo.fetch(alice);
+ eve.repo.fetch(alice);
+
+ let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
+ assert_eq!(bob_identity.current, a1);
+
+ let mut bob_doc = bob_identity.doc().clone().edit();
+ bob_doc.visibility = Visibility::private([]);
+ let bob_doc = bob_doc.verified().unwrap();
+ let b1 = cob::stable::with_advanced_timestamp(|| {
+ bob_identity
+ .update(
+ cob::Title::new("Make private").unwrap(),
+ "",
+ &bob_doc.clone(),
+ )
+ .unwrap()
+ });
+
+ // Now, bob is very eager to change the description of the repository,
+ // and does not wait for Eve to accept `b1`.
+
+ let bob_doc = bob_doc.clone().edit();
+ bob_doc
+ .project()
+ .unwrap()
+ .update(None, Some("New Description".to_string()), None)
+ .unwrap();
+ let bob_doc = bob_doc.verified().unwrap();
+ let b2 = cob::stable::with_advanced_timestamp(|| {
+ bob_identity
+ .update(cob::Title::new("Change Description").unwrap(), "", &bob_doc)
+ .unwrap()
+ });
+
+ eve.repo.fetch(bob);
+
+ let mut eve_identity = Identity::load_mut(&*eve.repo, &eve.signer).unwrap();
+
+ // Eve is now ready to accept Bob's revision `b1`, but Bob's newest is `b2`.
+ cob::stable::with_advanced_timestamp(|| eve_identity.accept(&b1).unwrap());
+
+ // Now that Eve has accepted `b1`, it should be accepted and thus current.
+ assert_eq!(eve_identity.current, b1);
+ // The sibling revision `b2` should be rejected.
+ assert_eq!(
+ eve_identity.revision(&b2).unwrap().state,
+ State::Rejected(RejectedBy::Sibling(b1))
+ );
+ }
+
#[test]
fn test_identity_remove_delegate_concurrent() {
let network = Network::default();
commit 284ffc1705748fab303b79fd3b7ac1d2e91ef8eb
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.
This is achieved through two main improvements. The first is that the state of
the revision is enumerated with a richer set of variants.
The `Active` and `Accepted` states remain, and their meanings also remain the same.
The `Rejected` state has been improved to also contain a `RejectedBy` enumeration.
This keeps track of the reason why the revision was rejected, one of: `Vote`,
`Ancestor`, or `Sibling`.
Similarly, the implicit state of being "redacted" is now explicitly tracked with
a variant, `Redacted`. This also keeps track of the reason, one of: `Author`, or
`Ancestor`.
The `Stale` variant is removed entirely.
With this in perspective, how these states are used is more clear. The
evaluation introduces keeping track of child revisions. The transition of a
revision from an `Active` state to one of the other states consequently
transitions sibling and child revisions.
If a revision transitions to `Accepted`, then the sibling revisions can no
longer be put up to vote. They are considered `Rejected` where the reason is
`Sibling`. This will then have a cascading effect on those revisions' children,
where they become `Rejected` with the reason being `Ancestor`.
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.
If a revision has been rejected through a set of votes, then the state
transitions to `Rejected` where the reason is `Vote`. Similarly to the above,
the children of this revision are also rejected with the reason of `Ancestor`.
Finally, when the author of a revision redacts a revision, the state transitions
to `Redacted`, with the reason being `Author`, and its children are redacted
with the reason being `Ancestor`.
Review
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..2e5cac46d 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,135 @@ 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./Ac
+ /// 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);
+
+ if let parent = candidate.parent.expect("revision has parent")
+ && parent != self.current
+ {
+ log::debug!(
+ "Cannot adopt revision {} because its parent {} is not the current revision {}.",
+ id,
+ parent,
+ self.current
+ );
+ return;
+ }
+
+ if let votes = candidate.accepted().count()
+ && !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 +848,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 +898,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 +967,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 +1034,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 +1046,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 +1232,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 +1244,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 +1362,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 +1399,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 +1467,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,7 +1516,10 @@ 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);
}
@@ -1494,10 +1672,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 +1751,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 ad2181a8deffee18982e8bd61843df54c04d9b52
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 eb7d8169e1f53d597caa53cdae60d8bf437700f2
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 a72cde70-f01d-4c56-bd4b-228dadf0a041 -v /opt/radcis/ci.rad.levitte.org/cci/state/a72cde70-f01d-4c56-bd4b-228dadf0a041/s:/a72cde70-f01d-4c56-bd4b-228dadf0a041/s:ro -v /opt/radcis/ci.rad.levitte.org/cci/state/a72cde70-f01d-4c56-bd4b-228dadf0a041/w:/a72cde70-f01d-4c56-bd4b-228dadf0a041/w -w /a72cde70-f01d-4c56-bd4b-228dadf0a041/w -v /opt/radcis/ci.rad.levitte.org/.radicle:/${id}/.radicle:ro -e RAD_HOME=/${id}/.radicle rust:trixie bash /a72cde70-f01d-4c56-bd4b-228dadf0a041/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 amplify_derive v4.0.1
Downloaded addr2line v0.25.1
Downloaded aho-corasick v1.1.4
Downloaded console v0.16.3
Downloaded convert_case v0.10.0
Downloaded clap_builder v4.6.0
Downloaded errno v0.3.14
Downloaded derive_more v2.1.1
Downloaded outref v0.5.2
Downloaded erased-serde v0.4.10
Downloaded crossterm v0.29.0
Downloaded ed25519 v1.5.3
Downloaded env_filter v1.0.0
Downloaded data-encoding-macro v0.1.19
Downloaded crc32fast v1.5.0
Downloaded cyphernet v0.5.4
Downloaded gix-config-value v0.18.0
Downloaded ed25519-dalek v2.2.0
Downloaded elliptic-curve v0.13.8
Downloaded gix-traverse v0.57.0
Downloaded gix-command v0.9.0
Downloaded diff v0.1.13
Downloaded gix-features v0.48.0
Downloaded jobserver v0.1.34
Downloaded icu_provider v2.1.1
Downloaded icu_properties v2.1.2
Downloaded gix-hashtable v0.15.0
Downloaded fastrand v2.3.0
Downloaded fnv v1.0.7
Downloaded gix-validate v0.11.1
Downloaded base16ct v0.2.0
Downloaded log v0.4.29
Downloaded num-complex v0.4.6
Downloaded pem-rfc7468 v0.7.0
Downloaded num-integer v0.1.46
Downloaded git-ref-format-macro v0.6.0
Downloaded normalize-line-endings v0.3.0
Downloaded pastey v0.2.1
Downloaded memchr v2.8.0
Downloaded num-bigint v0.4.6
Downloaded polyval v0.6.2
Downloaded pkcs8 v0.10.2
Downloaded parking_lot_core v0.9.12
Downloaded ref-cast-impl v1.0.25
Downloaded gix-sec v0.14.0
Downloaded proc-macro2 v1.0.106
Downloaded test-log-macros v0.2.19
Downloaded num v0.4.3
Downloaded sec1 v0.7.3
Downloaded rusty-fork v0.3.1
Downloaded num-cmp v0.1.0
Downloaded pkcs1 v0.7.5
Downloaded parking_lot v0.12.5
Downloaded signal-hook-registry v1.4.8
Downloaded rustc-demangle v0.1.27
Downloaded radicle-surf v0.27.1
Downloaded sqlite v0.37.0
Downloaded object v0.37.3
Downloaded sqlite3-sys v0.18.0
Downloaded salsa20 v0.10.2
Downloaded sval_serde v2.17.0
Downloaded heapless v0.8.0
Downloaded tempfile v3.27.0
Downloaded sval_json v2.17.0
Downloaded rand_core v0.6.4
Downloaded tracing-log v0.2.0
Downloaded structured-logger v1.0.5
Downloaded jiff-static v0.2.23
Downloaded unicode-display-width v0.3.0
Downloaded rand v0.9.2
Downloaded sval v2.17.0
Downloaded value-bag-serde1 v1.12.0
Downloaded regex-syntax v0.8.10
Downloaded tar v0.4.45
Downloaded siphasher v0.3.11
Downloaded snapbox-macros v1.1.0
Downloaded sval_ref v2.17.0
Downloaded wait-timeout v0.2.1
Downloaded semver v1.0.27
Downloaded utf8_iter v1.0.4
Downloaded signals_receipts v0.2.5
Downloaded tree-sitter-md v0.3.2
Downloaded walkdir v2.5.0
Downloaded universal-hash v0.5.1
Downloaded tree-sitter-json v0.24.8
Downloaded version_check v0.9.5
Downloaded tree-sitter-html v0.23.2
Downloaded url v2.5.8
Downloaded zerovec-derive v0.11.2
Downloaded zerofrom v0.1.6
Downloaded socket2 v0.5.10
Downloaded zeroize v1.8.2
Downloaded utf8parse v0.2.2
Downloaded systemd-journal-logger v2.2.2
Downloaded tree-sitter-rust v0.23.3
Downloaded xattr v1.6.1
Downloaded unarray v0.1.4
Downloaded zmij v1.0.21
Downloaded zerofrom-derive v0.1.6
Downloaded tree-sitter v0.24.7
Downloaded vsimd v0.8.0
Downloaded yoke-derive v0.8.1
Downloaded tree-sitter-css v0.23.2
Downloaded idna v1.1.0
Downloaded serde_derive v1.0.228
Downloaded thiserror-impl v1.0.69
Downloaded snapbox v1.2.2
Downloaded yansi v1.0.1
Downloaded tree-sitter-toml-ng v0.6.0
Downloaded yoke v0.8.1
Downloaded itertools v0.14.0
Downloaded tree-sitter-highlight v0.24.7
Downloaded zerotrie v0.2.3
Downloaded uuid v1.22.0
Downloaded ssh-agent-lib v0.6.0
Downloaded toml_datetime v0.7.5+spec-1.1.0
Downloaded zerocopy v0.8.42
Downloaded unicode-segmentation v1.12.0
Downloaded tree-sitter-go v0.23.4
Downloaded serde_json v1.0.149
Downloaded unicode-normalization v0.1.25
Downloaded zerovec v0.11.5
Downloaded toml v0.9.12+spec-1.1.0
Downloaded gimli v0.32.3
Downloaded zlib-rs v0.6.3
Downloaded tree-sitter-c v0.23.4
Downloaded sysinfo v0.37.2
Downloaded serde v1.0.228
Downloaded libm v0.2.16
Downloaded typenum v1.19.0
Downloaded syn v2.0.117
Downloaded tree-sitter-language v0.1.7
Downloaded rustix v1.1.4
Downloaded hashbrown v0.16.1
Downloaded value-bag v1.12.0
Downloaded tree-sitter-bash v0.23.3
Downloaded tracing v0.1.44
Downloaded sharded-slab v0.1.7
Downloaded git2 v0.20.4
Downloaded typeid v1.0.3
Downloaded tinyvec v1.11.0
Downloaded writeable v0.6.2
Downloaded tracing-core v0.1.36
Downloaded thiserror v1.0.69
Downloaded unicode-width v0.2.2
Downloaded test-log v0.2.19
Downloaded jiff v0.2.23
Downloaded syn v1.0.109
Downloaded subtle v2.6.1
Downloaded vcpkg v0.2.15
Downloaded libc v0.2.183
Downloaded streaming-iterator v0.1.9
Downloaded sha1-checked v0.10.0
Downloaded uuid-simd v0.8.0
Downloaded tree-sitter-typescript v0.23.2
Downloaded unicode-ident v1.0.24
Downloaded tree-sitter-ruby v0.23.1
Downloaded libz-sys v1.1.25
Downloaded tree-sitter-python v0.23.6
Downloaded sha3 v0.10.8
Downloaded synstructure v0.13.2
Downloaded ryu v1.0.23
Downloaded tokio v1.50.0
Downloaded serde_core v1.0.228
Downloaded icu_properties_data v2.1.2
Downloaded shlex v1.3.0
Downloaded unit-prefix v0.5.2
Downloaded timeago v0.4.2
Downloaded tracing-subscriber v0.3.23
Downloaded thiserror-impl v2.0.18
Downloaded ssh-key v0.6.7
Downloaded similar v3.1.1
Downloaded value-bag-sval2 v1.12.0
Downloaded toml_writer v1.0.7+spec-1.1.0
Downloaded thread_local v1.1.9
Downloaded thiserror v2.0.18
Downloaded regex-automata v0.4.14
Downloaded inquire v0.9.4
Downloaded stable_deref_trait v1.2.1
Downloaded serde_spanned v1.0.4
Downloaded serde-untagged v0.1.9
Downloaded scopeguard v1.2.0
Downloaded schemars_derive v1.2.1
Downloaded sval_fmt v2.17.0
Downloaded sval_buffer v2.17.0
Downloaded ssh-cipher v0.2.0
Downloaded sqlite3-src v0.7.0
Downloaded signal-hook-mio v0.2.5
Downloaded rsa v0.9.10
Downloaded sval_dynamic v2.17.0
Downloaded spki v0.7.3
Downloaded spin v0.9.8
Downloaded smallvec v1.15.1
Downloaded signature v2.2.0
Downloaded signal-hook v0.3.18
Downloaded same-file v1.0.6
Downloaded indexmap v2.13.0
Downloaded signature v1.6.4
Downloaded shell-words v1.1.1
Downloaded serde_fmt v1.1.0
Downloaded jsonschema v0.30.0
Downloaded gix-transport v0.57.0
Downloaded fraction v0.15.3
Downloaded tinyvec_macros v0.1.1
Downloaded tinystr v0.8.2
Downloaded simd-adler32 v0.3.8
Downloaded rand v0.8.5
Downloaded prodash v31.0.0
Downloaded potential_utf v0.1.4
Downloaded icu_collections v2.1.1
Downloaded ssh-encoding v0.2.0
Downloaded libgit2-sys v0.18.3+1.9.2
Downloaded sha2 v0.10.9
Downloaded ref-cast v1.0.25
Downloaded strsim v0.11.1
Downloaded socks5-client v0.4.3
Downloaded serde_derive_internals v0.29.1
Downloaded secrecy v0.10.3
Downloaded quote v1.0.45
Downloaded sval_nested v2.17.0
Downloaded scrypt v0.11.0
Downloaded referencing v0.30.0
Downloaded rand_chacha v0.9.0
Downloaded radicle-git-ext v0.12.0
Downloaded quick-error v1.2.3
Downloaded qcheck v1.0.0
Downloaded pretty_assertions v1.4.1
Downloaded ppv-lite86 v0.2.21
Downloaded portable-atomic v1.13.1
Downloaded poly1305 v0.8.0
Downloaded pin-project-lite v0.2.17
Downloaded icu_normalizer_data v2.1.1
Downloaded gix-protocol v0.61.0
Downloaded gix-object v0.60.0
Downloaded gix-diff v0.63.0
Downloaded siphasher v1.0.2
Downloaded sha1 v0.10.6
Downloaded sem_safe v0.2.1
Downloaded schemars v1.2.1
Downloaded rustc_version v0.4.1
Downloaded regex v1.12.3
Downloaded rand_chacha v0.3.1
Downloaded radicle-std-ext v0.2.0
Downloaded p384 v0.13.1
Downloaded hmac v0.12.1
Downloaded find-msvc-tools v0.1.9
Downloaded proptest v1.10.0
Downloaded fancy-regex v0.14.0
Downloaded proc-macro-error2 v2.0.1
Downloaded getrandom v0.4.2
Downloaded flate2 v1.1.9
Downloaded primeorder v0.13.6
Downloaded gix-shallow v0.12.0
Downloaded mio v1.1.1
Downloaded memmap2 v0.9.10
Downloaded keccak v0.1.6
Downloaded gix-revwalk v0.31.0
Downloaded gix-error v0.2.3
Downloaded escargot v0.5.15
Downloaded litemap v0.8.1
Downloaded lexopt v0.3.2
Downloaded group v0.13.0
Downloaded gix-url v0.36.0
Downloaded rustversion v1.0.22
Downloaded rfc6979 v0.4.0
Downloaded gix-ref v0.63.0
Downloaded filetime v0.2.27
Downloaded proc-macro-error-attr2 v2.0.0
Downloaded miniz_oxide v0.8.9
Downloaded qcheck-macros v1.0.0
Downloaded percent-encoding v2.3.2
Downloaded linux-raw-sys v0.12.1
Downloaded pbkdf2 v0.12.2
Downloaded gix-tempfile v23.0.0
Downloaded gix-refspec v0.41.0
Downloaded gix-packetline v0.21.3
Downloaded pkg-config v0.3.32
Downloaded p521 v0.13.3
Downloaded nu-ansi-term v0.50.3
Downloaded litrs v1.0.0
Downloaded getrandom v0.2.17
Downloaded rand_xorshift v0.4.0
Downloaded rand_core v0.9.5
Downloaded num-iter v0.1.45
Downloaded maybe-async v0.2.10
Downloaded git-ref-format v0.6.0
Downloaded opaque-debug v0.3.1
Downloaded gix-glob v0.26.0
Downloaded num-rational v0.4.2
Downloaded nonempty v0.12.0
Downloaded lazy_static v1.5.0
Downloaded itoa v1.0.17
Downloaded is_terminal_polyfill v1.70.2
Downloaded inout v0.1.4
Downloaded heck v0.5.0
Downloaded curve25519-dalek v4.1.3
Downloaded phf_shared v0.11.3
Downloaded phf v0.11.3
Downloaded p256 v0.13.2
Downloaded num-bigint-dig v0.8.6
Downloaded noise-framework v0.4.1
Downloaded humantime v2.3.0
Downloaded gix-negotiate v0.31.0
Downloaded gix-fs v0.21.1
Downloaded gix-commitgraph v0.37.0
Downloaded getrandom v0.3.4
Downloaded gix-credentials v0.38.0
Downloaded ghash v0.5.1
Downloaded ff v0.13.1
Downloaded gix-trace v0.1.19
Downloaded nonempty v0.9.0
Downloaded multibase v0.9.2
Downloaded indicatif v0.18.4
Downloaded gix-date v0.15.3
Downloaded either v1.15.0
Downloaded data-encoding v2.10.0
Downloaded once_cell v1.21.4
Downloaded num-traits v0.2.19
Downloaded matchers v0.2.0
Downloaded lock_api v0.4.14
Downloaded cypheraddr v0.4.1
Downloaded bstr v1.12.1
Downloaded match-lookup v0.1.2
Downloaded iana-time-zone v0.1.65
Downloaded gix-actor v0.41.0
Downloaded bcrypt-pbkdf v0.10.0
Downloaded fluent-uri v0.3.2
Downloaded bloomy v1.2.0
Downloaded gix-chunk v0.7.1
Downloaded faster-hex v0.10.0
Downloaded fast-glob v0.3.3
Downloaded anyhow v1.0.102
Downloaded ecdsa v0.16.9
Downloaded base64 v0.22.1
Downloaded gix-utils v0.3.2
Downloaded gix-revision v0.45.0
Downloaded gix-path v0.12.0
Downloaded ec25519 v0.1.0
Downloaded anstream v1.0.0
Downloaded human-panic v2.0.6
Downloaded hash32 v0.3.1
Downloaded gix-quote v0.7.1
Downloaded gix-odb v0.80.0
Downloaded gix-hash v0.25.0
Downloaded generic-array v0.14.7
Downloaded borrow-or-share v0.2.4
Downloaded amplify_syn v2.0.1
Downloaded idna_adapter v1.2.1
Downloaded icu_normalizer v2.1.1
Downloaded icu_locale_core v2.1.1
Downloaded gix-prompt v0.15.0
Downloaded gix-pack v0.70.0
Downloaded gix-lock v23.0.0
Downloaded env_logger v0.11.9
Downloaded emojis v0.6.4
Downloaded derive_more-impl v2.1.1
Downloaded chrono v0.4.44
Downloaded blowfish v0.9.1
Downloaded git-ref-format-core v0.6.0
Downloaded cc v1.2.57
Downloaded block-buffer v0.10.4
Downloaded arc-swap v1.9.1
Downloaded anstyle v1.0.14
Downloaded form_urlencoded v1.2.2
Downloaded cipher v0.4.4
Downloaded cyphergraphy v0.3.1
Downloaded ctr v0.9.2
Downloaded block-padding v0.3.3
Downloaded base64 v0.21.7
Downloaded base32 v0.4.0
Downloaded equivalent v1.0.2
Downloaded ed25519 v2.2.3
Downloaded displaydoc v0.2.5
Downloaded der v0.7.10
Downloaded curve25519-dalek-derive v0.1.1
Downloaded chacha20 v0.9.1
Downloaded cfg-if v1.0.4
Downloaded byteorder v1.5.0
Downloaded bytecount v0.6.9
Downloaded base256emoji v1.0.2
Downloaded anstyle-parse v1.0.0
Downloaded crossbeam-channel v0.5.15
Downloaded cbc v0.1.2
Downloaded ahash v0.8.12
Downloaded bytesize v2.3.1
Downloaded anstyle-parse v0.2.7
Downloaded dyn-clone v1.0.20
Downloaded ct-codecs v1.1.6
Downloaded clap v4.6.0
Downloaded chacha20poly1305 v0.10.1
Downloaded base64ct v1.8.3
Downloaded base-x v0.2.11
Downloaded anstyle-query v1.1.5
Downloaded bitflags v2.11.0
Downloaded backtrace v0.3.76
Downloaded document-features v0.2.12
Downloaded digest v0.10.7
Downloaded data-encoding-macro-internal v0.1.17
Downloaded crypto-common v0.1.7
Downloaded colored v2.2.0
Downloaded colorchoice v1.0.5
Downloaded clap_lex v1.1.0
Downloaded clap_complete v4.6.0
Downloaded crypto-bigint v0.5.5
Downloaded bytes v1.11.1
Downloaded amplify_num v0.5.3
Downloaded aes-gcm v0.10.3
Downloaded aes v0.8.4
Downloaded email_address v0.2.9
Downloaded dunce v1.0.5
Downloaded crossbeam-utils v0.8.21
Downloaded cpufeatures v0.2.17
Downloaded const-str v0.4.3
Downloaded const-oid v0.9.6
Downloaded bit-set v0.8.0
Downloaded ascii v1.1.0
Downloaded anstream v0.6.21
Downloaded aead v0.5.2
Downloaded adler2 v2.0.1
Downloaded bit-vec v0.8.0
Downloaded autocfg v1.5.0
Downloaded clap_derive v4.6.0
Downloaded amplify v4.9.0
Compiling libc v0.2.183
Compiling proc-macro2 v1.0.106
Compiling unicode-ident v1.0.24
Compiling quote v1.0.45
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
Compiling syn v2.0.117
Checking rand_core v0.6.4
Checking memchr v2.8.0
Compiling jobserver v0.1.34
Compiling shlex v1.3.0
Compiling find-msvc-tools v0.1.9
Checking crypto-common v0.1.7
Checking subtle v2.6.1
Compiling cc v1.2.57
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
Compiling crc32fast v1.5.0
Checking tinyvec_macros v0.1.1
Checking gix-trace v0.1.19
Compiling erased-serde v0.4.10
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
Checking bstr v1.12.1
Compiling thiserror-impl v2.0.18
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 rustix v1.1.4
Compiling heapless v0.8.0
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 percent-encoding v2.3.2
Checking once_cell v1.21.4
Checking litemap v0.8.1
Checking writeable v0.6.2
Checking gix-hash v0.25.0
Checking icu_locale_core v2.1.1
Checking zerotrie v0.2.3
Checking potential_utf v0.1.4
Compiling icu_properties_data v2.1.2
Compiling icu_normalizer_data v2.1.1
Compiling zmij v1.0.21
Checking icu_provider v2.1.1
Checking icu_collections v2.1.1
Checking der v0.7.10
Checking equivalent v1.0.2
Compiling serde_json v1.0.149
Checking indexmap v2.13.0
Compiling ref-cast v1.0.25
Compiling thiserror v1.0.69
Compiling vcpkg v0.2.15
Compiling syn v1.0.109
Checking icu_normalizer v2.1.1
Compiling libz-sys v1.1.25
Checking icu_properties v2.1.2
Checking ppv-lite86 v0.2.21
Checking tempfile v3.27.0
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 num-integer v0.1.46
Checking idna_adapter v1.2.1
Checking hmac v0.12.1
Checking universal-hash v0.5.1
Compiling tree-sitter-language v0.1.7
Checking opaque-debug v0.3.1
Checking dyn-clone v1.0.20
Checking utf8_iter v1.0.4
Checking spki v0.7.3
Checking idna v1.1.0
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 rand v0.8.5
Checking url v2.5.8
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
Checking schemars v1.2.1
Compiling rustc_version v0.4.1
Compiling amplify_derive v4.0.1
Checking poly1305 v0.8.0
Checking rfc6979 v0.4.0
Checking chacha20 v0.9.1
Checking amplify_num v0.5.3
Checking ct-codecs v1.1.6
Checking ascii v1.1.0
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 amplify v4.9.0
Checking primeorder v0.13.6
Checking polyval v0.6.2
Compiling num-bigint-dig v0.8.6
Checking base64ct v1.8.3
Checking cyphergraphy v0.3.1
Checking ghash v0.5.1
Checking pem-rfc7468 v0.7.0
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 aes-gcm v0.10.3
Checking sha3 v0.10.8
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 p384 v0.13.1
Checking p256 v0.13.2
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 base256emoji v1.0.2
Checking ssh-key v0.6.7
Checking data-encoding-macro v0.1.19
Checking noise-framework v0.4.1
Checking socks5-client v0.4.3
Checking secrecy v0.10.3
Checking base-x v0.2.11
Checking ssh-agent-lib v0.6.0
Checking multibase v0.9.2
Checking crossbeam-channel v0.5.15
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 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-localtime)
Checking radicle-git-metadata v0.2.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-git-metadata)
Checking radicle-dag v0.10.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-dag)
Checking colorchoice v1.0.5
Checking is_terminal_polyfill v1.70.2
Checking anstyle v1.0.14
Checking radicle-git-ref-format v0.1.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-git-ref-format)
Checking gix-hashtable v0.15.0
Compiling unicode-segmentation v1.12.0
Checking base64 v0.21.7
Compiling radicle v0.24.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle)
Compiling signal-hook v0.3.18
Compiling convert_case v0.10.0
Checking gix-date v0.15.3
Checking gix-actor v0.41.0
Checking signal-hook-registry v1.4.8
Checking gix-object v0.60.0
Checking serde-untagged v0.1.9
Checking bytesize v2.3.1
Checking memmap2 v0.9.10
Checking fast-glob v0.3.3
Checking dunce v1.0.5
Checking nonempty v0.12.0
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 litrs v1.0.0
Checking unicode-width v0.2.2
Compiling portable-atomic v1.13.1
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 gix-revwalk v0.31.0
Checking anstream v1.0.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 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-signals)
Checking gix-quote v0.7.1
Checking shell-words v1.1.1
Checking either v1.15.0
Checking iana-time-zone v0.1.65
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 gimli v0.32.3
Checking adler2 v2.0.1
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-shallow v0.12.0
Checking gix-ref v0.63.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 tar v0.4.45
Compiling flate2 v1.1.9
Compiling git-ref-format-macro v0.6.0
Checking snapbox-macros v1.1.0
Checking salsa20 v0.10.2
Checking clap_lex v1.1.0
Checking similar v3.1.1
Checking strsim v0.11.1
Compiling heck v0.5.0
Checking siphasher v0.3.11
Checking normalize-line-endings v0.3.0
Checking streaming-iterator v0.1.9
Checking snapbox v1.2.2
Checking bloomy v1.2.0
Compiling clap_derive v4.6.0
Checking clap_builder v4.6.0
Compiling radicle-surf v0.27.1
Checking scrypt v0.11.0
Checking git-ref-format v0.6.0
Checking systemd-journal-logger v2.2.2
Checking serde_spanned v1.0.4
Checking toml_datetime v0.7.5+spec-1.1.0
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-python v0.23.6
Compiling tree-sitter-json v0.24.8
Compiling tree-sitter-html v0.23.2
Compiling tree-sitter-md v0.3.2
Compiling tree-sitter-go v0.23.4
Compiling tree-sitter-ruby v0.23.1
Compiling tree-sitter-bash v0.23.3
Compiling tree-sitter-c v0.23.4
Compiling tree-sitter-rust v0.23.3
Checking radicle-std-ext v0.2.0
Checking pin-project-lite v0.2.17
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 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-crypto)
Checking clap v4.6.0
Checking sysinfo v0.37.2
Checking yansi v1.0.1
Compiling radicle-cli v0.21.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-cli)
Compiling radicle-node v0.20.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-node)
Checking diff v0.1.13
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 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/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
Compiling escargot v0.5.15
Checking timeago v0.4.2
Checking lexopt v0.3.2
Checking humantime v2.3.0
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 env_logger v0.11.9
Checking fluent-uri v0.3.2
Checking num-rational v0.4.2
Checking phf_shared v0.11.3
Compiling test-log-macros v0.2.19
Checking wait-timeout v0.2.1
Checking quick-error v1.2.3
Compiling radicle-remote-helper v0.17.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-remote-helper)
Checking num v0.4.3
Checking vsimd v0.8.0
Checking fnv v1.0.7
Checking outref v0.5.2
Checking rusty-fork v0.3.1
Checking test-log v0.2.19
Checking uuid-simd v0.8.0
Checking fraction v0.15.3
Checking phf v0.11.3
Checking referencing v0.30.0
Checking rand_xorshift v0.4.0
Checking rand v0.9.2
Checking rand_chacha v0.9.0
Checking fancy-regex v0.14.0
Checking email_address v0.2.9
Checking unarray v0.1.4
Checking bytecount v0.6.9
Checking base64 v0.22.1
Checking num-cmp v0.1.0
Checking proptest v1.10.0
Checking emojis v0.6.4
Checking jsonschema v0.30.0
Compiling pastey v0.2.1
Checking radicle-windows v0.1.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-windows)
Checking git2 v0.20.4
Checking radicle-oid v0.2.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-oid)
Checking radicle-term v0.18.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-term)
Checking radicle-git-ext v0.12.0
Checking radicle-cob v0.20.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-cob)
Checking radicle-core v0.3.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-core)
Checking radicle-log v0.1.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-log)
Checking radicle-fetch v0.20.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-fetch)
Checking radicle-cli-test v0.13.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-cli-test)
Checking radicle-schemars v0.8.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-schemars)
Checking radicle-protocol v0.8.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-protocol)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 43.29s
+ 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 crypto-common v0.1.7
Compiling cc v1.2.57
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 cpufeatures v0.2.17
Compiling digest v0.10.7
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 parking_lot_core v0.9.12
Compiling gix-trace v0.1.19
Compiling lock_api v0.4.14
Compiling tinyvec_macros v0.1.1
Compiling tinyvec v1.11.0
Compiling typeid v1.0.3
Compiling parking_lot v0.12.5
Compiling erased-serde v0.4.10
Compiling unicode-normalization v0.1.25
Compiling itoa v1.0.17
Compiling byteorder v1.5.0
Compiling serde v1.0.228
Compiling gix-utils v0.3.2
Compiling crc32fast v1.5.0
Compiling serde_fmt v1.1.0
Compiling hashbrown v0.16.1
Compiling value-bag-serde1 v1.12.0
Compiling value-bag v1.12.0
Compiling same-file v1.0.6
Compiling walkdir v2.5.0
Compiling bstr v1.12.1
Compiling log v0.4.29
Compiling zerofrom v0.1.6
Compiling prodash v31.0.0
Compiling zlib-rs v0.6.3
Compiling gix-validate v0.11.1
Compiling yoke v0.8.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 sha1 v0.10.6
Compiling num-traits v0.2.19
Compiling sha2 v0.10.9
Compiling sha1-checked v0.10.0
Compiling cipher v0.4.4
Compiling zerocopy v0.8.42
Compiling tinystr v0.8.2
Compiling once_cell v1.21.4
Compiling percent-encoding v2.3.2
Compiling litemap v0.8.1
Compiling gix-features v0.48.0
Compiling writeable v0.6.2
Compiling icu_locale_core v2.1.1
Compiling gix-hash v0.25.0
Compiling zerotrie v0.2.3
Compiling potential_utf v0.1.4
Compiling der v0.7.10
Compiling icu_collections v2.1.1
Compiling icu_provider v2.1.1
Compiling equivalent v1.0.2
Compiling indexmap v2.13.0
Compiling icu_properties_data v2.1.2
Compiling zmij v1.0.21
Compiling icu_normalizer_data v2.1.1
Compiling libz-sys v1.1.25
Compiling icu_normalizer v2.1.1
Compiling serde_json v1.0.149
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 opaque-debug v0.3.1
Compiling utf8_iter v1.0.4
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 ed25519 v1.5.3
Compiling schemars v1.2.1
Compiling elliptic-curve v0.13.8
Compiling poly1305 v0.8.0
Compiling rfc6979 v0.4.0
Compiling chacha20 v0.9.1
Compiling amplify_num v0.5.3
Compiling ct-codecs v1.1.6
Compiling ascii v1.1.0
Compiling ec25519 v0.1.0
Compiling amplify v4.9.0
Compiling ecdsa v0.16.9
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 pkcs8 v0.10.2
Compiling pem-rfc7468 v0.7.0
Compiling pbkdf2 v0.12.2
Compiling ctr v0.9.2
Compiling aes v0.8.4
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 ssh-encoding v0.2.0
Compiling pkcs1 v0.7.5
Compiling num-bigint-dig v0.8.6
Compiling ed25519 v2.2.3
Compiling blowfish v0.9.1
Compiling cbc v0.1.2
Compiling base32 v0.4.0
Compiling cypheraddr v0.4.1
Compiling rsa v0.9.10
Compiling ssh-cipher v0.2.0
Compiling bcrypt-pbkdf v0.10.0
Compiling ed25519-dalek v2.2.0
Compiling p521 v0.13.3
Compiling p256 v0.13.2
Compiling p384 v0.13.1
Compiling chacha20poly1305 v0.10.1
Compiling qcheck v1.0.0
Compiling data-encoding v2.10.0
Compiling const-str v0.4.3
Compiling base256emoji v1.0.2
Compiling data-encoding-macro v0.1.19
Compiling noise-framework v0.4.1
Compiling ssh-key v0.6.7
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 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-localtime)
Compiling radicle-git-metadata v0.2.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-git-metadata)
Compiling radicle-dag v0.10.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-dag)
Compiling is_terminal_polyfill v1.70.2
Compiling unicode-segmentation v1.12.0
Compiling anstyle v1.0.14
Compiling colorchoice v1.0.5
Compiling radicle-git-ref-format v0.1.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-git-ref-format)
Compiling gix-hashtable v0.15.0
Compiling base64 v0.21.7
Compiling radicle v0.24.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle)
Compiling convert_case v0.10.0
Compiling gix-date v0.15.3
Compiling gix-actor v0.41.0
Compiling gix-object v0.60.0
Compiling signal-hook-registry v1.4.8
Compiling tree-sitter-language v0.1.7
Compiling serde-untagged v0.1.9
Compiling bytesize v2.3.1
Compiling memmap2 v0.9.10
Compiling dunce v1.0.5
Compiling nonempty v0.12.0
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 derive_more v2.1.1
Compiling signal-hook-mio v0.2.5
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 portable-atomic v1.13.1
Compiling console v0.16.3
Compiling gix-fs v0.21.1
Compiling unit-prefix v0.5.2
Compiling indicatif v0.18.4
Compiling gix-tempfile v23.0.0
Compiling inquire v0.9.4
Compiling radicle-signals v0.11.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/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-traverse v0.57.0
Compiling gix-revision v0.45.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 sqlite3-sys v0.18.0
Compiling gix-pack v0.70.0
Compiling sqlite v0.37.0
Compiling radicle-crypto v0.17.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-crypto)
Compiling anstream v0.6.21
Compiling arc-swap v1.9.1
Compiling gix-credentials v0.38.0
Compiling gix-ref v0.63.0
Compiling gix-shallow v0.12.0
Compiling gix-negotiate v0.31.0
Compiling gix-protocol v0.61.0
Compiling gix-odb v0.80.0
Compiling xattr v1.6.1
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 getrandom v0.3.4
Compiling anyhow v1.0.102
Compiling flate2 v1.1.9
Compiling snapbox-macros v1.1.0
Compiling salsa20 v0.10.2
Compiling strsim v0.11.1
Compiling normalize-line-endings v0.3.0
Compiling streaming-iterator v0.1.9
Compiling similar v3.1.1
Compiling clap_lex v1.1.0
Compiling siphasher v0.3.11
Compiling clap_builder v4.6.0
Compiling bloomy v1.2.0
Compiling snapbox v1.2.2
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 toml_datetime v0.7.5+spec-1.1.0
Compiling serde_spanned v1.0.4
Compiling tree-sitter-css v0.23.2
Compiling tree-sitter-md v0.3.2
Compiling tree-sitter-bash v0.23.3
Compiling tree-sitter-toml-ng v0.6.0
Compiling tree-sitter-go v0.23.4
Compiling tree-sitter-rust v0.23.3
Compiling tree-sitter-python v0.23.6
Compiling tree-sitter-json v0.24.8
Compiling tree-sitter-c v0.23.4
Compiling tree-sitter-typescript v0.23.2
Compiling tree-sitter-ruby v0.23.1
Compiling tree-sitter-html 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-cli v0.21.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-cli)
Compiling radicle-node v0.20.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-node)
Compiling diff v0.1.13
Compiling yansi v1.0.1
Compiling human-panic v2.0.6
Compiling pretty_assertions v1.4.1
Compiling clap_complete v4.6.0
Compiling structured-logger v1.0.5
Compiling radicle-systemd v0.13.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/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 quick-error v1.2.3
Compiling vsimd v0.8.0
Compiling radicle-remote-helper v0.17.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-remote-helper)
Compiling fnv v1.0.7
Compiling rusty-fork v0.3.1
Compiling uuid-simd v0.8.0
Compiling test-log v0.2.19
Compiling phf v0.11.3
Compiling referencing v0.30.0
Compiling fraction v0.15.3
Compiling rand v0.9.2
Compiling rand_chacha v0.9.0
Compiling rand_xorshift v0.4.0
Compiling fancy-regex v0.14.0
Compiling email_address v0.2.9
Compiling bytecount v0.6.9
Compiling base64 v0.22.1
Compiling num-cmp v0.1.0
Compiling unarray v0.1.4
Compiling jsonschema v0.30.0
Compiling proptest v1.10.0
Compiling emojis v0.6.4
Compiling git2 v0.20.4
Compiling radicle-oid v0.2.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-oid)
Compiling radicle-cob v0.20.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-cob)
Compiling radicle-core v0.3.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-core)
Compiling radicle-term v0.18.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-term)
Compiling radicle-git-ext v0.12.0
Compiling radicle-log v0.1.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-log)
Compiling radicle-windows v0.1.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-windows)
Compiling radicle-fetch v0.20.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-fetch)
Compiling radicle-protocol v0.8.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-protocol)
Compiling radicle-cli-test v0.13.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-cli-test)
Compiling radicle-schemars v0.8.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-schemars)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 56.68s
+ cargo doc --workspace --no-deps --all-features
Downloading crates ...
Downloaded mintex v0.1.4
Downloaded thousands v0.2.0
Downloaded dhat v0.3.3
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 num-integer v0.1.46
Checking git2 v0.20.4
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
Compiling amplify_derive v4.0.1
Checking gix-features v0.48.0
Checking gix-error v0.2.3
Checking rsa v0.9.10
Checking gix-hash v0.25.0
Checking radicle-git-ref-format v0.1.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-git-ref-format)
Checking gix-date v0.15.3
Checking radicle-oid v0.2.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-oid)
Checking ssh-key v0.6.7
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 radicle-localtime v0.1.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-localtime)
Checking ssh-agent-lib v0.6.0
Checking radicle-git-metadata v0.2.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-git-metadata)
Checking amplify v4.9.0
Checking radicle-dag v0.10.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-dag)
Checking gix-chunk v0.7.1
Checking gix-commitgraph v0.37.0
Checking gix-fs v0.21.1
Checking cyphergraphy v0.3.1
Checking gix-tempfile v23.0.0
Checking cypheraddr v0.4.1
Checking noise-framework v0.4.1
Checking gix-revwalk v0.31.0
Checking gix-quote v0.7.1
Checking regex v1.12.3
Checking inquire v0.9.4
Checking socks5-client v0.4.3
Checking cyphernet v0.5.4
Checking radicle-signals v0.11.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-signals)
Checking gix-command v0.9.0
Checking radicle-crypto v0.17.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-crypto)
Checking chrono v0.4.44
Checking gix-lock v23.0.0
Checking gix-url v0.36.0
Checking radicle-term v0.18.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-term)
Checking radicle-core v0.3.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-core)
Checking radicle-cob v0.20.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-cob)
Checking gix-config-value v0.18.0
Checking gix-traverse v0.57.0
Checking gix-prompt v0.15.0
Checking gix-revision v0.45.0
Checking gix-diff v0.63.0
Checking radicle v0.24.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle)
Checking gix-glob v0.26.0
Checking gix-packetline v0.21.3
Checking tree-sitter v0.24.7
Checking gix-transport v0.57.0
Checking gix-refspec v0.41.0
Checking gix-pack v0.70.0
Checking radicle-log v0.1.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-log)
Checking gix-credentials v0.38.0
Checking git-ref-format v0.6.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 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/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
Compiling radicle-node v0.20.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-node)
Checking rustc-hash v1.1.0
Checking thousands v0.2.0
Checking mintex v0.1.4
Checking radicle-systemd v0.13.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-systemd)
Checking dhat v0.3.3
Documenting radicle-systemd v0.13.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-systemd)
Documenting radicle v0.24.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle)
Documenting radicle-log v0.1.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-log)
Documenting radicle-core v0.3.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-core)
Documenting radicle-cob v0.20.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-cob)
Documenting radicle-term v0.18.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-term)
Documenting radicle-crypto v0.17.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-crypto)
Documenting radicle-signals v0.11.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-signals)
Documenting radicle-oid v0.2.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-oid)
Documenting radicle-git-ref-format v0.1.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-git-ref-format)
Documenting radicle-localtime v0.1.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-localtime)
Documenting radicle-git-metadata v0.2.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-git-metadata)
Documenting radicle-dag v0.10.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-dag)
Documenting radicle-windows v0.1.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-windows)
Checking radicle-fetch v0.20.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-fetch)
Documenting radicle-cli v0.21.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-cli)
Documenting radicle-cli-test v0.13.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-cli-test)
Checking radicle-protocol v0.8.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-protocol)
Documenting radicle-protocol v0.8.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-protocol)
Documenting radicle-node v0.20.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-node)
Documenting radicle-schemars v0.8.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-schemars)
Documenting radicle-fetch v0.20.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-fetch)
Documenting radicle-remote-helper v0.17.0 (/a72cde70-f01d-4c56-bd4b-228dadf0a041/w/crates/radicle-remote-helper)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 10.78s
Generated /a72cde70-f01d-4c56-bd4b-228dadf0a041/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.17s
Running unittests src/lib.rs (target/debug/deps/radicle-f47a7c2ba456ab00)
running 393 tests
test canonical::formatter::test::ascii_control_characters ... ok
test canonical::formatter::test::securesystemslib_asserts ... ok
test canonical::formatter::test::ordered_nested_object ... ok
test cob::cache::migrations::_2::tests::test_patch_json_deserialization ... ok
test cob::common::test::test_color ... ok
test cob::cache::tests::test_check_version ... ok
test cob::common::test::test_emojis ... ok
test cob::cache::tests::test_migrate_to ... ok
test cob::common::test::test_title ... ok
test cob::cache::migrations::_2::tests::test_migration_2 ... ok
test cob::identity::test::accepted_sibling_causes_rejection ... ok
test cob::identity::test::cannot_redact_previously_accepted_revision ... ok
test cob::identity::test::evaluates_queued_children ... ok
test cob::identity::test::prop_json_eq_str ... ok
test cob::identity::test::cascading_rejections ... ok
test cob::identity::test::redact_parent_cascades ... ok
test cob::identity::test::queued_child_counts_non_delegate_votes ... FAILED
test cob::identity::test::evaluates_queued_children_with_new_delegate ... ok
test cob::identity::test::test_identity_redact_revision ... ok
test cob::identity::test::terminal_states_concurrent ... ok
test cob::identity::test::test_identity_reject_concurrent ... ok
test cob::identity::test::test_identity_cannot_redact_terminal_states ... ok
test cob::identity::test::test_identity_updates ... ok
test cob::identity::test::test_identity_remove_delegate_concurrent ... ok
test cob::identity::test::test_identity_update_rejected ... ok
test cob::identity::test::test_valid_identity ... ok
test cob::issue::cache::tests::test_counts ... ok
test cob::identity::test::test_identity_updates_concurrent ... ok
test cob::issue::cache::tests::test_is_empty ... ok
test cob::issue::cache::tests::test_list ... ok
test cob::issue::cache::tests::test_get ... ok
test cob::issue::cache::tests::test_list_by_status ... ok
test cob::issue::cache::tests::test_remove ... ok
test cob::issue::test::test_embeds ... ok
test cob::identity::test::test_identity_updates_concurrent_outdated ... ok
test cob::issue::test::test_embeds_edit ... ok
test cob::issue::test::test_invalid_actions ... ok
test cob::issue::test::test_invalid_tx ... ok
test cob::issue::test::test_invalid_cob ... 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_create_and_assign ... ok
test cob::issue::test::test_issue_comment_redact ... 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_create_and_unassign ... ok
test cob::issue::test::test_issue_edit ... 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_find_by_revision ... ok
test cob::patch::cache::tests::test_is_empty ... ok
test cob::patch::cache::tests::test_get ... ok
test cob::patch::cache::tests::test_list ... ok
test cob::patch::cache::tests::test_list_by_status ... 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_edit_comment ... ok
test cob::patch::test::test_patch_review_remove_summary ... 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::property::suffix_negative ... ok
test git::canonical::rules::test::property::trailing_asterisk_partial_component ... ok
test git::canonical::rules::test::roundtrip ... ok
test git::canonical::rules::test::canonical ... 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 cob::thread::tests::prop_ordering ... 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 identity::doc::test::test_canonical_example ... 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 node::address::store::test::test_empty ... ok
test node::address::store::test::test_entries ... ok
test node::address::store::test::test_entries_skips_unparsable_address ... ok
test identity::doc::test::test_max_delegates ... 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::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::address::store::test::test_node_aliases ... ok
test node::config::test::user_agent_default ... ok
test node::config::test::user_agent_custom ... ok
test node::config::test::user_agent_default_explicit ... ok
test node::config::test::user_agent_opt_out ... ok
test node::db::config::test::database_config_valid_combinations ... ok
test node::db::config::test::invalid ... 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::ipv4_row_is_unaffected ... ok
test node::db::test::migration_9::loopback_address_is_kept ... 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::db::test::test_version ... ok
test node::notifications::store::test::test_cob_notifications ... ok
test node::notifications::store::test::test_counts_by_repo ... ok
test node::notifications::store::test::test_duplicate_notifications ... 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_aliases ... 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_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_duplicate ... ok
test node::routing::test::test_insert_and_remove ... ok
test node::routing::test::test_insert_existing_updated_time ... ok
test node::routing::test::test_len ... 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::routing::test::test_prune ... 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::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_reached_preferred_seeds ... ok
test node::sync::announce::test::announcer_synced_with_unknown_node ... 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::construct_only_preferred_seeds_provided ... ok
test node::sync::announce::test::cannot_construct_announcer ... 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::announce::test::timed_out_after_reaching_success ... ok
test node::sync::fetch::test::all_nodes_are_candidates ... ok
test node::sync::fetch::test::all_nodes_are_fetchable ... 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::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 profile::config::test::schema ... ok
test rad::tests::test_fork ... 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 storage::refs::tests::test_rid_verification ... 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::sigrefs::property::roundtrip ... ok
test storage::refs::sigrefs::git::properties::chain_roundtrip ... ok
test cob::identity::test::property::prop_invariants ... ok
failures:
---- cob::identity::test::queued_child_counts_non_delegate_votes stdout ----
thread 'cob::identity::test::queued_child_counts_non_delegate_votes' (17204) panicked at crates/radicle/src/cob/identity.rs:2654:35:
called `Result::unwrap()` on an `Err` value: Store(Update(Evaluate(Apply(NonDelegateUnauthorized { author: Did("did:key:z6MkuPZpgayaafoz7Q7QqkFNjj4MPBujzxA5ucNkHxEuaPUp"), action: "accept a revision" }))))
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
failures:
cob::identity::test::queued_child_counts_non_delegate_votes
test result: FAILED. 392 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 21.79s
error: test failed, to rerun pass `-p radicle --lib`
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_url ... ok
test commands::clone::args::test::should_parse_rid_non_urn ... 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::clone::args::test::should_parse_rid_urn ... ok
test commands::cob::args::test::should_not_allow_show_pretty_format ... ok
test commands::fork::args::test::should_not_parse_rid_url ... ok
test commands::fork::args::test::should_parse_rid_non_urn ... ok
test commands::fork::args::test::should_parse_rid_urn ... 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::id::args::test::should_not_clobber_payload_args ... ok
test commands::id::args::test::should_not_parse_into_payload - should panic ... ok
test commands::id::args::test::should_not_parse_single_payloads ... ok
test commands::id::args::test::should_parse_into_payload ... ok
test commands::id::args::test::should_not_parse_single_payload ... ok
test commands::id::args::test::should_parse_single_payload ... ok
test commands::init::args::test::should_parse_rid_non_urn ... ok
test commands::init::args::test::should_not_parse_rid_url ... ok
test commands::init::args::test::should_parse_rid_urn ... ok
test commands::id::args::test::should_parse_multiple_payloads ... ok
test commands::inspect::test::test_tree ... ok
test commands::patch::review::builder::tests::test_review_comments_before ... ok
test commands::patch::review::builder::tests::test_review_comments_basic ... ok
test commands::patch::review::builder::tests::test_review_comments_multiline ... 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_urn ... ok
test commands::watch::args::test::should_parse_ref_str ... ok
test git::pretty_diff::test::test_pretty ... ignored
test commands::publish::args::test::should_parse_rid_non_urn ... ok
test git::ddiff::tests::diff_encode_decode_ddiff_hunk ... ok
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::args::test::should_parse_rid ... ok
test terminal::args::test::should_parse_nid ... ok
test terminal::format::test::test_bytes ... ok
test terminal::format::test::test_strip_comments ... ok
test terminal::patch::test::test_edit_display_message ... ok
test terminal::patch::test::test_update_display_message ... ok
test terminal::patch::test::test_create_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::checkout::rad_checkout ... ok
test commands::clone::rad_clone ... ok
test commands::clone::rad_clone_bare ... ok
test commands::clone::rad_clone_all ... ok
test commands::clone::rad_clone_scope ... ok
test commands::clone::rad_clone_unknown ... ok
test commands::clone::rad_clone_directory ... ok
test commands::clone::rad_clone_partial_fail ... ok
test commands::clone::rad_clone_connect ... 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_operations ... ok
test commands::cob::rad_cob_migrate ... 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::id::rad_id ... ok
test commands::git::git_tag ... ok
test commands::git::git_push_rollback ... 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::init::rad_init_bare ... ok
test commands::id::rad_id_multi_delegate ... 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_private ... ok
test commands::init::rad_init_no_seed ... 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::node::rad_node ... ok
test commands::patch::rad_merge_after_update ... ok
test commands::patch::rad_merge_no_ff ... ok
test commands::patch::rad_merge_via_push ... ok
test commands::patch::rad_patch_ahead_behind ... ok
test commands::patch::rad_patch ... ok
test commands::patch::rad_patch_change_base ... ok
test commands::patch::rad_patch_checkout ... ok
test commands::init::rad_init_sync_timeout ... ok
test commands::init::rad_init_sync_and_clone ... ok
test commands::patch::rad_patch_detached_head ... ok
test commands::patch::rad_patch_checkout_revision ... 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_fetch_2 ... ok
test commands::patch::rad_patch_edit ... ok
test commands::patch::rad_patch_fetch_1 ... ok
test commands::patch::rad_patch_merge_draft ... ok
test commands::patch::rad_patch_delete ... ok
test commands::patch::rad_patch_magic_push ... 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_merge ... ok
test commands::patch::rad_patch_revert_custom_branch ... 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 75.35s
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::parse_refstr ... ok
test tests::git::traverse_cobs ... 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::test::assert_prop_roundtrip_parse ... ok
test repo::serde_impls::test::assert_prop_roundtrip_serde_json ... 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_fingerprint ... ok
test ssh::fmt::test::test_key ... 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.82s
Running unittests src/lib.rs (target/debug/deps/radicle_dag-e10cdde88570a8e0)
running 20 tests
test tests::test_cycle ... ok
test tests::test_dependencies ... ok
test tests::test_contains ... ok
test tests::test_diamond ... ok
test tests::test_fold_diamond ... ok
test tests::test_fold_multiple_roots ... ok
test tests::test_complex ... 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_is_empty ... ok
test tests::test_len ... ok
test tests::test_merge_1 ... ok
test tests::test_merge_2 ... ok
test tests::test_prune_2 ... ok
test tests::test_prune_1 ... ok
test tests::test_remove ... ok
test tests::test_siblings ... ok
test tests::test_prune_by_sorting ... 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_header_body_separator ... ok
test commit::parse::test::error::missing_tree_empty_header ... ok
test commit::parse::test::success::commit_gpgsig_is_preserved_and_strip_removes_it ... ok
test commit::parse::test::error::missing_committer ... ok
test commit::parse::test::success::commit_last_paragraph_kept_in_message_when_not_all_trailers ... ok
test commit::parse::test::error::missing_tree_wrong_first_line ... ok
test commit::parse::test::success::commit_with_extra_headers ... 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::merge_commit ... ok
test commit::parse::test::success::commit_with_trailers ... ok
test commit::parse::test::success::root_commit ... ok
test commit::parse::test::unit::body_last_paragraph_not_trailers_stays_in_message ... ok
test commit::parse::test::success::roundtrip ... 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::body_no_paragraph_separator_means_no_trailers ... 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::pattern ... ok
test test::component_invalid - should panic ... ok
test test::qualified_invalid - should panic ... ok
test test::qualified ... ok
test test::qualified_pattern ... ok
test test::qualified_pattern_invalid - should panic ... ok
test test::refname ... ok
test test::refname_invalid - should panic ... 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 81 tests
test control::tests::test_control_socket ... ok
test reactor::timer::tests::test_next ... ok
test reactor::timer::tests::test_wake_exact ... ok
test reactor::timer::tests::test_wake ... 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_prevents_connection ... ok
test tests::e2e::test_block_active_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_fetch_emits_canonical_ref_update_partial_glob ... ok
test tests::e2e::test_dont_fetch_owned_refs ... ok
test tests::e2e::test_fetch_preserve_owned_refs ... ok
test tests::e2e::test_fetch_followed_remotes ... ok
test tests::e2e::test_concurrent_fetches ... 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_connection_kept_alive ... ok
test tests::test_announcement_relay ... 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_outbound_connection ... ok
test tests::test_inventory_pruning ... 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_from_command_same_rid ... ok
test tests::test_queued_fetch_max_capacity ... ok
test tests::test_redundant_connect ... ok
test tests::test_refs_announcement_fetch_trusted_no_inventory ... ok
test tests::test_refs_announcement_followed ... 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::test_refs_announcement_relay_public ... ok
test tests::test_announcement_message_amplification ... ok
test tests::test_seeding ... ok
test wire::test::test_inventory_ann_with_extension ... ok
test wire::test::test_pong_message_with_extension ... ok
test tests::test_seed_repo_subscribe ... ok
test tests::prop_inventory_exchange_dense ... ok
test tests::test_refs_synced_event ... ok
test result: ok. 81 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 15.56s
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 gix::test::zero ... ok
test fmt::test::gix ... ok
test str::test::fixture ... ok
test fmt::test::git2 ... ok
test str::test::zero ... ok
test str::test::git2_roundtrip ... ok
test str::test::gix_roundtrip ... 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 99 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::bounded ... ok
test fetcher::test::queue::properties::capacity::rejection ... 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::capacity::capacity_reached_returns_same_item ... ok
test fetcher::test::queue::properties::dequeue::drained_queue_returns_none ... 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::combines_refs ... ok
test fetcher::test::queue::properties::merge::longer_timeout_preserved ... ok
test fetcher::test::queue::properties::merge::does_not_increase_queue_length ... 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::queue::properties::merge::empty_refs_fetches_all ... 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_same_repo_different_nodes_queues_second ... ok
test fetcher::test::state::command::fetch::fetch_queue_rejected_capacity_reached ... 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::non_existent_returns_not_found ... ok
test fetcher::test::state::command::fetched::complete_then_dequeue_fifo ... 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::state::dequeue::maintains_fifo_order ... ok
test fetcher::test::state::invariant::queue_integrity_after_merge ... ok
test fetcher::test::queue::properties::merge::succeed_when_at_capacity ... 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 fetcher::test::queue::properties::merge::same_rid_merges_anywhere_in_queue ... ok
test service::limiter::test::test_limiter_refill ... ok
test fetcher::test::state::config::high_concurrency ... 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 wire::message::tests::prop_roundtrip_message ... ok
test wire::tests::prop_oid ... ok
test wire::tests::prop_roundtrip_filter ... ok
test service::message::tests::test_node_announcement_validate ... ok
test wire::tests::prop_roundtrip_refs ... ok
test wire::tests::prop_roundtrip_repoid ... ok
test wire::tests::prop_roundtrip_tuple ... 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_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_encode_overflow - should panic ... ok
test wire::varint::test::test_encoding ... ok
test wire::tests::prop_roundtrip_publickey ... ok
test wire::message::tests::test_refs_ann_max_size ... ok
test wire::message::tests::prop_message_decoder ... ok
test result: ok. 99 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.97s
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_fetch_whitespace ... ok
test protocol::tests::test_empty ... ok
test protocol::tests::test_fetch ... ok
test protocol::tests::test_invalid ... ok
test protocol::tests::test_list_for_push ... ok
test protocol::tests::test_option_whitespace_preservation ... ok
test protocol::tests::test_push ... ok
test protocol::tests::test_list ... ok
test protocol::tests::test_push_force ... ok
test protocol::tests::test_option ... ok
test protocol::tests::test_push_delete ... 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 21 tests
test ansi::tests::colors_disabled ... ok
test cell::test::test_width ... ok
test ansi::tests::wrapping ... ok
test element::test::test_spaced ... ok
test ansi::tests::colors_enabled ... ok
test element::test::test_truncate ... ok
test element::test::test_width ... ok
test table::test::test_table_border_maximized ... ok
test table::test::test_table ... ok
test table::test::test_table_truncate ... ok
test table::test::test_table_border ... ok
test table::test::test_table_border_truncated ... ok
test table::test::test_truncate ... ok
test table::test::test_table_unicode ... ok
test table::test::test_table_unicode_truncate ... ok
test textarea::test::test_wrapping ... ok
test textarea::test::test_wrapping_code_block ... ok
test vstack::test::test_vstack ... ok
test vstack::test::test_vstack_maximize ... ok
test textarea::test::test_wrapping_fenced_block ... ok
test textarea::test::test_wrapping_paragraphs ... ok
test result: ok. 21 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.09s; 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>::push (line 122) ... 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>::collect_from (line 30) ... 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>::with_capacity (line 66) ... ok
test crates/radicle-protocol/src/bounded.rs - bounded::BoundedVec<T,N>::unbound (line 149) ... ok
test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
all doctests ran in 0.38s; merged doctests compilation took 0.37s
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.18s; merged doctests compilation took 0.17s
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
error: 1 target failed:
`-p radicle --lib`
Exit code: 101
{
"response": "finished",
"result": "failure"
}