diff --git a/.cargo/config.toml b/.cargo/config.toml index 2082df4..8c6251c 100644 --- a/.cargo/config.toml +++ b/.cargo/config.toml @@ -13,5 +13,5 @@ debug = 0 strip = "debuginfo" [env] -RUSTLOG = "hyper=warn" +RUST_LOG = "hyper=warn,debug" RUSTFLAGS = "--cfg tokio_unstable" diff --git a/Cargo.toml b/Cargo.toml index f703b9a..d5e7c16 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -97,3 +97,4 @@ assert2 = "0.3" pretty_assertions = "1.4" rand = "0.8" mockall = "0.12" +test-log = "0.2" diff --git a/bacon.toml b/bacon.toml index 63dafe8..3d30b8b 100644 --- a/bacon.toml +++ b/bacon.toml @@ -4,7 +4,7 @@ # Complete help on configuration: https://dystroy.org/bacon/config/ default_job = "check" -reverse = true +# reverse = true [jobs.check] command = ["cargo", "check", "--color", "always"] @@ -48,7 +48,7 @@ need_stdout = false [jobs.doc-open] command = ["cargo", "doc", "--color", "always", "--no-deps", "--open"] need_stdout = false -on_success = "back" # so that we don't open the browser at each change +on_success = "back" # so that we don't open the browser at each change # You can run your application and have the result displayed in bacon, # *if* it makes sense for this crate. You can run an example the same @@ -57,7 +57,7 @@ on_success = "back" # so that we don't open the browser at each change # If you want to pass options to your program, a `--` separator # will be needed. [jobs.run] -command = [ "cargo", "run", "--color", "always" ] +command = ["cargo", "run", "--color", "always"] need_stdout = true allow_warnings = true diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs index a1023fb..c0ab962 100644 --- a/crates/cli/src/main.rs +++ b/crates/cli/src/main.rs @@ -42,7 +42,8 @@ async fn main() { git_next_server::init(fs); } Server::Start => { - git_next_server::start(fs, net, repo).await; + let sleep_duration = std::time::Duration::from_secs(10); + git_next_server::start(fs, net, repo, sleep_duration).await; } }, } diff --git a/crates/config/Cargo.toml b/crates/config/Cargo.toml index 93156d5..387c63a 100644 --- a/crates/config/Cargo.toml +++ b/crates/config/Cargo.toml @@ -10,17 +10,7 @@ github = [] [dependencies] # logging -# console-subscriber = { workspace = true } tracing = { workspace = true } -# tracing-subscriber = { workspace = true } - -# # base64 decoding -# base64 = { workspace = true } -# -# # git -# # gix = { workspace = true } -# gix = { workspace = true } -# async-trait = { workspace = true } # fs/network kxio = { workspace = true } @@ -33,26 +23,13 @@ toml = { workspace = true } # Secrets and Password secrecy = { workspace = true } -# # Conventional Commit check -# git-conventional = { workspace = true } -# # Webhooks -# bytes = { workspace = true } ulid = { workspace = true } -# warp = { workspace = true } # boilerplate derive_more = { workspace = true } derive-with = { workspace = true } thiserror = { workspace = true } -# -# # file watcher -# inotify = { workspace = true } - -# Actors -actix = { workspace = true } -# actix-rt = { workspace = true } -# tokio = { workspace = true } [dev-dependencies] # # Testing diff --git a/crates/config/src/forge_alias.rs b/crates/config/src/forge_alias.rs index e53790e..f8b5f29 100644 --- a/crates/config/src/forge_alias.rs +++ b/crates/config/src/forge_alias.rs @@ -1,5 +1,5 @@ // The name of a Forge to connect to -crate::newtype!(ForgeAlias is a String, derive_more::Display, Default); +crate::newtype!(ForgeAlias is a String, Hash, derive_more::Display, Default); impl From<&ForgeAlias> for std::path::PathBuf { fn from(value: &ForgeAlias) -> Self { Self::from(&value.0) diff --git a/crates/config/src/forge_config.rs b/crates/config/src/forge_config.rs index 8fb10bd..eae2d45 100644 --- a/crates/config/src/forge_config.rs +++ b/crates/config/src/forge_config.rs @@ -5,7 +5,16 @@ use crate::{ApiToken, ForgeType, Hostname, RepoAlias, ServerRepoConfig, User}; /// Defines a Forge to connect to /// Maps from `git-next-server.toml` at `forge.{forge}` #[derive( - Clone, Debug, PartialEq, Eq, serde::Deserialize, derive_more::Constructor, derive_more::Display, + Clone, + Debug, + derive_more::From, + PartialEq, + Eq, + PartialOrd, + Ord, + serde::Deserialize, + derive_more::Constructor, + derive_more::Display, )] #[display("{}:{}@{}", forge_type.to_string().to_lowercase(), user, hostname)] pub struct ForgeConfig { diff --git a/crates/config/src/forge_type.rs b/crates/config/src/forge_type.rs index 2449b3d..9154a78 100644 --- a/crates/config/src/forge_type.rs +++ b/crates/config/src/forge_type.rs @@ -1,5 +1,16 @@ /// Identifier for the type of Forge -#[derive(Clone, Default, Copy, Debug, PartialEq, Eq, serde::Deserialize)] +#[derive( + Clone, + Default, + Debug, + derive_more::From, + PartialEq, + Eq, + PartialOrd, + Ord, + serde::Deserialize, + Copy, +)] pub enum ForgeType { #[cfg(feature = "forgejo")] ForgeJo, diff --git a/crates/config/src/lib.rs b/crates/config/src/lib.rs index ab2cd4e..e9a8d65 100644 --- a/crates/config/src/lib.rs +++ b/crates/config/src/lib.rs @@ -41,5 +41,6 @@ pub use repo_path::RepoPath; pub use server_repo_config::ServerRepoConfig; pub use user::User; pub use webhook::auth::WebhookAuth; +pub use webhook::forge_notification::ForgeNotification; pub use webhook::id::WebhookId; -pub use webhook::message::WebhookMessage; + diff --git a/crates/config/src/newtype.rs b/crates/config/src/newtype.rs index 9536d22..038ad8c 100644 --- a/crates/config/src/newtype.rs +++ b/crates/config/src/newtype.rs @@ -32,7 +32,6 @@ macro_rules! newtype { Eq, PartialOrd, Ord, - Hash, derive_more::AsRef, derive_more::Deref, $($derive),* @@ -47,10 +46,10 @@ macro_rules! newtype { self.0 } } - impl From<$name> for $type { - fn from(value: $name) -> $type { - value.unwrap() - } + impl From<$name> for $type { + fn from(value: $name) -> $type { + value.unwrap() } + } }; } diff --git a/crates/config/src/repo_alias.rs b/crates/config/src/repo_alias.rs index 18e83da..3237576 100644 --- a/crates/config/src/repo_alias.rs +++ b/crates/config/src/repo_alias.rs @@ -1,9 +1,7 @@ -/// The alias of a repo -/// This is the alias for the repo within `git-next-server.toml` -#[derive(Clone, Default, Debug, PartialEq, Eq, Hash, derive_more::Display)] -pub struct RepoAlias(String); -impl RepoAlias { - pub fn new(str: impl Into) -> Self { - Self(str.into()) - } -} +use derive_more::Display; + +use crate::newtype; + +// The alias of a repo +// This is the alias for the repo within `git-next-server.toml` +newtype!(RepoAlias is a String, Display, Default); diff --git a/crates/config/src/repo_config.rs b/crates/config/src/repo_config.rs index d7661ca..db86a7e 100644 --- a/crates/config/src/repo_config.rs +++ b/crates/config/src/repo_config.rs @@ -16,6 +16,7 @@ use crate::RepoConfigSource; serde::Serialize, derive_more::Constructor, derive_more::Display, + derive_with::With, )] #[display("{}", branches)] pub struct RepoConfig { diff --git a/crates/config/src/server.rs b/crates/config/src/server.rs index a523b2a..0f76740 100644 --- a/crates/config/src/server.rs +++ b/crates/config/src/server.rs @@ -1,8 +1,7 @@ // -use actix::prelude::*; use std::{ - collections::HashMap, + collections::BTreeMap, net::SocketAddr, path::{Path, PathBuf}, str::FromStr, @@ -28,13 +27,23 @@ pub enum Error { type Result = core::result::Result; /// Mapped from the `git-next-server.toml` file -#[derive(Debug, PartialEq, Eq, serde::Deserialize, Message, derive_more::Constructor)] -#[rtype(result = "()")] +#[derive( + Clone, + Debug, + derive_more::From, + PartialEq, + Eq, + PartialOrd, + Ord, + derive_more::AsRef, + serde::Deserialize, + derive_more::Constructor, +)] pub struct ServerConfig { http: Http, webhook: Webhook, storage: ServerStorage, - pub forge: HashMap, + pub forge: BTreeMap, } impl ServerConfig { #[tracing::instrument(skip_all)] @@ -65,7 +74,18 @@ impl ServerConfig { } /// Defines the port the server will listen to for incoming webhooks messages -#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize, derive_more::Constructor)] +#[derive( + Clone, + Debug, + derive_more::From, + PartialEq, + Eq, + PartialOrd, + Ord, + derive_more::AsRef, + serde::Deserialize, + derive_more::Constructor, +)] pub struct Http { addr: String, port: u16, @@ -81,7 +101,18 @@ impl Http { /// Defines the Webhook Forges should send updates to /// Must be an address that is accessible from the remote forge -#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize, derive_more::Constructor)] +#[derive( + Clone, + Debug, + derive_more::From, + PartialEq, + Eq, + PartialOrd, + Ord, + derive_more::AsRef, + serde::Deserialize, + derive_more::Constructor, +)] pub struct Webhook { url: String, } @@ -99,7 +130,18 @@ impl Webhook { newtype!(WebhookUrl is a String, serde::Serialize); /// The directory to store server data, such as cloned repos -#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize, derive_more::Constructor)] +#[derive( + Clone, + Debug, + derive_more::From, + PartialEq, + Eq, + PartialOrd, + Ord, + derive_more::AsRef, + serde::Deserialize, + derive_more::Constructor, +)] pub struct ServerStorage { path: PathBuf, } diff --git a/crates/config/src/server_repo_config.rs b/crates/config/src/server_repo_config.rs index 7e6e37f..b43e0ac 100644 --- a/crates/config/src/server_repo_config.rs +++ b/crates/config/src/server_repo_config.rs @@ -5,7 +5,16 @@ use crate::{BranchName, GitDir, RepoBranches, RepoConfig, RepoConfigSource, Repo /// Defines a Repo within a ForgeConfig to be monitored by the server /// Maps from `git-next-server.toml` at `forge.{forge}.repos.{name}` #[derive( - Clone, Debug, PartialEq, Eq, serde::Deserialize, derive_more::Constructor, derive_more::Display, + Clone, + Debug, + derive_more::From, + PartialEq, + Eq, + PartialOrd, + Ord, + serde::Deserialize, + derive_more::Display, + derive_more::Constructor, )] #[display("{}@{}", repo, branch)] pub struct ServerRepoConfig { diff --git a/crates/config/src/tests.rs b/crates/config/src/tests.rs index 5035233..b4c8cee 100644 --- a/crates/config/src/tests.rs +++ b/crates/config/src/tests.rs @@ -575,12 +575,11 @@ mod webhook { use super::*; mod message { use super::*; - use std::collections::HashMap; #[test] fn should_return_forge_alias() { let forge_alias = given::a_forge_alias(); - let message = WebhookMessage::new( + let message = ForgeNotification::new( forge_alias.clone(), given::a_repo_alias(), Default::default(), @@ -591,7 +590,7 @@ mod webhook { #[test] fn should_return_repo_alias() { let repo_alias = given::a_repo_alias(); - let message = WebhookMessage::new( + let message = ForgeNotification::new( given::a_forge_alias(), repo_alias.clone(), Default::default(), @@ -602,7 +601,7 @@ mod webhook { #[test] fn should_return_body() { let body = given::a_webhook_message_body(); - let message = WebhookMessage::new( + let message = ForgeNotification::new( given::a_forge_alias(), given::a_repo_alias(), Default::default(), @@ -614,9 +613,9 @@ mod webhook { fn should_return_header() { let key = given::a_name(); let value = given::a_name(); - let mut headers: HashMap = Default::default(); + let mut headers: BTreeMap = Default::default(); headers.insert(key.clone(), value.clone()); - let message = WebhookMessage::new( + let message = ForgeNotification::new( given::a_forge_alias(), given::a_repo_alias(), headers, @@ -704,7 +703,7 @@ mod given { use super::*; use rand::Rng as _; use std::{ - collections::{BTreeMap, HashMap}, + collections::BTreeMap, path::{Path, PathBuf}, }; @@ -750,7 +749,7 @@ mod given { pub fn a_server_storage() -> ServerStorage { ServerStorage::new(a_name().into()) } - pub fn some_forge_configs() -> HashMap { + pub fn some_forge_configs() -> BTreeMap { [(a_name(), a_forge_config())].into() } pub fn a_forge_config() -> ForgeConfig { @@ -792,8 +791,8 @@ mod given { RepoAlias::new(a_name()) } - pub fn a_webhook_message_body() -> crate::webhook::message::Body { - crate::webhook::message::Body::new(a_name()) + pub fn a_webhook_message_body() -> crate::webhook::forge_notification::Body { + crate::webhook::forge_notification::Body::new(a_name()) } pub fn some_repo_branches() -> RepoBranches { diff --git a/crates/config/src/webhook/mod.rs b/crates/config/src/webhook.rs similarity index 75% rename from crates/config/src/webhook/mod.rs rename to crates/config/src/webhook.rs index 91de1c7..bbeaf10 100644 --- a/crates/config/src/webhook/mod.rs +++ b/crates/config/src/webhook.rs @@ -1,6 +1,6 @@ pub mod auth; +pub mod forge_notification; pub mod id; -pub mod message; pub mod push; #[cfg(test)] diff --git a/crates/config/src/webhook/message.rs b/crates/config/src/webhook/forge_notification.rs similarity index 65% rename from crates/config/src/webhook/message.rs rename to crates/config/src/webhook/forge_notification.rs index 2600646..6fda1fe 100644 --- a/crates/config/src/webhook/message.rs +++ b/crates/config/src/webhook/forge_notification.rs @@ -1,19 +1,17 @@ // -use actix::prelude::*; - use crate as config; -use std::collections::HashMap; +use std::collections::BTreeMap; -#[derive(Message, Debug, Clone, derive_more::Constructor)] -#[rtype(result = "()")] -pub struct WebhookMessage { +/// A notification receive from a Forge, typically via a Webhook. +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, derive_more::Constructor)] +pub struct ForgeNotification { forge_alias: config::ForgeAlias, repo_alias: config::RepoAlias, - headers: HashMap, + headers: BTreeMap, body: Body, } -impl WebhookMessage { +impl ForgeNotification { pub const fn forge_alias(&self) -> &config::ForgeAlias { &self.forge_alias } @@ -28,7 +26,7 @@ impl WebhookMessage { } } -#[derive(Clone, Debug, derive_more::Constructor)] +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, derive_more::Constructor)] pub struct Body(String); impl Body { pub fn as_str(&self) -> &str { diff --git a/crates/forge-forgejo/src/lib.rs b/crates/forge-forgejo/src/lib.rs index 29a6f73..4370ca0 100644 --- a/crates/forge-forgejo/src/lib.rs +++ b/crates/forge-forgejo/src/lib.rs @@ -23,13 +23,16 @@ impl ForgeJo { } #[async_trait::async_trait] impl git::ForgeLike for ForgeJo { + fn duplicate(&self) -> Box { + Box::new(self.clone()) + } fn name(&self) -> String { "forgejo".to_string() } fn is_message_authorised( &self, - msg: &config::WebhookMessage, + msg: &config::ForgeNotification, expected: &config::WebhookAuth, ) -> bool { let authorization = msg.header("authorization"); @@ -43,7 +46,7 @@ impl git::ForgeLike for ForgeJo { fn parse_webhook_body( &self, - body: &config::webhook::message::Body, + body: &config::webhook::forge_notification::Body, ) -> git::forge::webhook::Result { webhook::parse_body(body) } diff --git a/crates/forge-forgejo/src/tests.rs b/crates/forge-forgejo/src/tests.rs index f803f06..5352662 100644 --- a/crates/forge-forgejo/src/tests.rs +++ b/crates/forge-forgejo/src/tests.rs @@ -77,7 +77,7 @@ mod forgejo { let next = repo_branches.next(); let sha = given::a_name(); let message = given::a_name(); - let body = config::webhook::message::Body::new( + let body = config::webhook::forge_notification::Body::new( json!({"ref":format!("refs/heads/{next}"),"after":sha,"head_commit":{"message":message}}) .to_string(), ); @@ -94,7 +94,8 @@ mod forgejo { fn should_error_invalid_body() { let fs = given::a_filesystem(); let forge = given::a_forgejo_forge(&given::repo_details(&fs), given::a_network()); - let body = config::webhook::message::Body::new(r#"{"type":"invalid"}"#.to_string()); + let body = + config::webhook::forge_notification::Body::new(r#"{"type":"invalid"}"#.to_string()); let_assert!(Err(_) = forge.parse_webhook_body(&body)); } } @@ -588,7 +589,7 @@ mod forgejo { } mod given { - use std::collections::HashMap; + use std::collections::BTreeMap; use kxio::network::{MockNetwork, StatusCode}; use serde_json::json; @@ -630,8 +631,8 @@ mod forgejo { WrongUlid, } - pub fn a_webhook_message(header: Header) -> config::WebhookMessage { - config::WebhookMessage::new( + pub fn a_webhook_message(header: Header) -> config::ForgeNotification { + config::ForgeNotification::new( given::a_forge_alias(), given::a_repo_alias(), given::webhook_headers(header), @@ -639,8 +640,8 @@ mod forgejo { ) } - pub fn webhook_headers(header: Header) -> HashMap { - let mut headers = HashMap::new(); + pub fn webhook_headers(header: Header) -> BTreeMap { + let mut headers = BTreeMap::new(); match header { Header::Valid(auth) => { headers.insert("authorization".to_string(), format!("Basic {auth}")); @@ -678,8 +679,8 @@ mod forgejo { config::WebhookAuth::generate() } - pub fn a_webhook_message_body() -> config::webhook::message::Body { - config::webhook::message::Body::new(a_name()) + pub fn a_webhook_message_body() -> config::webhook::forge_notification::Body { + config::webhook::forge_notification::Body::new(a_name()) } pub fn repo_branches() -> config::RepoBranches { diff --git a/crates/forge-forgejo/src/webhook/parse.rs b/crates/forge-forgejo/src/webhook/parse.rs index 7b87b52..f6d577c 100644 --- a/crates/forge-forgejo/src/webhook/parse.rs +++ b/crates/forge-forgejo/src/webhook/parse.rs @@ -4,7 +4,7 @@ use git_next_config as config; use git_next_git as git; pub fn parse_body( - body: &config::webhook::message::Body, + body: &config::webhook::forge_notification::Body, ) -> git::forge::webhook::Result { serde_json::from_str::(body.as_str())?.try_into() } diff --git a/crates/forge-github/src/lib.rs b/crates/forge-github/src/lib.rs index 9fc660e..218a313 100644 --- a/crates/forge-github/src/lib.rs +++ b/crates/forge-github/src/lib.rs @@ -19,13 +19,16 @@ pub struct Github { } #[async_trait::async_trait] impl git::ForgeLike for Github { + fn duplicate(&self) -> Box { + Box::new(self.clone()) + } fn name(&self) -> String { "github".to_string() } fn is_message_authorised( &self, - msg: &config::WebhookMessage, + msg: &config::ForgeNotification, webhook_auth: &config::WebhookAuth, ) -> bool { github::webhook::is_authorised(msg, webhook_auth) @@ -33,7 +36,7 @@ impl git::ForgeLike for Github { fn parse_webhook_body( &self, - body: &config::webhook::message::Body, + body: &config::webhook::forge_notification::Body, ) -> git::forge::webhook::Result { github::webhook::parse_body(body) } diff --git a/crates/forge-github/src/tests/mod.rs b/crates/forge-github/src/tests/mod.rs index 0ca6995..dab577f 100644 --- a/crates/forge-github/src/tests/mod.rs +++ b/crates/forge-github/src/tests/mod.rs @@ -10,8 +10,8 @@ mod github { use crate::Github; use config::{ - webhook::message::Body, ForgeAlias, ForgeConfig, ForgeType, GitDir, RepoAlias, - RepoBranches, ServerRepoConfig, WebhookAuth, WebhookMessage, + webhook::forge_notification::Body, ForgeAlias, ForgeConfig, ForgeNotification, ForgeType, + GitDir, RepoAlias, RepoBranches, ServerRepoConfig, WebhookAuth, }; use git::ForgeLike as _; @@ -536,7 +536,6 @@ mod github { } mod given { - use std::collections::HashMap; use git_next_config::{server::Webhook, WebhookId}; use kxio::network::{MockNetwork, StatusCode}; @@ -584,20 +583,20 @@ mod github { Missing, Invalid, } - pub fn a_webhook_message(header: Header) -> WebhookMessage { + pub fn a_webhook_message(header: Header) -> ForgeNotification { let body = match &header { Header::Valid(_, body) => body.clone(), _ => given::a_webhook_message_body(), }; - WebhookMessage::new( + ForgeNotification::new( given::a_forge_alias(), given::a_repo_alias(), given::webhook_headers(header), body, ) } - pub fn webhook_headers(header: Header) -> HashMap { - let mut headers = HashMap::new(); + pub fn webhook_headers(header: Header) -> BTreeMap { + let mut headers = BTreeMap::new(); match header { Header::Valid(auth, body) => { if let Some(sig) = crate::webhook::sign_body(&auth, &body) { diff --git a/crates/forge-github/src/webhook/authorised.rs b/crates/forge-github/src/webhook/authorised.rs index fbde6b5..ccf2d9d 100644 --- a/crates/forge-github/src/webhook/authorised.rs +++ b/crates/forge-github/src/webhook/authorised.rs @@ -1,7 +1,7 @@ // use git_next_config as config; -pub fn is_authorised(msg: &config::WebhookMessage, webhook_auth: &config::WebhookAuth) -> bool { +pub fn is_authorised(msg: &config::ForgeNotification, webhook_auth: &config::WebhookAuth) -> bool { msg.header("x-hub-signature-256") .map(|x| x.trim_matches('"').to_string()) .and_then(|sha| sha.strip_prefix("sha256=").map(|k| k.to_string())) @@ -21,7 +21,7 @@ pub fn is_authorised(msg: &config::WebhookMessage, webhook_auth: &config::Webhoo #[cfg(test)] pub fn sign_body( webhook_auth: &config::WebhookAuth, - body: &config::webhook::message::Body, + body: &config::webhook::forge_notification::Body, ) -> std::option::Option { let payload = body.as_str(); use hmac::Mac; diff --git a/crates/forge-github/src/webhook/parse.rs b/crates/forge-github/src/webhook/parse.rs index 6307db4..5d2222a 100644 --- a/crates/forge-github/src/webhook/parse.rs +++ b/crates/forge-github/src/webhook/parse.rs @@ -4,7 +4,7 @@ use git_next_config as config; use git_next_git as git; pub fn parse_body( - body: &config::webhook::message::Body, + body: &config::webhook::forge_notification::Body, ) -> git::forge::webhook::Result { serde_json::from_str::(body.as_str())?.try_into() } diff --git a/crates/forge/src/lib.rs b/crates/forge/src/lib.rs index 8c43c25..1e85a58 100644 --- a/crates/forge/src/lib.rs +++ b/crates/forge/src/lib.rs @@ -4,11 +4,9 @@ use git_next_forge_github as github; use git_next_git as git; use kxio::network::Network; -mod mock_forge; - #[derive(Clone, Debug)] pub enum Forge { - Mock(mock_forge::MockForge), + Mock, #[cfg(feature = "forgejo")] ForgeJo(git_next_forge_forgejo::ForgeJo), @@ -17,17 +15,15 @@ pub enum Forge { Github(git_next_forge_github::Github), } impl Forge { - pub fn new(repo_details: git::RepoDetails, net: Network) -> Self { + pub fn create(repo_details: git::RepoDetails, net: Network) -> Box { match repo_details.forge.forge_type() { #[cfg(feature = "forgejo")] git_next_config::ForgeType::ForgeJo => { - Self::ForgeJo(forgejo::ForgeJo::new(repo_details, net)) + Box::new(forgejo::ForgeJo::new(repo_details, net)) } #[cfg(feature = "github")] - git_next_config::ForgeType::GitHub => { - Self::Github(github::Github::new(repo_details, net)) - } - git_next_config::ForgeType::MockForge => Self::Mock(mock_forge::MockForge::new()), + git_next_config::ForgeType::GitHub => Box::new(github::Github::new(repo_details, net)), + git_next_config::ForgeType::MockForge => unreachable!(), } } } @@ -35,7 +31,7 @@ impl std::ops::Deref for Forge { type Target = dyn git::ForgeLike; fn deref(&self) -> &Self::Target { match self { - Self::Mock(env) => env, + Self::Mock => unreachable!(), #[cfg(feature = "forgejo")] Self::ForgeJo(env) => env, #[cfg(feature = "github")] diff --git a/crates/forge/src/mock_forge.rs b/crates/forge/src/mock_forge.rs deleted file mode 100644 index e32463d..0000000 --- a/crates/forge/src/mock_forge.rs +++ /dev/null @@ -1,59 +0,0 @@ -// -#![cfg(not(tarpaulin_include))] - -use derive_more::Constructor; -use git_next_config as config; -use git_next_git as git; - -#[derive(Clone, Debug, Constructor)] -pub struct MockForge; - -#[async_trait::async_trait] -impl git::ForgeLike for MockForge { - fn name(&self) -> String { - "mock".to_string() - } - - fn is_message_authorised( - &self, - _msg: &config::WebhookMessage, - _expected: &config::WebhookAuth, - ) -> bool { - todo!("MockForge::is_message_authorised") - } - - fn parse_webhook_body( - &self, - _body: &config::webhook::message::Body, - ) -> git::forge::webhook::Result { - todo!("MockForge::parse_webhook_body") - } - - async fn commit_status(&self, _commit: &git::Commit) -> git::forge::commit::Status { - todo!("MockForge::commit_status") - } - - async fn list_webhooks( - &self, - _webhook_url: &config::server::WebhookUrl, - ) -> git::forge::webhook::Result> { - todo!("MockForge::list_webhooks") - } - - async fn unregister_webhook( - &self, - _webhook_id: &config::WebhookId, - ) -> git::forge::webhook::Result<()> { - todo!("MockForge::unregister_webhook") - } - - async fn register_webhook( - &self, - _webhook_url: &config::server::WebhookUrl, - ) -> git::forge::webhook::Result { - Ok(config::RegisteredWebhook::new( - config::WebhookId::new(""), - config::WebhookAuth::new(ulid::Ulid::new()), - )) - } -} diff --git a/crates/forge/src/tests.rs b/crates/forge/src/tests.rs index bf6a9cb..66ffdb0 100644 --- a/crates/forge/src/tests.rs +++ b/crates/forge/src/tests.rs @@ -4,19 +4,11 @@ use super::*; use git_next_config as config; use git_next_git::{self as git, RepoDetails}; -#[test] -fn test_mock_name() { - let net = Network::new_mock(); - let repo_details = given_repo_details(config::ForgeType::MockForge); - let forge = Forge::new(repo_details, net); - assert_eq!(forge.name(), "mock"); -} - #[test] fn test_forgejo_name() { let net = Network::new_mock(); let repo_details = given_repo_details(config::ForgeType::ForgeJo); - let forge = Forge::new(repo_details, net); + let forge = Forge::create(repo_details, net); assert_eq!(forge.name(), "forgejo"); } @@ -24,7 +16,7 @@ fn test_forgejo_name() { fn test_github_name() { let net = Network::new_mock(); let repo_details = given_repo_details(config::ForgeType::GitHub); - let forge = Forge::new(repo_details, net); + let forge = Forge::create(repo_details, net); assert_eq!(forge.name(), "github"); } diff --git a/crates/git/src/commit.rs b/crates/git/src/commit.rs index c7172db..68f98a8 100644 --- a/crates/git/src/commit.rs +++ b/crates/git/src/commit.rs @@ -37,8 +37,8 @@ impl From for Commit { } } -newtype!(Sha is a String, Display); -newtype!(Message is a String); +newtype!(Sha is a String, Display, Hash); +newtype!(Message is a String, Hash); #[derive(Clone, Debug)] pub struct Histories { diff --git a/crates/git/src/forge/commit.rs b/crates/git/src/forge/commit.rs index ace9830..e335713 100644 --- a/crates/git/src/forge/commit.rs +++ b/crates/git/src/forge/commit.rs @@ -1,4 +1,4 @@ -#[derive(Debug, PartialEq, Eq)] +#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] pub enum Status { Pass, Fail, diff --git a/crates/git/src/forge/like.rs b/crates/git/src/forge/like.rs index 7ac484b..d795118 100644 --- a/crates/git/src/forge/like.rs +++ b/crates/git/src/forge/like.rs @@ -1,21 +1,23 @@ use crate as git; use git_next_config as config; +#[mockall::automock] #[async_trait::async_trait] -pub trait ForgeLike { +pub trait ForgeLike: std::fmt::Debug + Send + Sync { + fn duplicate(&self) -> Box; fn name(&self) -> String; /// Checks that the message has a valid authorisation fn is_message_authorised( &self, - message: &config::WebhookMessage, + message: &config::ForgeNotification, expected: &config::WebhookAuth, ) -> bool; /// Parses the webhook body into Some(Push) struct if appropriate, or None if not. fn parse_webhook_body( &self, - body: &config::webhook::message::Body, + body: &config::webhook::forge_notification::Body, ) -> git::forge::webhook::Result; /// Checks the results of any (e.g. CI) status checks for the commit. diff --git a/crates/git/src/lib.rs b/crates/git/src/lib.rs index db926a5..a04978e 100644 --- a/crates/git/src/lib.rs +++ b/crates/git/src/lib.rs @@ -17,6 +17,7 @@ mod tests; pub use commit::Commit; pub use forge::like::ForgeLike; +pub use forge::like::MockForgeLike; pub use generation::Generation; pub use git_ref::GitRef; pub use git_remote::GitRemote; diff --git a/crates/git/src/push.rs b/crates/git/src/push.rs index 9e3d987..adf1096 100644 --- a/crates/git/src/push.rs +++ b/crates/git/src/push.rs @@ -47,12 +47,12 @@ pub enum Error { } pub fn reset( - repository: &dyn git::repository::OpenRepositoryLike, + open_repository: &dyn git::repository::OpenRepositoryLike, repo_details: &git::RepoDetails, branch_name: &config::BranchName, to_commit: &git::GitRef, force: &git::push::Force, ) -> Result<()> { - repository.fetch()?; - repository.push(repo_details, branch_name, to_commit, force) + open_repository.fetch()?; + open_repository.push(repo_details, branch_name, to_commit, force) } diff --git a/crates/git/src/repo_details.rs b/crates/git/src/repo_details.rs index f0d761d..f5f53ac 100644 --- a/crates/git/src/repo_details.rs +++ b/crates/git/src/repo_details.rs @@ -1,7 +1,8 @@ -use git_next_config::{ +use config::{ BranchName, ForgeAlias, ForgeConfig, ForgeDetails, GitDir, RepoAlias, RepoConfig, RepoPath, ServerRepoConfig, }; +use git_next_config as config; use super::{Generation, GitRemote}; @@ -57,4 +58,10 @@ impl RepoDetails { pub fn git_remote(&self) -> GitRemote { GitRemote::new(self.forge.hostname().clone(), self.repo_path.clone()) } + + pub fn with_hostname(mut self, hostname: config::Hostname) -> Self { + let forge = self.forge; + self.forge = forge.with_hostname(hostname); + self + } } diff --git a/crates/git/src/repository/mod.rs b/crates/git/src/repository/mod.rs index 42eeae9..78f7711 100644 --- a/crates/git/src/repository/mod.rs +++ b/crates/git/src/repository/mod.rs @@ -23,7 +23,7 @@ pub use real::RealRepository; use tracing::info; use crate::repository::test::TestRepository; -use crate::validation::repo::validate_repo; +use crate::validation::remotes::validate_default_remotes; use super::RepoDetails; @@ -52,19 +52,20 @@ pub const fn test(fs: kxio::fs::FileSystem) -> TestRepository { #[tracing::instrument(skip_all)] #[cfg(not(tarpaulin_include))] // requires network access to either clone new and/or fetch. pub fn open( - repository: &dyn RepositoryFactory, + repository_factory: &dyn RepositoryFactory, repo_details: &RepoDetails, gitdir: config::GitDir, ) -> Result> { let open_repository = if !gitdir.exists() { info!("Local copy not found - cloning..."); - repository.git_clone(repo_details)? + repository_factory.git_clone(repo_details)? } else { info!("Local copy found - opening..."); - repository.open(&gitdir)? + repository_factory.open(&gitdir)? }; info!("Validating..."); - validate_repo(&*open_repository, repo_details).map_err(|e| Error::Validation(e.to_string()))?; + validate_default_remotes(&*open_repository, repo_details) + .map_err(|e| Error::Validation(e.to_string()))?; Ok(open_repository) } @@ -125,7 +126,7 @@ impl std::ops::Deref for Repository { } } -#[derive(Debug, Copy, Clone, PartialEq, Eq)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] pub enum Direction { /// Push local changes to the remote. Push, diff --git a/crates/git/src/repository/tests.rs b/crates/git/src/repository/tests.rs index 695a27b..5ac458f 100644 --- a/crates/git/src/repository/tests.rs +++ b/crates/git/src/repository/tests.rs @@ -1,7 +1,7 @@ use crate as git; mod validate { - use crate::{tests::given, validation::repo::validate_repo}; + use crate::{tests::given, validation::remotes::validate_default_remotes}; use super::*; use git::repository::Direction; @@ -17,7 +17,7 @@ mod validate { .expect_find_default_remote() .returning(move |_direction| Some(repo_details_mock.git_remote())); - let result = validate_repo(&*open_repository, &repo_details); + let result = validate_default_remotes(&*open_repository, &repo_details); println!("{result:?}"); assert!(result.is_ok()); } @@ -36,7 +36,7 @@ mod validate { Direction::Fetch => Some(repo_details_mock.git_remote()), }); - let result = validate_repo(&*open_repository, &repo_details); + let result = validate_default_remotes(&*open_repository, &repo_details); println!("{result:?}"); assert!(result.is_err()); } @@ -55,7 +55,7 @@ mod validate { Direction::Fetch => None, }); - let result = validate_repo(&*open_repository, &repo_details); + let result = validate_default_remotes(&*open_repository, &repo_details); println!("{result:?}"); assert!(result.is_err()); } @@ -74,7 +74,7 @@ mod validate { Direction::Fetch => Some(repo_details_mock.git_remote()), }); - let result = validate_repo(&*open_repository, &repo_details); + let result = validate_default_remotes(&*open_repository, &repo_details); println!("{result:?}"); assert!(result.is_err()); } @@ -93,7 +93,7 @@ mod validate { Direction::Fetch => Some(given::a_git_remote()), }); - let result = validate_repo(&*open_repository, &repo_details); + let result = validate_default_remotes(&*open_repository, &repo_details); println!("{result:?}"); assert!(result.is_err()); } diff --git a/crates/git/src/validation/mod.rs b/crates/git/src/validation/mod.rs index 628b5cf..0639673 100644 --- a/crates/git/src/validation/mod.rs +++ b/crates/git/src/validation/mod.rs @@ -1,5 +1,5 @@ pub mod positions; -pub mod repo; +pub mod remotes; #[cfg(test)] mod tests; diff --git a/crates/git/src/validation/positions.rs b/crates/git/src/validation/positions.rs index f8acd64..1a55959 100644 --- a/crates/git/src/validation/positions.rs +++ b/crates/git/src/validation/positions.rs @@ -2,8 +2,6 @@ use crate as git; use git_next_config as config; -use tracing::{error, info, warn}; - pub type Result = core::result::Result; #[derive(Debug)] @@ -14,7 +12,7 @@ pub struct Positions { pub dev_commit_history: Vec, } -#[allow(clippy::cognitive_complexity)] // TODO: (#83) reduce complexity +// #[allow(clippy::cognitive_complexity)] // TODO: (#83) reduce complexity pub fn validate_positions( open_repository: &dyn git::repository::OpenRepositoryLike, repo_details: &git::RepoDetails, @@ -46,7 +44,7 @@ pub fn validate_positions( // Validations: // Dev must be on main branch, else the USER must rebase it if is_not_based_on(&commit_histories.dev, &main) { - warn!("Dev '{dev_branch}' not based on main '{main_branch}' - user must rebase",); + tracing::warn!("Dev '{dev_branch}' not based on main '{main_branch}' - user must rebase",); return Err(Error::DevBranchNotBasedOn { dev: dev_branch, other: main_branch, @@ -54,12 +52,12 @@ pub fn validate_positions( } // verify that next is on main or at most one commit on top of main, else reset it back to main if is_not_based_on(&commit_histories.next[0..=1], &main) { - info!("Main not on same commit as next, or it's parent - resetting next to main",); + tracing::info!("Main not on same commit as next, or it's parent - resetting next to main",); return reset_next_to_main(open_repository, repo_details, &main, &next, &next_branch); } // verify that next is an ancestor of dev, else reset it back to main if is_not_based_on(&commit_histories.dev, &next) { - info!("Next is not an ancestor of dev - resetting next to main"); + tracing::info!("Next is not an ancestor of dev - resetting next to main"); return reset_next_to_main(open_repository, repo_details, &main, &next, &next_branch); } @@ -72,21 +70,21 @@ pub fn validate_positions( } fn reset_next_to_main( - repository: &dyn crate::repository::OpenRepositoryLike, + open_repository: &dyn crate::repository::OpenRepositoryLike, repo_details: &crate::RepoDetails, main: &crate::Commit, next: &crate::Commit, next_branch: &config::BranchName, ) -> Result { git::push::reset( - repository, + open_repository, repo_details, next_branch, &main.clone().into(), &git::push::Force::From(next.clone().into()), ) .map_err(|err| { - warn!(?err, "Failed to reset next to main"); + tracing::warn!(?err, "Failed to reset next to main"); Error::FailedToResetBranch { branch: next_branch.clone(), commit: next.clone(), @@ -100,13 +98,13 @@ fn is_not_based_on(commits: &[crate::commit::Commit], needle: &crate::Commit) -> } fn get_commit_histories( - repository: &dyn git::repository::OpenRepositoryLike, + open_repository: &dyn git::repository::OpenRepositoryLike, repo_config: &config::RepoConfig, ) -> git::commit::log::Result { - let main = (repository.commit_log(&repo_config.branches().main(), &[]))?; + let main = (open_repository.commit_log(&repo_config.branches().main(), &[]))?; let main_head = [main[0].clone()]; - let next = repository.commit_log(&repo_config.branches().next(), &main_head)?; - let dev = repository.commit_log(&repo_config.branches().dev(), &main_head)?; + let next = open_repository.commit_log(&repo_config.branches().next(), &main_head)?; + let dev = open_repository.commit_log(&repo_config.branches().dev(), &main_head)?; let histories = git::commit::Histories { main, next, dev }; Ok(histories) } diff --git a/crates/git/src/validation/repo.rs b/crates/git/src/validation/remotes.rs similarity index 98% rename from crates/git/src/validation/repo.rs rename to crates/git/src/validation/remotes.rs index 46c9560..b13a71b 100644 --- a/crates/git/src/validation/repo.rs +++ b/crates/git/src/validation/remotes.rs @@ -3,7 +3,7 @@ use tracing::info; use crate as git; #[tracing::instrument(skip_all)] -pub fn validate_repo( +pub fn validate_default_remotes( open_repository: &dyn git::repository::OpenRepositoryLike, repo_details: &git::RepoDetails, ) -> Result<()> { diff --git a/crates/git/src/validation/tests.rs b/crates/git/src/validation/tests.rs index c4bc7a5..46096cb 100644 --- a/crates/git/src/validation/tests.rs +++ b/crates/git/src/validation/tests.rs @@ -33,12 +33,13 @@ mod repos { "open repo" ); - let result = git::validation::repo::validate_repo(&*open_repository, &repo_details); + let result = + git::validation::remotes::validate_default_remotes(&*open_repository, &repo_details); print!("{result:?}"); let_assert!(Err(err) = result); assert!(matches!( err, - git::validation::repo::Error::NoDefaultPushRemote + git::validation::remotes::Error::NoDefaultPushRemote )); } } diff --git a/crates/repo-actor/Cargo.toml b/crates/repo-actor/Cargo.toml index 4daf772..408d52f 100644 --- a/crates/repo-actor/Cargo.toml +++ b/crates/repo-actor/Cargo.toml @@ -42,12 +42,21 @@ ulid = { workspace = true } # boilerplate derive_more = { workspace = true } +thiserror = { workspace = true } # Actors actix = { workspace = true } actix-rt = { workspace = true } tokio = { workspace = true } +[dev-dependencies] +# Testing +assert2 = { workspace = true } +rand = { workspace = true } +pretty_assertions = { workspace = true } +mockall = { workspace = true } +test-log = { workspace = true } + [lints.clippy] nursery = { level = "warn", priority = -1 } # pedantic = "warn" diff --git a/crates/repo-actor/README.md b/crates/repo-actor/README.md new file mode 100644 index 0000000..bdb4fe0 --- /dev/null +++ b/crates/repo-actor/README.md @@ -0,0 +1,35 @@ +```mermaid +stateDiagram-v2 +[*] --> CloneRepo :Start + +CloneRepo --> LoadConfigFromRepo +CloneRepo --> ValidateRepo + +LoadConfigFromRepo --> ReceiveRepoConfig + +ValidateRepo --> CheckCIStatus +ValidateRepo --> AdvanceNext +ValidateRepo --> ValidateRepo :invalid + +CheckCIStatus --> ReceiveCIStatus + +ReceiveCIStatus --> AdvanceMain :Pass +ReceiveCIStatus --> ValidateRepo :Pending +ReceiveCIStatus --> [*] :Fail + +AdvanceNext --> ValidateRepo + +ReceiveRepoConfig --> ValidateRepo +ReceiveRepoConfig --> RegisterWebhook + +RegisterWebhook --> WebhookRegistered + +WebhookRegistered --> [*] + +AdvanceMain --> LoadConfigFromRepo :on repo config - reload +AdvanceMain --> ValidateRepo :on server config + +[*] --> WebhookNotification :WEBHOOK + +WebhookNotification --> ValidateRepo +``` diff --git a/crates/repo-actor/src/branch.rs b/crates/repo-actor/src/branch.rs index a373f71..57c0aff 100644 --- a/crates/repo-actor/src/branch.rs +++ b/crates/repo-actor/src/branch.rs @@ -1,96 +1,100 @@ // -use actix::prelude::*; - +use crate::messages::MessageToken; use git_next_config as config; use git_next_git as git; + +use derive_more::Display; use tracing::{info, warn}; -use crate::{MessageToken, ValidateRepo}; - -use std::time::Duration; - // advance next to the next commit towards the head of the dev branch #[tracing::instrument(fields(next), skip_all)] -pub async fn advance_next( - next: git::Commit, - dev_commit_history: Vec, +pub fn advance_next( + next: &git::Commit, + dev_commit_history: &[git::Commit], repo_details: git::RepoDetails, repo_config: config::RepoConfig, open_repository: &dyn git::repository::OpenRepositoryLike, - addr: Addr, message_token: MessageToken, -) { - let next_commit = find_next_commit_on_dev(next, dev_commit_history); - let Some(commit) = next_commit else { - warn!("No commits to advance next to"); - return; - }; - if let Some(problem) = validate_commit_message(commit.message()) { - warn!("Can't advance next to commit '{}': {}", commit, problem); - return; - } +) -> Result { + let commit = + find_next_commit_on_dev(next, dev_commit_history).ok_or_else(|| Error::NextAtDev)?; + validate_commit_message(commit.message())?; info!("Advancing next to commit '{}'", commit); - if let Err(err) = git::push::reset( + git::push::reset( open_repository, &repo_details, &repo_config.branches().next(), &commit.into(), &git::push::Force::No, - ) { - warn!(?err, "Failed") - } - tokio::time::sleep(Duration::from_secs(10)).await; - addr.do_send(ValidateRepo { message_token }) + )?; + Ok(message_token) } #[tracing::instrument] -fn validate_commit_message(message: &git::commit::Message) -> Option { +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' #[tracing::instrument(fields(next), skip_all)] -pub async fn advance_main( +pub fn advance_main( next: git::Commit, repo_details: &git::RepoDetails, repo_config: &config::RepoConfig, open_repository: &dyn git::repository::OpenRepositoryLike, -) { +) -> Result<()> { info!("Advancing main to next"); - if let Err(err) = git::push::reset( + git::push::reset( open_repository, repo_details, &repo_config.branches().main(), &next.into(), &git::push::Force::No, - ) { - warn!(?err, "Failed") - }; + )?; + Ok(()) +} + +pub type Result = 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.rs b/crates/repo-actor/src/handlers.rs new file mode 100644 index 0000000..42cf63a --- /dev/null +++ b/crates/repo-actor/src/handlers.rs @@ -0,0 +1,11 @@ +pub mod advance_main; +pub mod advance_next; +pub mod check_ci_status; +pub mod clone_repo; +pub mod load_config_from_repo; +pub mod receive_ci_status; +pub mod receive_repo_config; +pub mod register_webhook; +pub mod validate_repo; +pub mod webhook_notification; +pub mod webhook_registered; diff --git a/crates/repo-actor/src/handlers/advance_main.rs b/crates/repo-actor/src/handlers/advance_main.rs new file mode 100644 index 0000000..47424fb --- /dev/null +++ b/crates/repo-actor/src/handlers/advance_main.rs @@ -0,0 +1,50 @@ +// +use crate as actor; +use actix::prelude::*; + +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::AdvanceMain, + 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(open_repository) = &self.open_repository else { + return; + }; + let repo_details = self.repo_details.clone(); + let addr = ctx.address(); + let message_token = self.message_token; + + match actor::branch::advance_main( + msg.unwrap(), + &repo_details, + &repo_config, + &**open_repository, + ) { + Err(err) => { + tracing::warn!("advance main: {err}"); + } + Ok(_) => { + let log = self.log.clone(); + match repo_config.source() { + git_next_config::RepoConfigSource::Repo => { + actor::do_send(addr, actor::messages::LoadConfigFromRepo, &log); + } + git_next_config::RepoConfigSource::Server => { + actor::do_send( + addr, + actor::messages::ValidateRepo::new(message_token), + &log, + ); + } + } + } + } + } +} diff --git a/crates/repo-actor/src/handlers/advance_next.rs b/crates/repo-actor/src/handlers/advance_next.rs new file mode 100644 index 0000000..da04615 --- /dev/null +++ b/crates/repo-actor/src/handlers/advance_next.rs @@ -0,0 +1,44 @@ +// +use crate as actor; +use actix::prelude::*; + +impl Handler for actor::RepoActor { + type Result = (); + + fn handle( + &mut self, + msg: actor::messages::AdvanceNext, + ctx: &mut Self::Context, + ) -> Self::Result { + let Some(repo_config) = &self.repo_details.repo_config else { + return; + }; + let Some(open_repository) = &self.open_repository else { + return; + }; + let (next_commit, dev_commit_history) = msg.unwrap(); + let repo_details = self.repo_details.clone(); + let repo_config = repo_config.clone(); + let addr = ctx.address(); + + match actor::branch::advance_next( + &next_commit, + &dev_commit_history, + repo_details, + repo_config, + &**open_repository, + self.message_token, + ) { + Ok(message_token) => { + // pause to allow any CI checks to be started + std::thread::sleep(self.sleep_duration); + actor::do_send( + addr, + actor::messages::ValidateRepo::new(message_token), + &self.log, + ); + } + Err(err) => tracing::warn!("advance next: {err}"), + } + } +} diff --git a/crates/repo-actor/src/handlers/check_ci_status.rs b/crates/repo-actor/src/handlers/check_ci_status.rs new file mode 100644 index 0000000..264b93d --- /dev/null +++ b/crates/repo-actor/src/handlers/check_ci_status.rs @@ -0,0 +1,34 @@ +// +use crate as actor; +use actix::prelude::*; +use tracing::Instrument as _; + +impl Handler for actor::RepoActor { + type Result = (); + + fn handle( + &mut self, + msg: actor::messages::CheckCIStatus, + ctx: &mut Self::Context, + ) -> Self::Result { + actor::logger(&self.log, "start: CheckCIStatus"); + let addr = ctx.address(); + let forge = self.forge.duplicate(); + let next = msg.unwrap(); + let log = self.log.clone(); + + // get the status - pass, fail, pending (all others map to fail, e.g. error) + async move { + let status = forge.commit_status(&next).await; + let _ = actor::send( + addr, + actor::messages::ReceiveCIStatus::new((next, status)), + &log, + ) + .await; + } + .in_current_span() + .into_actor(self) + .wait(ctx); + } +} diff --git a/crates/repo-actor/src/handlers/clone_repo.rs b/crates/repo-actor/src/handlers/clone_repo.rs new file mode 100644 index 0000000..f474517 --- /dev/null +++ b/crates/repo-actor/src/handlers/clone_repo.rs @@ -0,0 +1,45 @@ +// +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 { + tracing::debug!("Handler: CloneRepo: start"); + let gitdir = self.repo_details.gitdir.clone(); + match git::repository::open(&*self.repository_factory, &self.repo_details, gitdir) { + Ok(repository) => { + actor::logger(&self.log, "open okay"); + tracing::debug!("open okay"); + self.open_repository.replace(repository); + if self.repo_details.repo_config.is_none() { + tracing::debug!("Handler: CloneRepo: Sending: LoadConfigFromRepo"); + actor::logger(&self.log, "send: LoadConfigFromRepo"); + ctx.address().do_send(actor::messages::LoadConfigFromRepo); + } else { + tracing::debug!("Handler: CloneRepo: Sending: ValidateRepo"); + actor::logger(&self.log, "send: ValidateRepo"); + if let Err(_e) = ctx + .address() + .try_send(actor::messages::ValidateRepo::new(self.message_token)) + { + actor::logger(&self.log, format!("ValidateRepo: error: {_e:?}")); + } + } + } + Err(err) => { + actor::logger(&self.log, "open failed"); + tracing::debug!("err: {err:?}"); + tracing::warn!("Could not open repo: {err}") + } + } + tracing::debug!("Handler: CloneRepo: finish"); + } +} 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..7213dad --- /dev/null +++ b/crates/repo-actor/src/handlers/load_config_from_repo.rs @@ -0,0 +1,38 @@ +// +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 { + tracing::debug!("Handler: LoadConfigFromRepo: start"); + let Some(open_repository) = &self.open_repository else { + return; + }; + let open_repository = open_repository.duplicate(); + let repo_details = self.repo_details.clone(); + let addr = ctx.address(); + let log = self.log.clone(); + async move { + match actor::load::config_from_repository(repo_details, &*open_repository).await { + Ok(repo_config) => { + actor::logger(&log, "send: LoadedConfig"); + addr.do_send(actor::messages::ReceiveRepoConfig::new(repo_config)) + } + Err(err) => tracing::warn!(?err, "Failed to load config"), + // TODO: (#95) should notify user + } + } + .in_current_span() + .into_actor(self) + .wait(ctx); + tracing::debug!("Handler: LoadConfigFromRepo: finish"); + } +} diff --git a/crates/repo-actor/src/handlers/receive_ci_status.rs b/crates/repo-actor/src/handlers/receive_ci_status.rs new file mode 100644 index 0000000..7e9bf88 --- /dev/null +++ b/crates/repo-actor/src/handlers/receive_ci_status.rs @@ -0,0 +1,42 @@ +// +use crate as actor; +use actix::prelude::*; +use git_next_git as git; + +impl Handler for actor::RepoActor { + type Result = (); + + fn handle( + &mut self, + msg: actor::messages::ReceiveCIStatus, + ctx: &mut Self::Context, + ) -> Self::Result { + let log = self.log.clone(); + actor::logger(&log, "start: ReceiveCIStatus"); + let addr = ctx.address(); + let (next, status) = msg.unwrap(); + let message_token = self.message_token; + let sleep_duration = self.sleep_duration; + + tracing::debug!(?status, ""); + match status { + git::forge::commit::Status::Pass => { + actor::do_send(addr, actor::messages::AdvanceMain::new(next), &self.log); + } + git::forge::commit::Status::Pending => { + std::thread::sleep(sleep_duration); + actor::do_send( + addr, + actor::messages::ValidateRepo::new(message_token), + &self.log, + ); + } + git::forge::commit::Status::Fail => { + tracing::warn!("Checks have failed"); + // TODO: (#95) test: repo with next ahead of main and failing CI should notify user + // TODO: (#88) recheck after a longer than normal delay + actor::logger(&log, "send: nothing"); // replace with messages to send notification and revalidate later + } + } + } +} diff --git a/crates/repo-actor/src/handlers/receive_repo_config.rs b/crates/repo-actor/src/handlers/receive_repo_config.rs new file mode 100644 index 0000000..b164250 --- /dev/null +++ b/crates/repo-actor/src/handlers/receive_repo_config.rs @@ -0,0 +1,29 @@ +// +use actix::prelude::*; + +use crate as actor; + +impl Handler for actor::RepoActor { + type Result = (); + #[tracing::instrument(name = "RepoActor::ReceiveRepoConfig", skip_all, fields(repo = %self.repo_details, branches = ?msg))] + fn handle( + &mut self, + msg: actor::messages::ReceiveRepoConfig, + ctx: &mut Self::Context, + ) -> Self::Result { + let repo_config = msg.unwrap(); + self.repo_details.repo_config.replace(repo_config); + + actor::do_send( + ctx.address(), + actor::messages::ValidateRepo::new(self.message_token), + &self.log, + ); + + actor::do_send( + ctx.address(), + actor::messages::RegisterWebhook::new(), + &self.log, + ); + } +} diff --git a/crates/repo-actor/src/handlers/register_webhook.rs b/crates/repo-actor/src/handlers/register_webhook.rs new file mode 100644 index 0000000..fda0af8 --- /dev/null +++ b/crates/repo-actor/src/handlers/register_webhook.rs @@ -0,0 +1,39 @@ +// +use actix::prelude::*; +use tracing::Instrument as _; + +use crate as actor; +use actor::{messages::RegisterWebhook, RepoActor}; + +impl Handler for RepoActor { + type Result = (); + + fn handle(&mut self, _msg: RegisterWebhook, ctx: &mut Self::Context) -> Self::Result { + if self.webhook_id.is_none() { + let forge_alias = self.repo_details.forge.forge_alias(); + let repo_alias = &self.repo_details.repo_alias; + let webhook_url = self.webhook.url(forge_alias, repo_alias); + let forge = self.forge.duplicate(); + let addr = ctx.address(); + let log = self.log.clone(); + tracing::debug!("registering webhook"); + async move { + match forge.register_webhook(&webhook_url).await { + Ok(registered_webhook) => { + tracing::debug!(?registered_webhook, ""); + actor::do_send( + addr, + actor::messages::WebhookRegistered::from(registered_webhook), + &log, + ); + } + Err(err) => tracing::warn!(?err, "registering webhook"), + } + } + .in_current_span() + .into_actor(self) + .wait(ctx); + tracing::debug!("registering webhook done"); + } + } +} 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..2fb3763 --- /dev/null +++ b/crates/repo-actor/src/handlers/validate_repo.rs @@ -0,0 +1,119 @@ +// +use actix::prelude::*; +use derive_more::Deref as _; +use tracing::Instrument as _; + +use crate::{self as actor, messages::MessageToken}; +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.deref()))] + fn handle( + &mut self, + msg: actor::messages::ValidateRepo, + ctx: &mut Self::Context, + ) -> Self::Result { + actor::logger(&self.log, "start: ValidateRepo"); + + // Message Token - make sure we are only triggered for the latest/current token + match self.token_status(msg.unwrap()) { + TokenStatus::Current => {} // do nothing + TokenStatus::Expired => { + actor::logger( + &self.log, + format!("discarded: old message token: {}", self.message_token), + ); + return; // message is expired + } + TokenStatus::New(message_token) => { + self.message_token = message_token; + actor::logger( + &self.log, + format!("new message token: {}", self.message_token), + ); + } + } + actor::logger(&self.log, format!("accepted token: {}", self.message_token)); + + // Repository positions + let Some(ref open_repository) = self.open_repository else { + return; + }; + let Some(repo_config) = self.repo_details.repo_config.clone() else { + return; + }; + + match git::validation::positions::validate_positions( + &**open_repository, + &self.repo_details, + repo_config, + ) { + Ok(git::validation::positions::Positions { + main, + next, + dev, + dev_commit_history, + }) => { + if next != main { + actor::do_send( + ctx.address(), + actor::messages::CheckCIStatus::new(next), + &self.log, + ); + } else if next != dev { + actor::do_send( + ctx.address(), + actor::messages::AdvanceNext::new((next, dev_commit_history)), + &self.log, + ) + } else { + // do nothing + } + } + Err(err) => { + actor::logger( + &self.log, + format!("invalid positions: {err:?} will sleep then retry"), + ); + tracing::warn!("Error: {err:?}"); + let addr = ctx.address(); + let message_token = self.message_token; + let sleep_duration = self.sleep_duration; + let log = self.log.clone(); + async move { + tracing::debug!("sleeping before retrying..."); + tokio::time::sleep(sleep_duration).await; + actor::do_send( + addr, + actor::messages::ValidateRepo::new(message_token), + &log, + ); + } + .in_current_span() + .into_actor(self) + .wait(ctx); + } + } + + tracing::debug!("Handler: ValidateRepo: finish"); + } +} + +enum TokenStatus { + Current, + Expired, + New(MessageToken), +} +impl actor::RepoActor { + fn token_status(&self, new: MessageToken) -> TokenStatus { + let current = &self.message_token; + if &new > current { + return TokenStatus::New(new); + } + if current > &new { + return TokenStatus::Expired; + } + TokenStatus::Current + } +} diff --git a/crates/repo-actor/src/webhook.rs b/crates/repo-actor/src/handlers/webhook_notification.rs similarity index 91% rename from crates/repo-actor/src/webhook.rs rename to crates/repo-actor/src/handlers/webhook_notification.rs index 21c808a..56b0ed1 100644 --- a/crates/repo-actor/src/webhook.rs +++ b/crates/repo-actor/src/handlers/webhook_notification.rs @@ -1,18 +1,18 @@ // use actix::prelude::*; -use crate::{RepoActor, ValidateRepo}; +use crate::{self as actor, messages::WebhookNotification}; 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 #[tracing::instrument(name = "RepoActor::WebhookMessage", skip_all, fields(token = %self.message_token, repo = %self.repo_details))] - fn handle(&mut self, msg: config::WebhookMessage, ctx: &mut Self::Context) -> Self::Result { + fn handle(&mut self, msg: WebhookNotification, ctx: &mut Self::Context) -> Self::Result { let Some(expected_authorization) = &self.webhook_auth else { warn!("Don't know what authorization to expect"); return; @@ -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 be59827..4e122a1 100644 --- a/crates/repo-actor/src/lib.rs +++ b/crates/repo-actor/src/lib.rs @@ -1,30 +1,59 @@ mod branch; +pub mod handlers; mod load; -pub mod status; -pub mod webhook; +pub mod messages; #[cfg(test)] mod tests; -use std::time::Duration; - use actix::prelude::*; -use config::RegisteredWebhook; -use git::validation::positions::{validate_positions, Positions}; -use crate as repo_actor; use git_next_config as config; -use git_next_forge as forge; use git_next_git as git; use kxio::network::Network; -use tracing::{debug, info, warn, Instrument}; +use tracing::{info, warn, Instrument}; +pub type RepoActorLog = std::sync::Arc>>; + +/// An actor that represents a Git Repository. +/// +/// When this actor is started it is sent the [CloneRepo] message. +/// +/// ```mermaid +/// stateDiagram-v2 +/// [*] --> CloneRepo :START +/// +/// CloneRepo --> LoadConfigFromRepo +/// CloneRepo --> ValidateRepo +/// +/// LoadConfigFromRepo --> LoadedConfig +/// +/// ValidateRepo --> WebhookRegistered +/// ValidateRepo --> StartMonitoring +/// ValidateRepo --> ValidateRepo :SLEEP 10s +/// +/// LoadedConfig --> ValidateRepo +/// +/// WebhookRegistered --> [*] +/// +/// StartMonitoring --> AdvanceMainTo +/// StartMonitoring --> ValidateRepo :SLEEP 10s +/// +/// AdvanceMainTo --> LoadConfigFromRepo +/// AdvanceMainTo --> ValidateRepo +/// +/// [*] --> WebhookMessage :WEBHOOK +/// +/// WebhookMessage --> ValidateRepo +/// ``` +/// #[derive(Debug, derive_more::Display)] #[display("{}:{}:{}", generation, repo_details.forge.forge_alias(), repo_details.repo_alias)] pub struct RepoActor { + sleep_duration: std::time::Duration, generation: git::Generation, - message_token: MessageToken, + message_token: messages::MessageToken, repo_details: git::RepoDetails, webhook: config::server::Webhook, webhook_id: Option, // INFO: if [None] then no webhook is configured @@ -32,47 +61,74 @@ pub struct RepoActor { last_main_commit: Option, last_next_commit: Option, last_dev_commit: Option, - repository: Box, + repository_factory: Box, open_repository: Option>, net: Network, - forge: forge::Forge, + forge: Box, + log: Option, } impl RepoActor { pub fn new( - details: git::RepoDetails, + repo_details: git::RepoDetails, + forge: Box, webhook: config::server::Webhook, generation: git::Generation, net: Network, - repository: Box, + repository_factory: Box, + sleep_duration: std::time::Duration, ) -> Self { - let forge = forge::Forge::new(details.clone(), net.clone()); - debug!(?forge, "new"); + let message_token = messages::MessageToken::default(); Self { generation, - message_token: MessageToken::new(), - repo_details: details, + message_token, + repo_details, webhook, webhook_id: None, webhook_auth: None, last_main_commit: None, last_next_commit: None, last_dev_commit: None, - repository, + repository_factory, open_repository: None, - net, forge, + net, + sleep_duration, + log: None, } } } + +#[cfg(test)] +impl RepoActor { + pub fn with_log(mut self, log: RepoActorLog) -> Self { + self.log = Some(log); + self + } + + pub fn with_open_repository( + mut self, + open_repository: Box, + ) -> Self { + self.open_repository.replace(open_repository); + self + } + + pub const fn with_message_token(mut self, message_token: messages::MessageToken) -> Self { + self.message_token = message_token; + self + } +} impl Actor for RepoActor { type Context = Context; #[tracing::instrument(name = "RepoActor::stopping", skip_all, fields(repo = %self.repo_details))] fn stopping(&mut self, ctx: &mut Self::Context) -> Running { + tracing::debug!("stopping"); info!("Checking webhook"); match self.webhook_id.take() { Some(webhook_id) => { + tracing::warn!("stopping - unregistering webhook"); info!(%webhook_id, "Unregistring webhook"); - let forge = self.forge.clone(); + let forge = self.forge.duplicate(); async move { if let Err(err) = forge.unregister_webhook(&webhook_id).await { warn!("unregistering webhook: {err}"); @@ -88,259 +144,38 @@ 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 else { - warn!("missing open repository - can't load configuration"); - return; - }; - let open_repository = open_repository.duplicate(); - async move { repo_actor::load::load_file(details, addr, &*open_repository).await } - .in_current_span() - .into_actor(self) - .wait(ctx) - } -} - -#[derive(Message)] -#[rtype(result = "()")] -struct LoadedConfig(git_next_config::RepoConfig); -impl Handler 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(open_repository), Some(repo_config)) = - (&self.open_repository, self.repo_details.repo_config.clone()) - { - let repo_details = self.repo_details.clone(); - let addr = ctx.address(); - let message_token = self.message_token; - let open_repository = open_repository.duplicate(); - async move { - match validate_positions(&*open_repository, &repo_details, repo_config) { - Ok(Positions { - main, - next, - dev, - dev_commit_history, - }) => { - addr.do_send(StartMonitoring::new(main, next, dev, dev_commit_history)); - } - Err(err) => { - warn!("{:?}", err); - tokio::time::sleep(Duration::from_secs(10)).await; - addr.do_send(ValidateRepo::new(message_token)); - } - } - } - .in_current_span() - .into_actor(self) - .wait(ctx); - } - } -} - -#[derive(Debug, derive_more::Constructor, Message)] -#[rtype(result = "()")] -pub struct StartMonitoring { - main: git::Commit, - next: git::Commit, - dev: git::Commit, - dev_commit_history: Vec, -} -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(open_repository) = &self.open_repository { - let open_repository = open_repository.duplicate(); - let repo_details = self.repo_details.clone(); - let message_token = self.message_token; - async move { - branch::advance_next( - msg.next, - msg.dev_commit_history, - repo_details, - repo_config, - &*open_repository, - addr, - message_token, - ) - .await - } - .in_current_span() - .into_actor(self) - .wait(ctx); - } - } - } -} - -#[derive(Message)] -#[rtype(result = "()")] -pub struct WebhookRegistered(config::WebhookId, config::WebhookAuth); -impl From 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(open_repository) = &self.open_repository else { - warn!("No repository opened"); - return; - }; - let repo_details = self.repo_details.clone(); - let addr = ctx.address(); - let message_token = self.message_token; - let open_repository = open_repository.duplicate(); - async move { - branch::advance_main(msg.0, &repo_details, &repo_config, &*open_repository).await; - match repo_config.source() { - git_next_config::RepoConfigSource::Repo => addr.do_send(LoadConfigFromRepo), - git_next_config::RepoConfigSource::Server => { - addr.do_send(ValidateRepo { message_token }) - } - } - } - .in_current_span() - .into_actor(self) - .wait(ctx); - } -} - -#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord, derive_more::Display)] -pub struct MessageToken(u32); -impl MessageToken { - pub fn new() -> Self { - Self::default() - } - pub const fn next(&self) -> Self { - Self(self.0 + 1) +pub fn do_send(_addr: Addr, msg: M, log: &Option) +where + M: actix::Message + Send + 'static + std::fmt::Debug, + RepoActor: actix::Handler, + ::Result: Send, +{ + let log_message = format!("send: {:?}", msg); + tracing::debug!(log_message); + logger(log, log_message); + #[cfg(not(test))] + _addr.do_send(msg) +} + +pub async fn send( + addr: Addr, + msg: M, + log: &Option, +) -> std::result::Result<::Result, actix::MailboxError> +where + M: actix::Message + Send + 'static + std::fmt::Debug, + RepoActor: actix::Handler, + ::Result: Send, +{ + let log_message = format!("send: {:?}", msg); + logger(log, log_message); + addr.send(msg).await +} + +pub fn logger(log: &Option, message: impl Into) { + if let Some(log) = log { + let message: String = message.into(); + tracing::debug!(message); + let _ = log.lock().map(|mut l| l.push(message)); } } diff --git a/crates/repo-actor/src/load.rs b/crates/repo-actor/src/load.rs index ff64e32..989bd00 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: &dyn git::repository::OpenRepositoryLike, -) { +) -> 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: &dyn git::repository::OpenRepositoryLike, -) -> Result { - let contents = open_repository.read_file(&details.branch, &PathBuf::from(".git-next.toml"))?; + let contents = + open_repository.read_file(&repo_details.branch, &PathBuf::from(".git-next.toml"))?; let config = config::RepoConfig::parse(&contents)?; - let config = validate(config, open_repository).await?; + let branches = open_repository.remote_branches()?; + required_branch(&config.branches().main(), &branches)?; + required_branch(&config.branches().next(), &branches)?; + required_branch(&config.branches().dev(), &branches)?; Ok(config) } -#[derive(Debug, derive_more::From, derive_more::Display)] +fn required_branch( + branch_name: &config::BranchName, + branches: &[config::BranchName], +) -> Result<()> { + branches + .iter() + .find(|branch| *branch == branch_name) + .ok_or_else(|| Error::BranchNotFound(branch_name.clone()))?; + Ok(()) +} + +pub type Result = 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: &dyn git::repository::OpenRepositoryLike, -) -> 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..69bbc18 --- /dev/null +++ b/crates/repo-actor/src/messages.rs @@ -0,0 +1,70 @@ +// +use config::newtype; +use derive_more::Display; + +use git_next_config as config; +use git_next_git as git; + +#[macro_export] +macro_rules! message { + ($name:ident wraps $value:ty) => { + git_next_config::newtype!($name is a $value); + impl actix::prelude::Message for $name { + type Result = (); + } + }; + ($name:ident) => { + git_next_config::newtype!($name); + impl actix::prelude::Message for $name { + type Result = (); + } + }; + ($name:ident wraps $value:ty => $result:ty) => { + git_next_config::newtype!($name is a $value); + impl actix::prelude::Message for $name { + type Result = $result; + } + }; + ($name:ident => $result:ty) => { + git_next_config::newtype!($name); + impl actix::prelude::Message for $name { + type Result = $result; + } + }; +} + +message!(LoadConfigFromRepo); +message!(CloneRepo); +message!(ReceiveRepoConfig wraps config::RepoConfig); +message!(ValidateRepo wraps MessageToken); + +message!(WebhookRegistered wraps (config::WebhookId, config::WebhookAuth)); +impl WebhookRegistered { + pub const fn webhook_id(&self) -> &config::WebhookId { + &self.0 .0 + } + pub const fn webhook_auth(&self) -> &config::WebhookAuth { + &self.0 .1 + } +} +impl From for WebhookRegistered { + fn from(value: config::RegisteredWebhook) -> Self { + let webhook_id = value.id().clone(); + let webhook_auth = value.auth().clone(); + Self::from((webhook_id, webhook_auth)) + } +} + +newtype!(MessageToken is a u32, Copy, Default, Display); +impl MessageToken { + pub const fn next(&self) -> Self { + Self(self.0 + 1) + } +} + +message!(RegisterWebhook); +message!(CheckCIStatus wraps git::Commit); // next commit +message!(ReceiveCIStatus wraps (git::Commit, git::forge::commit::Status)); // commit and it's status +message!(AdvanceNext wraps (git::Commit, Vec)); // next commit and the dev commit history +message!(AdvanceMain wraps git::Commit); // next commit +message!(WebhookNotification wraps config::webhook::forge_notification::ForgeNotification); 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..ddad1e3 100644 --- a/crates/repo-actor/src/tests.rs +++ b/crates/repo-actor/src/tests.rs @@ -1,34 +1,40 @@ // -use super::*; -mod branch { - use super::super::branch::*; - use super::*; +#![allow(unused_imports)] // TODO remove this - #[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 dev_commit_history = vec![ - git::Commit::new( - git::commit::Sha::new("dev".to_string()), - git::commit::Message::new("future".to_string()), - ), - expected.clone(), - next.clone(), - git::Commit::new( - git::commit::Sha::new("current-main".to_string()), - git::commit::Message::new("history".to_string()), - ), - ]; +use crate as actor; +use actix::prelude::*; +use actor::{ + messages::{CloneRepo, MessageToken, WebhookRegistered}, + RepoActor, RepoActorLog, +}; +use assert2::let_assert; +use config::{BranchName, RegisteredWebhook, RepoBranches, RepoConfig}; +use git::{ + repository::{ + open::MockOpenRepositoryLike, Direction, MockRepositoryFactory, RepositoryFactory, + }, + validation::remotes, + GitRemote, RepoDetails, +}; +use git_next_config as config; +use git_next_forge as forge; +use git_next_git as git; +use mockall::predicate::eq; +use std::{ + borrow::{Borrow, BorrowMut}, + cell::{Cell, RefCell}, + collections::HashMap, + path::PathBuf, + rc::Rc, + sync::{atomic::AtomicBool, Arc, Mutex}, +}; - let next_commit = find_next_commit_on_dev(next, dev_commit_history); +type TestResult = Result<(), Box>; - assert_eq!(next_commit, Some(expected), "Found the wrong commit"); - } -} +mod branch; +mod expect; +pub mod given; +mod handlers; +mod load; +pub mod then; +mod when; diff --git a/crates/repo-actor/src/tests/branch.rs b/crates/repo-actor/src/tests/branch.rs new file mode 100644 index 0000000..a64840d --- /dev/null +++ b/crates/repo-actor/src/tests/branch.rs @@ -0,0 +1,21 @@ +// +use super::*; + +mod advance_main; +mod advance_next; + +#[actix_rt::test] +async fn test_find_next_commit_on_dev() { + let next = given::a_commit(); + let expected = given::a_commit(); + let dev_commit_history = vec![ + given::a_commit(), // dev HEAD + expected.clone(), + next.clone(), // next - advancing towards dev HEAD + given::a_commit(), // parent of next + ]; + + let next_commit = actor::branch::find_next_commit_on_dev(&next, &dev_commit_history); + + assert_eq!(next_commit, Some(expected), "Found the wrong commit"); +} diff --git a/crates/repo-actor/src/tests/branch/advance_main.rs b/crates/repo-actor/src/tests/branch/advance_main.rs new file mode 100644 index 0000000..fcdf302 --- /dev/null +++ b/crates/repo-actor/src/tests/branch/advance_main.rs @@ -0,0 +1,35 @@ +// +use git::repository::{OnFetch, OnPush, OpenRepositoryLike}; + +use super::*; + +#[test] +fn push_is_error_should_error() { + let commit = given::a_commit(); + let fs = given::a_filesystem(); + let repo_config = given::a_repo_config(); + let (mut open_repository, repo_details) = given::an_open_repository(&fs); + expect::fetch_ok(&mut open_repository); + expect::push(&mut open_repository, Err(git::push::Error::Lock)); + let_assert!( + Err(err) = + actor::branch::advance_main(commit, &repo_details, &repo_config, &open_repository) + ); + assert!(matches!( + err, + actor::branch::Error::Push(git::push::Error::Lock) + )); +} + +#[test] +fn push_is_ok_should_ok() { + let commit = given::a_commit(); + let fs = given::a_filesystem(); + let repo_config = given::a_repo_config(); + let (mut open_repository, repo_details) = given::an_open_repository(&fs); + expect::fetch_ok(&mut open_repository); + expect::push_ok(&mut open_repository); + assert!( + actor::branch::advance_main(commit, &repo_details, &repo_config, &open_repository).is_ok() + ); +} diff --git a/crates/repo-actor/src/tests/branch/advance_next.rs b/crates/repo-actor/src/tests/branch/advance_next.rs new file mode 100644 index 0000000..f585aa7 --- /dev/null +++ b/crates/repo-actor/src/tests/branch/advance_next.rs @@ -0,0 +1,165 @@ +// +use super::*; +mod when_at_dev { + // next and dev branches are the same + use super::*; + #[test] + fn should_not_push() -> TestResult { + let next = given::a_commit(); + let dev_commit_history = &[next.clone()]; + let fs = given::a_filesystem(); + let repo_config = given::a_repo_config(); + let (open_repository, repo_details) = 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, + &open_repository, + message_token, + ) + ); + tracing::debug!("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::*; + #[test] + fn should_not_push() -> TestResult { + let next = given::a_commit(); + let dev = given::a_commit_with_message("wip: test: message".to_string()); + let dev_commit_history = &[dev, next.clone()]; + let fs = given::a_filesystem(); + let repo_config = given::a_repo_config(); + let (open_repository, repo_details) = 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, + &open_repository, + message_token, + ) + ); + tracing::debug!("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::*; + #[test] + fn should_not_push_and_error() -> TestResult { + let next = given::a_commit(); + let dev = given::a_commit(); + let dev_commit_history = &[dev, next.clone()]; + let fs = given::a_filesystem(); + let repo_config = given::a_repo_config(); + let (open_repository, repo_details) = 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, + &open_repository, + message_token, + ) + ); + tracing::debug!("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::*; + + #[test] + fn should_error() -> TestResult { + let next = given::a_commit(); + let dev = given::a_commit_with_message("test: message".to_string()); + let dev_commit_history = &[dev, next.clone()]; + let fs = given::a_filesystem(); + let repo_config = given::a_repo_config(); + let (mut open_repository, repo_details) = given::an_open_repository(&fs); + expect::fetch_ok(&mut open_repository); + expect::push(&mut open_repository, 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, + &open_repository, + message_token, + ) + ); + tracing::debug!("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::*; + #[test] + fn should_ok() -> TestResult { + let next = given::a_commit(); + let dev = given::a_commit_with_message("test: message".to_string()); + let dev_commit_history = &[dev, next.clone()]; + let fs = given::a_filesystem(); + let repo_config = given::a_repo_config(); + let (mut open_repository, repo_details) = given::an_open_repository(&fs); + expect::fetch_ok(&mut open_repository); + expect::push_ok(&mut open_repository); + let message_token = given::a_message_token(); + let_assert!( + Ok(mt) = actor::branch::advance_next( + &next, + dev_commit_history, + repo_details, + repo_config, + &open_repository, + message_token, + ) + ); + tracing::debug!("Got: {mt:?}"); + assert_eq!(mt, message_token); + Ok(()) + } + } + } +} diff --git a/crates/repo-actor/src/tests/expect.rs b/crates/repo-actor/src/tests/expect.rs new file mode 100644 index 0000000..8472f4d --- /dev/null +++ b/crates/repo-actor/src/tests/expect.rs @@ -0,0 +1,58 @@ +// +use super::*; + +use git::repository::MockRepositoryFactory; +use git_next_git::repository::open::MockOpenRepositoryLike; + +pub fn fetch_ok(open_repository: &mut MockOpenRepositoryLike) { + expect::fetch(open_repository, Ok(())); +} + +pub fn fetch(open_repository: &mut MockOpenRepositoryLike, result: Result<(), git::fetch::Error>) { + open_repository + .expect_fetch() + .times(1) + .return_once(|| result); +} + +pub fn push_ok(open_repository: &mut MockOpenRepositoryLike) { + expect::push(open_repository, Ok(())) +} + +pub fn push(open_repository: &mut MockOpenRepositoryLike, result: Result<(), git::push::Error>) { + open_repository + .expect_push() + .times(1) + .return_once(move |_, _, _, _| result); +} + +pub fn duplicate(open_repository: &mut MockOpenRepositoryLike, result: MockOpenRepositoryLike) { + open_repository + .expect_duplicate() + .times(1) + .return_once(move || Box::new(result)); +} + +pub fn open_repository( + repository_factory: &mut MockRepositoryFactory, + open_repository: MockOpenRepositoryLike, +) { + repository_factory + .expect_open() + .times(1) + .return_once(move |_| Ok(Box::new(open_repository))); +} + +pub fn main_commit_log( + validation_repo: &mut MockOpenRepositoryLike, + main_branch: config::BranchName, +) -> git::Commit { + let main_commit = given::a_commit(); + let main_branch_log = vec![main_commit.clone()]; + validation_repo + .expect_commit_log() + .times(1) + .with(eq(main_branch), eq([])) + .return_once(move |_, _| Ok(main_branch_log)); + main_commit +} diff --git a/crates/repo-actor/src/tests/given.rs b/crates/repo-actor/src/tests/given.rs new file mode 100644 index 0000000..4bd890c --- /dev/null +++ b/crates/repo-actor/src/tests/given.rs @@ -0,0 +1,366 @@ +// +#![allow(dead_code)] // TODO: remove this +#![allow(unused_imports)] // TODO: remove this + +use git_next_git::repository::RepositoryLike as _; +use mockall::predicate::eq; +use rand::RngCore; +use std::{ + collections::HashMap, + path::PathBuf, + sync::{Arc, Mutex}, +}; + +use super::*; +use config::{ + server::{Webhook, WebhookUrl}, + BranchName, ForgeAlias, ForgeConfig, ForgeType, GitDir, RepoAlias, RepoBranches, RepoConfig, + ServerRepoConfig, WebhookAuth, WebhookId, +}; +use git::{ + repository::{open::MockOpenRepositoryLike, Direction}, + Generation, GitRemote, MockForgeLike, RepoDetails, +}; + +pub fn has_all_valid_remote_defaults( + open_repository: &mut MockOpenRepositoryLike, + repo_details: &RepoDetails, +) { + has_remote_defaults( + open_repository, + HashMap::from([ + (Direction::Push, Some(repo_details.git_remote())), + (Direction::Fetch, Some(repo_details.git_remote())), + ]), + ); +} + +pub fn has_remote_defaults( + open_repository: &mut MockOpenRepositoryLike, + remotes: HashMap>, +) { + remotes.into_iter().for_each(|(direction, remote)| { + open_repository + .expect_find_default_remote() + .with(eq(direction)) + .return_once(|_| remote); + }); +} + +pub fn handles_validate_repo_message( + open_repository: &mut MockOpenRepositoryLike, + repo_branches: &RepoBranches, +) { + let validate_positions_open_repository = open_repository_for_validate_positions(repo_branches); + expect::duplicate(open_repository, validate_positions_open_repository); +} + +#[allow(clippy::type_complexity)] +pub fn open_repository_for_loading_config_from_repo( + repo_config: &RepoConfig, +) -> ( + MockOpenRepositoryLike, + Arc>>, +) { + let mut load_config_from_repo_open_repository = MockOpenRepositoryLike::new(); + let read_files = Arc::new(Mutex::new(vec![])); + let read_files_ref = read_files.clone(); + let branches = repo_config.branches().clone(); + load_config_from_repo_open_repository + .expect_read_file() + .return_once(move |branch_name, file_name| { + let branch_name = branch_name.clone(); + let file_name = file_name.to_path_buf(); + let _ = read_files_ref + .lock() + .map(move |mut l| l.push((branch_name, file_name))); + let contents = format!( + r#" + [branches] + main = "{}" + next = "{}" + dev = "{}" + "#, + branches.main(), + branches.next(), + branches.dev() + ); + Ok(contents) + }); + let branches = repo_config.branches().clone(); + let remote_branches = vec![branches.main(), branches.next(), branches.dev()]; + load_config_from_repo_open_repository + .expect_remote_branches() + .return_once(move || Ok(remote_branches)); + (load_config_from_repo_open_repository, read_files) +} + +pub fn open_repository_for_validate_positions(branches: &RepoBranches) -> MockOpenRepositoryLike { + let mut open_repository = MockOpenRepositoryLike::new(); + expect::fetch_ok(&mut open_repository); + let main_log = vec![given::a_commit()]; + let next_commit_log_filter = main_log.clone(); + let mut next_log: Vec = main_log.clone(); + next_log.extend(vec![given::a_commit()]); + let mut dev_log: Vec = next_log.clone(); + dev_log.extend(vec![given::a_commit()]); + + open_repository + .expect_commit_log() + .times(1) + .with(eq(branches.main()), eq([])) + .return_once(move |_, _| Ok(main_log)); + open_repository + .expect_commit_log() + .times(1) + .with(eq(branches.next()), eq(next_commit_log_filter.clone())) + .return_once(move |_, _| Ok(next_log)); + open_repository + .expect_commit_log() + .times(1) + .with(eq(branches.dev()), eq(next_commit_log_filter)) + .return_once(move |_, _| Ok(dev_log)); + open_repository +} + +pub fn a_webhook_auth() -> WebhookAuth { + WebhookAuth::generate() +} + +pub enum Header { + Valid(WebhookAuth, config::webhook::forge_notification::Body), + Missing, + Invalid, +} + +pub fn a_webhook_message_body() -> config::webhook::forge_notification::Body { + config::webhook::forge_notification::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(prefix: impl Into) -> BranchName { + BranchName::new(format!("{}-{}", prefix.into(), 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("main").to_string(); + let next = a_branch_name("next").to_string(); + let dev = a_branch_name("dev").to_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_named_commit(name: impl Into) -> git::Commit { + git::Commit::new(a_named_commit_sha(name), a_commit_message()) +} + +pub fn a_commit() -> git::Commit { + git::Commit::new(a_commit_sha(), a_commit_message()) +} + +pub fn a_commit_with_message(message: impl Into) -> git::Commit { + git::Commit::new(a_commit_sha(), message.into()) +} + +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_named_commit_sha(name: impl Into) -> git::commit::Sha { + git::commit::Sha::new(format!("{}-{}", name.into(), 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("webhook"); + 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::default(); + 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::open::MockOpenRepositoryLike, + git::RepoDetails, +) { + let open_repository = MockOpenRepositoryLike::new(); + let gitdir = given::a_git_dir(fs); + let hostname = given::a_hostname(); + let repo_details = given::repo_details(fs) + .with_gitdir(gitdir) + .with_hostname(hostname); + (open_repository, repo_details) +} + +pub fn a_message_token() -> MessageToken { + MessageToken::default() +} + +pub fn a_webhook(url: &WebhookUrl) -> Webhook { + Webhook::new(url.clone().into()) +} + +pub fn a_forge() -> Box { + Box::new(MockForgeLike::new()) +} + +pub fn a_repo_actor( + repo_details: git::RepoDetails, + repository_factory: Box, + forge: Box, + net: kxio::network::Network, +) -> (actor::RepoActor, RepoActorLog) { + let forge_alias = repo_details.forge.forge_alias(); + let repo_alias = &repo_details.repo_alias; + let webhook_url = given::a_webhook_url(forge_alias, repo_alias); + let webhook = given::a_webhook(&webhook_url); + let generation = Generation::default(); + let log = Arc::new(Mutex::new(vec![])); + let actors_log = log.clone(); + ( + actor::RepoActor::new( + repo_details, + forge, + webhook, + generation, + net, + repository_factory, + std::time::Duration::from_nanos(1), + ) + .with_log(actors_log), + log, + ) +} + +pub fn a_git_remote(repo_details: &git::RepoDetails) -> git::GitRemote { + let hostname = repo_details.forge.hostname().clone(); + let repo_path = repo_details.repo_path.clone(); + git::GitRemote::new(hostname, repo_path) +} + +pub fn a_hostname() -> config::Hostname { + config::Hostname::new(given::a_name()) +} + +pub fn a_repo_path() -> config::RepoPath { + config::RepoPath::new(given::a_name()) +} + +pub fn a_registered_webhook() -> RegisteredWebhook { + RegisteredWebhook::new(given::a_webhook_id(), given::a_webhook_auth()) +} diff --git a/crates/repo-actor/src/tests/handlers.rs b/crates/repo-actor/src/tests/handlers.rs new file mode 100644 index 0000000..6796547 --- /dev/null +++ b/crates/repo-actor/src/tests/handlers.rs @@ -0,0 +1,13 @@ +// +use super::*; +use actix::prelude::*; + +mod advance_main; +mod advance_next; +mod check_ci_status; +mod clone_repo; +mod load_config_from_repo; +mod loaded_config; +mod receive_ci_status; +mod register_webhook; +mod validate_repo; diff --git a/crates/repo-actor/src/tests/handlers/advance_main.rs b/crates/repo-actor/src/tests/handlers/advance_main.rs new file mode 100644 index 0000000..ee8a403 --- /dev/null +++ b/crates/repo-actor/src/tests/handlers/advance_main.rs @@ -0,0 +1,86 @@ +// +use super::*; + +#[actix::test] +async fn when_repo_config_should_fetch_then_push_then_revalidate() -> TestResult { + //given + let fs = given::a_filesystem(); + let (mut open_repository, mut repo_details) = given::an_open_repository(&fs); + + // config from repo + #[allow(clippy::unwrap_used)] + let repo_config = repo_details.repo_config.take().unwrap(); + repo_details.repo_config = Some(repo_config.with_source(config::RepoConfigSource::Repo)); + + let next_commit = given::a_commit_with_message("feat: next".to_string()); + + let mut seq = mockall::Sequence::new(); + open_repository + .expect_fetch() + .times(1) + .in_sequence(&mut seq) + .return_once(|| Ok(())); + open_repository + .expect_push() + .times(1) + .in_sequence(&mut seq) + .return_once(|_, _, _, _| Ok(())); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(actor::messages::AdvanceMain::new(next_commit.clone())) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + assert!(l + .iter() + .any(|message| message.contains("send: LoadConfigFromRepo"))) + })?; + Ok(()) +} + +#[actix::test] +async fn when_server_config_should_fetch_then_push_then_revalidate() -> TestResult { + //given + let fs = given::a_filesystem(); + let (mut open_repository, mut repo_details) = given::an_open_repository(&fs); + + // config from server + #[allow(clippy::unwrap_used)] + let repo_config = repo_details.repo_config.take().unwrap(); + repo_details.repo_config = Some(repo_config.with_source(config::RepoConfigSource::Server)); + + let next_commit = given::a_commit_with_message("feat: next".to_string()); + + let mut seq = mockall::Sequence::new(); + open_repository + .expect_fetch() + .times(1) + .in_sequence(&mut seq) + .return_once(|| Ok(())); + open_repository + .expect_push() + .times(1) + .in_sequence(&mut seq) + .return_once(|_, _, _, _| Ok(())); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(actor::messages::AdvanceMain::new(next_commit.clone())) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + assert!(l + .iter() + .any(|message| message.contains("send: ValidateRepo"))) + })?; + Ok(()) +} diff --git a/crates/repo-actor/src/tests/handlers/advance_next.rs b/crates/repo-actor/src/tests/handlers/advance_next.rs new file mode 100644 index 0000000..6d3405d --- /dev/null +++ b/crates/repo-actor/src/tests/handlers/advance_next.rs @@ -0,0 +1,46 @@ +// +use super::*; + +#[actix::test] +async fn should_fetch_then_push_then_revalidate() -> TestResult { + //given + let fs = given::a_filesystem(); + let (mut open_repository, repo_details) = given::an_open_repository(&fs); + let next_commit = given::a_commit_with_message("feat: next".to_string()); + let dev_commit_log = vec![ + given::a_commit_with_message("feat: dev".to_string()), + given::a_commit_with_message("feat: target".to_string()), + next_commit.clone(), + ]; + + let mut seq = mockall::Sequence::new(); + open_repository + .expect_fetch() + .times(1) + .in_sequence(&mut seq) + .return_once(|| Ok(())); + open_repository + .expect_push() + .times(1) + .in_sequence(&mut seq) + .return_once(|_, _, _, _| Ok(())); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(actor::messages::AdvanceNext::new(( + next_commit.clone(), + dev_commit_log, + ))) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + assert!(l + .iter() + .any(|message| message.contains("send: ValidateRepo"))) + })?; + Ok(()) +} diff --git a/crates/repo-actor/src/tests/handlers/check_ci_status.rs b/crates/repo-actor/src/tests/handlers/check_ci_status.rs new file mode 100644 index 0000000..b3180b0 --- /dev/null +++ b/crates/repo-actor/src/tests/handlers/check_ci_status.rs @@ -0,0 +1,32 @@ +// +use super::*; + +#[actix::test] +async fn should_passthrough_to_receive_ci_status() -> TestResult { + //given + let fs = given::a_filesystem(); + let (open_repository, repo_details) = given::an_open_repository(&fs); + let next_commit = given::a_named_commit("next"); + let mut forge = git::MockForgeLike::new(); + when::commit_status( + &mut forge, + next_commit.clone(), + git::forge::commit::Status::Pass, + ); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, Box::new(forge)); + addr.send(actor::messages::CheckCIStatus::new(next_commit.clone())) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + assert!(l + .iter() + .any(|message| message.contains("send: ReceiveCIStatus"))) + })?; + Ok(()) +} diff --git a/crates/repo-actor/src/tests/handlers/clone_repo.rs b/crates/repo-actor/src/tests/handlers/clone_repo.rs new file mode 100644 index 0000000..81495b7 --- /dev/null +++ b/crates/repo-actor/src/tests/handlers/clone_repo.rs @@ -0,0 +1,208 @@ +// + +use super::*; + +#[actix::test] +async fn should_clone() -> TestResult { + //given + let fs = given::a_filesystem(); + let (mut open_repository, /* mut */ repo_details) = given::an_open_repository(&fs); + // #[allow(clippy::unwrap_used)] + // let repo_config = repo_details.repo_config.take().unwrap(); + + given::has_all_valid_remote_defaults(&mut open_repository, &repo_details); + // handles_validate_repo_message(&mut open_repository, repo_config.branches()); + + // factory clones an open repository + let mut repository_factory = MockRepositoryFactory::new(); + let cloned = Arc::new(Mutex::new(vec![])); + let cloned_ref = cloned.clone(); + repository_factory + .expect_git_clone() + .times(2) + .return_once(move |_| { + let _ = cloned_ref.lock().map(|mut l| l.push(())); + Ok(Box::new(open_repository)) + }); + + //when + let (addr, _log) = when::start_actor(repository_factory, repo_details, given::a_forge()); + addr.send(CloneRepo::new()).await?; + System::current().stop(); + + //then + cloned + .lock() + .map_err(|e| e.to_string()) + .map(|o| assert_eq!(o.len(), 1))?; + + Ok(()) +} + +#[actix::test] +async fn should_open() -> TestResult { + //given + let fs = given::a_filesystem(); + let (mut open_repository, /* mut */ repo_details) = given::an_open_repository(&fs); + // #[allow(clippy::unwrap_used)] + // let repo_config = repo_details.repo_config.take().unwrap(); + + given::has_all_valid_remote_defaults(&mut open_repository, &repo_details); + // handles_validate_repo_message(&mut open_repository, repo_config.branches()); + + // factory opens a repository + let mut repository_factory = MockRepositoryFactory::new(); + let opened = Arc::new(Mutex::new(vec![])); + let opened_ref = opened.clone(); + repository_factory + .expect_open() + .times(1) + .return_once(move |_| { + let _ = opened_ref.lock().map(|mut l| l.push(())); + Ok(Box::new(open_repository)) + }); + fs.dir_create(&repo_details.gitdir)?; + + //when + let (addr, _log) = when::start_actor(repository_factory, repo_details, given::a_forge()); + addr.send(CloneRepo::new()).await?; + System::current().stop(); + + //then + opened + .lock() + .map_err(|e| e.to_string()) + .map(|o| assert_eq!(o.len(), 1))?; + + Ok(()) +} + +/// The server config can optionally include the names of the main, next and dev +/// branches. When it doesn't we should load the .git-next.yaml from from the +/// repo and get the branch names from there. +#[actix::test] +async fn when_server_has_no_repo_config_load_from_repo_and_validate() -> TestResult { + //given + let fs = given::a_filesystem(); + let (mut open_repository, mut repo_details) = given::an_open_repository(&fs); + #[allow(clippy::unwrap_used)] + let repo_config = repo_details.repo_config.take().unwrap(); + + given::has_all_valid_remote_defaults(&mut open_repository, &repo_details); + + // load config from repo + let (load_config_from_repo_open_repository, read_files) = + given::open_repository_for_loading_config_from_repo(&repo_config); + expect::duplicate(&mut open_repository, load_config_from_repo_open_repository); + + // handles_validate_repo_message(&mut open_repository, repo_config.branches()); + + let mut repository_factory = MockRepositoryFactory::new(); + expect::open_repository(&mut repository_factory, open_repository); + fs.dir_create(&repo_details.gitdir)?; + let branch = repo_details.branch.clone(); + + //when + let (addr, _log) = when::start_actor(repository_factory, repo_details, given::a_forge()); + addr.send(CloneRepo::new()).await?; + System::current().stop(); + + //then + tracing::debug!("{read_files:#?}"); + let file_name = PathBuf::from(".git-next.toml".to_string()); + read_files + .lock() + .map_err(|e| e.to_string()) + .map(|files| assert_eq!(files.clone(), vec![(branch, file_name)]))?; + + Ok(()) +} + +#[test_log::test(actix::test)] +async fn opened_repo_with_no_default_push_should_not_proceed() -> TestResult { + //given + let fs = given::a_filesystem(); + let (mut open_repository, repo_details) = given::an_open_repository(&fs); + + given::has_remote_defaults( + &mut open_repository, + HashMap::from([ + (Direction::Push, None), + (Direction::Fetch, Some(repo_details.git_remote())), + ]), + ); + + let mut repository_factory = MockRepositoryFactory::new(); + expect::open_repository(&mut repository_factory, open_repository); + fs.dir_create(&repo_details.gitdir)?; + + //when + let (addr, log) = when::start_actor(repository_factory, repo_details, given::a_forge()); + addr.send(CloneRepo::new()).await?; + System::current().stop(); + + //then + log.lock() + .map_err(|e| e.to_string()) + // doesn't log that it sent any messages to load config or validate the repo + .map(|l| assert_eq!(l.clone(), vec!["open failed"]))?; + + Ok(()) +} + +#[test_log::test(actix::test)] +async fn opened_repo_with_no_default_fetch_should_not_proceed() -> TestResult { + //given + let fs = given::a_filesystem(); + let (mut open_repository, repo_details) = given::an_open_repository(&fs); + + given::has_remote_defaults( + &mut open_repository, + HashMap::from([ + (Direction::Push, Some(repo_details.git_remote())), + (Direction::Fetch, None), + ]), + ); + + let mut repository_factory = MockRepositoryFactory::new(); + expect::open_repository(&mut repository_factory, open_repository); + fs.dir_create(&repo_details.gitdir)?; + + //when + let (addr, log) = when::start_actor(repository_factory, repo_details, given::a_forge()); + addr.send(CloneRepo::new()).await?; + System::current().stop(); + + //then + log.lock() + .map_err(|e| e.to_string()) + // doesn't log that it sent any messages to load config or validate the repo + .map(|l| assert_eq!(l.clone(), vec!["open failed"]))?; + + Ok(()) +} + +#[test_log::test(actix::test)] +async fn valid_repo_with_default_remotes_should_assess_branch_positions() -> TestResult { + //given + let fs = given::a_filesystem(); + let (mut open_repository, repo_details) = given::an_open_repository(&fs); + + given::has_all_valid_remote_defaults(&mut open_repository, &repo_details); + + let mut repository_factory = MockRepositoryFactory::new(); + expect::open_repository(&mut repository_factory, open_repository); + fs.dir_create(&repo_details.gitdir)?; + + //when + let (addr, log) = when::start_actor(repository_factory, repo_details, given::a_forge()); + addr.send(CloneRepo::new()).await?; + System::current().stop(); + + //then + log.lock() + .map_err(|e| e.to_string()) + .map(|l| assert!(l.iter().any(|l| l.contains("send: ValidateRepo"))))?; + + Ok(()) +} diff --git a/crates/repo-actor/src/tests/handlers/load_config_from_repo.rs b/crates/repo-actor/src/tests/handlers/load_config_from_repo.rs new file mode 100644 index 0000000..174e552 --- /dev/null +++ b/crates/repo-actor/src/tests/handlers/load_config_from_repo.rs @@ -0,0 +1,86 @@ +// +use super::*; + +#[actix::test] +async fn when_read_file_ok_should_send_config_loaded() -> TestResult { + //given + let fs = given::a_filesystem(); + let (mut open_repository, repo_details) = given::an_open_repository(&fs); + let mut load_config_open_repo = MockOpenRepositoryLike::new(); + let branches = given::repo_branches(); + let remote_branches = vec![branches.main(), branches.next(), branches.dev()]; + load_config_open_repo + .expect_read_file() + .return_once(move |_, _| { + Ok(format!( + r#" + [branches] + main = "{}" + next = "{}" + dev = "{}" + "#, + branches.main(), + branches.next(), + branches.dev() + )) + }); + + load_config_open_repo + .expect_remote_branches() + .return_once(|| Ok(remote_branches)); + + open_repository + .expect_duplicate() + .return_once(|| Box::new(load_config_open_repo)); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(actor::messages::LoadConfigFromRepo::new()) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + assert!(l + .iter() + .any(|message| message.contains("send: LoadedConfig"))) + })?; + Ok(()) +} + +#[actix::test] +#[ignore] //TODO: (#95) should notify user +async fn when_read_file_err_should_notify_user() -> TestResult { + //given + let fs = given::a_filesystem(); + let (mut open_repository, repo_details) = given::an_open_repository(&fs); + let mut load_config_open_repo = MockOpenRepositoryLike::new(); + load_config_open_repo + .expect_read_file() + .return_once(move |_, _| Err(git::file::Error::FileNotFound)); + + open_repository + .expect_duplicate() + .return_once(|| Box::new(load_config_open_repo)); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(actor::messages::LoadConfigFromRepo::new()) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + assert!(l.iter().any(|message| message.contains("send: NotifyUser"))); + assert!( + !l.iter() + .any(|message| message.contains("send: LoadedConfig")), + "not send LoadedConfig" + ); + })?; + Ok(()) +} diff --git a/crates/repo-actor/src/tests/handlers/loaded_config.rs b/crates/repo-actor/src/tests/handlers/loaded_config.rs new file mode 100644 index 0000000..cb0b6fb --- /dev/null +++ b/crates/repo-actor/src/tests/handlers/loaded_config.rs @@ -0,0 +1,95 @@ +// +use super::*; +use actix::prelude::*; + +#[actix::test] +async fn should_store_repo_config_in_actor() -> TestResult { + //given + let fs = given::a_filesystem(); + let (open_repository, repo_details) = given::an_open_repository(&fs); + + let new_repo_config = given::a_repo_config(); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(actor::messages::ReceiveRepoConfig::new( + new_repo_config.clone(), + )) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + + let repo_config = addr.send(TakeRepoConfig).await?; + assert_eq!(repo_config, Some(new_repo_config)); + Ok(()) +} + +#[actix::test] +async fn should_validate_repo() -> TestResult { + //given + let fs = given::a_filesystem(); + let (open_repository, repo_details) = given::an_open_repository(&fs); + + let new_repo_config = given::a_repo_config(); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(actor::messages::ReceiveRepoConfig::new( + new_repo_config.clone(), + )) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + assert!(l + .iter() + .any(|message| message.contains("send: ValidateRepo"))) + })?; + Ok(()) +} + +#[actix::test] +async fn should_register_webhook() -> TestResult { + //given + let fs = given::a_filesystem(); + let (open_repository, repo_details) = given::an_open_repository(&fs); + + let new_repo_config = given::a_repo_config(); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(actor::messages::ReceiveRepoConfig::new( + new_repo_config.clone(), + )) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + assert!(l + .iter() + .any(|message| message.contains("send: RegisterWebhook"))) + })?; + Ok(()) +} + +actor::message!(TakeRepoConfig => Option); + +impl Handler for actor::RepoActor { + type Result = Option; + + fn handle(&mut self, _msg: TakeRepoConfig, _ctx: &mut Self::Context) -> Self::Result { + tracing::debug!("TakeRepoConfig >>"); + let repo_config = self.repo_details.repo_config.take(); + tracing::debug!(?repo_config, "TakeRepoConfig <<"); + repo_config + } +} diff --git a/crates/repo-actor/src/tests/handlers/receive_ci_status.rs b/crates/repo-actor/src/tests/handlers/receive_ci_status.rs new file mode 100644 index 0000000..8aa096a --- /dev/null +++ b/crates/repo-actor/src/tests/handlers/receive_ci_status.rs @@ -0,0 +1,82 @@ +// +use super::*; + +#[actix::test] +async fn when_pass_should_advance_main_to_next() -> TestResult { + //given + let fs = given::a_filesystem(); + let (open_repository, repo_details) = given::an_open_repository(&fs); + let next_commit = given::a_named_commit("next"); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(actor::messages::ReceiveCIStatus::new(( + next_commit.clone(), + git::forge::commit::Status::Pass, + ))) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + let expected = format!("send: AdvanceMain({:?})", next_commit); + tracing::debug!(%expected,""); + assert!(l.iter().any(|message| message.contains(&expected))) + })?; + Ok(()) +} + +#[actix::test] +async fn when_pending_should_recheck_ci_status() -> TestResult { + //given + let fs = given::a_filesystem(); + let (open_repository, repo_details) = given::an_open_repository(&fs); + let next_commit = given::a_named_commit("next"); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(actor::messages::ReceiveCIStatus::new(( + next_commit.clone(), + git::forge::commit::Status::Pending, + ))) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + assert!(l + .iter() + .any(|message| message.contains("send: ValidateRepo"))) + })?; + Ok(()) +} + +#[actix::test] +#[ignore] //TODO: (#95) should notify user +async fn when_fail_should_notify_user() -> TestResult { + //given + let fs = given::a_filesystem(); + let (open_repository, repo_details) = given::an_open_repository(&fs); + let next_commit = given::a_named_commit("next"); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(actor::messages::ReceiveCIStatus::new(( + next_commit.clone(), + git::forge::commit::Status::Fail, + ))) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock() + .map_err(|e| e.to_string()) + .map(|l| assert!(l.iter().any(|message| message.contains("send: NotifyUser"))))?; + Ok(()) +} diff --git a/crates/repo-actor/src/tests/handlers/register_webhook.rs b/crates/repo-actor/src/tests/handlers/register_webhook.rs new file mode 100644 index 0000000..a9eddcb --- /dev/null +++ b/crates/repo-actor/src/tests/handlers/register_webhook.rs @@ -0,0 +1,64 @@ +// +use super::*; + +#[actix::test] +async fn when_registered_ok_should_send_webhook_registered() -> TestResult { + //given + let fs = given::a_filesystem(); + let (open_repository, repo_details) = given::an_open_repository(&fs); + + let registered_webhook = given::a_registered_webhook(); + let mut my_forge = git::MockForgeLike::new(); + my_forge + .expect_register_webhook() + .return_once(move |_| Ok(registered_webhook)); + + let mut forge = git::MockForgeLike::new(); + forge.expect_duplicate().return_once(|| Box::new(my_forge)); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, Box::new(forge)); + addr.send(actor::messages::RegisterWebhook::new()).await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + assert!(l + .iter() + .any(|message| message.contains("send: WebhookRegistered"))) + })?; + Ok(()) +} + +#[actix::test] +#[ignore] //TODO: (#95) should notify user +async fn when_registered_error_should_send_notify_user() -> TestResult { + //given + let fs = given::a_filesystem(); + let (open_repository, repo_details) = given::an_open_repository(&fs); + + let mut my_forge = git::MockForgeLike::new(); + my_forge.expect_register_webhook().return_once(move |_| { + Err(git::forge::webhook::Error::FailedToRegister( + "foo".to_string(), + )) + }); + + let mut forge = git::MockForgeLike::new(); + forge.expect_duplicate().return_once(|| Box::new(my_forge)); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, Box::new(forge)); + addr.send(actor::messages::RegisterWebhook::new()).await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock() + .map_err(|e| e.to_string()) + .map(|l| assert!(l.iter().any(|message| message.contains("send: NotifyUser"))))?; + Ok(()) +} diff --git a/crates/repo-actor/src/tests/handlers/validate_repo.rs b/crates/repo-actor/src/tests/handlers/validate_repo.rs new file mode 100644 index 0000000..6860fa4 --- /dev/null +++ b/crates/repo-actor/src/tests/handlers/validate_repo.rs @@ -0,0 +1,375 @@ +// +use crate::messages::{MessageToken, ValidateRepo}; + +use super::*; + +#[test_log::test(actix::test)] +async fn repo_with_next_not_an_ancestor_of_dev_should_be_reset() -> TestResult { + //given + let fs = given::a_filesystem(); + let (mut open_repository, repo_details) = given::an_open_repository(&fs); + #[allow(clippy::unwrap_used)] + let repo_config = repo_details.repo_config.clone().unwrap(); + expect::fetch_ok(&mut open_repository); + let branches = repo_config.branches(); + // commit_log main + let main_commit = expect::main_commit_log(&mut open_repository, branches.main()); + // next - based on main + let next_branch_log = vec![given::a_commit(), main_commit.clone()]; + // dev - based on main, but not on next + let dev_branch_log = vec![given::a_commit(), main_commit.clone()]; + // commit_log next - based on main, but not a parent of dev + open_repository + .expect_commit_log() + .times(1) + .with(eq(branches.next()), eq([main_commit.clone()])) + .return_once(move |_, _| Ok(next_branch_log)); + // commit_log dev + open_repository + .expect_commit_log() + .times(1) + .with(eq(branches.dev()), eq([main_commit])) + .return_once(|_, _| Ok(dev_branch_log)); + // expect to reset the branch + expect::fetch_ok(&mut open_repository); + expect::push_ok(&mut open_repository); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(crate::messages::ValidateRepo::new(MessageToken::default())) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + assert!(l + .iter() + .any(|message| message.contains("NextBranchResetRequired"))) + })?; + Ok(()) +} + +#[test_log::test(actix::test)] +async fn repo_with_next_not_on_or_near_main_should_be_reset() -> TestResult { + //given + let fs = given::a_filesystem(); + let (mut open_repository, repo_details) = given::an_open_repository(&fs); + #[allow(clippy::unwrap_used)] + let repo_config = repo_details.repo_config.clone().unwrap(); + expect::fetch_ok(&mut open_repository); + let branches = repo_config.branches(); + // commit_log main + let main_commit = expect::main_commit_log(&mut open_repository, branches.main()); + // next - based on main, but too far in advance + let next_branch_log = vec![given::a_commit(), given::a_commit(), main_commit.clone()]; + // dev - based on next + let mut dev_branch_log = vec![given::a_commit()]; + dev_branch_log.extend(next_branch_log.clone()); + // commit_log next + open_repository + .expect_commit_log() + .times(1) + .with(eq(branches.next()), eq([main_commit.clone()])) + .return_once(move |_, _| Ok(next_branch_log)); + // commit_log dev + open_repository + .expect_commit_log() + .times(1) + .with(eq(branches.dev()), eq([main_commit])) + .return_once(|_, _| Ok(dev_branch_log)); + expect::fetch_ok(&mut open_repository); + expect::push_ok(&mut open_repository); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(crate::messages::ValidateRepo::new(MessageToken::default())) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + assert!(l + .iter() + .any(|message| message.contains("NextBranchResetRequired"))) + })?; + Ok(()) +} + +#[test_log::test(actix::test)] +async fn repo_with_next_not_based_on_main_should_be_reset() -> TestResult { + //given + let fs = given::a_filesystem(); + let (mut open_repository, repo_details) = given::an_open_repository(&fs); + #[allow(clippy::unwrap_used)] + let repo_config = repo_details.repo_config.clone().unwrap(); + // given::has_all_valid_remote_defaults(&mut open_repository, &repo_details); + expect::fetch_ok(&mut open_repository); + let branches = repo_config.branches(); + // commit_log main + let main_commit = expect::main_commit_log(&mut open_repository, branches.main()); + // next - not based on main + let next_branch_log = vec![given::a_commit(), given::a_commit(), given::a_commit()]; + // dev - based on main + let dev_branch_log = vec![given::a_commit(), main_commit.clone()]; + // commit_log next + open_repository + .expect_commit_log() + .times(1) + .with(eq(branches.next()), eq([main_commit.clone()])) + .return_once(move |_, _| Ok(next_branch_log)); + // commit_log dev + open_repository + .expect_commit_log() + .times(1) + .with(eq(branches.dev()), eq([main_commit])) + .return_once(|_, _| Ok(dev_branch_log)); + expect::fetch_ok(&mut open_repository); + expect::push_ok(&mut open_repository); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(crate::messages::ValidateRepo::new(MessageToken::default())) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + assert!(l + .iter() + .any(|message| message.contains("NextBranchResetRequired"))) + })?; + Ok(()) +} + +#[test_log::test(actix::test)] +async fn repo_with_next_ahead_of_main_should_check_ci_status() -> TestResult { + //given + let fs = given::a_filesystem(); + let (mut open_repository, repo_details) = given::an_open_repository(&fs); + #[allow(clippy::unwrap_used)] + let repo_config = repo_details.repo_config.clone().unwrap(); + // Validate repo branches + expect::fetch_ok(&mut open_repository); + let branches = repo_config.branches(); + // commit_log main + let main_commit = expect::main_commit_log(&mut open_repository, branches.main()); + // next - ahead of main + let next_commit = given::a_named_commit("next"); + let next_branch_log = vec![next_commit.clone(), main_commit.clone()]; + // dev - on next + let dev_branch_log = next_branch_log.clone(); + // commit_log next + open_repository + .expect_commit_log() + .times(1) + .with(eq(branches.next()), eq([main_commit.clone()])) + .return_once(move |_, _| Ok(next_branch_log)); + // commit_log dev + open_repository + .expect_commit_log() + .times(1) + .with(eq(branches.dev()), eq([main_commit])) + .return_once(|_, _| Ok(dev_branch_log)); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(crate::messages::ValidateRepo::new(MessageToken::default())) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + let expected = format!("send: CheckCIStatus({next_commit:?})"); + assert!(l.iter().any(|message| message.contains(&expected))) + })?; + Ok(()) +} + +#[test_log::test(actix::test)] +async fn repo_with_dev_and_next_on_main_should_do_nothing() -> TestResult { + // Do nothing, when the situation changes we will hear about it via a webhook + //given + let fs = given::a_filesystem(); + let (mut open_repository, repo_details) = given::an_open_repository(&fs); + #[allow(clippy::unwrap_used)] + let repo_config = repo_details.repo_config.clone().unwrap(); + // Validate repo branches + expect::fetch_ok(&mut open_repository); + let branches = repo_config.branches(); + // commit_log main + let main_commit = expect::main_commit_log(&mut open_repository, branches.main()); + // next - on main + let next_branch_log = vec![main_commit.clone(), given::a_commit()]; + // dev - on next + let dev_branch_log = next_branch_log.clone(); + // commit_log next + open_repository + .expect_commit_log() + .times(1) + .with(eq(branches.next()), eq([main_commit.clone()])) + .return_once(move |_, _| Ok(next_branch_log)); + // commit_log dev + let dev_commit_log = dev_branch_log.clone(); + open_repository + .expect_commit_log() + .times(1) + .with(eq(branches.dev()), eq([main_commit])) + .return_once(move |_, _| Ok(dev_commit_log)); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(crate::messages::ValidateRepo::new(MessageToken::default())) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock() + .map_err(|e| e.to_string()) + .map(|l| assert!(!l.iter().any(|message| message.contains("send:"))))?; + Ok(()) +} + +#[test_log::test(actix::test)] +async fn repo_with_dev_ahead_of_next_should_advance_next() -> TestResult { + //given + let fs = given::a_filesystem(); + let (mut open_repository, repo_details) = given::an_open_repository(&fs); + #[allow(clippy::unwrap_used)] + let repo_config = repo_details.repo_config.clone().unwrap(); + // Validate repo branches + expect::fetch_ok(&mut open_repository); + let branches = repo_config.branches(); + // commit_log main + let main_commit = expect::main_commit_log(&mut open_repository, branches.main()); + // next - on main + let next_commit = main_commit.clone(); + let next_branch_log = vec![main_commit.clone(), given::a_commit()]; + // dev - ahead of next + let dev_commit = given::a_named_commit("dev"); + let dev_branch_log = vec![dev_commit, main_commit.clone()]; + // commit_log next + open_repository + .expect_commit_log() + .times(1) + .with(eq(branches.next()), eq([main_commit.clone()])) + .return_once(move |_, _| Ok(next_branch_log)); + // commit_log dev + let dev_commit_log = dev_branch_log.clone(); + open_repository + .expect_commit_log() + .times(1) + .with(eq(branches.dev()), eq([main_commit])) + .return_once(move |_, _| Ok(dev_commit_log)); + + //when + let (addr, log) = + when::start_actor_with_open_repository(open_repository, repo_details, given::a_forge()); + addr.send(crate::messages::ValidateRepo::new(MessageToken::default())) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + let expected = format!("send: AdvanceNext(({next_commit:?}, {dev_branch_log:?}))"); + assert!(l.iter().any(|message| message.contains(&expected))) + })?; + Ok(()) +} + +// TODO: (#95) test: repo with dev not a child of main should notify user + +#[test_log::test(actix::test)] +async fn should_accept_message_with_current_token() -> TestResult { + //given + let fs = given::a_filesystem(); + let repo_details = given::repo_details(&fs); + + //when + let (actor, log) = given::a_repo_actor( + repo_details, + git::repository::mock(), + given::a_forge(), + given::a_network().into(), + ); + let actor = actor.with_message_token(MessageToken::new(2_u32)); + let addr = actor.start(); + addr.send(crate::messages::ValidateRepo::new(MessageToken::new(2_u32))) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + assert!(l + .iter() + .any(|message| message.contains("accepted token: 2"))) + })?; + Ok(()) +} + +#[test_log::test(actix::test)] +async fn should_accept_message_with_new_token() -> TestResult { + //given + let fs = given::a_filesystem(); + let repo_details = given::repo_details(&fs); + + //when + let (actor, log) = given::a_repo_actor( + repo_details, + git::repository::mock(), + given::a_forge(), + given::a_network().into(), + ); + let actor = actor.with_message_token(MessageToken::new(2_u32)); + let addr = actor.start(); + addr.send(crate::messages::ValidateRepo::new(MessageToken::new(3_u32))) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock().map_err(|e| e.to_string()).map(|l| { + assert!(l + .iter() + .any(|message| message.contains("accepted token: 3"))) + })?; + Ok(()) +} + +#[test_log::test(actix::test)] +async fn should_reject_message_with_expired_token() -> TestResult { + //given + let fs = given::a_filesystem(); + let repo_details = given::repo_details(&fs); + + //when + let (actor, log) = given::a_repo_actor( + repo_details, + git::repository::mock(), + given::a_forge(), + given::a_network().into(), + ); + let actor = actor.with_message_token(MessageToken::new(4_u32)); + let addr = actor.start(); + addr.send(crate::messages::ValidateRepo::new(MessageToken::new(3_u32))) + .await?; + System::current().stop(); + + //then + tracing::debug!(?log, ""); + log.lock() + .map_err(|e| e.to_string()) + .map(|l| assert!(!l.iter().any(|message| message.contains("accepted token"))))?; + Ok(()) +} diff --git a/crates/repo-actor/src/tests/load.rs b/crates/repo-actor/src/tests/load.rs new file mode 100644 index 0000000..0d0ab3a --- /dev/null +++ b/crates/repo-actor/src/tests/load.rs @@ -0,0 +1,183 @@ +// +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 (mut open_repository, repo_details) = given::an_open_repository(&fs); + open_repository + .expect_read_file() + .returning(|_, _| Err(git::file::Error::FileNotFound)); + //when + let_assert!( + Err(err) = actor::load::config_from_repository(repo_details, &open_repository).await + ); + //then + tracing::debug!("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 (mut open_repository, repo_details) = given::an_open_repository(&fs); + let contents = given::a_name(); // not a valid file content + open_repository + .expect_read_file() + .return_once(move |_, _| Ok(contents)); + //when + let_assert!( + Err(err) = actor::load::config_from_repository(repo_details, &open_repository).await + ); + //then + tracing::debug!("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 (mut open_repository, repo_details) = given::an_open_repository(&fs); + 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}" + "# + ); + open_repository + .expect_read_file() + .return_once(|_, _| Ok(contents)); + let branches = vec![next, dev]; + open_repository + .expect_remote_branches() + .return_once(move || Ok(branches)); + //when + let_assert!( + Err(err) = actor::load::config_from_repository(repo_details, &open_repository).await + ); + //then + tracing::debug!("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 (mut open_repository, repo_details) = given::an_open_repository(&fs); + 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}" + "# + ); + open_repository + .expect_read_file() + .return_once(|_, _| Ok(contents)); + let branches = vec![main, dev]; + open_repository + .expect_remote_branches() + .return_once(move || Ok(branches)); + //when + let_assert!( + Err(err) = actor::load::config_from_repository(repo_details, &open_repository).await + ); + //then + tracing::debug!("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 (mut open_repository, repo_details) = given::an_open_repository(&fs); + 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}" + "# + ); + open_repository + .expect_read_file() + .return_once(move |_, _| Ok(contents)); + let branches = vec![main, next]; + open_repository + .expect_remote_branches() + .return_once(move || Ok(branches)); + //when + let_assert!( + Err(err) = actor::load::config_from_repository(repo_details, &open_repository).await + ); + //then + tracing::debug!("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 (mut open_repository, repo_details) = given::an_open_repository(&fs); + 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}" + "# + ); + open_repository + .expect_read_file() + .return_once(move |_, _| Ok(contents)); + let branches = vec![main, next, dev]; + open_repository + .expect_remote_branches() + .return_once(move || Ok(branches)); + //when + let_assert!( + Ok(result) = actor::load::config_from_repository(repo_details, &open_repository).await + ); + //then + tracing::debug!("Got: {result:?}"); + assert_eq!(result, repo_config); + Ok(()) +} diff --git a/crates/repo-actor/src/tests/then.rs b/crates/repo-actor/src/tests/then.rs new file mode 100644 index 0000000..e070c07 --- /dev/null +++ b/crates/repo-actor/src/tests/then.rs @@ -0,0 +1,168 @@ +// +#![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 { + tracing::debug!("== {label}"); + match output { + Ok(output) => { + tracing::debug!( + "\nstdout:\n{}\nstderr:\n{}", + String::from_utf8_lossy(output.stdout.as_slice()), + String::from_utf8_lossy(output.stderr.as_slice()) + ); + Ok(()) + } + Err(err) => { + tracing::debug!("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/repo-actor/src/tests/when.rs b/crates/repo-actor/src/tests/when.rs new file mode 100644 index 0000000..88e5c04 --- /dev/null +++ b/crates/repo-actor/src/tests/when.rs @@ -0,0 +1,48 @@ +// +use git::repository::OpenRepositoryLike; + +use super::*; + +pub fn start_actor( + repository_factory: git::repository::MockRepositoryFactory, + repo_details: git::RepoDetails, + forge: Box, +) -> (actix::Addr, RepoActorLog) { + let (actor, log) = given::a_repo_actor( + repo_details, + Box::new(repository_factory), + forge, + given::a_network().into(), + ); + (actor.start(), log) +} + +pub fn start_actor_with_open_repository( + open_repository: MockOpenRepositoryLike, + repo_details: git::RepoDetails, + forge: Box, +) -> (actix::Addr, RepoActorLog) { + let (actor, log) = given::a_repo_actor( + repo_details, + git::repository::mock(), + forge, + given::a_network().into(), + ); + let actor = actor.with_open_repository(Box::new(open_repository)); + (actor.start(), log) +} + +pub fn commit_status( + forge: &mut git::MockForgeLike, + commit: git::Commit, + status: git::forge::commit::Status, +) { + let mut commit_status_forge = git::MockForgeLike::new(); + commit_status_forge + .expect_commit_status() + .with(mockall::predicate::eq(commit)) + .return_once(|_| status); + forge + .expect_duplicate() + .return_once(move || Box::new(commit_status_forge)); +} diff --git a/crates/server/src/actors/messages.rs b/crates/server/src/actors/messages.rs new file mode 100644 index 0000000..d1db605 --- /dev/null +++ b/crates/server/src/actors/messages.rs @@ -0,0 +1,4 @@ +use git_next_config::server::ServerConfig; +use git_next_repo_actor::message; + +message!(ReceiveServerConfig wraps ServerConfig); diff --git a/crates/server/src/actors/mod.rs b/crates/server/src/actors/mod.rs index 2fd2c6f..baf0b68 100644 --- a/crates/server/src/actors/mod.rs +++ b/crates/server/src/actors/mod.rs @@ -1,3 +1,4 @@ pub mod file_watcher; +pub mod messages; pub mod server; pub mod webhook; diff --git a/crates/server/src/actors/server.rs b/crates/server/src/actors/server.rs index 6929c66..54bdd1d 100644 --- a/crates/server/src/actors/server.rs +++ b/crates/server/src/actors/server.rs @@ -8,12 +8,14 @@ use git_next_config::{ self as config, ForgeAlias, ForgeConfig, GitDir, RepoAlias, ServerRepoConfig, }; use git_next_git::{repository::RepositoryFactory, Generation, RepoDetails}; -use git_next_repo_actor::{CloneRepo, RepoActor}; +use git_next_repo_actor::messages::CloneRepo; +use git_next_repo_actor::RepoActor; use kxio::{fs::FileSystem, network::Network}; use tracing::{error, info, warn}; use crate::actors::{ file_watcher::FileUpdated, + messages::ReceiveServerConfig, webhook::{AddWebhookRecipient, ShutdownWebhook, WebhookActor, WebhookRouter}, }; @@ -39,6 +41,7 @@ pub struct Server { fs: FileSystem, net: Network, repository_factory: Box, + sleep_duration: std::time::Duration, } impl Actor for Server { type Context = Context; @@ -54,14 +57,14 @@ impl Handler for Server { return; } }; - ctx.notify(server_config); + ctx.notify(ReceiveServerConfig::new(server_config)); } } -impl Handler for Server { +impl Handler for Server { type Result = (); #[allow(clippy::cognitive_complexity)] // TODO: (#75) reduce complexity - fn handle(&mut self, msg: ServerConfig, _ctx: &mut Self::Context) -> Self::Result { + fn handle(&mut self, msg: ReceiveServerConfig, _ctx: &mut Self::Context) -> Self::Result { let Ok(socket_addr) = msg.http() else { warn!("Unable to parse http.addr"); return; @@ -114,7 +117,12 @@ impl Handler for Server { } } impl Server { - pub fn new(fs: FileSystem, net: Network, repo: Box) -> Self { + pub fn new( + fs: FileSystem, + net: Network, + repo: Box, + sleep_duration: std::time::Duration, + ) -> Self { let generation = Generation::default(); Self { generation, @@ -122,6 +130,7 @@ impl Server { fs, net, repository_factory: repo, + sleep_duration, } } fn create_forge_data_directories( @@ -182,6 +191,7 @@ impl Server { let net = self.net.clone(); let repository_factory = self.repository_factory.duplicate(); let generation = self.generation; + let sleep_duration = self.sleep_duration; move |(repo_alias, server_repo_config)| { let span = tracing::info_span!("create_actor", alias = %repo_alias, config = %server_repo_config); let _guard = span.enter(); @@ -207,13 +217,16 @@ impl Server { &forge_config, gitdir, ); + let forge = git_next_forge::Forge::create(repo_details.clone(), net.clone()); info!("Starting Repo Actor"); let actor = RepoActor::new( repo_details, + forge, webhook.clone(), generation, net.clone(), repository_factory.duplicate(), + sleep_duration, ); (forge_name.clone(), repo_alias, actor) } diff --git a/crates/server/src/actors/webhook/mod.rs b/crates/server/src/actors/webhook/mod.rs index 502535f..287e805 100644 --- a/crates/server/src/actors/webhook/mod.rs +++ b/crates/server/src/actors/webhook/mod.rs @@ -4,7 +4,7 @@ use actix::prelude::*; mod router; mod server; -use git_next_config as config; +use git_next_repo_actor::messages::WebhookNotification; use std::net::SocketAddr; @@ -17,13 +17,10 @@ pub struct WebhookActor { socket_addr: SocketAddr, span: tracing::Span, spawn_handle: Option, - message_receiver: Recipient, + message_receiver: Recipient, } impl WebhookActor { - pub fn new( - socket_addr: SocketAddr, - message_receiver: Recipient, - ) -> Self { + pub fn new(socket_addr: SocketAddr, message_receiver: Recipient) -> Self { let span = tracing::info_span!("WebhookActor"); Self { socket_addr, @@ -37,7 +34,7 @@ impl Actor for WebhookActor { type Context = actix::Context; fn started(&mut self, ctx: &mut Self::Context) { let _gaurd = self.span.enter(); - let address: Recipient = self.message_receiver.clone(); + let address: Recipient = self.message_receiver.clone(); let server = server::start(self.socket_addr, address); let spawn_handle = ctx.spawn(server.in_current_span().into_actor(self)); self.spawn_handle.replace(spawn_handle); diff --git a/crates/server/src/actors/webhook/router.rs b/crates/server/src/actors/webhook/router.rs index 993bd9d..9179de7 100644 --- a/crates/server/src/actors/webhook/router.rs +++ b/crates/server/src/actors/webhook/router.rs @@ -1,15 +1,15 @@ // -use std::collections::HashMap; +use std::collections::BTreeMap; use actix::prelude::*; use derive_more::Constructor; -use git_next_config::WebhookMessage; use git_next_config::{ForgeAlias, RepoAlias}; +use git_next_repo_actor::messages::WebhookNotification; use tracing::{debug, info}; pub struct WebhookRouter { span: tracing::Span, - recipients: HashMap>>, + recipients: BTreeMap>>, } impl WebhookRouter { pub fn new() -> Self { @@ -24,10 +24,10 @@ impl Actor for WebhookRouter { type Context = Context; } -impl Handler for WebhookRouter { +impl Handler for WebhookRouter { type Result = (); - fn handle(&mut self, msg: WebhookMessage, _ctx: &mut Self::Context) -> Self::Result { + fn handle(&mut self, msg: WebhookNotification, _ctx: &mut Self::Context) -> Self::Result { let _gaurd = self.span.enter(); let forge_alias = msg.forge_alias(); let repo_alias = msg.repo_alias(); @@ -48,7 +48,7 @@ impl Handler for WebhookRouter { pub struct AddWebhookRecipient { pub forge_alias: ForgeAlias, pub repo_alias: RepoAlias, - pub recipient: Recipient, + pub recipient: Recipient, } impl Handler for WebhookRouter { type Result = (); @@ -58,7 +58,7 @@ impl Handler for WebhookRouter { info!(forge = %msg.forge_alias, repo = %msg.repo_alias, "Register Recipient"); if !self.recipients.contains_key(&msg.forge_alias) { self.recipients - .insert(msg.forge_alias.clone(), HashMap::new()); + .insert(msg.forge_alias.clone(), BTreeMap::new()); } self.recipients .get_mut(&msg.forge_alias) diff --git a/crates/server/src/actors/webhook/server.rs b/crates/server/src/actors/webhook/server.rs index ce83c55..a6bd13e 100644 --- a/crates/server/src/actors/webhook/server.rs +++ b/crates/server/src/actors/webhook/server.rs @@ -1,16 +1,17 @@ // -use std::{collections::HashMap, net::SocketAddr}; +use std::{collections::BTreeMap, net::SocketAddr}; use actix::prelude::*; use config::{ForgeAlias, RepoAlias}; use git_next_config as config; +use git_next_repo_actor::messages::WebhookNotification; use tracing::{info, warn}; pub async fn start( socket_addr: SocketAddr, - address: actix::prelude::Recipient, + address: actix::prelude::Recipient, ) { // start webhook server use warp::Filter; @@ -22,7 +23,7 @@ pub async fn start( .and(warp::header::headers_cloned()) .and(warp::body::bytes()) .and_then( - |recipient: Recipient, + |recipient: Recipient, forge_alias: String, repo_alias: String, // query: String, @@ -32,7 +33,7 @@ pub async fn start( let forge_alias = ForgeAlias::new(forge_alias); let repo_alias = RepoAlias::new(repo_alias); let bytes = body.to_vec(); - let body = config::webhook::message::Body::new( + let body = config::webhook::forge_notification::Body::new( String::from_utf8_lossy(&bytes).to_string(), ); let headers = headers @@ -40,8 +41,13 @@ pub async fn start( .filter_map(|(k, v)| { k.map(|k| (k.to_string(), v.to_str().unwrap_or_default().to_string())) }) - .collect::>(); - let message = config::WebhookMessage::new(forge_alias, repo_alias, headers, body); + .collect::>(); + let message = WebhookNotification::new(config::ForgeNotification::new( + forge_alias, + repo_alias, + headers, + body, + )); recipient .try_send(message) .map(|_| { diff --git a/crates/server/src/config/tests.rs b/crates/server/src/config/tests.rs index 98f60d9..86ea69d 100644 --- a/crates/server/src/config/tests.rs +++ b/crates/server/src/config/tests.rs @@ -1,6 +1,6 @@ // use assert2::let_assert; -use git::{repository::Direction, validation::repo::validate_repo}; +use git::{repository::Direction, validation::remotes::validate_default_remotes}; use git_next_config::{ self as config, ForgeType, GitDir, Hostname, RepoBranches, RepoConfig, RepoConfigSource, RepoPath, @@ -46,7 +46,7 @@ fn gitdir_should_display_as_pathbuf() { // git.kemitix.net:kemitix/git-next // If the default push remote is something else, then this test will fail fn repo_details_find_default_push_remote_finds_correct_remote() -> Result<()> { - let cli_crate_dir = std::env::current_dir().map_err(git::validation::repo::Error::Io)?; + let cli_crate_dir = std::env::current_dir().map_err(git::validation::remotes::Error::Io)?; let_assert!(Some(Some(root)) = cli_crate_dir.parent().map(|p| p.parent())); let mut repo_details = git::common::repo_details( 1, @@ -77,7 +77,7 @@ fn repo_details_find_default_push_remote_finds_correct_remote() -> Result<()> { #[test] fn gitdir_validate_should_pass_a_valid_git_repo() -> Result<()> { - let cli_crate_dir = std::env::current_dir().map_err(git::validation::repo::Error::Io)?; + let cli_crate_dir = std::env::current_dir().map_err(git::validation::remotes::Error::Io)?; let_assert!(Some(Some(root)) = cli_crate_dir.parent().map(|p| p.parent())); let mut repo_details = git::common::repo_details( 1, @@ -92,7 +92,7 @@ fn gitdir_validate_should_pass_a_valid_git_repo() -> Result<()> { .with_hostname(Hostname::new("git.kemitix.net")); let gitdir = &repo_details.gitdir; let repository = git::repository::real().open(gitdir)?; - validate_repo(&*repository, &repo_details)?; + validate_default_remotes(&*repository, &repo_details)?; Ok(()) } @@ -100,7 +100,7 @@ fn gitdir_validate_should_pass_a_valid_git_repo() -> Result<()> { #[test] fn gitdir_validate_should_fail_a_git_repo_with_wrong_remote() -> Result<()> { let_assert!( - Ok(cli_crate_dir) = std::env::current_dir().map_err(git::validation::repo::Error::Io) + Ok(cli_crate_dir) = std::env::current_dir().map_err(git::validation::remotes::Error::Io) ); let_assert!(Some(Some(root)) = cli_crate_dir.parent().map(|p| p.parent())); let repo_details = git::common::repo_details( @@ -113,7 +113,7 @@ fn gitdir_validate_should_fail_a_git_repo_with_wrong_remote() -> Result<()> { .with_repo_path(RepoPath::new("hello/world".to_string())); let gitdir = &repo_details.gitdir; let repository = git::repository::real().open(gitdir)?; - let_assert!(Err(_) = validate_repo(&*repository, &repo_details)); + let_assert!(Err(_) = validate_default_remotes(&*repository, &repo_details)); Ok(()) } diff --git a/crates/server/src/lib.rs b/crates/server/src/lib.rs index f0930b6..e4e6ea6 100644 --- a/crates/server/src/lib.rs +++ b/crates/server/src/lib.rs @@ -37,11 +37,16 @@ pub fn init(fs: FileSystem) { } } -pub async fn start(fs: FileSystem, net: Network, repo: Box) { +pub async fn start( + fs: FileSystem, + net: Network, + repo: Box, + sleep_duration: std::time::Duration, +) { init_logging(); info!("Starting Server..."); - let server = Server::new(fs.clone(), net.clone(), repo).start(); + let server = Server::new(fs.clone(), net.clone(), repo, sleep_duration).start(); server.do_send(FileUpdated); info!("Starting File Watcher...");