resolver = "2"

[workspace.package]

homepage = "https://radicle.xyz"

license = "MIT OR Apache-2.0"

repository = "https://app.radicle.xyz/seeds/seed.radicle.xyz/rad:z3gqcJUoA1n9HaHKufZs5FCSGazv5"

        exe

    }

        match self.exe().into_string() {

            Ok(exe) => exe,

            Err(exe) => format!("{exe:?}"),

    #[test]

    fn roundtrip() {

        let storage = test::Storage::new();

        let terry = test::Person::new(&storage, "terry", *signer.public_key()).unwrap();

        let proj = test::Project::new(&storage, "discworld", *signer.public_key()).unwrap();

        let proj = test::RemoteProject {

    #[test]

    fn list_cobs() {

        let storage = test::Storage::new();

        let terry = test::Person::new(&storage, "terry", *signer.public_key()).unwrap();

        let proj = test::Project::new(&storage, "discworld", *signer.public_key()).unwrap();

        let proj = test::RemoteProject {

    #[test]

    fn update_cob() {

        let storage = test::Storage::new();

        let terry = test::Person::new(&storage, "terry", *signer.public_key()).unwrap();

        let proj = test::Project::new(&storage, "discworld", *signer.public_key()).unwrap();

        let proj = test::RemoteProject {

    #[test]

    fn traverse_cobs() {

        let storage = test::Storage::new();

        let neil = test::Person::new(&storage, "gaiman", *neil_signer.public_key()).unwrap();

        let terry = test::Person::new(&storage, "pratchett", *terry_signer.public_key()).unwrap();

        let proj = test::Project::new(&storage, "discworld", *terry_signer.public_key()).unwrap();

        let terry_proj = test::RemoteProject {

        Ok(())

    }

    }

}

    where

        Self: Sized,

    {

        let pk = ms.public;

        (ms, pk)

    }

    /// Generate a new memory signer.

        let keypair = KeyPair::generate();

        let sk = keypair.sk;

    fn test_seed_unseed() {

        let tmp = tempfile::tempdir().unwrap();

        let socket = tmp.path().join("node.sock");

        let listener = UnixListener::bind(&socket).unwrap();

        let mut handle = Node::new(&socket);

    #[cfg(all(feature = "systemd", target_os = "linux"))]

    fn receive_listener() -> Option<UnixListener> {

            Ok(Some(fd)) => fd,

            Ok(None) => return None,

            Err(err) => {

use radicle::node;

use radicle::node::device::Device;

use radicle::node::UserAgent;

use crate::test::arbitrary;

use crate::{

                version: PROTOCOL_VERSION,

                features: node::Features::SEED,

                timestamp: time.into(),

                addresses: None.into(),

                nonce: 0,

                agent: UserAgent::from_str("/radicle:test/").unwrap(),

    }

    /// Drain outgoing messages sent from this peer to the remote peer.

        let mut msgs = Vec::new();

        Service::outbox(&mut self.service)

                                    canonical: fetch::UpdatedCanonicalRefs::default(),

                                    namespaces: HashSet::new(),

                                    clone: true,

                                })),

                            ),

                        },

use radicle::node::{ConnectOptions, DEFAULT_TIMEOUT};

use radicle::storage::refs::RefsAt;

use radicle::storage::RefUpdate;

use radicle::test::storage::MockRepository;

use radicle_protocol::bounded::BoundedVec;

#[test]

fn test_inventory_decode() {

    let timestamp: Timestamp = LocalTime::now().into();

    let mut buf = Vec::new();

#[test]

fn test_seeding() {

    let mut alice = Peer::new("alice", [7, 7, 7, 7]);

    let (cmd, receiver) = Command::seed(proj_id, policy::Scope::default());

    alice.command(cmd);

        .elapse(service::GOSSIP_INTERVAL);

    // Pretend Alice cloned Bob's repos.

    for (i, mut repo) in repos.into_iter().enumerate() {

        repo.doc.doc = repo

            .doc

    // The first repo is not visible to Eve.

    let repo1 = {

        repo.doc.doc = repo

            .doc

            .doc

    // The second repo is visible to Eve.

    let repo2 = {

        repo.doc.doc = repo

            .doc

            .doc

    let mut alice = Peer::with_storage("alice", [7, 7, 7, 7], storage);

    let bob = Peer::new("bob", [8, 8, 8, 8]);

    let eve = Peer::new("eve", [9, 9, 9, 9]);

    alice.seed(&id, policy::Scope::All).unwrap();

    alice.connect_to(&bob);

fn test_seed_repo_subscribe() {

    let mut alice = Peer::new("alice", [7, 7, 7, 7]);

    let bob = Peer::new("bob", [8, 8, 8, 8]);

    alice.connect_to(&bob);

    let (cmd, recv) = Command::seed(rid, policy::Scope::default());

#[test]

fn test_fetch_missing_inventory_on_gossip() {

    let mut alice = Peer::new("alice", [7, 7, 7, 7]);

    let bob = Peer::new("bob", [8, 8, 8, 8]);

    let now = LocalTime::now();

#[test]

fn test_fetch_missing_inventory_on_schedule() {

    let mut alice = Peer::new("alice", [7, 7, 7, 7]);

    let bob = Peer::new("bob", [8, 8, 8, 8]);

    let now = LocalTime::now();

            canonical: fetch::UpdatedCanonicalRefs::default(),

            namespaces: [carol.id()].into_iter().collect(),

            clone: false,

        }),

    );

    // Now the 1st fetch is done, but the 2nd and 3rd fetches are redundant.

    alice.elapse(KEEP_ALIVE_DELTA);

    // Finish the 1st fetch.

    // Now the 1st fetch is done, the 2nd fetch is dequeued.

    let (rid, nid) = alice.fetches().next().unwrap();

    assert_eq!(rid, rid1);

    assert_matches!(alice.fetches().next(), None);

    // Finish the 2nd fetch.

    // Now the 2nd fetch is done, the 3rd fetch is dequeued.

    assert_matches!(alice.fetches().next(), Some((rid, nid)) if rid == rid1 && peers.remove(&nid));

    // All fetches were initiated.

        }

    }

    qcheck::QuickCheck::new()

        .tests(20)

        .quickcheck(property as fn(MockStorage, MockStorage, MockStorage));

}

                failure_rate: 0.,

            },

        );

        // Make sure the node gossip intervals are not accidentally synchronized.

        alice.elapse(LocalDuration::from_millis(

        alice

            .storage_mut()

            .repos

        let (cmd, _) = Command::add_inventory(rid);

        alice.command(cmd);

            }

        }

        // Message with extension.

        let mut stream = Vec::new();

        .extra

        .iter()

        .find_map(|kv| match kv {

                let version = match v.as_str() {

                    "2" => 2,

                    "1" => 1,

    /// See also [`::git2::Oid::is_zero`].

    pub fn is_zero(&self) -> bool {

        match self {

        }

    }

}

impl AsRef<[u8]> for Oid {

    fn as_ref(&self) -> &[u8] {

        match self {

        }

    }

}

        debug_assert!(len <= N);

    }

    fn chunk_mut(&mut self) -> &mut bytes::buf::UninitSlice {

    }

    unsafe fn advance_mut(&mut self, cnt: usize) {

    }

    fn chunk_mut(&mut self) -> &mut bytes::buf::UninitSlice {

            .with_max_concurrency(NonZeroUsize::new(1).unwrap())

            .with_max_capacity(MaxQueueSize::new(NonZeroUsize::new(10).unwrap()));

        let mut service = FetcherService::<usize>::new(config);

        let refs_specific: Vec<RefsAt> = arbitrary::vec(2);

        let refs_all = vec![];

        let config = FetchConfig::default();

pub fn create_fetch() -> QueuedFetch {

    QueuedFetch {

        refs: RefsToFetch::All,

        config: FetchConfig::default(),

    }

    let target_index = merge_index % items.len();

    let same_rid_item = QueuedFetch {

        rid: items[target_index].rid,

        config: FetchConfig::default(),

    };

    let mut queue = create_queue(10);

    let config = FetchConfig::default();

    let base_item = QueuedFetch {

        rid,

#[quickcheck]

fn empty_refs_fetches_all() -> bool {

    let mut queue = create_queue(10);

    let config = FetchConfig::default();

    // First enqueue with specific refs

    let item_with_refs = QueuedFetch {

        rid,

        config,

    };

    let long = Duration::from_secs(short_secs.max(long_secs) as u64);

    let config = FetchConfig::default();

    let mut queue = create_queue(10);

    let item_short = QueuedFetch {

        rid,

#[quickcheck]

fn does_not_increase_queue_length() -> bool {

    let mut queue = create_queue(10);

    let config = FetchConfig::default();

    let item1 = QueuedFetch {

        rid,

        config: config.with_timeout(Duration::from_secs(30)),

    };

    let item2 = QueuedFetch {

        rid,

        config: config.with_timeout(Duration::from_secs(60)),

    };

    // Item with different rid should be queued (not merged)

    let different_rid = QueuedFetch {

        ..base_item

    };

fn succeed_when_at_capacity() -> bool {

    // When queue is at capacity, merging with existing item should still work

    let mut queue = create_queue(2);

    let config = FetchConfig::default();

    let item1 = QueuedFetch {

    };

    let item2 = QueuedFetch {

        refs: RefsToFetch::All,

        config: config.with_timeout(Duration::from_secs(30)),

    };

    let merge_item = QueuedFetch {

        rid, // Same as item1

        config: config.with_timeout(Duration::from_secs(60)),

    };

    let mut queue = create_queue(10);

    let config = FetchConfig::default().with_timeout(Duration::ZERO);

    let item = QueuedFetch {

        refs: RefsToFetch::All,

        config,

    };

    let mut queue = create_queue(10);

    let config = FetchConfig::default().with_timeout(Duration::MAX);

    let item = QueuedFetch {

        refs: RefsToFetch::All,

        config,

    };

#[test]

fn empty_refs_items_can_be_equal() {

    let config = FetchConfig::default();

    let item1 = QueuedFetch {

fn merge_preserves_position_in_queue() {

    let mut queue = create_queue(10);

    let config = FetchConfig::default();

    // Enqueue three items

    // Merge into the second item

    let result = queue.enqueue(QueuedFetch {

        rid: rid_second,

        config: config.with_timeout(Duration::from_secs(60)),

    });

    assert_eq!(result, Enqueue::Merged);

#[test]

fn single_ongoing() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let refs_1 = helpers::gen_refs(1);

    let config = FetchConfig::default();

#[test]

fn ongoing_and_queued() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let config = FetchConfig::default();

    state.fetch(command::Fetch {

#[test]

fn non_existent_returns_unexpected() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let event = state.cancel(command::Cancel { from: node_unknown });

#[test]

fn cancellation_is_isolated() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let config = FetchConfig::default();

    state.fetch(command::Fetch {

#[test]

fn fetch_start_first_fetch_for_node() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let refs_1 = helpers::gen_refs(2);

    let config = FetchConfig::default();

#[test]

fn fetch_different_repo_same_node_within_capacity() {

    let mut state = FetcherState::new(helpers::config(2, 10));

    let config = FetchConfig::default();

    let event1 = state.fetch(command::Fetch {

#[test]

fn fetch_same_repo_different_nodes_queues_second() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let refs_1 = helpers::gen_refs(1);

    let config = FetchConfig::default();

#[test]

fn fetch_duplicate_returns_already_fetching() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let refs_1 = helpers::gen_refs(2);

    let config = FetchConfig::default();

#[test]

fn fetch_same_repo_different_refs_enqueues() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let refs_1 = helpers::gen_refs(1);

    let refs_2 = helpers::gen_refs(2);

    let config = FetchConfig::default();

#[test]

fn fetch_at_capacity_enqueues() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let config = FetchConfig::default();

    state.fetch(command::Fetch {

#[test]

fn fetch_queue_rejected_capacity_reached() {

    let mut state = FetcherState::new(helpers::config(1, 2));

    let config = FetchConfig::default();

    // Fill concurrency

#[test]

fn fetch_queue_merges_already_queued() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let refs_2a = helpers::gen_refs(1);

    let refs_2b = helpers::gen_refs(1);

    let config = FetchConfig::default();

#[test]

fn fetch_queue_merge_empty_refs_fetches_all() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let refs_2 = helpers::gen_refs(2);

    let config = FetchConfig::default();

#[test]

fn fetch_queue_merge_takes_longer_timeout() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let short_timeout = Duration::from_secs(10);

    let long_timeout = Duration::from_secs(60);

    let config = FetchConfig::default();

#[test]

fn fetch_after_previous_completed() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let refs_1 = helpers::gen_refs(1);

    let config = FetchConfig::default();

#[test]

fn complete_single_ongoing() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let refs_1 = helpers::gen_refs(2);

    let config = FetchConfig::default();

#[test]

fn complete_then_dequeue_fifo() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let refs_2 = helpers::gen_refs(1);

    let config = FetchConfig::default();

#[test]

fn complete_one_of_multiple() {

    let mut state = FetcherState::new(helpers::config(3, 10));

    let config = FetchConfig::default();

    state.fetch(command::Fetch {

#[test]

fn non_existent_returns_not_found() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let event = state.fetched(command::Fetched {

        from: node_a,

#[test]

fn interleaved_operations() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let config = FetchConfig::default();

    // fetch(A, r1)

#[test]

fn fetched_then_cancel() {

    let mut state = FetcherState::new(helpers::config(2, 10));

    let config = FetchConfig::default();

    state.fetch(command::Fetch {

#[test]

fn high_concurrency() {

    let mut state = FetcherState::new(helpers::config(100, 10));

    let config = FetchConfig::default();

    for i in 0..100 {

        let event = state.fetch(command::Fetch {

            from: node_a,

            rid: repo,

#[test]

fn min_queue_size() {

    let mut state = FetcherState::new(helpers::config(1, 1));

    let config = FetchConfig::default();

    state.fetch(command::Fetch {

#[test]

fn cannot_dequeue_while_node_at_capacity() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let refs_2 = helpers::gen_refs(3);

    let timeout_2 = Duration::from_secs(42);

#[test]

fn maintains_fifo_order() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let config = FetchConfig::default();

    state.fetch(command::Fetch {

#[test]

fn empty_queue_returns_none() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    assert!(state.dequeue(&node_a).is_none());

}

}

pub fn gen_refs(count: usize) -> RefsToFetch {

    refs.into()

}

#[test]

fn queue_integrity_after_merge() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let refs_2a = helpers::gen_refs(1);

    let refs_2b = helpers::gen_refs(1);

    let config = FetchConfig::default();

#[test]

fn independent_queues() {

    let mut state = FetcherState::new(helpers::config(1, 10));

    let fetch_config = FetchConfig::default();

    // Fill capacity for both nodes

    let config = FetchConfig::default();

    for i in 0..100 {

        let event = state.fetch(command::Fetch {

            from: node,

            rid: repo,

    #[test]

    fn test_announced() {

        let mut db = Database::memory().unwrap();

        let timestamp = LocalTime::now().into();

        let signer = Device::mock();

        let refs = AnnouncementMessage::Refs(RefsAnnouncement {

        let mut r = RateLimiter::default();

        let t = (3, 0.2); // Three tokens burst. One token every 5 seconds.

        let a = HostName::Dns(String::from("seed.radicle.example.com"));

        let n = Some(&n);

        assert_eq!(r.limit(a.clone(), n, &t, LocalTime::from_secs(0)), false); // Burst capacity

    #[rustfmt::skip]

    fn test_limiter_multi() {

        let t = (1, 1.0); // One token per second. One token burst.

        let n = Some(&n);

        let mut r = RateLimiter::default();

        let addr1 = HostName::Dns(String::from("seed.radicle.example.com"));

    fn test_limiter_different_rates() {

        let t1 = (1, 1.0); // One token per second. One token burst.

        let t2 = (2, 2.0); // Two tokens per second. Two token burst.

        let n = Some(&n);

        let mut r = RateLimiter::default();

        let addr1 = HostName::Dns(String::from("seed.radicle.example.com"));

        .expect("proof-of-work output vector is a valid length");

        // Calculate the number of leading zero bits in the output vector.

            zero_bytes as u32 * 8 + non_zero.leading_zeros()

        } else {

            output.len() as u32 * 8

        }

        let msg: Message = AnnouncementMessage::from(RefsAnnouncement {

            refs,

            timestamp: LocalTime::now().into(),

        })

    #[test]

    fn test_refs_ann_max_size() {

        let signer = Device::mock();

        let ann = AnnouncementMessage::Refs(RefsAnnouncement {

            refs: BoundedVec::collect_from(&mut refs.into_iter()),

        });

        let ann = ann.signed(&signer);

        let msg = Message::Announcement(ann);

    #[test]

    fn test_inv_ann_max_size() {

        let signer = Device::mock();

        let ann = AnnouncementMessage::Inventory(InventoryAnnouncement {

            inventory: BoundedVec::collect_from(&mut inv.into_iter()),

        });

        let ann = ann.signed(&signer);

        let msg = Message::Announcement(ann);

    #[test]

    fn test_node_ann_max_size() {

        let signer = Device::mock();

        let alias = ['@'; radicle::node::MAX_ALIAS_LENGTH];

        let ann = AnnouncementMessage::Node(NodeAnnouncement {

            version: 1,

            features: Default::default(),

            alias: radicle::node::Alias::new(String::from_iter(alias)),

            addresses: BoundedVec::collect_from(&mut addrs.into_iter()),

            nonce: u64::MAX,

            agent: UserAgent::default(),

        });

        }

        qcheck::QuickCheck::new()

            .quickcheck(property as fn(items: Vec<Message>));

    }

///  - <https://github.com/systemd/systemd/blob/v254/src/libsystemd/sd-daemon/sd-daemon.c>

///  - <https://0pointer.de/blog/projects/socket-activation.html>

///  - <https://0pointer.de/blog/projects/socket-activation2.html>

        Err(VarError::NotPresent) => Ok(None),

        Err(err) => Err(err),

        Ok(pid) if pid != id().to_string() => Ok(None),

        _ if var(LISTEN_FDS)? != "1" || var(LISTEN_FDNAMES).ok() != Some(name.to_string()) => {

            Ok(None)

        }

}

#[macro_export]

macro_rules! info {

        writeln!($writer, $($arg)*).ok();

    });

    ($($arg:tt)*) => ({

#[macro_export]

macro_rules! success {

    // Pattern when a writer is provided.

        $crate::io::success_args($writer, format_args!($($arg)*));

    });

    // Pattern without writer.

#[macro_export]

macro_rules! notice {

    // Pattern when a writer is provided.

        $crate::io::notice_args($writer, format_args!($($arg)*));

    });

    ($($arg:tt)*) => ({

    }

    /// Get the lines of text in this text area.

        let mut lines: Vec<String> = Vec::new();

        let mut fenced = false;

        let test::setup::NodeWithRepo { node, repo, .. } = test::setup::NodeWithRepo::default();

        let mut issues = Cache::no_cache(&*repo).unwrap();

        let issue = issues

            .create(

                cob::Title::new("My first issue").unwrap(),

        let test::setup::NodeWithRepo { node, repo, .. } = test::setup::NodeWithRepo::default();

        let mut issues = Cache::no_cache(&*repo).unwrap();

        let mut issue = issues

            .create(

                cob::Title::new("My first issue").unwrap(),

        let test::setup::NodeWithRepo { node, repo, .. } = test::setup::NodeWithRepo::default();

        let mut issues = Cache::no_cache(&*repo).unwrap();

        let mut issue = issues

            .create(

                cob::Title::new("My first issue").unwrap(),

    #[test]

    fn test_is_empty() {

        let mut cache = memory(repo);

        assert!(cache.is_empty().unwrap());

    #[test]

    fn test_counts() {

        let mut cache = memory(repo);

        let open_ids = (0..n_open)

            .map(|_| IssueId::from(arbitrary::oid()))

            .collect::<BTreeSet<IssueId>>();

    #[test]

    fn test_get() {

        let mut cache = memory(repo);

            .map(|_| IssueId::from(arbitrary::oid()))

            .collect::<BTreeSet<IssueId>>();

            .filter_map(|_| {

                let id = IssueId::from(arbitrary::oid());

                (!ids.contains(&id)).then_some(id)

    #[test]

    fn test_list() {

        let mut cache = memory(repo);

            .map(|_| IssueId::from(arbitrary::oid()))

            .collect::<BTreeSet<IssueId>>();

        let mut issues = Vec::with_capacity(ids.len());

    #[test]

    fn test_list_by_status() {

        let mut cache = memory(repo);

            .map(|_| IssueId::from(arbitrary::oid()))

            .collect::<BTreeSet<IssueId>>();

        let mut issues = Vec::with_capacity(ids.len());

    #[test]

    fn test_remove() {

        let mut cache = memory(repo);

            .map(|_| IssueId::from(arbitrary::oid()))

            .collect::<BTreeSet<IssueId>>();

    use crate::profile::env;

    use crate::test;

    use crate::test::arbitrary;

    use crate::test::storage::MockRepository;

    use cob::migrate;

        let base = git::Oid::from_str("cb18e95ada2bb38aadd8e6cef0963ce37a87add3").unwrap();

        let oid = git::Oid::from_str("518d5069f94c03427f694bb494ac1cd7d1339380").unwrap();

        let mut alice = Actor::<MockSigner>::default();

        let doc = RawDoc::new(

            vec![alice.did()],

            1,

            identity::Visibility::Public,

    fn test_revision_edit_redact() {

        let base = arbitrary::oid();

        let oid = arbitrary::oid();

        let time = env::local_time();

        let alice = MockSigner::default();

        let bob = MockSigner::default();

        let base = git::Oid::from_str("cb18e95ada2bb38aadd8e6cef0963ce37a87add3").unwrap();

        let oid = git::Oid::from_str("518d5069f94c03427f694bb494ac1cd7d1339380").unwrap();

        let mut alice = Actor::<MockSigner>::default();

        let reaction = Reaction::new('👍').expect("failed to create a reaction");

        let a1 = alice.op::<Patch>([

    }

    fn revision() -> (RevisionId, Revision) {

        let base = arbitrary::oid();

        let oid = arbitrary::oid();

        let timestamp = env::local_time();

    #[test]

    fn test_is_empty() {

        let mut cache = memory(repo);

        assert!(cache.is_empty().unwrap());

    #[test]

    fn test_counts() {

        let mut cache = memory(repo);

        let open_ids = (0..n_open)

            .map(|_| PatchId::from(arbitrary::oid()))

            .collect::<BTreeSet<PatchId>>();

    #[test]

    fn test_get() {

        let mut cache = memory(repo);

            .map(|_| PatchId::from(arbitrary::oid()))

            .collect::<BTreeSet<PatchId>>();

            .filter_map(|_| {

                let id = PatchId::from(arbitrary::oid());

                (!ids.contains(&id)).then_some(id)

    #[test]

    fn test_find_by_revision() {

        let mut cache = memory(repo);

        let patch_id = PatchId::from(arbitrary::oid());

            .map(|_| revision())

            .collect::<BTreeMap<RevisionId, Revision>>();

        let (rev_id, rev) = revisions

    #[test]

    fn test_list() {

        let mut cache = memory(repo);

            .map(|_| PatchId::from(arbitrary::oid()))

            .collect::<BTreeSet<PatchId>>();

        let mut patches = Vec::with_capacity(ids.len());

    #[test]

    fn test_list_by_status() {

        let mut cache = memory(repo);

            .map(|_| PatchId::from(arbitrary::oid()))

            .collect::<BTreeSet<PatchId>>();

        let mut patches = Vec::with_capacity(ids.len());

    #[test]

    fn test_remove() {

        let mut cache = memory(repo);

            .map(|_| PatchId::from(arbitrary::oid()))

            .collect::<BTreeSet<PatchId>>();

    /// Return all objects.

    pub fn all(

        &self,

        let raw = cob::list::<T, _>(self.repo, self.type_name)?;

        Ok(raw.into_iter().map(|o| Ok((*o.id(), o.object))))

    use crate::cob::change::Storage as _;

    use crate::crypto::test::signer::MockSigner;

    use crate::test::arbitrary;

    use crate::{cob, test};

    use super::*;

    fn gen_ops(repo: &git::raw::Repository, signer: &MockSigner) -> Vec<cob::Entry> {

        // Number of ops

        let mut entries = Vec::with_capacity(n.into());

        let mut parent = None;

        for _ in 0..n {

            // Number of actions in this op

            let contents = create_contents((0..m).map(|_| arbitrary::alphanumeric(1)));

            let entry = create_entry(repo, signer, contents, parent);

            parent = Some(entry.id);

            until: ops.last().unwrap().id.into(),

        };

        let n = ops.len() - 1;

        let x = x.clamp(0, n);

        let y = y.clamp(0, n);

        let (from, until) = if x <= y {

    use crate::node::device::Device;

    use crate::profile::env;

    use crate::test::arbitrary;

    use crate::test::storage::MockRepository;

    /// An object that can be used to create and sign changes.

    #[test]

    fn test_redact_comment() {

        let radicle::test::setup::Node { signer, .. } = radicle::test::setup::Node::default();

        let mut alice = Actor::new(signer);

        let a0 = alice.comment("First comment", None);

    #[test]

    fn test_edit_comment() {

        let mut alice = Actor::<MockSigner>::default();

        let c0 = alice.comment("Hello world!", None);

        let c1 = alice.edit(c0.id(), "Goodbye world.");

        let alice = MockSigner::default();

        let bob = MockSigner::default();

        let eve = MockSigner::default();

        let time = env::local_time();

        let mut a = test::history::<Thread, _>(

    #[test]

    fn test_duplicate_comments() {

        let alice = MockSigner::default();

        let bob = MockSigner::default();

        let time = env::local_time();

    #[quickcheck]

    fn prop_ordering(timestamp: u64) {

        let alice = MockSigner::default();

        let bob = MockSigner::default();

        let timestamp = Timestamp::from_secs(timestamp);

    #[test]

    fn test_comment_redact_missing() {

        let mut alice = Actor::<MockSigner>::default();

        let mut t = Thread::default();

        let id = arbitrary::entry_id();

    #[test]

    fn test_comment_edit_missing() {

        let mut alice = Actor::<MockSigner>::default();

        let mut t = Thread::default();

        let id = arbitrary::entry_id();

    #[test]

    fn test_comment_edit_redacted() {

        let mut alice = Actor::<MockSigner>::default();

        let a1 = alice.comment("Hi", None);

        }

    }

        match self.commit_quorum.next_candidate() {

            Some(candidate) => ControlFlow::Continue(candidate),

            None => ControlFlow::Break(()),

    ///

    /// A [`MergeBase`] should be calculated for each, and these should be

    /// recorded using [`CommitQuorum::found_merge_bases`].

        self.voting.next_candidate()

    }

    #[test]

    fn test_rule_validate_success() {

        let delegates = Allowed::Set(doc.delegates().as_ref().clone());

        let threshold = doc.majority();

    #[test]

    fn test_rule_validate_failures() {

        let pattern = pattern(qualified_pattern!("refs/heads/main"));

        assert!(matches!(

    /// compared to the other commit to see what their common merge base is. The

    /// merge base is then recorded using [`MergeBase`] and is recorded using

    /// [`CommitVoting::found_merge_base`].

        self.candidates

            .pop()

            .map(|(oid, others)| others.into_iter().map(move |other| (oid, other)))

    use crate::storage::git::Storage;

    use crate::storage::{ReadStorage as _, RemoteId, WriteStorage as _};

    use crate::test::arbitrary;

    use crate::test::fixtures;

    use super::*;

    fn test_duplicate_dids() {

        let delegate = Device::mock_from_seed([0xff; 32]);

        let did = Did::from(delegate.public_key());

        doc.delegate(did);

        let doc = doc.verified().unwrap();

        assert!(doc.delegates().len() == 1, "Duplicate DID was not removed");

    #[test]

    fn test_max_delegates() {

        // Generate more than the max delegates

        // A document with max delegates will be fine

        let doc = RawDoc::new(

            delegates[0..MAX_DELEGATES].into(),

            1,

            Visibility::Public,

        assert_matches!(doc.verified(), Ok(_));

        // A document that exceeds max delegates should fail

        assert_matches!(doc.verified(), Err(DocError::Delegates(DelegatesError(_))));

    }

    fn test_not_found() {

        let tempdir = tempfile::tempdir().unwrap();

        let storage = Storage::open(tempdir.path().join("storage"), fixtures::user()).unwrap();

        let repo = storage.create(proj).unwrap();

        let oid = git::raw::Oid::from_str("2d52a53ce5e4f141148a5f770cfd3ead2d6a45b8").unwrap();

    #[test]

    fn test_can_update_crefs() {

        let raw = super::payload(

            raw,

            [PayloadUpsert {

    #[test]

    fn test_cannot_include_default_branch_rule() {

        let branch = git::fmt::Qualified::from(git::fmt::lit::refs_heads(

            raw.project().unwrap().default_branch(),

        ));

    #[test]

    fn test_default_branch_rule_exists_after_verification() {

        let branch = git::fmt::Qualified::from(git::fmt::lit::refs_heads(