git-next/crates/cli/src/repo/tests/mod.rs

//
use actix::prelude::*;

use crate::{
    git,
    repo::{
        messages::{CloneRepo, MessageToken},
        ActorLog, RepoActor,
    },
};

use git_next_core::{
    git::{
        commit::Sha,
        forge::commit::Status,
        repository::{
            factory::{mock, MockRepositoryFactory, RepositoryFactory},
            open::{MockOpenRepositoryLike, OpenRepositoryLike},
            Direction,
        },
        Commit, ForgeLike, Generation, MockForgeLike, RepoDetails,
    },
    message,
    webhook::{forge_notification::Body, Push},
    BranchName, ForgeAlias, ForgeConfig, ForgeNotification, ForgeType, GitDir, Hostname,
    RegisteredWebhook, RemoteUrl, RepoAlias, RepoBranches, RepoConfig, RepoConfigSource,
    ServerRepoConfig, StoragePathType, WebhookAuth, WebhookId,
};

use assert2::let_assert;
use mockall::predicate::eq;
use tracing::{debug, error};

use std::{
    collections::{BTreeMap, HashMap},
    sync::{Arc, RwLock},
};

type TestResult = Result<(), Box<dyn std::error::Error>>;

mod branch;
mod expect;
pub mod given;
mod handlers;
mod load;
mod when;

impl ActorLog {
    pub fn no_message_contains(&self, needle: impl AsRef<str> + std::fmt::Display) -> TestResult {
        if self.find_in_messages(needle.as_ref())? {
            error!(?self, "");
            panic!("found unexpected message: {needle}");
        }
        Ok(())
    }

    pub fn require_message_containing(
        &self,
        needle: impl AsRef<str> + std::fmt::Display,
    ) -> TestResult {
        if !self.find_in_messages(needle.as_ref())? {
            error!(?self, "");
            panic!("expected message not found: {needle}");
        }
        Ok(())
    }

    fn find_in_messages(
        &self,
        needle: impl AsRef<str>,
    ) -> Result<bool, Box<dyn std::error::Error>> {
        let found = self
            .read()
            .map_err(|e| e.to_string())?
            .iter()
            .any(|message| message.contains(needle.as_ref()));
        Ok(found)
    }
}

message!(ExamineActor => RepoActorView: "Request a view of the current state of the [RepoActor].");
impl Handler<ExamineActor> for RepoActor {
    type Result = RepoActorView;

    fn handle(&mut self, _msg: ExamineActor, _ctx: &mut Self::Context) -> Self::Result {
        let repo_actor: &Self = self;
        Self::Result::from(repo_actor)
    }
}
#[derive(Debug, MessageResponse)]
pub struct RepoActorView {
    pub repo_details: RepoDetails,
    pub webhook_id: Option<WebhookId>, // INFO: if [None] then no webhook is configured
    pub webhook_auth: Option<WebhookAuth>, // INFO: if [None] then no webhook is configured
    pub last_main_commit: Option<Commit>,
    pub last_next_commit: Option<Commit>,
    pub last_dev_commit: Option<Commit>,
}
impl From<&RepoActor> for RepoActorView {
    fn from(repo_actor: &RepoActor) -> Self {
        Self {
            repo_details: repo_actor.repo_details.clone(),
            webhook_id: repo_actor.webhook_id.clone(),
            webhook_auth: repo_actor.webhook_auth.clone(),
            last_main_commit: repo_actor.last_main_commit.clone(),
            last_next_commit: repo_actor.last_next_commit.clone(),
            last_dev_commit: repo_actor.last_dev_commit.clone(),
        }
    }
}