WIP: use newtype macro

crates/config/src/repo_config.rs

@@ -13,7 +13,7 @@ pub struct RepoConfig {
     source: RepoConfigSource,
 }
 impl RepoConfig {
-    pub fn parse(toml: &str) -> Result<Self, toml::de::Error> {
+    pub fn load(toml: &str) -> Result<Self, toml::de::Error> {
         toml::from_str(format!("source = \"Repo\"\n{}", toml).as_str())
     }
 

crates/config/src/tests.rs

@@ -110,7 +110,7 @@ mod repo_config {
         "#
         );
 
-        let rc = RepoConfig::parse(toml.as_str())?;
+        let rc = RepoConfig::load(toml.as_str())?;
 
         assert_eq!(
             rc,

crates/git/src/repository/mod.rs

@@ -8,7 +8,7 @@ pub use open::MockOpenRepository;
 
 mod open;
 mod real;
-pub mod test;
+mod test;
 
 #[cfg(test)]
 mod tests;
@@ -49,8 +49,8 @@ pub fn mock() -> MockRepository {
     MockRepository::new()
 }
 
-pub fn test(fs: kxio::fs::FileSystem) -> TestRepository {
-    TestRepository::new(false, fs, Default::default(), Default::default())
+pub const fn test(fs: kxio::fs::FileSystem) -> TestRepository {
+    TestRepository::new(false, fs, vec![], vec![])
 }
 
 // #[cfg(test)]

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

@@ -58,8 +58,8 @@ pub fn real(gix_repo: gix::Repository) -> OpenRepository {
 pub fn test(
     gitdir: &config::GitDir,
     fs: kxio::fs::FileSystem,
-    on_fetch: Arc<Mutex<Vec<otest::OnFetch>>>,
-    on_push: Arc<Mutex<Vec<otest::OnPush>>>,
+    on_fetch: Vec<otest::OnFetch>,
+    on_push: Vec<otest::OnPush>,
 ) -> OpenRepository {
     OpenRepository::Test(TestOpenRepository::new(gitdir, fs, on_fetch, on_push))
 }
@@ -68,8 +68,8 @@ pub fn test(
 pub fn test_bare(
     gitdir: &config::GitDir,
     fs: kxio::fs::FileSystem,
-    on_fetch: Arc<Mutex<Vec<otest::OnFetch>>>,
-    on_push: Arc<Mutex<Vec<otest::OnPush>>>,
+    on_fetch: Vec<otest::OnFetch>,
+    on_push: Vec<otest::OnPush>,
 ) -> OpenRepository {
     OpenRepository::Test(TestOpenRepository::new_bare(gitdir, fs, on_fetch, on_push))
 }

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

@@ -61,9 +61,9 @@ impl OnPush {
 
 #[derive(Clone, Debug)]
 pub struct TestOpenRepository {
-    on_fetch: Arc<Mutex<Vec<OnFetch>>>,
+    on_fetch: Vec<OnFetch>,
     fetch_counter: Arc<RwLock<usize>>,
-    on_push: Arc<Mutex<Vec<OnPush>>>,
+    on_push: Vec<OnPush>,
     push_counter: Arc<RwLock<usize>>,
     real: git::repository::RealOpenRepository,
 }
@@ -87,14 +87,9 @@ impl git::repository::OpenRepositoryLike for TestOpenRepository {
             .write()
             .map_err(|_| git::fetch::Error::Lock)
             .map(|mut c| *c += 1)?;
-        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");
-                })
-            })?
+        self.on_fetch.get(i).map(|f| f.invoke()).unwrap_or_else(|| {
+            unimplemented!("Unexpected fetch");
+        })
     }
 
     fn push(
@@ -115,15 +110,11 @@ impl git::repository::OpenRepositoryLike for TestOpenRepository {
             .map_err(|_| git::fetch::Error::Lock)
             .map(|mut c| *c += 1)?;
         self.on_push
-            .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");
-                    })
-            })?
+            .get(i)
+            .map(|f| f.invoke(repo_details, branch_name, to_commit, force))
+            .unwrap_or_else(|| {
+                unimplemented!("Unexpected push");
+            })
     }
 
     fn commit_log(
@@ -146,8 +137,8 @@ impl TestOpenRepository {
     pub fn new(
         gitdir: &config::GitDir,
         fs: kxio::fs::FileSystem,
-        on_fetch: Arc<Mutex<Vec<OnFetch>>>,
-        on_push: Arc<Mutex<Vec<OnPush>>>,
+        on_fetch: Vec<OnFetch>,
+        on_push: Vec<OnPush>,
     ) -> Self {
         let pathbuf = fs.base().join(gitdir.to_path_buf());
         #[allow(clippy::expect_used)]
@@ -164,8 +155,8 @@ impl TestOpenRepository {
     pub fn new_bare(
         gitdir: &config::GitDir,
         fs: kxio::fs::FileSystem,
-        on_fetch: Arc<Mutex<Vec<OnFetch>>>,
-        on_push: Arc<Mutex<Vec<OnPush>>>,
+        on_fetch: Vec<OnFetch>,
+        on_push: Vec<OnPush>,
     ) -> Self {
         let pathbuf = fs.base().join(gitdir.to_path_buf());
         #[allow(clippy::expect_used)]

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

@@ -114,7 +114,7 @@ mod repo_config {
         "#
         );
 
-        let rc = config::RepoConfig::parse(toml.as_str())?;
+        let rc = config::RepoConfig::load(toml.as_str())?;
 
         assert_eq!(
             rc,

crates/git/src/repository/test.rs

@@ -1,5 +1,3 @@
-use std::sync::{Arc, Mutex};
-
 //
 use derive_more::Constructor;
 
@@ -11,16 +9,16 @@ use git_next_config as config;
 pub struct TestRepository {
     is_bare: bool,
     fs: kxio::fs::FileSystem,
-    on_fetch: Arc<Mutex<Vec<git::repository::open::otest::OnFetch>>>,
-    on_push: Arc<Mutex<Vec<git::repository::open::otest::OnPush>>>,
+    on_fetch: Vec<git::repository::open::otest::OnFetch>,
+    on_push: Vec<git::repository::open::otest::OnPush>,
 }
 impl TestRepository {
     pub fn on_fetch(&mut self, on_fetch: git::repository::OnFetch) {
-        let _ = self.on_fetch.lock().map(|mut a| a.push(on_fetch));
+        self.on_fetch.push(on_fetch);
     }
 
     pub fn on_push(&mut self, on_push: git::repository::OnPush) {
-        let _ = self.on_push.lock().map(|mut a| a.push(on_push));
+        self.on_push.push(on_push);
     }
 
     pub const fn fs(&self) -> &kxio::fs::FileSystem {

crates/repo-actor/Cargo.toml

@@ -42,19 +42,12 @@ 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,67 +1,78 @@
 //
-use crate as actor;
+use actix::prelude::*;
+
 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: &[git::Commit],
+    next: git::Commit,
+    dev_commit_history: Vec<git::Commit>,
     repo_details: git::RepoDetails,
     repo_config: config::RepoConfig,
     repository: git::OpenRepository,
-    message_token: actor::MessageToken,
-) -> Result<actor::MessageToken> {
-    let commit =
-        find_next_commit_on_dev(next, dev_commit_history).ok_or_else(|| Error::NextAtDev)?;
-    validate_commit_message(commit.message())?;
+    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;
+    }
     info!("Advancing next to commit '{}'", commit);
-    git::push::reset(
+    if let Err(err) = git::push::reset(
         &repository,
         &repo_details,
         &repo_config.branches().next(),
         &commit.into(),
         &git::push::Force::No,
-    )?;
-    Ok(message_token)
+    ) {
+        warn!(?err, "Failed")
+    }
+    tokio::time::sleep(Duration::from_secs(10)).await;
+    addr.do_send(ValidateRepo { message_token })
 }
 
 #[tracing::instrument]
-fn validate_commit_message(message: &git::commit::Message) -> Result<()> {
+fn validate_commit_message(message: &git::commit::Message) -> Option<String> {
     let message = &message.to_string();
     if message.to_ascii_lowercase().starts_with("wip") {
-        return Err(Error::IsWorkInProgress);
+        return Some("Is Work-In-Progress".to_string());
     }
     match git_conventional::Commit::parse(message) {
         Ok(commit) => {
             info!(?commit, "Pass");
-            Ok(())
+            None
         }
         Err(err) => {
             warn!(?err, "Fail");
-            Err(Error::InvalidCommitMessage {
-                reason: err.kind().to_string(),
-            })
+            Some(err.kind().to_string())
         }
     }
 }
 
 pub fn find_next_commit_on_dev(
-    next: &git::Commit,
-    dev_commit_history: &[git::Commit],
+    next: git::Commit,
+    dev_commit_history: Vec<git::Commit>,
 ) -> Option<git::Commit> {
-    let mut next_commit: Option<&git::Commit> = None;
-    for commit in dev_commit_history.iter() {
+    let mut next_commit: Option<git::Commit> = None;
+    for commit in dev_commit_history.into_iter() {
         if commit == next {
             break;
         };
         next_commit.replace(commit);
     }
-    next_commit.cloned()
+    next_commit
 }
 
 // advance main branch to the commit 'next'
@@ -71,30 +82,15 @@ pub async fn advance_main(
     repo_details: &git::RepoDetails,
     repo_config: &config::RepoConfig,
     repository: &git::OpenRepository,
-) -> Result<()> {
+) {
     info!("Advancing main to next");
-    git::push::reset(
+    if let Err(err) = git::push::reset(
         repository,
         repo_details,
         &repo_config.branches().main(),
         &next.into(),
         &git::push::Force::No,
-    )?;
-    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 },
+    ) {
+        warn!(?err, "Failed")
+    };
 }

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

@@ -1,42 +0,0 @@
-//
-use actix::prelude::*;
-use tracing::Instrument as _;
-
-use crate as actor;
-
-impl Handler<actor::AdvanceMainTo> for actor::RepoActor {
-    type Result = ();
-    #[tracing::instrument(name = "RepoActor::AdvanceMainTo", skip_all, fields(repo = %self.repo_details, commit = %msg.0))]
-    fn handle(&mut self, msg: actor::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.0, &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::LoadConfigFromRepo)
-                    }
-                    git_next_config::RepoConfigSource::Server => {
-                        addr.do_send(actor::ValidateRepo { message_token })
-                    }
-                },
-            }
-        }
-        .in_current_span()
-        .into_actor(self)
-        .wait(ctx);
-    }
-}

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

@@ -1,26 +0,0 @@
-//
-use actix::prelude::*;
-
-use crate as actor;
-use git_next_git as git;
-
-impl Handler<actor::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::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(actor::LoadConfigFromRepo);
-                } else {
-                    ctx.address().do_send(actor::ValidateRepo {
-                        message_token: self.message_token,
-                    });
-                }
-            }
-            Err(err) => tracing::warn!("Could not open repo: {err}"),
-        }
-    }
-}

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

@@ -1,27 +0,0 @@
-//
-use actix::prelude::*;
-use tracing::Instrument as _;
-
-use crate as actor;
-
-impl Handler<actor::LoadConfigFromRepo> for actor::RepoActor {
-    type Result = ();
-    #[tracing::instrument(name = "RepoActor::LoadConfigFromRepo", skip_all, fields(repo = %self.repo_details))]
-    fn handle(&mut self, _msg: actor::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::LoadedConfig(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

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

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

@@ -1,8 +0,0 @@
-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;

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

@@ -1,77 +0,0 @@
-//
-use actix::prelude::*;
-use tracing::Instrument as _;
-
-use crate as actor;
-use git_next_git as git;
-
-impl Handler<actor::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::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;
-            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::AdvanceMainTo(msg.next));
-                    }
-                    git::forge::commit::Status::Pending => {
-                        tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
-                        addr.do_send(actor::ValidateRepo { 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;
-                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(std::time::Duration::from_secs(10)).await;
-                            addr.do_send(actor::ValidateRepo { message_token })
-                        }
-                        Err(err) => tracing::warn!("advance next: {err}"),
-                    }
-                }
-                .in_current_span()
-                .into_actor(self)
-                .wait(ctx);
-            }
-        }
-    }
-}

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

@@ -1,88 +0,0 @@
-//
-use actix::prelude::*;
-use tracing::Instrument as _;
-
-use crate as actor;
-use git_next_git as git;
-
-impl Handler<actor::ValidateRepo> for actor::RepoActor {
-    type Result = ();
-    #[tracing::instrument(name = "RepoActor::ValidateRepo", skip_all, fields(repo = %self.repo_details, token = %msg.message_token))]
-    fn handle(&mut self, msg: actor::ValidateRepo, ctx: &mut Self::Context) -> Self::Result {
-        match msg.message_token {
-            message_token if self.message_token < message_token => {
-                tracing::info!(%message_token, "New message token");
-                self.message_token = msg.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::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;
-            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::StartMonitoring::new(
-                            main,
-                            next,
-                            dev,
-                            dev_commit_history,
-                        ));
-                    }
-                    Err(err) => {
-                        tracing::warn!("{:?}", err);
-                        tokio::time::sleep(std::time::Duration::from_secs(10)).await;
-                        addr.do_send(actor::ValidateRepo::new(message_token));
-                    }
-                }
-            }
-            .in_current_span()
-            .into_actor(self)
-            .wait(ctx);
-        }
-    }
-}

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

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

crates/repo-actor/src/lib.rs

@@ -1,13 +1,18 @@
 mod branch;
-pub mod handlers;
 mod load;
+pub mod status;
+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;
@@ -85,21 +90,141 @@ impl Actor for RepoActor {
 
 #[derive(Message)]
 #[rtype(result = "()")]
-pub struct LoadConfigFromRepo;
+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 CloneRepo;
+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 = "()")]
@@ -109,6 +234,47 @@ pub struct StartMonitoring {
     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 = "()")]
@@ -118,10 +284,47 @@ impl From<RegisteredWebhook> for WebhookRegistered {
         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);

crates/repo-actor/src/load.rs

@@ -1,54 +1,75 @@
-//
-use derive_more::Display;
 use std::path::PathBuf;
-use tracing::info;
+
+//
+use actix::prelude::*;
+
+use tracing::{error, 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 config_from_repository(
+pub async fn load_file(
     repo_details: git::RepoDetails,
+    addr: Addr<RepoActor>,
     open_repository: git::OpenRepository,
-) -> Result<config::RepoConfig> {
+) {
     info!("Loading .git-next.toml from repo");
-    let contents =
-        open_repository.read_file(&repo_details.branch, &PathBuf::from(".git-next.toml"))?;
-    let config = config::RepoConfig::parse(&contents)?;
-    let branches = open_repository.remote_branches()?;
-    required_branch(&config.branches().main(), &branches)?;
-    required_branch(&config.branches().next(), &branches)?;
-    required_branch(&config.branches().dev(), &branches)?;
+    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: &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)
 }
 
-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)]
+#[derive(Debug, derive_more::From, derive_more::Display)]
 pub enum 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)]
+    File(git::file::Error),
+    Config(config::server::Error),
+    Toml(toml::de::Error),
+    Branch(git::push::Error),
     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/status.rs

@@ -0,0 +1,33 @@
+//
+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/repo-actor/src/tests.rs

@@ -1,908 +1,34 @@
 //
-#![allow(unused_imports)] // TODO remove this
-
-use crate as actor;
-use git_next_config as config;
-use git_next_forge as forge;
-use git_next_git as git;
-
 use super::*;
-
-use assert2::let_assert;
-
-type TestResult = Result<(), Box<dyn std::error::Error>>;
-
 mod branch {
+    use super::super::branch::*;
     use super::*;
 
-    mod advance_next {
-        use super::*;
-        mod when_at_dev {
-            // next and dev branches are the same
-            use super::*;
-            #[tokio::test]
-            async fn should_not_push() -> TestResult {
-                let next = given::a_commit();
-                let dev_commit_history = &[next.clone()];
-                let fs = given::a_filesystem();
-                let repo_details = given::repo_details(&fs);
-                let repo_config = given::a_repo_config();
-                let (repository, _, _) = given::an_open_repository(&fs);
-                // no on_push defined - so any call to push will cause an error
-                let message_token = given::a_message_token();
-                let_assert!(
-                    Err(err) = actor::branch::advance_next(
-                        &next,
-                        dev_commit_history,
-                        repo_details,
-                        repo_config,
-                        repository,
-                        message_token,
-                    )
-                    .await
-                );
-                eprintln!("Got: {err}");
-                assert!(matches!(err, actor::branch::Error::NextAtDev));
-                Ok(())
-            }
-        }
-        mod can_advance {
-            // dev has at least one commit ahead of next
-            use super::*;
-            mod to_wip_commit {
-                // commit on dev is either invalid message or a WIP
-                use super::*;
-                #[tokio::test]
-                async fn should_not_push() -> TestResult {
-                    let next = given::a_commit();
-                    let dev = given::a_commit_with_message(&git::commit::Message::new(
-                        "wip: test: message".to_string(),
-                    ));
-                    let dev_commit_history = &[dev.clone(), next.clone()];
-                    let fs = given::a_filesystem();
-                    let repo_details = given::repo_details(&fs);
-                    let repo_config = given::a_repo_config();
-                    let (repository, _, _) = given::an_open_repository(&fs);
-                    // no on_push defined - so any call to push will cause an error
-                    let message_token = given::a_message_token();
-                    let_assert!(
-                        Err(err) = actor::branch::advance_next(
-                            &next,
-                            dev_commit_history,
-                            repo_details,
-                            repo_config,
-                            repository,
-                            message_token,
-                        )
-                        .await
-                    );
-                    eprintln!("Got: {err}");
-                    assert!(matches!(err, actor::branch::Error::IsWorkInProgress));
-                    Ok(())
-                }
-            }
-            mod to_invalid_commit {
-                // commit on dev is either invalid message or a WIP
-                use super::*;
-                #[tokio::test]
-                async fn should_not_push_and_error() -> TestResult {
-                    let next = given::a_commit();
-                    let dev = given::a_commit();
-                    let dev_commit_history = &[dev.clone(), next.clone()];
-                    let fs = given::a_filesystem();
-                    let repo_details = given::repo_details(&fs);
-                    let repo_config = given::a_repo_config();
-                    let (repository, _, _) = given::an_open_repository(&fs);
-                    // no on_push defined - so any call to push will cause an error
-                    let message_token = given::a_message_token();
-                    let_assert!(
-                        Err(err) = actor::branch::advance_next(
-                            &next,
-                            dev_commit_history,
-                            repo_details,
-                            repo_config,
-                            repository,
-                            message_token,
-                        )
-                        .await
-                    );
-                    eprintln!("Got: {err}");
-                    assert!(matches!(
-                        err,
-                        actor::branch::Error::InvalidCommitMessage{reason}
-                        if reason == "Missing type in the commit summary, expected `type: description`"
-                    ));
-                    Ok(())
-                }
-            }
-            mod to_valid_commit {
-                // commit on dev is valid conventional commit message
-                use super::*;
-                mod push_is_err {
-                    use git::repository::{OnFetch, OnPush};
-
-                    // the git push command fails
-                    use super::*;
-                    #[tokio::test]
-                    async fn should_error() -> TestResult {
-                        let next = given::a_commit();
-                        let dev = given::a_commit_with_message(&git::commit::Message::new(
-                            "test: message".to_string(),
-                        ));
-                        let dev_commit_history = &[dev.clone(), next.clone()];
-                        let fs = given::a_filesystem();
-                        let repo_details = given::repo_details(&fs);
-                        let repo_config = given::a_repo_config();
-                        let (repository, gitdir, mut test_repository) =
-                            given::an_open_repository(&fs);
-                        let repo_branches = repo_config.branches();
-                        test_repository.on_fetch(OnFetch::new(
-                            repo_branches.clone(),
-                            gitdir.clone(),
-                            fs.clone(),
-                            |_, _, _| git::fetch::Result::Ok(()),
-                        ));
-                        test_repository.on_push(OnPush::new(
-                            repo_branches.clone(),
-                            gitdir,
-                            fs,
-                            |_, _, _, _, _, _, _| git::push::Result::Err(git::push::Error::Lock),
-                        ));
-                        let message_token = given::a_message_token();
-                        let_assert!(
-                            Err(err) = actor::branch::advance_next(
-                                &next,
-                                dev_commit_history,
-                                repo_details,
-                                repo_config,
-                                repository,
-                                message_token,
-                            )
-                            .await
-                        );
-                        eprintln!("Got: {err:?}");
-                        assert!(matches!(
-                            err,
-                            actor::branch::Error::Push(git::push::Error::Lock)
-                        ));
-                        Ok(())
-                    }
-                }
-                mod push_is_ok {
-                    // the git push command succeeds
-                    use git_next_git::repository::{OnFetch, OnPush};
-
-                    // the git push command fails
-                    use super::*;
-                    #[tokio::test]
-                    async fn should_ok() -> TestResult {
-                        let next = given::a_commit();
-                        let dev = given::a_commit_with_message(&git::commit::Message::new(
-                            "test: message".to_string(),
-                        ));
-                        let dev_commit_history = &[dev.clone(), next.clone()];
-                        let fs = given::a_filesystem();
-                        let repo_details = given::repo_details(&fs);
-                        let repo_config = given::a_repo_config();
-                        let (repository, gitdir, mut test_repository) =
-                            given::an_open_repository(&fs);
-                        let repo_branches = repo_config.branches();
-                        test_repository.on_fetch(OnFetch::new(
-                            repo_branches.clone(),
-                            gitdir.clone(),
-                            fs.clone(),
-                            |_, _, _| git::fetch::Result::Ok(()),
-                        ));
-                        test_repository.on_push(OnPush::new(
-                            repo_branches.clone(),
-                            gitdir,
-                            fs,
-                            |_, _, _, _, _, _, _| git::push::Result::Ok(()),
-                        ));
-                        let message_token = given::a_message_token();
-                        let_assert!(
-                            Ok(mt) = actor::branch::advance_next(
-                                &next,
-                                dev_commit_history,
-                                repo_details,
-                                repo_config,
-                                repository,
-                                message_token,
-                            )
-                            .await
-                        );
-                        eprintln!("Got: {mt:?}");
-                        assert_eq!(mt, message_token);
-                        Ok(())
-                    }
-                }
-            }
-        }
-    }
-    mod advance_main {
-        use git::repository::{OnFetch, OnPush};
-
-        use super::*;
-        #[tokio::test]
-        async fn push_is_error_should_error() {
-            let commit = given::a_commit();
-            let fs = given::a_filesystem();
-            let repo_details = given::repo_details(&fs);
-            let repo_config = given::a_repo_config();
-            let (open_repository, gitdir, mut test_repository) = given::an_open_repository(&fs);
-            let repo_branches = repo_config.branches();
-            test_repository.on_fetch(OnFetch::new(
-                repo_branches.clone(),
-                gitdir.clone(),
-                fs.clone(),
-                |_, _, _| git::fetch::Result::Ok(()),
-            ));
-            test_repository.on_push(OnPush::new(
-                repo_branches.clone(),
-                gitdir,
-                fs,
-                |_, _, _, _, _, _, _| git::push::Result::Err(git::push::Error::Lock),
-            ));
-            let_assert!(
-                Err(err) = actor::branch::advance_main(
-                    commit,
-                    &repo_details,
-                    &repo_config,
-                    &open_repository
-                )
-                .await
-            );
-            assert!(matches!(
-                err,
-                actor::branch::Error::Push(git::push::Error::Lock)
-            ));
-        }
-        #[tokio::test]
-        async fn push_is_ok_should_ok() {
-            let commit = given::a_commit();
-            let fs = given::a_filesystem();
-            let repo_details = given::repo_details(&fs);
-            let repo_config = given::a_repo_config();
-            let (open_repository, gitdir, mut test_repository) = given::an_open_repository(&fs);
-            let repo_branches = repo_config.branches();
-            test_repository.on_fetch(OnFetch::new(
-                repo_branches.clone(),
-                gitdir.clone(),
-                fs.clone(),
-                |_, _, _| git::fetch::Result::Ok(()),
-            ));
-            test_repository.on_push(OnPush::new(
-                repo_branches.clone(),
-                gitdir,
-                fs,
-                |_, _, _, _, _, _, _| git::push::Result::Ok(()),
-            ));
-            let_assert!(
-                Ok(_) = actor::branch::advance_main(
-                    commit,
-                    &repo_details,
-                    &repo_config,
-                    &open_repository
-                )
-                .await
-            );
-        }
-    }
     #[actix_rt::test]
     async fn test_find_next_commit_on_dev() {
-        let next = given::a_commit();
-        let expected = given::a_commit();
+        let next = git::Commit::new(
+            git::commit::Sha::new("current-next".to_string()),
+            git::commit::Message::new("foo".to_string()),
+        );
+        let expected = git::Commit::new(
+            git::commit::Sha::new("dev-next".to_string()),
+            git::commit::Message::new("next-should-go-here".to_string()),
+        );
         let dev_commit_history = vec![
-            given::a_commit(), // dev HEAD
+            git::Commit::new(
+                git::commit::Sha::new("dev".to_string()),
+                git::commit::Message::new("future".to_string()),
+            ),
             expected.clone(),
-            next.clone(),      // next - advancing towards dev HEAD
-            given::a_commit(), // parent of next
+            next.clone(),
+            git::Commit::new(
+                git::commit::Sha::new("current-main".to_string()),
+                git::commit::Message::new("history".to_string()),
+            ),
         ];
 
-        let next_commit = actor::branch::find_next_commit_on_dev(&next, &dev_commit_history);
+        let next_commit = find_next_commit_on_dev(next, dev_commit_history);
 
         assert_eq!(next_commit, Some(expected), "Found the wrong commit");
     }
 }
-mod load {
-    use std::path::PathBuf;
-
-    use git_next_git::common::repo_details;
-
-    use super::*;
-
-    #[tokio::test]
-    async fn when_file_not_found_should_error() -> TestResult {
-        //given
-        let fs = given::a_filesystem();
-        let repo_details = given::repo_details(&fs);
-        let (open_repository, gitdir, _) = given::an_open_repository(&fs);
-        // create file to create commit on the branch that we then look for config file on
-        let file_name = given::a_pathbuf(); // not the file we want to load
-        let contents = given::a_name();
-        let branch_name = &repo_details.branch;
-        let_assert!(
-            Ok(_) =
-                then::commit_named_file_to_branch(&file_name, &contents, &fs, &gitdir, branch_name),
-            "create branch"
-        );
-        //when
-        let_assert!(
-            Err(err) = actor::load::config_from_repository(repo_details, open_repository).await
-        );
-        //then
-        eprintln!("Got: {err:?}");
-        assert!(matches!(
-            err,
-            actor::load::Error::File(git::file::Error::FileNotFound)
-        ));
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn when_file_format_invalid_should_error() -> TestResult {
-        //given
-        let fs = given::a_filesystem();
-        let repo_details = given::repo_details(&fs);
-        let (open_repository, gitdir, _) = given::an_open_repository(&fs);
-        // create file to create commit on the branch that we then look for config file on
-        let file_name = PathBuf::from(".git-next.toml"); // the file we want to load
-        let contents = given::a_name(); // not a valid file content
-        let branch_name = &repo_details.branch;
-        let_assert!(
-            Ok(_) =
-                then::commit_named_file_to_branch(&file_name, &contents, &fs, &gitdir, branch_name),
-            "create branch"
-        );
-        //when
-        let_assert!(
-            Err(err) = actor::load::config_from_repository(repo_details, open_repository).await
-        );
-        //then
-        eprintln!("Got: {err:?}");
-        assert!(matches!(err, actor::load::Error::Toml(_)));
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn when_main_branch_is_missing_should_error() -> TestResult {
-        //given
-        let fs = given::a_filesystem();
-        let repo_details = given::repo_details(&fs);
-        let (open_repository, gitdir, _) = given::an_open_repository(&fs);
-        // create file to create commit on the branch that we then look for config file on
-        let file_name = PathBuf::from(".git-next.toml"); // the file we want to load
-        let branches = given::repo_branches();
-        let main = branches.main();
-        let next = branches.next();
-        let dev = branches.dev();
-        let contents = format!(
-            r#"
-        [branches]
-        main = "{main}"
-        next = "{next}"
-        dev = "{dev}"
-        "#
-        );
-        let branch_name = &repo_details.branch;
-        let_assert!(
-            Ok(_) =
-                then::commit_named_file_to_branch(&file_name, &contents, &fs, &gitdir, branch_name),
-            "create branch"
-        );
-        //when
-        let_assert!(
-            Err(err) = actor::load::config_from_repository(repo_details, open_repository).await
-        );
-        //then
-        eprintln!("Got: {err:?}");
-        assert!(matches!(err, actor::load::Error::BranchNotFound(branch) if branch == main));
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn when_next_branch_is_missing_should_error() -> TestResult {
-        //given
-        let fs = given::a_filesystem();
-        let repo_details = given::repo_details(&fs);
-        let (open_repository, gitdir, _) = given::an_open_repository(&fs);
-        // create file to create commit on the branch that we then look for config file on
-        let file_name = PathBuf::from(".git-next.toml"); // the file we want to load
-        let branches = given::repo_branches();
-        let main = branches.main();
-        let next = branches.next();
-        let dev = branches.dev();
-        let contents = format!(
-            r#"
-        [branches]
-        main = "{main}"
-        next = "{next}"
-        dev = "{dev}"
-        "#
-        );
-        let branch_name = &repo_details.branch;
-        let_assert!(
-            Ok(_) =
-                then::commit_named_file_to_branch(&file_name, &contents, &fs, &gitdir, branch_name),
-            "create branch"
-        );
-        // create main branch
-        let_assert!(
-            Ok(_) = then::create_a_commit_on_branch(&fs, &gitdir, &main),
-            "create main branch"
-        );
-        //when
-        let_assert!(
-            Err(err) = actor::load::config_from_repository(repo_details, open_repository).await
-        );
-        //then
-        eprintln!("Got: {err:?}");
-        assert!(matches!(err, actor::load::Error::BranchNotFound(branch) if branch == next));
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn when_dev_branch_is_missing_should_error() -> TestResult {
-        //given
-        let fs = given::a_filesystem();
-        let repo_details = given::repo_details(&fs);
-        let (open_repository, gitdir, _) = given::an_open_repository(&fs);
-        // create file to create commit on the branch that we then look for config file on
-        let file_name = PathBuf::from(".git-next.toml"); // the file we want to load
-        let branches = given::repo_branches();
-        let main = branches.main();
-        let next = branches.next();
-        let dev = branches.dev();
-        let contents = format!(
-            r#"
-        [branches]
-        main = "{main}"
-        next = "{next}"
-        dev = "{dev}"
-        "#
-        );
-        let branch_name = &repo_details.branch;
-        let_assert!(
-            Ok(_) =
-                then::commit_named_file_to_branch(&file_name, &contents, &fs, &gitdir, branch_name),
-            "create branch"
-        );
-        // create main branch
-        let_assert!(
-            Ok(_) = then::create_a_commit_on_branch(&fs, &gitdir, &main),
-            "create main branch"
-        );
-        // create next branch
-        let_assert!(
-            Ok(_) = then::create_a_commit_on_branch(&fs, &gitdir, &next),
-            "create next branch"
-        );
-        //when
-        let_assert!(
-            Err(err) = actor::load::config_from_repository(repo_details, open_repository).await
-        );
-        //then
-        eprintln!("Got: {err:?}");
-        assert!(matches!(err, actor::load::Error::BranchNotFound(branch) if branch == dev));
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn when_valid_file_should_return_repo_config() -> TestResult {
-        //given
-        let fs = given::a_filesystem();
-        let repo_details = given::repo_details(&fs);
-        let (open_repository, gitdir, _) = given::an_open_repository(&fs);
-        // create file to create commit on the branch that we then look for config file on
-        let file_name = PathBuf::from(".git-next.toml"); // the file we want to load
-        let repo_config = given::a_repo_config();
-        let branches = repo_config.branches();
-        let main = branches.main();
-        let next = branches.next();
-        let dev = branches.dev();
-        let contents = format!(
-            r#"
-        [branches]
-        main = "{main}"
-        next = "{next}"
-        dev = "{dev}"
-        "#
-        );
-        let branch_name = &repo_details.branch;
-        let_assert!(
-            Ok(_) =
-                then::commit_named_file_to_branch(&file_name, &contents, &fs, &gitdir, branch_name),
-            "create branch"
-        );
-        // create main branch
-        let_assert!(
-            Ok(_) = then::create_a_commit_on_branch(&fs, &gitdir, &main),
-            "create main branch"
-        );
-        // create next branch
-        let_assert!(
-            Ok(_) = then::create_a_commit_on_branch(&fs, &gitdir, &next),
-            "create next branch"
-        );
-        // create dev branch
-        let_assert!(
-            Ok(_) = then::create_a_commit_on_branch(&fs, &gitdir, &dev),
-            "create dev branch"
-        );
-        //when
-        let_assert!(
-            Ok(result) = actor::load::config_from_repository(repo_details, open_repository).await
-        );
-        //then
-        eprintln!("Got: {result:?}");
-        assert_eq!(result, repo_config);
-        Ok(())
-    }
-}
-pub mod given {
-    #![allow(dead_code)] // TODO: remove this
-    #![allow(unused_imports)] // TODO: remove this
-
-    use git_next_git::repository::RepositoryLike as _;
-    use rand::RngCore;
-    use std::path::PathBuf;
-
-    use super::*;
-    use config::{
-        BranchName, ForgeAlias, ForgeConfig, ForgeType, GitDir, RepoAlias, RepoBranches,
-        RepoConfig, ServerRepoConfig, WebhookAuth, WebhookId,
-    };
-    use git::RepoDetails;
-
-    pub fn a_webhook_auth() -> WebhookAuth {
-        WebhookAuth::generate()
-    }
-
-    pub enum Header {
-        Valid(WebhookAuth, config::webhook::message::Body),
-        Missing,
-        Invalid,
-    }
-
-    pub fn a_webhook_message_body() -> config::webhook::message::Body {
-        config::webhook::message::Body::new(a_name())
-    }
-
-    pub fn repo_branches() -> RepoBranches {
-        RepoBranches::new(
-            format!("main-{}", a_name()),
-            format!("next-{}", a_name()),
-            format!("dev-{}", a_name()),
-        )
-    }
-
-    pub fn a_forge_alias() -> ForgeAlias {
-        ForgeAlias::new(a_name())
-    }
-
-    pub fn a_repo_alias() -> RepoAlias {
-        RepoAlias::new(a_name())
-    }
-
-    pub fn a_network() -> kxio::network::MockNetwork {
-        kxio::network::MockNetwork::new()
-    }
-
-    pub fn a_webhook_url(
-        forge_alias: &ForgeAlias,
-        repo_alias: &RepoAlias,
-    ) -> git_next_config::server::WebhookUrl {
-        config::server::Webhook::new(a_name()).url(forge_alias, repo_alias)
-    }
-
-    pub fn any_webhook_url() -> git_next_config::server::WebhookUrl {
-        a_webhook_url(&a_forge_alias(), &a_repo_alias())
-    }
-
-    pub fn a_pathbuf() -> PathBuf {
-        PathBuf::from(given::a_name())
-    }
-
-    pub fn a_name() -> String {
-        use rand::Rng;
-        use std::iter;
-
-        fn generate(len: usize) -> String {
-            const CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-            let mut rng = rand::thread_rng();
-            let one_char = || CHARSET[rng.gen_range(0..CHARSET.len())] as char;
-            iter::repeat_with(one_char).take(len).collect()
-        }
-        generate(5)
-    }
-
-    pub fn a_webhook_id() -> WebhookId {
-        WebhookId::new(a_name())
-    }
-
-    pub fn a_github_webhook_id() -> i64 {
-        rand::thread_rng().next_u32().into()
-    }
-
-    pub fn a_branch_name() -> BranchName {
-        BranchName::new(a_name())
-    }
-
-    pub fn a_git_dir(fs: &kxio::fs::FileSystem) -> GitDir {
-        let dir_name = a_name();
-        let dir = fs.base().join(dir_name);
-        GitDir::new(dir)
-    }
-
-    pub fn a_forge_config() -> ForgeConfig {
-        ForgeConfig::new(
-            ForgeType::MockForge,
-            a_name(),
-            a_name(),
-            a_name(),
-            Default::default(), // no repos
-        )
-    }
-
-    pub fn a_server_repo_config() -> ServerRepoConfig {
-        let main = a_branch_name().unwrap();
-        let next = a_branch_name().unwrap();
-        let dev = a_branch_name().unwrap();
-        ServerRepoConfig::new(
-            format!("{}/{}", a_name(), a_name()),
-            main.clone(),
-            None,
-            Some(main),
-            Some(next),
-            Some(dev),
-        )
-    }
-
-    pub fn a_repo_config() -> RepoConfig {
-        RepoConfig::new(given::repo_branches(), config::RepoConfigSource::Repo)
-    }
-
-    pub fn a_commit() -> git::Commit {
-        git::Commit::new(a_commit_sha(), a_commit_message())
-    }
-
-    pub fn a_commit_with_message(message: &git::commit::Message) -> git::Commit {
-        git::Commit::new(a_commit_sha(), message.to_owned())
-    }
-
-    pub fn a_commit_with_sha(sha: &git::commit::Sha) -> git::Commit {
-        git::Commit::new(sha.to_owned(), a_commit_message())
-    }
-
-    pub fn a_commit_with(sha: &git::commit::Sha, message: &git::commit::Message) -> git::Commit {
-        git::Commit::new(sha.to_owned(), message.to_owned())
-    }
-
-    pub fn a_commit_message() -> git::commit::Message {
-        git::commit::Message::new(a_name())
-    }
-
-    pub fn a_commit_sha() -> git::commit::Sha {
-        git::commit::Sha::new(a_name())
-    }
-
-    pub fn a_webhook_push(
-        sha: &git::commit::Sha,
-        message: &git::commit::Message,
-    ) -> config::webhook::Push {
-        let branch = a_branch_name();
-        config::webhook::Push::new(branch, sha.to_string(), message.to_string())
-    }
-
-    pub fn a_filesystem() -> kxio::fs::FileSystem {
-        kxio::fs::temp().unwrap_or_else(|e| panic!("{}", e))
-    }
-
-    pub fn repo_details(fs: &kxio::fs::FileSystem) -> git::RepoDetails {
-        let generation = git::Generation::new();
-        let repo_alias = a_repo_alias();
-        let server_repo_config = a_server_repo_config();
-        let forge_alias = a_forge_alias();
-        let forge_config = a_forge_config();
-        let gitdir = a_git_dir(fs);
-        RepoDetails::new(
-            generation,
-            &repo_alias,
-            &server_repo_config,
-            &forge_alias,
-            &forge_config,
-            gitdir,
-        )
-    }
-
-    pub fn an_open_repository(
-        fs: &kxio::fs::FileSystem,
-    ) -> (
-        git::repository::OpenRepository,
-        GitDir,
-        git::repository::test::TestRepository,
-    ) {
-        #![allow(clippy::expect_used)]
-        let gitdir = a_git_dir(fs);
-        let repo = git::repository::test(fs.clone());
-        let or = repo.open(&gitdir).expect("open repo");
-        (or, gitdir, repo)
-    }
-
-    pub fn a_message_token() -> MessageToken {
-        MessageToken::new()
-    }
-}
-pub mod then {
-    #![allow(dead_code)] // TODO: remove this
-    #![allow(unused_imports)] // TODO: remove this
-
-    use std::path::{Path, PathBuf};
-
-    type TestResult = Result<(), Box<dyn std::error::Error>>;
-
-    use super::*;
-
-    pub fn commit_named_file_to_branch(
-        file_name: &Path,
-        contents: &str,
-        fs: &kxio::fs::FileSystem,
-        gitdir: &config::GitDir,
-        branch_name: &config::BranchName,
-    ) -> TestResult {
-        // git checkout ${branch_name}
-        git_checkout_new_branch(branch_name, gitdir)?;
-        // echo ${word} > file-${word}
-        let pathbuf = PathBuf::from(gitdir);
-        let file = fs.base().join(pathbuf).join(file_name);
-        #[allow(clippy::expect_used)]
-        fs.file_write(&file, contents)?;
-        // git add ${file}
-        git_add_file(gitdir, &file)?;
-        // git commit -m"Added ${file}"
-        git_commit(gitdir, &file)?;
-
-        then::push_branch(fs, gitdir, branch_name)?;
-
-        Ok(())
-    }
-
-    pub fn create_a_commit_on_branch(
-        fs: &kxio::fs::FileSystem,
-        gitdir: &config::GitDir,
-        branch_name: &config::BranchName,
-    ) -> TestResult {
-        // git checkout ${branch_name}
-        git_checkout_new_branch(branch_name, gitdir)?;
-        // echo ${word} > file-${word}
-        let word = given::a_name();
-        let pathbuf = PathBuf::from(gitdir);
-        let file = fs.base().join(pathbuf).join(&word);
-        fs.file_write(&file, &word)?;
-        // git add ${file}
-        git_add_file(gitdir, &file)?;
-        // git commit -m"Added ${file}"
-        git_commit(gitdir, &file)?;
-
-        then::push_branch(fs, gitdir, branch_name)?;
-
-        Ok(())
-    }
-
-    fn push_branch(
-        fs: &kxio::fs::FileSystem,
-        gitdir: &config::GitDir,
-        branch_name: &config::BranchName,
-    ) -> TestResult {
-        let gitrefs = fs
-            .base()
-            .join(gitdir.to_path_buf())
-            .join(".git")
-            .join("refs");
-        let local_branch = gitrefs.join("heads").join(branch_name.to_string().as_str());
-        let origin_heads = gitrefs.join("remotes").join("origin");
-        let remote_branch = origin_heads.join(branch_name.to_string().as_str());
-        let contents = fs.file_read_to_string(&local_branch)?;
-        fs.dir_create_all(&origin_heads)?;
-        fs.file_write(&remote_branch, &contents)?;
-        Ok(())
-    }
-
-    pub fn git_checkout_new_branch(
-        branch_name: &git_next_config::BranchName,
-        gitdir: &git_next_config::GitDir,
-    ) -> TestResult {
-        exec(
-            format!("git checkout -b {}", branch_name),
-            std::process::Command::new("/usr/bin/git")
-                .current_dir(gitdir.to_path_buf())
-                .args(["checkout", "-b", branch_name.to_string().as_str()])
-                .output(),
-        )?;
-        Ok(())
-    }
-
-    pub fn git_switch(
-        branch_name: &git_next_config::BranchName,
-        gitdir: &git_next_config::GitDir,
-    ) -> TestResult {
-        exec(
-            format!("git switch {}", branch_name),
-            std::process::Command::new("/usr/bin/git")
-                .current_dir(gitdir.to_path_buf())
-                .args(["switch", branch_name.to_string().as_str()])
-                .output(),
-        )
-    }
-
-    fn exec(label: String, output: Result<std::process::Output, std::io::Error>) -> TestResult {
-        eprintln!("== {label}");
-        match output {
-            Ok(output) => {
-                eprintln!(
-                    "\nstdout:\n{}",
-                    String::from_utf8_lossy(output.stdout.as_slice())
-                );
-                eprintln!(
-                    "\nstderr:\n{}",
-                    String::from_utf8_lossy(output.stderr.as_slice())
-                );
-                eprintln!("=============================");
-                Ok(())
-            }
-            Err(err) => {
-                eprintln!("ERROR: {err:#?}");
-                Ok(Err(err)?)
-            }
-        }
-    }
-
-    fn git_add_file(gitdir: &git_next_config::GitDir, file: &Path) -> TestResult {
-        exec(
-            format!("git add {file:?}"),
-            std::process::Command::new("/usr/bin/git")
-                .current_dir(gitdir.to_path_buf())
-                .args(["add", file.display().to_string().as_str()])
-                .output(),
-        )
-    }
-
-    fn git_commit(gitdir: &git_next_config::GitDir, file: &Path) -> TestResult {
-        exec(
-            format!(r#"git commit -m"Added {file:?}""#),
-            std::process::Command::new("/usr/bin/git")
-                .current_dir(gitdir.to_path_buf())
-                .args([
-                    "commit",
-                    format!(r#"-m"Added {}"#, file.display().to_string().as_str()).as_str(),
-                ])
-                .output(),
-        )
-    }
-
-    pub fn git_log_all(gitdir: &config::GitDir) -> TestResult {
-        exec(
-            "git log --all --oneline --decorate --graph".to_string(),
-            std::process::Command::new("/usr/bin/git")
-                .current_dir(gitdir.to_path_buf())
-                .args(["log", "--all", "--oneline", "--decorate", "--graph"])
-                .output(),
-        )
-    }
-
-    pub fn get_sha_for_branch(
-        fs: &kxio::fs::FileSystem,
-        gitdir: &git_next_config::GitDir,
-        branch_name: &git_next_config::BranchName,
-    ) -> Result<git::commit::Sha, Box<dyn std::error::Error>> {
-        let main_ref = fs
-            .base()
-            .join(gitdir.to_path_buf())
-            .join(".git")
-            .join("refs")
-            .join("heads")
-            .join(branch_name.to_string().as_str());
-        let sha = fs.file_read_to_string(&main_ref)?;
-        Ok(git::commit::Sha::new(sha.trim().to_string()))
-    }
-}

crates/server/src/config/tests.rs

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