$ rad issue open --title "Test `rad sync`" --description "Check that the command works" -q --no-announce

```

```

$ rad sync status --sort-by alias

╭──────────────────────────────────────────────────────────────────────────────────────────────╮

│ ●   Node                      Address                      Status        Tip       Timestamp │

├──────────────────────────────────────────────────────────────────────────────────────────────┤

│ ●   bob     z6Mkt67…v4N1tRk   bob.radicle.example:8776     out-of-sync   f209c9f   [  ...  ] │

│ ●   eve     z6Mkux1…nVhib7Z   eve.radicle.example:8776     out-of-sync   f209c9f   [  ...  ] │

╰──────────────────────────────────────────────────────────────────────────────────────────────╯

        head,

        doc,

        refs,

    } in repos

    {

        if doc.visibility.is_public() && options.private && !options.public {

) -> anyhow::Result<()> {

    let mut table = Table::<7, term::Label>::new(TableOptions::bordered());

    let mut seeds: Vec<_> = node.seeds(rid)?.into();

    let aliases = profile.aliases();

    table.push([

    ]);

    table.divider();

    for seed in seeds {

        let (icon, status, head, time) = match seed.sync {

            Some(SyncStatus::Synced { at }) => (

                term::format::positive("●"),

                term::format::oid(at.oid),

                term::format::timestamp(at.timestamp),

            ),

                term::format::timestamp(remote.timestamp),

            ),

            None if options.verbose => (

        assert_ne!(time, LocalTime::default());

        let nid = self.node_id();

        self.started_at = Some(time);

        self.clock = time;

        // Populate refs database. This is only useful as part of the upgrade process for nodes

        // that have been online since before the refs database was created.

            )

            .expect("Service::initialize: error adding local node to address database");

        let announced = self

            .db

            .seeds()

            .seeded_by(&nid)?

            .collect::<Result<HashMap<_, _>, _>>()?;

            // If we're not seeding this repo, just skip it.

            if !self.policies.is_seeding(&rid)? {

                warn!(target: "service", "Local repository {rid} is not seeded");

                continue;

            }

            // If we have no owned refs for this repo, then there's nothing to announce.

                continue;

            };

            // Skip this repo if the sync status matches what we have in storage.

            if let Some(announced) = announced.get(&rid) {

                if updated_at.oid == announced.oid {

            )? {

                debug!(target: "service", "Saved local sync status for {rid}..");

            }

            // If we got here, it likely means a repo was updated while the node was stopped.

            // Therefore, we pre-load a refs announcement for this repo, so that it is included in

            // the historical gossip messages when a node connects and subscribes to this repo.

            }

        }

        // Setup subscription filter for seeded repos.

        self.filter = Filter::new(

            self.policies

        // Update our sync status for our own refs. This is useful for determining if refs were

        // updated while the node was stopped.

        if let Some(refs) = refs.iter().find(|r| r.remote == ann.node) {

            info!(

                target: "service",

                "Announcing own refs for {rid} to peers ({}) (t={timestamp})..",

                refs.at

            );

            if let Err(e) = self

                .db

                .seeds_mut()

                .synced(&rid, &ann.node, refs.at, timestamp)

            {

                error!(target: "service", "Error updating sync status for local node: {e}");

            }

        }

#[test]

fn test_refs_announcement_offline() {

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

    let mut alice = {

        let signer = MockSigner::default();

            },

        )

    };

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

    // Make sure alice's service wasn't initialized before.

    assert_eq!(*alice.clock(), LocalTime::default());

    // Alice announces the refs of all projects since she hasn't announced refs for these projects

    // yet.

        assert_matches!(

            msg,

                node,

                message: AnnouncementMessage::Refs(RefsAnnouncement {

                    rid,

                    ..

                }),

                ..

        );

    }

    // Create an issue without telling the node.

    let old_refs = RefsAt::new(&repo, alice.id).unwrap();

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

    issues

        .collect::<Vec<_>>();

    assert_eq!(anns.len(), 1);

    assert_eq!(anns.first().unwrap().refs.first().unwrap().at, new_refs.at);

}

use crate::identity::{Did, PayloadError};

use crate::identity::{Doc, DocAt, DocError};

use crate::identity::{Identity, RepoId};

use crate::storage::git::NAMESPACES_GLOB;

use crate::storage::refs::Refs;

    /// Local signed refs, if any.

    /// Repositories with this set to `None` are ones that are seeded but not forked.

    pub refs: Option<refs::SignedRefsAt>,

}

/// Describes one or more namespaces.

use tempfile::TempDir;

use crate::crypto::Unverified;

use crate::identity::doc::DocError;

use crate::identity::{doc::DocAt, Doc, RepoId};

use crate::identity::{Identity, Project};

use crate::storage::refs;

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

use crate::storage::{

    Inventory, ReadRepository, ReadStorage, Remote, Remotes, RepositoryError, RepositoryInfo,

    SetHead, SignRepository, WriteRepository, WriteStorage,

};

pub use crate::git::{

    ext, raw, refname, refspec, Oid, PatternStr, Qualified, RefError, RefString, UserInfo,

            .lock()

            .unwrap_or_else(|poisoned| poisoned.into_inner());

        if let Some(ref mut repos) = *repos {

            repos.insert(rid);

        }

    }

            };

            // Nb. This will be `None` if they were not found.

            let refs = refs::SignedRefsAt::load(self.info.key, &repo)?;

            repos.push(RepositoryInfo {

                rid,

                head,

                doc,

                refs,

            });

        }

        Ok(repos)

        rids.try_fold(Vec::new(), |mut infos, rid| {

            let repo = self.repository(*rid)?;

            let (_, head) = repo.head()?;

            let info = RepositoryInfo {

                rid: *rid,

                head,

                doc: repo.identity_doc()?.into(),

            };

            infos.push(info);

            Ok(infos)

    where

        S: ReadRepository,

    {

            Err(e) if git::is_not_found_err(&e) => return Ok(None),

            Err(e) => return Err(e.into()),

        };

/// Create a new storage with a project.

pub fn storage<P: AsRef<Path>, G: Signer>(path: P, signer: &G) -> Result<Storage, rad::InitError> {

    let path = path.as_ref();

    transport::local::register(storage.clone());

    transport::remote::mock::register(signer.public_key(), storage.path());

                head: r.head().unwrap().1,

                doc: r.doc.clone().into(),

                refs: None,

            })

            .collect())

    }