rad:z3gqcJUoA1n9HaHKufZs5FCSGazv5 heartwood411c73948a9857eb083a2fc8330ffae822e20efd
{
"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": "411c73948a9857eb083a2fc8330ffae822e20efd",
"commits": [
"411c73948a9857eb083a2fc8330ffae822e20efd",
"46d276d7bac7c6e25614de96e87f2b17ec237fb7",
"cd15af7621b24415405ce8bef6e7904b2c625981",
"6cde98b2b264f40e47763d1b168d74c15426ec2c",
"1a796c585e6ee7ac43ec66db1f91e6d2d55b7c91",
"dd7514e542f6893ce60c4ac1ff8de339fd60d67d",
"b13981875fe0056b76a9fe1347e0289299b2c50e",
"e36f1b37ed7d96795eba7e93067b2406851918ab",
"f55bdcd7dff252a6a28ff04e1fa4d214daa18f23",
"3318a050aa0630b1ebecb369d518a634e865306c",
"991a9cd6f21bb7b18d1c9667f39b2b70f9e4b372",
"1e0f0e2bd2963c79e94af43192bddb3f5f99a072",
"fc30d9c19eb49e6e5334a96e37f18dcecbe070e1",
"1dbb9bf4128415537b036974821e60ed27318d21",
"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
},
{
"id": "432f8d7a19045a11354ae98d6e594e157eaf10c7",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Refactor property tests and existing unit to incorporate new authorisation rules dictated by the parent revision.",
"base": "88bf2a9648750365d4565e32deae35b18808a391",
"oid": "5326910464131de4ecf99c1d343f57d2edfc5ddc",
"timestamp": 1782313654
},
{
"id": "51d685da41a4298859a2cde289f86e168e4e44a1",
"author": {
"id": "did:key:z6MkkPvBfjP4bQmco5Dm7UGsX2ruDBieEHi8n9DVJWX5sTEz",
"alias": "lorenz"
},
"description": "Work in review, reword commit messages.",
"base": "88bf2a9648750365d4565e32deae35b18808a391",
"oid": "411c73948a9857eb083a2fc8330ffae822e20efd",
"timestamp": 1782338152
}
]
}
}
{
"response": "triggered",
"run_id": {
"id": "1d88975e-a359-4954-80e3-b465f4d23cc1"
},
"info_url": "https://cci.rad.levitte.org//1d88975e-a359-4954-80e3-b465f4d23cc1.html"
}
Started at: 2026-06-24 23:56:28.926332+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/1d88975e-a359-4954-80e3-b465f4d23cc1/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 51d685d
✓ Branch patch/712a995 setup to track rad/patches/712a995a282fd544b081ea02dae7ff246810a20c
Exit code: 0
$ git config advice.detachedHead false
Exit code: 0
$ git checkout 411c73948a9857eb083a2fc8330ffae822e20efd
HEAD is now at 411c7394 radicle/cob/identity: Deprecate `Identity::id`
Exit code: 0
$ rad patch show 712a995a282fd544b081ea02dae7ff246810a20c -p
╭────────────────────────────────────────────────────────────────────────────────╮
│ Title radicle/cob/identity: Rewrite Evaluation │
│ Patch 712a995a282fd544b081ea02dae7ff246810a20c │
│ Author lorenz z6MkkPv…WX5sTEz │
│ Head 411c73948a9857eb083a2fc8330ffae822e20efd │
│ Base 88bf2a9648750365d4565e32deae35b18808a391 │
│ Branches patch/712a995 │
│ Commits ahead 16, 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>>`. │
├────────────────────────────────────────────────────────────────────────────────┤
│ 411c739 radicle/cob/identity: Deprecate `Identity::id` │
│ 46d276d radicle/cob/identity: Test redacting accepted revisions │
│ cd15af7 radicle/cob/identity: Test `authorization_based_on_parent_not_current` │
│ 6cde98b radicle/cob/identity: Test queued children with delegate change │
│ 1a796c5 radicle/cob/identity: Add Property Tests │
│ dd7514e radicle/test/arbitrary: Make BoundedVec shared │
│ b139818 radicle/cob/identity: Fix comments in test `reject_concurrent` │
│ e36f1b3 radicle/cob/identity: Test evaluating children of accepted revision │
│ f55bdcd radicle/cob/identity: Test cascading of redaction │
│ 3318a05 radicle/cob/identity: Test cascading rejection │
│ 991a9cd radicle/cob/identity: Test terminal states │
│ 1e0f0e2 radicle/cob/identity: Add concurrent terminal state test │
│ fc30d9c radicle/cob/identity: Test rejected sibling │
│ 1dbb9bf 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 4 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 5 days ago │
│ ↑ Revision b013388 @ 88bf2a9..ccde4df by lorenz z6MkkPv…WX5sTEz 4 days ago │
│ ↑ Revision 8ff7c16 @ 88bf2a9..fe4b011 by lorenz z6MkkPv…WX5sTEz 23 hours ago │
│ ↑ Revision 432f8d7 @ 88bf2a9..5326910 by ade z6MkwGo…yS2aagA 6 hours ago │
│ ↑ Revision 51d685d @ 88bf2a9..411c739 by lorenz z6MkkPv…WX5sTEz 38 seconds ago │
╰────────────────────────────────────────────────────────────────────────────────╯
commit 411c73948a9857eb083a2fc8330ffae822e20efd
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 be4b303fc..32d3b0011 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.
@@ -2353,7 +2350,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 46d276d7bac7c6e25614de96e87f2b17ec237fb7
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 d3fefba7e..be4b303fc 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -2207,6 +2207,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 cd15af7621b24415405ce8bef6e7904b2c625981
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Thu Jun 11 08:51:31 2026 +0100
radicle/cob/identity: Test `authorization_based_on_parent_not_current`
To reflect that autorization is governed by the causal parent of a
revision, not the currently accepted revision.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index bbb7e2018..d3fefba7e 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -2505,4 +2505,102 @@ mod test {
assert_eq!(eve_identity.revision(&b1).unwrap().state, State::Accepted);
assert_eq!(eve_identity.current, b1);
}
+
+ /// Demonstrates that authorization to vote on a revision is strictly governed
+ /// by its parent, not by the currently accepted identity document.
+ #[test]
+ fn authorization_based_on_parent_not_current() {
+ use crate::crypto::test::signer::MockSigner;
+ use crate::test::setup::{Node, NodeRepo};
+ use tempfile::tempdir;
+
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+ let eve = &network.eve;
+
+ // Create Dave as a 4th participant.
+ let mut dave_node = Node::new(tempdir().unwrap(), MockSigner::from_seed([!3; 32]), "dave");
+ dave_node.clone(network.rid, alice);
+ let dave_repo = NodeRepo {
+ repo: dave_node.storage.repository(network.rid).unwrap(),
+ checkout: None,
+ };
+
+ // Revision A₁ lists 4 delegates: Alice, Bob, Eve, and Dave.
+ // Since alice is the only delegate initially, A₁ is immediately accepted
+ // and becomes the current revision.
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ alice_doc.delegate(eve.signer.public_key().into());
+ alice_doc.delegate(dave_node.signer.public_key().into());
+ let _a1 = alice_identity
+ .update(
+ cob::Title::new("A₁").unwrap(),
+ "Add Bob, Eve, and Dave",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ bob.repo.fetch(alice);
+ eve.repo.fetch(alice);
+ dave_repo.fetch(alice);
+
+ // Revision A₂ lists 3 delegates: Alice, Bob, and Eve.
+ // Dave is removed in this proposal.
+ let mut doc_a2 = alice_identity.doc().clone().edit();
+ doc_a2
+ .rescind(&dave_node.signer.public_key().into())
+ .unwrap();
+ let a2 = alice_identity
+ .update(
+ cob::Title::new("A₂").unwrap(),
+ "Remove Dave",
+ &doc_a2.clone().verified().unwrap(),
+ )
+ .unwrap();
+
+ // Revision A₃ is a child of A₂.
+ // Note that at this point, A₁ is still the currently accepted revision,
+ // meaning Dave is a delegate according to the currently accepted revision.
+ let mut doc_a3 = doc_a2.clone();
+ doc_a3.visibility = Visibility::private([]);
+ let a3 = alice_identity
+ .transaction("A₃", |tx, repo| {
+ *tx = Transaction::new_revision(
+ cob::Title::new("A₃").unwrap(),
+ "Set visibility to private",
+ &doc_a3.verified().unwrap(),
+ Some(a2),
+ repo,
+ &alice.signer,
+ )?;
+ Ok(())
+ })
+ .unwrap();
+
+ // Dave fetches and attempts to accept A₃.
+ // Even though Dave is a delegate in the currently accepted revision (A₁),
+ // authorization is governed by the parent of A₃, which is A₂.
+ // Because A₂ removed Dave, this action must error.
+ dave_repo.fetch(alice);
+ let mut dave_identity = Identity::load_mut(&*dave_repo, &dave_node.signer).unwrap();
+
+ let err = dave_identity.accept(&a3).unwrap_err();
+ let is_unauthorized =
+ std::iter::successors::<&dyn std::error::Error, _>(Some(&err), |err| err.source()).any(
+ |source| {
+ matches!(
+ source.downcast_ref::<ApplyError>(),
+ Some(ApplyError::NonDelegateUnauthorized { .. })
+ )
+ },
+ );
+
+ assert!(
+ is_unauthorized,
+ "Dave should be unauthorized because he was removed in the parent (A₂). Actual error: {err:?}"
+ );
+ }
}
commit 6cde98b2b264f40e47763d1b168d74c15426ec2c
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 8b96bb152..bbb7e2018 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -2388,4 +2388,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 1a796c585e6ee7ac43ec66db1f91e6d2d55b7c91
Author: Adrian Duke <adrian.duke@gmail.com>
Date: Wed May 27 18:00:31 2026 +0100
radicle/cob/identity: Add Property Tests
Introduce a property testing harness for asserting a set of properties expected
of the repository identity.
The harness uses the `Network` fixture for providing four nodes that can
interact with the repository identity. The state of the harness is advanced by
providing an actor and operation on the identity document. Invariants are then
asserted about the identity.
The current invariants are:
- The `current` revision is the one and only `Accepted` revision.
- The chain of revisions is valid. That is, `Active` revisions only have a
parent that is `Accepted`, and not `Rejected` or `Redacted`.
- `Active` revisions do not contain a majority approval.
- `Accepted` revisions contain a majority approval.
- `Rejected` revisions do not contain a majority approval.
- For each revision, at most one child is `Accepted`.
- For each revision, if any of its children is `Accepted`, all other
children are `Rejected`.
- A revision which is `Rejected(RejectedBy::Parent)` has a parent that
is `Rejected`.
- A revision which is `Redacted(RedactedBy::Parent)` has a parent that
is `Redacted`.
- For each revision that is `Rejected` or `Redacted`, none of its
children is `Active`.
- A sibling or ancestor revision's rejected state applies to its sibling or
descendant.
- The repository identity documents converge when all nodes have applied all
operations.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index f3f832299..8b96bb152 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..7bf7e6c5a
--- /dev/null
+++ b/crates/radicle/src/cob/identity/test/property.rs
@@ -0,0 +1,947 @@
+use qcheck::{Arbitrary, QuickCheck, TestResult};
+
+use crate::assert_matches;
+use crate::cob;
+use crate::cob::identity::{Did, Identity, RedactedBy, RejectedBy, RevisionId, State};
+use crate::cob::store::Transaction;
+use crate::identity::doc::PayloadId;
+use crate::test::arbitrary::BoundedVec;
+use crate::test::setup::Network;
+
+// NOTE: If these tests take too much time to run, consider lowering the
+// second argument (`const N: usize`) of the `ops: BoundedVec` argument.
+// Additionally you can reduce `.tests(X)` or set `QUICKCHECK_TESTS=X`
+// environment variable to a lower number, which reduces the number of
+// passing tests quickcheck requires before returning green.
+#[test]
+fn prop_invariants() {
+ fn prop(ops: BoundedVec<TestOp, 8>) -> TestResult {
+ if ops.is_empty() {
+ return TestResult::discard();
+ }
+
+ let mut harness = Harness::new();
+ for op in ops {
+ harness.apply(&op);
+ }
+
+ harness.assert_local_invariants();
+ harness.converge();
+ harness.assert_local_invariants();
+ harness.assert_convergence();
+
+ TestResult::passed()
+ }
+
+ QuickCheck::new()
+ .tests(30)
+ .quickcheck(prop as fn(BoundedVec<TestOp, 8>) -> TestResult);
+}
+
+/// The property tests keep track of 3 actors interacting with the repository
+/// identity.
+#[derive(Clone, Copy, Debug)]
+enum Actor {
+ Alice,
+ Bob,
+ Eve,
+ Dave,
+}
+
+/// Enumerate all the actors in an array.
+const ACTORS: [Actor; 4] = [Actor::Alice, Actor::Bob, Actor::Eve, Actor::Dave];
+
+/// [`OpAction`] describes a given action that can be made when emulating
+/// interactions with the repository identity document.
+#[derive(Clone, Debug)]
+enum OpAction {
+ /// The repository identity is updated with a new description and given
+ /// [`Actor`]'s delegate status is updated in the identity document.
+ ///
+ /// If they were previously a delegate then their delegate status is
+ /// rescinded.
+ ///
+ /// Otherwise, they are added as a delegate.
+ Update { toggle_delegate: Actor },
+ /// The repository identity is updated with a new description and given
+ /// [`Actor`]'s delegate status is updated in the identity document.
+ /// The given `parent_idx` chooses a random revision to use as the parent.
+ /// This ensures that sibling operations are created.
+ ///
+ /// If they were previously a delegate then their delegate status is
+ /// rescinded.
+ ///
+ /// Otherwise, they are added as a delegate.
+ UpdateRandom {
+ toggle_delegate: Actor,
+ parent_idx: usize,
+ },
+ /// The revision found at the given index is accepted.
+ Accept(usize),
+ /// The revision found at the given index is rejected.
+ Reject(usize),
+ /// The revision found at the given index is redacted.
+ Redact(usize),
+ /// The [`Actor`] paired with this operation synchronizes with all other
+ /// actors.
+ Sync,
+}
+
+/// Combine an [`OpAction`] with an [`Actor`], where the [`Actor`] performs the
+/// action on the repository identity.
+#[derive(Clone, Debug)]
+struct TestOp {
+ actor: Actor,
+ action: OpAction,
+}
+
+impl Arbitrary for TestOp {
+ fn arbitrary(g: &mut qcheck::Gen) -> Self {
+ let actor = *g.choose(&ACTORS).unwrap();
+
+ let action = match u8::arbitrary(g) % 6 {
+ 0 => OpAction::Update {
+ toggle_delegate: *g.choose(&ACTORS).unwrap(),
+ },
+ 1 => OpAction::UpdateRandom {
+ toggle_delegate: *g.choose(&ACTORS).unwrap(),
+ parent_idx: usize::arbitrary(g),
+ },
+ 2 => OpAction::Accept(usize::arbitrary(g)),
+ 3 => OpAction::Reject(usize::arbitrary(g)),
+ 4 => OpAction::Redact(usize::arbitrary(g)),
+ _ => OpAction::Sync,
+ };
+
+ Self { actor, action }
+ }
+}
+
+/// A test harness that contains a [`Network`] of nodes that interact with a
+/// shared repository [`Identity`].
+///
+/// These interactions are then verified to hold against a set of properties
+/// expected of the [`Identity`].
+struct Harness {
+ network: Network,
+ revisions: Vec<RevisionId>,
+}
+
+impl Harness {
+ fn new() -> Self {
+ let network = Network::default();
+ let alice = &network.alice;
+ let bob = &network.bob;
+ let eve = &network.eve;
+
+ let mut alice_identity = Identity::load_mut(&*alice.repo, &alice.signer).unwrap();
+ let mut alice_doc = alice_identity.doc().clone().edit();
+ alice_doc.delegate(bob.signer.public_key().into());
+ alice_doc.delegate(eve.signer.public_key().into());
+ alice_doc.threshold = 2;
+
+ let a1 = alice_identity
+ .update(
+ cob::Title::new("Init").unwrap(),
+ "",
+ &alice_doc.verified().unwrap(),
+ )
+ .unwrap();
+
+ bob.repo.fetch(alice);
+ eve.repo.fetch(alice);
+
+ let mut bob_identity = Identity::load_mut(&*bob.repo, &bob.signer).unwrap();
+ let mut eve_identity = Identity::load_mut(&*eve.repo, &eve.signer).unwrap();
+
+ bob_identity.accept(&a1).unwrap();
+ eve_identity.accept(&a1).unwrap();
+
+ alice.repo.fetch(bob);
+ alice.repo.fetch(eve);
+
+ Self {
+ network,
+ revisions: vec![a1],
+ }
+ }
+
+ /// The parent document always dictates the active delegate set
+ fn is_delegate(&self, actor: Actor, parent_id: RevisionId) -> bool {
+ let identity = self.identity_for(&actor);
+ let parent_doc = &identity.revision(&parent_id).unwrap().doc;
+
+ parent_doc.is_delegate(&self.did_for(&actor))
+ }
+
+ fn has_apply_error<E, F>(err: &E, predicate: F) -> bool
+ where
+ E: std::error::Error + 'static,
+ F: Fn(&cob::identity::ApplyError) -> bool,
+ {
+ std::iter::successors(Some(err as &dyn std::error::Error), |e| e.source())
+ .filter_map(|e| e.downcast_ref::<cob::identity::ApplyError>())
+ .any(predicate)
+ }
+
+ fn execute<F, T>(&self, actor: Actor, action: F) -> Result<T, cob::identity::Error>
+ where
+ T: std::fmt::Debug,
+ F: FnOnce(
+ &mut cob::identity::IdentityMut<
+ '_,
+ '_,
+ crate::storage::git::Repository,
+ crate::node::device::Device<crypto::test::signer::MockSigner>,
+ >,
+ ) -> Result<T, cob::identity::Error>,
+ {
+ let mut identity = self.identity_for(&actor);
+ cob::stable::with_advanced_timestamp(|| action(&mut identity))
+ }
+
+ fn apply(&mut self, op: &TestOp) {
+ match &op.action {
+ OpAction::Update { toggle_delegate } => {
+ let current_id = self.identity_for(&op.actor).current;
+ let is_delegate = self.is_delegate(op.actor, current_id);
+ let (_, _, mut doc) = self.signer_identity_doc_for(&op.actor);
+
+ self.toggle_delegate(toggle_delegate, &mut doc);
+ self.update_description(&mut doc, "Fuzz");
+
+ let result = self.execute(op.actor, |id| {
+ id.update(
+ cob::Title::new("Update").unwrap(),
+ "",
+ &doc.verified().unwrap(),
+ )
+ });
+
+ if is_delegate {
+ if let Ok(rev) = result {
+ self.revisions.push(rev);
+ } else {
+ panic!(
+ "Delegate action should succeed, but failed with: {:?}",
+ result.unwrap_err()
+ );
+ }
+ } else {
+ let e = result.expect_err("Non-delegate action must fail");
+ assert!(Self::has_apply_error(&e, |err| matches!(
+ err,
+ cob::identity::ApplyError::NonDelegateUnauthorized { .. }
+ )));
+ }
+ }
+ OpAction::UpdateRandom {
+ toggle_delegate,
+ parent_idx,
+ } => {
+ if self.revisions.is_empty() {
+ return;
+ }
+ let parent_rev = self.revisions[*parent_idx % self.revisions.len()];
+
+ if self.identity_for(&op.actor).revision(&parent_rev).is_none() {
+ return;
+ }
+
+ let is_delegate = self.is_delegate(op.actor, parent_rev);
+ let (signer, _, mut doc) = self.signer_identity_doc_for(&op.actor);
+
+ self.toggle_delegate(toggle_delegate, &mut doc);
+ self.update_description(&mut doc, "Fuzz Child");
+
+ let result = self.execute(op.actor, |id| {
+ id.transaction("Update Child", |tx, r| {
+ *tx = Transaction::new_revision(
+ cob::Title::new("Update Child").unwrap(),
+ "",
+ &doc.verified().unwrap(),
+ Some(parent_rev),
+ r,
+ signer,
+ )?;
+ Ok(())
+ })
+ });
+
+ if is_delegate {
+ if let Ok(rev) = result {
+ self.revisions.push(rev);
+ } else {
+ panic!(
+ "Delegate action should succeed, but failed with: {:?}",
+ result.unwrap_err()
+ );
+ }
+ } else {
+ let e = result.expect_err("Non-delegate action must fail");
+ assert!(Self::has_apply_error(&e, |err| matches!(
+ err,
+ cob::identity::ApplyError::NonDelegateUnauthorized { .. }
+ )));
+ }
+ }
+ OpAction::Accept(idx) => {
+ if self.revisions.is_empty() {
+ return;
+ }
+ let rev = self.revisions[*idx % self.revisions.len()];
+ let identity = self.identity_for(&op.actor);
+ let Some(revision) = identity.revision(&rev) else {
+ return;
+ };
+ let parent_id = revision.parent.unwrap();
+ let is_delegate = self.is_delegate(op.actor, parent_id);
+ let is_terminal = !revision.is_active();
+
+ let result = self.execute(op.actor, |id| id.accept(&rev));
+
+ if is_terminal {
+ assert!(result.is_ok(), "Terminal accept should be a no-op");
+ } else if is_delegate {
+ match result {
+ Ok(_) => {}
+ Err(e) => assert!(
+ Self::has_apply_error(&e, |err| matches!(
+ err,
+ cob::identity::ApplyError::DuplicateVerdict
+ )),
+ "Delegate accept failed with unexpected error: {e:?}"
+ ),
+ }
+ } else {
+ let e = result.expect_err("Non-delegate must fail on active revision");
+ assert!(
+ Self::has_apply_error(&e, |err| matches!(
+ err,
+ cob::identity::ApplyError::NonDelegateUnauthorized { .. }
+ )),
+ "Expected NonDelegateUnauthorized, got: {e:?}"
+ );
+ }
+ }
+ OpAction::Reject(idx) => {
+ if self.revisions.is_empty() {
+ return;
+ }
+ let rev = self.revisions[*idx % self.revisions.len()];
+ let identity = self.identity_for(&op.actor);
+ let Some(revision) = identity.revision(&rev) else {
+ return;
+ };
+ let parent_id = revision.parent.unwrap();
+ let is_delegate = self.is_delegate(op.actor, parent_id);
+ let is_terminal = !revision.is_active();
+
+ let result = self.execute(op.actor, |id| id.reject(rev));
+
+ if is_terminal {
+ assert!(result.is_ok(), "Terminal reject should be a no-op");
+ } else if is_delegate {
+ match result {
+ Ok(_) => {}
+ Err(e) => assert!(
+ Self::has_apply_error(&e, |err| matches!(
+ err,
+ cob::identity::ApplyError::DuplicateVerdict
+ )),
+ "Delegate reject failed with unexpected error: {e:?}"
+ ),
+ }
+ } else {
+ let e = result.expect_err("Non-delegate must fail on active revision");
+ assert!(
+ Self::has_apply_error(&e, |err| matches!(
+ err,
+ cob::identity::ApplyError::NonDelegateUnauthorized { .. }
+ )),
+ "Expected NonDelegateUnauthorized, got: {e:?}"
+ );
+ }
+ }
+ OpAction::Redact(idx) => {
+ if self.revisions.is_empty() {
+ return;
+ }
+ let rev = self.revisions[*idx % self.revisions.len()];
+ let identity = self.identity_for(&op.actor);
+ let Some(revision) = identity.revision(&rev) else {
+ return;
+ };
+ let is_author = revision.author.id() == &self.did_for(&op.actor);
+
+ let result = self.execute(op.actor, |id| id.redact(rev));
+
+ if is_author {
+ assert!(result.is_ok(), "Author should be able to redact");
+ } else {
+ let e = result.expect_err("Non-author must fail to redact");
+ assert!(
+ Self::has_apply_error(&e, |err| matches!(
+ err,
+ cob::identity::ApplyError::NotAuthorized
+ )),
+ "Expected NotAuthorized, got: {e:?}"
+ );
+ }
+ }
+ OpAction::Sync => match op.actor {
+ Actor::Alice => {
+ self.network.alice.repo.fetch(&self.network.bob);
+ self.network.alice.repo.fetch(&self.network.eve);
+ self.network.alice.repo.fetch(&self.network.dave);
+ }
+ Actor::Bob => {
+ self.network.bob.repo.fetch(&self.network.alice);
+ self.network.bob.repo.fetch(&self.network.eve);
+ self.network.bob.repo.fetch(&self.network.dave);
+ }
+ Actor::Eve => {
+ self.network.eve.repo.fetch(&self.network.alice);
+ self.network.eve.repo.fetch(&self.network.bob);
+ self.network.eve.repo.fetch(&self.network.dave);
+ }
+ Actor::Dave => {
+ self.network.dave.repo.fetch(&self.network.alice);
+ self.network.dave.repo.fetch(&self.network.bob);
+ self.network.dave.repo.fetch(&self.network.eve);
+ }
+ },
+ }
+ }
+
+ fn update_description(&self, doc: &mut crate::prelude::RawDoc, msg: &str) {
+ let prj = doc.project().unwrap();
+ let desc = format!("{} {}", msg, self.revisions.len());
+ let prj = prj.update(None, desc, None).unwrap();
+ doc.payload.insert(PayloadId::project(), prj.into());
+ }
+
+ fn did_for(&self, actor: &Actor) -> Did {
+ match actor {
+ Actor::Alice => self.network.alice.signer.public_key().into(),
+ Actor::Bob => self.network.bob.signer.public_key().into(),
+ Actor::Eve => self.network.eve.signer.public_key().into(),
+ Actor::Dave => self.network.dave.signer.public_key().into(),
+ }
+ }
+
+ fn toggle_delegate(&self, delegate: &Actor, doc: &mut crate::prelude::RawDoc) {
+ let target_delegate: Did = self.did_for(delegate);
+
+ if doc.delegates.contains(&target_delegate) {
+ if doc.delegates.len() > 1 {
+ doc.rescind(&target_delegate).unwrap();
+
+ // Ensure threshold never exceeds new delegate count
+ if doc.threshold > doc.delegates.len() {
+ doc.threshold = doc.delegates.len();
+ }
+ }
+ } else {
+ doc.delegate(target_delegate);
+ }
+ }
+
+ fn identity_for(
+ &self,
+ actor: &Actor,
+ ) -> cob::identity::IdentityMut<
+ '_,
+ '_,
+ crate::storage::git::Repository,
+ crate::node::device::Device<crypto::test::signer::MockSigner>,
+ > {
+ let (_, identity, _) = self.signer_identity_doc_for(actor);
+
+ identity
+ }
+
+ fn signer_identity_doc_for(
+ &self,
+ actor: &Actor,
+ ) -> (
+ &crate::node::device::Device<crypto::test::signer::MockSigner>,
+ cob::identity::IdentityMut<
+ '_,
+ '_,
+ crate::storage::git::Repository,
+ crate::node::device::Device<crypto::test::signer::MockSigner>,
+ >,
+ crate::prelude::RawDoc,
+ ) {
+ let (repo, signer) = match actor {
+ Actor::Alice => (&*self.network.alice.repo, &self.network.alice.signer),
+ Actor::Bob => (&*self.network.bob.repo, &self.network.bob.signer),
+ Actor::Eve => (&*self.network.eve.repo, &self.network.eve.signer),
+ Actor::Dave => (&*self.network.dave.repo, &self.network.dave.signer),
+ };
+ let identity = Identity::load_mut(repo, signer).unwrap();
+ let doc = identity.doc().clone().edit();
+ (signer, identity, doc)
+ }
+
+ fn converge(&mut self) {
+ let alice = &self.network.alice;
+ let bob = &self.network.bob;
+ let eve = &self.network.eve;
+ let dave = &self.network.dave;
+
+ // Hub and spoke sync
+ alice.repo.fetch(bob);
+ alice.repo.fetch(eve);
+ alice.repo.fetch(dave);
+
+ bob.repo.fetch(alice);
+ eve.repo.fetch(alice);
+ dave.repo.fetch(alice);
+ }
+
+ fn assert_local_invariants(&self) {
+ let alice_diverged_id = Identity::load(&*self.network.alice.repo).unwrap();
+ let bob_diverged_id = Identity::load(&*self.network.bob.repo).unwrap();
+ let eve_diverged_id = Identity::load(&*self.network.eve.repo).unwrap();
+ let dave_diverged_id = Identity::load(&*self.network.dave.repo).unwrap();
+
+ self.assert_local_invariants_for(&alice_diverged_id);
+ self.assert_local_invariants_for(&bob_diverged_id);
+ self.assert_local_invariants_for(&eve_diverged_id);
+ self.assert_local_invariants_for(&dave_diverged_id);
+ }
+
+ fn assert_local_invariants_for(&self, identity: &Identity) {
+ self.assert_single_accepted_head(identity);
+ self.assert_linear_history(identity);
+ self.assert_active_quorum(identity);
+ self.assert_accepted_quorum(identity);
+ self.assert_rejected_quorum(identity);
+ self.assert_sibling_rejection(identity);
+ self.assert_ancestor_redacted_from_redacted_parent(identity);
+ self.assert_ancestor_rejected_from_rejected_parent(identity);
+ self.assert_failed_parents_have_failed_children(identity);
+ self.assert_rejection_reasons_are_accurate(identity);
+ self.assert_verdicts_match_parent_delegates(identity);
+ }
+
+ /// Strong eventual consistency.
+ ///
+ /// Nodes can receive operations in different orders. Regardless of the path taken,
+ /// once nodes sync the same data, their state machines must compute the exact same
+ /// state.
+ ///
+ /// PASS:
+ /// Alice (Ops: 1, 2, 3) => State A
+ /// Bob (Ops: 3, 1, 2) => State A
+ ///
+ /// FAIL:
+ /// Alice (Ops: 1, 2, 3) => State A
+ /// Bob (Ops: 2, 1, 3) => State B (non-commutative)
+ fn assert_convergence(&self) {
+ let alice = Identity::load(&*self.network.alice.repo).unwrap();
+ let bob = Identity::load(&*self.network.bob.repo).unwrap();
+ let eve = Identity::load(&*self.network.eve.repo).unwrap();
+ let dave = Identity::load(&*self.network.dave.repo).unwrap();
+
+ assert_eq!(alice.current, bob.current, "Alice and Bob must converge");
+ assert_eq!(bob.current, eve.current, "Bob and Eve must converge");
+ assert_eq!(eve.current, dave.current, "Eve and Dave must converge");
+ assert_eq!(dave.current, alice.current, "Dave and Alice must converge");
+ }
+
+ /// The `current` pointer always points to a valid, `Accepted` revision.
+ ///
+ /// The repository must have a single, unambiguous canonical identity document.
+ /// The head of the identity cannot be a pending, rejected, or redacted proposal.
+ ///
+ /// PASS:
+ /// current == [Accepted]
+ ///
+ /// FAIL:
+ /// current == [Active] (Pointer moved before quorum was reached)
+ /// current == [Redacted] (The canonical head was illegally redacted)
+ fn assert_single_accepted_head(&self, identity: &Identity) {
+ let accepted_count = identity
+ .revisions()
+ .filter(|r| r.state == State::Accepted && r.id == identity.current)
+ .count();
+ assert_eq!(
+ accepted_count, 1,
+ "Exactly one accepted revision must match current"
+ );
+ }
+
+ /// The causal chain is unbroken and valid.
+ ///
+ /// 1. We cannot have "zombie" children (Active revisions whose parents are redacted/rejected).
+ /// 2. The canonical history must be a straight line of accepted states back to the root.
+ ///
+ /// PASS:
+ /// [Accepted] <-- [Accepted] <-- [Active] (Valid pending proposal)
+ ///
+ /// FAIL:
+ /// [Rejected] <-- [Active] (Zombie child, parent is dead but child is pending)
+ /// [Active] <-- [Accepted] (Broken chain, an accepted state has an unaccepted parent)
+ fn assert_linear_history(&self, identity: &Identity) {
+ // No active revision has a rejected/redacted parent
+ for rev in identity.revisions() {
+ if rev.state == State::Active
+ && let Some(parent_id) = rev.parent
+ && let Some(parent) = identity.revision(&parent_id)
+ {
+ assert!(
+ !matches!(parent.state, State::Rejected(_) | State::Redacted(_)),
+ "Active revision {} has invalid parent state {:?}",
+ rev.id,
+ parent.state
+ );
+ }
+ }
+
+ // All ancestors of the current revision must be Accepted.
+ let mut curr_id = identity.current;
+ while let Some(rev) = identity.revision(&curr_id) {
+ assert_eq!(
+ rev.state,
+ State::Accepted,
+ "Parent {} in the canonical chain must be Accepted",
+ rev.id
+ );
+ if let Some(parent_id) = rev.parent {
+ curr_id = parent_id;
+ } else {
+ break;
+ }
+ }
+ }
+
+ /// No `Active` revision has met the required majority.
+ ///
+ /// If an active revision gathers enough votes, the state machine should
+ /// have automatically transitioned it to `Accepted`. If it is still `Active`,
+ /// the `adopt()` trigger failed to fire.
+ ///
+ /// PASS:
+ /// [Active, 1/2 votes]
+ ///
+ /// FAIL:
+ /// [Active, 2/2 votes] (Should have been Accepted)
+ fn assert_active_quorum(&self, identity: &Identity) {
+ for rev in identity.revisions() {
+ if rev.state == State::Active {
+ let parent_id = rev.parent.expect("Active revision must have a parent");
+
+ // If the parent is not the current document, it is perfectly valid for this
+ // revision to have reached a majority while still being `Active`.
+ // It is queued and waiting for its parent to be adopted first.
+ if parent_id != identity.current {
+ continue;
+ }
+
+ let parent = identity.revision(&parent_id).unwrap();
+ let majority = parent.doc.majority();
+
+ assert!(
+ rev.accepted().count() < majority,
+ "Active revision {} has {} votes but majority is {}. It should have been adopted!",
+ rev.id,
+ rev.accepted().count(),
+ majority
+ );
+ }
+ }
+ }
+
+ /// Every `Accepted` revision actually met the required majority.
+ ///
+ /// Prevents illegally accepted revisions. A revision cannot bypass the voting
+ /// rules to become accepted.
+ ///
+ /// PASS:
+ /// [Accepted, 2/2 votes]
+ ///
+ /// FAIL:
+ /// [Accepted, 1/2 votes] (Accepted without reaching quorum)
+ fn assert_accepted_quorum(&self, identity: &Identity) {
+ for rev in identity.revisions() {
+ if rev.state == State::Accepted && rev.id != identity.root {
+ let parent_id = rev.parent.expect("Accepted revision must have a parent");
+ let parent = identity.revision(&parent_id).unwrap();
+ let majority = parent.doc.majority();
+
+ assert!(
+ rev.accepted().count() >= majority,
+ "Accepted revision {} only has {} votes, but needed {}!",
+ rev.id,
+ rev.accepted().count(),
+ majority
+ );
+ }
+ }
+ }
+
+ /// Every `Rejected(Vote)` revision actually met the required majority.
+ ///
+ /// Prevents illegally rejected revisions. A revision cannot bypass the voting
+ /// rules to become rejected.
+ ///
+ /// PASS (3 delegates, majority 2):
+ /// [Rejected(Vote), 2/3 reject votes] (Only 1 delegate left, impossible to reach 2 accepts)
+ ///
+ /// FAIL (3 delegates, majority 2):
+ /// [Rejected(Vote), 1/3 reject votes] (2 delegates left, still possible to reach 2 accepts)
+ fn assert_rejected_quorum(&self, identity: &Identity) {
+ for rev in identity.revisions() {
+ if rev.state == State::Rejected(RejectedBy::Vote) && rev.id != identity.root {
+ let parent_id = rev.parent.expect("Rejected revision must have a parent");
+ let parent = identity.revision(&parent_id).unwrap();
+
+ let rejection_threshold = parent.doc.delegates().len() - parent.doc.majority();
+ let needed_majority = rejection_threshold + 1;
+
+ assert!(
+ rev.rejected().count() >= needed_majority,
+ "RejectedBy::Vote revision {} only has {} votes, but needed {}!",
+ rev.id,
+ rev.rejected().count(),
+ needed_majority
+ );
+ }
+ }
+ }
+
+ /// There can be only one accepted sibling.
+ ///
+ /// When a revision is accepted, all competing forks must be explicitly
+ /// rejected to prevent split-brain scenarios and enforce a linear history.
+ ///
+ /// PASS:
+ /// /-- [Accepted]
+ /// [Parent]<
+ /// \-- [Rejected]
+ ///
+ /// FAIL:
+ /// /-- [Accepted]
+ /// [Parent]<
+ /// \-- [Active] (Sibling was not rejected)
+ fn assert_sibling_rejection(&self, identity: &Identity) {
+ for rev in identity.revisions() {
+ if rev.state == State::Accepted {
+ for sibling in identity.revisions() {
+ // If they share the same parent but have different IDs, they are siblings
+ if sibling.id != rev.id && sibling.parent == rev.parent {
+ assert!(
+ matches!(sibling.state, State::Rejected(_) | State::Redacted(_)),
+ "Sibling {} of accepted revision {} must be rejected or redacted, but is {:?}",
+ sibling.id,
+ rev.id,
+ sibling.state
+ );
+ }
+ }
+ }
+ }
+ }
+
+ /// A revision can only be `Rejected(RejedtedBy::Parent)` if its parent was rejected.
+ ///
+ /// Ensures that the `RejectedBy::Parent` state is causally linked to a parent's rejection.
+ ///
+ /// PASS:
+ /// [Rejected] <-- [Rejected(RejectedBy::Parent)]
+ ///
+ /// FAIL:
+ /// [Active] <-- [Rejected(RejectedBy::Parent)] (Parent is not rejected)
+ fn assert_ancestor_rejected_from_rejected_parent(&self, identity: &Identity) {
+ for id in &identity.timeline {
+ if let Some(rev) = identity.revision(id)
+ && matches!(rev.state, State::Rejected(RejectedBy::Parent))
+ {
+ let parent_id = rev
+ .parent
+ .expect("a revision in `RejectedBy::Parent` must have a parent");
+ let parent = identity.revision(&parent_id).unwrap();
+ assert!(
+ matches!(
+ parent.state,
+ State::Rejected(RejectedBy::Vote)
+ | State::Rejected(RejectedBy::Sibling(_))
+ | State::Rejected(RejectedBy::Parent)
+ ),
+ "RejectedBy::Parent revision {} has invalid parent state {:?}",
+ rev.id,
+ parent.state
+ );
+ }
+ }
+ }
+
+ /// A revision can only be `Redacted(RedactedBy::Parent)` if its parent was redacted.
+ ///
+ /// Ensures that the `RedactedBy::Parent` state is causally linked to a parent's redaction.
+ ///
+ /// PASS:
+ /// [Redacted] <-- [Redacted(RedactedBy::Parent)]
+ ///
+ /// FAIL:
+ /// [Accepted] <-- [Redacted(RedactedBy::Parent)] (Parent is not redacted)
+ fn assert_ancestor_redacted_from_redacted_parent(&self, identity: &Identity) {
+ for id in &identity.timeline {
+ if let Some(rev) = identity.revision(id)
+ && matches!(rev.state, State::Redacted(RedactedBy::Parent))
+ {
+ let parent_id = rev
+ .parent
+ .expect("a revision in `RedactedBy::Parent` must have a parent");
+ let parent = identity.revision(&parent_id).unwrap();
+ assert!(
+ matches!(
+ parent.state,
+ State::Redacted(RedactedBy::Author) | State::Redacted(RedactedBy::Parent)
+ ),
+ "RedactedBy::Parent revision {} has invalid parent state {:?}",
+ rev.id,
+ parent.state
+ );
+ }
+ }
+ }
+
+ /// If a parent is in a failed state, it cannot have any `Active` or `Accepted` children.
+ ///
+ /// Enforces the "cascade" rule. When a branch dies (via rejection or redaction),
+ /// all of its pending children must also die. A dead branch cannot produce canonical history.
+ /// Note that a child can still be explicitly `Rejected(Vote)` or `Redacted(Author)` on its
+ /// own merits.
+ ///
+ /// PASS:
+ /// [Rejected] <-- [Rejected(RejectedBy::Parent)]
+ /// [Rejected] <-- [Rejected(Vote)] (Child was explicitly voted down before parent died)
+ ///
+ /// FAIL:
+ /// [Rejected] <-- [Active] (Zombie child)
+ fn assert_failed_parents_have_failed_children(&self, identity: &Identity) {
+ for id in &identity.timeline {
+ if let Some(rev) = identity.revision(id)
+ && let Some(parent_id) = rev.parent
+ && let Some(parent) = identity.revision(&parent_id)
+ {
+ let parent_is_failed = matches!(
+ parent.state,
+ State::Rejected(RejectedBy::Vote)
+ | State::Rejected(RejectedBy::Parent)
+ | State::Rejected(RejectedBy::Sibling(_))
+ | State::Redacted(RedactedBy::Author)
+ | State::Redacted(RedactedBy::Parent)
+ );
+
+ if parent_is_failed {
+ assert!(
+ !matches!(rev.state, State::Active | State::Accepted),
+ "Child {} is {:?} but parent {} has failed ({:?})",
+ rev.id,
+ rev.state,
+ parent.id,
+ parent.state
+ );
+ }
+ }
+ }
+ }
+
+ /// Validates that the [`Oid`]s inside terminal states point to the correct revisions.
+ ///
+ /// Ensures that `RejectedBy::Sibling` points to a true sibling that actually won (`Accepted`),
+ /// and that `RejectedBy::Parent` variants point to a true parent in a failed state. Prevents broken
+ /// causal links like pointing to an "uncle" or a revision on a completely different branch.
+ ///
+ /// PASS:
+ /// [Accepted (A)] and [RejectedBy::Sibling(A)] share the same parent.
+ ///
+ /// FAIL:
+ /// [RejectedBy::Sibling(B)] where B does not share the same parent.
+ /// [RejectedBy::Parent] without a rejedted parent.
+ fn assert_rejection_reasons_are_accurate(&self, identity: &Identity) {
+ for id in &identity.timeline {
+ let Some(rev) = identity.revision(id) else {
+ continue;
+ };
+
+ match rev.state {
+ State::Rejected(RejectedBy::Sibling(sibling_id)) => {
+ let sibling = identity.revision(&sibling_id).expect("Sibling must exist");
+
+ assert_eq!(
+ sibling.state,
+ State::Accepted,
+ "The winning sibling {} must be Accepted",
+ sibling_id
+ );
+ assert_eq!(
+ sibling.parent, rev.parent,
+ "Revision {} and {} must share the same parent",
+ rev.id, sibling_id
+ );
+ assert_ne!(
+ sibling.id, rev.id,
+ "A revision cannot be rejected by itself"
+ );
+ }
+ State::Rejected(RejectedBy::Parent) => {
+ let parent_id = rev.parent.expect("revision is not the root revision");
+ let parent = identity.revision(&parent_id).expect("parent exists");
+
+ assert_matches!(
+ parent.state,
+ State::Rejected(_),
+ "Parent {parent_id} must be rejected state",
+ );
+ }
+ State::Redacted(RedactedBy::Parent) => {
+ let parent_id = rev.parent.expect("revision is not the root revision");
+ let parent = identity.revision(&parent_id).expect("parent exists");
+
+ assert_matches!(
+ parent.state,
+ State::Redacted(_),
+ "Parent {parent_id} must be redacted",
+ );
+ }
+ _ => {}
+ }
+ }
+ }
+
+ /// Every vote on a revision must be cast by an authorized delegate according to its causal parent.
+ ///
+ /// Ensures that authorization is strictly governed by the causal history of the document,
+ /// rather than the network's currently accepted state. A user cannot cast a verdict on a
+ /// revision if they are not a delegate in that specific revision's parent.
+ ///
+ /// PASS:
+ /// [Parent: Alice, Bob are delegates] <-- [Child: Bob votes Accept]
+ ///
+ /// FAIL:
+ /// [Parent: Alice is sole delegate] <-- [Child: Bob votes Accept] (Unauthorized)
+ /// [Parent: Removes Bob] <-- [Child: Bob votes Accept] (Bob is no longer a delegate)
+ fn assert_verdicts_match_parent_delegates(&self, identity: &Identity) {
+ for rev in identity.revisions() {
+ if let Some(parent_id) = rev.parent {
+ let parent = identity.revision(&parent_id).unwrap();
+ for (voter_key, _) in rev.verdicts() {
+ let voter_did = Did::from(*voter_key);
+ assert!(
+ parent.doc.is_delegate(&voter_did),
+ "Voter {} cast a verdict on revision {} but is not a delegate in parent {}",
+ voter_did,
+ rev.id,
+ parent_id
+ );
+ }
+ }
+ }
+ }
+}
diff --git a/crates/radicle/src/test.rs b/crates/radicle/src/test.rs
index 3fc9dc0da..d21c3d95d 100644
--- a/crates/radicle/src/test.rs
+++ b/crates/radicle/src/test.rs
@@ -245,6 +245,7 @@ pub mod setup {
pub alice: NodeWithRepo,
pub bob: NodeWithRepo,
pub eve: NodeWithRepo,
+ pub dave: NodeWithRepo,
pub rid: RepoId,
}
@@ -253,11 +254,13 @@ pub mod setup {
let alice = Node::new(tempdir().unwrap(), MockSigner::from_seed([!0; 32]), "alice");
let mut bob = Node::new(tempdir().unwrap(), MockSigner::from_seed([!1; 32]), "bob");
let mut eve = Node::new(tempdir().unwrap(), MockSigner::from_seed([!2; 32]), "eve");
+ let mut dave = Node::new(tempdir().unwrap(), MockSigner::from_seed([!3; 32]), "dave");
let repo = alice.project();
let rid = repo.id;
bob.clone(repo.id, &alice);
eve.clone(repo.id, &alice);
+ dave.clone(repo.id, &alice);
let alice = NodeWithRepo { node: alice, repo };
let repo = bob.storage.repository(rid).unwrap();
@@ -276,11 +279,20 @@ pub mod setup {
checkout: None,
},
};
+ let repo = dave.storage.repository(rid).unwrap();
+ let dave = NodeWithRepo {
+ node: dave,
+ repo: NodeRepo {
+ repo,
+ checkout: None,
+ },
+ };
Self {
alice,
bob,
eve,
+ dave,
rid,
}
}
commit dd7514e542f6893ce60c4ac1ff8de339fd60d67d
Author: Fintan Halpenny <fintan.halpenny@gmail.com>
Date: Fri Jun 12 10:40:22 2026 +0100
radicle/test/arbitrary: Make BoundedVec shared
A `BoundedVec` that implements `Arbitrary` is useful for all property testing.
Move it from the `sigrefs` module so that it can be reused by other components.
diff --git a/crates/radicle/src/storage/refs/sigrefs/git/properties.rs b/crates/radicle/src/storage/refs/sigrefs/git/properties.rs
index 70db07002..5c3d636b4 100644
--- a/crates/radicle/src/storage/refs/sigrefs/git/properties.rs
+++ b/crates/radicle/src/storage/refs/sigrefs/git/properties.rs
@@ -14,24 +14,11 @@ use crate::storage::refs::sigrefs::VerifiedCommit;
use crate::storage::refs::sigrefs::read::{SignedRefsReader, Tip};
use crate::storage::refs::sigrefs::write::{SignedRefsWriter, Update};
use crate::storage::refs::{IDENTITY_ROOT, Refs};
+use crate::test::arbitrary;
use super::Committer;
-/// Newtype wrapper around [`Vec`] to keep the [`Arbitrary`] implementation
-/// bounded to a smaller size.
-#[derive(Clone, Debug)]
-struct BoundedVec<T>(Vec<T>);
-
-impl<T: qcheck::Arbitrary> qcheck::Arbitrary for BoundedVec<T> {
- fn arbitrary(g: &mut qcheck::Gen) -> Self {
- let size = usize::arbitrary(g) % 24;
- BoundedVec((0..size).map(|_| T::arbitrary(g)).collect())
- }
-
- fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
- Box::new(self.0.shrink().map(BoundedVec))
- }
-}
+type BoundedVec<T> = arbitrary::BoundedVec<T, 24>;
struct Verifier {
key: PublicKey,
@@ -176,7 +163,7 @@ fn initial_commit_roundtrip(mut refs: Refs) -> bool {
#[quickcheck]
fn chain_roundtrip(chain: BoundedVec<Refs>) -> TestResult {
- let chain = chain.0;
+ let chain = chain.to_vec();
if chain.is_empty() {
return TestResult::discard();
}
diff --git a/crates/radicle/src/test/arbitrary.rs b/crates/radicle/src/test/arbitrary.rs
index a5c2fbe79..903e1d43c 100644
--- a/crates/radicle/src/test/arbitrary.rs
+++ b/crates/radicle/src/test/arbitrary.rs
@@ -322,3 +322,55 @@ impl Arbitrary for UserAgent {
.unwrap()
}
}
+
+/// Newtype wrapper around [`Vec`] to keep the [`Arbitrary`] implementation
+/// bounded to a smaller size.
+#[derive(Clone, Debug)]
+pub struct BoundedVec<T, const N: usize> {
+ inner: Vec<T>,
+}
+
+impl<T, const N: usize> BoundedVec<T, N> {
+ pub fn to_vec(self) -> Vec<T> {
+ self.inner
+ }
+
+ pub fn is_empty(&self) -> bool {
+ self.inner.is_empty()
+ }
+
+ pub fn len(&self) -> usize {
+ self.inner.len()
+ }
+}
+
+impl<T, const N: usize> IntoIterator for BoundedVec<T, N> {
+ type Item = T;
+ type IntoIter = std::vec::IntoIter<T>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.inner.into_iter()
+ }
+}
+
+impl<'a, T, const N: usize> IntoIterator for &'a BoundedVec<T, N> {
+ type Item = &'a T;
+ type IntoIter = std::slice::Iter<'a, T>;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.inner.iter()
+ }
+}
+
+impl<T: qcheck::Arbitrary, const N: usize> qcheck::Arbitrary for BoundedVec<T, N> {
+ fn arbitrary(g: &mut qcheck::Gen) -> Self {
+ let size = usize::arbitrary(g) % N;
+ Self {
+ inner: (0..size).map(|_| T::arbitrary(g)).collect(),
+ }
+ }
+
+ fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
+ Box::new(self.inner.shrink().map(|inner| Self { inner }))
+ }
+}
commit b13981875fe0056b76a9fe1347e0289299b2c50e
Author: Adrian Duke <adrian.duke@gmail.com>
Date: Fri May 29 19:43:44 2026 +0100
radicle/cob/identity: Fix comments in test `reject_concurrent`
This incorrectly listed the number of votes and delegates.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 27cedc7aa..f3f832299 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1752,7 +1752,7 @@ mod test {
}
#[test]
- fn test_identity_reject_concurrent() {
+ fn reject_concurrent() {
let network = Network::default();
let alice = &network.alice;
let bob = &network.bob;
@@ -1809,14 +1809,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 e36f1b37ed7d96795eba7e93067b2406851918ab
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 a377681a3..27cedc7aa 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -2300,4 +2300,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 f55bdcd7dff252a6a28ff04e1fa4d214daa18f23
Author: Adrian Duke <adrian.duke@gmail.com>
Date: Fri May 22 15:35:02 2026 +0100
radicle/cob/identity: Test cascading of redaction
Add a test case to show that when a revision is redacted that its children also
become redacted, tracking `RedactedBy::Parent`.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 75b9c577e..a377681a3 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 3318a050aa0630b1ebecb369d518a634e865306c
Author: Adrian Duke <adrian.duke@gmail.com>
Date: Fri May 22 14:39:18 2026 +0100
radicle/cob/identity: Test cascading rejection
When a revision reaches qourum and is adopted, the state all competing sibling
revisions as `Rejected`.
However, the test suite lacked coverage for deeper proposal branches,
specifically testing that this rejection correctly cascades to the
children of those rejected siblings.
Introduces a test to simulate the scenario where a delegate eagerly
proposes a chain of revisions (a child branching off a sibling) while
others concurrently accept a competing branch.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index b713736fa..75b9c577e 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1836,6 +1836,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 991a9cd6f21bb7b18d1c9667f39b2b70f9e4b372
Author: Adrian Duke <adrian.duke@gmail.com>
Date: Fri May 22 14:24:33 2026 +0100
radicle/cob/identity: Test terminal states
The identity evaluation rewrite changed how revision redactions are
handled. Instead of removing the revision entirely, it explicitly
transitions the revision to `State::Redacted`.
Add a test to cover two redaction scenarios:
- Attempting to redact a revision that has already been `Accepted`.
- Attempting to redact a revision that has already been `Rejected`.
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index c63400f97..b713736fa 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1912,6 +1912,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 1e0f0e2bd2963c79e94af43192bddb3f5f99a072
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 2904f0146..c63400f97 100644
--- a/crates/radicle/src/cob/identity.rs
+++ b/crates/radicle/src/cob/identity.rs
@@ -1836,6 +1836,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 fc30d9c19eb49e6e5334a96e37f18dcecbe070e1
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 9c218363a..2904f0146 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 remove_delegate_concurrent() {
let network = Network::default();
commit 1dbb9bf4128415537b036974821e60ed27318d21
Author: Lorenz Leutgeb <lorenz.leutgeb@radicle.xyz>
Date: Mon Mar 30 17:57:28 2026 +0200
radicle/cob/identity: Rewrite Evaluation
The evaluation of the reposioty identity is rewritten to better handle cases
where there are child and sibling revisions that are active at the same time.
In particular, `fn Identity::action` is now free of any references to
`self.current`.
This is achieved through two main improvements. The first is that the `State`
of revisions changes to improve clarity:
1. `Active` and `Accepted` remain, and their meanings also remain the same.
2. `Stale` is removed entirely.
3. `Rejected` is improved to also contain `RejectedBy`, to keep track of the
reason for rejection.
4. `Redacted` is promoted to a state. Similarly, the reason for
redaction is tracked by `RedactedBy`.
The transition of a revision from `Active` to one of the other states now
influences siblings and children.
If a revision transitions to `Accepted`, then the sibling revisions can no
longer transition to `Accepted`. They are considered `Rejected` where the reason
is `Sibling`. This cascades: Children of siblings are `Rejected`
recursively, tracking `RejectedBy::Parent`.
Any children of the `Accepted` revision are also evaluated to see if they can be
similarly transitioned to the `Accepted` state; since they may have already been
voted on.
If a revision was rejected by a majority, then the it transitions to `Rejected`
with `RejectedBy::Vote`. Dually to acceptance, the children of this revision
are also rejected with the reason of `Ancestor`.
Finally, when the author of a revision redacts a revision, it transitions
to `Redacted`, tracking `RedactedBy::Author`, and its children are redacted
tracking `RedactedBy::Parent`.
The test is adjusted to `remove_delegate_concurrent` reflect that concurrently
proposed revisions are retained in the timeline and explicitly marked as rejected,
rather than being dropped entirely (as before).
diff --git a/crates/radicle-cli/examples/rad-id-conflict.md b/crates/radicle-cli/examples/rad-id-conflict.md
index 495dc6f70..b43fe5915 100644
--- a/crates/radicle-cli/examples/rad-id-conflict.md
+++ b/crates/radicle-cli/examples/rad-id-conflict.md
@@ -53,7 +53,7 @@ $ rad id list
│ ● ID Title Author Status Created Parent │
├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ ● 89b2623 Edit project name bob z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk accepted now 0ca42d3 │
-│ ● 12d7300 Edit project name alice (you) stale now 0ca42d3 │
+│ ● 12d7300 Edit project name alice (you) rejected now 0ca42d3 │
│ ● 0ca42d3 Add Bob alice (you) accepted now 0656c21 │
│ ● 0656c21 Initial revision alice (you) accepted now none │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
@@ -70,9 +70,9 @@ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from the network, found 1 potential s
```
``` ~bob (fail)
$ rad id accept 12d7300 -q
-✗ Error: cannot vote on revision that is stale
+✗ Error: cannot vote on revision that is rejected
$ rad id reject 12d7300 -q
-✗ Error: cannot vote on revision that is stale
+✗ Error: cannot vote on revision that is rejected
```
``` ~bob
$ rad id show 12d7300
@@ -82,7 +82,7 @@ $ rad id show 12d7300
│ Parent 0ca42d376bd566631083c8913cf86bec722da392 │
│ Blob e93aa3e3c5c448bacd3537a81daf1437eccd046a │
│ Author did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi │
-│ State stale │
+│ State rejected │
│ Quorum no │
├────────────────────────────────────────────────────────────────────────┤
│ ✓ did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi alice │
diff --git a/crates/radicle-cli/src/commands/id.rs b/crates/radicle-cli/src/commands/id.rs
index c7b2b0356..3fc9df01f 100644
--- a/crates/radicle-cli/src/commands/id.rs
+++ b/crates/radicle-cli/src/commands/id.rs
@@ -222,8 +222,8 @@ pub fn run(args: Args, ctx: impl term::Context) -> anyhow::Result<()> {
let icon = match r.state {
identity::State::Active => term::format::tertiary("●"),
identity::State::Accepted => term::format::positive("●"),
- identity::State::Rejected => term::format::negative("●"),
- identity::State::Stale => term::format::dim("●"),
+ identity::State::Rejected(_) => term::format::negative("●"),
+ identity::State::Redacted(_) => continue,
}
.into();
let state = r.state.to_string().into();
@@ -288,6 +288,7 @@ fn get<'a>(
let id = revision.resolve(&repo.backend)?;
let revision = identity
.revision(&id)
+ .filter(|revision| !matches!(revision.state, identity::State::Redacted(_)))
.ok_or(anyhow!("revision `{id}` not found"))?;
Ok(revision)
@@ -344,13 +345,28 @@ fn print_meta(revision: &Revision, previous: &Doc, profile: &Profile) -> anyhow:
})
.divider();
- let accepted = revision.accepted().collect::<Vec<_>>();
- let rejected = revision.rejected().collect::<Vec<_>>();
- let unknown = previous
- .delegates()
- .iter()
- .filter(|id| !accepted.contains(id) && !rejected.contains(id))
- .collect::<Vec<_>>();
+ let accepted = {
+ let mut accepted = revision.accepted().collect::<Vec<_>>();
+ accepted.sort();
+ accepted
+ };
+
+ let rejected = {
+ let mut rejected = revision.rejected().collect::<Vec<_>>();
+ rejected.sort();
+ rejected
+ };
+
+ let unknown = {
+ let mut unknown = previous
+ .delegates()
+ .iter()
+ .filter(|id| !accepted.contains(id) && !rejected.contains(id))
+ .collect::<Vec<_>>();
+ unknown.sort();
+ unknown
+ };
+
let mut signatures = term::Table::<4, _>::default();
for id in accepted {
@@ -485,7 +501,6 @@ fn on_apply_err(e: &identity::ApplyError, profile: &Profile) -> anyhow::Error {
| e @ radicle::cob::identity::ApplyError::MissingParent
| e @ radicle::cob::identity::ApplyError::DuplicateVerdict
| e @ radicle::cob::identity::ApplyError::UnexpectedState
- | e @ radicle::cob::identity::ApplyError::Redacted
| e @ radicle::cob::identity::ApplyError::DocUnchanged
| e @ radicle::cob::identity::ApplyError::Git(_)
| e @ radicle::cob::identity::ApplyError::Doc(_)
diff --git a/crates/radicle-cli/src/terminal/format.rs b/crates/radicle-cli/src/terminal/format.rs
index 78a42390c..e12029a3f 100644
--- a/crates/radicle-cli/src/terminal/format.rs
+++ b/crates/radicle-cli/src/terminal/format.rs
@@ -405,8 +405,7 @@ pub mod identity {
match s {
State::Active => term::format::tertiary(s.to_string()),
State::Accepted => term::format::positive(s.to_string()),
- State::Rejected => term::format::negative(s.to_string()),
- State::Stale => term::format::dim(s.to_string()),
+ State::Rejected(_) | State::Redacted(_) => term::format::negative(s.to_string()),
}
}
}
diff --git a/crates/radicle/src/cob/identity.rs b/crates/radicle/src/cob/identity.rs
index 368e85d49..9c218363a 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))?;
+
+ if !parent.is_delegate(&did) {
+ return Err(ApplyError::non_delegate_unauthorized(did, &action));
+ }
- revision.reject(author)?;
+ 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,12 +1516,15 @@ mod test {
bob_identity.reload().unwrap();
assert_eq!(bob_identity.timeline, vec![a0, a1, a2, a3, b1]);
- assert_eq!(bob_identity.revision(&a2), None);
+ assert_eq!(
+ bob_identity.revision(&a2).unwrap().state,
+ State::Redacted(RedactedBy::Author)
+ );
assert_eq!(bob_identity.current, a1);
}
#[test]
- fn test_identity_remove_delegate_concurrent() {
+ fn remove_delegate_concurrent() {
let network = Network::default();
let alice = &network.alice;
let bob = &network.bob;
@@ -1357,6 +1535,8 @@ mod test {
alice_doc.delegate(bob.signer.public_key().into());
alice_doc.delegate(eve.signer.public_key().into());
+ assert_eq!(alice_doc.delegates.len(), 3);
+
let a0 = alice_identity.root;
let a1 = alice_identity // Change description to change traversal order.
.update(
@@ -1367,6 +1547,8 @@ mod test {
.unwrap();
alice_doc.rescind(&eve.signer.public_key().into()).unwrap();
+ assert_eq!(alice_doc.delegates.len(), 2);
+
let a2 = alice_identity
.update(
cob::Title::new("Remove Eve").unwrap(),
@@ -1413,7 +1595,10 @@ mod test {
// 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.revision(&e1).unwrap().state,
+ State::Rejected(RejectedBy::Sibling(a2))
+ );
assert!(!eve_identity.is_delegate(&eve.signer.public_key().into()));
}
@@ -1494,10 +1679,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 +1758,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 1d88975e-a359-4954-80e3-b465f4d23cc1 -v /opt/radcis/ci.rad.levitte.org/cci/state/1d88975e-a359-4954-80e3-b465f4d23cc1/s:/1d88975e-a359-4954-80e3-b465f4d23cc1/s:ro -v /opt/radcis/ci.rad.levitte.org/cci/state/1d88975e-a359-4954-80e3-b465f4d23cc1/w:/1d88975e-a359-4954-80e3-b465f4d23cc1/w -w /1d88975e-a359-4954-80e3-b465f4d23cc1/w -v /opt/radcis/ci.rad.levitte.org/.radicle:/${id}/.radicle:ro -e RAD_HOME=/${id}/.radicle rust:trixie bash /1d88975e-a359-4954-80e3-b465f4d23cc1/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 block-padding v0.3.3
Downloaded base16ct v0.2.0
Downloaded bcrypt-pbkdf v0.10.0
Downloaded base256emoji v1.0.2
Downloaded bitflags v2.11.0
Downloaded errno v0.3.14
Downloaded bytecount v0.6.9
Downloaded bit-vec v0.8.0
Downloaded icu_normalizer_data v2.1.1
Downloaded base64ct v1.8.3
Downloaded indexmap v2.13.0
Downloaded mio v1.1.1
Downloaded heck v0.5.0
Downloaded email_address v0.2.9
Downloaded gix-prompt v0.15.0
Downloaded gix-negotiate v0.31.0
Downloaded itoa v1.0.17
Downloaded either v1.15.0
Downloaded human-panic v2.0.6
Downloaded gix-commitgraph v0.37.0
Downloaded lock_api v0.4.14
Downloaded match-lookup v0.1.2
Downloaded nu-ansi-term v0.50.3
Downloaded inout v0.1.4
Downloaded num-integer v0.1.46
Downloaded maybe-async v0.2.10
Downloaded ref-cast-impl v1.0.25
Downloaded num-complex v0.4.6
Downloaded num-iter v0.1.45
Downloaded once_cell v1.21.4
Downloaded rustc_version v0.4.1
Downloaded radicle-std-ext v0.2.0
Downloaded ref-cast v1.0.25
Downloaded rand_xorshift v0.4.0
Downloaded rusty-fork v0.3.1
Downloaded rfc6979 v0.4.0
Downloaded parking_lot v0.12.5
Downloaded signal-hook-mio v0.2.5
Downloaded schemars_derive v1.2.1
Downloaded sha1 v0.10.6
Downloaded serde_derive_internals v0.29.1
Downloaded snapbox-macros v1.1.0
Downloaded socks5-client v0.4.3
Downloaded signal-hook-registry v1.4.8
Downloaded stable_deref_trait v1.2.1
Downloaded clap_builder v4.6.0
Downloaded sval_dynamic v2.17.0
Downloaded sval_fmt v2.17.0
Downloaded sval_serde v2.17.0
Downloaded sval_ref v2.17.0
Downloaded sval_json v2.17.0
Downloaded secrecy v0.10.3
Downloaded signature v2.2.0
Downloaded test-log-macros v0.2.19
Downloaded tree-sitter-json v0.24.8
Downloaded tinyvec_macros v0.1.1
Downloaded spin v0.9.8
Downloaded timeago v0.4.2
Downloaded unicode-display-width v0.3.0
Downloaded tree-sitter-language v0.1.7
Downloaded tinystr v0.8.2
Downloaded signature v1.6.4
Downloaded universal-hash v0.5.1
Downloaded wait-timeout v0.2.1
Downloaded tree-sitter-html v0.23.2
Downloaded walkdir v2.5.0
Downloaded rustversion v1.0.22
Downloaded zerofrom v0.1.6
Downloaded writeable v0.6.2
Downloaded zerofrom-derive v0.1.6
Downloaded object v0.37.3
Downloaded zeroize v1.8.2
Downloaded zmij v1.0.21
Downloaded uuid-simd v0.8.0
Downloaded shlex v1.3.0
Downloaded serde_json v1.0.149
Downloaded yansi v1.0.1
Downloaded url v2.5.8
Downloaded proptest v1.10.0
Downloaded xattr v1.6.1
Downloaded unicode-normalization v0.1.25
Downloaded thread_local v1.1.9
Downloaded tree-sitter-python v0.23.6
Downloaded version_check v0.9.5
Downloaded getrandom v0.4.2
Downloaded tree-sitter-c v0.23.4
Downloaded zlib-rs v0.6.3
Downloaded vsimd v0.8.0
Downloaded syn v2.0.117
Downloaded tree-sitter-md v0.3.2
Downloaded signals_receipts v0.2.5
Downloaded sharded-slab v0.1.7
Downloaded serde_core v1.0.228
Downloaded fraction v0.15.3
Downloaded jiff-static v0.2.23
Downloaded tree-sitter-bash v0.23.3
Downloaded tracing v0.1.44
Downloaded zerotrie v0.2.3
Downloaded tree-sitter-go v0.23.4
Downloaded zerovec v0.11.5
Downloaded regex v1.12.3
Downloaded itertools v0.14.0
Downloaded icu_properties_data v2.1.2
Downloaded libm v0.2.16
Downloaded sysinfo v0.37.2
Downloaded git2 v0.20.4
Downloaded gimli v0.32.3
Downloaded zerocopy v0.8.42
Downloaded unicode-width v0.2.2
Downloaded tree-sitter-typescript v0.23.2
Downloaded tree-sitter-rust v0.23.3
Downloaded libc v0.2.183
Downloaded idna v1.1.0
Downloaded tokio v1.50.0
Downloaded rustix v1.1.4
Downloaded hashbrown v0.16.1
Downloaded regex-automata v0.4.14
Downloaded jsonschema v0.30.0
Downloaded inquire v0.9.4
Downloaded uuid v1.22.0
Downloaded tree-sitter-ruby v0.23.1
Downloaded icu_collections v2.1.1
Downloaded gix-pack v0.70.0
Downloaded toml v0.9.12+spec-1.1.0
Downloaded tar v0.4.45
Downloaded gix-odb v0.80.0
Downloaded fancy-regex v0.14.0
Downloaded jiff v0.2.23
Downloaded p256 v0.13.2
Downloaded icu_locale_core v2.1.1
Downloaded tempfile v3.27.0
Downloaded sha1-checked v0.10.0
Downloaded regex-syntax v0.8.10
Downloaded indicatif v0.18.4
Downloaded sha3 v0.10.8
Downloaded libz-sys v1.1.25
Downloaded icu_normalizer v2.1.1
Downloaded gix-transport v0.57.0
Downloaded flate2 v1.1.9
Downloaded vcpkg v0.2.15
Downloaded tree-sitter-highlight v0.24.7
Downloaded tracing-subscriber v0.3.23
Downloaded toml_writer v1.0.7+spec-1.1.0
Downloaded toml_datetime v0.7.5+spec-1.1.0
Downloaded syn v1.0.109
Downloaded sem_safe v0.2.1
Downloaded tree-sitter v0.24.7
Downloaded synstructure v0.13.2
Downloaded icu_provider v2.1.1
Downloaded hmac v0.12.1
Downloaded gix-path v0.12.0
Downloaded gix-object v0.60.0
Downloaded heapless v0.8.0
Downloaded gix-ref v0.63.0
Downloaded gix-diff v0.63.0
Downloaded getrandom v0.3.4
Downloaded utf8parse v0.2.2
Downloaded structured-logger v1.0.5
Downloaded sqlite v0.37.0
Downloaded referencing v0.30.0
Downloaded parking_lot_core v0.9.12
Downloaded unicode-segmentation v1.12.0
Downloaded sha2 v0.10.9
Downloaded typenum v1.19.0
Downloaded group v0.13.0
Downloaded gix-packetline v0.21.3
Downloaded fluent-uri v0.3.2
Downloaded portable-atomic v1.13.1
Downloaded p384 v0.13.1
Downloaded sqlite3-src v0.7.0
Downloaded libgit2-sys v0.18.3+1.9.2
Downloaded zerovec-derive v0.11.2
Downloaded yoke v0.8.1
Downloaded unicode-ident v1.0.24
Downloaded tree-sitter-css v0.23.2
Downloaded tracing-core v0.1.36
Downloaded ssh-key v0.6.7
Downloaded curve25519-dalek v4.1.3
Downloaded yoke-derive v0.8.1
Downloaded value-bag v1.12.0
Downloaded test-log v0.2.19
Downloaded serde-untagged v0.1.9
Downloaded sec1 v0.7.3
Downloaded radicle-surf v0.27.1
Downloaded litrs v1.0.0
Downloaded gix-protocol v0.61.0
Downloaded tinyvec v1.11.0
Downloaded bloomy v1.2.0
Downloaded sval v2.17.0
Downloaded litemap v0.8.1
Downloaded gix-features v0.48.0
Downloaded value-bag-serde1 v1.12.0
Downloaded tree-sitter-toml-ng v0.6.0
Downloaded similar v3.1.1
Downloaded filetime v0.2.27
Downloaded tracing-log v0.2.0
Downloaded value-bag-sval2 v1.12.0
Downloaded utf8_iter v1.0.4
Downloaded unit-prefix v0.5.2
Downloaded unarray v0.1.4
Downloaded typeid v1.0.3
Downloaded linux-raw-sys v0.12.1
Downloaded gix-command v0.9.0
Downloaded strsim v0.11.1
Downloaded ssh-agent-lib v0.6.0
Downloaded serde v1.0.228
Downloaded sval_buffer v2.17.0
Downloaded rand v0.9.2
Downloaded pretty_assertions v1.4.1
Downloaded thiserror-impl v2.0.18
Downloaded thiserror v2.0.18
Downloaded sval_nested v2.17.0
Downloaded serde_derive v1.0.228
Downloaded rand v0.8.5
Downloaded prodash v31.0.0
Downloaded p521 v0.13.3
Downloaded schemars v1.2.1
Downloaded gix-fs v0.21.1
Downloaded ff v0.13.1
Downloaded thiserror v1.0.69
Downloaded systemd-journal-logger v2.2.2
Downloaded socket2 v0.5.10
Downloaded gix-error v0.2.3
Downloaded thiserror-impl v1.0.69
Downloaded snapbox v1.2.2
Downloaded ryu v1.0.23
Downloaded signal-hook v0.3.18
Downloaded shell-words v1.1.1
Downloaded rsa v0.9.10
Downloaded gix-glob v0.26.0
Downloaded icu_properties v2.1.2
Downloaded smallvec v1.15.1
Downloaded streaming-iterator v0.1.9
Downloaded ssh-encoding v0.2.0
Downloaded sqlite3-sys v0.18.0
Downloaded subtle v2.6.1
Downloaded spki v0.7.3
Downloaded simd-adler32 v0.3.8
Downloaded jobserver v0.1.34
Downloaded humantime v2.3.0
Downloaded gix-url v0.36.0
Downloaded gix-sec v0.14.0
Downloaded gix-revision v0.45.0
Downloaded gix-refspec v0.41.0
Downloaded gix-credentials v0.38.0
Downloaded ssh-cipher v0.2.0
Downloaded proc-macro-error2 v2.0.1
Downloaded num-bigint-dig v0.8.6
Downloaded lexopt v0.3.2
Downloaded gix-revwalk v0.31.0
Downloaded siphasher v1.0.2
Downloaded siphasher v0.3.11
Downloaded scrypt v0.11.0
Downloaded rustc-demangle v0.1.27
Downloaded rand_chacha v0.3.1
Downloaded qcheck v1.0.0
Downloaded serde_spanned v1.0.4
Downloaded semver v1.0.27
Downloaded proc-macro2 v1.0.106
Downloaded proc-macro-error-attr2 v2.0.0
Downloaded gix-hash v0.25.0
Downloaded salsa20 v0.10.2
Downloaded ppv-lite86 v0.2.21
Downloaded pkcs8 v0.10.2
Downloaded gix-traverse v0.57.0
Downloaded gix-tempfile v23.0.0
Downloaded find-msvc-tools v0.1.9
Downloaded serde_fmt v1.1.0
Downloaded scopeguard v1.2.0
Downloaded same-file v1.0.6
Downloaded rand_core v0.9.5
Downloaded rand_core v0.6.4
Downloaded polyval v0.6.2
Downloaded poly1305 v0.8.0
Downloaded phf v0.11.3
Downloaded pastey v0.2.1
Downloaded num-bigint v0.4.6
Downloaded multibase v0.9.2
Downloaded chacha20poly1305 v0.10.1
Downloaded phf_shared v0.11.3
Downloaded pem-rfc7468 v0.7.0
Downloaded rand_chacha v0.9.0
Downloaded quote v1.0.45
Downloaded primeorder v0.13.6
Downloaded pbkdf2 v0.12.2
Downloaded memchr v2.8.0
Downloaded keccak v0.1.6
Downloaded faster-hex v0.10.0
Downloaded emojis v0.6.4
Downloaded derive_more-impl v2.1.1
Downloaded pkg-config v0.3.32
Downloaded pin-project-lite v0.2.17
Downloaded percent-encoding v2.3.2
Downloaded lazy_static v1.5.0
Downloaded idna_adapter v1.2.1
Downloaded git-ref-format-macro v0.6.0
Downloaded crypto-bigint v0.5.5
Downloaded radicle-git-ext v0.12.0
Downloaded miniz_oxide v0.8.9
Downloaded hash32 v0.3.1
Downloaded der v0.7.10
Downloaded crossterm v0.29.0
Downloaded iana-time-zone v0.1.65
Downloaded gix-date v0.15.3
Downloaded escargot v0.5.15
Downloaded quick-error v1.2.3
Downloaded qcheck-macros v1.0.0
Downloaded potential_utf v0.1.4
Downloaded pkcs1 v0.7.5
Downloaded outref v0.5.2
Downloaded num-traits v0.2.19
Downloaded num-rational v0.4.2
Downloaded gix-shallow v0.12.0
Downloaded gix-actor v0.41.0
Downloaded backtrace v0.3.76
Downloaded log v0.4.29
Downloaded num-cmp v0.1.0
Downloaded noise-framework v0.4.1
Downloaded git-ref-format v0.6.0
Downloaded fastrand v2.3.0
Downloaded normalize-line-endings v0.3.0
Downloaded nonempty v0.9.0
Downloaded ed25519-dalek v2.2.0
Downloaded cyphernet v0.5.4
Downloaded opaque-debug v0.3.1
Downloaded memmap2 v0.9.10
Downloaded gix-config-value v0.18.0
Downloaded ascii v1.1.0
Downloaded matchers v0.2.0
Downloaded num v0.4.3
Downloaded nonempty v0.12.0
Downloaded erased-serde v0.4.10
Downloaded crossbeam-channel v0.5.15
Downloaded gix-quote v0.7.1
Downloaded generic-array v0.14.7
Downloaded colored v2.2.0
Downloaded anstream v1.0.0
Downloaded is_terminal_polyfill v1.70.2
Downloaded gix-trace v0.1.19
Downloaded gix-lock v23.0.0
Downloaded gix-hashtable v0.15.0
Downloaded git-ref-format-core v0.6.0
Downloaded fast-glob v0.3.3
Downloaded elliptic-curve v0.13.8
Downloaded ed25519 v1.5.3
Downloaded ctr v0.9.2
Downloaded ct-codecs v1.1.6
Downloaded anstyle-parse v0.2.7
Downloaded gix-validate v0.11.1
Downloaded gix-utils v0.3.2
Downloaded derive_more v2.1.1
Downloaded gix-chunk v0.7.1
Downloaded fnv v1.0.7
Downloaded cbc v0.1.2
Downloaded displaydoc v0.2.5
Downloaded digest v0.10.7
Downloaded curve25519-dalek-derive v0.1.1
Downloaded cpufeatures v0.2.17
Downloaded clap_lex v1.1.0
Downloaded ghash v0.5.1
Downloaded env_filter v1.0.0
Downloaded ed25519 v2.2.3
Downloaded crypto-common v0.1.7
Downloaded cfg-if v1.0.4
Downloaded anyhow v1.0.102
Downloaded amplify_syn v2.0.1
Downloaded form_urlencoded v1.2.2
Downloaded env_logger v0.11.9
Downloaded data-encoding-macro-internal v0.1.17
Downloaded data-encoding v2.10.0
Downloaded cypheraddr v0.4.1
Downloaded autocfg v1.5.0
Downloaded anstyle v1.0.14
Downloaded ecdsa v0.16.9
Downloaded document-features v0.2.12
Downloaded cyphergraphy v0.3.1
Downloaded crossbeam-utils v0.8.21
Downloaded cc v1.2.57
Downloaded arc-swap v1.9.1
Downloaded const-str v0.4.3
Downloaded console v0.16.3
Downloaded cipher v0.4.4
Downloaded chacha20 v0.9.1
Downloaded byteorder v1.5.0
Downloaded anstream v0.6.21
Downloaded ec25519 v0.1.0
Downloaded dunce v1.0.5
Downloaded diff v0.1.13
Downloaded crc32fast v1.5.0
Downloaded const-oid v0.9.6
Downloaded clap_complete v4.6.0
Downloaded clap v4.6.0
Downloaded base32 v0.4.0
Downloaded amplify v4.9.0
Downloaded equivalent v1.0.2
Downloaded dyn-clone v1.0.20
Downloaded data-encoding-macro v0.1.19
Downloaded convert_case v0.10.0
Downloaded clap_derive v4.6.0
Downloaded bstr v1.12.1
Downloaded getrandom v0.2.17
Downloaded aes v0.8.4
Downloaded base-x v0.2.11
Downloaded colorchoice v1.0.5
Downloaded bytes v1.11.1
Downloaded blowfish v0.9.1
Downloaded bit-set v0.8.0
Downloaded amplify_derive v4.0.1
Downloaded aes-gcm v0.10.3
Downloaded aho-corasick v1.1.4
Downloaded borrow-or-share v0.2.4
Downloaded block-buffer v0.10.4
Downloaded base64 v0.21.7
Downloaded anstyle-query v1.1.5
Downloaded anstyle-parse v1.0.0
Downloaded amplify_num v0.5.3
Downloaded ahash v0.8.12
Downloaded adler2 v2.0.1
Downloaded addr2line v0.25.1
Downloaded chrono v0.4.44
Downloaded bytesize v2.3.1
Downloaded base64 v0.22.1
Downloaded aead v0.5.2
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 find-msvc-tools v0.1.9
Compiling shlex v1.3.0
Compiling cc v1.2.57
Checking crypto-common v0.1.7
Checking subtle v2.6.1
Compiling serde_core v1.0.228
Checking regex-syntax v0.8.10
Checking aho-corasick v1.1.4
Checking const-oid v0.9.6
Checking smallvec v1.15.1
Checking block-buffer v0.10.4
Checking digest v0.10.7
Checking cpufeatures v0.2.17
Checking stable_deref_trait v1.2.1
Compiling thiserror v2.0.18
Checking fastrand v2.3.0
Compiling parking_lot_core v0.9.12
Checking regex-automata v0.4.14
Checking scopeguard v1.2.0
Checking lock_api v0.4.14
Checking bitflags v2.11.0
Checking parking_lot v0.12.5
Compiling typeid v1.0.3
Compiling erased-serde v0.4.10
Checking gix-trace v0.1.19
Compiling crc32fast v1.5.0
Checking tinyvec_macros v0.1.1
Checking tinyvec v1.11.0
Compiling serde v1.0.228
Checking unicode-normalization v0.1.25
Checking itoa v1.0.17
Checking byteorder v1.5.0
Checking gix-utils v0.3.2
Checking serde_fmt v1.1.0
Checking hashbrown v0.16.1
Checking value-bag-serde1 v1.12.0
Compiling synstructure v0.13.2
Compiling thiserror-impl v2.0.18
Checking bstr v1.12.1
Compiling serde_derive v1.0.228
Checking value-bag v1.12.0
Checking gix-validate v0.11.1
Compiling zerofrom-derive v0.1.6
Checking log v0.4.29
Checking same-file v1.0.6
Checking walkdir v2.5.0
Compiling yoke-derive v0.8.1
Checking gix-path v0.12.0
Checking prodash v31.0.0
Checking zlib-rs v0.6.3
Checking zerofrom v0.1.6
Compiling heapless v0.8.0
Compiling pkg-config v0.3.32
Checking yoke v0.8.1
Compiling rustix v1.1.4
Compiling zerovec-derive v0.11.2
Checking hash32 v0.3.1
Compiling autocfg v1.5.0
Checking gix-features v0.48.0
Checking linux-raw-sys v0.12.1
Compiling libm v0.2.16
Compiling num-traits v0.2.19
Checking zerovec v0.11.5
Compiling displaydoc v0.2.5
Compiling getrandom v0.4.2
Checking faster-hex v0.10.0
Checking block-padding v0.3.3
Compiling zerocopy v0.8.42
Checking inout v0.1.4
Checking sha2 v0.10.9
Checking sha1 v0.10.6
Checking sha1-checked v0.10.0
Checking cipher v0.4.4
Checking tinystr v0.8.2
Checking litemap v0.8.1
Checking writeable v0.6.2
Checking once_cell v1.21.4
Checking percent-encoding v2.3.2
Checking icu_locale_core v2.1.1
Checking gix-hash v0.25.0
Checking zerotrie v0.2.3
Checking potential_utf v0.1.4
Compiling icu_normalizer_data v2.1.1
Compiling zmij v1.0.21
Compiling icu_properties_data v2.1.2
Checking icu_provider v2.1.1
Checking icu_collections v2.1.1
Checking der v0.7.10
Compiling serde_json v1.0.149
Checking equivalent v1.0.2
Checking indexmap v2.13.0
Compiling thiserror v1.0.69
Compiling ref-cast v1.0.25
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
Checking dyn-clone v1.0.20
Checking utf8_iter v1.0.4
Compiling tree-sitter-language v0.1.7
Checking opaque-debug v0.3.1
Checking idna v1.1.0
Checking spki v0.7.3
Compiling libgit2-sys v0.18.3+1.9.2
Checking signature v2.2.0
Checking ff v0.13.1
Checking base16ct v0.2.0
Checking group v0.13.0
Checking sec1 v0.7.3
Checking rand_chacha v0.3.1
Checking form_urlencoded v1.2.2
Compiling serde_derive_internals v0.29.1
Checking crypto-bigint v0.5.5
Compiling schemars_derive v1.2.1
Checking elliptic-curve v0.13.8
Compiling amplify_syn v2.0.1
Checking url v2.5.8
Checking rand v0.8.5
Checking num-iter v0.1.45
Checking aead v0.5.2
Compiling semver v1.0.27
Checking signature v1.6.4
Checking ed25519 v1.5.3
Compiling rustc_version v0.4.1
Checking schemars v1.2.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
Checking base64ct v1.8.3
Compiling num-bigint-dig v0.8.6
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 aes v0.8.4
Checking ctr v0.9.2
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 blowfish v0.9.1
Checking cbc v0.1.2
Compiling data-encoding v2.10.0
Checking base32 v0.4.0
Compiling crossbeam-utils v0.8.21
Checking cypheraddr v0.4.1
Compiling data-encoding-macro-internal v0.1.17
Checking rsa v0.9.10
Checking ssh-cipher v0.2.0
Checking bcrypt-pbkdf v0.10.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 data-encoding-macro v0.1.19
Checking ssh-key v0.6.7
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 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-localtime)
Checking radicle-git-metadata v0.2.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-git-metadata)
Checking radicle-dag v0.10.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-dag)
Checking is_terminal_polyfill v1.70.2
Checking anstyle v1.0.14
Checking colorchoice v1.0.5
Checking radicle-git-ref-format v0.1.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-git-ref-format)
Checking gix-hashtable v0.15.0
Compiling radicle v0.24.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle)
Compiling unicode-segmentation v1.12.0
Checking base64 v0.21.7
Compiling signal-hook v0.3.18
Compiling convert_case v0.10.0
Checking gix-date v0.15.3
Checking signal-hook-registry v1.4.8
Checking gix-actor v0.41.0
Checking gix-object v0.60.0
Checking serde-untagged v0.1.9
Checking bytesize v2.3.1
Checking memmap2 v0.9.10
Checking dunce v1.0.5
Checking nonempty v0.12.0
Checking fast-glob v0.3.3
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
Checking unicode-width v0.2.2
Compiling portable-atomic v1.13.1
Compiling litrs v1.0.0
Checking signals_receipts v0.2.5
Checking derive_more v2.1.1
Compiling document-features v0.2.12
Checking signal-hook-mio v0.2.5
Checking gix-commitgraph v0.37.0
Checking anstyle-parse v1.0.0
Checking crossterm v0.29.0
Checking anstream v1.0.0
Checking gix-revwalk v0.31.0
Checking console v0.16.3
Checking gix-fs v0.21.1
Checking unit-prefix v0.5.2
Checking indicatif v0.18.4
Checking gix-tempfile v23.0.0
Checking inquire v0.9.4
Checking unicode-display-width v0.3.0
Checking radicle-signals v0.11.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-signals)
Checking gix-quote v0.7.1
Checking either v1.15.0
Checking iana-time-zone v0.1.65
Checking shell-words v1.1.1
Checking chrono v0.4.44
Checking gix-command v0.9.0
Checking colored v2.2.0
Compiling object v0.37.3
Compiling rustversion v1.0.22
Checking gix-lock v23.0.0
Checking gix-url v0.36.0
Checking gix-config-value v0.18.0
Checking gix-sec v0.14.0
Checking adler2 v2.0.1
Checking gimli v0.32.3
Checking miniz_oxide v0.8.9
Checking gix-prompt v0.15.0
Checking addr2line v0.25.1
Checking gix-traverse v0.57.0
Checking gix-revision v0.45.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
Compiling anyhow v1.0.102
Checking rustc-demangle v0.1.27
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 flate2 v1.1.9
Compiling tar v0.4.45
Compiling git-ref-format-macro v0.6.0
Checking snapbox-macros v1.1.0
Checking salsa20 v0.10.2
Checking streaming-iterator v0.1.9
Checking siphasher v0.3.11
Checking similar v3.1.1
Checking clap_lex v1.1.0
Checking normalize-line-endings v0.3.0
Compiling heck v0.5.0
Checking strsim v0.11.1
Checking snapbox v1.2.2
Checking clap_builder v4.6.0
Compiling clap_derive v4.6.0
Checking bloomy v1.2.0
Checking scrypt v0.11.0
Compiling radicle-surf v0.27.1
Checking git-ref-format v0.6.0
Checking systemd-journal-logger v2.2.2
Checking serde_spanned v1.0.4
Checking toml_datetime v0.7.5+spec-1.1.0
Compiling tree-sitter-go v0.23.4
Compiling tree-sitter-python v0.23.6
Compiling tree-sitter-md v0.3.2
Compiling tree-sitter-css v0.23.2
Compiling tree-sitter-html v0.23.2
Compiling tree-sitter-rust v0.23.3
Compiling tree-sitter-typescript v0.23.2
Compiling tree-sitter-json v0.24.8
Compiling tree-sitter-c v0.23.4
Compiling tree-sitter-bash v0.23.3
Compiling tree-sitter-ruby v0.23.1
Compiling tree-sitter-toml-ng v0.6.0
Checking radicle-std-ext v0.2.0
Checking toml_writer v1.0.7+spec-1.1.0
Checking pin-project-lite v0.2.17
Checking tokio v1.50.0
Checking toml v0.9.12+spec-1.1.0
Checking sqlite3-sys v0.18.0
Checking sqlite v0.37.0
Checking radicle-crypto v0.17.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-crypto)
Checking clap v4.6.0
Checking sysinfo v0.37.2
Compiling radicle-node v0.20.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-node)
Checking diff v0.1.13
Checking yansi v1.0.1
Compiling radicle-cli v0.21.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-cli)
Checking human-panic v2.0.6
Checking pretty_assertions v1.4.1
Checking clap_complete v4.6.0
Checking structured-logger v1.0.5
Checking radicle-systemd v0.13.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-systemd)
Checking tree-sitter-highlight v0.24.7
Checking itertools v0.14.0
Compiling qcheck-macros v1.0.0
Checking socket2 v0.5.10
Checking humantime v2.3.0
Checking timeago v0.4.2
Checking lexopt v0.3.2
Compiling escargot v0.5.15
Checking bit-vec v0.8.0
Checking bit-set v0.8.0
Checking rand_core v0.9.5
Checking num-bigint v0.4.6
Compiling ahash v0.8.12
Checking num-complex v0.4.6
Checking env_filter v1.0.0
Checking borrow-or-share v0.2.4
Checking fluent-uri v0.3.2
Checking env_logger v0.11.9
Checking phf_shared v0.11.3
Compiling test-log-macros v0.2.19
Checking num-rational v0.4.2
Checking wait-timeout v0.2.1
Checking fnv v1.0.7
Checking quick-error v1.2.3
Compiling radicle-remote-helper v0.17.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-remote-helper)
Checking vsimd v0.8.0
Checking num v0.4.3
Checking outref v0.5.2
Checking fraction v0.15.3
Checking uuid-simd v0.8.0
Checking test-log v0.2.19
Checking rusty-fork v0.3.1
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 bytecount v0.6.9
Checking num-cmp v0.1.0
Checking unarray v0.1.4
Checking base64 v0.22.1
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 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-windows)
Checking git2 v0.20.4
Checking radicle-oid v0.2.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-oid)
Checking radicle-term v0.18.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-term)
Checking radicle-git-ext v0.12.0
Checking radicle-cob v0.20.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-cob)
Checking radicle-core v0.3.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-core)
Checking radicle-log v0.1.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-log)
Checking radicle-fetch v0.20.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-fetch)
Checking radicle-cli-test v0.13.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-cli-test)
Checking radicle-protocol v0.8.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-protocol)
Checking radicle-schemars v0.8.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-schemars)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 43.38s
+ 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 aho-corasick v1.1.4
Compiling getrandom v0.2.17
Compiling rand_core v0.6.4
Compiling jobserver v0.1.34
Compiling crypto-common v0.1.7
Compiling serde_core v1.0.228
Compiling cc v1.2.57
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 fastrand v2.3.0
Compiling bitflags v2.11.0
Compiling thiserror v2.0.18
Compiling scopeguard v1.2.0
Compiling parking_lot_core v0.9.12
Compiling tinyvec_macros v0.1.1
Compiling lock_api v0.4.14
Compiling gix-trace v0.1.19
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 same-file v1.0.6
Compiling value-bag v1.12.0
Compiling walkdir v2.5.0
Compiling log v0.4.29
Compiling zerofrom v0.1.6
Compiling prodash v31.0.0
Compiling zlib-rs v0.6.3
Compiling bstr v1.12.1
Compiling gix-validate v0.11.1
Compiling gix-path v0.12.0
Compiling yoke v0.8.1
Compiling hash32 v0.3.1
Compiling linux-raw-sys v0.12.1
Compiling zerovec v0.11.5
Compiling heapless v0.8.0
Compiling faster-hex v0.10.0
Compiling rustix v1.1.4
Compiling libm v0.2.16
Compiling block-padding v0.3.3
Compiling inout v0.1.4
Compiling num-traits v0.2.19
Compiling getrandom v0.4.2
Compiling sha1 v0.10.6
Compiling sha2 v0.10.9
Compiling sha1-checked v0.10.0
Compiling gix-features v0.48.0
Compiling cipher v0.4.4
Compiling zerocopy v0.8.42
Compiling tinystr v0.8.2
Compiling writeable v0.6.2
Compiling litemap v0.8.1
Compiling percent-encoding v2.3.2
Compiling once_cell v1.21.4
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 icu_collections v2.1.1
Compiling der v0.7.10
Compiling icu_provider v2.1.1
Compiling equivalent v1.0.2
Compiling indexmap v2.13.0
Compiling icu_normalizer_data v2.1.1
Compiling zmij v1.0.21
Compiling icu_properties_data v2.1.2
Compiling libz-sys v1.1.25
Compiling icu_properties v2.1.2
Compiling serde_json v1.0.149
Compiling icu_normalizer v2.1.1
Compiling tempfile v3.27.0
Compiling ppv-lite86 v0.2.21
Compiling spin v0.9.8
Compiling ref-cast v1.0.25
Compiling lazy_static v1.5.0
Compiling idna_adapter v1.2.1
Compiling num-integer v0.1.46
Compiling hmac v0.12.1
Compiling universal-hash v0.5.1
Compiling dyn-clone v1.0.20
Compiling opaque-debug v0.3.1
Compiling utf8_iter v1.0.4
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 sec1 v0.7.3
Compiling group v0.13.0
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 pem-rfc7468 v0.7.0
Compiling pkcs8 v0.10.2
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 aes-gcm v0.10.3
Compiling sha3 v0.10.8
Compiling curve25519-dalek v4.1.3
Compiling pkcs1 v0.7.5
Compiling ssh-encoding v0.2.0
Compiling num-bigint-dig v0.8.6
Compiling ed25519 v2.2.3
Compiling 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 p384 v0.13.1
Compiling p521 v0.13.3
Compiling p256 v0.13.2
Compiling chacha20poly1305 v0.10.1
Compiling qcheck v1.0.0
Compiling const-str v0.4.3
Compiling data-encoding v2.10.0
Compiling data-encoding-macro v0.1.19
Compiling base256emoji v1.0.2
Compiling noise-framework v0.4.1
Compiling ssh-key v0.6.7
Compiling crossbeam-utils v0.8.21
Compiling socks5-client v0.4.3
Compiling secrecy v0.10.3
Compiling base-x v0.2.11
Compiling multibase v0.9.2
Compiling ssh-agent-lib v0.6.0
Compiling cyphernet v0.5.4
Compiling crossbeam-channel v0.5.15
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 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-localtime)
Compiling radicle-git-metadata v0.2.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-git-metadata)
Compiling radicle-dag v0.10.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-dag)
Compiling colorchoice v1.0.5
Compiling is_terminal_polyfill v1.70.2
Compiling unicode-segmentation v1.12.0
Compiling anstyle v1.0.14
Compiling radicle-git-ref-format v0.1.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-git-ref-format)
Compiling gix-hashtable v0.15.0
Compiling radicle v0.24.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle)
Compiling base64 v0.21.7
Compiling convert_case v0.10.0
Compiling signal-hook-registry v1.4.8
Compiling gix-date v0.15.3
Compiling gix-actor v0.41.0
Compiling gix-object v0.60.0
Compiling tree-sitter-language v0.1.7
Compiling serde-untagged v0.1.9
Compiling bytesize v2.3.1
Compiling memmap2 v0.9.10
Compiling fast-glob v0.3.3
Compiling nonempty v0.12.0
Compiling dunce v1.0.5
Compiling signal-hook v0.3.18
Compiling derive_more-impl v2.1.1
Compiling gix-chunk v0.7.1
Compiling regex v1.12.3
Compiling mio v1.1.1
Compiling sem_safe v0.2.1
Compiling unicode-width v0.2.2
Compiling signals_receipts v0.2.5
Compiling signal-hook-mio v0.2.5
Compiling derive_more v2.1.1
Compiling gix-commitgraph v0.37.0
Compiling anstyle-parse v1.0.0
Compiling adler2 v2.0.1
Compiling gix-revwalk v0.31.0
Compiling anstream v1.0.0
Compiling crossterm v0.29.0
Compiling console v0.16.3
Compiling portable-atomic v1.13.1
Compiling gix-fs v0.21.1
Compiling unit-prefix v0.5.2
Compiling gix-tempfile v23.0.0
Compiling indicatif v0.18.4
Compiling inquire v0.9.4
Compiling radicle-signals v0.11.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-signals)
Compiling unicode-display-width v0.3.0
Compiling gix-quote v0.7.1
Compiling shell-words v1.1.1
Compiling iana-time-zone v0.1.65
Compiling either v1.15.0
Compiling chrono v0.4.44
Compiling gix-command v0.9.0
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 sqlite3-sys v0.18.0
Compiling sqlite v0.37.0
Compiling radicle-crypto v0.17.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-crypto)
Compiling gix-transport v0.57.0
Compiling anstream v0.6.21
Compiling gix-pack v0.70.0
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 anyhow v1.0.102
Compiling flate2 v1.1.9
Compiling getrandom v0.3.4
Compiling snapbox-macros v1.1.0
Compiling salsa20 v0.10.2
Compiling normalize-line-endings v0.3.0
Compiling similar v3.1.1
Compiling strsim v0.11.1
Compiling clap_lex v1.1.0
Compiling siphasher v0.3.11
Compiling streaming-iterator v0.1.9
Compiling bloomy v1.2.0
Compiling clap_builder v4.6.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-python v0.23.6
Compiling tree-sitter-typescript v0.23.2
Compiling tree-sitter-md v0.3.2
Compiling tree-sitter-ruby v0.23.1
Compiling tree-sitter-toml-ng v0.6.0
Compiling tree-sitter-go v0.23.4
Compiling tree-sitter-json v0.24.8
Compiling tree-sitter-rust v0.23.3
Compiling tree-sitter-css v0.23.2
Compiling tree-sitter-c v0.23.4
Compiling tree-sitter-bash v0.23.3
Compiling tree-sitter-html v0.23.2
Compiling radicle-std-ext v0.2.0
Compiling pin-project-lite v0.2.17
Compiling toml_writer v1.0.7+spec-1.1.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 diff v0.1.13
Compiling yansi v1.0.1
Compiling radicle-cli v0.21.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-cli)
Compiling radicle-node v0.20.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-node)
Compiling pretty_assertions v1.4.1
Compiling human-panic v2.0.6
Compiling clap_complete v4.6.0
Compiling structured-logger v1.0.5
Compiling radicle-systemd v0.13.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-systemd)
Compiling tree-sitter-highlight v0.24.7
Compiling itertools v0.14.0
Compiling socket2 v0.5.10
Compiling lexopt v0.3.2
Compiling timeago v0.4.2
Compiling humantime v2.3.0
Compiling bit-vec v0.8.0
Compiling bit-set v0.8.0
Compiling escargot v0.5.15
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 vsimd v0.8.0
Compiling outref v0.5.2
Compiling fnv v1.0.7
Compiling quick-error v1.2.3
Compiling radicle-remote-helper v0.17.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-remote-helper)
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 git2 v0.20.4
Compiling rand_xorshift v0.4.0
Compiling rand_chacha v0.9.0
Compiling fancy-regex v0.14.0
Compiling email_address v0.2.9
Compiling num-cmp v0.1.0
Compiling unarray v0.1.4
Compiling base64 v0.22.1
Compiling bytecount v0.6.9
Compiling proptest v1.10.0
Compiling jsonschema v0.30.0
Compiling emojis v0.6.4
Compiling radicle-oid v0.2.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-oid)
Compiling radicle-cob v0.20.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-cob)
Compiling radicle-core v0.3.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-core)
Compiling radicle-term v0.18.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-term)
Compiling radicle-git-ext v0.12.0
Compiling radicle-log v0.1.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-log)
Compiling radicle-windows v0.1.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-windows)
Compiling radicle-fetch v0.20.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-fetch)
Compiling radicle-protocol v0.8.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-protocol)
Compiling radicle-cli-test v0.13.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-cli-test)
Compiling radicle-schemars v0.8.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-schemars)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 57.31s
+ cargo doc --workspace --no-deps --all-features
Downloading crates ...
Downloaded rustc-hash v1.1.0
Downloaded thousands v0.2.0
Downloaded mintex v0.1.4
Downloaded dhat v0.3.3
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
Checking rsa v0.9.10
Checking bstr v1.12.1
Compiling amplify_syn v2.0.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 ssh-key v0.6.7
Checking radicle-git-ref-format v0.1.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-git-ref-format)
Checking gix-hash v0.25.0
Checking gix-date v0.15.3
Checking rusty-fork v0.3.1
Checking radicle-oid v0.2.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-oid)
Checking gix-hashtable v0.15.0
Checking gix-actor v0.41.0
Checking proptest v1.10.0
Checking gix-object v0.60.0
Checking ssh-agent-lib v0.6.0
Checking radicle-localtime v0.1.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-localtime)
Checking radicle-git-metadata v0.2.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-git-metadata)
Checking radicle-dag v0.10.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-dag)
Checking gix-chunk v0.7.1
Checking gix-fs v0.21.1
Checking gix-commitgraph v0.37.0
Checking gix-tempfile v23.0.0
Checking amplify v4.9.0
Checking gix-quote v0.7.1
Checking gix-revwalk v0.31.0
Checking regex v1.12.3
Checking inquire v0.9.4
Checking cyphergraphy v0.3.1
Checking radicle-signals v0.11.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-signals)
Checking cypheraddr v0.4.1
Checking noise-framework v0.4.1
Checking gix-command v0.9.0
Checking chrono v0.4.44
Checking gix-lock v23.0.0
Checking radicle-term v0.18.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-term)
Checking socks5-client v0.4.3
Checking gix-config-value v0.18.0
Checking cyphernet v0.5.4
Checking radicle-crypto v0.17.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-crypto)
Checking gix-url v0.36.0
Checking gix-prompt v0.15.0
Checking gix-traverse v0.57.0
Checking radicle-cob v0.20.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-cob)
Checking radicle-core v0.3.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-core)
Checking gix-revision v0.45.0
Checking gix-diff v0.63.0
Checking gix-glob v0.26.0
Checking gix-packetline v0.21.3
Checking tree-sitter v0.24.7
Checking gix-refspec v0.41.0
Checking gix-transport v0.57.0
Checking radicle v0.24.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle)
Checking gix-pack v0.70.0
Checking radicle-log v0.1.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/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
Compiling radicle-cli v0.21.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-cli)
Checking human-panic v2.0.6
Checking gix-protocol v0.61.0
Checking radicle-surf v0.27.1
Checking gix-odb v0.80.0
Checking tree-sitter-toml-ng v0.6.0
Checking tree-sitter-highlight v0.24.7
Checking rustc-hash v1.1.0
Checking mintex v0.1.4
Checking thousands v0.2.0
Compiling radicle-node v0.20.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-node)
Checking radicle-systemd v0.13.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-systemd)
Checking dhat v0.3.3
Documenting radicle-systemd v0.13.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-systemd)
Documenting radicle v0.24.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle)
Documenting radicle-log v0.1.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-log)
Documenting radicle-cob v0.20.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-cob)
Documenting radicle-core v0.3.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-core)
Documenting radicle-crypto v0.17.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-crypto)
Documenting radicle-term v0.18.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-term)
Documenting radicle-signals v0.11.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-signals)
Documenting radicle-oid v0.2.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-oid)
Documenting radicle-git-ref-format v0.1.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-git-ref-format)
Documenting radicle-localtime v0.1.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-localtime)
Documenting radicle-git-metadata v0.2.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-git-metadata)
Documenting radicle-dag v0.10.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-dag)
Documenting radicle-windows v0.1.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-windows)
Checking radicle-fetch v0.20.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-fetch)
Documenting radicle-cli v0.21.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-cli)
Documenting radicle-cli-test v0.13.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-cli-test)
Checking radicle-protocol v0.8.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-protocol)
Documenting radicle-protocol v0.8.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-protocol)
Documenting radicle-node v0.20.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-node)
Documenting radicle-fetch v0.20.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-fetch)
Documenting radicle-schemars v0.8.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-schemars)
Documenting radicle-remote-helper v0.17.0 (/1d88975e-a359-4954-80e3-b465f4d23cc1/w/crates/radicle-remote-helper)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 11.05s
Generated /1d88975e-a359-4954-80e3-b465f4d23cc1/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.20s
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::ordered_nested_object ... ok
test cob::cache::migrations::_2::tests::test_migration_2 ... ok
test canonical::formatter::test::securesystemslib_asserts ... ok
test cob::common::test::test_color ... ok
test cob::common::test::test_emojis ... ok
test cob::cache::tests::test_check_version ... ok
test cob::cache::migrations::_2::tests::test_patch_json_deserialization ... ok
test cob::cache::tests::test_migrate_to ... ok
test cob::common::test::test_title ... ok
test cob::identity::test::accepted_sibling_causes_rejection ... ok
test cob::identity::test::authorization_based_on_parent_not_current ... ok
test cob::identity::test::cannot_redact_previously_accepted_revision ... ok
test cob::identity::test::cascading_rejections ... ok
test cob::identity::test::prop_json_eq_str ... ok
test cob::identity::test::evaluates_queued_children ... ok
test cob::identity::test::evaluates_queued_children_with_new_delegate ... ok
test cob::identity::test::redact_parent_cascades ... ok
test cob::identity::test::reject_concurrent ... ok
test cob::identity::test::remove_delegate_concurrent ... FAILED
test cob::identity::test::terminal_states_concurrent ... ok
test cob::identity::test::test_identity_redact_revision ... ok
test cob::identity::test::test_identity_updates ... ok
test cob::identity::test::test_identity_update_rejected ... ok
test cob::identity::test::test_identity_cannot_redact_terminal_states ... ok
test cob::identity::test::test_valid_identity ... ok
test cob::identity::test::test_identity_updates_concurrent ... ok
test cob::issue::cache::tests::test_counts ... ok
test cob::issue::cache::tests::test_get ... ok
test cob::issue::cache::tests::test_list ... ok
test cob::issue::cache::tests::test_is_empty ... ok
test cob::issue::cache::tests::test_remove ... ok
test cob::issue::cache::tests::test_list_by_status ... 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_cob ... ok
test cob::issue::test::test_invalid_tx ... ok
test cob::issue::test::test_concurrency ... ok
test cob::issue::test::test_invalid_tx_reference ... 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_change_state ... ok
test cob::issue::test::test_issue_create_and_get ... ok
test cob::issue::test::test_issue_create_and_unassign ... ok
test cob::issue::test::test_issue_create_and_reassign ... ok
test cob::issue::test::test_issue_edit ... ok
test cob::issue::test::test_issue_edit_description ... ok
test cob::issue::test::test_issue_multilines ... ok
test cob::issue::test::test_issue_label ... ok
test cob::issue::test::test_issue_state_serde ... ok
test cob::issue::test::test_ordering ... ok
test cob::patch::actions::test::test_review_edit ... ok
test cob::issue::test::test_issue_react ... ok
test cob::issue::test::test_issue_reply ... ok
test cob::patch::cache::tests::test_get ... ok
test cob::patch::cache::tests::test_is_empty ... ok
test cob::patch::cache::tests::test_list ... ok
test cob::patch::cache::tests::test_list_by_status ... ok
test cob::patch::cache::tests::test_counts ... 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::test::test_patch_create_and_get ... ok
test cob::patch::cache::tests::test_remove ... ok
test cob::patch::test::test_patch_discussion ... 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_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_duplicate ... ok
test cob::patch::test::test_patch_review_edit ... 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_patch_review_revision_redact ... 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_update ... ok
test cob::stream::tests::test_all_from_until ... ok
test cob::stream::tests::test_all_until ... ok
test cob::stream::tests::test_from_until ... ok
test cob::stream::tests::test_regression_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 git::canonical::rules::test::canonical ... 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::rule_validate_failures ... 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 cob::thread::tests::prop_ordering ... ok
test git::canonical::tests::test_tag_quorum ... ok
test git::test::test_version_from_str ... ok
test git::test::test_version_ord ... ok
test identity::crefs::tests::invalid_clash ... ok
test identity::crefs::tests::invalid_clash_asterisk_name ... ok
test identity::crefs::tests::invalid_dangling ... ok
test identity::crefs::tests::omit_symbolic ... ok
test identity::crefs::tests::valid ... ok
test identity::crefs::tests::valid_asterisk_target ... ok
test identity::did::test::test_did_encode_decode ... ok
test identity::did::test::test_did_vectors ... ok
test identity::doc::test::default_branch_clash ... ok
test identity::doc::test::default_branch_without_project ... ok
test git::canonical::tests::test_quorum_properties ... ok
test identity::doc::test::test_canonical_doc ... ok
test identity::doc::test::test_canonical_example ... ok
test identity::doc::test::test_duplicate_dids ... ok
test identity::doc::test::test_future_version_error ... ok
test identity::doc::test::test_is_valid_version ... ok
test identity::doc::test::test_max_delegates ... 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 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_node_aliases ... 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::config::test::user_agent_custom ... ok
test node::config::test::user_agent_default ... ok
test node::config::test::user_agent_default_explicit ... ok
test node::config::test::user_agent_opt_out ... ok
test node::db::config::test::database_config_valid_combinations ... ok
test node::db::config::test::invalid ... ok
test node::db::test::migration_8::all_ipv6_formatted_dns_addresses_are_retyped ... 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::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::db::test::test_version ... ok
test node::features::test::test_operations ... ok
test node::notifications::store::test::test_branch_notifications ... ok
test node::notifications::store::test::test_clear ... ok
test node::notifications::store::test::test_cob_notifications ... ok
test node::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_alias ... ok
test node::policy::store::test::test_update_scope ... ok
test node::refs::store::test::test_count ... ok
test node::refs::store::test::test_set_and_delete ... ok
test node::refs::store::test::test_set_and_get ... ok
test node::routing::test::test_count ... ok
test node::routing::test::test_entries ... ok
test node::routing::test::test_insert_and_get ... ok
test node::routing::test::test_insert_and_get_resources ... ok
test node::routing::test::test_insert_and_remove ... ok
test node::routing::test::test_insert_duplicate ... ok
test node::routing::test::test_insert_existing_updated_time ... ok
test node::routing::test::test_len ... ok
test node::routing::test::test_prune ... ok
test node::routing::test::test_remove_many ... ok
test node::routing::test::test_remove_redundant ... ok
test node::routing::test::test_update_existing_multi ... ok
test node::sync::announce::test::all_synced_nodes_are_preferred_seeds ... ok
test node::sync::announce::test::announcer_adapts_target_to_reach ... ok
test node::sync::announce::test::announcer_preferred_seeds_or_replica_factor ... ok
test node::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_timed_out ... ok
test node::sync::announce::test::announcer_with_replication_factor_zero_and_preferred_seeds ... ok
test node::sync::announce::test::cannot_construct_announcer ... 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::invariant_progress_should_match_state ... ok
test node::sync::announce::test::local_node_in_multiple_sets ... ok
test cob::patch::cache::tests::test_find_by_revision ... 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::could_not_reach_target ... ok
test node::sync::fetch::test::all_nodes_are_fetchable ... 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::sync::fetch::test::reaches_target_of_replicas ... ok
test node::test::test_user_agent ... ok
test node::timestamp::tests::test_timestamp_max ... ok
test node::test::test_command_result ... ok
test profile::test::canonicalize_home ... ok
test profile::test::test_config ... ok
test rad::tests::test_checkout ... ok
test rad::tests::test_fork ... ok
test profile::config::test::schema ... ok
test rad::tests::test_init ... ok
test storage::git::tests::test_references_of ... ok
test storage::git::transport::local::url::test::test_url_parse ... ok
test storage::git::transport::local::url::test::test_url_to_string ... ok
test storage::git::transport::remote::url::test::test_url_parse ... ok
test storage::git::tests::test_sign_refs ... ok
test identity::doc::test::prop_encode_decode ... ok
test storage::refs::sigrefs::git::properties::idempotent_write ... ok
test storage::refs::sigrefs::git::properties::initial_commit_roundtrip ... ok
test storage::refs::sigrefs::property::idempotent ... ok
test storage::refs::sigrefs::read::test::commit_reader::identity_root_error ... ok
test storage::refs::sigrefs::read::test::commit_reader::missing_commit ... ok
test storage::refs::sigrefs::read::test::commit_reader::read_ok ... ok
test storage::refs::sigrefs::read::test::commit_reader::too_many_parents ... ok
test storage::refs::sigrefs::read::test::commit_reader::tree_error ... ok
test storage::refs::sigrefs::read::test::identity_root_reader::doc_blob_error ... ok
test storage::refs::sigrefs::read::test::identity_root_reader::missing_identity ... ok
test storage::refs::sigrefs::read::test::identity_root_reader::read_ok_none ... ok
test storage::refs::sigrefs::read::test::identity_root_reader::read_ok_some ... ok
test storage::refs::sigrefs::read::test::resolve_tip::find_reference_error ... ok
test storage::refs::sigrefs::read::test::resolve_tip::missing_sigrefs ... ok
test storage::refs::sigrefs::read::test::resolve_tip::resolve_tip_ok ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::detect_parent::root_without_parent ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::detect_parent::root_without_root ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::downgrade::parent ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::downgrade::restore ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::downgrade::root ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::downgrade::root_with_parent ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::head_commit_error ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::head_verify_mismatched_identity_error ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::head_verify_signature_error ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::invalid_parent ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::read_ok_no_parent ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::read_ok_parent ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::read_ok_root ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::replay::alternating ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::replay::chain ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::replay::multiple ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::replay::root_at_head ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::single_commit ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::two_commits ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::walk_commit_error ... ok
test storage::refs::sigrefs::read::test::signed_refs_reader::walk_verify_error ... ok
test storage::refs::sigrefs::read::test::tree_reader::missing_both ... ok
test storage::refs::sigrefs::read::test::tree_reader::missing_refs ... ok
test storage::refs::sigrefs::read::test::tree_reader::missing_signature ... ok
test storage::refs::sigrefs::read::test::tree_reader::parse_refs_error ... ok
test storage::refs::sigrefs::read::test::tree_reader::parse_signature_error ... ok
test storage::refs::sigrefs::read::test::tree_reader::read_ok ... ok
test storage::refs::sigrefs::read::test::tree_reader::read_refs_error ... ok
test storage::refs::sigrefs::read::test::tree_reader::read_signature_error ... ok
test storage::refs::sigrefs::write::test::commit_writer::tree_error ... ok
test storage::refs::sigrefs::write::test::commit_writer::write_commit_error ... ok
test storage::refs::sigrefs::write::test::commit_writer::write_empty_refs ... ok
test storage::refs::sigrefs::write::test::commit_writer::write_root_ok ... ok
test storage::refs::sigrefs::write::test::commit_writer::write_with_parent_ok ... ok
test storage::refs::sigrefs::write::test::head_reader::no_head ... ok
test storage::refs::sigrefs::write::test::head_reader::read_ok ... ok
test storage::refs::sigrefs::write::test::head_reader::reference_error ... ok
test storage::refs::sigrefs::write::test::head_reader::refs_blob_error ... ok
test storage::refs::sigrefs::write::test::head_reader::refs_blob_missing ... ok
test storage::refs::sigrefs::write::test::head_reader::refs_parse_error ... ok
test storage::refs::sigrefs::write::test::head_reader::signature_blob_error ... ok
test storage::refs::sigrefs::write::test::head_reader::signature_blob_missing ... ok
test storage::refs::sigrefs::write::test::head_reader::signature_parse_error ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::commit_error ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::head_error ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::never_write_rad_sigrefs ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::reference_error ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::unchanged ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::unchanged_force_writes_new_commit ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::write_empty_refs ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::write_root_ok ... ok
test storage::refs::sigrefs::write::test::signed_refs_writer::write_with_parent_ok ... ok
test storage::refs::sigrefs::write::test::tree_writer::sign_error ... ok
test storage::refs::sigrefs::write::test::tree_writer::write_ok ... ok
test storage::refs::sigrefs::write::test::tree_writer::write_tree_error ... ok
test storage::refs::tests::prop_canonical_roundtrip ... ok
test 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::remove_delegate_concurrent stdout ----
thread 'cob::identity::test::remove_delegate_concurrent' (17380) panicked at crates/radicle/src/cob/identity.rs:1745:9:
assertion `left == right` failed
left: [5a3c5d50c7c9dda65c79f6b1c91d2840937d58fd, dd191a7a73d76c510f4f1c3d9be0e8fa0259baaf, 65a5efe0585dc66d6d10a30f732704b34abec9c9, dd34002f40deb47ed32c8c419ca6cf19b52b424a, 60d7b6ebcda7406be757f187da9acc710a247d34]
right: [5a3c5d50c7c9dda65c79f6b1c91d2840937d58fd, dd191a7a73d76c510f4f1c3d9be0e8fa0259baaf, 65a5efe0585dc66d6d10a30f732704b34abec9c9, dd34002f40deb47ed32c8c419ca6cf19b52b424a]
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
failures:
cob::identity::test::remove_delegate_concurrent
test result: FAILED. 392 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 8.91s
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_non_urn ... ok
test commands::clone::args::test::should_parse_rid_url ... ok
test commands::clone::args::test::should_parse_rid_urn ... ok
test commands::cob::args::test::should_allow_log_json_format ... ok
test commands::cob::args::test::should_allow_log_pretty_format ... ok
test commands::cob::args::test::should_allow_show_json_format ... ok
test commands::cob::args::test::should_allow_update_json_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_show_pretty_format ... ok
test commands::cob::args::test::should_not_allow_update_pretty_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_payload ... ok
test commands::id::args::test::should_parse_into_payload ... ok
test commands::id::args::test::should_not_parse_single_payloads ... ok
test commands::id::args::test::should_parse_single_payload ... ok
test commands::id::args::test::should_parse_multiple_payloads ... ok
test commands::init::args::test::should_not_parse_rid_url ... ok
test commands::init::args::test::should_parse_rid_non_urn ... ok
test commands::init::args::test::should_parse_rid_urn ... ok
test commands::inspect::test::test_tree ... ok
test commands::patch::review::builder::tests::test_review_comments_multiline ... ok
test commands::patch::review::builder::tests::test_review_comments_before ... ok
test commands::patch::review::builder::tests::test_review_comments_split_hunk ... ok
test commands::publish::args::test::should_not_parse_rid_url ... ok
test commands::publish::args::test::should_parse_rid_non_urn ... ok
test commands::patch::review::builder::tests::test_review_comments_basic ... ok
test commands::publish::args::test::should_parse_rid_urn ... ok
test git::pretty_diff::test::test_pretty ... ignored
test git::ddiff::tests::diff_encode_decode_ddiff_hunk ... ok
test commands::watch::args::test::should_parse_ref_str ... 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_parse_rid ... ok
test terminal::args::test::should_parse_nid ... ok
test terminal::format::test::test_bytes ... ok
test terminal::patch::test::test_edit_display_message ... ok
test terminal::format::test::test_strip_comments ... ok
test terminal::args::test::should_not_parse ... ok
test terminal::patch::test::test_create_display_message ... ok
test terminal::patch::test::test_update_display_message ... ok
test result: ok. 45 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out; finished in 0.01s
Running unittests src/main.rs (target/debug/deps/rad-9617691c862a9839)
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running tests/commands.rs (target/debug/deps/commands-f88e037b1bdbeca7)
running 126 tests
test commands::checkout::rad_checkout ... ok
test commands::clone::rad_clone_bare ... ok
test commands::clone::rad_clone ... ok
test commands::clone::rad_clone_all ... ok
test commands::clone::rad_clone_scope ... ok
test commands::clone::rad_clone_connect ... ok
test commands::clone::rad_clone_directory ... ok
test commands::clone::rad_clone_unknown ... ok
test commands::clone::rad_clone_partial_fail ... ok
test commands::cob::rad_cob_multiset ... ok
test commands::clone::test_clone_without_seeds ... ok
test commands::cob::rad_cob_log ... ok
test commands::cob::rad_cob_migrate ... ok
test commands::cob::rad_cob_operations ... ok
test commands::cob::rad_cob_show ... ok
test commands::cob::rad_cob_update_identity ... ok
test commands::cob::test_cob_deletion ... ok
test commands::cob::rad_cob_update ... 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_unknown_field ... ok
test commands::id::rad_id_threshold ... 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_no_git ... ok
test commands::init::rad_init_existing ... ok
test commands::init::rad_init_existing_bare ... ok
test commands::init::rad_init_no_seed ... ok
test commands::init::rad_init_private ... ok
test commands::init::rad_init_private_no_seed ... ok
test commands::init::rad_init_private_clone ... ok
test commands::inbox::rad_inbox ... ok
test commands::init::rad_init_private_clone_seed ... ok
test commands::init::rad_init_private_seed ... ok
test commands::init::rad_init_sync_not_connected ... ok
test commands::init::rad_init_sync_preferred ... ok
test commands::init::rad_init_with_existing_remote ... ok
test commands::init::rad_publish ... ok
test commands::issue::rad_issue ... ok
test commands::jj::rad_jj_bare ... ignored, the bare repository does not have a `rad` remote, and so it cannot determine the RID of the repository
test commands::jj::rad_jj_colocated_patch ... ok
test commands::issue::rad_issue_list ... ok
test commands::node::rad_node_connect ... ok
test commands::node::rad_node_connect_without_address ... ok
test commands::patch::rad_merge_after_update ... ok
test commands::node::rad_node ... ok
test commands::patch::rad_merge_no_ff ... ok
test commands::patch::rad_merge_via_push ... ok
test commands::patch::rad_patch ... ok
test commands::patch::rad_patch_ahead_behind ... ok
test commands::patch::rad_patch_change_base ... ok
test commands::patch::rad_patch_checkout ... ok
test commands::init::rad_init_sync_timeout ... ok
test commands::init::rad_init_sync_and_clone ... ok
test commands::patch::rad_patch_checkout_revision ... ok
test commands::patch::rad_patch_detached_head ... ok
test commands::patch::rad_patch_checkout_force ... ok
test commands::patch::rad_patch_draft ... ok
test commands::patch::rad_patch_diff ... ok
test commands::patch::rad_patch_edit ... ok
test commands::patch::rad_patch_fetch_2 ... ok
test commands::patch::rad_patch_merge_draft ... ok
test commands::patch::rad_patch_fetch_1 ... ok
test commands::patch::rad_patch_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::policy::rad_block ... ok
test commands::patch::rad_review_by_hunk ... 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::sync::rad_fetch ... ok
test commands::watch::rad_watch ... 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.30s
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.00s
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::git::list_cobs ... ok
test tests::invalid_parse_refstr ... ok
test type_name::test::invalid_typenames ... ok
test tests::git::update_cob ... ok
test tests::git::traverse_cobs ... ok
test tests::parse_refstr ... ok
test type_name::test::valid_typenames ... 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::fmt::test::test_key ... ok
test ssh::agent::test::test_agent_encoding_sign ... ok
test ssh::agent::test::test_agent_encoding_remove ... ok
test ssh::fmt::test::test_fingerprint ... ok
test ssh::keystore::tests::test_init_no_passphrase ... ok
test tests::prop_encode_decode ... ok
test tests::test_e25519_dh ... ok
test tests::test_encode_decode ... ok
test tests::prop_key_equality ... ok
test ssh::keystore::tests::test_signer ... ok
test ssh::keystore::tests::test_init_passphrase ... ok
test result: ok. 11 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.82s
Running unittests src/lib.rs (target/debug/deps/radicle_dag-e10cdde88570a8e0)
running 20 tests
test tests::test_dependencies ... ok
test tests::test_contains ... ok
test tests::test_diamond ... ok
test tests::test_cycle ... ok
test tests::test_fold_diamond ... ok
test tests::test_fold_multiple_roots ... ok
test tests::test_fold_reject ... ok
test tests::test_fold_sorting_1 ... 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_complex ... ok
test tests::test_merge_1 ... ok
test tests::test_merge_2 ... ok
test tests::test_prune_1 ... ok
test tests::test_prune_2 ... ok
test tests::test_remove ... ok
test tests::test_prune_by_sorting ... ok
test tests::test_siblings ... ok
test result: ok. 20 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/lib.rs (target/debug/deps/radicle_fetch-92b111a684cd2a9a)
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/lib.rs (target/debug/deps/radicle_git_metadata-41b02b9ef3e2236d)
running 24 tests
test commit::parse::test::error::invalid_author ... ok
test commit::parse::test::error::invalid_committer ... ok
test commit::parse::test::error::invalid_format_continuation_without_preceding_header ... ok
test commit::parse::test::error::invalid_parent ... ok
test commit::parse::test::error::invalid_tree ... ok
test commit::parse::test::error::missing_author ... ok
test commit::parse::test::error::missing_committer ... ok
test commit::parse::test::error::missing_header_body_separator ... ok
test commit::parse::test::error::missing_tree_empty_header ... ok
test commit::parse::test::error::missing_tree_wrong_first_line ... ok
test commit::parse::test::success::commit_gpgsig_is_preserved_and_strip_removes_it ... ok
test commit::parse::test::success::commit_last_paragraph_kept_in_message_when_not_all_trailers ... ok
test commit::parse::test::success::commit_with_extra_headers ... ok
test commit::parse::test::success::commit_with_multiline_gpgsig ... ok
test commit::parse::test::success::commit_with_single_parent ... ok
test commit::parse::test::success::commit_with_trailers ... ok
test commit::parse::test::success::merge_commit ... ok
test commit::parse::test::success::root_commit ... ok
test commit::parse::test::success::roundtrip ... ok
test commit::parse::test::unit::body_last_paragraph_not_trailers_stays_in_message ... ok
test commit::parse::test::unit::body_no_paragraph_separator_means_no_trailers ... ok
test commit::parse::test::unit::trailers_accepts_empty_input ... ok
test commit::parse::test::unit::trailers_rejects_invalid_token_chars ... ok
test commit::parse::test::unit::trailers_rejects_line_without_separator ... ok
test result: ok. 24 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Running unittests src/lib.rs (target/debug/deps/radicle_git_ref_format-2868a65b3ff2c590)
running 9 tests
test test::pattern ... ok
test test::component ... ok
test test::component_invalid - should panic ... ok
test test::qualified ... ok
test test::qualified_invalid - should panic ... 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 reactor::timer::tests::test_next ... ok
test reactor::timer::tests::test_wake ... ok
test reactor::timer::tests::test_wake_exact ... ok
test control::tests::test_control_socket ... ok
test control::tests::test_seed_unseed ... ok
test fingerprint::tests::matching ... ok
test tests::e2e::missing_default_branch ... ok
test tests::e2e::fetch_does_not_contain_rad_sigrefs_parent ... 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_clone ... ok
test tests::e2e::test_catchup_on_refs_announcements ... ok
test tests::e2e::test_connection_crossing ... ok
test tests::e2e::test_dont_fetch_owned_refs ... ok
test tests::e2e::test_fetch_emits_canonical_ref_update_partial_glob ... ok
test tests::e2e::test_fetch_followed_remotes ... ok
test tests::e2e::test_fetch_preserve_owned_refs ... ok
test tests::e2e::test_concurrent_fetches ... ok
test tests::e2e::test_fetch_unseeded ... ok
test tests::e2e::test_fetch_up_to_date ... ok
test tests::e2e::test_inventory_sync_basic ... 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_inventory_sync_bridge ... ok
test tests::e2e::test_replication ... ok
test tests::e2e::test_inventory_sync_ring ... ok
test tests::e2e::test_replication_invalid ... ok
test tests::e2e::test_inventory_sync_star ... ok
test tests::e2e::test_replication_ref_in_sigrefs ... ok
test tests::test_announcement_rebroadcast ... ok
test tests::test_announcement_rebroadcast_duplicates ... ok
test tests::test_announcement_rebroadcast_timestamp_filtered ... ok
test tests::test_announcement_relay ... ok
test tests::test_connection_kept_alive ... ok
test tests::test_disconnecting_unresponsive_peer ... ok
test tests::test_fetch_missing_inventory_on_gossip ... ok
test tests::test_fetch_missing_inventory_on_schedule ... ok
test tests::test_inbound_connection ... ok
test tests::test_inventory_decode ... ok
test tests::test_init_and_seed ... ok
test tests::test_inventory_relay ... ok
test tests::test_inventory_relay_bad_timestamp ... ok
test tests::test_inventory_sync ... ok
test tests::test_maintain_connections ... ok
test tests::test_maintain_connections_failed_attempt ... ok
test tests::test_maintain_connections_same_second_loop ... ok
test tests::test_maintain_connections_transient ... ok
test tests::test_inventory_pruning ... ok
test tests::test_outbound_connection ... ok
test tests::test_persistent_peer_connect ... ok
test tests::test_persistent_peer_reconnect_attempt ... ok
test tests::test_persistent_peer_reconnect_success ... ok
test tests::test_ping_response ... ok
test tests::test_queued_fetch_from_ann_same_rid ... ok
test tests::test_queued_fetch_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::prop_inventory_exchange_dense ... ok
test tests::test_refs_announcement_relay_private ... ok
test tests::test_refs_announcement_relay_public ... ok
test tests::test_seed_repo_subscribe ... ok
test wire::test::test_inventory_ann_with_extension ... ok
test wire::test::test_pong_message_with_extension ... ok
test tests::test_seeding ... ok
test tests::test_announcement_message_amplification ... 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.15s
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::fixture ... ok
test fmt::test::git2 ... ok
test fmt::test::gix ... ok
test fmt::test::zero ... ok
test git2::test::zero ... ok
test gix::test::zero ... ok
test str::test::fixture ... 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 fetcher::service::tests::test_fetch_coalescing_different_refs ... ok
test deserializer::test::prop_decode_next ... ok
test deserializer::test::test_unparsed ... ok
test fetcher::test::queue::properties::capacity::restored_after_dequeue ... ok
test fetcher::test::queue::properties::capacity::bounded ... ok
test fetcher::test::queue::properties::dequeue::empty_queue_returns_none ... ok
test fetcher::test::queue::properties::dequeue::enables_reenqueue ... ok
test fetcher::test::queue::properties::capacity::rejection ... ok
test fetcher::test::queue::properties::dequeue::drained_queue_returns_none ... ok
test fetcher::test::queue::properties::capacity::capacity_reached_returns_same_item ... ok
test fetcher::test::queue::properties::fifo::interleaved_operations ... ok
test fetcher::test::queue::properties::equality::reflexive ... ok
test fetcher::test::queue::properties::fifo::ordering ... 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::equality::transitive ... ok
test fetcher::test::queue::properties::merge::does_not_increase_queue_length ... 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::queue::properties::merge::empty_refs_fetches_all ... 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::cancel::ongoing_and_queued ... ok
test fetcher::test::state::command::fetch::fetch_at_capacity_enqueues ... ok
test fetcher::test::state::command::fetch::fetch_different_repo_same_node_within_capacity ... ok
test fetcher::test::state::command::fetch::fetch_duplicate_returns_already_fetching ... ok
test fetcher::test::state::command::fetch::fetch_queue_merge_takes_longer_timeout ... ok
test fetcher::test::state::command::fetch::fetch_queue_merge_empty_refs_fetches_all ... ok
test fetcher::test::state::command::fetch::fetch_queue_merges_already_queued ... ok
test fetcher::test::state::command::fetch::fetch_queue_rejected_capacity_reached ... ok
test fetcher::test::state::command::fetch::fetch_same_repo_different_nodes_queues_second ... ok
test fetcher::test::state::command::fetch::fetch_start_first_fetch_for_node ... ok
test fetcher::test::state::command::fetch::fetch_same_repo_different_refs_enqueues ... ok
test fetcher::test::state::command::fetched::complete_single_ongoing ... ok
test fetcher::test::state::command::fetched::complete_one_of_multiple ... ok
test fetcher::test::state::command::fetched::complete_then_dequeue_fifo ... ok
test fetcher::test::state::command::fetched::non_existent_returns_not_found ... ok
test fetcher::test::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::queue::properties::merge::succeed_when_at_capacity ... ok
test fetcher::test::state::invariant::queue_integrity_after_merge ... ok
test fetcher::test::state::multinode::independent_queues ... ok
test service::filter::test::compatible ... ok
test service::filter::test::test_parameters ... ok
test service::filter::test::test_sizes ... ok
test service::gossip::store::test::test_announced ... ok
test service::limiter::test::test_limiter_different_rates ... ok
test service::limiter::test::test_limiter_multi ... ok
test service::limiter::test::test_limiter_refill ... ok
test fetcher::test::state::config::high_concurrency ... ok
test service::message::tests::test_inventory_limit ... ok
test fetcher::test::queue::properties::merge::same_rid_merges_anywhere_in_queue ... ok
test service::message::tests::test_ref_remote_limit ... ok
test wire::frame::test::test_encode_git_large ... ok
test wire::frame::test::test_stream_id ... ok
test fetcher::test::state::multinode::high_count ... ok
test wire::message::tests::prop_roundtrip_address ... ok
test service::message::tests::prop_refs_announcement_signing ... ok
test wire::message::tests::prop_zero_bytes_encode_decode ... ok
test wire::message::tests::test_inv_ann_max_size ... ok
test wire::message::tests::test_node_ann_max_size ... ok
test wire::message::tests::test_ping_encode_size_overflow - should panic ... ok
test wire::message::tests::test_pingpong_encode_max_size ... ok
test wire::message::tests::test_pong_encode_size_overflow - should panic ... ok
test service::message::tests::test_node_announcement_validate ... ok
test wire::tests::prop_oid ... ok
test wire::message::tests::prop_roundtrip_message ... ok
test wire::tests::prop_roundtrip_filter ... 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.93s
Running unittests src/main.rs (target/debug/deps/git_remote_rad-ec460ed6e139fb1e)
running 12 tests
test protocol::tests::test_fetch ... ok
test protocol::tests::test_fetch_whitespace ... ok
test protocol::tests::test_empty ... ok
test protocol::tests::test_invalid ... ok
test protocol::tests::test_list ... ok
test protocol::tests::test_option_whitespace_preservation ... ok
test protocol::tests::test_option ... ok
test protocol::tests::test_list_for_push ... ok
test protocol::tests::test_capabilities ... ok
test protocol::tests::test_push ... ok
test protocol::tests::test_push_force ... 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 cell::test::test_width ... ok
test ansi::tests::colors_disabled ... ok
test ansi::tests::colors_enabled ... ok
test element::test::test_spaced ... ok
test ansi::tests::wrapping ... ok
test element::test::test_width ... ok
test table::test::test_table ... ok
test table::test::test_table_border ... ok
test table::test::test_table_border_maximized ... ok
test table::test::test_table_border_truncated ... ok
test table::test::test_table_truncate ... ok
test table::test::test_truncate ... ok
test element::test::test_truncate ... ok
test table::test::test_table_unicode_truncate ... ok
test table::test::test_table_unicode ... ok
test textarea::test::test_wrapping ... ok
test textarea::test::test_wrapping_fenced_block ... ok
test vstack::test::test_vstack ... ok
test textarea::test::test_wrapping_code_block ... ok
test vstack::test::test_vstack_maximize ... 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.08s; merged doctests compilation took 0.08s
Doc-tests radicle_core
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_crypto
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_dag
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_fetch
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_git_metadata
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_git_ref_format
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_localtime
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_log
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_node
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_oid
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_protocol
running 6 tests
test crates/radicle-protocol/src/bounded.rs - bounded::BoundedVec<T,N>::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>::push (line 122) ... ok
test crates/radicle-protocol/src/bounded.rs - bounded::BoundedVec<T,N>::unbound (line 149) ... ok
test crates/radicle-protocol/src/bounded.rs - bounded::BoundedVec<T,N>::with_capacity (line 66) ... ok
test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
all doctests ran in 0.43s; merged doctests compilation took 0.41s
Doc-tests radicle_signals
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_systemd
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests radicle_term
running 1 test
test crates/radicle-term/src/table.rs - table (line 4) ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
all doctests ran in 0.19s; merged doctests compilation took 0.18s
Doc-tests radicle_windows
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: 1 target failed:
`-p radicle --lib`
Exit code: 101
{
"response": "finished",
"result": "failure"
}