.cargo/config.toml

@@ -13,5 +13,5 @@ debug = 0
 strip = "debuginfo"
 
 [env]
-RUST_LOG = "hyper=warn,debug"
+RUST_LOG = "hyper=warn,info"
 RUSTFLAGS = "--cfg tokio_unstable"

bacon.toml

@@ -24,15 +24,7 @@ command = ["cargo", "check", "--all-targets", "--color", "always"]
 need_stdout = false
 
 [jobs.clippy]
-command = [
+command = ["cargo", "clippy", "--all-targets", "--color", "always"]
-  "cargo",
-  "clippy",
-  "--all-targets",
-  "--color",
-  "always",
-  "--",
-  "-Dwarnings",
-]
 need_stdout = false
 
 [jobs.test]

crates/config/src/git_dir.rs

@@ -1,43 +1,20 @@
 //
 use std::path::PathBuf;
 
-use derive_more::Deref;
+crate::newtype!(GitDir: PathBuf, Default: "The path to the directory containing the git repository.");
-
-/// The path to the directory containing the git repository.
-#[derive(
-    Clone,
-    Debug,
-    derive_more::From,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    derive_more::AsRef,
-    derive_more::Constructor,
-)]
-pub struct GitDir {
-    pathbuf: PathBuf,
-    /// Whether the directory is under the control of git-next (Internal) or not (External).
-    storage_path_type: StoragePathType,
-}
 impl GitDir {
     pub const fn pathbuf(&self) -> &PathBuf {
-        &self.pathbuf
+        &self.0
-    }
-    pub const fn storage_path_type(&self) -> &StoragePathType {
-        &self.storage_path_type
     }
 }
 impl std::fmt::Display for GitDir {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", &self.pathbuf.display())
+        write!(f, "{}", &self.0.display())
     }
 }
-impl Deref for GitDir {
+impl From<&str> for GitDir {
-    type Target = PathBuf;
+    fn from(value: &str) -> Self {
-
+        Self(value.into())
-    fn deref(&self) -> &Self::Target {
-        &self.pathbuf
     }
 }
 impl From<&GitDir> for PathBuf {
@@ -45,9 +22,3 @@ impl From<&GitDir> for PathBuf {
         value.to_path_buf()
     }
 }
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub enum StoragePathType {
-    Internal,
-    External,
-}

crates/config/src/lib.rs

@@ -30,7 +30,6 @@ pub use forge_config::ForgeConfig;
 pub use forge_details::ForgeDetails;
 pub use forge_type::ForgeType;
 pub use git_dir::GitDir;
-pub use git_dir::StoragePathType;
 pub use host_name::Hostname;
 pub use registered_webhook::RegisteredWebhook;
 pub use repo_alias::RepoAlias;

crates/config/src/server_repo_config.rs

@@ -35,10 +35,7 @@ impl ServerRepoConfig {
     }
 
     pub fn gitdir(&self) -> Option<GitDir> {
-        self.gitdir
+        self.gitdir.clone().map(GitDir::from)
-            .clone()
-            // Provenance is external as the gitdir is only used to specify non-internal paths
-            .map(|dir| GitDir::new(dir, crate::git_dir::StoragePathType::External))
     }
 
     /// Returns a RepoConfig from the server configuration if ALL THREE branches were provided

crates/config/src/tests.rs

@@ -90,10 +90,7 @@ mod server_repo_config {
 
         assert_eq!(
             src.gitdir(),
-            Some(GitDir::new(
+            Some(GitDir::new(PathBuf::default().join(gitdir)))
-                PathBuf::default().join(gitdir),
-                git_dir::StoragePathType::External
-            ))
         );
     }
 }
@@ -385,29 +382,47 @@ mod gitdir {
     #[test]
     fn should_return_pathbuf() {
         let pathbuf = PathBuf::default().join(given::a_name());
-        let gitdir = GitDir::new(pathbuf.clone(), git_dir::StoragePathType::Internal);
+        let gitdir = GitDir::new(&pathbuf);
 
-        let result = gitdir.to_path_buf();
+        let result = gitdir.unwrap();
 
         assert_eq!(result, pathbuf);
     }
     #[test]
     fn should_display() {
         let pathbuf = PathBuf::default().join("foo");
-        let gitdir = GitDir::new(pathbuf, git_dir::StoragePathType::Internal);
+        let gitdir = GitDir::new(pathbuf);
 
         let result = gitdir.to_string();
 
         assert_eq!(result, "foo");
     }
     #[test]
+    fn should_convert_from_str() {
+        let path = given::a_name();
+        let pathbuf = PathBuf::default().join(path.clone());
+        let gitdir: GitDir = path.as_str().into();
+
+        assert_eq!(gitdir, GitDir::new(pathbuf));
+    }
+    #[test]
     fn should_convert_to_pathbuf_from_ref() {
         let path = given::a_name();
-        let pathbuf = PathBuf::default().join(path);
+        let pathbuf = PathBuf::default().join(path.clone());
-        let gitdir: GitDir = GitDir::new(pathbuf.clone(), git_dir::StoragePathType::Internal);
+        let gitdir: GitDir = path.as_str().into();
 
         let result: PathBuf = (&gitdir).into();
 
+        assert_eq!(result, pathbuf);
+    }
+    #[test]
+    fn should_convert_to_pathbuf_from_inst() {
+        let path = given::a_name();
+        let pathbuf = PathBuf::default().join(path.clone());
+        let gitdir: GitDir = path.as_str().into();
+
+        let result: PathBuf = gitdir.into();
+
         assert_eq!(result, pathbuf);
     }
 }
@@ -488,7 +503,7 @@ mod server {
                 let branch = server_repo_config.branch();
                 let gitdir = server_repo_config
                     .gitdir()
-                    .map(|gitdir| gitdir.to_path_buf())
+                    .map(|gitdir| gitdir.unwrap())
                     .map(|pathbuf| pathbuf.display().to_string())
                     .map(|gitdir| format!(r#", gitdir = "{gitdir}" "#))
                     .unwrap_or_default();

crates/forge-forgejo/src/tests.rs

@@ -734,7 +734,7 @@ mod forgejo {
         pub fn a_git_dir(fs: &kxio::fs::FileSystem) -> config::GitDir {
             let dir_name = a_name();
             let dir = fs.base().join(dir_name);
-            config::GitDir::new(dir, config::git_dir::StoragePathType::Internal)
+            config::GitDir::new(dir)
         }
 
         pub fn a_forge_config() -> config::ForgeConfig {

crates/forge-github/src/tests/mod.rs

@@ -508,8 +508,6 @@ mod github {
 
     mod given {
 
-        use std::path::PathBuf;
-
         use git_next_config::{server::Webhook, WebhookId};
         use kxio::network::{MockNetwork, StatusCode};
         use rand::RngCore;
@@ -626,10 +624,7 @@ mod github {
                     a_name(),
                     BTreeMap::default(),
                 ),
-                GitDir::new(
+                GitDir::default(),
-                    PathBuf::default(),
-                    config::git_dir::StoragePathType::External,
-                ),
             )
         }
 

crates/forge/src/tests.rs

@@ -37,9 +37,6 @@ fn given_repo_details(forge_type: config::ForgeType) -> RepoDetails {
             1,
             config::RepoConfigSource::Repo,
         )),
-        config::GitDir::new(
+        config::GitDir::new(fs.base()),
-            fs.base().to_path_buf(),
-            config::git_dir::StoragePathType::Internal,
-        ),
     )
 }

crates/git/src/repo_details.rs

@@ -7,7 +7,7 @@ use git_next_config as config;
 use super::{Generation, GitRemote};
 
 /// The derived information about a repo, used to interact with it
-#[derive(Clone, Debug, derive_more::Display, derive_with::With)]
+#[derive(Clone, Default, Debug, derive_more::Display, derive_with::With)]
 #[display("gen-{}:{}:{}/{}", generation, forge.forge_type(), forge.forge_alias(), repo_alias )]
 pub struct RepoDetails {
     pub generation: Generation,

crates/git/src/repository/factory.rs

@@ -1,51 +0,0 @@
-use super::RepoDetails;
-use super::Result;
-pub use crate::repository::open::OpenRepositoryLike;
-use crate::repository::RealOpenRepository;
-use derive_more::Deref as _;
-use git_next_config::GitDir;
-use std::sync::{atomic::AtomicBool, Arc, RwLock};
-
-#[mockall::automock]
-pub trait RepositoryFactory: std::fmt::Debug + Sync + Send {
-    fn duplicate(&self) -> Box<dyn RepositoryFactory>;
-    fn open(&self, gitdir: &GitDir) -> Result<Box<dyn OpenRepositoryLike>>;
-    fn git_clone(&self, repo_details: &RepoDetails) -> Result<Box<dyn OpenRepositoryLike>>;
-}
-
-pub fn real() -> Box<dyn RepositoryFactory> {
-    Box::new(RealRepositoryFactory)
-}
-
-pub fn mock() -> Box<MockRepositoryFactory> {
-    Box::new(MockRepositoryFactory::new())
-}
-
-#[derive(Debug, Clone)]
-struct RealRepositoryFactory;
-
-#[cfg(not(tarpaulin_include))] // requires network access to either clone new and/or fetch.
-impl RepositoryFactory for RealRepositoryFactory {
-    fn open(&self, gitdir: &GitDir) -> Result<Box<dyn OpenRepositoryLike>> {
-        let gix_repo = gix::ThreadSafeRepository::open(gitdir.to_path_buf())?.to_thread_local();
-        let repo = RealOpenRepository::new(Arc::new(RwLock::new(gix_repo.into())));
-        Ok(Box::new(repo))
-    }
-
-    fn git_clone(&self, repo_details: &RepoDetails) -> Result<Box<dyn OpenRepositoryLike>> {
-        tracing::info!("creating");
-        use secrecy::ExposeSecret;
-        let (gix_repo, _outcome) = gix::prepare_clone_bare(
-            repo_details.origin().expose_secret().as_str(),
-            repo_details.gitdir.deref(),
-        )?
-        .fetch_only(gix::progress::Discard, &AtomicBool::new(false))?;
-        tracing::info!("created");
-        let repo = RealOpenRepository::new(Arc::new(RwLock::new(gix_repo.into())));
-        Ok(Box::new(repo))
-    }
-
-    fn duplicate(&self) -> Box<dyn RepositoryFactory> {
-        Box::new(self.clone())
-    }
-}

crates/git/src/repository/mod.rs

@@ -1,23 +1,30 @@
 //
-use super::RepoDetails;
+use std::sync::{atomic::AtomicBool, Arc, RwLock};
-use crate::repository::test::TestRepository;
+
-use crate::validation::remotes::validate_default_remotes;
+use derive_more::Deref as _;
-pub use factory::RepositoryFactory;
+
+pub mod open;
+// mod real;
+mod test;
+
+#[cfg(test)]
+mod tests;
+
 use git_next_config as config;
 use git_next_config::GitDir;
+
 pub use open::otest::OnFetch;
 pub use open::otest::OnPush;
+
 pub use open::OpenRepository;
 pub use open::OpenRepositoryLike;
 pub use open::RealOpenRepository;
 use tracing::info;
 
-pub mod factory;
+use crate::repository::test::TestRepository;
-pub mod open;
+use crate::validation::remotes::validate_default_remotes;
-mod test;
 
-#[cfg(test)]
+use super::RepoDetails;
-mod tests;
 
 #[derive(Clone, Debug)]
 #[allow(clippy::large_enum_variant)]
@@ -34,7 +41,7 @@ pub const fn test(fs: kxio::fs::FileSystem) -> TestRepository {
 #[tracing::instrument(skip_all)]
 #[cfg(not(tarpaulin_include))] // requires network access to either clone new and/or fetch.
 pub fn open(
-    repository_factory: &dyn factory::RepositoryFactory,
+    repository_factory: &dyn RepositoryFactory,
     repo_details: &RepoDetails,
     gitdir: config::GitDir,
 ) -> Result<Box<dyn OpenRepositoryLike>> {
@@ -51,6 +58,50 @@ pub fn open(
     Ok(open_repository)
 }
 
+#[mockall::automock]
+pub trait RepositoryFactory: std::fmt::Debug + Sync + Send {
+    fn duplicate(&self) -> Box<dyn RepositoryFactory>;
+    fn open(&self, gitdir: &GitDir) -> Result<Box<dyn OpenRepositoryLike>>;
+    fn git_clone(&self, repo_details: &RepoDetails) -> Result<Box<dyn OpenRepositoryLike>>;
+}
+
+pub fn real() -> Box<dyn RepositoryFactory> {
+    Box::new(RealRepositoryFactory)
+}
+
+pub fn mock() -> Box<MockRepositoryFactory> {
+    Box::new(MockRepositoryFactory::new())
+}
+
+#[derive(Debug, Clone)]
+struct RealRepositoryFactory;
+
+#[cfg(not(tarpaulin_include))] // requires network access to either clone new and/or fetch.
+impl RepositoryFactory for RealRepositoryFactory {
+    fn open(&self, gitdir: &GitDir) -> Result<Box<dyn OpenRepositoryLike>> {
+        let gix_repo = gix::ThreadSafeRepository::open(gitdir.to_path_buf())?.to_thread_local();
+        let repo = RealOpenRepository::new(Arc::new(RwLock::new(gix_repo.into())));
+        Ok(Box::new(repo))
+    }
+
+    fn git_clone(&self, repo_details: &RepoDetails) -> Result<Box<dyn OpenRepositoryLike>> {
+        tracing::info!("creating");
+        use secrecy::ExposeSecret;
+        let (gix_repo, _outcome) = gix::prepare_clone_bare(
+            repo_details.origin().expose_secret().as_str(),
+            repo_details.gitdir.deref(),
+        )?
+        .fetch_only(gix::progress::Discard, &AtomicBool::new(false))?;
+        tracing::info!("created");
+        let repo = RealOpenRepository::new(Arc::new(RwLock::new(gix_repo.into())));
+        Ok(Box::new(repo))
+    }
+
+    fn duplicate(&self) -> Box<dyn RepositoryFactory> {
+        Box::new(self.clone())
+    }
+}
+
 pub trait RepositoryLike {
     fn open(&self, gitdir: &GitDir) -> Result<OpenRepository>;
     fn git_clone(&self, repo_details: &RepoDetails) -> Result<OpenRepository>;

crates/git/src/repository/open/mod.rs

@@ -5,6 +5,9 @@ mod tests;
 pub mod oreal;
 pub mod otest;
 
+#[cfg(test)]
+pub mod ofake;
+
 use std::{
     path::Path,
     sync::{Arc, RwLock},
@@ -13,6 +16,8 @@ use std::{
 use crate as git;
 use git::repository::Direction;
 use git_next_config as config;
+#[cfg(test)]
+pub use ofake::FakeOpenRepository;
 pub use oreal::RealOpenRepository;
 pub use otest::TestOpenRepository;
 

crates/git/src/repository/open/ofake.rs

@@ -0,0 +1,121 @@
+//
+use crate::{self as git, repository::OpenRepositoryLike};
+use git_next_config as config;
+
+use std::{
+    path::Path,
+    sync::{Arc, RwLock},
+};
+
+#[derive(Clone, Debug, Default)]
+pub struct FakeOpenRepository {
+    default_push_remote: Arc<RwLock<Option<git::GitRemote>>>,
+    default_fetch_remote: Arc<RwLock<Option<git::GitRemote>>>,
+    operations: Arc<RwLock<Vec<String>>>,
+}
+impl FakeOpenRepository {
+    pub fn new() -> Self {
+        Self::default()
+    }
+    pub fn given_has_default_remote(
+        &mut self,
+        direction: git::repository::Direction,
+        remote: Option<git::GitRemote>,
+    ) {
+        #[allow(clippy::unwrap_used)]
+        match direction {
+            git::repository::Direction::Push => self
+                .default_push_remote
+                .write()
+                .map(|mut o| match remote {
+                    Some(gr) => o.replace(gr),
+                    None => o.take(),
+                })
+                .unwrap(),
+            git::repository::Direction::Fetch => self
+                .default_fetch_remote
+                .write()
+                .map(|mut o| match remote {
+                    Some(gr) => o.replace(gr),
+                    None => o.take(),
+                })
+                .unwrap(),
+        };
+    }
+
+    pub fn operations(&self) -> Vec<String> {
+        self.operations
+            .read()
+            .map(|operations| operations.clone())
+            .unwrap_or_default()
+    }
+}
+
+#[allow(clippy::unwrap_used)]
+impl git::repository::OpenRepositoryLike for FakeOpenRepository {
+    fn remote_branches(&self) -> git::push::Result<Vec<config::BranchName>> {
+        todo!("MockOpenRepository::remote_branched")
+    }
+    fn find_default_remote(&self, direction: git::repository::Direction) -> Option<git::GitRemote> {
+        match direction {
+            git::repository::Direction::Push => self
+                .default_push_remote
+                .read()
+                .map(|r| r.clone())
+                .unwrap_or(None),
+            git::repository::Direction::Fetch => self
+                .default_fetch_remote
+                .read()
+                .map(|r| r.clone())
+                .unwrap_or(None),
+        }
+    }
+
+    fn fetch(&self) -> core::result::Result<(), crate::fetch::Error> {
+        self.operations
+            .write()
+            .map_err(|_| crate::fetch::Error::Lock)
+            .map(|mut operations| operations.push("fetch".to_string()))?;
+        Ok(())
+    }
+
+    fn push(
+        &self,
+        repo_details: &git::RepoDetails,
+        branch_name: &git_next_config::BranchName,
+        to_commit: &crate::GitRef,
+        force: &crate::push::Force,
+    ) -> core::result::Result<(), crate::push::Error> {
+        let forge_alias = repo_details.forge.forge_alias();
+        let repo_alias = &repo_details.repo_alias;
+        self.operations
+            .write()
+            .map_err(|_| crate::fetch::Error::Lock)
+            .map(|mut operations| {
+                operations.push(format!(
+                    "push fa:{forge_alias} ra:{repo_alias} bn:{branch_name} tc:{to_commit} f:{force}"
+                ))
+            })?;
+        Ok(())
+    }
+
+    fn commit_log(
+        &self,
+        _branch_name: &git_next_config::BranchName,
+        _find_commits: &[git::Commit],
+    ) -> core::result::Result<Vec<crate::Commit>, git::commit::log::Error> {
+        todo!("MockOpenRepository::commit_log")
+    }
+
+    fn read_file(
+        &self,
+        _branch_name: &git_next_config::BranchName,
+        _file_name: &Path,
+    ) -> git::file::Result<String> {
+        todo!("MockOpenRepository::read_file")
+    }
+
+    fn duplicate(&self) -> Box<dyn OpenRepositoryLike> {
+        Box::new(self.clone())
+    }
+}

crates/git/src/repository/open/tests.rs

@@ -0,0 +1,454 @@
+//
+use crate as git;
+use crate::repository::RepositoryLike as _;
+use git::tests::given;
+use git_next_config as config;
+
+use assert2::let_assert;
+type TestResult = Result<(), Box<dyn std::error::Error>>;
+
+mod server_repo_config {
+    use super::*;
+    use std::path::PathBuf;
+
+    use assert2::let_assert;
+
+    use crate::tests::given;
+
+    #[test]
+    fn should_not_return_repo_config_when_no_branches() {
+        let main = None;
+        let next = None;
+        let dev = None;
+        let src =
+            config::ServerRepoConfig::new(given::a_name(), given::a_name(), None, main, next, dev);
+
+        let_assert!(None = src.repo_config());
+    }
+
+    #[test]
+    fn should_return_repo_config_when_branches() {
+        let main = given::a_name();
+        let next = given::a_name();
+        let dev = given::a_name();
+        let src = config::ServerRepoConfig::new(
+            given::a_name(),
+            given::a_name(),
+            None,
+            Some(main.clone()),
+            Some(next.clone()),
+            Some(dev.clone()),
+        );
+
+        let_assert!(Some(rc) = src.repo_config());
+        assert_eq!(
+            rc,
+            config::RepoConfig::new(
+                config::RepoBranches::new(main, next, dev),
+                config::RepoConfigSource::Server
+            )
+        );
+    }
+
+    #[test]
+    fn should_return_repo() {
+        let repo_path = given::a_name();
+        let src = config::ServerRepoConfig::new(
+            repo_path.clone(),
+            given::a_name(),
+            None,
+            Some(given::a_name()),
+            Some(given::a_name()),
+            Some(given::a_name()),
+        );
+
+        assert_eq!(src.repo(), config::RepoPath::new(repo_path));
+    }
+
+    #[test]
+    fn should_return_branch() {
+        let branch = given::a_name();
+        let src = config::ServerRepoConfig::new(
+            given::a_name(),
+            branch.clone(),
+            None,
+            Some(given::a_name()),
+            Some(given::a_name()),
+            Some(given::a_name()),
+        );
+
+        assert_eq!(src.branch(), config::BranchName::new(branch));
+    }
+
+    #[test]
+    fn should_return_gitdir() {
+        let gitdir = given::a_name();
+        let src = config::ServerRepoConfig::new(
+            given::a_name(),
+            given::a_name(),
+            Some(gitdir.clone().into()),
+            Some(given::a_name()),
+            Some(given::a_name()),
+            Some(given::a_name()),
+        );
+
+        assert_eq!(
+            src.gitdir(),
+            Some(config::GitDir::new(PathBuf::default().join(gitdir)))
+        );
+    }
+}
+
+mod repo_config {
+
+    use super::*;
+
+    #[test]
+    fn should_parse_toml() -> TestResult {
+        let main = given::a_name();
+        let next = given::a_name();
+        let dev = given::a_name();
+        let toml = format!(
+            r#"
+        [branches]
+        main = "{main}"
+        next = "{next}"
+        dev = "{dev}"
+        "#
+        );
+
+        let rc = config::RepoConfig::parse(toml.as_str())?;
+
+        assert_eq!(
+            rc,
+            config::RepoConfig::new(
+                config::RepoBranches::new(main, next, dev),
+                config::RepoConfigSource::Repo // reading from repo is the default
+            )
+        );
+
+        Ok(())
+    }
+    #[test]
+    fn should_return_branches() {
+        let main = given::a_name();
+        let next = given::a_name();
+        let dev = given::a_name();
+        let branches = config::RepoBranches::new(main, next, dev);
+        let repo_config = config::RepoConfig::new(branches.clone(), config::RepoConfigSource::Repo);
+
+        assert_eq!(repo_config.branches(), &branches);
+    }
+    #[test]
+    fn should_return_source() {
+        let main = given::a_name();
+        let next = given::a_name();
+        let dev = given::a_name();
+        let repo_config = config::RepoConfig::new(
+            config::RepoBranches::new(main, next, dev),
+            config::RepoConfigSource::Repo,
+        );
+
+        assert_eq!(repo_config.source(), config::RepoConfigSource::Repo);
+    }
+}
+
+mod forge_config {
+    use super::*;
+    use std::collections::BTreeMap;
+
+    use secrecy::ExposeSecret;
+
+    use crate::tests::given;
+
+    #[test]
+    fn should_return_repos() {
+        let forge_type = config::ForgeType::MockForge;
+        let hostname = given::a_name();
+        let user = given::a_name();
+        let token = given::a_name();
+        // alphabetical order by key
+        let red_name = format!("a-{}", given::a_name());
+        let blue_name = format!("b-{}", given::a_name());
+        let red = config::ServerRepoConfig::new(
+            red_name.clone(),
+            given::a_name(),
+            None,
+            None,
+            None,
+            None,
+        );
+        let blue = config::ServerRepoConfig::new(
+            blue_name.clone(),
+            given::a_name(),
+            None,
+            None,
+            None,
+            None,
+        );
+        let mut repos = BTreeMap::new();
+        repos.insert(red_name.clone(), red.clone());
+        repos.insert(blue_name.clone(), blue.clone());
+        let fc = config::ForgeConfig::new(forge_type, hostname, user, token, repos);
+
+        let returned_repos = fc.repos().collect::<Vec<_>>();
+
+        assert_eq!(
+            returned_repos,
+            vec![
+                // alphabetical order by key
+                (config::RepoAlias::new(red_name.as_str()), &red),
+                (config::RepoAlias::new(blue_name.as_str()), &blue),
+            ]
+        );
+    }
+
+    #[test]
+    fn should_return_forge_type() {
+        let forge_type = config::ForgeType::MockForge;
+        let hostname = given::a_name();
+        let user = given::a_name();
+        let token = given::a_name();
+        let repos = BTreeMap::new();
+        let fc = config::ForgeConfig::new(forge_type, hostname, user, token, repos);
+
+        assert_eq!(fc.forge_type(), config::ForgeType::MockForge);
+    }
+
+    #[test]
+    fn should_return_hostname() {
+        let forge_type = config::ForgeType::MockForge;
+        let hostname = given::a_name();
+        let user = given::a_name();
+        let token = given::a_name();
+        let repos = BTreeMap::new();
+        let fc = config::ForgeConfig::new(forge_type, hostname.clone(), user, token, repos);
+
+        assert_eq!(fc.hostname(), config::Hostname::new(hostname));
+    }
+
+    #[test]
+    fn should_return_user() {
+        let forge_type = config::ForgeType::MockForge;
+        let hostname = given::a_name();
+        let user = given::a_name();
+        let token = given::a_name();
+        let repos = BTreeMap::new();
+        let fc = config::ForgeConfig::new(forge_type, hostname, user.clone(), token, repos);
+
+        assert_eq!(fc.user(), config::User::new(user));
+    }
+
+    #[test]
+    fn should_return_token() {
+        let forge_type = config::ForgeType::MockForge;
+        let hostname = given::a_name();
+        let user = given::a_name();
+        let token = given::a_name();
+        let repos = BTreeMap::new();
+        let fc = config::ForgeConfig::new(forge_type, hostname, user, token.clone(), repos);
+
+        assert_eq!(fc.token().expose_secret(), token.as_str());
+    }
+
+    #[test]
+    fn should_return_repo() {
+        let forge_type = config::ForgeType::MockForge;
+        let hostname = given::a_name();
+        let user = given::a_name();
+        let token = given::a_name();
+        let red_name = given::a_name();
+        let blue_name = given::a_name();
+        let red = config::ServerRepoConfig::new(
+            red_name.clone(),
+            given::a_name(),
+            None,
+            None,
+            None,
+            None,
+        );
+        let blue = config::ServerRepoConfig::new(
+            blue_name.clone(),
+            given::a_name(),
+            None,
+            None,
+            None,
+            None,
+        );
+
+        let mut repos = BTreeMap::new();
+        repos.insert(red_name.clone(), red.clone());
+        repos.insert(blue_name, blue);
+        let fc = config::ForgeConfig::new(forge_type, hostname, user, token, repos);
+
+        let returned_repo = fc.get_repo(red_name.as_str());
+
+        assert_eq!(returned_repo, Some(&red),);
+    }
+}
+
+mod find_default_remote {
+    use super::*;
+
+    use assert2::let_assert;
+
+    #[test]
+    fn should_find_default_push_remote() {
+        // uses the current repo
+        let_assert!(Ok(cwd) = std::env::current_dir());
+        let gitdir = config::GitDir::from(cwd.join("../..")); // from ./crate/git directory to the project rook
+        let_assert!(Ok(repo) = crate::repository::real().open(&gitdir));
+        let_assert!(Some(remote) = repo.find_default_remote(crate::repository::Direction::Push));
+        assert_eq!(
+            remote,
+            git::GitRemote::new(
+                config::Hostname::new("git.kemitix.net"),
+                config::RepoPath::new("kemitix/git-next".to_string())
+            )
+        )
+    }
+}
+
+mod fetch {
+    use assert2::let_assert;
+    use git_next_config::GitDir;
+
+    #[test]
+    #[ignore] // requires authentication to the server - which the CI doesn't have
+    fn should_fetch_from_repo() {
+        // uses the current repo and fetches from the remote server
+        let_assert!(Ok(cwd) = std::env::current_dir());
+        let gitdir = GitDir::from(cwd.join("../.."));
+        let_assert!(Ok(repo) = crate::repository::real().open(&gitdir));
+        let_assert!(Ok(_) = repo.fetch());
+    }
+}
+
+mod commit_log {
+    use git::tests::given;
+
+    use crate::tests::then;
+
+    use super::*;
+
+    #[test]
+    // assumes running in the git-next repo which should have main, next and dev as remote branches
+    fn should_return_single_item_in_commit_log_when_not_searching() -> TestResult {
+        let_assert!(Ok(fs) = kxio::fs::temp());
+        let gitdir: config::GitDir = fs.base().to_path_buf().into();
+        let test_repository = git::repository::test(fs.clone());
+        let_assert!(Ok(open_repository) = test_repository.open(&gitdir));
+        let repo_config = &given::a_repo_config();
+        let branches = repo_config.branches();
+        then::create_a_commit_on_branch(&fs, &gitdir, &branches.main())?;
+        then::create_a_commit_on_branch(&fs, &gitdir, &branches.main())?;
+        let_assert!(Ok(result) = open_repository.commit_log(&branches.main(), &[]));
+        assert_eq!(result.len(), 1);
+        Ok(())
+    }
+
+    #[test]
+    // assumes running in the git-next repo which should have main, next and dev as remote branches
+    fn should_return_capacity_50_in_commit_log_when_searching_for_garbage() -> TestResult {
+        let_assert!(Ok(fs) = kxio::fs::temp());
+        let branch_name = given::a_branch_name();
+        let gitdir: config::GitDir = fs.base().to_path_buf().into();
+        let test_repository = git::repository::test(fs.clone());
+        let_assert!(Ok(open_repository) = test_repository.open(&gitdir));
+        for _ in [0; 60] {
+            // create 60 commits
+            then::create_a_commit_on_branch(&fs, &gitdir, &branch_name)?;
+        }
+        let_assert!(Ok(result) = open_repository.commit_log(&branch_name, &[given::a_commit()]));
+        assert_eq!(result.len(), 50);
+        Ok(())
+    }
+
+    #[test]
+    // assumes running in the git-next repo which should have main, next and dev as remote branches
+    fn should_return_5_in_commit_log_when_searching_for_5th_item() -> TestResult {
+        let_assert!(Ok(fs) = kxio::fs::temp(), "create temp directory");
+        let branch_name = given::a_branch_name();
+        let gitdir: config::GitDir = fs.base().to_path_buf().into();
+        let test_repository = git::repository::test(fs.clone());
+        let_assert!(
+            Ok(open_repository) = test_repository.open(&gitdir),
+            "open repository"
+        );
+        for _ in [0; 10] {
+            then::create_a_commit_on_branch(&fs, &gitdir, &branch_name)?;
+        }
+        // search to garbage to get all 10 items
+        let_assert!(
+            Ok(long_list) = open_repository.commit_log(&branch_name, &[given::a_commit()]),
+            "get commit_log"
+        );
+        // pick the 5th item
+        let search = &long_list[4]; // zero-based
+                                    // search for the 25th item
+        let_assert!(
+            Ok(result) = open_repository.commit_log(&branch_name, &[search.clone()]),
+            "get commit log"
+        );
+        // returns
+        assert_eq!(result.len(), 5);
+
+        Ok(())
+    }
+}
+
+mod read_file {
+
+    use git::tests::given;
+    use git::tests::then;
+
+    type TestResult = Result<(), Box<dyn std::error::Error>>;
+
+    use super::*;
+
+    #[test]
+    // assumes running in the git-next repo which should have main, next and dev as remote branches
+    fn should_return_file() -> TestResult {
+        let_assert!(Ok(fs) = kxio::fs::temp());
+        let repo_config = given::a_repo_config();
+        let file_name = given::a_pathbuf();
+        let contents = given::a_name();
+        let gitdir: config::GitDir = fs.base().to_path_buf().into();
+
+        let test_repository = git::repository::test(fs.clone());
+        let_assert!(Ok(open_repository) = test_repository.open(&gitdir));
+        then::commit_named_file_to_branch(
+            &file_name,
+            &contents,
+            &fs,
+            &gitdir,
+            &repo_config.branches().main(),
+        )?;
+        // then::create_a_commit_on_branch(&fs, &gitdir, &repo_config.branches().main())?;
+        let_assert!(
+            Ok(result) = open_repository.read_file(&repo_config.branches().main(), &file_name),
+            "read file"
+        );
+        assert_eq!(result, contents);
+        Ok(())
+    }
+
+    #[test]
+    // assumes running in the git-next repo which should have main, next and dev as remote branches
+    fn should_error_on_missing_file() -> TestResult {
+        let_assert!(Ok(fs) = kxio::fs::temp());
+        let gitdir: config::GitDir = fs.base().to_path_buf().into();
+        let test_repository = git::repository::test(fs.clone());
+        let_assert!(Ok(open_repository) = test_repository.open(&gitdir));
+        let repo_config = &given::a_repo_config();
+        let branches = repo_config.branches();
+        then::create_a_commit_on_branch(&fs, &gitdir, &branches.dev())?;
+        let_assert!(
+            Err(err) = open_repository.read_file(&branches.dev(), &given::a_pathbuf()),
+            "read file"
+        );
+        eprintln!("err: {err:#?}");
+        assert!(matches!(err, git::file::Error::FileNotFound));
+        Ok(())
+    }
+}

crates/git/src/repository/open/tests/commit_log.rs

@@ -1,75 +0,0 @@
-use super::*;
-
-#[test]
-// assumes running in the git-next repo which should have main, next and dev as remote branches
-fn should_return_single_item_in_commit_log_when_not_searching() -> TestResult {
-    let_assert!(Ok(fs) = kxio::fs::temp());
-    let gitdir = GitDir::new(
-        fs.base().to_path_buf(),
-        config::git_dir::StoragePathType::Internal,
-    );
-    let test_repository = git::repository::test(fs.clone());
-    let_assert!(Ok(open_repository) = test_repository.open(&gitdir));
-    let repo_config = &given::a_repo_config();
-    let branches = repo_config.branches();
-    then::create_a_commit_on_branch(&fs, &gitdir, &branches.main())?;
-    then::create_a_commit_on_branch(&fs, &gitdir, &branches.main())?;
-    let_assert!(Ok(result) = open_repository.commit_log(&branches.main(), &[]));
-    assert_eq!(result.len(), 1);
-    Ok(())
-}
-
-#[test]
-// assumes running in the git-next repo which should have main, next and dev as remote branches
-fn should_return_capacity_50_in_commit_log_when_searching_for_garbage() -> TestResult {
-    let_assert!(Ok(fs) = kxio::fs::temp());
-    let branch_name = given::a_branch_name();
-    let gitdir = GitDir::new(
-        fs.base().to_path_buf(),
-        config::git_dir::StoragePathType::Internal,
-    );
-    let test_repository = git::repository::test(fs.clone());
-    let_assert!(Ok(open_repository) = test_repository.open(&gitdir));
-    for _ in [0; 60] {
-        // create 60 commits
-        then::create_a_commit_on_branch(&fs, &gitdir, &branch_name)?;
-    }
-    let_assert!(Ok(result) = open_repository.commit_log(&branch_name, &[given::a_commit()]));
-    assert_eq!(result.len(), 50);
-    Ok(())
-}
-
-#[test]
-// assumes running in the git-next repo which should have main, next and dev as remote branches
-fn should_return_5_in_commit_log_when_searching_for_5th_item() -> TestResult {
-    let_assert!(Ok(fs) = kxio::fs::temp(), "create temp directory");
-    let branch_name = given::a_branch_name();
-    let gitdir = GitDir::new(
-        fs.base().to_path_buf(),
-        config::git_dir::StoragePathType::Internal,
-    );
-    let test_repository = git::repository::test(fs.clone());
-    let_assert!(
-        Ok(open_repository) = test_repository.open(&gitdir),
-        "open repository"
-    );
-    for _ in [0; 10] {
-        then::create_a_commit_on_branch(&fs, &gitdir, &branch_name)?;
-    }
-    // search to garbage to get all 10 items
-    let_assert!(
-        Ok(long_list) = open_repository.commit_log(&branch_name, &[given::a_commit()]),
-        "get commit_log"
-    );
-    // pick the 5th item
-    let search = &long_list[4]; // zero-based
-                                // search for the 25th item
-    let_assert!(
-        Ok(result) = open_repository.commit_log(&branch_name, &[search.clone()]),
-        "get commit log"
-    );
-    // returns
-    assert_eq!(result.len(), 5);
-
-    Ok(())
-}

crates/git/src/repository/open/tests/fetch.rs

@@ -1,14 +0,0 @@
-use super::*;
-
-#[test]
-#[ignore] // requires authentication to the server - which the CI doesn't have
-fn should_fetch_from_repo() {
-    // uses the current repo and fetches from the remote server
-    let_assert!(Ok(cwd) = std::env::current_dir());
-    let gitdir = GitDir::new(
-        cwd.join("../.."),
-        config::git_dir::StoragePathType::External,
-    );
-    let_assert!(Ok(repo) = crate::repository::factory::real().open(&gitdir));
-    let_assert!(Ok(_) = repo.fetch());
-}

crates/git/src/repository/open/tests/find_default_remote.rs

@@ -1,20 +0,0 @@
-use super::*;
-
-#[test]
-fn should_find_default_push_remote() {
-    // uses the current repo
-    let_assert!(Ok(cwd) = std::env::current_dir());
-    let gitdir = config::GitDir::new(
-        cwd.join("../.."),
-        config::git_dir::StoragePathType::External,
-    ); // from ./crate/git directory to the project root
-    let_assert!(Ok(repo) = git::repository::factory::real().open(&gitdir));
-    let_assert!(Some(remote) = repo.find_default_remote(crate::repository::Direction::Push));
-    assert_eq!(
-        remote,
-        git::GitRemote::new(
-            config::Hostname::new("git.kemitix.net"),
-            config::RepoPath::new("kemitix/git-next".to_string())
-        )
-    )
-}

crates/git/src/repository/open/tests/forge_config.rs

@@ -1,102 +0,0 @@
-use super::*;
-
-#[test]
-fn should_return_repos() {
-    let forge_type = config::ForgeType::MockForge;
-    let hostname = given::a_name();
-    let user = given::a_name();
-    let token = given::a_name();
-    // alphabetical order by key
-    let red_name = format!("a-{}", given::a_name());
-    let blue_name = format!("b-{}", given::a_name());
-    let red =
-        config::ServerRepoConfig::new(red_name.clone(), given::a_name(), None, None, None, None);
-    let blue =
-        config::ServerRepoConfig::new(blue_name.clone(), given::a_name(), None, None, None, None);
-    let mut repos = BTreeMap::new();
-    repos.insert(red_name.clone(), red.clone());
-    repos.insert(blue_name.clone(), blue.clone());
-    let fc = config::ForgeConfig::new(forge_type, hostname, user, token, repos);
-
-    let returned_repos = fc.repos().collect::<Vec<_>>();
-
-    assert_eq!(
-        returned_repos,
-        vec![
-            // alphabetical order by key
-            (config::RepoAlias::new(red_name.as_str()), &red),
-            (config::RepoAlias::new(blue_name.as_str()), &blue),
-        ]
-    );
-}
-
-#[test]
-fn should_return_forge_type() {
-    let forge_type = config::ForgeType::MockForge;
-    let hostname = given::a_name();
-    let user = given::a_name();
-    let token = given::a_name();
-    let repos = BTreeMap::new();
-    let fc = config::ForgeConfig::new(forge_type, hostname, user, token, repos);
-
-    assert_eq!(fc.forge_type(), config::ForgeType::MockForge);
-}
-
-#[test]
-fn should_return_hostname() {
-    let forge_type = config::ForgeType::MockForge;
-    let hostname = given::a_name();
-    let user = given::a_name();
-    let token = given::a_name();
-    let repos = BTreeMap::new();
-    let fc = config::ForgeConfig::new(forge_type, hostname.clone(), user, token, repos);
-
-    assert_eq!(fc.hostname(), config::Hostname::new(hostname));
-}
-
-#[test]
-fn should_return_user() {
-    let forge_type = config::ForgeType::MockForge;
-    let hostname = given::a_name();
-    let user = given::a_name();
-    let token = given::a_name();
-    let repos = BTreeMap::new();
-    let fc = config::ForgeConfig::new(forge_type, hostname, user.clone(), token, repos);
-
-    assert_eq!(fc.user(), config::User::new(user));
-}
-
-#[test]
-fn should_return_token() {
-    let forge_type = config::ForgeType::MockForge;
-    let hostname = given::a_name();
-    let user = given::a_name();
-    let token = given::a_name();
-    let repos = BTreeMap::new();
-    let fc = config::ForgeConfig::new(forge_type, hostname, user, token.clone(), repos);
-
-    assert_eq!(fc.token().expose_secret(), token.as_str());
-}
-
-#[test]
-fn should_return_repo() {
-    let forge_type = config::ForgeType::MockForge;
-    let hostname = given::a_name();
-    let user = given::a_name();
-    let token = given::a_name();
-    let red_name = given::a_name();
-    let blue_name = given::a_name();
-    let red =
-        config::ServerRepoConfig::new(red_name.clone(), given::a_name(), None, None, None, None);
-    let blue =
-        config::ServerRepoConfig::new(blue_name.clone(), given::a_name(), None, None, None, None);
-
-    let mut repos = BTreeMap::new();
-    repos.insert(red_name.clone(), red.clone());
-    repos.insert(blue_name, blue);
-    let fc = config::ForgeConfig::new(forge_type, hostname, user, token, repos);
-
-    let returned_repo = fc.get_repo(red_name.as_str());
-
-    assert_eq!(returned_repo, Some(&red),);
-}

crates/git/src/repository/open/tests/mod.rs

@@ -1,21 +0,0 @@
-//
-use crate as git;
-use assert2::let_assert;
-use config::GitDir;
-use git::repository::RepositoryLike as _;
-use git::tests::given;
-use git::tests::then;
-use git_next_config as config;
-use secrecy::ExposeSecret;
-use std::collections::BTreeMap;
-use std::path::PathBuf;
-
-type TestResult = Result<(), Box<dyn std::error::Error>>;
-
-mod commit_log;
-mod fetch;
-mod find_default_remote;
-mod forge_config;
-mod read_file;
-mod repo_config;
-mod server_repo_config;

crates/git/src/repository/open/tests/read_file.rs

@@ -1,53 +0,0 @@
-use super::*;
-
-#[test]
-// assumes running in the git-next repo which should have main, next and dev as remote branches
-fn should_return_file() -> TestResult {
-    let_assert!(Ok(fs) = kxio::fs::temp());
-    let repo_config = given::a_repo_config();
-    let file_name = given::a_pathbuf();
-    let contents = given::a_name();
-    let gitdir = GitDir::new(
-        fs.base().to_path_buf(),
-        config::git_dir::StoragePathType::Internal,
-    );
-
-    let test_repository = git::repository::test(fs.clone());
-    let_assert!(Ok(open_repository) = test_repository.open(&gitdir));
-    then::commit_named_file_to_branch(
-        &file_name,
-        &contents,
-        &fs,
-        &gitdir,
-        &repo_config.branches().main(),
-    )?;
-    // then::create_a_commit_on_branch(&fs, &gitdir, &repo_config.branches().main())?;
-    let_assert!(
-        Ok(result) = open_repository.read_file(&repo_config.branches().main(), &file_name),
-        "read file"
-    );
-    assert_eq!(result, contents);
-    Ok(())
-}
-
-#[test]
-// assumes running in the git-next repo which should have main, next and dev as remote branches
-fn should_error_on_missing_file() -> TestResult {
-    let_assert!(Ok(fs) = kxio::fs::temp());
-    let gitdir = GitDir::new(
-        fs.base().to_path_buf(),
-        config::git_dir::StoragePathType::Internal,
-    );
-    let test_repository = git::repository::test(fs.clone());
-    let_assert!(Ok(open_repository) = test_repository.open(&gitdir));
-    let repo_config = &given::a_repo_config();
-    let branches = repo_config.branches();
-    then::create_a_commit_on_branch(&fs, &gitdir, &branches.dev())?;
-    let_assert!(
-        Err(err) = open_repository.read_file(&branches.dev(), &given::a_pathbuf()),
-        "read file"
-    );
-    eprintln!("err: {err:#?}");
-    assert!(matches!(err, git::file::Error::FileNotFound));
-    Ok(())
-}

crates/git/src/repository/open/tests/repo_config.rs

@@ -1,50 +0,0 @@
-use super::*;
-
-#[test]
-fn should_parse_toml() -> TestResult {
-    let main = given::a_name();
-    let next = given::a_name();
-    let dev = given::a_name();
-    let toml = format!(
-        r#"
-        [branches]
-        main = "{main}"
-        next = "{next}"
-        dev = "{dev}"
-        "#
-    );
-
-    let rc = config::RepoConfig::parse(toml.as_str())?;
-
-    assert_eq!(
-        rc,
-        config::RepoConfig::new(
-            config::RepoBranches::new(main, next, dev),
-            config::RepoConfigSource::Repo // reading from repo is the default
-        )
-    );
-
-    Ok(())
-}
-#[test]
-fn should_return_branches() {
-    let main = given::a_name();
-    let next = given::a_name();
-    let dev = given::a_name();
-    let branches = config::RepoBranches::new(main, next, dev);
-    let repo_config = config::RepoConfig::new(branches.clone(), config::RepoConfigSource::Repo);
-
-    assert_eq!(repo_config.branches(), &branches);
-}
-#[test]
-fn should_return_source() {
-    let main = given::a_name();
-    let next = given::a_name();
-    let dev = given::a_name();
-    let repo_config = config::RepoConfig::new(
-        config::RepoBranches::new(main, next, dev),
-        config::RepoConfigSource::Repo,
-    );
-
-    assert_eq!(repo_config.source(), config::RepoConfigSource::Repo);
-}

crates/git/src/repository/open/tests/server_repo_config.rs

@@ -1,87 +0,0 @@
-use super::*;
-
-#[test]
-fn should_not_return_repo_config_when_no_branches() {
-    let main = None;
-    let next = None;
-    let dev = None;
-    let src =
-        config::ServerRepoConfig::new(given::a_name(), given::a_name(), None, main, next, dev);
-
-    let_assert!(None = src.repo_config());
-}
-
-#[test]
-fn should_return_repo_config_when_branches() {
-    let main = given::a_name();
-    let next = given::a_name();
-    let dev = given::a_name();
-    let src = config::ServerRepoConfig::new(
-        given::a_name(),
-        given::a_name(),
-        None,
-        Some(main.clone()),
-        Some(next.clone()),
-        Some(dev.clone()),
-    );
-
-    let_assert!(Some(rc) = src.repo_config());
-    assert_eq!(
-        rc,
-        config::RepoConfig::new(
-            config::RepoBranches::new(main, next, dev),
-            config::RepoConfigSource::Server
-        )
-    );
-}
-
-#[test]
-fn should_return_repo() {
-    let repo_path = given::a_name();
-    let src = config::ServerRepoConfig::new(
-        repo_path.clone(),
-        given::a_name(),
-        None,
-        Some(given::a_name()),
-        Some(given::a_name()),
-        Some(given::a_name()),
-    );
-
-    assert_eq!(src.repo(), config::RepoPath::new(repo_path));
-}
-
-#[test]
-fn should_return_branch() {
-    let branch = given::a_name();
-    let src = config::ServerRepoConfig::new(
-        given::a_name(),
-        branch.clone(),
-        None,
-        Some(given::a_name()),
-        Some(given::a_name()),
-        Some(given::a_name()),
-    );
-
-    assert_eq!(src.branch(), config::BranchName::new(branch));
-}
-
-#[test]
-fn should_return_gitdir() {
-    let gitdir = given::a_name();
-    let src = config::ServerRepoConfig::new(
-        given::a_name(),
-        given::a_name(),
-        Some(gitdir.clone().into()),
-        Some(given::a_name()),
-        Some(given::a_name()),
-        Some(given::a_name()),
-    );
-
-    assert_eq!(
-        src.gitdir(),
-        Some(GitDir::new(
-            PathBuf::default().join(gitdir),
-            config::StoragePathType::External,
-        ))
-    );
-}

crates/git/src/repository/tests.rs

@@ -0,0 +1,100 @@
+use crate as git;
+
+mod validate {
+    use crate::{tests::given, validation::remotes::validate_default_remotes};
+
+    use super::*;
+    use git::repository::Direction;
+
+    #[test]
+    fn should_ok_a_valid_repo() {
+        let fs = given::a_filesystem();
+        let repo_details = given::repo_details(&fs);
+        let repo_details_mock = repo_details.clone();
+
+        let mut open_repository = git::repository::open::mock();
+        open_repository
+            .expect_find_default_remote()
+            .returning(move |_direction| Some(repo_details_mock.git_remote()));
+
+        let result = validate_default_remotes(&*open_repository, &repo_details);
+        println!("{result:?}");
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn should_fail_where_no_default_push_remote() {
+        let fs = given::a_filesystem();
+        let repo_details = given::repo_details(&fs);
+        let repo_details_mock = repo_details.clone();
+
+        let mut open_repository = git::repository::open::mock();
+        open_repository
+            .expect_find_default_remote()
+            .returning(move |direction| match direction {
+                Direction::Push => None,
+                Direction::Fetch => Some(repo_details_mock.git_remote()),
+            });
+
+        let result = validate_default_remotes(&*open_repository, &repo_details);
+        println!("{result:?}");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn should_fail_where_no_default_fetch_remote() {
+        let fs = given::a_filesystem();
+        let repo_details = given::repo_details(&fs);
+        let repo_details_mock = repo_details.clone();
+
+        let mut open_repository = git::repository::open::mock();
+        open_repository
+            .expect_find_default_remote()
+            .returning(move |direction| match direction {
+                Direction::Push => Some(repo_details_mock.git_remote()),
+                Direction::Fetch => None,
+            });
+
+        let result = validate_default_remotes(&*open_repository, &repo_details);
+        println!("{result:?}");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn should_fail_where_invalid_default_push_remote() {
+        let fs = given::a_filesystem();
+        let repo_details = given::repo_details(&fs);
+        let repo_details_mock = repo_details.clone();
+
+        let mut open_repository = git::repository::open::mock();
+        open_repository
+            .expect_find_default_remote()
+            .returning(move |direction| match direction {
+                Direction::Push => Some(given::a_git_remote()),
+                Direction::Fetch => Some(repo_details_mock.git_remote()),
+            });
+
+        let result = validate_default_remotes(&*open_repository, &repo_details);
+        println!("{result:?}");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn should_fail_where_invalid_default_fetch_remote() {
+        let fs = given::a_filesystem();
+        let repo_details = given::repo_details(&fs);
+        let repo_details_mock = repo_details.clone();
+
+        let mut open_repository = git::repository::open::mock();
+        open_repository
+            .expect_find_default_remote()
+            .returning(move |direction| match direction {
+                Direction::Push => Some(repo_details_mock.git_remote()),
+                Direction::Fetch => Some(given::a_git_remote()),
+            });
+
+        let result = validate_default_remotes(&*open_repository, &repo_details);
+        println!("{result:?}");
+        assert!(result.is_err());
+    }
+}

crates/git/src/repository/tests/factory.rs

@@ -1,52 +0,0 @@
-use git_next_config::GitDir;
-
-use super::*;
-
-use crate::tests::given;
-
-// clone - can't test are this required a remote server (git_clone only works with https origins)
-// open
-// - outside storage path
-#[test_log::test]
-fn open_where_storage_external() -> TestResult {
-    //given
-    let fs = given::a_filesystem();
-    // create a bare repo
-    let _x = gix::prepare_clone_bare("https://user:auth@git.kemitix.net/user/repo.git", fs.base())?;
-    let gitdir = GitDir::new(
-        fs.base().to_path_buf(),
-        git_next_config::git_dir::Provenance::Internal,
-    );
-    let factory = crate::repository::factory::real();
-
-    //when
-    let result = factory.open(&gitdir);
-
-    //then
-    tracing::debug!(?result, "open");
-    assert!(result.is_ok());
-    Ok(())
-}
-// - in storage path
-#[test_log::test]
-fn open_where_storage_internal() -> TestResult {
-    //given
-    let fs = given::a_filesystem();
-    // create a bare repo
-    let _x = gix::prepare_clone_bare("https://user:auth@git.kemitix.net/user/repo.git", fs.base())?;
-    let gitdir = GitDir::new(
-        fs.base().to_path_buf(),
-        git_next_config::git_dir::Provenance::Internal,
-    );
-    let factory = crate::repository::factory::real();
-
-    //when
-    let result = factory.open(&gitdir);
-
-    //then
-    tracing::debug!(?result, "open");
-    assert!(result.is_ok());
-    Ok(())
-}
-// - - auth matches
-// - - NEW: auth does not match

crates/git/src/repository/tests/mod.rs

@@ -1,3 +0,0 @@
-use crate as git;
-
-mod validate;

crates/git/src/repository/tests/validate.rs

@@ -1,94 +0,0 @@
-use super::*;
-use git::{repository::Direction, tests::given, validation::remotes::validate_default_remotes};
-
-#[test]
-fn should_ok_a_valid_repo() {
-    let fs = given::a_filesystem();
-    let repo_details = given::repo_details(&fs);
-    let repo_details_mock = repo_details.clone();
-
-    let mut open_repository = git::repository::open::mock();
-    open_repository
-        .expect_find_default_remote()
-        .returning(move |_direction| Some(repo_details_mock.git_remote()));
-
-    let result = validate_default_remotes(&*open_repository, &repo_details);
-    println!("{result:?}");
-    assert!(result.is_ok());
-}
-
-#[test]
-fn should_fail_where_no_default_push_remote() {
-    let fs = given::a_filesystem();
-    let repo_details = given::repo_details(&fs);
-    let repo_details_mock = repo_details.clone();
-
-    let mut open_repository = git::repository::open::mock();
-    open_repository
-        .expect_find_default_remote()
-        .returning(move |direction| match direction {
-            Direction::Push => None,
-            Direction::Fetch => Some(repo_details_mock.git_remote()),
-        });
-
-    let result = validate_default_remotes(&*open_repository, &repo_details);
-    println!("{result:?}");
-    assert!(result.is_err());
-}
-
-#[test]
-fn should_fail_where_no_default_fetch_remote() {
-    let fs = given::a_filesystem();
-    let repo_details = given::repo_details(&fs);
-    let repo_details_mock = repo_details.clone();
-
-    let mut open_repository = git::repository::open::mock();
-    open_repository
-        .expect_find_default_remote()
-        .returning(move |direction| match direction {
-            Direction::Push => Some(repo_details_mock.git_remote()),
-            Direction::Fetch => None,
-        });
-
-    let result = validate_default_remotes(&*open_repository, &repo_details);
-    println!("{result:?}");
-    assert!(result.is_err());
-}
-
-#[test]
-fn should_fail_where_invalid_default_push_remote() {
-    let fs = given::a_filesystem();
-    let repo_details = given::repo_details(&fs);
-    let repo_details_mock = repo_details.clone();
-
-    let mut open_repository = git::repository::open::mock();
-    open_repository
-        .expect_find_default_remote()
-        .returning(move |direction| match direction {
-            Direction::Push => Some(given::a_git_remote()),
-            Direction::Fetch => Some(repo_details_mock.git_remote()),
-        });
-
-    let result = validate_default_remotes(&*open_repository, &repo_details);
-    println!("{result:?}");
-    assert!(result.is_err());
-}
-
-#[test]
-fn should_fail_where_invalid_default_fetch_remote() {
-    let fs = given::a_filesystem();
-    let repo_details = given::repo_details(&fs);
-    let repo_details_mock = repo_details.clone();
-
-    let mut open_repository = git::repository::open::mock();
-    open_repository
-        .expect_find_default_remote()
-        .returning(move |direction| match direction {
-            Direction::Push => Some(repo_details_mock.git_remote()),
-            Direction::Fetch => Some(given::a_git_remote()),
-        });
-
-    let result = validate_default_remotes(&*open_repository, &repo_details);
-    println!("{result:?}");
-    assert!(result.is_err());
-}

crates/git/src/tests.rs

@@ -144,8 +144,7 @@ mod repo_details {
     use std::{collections::BTreeMap, path::PathBuf};
 
     use git_next_config::{
-        git_dir::StoragePathType, ForgeAlias, ForgeConfig, ForgeType, GitDir, Hostname, RepoAlias,
+        ForgeAlias, ForgeConfig, ForgeType, GitDir, Hostname, RepoAlias, RepoPath, ServerRepoConfig,
-        RepoPath, ServerRepoConfig,
     };
     use secrecy::ExposeSecret;
 
@@ -172,7 +171,7 @@ mod repo_details {
                 "token".to_string(),
                 BTreeMap::new(),
             ),
-            GitDir::new(PathBuf::default().join("foo"), StoragePathType::Internal),
+            GitDir::from(PathBuf::default().join("foo")),
         );
 
         assert_eq!(
@@ -201,7 +200,7 @@ mod repo_details {
                 "token".to_string(),
                 BTreeMap::new(),
             ),
-            GitDir::new(PathBuf::default().join("foo"), StoragePathType::Internal),
+            GitDir::from(PathBuf::default().join("foo")),
         );
 
         assert_eq!(
@@ -216,7 +215,7 @@ mod repo_details {
 pub mod given {
     use std::path::PathBuf;
 
-    use crate::{self as git, repository::open::MockOpenRepositoryLike};
+    use crate as git;
     use config::{
         BranchName, ForgeAlias, ForgeConfig, ForgeType, GitDir, RepoAlias, RepoBranches,
         RepoConfig, ServerRepoConfig,
@@ -264,7 +263,7 @@ pub mod given {
     pub fn a_git_dir(fs: &kxio::fs::FileSystem) -> GitDir {
         let dir_name = a_name();
         let dir = fs.base().join(dir_name);
-        GitDir::new(dir, config::git_dir::StoragePathType::Internal)
+        GitDir::new(dir)
     }
 
     pub fn a_forge_config() -> ForgeConfig {
@@ -327,25 +326,6 @@ pub mod given {
         kxio::fs::temp().unwrap_or_else(|e| panic!("{}", e))
     }
 
-    pub fn an_open_repository(
-        fs: &kxio::fs::FileSystem,
-    ) -> (
-        git::repository::open::MockOpenRepositoryLike,
-        git::RepoDetails,
-    ) {
-        let open_repository = MockOpenRepositoryLike::new();
-        let gitdir = given::a_git_dir(fs);
-        let hostname = given::a_hostname();
-        let repo_details = given::repo_details(fs)
-            .with_gitdir(gitdir)
-            .with_hostname(hostname);
-        (open_repository, repo_details)
-    }
-
-    pub fn a_hostname() -> config::Hostname {
-        config::Hostname::new(given::a_name())
-    }
-
     pub fn repo_details(fs: &kxio::fs::FileSystem) -> git::RepoDetails {
         let generation = git::Generation::default();
         let repo_alias = a_repo_alias();

crates/git/src/validation/tests.rs

@@ -10,8 +10,6 @@ use assert2::let_assert;
 
 mod repos {
 
-    use config::{git_dir::StoragePathType, GitDir};
-
     use crate::repository::Direction;
 
     use super::*;
@@ -19,13 +17,13 @@ mod repos {
     #[test]
     fn where_repo_has_no_push_remote() {
         let_assert!(Ok(fs) = kxio::fs::temp(), "temp fs");
-        let gitdir = GitDir::new(fs.base().to_path_buf(), StoragePathType::Internal);
+        let gitdir: config::GitDir = fs.base().to_path_buf().into();
         let mut mock_open_repository = git::repository::open::mock();
         mock_open_repository
             .expect_find_default_remote()
             .with(mockall::predicate::eq(Direction::Push))
             .return_once(|_| None);
-        let mut repository_factory = git::repository::factory::mock();
+        let mut repository_factory = git::repository::mock();
         repository_factory
             .expect_open()
             .return_once(move |_| Ok(mock_open_repository));
@@ -51,7 +49,6 @@ mod positions {
 
     mod validate_positions {
 
-        use config::{git_dir::StoragePathType, GitDir};
         use git::validation::positions::validate_positions;
 
         use git::tests::then;
@@ -61,12 +58,12 @@ mod positions {
         #[test]
         fn where_fetch_fails_should_error() {
             let fs = given::a_filesystem();
-            let gitdir = GitDir::new(fs.base().to_path_buf(), StoragePathType::Internal);
+            let gitdir: config::GitDir = fs.base().to_path_buf().into();
             let mut mock_open_repository = git::repository::open::mock();
             mock_open_repository
                 .expect_fetch()
                 .return_once(|| Err(git::fetch::Error::TestFailureExpected));
-            let mut repository_factory = git::repository::factory::mock();
+            let mut repository_factory = git::repository::mock();
             repository_factory
                 .expect_open()
                 .return_once(move |_| Ok(mock_open_repository));
@@ -90,7 +87,7 @@ mod positions {
         #[test]
         fn where_main_branch_is_missing_or_commit_log_is_empty_should_error() {
             let fs = given::a_filesystem();
-            let gitdir = GitDir::new(fs.base().to_path_buf(), StoragePathType::Internal);
+            let gitdir: config::GitDir = fs.base().to_path_buf().into();
             let repo_config = given::a_repo_config();
             let main_branch = repo_config.branches().main();
             let mut mock_open_repository = git::repository::open::mock();
@@ -107,7 +104,7 @@ mod positions {
                         Ok(vec![])
                     }
                 });
-            let mut repository_factory = git::repository::factory::mock();
+            let mut repository_factory = git::repository::mock();
             repository_factory
                 .expect_open()
                 .return_once(move |_| Ok(mock_open_repository));
@@ -129,7 +126,7 @@ mod positions {
         #[test]
         fn where_next_branch_is_missing_or_commit_log_is_empty_should_error() {
             let fs = given::a_filesystem();
-            let gitdir = GitDir::new(fs.base().to_path_buf(), StoragePathType::Internal);
+            let gitdir: config::GitDir = fs.base().to_path_buf().into();
             let repo_config = given::a_repo_config();
             let next_branch = repo_config.branches().next();
             let mut mock_open_repository = git::repository::open::mock();
@@ -146,7 +143,7 @@ mod positions {
                         Ok(vec![given::a_commit()])
                     }
                 });
-            let mut repository_factory = git::repository::factory::mock();
+            let mut repository_factory = git::repository::mock();
             repository_factory
                 .expect_open()
                 .return_once(move |_| Ok(mock_open_repository));
@@ -168,7 +165,7 @@ mod positions {
         #[test]
         fn where_dev_branch_is_missing_or_commit_log_is_empty_should_error() {
             let fs = given::a_filesystem();
-            let gitdir = GitDir::new(fs.base().to_path_buf(), StoragePathType::Internal);
+            let gitdir: config::GitDir = fs.base().to_path_buf().into();
             let repo_config = given::a_repo_config();
             let dev_branch = repo_config.branches().dev();
             let mut mock_open_repository = git::repository::open::mock();
@@ -185,7 +182,7 @@ mod positions {
                         Ok(vec![given::a_commit()])
                     }
                 });
-            let mut repository_factory = git::repository::factory::mock();
+            let mut repository_factory = git::repository::mock();
             repository_factory
                 .expect_open()
                 .return_once(move |_| Ok(mock_open_repository));
@@ -208,7 +205,7 @@ mod positions {
         fn where_dev_branch_is_not_based_on_main_should_error() {
             //given
             let fs = given::a_filesystem();
-            let gitdir = GitDir::new(fs.base().to_path_buf(), StoragePathType::Internal);
+            let gitdir: config::GitDir = fs.base().to_path_buf().into();
             let mut test_repository = git::repository::test(fs.clone());
             let repo_config = given::a_repo_config();
             test_repository.on_fetch(git::repository::OnFetch::new(
@@ -258,7 +255,7 @@ mod positions {
         {
             //given
             let_assert!(Ok(fs) = kxio::fs::temp(), "temp fs");
-            let gitdir = GitDir::new(fs.base().to_path_buf(), StoragePathType::Internal);
+            let gitdir: config::GitDir = fs.base().to_path_buf().into();
             let mut test_repository = git::repository::test(fs.clone());
             let repo_config = given::a_repo_config();
             test_repository.on_fetch(git::repository::OnFetch::new(
@@ -344,7 +341,7 @@ mod positions {
         fn where_next_branch_is_not_based_on_main_and_reset_of_next_fails_should_error() {
             //given
             let_assert!(Ok(fs) = kxio::fs::temp(), "temp fs");
-            let gitdir = GitDir::new(fs.base().to_path_buf(), StoragePathType::Internal);
+            let gitdir: config::GitDir = fs.base().to_path_buf().into();
             let mut test_repository = git::repository::test(fs.clone());
             let repo_config = given::a_repo_config();
             test_repository.on_fetch(git::repository::OnFetch::new(
@@ -417,7 +414,7 @@ mod positions {
         fn where_dev_branch_is_not_based_on_next_should_reset_next_branch_to_main_and_then_error() {
             //given
             let_assert!(Ok(fs) = kxio::fs::temp(), "temp fs");
-            let gitdir = GitDir::new(fs.base().to_path_buf(), StoragePathType::Internal);
+            let gitdir: config::GitDir = fs.base().to_path_buf().into();
             let mut test_repository = git::repository::test(fs.clone());
             let repo_config = given::a_repo_config();
             test_repository.on_fetch(git::repository::OnFetch::new(
@@ -501,7 +498,7 @@ mod positions {
         fn where_dev_branch_is_not_based_on_next_and_reset_of_next_fails_should_error() {
             //given
             let_assert!(Ok(fs) = kxio::fs::temp(), "temp fs");
-            let gitdir = GitDir::new(fs.base().to_path_buf(), StoragePathType::Internal);
+            let gitdir: config::GitDir = fs.base().to_path_buf().into();
             let mut test_repository = git::repository::test(fs.clone());
             let repo_config = given::a_repo_config();
             test_repository.on_fetch(git::repository::OnFetch::new(
@@ -572,7 +569,7 @@ mod positions {
         fn where_branches_are_all_valid_should_return_positions() {
             //given
             let_assert!(Ok(fs) = kxio::fs::temp(), "temp fs");
-            let gitdir = GitDir::new(fs.base().to_path_buf(), StoragePathType::Internal);
+            let gitdir: config::GitDir = fs.base().to_path_buf().into();
             let mut test_repository = git::repository::test(fs.clone());
             let repo_config = given::a_repo_config();
             test_repository.on_fetch(git::repository::OnFetch::new(

crates/repo-actor/src/tests/expect.rs

@@ -1,7 +1,7 @@
 //
 use super::*;
 
-use git::repository::factory::MockRepositoryFactory;
+use git::repository::MockRepositoryFactory;
 use git_next_git::repository::open::MockOpenRepositoryLike;
 
 pub fn fetch_ok(open_repository: &mut MockOpenRepositoryLike) {

crates/repo-actor/src/tests/given.rs

@@ -1,5 +1,3 @@
-use config::git_dir::StoragePathType;
-
 //
 use super::*;
 
@@ -83,7 +81,7 @@ pub fn a_branch_name(prefix: impl Into<String>) -> BranchName {
 pub fn a_git_dir(fs: &kxio::fs::FileSystem) -> GitDir {
     let dir_name = a_name();
     let dir = fs.base().join(dir_name);
-    GitDir::new(dir, StoragePathType::Internal)
+    GitDir::new(dir)
 }
 
 pub fn a_forge_config() -> ForgeConfig {

crates/repo-actor/src/tests/handlers/validate_repo.rs

@@ -290,7 +290,7 @@ async fn should_accept_message_with_current_token() -> TestResult {
     //when
     let (actor, log) = given::a_repo_actor(
         repo_details,
-        git::repository::factory::mock(),
+        git::repository::mock(),
         given::a_forge(),
         given::a_network().into(),
     );
@@ -314,7 +314,7 @@ async fn should_accept_message_with_new_token() -> TestResult {
     //when
     let (actor, log) = given::a_repo_actor(
         repo_details,
-        git::repository::factory::mock(),
+        git::repository::mock(),
         given::a_forge(),
         given::a_network().into(),
     );
@@ -338,7 +338,7 @@ async fn should_reject_message_with_expired_token() -> TestResult {
     //when
     let (actor, log) = given::a_repo_actor(
         repo_details,
-        git::repository::factory::mock(),
+        git::repository::mock(),
         given::a_forge(),
         given::a_network().into(),
     );

crates/repo-actor/src/tests/mod.rs

@@ -13,7 +13,7 @@ use config::{
     RepoAlias, RepoBranches, RepoConfig, ServerRepoConfig, WebhookAuth, WebhookId,
 };
 use git::{
-    repository::{factory::MockRepositoryFactory, open::MockOpenRepositoryLike, Direction},
+    repository::{open::MockOpenRepositoryLike, Direction, MockRepositoryFactory},
     Generation, GitRemote, MockForgeLike, RepoDetails,
 };
 use git_next_actor_macros::message;

crates/repo-actor/src/tests/when.rs

@@ -4,7 +4,7 @@ use git::repository::OpenRepositoryLike;
 use super::*;
 
 pub fn start_actor(
-    repository_factory: git::repository::factory::MockRepositoryFactory,
+    repository_factory: git::repository::MockRepositoryFactory,
     repo_details: git::RepoDetails,
     forge: Box<dyn git::ForgeLike>,
 ) -> (actix::Addr<RepoActor>, RepoActorLog) {
@@ -24,7 +24,7 @@ pub fn start_actor_with_open_repository(
 ) -> (actix::Addr<RepoActor>, RepoActorLog) {
     let (actor, log) = given::a_repo_actor(
         repo_details,
-        git::repository::factory::mock(),
+        git::repository::mock(),
         forge,
         given::a_network().into(),
     );

crates/server-actor/src/lib.rs

@@ -13,7 +13,7 @@ use std::path::PathBuf;
 use tracing::{error, info, warn};
 use webhook::{AddWebhookRecipient, ShutdownWebhook, WebhookActor, WebhookRouter};
 
-pub use git_next_git::repository::{factory::real as repository_factory, RepositoryFactory};
+pub use git_next_git::repository::{real as repository_factory, RepositoryFactory};
 
 message!(ReceiveServerConfig: ServerConfig: "Notification of newly loaded server configuration.
 
@@ -200,12 +200,11 @@ impl Server {
             info!("Creating Repo");
             let gitdir = server_repo_config.gitdir().map_or_else(
                 || {
-                    GitDir::new(
+                    GitDir::from(
                         server_storage
                             .path()
                             .join(forge_name.to_string())
                             .join(repo_alias.to_string()),
-                        config::git_dir::StoragePathType::Internal,
                     )
                 },
                 |gitdir| gitdir,