logger::init(log::Level::Debug);

    let mut environment = Environment::new();

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

    let alice = alice.spawn();

#[test]

fn rad_track() {

    let mut environment = Environment::new();

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

    let alice = alice.spawn();

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    // Setup a test project.

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    // Setup a test project.

#[test]

fn rad_self() {

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    test("examples/rad-self.md", working, Some(&alice.home), []).unwrap();

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    let alice = alice.spawn();

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    let alice = alice.spawn();

fn rad_fetch() {

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    let mut alice = alice.spawn();

    let bob = bob.spawn();

fn rad_fork() {

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    let mut alice = alice.spawn();

    let bob = bob.spawn();

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    let rid = alice.project("heartwood", "Radicle Heartwood Protocol & Stack");

    let mut alice = alice.spawn();

    let mut environment = Environment::new();

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

    let rid = alice.project("heartwood", "");

fn test_cob_deletion() {

    let mut environment = Environment::new();

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

    let rid = alice.project("heartwood", "");

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    let acme = Id::from_str("z42hL2jL4XNk6K8oHQaSWfMgCL7ji").unwrap();

    fixtures::repository(working.join("acme"));

//

fn test_replication_via_seed() {

    let mut environment = Environment::new();

    let seed = environment.node(Config {

        policy: Policy::Track,

        scope: Scope::All,

    });

    let working = environment.tmp().join("working");

    let rid = Id::from_str("z42hL2jL4XNk6K8oHQaSWfMgCL7ji").unwrap();

#[test]

fn rad_remote() {

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    let home = alice.home.clone();

    let rid = Id::from_str("z42hL2jL4XNk6K8oHQaSWfMgCL7ji").unwrap();

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    fixtures::repository(working.join("alice"));

#[test]

fn rad_merge_after_update() {

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    fixtures::repository(working.join("alice"));

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    fixtures::repository(working.join("alice"));

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

    formula(&environment.tmp(), "examples/framework/home.md")

        .unwrap()

    logger::init(log::Level::Debug);

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    fixtures::repository(working.join("alice"));

#[test]

fn rad_workflow() {

    let mut environment = Environment::new();

    let working = environment.tmp().join("working");

    fixtures::repository(working.join("alice"));

use thiserror::Error;

use radicle::git;

use radicle::node::address;

use radicle::node::Handle as _;

use radicle::node::{ADDRESS_DB_FILE, NODE_ANNOUNCEMENT_FILE, ROUTING_DB_FILE, TRACKING_DB_FILE};

use radicle::profile::Home;

        let tracking_db = node_dir.join(TRACKING_DB_FILE);

        log::info!(target: "node", "Opening address book {}..", address_db.display());

        log::info!(target: "node", "Opening routing table {}..", routing_db.display());

        let routing = routing::Table::open(routing_db)?;

                .expect("Runtime::init: unable to solve proof-of-work puzzle")

        };

        let emitter: Emitter<Event> = Default::default();

        let service = service::Service::new(

            config,

        let signer = MockSigner::new(&mut rng);

        Config {

            addrs: address::Book::memory().unwrap(),

            local_time: LocalTime::now(),

            policy: Policy::default(),

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

    alice.project("alice", "");

    bob.project("bob", "");

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

    alice.project("alice", "");

    bob.project("bob", "");

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

    alice.project("alice", "");

    bob.project("bob", "");

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

    alice.project("alice", "");

    bob.project("bob", "");

    logger::init(log::Level::Debug);

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

    let acme = bob.project("acme", "");

    let mut alice = alice.spawn();

    logger::init(log::Level::Debug);

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

    let acme = bob.project("acme", "");

    // Delete one of the signed refs.

#[test]

fn test_replication_invalid() {

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

    let carol = MockSigner::default();

    let acme = bob.project("acme", "");

    let repo = bob.storage.repository_mut(acme).unwrap();

    logger::init(log::Level::Debug);

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

    let acme = alice.project("acme", "");

    let mut alice = alice.spawn();

    logger::init(log::Level::Debug);

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

    let acme = alice.project("acme", "");

    let mut alice = alice.spawn();

    logger::init(log::Level::Debug);

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

    let acme = alice.project("acme", "");

    let mut signers = Vec::with_capacity(5);

    {

    logger::init(log::Level::Debug);

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

    let acme = alice.project("acme", "");

    let mut alice = alice.spawn();

    logger::init(log::Level::Debug);

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

    let acme = alice.project("acme", "");

    let mut alice = alice.spawn();

    let mut bob = bob.spawn();

    logger::init(log::Level::Debug);

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

    let acme = bob.project("acme", "");

    let mut alice = alice.spawn();

    logger::init(log::Level::Debug);

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

    let acme = bob.project("acme", "");

    let mut alice = alice.spawn();

    let env = Environment::new();

    let scale = env.scale();

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

    let (repo, _) = fixtures::repository(tmp.path());

        &env.tmp(),

        service::Config {

            limits: limits.clone(),

        },

    );

    let mut bob = Node::init(

        &env.tmp(),

        service::Config {

            limits,

        },

    );

    logger::init(log::Level::Debug);

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

    let mut alice = alice.spawn();

    let mut bob = bob.spawn();

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

    let rid = bob.project("acme", "");

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

    let rid = alice.project("acme", "");

pub use store::*;

pub use types::*;

use cyphernet::addr::HostName;

use crate::node::Address;

        };

        match value {

            sql::Value::String(s) => match s.as_str() {

                "peer" => Ok(Source::Peer),

                "imported" => Ok(Source::Imported),

                _ => Err(err),

impl sql::BindableWithIndex for Source {

    fn bind<I: sql::ParameterIndex>(self, stmt: &mut sql::Statement<'_>, i: I) -> sql::Result<()> {

        match self {

            Self::Peer => "peer".bind(stmt, i),

            Self::Imported => "imported".bind(stmt, i),

        }

            sql::Value::String(s) => match s.as_str() {

                "ipv4" => Ok(AddressType::Ipv4),

                "ipv6" => Ok(AddressType::Ipv6),

                "onion" => Ok(AddressType::Onion),

                _ => Err(err),

            },

            let addr = net::SocketAddr::from((net::Ipv4Addr::from(ip), rng.u16(..)));

            let ka = KnownAddress {

                addr: addr.into(),

                // TODO: Test times as well.

                last_success: None,

                last_attempt: None,

pub enum Source {

    /// An address that was shared by another peer.

    Peer,

    /// An address that came from some source external to the system, eg.

    /// specified by the user or added directly to the address manager.

    Imported,

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        match self {

            Self::Peer => write!(f, "Peer"),

            Self::Imported => write!(f, "Imported"),

        }

    }

    Test,

}

/// Configuration parameters defining attributes of minima and maxima.

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]

#[serde(rename_all = "camelCase")]

    }

}

impl Deref for ConnectAddress {

    type Target = PeerAddr<NodeId, Address>;

}

impl Config {

    pub fn new(alias: Alias) -> Self {

        Self {

            alias,