WIP: refactor: repo-actor: rewrite tests using mockall

.cargo/config.toml

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

Cargo.toml

@@ -97,3 +97,4 @@ assert2 = "0.3"
 pretty_assertions = "1.4"
 rand = "0.8"
 mockall = "0.12"
+test-log = "0.2"

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/cli/src/main.rs

@@ -42,7 +42,8 @@ async fn main() {
                 git_next_server::init(fs);
             }
             Server::Start => {
-                git_next_server::start(fs, net, repo).await;
+                let sleep_duration = std::time::Duration::from_secs(10);
+                git_next_server::start(fs, net, repo, sleep_duration).await;
             }
         },
     }

crates/config/src/repo_config.rs

@@ -16,6 +16,7 @@ use crate::RepoConfigSource;
     serde::Serialize,
     derive_more::Constructor,
     derive_more::Display,
+    derive_with::With,
 )]
 #[display("{}", branches)]
 pub struct RepoConfig {

crates/forge-forgejo/src/lib.rs

@@ -23,6 +23,9 @@ impl ForgeJo {
 }
 #[async_trait::async_trait]
 impl git::ForgeLike for ForgeJo {
+    fn duplicate(&self) -> Box<dyn git::ForgeLike> {
+        Box::new(self.clone())
+    }
     fn name(&self) -> String {
         "forgejo".to_string()
     }

crates/forge-github/src/lib.rs

@@ -19,6 +19,9 @@ pub struct Github {
 }
 #[async_trait::async_trait]
 impl git::ForgeLike for Github {
+    fn duplicate(&self) -> Box<dyn git::ForgeLike> {
+        Box::new(self.clone())
+    }
     fn name(&self) -> String {
         "github".to_string()
     }

crates/forge/src/lib.rs

@@ -17,6 +17,7 @@ pub enum Forge {
     Github(git_next_forge_github::Github),
 }
 impl Forge {
+    #[deprecated(note = "use Forge::create instead")]
     pub fn new(repo_details: git::RepoDetails, net: Network) -> Self {
         match repo_details.forge.forge_type() {
             #[cfg(feature = "forgejo")]
@@ -30,6 +31,18 @@ impl Forge {
             git_next_config::ForgeType::MockForge => Self::Mock(mock_forge::MockForge::new()),
         }
     }
+
+    pub fn create(repo_details: git::RepoDetails, net: Network) -> Box<dyn git::ForgeLike> {
+        match repo_details.forge.forge_type() {
+            #[cfg(feature = "forgejo")]
+            git_next_config::ForgeType::ForgeJo => {
+                Box::new(forgejo::ForgeJo::new(repo_details, net))
+            }
+            #[cfg(feature = "github")]
+            git_next_config::ForgeType::GitHub => Box::new(github::Github::new(repo_details, net)),
+            git_next_config::ForgeType::MockForge => Box::new(git::MockForgeLike::new()),
+        }
+    }
 }
 impl std::ops::Deref for Forge {
     type Target = dyn git::ForgeLike;

crates/forge/src/mock_forge.rs

@@ -10,6 +10,9 @@ pub struct MockForge;
 
 #[async_trait::async_trait]
 impl git::ForgeLike for MockForge {
+    fn duplicate(&self) -> Box<dyn git::ForgeLike> {
+        Box::new(self.clone())
+    }
     fn name(&self) -> String {
         "mock".to_string()
     }

crates/forge/src/tests.rs

@@ -8,7 +8,7 @@ use git_next_git::{self as git, RepoDetails};
 fn test_mock_name() {
     let net = Network::new_mock();
     let repo_details = given_repo_details(config::ForgeType::MockForge);
-    let forge = Forge::new(repo_details, net);
+    let forge = Forge::create(repo_details, net);
     assert_eq!(forge.name(), "mock");
 }
 
@@ -16,7 +16,7 @@ fn test_mock_name() {
 fn test_forgejo_name() {
     let net = Network::new_mock();
     let repo_details = given_repo_details(config::ForgeType::ForgeJo);
-    let forge = Forge::new(repo_details, net);
+    let forge = Forge::create(repo_details, net);
     assert_eq!(forge.name(), "forgejo");
 }
 
@@ -24,7 +24,7 @@ fn test_forgejo_name() {
 fn test_github_name() {
     let net = Network::new_mock();
     let repo_details = given_repo_details(config::ForgeType::GitHub);
-    let forge = Forge::new(repo_details, net);
+    let forge = Forge::create(repo_details, net);
     assert_eq!(forge.name(), "github");
 }
 

crates/git/src/forge/like.rs

@@ -1,8 +1,10 @@
 use crate as git;
 use git_next_config as config;
 
+#[mockall::automock]
 #[async_trait::async_trait]
-pub trait ForgeLike {
+pub trait ForgeLike: std::fmt::Debug + Send + Sync {
+    fn duplicate(&self) -> Box<dyn ForgeLike>;
     fn name(&self) -> String;
 
     /// Checks that the message has a valid authorisation

crates/git/src/lib.rs

@@ -17,6 +17,7 @@ mod tests;
 
 pub use commit::Commit;
 pub use forge::like::ForgeLike;
+pub use forge::like::MockForgeLike;
 pub use generation::Generation;
 pub use git_ref::GitRef;
 pub use git_remote::GitRemote;

crates/git/src/push.rs

@@ -47,12 +47,12 @@ pub enum Error {
 }
 
 pub fn reset(
-    repository: &dyn git::repository::OpenRepositoryLike,
+    open_repository: &dyn git::repository::OpenRepositoryLike,
     repo_details: &git::RepoDetails,
     branch_name: &config::BranchName,
     to_commit: &git::GitRef,
     force: &git::push::Force,
 ) -> Result<()> {
-    repository.fetch()?;
-    repository.push(repo_details, branch_name, to_commit, force)
+    open_repository.fetch()?;
+    open_repository.push(repo_details, branch_name, to_commit, force)
 }

crates/git/src/repo_details.rs

@@ -1,7 +1,8 @@
-use git_next_config::{
+use config::{
     BranchName, ForgeAlias, ForgeConfig, ForgeDetails, GitDir, RepoAlias, RepoConfig, RepoPath,
     ServerRepoConfig,
 };
+use git_next_config as config;
 
 use super::{Generation, GitRemote};
 
@@ -57,4 +58,10 @@ impl RepoDetails {
     pub fn git_remote(&self) -> GitRemote {
         GitRemote::new(self.forge.hostname().clone(), self.repo_path.clone())
     }
+
+    pub fn with_hostname(mut self, hostname: config::Hostname) -> Self {
+        let forge = self.forge;
+        self.forge = forge.with_hostname(hostname);
+        self
+    }
 }

crates/git/src/repository/mod.rs

@@ -23,7 +23,7 @@ pub use real::RealRepository;
 use tracing::info;
 
 use crate::repository::test::TestRepository;
-use crate::validation::repo::validate_repo;
+use crate::validation::remotes::validate_default_remotes;
 
 use super::RepoDetails;
 
@@ -52,19 +52,20 @@ pub const fn test(fs: kxio::fs::FileSystem) -> TestRepository {
 #[tracing::instrument(skip_all)]
 #[cfg(not(tarpaulin_include))] // requires network access to either clone new and/or fetch.
 pub fn open(
-    repository: &dyn RepositoryFactory,
+    repository_factory: &dyn RepositoryFactory,
     repo_details: &RepoDetails,
     gitdir: config::GitDir,
 ) -> Result<Box<dyn OpenRepositoryLike>> {
     let open_repository = if !gitdir.exists() {
         info!("Local copy not found - cloning...");
-        repository.git_clone(repo_details)?
+        repository_factory.git_clone(repo_details)?
     } else {
         info!("Local copy found - opening...");
-        repository.open(&gitdir)?
+        repository_factory.open(&gitdir)?
     };
     info!("Validating...");
-    validate_repo(&*open_repository, repo_details).map_err(|e| Error::Validation(e.to_string()))?;
+    validate_default_remotes(&*open_repository, repo_details)
+        .map_err(|e| Error::Validation(e.to_string()))?;
     Ok(open_repository)
 }
 
@@ -125,7 +126,7 @@ impl std::ops::Deref for Repository {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub enum Direction {
     /// Push local changes to the remote.
     Push,

crates/git/src/repository/tests.rs

@@ -1,7 +1,7 @@
 use crate as git;
 
 mod validate {
-    use crate::{tests::given, validation::repo::validate_repo};
+    use crate::{tests::given, validation::remotes::validate_default_remotes};
 
     use super::*;
     use git::repository::Direction;
@@ -17,7 +17,7 @@ mod validate {
             .expect_find_default_remote()
             .returning(move |_direction| Some(repo_details_mock.git_remote()));
 
-        let result = validate_repo(&*open_repository, &repo_details);
+        let result = validate_default_remotes(&*open_repository, &repo_details);
         println!("{result:?}");
         assert!(result.is_ok());
     }
@@ -36,7 +36,7 @@ mod validate {
                 Direction::Fetch => Some(repo_details_mock.git_remote()),
             });
 
-        let result = validate_repo(&*open_repository, &repo_details);
+        let result = validate_default_remotes(&*open_repository, &repo_details);
         println!("{result:?}");
         assert!(result.is_err());
     }
@@ -55,7 +55,7 @@ mod validate {
                 Direction::Fetch => None,
             });
 
-        let result = validate_repo(&*open_repository, &repo_details);
+        let result = validate_default_remotes(&*open_repository, &repo_details);
         println!("{result:?}");
         assert!(result.is_err());
     }
@@ -74,7 +74,7 @@ mod validate {
                 Direction::Fetch => Some(repo_details_mock.git_remote()),
             });
 
-        let result = validate_repo(&*open_repository, &repo_details);
+        let result = validate_default_remotes(&*open_repository, &repo_details);
         println!("{result:?}");
         assert!(result.is_err());
     }
@@ -93,7 +93,7 @@ mod validate {
                 Direction::Fetch => Some(given::a_git_remote()),
             });
 
-        let result = validate_repo(&*open_repository, &repo_details);
+        let result = validate_default_remotes(&*open_repository, &repo_details);
         println!("{result:?}");
         assert!(result.is_err());
     }

crates/git/src/validation/mod.rs

@@ -1,5 +1,5 @@
 pub mod positions;
-pub mod repo;
+pub mod remotes;
 
 #[cfg(test)]
 mod tests;

crates/git/src/validation/positions.rs

@@ -45,6 +45,7 @@ pub fn validate_positions(
         .ok_or_else(|| Error::BranchHasNoCommits(dev_branch.clone()))?;
     // Validations:
     // Dev must be on main branch, else the USER must rebase it
+    tracing::debug!(dev=?commit_histories.dev, %main, "dev must be on main");
     if is_not_based_on(&commit_histories.dev, &main) {
         warn!("Dev '{dev_branch}' not based on main '{main_branch}' - user must rebase",);
         return Err(Error::DevBranchNotBasedOn {
@@ -53,16 +54,19 @@ pub fn validate_positions(
         });
     }
     // verify that next is on main or at most one commit on top of main, else reset it back to main
+    tracing::debug!(next=?commit_histories.next[0..=1], %main, "next is on main, or at most one commit on top of main");
     if is_not_based_on(&commit_histories.next[0..=1], &main) {
         info!("Main not on same commit as next, or it's parent - resetting next to main",);
         return reset_next_to_main(open_repository, repo_details, &main, &next, &next_branch);
     }
     // verify that next is an ancestor of dev, else reset it back to main
+    tracing::debug!(dev=?commit_histories.dev, %next, "next is ancestor of dev");
     if is_not_based_on(&commit_histories.dev, &next) {
         info!("Next is not an ancestor of dev - resetting next to main");
         return reset_next_to_main(open_repository, repo_details, &main, &next, &next_branch);
     }
 
+    tracing::debug!("branch positions okay");
     Ok(git::validation::positions::Positions {
         main,
         next,
@@ -72,14 +76,14 @@ pub fn validate_positions(
 }
 
 fn reset_next_to_main(
-    repository: &dyn crate::repository::OpenRepositoryLike,
+    open_repository: &dyn crate::repository::OpenRepositoryLike,
     repo_details: &crate::RepoDetails,
     main: &crate::Commit,
     next: &crate::Commit,
     next_branch: &config::BranchName,
 ) -> Result<Positions> {
     git::push::reset(
-        repository,
+        open_repository,
         repo_details,
         next_branch,
         &main.clone().into(),
@@ -100,13 +104,13 @@ fn is_not_based_on(commits: &[crate::commit::Commit], needle: &crate::Commit) ->
 }
 
 fn get_commit_histories(
-    repository: &dyn git::repository::OpenRepositoryLike,
+    open_repository: &dyn git::repository::OpenRepositoryLike,
     repo_config: &config::RepoConfig,
 ) -> git::commit::log::Result<git::commit::Histories> {
-    let main = (repository.commit_log(&repo_config.branches().main(), &[]))?;
+    let main = (open_repository.commit_log(&repo_config.branches().main(), &[]))?;
     let main_head = [main[0].clone()];
-    let next = repository.commit_log(&repo_config.branches().next(), &main_head)?;
-    let dev = repository.commit_log(&repo_config.branches().dev(), &main_head)?;
+    let next = open_repository.commit_log(&repo_config.branches().next(), &main_head)?;
+    let dev = open_repository.commit_log(&repo_config.branches().dev(), &main_head)?;
     let histories = git::commit::Histories { main, next, dev };
     Ok(histories)
 }

crates/git/src/validation/remotes.rs

@@ -3,7 +3,7 @@ use tracing::info;
 use crate as git;
 
 #[tracing::instrument(skip_all)]
-pub fn validate_repo(
+pub fn validate_default_remotes(
     open_repository: &dyn git::repository::OpenRepositoryLike,
     repo_details: &git::RepoDetails,
 ) -> Result<()> {

crates/git/src/validation/tests.rs

@@ -33,12 +33,13 @@ mod repos {
             "open repo"
         );
 
-        let result = git::validation::repo::validate_repo(&*open_repository, &repo_details);
+        let result =
+            git::validation::remotes::validate_default_remotes(&*open_repository, &repo_details);
         print!("{result:?}");
         let_assert!(Err(err) = result);
         assert!(matches!(
             err,
-            git::validation::repo::Error::NoDefaultPushRemote
+            git::validation::remotes::Error::NoDefaultPushRemote
         ));
     }
 }

crates/repo-actor/Cargo.toml

@@ -42,12 +42,21 @@ 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 }
+mockall = { workspace = true }
+test-log = { workspace = true }
+
 [lints.clippy]
 nursery = { level = "warn", priority = -1 }
 # pedantic = "warn"

crates/repo-actor/README.md

@@ -0,0 +1,29 @@
+```mermaid
+stateDiagram-v2
+[*] --> CloneRepo :START
+
+CloneRepo --> LoadConfigFromRepo
+CloneRepo --> ValidateRepo
+
+LoadConfigFromRepo --> LoadedConfig
+
+ValidateRepo --> StartMonitoring
+ValidateRepo --> ValidateRepo :SLEEP 10s
+
+LoadedConfig --> ValidateRepo
+LoadedConfig --> RegisterWebhook
+
+RegisterWebhook --> WebhookRegistered
+
+WebhookRegistered --> [*]
+
+StartMonitoring --> AdvanceMainTo
+StartMonitoring --> ValidateRepo :SLEEP 10s
+
+AdvanceMainTo --> LoadConfigFromRepo
+AdvanceMainTo --> ValidateRepo
+
+[*] --> WebhookMessage :WEBHOOK
+
+WebhookMessage --> ValidateRepo
+```

crates/repo-actor/src/branch.rs

@@ -1,96 +1,100 @@
 //
-use actix::prelude::*;
-
+use crate::messages::MessageToken;
 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,
-    dev_commit_history: Vec<git::Commit>,
+pub fn advance_next(
+    next: &git::Commit,
+    dev_commit_history: &[git::Commit],
     repo_details: git::RepoDetails,
     repo_config: config::RepoConfig,
     open_repository: &dyn git::repository::OpenRepositoryLike,
-    addr: Addr<super::RepoActor>,
     message_token: MessageToken,
-) {
-    let next_commit = find_next_commit_on_dev(next, dev_commit_history);
-    let Some(commit) = next_commit else {
-        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;
-    }
+) -> Result<MessageToken> {
+    let commit =
+        find_next_commit_on_dev(next, dev_commit_history).ok_or_else(|| Error::NextAtDev)?;
+    validate_commit_message(commit.message())?;
     info!("Advancing next to commit '{}'", commit);
-    if let Err(err) = git::push::reset(
+    git::push::reset(
         open_repository,
         &repo_details,
         &repo_config.branches().next(),
         &commit.into(),
         &git::push::Force::No,
-    ) {
-        warn!(?err, "Failed")
-    }
-    tokio::time::sleep(Duration::from_secs(10)).await;
-    addr.do_send(ValidateRepo { message_token })
+    )?;
+    Ok(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,
-    dev_commit_history: Vec<git::Commit>,
+    next: &git::Commit,
+    dev_commit_history: &[git::Commit],
 ) -> Option<git::Commit> {
-    let mut next_commit: Option<git::Commit> = None;
-    for commit in dev_commit_history.into_iter() {
+    let mut next_commit: Option<&git::Commit> = None;
+    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'
 #[tracing::instrument(fields(next), skip_all)]
-pub async fn advance_main(
+pub fn advance_main(
     next: git::Commit,
     repo_details: &git::RepoDetails,
     repo_config: &config::RepoConfig,
     open_repository: &dyn git::repository::OpenRepositoryLike,
-) {
+) -> Result<()> {
     info!("Advancing main to next");
-    if let Err(err) = git::push::reset(
+    git::push::reset(
         open_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,56 @@
+//
+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;
+        };
+        self.open_repository.iter().for_each(|open_repository| {
+            let open_repository = open_repository.duplicate();
+            let repo_details = self.repo_details.clone();
+            let repo_config = repo_config.clone();
+            let addr = ctx.address();
+            let msg = msg.clone();
+            let message_token = self.message_token;
+
+            match actor::branch::advance_main(
+                msg.unwrap(),
+                &repo_details,
+                &repo_config,
+                &*open_repository,
+            ) {
+                Err(err) => {
+                    tracing::warn!("advance main: {err}");
+                }
+                Ok(_) => {
+                    async move {
+                        match repo_config.source() {
+                            git_next_config::RepoConfigSource::Repo => {
+                                let _ = addr.send(actor::messages::LoadConfigFromRepo).await;
+                            }
+                            git_next_config::RepoConfigSource::Server => {
+                                let _ = addr
+                                    .send(actor::messages::ValidateRepo::new(message_token))
+                                    .await;
+                            }
+                        }
+                    }
+                    .in_current_span()
+                    .into_actor(self)
+                    .wait(ctx);
+                }
+            }
+        });
+    }
+}

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

@@ -0,0 +1,50 @@
+//
+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 {
+        tracing::debug!("Handler: CloneRepo: start");
+        let gitdir = self.repo_details.gitdir.clone();
+        match git::repository::open(&*self.repository_factory, &self.repo_details, gitdir) {
+            Ok(repository) => {
+                #[cfg(test)]
+                self.log("open okay");
+                tracing::debug!("open okay");
+                self.open_repository.replace(repository);
+                if self.repo_details.repo_config.is_none() {
+                    tracing::debug!("Handler: CloneRepo: Sending: LoadConfigFromRepo");
+                    #[cfg(test)]
+                    self.log("send: LoadConfigFromRepo");
+                    ctx.address().do_send(actor::messages::LoadConfigFromRepo);
+                } else {
+                    tracing::debug!("Handler: CloneRepo: Sending: ValidateRepo");
+                    #[cfg(test)]
+                    self.log("send: ValidateRepo");
+                    if let Err(_e) = ctx
+                        .address()
+                        .try_send(actor::messages::ValidateRepo::new(self.message_token))
+                    {
+                        #[cfg(test)]
+                        self.log(format!("ValidateRepo: error: {_e:?}"));
+                    }
+                }
+            }
+            Err(err) => {
+                #[cfg(test)]
+                self.log("open failed");
+                tracing::debug!("err: {err:?}");
+                tracing::warn!("Could not open repo: {err}")
+            }
+        }
+        tracing::debug!("Handler: CloneRepo: finish");
+    }
+}

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

@@ -0,0 +1,34 @@
+//
+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 {
+        tracing::debug!("Handler: LoadConfigFromRepo: start");
+        self.open_repository.iter().for_each(|open_repository| {
+            let open_repository = open_repository.duplicate();
+            let repo_details = self.repo_details.clone();
+            let addr = ctx.address();
+            async move {
+                match actor::load::config_from_repository(repo_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);
+        });
+        tracing::debug!("Handler: LoadConfigFromRepo: finish");
+    }
+}

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

@@ -0,0 +1,22 @@
+//
+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));
+        ctx.address()
+            .do_send(actor::messages::RegisterWebhook::new());
+    }
+}

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

@@ -0,0 +1,9 @@
+pub mod advance_to_main;
+pub mod clone;
+pub mod load_config_from_repo;
+pub mod loaded_config;
+pub mod register_webhook;
+pub mod start_monitoring;
+pub mod validate_repo;
+pub mod webhook_message;
+pub mod webhook_registered;

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

@@ -0,0 +1,37 @@
+//
+use actix::prelude::*;
+use tracing::Instrument as _;
+
+use crate as actor;
+use actor::{messages::RegisterWebhook, RepoActor};
+
+impl Handler<RegisterWebhook> for RepoActor {
+    type Result = ();
+
+    fn handle(&mut self, _msg: RegisterWebhook, ctx: &mut Self::Context) -> Self::Result {
+        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.duplicate();
+            let addr = ctx.address();
+            tracing::debug!("registering webhook");
+            async move {
+                match forge.register_webhook(&webhook_url).await {
+                    Ok(registered_webhook) => {
+                        tracing::debug!(?registered_webhook, "");
+                        let _ = addr
+                            .send(actor::messages::WebhookRegistered::from(registered_webhook))
+                            .await;
+                        tracing::debug!("message sent");
+                    }
+                    Err(err) => tracing::warn!(?err, "registering webhook"),
+                }
+            }
+            .in_current_span()
+            .into_actor(self)
+            .wait(ctx);
+            tracing::debug!("registering webhook done");
+        }
+    }
+}

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

@@ -0,0 +1,99 @@
+//
+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 {
+        #[cfg(test)]
+        self.log("StartMonitoring: start");
+        tracing::debug!("Handler: StartMonitoring: start");
+        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.duplicate();
+
+        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 => {
+                        let _ = addr
+                            .send(actor::messages::AdvanceMainTo::new(msg.next().clone()))
+                            .await;
+                    }
+                    git::forge::commit::Status::Pending => {
+                        tokio::time::sleep(sleep_duration).await;
+                        let _ = addr
+                            .send(actor::messages::ValidateRepo::new(message_token))
+                            .await;
+                    }
+                    git::forge::commit::Status::Fail => {
+                        tracing::warn!("Checks have failed");
+                    }
+                }
+            }
+            .in_current_span()
+            .into_actor(self)
+            .wait(ctx);
+        } else if dev_ahead_of_next {
+            let message_token = self.message_token;
+            let sleep_duration = self.sleep_duration;
+
+            self.open_repository.iter().for_each(|open_repository| {
+                let open_repository = open_repository.duplicate();
+                let msg = msg.clone();
+                let repo_details = self.repo_details.clone();
+                let repo_config = repo_config.clone();
+                let addr = addr.clone();
+
+                match actor::branch::advance_next(
+                    msg.next(),
+                    msg.dev_commit_history(),
+                    repo_details,
+                    repo_config,
+                    &*open_repository,
+                    message_token,
+                ) {
+                    Ok(message_token) => {
+                        async move {
+                            // pause to allow any CI checks to be started
+                            tokio::time::sleep(sleep_duration).await;
+                            let _ = addr
+                                .send(actor::messages::ValidateRepo::new(message_token))
+                                .await;
+                        }
+                        .in_current_span()
+                        .into_actor(self)
+                        .wait(ctx);
+                    }
+                    Err(err) => tracing::warn!("advance next: {err}"),
+                }
+            });
+        }
+        tracing::debug!("Handler: StartMonitoring: finish");
+        #[cfg(test)]
+        self.log("StartMonitoring: start");
+    }
+}

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

@@ -0,0 +1,103 @@
+//
+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 {
+        #[cfg(test)]
+        self.log("start: ValidateRepo");
+        tracing::debug!("Handler: ValidateRepo: start");
+
+        // Message Token
+        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
+            }
+        }
+
+        // Repository positions
+        #[cfg(test)]
+        let mut messages: Vec<String> = vec![];
+        #[allow(clippy::cognitive_complexity)]
+        self.open_repository.iter().for_each(|open_repository| {
+            tracing::debug!("we have an open repo");
+            if let Some(repo_config) = self.repo_details.repo_config.clone() {
+                tracing::debug!("we have repo config");
+                let repo_details = self.repo_details.clone();
+                let addr = ctx.address();
+                let message_token = self.message_token;
+                let sleep_duration = self.sleep_duration;
+                tracing::debug!("Duplicating open repo");
+                let open_repository = open_repository.duplicate();
+                tracing::debug!("Validating branch positions");
+                match git::validation::positions::validate_positions(
+                    &*open_repository,
+                    &repo_details,
+                    repo_config,
+                ) {
+                    Ok(git::validation::positions::Positions {
+                        main,
+                        next,
+                        dev,
+                        dev_commit_history,
+                    }) => {
+                        tracing::debug!("Positions valid - sending StartMonitoring#");
+                        #[cfg(test)]
+                        messages.push("send: StartMonitoring".to_string());
+                        async move {
+                            let _ = addr
+                                .send(actor::messages::StartMonitoring::new(
+                                    main,
+                                    next,
+                                    dev,
+                                    dev_commit_history,
+                                ))
+                                .await;
+                        }
+                        .in_current_span()
+                        .into_actor(self)
+                        .wait(ctx);
+                    }
+                    Err(err) => {
+                        #[cfg(test)]
+                        messages.push(format!("invalid positions: {err:?}, sleep then retry"));
+                        tracing::warn!("Error: {err:?}");
+                        tracing::debug!("sleeping before retrying...");
+                        async move {
+                            tokio::time::sleep(sleep_duration).await;
+                            tracing::debug!("retrying...");
+                            let _ = addr
+                                .send(actor::messages::ValidateRepo::new(message_token))
+                                .await;
+                        }
+                        .in_current_span()
+                        .into_actor(self)
+                        .wait(ctx);
+                    }
+                }
+            }
+        });
+        #[cfg(test)]
+        messages.into_iter().for_each(|message| self.log(message));
+
+        tracing::debug!("Handler: ValidateRepo: 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,60 @@
 mod branch;
+pub mod handlers;
 mod load;
-pub mod status;
-pub mod webhook;
+pub mod messages;
 
 #[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};
 
+#[cfg(test)]
+pub type RepoActorLog = std::sync::Arc<std::sync::Mutex<Vec<String>>>;
+
+/// 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
+/// ```
+///
 #[derive(Debug, derive_more::Display)]
 #[display("{}:{}:{}", generation, repo_details.forge.forge_alias(), repo_details.repo_alias)]
 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
@@ -32,35 +62,56 @@ pub struct RepoActor {
     last_main_commit: Option<git::Commit>,
     last_next_commit: Option<git::Commit>,
     last_dev_commit: Option<git::Commit>,
-    repository: Box<dyn git::repository::RepositoryFactory>,
+    repository_factory: Box<dyn git::repository::RepositoryFactory>,
     open_repository: Option<Box<dyn git::repository::OpenRepositoryLike>>,
     net: Network,
-    forge: forge::Forge,
+    forge: Box<dyn git::ForgeLike>,
+    #[cfg(test)]
+    log: Option<RepoActorLog>,
 }
 impl RepoActor {
     pub fn new(
-        details: git::RepoDetails,
+        repo_details: git::RepoDetails,
+        forge: Box<dyn git::ForgeLike>,
         webhook: config::server::Webhook,
         generation: git::Generation,
         net: Network,
-        repository: Box<dyn git::repository::RepositoryFactory>,
+        repository_factory: Box<dyn git::repository::RepositoryFactory>,
+        sleep_duration: std::time::Duration,
     ) -> Self {
-        let forge = forge::Forge::new(details.clone(), net.clone());
-        debug!(?forge, "new");
+        let message_token = messages::MessageToken::default();
         Self {
             generation,
-            message_token: MessageToken::new(),
-            repo_details: details,
+            message_token,
+            repo_details,
             webhook,
             webhook_id: None,
             webhook_auth: None,
             last_main_commit: None,
             last_next_commit: None,
             last_dev_commit: None,
-            repository,
+            repository_factory,
             open_repository: None,
-            net,
             forge,
+            net,
+            sleep_duration,
+            #[cfg(test)]
+            log: None,
+        }
+    }
+}
+
+#[cfg(test)]
+impl RepoActor {
+    pub fn with_log(mut self, log: RepoActorLog) -> Self {
+        self.log = Some(log);
+        self
+    }
+
+    fn log(&mut self, message: impl Into<String>) {
+        let message: String = message.into();
+        for log in self.log.iter() {
+            let _ = log.lock().map(|mut l| l.push(message.clone()));
         }
     }
 }
@@ -68,11 +119,13 @@ 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 {
+        tracing::debug!("stopping");
         info!("Checking webhook");
         match self.webhook_id.take() {
             Some(webhook_id) => {
+                tracing::warn!("stopping - unregistering webhook");
                 info!(%webhook_id, "Unregistring webhook");
-                let forge = self.forge.clone();
+                let forge = self.forge.duplicate();
                 async move {
                     if let Err(err) = forge.unregister_webhook(&webhook_id).await {
                         warn!("unregistering webhook: {err}");
@@ -87,260 +140,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 else {
-            warn!("missing open repository - can't load configuration");
-            return;
-        };
-        let open_repository = open_repository.duplicate();
-        async move { repo_actor::load::load_file(details, addr, &*open_repository).await }
-            .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(open_repository), Some(repo_config)) =
-            (&self.open_repository, self.repo_details.repo_config.clone())
-        {
-            let repo_details = self.repo_details.clone();
-            let addr = ctx.address();
-            let message_token = self.message_token;
-            let open_repository = open_repository.duplicate();
-            async move {
-                match validate_positions(&*open_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(open_repository) = &self.open_repository {
-                let open_repository = open_repository.duplicate();
-                let repo_details = self.repo_details.clone();
-                let message_token = self.message_token;
-                async move {
-                    branch::advance_next(
-                        msg.next,
-                        msg.dev_commit_history,
-                        repo_details,
-                        repo_config,
-                        &*open_repository,
-                        addr,
-                        message_token,
-                    )
-                    .await
-                }
-                .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(open_repository) = &self.open_repository else {
-            warn!("No repository opened");
-            return;
-        };
-        let repo_details = self.repo_details.clone();
-        let addr = ctx.address();
-        let message_token = self.message_token;
-        let open_repository = open_repository.duplicate();
-        async move {
-            branch::advance_main(msg.0, &repo_details, &repo_config, &*open_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 tracing::{error, info};
+use derive_more::Display;
+use std::path::PathBuf;
+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: &dyn git::repository::OpenRepositoryLike,
-) {
+) -> Result<config::RepoConfig> {
     info!("Loading .git-next.toml from repo");
-    let repo_config = match load(&repo_details, open_repository).await {
-        Ok(repo_config) => repo_config,
-        Err(err) => {
-            error!(?err, "Failed to load config");
-            return;
-        }
-    };
-    info!("Loaded .git-next.toml from repo");
-    addr.do_send(LoadedConfig(repo_config));
-}
-
-async fn load(
-    details: &git::RepoDetails,
-    open_repository: &dyn git::repository::OpenRepositoryLike,
-) -> Result<config::RepoConfig, Error> {
-    let contents = open_repository.read_file(&details.branch, &PathBuf::from(".git-next.toml"))?;
+    let contents =
+        open_repository.read_file(&repo_details.branch, &PathBuf::from(".git-next.toml"))?;
     let config = config::RepoConfig::parse(&contents)?;
-    let config = validate(config, open_repository).await?;
+    let branches = open_repository.remote_branches()?;
+    required_branch(&config.branches().main(), &branches)?;
+    required_branch(&config.branches().next(), &branches)?;
+    required_branch(&config.branches().dev(), &branches)?;
     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),
-    Config(config::server::Error),
-    Toml(toml::de::Error),
-    Branch(git::push::Error),
+    #[display("file")]
+    File(#[from] git::file::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: &dyn git::repository::OpenRepositoryLike,
-) -> 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,91 @@
+//
+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(Clone, 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)
+    }
+}
+
+message!(RegisterWebhook);

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,8 @@ use git_next_config::{
     self as config, ForgeAlias, ForgeConfig, GitDir, RepoAlias, ServerRepoConfig,
 };
 use git_next_git::{repository::RepositoryFactory, Generation, RepoDetails};
-use git_next_repo_actor::{CloneRepo, RepoActor};
+use git_next_repo_actor::messages::CloneRepo;
+use git_next_repo_actor::RepoActor;
 use kxio::{fs::FileSystem, network::Network};
 use tracing::{error, info, warn};
 
@@ -39,6 +40,7 @@ pub struct Server {
     fs: FileSystem,
     net: Network,
     repository_factory: Box<dyn RepositoryFactory>,
+    sleep_duration: std::time::Duration,
 }
 impl Actor for Server {
     type Context = Context<Self>;
@@ -114,7 +116,12 @@ impl Handler<ServerConfig> for Server {
     }
 }
 impl Server {
-    pub fn new(fs: FileSystem, net: Network, repo: Box<dyn RepositoryFactory>) -> Self {
+    pub fn new(
+        fs: FileSystem,
+        net: Network,
+        repo: Box<dyn RepositoryFactory>,
+        sleep_duration: std::time::Duration,
+    ) -> Self {
         let generation = Generation::default();
         Self {
             generation,
@@ -122,6 +129,7 @@ impl Server {
             fs,
             net,
             repository_factory: repo,
+            sleep_duration,
         }
     }
     fn create_forge_data_directories(
@@ -182,6 +190,7 @@ impl Server {
         let net = self.net.clone();
         let repository_factory = self.repository_factory.duplicate();
         let generation = self.generation;
+        let sleep_duration = self.sleep_duration;
         move |(repo_alias, server_repo_config)| {
             let span = tracing::info_span!("create_actor", alias = %repo_alias, config = %server_repo_config);
             let _guard = span.enter();
@@ -207,13 +216,16 @@ impl Server {
                 &forge_config,
                 gitdir,
             );
+            let forge = git_next_forge::Forge::create(repo_details.clone(), net.clone());
             info!("Starting Repo Actor");
             let actor = RepoActor::new(
                 repo_details,
+                forge,
                 webhook.clone(),
                 generation,
                 net.clone(),
                 repository_factory.duplicate(),
+                sleep_duration,
             );
             (forge_name.clone(), repo_alias, actor)
         }

crates/server/src/config/tests.rs

@@ -1,6 +1,6 @@
 //
 use assert2::let_assert;
-use git::{repository::Direction, validation::repo::validate_repo};
+use git::{repository::Direction, validation::remotes::validate_default_remotes};
 use git_next_config::{
     self as config, ForgeType, GitDir, Hostname, RepoBranches, RepoConfig, RepoConfigSource,
     RepoPath,
@@ -46,7 +46,7 @@ fn gitdir_should_display_as_pathbuf() {
 // git.kemitix.net:kemitix/git-next
 // If the default push remote is something else, then this test will fail
 fn repo_details_find_default_push_remote_finds_correct_remote() -> Result<()> {
-    let cli_crate_dir = std::env::current_dir().map_err(git::validation::repo::Error::Io)?;
+    let cli_crate_dir = std::env::current_dir().map_err(git::validation::remotes::Error::Io)?;
     let_assert!(Some(Some(root)) = cli_crate_dir.parent().map(|p| p.parent()));
     let mut repo_details = git::common::repo_details(
         1,
@@ -77,7 +77,7 @@ fn repo_details_find_default_push_remote_finds_correct_remote() -> Result<()> {
 
 #[test]
 fn gitdir_validate_should_pass_a_valid_git_repo() -> Result<()> {
-    let cli_crate_dir = std::env::current_dir().map_err(git::validation::repo::Error::Io)?;
+    let cli_crate_dir = std::env::current_dir().map_err(git::validation::remotes::Error::Io)?;
     let_assert!(Some(Some(root)) = cli_crate_dir.parent().map(|p| p.parent()));
     let mut repo_details = git::common::repo_details(
         1,
@@ -92,7 +92,7 @@ fn gitdir_validate_should_pass_a_valid_git_repo() -> Result<()> {
         .with_hostname(Hostname::new("git.kemitix.net"));
     let gitdir = &repo_details.gitdir;
     let repository = git::repository::real().open(gitdir)?;
-    validate_repo(&*repository, &repo_details)?;
+    validate_default_remotes(&*repository, &repo_details)?;
 
     Ok(())
 }
@@ -100,7 +100,7 @@ fn gitdir_validate_should_pass_a_valid_git_repo() -> Result<()> {
 #[test]
 fn gitdir_validate_should_fail_a_git_repo_with_wrong_remote() -> Result<()> {
     let_assert!(
-        Ok(cli_crate_dir) = std::env::current_dir().map_err(git::validation::repo::Error::Io)
+        Ok(cli_crate_dir) = std::env::current_dir().map_err(git::validation::remotes::Error::Io)
     );
     let_assert!(Some(Some(root)) = cli_crate_dir.parent().map(|p| p.parent()));
     let repo_details = git::common::repo_details(
@@ -113,7 +113,7 @@ fn gitdir_validate_should_fail_a_git_repo_with_wrong_remote() -> Result<()> {
     .with_repo_path(RepoPath::new("hello/world".to_string()));
     let gitdir = &repo_details.gitdir;
     let repository = git::repository::real().open(gitdir)?;
-    let_assert!(Err(_) = validate_repo(&*repository, &repo_details));
+    let_assert!(Err(_) = validate_default_remotes(&*repository, &repo_details));
 
     Ok(())
 }

crates/server/src/lib.rs

@@ -37,11 +37,16 @@ pub fn init(fs: FileSystem) {
     }
 }
 
-pub async fn start(fs: FileSystem, net: Network, repo: Box<dyn RepositoryFactory>) {
+pub async fn start(
+    fs: FileSystem,
+    net: Network,
+    repo: Box<dyn RepositoryFactory>,
+    sleep_duration: std::time::Duration,
+) {
     init_logging();
 
     info!("Starting Server...");
-    let server = Server::new(fs.clone(), net.clone(), repo).start();
+    let server = Server::new(fs.clone(), net.clone(), repo, sleep_duration).start();
     server.do_send(FileUpdated);
 
     info!("Starting File Watcher...");