From b5de7d55e932c9b93a59edb44d51028f73bd0770 Mon Sep 17 00:00:00 2001 From: Paul Campbell Date: Fri, 14 Jun 2024 09:26:27 +0100 Subject: [PATCH] WIP: add more tests to repo-actor crate --- crates/config/src/repo_config.rs | 2 +- crates/config/src/tests.rs | 2 +- crates/git/src/repository/mod.rs | 6 +- crates/git/src/repository/open/mod.rs | 8 +- crates/git/src/repository/open/otest.rs | 37 +- crates/git/src/repository/open/tests.rs | 2 +- crates/git/src/repository/test.rs | 10 +- crates/repo-actor/Cargo.toml | 7 + crates/repo-actor/src/branch.rs | 84 +- .../src/handlers/advance_to_main.rs | 52 + crates/repo-actor/src/handlers/clone.rs | 29 + .../src/handlers/load_config_from_repo.rs | 31 + .../repo-actor/src/handlers/loaded_config.rs | 20 + crates/repo-actor/src/handlers/mod.rs | 8 + .../src/handlers/start_monitoring.rs | 81 ++ .../repo-actor/src/handlers/validate_repo.rs | 94 ++ .../webhook_message.rs} | 7 +- .../src/handlers/webhook_registered.rs | 17 + crates/repo-actor/src/lib.rs | 262 +---- crates/repo-actor/src/load.rs | 97 +- crates/repo-actor/src/messages.rs | 105 ++ crates/repo-actor/src/status.rs | 33 - crates/repo-actor/src/tests.rs | 917 +++++++++++++++++- crates/server/src/actors/server.rs | 15 +- crates/server/src/config/tests.rs | 2 +- 25 files changed, 1480 insertions(+), 448 deletions(-) create mode 100644 crates/repo-actor/src/handlers/advance_to_main.rs create mode 100644 crates/repo-actor/src/handlers/clone.rs create mode 100644 crates/repo-actor/src/handlers/load_config_from_repo.rs create mode 100644 crates/repo-actor/src/handlers/loaded_config.rs create mode 100644 crates/repo-actor/src/handlers/mod.rs create mode 100644 crates/repo-actor/src/handlers/start_monitoring.rs create mode 100644 crates/repo-actor/src/handlers/validate_repo.rs rename crates/repo-actor/src/{webhook.rs => handlers/webhook_message.rs} (95%) create mode 100644 crates/repo-actor/src/handlers/webhook_registered.rs create mode 100644 crates/repo-actor/src/messages.rs delete mode 100644 crates/repo-actor/src/status.rs diff --git a/crates/config/src/repo_config.rs b/crates/config/src/repo_config.rs index 6a649e7..b9bbf16 100644 --- a/crates/config/src/repo_config.rs +++ b/crates/config/src/repo_config.rs @@ -13,7 +13,7 @@ pub struct RepoConfig { source: RepoConfigSource, } impl RepoConfig { - pub fn load(toml: &str) -> Result { + pub fn parse(toml: &str) -> Result { toml::from_str(format!("source = \"Repo\"\n{}", toml).as_str()) } diff --git a/crates/config/src/tests.rs b/crates/config/src/tests.rs index 4a47c47..a532641 100644 --- a/crates/config/src/tests.rs +++ b/crates/config/src/tests.rs @@ -110,7 +110,7 @@ mod repo_config { "# ); - let rc = RepoConfig::load(toml.as_str())?; + let rc = RepoConfig::parse(toml.as_str())?; assert_eq!( rc, diff --git a/crates/git/src/repository/mod.rs b/crates/git/src/repository/mod.rs index 14e1b1a..bcca435 100644 --- a/crates/git/src/repository/mod.rs +++ b/crates/git/src/repository/mod.rs @@ -8,7 +8,7 @@ pub use open::MockOpenRepository; mod open; mod real; -mod test; +pub mod test; #[cfg(test)] mod tests; @@ -49,8 +49,8 @@ pub fn mock() -> MockRepository { MockRepository::new() } -pub const fn test(fs: kxio::fs::FileSystem) -> TestRepository { - TestRepository::new(false, fs, vec![], vec![]) +pub fn test(fs: kxio::fs::FileSystem) -> TestRepository { + TestRepository::new(false, fs, Default::default(), Default::default()) } // #[cfg(test)] diff --git a/crates/git/src/repository/open/mod.rs b/crates/git/src/repository/open/mod.rs index 0082fe0..3f0f971 100644 --- a/crates/git/src/repository/open/mod.rs +++ b/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: Vec, - on_push: Vec, + on_fetch: Arc>>, + on_push: Arc>>, ) -> 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: Vec, - on_push: Vec, + on_fetch: Arc>>, + on_push: Arc>>, ) -> OpenRepository { OpenRepository::Test(TestOpenRepository::new_bare(gitdir, fs, on_fetch, on_push)) } diff --git a/crates/git/src/repository/open/otest.rs b/crates/git/src/repository/open/otest.rs index 7720011..2433e32 100644 --- a/crates/git/src/repository/open/otest.rs +++ b/crates/git/src/repository/open/otest.rs @@ -61,9 +61,9 @@ impl OnPush { #[derive(Clone, Debug)] pub struct TestOpenRepository { - on_fetch: Vec, + on_fetch: Arc>>, fetch_counter: Arc>, - on_push: Vec, + on_push: Arc>>, push_counter: Arc>, real: git::repository::RealOpenRepository, } @@ -87,9 +87,14 @@ impl git::repository::OpenRepositoryLike for TestOpenRepository { .write() .map_err(|_| git::fetch::Error::Lock) .map(|mut c| *c += 1)?; - self.on_fetch.get(i).map(|f| f.invoke()).unwrap_or_else(|| { - unimplemented!("Unexpected fetch"); - }) + self.on_fetch + .lock() + .map_err(|_| git::fetch::Error::Lock) + .map(|a| { + a.get(i).map(|f| f.invoke()).unwrap_or_else(|| { + unimplemented!("Unexpected fetch"); + }) + })? } fn push( @@ -110,11 +115,15 @@ impl git::repository::OpenRepositoryLike for TestOpenRepository { .map_err(|_| git::fetch::Error::Lock) .map(|mut c| *c += 1)?; self.on_push - .get(i) - .map(|f| f.invoke(repo_details, branch_name, to_commit, force)) - .unwrap_or_else(|| { - unimplemented!("Unexpected 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"); + }) + })? } fn commit_log( @@ -137,8 +146,8 @@ impl TestOpenRepository { pub fn new( gitdir: &config::GitDir, fs: kxio::fs::FileSystem, - on_fetch: Vec, - on_push: Vec, + on_fetch: Arc>>, + on_push: Arc>>, ) -> Self { let pathbuf = fs.base().join(gitdir.to_path_buf()); #[allow(clippy::expect_used)] @@ -155,8 +164,8 @@ impl TestOpenRepository { pub fn new_bare( gitdir: &config::GitDir, fs: kxio::fs::FileSystem, - on_fetch: Vec, - on_push: Vec, + on_fetch: Arc>>, + on_push: Arc>>, ) -> Self { let pathbuf = fs.base().join(gitdir.to_path_buf()); #[allow(clippy::expect_used)] diff --git a/crates/git/src/repository/open/tests.rs b/crates/git/src/repository/open/tests.rs index 4500173..46d7476 100644 --- a/crates/git/src/repository/open/tests.rs +++ b/crates/git/src/repository/open/tests.rs @@ -114,7 +114,7 @@ mod repo_config { "# ); - let rc = config::RepoConfig::load(toml.as_str())?; + let rc = config::RepoConfig::parse(toml.as_str())?; assert_eq!( rc, diff --git a/crates/git/src/repository/test.rs b/crates/git/src/repository/test.rs index 7331f84..4446434 100644 --- a/crates/git/src/repository/test.rs +++ b/crates/git/src/repository/test.rs @@ -1,3 +1,5 @@ +use std::sync::{Arc, Mutex}; + // use derive_more::Constructor; @@ -9,16 +11,16 @@ use git_next_config as config; pub struct TestRepository { is_bare: bool, fs: kxio::fs::FileSystem, - on_fetch: Vec, - on_push: Vec, + on_fetch: Arc>>, + on_push: Arc>>, } impl TestRepository { pub fn on_fetch(&mut self, on_fetch: git::repository::OnFetch) { - self.on_fetch.push(on_fetch); + let _ = self.on_fetch.lock().map(|mut a| a.push(on_fetch)); } pub fn on_push(&mut self, on_push: git::repository::OnPush) { - self.on_push.push(on_push); + let _ = self.on_push.lock().map(|mut a| a.push(on_push)); } pub const fn fs(&self) -> &kxio::fs::FileSystem { diff --git a/crates/repo-actor/Cargo.toml b/crates/repo-actor/Cargo.toml index 4daf772..b1e20e0 100644 --- a/crates/repo-actor/Cargo.toml +++ b/crates/repo-actor/Cargo.toml @@ -42,12 +42,19 @@ ulid = { workspace = true } # boilerplate derive_more = { workspace = true } +thiserror = { workspace = true } # Actors actix = { workspace = true } actix-rt = { workspace = true } tokio = { workspace = true } +[dev-dependencies] +# Testing +assert2 = { workspace = true } +rand = { workspace = true } +pretty_assertions = { workspace = true } + [lints.clippy] nursery = { level = "warn", priority = -1 } # pedantic = "warn" diff --git a/crates/repo-actor/src/branch.rs b/crates/repo-actor/src/branch.rs index d514b82..5f44afc 100644 --- a/crates/repo-actor/src/branch.rs +++ b/crates/repo-actor/src/branch.rs @@ -1,78 +1,67 @@ // -use actix::prelude::*; - +use crate as actor; use git_next_config as config; use git_next_git as git; + +use derive_more::Display; use tracing::{info, warn}; -use crate::{MessageToken, ValidateRepo}; - -use std::time::Duration; - // advance next to the next commit towards the head of the dev branch #[tracing::instrument(fields(next), skip_all)] pub async fn advance_next( - next: git::Commit, - dev_commit_history: Vec, + next: &git::Commit, + dev_commit_history: &[git::Commit], repo_details: git::RepoDetails, repo_config: config::RepoConfig, repository: git::OpenRepository, - addr: Addr, - 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; - } + message_token: actor::messages::MessageToken, +) -> Result { + 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( &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 { +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, + next: &git::Commit, + dev_commit_history: &[git::Commit], ) -> Option { - let mut next_commit: Option = 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' @@ -82,15 +71,30 @@ pub async fn advance_main( repo_details: &git::RepoDetails, repo_config: &config::RepoConfig, repository: &git::OpenRepository, -) { +) -> Result<()> { info!("Advancing main to next"); - if let Err(err) = git::push::reset( + git::push::reset( repository, repo_details, &repo_config.branches().main(), &next.into(), &git::push::Force::No, - ) { - warn!(?err, "Failed") - }; + )?; + Ok(()) +} + +pub type Result = core::result::Result; +#[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 }, } diff --git a/crates/repo-actor/src/handlers/advance_to_main.rs b/crates/repo-actor/src/handlers/advance_to_main.rs new file mode 100644 index 0000000..ab4ffb5 --- /dev/null +++ b/crates/repo-actor/src/handlers/advance_to_main.rs @@ -0,0 +1,52 @@ +// +use actix::prelude::*; +use tracing::Instrument as _; + +use crate as actor; + +impl Handler for actor::RepoActor { + type Result = (); + #[tracing::instrument(name = "RepoActor::AdvanceMainTo", skip_all, fields(repo = %self.repo_details, commit = ?msg))] + fn handle( + &mut self, + msg: actor::messages::AdvanceMainTo, + ctx: &mut Self::Context, + ) -> Self::Result { + let Some(repo_config) = self.repo_details.repo_config.clone() else { + tracing::warn!("No config loaded"); + return; + }; + let Some(repository) = self.open_repository.clone() else { + tracing::warn!("No repository opened"); + return; + }; + let repo_details = self.repo_details.clone(); + let addr = ctx.address(); + let message_token = self.message_token; + async move { + match actor::branch::advance_main( + msg.unwrap(), + &repo_details, + &repo_config, + &repository, + ) + .await + { + Err(err) => { + tracing::warn!("advance main: {err}"); + } + Ok(_) => match repo_config.source() { + git_next_config::RepoConfigSource::Repo => { + addr.do_send(actor::messages::LoadConfigFromRepo) + } + git_next_config::RepoConfigSource::Server => { + addr.do_send(actor::messages::ValidateRepo::new(message_token)) + } + }, + } + } + .in_current_span() + .into_actor(self) + .wait(ctx); + } +} diff --git a/crates/repo-actor/src/handlers/clone.rs b/crates/repo-actor/src/handlers/clone.rs new file mode 100644 index 0000000..50c860c --- /dev/null +++ b/crates/repo-actor/src/handlers/clone.rs @@ -0,0 +1,29 @@ +// +use actix::prelude::*; + +use crate as actor; +use git_next_git as git; + +impl Handler 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 { + 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::messages::LoadConfigFromRepo); + } else { + ctx.address() + .do_send(actor::messages::ValidateRepo::new(self.message_token)); + } + } + Err(err) => tracing::warn!("Could not open repo: {err}"), + } + } +} diff --git a/crates/repo-actor/src/handlers/load_config_from_repo.rs b/crates/repo-actor/src/handlers/load_config_from_repo.rs new file mode 100644 index 0000000..d0f0011 --- /dev/null +++ b/crates/repo-actor/src/handlers/load_config_from_repo.rs @@ -0,0 +1,31 @@ +// +use actix::prelude::*; +use tracing::Instrument as _; + +use crate as actor; + +impl Handler for actor::RepoActor { + type Result = (); + #[tracing::instrument(name = "RepoActor::LoadConfigFromRepo", skip_all, fields(repo = %self.repo_details))] + fn handle( + &mut self, + _msg: actor::messages::LoadConfigFromRepo, + ctx: &mut Self::Context, + ) -> Self::Result { + let details = self.repo_details.clone(); + let addr = ctx.address(); + let Some(open_repository) = self.open_repository.clone() else { + tracing::warn!("missing open repository - can't load configuration"); + return; + }; + async move { + match actor::load::config_from_repository(details, open_repository).await { + Ok(repo_config) => addr.do_send(actor::messages::LoadedConfig::new(repo_config)), + Err(err) => tracing::warn!(?err, "Failed to load config"), + } + } + .in_current_span() + .into_actor(self) + .wait(ctx); + } +} diff --git a/crates/repo-actor/src/handlers/loaded_config.rs b/crates/repo-actor/src/handlers/loaded_config.rs new file mode 100644 index 0000000..3a2f005 --- /dev/null +++ b/crates/repo-actor/src/handlers/loaded_config.rs @@ -0,0 +1,20 @@ +// +use actix::prelude::*; + +use crate as actor; + +impl Handler 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)); + } +} diff --git a/crates/repo-actor/src/handlers/mod.rs b/crates/repo-actor/src/handlers/mod.rs new file mode 100644 index 0000000..be9084d --- /dev/null +++ b/crates/repo-actor/src/handlers/mod.rs @@ -0,0 +1,8 @@ +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; diff --git a/crates/repo-actor/src/handlers/start_monitoring.rs b/crates/repo-actor/src/handlers/start_monitoring.rs new file mode 100644 index 0000000..f7da602 --- /dev/null +++ b/crates/repo-actor/src/handlers/start_monitoring.rs @@ -0,0 +1,81 @@ +// +use actix::prelude::*; +use tracing::Instrument as _; + +use crate as actor; +use git_next_git as git; + +impl Handler for actor::RepoActor { + type Result = (); + #[tracing::instrument(name = "RepoActor::StartMonitoring", skip_all, + fields(token = %self.message_token, repo = %self.repo_details, main = %msg.main(), next = %msg.next(), dev = %msg.dev())) + ] + fn handle( + &mut self, + msg: actor::messages::StartMonitoring, + ctx: &mut Self::Context, + ) -> Self::Result { + let Some(repo_config) = self.repo_details.repo_config.clone() else { + tracing::warn!("No config loaded"); + return; + }; + + let next_ahead_of_main = msg.main() != msg.next(); + let dev_ahead_of_next = msg.next() != msg.dev(); + tracing::info!(next_ahead_of_main, dev_ahead_of_next, "StartMonitoring"); + + let addr = ctx.address(); + let forge = self.forge.clone(); + + if next_ahead_of_main { + let message_token = self.message_token; + async move { + // get the status - pass, fail, pending (all others map to fail, e.g. error) + let status = forge.commit_status(msg.next()).await; + tracing::info!(?status, "Checking next branch"); + match status { + git::forge::commit::Status::Pass => { + addr.do_send(actor::messages::AdvanceMainTo::new(msg.next().clone())); + } + git::forge::commit::Status::Pending => { + tokio::time::sleep(tokio::time::Duration::from_secs(10)).await; + addr.do_send(actor::messages::ValidateRepo::new(message_token)); + } + git::forge::commit::Status::Fail => { + tracing::warn!("Checks have failed"); + } + } + } + .in_current_span() + .into_actor(self) + .wait(ctx); + } else if dev_ahead_of_next { + if let Some(repository) = self.open_repository.clone() { + let repo_details = self.repo_details.clone(); + let message_token = self.message_token; + 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::messages::ValidateRepo::new(message_token)) + } + Err(err) => tracing::warn!("advance next: {err}"), + } + } + .in_current_span() + .into_actor(self) + .wait(ctx); + } + } + } +} diff --git a/crates/repo-actor/src/handlers/validate_repo.rs b/crates/repo-actor/src/handlers/validate_repo.rs new file mode 100644 index 0000000..f4c3269 --- /dev/null +++ b/crates/repo-actor/src/handlers/validate_repo.rs @@ -0,0 +1,94 @@ +// +use actix::prelude::*; +use tracing::Instrument as _; + +use crate as actor; +use git_next_git as git; + +impl Handler 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::messages::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.unwrap(); + } + message_token if &self.message_token > message_token => { + tracing::info!("Dropping message from previous generation"); + return; // message is expired + } + _ => { + // do nothing + } + } + if self.webhook_id.is_none() { + let forge_alias = self.repo_details.forge.forge_alias(); + let repo_alias = &self.repo_details.repo_alias; + let webhook_url = self.webhook.url(forge_alias, repo_alias); + let forge = self.forge.clone(); + let addr = ctx.address(); + async move { + if let Err(err) = + forge + .register_webhook(&webhook_url) + .await + .and_then(|registered_webhook| { + addr.try_send(actor::messages::WebhookRegistered::from( + registered_webhook, + )) + .map_err(|e| { + git::forge::webhook::Error::FailedToNotifySelf(e.to_string()) + }) + }) + { + tracing::warn!("registering webhook: {err}"); + } + } + .in_current_span() + .into_actor(self) + .wait(ctx); + } + if let (Some(repository), Some(repo_config)) = ( + self.open_repository.clone(), + self.repo_details.repo_config.clone(), + ) { + let repo_details = self.repo_details.clone(); + let addr = ctx.address(); + let message_token = self.message_token; + async move { + match git::validation::positions::validate_positions( + &repository, + &repo_details, + repo_config, + ) { + Ok(git::validation::positions::Positions { + main, + next, + dev, + dev_commit_history, + }) => { + addr.do_send(actor::messages::StartMonitoring::new( + main, + next, + dev, + dev_commit_history, + )); + } + Err(err) => { + tracing::warn!("{:?}", err); + tokio::time::sleep(std::time::Duration::from_secs(10)).await; + addr.do_send(actor::messages::ValidateRepo::new(message_token)); + } + } + } + .in_current_span() + .into_actor(self) + .wait(ctx); + } + } +} diff --git a/crates/repo-actor/src/webhook.rs b/crates/repo-actor/src/handlers/webhook_message.rs similarity index 95% rename from crates/repo-actor/src/webhook.rs rename to crates/repo-actor/src/handlers/webhook_message.rs index 21c808a..79bc3fa 100644 --- a/crates/repo-actor/src/webhook.rs +++ b/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 for RepoActor { +impl Handler for actor::RepoActor { type Result = (); #[allow(clippy::cognitive_complexity)] // TODO: (#49) reduce complexity @@ -88,6 +88,7 @@ impl Handler for RepoActor { token = %message_token, "New commit" ); - ctx.address().do_send(ValidateRepo { message_token }); + ctx.address() + .do_send(actor::messages::ValidateRepo::new(message_token)); } } diff --git a/crates/repo-actor/src/handlers/webhook_registered.rs b/crates/repo-actor/src/handlers/webhook_registered.rs new file mode 100644 index 0000000..f11ff2b --- /dev/null +++ b/crates/repo-actor/src/handlers/webhook_registered.rs @@ -0,0 +1,17 @@ +// +use actix::prelude::*; + +use crate as actor; + +impl Handler 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()); + } +} diff --git a/crates/repo-actor/src/lib.rs b/crates/repo-actor/src/lib.rs index 3bf1815..3512f34 100644 --- a/crates/repo-actor/src/lib.rs +++ b/crates/repo-actor/src/lib.rs @@ -1,18 +1,13 @@ 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; @@ -24,7 +19,7 @@ use tracing::{debug, info, warn, Instrument}; #[display("{}:{}:{}", generation, repo_details.forge.forge_alias(), repo_details.repo_alias)] pub struct RepoActor { generation: git::Generation, - message_token: MessageToken, + message_token: messages::MessageToken, repo_details: git::RepoDetails, webhook: config::server::Webhook, webhook_id: Option, // INFO: if [None] then no webhook is configured @@ -49,7 +44,7 @@ impl RepoActor { debug!(?forge, "new"); Self { generation, - message_token: MessageToken::new(), + message_token: messages::MessageToken::new(), repo_details: details, webhook, webhook_id: None, @@ -87,252 +82,3 @@ impl Actor for RepoActor { } } } - -#[derive(Message)] -#[rtype(result = "()")] -pub struct CloneRepo; -impl Handler 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 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 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 for RepoActor { - type Result = (); - #[tracing::instrument(name = "RepoActor::ValidateRepo", skip_all, fields(repo = %self.repo_details, token = %msg.message_token))] - fn handle(&mut self, msg: ValidateRepo, ctx: &mut Self::Context) -> Self::Result { - match msg.message_token { - message_token if self.message_token < message_token => { - info!(%message_token, "New message token"); - self.message_token = msg.message_token; - } - message_token if self.message_token > message_token => { - info!("Dropping message from previous generation"); - return; // message is expired - } - _ => { - // do nothing - } - } - if self.webhook_id.is_none() { - let forge_alias = self.repo_details.forge.forge_alias(); - let repo_alias = &self.repo_details.repo_alias; - let webhook_url = self.webhook.url(forge_alias, repo_alias); - let forge = self.forge.clone(); - let addr = ctx.address(); - async move { - if let Err(err) = - forge - .register_webhook(&webhook_url) - .await - .and_then(|registered_webhook| { - addr.try_send(WebhookRegistered::from(registered_webhook)) - .map_err(|e| { - git::forge::webhook::Error::FailedToNotifySelf(e.to_string()) - }) - }) - { - warn!("registering webhook: {err}"); - } - } - .in_current_span() - .into_actor(self) - .wait(ctx); - } - if let (Some(repository), Some(repo_config)) = ( - self.open_repository.clone(), - self.repo_details.repo_config.clone(), - ) { - let repo_details = self.repo_details.clone(); - let addr = ctx.address(); - let message_token = self.message_token; - async move { - match validate_positions(&repository, &repo_details, repo_config) { - Ok(Positions { - main, - next, - dev, - dev_commit_history, - }) => { - addr.do_send(StartMonitoring::new(main, next, dev, dev_commit_history)); - } - Err(err) => { - warn!("{:?}", err); - tokio::time::sleep(Duration::from_secs(10)).await; - addr.do_send(ValidateRepo::new(message_token)); - } - } - } - .in_current_span() - .into_actor(self) - .wait(ctx); - } - } -} - -#[derive(Debug, derive_more::Constructor, Message)] -#[rtype(result = "()")] -pub struct StartMonitoring { - main: git::Commit, - next: git::Commit, - dev: git::Commit, - dev_commit_history: Vec, -} -impl Handler for RepoActor { - type Result = (); - #[tracing::instrument(name = "RepoActor::StartMonitoring", skip_all, - fields(token = %self.message_token, repo = %self.repo_details, main = %msg.main, next= %msg.next, dev = %msg.dev)) - ] - fn handle(&mut self, msg: StartMonitoring, ctx: &mut Self::Context) -> Self::Result { - let Some(repo_config) = self.repo_details.repo_config.clone() else { - warn!("No config loaded"); - return; - }; - - let next_ahead_of_main = msg.main != msg.next; - let dev_ahead_of_next = msg.next != msg.dev; - info!(next_ahead_of_main, dev_ahead_of_next, "StartMonitoring"); - - let addr = ctx.address(); - let forge = self.forge.clone(); - - if next_ahead_of_main { - status::check_next(msg.next, addr, forge, self.message_token) - .in_current_span() - .into_actor(self) - .wait(ctx); - } else if dev_ahead_of_next { - if let Some(repository) = self.open_repository.clone() { - branch::advance_next( - msg.next, - msg.dev_commit_history, - self.repo_details.clone(), - repo_config, - repository, - addr, - self.message_token, - ) - .in_current_span() - .into_actor(self) - .wait(ctx); - } - } - } -} - -#[derive(Message)] -#[rtype(result = "()")] -pub struct WebhookRegistered(config::WebhookId, config::WebhookAuth); -impl From for WebhookRegistered { - fn from(value: RegisteredWebhook) -> Self { - Self(value.id().clone(), value.auth().clone()) - } -} -impl Handler 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 for RepoActor { - type Result = (); - #[tracing::instrument(name = "RepoActor::AdvanceMainTo", skip_all, fields(repo = %self.repo_details, commit = %msg.0))] - fn handle(&mut self, msg: AdvanceMainTo, ctx: &mut Self::Context) -> Self::Result { - let Some(repo_config) = self.repo_details.repo_config.clone() else { - warn!("No config loaded"); - return; - }; - let Some(repository) = self.open_repository.clone() else { - warn!("No repository opened"); - return; - }; - let repo_details = self.repo_details.clone(); - let addr = ctx.address(); - let message_token = self.message_token; - async move { - branch::advance_main(msg.0, &repo_details, &repo_config, &repository).await; - match repo_config.source() { - git_next_config::RepoConfigSource::Repo => addr.do_send(LoadConfigFromRepo), - git_next_config::RepoConfigSource::Server => { - addr.do_send(ValidateRepo { message_token }) - } - } - } - .in_current_span() - .into_actor(self) - .wait(ctx); - } -} - -#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord, derive_more::Display)] -pub struct MessageToken(u32); -impl MessageToken { - pub fn new() -> Self { - Self::default() - } - pub const fn next(&self) -> Self { - Self(self.0 + 1) - } -} diff --git a/crates/repo-actor/src/load.rs b/crates/repo-actor/src/load.rs index 313e344..7da477e 100644 --- a/crates/repo-actor/src/load.rs +++ b/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, open_repository: git::OpenRepository, -) { +) -> Result { 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: &git::OpenRepository, -) -> Result { - 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?; + 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)?; 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 = core::result::Result; +#[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: &git::OpenRepository, -) -> Result { - 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) -} diff --git a/crates/repo-actor/src/messages.rs b/crates/repo-actor/src/messages.rs new file mode 100644 index 0000000..4d6b79d --- /dev/null +++ b/crates/repo-actor/src/messages.rs @@ -0,0 +1,105 @@ +// +use actix::prelude::*; +use derive_more::{Constructor, Display}; + +use git_next_config as config; +use git_next_git as git; + +#[derive(Message)] +#[rtype(result = "()")] +pub struct LoadConfigFromRepo; + +#[derive(Message)] +#[rtype(result = "()")] +pub struct CloneRepo; + +#[derive(Message, Constructor, Debug, Display)] +#[rtype(result = "()")] +pub struct LoadedConfig(config::RepoConfig); +impl LoadedConfig { + pub fn unwrap(self) -> config::RepoConfig { + self.0 + } +} + +#[derive(Constructor, Message)] +#[rtype(result = "()")] +pub struct ValidateRepo { + message_token: MessageToken, +} +impl ValidateRepo { + pub const fn unwrap(self) -> MessageToken { + self.message_token + } + pub const fn message_token(&self) -> &MessageToken { + &self.message_token + } +} + +#[derive(Debug, Constructor, Message)] +#[rtype(result = "()")] +pub struct StartMonitoring { + main: git::Commit, + next: git::Commit, + dev: git::Commit, + dev_commit_history: Vec, +} +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 + } +} + +#[derive(Message)] +#[rtype(result = "()")] +pub struct WebhookRegistered { + webhook_id: config::WebhookId, + webhook_auth: config::WebhookAuth, +} +impl WebhookRegistered { + pub const fn webhook_id(&self) -> &config::WebhookId { + &self.webhook_id + } + pub const fn webhook_auth(&self) -> &config::WebhookAuth { + &self.webhook_auth + } +} +impl From for WebhookRegistered { + fn from(value: config::RegisteredWebhook) -> Self { + let webhook_id = value.id().clone(); + let webhook_auth = value.auth().clone(); + Self { + webhook_id, + webhook_auth, + } + } +} + +#[derive(Message, Debug, Constructor, Display)] +#[rtype(result = "()")] +pub struct AdvanceMainTo(git::Commit); +impl AdvanceMainTo { + pub fn unwrap(self) -> git::Commit { + self.0 + } +} + +#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord, Display)] +pub struct MessageToken(u32); +impl MessageToken { + pub fn new() -> Self { + Self::default() + } + pub const fn next(&self) -> Self { + Self(self.0 + 1) + } +} diff --git a/crates/repo-actor/src/status.rs b/crates/repo-actor/src/status.rs deleted file mode 100644 index b7b4ea4..0000000 --- a/crates/repo-actor/src/status.rs +++ /dev/null @@ -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, - 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"); - } - } -} diff --git a/crates/repo-actor/src/tests.rs b/crates/repo-actor/src/tests.rs index b9c7df4..7fc5195 100644 --- a/crates/repo-actor/src/tests.rs +++ b/crates/repo-actor/src/tests.rs @@ -1,34 +1,913 @@ // +#![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>; + +mod repo_actor { + mod create { + // + } +} 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 = 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 next = given::a_commit(); + let expected = given::a_commit(); let dev_commit_history = vec![ - git::Commit::new( - git::commit::Sha::new("dev".to_string()), - git::commit::Message::new("future".to_string()), - ), + given::a_commit(), // dev HEAD expected.clone(), - next.clone(), - git::Commit::new( - git::commit::Sha::new("current-main".to_string()), - git::commit::Message::new("history".to_string()), - ), + next.clone(), // next - advancing towards dev HEAD + given::a_commit(), // parent of next ]; - let next_commit = find_next_commit_on_dev(next, dev_commit_history); + let next_commit = actor::branch::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().into_string(); + let next = a_branch_name().into_string(); + let dev = a_branch_name().into_string(); + 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() -> messages::MessageToken { + messages::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>; + + 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) -> 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> { + 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())) + } +} diff --git a/crates/server/src/actors/server.rs b/crates/server/src/actors/server.rs index 68df2b9..ec36047 100644 --- a/crates/server/src/actors/server.rs +++ b/crates/server/src/actors/server.rs @@ -8,7 +8,7 @@ use git_next_config::{ self as config, ForgeAlias, ForgeConfig, GitDir, RepoAlias, ServerRepoConfig, }; use git_next_git::{Generation, RepoDetails, Repository}; -use git_next_repo_actor::{CloneRepo, RepoActor}; +use git_next_repo_actor as repo_actor; use kxio::{fs::FileSystem, network::Network}; use tracing::{error, info, warn}; @@ -151,7 +151,7 @@ impl Server { forge_name: ForgeAlias, server_storage: &ServerStorage, webhook: &Webhook, - ) -> Vec<(ForgeAlias, RepoAlias, RepoActor)> { + ) -> Vec<(ForgeAlias, RepoAlias, repo_actor::RepoActor)> { let span = tracing::info_span!("create_forge_repos", name = %forge_name, config = %forge_config); @@ -176,7 +176,8 @@ impl Server { forge_config: ForgeConfig, server_storage: &ServerStorage, webhook: &Webhook, - ) -> impl Fn((RepoAlias, &ServerRepoConfig)) -> (ForgeAlias, RepoAlias, RepoActor) { + ) -> impl Fn((RepoAlias, &ServerRepoConfig)) -> (ForgeAlias, RepoAlias, repo_actor::RepoActor) + { let server_storage = server_storage.clone(); let webhook = webhook.clone(); let net = self.net.clone(); @@ -208,7 +209,7 @@ impl Server { gitdir, ); info!("Starting Repo Actor"); - let actor = RepoActor::new( + let actor = repo_actor::RepoActor::new( repo_details, webhook.clone(), generation, @@ -221,13 +222,13 @@ impl Server { fn start_actor( &self, - actor: (ForgeAlias, RepoAlias, RepoActor), - ) -> (RepoAlias, Addr) { + actor: (ForgeAlias, RepoAlias, repo_actor::RepoActor), + ) -> (RepoAlias, Addr) { let (forge_name, repo_alias, actor) = actor; let span = tracing::info_span!("start_actor", forge = %forge_name, repo = %repo_alias); let _guard = span.enter(); let addr = actor.start(); - addr.do_send(CloneRepo); + addr.do_send(repo_actor::messages::CloneRepo); info!("Started"); (repo_alias, addr) } diff --git a/crates/server/src/config/tests.rs b/crates/server/src/config/tests.rs index f0b0076..6f829c3 100644 --- a/crates/server/src/config/tests.rs +++ b/crates/server/src/config/tests.rs @@ -18,7 +18,7 @@ fn test_repo_config_load() -> Result<()> { [options] "#; - let config = RepoConfig::load(toml)?; + let config = RepoConfig::parse(toml)?; assert_eq!( config,