WIP: add more tests to repo-actor crate

bacon.toml

@@ -4,7 +4,7 @@
 # Complete help on configuration: https://dystroy.org/bacon/config/
 
 default_job = "check"
-reverse = true
+# reverse = true
 
 [jobs.check]
 command = ["cargo", "check", "--color", "always"]
@@ -57,7 +57,7 @@ on_success = "back" # so that we don't open the browser at each change
 # If you want to pass options to your program, a `--` separator
 # will be needed.
 [jobs.run]
-command = [ "cargo", "run", "--color", "always" ]
+command = ["cargo", "run", "--color", "always"]
 need_stdout = true
 allow_warnings = true
 

crates/config/src/newtype.rs

@@ -1,35 +1,10 @@
 //
 #[macro_export]
 macro_rules! newtype {
-    ($name:ident is a $type:ty, without Display) => {
+    ($name:ident) => {
-        #[derive(
-            Clone,
-            Default,
-            Debug,
-            derive_more::From,
-            PartialEq,
-            Eq,
-            PartialOrd,
-            Ord,
-            Hash,
-            derive_more::AsRef,
-            derive_more::Deref,
-            serde::Deserialize,
-            serde::Serialize,
-        )]
-        pub struct $name($type);
-        impl $name {
-            pub fn new(value: impl Into<$type>) -> Self {
-                Self(value.into())
-            }
-            pub fn unwrap(self) -> $type {
-                self.0
-            }
-        }
-    };
-    ($name:ident is a $type:ty) => {
         #[derive(
             Clone,
+            Copy,
             Default,
             Debug,
             derive_more::Display,
@@ -40,18 +15,42 @@ macro_rules! newtype {
             Ord,
             Hash,
             derive_more::AsRef,
+        )]
+        pub struct $name;
+        impl $name {
+            pub fn new() -> Self {
+                Self
+            }
+        }
+    };
+    ($name:ident is a $type:ty $(, $derive:ty)*) => {
+        #[derive(
+            Clone,
+            Debug,
+            derive_more::From,
+            PartialEq,
+            Eq,
+            PartialOrd,
+            Ord,
+            Hash,
+            derive_more::AsRef,
             derive_more::Deref,
-            serde::Deserialize,
+            $($derive),*
-            serde::Serialize,
         )]
         pub struct $name($type);
         impl $name {
             pub fn new(value: impl Into<$type>) -> Self {
                 Self(value.into())
             }
+            #[allow(clippy::missing_const_for_fn)]
             pub fn unwrap(self) -> $type {
                 self.0
             }
         }
+            impl From<$name> for $type {
+                fn from(value: $name) -> $type {
+                        value.unwrap()
+                }
+            }
     };
 }

crates/config/src/repo_branches.rs

@@ -2,7 +2,17 @@ use crate::BranchName;
 
 /// Mapped from `.git-next.toml` file at `branches`
 #[derive(
-    Clone, Debug, PartialEq, Eq, serde::Deserialize, derive_more::Constructor, derive_more::Display,
+    Clone,
+    Hash,
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    serde::Deserialize,
+    serde::Serialize,
+    derive_more::Constructor,
+    derive_more::Display,
 )]
 #[display("{},{},{}", main, next, dev)]
 pub struct RepoBranches {

crates/config/src/repo_config.rs

@@ -5,7 +5,17 @@ use crate::RepoConfigSource;
 /// Is also derived from the optional parameters in `git-next-server.toml` at
 /// `forge.{forge}.repos.{repo}.(main|next|dev)`
 #[derive(
-    Clone, Debug, PartialEq, Eq, serde::Deserialize, derive_more::Constructor, derive_more::Display,
+    Clone,
+    Hash,
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    serde::Deserialize,
+    serde::Serialize,
+    derive_more::Constructor,
+    derive_more::Display,
 )]
 #[display("{}", branches)]
 pub struct RepoConfig {
@@ -13,7 +23,7 @@ pub struct RepoConfig {
     source: RepoConfigSource,
 }
 impl RepoConfig {
-    pub fn load(toml: &str) -> Result<Self, toml::de::Error> {
+    pub fn parse(toml: &str) -> Result<Self, toml::de::Error> {
         toml::from_str(format!("source = \"Repo\"\n{}", toml).as_str())
     }
 

crates/config/src/repo_config_source.rs

@@ -1,4 +1,6 @@
-#[derive(Copy, Clone, Debug, PartialEq, Eq, serde::Deserialize)]
+#[derive(
+    Copy, Hash, Clone, Debug, PartialEq, Eq, serde::Deserialize, PartialOrd, Ord, serde::Serialize,
+)]
 pub enum RepoConfigSource {
     Repo,
     Server,

crates/config/src/server.rs

@@ -1,6 +1,5 @@
 //
 use actix::prelude::*;
-use derive_more::Constructor;
 
 use std::{
     collections::HashMap,
@@ -12,7 +11,7 @@ use std::{
 use kxio::fs::FileSystem;
 use tracing::info;
 
-use crate::{ForgeAlias, ForgeConfig, RepoAlias};
+use crate::{newtype, ForgeAlias, ForgeConfig, RepoAlias};
 
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
@@ -96,18 +95,8 @@ impl Webhook {
     }
 }
 
-/// The URL for the webhook where forges should send their updates
+// The RL for the webhook where forges should send their updates
-#[derive(
+newtype!(WebhookUrl is a String, serde::Serialize);
-    Clone,
-    Debug,
-    PartialEq,
-    Eq,
-    serde::Serialize,
-    serde::Deserialize,
-    derive_more::AsRef,
-    Constructor,
-)]
-pub struct WebhookUrl(String);
 
 /// The directory to store server data, such as cloned repos
 #[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize, derive_more::Constructor)]

crates/config/src/tests.rs

@@ -110,7 +110,7 @@ mod repo_config {
         "#
         );
 
-        let rc = RepoConfig::load(toml.as_str())?;
+        let rc = RepoConfig::parse(toml.as_str())?;
 
         assert_eq!(
             rc,
@@ -557,7 +557,7 @@ token = "{forge_token}"
 {repos}
                 "#
             );
-            eprintln!("{file_contents}");
+            println!("{file_contents}");
             fs.file_write(
                 &fs.base().join("git-next-server.toml"),
                 file_contents.as_str(),

crates/config/src/webhook/auth.rs

@@ -1,7 +1,7 @@
-#[derive(Clone, Debug, PartialEq, Eq, derive_more::Deref, derive_more::Display)]
+//
-pub struct WebhookAuth(ulid::Ulid);
+crate::newtype!(WebhookAuth is a ulid::Ulid, derive_more::Display);
 impl WebhookAuth {
-    pub fn new(authorisation: &str) -> Result<Self, ulid::DecodeError> {
+    pub fn try_new(authorisation: &str) -> Result<Self, ulid::DecodeError> {
         use std::str::FromStr as _;
         let id = ulid::Ulid::from_str(authorisation)?;
         tracing::info!("Parse auth token: {}", id);

crates/config/src/webhook/id.rs

@@ -1,4 +1,2 @@
-use derive_more::{Constructor, Deref, Display};
+//
-
+crate::newtype!(WebhookId is a String, derive_more::Display);
-#[derive(Clone, Debug, PartialEq, Eq, Constructor, Deref, Display)]
-pub struct WebhookId(String);

crates/config/src/webhook/tests.rs

@@ -5,7 +5,7 @@ mod auth {
     fn bytes() -> Result<(), Box<dyn std::error::Error>> {
         let ulid = ulid::Ulid::new();
 
-        let wa = WebhookAuth::new(ulid.to_string().as_str())?;
+        let wa = WebhookAuth::try_new(ulid.to_string().as_str())?;
 
         assert_eq!(ulid.to_bytes(), wa.to_bytes());
 
@@ -16,7 +16,7 @@ mod auth {
     fn string() -> Result<(), Box<dyn std::error::Error>> {
         let ulid = ulid::Ulid::new();
 
-        let wa = WebhookAuth::new(ulid.to_string().as_str())?;
+        let wa = WebhookAuth::try_new(ulid.to_string().as_str())?;
 
         assert_eq!(ulid.to_string(), wa.to_string());
 

crates/forge-forgejo/src/lib.rs

@@ -36,7 +36,7 @@ impl git::ForgeLike for ForgeJo {
         tracing::info!(?authorization, %expected, "is message authorised?");
         authorization
             .and_then(|header| header.strip_prefix("Basic ").map(|v| v.to_owned()))
-            .and_then(|value| config::WebhookAuth::new(value.as_str()).ok())
+            .and_then(|value| config::WebhookAuth::try_new(value.as_str()).ok())
             .map(|auth| &auth == expected)
             .unwrap_or(false)
     }

crates/forge/src/mock_forge.rs

@@ -19,38 +19,41 @@ impl git::ForgeLike for MockForge {
         _msg: &config::WebhookMessage,
         _expected: &config::WebhookAuth,
     ) -> bool {
-        todo!()
+        todo!("MockForge::is_message_authorised")
     }
 
     fn parse_webhook_body(
         &self,
         _body: &config::webhook::message::Body,
     ) -> git::forge::webhook::Result<config::webhook::push::Push> {
-        todo!()
+        todo!("MockForge::parse_webhook_body")
     }
 
     async fn commit_status(&self, _commit: &git::Commit) -> git::forge::commit::Status {
-        todo!()
+        todo!("MockForge::commit_status")
     }
 
     async fn list_webhooks(
         &self,
         _webhook_url: &config::server::WebhookUrl,
     ) -> git::forge::webhook::Result<Vec<config::WebhookId>> {
-        todo!()
+        todo!("MockForge::list_webhooks")
     }
 
     async fn unregister_webhook(
         &self,
         _webhook_id: &config::WebhookId,
     ) -> git::forge::webhook::Result<()> {
-        todo!()
+        todo!("MockForge::unregister_webhook")
     }
 
     async fn register_webhook(
         &self,
         _webhook_url: &config::server::WebhookUrl,
     ) -> git::forge::webhook::Result<config::RegisteredWebhook> {
-        todo!()
+        Ok(config::RegisteredWebhook::new(
+            config::WebhookId::new(""),
+            config::WebhookAuth::new(ulid::Ulid::new()),
+        ))
     }
 }

crates/forge/src/tests.rs

@@ -30,7 +30,7 @@ fn test_github_name() {
 
 fn given_fs() -> kxio::fs::FileSystem {
     kxio::fs::temp().unwrap_or_else(|e| {
-        eprintln!("{e}");
+        println!("{e}");
         panic!("fs")
     })
 }

crates/git/src/commit.rs

@@ -1,7 +1,19 @@
+use config::newtype;
+use derive_more::Display;
 //
 use git_next_config as config;
 
-#[derive(Clone, Debug, PartialEq, Eq, derive_more::Constructor, derive_more::Display)]
+#[derive(
+    Clone,
+    Debug,
+    Hash,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    derive_more::Constructor,
+    derive_more::Display,
+)]
 #[display("{}", sha)]
 pub struct Commit {
     sha: Sha,
@@ -25,11 +37,8 @@ impl From<config::webhook::Push> for Commit {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, derive_more::Constructor, derive_more::Display)]
+newtype!(Sha is a String, Display);
-pub struct Sha(String);
+newtype!(Message is a String);
-
-#[derive(Clone, Debug, PartialEq, Eq, derive_more::Constructor, derive_more::Display)]
-pub struct Message(String);
 
 #[derive(Clone, Debug)]
 pub struct Histories {

crates/git/src/repository/mock.rs

@@ -12,27 +12,44 @@ use git_next_config as config;
 #[derive(Debug, Default, Clone)]
 pub struct MockRepository {
     open_repos: Arc<Mutex<HashMap<config::GitDir, git::repository::MockOpenRepository>>>,
+    clone_repos: Arc<Mutex<HashMap<config::GitDir, git::repository::MockOpenRepository>>>,
 }
 impl MockRepository {
     pub fn new() -> Self {
         Self {
             open_repos: Default::default(),
+            clone_repos: Default::default(),
         }
     }
 
     pub fn given_can_be_opened(
         &mut self,
-        gitdir: &config::GitDir,
+        repo_details: git::RepoDetails,
     ) -> git::repository::MockOpenRepository {
-        let open_repo = git::repository::MockOpenRepository::new();
+        let gitdir = repo_details.gitdir.clone();
+        let open_repo = git::repository::MockOpenRepository::new(repo_details);
         #[allow(clippy::unwrap_used)]
         self.open_repos
             .lock()
-            .map(|mut or| or.insert(gitdir.clone(), open_repo.clone()))
+            .map(|mut or| or.insert(gitdir, open_repo.clone()))
             .unwrap();
         open_repo
     }
 
+    pub fn given_can_be_cloned(
+        &mut self,
+        repo_details: git::RepoDetails,
+    ) -> git::repository::MockOpenRepository {
+        let gitdir = repo_details.gitdir.clone();
+        let clone_repo = git::repository::MockOpenRepository::new(repo_details);
+        #[allow(clippy::unwrap_used)]
+        self.clone_repos
+            .lock()
+            .map(|mut or| or.insert(gitdir, clone_repo.clone()))
+            .unwrap();
+        clone_repo
+    }
+
     pub fn seal(self) -> (git::Repository, Self) {
         (git::Repository::Mock(self.clone()), self)
     }
@@ -64,8 +81,20 @@ impl git::repository::RepositoryLike for MockRepository {
 
     fn git_clone(
         &self,
-        _repo_details: &git::RepoDetails,
+        repo_details: &git::RepoDetails,
     ) -> std::result::Result<git::repository::OpenRepository, crate::repository::Error> {
-        todo!("MockRepository::git_clone")
+        let gitdir = &repo_details.gitdir;
+        #[allow(clippy::unwrap_used)]
+        self.clone_repos
+            .lock()
+            .map_err(|_| crate::repository::Error::MockLock)
+            .map(|or| or.get(gitdir).cloned())
+            .transpose()
+            .unwrap_or_else(|| Err(crate::repository::Error::InvalidGitDir(gitdir.clone())))
+            .map(|mor| {
+                let repo_path = &repo_details.repo_path;
+                mor.log(format!("git_clone {repo_path}"));
+                mor.into()
+            })
     }
 }

crates/git/src/repository/mod.rs

@@ -1,14 +1,11 @@
 //
-#[cfg(test)]
 mod mock;
-#[cfg(test)]
 pub use mock::MockRepository;
-#[cfg(test)]
 pub use open::MockOpenRepository;
 
 mod open;
 mod real;
-mod test;
+pub mod test;
 
 #[cfg(test)]
 mod tests;
@@ -35,22 +32,24 @@ use super::RepoDetails;
 #[allow(clippy::large_enum_variant)]
 pub enum Repository {
     Real,
-    #[cfg(test)]
-    Mock(MockRepository),
     Test(TestRepository),
+    Mock(MockRepository),
 }
 
 pub const fn new() -> Repository {
     Repository::Real
 }
 
-#[cfg(test)]
 pub fn mock() -> MockRepository {
     MockRepository::new()
 }
 
-pub const fn test(fs: kxio::fs::FileSystem) -> TestRepository {
+pub fn new_test(fs: kxio::fs::FileSystem) -> Repository {
-    TestRepository::new(false, fs, vec![], vec![])
+    Repository::Test(test(fs))
+}
+
+pub fn test(fs: kxio::fs::FileSystem) -> TestRepository {
+    TestRepository::new(false, fs, Default::default(), Default::default())
 }
 
 // #[cfg(test)]
@@ -66,15 +65,20 @@ pub fn open(
     repo_details: &RepoDetails,
     gitdir: config::GitDir,
 ) -> Result<OpenRepository> {
+    println!("validating repo in {gitdir:?}");
     let repository = if !gitdir.exists() {
+        println!("dir doesn't exist - cloning...");
         info!("Local copy not found - cloning...");
         repository.git_clone(repo_details)?
     } else {
+        println!("dir exists - opening...");
         info!("Local copy found - opening...");
         repository.open(&gitdir)?
     };
+    println!("open - validating");
     info!("Validating...");
     validate_repo(&repository, repo_details).map_err(|e| Error::Validation(e.to_string()))?;
+    println!("open - validated - okay");
     Ok(repository)
 }
 
@@ -88,10 +92,8 @@ impl std::ops::Deref for Repository {
     fn deref(&self) -> &Self::Target {
         match self {
             Self::Real => &real::RealRepository,
-            Self::Test(test_repository) => test_repository,
+            Self::Test(test) => test,
-
+            Self::Mock(mock) => mock,
-            #[cfg(test)]
-            Self::Mock(mock_repository) => mock_repository,
         }
     }
 }

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

@@ -7,7 +7,6 @@ pub mod oreal;
 
 pub mod otest;
 
-#[cfg(test)]
 pub mod omock;
 
 use std::{
@@ -18,12 +17,12 @@ use std::{
 use crate as git;
 use git::repository::Direction;
 use git_next_config as config;
-#[cfg(test)]
 pub use omock::MockOpenRepository;
 pub use oreal::RealOpenRepository;
 pub use otest::TestOpenRepository;
 
 #[derive(Clone, Debug)]
+#[allow(clippy::large_enum_variant)]
 pub enum OpenRepository {
     /// A real git repository.
     ///
@@ -44,7 +43,6 @@ pub enum OpenRepository {
     /// the behaviour of a git repository.  Once the [Self::LocalOnly]
     /// variant is ready for use, tests should be converted to using
     /// that instead.
-    #[cfg(test)]
     Mock(git::repository::MockOpenRepository), // TODO: (#38) contain a mock model of a repo
 }
 
@@ -58,20 +56,24 @@ pub fn real(gix_repo: gix::Repository) -> OpenRepository {
 pub fn test(
     gitdir: &config::GitDir,
     fs: kxio::fs::FileSystem,
-    on_fetch: Vec<otest::OnFetch>,
+    on_fetch: Arc<Mutex<Vec<otest::OnFetch>>>,
-    on_push: Vec<otest::OnPush>,
+    on_push: Arc<Mutex<Vec<otest::OnPush>>>,
 ) -> OpenRepository {
-    OpenRepository::Test(TestOpenRepository::new(gitdir, fs, on_fetch, on_push))
+    let open_repo = TestOpenRepository::new(gitdir, fs, on_fetch, on_push);
+    open_repo.log("test");
+    OpenRepository::Test(open_repo)
 }
 
 #[cfg(not(tarpaulin_include))] // don't test mocks
 pub fn test_bare(
     gitdir: &config::GitDir,
     fs: kxio::fs::FileSystem,
-    on_fetch: Vec<otest::OnFetch>,
+    on_fetch: Arc<Mutex<Vec<otest::OnFetch>>>,
-    on_push: Vec<otest::OnPush>,
+    on_push: Arc<Mutex<Vec<otest::OnPush>>>,
 ) -> OpenRepository {
-    OpenRepository::Test(TestOpenRepository::new_bare(gitdir, fs, on_fetch, on_push))
+    let open_repo = TestOpenRepository::new_bare(gitdir, fs, on_fetch, on_push);
+    open_repo.log("test_bare");
+    OpenRepository::Test(open_repo)
 }
 
 pub trait OpenRepositoryLike {
@@ -109,8 +111,6 @@ impl std::ops::Deref for OpenRepository {
         match self {
             Self::Real(real) => real,
             Self::Test(test) => test,
-
-            #[cfg(test)]
             Self::Mock(mock) => mock,
         }
     }

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

@@ -1,21 +1,33 @@
 //
-use crate as git;
+#![cfg(not(tarpaulin_include))]
+
+use crate::{self as git, RepoDetails};
 use git_next_config as config;
 
 use std::{
+    collections::HashMap,
     path::Path,
     sync::{Arc, Mutex},
 };
 
 #[derive(Clone, Debug, Default)]
 pub struct MockOpenRepository {
+    log: Arc<Mutex<Vec<String>>>,
     default_push_remote: Arc<Mutex<Option<git::GitRemote>>>,
     default_fetch_remote: Arc<Mutex<Option<git::GitRemote>>>,
-    operations: Arc<Mutex<Vec<String>>>,
+    commit_logs: HashMap<config::BranchName, Vec<git::Commit>>,
+    repo_details: RepoDetails,
 }
 impl MockOpenRepository {
-    pub fn new() -> Self {
+    pub fn new(repo_details: RepoDetails) -> Self {
-        Self::default()
+        Self {
+            repo_details,
+            ..Default::default()
+        }
+    }
+    pub fn with_default_remote(mut self, direction: git::repository::Direction) -> Self {
+        self.given_has_default_remote(direction, Some(self.repo_details.git_remote()));
+        self
     }
     pub fn given_has_default_remote(
         &mut self,
@@ -43,10 +55,29 @@ impl MockOpenRepository {
         };
     }
 
-    pub fn operations(&self) -> Vec<String> {
+    pub fn with_commit_log(
-        self.operations
+        mut self,
+        branch_name: config::BranchName,
+        commits: Vec<git::Commit>,
+    ) -> Self {
+        self.commit_logs.insert(branch_name, commits);
+        self
+    }
+
+    pub fn log(&self, message: impl Into<String>) {
+        let message: String = message.into();
+        let _ = self.log.lock().map(|mut log| log.push(message));
+    }
+
+    pub fn take_log(&mut self) -> Vec<String> {
+        println!("take_log: {:#?}", self.log);
+        self.log
             .lock()
-            .map(|operations| operations.clone())
+            .map(|mut self_log| {
+                let out_log: Vec<String> = self_log.clone();
+                self_log.clear();
+                out_log
+            })
             .unwrap_or_default()
     }
 }
@@ -76,10 +107,7 @@ impl git::repository::OpenRepositoryLike for MockOpenRepository {
     }
 
     fn fetch(&self) -> core::result::Result<(), crate::fetch::Error> {
-        self.operations
+        self.log("fetch");
-            .lock()
-            .map_err(|_| crate::fetch::Error::Lock)
-            .map(|mut operations| operations.push("fetch".to_string()))?;
         Ok(())
     }
 
@@ -92,23 +120,22 @@ impl git::repository::OpenRepositoryLike for MockOpenRepository {
     ) -> core::result::Result<(), crate::push::Error> {
         let forge_alias = repo_details.forge.forge_alias();
         let repo_alias = &repo_details.repo_alias;
-        self.operations
+        self.log(format!(
-            .lock()
-            .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,
+        branch_name: &git_next_config::BranchName,
-        _find_commits: &[git::Commit],
+        find_commits: &[git::Commit],
     ) -> core::result::Result<Vec<crate::Commit>, git::commit::log::Error> {
-        todo!("MockOpenRepository::commit_log")
+        self.log(format!("commit_log {branch_name} {find_commits:?}"));
+        self.commit_logs
+            .get(branch_name)
+            .cloned()
+            .ok_or(git::commit::log::Error::Lock)
     }
 
     fn read_file(

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

@@ -1,4 +1,6 @@
 //
+#![cfg(not(tarpaulin_include))]
+
 use crate as git;
 use derive_more::{Constructor, Deref};
 use git_next_config as config;
@@ -61,9 +63,10 @@ impl OnPush {
 
 #[derive(Clone, Debug)]
 pub struct TestOpenRepository {
-    on_fetch: Vec<OnFetch>,
+    log: Arc<Mutex<Vec<String>>>,
+    on_fetch: Arc<Mutex<Vec<OnFetch>>>,
     fetch_counter: Arc<RwLock<usize>>,
-    on_push: Vec<OnPush>,
+    on_push: Arc<Mutex<Vec<OnPush>>>,
     push_counter: Arc<RwLock<usize>>,
     real: git::repository::RealOpenRepository,
 }
@@ -77,19 +80,25 @@ impl git::repository::OpenRepositoryLike for TestOpenRepository {
     }
 
     fn fetch(&self) -> Result<(), git::fetch::Error> {
+        self.log("fetch");
         let i: usize = *self
             .fetch_counter
             .read()
             .map_err(|_| git::fetch::Error::Lock)?
             .deref();
-        eprintln!("Fetch: {i}");
+        println!("Fetch: {i}");
         self.fetch_counter
             .write()
             .map_err(|_| git::fetch::Error::Lock)
             .map(|mut c| *c += 1)?;
-        self.on_fetch.get(i).map(|f| f.invoke()).unwrap_or_else(|| {
+        self.on_fetch
+            .lock()
+            .map_err(|_| git::fetch::Error::Lock)
+            .map(|a| {
+                a.get(i).map(|f| f.invoke()).unwrap_or_else(|| {
                     unimplemented!("Unexpected fetch");
                 })
+            })?
     }
 
     fn push(
@@ -99,22 +108,29 @@ impl git::repository::OpenRepositoryLike for TestOpenRepository {
         to_commit: &git::GitRef,
         force: &git::push::Force,
     ) -> git::push::Result<()> {
+        self.log(format!(
+            "push branch:{branch_name} to:{to_commit} force:{force}"
+        ));
         let i: usize = *self
             .push_counter
             .read()
             .map_err(|_| git::fetch::Error::Lock)?
             .deref();
-        eprintln!("Push: {i}");
+        println!("Push: {i}");
         self.push_counter
             .write()
             .map_err(|_| git::fetch::Error::Lock)
             .map(|mut c| *c += 1)?;
         self.on_push
-            .get(i)
+            .lock()
+            .map_err(|_| git::fetch::Error::Lock)
+            .map(|a| {
+                a.get(i)
                     .map(|f| f.invoke(repo_details, branch_name, to_commit, force))
                     .unwrap_or_else(|| {
                         unimplemented!("Unexpected push");
                     })
+            })?
     }
 
     fn commit_log(
@@ -130,6 +146,7 @@ impl git::repository::OpenRepositoryLike for TestOpenRepository {
         branch_name: &config::BranchName,
         file_name: &Path,
     ) -> git::file::Result<String> {
+        self.log(format!("read_file branch:{branch_name} file:{file_name:?}"));
         self.real.read_file(branch_name, file_name)
     }
 }
@@ -137,14 +154,15 @@ impl TestOpenRepository {
     pub fn new(
         gitdir: &config::GitDir,
         fs: kxio::fs::FileSystem,
-        on_fetch: Vec<OnFetch>,
+        on_fetch: Arc<Mutex<Vec<OnFetch>>>,
-        on_push: Vec<OnPush>,
+        on_push: Arc<Mutex<Vec<OnPush>>>,
     ) -> Self {
         let pathbuf = fs.base().join(gitdir.to_path_buf());
         #[allow(clippy::expect_used)]
         let gix = gix::init(pathbuf).expect("git init");
         Self::write_origin(gitdir, &fs);
         Self {
+            log: Arc::new(Mutex::new(vec![format!("new gitdir:{gitdir:?}")])),
             on_fetch,
             fetch_counter: Arc::new(RwLock::new(0)),
             on_push,
@@ -155,14 +173,15 @@ impl TestOpenRepository {
     pub fn new_bare(
         gitdir: &config::GitDir,
         fs: kxio::fs::FileSystem,
-        on_fetch: Vec<OnFetch>,
+        on_fetch: Arc<Mutex<Vec<OnFetch>>>,
-        on_push: Vec<OnPush>,
+        on_push: Arc<Mutex<Vec<OnPush>>>,
     ) -> Self {
         let pathbuf = fs.base().join(gitdir.to_path_buf());
         #[allow(clippy::expect_used)]
         let gix = gix::init_bare(pathbuf).expect("git init bare");
         Self::write_origin(gitdir, &fs);
         Self {
+            log: Arc::new(Mutex::new(vec![format!("new bare gitdir:{gitdir:?}")])),
             on_fetch,
             fetch_counter: Arc::new(RwLock::new(0)),
             on_push,
@@ -188,4 +207,21 @@ impl TestOpenRepository {
         fs.file_write(&config_file, &updated_contents)
             .expect("write updated .git/config")
     }
+
+    pub fn log(&self, message: impl Into<String>) {
+        let message: String = message.into();
+        let _ = self.log.lock().map(|mut log| log.push(message));
+    }
+
+    pub fn take_log(&mut self) -> Vec<String> {
+        println!("take_log: {:#?}", self.log);
+        self.log
+            .lock()
+            .map(|mut self_log| {
+                let out_log: Vec<String> = self_log.clone();
+                self_log.clear();
+                out_log
+            })
+            .unwrap_or_default()
+    }
 }

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

@@ -114,7 +114,7 @@ mod repo_config {
         "#
         );
 
-        let rc = config::RepoConfig::load(toml.as_str())?;
+        let rc = config::RepoConfig::parse(toml.as_str())?;
 
         assert_eq!(
             rc,
@@ -457,7 +457,7 @@ mod read_file {
             Err(err) = open_repository.read_file(&branches.dev(), &given::a_pathbuf()),
             "read file"
         );
-        eprintln!("err: {err:#?}");
+        println!("err: {err:#?}");
         assert!(matches!(err, git::file::Error::FileNotFound));
         Ok(())
     }

crates/git/src/repository/test.rs

@@ -1,5 +1,8 @@
 //
+#![cfg(not(tarpaulin_include))]
+
 use derive_more::Constructor;
+use std::sync::{Arc, Mutex};
 
 use crate as git;
 use git::repository::RepositoryLike;
@@ -9,16 +12,16 @@ use git_next_config as config;
 pub struct TestRepository {
     is_bare: bool,
     fs: kxio::fs::FileSystem,
-    on_fetch: Vec<git::repository::open::otest::OnFetch>,
+    on_fetch: Arc<Mutex<Vec<git::repository::open::otest::OnFetch>>>,
-    on_push: Vec<git::repository::open::otest::OnPush>,
+    on_push: Arc<Mutex<Vec<git::repository::open::otest::OnPush>>>,
 }
 impl TestRepository {
     pub fn on_fetch(&mut self, on_fetch: git::repository::OnFetch) {
-        self.on_fetch.push(on_fetch);
+        let _ = self.on_fetch.lock().map(|mut a| a.push(on_fetch));
     }
 
     pub fn on_push(&mut self, on_push: git::repository::OnPush) {
-        self.on_push.push(on_push);
+        let _ = self.on_push.lock().map(|mut a| a.push(on_push));
     }
 
     pub const fn fs(&self) -> &kxio::fs::FileSystem {
@@ -44,10 +47,8 @@ impl RepositoryLike for TestRepository {
         }
     }
 
-    fn git_clone(
+    fn git_clone(&self, repo_details: &crate::RepoDetails) -> super::Result<crate::OpenRepository> {
-        &self,
+        let gitdir = &repo_details.gitdir;
-        _repo_details: &crate::RepoDetails,
+        self.open(gitdir)
-    ) -> super::Result<crate::OpenRepository> {
-        todo!()
     }
 }

crates/git/src/repository/tests.rs

@@ -15,19 +15,11 @@ mod validate {
             )
             .with_repo_path(RepoPath::new("kemitix/test".to_string()));
         let gitdir = GitDir::from("foo");
-        let remote = GitRemote::new(
-            Hostname::new("localhost"),
-            RepoPath::new("kemitix/test".to_string()),
-        );
-
         let mut mock_repository = git::repository::mock();
-        {
+        mock_repository
-            let mut mock_open_repo = mock_repository.given_can_be_opened(&gitdir);
+            .given_can_be_opened(repo_details.clone())
-            mock_open_repo
+            .with_default_remote(git::repository::Direction::Push)
-                .given_has_default_remote(git::repository::Direction::Push, Some(remote.clone()));
+            .with_default_remote(git::repository::Direction::Fetch);
-            mock_open_repo
-                .given_has_default_remote(git::repository::Direction::Fetch, Some(remote));
-        }
         let (repository, _mock_repository) = mock_repository.seal();
         let_assert!(Ok(open_repository) = repository.open(&gitdir));
         let_assert!(Ok(_) = validate_repo(&open_repository, &repo_details));
@@ -41,18 +33,10 @@ mod validate {
             )
             .with_repo_path(RepoPath::new("kemitix/test".to_string()));
         let gitdir = GitDir::from("foo");
-        let remote = GitRemote::new(
-            Hostname::new("localhost"),
-            RepoPath::new("kemitix/test".to_string()),
-        );
-
         let mut mock_repository = git::repository::mock();
-        {
+        mock_repository
-            let mut mock_open_repo = mock_repository.given_can_be_opened(&gitdir);
+            .given_can_be_opened(repo_details.clone())
-            mock_open_repo.given_has_default_remote(git::repository::Direction::Push, None);
+            .with_default_remote(git::repository::Direction::Fetch);
-            mock_open_repo
-                .given_has_default_remote(git::repository::Direction::Fetch, Some(remote));
-        }
         let (repository, _mock_repository) = mock_repository.seal();
         let_assert!(Ok(open_repository) = repository.open(&gitdir));
         let_assert!(Err(_) = validate_repo(&open_repository, &repo_details));
@@ -65,18 +49,10 @@ mod validate {
             )
             .with_repo_path(RepoPath::new("kemitix/test".to_string()));
         let gitdir = GitDir::from("foo");
-        let remote = GitRemote::new(
-            Hostname::new("localhost"),
-            RepoPath::new("kemitix/test".to_string()),
-        );
-
         let mut mock_repository = git::repository::mock();
-        {
+        mock_repository
-            let mut mock_open_repo = mock_repository.given_can_be_opened(&gitdir);
+            .given_can_be_opened(repo_details.clone())
-            mock_open_repo.given_has_default_remote(git::repository::Direction::Push, None);
+            .with_default_remote(git::repository::Direction::Push);
-            mock_open_repo
-                .given_has_default_remote(git::repository::Direction::Fetch, Some(remote));
-        }
         let (repository, _mock_repository) = mock_repository.seal();
         let_assert!(Ok(open_repository) = repository.open(&gitdir));
         let_assert!(Err(_) = validate_repo(&open_repository, &repo_details));
@@ -89,23 +65,15 @@ mod validate {
             )
             .with_repo_path(RepoPath::new("kemitix/test".to_string()));
         let gitdir = GitDir::from("foo");
-        let remote = GitRemote::new(
-            Hostname::new("localhost"),
-            RepoPath::new("kemitix/test".to_string()),
-        );
         let other_remote = GitRemote::new(
             Hostname::new("localhost"),
             RepoPath::new("kemitix/other".to_string()),
         );
-
         let mut mock_repository = git::repository::mock();
-        {
+        mock_repository
-            let mut mock_open_repo = mock_repository.given_can_be_opened(&gitdir);
+            .given_can_be_opened(repo_details.clone())
-            mock_open_repo
+            .with_default_remote(git::repository::Direction::Fetch)
             .given_has_default_remote(git::repository::Direction::Push, Some(other_remote));
-            mock_open_repo
-                .given_has_default_remote(git::repository::Direction::Fetch, Some(remote));
-        }
         let (repository, _mock_repository) = mock_repository.seal();
         let_assert!(Ok(open_repository) = repository.open(&gitdir));
         let_assert!(Err(_) = validate_repo(&open_repository, &repo_details));
@@ -118,22 +86,15 @@ mod validate {
             )
             .with_repo_path(RepoPath::new("kemitix/test".to_string()));
         let gitdir = GitDir::from("foo");
-        let remote = GitRemote::new(
-            Hostname::new("localhost"),
-            RepoPath::new("kemitix/test".to_string()),
-        );
         let other_remote = GitRemote::new(
             Hostname::new("localhost"),
             RepoPath::new("kemitix/other".to_string()),
         );
-
         let mut mock_repository = git::repository::mock();
-        {
+        mock_repository
-            let mut mock_open_repo = mock_repository.given_can_be_opened(&gitdir);
+            .given_can_be_opened(repo_details.clone())
-            mock_open_repo.given_has_default_remote(git::repository::Direction::Push, Some(remote));
+            .with_default_remote(git::repository::Direction::Push)
-            mock_open_repo
             .given_has_default_remote(git::repository::Direction::Fetch, Some(other_remote));
-        }
         let (repository, _mock_repository) = mock_repository.seal();
         let_assert!(Ok(open_repository) = repository.open(&gitdir));
         let_assert!(Err(_) = validate_repo(&open_repository, &repo_details));

crates/git/src/tests.rs

@@ -108,9 +108,9 @@ mod push {
         #[test]
         fn should_perform_a_fetch_then_push() {
             let fs = given::a_filesystem();
-            let (mock_open_repository, gitdir, mock_repository) = given::an_open_repository(&fs);
+            let (mock_open_repository, repo_details, mock_repository) =
+                given::an_open_repository(&fs);
             let open_repository: OpenRepository = mock_open_repository.into();
-            let repo_details = given::repo_details(&fs);
             let branch_name = &repo_details.branch;
             let commit = given::a_commit();
             let gitref = GitRef::from(commit);
@@ -123,14 +123,14 @@ mod push {
                     &git::push::Force::No
                 )
             );
-            let_assert!(Some(mock_open_repository) = mock_repository.get(&gitdir));
+            let_assert!(Some(mut mock_open_repository) = mock_repository.get(&repo_details.gitdir));
-            let operations = mock_open_repository.operations();
+            let log = mock_open_repository.take_log();
             let forge_alias = repo_details.forge.forge_alias();
             let repo_alias = &repo_details.repo_alias;
             let to_commit = gitref;
             let force = "fast-forward";
             assert_eq!(
-                operations,
+                log,
                 vec![format!("fetch"), format!("push fa:{forge_alias} ra:{repo_alias} bn:{branch_name} tc:{to_commit} f:{force}")]
             );
         }
@@ -348,11 +348,11 @@ pub mod given {
 
     pub fn an_open_repository(
         fs: &kxio::fs::FileSystem,
-    ) -> (MockOpenRepository, GitDir, MockRepository) {
+    ) -> (MockOpenRepository, RepoDetails, MockRepository) {
         let mut mock = git::repository::mock();
-        let gitdir = a_git_dir(fs);
+        let repo_details = given::repo_details(fs);
-        let or = mock.given_can_be_opened(&gitdir);
+        let or = mock.given_can_be_opened(repo_details.clone());
-        (or, gitdir, mock)
+        (or, repo_details, mock)
     }
 }
 pub mod then {
@@ -455,22 +455,22 @@ pub mod then {
     }
 
     fn exec(label: String, output: Result<std::process::Output, std::io::Error>) -> TestResult {
-        eprintln!("== {label}");
+        println!("== {label}");
         match output {
             Ok(output) => {
-                eprintln!(
+                println!(
                     "\nstdout:\n{}",
                     String::from_utf8_lossy(output.stdout.as_slice())
                 );
-                eprintln!(
+                println!(
                     "\nstderr:\n{}",
                     String::from_utf8_lossy(output.stderr.as_slice())
                 );
-                eprintln!("=============================");
+                println!("=============================");
                 Ok(())
             }
             Err(err) => {
-                eprintln!("ERROR: {err:#?}");
+                println!("ERROR: {err:#?}");
                 Ok(Err(err)?)
             }
         }

crates/git/src/validation/tests.rs

@@ -304,7 +304,7 @@ mod positions {
             );
 
             //then
-            eprintln!("Got: {err:?}");
+            println!("Got: {err:?}");
             // NOTE: assertions for correct push are in on_push above
             assert!(matches!(
                 err,
@@ -371,7 +371,7 @@ mod positions {
             );
 
             //then
-            eprintln!("Got: {err:?}");
+            println!("Got: {err:?}");
             let_assert!(
                 Ok(sha_next) =
                     then::get_sha_for_branch(&fs, &gitdir, &repo_config.branches().next()),
@@ -457,7 +457,7 @@ mod positions {
             );
 
             //then
-            eprintln!("Got: {err:?}");
+            println!("Got: {err:?}");
             // NOTE: assertions for correct push are in on_push above
             assert!(matches!(
                 err,
@@ -522,7 +522,7 @@ mod positions {
             );
 
             //then
-            eprintln!("Got: {err:?}");
+            println!("Got: {err:?}");
             let_assert!(
                 Ok(sha_next) =
                     then::get_sha_for_branch(&fs, &gitdir, &repo_config.branches().next()),
@@ -571,7 +571,7 @@ mod positions {
             );
 
             //then
-            eprintln!("positions: {positions:#?}");
+            println!("positions: {positions:#?}");
 
             let_assert!(
                 Ok(main_sha) =

crates/repo-actor/Cargo.toml

@@ -42,12 +42,19 @@ ulid = { workspace = true }
 
 # boilerplate
 derive_more = { workspace = true }
+thiserror = { workspace = true }
 
 # Actors
 actix = { workspace = true }
 actix-rt = { workspace = true }
 tokio = { workspace = true }
 
+[dev-dependencies]
+# Testing
+assert2 = { workspace = true }
+rand = { workspace = true }
+pretty_assertions = { workspace = true }
+
 [lints.clippy]
 nursery = { level = "warn", priority = -1 }
 # pedantic = "warn"

crates/repo-actor/src/branch.rs

@@ -1,78 +1,67 @@
 //
-use actix::prelude::*;
+use crate as actor;
-
 use git_next_config as config;
 use git_next_git as git;
+
+use derive_more::Display;
 use tracing::{info, warn};
 
-use crate::{MessageToken, ValidateRepo};
-
-use std::time::Duration;
-
 // advance next to the next commit towards the head of the dev branch
 #[tracing::instrument(fields(next), skip_all)]
 pub async fn advance_next(
-    next: git::Commit,
+    next: &git::Commit,
-    dev_commit_history: Vec<git::Commit>,
+    dev_commit_history: &[git::Commit],
     repo_details: git::RepoDetails,
     repo_config: config::RepoConfig,
     repository: git::OpenRepository,
-    addr: Addr<super::RepoActor>,
+    message_token: actor::messages::MessageToken,
-    message_token: MessageToken,
+) -> Result<actor::messages::MessageToken> {
-) {
+    let commit =
-    let next_commit = find_next_commit_on_dev(next, dev_commit_history);
+        find_next_commit_on_dev(next, dev_commit_history).ok_or_else(|| Error::NextAtDev)?;
-    let Some(commit) = next_commit else {
+    validate_commit_message(commit.message())?;
-        warn!("No commits to advance next to");
-        return;
-    };
-    if let Some(problem) = validate_commit_message(commit.message()) {
-        warn!("Can't advance next to commit '{}': {}", commit, problem);
-        return;
-    }
     info!("Advancing next to commit '{}'", commit);
-    if let Err(err) = git::push::reset(
+    git::push::reset(
         &repository,
         &repo_details,
         &repo_config.branches().next(),
         &commit.into(),
         &git::push::Force::No,
-    ) {
+    )?;
-        warn!(?err, "Failed")
+    Ok(message_token)
-    }
-    tokio::time::sleep(Duration::from_secs(10)).await;
-    addr.do_send(ValidateRepo { message_token })
 }
 
 #[tracing::instrument]
-fn validate_commit_message(message: &git::commit::Message) -> Option<String> {
+fn validate_commit_message(message: &git::commit::Message) -> Result<()> {
     let message = &message.to_string();
     if message.to_ascii_lowercase().starts_with("wip") {
-        return Some("Is Work-In-Progress".to_string());
+        return Err(Error::IsWorkInProgress);
     }
     match git_conventional::Commit::parse(message) {
         Ok(commit) => {
             info!(?commit, "Pass");
-            None
+            Ok(())
         }
         Err(err) => {
             warn!(?err, "Fail");
-            Some(err.kind().to_string())
+            Err(Error::InvalidCommitMessage {
+                reason: err.kind().to_string(),
+            })
         }
     }
 }
 
 pub fn find_next_commit_on_dev(
-    next: git::Commit,
+    next: &git::Commit,
-    dev_commit_history: Vec<git::Commit>,
+    dev_commit_history: &[git::Commit],
 ) -> Option<git::Commit> {
-    let mut next_commit: Option<git::Commit> = None;
+    let mut next_commit: Option<&git::Commit> = None;
-    for commit in dev_commit_history.into_iter() {
+    for commit in dev_commit_history.iter() {
         if commit == next {
             break;
         };
         next_commit.replace(commit);
     }
-    next_commit
+    next_commit.cloned()
 }
 
 // advance main branch to the commit 'next'
@@ -82,15 +71,30 @@ pub async fn advance_main(
     repo_details: &git::RepoDetails,
     repo_config: &config::RepoConfig,
     repository: &git::OpenRepository,
-) {
+) -> Result<()> {
     info!("Advancing main to next");
-    if let Err(err) = git::push::reset(
+    git::push::reset(
         repository,
         repo_details,
         &repo_config.branches().main(),
         &next.into(),
         &git::push::Force::No,
-    ) {
+    )?;
-        warn!(?err, "Failed")
+    Ok(())
-    };
+}
+
+pub type Result<T> = core::result::Result<T, Error>;
+#[derive(Debug, thiserror::Error, Display)]
+pub enum Error {
+    #[display("push: {}", 0)]
+    Push(#[from] git::push::Error),
+
+    #[display("no commits to advance next to")]
+    NextAtDev,
+
+    #[display("commit is a Work-in-progress")]
+    IsWorkInProgress,
+
+    #[display("commit message is not in conventional commit format: {reason}")]
+    InvalidCommitMessage { reason: String },
 }

crates/repo-actor/src/handlers/advance_to_main.rs

@@ -0,0 +1,52 @@
+//
+use actix::prelude::*;
+use tracing::Instrument as _;
+
+use crate as actor;
+
+impl Handler<actor::messages::AdvanceMainTo> for actor::RepoActor {
+    type Result = ();
+    #[tracing::instrument(name = "RepoActor::AdvanceMainTo", skip_all, fields(repo = %self.repo_details, commit = ?msg))]
+    fn handle(
+        &mut self,
+        msg: actor::messages::AdvanceMainTo,
+        ctx: &mut Self::Context,
+    ) -> Self::Result {
+        let Some(repo_config) = self.repo_details.repo_config.clone() else {
+            tracing::warn!("No config loaded");
+            return;
+        };
+        let Some(repository) = self.open_repository.clone() else {
+            tracing::warn!("No repository opened");
+            return;
+        };
+        let repo_details = self.repo_details.clone();
+        let addr = ctx.address();
+        let message_token = self.message_token;
+        async move {
+            match actor::branch::advance_main(
+                msg.unwrap(),
+                &repo_details,
+                &repo_config,
+                &repository,
+            )
+            .await
+            {
+                Err(err) => {
+                    tracing::warn!("advance main: {err}");
+                }
+                Ok(_) => match repo_config.source() {
+                    git_next_config::RepoConfigSource::Repo => {
+                        addr.do_send(actor::messages::LoadConfigFromRepo)
+                    }
+                    git_next_config::RepoConfigSource::Server => {
+                        addr.do_send(actor::messages::ValidateRepo::new(message_token))
+                    }
+                },
+            }
+        }
+        .in_current_span()
+        .into_actor(self)
+        .wait(ctx);
+    }
+}

crates/repo-actor/src/handlers/clone.rs

@@ -0,0 +1,37 @@
+//
+use actix::prelude::*;
+
+use crate as actor;
+use git_next_git as git;
+
+impl Handler<actor::messages::CloneRepo> for actor::RepoActor {
+    type Result = ();
+    #[tracing::instrument(name = "RepoActor::CloneRepo", skip_all, fields(repo = %self.repo_details /*, gitdir = %self.repo_details.gitdir */))]
+    fn handle(
+        &mut self,
+        _msg: actor::messages::CloneRepo,
+        ctx: &mut Self::Context,
+    ) -> Self::Result {
+        println!("handler clone repo start");
+        let gitdir = self.repo_details.gitdir.clone();
+        match git::repository::open(&self.repository, &self.repo_details, gitdir) {
+            Ok(repository) => {
+                println!("- open okay");
+                self.open_repository.replace(repository);
+                if self.repo_details.repo_config.is_none() {
+                    println!("need to load config from repo");
+                    ctx.address().do_send(actor::messages::LoadConfigFromRepo);
+                } else {
+                    println!("need to validate repo");
+                    ctx.address()
+                        .do_send(actor::messages::ValidateRepo::new(self.message_token));
+                }
+            }
+            Err(err) => {
+                println!("err: {err:?}");
+                tracing::warn!("Could not open repo: {err}")
+            }
+        }
+        println!("handler clone repo finish");
+    }
+}

crates/repo-actor/src/handlers/load_config_from_repo.rs

@@ -0,0 +1,31 @@
+//
+use actix::prelude::*;
+use tracing::Instrument as _;
+
+use crate as actor;
+
+impl Handler<actor::messages::LoadConfigFromRepo> for actor::RepoActor {
+    type Result = ();
+    #[tracing::instrument(name = "RepoActor::LoadConfigFromRepo", skip_all, fields(repo = %self.repo_details))]
+    fn handle(
+        &mut self,
+        _msg: actor::messages::LoadConfigFromRepo,
+        ctx: &mut Self::Context,
+    ) -> Self::Result {
+        let details = self.repo_details.clone();
+        let addr = ctx.address();
+        let Some(open_repository) = self.open_repository.clone() else {
+            tracing::warn!("missing open repository - can't load configuration");
+            return;
+        };
+        async move {
+            match actor::load::config_from_repository(details, open_repository).await {
+                Ok(repo_config) => addr.do_send(actor::messages::LoadedConfig::new(repo_config)),
+                Err(err) => tracing::warn!(?err, "Failed to load config"),
+            }
+        }
+        .in_current_span()
+        .into_actor(self)
+        .wait(ctx);
+    }
+}

crates/repo-actor/src/handlers/loaded_config.rs

@@ -0,0 +1,20 @@
+//
+use actix::prelude::*;
+
+use crate as actor;
+
+impl Handler<actor::messages::LoadedConfig> for actor::RepoActor {
+    type Result = ();
+    #[tracing::instrument(name = "RepoActor::LoadedConfig", skip_all, fields(repo = %self.repo_details, branches = ?msg))]
+    fn handle(
+        &mut self,
+        msg: actor::messages::LoadedConfig,
+        ctx: &mut Self::Context,
+    ) -> Self::Result {
+        let repo_config = msg.unwrap();
+        self.repo_details.repo_config.replace(repo_config);
+
+        ctx.address()
+            .do_send(actor::messages::ValidateRepo::new(self.message_token));
+    }
+}

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

@@ -0,0 +1,11 @@
+pub mod advance_to_main;
+pub mod clone;
+pub mod load_config_from_repo;
+pub mod loaded_config;
+pub mod start_monitoring;
+pub mod validate_repo;
+pub mod webhook_message;
+pub mod webhook_registered;
+
+#[cfg(test)]
+pub mod test;

crates/repo-actor/src/handlers/start_monitoring.rs

@@ -0,0 +1,83 @@
+//
+use actix::prelude::*;
+use tracing::Instrument as _;
+
+use crate as actor;
+use git_next_git as git;
+
+impl Handler<actor::messages::StartMonitoring> for actor::RepoActor {
+    type Result = ();
+    #[tracing::instrument(name = "RepoActor::StartMonitoring", skip_all, 
+        fields(token = %self.message_token, repo = %self.repo_details, main = %msg.main(), next = %msg.next(), dev = %msg.dev()))
+    ]
+    fn handle(
+        &mut self,
+        msg: actor::messages::StartMonitoring,
+        ctx: &mut Self::Context,
+    ) -> Self::Result {
+        let Some(repo_config) = self.repo_details.repo_config.clone() else {
+            tracing::warn!("No config loaded");
+            return;
+        };
+
+        let next_ahead_of_main = msg.main() != msg.next();
+        let dev_ahead_of_next = msg.next() != msg.dev();
+        tracing::info!(next_ahead_of_main, dev_ahead_of_next, "StartMonitoring");
+
+        let addr = ctx.address();
+        let forge = self.forge.clone();
+
+        if next_ahead_of_main {
+            let message_token = self.message_token;
+            let sleep_duration = self.sleep_duration;
+            async move {
+                // get the status - pass, fail, pending (all others map to fail, e.g. error)
+                let status = forge.commit_status(msg.next()).await;
+                tracing::info!(?status, "Checking next branch");
+                match status {
+                    git::forge::commit::Status::Pass => {
+                        addr.do_send(actor::messages::AdvanceMainTo::new(msg.next().clone()));
+                    }
+                    git::forge::commit::Status::Pending => {
+                        tokio::time::sleep(sleep_duration).await;
+                        addr.do_send(actor::messages::ValidateRepo::new(message_token));
+                    }
+                    git::forge::commit::Status::Fail => {
+                        tracing::warn!("Checks have failed");
+                    }
+                }
+            }
+            .in_current_span()
+            .into_actor(self)
+            .wait(ctx);
+        } else if dev_ahead_of_next {
+            if let Some(repository) = self.open_repository.clone() {
+                let repo_details = self.repo_details.clone();
+                let message_token = self.message_token;
+                let sleep_duration = self.sleep_duration;
+                async move {
+                    match actor::branch::advance_next(
+                        msg.next(),
+                        msg.dev_commit_history(),
+                        repo_details,
+                        repo_config,
+                        repository,
+                        message_token,
+                    )
+                    .await
+                    {
+                        Ok(message_token) => {
+                            // pause to allow any CI checks to be started
+                            tokio::time::sleep(sleep_duration).await;
+                            addr.do_send(actor::messages::ValidateRepo::new(message_token))
+                        }
+                        Err(err) => tracing::warn!("advance next: {err}"),
+                    }
+                }
+                .in_current_span()
+                .into_actor(self)
+                .wait(ctx);
+            }
+        }
+    }
+}

crates/repo-actor/src/handlers/test.rs

@@ -0,0 +1,28 @@
+use crate as repo_actor;
+use actix::{Handler, Message};
+use git_next_git as git;
+use repo_actor::message;
+
+message!(GetRepositoryLog => Vec<String>);
+
+impl Handler<GetRepositoryLog> for repo_actor::RepoActor {
+    type Result = Vec<String>;
+
+    fn handle(&mut self, _msg: GetRepositoryLog, _ctx: &mut Self::Context) -> Self::Result {
+        println!("self.open_repo: {:?}", self.open_repository);
+        match &mut self.open_repository {
+            Some(git::OpenRepository::Test(tor)) => {
+                println!("we have a test repo...");
+                tor.take_log()
+            }
+            Some(git::OpenRepository::Mock(mor)) => {
+                println!("we have a mock repo...");
+                mor.take_log()
+            }
+            _ => {
+                println!("not a test repo");
+                vec![]
+            }
+        }
+    }
+}

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

@@ -0,0 +1,98 @@
+//
+use actix::prelude::*;
+use derive_more::Deref as _;
+use tracing::Instrument as _;
+
+use crate as actor;
+use git_next_git as git;
+
+impl Handler<actor::messages::ValidateRepo> for actor::RepoActor {
+    type Result = ();
+    #[tracing::instrument(name = "RepoActor::ValidateRepo", skip_all, fields(repo = %self.repo_details, token = %msg.deref()))]
+    fn handle(
+        &mut self,
+        msg: actor::messages::ValidateRepo,
+        ctx: &mut Self::Context,
+    ) -> Self::Result {
+        println!("handler validate repo - start");
+        match msg.unwrap() {
+            message_token if self.message_token < message_token => {
+                tracing::info!(%message_token, "New message token");
+                self.message_token = message_token;
+            }
+            message_token if self.message_token > message_token => {
+                tracing::info!("Dropping message from previous generation");
+                return; // message is expired
+            }
+            _ => {
+                // do nothing
+            }
+        }
+        if self.webhook_id.is_none() {
+            let forge_alias = self.repo_details.forge.forge_alias();
+            let repo_alias = &self.repo_details.repo_alias;
+            let webhook_url = self.webhook.url(forge_alias, repo_alias);
+            let forge = self.forge.clone();
+            let addr = ctx.address();
+            async move {
+                if let Err(err) =
+                    forge
+                        .register_webhook(&webhook_url)
+                        .await
+                        .and_then(|registered_webhook| {
+                            addr.try_send(actor::messages::WebhookRegistered::from(
+                                registered_webhook,
+                            ))
+                            .map_err(|e| {
+                                git::forge::webhook::Error::FailedToNotifySelf(e.to_string())
+                            })
+                        })
+                {
+                    tracing::warn!("registering webhook: {err}");
+                }
+            }
+            .in_current_span()
+            .into_actor(self)
+            .wait(ctx);
+        }
+        if let (Some(repository), Some(repo_config)) = (
+            self.open_repository.clone(),
+            self.repo_details.repo_config.clone(),
+        ) {
+            let repo_details = self.repo_details.clone();
+            let addr = ctx.address();
+            let message_token = self.message_token;
+            let sleep_duration = self.sleep_duration;
+            async move {
+                match git::validation::positions::validate_positions(
+                    &repository,
+                    &repo_details,
+                    repo_config,
+                ) {
+                    Ok(git::validation::positions::Positions {
+                        main,
+                        next,
+                        dev,
+                        dev_commit_history,
+                    }) => {
+                        addr.do_send(actor::messages::StartMonitoring::new(
+                            main,
+                            next,
+                            dev,
+                            dev_commit_history,
+                        ));
+                    }
+                    Err(err) => {
+                        tracing::warn!("{:?}", err);
+                        tokio::time::sleep(sleep_duration).await;
+                        addr.do_send(actor::messages::ValidateRepo::new(message_token));
+                    }
+                }
+            }
+            .in_current_span()
+            .into_actor(self)
+            .wait(ctx);
+        }
+        println!("handler validate repo - finish");
+    }
+}

crates/repo-actor/src/handlers/webhook_message.rs

@@ -1,13 +1,13 @@
 //
 use actix::prelude::*;
 
-use crate::{RepoActor, ValidateRepo};
+use crate as actor;
 use git_next_config as config;
 use git_next_git as git;
 
 use tracing::{info, warn};
 
-impl Handler<config::WebhookMessage> for RepoActor {
+impl Handler<config::WebhookMessage> for actor::RepoActor {
     type Result = ();
 
     #[allow(clippy::cognitive_complexity)] // TODO: (#49) reduce complexity
@@ -88,6 +88,7 @@ impl Handler<config::WebhookMessage> for RepoActor {
             token = %message_token,
             "New commit"
         );
-        ctx.address().do_send(ValidateRepo { message_token });
+        ctx.address()
+            .do_send(actor::messages::ValidateRepo::new(message_token));
     }
 }

crates/repo-actor/src/handlers/webhook_registered.rs

@@ -0,0 +1,17 @@
+//
+use actix::prelude::*;
+
+use crate as actor;
+
+impl Handler<actor::messages::WebhookRegistered> for actor::RepoActor {
+    type Result = ();
+    #[tracing::instrument(name = "RepoActor::WebhookRegistered", skip_all, fields(repo = %self.repo_details, webhook_id = %msg.webhook_id()))]
+    fn handle(
+        &mut self,
+        msg: actor::messages::WebhookRegistered,
+        _ctx: &mut Self::Context,
+    ) -> Self::Result {
+        self.webhook_id.replace(msg.webhook_id().clone());
+        self.webhook_auth.replace(msg.webhook_auth().clone());
+    }
+}

crates/repo-actor/src/lib.rs

@@ -1,30 +1,58 @@
 mod branch;
+pub mod handlers;
 mod load;
-pub mod status;
+pub mod messages;
-pub mod webhook;
 
 #[cfg(test)]
 mod tests;
 
-use std::time::Duration;
-
 use actix::prelude::*;
-use config::RegisteredWebhook;
-use git::validation::positions::{validate_positions, Positions};
 
-use crate as repo_actor;
 use git_next_config as config;
 use git_next_forge as forge;
 use git_next_git as git;
 
 use kxio::network::Network;
-use tracing::{debug, info, warn, Instrument};
+use tracing::{info, warn, Instrument};
 
 #[derive(Debug, derive_more::Display)]
 #[display("{}:{}:{}", generation, repo_details.forge.forge_alias(), repo_details.repo_alias)]
+/// An actor that represents a Git Repository.
+///
+/// When this actor is started it is sent the [CloneRepo] message.
+///
+/// ```mermaid
+/// stateDiagram-v2
+/// [*] --> CloneRepo :START
+///
+/// CloneRepo --> LoadConfigFromRepo
+/// CloneRepo --> ValidateRepo
+///
+/// LoadConfigFromRepo --> LoadedConfig
+///
+/// ValidateRepo --> WebhookRegistered
+/// ValidateRepo --> StartMonitoring
+/// ValidateRepo --> ValidateRepo :SLEEP 10s
+///
+/// LoadedConfig --> ValidateRepo
+///
+/// WebhookRegistered --> [*]
+///
+/// StartMonitoring --> AdvanceMainTo
+/// StartMonitoring --> ValidateRepo :SLEEP 10s
+///
+/// AdvanceMainTo --> LoadConfigFromRepo
+/// AdvanceMainTo --> ValidateRepo
+///
+/// [*] --> WebhookMessage :WEBHOOK
+///
+/// WebhookMessage --> ValidateRepo
+/// ```
+///
 pub struct RepoActor {
+    sleep_duration: std::time::Duration,
     generation: git::Generation,
-    message_token: MessageToken,
+    message_token: messages::MessageToken,
     repo_details: git::RepoDetails,
     webhook: config::server::Webhook,
     webhook_id: Option<config::WebhookId>, // INFO: if [None] then no webhook is configured
@@ -39,28 +67,30 @@ pub struct RepoActor {
 }
 impl RepoActor {
     pub fn new(
-        details: git::RepoDetails,
+        repo_details: git::RepoDetails,
         webhook: config::server::Webhook,
         generation: git::Generation,
         net: Network,
-        repo: git::Repository,
+        repository: git::Repository,
+        sleep_duration: std::time::Duration,
     ) -> Self {
-        let forge = forge::Forge::new(details.clone(), net.clone());
+        let message_token = messages::MessageToken::default();
-        debug!(?forge, "new");
+        let forge = forge::Forge::new(repo_details.clone(), net.clone());
         Self {
             generation,
-            message_token: MessageToken::new(),
+            message_token,
-            repo_details: details,
+            repo_details,
             webhook,
             webhook_id: None,
             webhook_auth: None,
             last_main_commit: None,
             last_next_commit: None,
             last_dev_commit: None,
-            repository: repo,
+            repository,
             open_repository: None,
-            net,
             forge,
+            net,
+            sleep_duration,
         }
     }
 }
@@ -68,9 +98,11 @@ impl Actor for RepoActor {
     type Context = Context<Self>;
     #[tracing::instrument(name = "RepoActor::stopping", skip_all, fields(repo = %self.repo_details))]
     fn stopping(&mut self, ctx: &mut Self::Context) -> Running {
+        eprintln!("stopping");
         info!("Checking webhook");
         match self.webhook_id.take() {
             Some(webhook_id) => {
+                eprintln!("stopping - unregistering webhook");
                 info!(%webhook_id, "Unregistring webhook");
                 let forge = self.forge.clone();
                 async move {
@@ -87,252 +119,3 @@ impl Actor for RepoActor {
         }
     }
 }
-
-#[derive(Message)]
-#[rtype(result = "()")]
-pub struct CloneRepo;
-impl Handler<CloneRepo> for RepoActor {
-    type Result = ();
-    #[tracing::instrument(name = "RepoActor::CloneRepo", skip_all, fields(repo = %self.repo_details /*, gitdir = %self.repo_details.gitdir */))]
-    fn handle(&mut self, _msg: CloneRepo, ctx: &mut Self::Context) -> Self::Result {
-        let gitdir = self.repo_details.gitdir.clone();
-        match git::repository::open(&self.repository, &self.repo_details, gitdir) {
-            Ok(repository) => {
-                self.open_repository.replace(repository);
-                if self.repo_details.repo_config.is_none() {
-                    ctx.address().do_send(LoadConfigFromRepo);
-                } else {
-                    ctx.address().do_send(ValidateRepo {
-                        message_token: self.message_token,
-                    });
-                }
-            }
-            Err(err) => warn!("Could not open repo: {err}"),
-        }
-    }
-}
-
-#[derive(Message)]
-#[rtype(result = "()")]
-pub struct LoadConfigFromRepo;
-impl Handler<LoadConfigFromRepo> for RepoActor {
-    type Result = ();
-    #[tracing::instrument(name = "RepoActor::LoadConfigFromRepo", skip_all, fields(repo = %self.repo_details))]
-    fn handle(&mut self, _msg: LoadConfigFromRepo, ctx: &mut Self::Context) -> Self::Result {
-        let details = self.repo_details.clone();
-        let addr = ctx.address();
-        let Some(open_repository) = self.open_repository.clone() else {
-            warn!("missing open repository - can't load configuration");
-            return;
-        };
-        repo_actor::load::load_file(details, addr, open_repository)
-            .in_current_span()
-            .into_actor(self)
-            .wait(ctx);
-    }
-}
-
-#[derive(Message)]
-#[rtype(result = "()")]
-struct LoadedConfig(git_next_config::RepoConfig);
-impl Handler<LoadedConfig> for RepoActor {
-    type Result = ();
-    #[tracing::instrument(name = "RepoActor::LoadedConfig", skip_all, fields(repo = %self.repo_details, branches = %msg.0))]
-    fn handle(&mut self, msg: LoadedConfig, ctx: &mut Self::Context) -> Self::Result {
-        let repo_config = msg.0;
-        self.repo_details.repo_config.replace(repo_config);
-
-        ctx.address().do_send(ValidateRepo {
-            message_token: self.message_token,
-        });
-    }
-}
-
-#[derive(derive_more::Constructor, Message)]
-#[rtype(result = "()")]
-pub struct ValidateRepo {
-    message_token: MessageToken,
-}
-impl Handler<ValidateRepo> for RepoActor {
-    type Result = ();
-    #[tracing::instrument(name = "RepoActor::ValidateRepo", skip_all, fields(repo = %self.repo_details, token = %msg.message_token))]
-    fn handle(&mut self, msg: ValidateRepo, ctx: &mut Self::Context) -> Self::Result {
-        match msg.message_token {
-            message_token if self.message_token < message_token => {
-                info!(%message_token, "New message token");
-                self.message_token = msg.message_token;
-            }
-            message_token if self.message_token > message_token => {
-                info!("Dropping message from previous generation");
-                return; // message is expired
-            }
-            _ => {
-                // do nothing
-            }
-        }
-        if self.webhook_id.is_none() {
-            let forge_alias = self.repo_details.forge.forge_alias();
-            let repo_alias = &self.repo_details.repo_alias;
-            let webhook_url = self.webhook.url(forge_alias, repo_alias);
-            let forge = self.forge.clone();
-            let addr = ctx.address();
-            async move {
-                if let Err(err) =
-                    forge
-                        .register_webhook(&webhook_url)
-                        .await
-                        .and_then(|registered_webhook| {
-                            addr.try_send(WebhookRegistered::from(registered_webhook))
-                                .map_err(|e| {
-                                    git::forge::webhook::Error::FailedToNotifySelf(e.to_string())
-                                })
-                        })
-                {
-                    warn!("registering webhook: {err}");
-                }
-            }
-            .in_current_span()
-            .into_actor(self)
-            .wait(ctx);
-        }
-        if let (Some(repository), Some(repo_config)) = (
-            self.open_repository.clone(),
-            self.repo_details.repo_config.clone(),
-        ) {
-            let repo_details = self.repo_details.clone();
-            let addr = ctx.address();
-            let message_token = self.message_token;
-            async move {
-                match validate_positions(&repository, &repo_details, repo_config) {
-                    Ok(Positions {
-                        main,
-                        next,
-                        dev,
-                        dev_commit_history,
-                    }) => {
-                        addr.do_send(StartMonitoring::new(main, next, dev, dev_commit_history));
-                    }
-                    Err(err) => {
-                        warn!("{:?}", err);
-                        tokio::time::sleep(Duration::from_secs(10)).await;
-                        addr.do_send(ValidateRepo::new(message_token));
-                    }
-                }
-            }
-            .in_current_span()
-            .into_actor(self)
-            .wait(ctx);
-        }
-    }
-}
-
-#[derive(Debug, derive_more::Constructor, Message)]
-#[rtype(result = "()")]
-pub struct StartMonitoring {
-    main: git::Commit,
-    next: git::Commit,
-    dev: git::Commit,
-    dev_commit_history: Vec<git::Commit>,
-}
-impl Handler<StartMonitoring> for RepoActor {
-    type Result = ();
-    #[tracing::instrument(name = "RepoActor::StartMonitoring", skip_all, 
-        fields(token = %self.message_token, repo = %self.repo_details, main = %msg.main, next= %msg.next, dev = %msg.dev))
-    ]
-    fn handle(&mut self, msg: StartMonitoring, ctx: &mut Self::Context) -> Self::Result {
-        let Some(repo_config) = self.repo_details.repo_config.clone() else {
-            warn!("No config loaded");
-            return;
-        };
-
-        let next_ahead_of_main = msg.main != msg.next;
-        let dev_ahead_of_next = msg.next != msg.dev;
-        info!(next_ahead_of_main, dev_ahead_of_next, "StartMonitoring");
-
-        let addr = ctx.address();
-        let forge = self.forge.clone();
-
-        if next_ahead_of_main {
-            status::check_next(msg.next, addr, forge, self.message_token)
-                .in_current_span()
-                .into_actor(self)
-                .wait(ctx);
-        } else if dev_ahead_of_next {
-            if let Some(repository) = self.open_repository.clone() {
-                branch::advance_next(
-                    msg.next,
-                    msg.dev_commit_history,
-                    self.repo_details.clone(),
-                    repo_config,
-                    repository,
-                    addr,
-                    self.message_token,
-                )
-                .in_current_span()
-                .into_actor(self)
-                .wait(ctx);
-            }
-        }
-    }
-}
-
-#[derive(Message)]
-#[rtype(result = "()")]
-pub struct WebhookRegistered(config::WebhookId, config::WebhookAuth);
-impl From<RegisteredWebhook> for WebhookRegistered {
-    fn from(value: RegisteredWebhook) -> Self {
-        Self(value.id().clone(), value.auth().clone())
-    }
-}
-impl Handler<WebhookRegistered> for RepoActor {
-    type Result = ();
-    #[tracing::instrument(name = "RepoActor::WebhookRegistered", skip_all, fields(repo = %self.repo_details, webhook_id = %msg.0))]
-    fn handle(&mut self, msg: WebhookRegistered, _ctx: &mut Self::Context) -> Self::Result {
-        self.webhook_id.replace(msg.0);
-        self.webhook_auth.replace(msg.1);
-    }
-}
-
-#[derive(Message)]
-#[rtype(result = "()")]
-pub struct AdvanceMainTo(git::Commit);
-impl Handler<AdvanceMainTo> for RepoActor {
-    type Result = ();
-    #[tracing::instrument(name = "RepoActor::AdvanceMainTo", skip_all, fields(repo = %self.repo_details, commit = %msg.0))]
-    fn handle(&mut self, msg: AdvanceMainTo, ctx: &mut Self::Context) -> Self::Result {
-        let Some(repo_config) = self.repo_details.repo_config.clone() else {
-            warn!("No config loaded");
-            return;
-        };
-        let Some(repository) = self.open_repository.clone() else {
-            warn!("No repository opened");
-            return;
-        };
-        let repo_details = self.repo_details.clone();
-        let addr = ctx.address();
-        let message_token = self.message_token;
-        async move {
-            branch::advance_main(msg.0, &repo_details, &repo_config, &repository).await;
-            match repo_config.source() {
-                git_next_config::RepoConfigSource::Repo => addr.do_send(LoadConfigFromRepo),
-                git_next_config::RepoConfigSource::Server => {
-                    addr.do_send(ValidateRepo { message_token })
-                }
-            }
-        }
-        .in_current_span()
-        .into_actor(self)
-        .wait(ctx);
-    }
-}
-
-#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord, derive_more::Display)]
-pub struct MessageToken(u32);
-impl MessageToken {
-    pub fn new() -> Self {
-        Self::default()
-    }
-    pub const fn next(&self) -> Self {
-        Self(self.0 + 1)
-    }
-}

crates/repo-actor/src/load.rs

@@ -1,75 +1,54 @@
-use std::path::PathBuf;
-
 //
-use actix::prelude::*;
+use derive_more::Display;
-
+use std::path::PathBuf;
-use tracing::{error, info};
+use tracing::info;
 
 use git_next_config as config;
 use git_next_git as git;
 
-use super::{LoadedConfig, RepoActor};
-
 /// Loads the [RepoConfig] from the `.git-next.toml` file in the repository
 #[tracing::instrument(skip_all, fields(branch = %repo_details.branch))]
-pub async fn load_file(
+pub async fn config_from_repository(
     repo_details: git::RepoDetails,
-    addr: Addr<RepoActor>,
     open_repository: git::OpenRepository,
-) {
+) -> Result<config::RepoConfig> {
     info!("Loading .git-next.toml from repo");
-    let repo_config = match load(&repo_details, &open_repository).await {
+    let contents =
-        Ok(repo_config) => repo_config,
+        open_repository.read_file(&repo_details.branch, &PathBuf::from(".git-next.toml"))?;
-        Err(err) => {
+    let config = config::RepoConfig::parse(&contents)?;
-            error!(?err, "Failed to load config");
+    let branches = open_repository.remote_branches()?;
-            return;
+    required_branch(&config.branches().main(), &branches)?;
-        }
+    required_branch(&config.branches().next(), &branches)?;
-    };
+    required_branch(&config.branches().dev(), &branches)?;
-    info!("Loaded .git-next.toml from repo");
-    addr.do_send(LoadedConfig(repo_config));
-}
-
-async fn load(
-    details: &git::RepoDetails,
-    open_repository: &git::OpenRepository,
-) -> Result<config::RepoConfig, Error> {
-    let contents = open_repository.read_file(&details.branch, &PathBuf::from(".git-next.toml"))?;
-    let config = config::RepoConfig::load(&contents)?;
-    let config = validate(config, open_repository).await?;
     Ok(config)
 }
 
-#[derive(Debug, derive_more::From, derive_more::Display)]
+fn required_branch(
+    branch_name: &config::BranchName,
+    branches: &[config::BranchName],
+) -> Result<()> {
+    branches
+        .iter()
+        .find(|branch| *branch == branch_name)
+        .ok_or_else(|| Error::BranchNotFound(branch_name.clone()))?;
+    Ok(())
+}
+
+pub type Result<T> = core::result::Result<T, Error>;
+#[derive(Debug, thiserror::Error, Display)]
 pub enum Error {
-    File(git::file::Error),
+    #[display("file")]
-    Config(config::server::Error),
+    File(#[from] git::file::Error),
-    Toml(toml::de::Error),
+
-    Branch(git::push::Error),
+    #[display("config")]
+    Config(#[from] config::server::Error),
+
+    #[display("toml")]
+    Toml(#[from] toml::de::Error),
+
+    #[display("push")]
+    Push(#[from] git::push::Error),
+
+    #[display("branch not found: {}", 0)]
     BranchNotFound(config::BranchName),
 }
-
-pub async fn validate(
-    config: config::RepoConfig,
-    open_repository: &git::OpenRepository,
-) -> Result<config::RepoConfig, Error> {
-    let branches = open_repository.remote_branches()?;
-    if !branches
-        .iter()
-        .any(|branch| branch == &config.branches().main())
-    {
-        return Err(Error::BranchNotFound(config.branches().main()));
-    }
-    if !branches
-        .iter()
-        .any(|branch| branch == &config.branches().next())
-    {
-        return Err(Error::BranchNotFound(config.branches().next()));
-    }
-    if !branches
-        .iter()
-        .any(|branch| branch == &config.branches().dev())
-    {
-        return Err(Error::BranchNotFound(config.branches().dev()));
-    }
-    Ok(config)
-}

crates/repo-actor/src/messages.rs

@@ -0,0 +1,89 @@
+//
+use actix::prelude::*;
+use config::newtype;
+use derive_more::{Constructor, Display};
+
+use git_next_config as config;
+use git_next_git as git;
+
+#[macro_export]
+macro_rules! message {
+    ($name:ident wraps $value:ty) => {
+        git_next_config::newtype!($name is a $value);
+        impl Message for $name {
+            type Result = ();
+        }
+    };
+    ($name:ident) => {
+        git_next_config::newtype!($name);
+        impl Message for $name {
+            type Result = ();
+        }
+    };
+    ($name:ident wraps $value:ty => $result:ty) => {
+        git_next_config::newtype!($name is a $value);
+        impl Message for $name {
+            type Result = $result;
+        }
+    };
+    ($name:ident => $result:ty) => {
+        git_next_config::newtype!($name);
+        impl Message for $name {
+            type Result = $result;
+        }
+    };
+}
+
+message!(LoadConfigFromRepo);
+message!(CloneRepo);
+message!(LoadedConfig wraps config::RepoConfig);
+message!(ValidateRepo wraps MessageToken);
+
+#[derive(Debug, Constructor, Message)]
+#[rtype(result = "()")]
+pub struct StartMonitoring {
+    main: git::Commit,
+    next: git::Commit,
+    dev: git::Commit,
+    dev_commit_history: Vec<git::Commit>,
+}
+impl StartMonitoring {
+    pub const fn main(&self) -> &git::Commit {
+        &self.main
+    }
+    pub const fn next(&self) -> &git::Commit {
+        &self.next
+    }
+    pub const fn dev(&self) -> &git::Commit {
+        &self.dev
+    }
+    pub fn dev_commit_history(&self) -> &[git::Commit] {
+        &self.dev_commit_history
+    }
+}
+
+message!(WebhookRegistered wraps (config::WebhookId, config::WebhookAuth));
+impl WebhookRegistered {
+    pub const fn webhook_id(&self) -> &config::WebhookId {
+        &self.0 .0
+    }
+    pub const fn webhook_auth(&self) -> &config::WebhookAuth {
+        &self.0 .1
+    }
+}
+impl From<config::RegisteredWebhook> for WebhookRegistered {
+    fn from(value: config::RegisteredWebhook) -> Self {
+        let webhook_id = value.id().clone();
+        let webhook_auth = value.auth().clone();
+        Self::from((webhook_id, webhook_auth))
+    }
+}
+
+message!(AdvanceMainTo wraps git::Commit);
+
+newtype!(MessageToken is a u32, Copy, Default, Display);
+impl MessageToken {
+    pub const fn next(&self) -> Self {
+        Self(self.0 + 1)
+    }
+}

crates/repo-actor/src/status.rs

@@ -1,33 +0,0 @@
-//
-use actix::prelude::*;
-
-use git_next_forge as forge;
-use git_next_git as git;
-use tracing::{info, warn};
-
-use crate::{MessageToken, ValidateRepo};
-
-use super::AdvanceMainTo;
-
-pub async fn check_next(
-    next: git::Commit,
-    addr: Addr<super::RepoActor>,
-    forge: forge::Forge,
-    message_token: MessageToken,
-) {
-    // get the status - pass, fail, pending (all others map to fail, e.g. error)
-    let status = forge.commit_status(&next).await;
-    info!(?status, "Checking next branch");
-    match status {
-        git::forge::commit::Status::Pass => {
-            addr.do_send(AdvanceMainTo(next));
-        }
-        git::forge::commit::Status::Pending => {
-            tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
-            addr.do_send(ValidateRepo { message_token });
-        }
-        git::forge::commit::Status::Fail => {
-            warn!("Checks have failed");
-        }
-    }
-}

crates/server/src/actors/server.rs

@@ -8,7 +8,7 @@ use git_next_config::{
     self as config, ForgeAlias, ForgeConfig, GitDir, RepoAlias, ServerRepoConfig,
 };
 use git_next_git::{Generation, RepoDetails, Repository};
-use git_next_repo_actor::{CloneRepo, RepoActor};
+use git_next_repo_actor as repo_actor;
 use kxio::{fs::FileSystem, network::Network};
 use tracing::{error, info, warn};
 
@@ -151,7 +151,7 @@ impl Server {
         forge_name: ForgeAlias,
         server_storage: &ServerStorage,
         webhook: &Webhook,
-    ) -> Vec<(ForgeAlias, RepoAlias, RepoActor)> {
+    ) -> Vec<(ForgeAlias, RepoAlias, repo_actor::RepoActor)> {
         let span =
             tracing::info_span!("create_forge_repos", name = %forge_name, config = %forge_config);
 
@@ -176,7 +176,8 @@ impl Server {
         forge_config: ForgeConfig,
         server_storage: &ServerStorage,
         webhook: &Webhook,
-    ) -> impl Fn((RepoAlias, &ServerRepoConfig)) -> (ForgeAlias, RepoAlias, RepoActor) {
+    ) -> impl Fn((RepoAlias, &ServerRepoConfig)) -> (ForgeAlias, RepoAlias, repo_actor::RepoActor)
+    {
         let server_storage = server_storage.clone();
         let webhook = webhook.clone();
         let net = self.net.clone();
@@ -208,7 +209,7 @@ impl Server {
                 gitdir,
             );
             info!("Starting Repo Actor");
-            let actor = RepoActor::new(
+            let actor = repo_actor::RepoActor::new(
                 repo_details,
                 webhook.clone(),
                 generation,
@@ -221,13 +222,13 @@ impl Server {
 
     fn start_actor(
         &self,
-        actor: (ForgeAlias, RepoAlias, RepoActor),
+        actor: (ForgeAlias, RepoAlias, repo_actor::RepoActor),
-    ) -> (RepoAlias, Addr<RepoActor>) {
+    ) -> (RepoAlias, Addr<repo_actor::RepoActor>) {
         let (forge_name, repo_alias, actor) = actor;
         let span = tracing::info_span!("start_actor", forge = %forge_name, repo = %repo_alias);
         let _guard = span.enter();
         let addr = actor.start();
-        addr.do_send(CloneRepo);
+        addr.do_send(repo_actor::messages::CloneRepo);
         info!("Started");
         (repo_alias, addr)
     }

crates/server/src/config/tests.rs

@@ -18,7 +18,7 @@ fn test_repo_config_load() -> Result<()> {
 
             [options]
         "#;
-    let config = RepoConfig::load(toml)?;
+    let config = RepoConfig::parse(toml)?;
 
     assert_eq!(
         config,

crates/server/src/lib.rs

@@ -1,19 +1,18 @@
+//
 mod actors;
 mod config;
-//
+
 use actix::prelude::*;
 
-use git_next_git::Repository;
 use kxio::{fs::FileSystem, network::Network};
-
 use std::path::PathBuf;
-
 use tracing::{error, info, level_filters::LevelFilter};
 
 use crate::actors::{
     file_watcher::{self, FileUpdated},
     server::Server,
 };
+use git_next_git::Repository;
 
 pub fn init(fs: FileSystem) {
     let file_name = "git-next-server.toml";
@@ -58,6 +57,7 @@ pub async fn start(fs: FileSystem, net: Network, repo: Repository) {
     info!("Server running - Press Ctrl-C to stop...");
     let _ = actix_rt::signal::ctrl_c().await;
     info!("Ctrl-C received, shutting down...");
+    // TODO: (#94) perform a controlled shutdown of server and file watcher
 }
 
 pub fn init_logging() {