WIP: mock repository

Cargo.toml

@@ -62,6 +62,7 @@ derive_more = { version = "1.0.0-beta.6", features = [
   "deref",
   "from",
 ] }
+derive-with = "0.5"
 
 # file watcher
 inotify = "0.10"

crates/config/Cargo.toml

@@ -40,9 +40,10 @@ secrecy = { workspace = true }
 # bytes = { workspace = true }
 # ulid = { workspace = true }
 # warp = { workspace = true }
-#
+
-# # error handling
+# boilerplate
 derive_more = { workspace = true }
+derive-with = { workspace = true }
 #
 # # file watcher
 # inotify = { workspace = true }

crates/config/src/api_token.rs

@@ -9,3 +9,8 @@ impl secrecy::ExposeSecret<String> for ApiToken {
         self.0.expose_secret()
     }
 }
+impl Default for ApiToken {
+    fn default() -> Self {
+        Self("".to_string().into())
+    }
+}

crates/config/src/branch_name.rs

@@ -1,5 +1,5 @@
 /// The name of a Branch
-#[derive(Clone, Debug, Hash, PartialEq, Eq, derive_more::Display)]
+#[derive(Clone, Default, Debug, Hash, PartialEq, Eq, derive_more::Display)]
 pub struct BranchName(String);
 impl BranchName {
     pub fn new(str: impl Into<String>) -> Self {

crates/config/src/forge_details.rs

@@ -1,7 +1,7 @@
 use crate::{ApiToken, ForgeConfig, ForgeName, ForgeType, Hostname, User};
 
 /// The derived information about a Forge, used to create interactions with it
-#[derive(Clone, Debug, derive_more::Constructor)]
+#[derive(Clone, Default, Debug, derive_more::Constructor, derive_with::With)]
 pub struct ForgeDetails {
     forge_name: ForgeName,
     forge_type: ForgeType,
@@ -27,11 +27,6 @@ impl ForgeDetails {
     pub const fn token(&self) -> &ApiToken {
         &self.token
     }
-    pub fn with_hostname(self, hostname: Hostname) -> Self {
-        let mut me = self;
-        me.hostname = hostname;
-        me
-    }
 }
 impl From<(&ForgeName, &ForgeConfig)> for ForgeDetails {
     fn from(forge: (&ForgeName, &ForgeConfig)) -> Self {

crates/config/src/forge_name.rs

@@ -1,7 +1,7 @@
 use std::path::PathBuf;
 
 /// The name of a Forge to connect to
-#[derive(Clone, Debug, PartialEq, Eq, derive_more::Constructor, derive_more::Display)]
+#[derive(Clone, Default, Debug, PartialEq, Eq, derive_more::Constructor, derive_more::Display)]
 pub struct ForgeName(String);
 impl From<&ForgeName> for PathBuf {
     fn from(value: &ForgeName) -> Self {

crates/config/src/forge_type.rs

@@ -1,5 +1,5 @@
 /// Identifier for the type of Forge
-#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Deserialize)]
+#[derive(Clone, Default, Copy, Debug, PartialEq, Eq, serde::Deserialize)]
 pub enum ForgeType {
     #[cfg(feature = "forgejo")]
     ForgeJo,
@@ -7,6 +7,7 @@ pub enum ForgeType {
     // GitHub,
     // GitLab,
     // BitBucket,
+    #[default]
     MockForge,
 }
 impl std::fmt::Display for ForgeType {

crates/config/src/git_dir.rs

@@ -1,7 +1,15 @@
 use std::path::PathBuf;
 
 #[derive(
-    Debug, Clone, PartialEq, Eq, serde::Deserialize, derive_more::Deref, derive_more::From,
+    Clone,
+    Default,
+    Debug,
+    Hash,
+    PartialEq,
+    Eq,
+    serde::Deserialize,
+    derive_more::Deref,
+    derive_more::From,
 )]
 pub struct GitDir(PathBuf);
 impl GitDir {

crates/config/src/host_name.rs

@@ -1,5 +1,5 @@
 /// The hostname of a forge
-#[derive(Clone, Debug, PartialEq, Eq, derive_more::Display)]
+#[derive(Clone, Default, Debug, PartialEq, Eq, derive_more::Display)]
 pub struct Hostname(String);
 impl Hostname {
     pub fn new(str: impl Into<String>) -> Self {

crates/config/src/repo_alias.rs

@@ -1,6 +1,6 @@
 /// The alias of a repo
 /// This is the alias for the repo within `git-next-server.toml`
-#[derive(Clone, Debug, PartialEq, Eq, Hash, derive_more::Display)]
+#[derive(Clone, Default, Debug, PartialEq, Eq, Hash, derive_more::Display)]
 pub struct RepoAlias(String);
 impl RepoAlias {
     pub fn new(str: impl Into<String>) -> Self {

crates/config/src/repo_path.rs

@@ -1,5 +1,5 @@
 /// The path for the repo within the forge.
 /// Typically this is composed of the user or organisation and the name of the repo
 /// e.g. `{user}/{repo}`
-#[derive(Clone, Debug, PartialEq, Eq, derive_more::Constructor, derive_more::Display)]
+#[derive(Clone, Default, Debug, PartialEq, Eq, derive_more::Constructor, derive_more::Display)]
 pub struct RepoPath(String);

crates/config/src/user.rs

@@ -1,3 +1,3 @@
 /// The user within the forge to connect as
-#[derive(Clone, Debug, PartialEq, Eq, derive_more::Constructor, derive_more::Display)]
+#[derive(Clone, Default, Debug, PartialEq, Eq, derive_more::Constructor, derive_more::Display)]
 pub struct User(String);

crates/git/Cargo.toml

@@ -45,6 +45,7 @@ secrecy = { workspace = true }
 
 # error handling
 derive_more = { workspace = true }
+derive-with = { workspace = true }
 
 # # file watcher
 # inotify = { workspace = true }
@@ -54,9 +55,9 @@ derive_more = { workspace = true }
 # actix-rt = { workspace = true }
 # tokio = { workspace = true }
 #
-# [dev-dependencies]
+[dev-dependencies]
-# # Testing
+# Testing
-# assert2 = { workspace = true }
+assert2 = { workspace = true }
 
 [lints.clippy]
 nursery = { level = "warn", priority = -1 }

crates/git/src/repo_details.rs

@@ -6,7 +6,7 @@ use git_next_config::{
 use super::{Generation, GitRemote};
 
 /// The derived information about a repo, used to interact with it
-#[derive(Clone, Debug, derive_more::Display)]
+#[derive(Clone, Default, Debug, derive_more::Display, derive_with::With)]
 #[display("gen-{}:{}:{}/{}:{}@{}/{}@{}", generation, forge.forge_type(),
     forge.forge_name(), repo_alias, forge.user(), forge.hostname(), repo_path,
     branch)]

crates/git/src/repository/mock.rs

@@ -1,17 +1,114 @@
+use std::{
+    collections::HashMap,
+    sync::{Arc, Mutex},
+};
+
 use git_next_config::GitDir;
 
 use crate::{
-    repository::{open::OpenRepository, Error, RepositoryLike},
+    repository::{
+        open::{OpenRepository, OpenRepositoryLike},
+        Direction, RepositoryLike, Result,
+    },
     RepoDetails,
 };
 
-pub struct MockRepository;
+use super::Error;
-impl RepositoryLike for MockRepository {
-    fn open(&self, _gitdir: &GitDir) -> Result<OpenRepository, Error> {
-        Ok(OpenRepository::Mock)
-    }
 
-    fn git_clone(&self, _repo_details: &RepoDetails) -> Result<OpenRepository, Error> {
+#[derive(Debug, Default, Clone)]
-        Ok(OpenRepository::Mock)
+pub struct MockRepository(Arc<Mutex<Reality>>);
+impl MockRepository {
+    pub fn new() -> Self {
+        Self(Arc::new(Mutex::new(Reality::default())))
+    }
+    pub fn can_open_repo(&mut self, gitdir: &GitDir) -> Result<MockOpenRepository> {
+        self.0
+            .lock()
+            .map_err(|_| Error::MockLock)
+            .map(|mut r| r.can_open_repo(gitdir))
+    }
+    fn open_repository(
+        &self,
+        gitdir: &GitDir,
+    ) -> std::result::Result<MockOpenRepository, crate::repository::Error> {
+        self.0.lock().map_err(|_| Error::MockLock).and_then(|r| {
+            r.open_repository(gitdir)
+                .ok_or_else(|| Error::Open(format!("mock - could not open: {}", gitdir)))
+        })
+    }
+    fn clone_repository(
+        &self,
+    ) -> std::result::Result<MockOpenRepository, crate::repository::Error> {
+        todo!()
+    }
+}
+impl RepositoryLike for MockRepository {
+    fn open(
+        &self,
+        gitdir: &GitDir,
+    ) -> std::result::Result<OpenRepository, crate::repository::Error> {
+        Ok(OpenRepository::Mock(self.open_repository(gitdir)?))
+    }
+
+    fn git_clone(
+        &self,
+        _repo_details: &RepoDetails,
+    ) -> std::result::Result<OpenRepository, crate::repository::Error> {
+        Ok(OpenRepository::Mock(self.clone_repository()?))
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct Reality {
+    openable_repos: HashMap<GitDir, MockOpenRepository>,
+}
+impl Reality {
+    pub fn can_open_repo(&mut self, gitdir: &GitDir) -> MockOpenRepository {
+        let mor = self.openable_repos.get(gitdir);
+        match mor {
+            Some(mor) => mor.clone(),
+            None => {
+                let mor = MockOpenRepository::default();
+                self.openable_repos.insert(gitdir.clone(), mor.clone());
+                mor
+            }
+        }
+    }
+    pub fn open_repository(&self, gitdir: &GitDir) -> Option<MockOpenRepository> {
+        self.openable_repos.get(gitdir).cloned()
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct MockOpenRepository {
+    default_push_remote: Option<String>,
+    default_fetch_remote: Option<String>,
+}
+impl MockOpenRepository {
+    pub fn has_default_remote(&mut self, direction: Direction, url: &str) {
+        let url = url.to_string();
+        match direction {
+            Direction::Push => self.default_push_remote.replace(url),
+            Direction::Fetch => self.default_fetch_remote.replace(url),
+        };
+    }
+}
+impl OpenRepositoryLike for MockOpenRepository {
+    fn find_default_remote(&self, direction: Direction) -> Option<crate::GitRemote> {
+        todo!()
+    }
+
+    fn fetch(&self) -> std::prelude::v1::Result<(), crate::fetch::Error> {
+        todo!()
+    }
+
+    fn push(
+        &self,
+        repo_details: &RepoDetails,
+        branch_name: git_next_config::BranchName,
+        to_commit: crate::GitRef,
+        force: crate::push::Force,
+    ) -> std::prelude::v1::Result<(), crate::push::Error> {
+        todo!()
     }
 }

crates/git/src/repository/mod.rs

@@ -9,23 +9,26 @@ use git_next_config::GitDir;
 
 pub use open::OpenRepository;
 
+use crate::repository::mock::MockRepository;
+
 use super::RepoDetails;
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Debug)]
 pub enum Repository {
     Real,
-    Mock,
+    Mock(MockRepository),
 }
 pub const fn new() -> Repository {
     Repository::Real
 }
-pub const fn mock() -> Repository {
+pub fn mock() -> (Repository, MockRepository) {
-    Repository::Mock
+    let mock_repository = MockRepository::new();
+    (Repository::Mock(mock_repository.clone()), mock_repository)
 }
 
 pub trait RepositoryLike {
-    fn open(&self, gitdir: &GitDir) -> Result<OpenRepository, Error>;
+    fn open(&self, gitdir: &GitDir) -> Result<OpenRepository>;
-    fn git_clone(&self, repo_details: &RepoDetails) -> Result<OpenRepository, Error>;
+    fn git_clone(&self, repo_details: &RepoDetails) -> Result<OpenRepository>;
 }
 impl std::ops::Deref for Repository {
     type Target = dyn RepositoryLike;
@@ -33,7 +36,7 @@ impl std::ops::Deref for Repository {
     fn deref(&self) -> &Self::Target {
         match self {
             Self::Real => &real::RealRepository,
-            Self::Mock => &mock::MockRepository,
+            Self::Mock(mock_repository) => mock_repository,
         }
     }
 }
@@ -54,6 +57,8 @@ impl From<Direction> for gix::remote::Direction {
     }
 }
 
+pub type Result<T> = core::result::Result<T, Error>;
+
 #[derive(Debug, derive_more::Display)]
 pub enum Error {
     InvalidGitDir(git_next_config::GitDir),
@@ -64,6 +69,7 @@ pub enum Error {
     Clone(String),
     Open(String),
     Fetch(String),
+    MockLock,
 }
 impl std::error::Error for Error {}
 impl From<gix::clone::Error> for Error {

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

@@ -7,19 +7,22 @@ use git_next_config::BranchName;
 
 use crate::{
     fetch, push,
-    repository::{open::oreal::RealOpenRepository, Direction},
+    repository::{mock::MockOpenRepository, open::oreal::RealOpenRepository, Direction},
     GitRef, GitRemote, RepoDetails,
 };
 
 #[derive(Clone, Debug)]
 pub enum OpenRepository {
     Real(oreal::RealOpenRepository),
-    Mock, // TODO: (#38) contain a mock model of a repo
+    Mock(MockOpenRepository), // TODO: (#38) contain a mock model of a repo
 }
 impl OpenRepository {
-    pub fn new(gix_repo: gix::Repository) -> Self {
+    pub fn real(gix_repo: gix::Repository) -> Self {
         Self::Real(RealOpenRepository::new(Arc::new(Mutex::new(gix_repo))))
     }
+    pub fn mock(mock: MockOpenRepository) -> Self {
+        Self::Mock(mock)
+    }
 }
 pub trait OpenRepositoryLike {
     fn find_default_remote(&self, direction: Direction) -> Option<GitRemote>;
@@ -38,7 +41,7 @@ impl std::ops::Deref for OpenRepository {
     fn deref(&self) -> &Self::Target {
         match self {
             Self::Real(real) => real,
-            Self::Mock => todo!(),
+            Self::Mock(mock) => mock,
         }
     }
 }

crates/git/src/repository/real.rs

@@ -12,7 +12,7 @@ pub struct RealRepository;
 impl RepositoryLike for RealRepository {
     fn open(&self, gitdir: &GitDir) -> Result<OpenRepository, Error> {
         let gix_repo = gix::ThreadSafeRepository::open(gitdir.to_path_buf())?.to_thread_local();
-        Ok(OpenRepository::new(gix_repo))
+        Ok(OpenRepository::real(gix_repo))
     }
 
     fn git_clone(&self, repo_details: &RepoDetails) -> Result<OpenRepository, Error> {
@@ -23,6 +23,6 @@ impl RepositoryLike for RealRepository {
         )?
         .fetch_only(gix::progress::Discard, &AtomicBool::new(false))?;
 
-        Ok(OpenRepository::new(gix_repo))
+        Ok(OpenRepository::real(gix_repo))
     }
 }

crates/git/src/tests.rs

@@ -160,3 +160,33 @@ mod repo_details {
         );
     }
 }
+mod repository {
+    use assert2::let_assert;
+    use git_next_config::{ForgeDetails, GitDir, Hostname, RepoPath};
+
+    use crate::{
+        repository::{self, Direction},
+        validate, RepoDetails,
+    };
+
+    #[test]
+    fn should_ok_a_valid_repo() {
+        let forge_details =
+            ForgeDetails::default().with_hostname(Hostname::new("localhost".to_string()));
+        let repo_details = RepoDetails::default()
+            .with_forge(forge_details)
+            .with_repo_path(RepoPath::new("kemitix/test".to_string()));
+        let gitdir = GitDir::from("foo");
+
+        let (repository, mut reality) = repository::mock();
+        let_assert!(Ok(open_repo_handle) = reality.can_open_repo(&gitdir));
+        if let Ok(mut open_repo) = open_repo_handle.lock() {
+            open_repo.has_default_remote(Direction::Push, "https://localhost/kemitix/test");
+            open_repo.has_default_remote(Direction::Fetch, "https://localhost/kemitix/test");
+        }
+
+        let_assert!(Ok(open_repository) = repository.open(&gitdir));
+
+        let_assert!(Ok(_) = validate(&open_repository, &repo_details));
+    }
+}

crates/server/src/actors/server.rs

@@ -177,7 +177,7 @@ impl Server {
         let server_storage = server_storage.clone();
         let webhook = webhook.clone();
         let net = self.net.clone();
-        let repo = self.repo;
+        let repo = self.repo.clone();
         let generation = self.generation;
         move |(repo_alias, server_repo_config)| {
             let span = tracing::info_span!("create_actor", alias = %repo_alias, config = %server_repo_config);
@@ -205,8 +205,13 @@ impl Server {
                 gitdir,
             );
             info!("Starting Repo Actor");
-            let actor =
+            let actor = RepoActor::new(
-                RepoActor::new(repo_details, webhook.clone(), generation, net.clone(), repo);
+                repo_details,
+                webhook.clone(),
+                generation,
+                net.clone(),
+                repo.clone(),
+            );
             (forge_name.clone(), repo_alias, actor)
         }
     }

crates/server/src/gitforge/tests/forgejo.rs

@@ -13,7 +13,7 @@ fn test_name() {
         panic!("fs")
     };
     let net = Network::new_mock();
-    let repo = git::repository::mock();
+    let (repo, _reality) = git::repository::mock();
     let repo_details = common::repo_details(
         1,
         Generation::new(),
@@ -40,7 +40,7 @@ async fn test_branches_get() {
     let body = include_str!("./data-forgejo-branches-get.json");
     net.add_get_response(&url, StatusCode::OK, body);
     let net = Network::from(net);
-    let repo = git::repository::mock();
+    let (repo, _reality) = git::repository::mock();
 
     let repo_details = common::repo_details(
         1,