}

}

impl AsRef<PublicKey> for MockSigner {

    fn as_ref(&self) -> &PublicKey {

        &self.pk

        signer: &S,

    ) -> Result<SignedRefsAt, Error>

    where

        R: sigrefs::git::object::Reader + sigrefs::git::object::Writer,

        R: sigrefs::git::reference::Reader + sigrefs::git::reference::Writer,

    {

        let msg = "Update signed refs\n";

        let reflog = format!("Save {} signed references", self.len());

        match update {

            }

            }

        }

    }

    for refs in all_refs {

        let refs = fixture.with_identity_root(refs);

        let update = match writer.write(

            fixture.committer(),

            "roundtrip write".into(),

        };

        let written_refs = match update {

        };

        assert_eq!(refs, written_refs);

    let signer = MockSigner::default();

    let node_id = *signer.public_key();

        fixture.committer(),

        "first write".into(),

        "first reflog".into(),

        return TestResult::error(format!("first write error: {e}"));

    }

        fixture.committer(),

        "second write".into(),

        "second reflog".into(),

    }

    // The [`FeatureLevel`] of the refs in this commit.

        self.level

    }

            let commit = verified.commit();

            let commits = seen.get(&commit.signature).expect(SIGNATURES_COLLECTED);

            if commits.len_nonzero() == ONE {

                return Ok(verified);

            }

            let id = &commit.oid;

            if id == commits.last() {

                // If this commit is the last element of `commits`,

                // then this means it is the earliest of all that share

}

impl Commit {

    #[cfg(test)]

    pub(super) fn refs(&self) -> &Refs {

        &self.refs

    }

    where

        V: signature::Verifier<crypto::Signature>,

    {

    }

}

    commit: Oid,

    repository: &'a R,

}

where

    R: object::Reader,

{

        Self { commit, repository }

    }

        let commit = self.read_commit_data()?;

        let Tree { refs, signature } = TreeReader::new(self.commit, self.repository)

            .read()

}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

    commit: Oid,

    rid: RepoId,

}

use radicle_oid::Oid;

use crate::storage::refs::sigrefs::read::error::{Read, Verify};

use crate::storage::refs::sigrefs::VerifiedCommit;

use crate::storage::refs::{FeatureLevel, IDENTITY_ROOT, SIGREFS_PARENT};

use crate::{assert_matches, git};

    let vc = read(c1, repo).unwrap();

    assert_eq!(vc.commit.oid, c1);

}

#[test]

    let vc = read(c1, repo).unwrap();

    assert_eq!(vc.commit.oid, c1);

    assert_eq!(vc.commit.parent, Some(c2));

}

#[test]

    let vc = read(c1, repo).unwrap();

    assert_eq!(vc.commit.oid, c1);

}

#[test]

use std::path::Path;

use crypto::PublicKey;

use radicle_git_metadata::author::Author;

use radicle_git_metadata::commit::{headers::Headers, trailers::OwnedTrailer, CommitData};

use radicle_oid::Oid;

use crate::git;

use crate::storage::refs::sigrefs::git::{object, reference, Committer};

use crate::storage::refs::{

    FeatureLevel, Refs, IDENTITY_ROOT, REFS_BLOB_PATH, SIGNATURE_BLOB_PATH, SIGREFS_BRANCH,

    SIGREFS_PARENT,

};

use crate::storage::refs::{SignedRefs, SignedRefsAt};

#[derive(Clone, Debug, PartialEq, Eq)]

pub enum Update {

    /// The new signed references commit was written to the Git repository.

    /// The provided [`Refs`] were equal to the current [`Refs`], so the process

    /// exited early.

}

        Self::Changed {

            entry: Box::new(commit),

        }

    }

    }

}

///   over the [`Refs`].

pub struct SignedRefsWriter<'a, R, S> {

    refs: Refs,

    namespace: NodeId,

    repository: &'a R,

    signer: &'a S,

where

    R: object::Writer + object::Reader + reference::Writer + reference::Reader,

    S: Signer<crypto::Signature>,

{

    /// Construct a new [`SignedRefsWriter`].

    ///

    /// The construction removes the ref [`SIGREFS_BRANCH`] from [`Refs`]

    /// (if present).

    ///

    /// the given [`Refs`] will be written to the provided `namespace`.

        debug_assert!(refs.get(&IDENTITY_ROOT).is_some());

        debug_assert!(refs.get(&SIGREFS_PARENT).is_none());

        refs.remove_sigrefs();

        Self {

            refs,

            namespace,

            repository,

            signer,

        let author = committer.into_inner();

        let Self {

            refs,

            namespace,

            repository,

            signer,

        } = self;

        let reference = SIGREFS_BRANCH.with_namespace(git::fmt::Component::from(&namespace));

            .read()

            .map_err(error::Write::Head)?;

        let commit_writer = match head {

            None => CommitWriter::root(refs, author, message, repository, signer),

        };

        let commit = commit_writer.write().map_err(error::Write::Commit)?;

        repository

            .write_reference(&reference, commit.oid, commit.parent, reflog)

            .map_err(error::Write::Reference)?;

    }

}

/// references payload.

#[derive(Clone, Debug, PartialEq, Eq)]

struct Head {

}

impl Head {

    /// Returns `true` if the `proposed` [`Refs`] are equal to the [`Refs`]

    /// of the [`Head`].

    fn is_unchanged(&self, proposed: &Refs) -> bool {

    }

}

    reference: &'a git::fmt::Namespaced<'a>,

    repository: &'b R,

}

where

    R: object::Reader + reference::Reader,

{

    /// Construct a [`HeadReader`] with the `reference` that is being read from

    /// the `repository.`

        Self {

            reference,

            repository,

        }

    }

    ///

    /// The returned [`Refs`] do not contain the [`SIGREFS_PARENT`] reference.

    fn read(self) -> Result<Option<Head>, error::Head> {

            .find_reference(self.reference)

            .map_err(error::Head::Reference)?

    }

}

use thiserror::Error;

use crate::storage::refs::sigrefs::git::{object, reference};

// TODO: use commit NID (and RID?) for traceability

    #[error(transparent)]

    Reference(reference::error::FindReference),

    #[error(transparent)]

    #[error(transparent)]

}

use radicle_git_ref_format::Component;

use super::mock::{self, MockRepository};

use crate::storage::refs::sigrefs::write::{error, Head, HeadReader};

/// Drive `HeadReader` directly via the sigrefs reference for `mock::node_id()`.

fn read(repo: &MockRepository) -> Result<Option<Head>, error::Head> {

    let namespace = mock::node_id();

    let reference = SIGREFS_BRANCH.with_namespace(Component::from(&namespace));

}

#[test]

    let head = mock::oid(1);

    let repo = MockRepository::new()

        .with_rad_sigrefs(&mock::node_id(), head)

        .with_refs_error(head);

}

#[test]

    let head = mock::oid(1);

    let repo = MockRepository::new()

        .with_rad_sigrefs(&mock::node_id(), head)

        .with_missing_refs(head)

        .with_signature(head, 1);

}

#[test]

    let head = mock::oid(1);

    let repo = MockRepository::new()

        .with_rad_sigrefs(&mock::node_id(), head)

        .with_invalid_refs(head)

        .with_signature(head, 1);

}

#[test]

    let head = mock::oid(1);

    let repo = MockRepository::new()

        .with_rad_sigrefs(&mock::node_id(), head)

        .with_signature_error(head);

}

#[test]

    let head = mock::oid(1);

    let repo = MockRepository::new()

        .with_rad_sigrefs(&mock::node_id(), head)

        .with_missing_signature(head);

}

#[test]

    let head = mock::oid(1);

    let repo = MockRepository::new()

        .with_rad_sigrefs(&mock::node_id(), head)

        .with_invalid_signature(head);

}

#[test]

fn read_ok() {

    let repo = MockRepository::new()

    assert_eq!(

    );

}

use std::path::{Path, PathBuf};

use std::str::FromStr as _;

use radicle_git_metadata::author::{Author, Time};

use radicle_oid::Oid;

use crate::git;

use crate::storage::refs::sigrefs::git::{object, reference};

use crate::storage::refs::{Refs, REFS_BLOB_PATH, SIGNATURE_BLOB_PATH, SIGREFS_BRANCH};

enum WriteTreeBehavior {

    /// [`object::Writer::write_tree`] returns `Ok(oid)`.

}

pub struct MockRepository {

    blobs: HashMap<(Oid, PathBuf), BlobBehavior>,

    references: HashMap<String, RefBehavior>,

    write_tree: Option<WriteTreeBehavior>,

    write_reference: Option<WriteReferenceBehavior>,

}

impl MockRepository {

    pub fn new() -> MockRepository {

        MockRepository {

            blobs: HashMap::new(),

            references: HashMap::new(),

            write_tree: None,

            write_commit: None,

            write_reference: None,

        }

    }

    pub fn with_rad_sigrefs(mut self, namespace: &NodeId, commit: Oid) -> MockRepository {

        self.with_blob(commit, Path::new(SIGNATURE_BLOB_PATH), bytes)

    }

    fn with_blob(mut self, commit: Oid, path: &Path, bytes: Vec<u8>) -> Self {

        self.blobs

            .insert((commit, path.to_path_buf()), BlobBehavior::Present(bytes));

    }

}

impl object::Reader for MockRepository {

    }

    fn read_blob(

    }

}

/// Always fails to sign.

pub struct NeverSign;

    Oid::from_sha1([n; 20])

}

/// A fixed [`NodeId`] for tests.

pub fn node_id() -> NodeId {

    NodeId::from([1u8; 32])

    }

}

fn sigrefs_ref_name(namespace: &NodeId) -> String {

    SIGREFS_BRANCH

        .with_namespace(git::fmt::Component::from(namespace))

        .as_str()

        .to_owned()

}

use crate::storage::refs::sigrefs::git::Committer;

use crate::storage::refs::sigrefs::write::{error, SignedRefsWriter, Update};

use super::mock;

use super::mock::MockRepository;

}

fn other_refs() -> Refs {

}

fn refs_with_rad_sigrefs() -> Refs {

}

fn write(refs: Refs, repo: &MockRepository) -> Result<Update, error::Write> {

        Committer::new(mock::author()),

        "msg".into(),

        "reflog".into(),

    let refs = some_refs(mock::oid(99));

    let repo = MockRepository::new()

        .with_rad_sigrefs(&mock::node_id(), head)

        .with_refs(head, refs.clone())

        .with_signature(head, 1);

        }

}

#[test]

        .with_write_reference_ok();

    let refs = some_refs(mock::oid(99));

    let update = write(refs.clone(), &repo).unwrap();

        panic!("expected Update::Changed, got {update:?}");

    };

    assert_eq!(entry.parent, None);

    let commit_oid = mock::oid(42);

    let repo = MockRepository::new()

        .with_rad_sigrefs(&mock::node_id(), head)

        .with_refs(head, other_refs())

        .with_signature(head, 1)

        .with_write_tree_ok(mock::oid(99))

        .with_write_reference_ok();

    let refs = some_refs(mock::oid(99));

    let update = write(refs.clone(), &repo).unwrap();

        panic!("expected Update::Changed, got {update:?}");

    };

    assert_eq!(entry.parent, Some(head));

        .with_write_commit_ok(commit_oid)

        .with_write_reference_ok();

    let update = write(refs.clone(), &repo).unwrap();

        panic!("expected Update::Changed, got {update:?}");

    };

    assert_eq!(entry.parent, None);

        .with_write_reference_ok();

    let mut refs = refs_with_rad_sigrefs();

    let update = write(refs.clone(), &repo).unwrap();

        panic!("expected Update::Changed, got {update:?}");

    };

    assert_eq!(entry.parent, None);