cossmass/git-next
1
0
Fork 0
forked from kemitix/git-next
Code Pull requests Activity

refactor: repo-actor: rewrite tests using mockall

Browse source
This commit is contained in:
Paul Campbell 2024-06-19 07:03:08 +01:00
parent 601e400300
commit ffab1986a7
84 changed files with 2955 additions and 692 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.cargo/config.toml
View file

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

1
Cargo.toml
View file

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

2
bacon.toml
View file

@ -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"]

3
crates/cli/src/main.rs
View file

@ -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;
}
},
}

23
crates/config/Cargo.toml
View file

@ -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

2
crates/config/src/forge_alias.rs
View file

@ -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)

11
crates/config/src/forge_config.rs
View file

@ -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 {

13
crates/config/src/forge_type.rs
View file

@ -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,

3
crates/config/src/lib.rs
View file

@ -1,5 +1,4 @@
//
mod api_token;
mod branch_name;
pub mod common;
@ -41,5 +40,5 @@ 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;

1
crates/config/src/newtype.rs
View file

@ -32,7 +32,6 @@ macro_rules! newtype {
Eq,
PartialOrd,
Ord,
Hash,
derive_more::AsRef,
derive_more::Deref,
$($derive),*

16
crates/config/src/repo_alias.rs
View file

@ -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<String>) -> 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);

1
crates/config/src/repo_config.rs
View file

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

58
crates/config/src/server.rs
View file

@ -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<T> = core::result::Result<T, Error>;
/// 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<String, ForgeConfig>,
pub forge: BTreeMap<String, ForgeConfig>,
}
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,
}

11
crates/config/src/server_repo_config.rs
View file

@ -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 {

19
crates/config/src/tests.rs
View file

@ -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<String, String> = Default::default();
let mut headers: BTreeMap<String, String> = 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<String, ForgeConfig> {
pub fn some_forge_configs() -> BTreeMap<String, ForgeConfig> {
[(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 {

2
crates/config/src/webhook/mod.rs → crates/config/src/webhook.rs
View file

@ -1,6 +1,6 @@
pub mod auth;
pub mod forge_notification;
pub mod id;
pub mod message;
pub mod push;
#[cfg(test)]

16
crates/config/src/webhook/message.rs → crates/config/src/webhook/forge_notification.rs
View file

@ -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<String, String>,
headers: BTreeMap<String, String>,
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 {

7
crates/forge-forgejo/src/lib.rs
View file

@ -23,13 +23,16 @@ impl ForgeJo {
}
#[async_trait::async_trait]
impl git::ForgeLike for ForgeJo {
fn duplicate(&self) -> Box<dyn git::ForgeLike> {
Box::new(self.clone())
}
fn name(&self) -> String {
"forgejo".to_string()
}
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<config::webhook::Push> {
webhook::parse_body(body)
}

19
crates/forge-forgejo/src/tests.rs
View file

@ -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<String, String> {
let mut headers = HashMap::new();
pub fn webhook_headers(header: Header) -> BTreeMap<String, String> {
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 {

2
crates/forge-forgejo/src/webhook/parse.rs
View file

@ -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<config::webhook::Push> {
serde_json::from_str::<forgejo::webhook::Push>(body.as_str())?.try_into()
}

7
crates/forge-github/src/lib.rs
View file

@ -19,13 +19,16 @@ pub struct Github {
}
#[async_trait::async_trait]
impl git::ForgeLike for Github {
fn duplicate(&self) -> Box<dyn git::ForgeLike> {
Box::new(self.clone())
}
fn name(&self) -> String {
"github".to_string()
}
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<config::webhook::push::Push> {
github::webhook::parse_body(body)
}

13
crates/forge-github/src/tests/mod.rs
View file

@ -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<String, String> {
let mut headers = HashMap::new();
pub fn webhook_headers(header: Header) -> BTreeMap<String, String> {
let mut headers = BTreeMap::new();
match header {
Header::Valid(auth, body) => {
if let Some(sig) = crate::webhook::sign_body(&auth, &body) {

4
crates/forge-github/src/webhook/authorised.rs
View file

@ -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<String> {
let payload = body.as_str();
use hmac::Mac;

2
crates/forge-github/src/webhook/parse.rs
View file

@ -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<config::webhook::push::Push> {
serde_json::from_str::<github::webhook::Push>(body.as_str())?.try_into()
}

16
crates/forge/src/lib.rs
View file

@ -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<dyn git::ForgeLike> {
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")]

59
crates/forge/src/mock_forge.rs
View file

@ -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<config::webhook::push::Push> {
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<Vec<config::WebhookId>> {
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<config::RegisteredWebhook> {
Ok(config::RegisteredWebhook::new(
config::WebhookId::new(""),
config::WebhookAuth::new(ulid::Ulid::new()),
))
}
}

12
crates/forge/src/tests.rs
View file

@ -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");
}

4
crates/git/src/commit.rs
View file

@ -37,8 +37,8 @@ impl From<config::webhook::Push> 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 {

2
crates/git/src/forge/commit.rs
View file

@ -1,4 +1,4 @@
#[derive(Debug, PartialEq, Eq)]
#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub enum Status {
Pass,
Fail,

8
crates/git/src/forge/like.rs
View file

@ -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<dyn ForgeLike>;
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<config::webhook::push::Push>;
/// Checks the results of any (e.g. CI) status checks for the commit.

1
crates/git/src/lib.rs
View file

@ -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;

6
crates/git/src/push.rs
View file

@ -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)
}

9
crates/git/src/repo_details.rs
View file

@ -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
}
}

13
crates/git/src/repository/mod.rs
View file

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

12
crates/git/src/repository/tests.rs
View file

@ -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());
}

2
crates/git/src/validation/mod.rs
View file

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

24
crates/git/src/validation/positions.rs
View file

@ -2,8 +2,6 @@
use crate as git;
use git_next_config as config;
use tracing::{error, info, warn};
pub type Result<T> = core::result::Result<T, Error>;
#[derive(Debug)]
@ -14,7 +12,7 @@ pub struct Positions {
pub dev_commit_history: Vec<git::Commit>,
}
#[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<Positions> {
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<git::commit::Histories> {
let main = (repository.commit_log(&repo_config.branches().main(), &[]))?;
let main = (open_repository.commit_log(&repo_config.branches().main(), &[]))?;
let main_head = [main[0].clone()];
let next = repository.commit_log(&repo_config.branches().next(), &main_head)?;
let dev = repository.commit_log(&repo_config.branches().dev(), &main_head)?;
let next = open_repository.commit_log(&repo_config.branches().next(), &main_head)?;
let dev = open_repository.commit_log(&repo_config.branches().dev(), &main_head)?;
let histories = git::commit::Histories { main, next, dev };
Ok(histories)
}

2
crates/git/src/validation/repo.rs → crates/git/src/validation/remotes.rs
View file

@ -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<()> {

5
crates/git/src/validation/tests.rs
View file

@ -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
));
}
}

9
crates/repo-actor/Cargo.toml
View file

@ -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"

35
crates/repo-actor/README.md Normal file
View file

@ -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
```

86
crates/repo-actor/src/branch.rs
View file

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

11
crates/repo-actor/src/handlers.rs Normal file
View file

@ -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;

50
crates/repo-actor/src/handlers/advance_main.rs Normal file
View file

@ -0,0 +1,50 @@
//
use crate as actor;
use actix::prelude::*;
impl Handler<actor::messages::AdvanceMain> 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,
);
}
}
}
}
}
}

44
crates/repo-actor/src/handlers/advance_next.rs Normal file
View file

@ -0,0 +1,44 @@
//
use crate as actor;
use actix::prelude::*;
impl Handler<actor::messages::AdvanceNext> 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}"),
}
}
}

34
crates/repo-actor/src/handlers/check_ci_status.rs Normal file
View file

@ -0,0 +1,34 @@
//
use crate as actor;
use actix::prelude::*;
use tracing::Instrument as _;
impl Handler<actor::messages::CheckCIStatus> 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);
}
}

45
crates/repo-actor/src/handlers/clone_repo.rs Normal file
View file

@ -0,0 +1,45 @@
//
use actix::prelude::*;
use crate as actor;
use git_next_git as git;
impl Handler<actor::messages::CloneRepo> for actor::RepoActor {
type Result = ();
#[tracing::instrument(name = "RepoActor::CloneRepo", skip_all, fields(repo = %self.repo_details /*, gitdir = %self.repo_details.gitdir */))]
fn handle(
&mut self,
_msg: actor::messages::CloneRepo,
ctx: &mut Self::Context,
) -> Self::Result {
tracing::debug!("Handler: CloneRepo: start");
let gitdir = self.repo_details.gitdir.clone();
match git::repository::open(&*self.repository_factory, &self.repo_details, gitdir) {
Ok(repository) => {
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");
}
}

38
crates/repo-actor/src/handlers/load_config_from_repo.rs Normal file
View file

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

42
crates/repo-actor/src/handlers/receive_ci_status.rs Normal file
View file

@ -0,0 +1,42 @@
//
use crate as actor;
use actix::prelude::*;
use git_next_git as git;
impl Handler<actor::messages::ReceiveCIStatus> 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
}
}
}
}

29
crates/repo-actor/src/handlers/receive_repo_config.rs Normal file
View file

@ -0,0 +1,29 @@
//
use actix::prelude::*;
use crate as actor;
impl Handler<actor::messages::ReceiveRepoConfig> 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,
);
}
}

39
crates/repo-actor/src/handlers/register_webhook.rs Normal file
View file

@ -0,0 +1,39 @@
//
use actix::prelude::*;
use tracing::Instrument as _;
use crate as actor;
use actor::{messages::RegisterWebhook, RepoActor};
impl Handler<RegisterWebhook> for RepoActor {
type Result = ();
fn handle(&mut self, _msg: RegisterWebhook, ctx: &mut Self::Context) -> Self::Result {
if self.webhook_id.is_none() {
let forge_alias = self.repo_details.forge.forge_alias();
let repo_alias = &self.repo_details.repo_alias;
let webhook_url = self.webhook.url(forge_alias, repo_alias);
let forge = self.forge.duplicate();
let addr = ctx.address();
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");
}
}
}

119
crates/repo-actor/src/handlers/validate_repo.rs Normal file
View file

@ -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<actor::messages::ValidateRepo> for actor::RepoActor {
type Result = ();
#[tracing::instrument(name = "RepoActor::ValidateRepo", skip_all, fields(repo = %self.repo_details, token = %msg.deref()))]
fn handle(
&mut self,
msg: actor::messages::ValidateRepo,
ctx: &mut Self::Context,
) -> Self::Result {
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
}
}

9
crates/repo-actor/src/webhook.rs → crates/repo-actor/src/handlers/webhook_notification.rs
View file

@ -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<config::WebhookMessage> for RepoActor {
impl Handler<WebhookNotification> 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<config::WebhookMessage> for RepoActor {
token = %message_token,
"New commit"
);
ctx.address().do_send(ValidateRepo { message_token });
ctx.address()
.do_send(actor::messages::ValidateRepo::new(message_token));
}
}

17
crates/repo-actor/src/handlers/webhook_registered.rs Normal file
View file

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

375
crates/repo-actor/src/lib.rs
View file

@ -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<std::sync::Mutex<Vec<String>>>;
/// An actor that represents a Git Repository.
///
/// When this actor is started it is sent the [CloneRepo] message.
///
/// ```mermaid
/// stateDiagram-v2
/// [*] --> CloneRepo :START
///
/// CloneRepo --> LoadConfigFromRepo
/// CloneRepo --> ValidateRepo
///
/// LoadConfigFromRepo --> LoadedConfig
///
/// ValidateRepo --> WebhookRegistered
/// ValidateRepo --> StartMonitoring
/// ValidateRepo --> ValidateRepo :SLEEP 10s
///
/// LoadedConfig --> ValidateRepo
///
/// WebhookRegistered --> [*]
///
/// StartMonitoring --> AdvanceMainTo
/// StartMonitoring --> ValidateRepo :SLEEP 10s
///
/// AdvanceMainTo --> LoadConfigFromRepo
/// AdvanceMainTo --> ValidateRepo
///
/// [*] --> WebhookMessage :WEBHOOK
///
/// WebhookMessage --> ValidateRepo
/// ```
///
#[derive(Debug, derive_more::Display)]
#[display("{}:{}:{}", generation, repo_details.forge.forge_alias(), repo_details.repo_alias)]
pub struct RepoActor {
sleep_duration: std::time::Duration,
generation: git::Generation,
message_token: MessageToken,
message_token: messages::MessageToken,
repo_details: git::RepoDetails,
webhook: config::server::Webhook,
webhook_id: Option<config::WebhookId>, // INFO: if [None] then no webhook is configured
@ -32,47 +61,74 @@ pub struct RepoActor {
last_main_commit: Option<git::Commit>,
last_next_commit: Option<git::Commit>,
last_dev_commit: Option<git::Commit>,
repository: Box<dyn git::repository::RepositoryFactory>,
repository_factory: Box<dyn git::repository::RepositoryFactory>,
open_repository: Option<Box<dyn git::repository::OpenRepositoryLike>>,
net: Network,
forge: forge::Forge,
forge: Box<dyn git::ForgeLike>,
log: Option<RepoActorLog>,
}
impl RepoActor {
pub fn new(
details: git::RepoDetails,
repo_details: git::RepoDetails,
forge: Box<dyn git::ForgeLike>,
webhook: config::server::Webhook,
generation: git::Generation,
net: Network,
repository: Box<dyn git::repository::RepositoryFactory>,
repository_factory: Box<dyn git::repository::RepositoryFactory>,
sleep_duration: std::time::Duration,
) -> Self {
let forge = forge::Forge::new(details.clone(), net.clone());
debug!(?forge, "new");
let message_token = messages::MessageToken::default();
Self {
generation,
message_token: MessageToken::new(),
repo_details: details,
message_token,
repo_details,
webhook,
webhook_id: None,
webhook_auth: None,
last_main_commit: None,
last_next_commit: None,
last_dev_commit: None,
repository,
repository_factory,
open_repository: None,
net,
forge,
net,
sleep_duration,
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<dyn git::repository::OpenRepositoryLike>,
) -> 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<Self>;
#[tracing::instrument(name = "RepoActor::stopping", skip_all, fields(repo = %self.repo_details))]
fn stopping(&mut self, ctx: &mut Self::Context) -> Running {
tracing::debug!("stopping");
info!("Checking webhook");
match self.webhook_id.take() {
Some(webhook_id) => {
tracing::warn!("stopping - unregistering webhook");
info!(%webhook_id, "Unregistring webhook");
let forge = self.forge.clone();
let forge = self.forge.duplicate();
async move {
if let Err(err) = forge.unregister_webhook(&webhook_id).await {
warn!("unregistering webhook: {err}");
@ -88,259 +144,38 @@ impl Actor for RepoActor {
}
}
#[derive(Message)]
#[rtype(result = "()")]
pub struct CloneRepo;
impl Handler<CloneRepo> for RepoActor {
type Result = ();
#[tracing::instrument(name = "RepoActor::CloneRepo", skip_all, fields(repo = %self.repo_details /*, gitdir = %self.repo_details.gitdir */))]
fn handle(&mut self, _msg: CloneRepo, ctx: &mut Self::Context) -> Self::Result {
let gitdir = self.repo_details.gitdir.clone();
match git::repository::open(&*self.repository, &self.repo_details, gitdir) {
Ok(repository) => {
self.open_repository.replace(repository);
if self.repo_details.repo_config.is_none() {
ctx.address().do_send(LoadConfigFromRepo);
} else {
ctx.address().do_send(ValidateRepo {
message_token: self.message_token,
});
}
}
Err(err) => warn!("Could not open repo: {err}"),
}
}
}
#[derive(Message)]
#[rtype(result = "()")]
pub struct LoadConfigFromRepo;
impl Handler<LoadConfigFromRepo> for RepoActor {
type Result = ();
#[tracing::instrument(name = "RepoActor::LoadConfigFromRepo", skip_all, fields(repo = %self.repo_details))]
fn handle(&mut self, _msg: LoadConfigFromRepo, ctx: &mut Self::Context) -> Self::Result {
let details = self.repo_details.clone();
let addr = ctx.address();
let Some(open_repository) = &self.open_repository else {
warn!("missing open repository - can't load configuration");
return;
};
let open_repository = open_repository.duplicate();
async move { repo_actor::load::load_file(details, addr, &*open_repository).await }
.in_current_span()
.into_actor(self)
.wait(ctx)
}
}
#[derive(Message)]
#[rtype(result = "()")]
struct LoadedConfig(git_next_config::RepoConfig);
impl Handler<LoadedConfig> for RepoActor {
type Result = ();
#[tracing::instrument(name = "RepoActor::LoadedConfig", skip_all, fields(repo = %self.repo_details, branches = %msg.0))]
fn handle(&mut self, msg: LoadedConfig, ctx: &mut Self::Context) -> Self::Result {
let repo_config = msg.0;
self.repo_details.repo_config.replace(repo_config);
ctx.address().do_send(ValidateRepo {
message_token: self.message_token,
});
}
}
#[derive(derive_more::Constructor, Message)]
#[rtype(result = "()")]
pub struct ValidateRepo {
message_token: MessageToken,
}
impl Handler<ValidateRepo> for RepoActor {
type Result = ();
#[tracing::instrument(name = "RepoActor::ValidateRepo", skip_all, fields(repo = %self.repo_details, token = %msg.message_token))]
fn handle(&mut self, msg: ValidateRepo, ctx: &mut Self::Context) -> Self::Result {
match msg.message_token {
message_token if self.message_token < message_token => {
info!(%message_token, "New message token");
self.message_token = msg.message_token;
}
message_token if self.message_token > message_token => {
info!("Dropping message from previous generation");
return; // message is expired
}
_ => {
// do nothing
}
}
if self.webhook_id.is_none() {
let forge_alias = self.repo_details.forge.forge_alias();
let repo_alias = &self.repo_details.repo_alias;
let webhook_url = self.webhook.url(forge_alias, repo_alias);
let forge = self.forge.clone();
let addr = ctx.address();
async move {
if let Err(err) =
forge
.register_webhook(&webhook_url)
.await
.and_then(|registered_webhook| {
addr.try_send(WebhookRegistered::from(registered_webhook))
.map_err(|e| {
git::forge::webhook::Error::FailedToNotifySelf(e.to_string())
})
})
pub fn do_send<M>(_addr: Addr<RepoActor>, msg: M, log: &Option<crate::RepoActorLog>)
where
M: actix::Message + Send + 'static + std::fmt::Debug,
RepoActor: actix::Handler<M>,
<M as actix::Message>::Result: Send,
{
warn!("registering webhook: {err}");
let log_message = format!("send: {:?}", msg);
tracing::debug!(log_message);
logger(log, log_message);
#[cfg(not(test))]
_addr.do_send(msg)
}
}
.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())
pub async fn send<M>(
addr: Addr<RepoActor>,
msg: M,
log: &Option<crate::RepoActorLog>,
) -> std::result::Result<<M as actix::Message>::Result, actix::MailboxError>
where
M: actix::Message + Send + 'static + std::fmt::Debug,
RepoActor: actix::Handler<M>,
<M as actix::Message>::Result: Send,
{
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);
}
}
let log_message = format!("send: {:?}", msg);
logger(log, log_message);
addr.send(msg).await
}
#[derive(Debug, derive_more::Constructor, Message)]
#[rtype(result = "()")]
pub struct StartMonitoring {
main: git::Commit,
next: git::Commit,
dev: git::Commit,
dev_commit_history: Vec<git::Commit>,
}
impl Handler<StartMonitoring> for RepoActor {
type Result = ();
#[tracing::instrument(name = "RepoActor::StartMonitoring", skip_all,
fields(token = %self.message_token, repo = %self.repo_details, main = %msg.main, next= %msg.next, dev = %msg.dev))
]
fn handle(&mut self, msg: StartMonitoring, ctx: &mut Self::Context) -> Self::Result {
let Some(repo_config) = self.repo_details.repo_config.clone() else {
warn!("No config loaded");
return;
};
let next_ahead_of_main = msg.main != msg.next;
let dev_ahead_of_next = msg.next != msg.dev;
info!(next_ahead_of_main, dev_ahead_of_next, "StartMonitoring");
let addr = ctx.address();
let forge = self.forge.clone();
if next_ahead_of_main {
status::check_next(msg.next, addr, forge, self.message_token)
.in_current_span()
.into_actor(self)
.wait(ctx);
} else if dev_ahead_of_next {
if let Some(open_repository) = &self.open_repository {
let open_repository = open_repository.duplicate();
let repo_details = self.repo_details.clone();
let message_token = self.message_token;
async move {
branch::advance_next(
msg.next,
msg.dev_commit_history,
repo_details,
repo_config,
&*open_repository,
addr,
message_token,
)
.await
}
.in_current_span()
.into_actor(self)
.wait(ctx);
}
}
}
}
#[derive(Message)]
#[rtype(result = "()")]
pub struct WebhookRegistered(config::WebhookId, config::WebhookAuth);
impl From<RegisteredWebhook> for WebhookRegistered {
fn from(value: RegisteredWebhook) -> Self {
Self(value.id().clone(), value.auth().clone())
}
}
impl Handler<WebhookRegistered> for RepoActor {
type Result = ();
#[tracing::instrument(name = "RepoActor::WebhookRegistered", skip_all, fields(repo = %self.repo_details, webhook_id = %msg.0))]
fn handle(&mut self, msg: WebhookRegistered, _ctx: &mut Self::Context) -> Self::Result {
self.webhook_id.replace(msg.0);
self.webhook_auth.replace(msg.1);
}
}
#[derive(Message)]
#[rtype(result = "()")]
pub struct AdvanceMainTo(git::Commit);
impl Handler<AdvanceMainTo> for RepoActor {
type Result = ();
#[tracing::instrument(name = "RepoActor::AdvanceMainTo", skip_all, fields(repo = %self.repo_details, commit = %msg.0))]
fn handle(&mut self, msg: AdvanceMainTo, ctx: &mut Self::Context) -> Self::Result {
let Some(repo_config) = self.repo_details.repo_config.clone() else {
warn!("No config loaded");
return;
};
let Some(open_repository) = &self.open_repository else {
warn!("No repository opened");
return;
};
let repo_details = self.repo_details.clone();
let addr = ctx.address();
let message_token = self.message_token;
let open_repository = open_repository.duplicate();
async move {
branch::advance_main(msg.0, &repo_details, &repo_config, &*open_repository).await;
match repo_config.source() {
git_next_config::RepoConfigSource::Repo => addr.do_send(LoadConfigFromRepo),
git_next_config::RepoConfigSource::Server => {
addr.do_send(ValidateRepo { message_token })
}
}
}
.in_current_span()
.into_actor(self)
.wait(ctx);
}
}
#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord, derive_more::Display)]
pub struct MessageToken(u32);
impl MessageToken {
pub fn new() -> Self {
Self::default()
}
pub const fn next(&self) -> Self {
Self(self.0 + 1)
pub fn logger(log: &Option<crate::RepoActorLog>, message: impl Into<String>) {
if let Some(log) = log {
let message: String = message.into();
tracing::debug!(message);
let _ = log.lock().map(|mut l| l.push(message));
}
}

95
crates/repo-actor/src/load.rs
View file

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

70
crates/repo-actor/src/messages.rs Normal file
View file

@ -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<config::RegisteredWebhook> for WebhookRegistered {
fn from(value: config::RegisteredWebhook) -> Self {
let webhook_id = value.id().clone();
let webhook_auth = value.auth().clone();
Self::from((webhook_id, webhook_auth))
}
}
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<git::Commit>)); // next commit and the dev commit history
message!(AdvanceMain wraps git::Commit); // next commit
message!(WebhookNotification wraps config::webhook::forge_notification::ForgeNotification);

33
crates/repo-actor/src/status.rs
View file

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

65
crates/repo-actor/src/tests.rs
View file

@ -1,34 +1,39 @@
//
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<dyn std::error::Error>>;
assert_eq!(next_commit, Some(expected), "Found the wrong commit");
}
}
mod branch;
mod expect;
pub mod given;
mod handlers;
mod load;
mod when;

21
crates/repo-actor/src/tests/branch.rs Normal file
View file

@ -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");
}

35
crates/repo-actor/src/tests/branch/advance_main.rs Normal file
View file

@ -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()
);
}

165
crates/repo-actor/src/tests/branch/advance_next.rs Normal file
View file

@ -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(())
}
}
}
}

58
crates/repo-actor/src/tests/expect.rs Normal file
View file

@ -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
}

278
crates/repo-actor/src/tests/given.rs Normal file
View file

@ -0,0 +1,278 @@
//
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,
};
use git_next_git::repository::RepositoryLike as _;
use mockall::predicate::eq;
use rand::RngCore;
use std::{
collections::HashMap,
path::PathBuf,
sync::{Arc, Mutex},
};
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<Direction, Option<GitRemote>>,
) {
remotes.into_iter().for_each(|(direction, remote)| {
open_repository
.expect_find_default_remote()
.with(eq(direction))
.return_once(|_| remote);
});
}
#[allow(clippy::type_complexity)]
pub fn open_repository_for_loading_config_from_repo(
repo_config: &RepoConfig,
) -> (
MockOpenRepositoryLike,
Arc<Mutex<Vec<(BranchName, PathBuf)>>>,
) {
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 a_webhook_auth() -> WebhookAuth {
WebhookAuth::generate()
}
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 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_branch_name(prefix: impl Into<String>) -> 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<String>) -> 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::Message>) -> git::Commit {
git::Commit::new(a_commit_sha(), message.into())
}
pub fn a_commit_message() -> git::commit::Message {
git::commit::Message::new(a_name())
}
pub fn a_named_commit_sha(name: impl Into<String>) -> 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_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<MockForgeLike> {
Box::new(MockForgeLike::new())
}
pub fn a_repo_actor(
repo_details: git::RepoDetails,
repository_factory: Box<dyn git::repository::RepositoryFactory>,
forge: Box<dyn git::ForgeLike>,
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_hostname() -> config::Hostname {
config::Hostname::new(given::a_name())
}
pub fn a_registered_webhook() -> RegisteredWebhook {
RegisteredWebhook::new(given::a_webhook_id(), given::a_webhook_auth())
}

13
crates/repo-actor/src/tests/handlers.rs Normal file
View file

@ -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;

86
crates/repo-actor/src/tests/handlers/advance_main.rs Normal file
View file

@ -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(())
}

46
crates/repo-actor/src/tests/handlers/advance_next.rs Normal file
View file

@ -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(())
}

32
crates/repo-actor/src/tests/handlers/check_ci_status.rs Normal file
View file

@ -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(())
}

208
crates/repo-actor/src/tests/handlers/clone_repo.rs Normal file
View file

@ -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(())
}

86
crates/repo-actor/src/tests/handlers/load_config_from_repo.rs Normal file
View file

@ -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(())
}

95
crates/repo-actor/src/tests/handlers/loaded_config.rs Normal file
View file

@ -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<RepoConfig>);
impl Handler<TakeRepoConfig> for actor::RepoActor {
type Result = Option<RepoConfig>;
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
}
}

82
crates/repo-actor/src/tests/handlers/receive_ci_status.rs Normal file
View file

@ -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(())
}

64
crates/repo-actor/src/tests/handlers/register_webhook.rs Normal file
View file

@ -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(())
}

375
crates/repo-actor/src/tests/handlers/validate_repo.rs Normal file
View file

@ -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(())
}

183
crates/repo-actor/src/tests/load.rs Normal file
View file

@ -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(())
}

48
crates/repo-actor/src/tests/when.rs Normal file
View file

@ -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<dyn git::ForgeLike>,
) -> (actix::Addr<RepoActor>, 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<dyn git::ForgeLike>,
) -> (actix::Addr<RepoActor>, 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));
}

4
crates/server/src/actors/messages.rs Normal file
View file

@ -0,0 +1,4 @@
use git_next_config::server::ServerConfig;
use git_next_repo_actor::message;
message!(ReceiveServerConfig wraps ServerConfig);

1
crates/server/src/actors/mod.rs
View file

@ -1,3 +1,4 @@
pub mod file_watcher;
pub mod messages;
pub mod server;
pub mod webhook;

23
crates/server/src/actors/server.rs
View file

@ -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<dyn RepositoryFactory>,
sleep_duration: std::time::Duration,
}
impl Actor for Server {
type Context = Context<Self>;
@ -54,14 +57,14 @@ impl Handler<FileUpdated> for Server {
return;
}
};
ctx.notify(server_config);
ctx.notify(ReceiveServerConfig::new(server_config));
}
}
impl Handler<ServerConfig> for Server {
impl Handler<ReceiveServerConfig> 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<ServerConfig> for Server {
}
}
impl Server {
pub fn new(fs: FileSystem, net: Network, repo: Box<dyn RepositoryFactory>) -> Self {
pub fn new(
fs: FileSystem,
net: Network,
repo: Box<dyn RepositoryFactory>,
sleep_duration: std::time::Duration,
) -> Self {
let generation = Generation::default();
Self {
generation,
@ -122,6 +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)
}

11
crates/server/src/actors/webhook/mod.rs
View file

@ -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<actix::SpawnHandle>,
message_receiver: Recipient<config::WebhookMessage>,
message_receiver: Recipient<WebhookNotification>,
}
impl WebhookActor {
pub fn new(
socket_addr: SocketAddr,
message_receiver: Recipient<config::WebhookMessage>,
) -> Self {
pub fn new(socket_addr: SocketAddr, message_receiver: Recipient<WebhookNotification>) -> Self {
let span = tracing::info_span!("WebhookActor");
Self {
socket_addr,
@ -37,7 +34,7 @@ impl Actor for WebhookActor {
type Context = actix::Context<Self>;
fn started(&mut self, ctx: &mut Self::Context) {
let _gaurd = self.span.enter();
let address: Recipient<config::WebhookMessage> = self.message_receiver.clone();
let address: Recipient<WebhookNotification> = 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);

14
crates/server/src/actors/webhook/router.rs
View file

@ -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<ForgeAlias, HashMap<RepoAlias, Recipient<WebhookMessage>>>,
recipients: BTreeMap<ForgeAlias, BTreeMap<RepoAlias, Recipient<WebhookNotification>>>,
}
impl WebhookRouter {
pub fn new() -> Self {
@ -24,10 +24,10 @@ impl Actor for WebhookRouter {
type Context = Context<Self>;
}
impl Handler<WebhookMessage> for WebhookRouter {
impl Handler<WebhookNotification> 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<WebhookMessage> for WebhookRouter {
pub struct AddWebhookRecipient {
pub forge_alias: ForgeAlias,
pub repo_alias: RepoAlias,
pub recipient: Recipient<WebhookMessage>,
pub recipient: Recipient<WebhookNotification>,
}
impl Handler<AddWebhookRecipient> for WebhookRouter {
type Result = ();
@ -58,7 +58,7 @@ impl Handler<AddWebhookRecipient> 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)

18
crates/server/src/actors/webhook/server.rs
View file

@ -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<config::WebhookMessage>,
address: actix::prelude::Recipient<WebhookNotification>,
) {
// 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<config::WebhookMessage>,
|recipient: Recipient<WebhookNotification>,
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::<HashMap<String, String>>();
let message = config::WebhookMessage::new(forge_alias, repo_alias, headers, body);
.collect::<BTreeMap<String, String>>();
let message = WebhookNotification::new(config::ForgeNotification::new(
forge_alias,
repo_alias,
headers,
body,
));
recipient
.try_send(message)
.map(|_| {

12
crates/server/src/config/tests.rs
View file

@ -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(())
}

9
crates/server/src/lib.rs
View file

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