xianyun_update/

updater.rs

//! Repository update orchestration and result/output formatting.
//!
//! Ported from `internal/update/{updater,result,output}.go`, including
//! every test in `updater_test.go`. See `PORT_NOTES.md`.

use std::collections::HashSet;
use std::sync::Arc;

use xianyun_backends::git::{Backend as GitBackend, GitError, RepositoryState};
use xianyun_core::config::container::Container;
use xianyun_core::config::latest::CaproniConfig;
use xianyun_executor::exec::CommandRunner;

/// Ported from `UpdateStatus`. Go's zero value (`iota` 0) is `StatusUpdated`;
/// [`Default`] mirrors that so a zero-initialized [`UpdateResult`] matches
/// Go's zero-valued `UpdateResult`.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum UpdateStatus {
    #[default]
    Updated,
    Diverged,
    Dirty,
    Detached,
    Warning,
    Failed,
    Skipped,
    Pinned,
}

impl std::fmt::Display for UpdateStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let s = match self {
            UpdateStatus::Updated => "Updated",
            UpdateStatus::Diverged => "Diverged",
            UpdateStatus::Dirty => "Dirty",
            UpdateStatus::Detached => "Detached",
            UpdateStatus::Warning => "Warning",
            UpdateStatus::Failed => "Failed",
            UpdateStatus::Skipped => "Skipped",
            UpdateStatus::Pinned => "Pinned",
        };

        write!(f, "{s}")
    }
}

/// Ported from `UpdateResult`.
#[derive(Debug, Default)]
pub struct UpdateResult {
    pub repo_name: String,
    pub status: UpdateStatus,
    pub branch: String,
    pub default_branch: String,
    pub ref_: String,
    pub commits_behind: i64,
    pub commits_ahead: i64,
    pub tracking_branch: String,
    pub notes: String,
    pub error: Option<GitError>,
}

/// Ported from `UpdateStrategy`.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum UpdateStrategy {
    #[default]
    FullUpdate,
    MinimalRequired,
    VerifyOnly,
}

/// Ported from `RepoFilterFunc`.
pub type RepoFilterFn = Box<dyn Fn(&str) -> bool + Send + Sync>;

/// Ported from `UpdateOptions`.
#[derive(Default)]
pub struct UpdateOptions {
    pub strategy: UpdateStrategy,
    pub stash: bool,
    pub filter: Option<RepoFilterFn>,
    pub quiet: bool,
    pub skip_prepare_hooks: bool,
}

/// Ported from `DetermineRequiredRepositories`. Returns the set of
/// repository names that are required based on `edit_mode` deployers,
/// reloaders, and repositories in the configuration.
#[must_use]
pub fn determine_required_repositories(caproni_cfg: &CaproniConfig) -> HashSet<String> {
    let mut required = HashSet::new();

    if let Some(repositories) = &caproni_cfg.repositories {
        for (name, repo_config) in repositories.iter() {
            if repo_config.edit_mode {
                required.insert(name.clone());
            }
        }
    }

    if let Some(deployers) = &caproni_cfg.deployers {
        for deployer_config in deployers.values() {
            if deployer_config.edit_mode
                && let Some(repository) = &deployer_config.repository
            {
                required.insert(repository.clone());
            }
        }
    }

    if let Some(reloaders) = &caproni_cfg.reloaders {
        for reloader_config in reloaders.values() {
            if reloader_config.edit_mode {
                required.insert(reloader_config.repository.clone());
            }
        }
    }

    required
}

/// Ported from `Updater`.
pub struct Updater {
    backend: Arc<dyn GitBackend + Send + Sync>,
    options: UpdateOptions,
}

impl Updater {
    /// Ported from `NewUpdater`.
    pub fn new(backend: Arc<dyn GitBackend + Send + Sync>, options: UpdateOptions) -> Self {
        Self { backend, options }
    }

    /// Ported from `(*Updater).UpdateRepositories`. Updates multiple
    /// repositories based on configuration. Returns results for all
    /// repositories and a success flag. The success flag is `false` if
    /// any repository has [`UpdateStatus::Failed`].
    ///
    /// This also invokes the [`crate::lifecyclehooks::HookType::EditModePrepare`]
    /// hooks but without the `KUBECONFIG` because the cluster isn't
    /// guaranteed to be available yet.
    pub fn update_repositories(
        &self,
        exec: &dyn CommandRunner,
        cfg: &Container,
    ) -> (Vec<UpdateResult>, bool) {
        let mut results = Vec::new();
        let mut success = true;

        // Calculate required repos once (for FullUpdate and MinimalRequired).
        let required_repos = determine_required_repositories(&cfg.caproni);

        let Some(repositories) = &cfg.caproni.repositories else {
            return (results, success);
        };

        for (name, repo_config) in repositories.iter() {
            let mut result =
                self.update_repository(name, repo_config, &cfg.caproni, &required_repos);

            if (result.status == UpdateStatus::Updated || result.status == UpdateStatus::Pinned)
                && !self.options.skip_prepare_hooks
            {
                let hooks = crate::lifecyclehooks::resolve_repository_hooks(
                    &cfg.caproni,
                    name,
                    crate::lifecyclehooks::HookType::EditModePrepare,
                );

                let hook_result = crate::lifecyclehooks::run_hooks(
                    exec,
                    &cfg.caproni,
                    cfg.resolver.as_ref(),
                    repo_config,
                    name,
                    &hooks,
                    None,
                );

                if let Err(err) = hook_result {
                    result.status = UpdateStatus::Failed;
                    result.notes = err.to_string();
                    success = false;
                    results.push(result);

                    break;
                }
            }

            if result.status == UpdateStatus::Failed {
                success = false;
            }

            results.push(result);
        }

        (results, success)
    }

    /// Ported from `(*Updater).updateRepository`. Performs update for a
    /// single repository with pre-calculated required repos.
    // Ported from the Go original's own `//nolint:gocyclo,cyclop,funlen`:
    // acceptable complexity for comprehensive update decision logic.
    #[allow(clippy::too_many_lines)]
    fn update_repository(
        &self,
        repo_name: &str,
        repo_config: &xianyun_core::config::latest::RepositoryConfig,
        caproni_config: &CaproniConfig,
        required_repos: &HashSet<String>,
    ) -> UpdateResult {
        let mut result = UpdateResult {
            repo_name: repo_name.to_string(),
            ..Default::default()
        };

        // Apply filter predicate.
        if let Some(filter) = &self.options.filter
            && !filter(repo_name)
        {
            result.status = UpdateStatus::Skipped;
            result.notes = "Filtered out".to_string();

            return result;
        }

        // Resolve directory path relative to config file.
        let directory = caproni_config.resolve_path(&repo_config.directory);

        // Detect repository state.
        let mut state = match self
            .backend
            .detect_state(&directory, &repo_config.repository)
        {
            Ok(state) => state,
            Err(err) => {
                result.status = UpdateStatus::Failed;
                result.notes = format!("Failed to detect state: {err}");
                result.error = Some(err);

                return result;
            }
        };

        // Populate result with state information.
        state.current_branch.clone_into(&mut result.branch);
        state.default_branch.clone_into(&mut result.default_branch);
        result.commits_behind = state.commits_behind;
        result.commits_ahead = state.commits_ahead;
        state
            .tracking_branch
            .clone_into(&mut result.tracking_branch);

        // No pinned ref: refresh the current branch's upstream so
        // behind/ahead below is accurate.
        if self.should_refresh_tracking(repo_config, &state)
            && let Some(res) = self.refresh_tracking_branch(&directory, &mut state, &mut result)
        {
            return res;
        }

        // Check if this repo is required for edit_mode.
        let is_required = required_repos.contains(repo_name);

        // Strategy-based decision logic.
        if !state.exists && is_required && self.options.strategy != UpdateStrategy::VerifyOnly {
            // Clone missing repos that are required (FullUpdate or MinimalRequired).
            return self.clone_repository(
                &repo_config.repository,
                &directory,
                &repo_config.ref_,
                result,
            );
        }

        if !state.exists && !is_required {
            // Skip repos that aren't required for edit_mode.
            result.status = UpdateStatus::Skipped;
            result.notes = "Not cloned and not required for edit_mode".to_string();

            return result;
        }

        if !state.exists && self.options.strategy == UpdateStrategy::VerifyOnly {
            // VerifyOnly: don't clone, just report.
            result.status = UpdateStatus::Skipped;
            result.notes = "Not cloned (verify-only mode)".to_string();

            return result;
        }

        if self.options.strategy == UpdateStrategy::MinimalRequired && state.exists {
            // MinimalRequired: if repo exists, skip all other checks.
            result.status = UpdateStatus::Skipped;
            result.notes = "Already cloned".to_string();

            return result;
        }

        if !state.is_git_repo {
            // Directory exists but is not a git repository.
            result.status = UpdateStatus::Failed;
            result.notes = "Not a Git repository".to_string();

            return result;
        }

        if !state.remote_matches {
            // Remote URL doesn't match configuration.
            result.status = UpdateStatus::Warning;
            result.notes = "Remote URL mismatch".to_string();

            return result;
        }

        if state.has_uncommitted && !self.options.stash {
            // Uncommitted changes prevent update.
            result.status = UpdateStatus::Dirty;
            result.notes = "Uncommitted changes".to_string();

            return result;
        }

        if state.has_uncommitted && self.options.stash {
            // Stash uncommitted changes if --stash flag is set.
            return self.stash_and_update(&directory, &state, result);
        }

        if !repo_config.ref_.is_empty() {
            // A configured ref pins to a SHA/tag or tracks a branch (before
            // the detached case).
            return self.checkout_ref(&directory, &repo_config.ref_, false, result);
        }

        if state.is_detached {
            // Detached HEAD - skip update.
            result.status = UpdateStatus::Detached;
            result.notes = "Not on any branch".to_string();

            return result;
        }

        if state.commits_ahead > 0 && state.commits_behind > 0 {
            // Branch has diverged (both ahead and behind).
            result.status = UpdateStatus::Diverged;
            result.notes = format!(
                "{} behind, {} ahead of {}",
                state.commits_behind, state.commits_ahead, state.tracking_branch
            );

            return result;
        }

        if state.commits_ahead > 0 {
            // Branch is ahead - can't auto-update.
            result.status = UpdateStatus::Diverged;
            result.notes = format!(
                "{} commits ahead of {}",
                state.commits_ahead, state.tracking_branch
            );

            return result;
        }

        if state.commits_behind > 0 {
            // Branch is behind - update it.
            return self.pull_repository(&directory, result);
        }

        // Repository is clean and up-to-date.
        result.status = UpdateStatus::Updated;
        result.notes = "Already up-to-date".to_string();

        result
    }

    /// Ported from `(*Updater).shouldRefreshTracking`. Reports whether to
    /// fetch the upstream before the behind/ahead check.
    fn should_refresh_tracking(
        &self,
        cfg: &xianyun_core::config::latest::RepositoryConfig,
        state: &RepositoryState,
    ) -> bool {
        self.options.strategy == UpdateStrategy::FullUpdate
            && cfg.ref_.is_empty()
            && state.exists
            && state.is_git_repo
            && state.remote_matches
            && !state.is_detached
            && !state.tracking_branch.is_empty()
            && (!state.has_uncommitted || self.options.stash)
    }

    /// Ported from `(*Updater).refreshTrackingBranch`. Fetches the current
    /// branch's upstream and recomputes behind/ahead. Returns `Some` only
    /// on fetch failure.
    fn refresh_tracking_branch(
        &self,
        directory: &str,
        state: &mut RepositoryState,
        result: &mut UpdateResult,
    ) -> Option<UpdateResult> {
        let (remote, branch) = split_tracking_branch(&state.tracking_branch);

        if let Err(err) = self.backend.fetch(directory, &remote, &branch) {
            result.status = UpdateStatus::Failed;
            result.notes = format!("Fetch failed: {err}");
            result.error = Some(err);

            return Some(std::mem::take(result));
        }

        if let Ok((behind, ahead)) = self.backend.get_commit_counts(directory) {
            state.commits_behind = behind;
            state.commits_ahead = ahead;
            result.commits_behind = behind;
            result.commits_ahead = ahead;
        }

        None
    }

    /// Ported from `(*Updater).pullRepository`. Pulls the latest changes.
    fn pull_repository(&self, directory: &str, mut result: UpdateResult) -> UpdateResult {
        if self.options.strategy == UpdateStrategy::VerifyOnly {
            result.status = UpdateStatus::Updated;
            result.notes = format!(
                "Would pull {} commits (verify-only mode)",
                result.commits_behind
            );

            return result;
        }

        // Upstream already refreshed (refresh_tracking_branch/checkout_ref),
        // so this needs no network.
        if let Err(err) = self.backend.merge_ff_only(directory) {
            result.status = UpdateStatus::Failed;
            result.notes = format!("Pull failed: {err}");
            result.error = Some(err);

            return result;
        }

        result.status = UpdateStatus::Updated;
        result.notes = format!("Pulled {} commits", result.commits_behind);
        result.commits_behind = 0;

        result
    }

    /// Ported from `(*Updater).cloneRepository`. Clones a missing
    /// repository, checking out `ref_` if configured.
    fn clone_repository(
        &self,
        repo_url: &str,
        directory: &str,
        ref_: &str,
        mut result: UpdateResult,
    ) -> UpdateResult {
        if self.options.strategy == UpdateStrategy::VerifyOnly {
            result.status = UpdateStatus::Updated;
            if ref_.is_empty() {
                result.notes = "Would clone (verify-only mode)".to_string();
            } else {
                result.notes = format!("Would clone and check out ref {ref_:?} (verify-only mode)");
            }

            return result;
        }

        if let Err(err) = self.backend.ensure_cloned(repo_url, directory, "on-demand") {
            result.status = UpdateStatus::Failed;
            result.notes = format!("Clone failed: {err}");
            result.error = Some(err);

            return result;
        }

        if !ref_.is_empty() {
            // Freshly cloned repo already has all refs; skip the redundant fetch.
            return self.checkout_ref(directory, ref_, true, result);
        }

        result.status = UpdateStatus::Updated;
        result.notes = "Cloned".to_string();

        result
    }

    /// Ported from `(*Updater).checkoutRef`. Checks out the ref: a
    /// detached SHA/tag is pinned, a branch is fast-forwarded.
    fn checkout_ref(
        &self,
        directory: &str,
        ref_: &str,
        skip_fetch: bool,
        mut result: UpdateResult,
    ) -> UpdateResult {
        result.ref_ = ref_.to_string();

        if self.options.strategy == UpdateStrategy::VerifyOnly {
            result.status = UpdateStatus::Updated;
            result.notes = format!("Would check out ref {ref_:?} (verify-only mode)");

            return result;
        }

        if !skip_fetch {
            let mut fetch_result = self.backend.fetch(directory, "origin", ref_);
            if fetch_result.is_err() {
                // Commit-ID fallback: fetch all branches when a direct
                // commit fetch is refused.
                fetch_result = self.backend.fetch(directory, "origin", "");
            }

            if let Err(err) = fetch_result {
                result.status = UpdateStatus::Failed;
                result.notes = format!("Fetch failed: {err}");
                result.error = Some(err);

                return result;
            }
        }

        if let Err(err) = self.backend.checkout(directory, ref_) {
            result.status = UpdateStatus::Failed;
            result.notes = format!("Checkout of ref {ref_:?} failed: {err}");
            result.error = Some(err);

            return result;
        }

        let detached = match self.backend.is_detached(directory) {
            Ok(detached) => detached,
            Err(err) => {
                result.status = UpdateStatus::Failed;
                result.notes = format!("Detecting HEAD state failed: {err}");
                result.error = Some(err);

                return result;
            }
        };

        if detached {
            // Detached HEAD (SHA or tag): pin, do not advance.
            result.status = UpdateStatus::Pinned;
            result.notes = format!("Pinned at {ref_}");

            return result;
        }

        // A branch: fast-forward to the just-fetched tip.
        if let Err(err) = self.backend.merge_ff_only(directory) {
            result.status = UpdateStatus::Failed;
            result.notes = format!("Fast-forward of branch {ref_:?} failed: {err}");
            result.error = Some(err);

            return result;
        }

        result.status = UpdateStatus::Updated;
        result.notes = format!("Checked out and fast-forwarded branch {ref_}");

        result
    }

    /// Ported from `(*Updater).stashAndUpdate`. Stashes uncommitted
    /// changes and then updates.
    fn stash_and_update(
        &self,
        directory: &str,
        _state: &RepositoryState,
        mut result: UpdateResult,
    ) -> UpdateResult {
        if self.options.strategy == UpdateStrategy::VerifyOnly {
            result.status = UpdateStatus::Updated;
            result.notes = "Would stash and update (verify-only mode)".to_string();

            return result;
        }

        if let Err(err) = self.backend.stash_push(directory, "caproni update --stash") {
            result.status = UpdateStatus::Failed;
            result.notes = format!("Stash failed: {err}");
            result.error = Some(err);

            return result;
        }

        self.pull_repository(directory, result)
    }
}

/// Ported from the package-level `splitTrackingBranch` helper. Splits a
/// remote branch name like `"origin/master"` into the remote and branch
/// names (`"origin"`, `"master"`).
fn split_tracking_branch(tracking_branch: &str) -> (String, String) {
    match tracking_branch.split_once('/') {
        Some((remote, branch)) => (remote.to_string(), branch.to_string()),
        None => ("origin".to_string(), tracking_branch.to_string()),
    }
}

/// Ported from `FormatTable` in `output.go`. Go's original renders a
/// `pterm`-styled table with ANSI colors via `termutil`; no equivalent
/// terminal-styling crate is in this workspace yet (see `PORT_NOTES.md`),
/// so this port renders a plain-text table with the same columns and
/// content, without color.
pub fn format_table(results: &[UpdateResult], quiet: bool) -> String {
    if results.is_empty() {
        return "No repositories to update.\n".to_string();
    }

    let header = ["Repository", "Branch", "Status", "Behind", "Ahead", "Notes"];
    let mut rows: Vec<[String; 6]> = Vec::with_capacity(results.len());

    for result in results {
        let branch = if result.branch.is_empty() {
            match result.status {
                UpdateStatus::Detached => "detached".to_string(),
                UpdateStatus::Pinned => result.ref_.clone(),
                _ => "-".to_string(),
            }
        } else {
            result.branch.clone()
        };

        let behind = format_count(result.commits_behind, result.status);
        let ahead = format_count(result.commits_ahead, result.status);

        let notes = if !quiet && result.notes.is_empty() {
            result
                .error
                .as_ref()
                .map_or_else(|| result.notes.clone(), ToString::to_string)
        } else {
            result.notes.clone()
        };

        rows.push([
            truncate(&result.repo_name, 25),
            truncate(&branch, 20),
            result.status.to_string(),
            behind,
            ahead,
            truncate(&notes, 40),
        ]);
    }

    let mut widths: [usize; 6] = header.map(str::len);
    for row in &rows {
        for (i, cell) in row.iter().enumerate() {
            widths[i] = widths[i].max(cell.len());
        }
    }

    let mut out = String::from("Repository Update Summary\n\n");
    for (i, h) in header.iter().enumerate() {
        out.push_str(&format!("{:<width$}  ", h, width = widths[i]));
    }
    out.push('\n');

    for row in &rows {
        for (i, cell) in row.iter().enumerate() {
            out.push_str(&format!("{:<width$}  ", cell, width = widths[i]));
        }
        out.push('\n');
    }

    out
}

/// Ported from `FormatSummary` in `output.go`.
#[must_use]
pub fn format_summary(results: &[UpdateResult]) -> String {
    let total = results.len();
    let mut updated = 0;
    let mut pinned = 0;
    let mut warnings = 0;
    let mut failed = 0;
    let mut skipped = 0;

    for result in results {
        match result.status {
            UpdateStatus::Updated => updated += 1,
            UpdateStatus::Pinned => pinned += 1,
            UpdateStatus::Diverged
            | UpdateStatus::Dirty
            | UpdateStatus::Detached
            | UpdateStatus::Warning => warnings += 1,
            UpdateStatus::Failed => failed += 1,
            UpdateStatus::Skipped => skipped += 1,
        }
    }

    let mut b = String::new();
    b.push('\n');
    b.push_str("Summary:");
    b.push('\n');
    b.push_str(&format!("  {total} total repositories\n"));

    if updated > 0 {
        b.push_str(&format!("  {updated} updated successfully\n"));
    }

    if pinned > 0 {
        b.push_str(&format!("  {pinned} pinned to a ref\n"));
    }

    if warnings > 0 {
        b.push_str(&format!("  {warnings} need attention\n"));
    }

    if failed > 0 {
        b.push_str(&format!("  {failed} failed\n"));
    }

    if skipped > 0 {
        b.push_str(&format!("  {skipped} skipped\n"));
    }

    b
}

/// Ported from `FormatSuggestions` in `output.go`. Generates actionable
/// suggestions for repositories needing attention.
#[must_use]
pub fn format_suggestions(results: &[UpdateResult]) -> String {
    let needs_attention: Vec<&UpdateResult> = results
        .iter()
        .filter(|result| {
            matches!(
                result.status,
                UpdateStatus::Diverged
                    | UpdateStatus::Dirty
                    | UpdateStatus::Detached
                    | UpdateStatus::Warning
            )
        })
        .collect();

    if needs_attention.is_empty() {
        return String::new();
    }

    let mut b = String::new();
    b.push('\n');
    b.push_str("Repositories needing attention:");
    b.push('\n');

    for result in needs_attention {
        let suggestion = get_suggestion(result);
        b.push_str(&format!(
            "  \u{2022} {} ({}): {suggestion}\n",
            result.repo_name, result.branch
        ));
    }

    b
}

/// Ported from `formatCount` in `output.go`.
fn format_count(count: i64, status: UpdateStatus) -> String {
    match status {
        UpdateStatus::Skipped
        | UpdateStatus::Detached
        | UpdateStatus::Failed
        | UpdateStatus::Pinned => "-".to_string(),
        UpdateStatus::Updated
        | UpdateStatus::Diverged
        | UpdateStatus::Dirty
        | UpdateStatus::Warning => count.to_string(),
    }
}

/// Ported from `getSuggestion` in `output.go`. Returns a helpful
/// suggestion for a result that needs attention.
fn get_suggestion(result: &UpdateResult) -> String {
    match result.status {
        UpdateStatus::Dirty => "Commit or stash changes, then run 'caproni update'".to_string(),
        UpdateStatus::Detached => {
            format!(
                "Checkout a branch with 'git checkout {}'",
                result.default_branch
            )
        }
        UpdateStatus::Diverged => {
            if result.commits_ahead > 0 && result.commits_behind > 0 {
                "Run 'git pull --rebase' or merge and push".to_string()
            } else if result.commits_ahead > 0 {
                "Push local commits or rebase with remote".to_string()
            } else {
                "Pull latest changes".to_string()
            }
        }
        UpdateStatus::Warning => {
            if result.notes.contains("Remote URL") {
                "Verify remote configuration with 'git remote -v'".to_string()
            } else {
                "Check repository configuration".to_string()
            }
        }
        UpdateStatus::Updated
        | UpdateStatus::Pinned
        | UpdateStatus::Failed
        | UpdateStatus::Skipped => "Manual intervention required".to_string(),
    }
}

/// Ported from `truncate` in `output.go`. Truncates a string to a maximum
/// length, adding an ellipsis if needed.
fn truncate(s: &str, max_len: usize) -> String {
    if s.len() <= max_len {
        return s.to_string();
    }

    if max_len <= 3 {
        return s.chars().take(max_len).collect();
    }

    let mut truncated: String = s.chars().take(max_len - 3).collect();
    truncated.push_str("...");

    truncated
}
#[cfg(test)]
mod tests {
    use super::*;
    use std::sync::Arc;

    use xianyun_backends::git::GitError;
    use xianyun_core::config::global::GlobalConfig;
    use xianyun_core::config::latest::{
        CaproniConfig, DeployerConfig, LifecycleHookConfig, MirrorConfig, ReloaderConfig,
        RepositoryConfig,
    };
    use xianyun_core::config::types::NetworkConfig;
    use xianyun_core::orderedmap::OrderedMap;
    use xianyun_core::variables::resolver::Resolver;

    use crate::testutil::{MockCommandRunner, MockGitBackend};

    const TEST_REPO_NAME: &str = "gitlab";

    /// Ported from `errTestCloneFailed`, `errTestExitStatus1`,
    /// `errTestFetchFailed`, `errTestPullFailed`. Go's sentinel `errors.New`
    /// values become `GitError::Other` so they carry through
    /// `UpdateResult.error` the same way a wrapped Go error does.
    fn err_test_clone_failed() -> GitError {
        GitError::Other("clone failed: network error".to_string())
    }

    fn err_test_exit_status1() -> GitError {
        GitError::Other("exit status 1".to_string())
    }

    fn err_test_fetch_failed() -> GitError {
        GitError::Other("fetch failed: network error".to_string())
    }

    fn err_test_pull_failed() -> GitError {
        GitError::Other("pull failed".to_string())
    }

    /// A minimal [`Resolver`] test double, standing in for the real
    /// `variables::resolver::new_resolver`'s `Resolver`. Ported tests only
    /// need a [`Container`] that constructs without panicking; they do not
    /// exercise variable expansion.
    #[derive(Default)]
    struct TestResolver;

    impl Resolver for TestResolver {
        fn expand(&self, _name: &str) -> String {
            String::new()
        }

        fn all(&self) -> std::collections::HashMap<String, String> {
            std::collections::HashMap::new()
        }

        fn lookup(&self, _name: &str) -> Option<String> {
            None
        }
    }

    fn empty_caproni_config() -> CaproniConfig {
        CaproniConfig {
            config_dir: "/test".to_string(),
            repositories: Some(OrderedMap::new()),
            deployers: Some(OrderedMap::new()),
            reloaders: Some(OrderedMap::new()),
            ..Default::default()
        }
    }

    /// Ported from `newTestConfigBox`. Ensures `Cluster.Network` is non-nil so
    /// the variables resolver can compute `CAPRONI_PRIMARY_HOSTNAME` when
    /// lifecycle hooks enumerate variables.
    fn new_test_container(mut caproni_config: CaproniConfig) -> Container {
        if caproni_config.cluster.network.is_none() {
            caproni_config.cluster.network = Some(NetworkConfig {
                hostname: "test.example.com".to_string(),
                ..Default::default()
            });
        }

        Container {
            global: GlobalConfig::default(),
            caproni: caproni_config,
            resolver: Box::new(TestResolver),
        }
    }

    /// Ported from `newRefTestConfig`.
    fn new_ref_test_config(ref_: &str, edit_mode: bool) -> CaproniConfig {
        let mut cfg = empty_caproni_config();
        cfg.repositories.as_mut().unwrap().set(
            TEST_REPO_NAME.to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/gitlab.git".to_string(),
                directory: "gitlab".to_string(),
                ref_: ref_.to_string(),
                edit_mode,
                ..Default::default()
            },
        );

        cfg
    }

    /// Ported from `cleanExistingState`.
    fn clean_existing_state() -> RepositoryState {
        RepositoryState {
            exists: true,
            is_git_repo: true,
            current_branch: "main".to_string(),
            remote_matches: true,
            ..Default::default()
        }
    }

    /// Ported from `noRefTrackingConfig`.
    fn no_ref_tracking_config() -> CaproniConfig {
        let mut cfg = empty_caproni_config();
        cfg.repositories.as_mut().unwrap().set(
            "gitlab".to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/gitlab.git".to_string(),
                directory: "gitlab".to_string(),
                ..Default::default()
            },
        );

        cfg
    }

    // --- Ported from TestDetermineRequiredRepositories ---

    #[test]
    fn determine_required_repositories_no_deployers_or_reloaders() {
        let cfg = empty_caproni_config();
        let result = determine_required_repositories(&cfg);
        assert!(result.is_empty());
    }

    #[test]
    fn determine_required_repositories_edit_mode_deployer() {
        let mut cfg = empty_caproni_config();
        cfg.deployers.as_mut().unwrap().set(
            "gitlab-deployer".to_string(),
            DeployerConfig {
                edit_mode: true,
                repository: Some(TEST_REPO_NAME.to_string()),
                ..Default::default()
            },
        );

        let result = determine_required_repositories(&cfg);
        assert_eq!(
            result,
            std::collections::HashSet::from([TEST_REPO_NAME.to_string()])
        );
    }

    #[test]
    fn determine_required_repositories_non_edit_mode_deployer() {
        let mut cfg = empty_caproni_config();
        cfg.deployers.as_mut().unwrap().set(
            "gitlab-deployer".to_string(),
            DeployerConfig {
                edit_mode: false,
                repository: Some(TEST_REPO_NAME.to_string()),
                ..Default::default()
            },
        );

        let result = determine_required_repositories(&cfg);
        assert!(result.is_empty());
    }

    #[test]
    fn determine_required_repositories_edit_mode_reloader() {
        let mut cfg = empty_caproni_config();
        cfg.reloaders.as_mut().unwrap().set(
            "gitlab-reloader".to_string(),
            ReloaderConfig {
                edit_mode: true,
                repository: TEST_REPO_NAME.to_string(),
                ..Default::default()
            },
        );

        let result = determine_required_repositories(&cfg);
        assert_eq!(
            result,
            std::collections::HashSet::from([TEST_REPO_NAME.to_string()])
        );
    }

    #[test]
    fn determine_required_repositories_edit_mode_repository() {
        let mut cfg = empty_caproni_config();
        cfg.repositories.as_mut().unwrap().set(
            TEST_REPO_NAME.to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/gitlab.git".to_string(),
                directory: "./gitlab/".to_string(),
                edit_mode: true,
                ..Default::default()
            },
        );

        let result = determine_required_repositories(&cfg);
        assert_eq!(
            result,
            std::collections::HashSet::from([TEST_REPO_NAME.to_string()])
        );
    }

    #[test]
    fn determine_required_repositories_multiple_edit_mode_items() {
        let mut cfg = empty_caproni_config();
        cfg.deployers.as_mut().unwrap().set(
            "gitlab-deployer".to_string(),
            DeployerConfig {
                edit_mode: true,
                repository: Some(TEST_REPO_NAME.to_string()),
                ..Default::default()
            },
        );
        cfg.deployers.as_mut().unwrap().set(
            "charts-deployer".to_string(),
            DeployerConfig {
                edit_mode: true,
                repository: Some("charts".to_string()),
                ..Default::default()
            },
        );
        cfg.reloaders.as_mut().unwrap().set(
            "gitlab-reloader".to_string(),
            ReloaderConfig {
                edit_mode: true,
                repository: "gitlab".to_string(),
                ..Default::default()
            },
        );

        let result = determine_required_repositories(&cfg);
        assert_eq!(
            result,
            std::collections::HashSet::from(["gitlab".to_string(), "charts".to_string()])
        );
    }

    // --- Ported from TestUpdateRepositories_StrategyFullUpdate ---

    #[test]
    fn update_repositories_strategy_full_update() {
        let mock_backend = Arc::new(MockGitBackend::new());

        let mut caproni_config = empty_caproni_config();
        caproni_config.repositories.as_mut().unwrap().set(
            "gitlab".to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/gitlab.git".to_string(),
                directory: "gitlab".to_string(),
                ..Default::default()
            },
        );
        caproni_config.deployers.as_mut().unwrap().set(
            "gitlab-deployer".to_string(),
            DeployerConfig {
                edit_mode: true,
                repository: Some(TEST_REPO_NAME.to_string()),
                ..Default::default()
            },
        );

        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: false,
                ..Default::default()
            }),
        );
        mock_backend.expect_ensure_cloned(
            "https://gitlab.com/gitlab-org/gitlab.git",
            "/test/gitlab",
            "on-demand",
            Ok(()),
        );

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) =
            updater.update_repositories(&mock_executor, &new_test_container(caproni_config));

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].repo_name, "gitlab");
        assert_eq!(results[0].status, UpdateStatus::Updated);
        assert_eq!(results[0].notes, "Cloned");
    }

    // --- Ported from TestUpdateRepositories_ExistingRepoPinnedSHA ---

    #[test]
    fn update_repositories_existing_repo_pinned_sha() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(clean_existing_state()),
        );
        mock_backend.expect_fetch("/test/gitlab", "origin", "abc123", Ok(()));
        mock_backend.expect_checkout("/test/gitlab", "abc123", Ok(()));
        mock_backend.expect_is_detached("/test/gitlab", Ok(true));

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(new_ref_test_config("abc123", false)),
        );

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Pinned);
        assert_eq!(results[0].notes, "Pinned at abc123");
        assert_eq!(results[0].ref_, "abc123");
        mock_backend.assert_not_called("MergeFFOnly");
    }

    // --- Ported from TestUpdateRepositories_ExistingRepoRefBranch ---

    #[test]
    fn update_repositories_existing_repo_ref_branch() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(clean_existing_state()),
        );
        mock_backend.expect_fetch("/test/gitlab", "origin", "feature-branch", Ok(()));
        mock_backend.expect_checkout("/test/gitlab", "feature-branch", Ok(()));
        mock_backend.expect_is_detached("/test/gitlab", Ok(false));
        mock_backend.expect_merge_ff_only("/test/gitlab", Ok(()));

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(new_ref_test_config("feature-branch", false)),
        );

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Updated);
        assert_eq!(
            results[0].notes,
            "Checked out and fast-forwarded branch feature-branch"
        );
    }

    // --- Ported from TestUpdateRepositories_CloneWithRef ---

    #[test]
    fn update_repositories_clone_with_ref() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: false,
                ..Default::default()
            }),
        );
        mock_backend.expect_ensure_cloned(
            "https://gitlab.com/gitlab-org/gitlab.git",
            "/test/gitlab",
            "on-demand",
            Ok(()),
        );
        mock_backend.expect_checkout("/test/gitlab", "v1.2.3", Ok(()));
        mock_backend.expect_is_detached("/test/gitlab", Ok(true));

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                skip_prepare_hooks: true,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(new_ref_test_config("v1.2.3", true)),
        );

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Pinned);
        assert_eq!(results[0].notes, "Pinned at v1.2.3");
    }

    // --- Ported from TestUpdateRepositories_RefCheckoutFailed ---

    #[test]
    fn update_repositories_ref_checkout_failed() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(clean_existing_state()),
        );
        mock_backend.expect_fetch("/test/gitlab", "origin", "abc123", Ok(()));
        mock_backend.expect_checkout("/test/gitlab", "abc123", Err(err_test_exit_status1()));

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(new_ref_test_config("abc123", false)),
        );

        assert!(!success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Failed);
        assert!(results[0].notes.contains("Checkout of ref"));
        mock_backend.assert_not_called("IsDetached");
    }

    // --- Ported from TestUpdateRepositories_RefVerifyOnly ---

    #[test]
    fn update_repositories_ref_verify_only() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(clean_existing_state()),
        );

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::VerifyOnly,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(new_ref_test_config("abc123", false)),
        );

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Updated);
        assert!(results[0].notes.contains("Would check out ref"));
        mock_backend.assert_not_called("Checkout");
    }

    // --- Ported from TestUpdateRepositories_StrategyMinimalRequired ---

    #[test]
    fn update_repositories_strategy_minimal_required() {
        let mock_backend = Arc::new(MockGitBackend::new());

        let mut caproni_config = empty_caproni_config();
        caproni_config.repositories.as_mut().unwrap().set(
            "gitlab".to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/gitlab.git".to_string(),
                directory: "gitlab".to_string(),
                ..Default::default()
            },
        );
        caproni_config.deployers.as_mut().unwrap().set(
            "gitlab-deployer".to_string(),
            DeployerConfig {
                edit_mode: true,
                repository: Some(TEST_REPO_NAME.to_string()),
                ..Default::default()
            },
        );

        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: true,
                ..Default::default()
            }),
        );

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::MinimalRequired,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) =
            updater.update_repositories(&mock_executor, &new_test_container(caproni_config));

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].repo_name, "gitlab");
        assert_eq!(results[0].status, UpdateStatus::Skipped);
        assert_eq!(results[0].notes, "Already cloned");
    }

    // --- Ported from TestUpdateRepositories_StrategyVerifyOnly ---

    #[test]
    fn update_repositories_strategy_verify_only() {
        let mock_backend = Arc::new(MockGitBackend::new());

        let mut caproni_config = empty_caproni_config();
        caproni_config.repositories.as_mut().unwrap().set(
            "gitlab".to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/gitlab.git".to_string(),
                directory: "gitlab".to_string(),
                ..Default::default()
            },
        );
        caproni_config.deployers.as_mut().unwrap().set(
            "gitlab-deployer".to_string(),
            DeployerConfig {
                edit_mode: true,
                repository: Some(TEST_REPO_NAME.to_string()),
                ..Default::default()
            },
        );

        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: false,
                ..Default::default()
            }),
        );

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::VerifyOnly,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) =
            updater.update_repositories(&mock_executor, &new_test_container(caproni_config));

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].repo_name, "gitlab");
        assert_eq!(results[0].status, UpdateStatus::Skipped);
        assert_eq!(results[0].notes, "Not cloned (verify-only mode)");
        mock_backend.assert_not_called("EnsureCloned");
    }

    // --- Ported from TestUpdateRepositories_NonRequiredRepoNotCloned ---

    #[test]
    fn update_repositories_non_required_repo_not_cloned() {
        let mock_backend = Arc::new(MockGitBackend::new());

        let mut caproni_config = empty_caproni_config();
        caproni_config.repositories.as_mut().unwrap().set(
            "gitlab".to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/gitlab.git".to_string(),
                directory: "gitlab".to_string(),
                ..Default::default()
            },
        );

        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: false,
                ..Default::default()
            }),
        );

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) =
            updater.update_repositories(&mock_executor, &new_test_container(caproni_config));

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].repo_name, "gitlab");
        assert_eq!(results[0].status, UpdateStatus::Skipped);
        assert_eq!(
            results[0].notes,
            "Not cloned and not required for edit_mode"
        );
        mock_backend.assert_not_called("EnsureCloned");
    }

    // --- Ported from TestUpdateRepositories_ExistingRepoNeedsPull ---

    #[test]
    fn update_repositories_existing_repo_needs_pull() {
        let mock_backend = Arc::new(MockGitBackend::new());

        let mut caproni_config = empty_caproni_config();
        caproni_config.repositories.as_mut().unwrap().set(
            "gitlab".to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/gitlab.git".to_string(),
                directory: "gitlab".to_string(),
                ..Default::default()
            },
        );

        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: true,
                is_git_repo: true,
                current_branch: "main".to_string(),
                tracking_branch: "origin/main".to_string(),
                commits_behind: 5,
                commits_ahead: 0,
                remote_matches: true,
                has_uncommitted: false,
                ..Default::default()
            }),
        );
        mock_backend.expect_fetch("/test/gitlab", "origin", "main", Ok(()));
        mock_backend.expect_get_commit_counts("/test/gitlab", Ok((5, 0)));
        mock_backend.expect_merge_ff_only("/test/gitlab", Ok(()));

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) =
            updater.update_repositories(&mock_executor, &new_test_container(caproni_config));

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].repo_name, "gitlab");
        assert_eq!(results[0].status, UpdateStatus::Updated);
        assert_eq!(results[0].notes, "Pulled 5 commits");
    }

    // --- Ported from TestUpdateRepositories_NoRefRefreshDiscoversBehind ---
    //
    // Regression test for the silent no-update bug: DetectState is
    // network-free and reports 0 behind, but the scoped fetch of the current
    // branch reveals new upstream commits.

    #[test]
    fn update_repositories_no_ref_refresh_discovers_behind() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: true,
                is_git_repo: true,
                current_branch: "main".to_string(),
                tracking_branch: "origin/main".to_string(),
                commits_behind: 0,
                remote_matches: true,
                ..Default::default()
            }),
        );
        mock_backend.expect_fetch("/test/gitlab", "origin", "main", Ok(()));
        mock_backend.expect_get_commit_counts("/test/gitlab", Ok((2, 0)));
        mock_backend.expect_merge_ff_only("/test/gitlab", Ok(()));

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(no_ref_tracking_config()),
        );

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Updated);
        assert_eq!(results[0].notes, "Pulled 2 commits");
    }

    // --- Ported from TestUpdateRepositories_NoRefRefreshUpToDate ---
    //
    // Confirms the refresh fetch runs but no fast-forward happens when the
    // branch is genuinely current.

    #[test]
    fn update_repositories_no_ref_refresh_up_to_date() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: true,
                is_git_repo: true,
                current_branch: "main".to_string(),
                tracking_branch: "origin/main".to_string(),
                remote_matches: true,
                ..Default::default()
            }),
        );
        mock_backend.expect_fetch("/test/gitlab", "origin", "main", Ok(()));
        mock_backend.expect_get_commit_counts("/test/gitlab", Ok((0, 0)));

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(no_ref_tracking_config()),
        );

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Updated);
        assert_eq!(results[0].notes, "Already up-to-date");
        mock_backend.assert_not_called("MergeFFOnly");
    }

    // --- Ported from TestUpdateRepositories_NoRefNoUpstreamSkipsFetch ---
    //
    // Confirms a branch with no upstream is left untouched (no fetch, no
    // branch switching).

    #[test]
    fn update_repositories_no_ref_no_upstream_skips_fetch() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: true,
                is_git_repo: true,
                current_branch: "wip".to_string(),
                remote_matches: true,
                ..Default::default()
            }),
        );

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(no_ref_tracking_config()),
        );

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Updated);
        assert_eq!(results[0].notes, "Already up-to-date");
        mock_backend.assert_not_called("Fetch");
    }

    // --- Ported from TestUpdateRepositories_NoRefFetchFailed ---
    //
    // Confirms a failed refresh fetch surfaces as a failure rather than a
    // silent up-to-date.

    #[test]
    fn update_repositories_no_ref_fetch_failed() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: true,
                is_git_repo: true,
                current_branch: "main".to_string(),
                tracking_branch: "origin/main".to_string(),
                remote_matches: true,
                ..Default::default()
            }),
        );
        mock_backend.expect_fetch(
            "/test/gitlab",
            "origin",
            "main",
            Err(err_test_fetch_failed()),
        );

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(no_ref_tracking_config()),
        );

        assert!(!success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Failed);
        assert!(results[0].notes.contains("Fetch failed"));
        mock_backend.assert_not_called("MergeFFOnly");
    }

    // --- Ported from TestUpdateRepositories_NoRefRefreshNonOriginRemote ---
    //
    // Confirms the refresh fetches from the remote the branch actually
    // tracks, not always origin.

    #[test]
    fn update_repositories_no_ref_refresh_non_origin_remote() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: true,
                is_git_repo: true,
                current_branch: "main".to_string(),
                tracking_branch: "upstream/main".to_string(),
                remote_matches: true,
                ..Default::default()
            }),
        );
        mock_backend.expect_fetch("/test/gitlab", "upstream", "main", Ok(()));
        mock_backend.expect_get_commit_counts("/test/gitlab", Ok((1, 0)));
        mock_backend.expect_merge_ff_only("/test/gitlab", Ok(()));

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(no_ref_tracking_config()),
        );

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Updated);
        assert_eq!(results[0].notes, "Pulled 1 commits");
    }

    // --- Ported from TestUpdateRepositories_RefShaFetchFallback ---
    //
    // Confirms that when a scoped fetch of a commit ID is refused, caproni
    // falls back to a full fetch before checkout.

    #[test]
    fn update_repositories_ref_sha_fetch_fallback() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(clean_existing_state()),
        );
        mock_backend.expect_fetch(
            "/test/gitlab",
            "origin",
            "abc123",
            Err(err_test_fetch_failed()),
        );
        mock_backend.expect_fetch("/test/gitlab", "origin", "", Ok(()));
        mock_backend.expect_checkout("/test/gitlab", "abc123", Ok(()));
        mock_backend.expect_is_detached("/test/gitlab", Ok(true));

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(new_ref_test_config("abc123", false)),
        );

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Pinned);
        assert_eq!(results[0].notes, "Pinned at abc123");
    }

    // --- Ported from TestUpdateRepositories_DirtyRepository ---

    #[test]
    fn update_repositories_dirty_repository() {
        let mock_backend = Arc::new(MockGitBackend::new());

        let mut caproni_config = empty_caproni_config();
        caproni_config.repositories.as_mut().unwrap().set(
            "gitlab".to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/gitlab.git".to_string(),
                directory: "gitlab".to_string(),
                ..Default::default()
            },
        );

        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: true,
                is_git_repo: true,
                current_branch: "main".to_string(),
                has_uncommitted: true,
                remote_matches: true,
                ..Default::default()
            }),
        );

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                stash: false,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) =
            updater.update_repositories(&mock_executor, &new_test_container(caproni_config));

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].repo_name, "gitlab");
        assert_eq!(results[0].status, UpdateStatus::Dirty);
        assert_eq!(results[0].notes, "Uncommitted changes");
        mock_backend.assert_not_called("MergeFFOnly");
    }

    // --- Ported from TestUpdateRepositories_StashAndUpdate ---

    #[test]
    fn update_repositories_stash_and_update() {
        let mock_backend = Arc::new(MockGitBackend::new());

        let mut caproni_config = empty_caproni_config();
        caproni_config.repositories.as_mut().unwrap().set(
            "gitlab".to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/gitlab.git".to_string(),
                directory: "gitlab".to_string(),
                ..Default::default()
            },
        );

        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: true,
                is_git_repo: true,
                current_branch: "main".to_string(),
                tracking_branch: "origin/main".to_string(),
                commits_behind: 3,
                has_uncommitted: true,
                remote_matches: true,
                ..Default::default()
            }),
        );
        mock_backend.expect_fetch("/test/gitlab", "origin", "main", Ok(()));
        mock_backend.expect_get_commit_counts("/test/gitlab", Ok((3, 0)));
        mock_backend.expect_stash_push("/test/gitlab", "caproni update --stash", Ok(()));
        mock_backend.expect_merge_ff_only("/test/gitlab", Ok(()));

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                stash: true,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) =
            updater.update_repositories(&mock_executor, &new_test_container(caproni_config));

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].repo_name, "gitlab");
        assert_eq!(results[0].status, UpdateStatus::Updated);
        assert_eq!(results[0].notes, "Pulled 3 commits");
    }

    // --- Ported from TestUpdateRepositories_DivergedRepository ---

    #[test]
    fn update_repositories_diverged_repository() {
        let mock_backend = Arc::new(MockGitBackend::new());

        let mut caproni_config = empty_caproni_config();
        caproni_config.repositories.as_mut().unwrap().set(
            "gitlab".to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/gitlab.git".to_string(),
                directory: "gitlab".to_string(),
                ..Default::default()
            },
        );

        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: true,
                is_git_repo: true,
                current_branch: "main".to_string(),
                tracking_branch: "origin/main".to_string(),
                commits_behind: 5,
                commits_ahead: 3,
                remote_matches: true,
                ..Default::default()
            }),
        );
        mock_backend.expect_fetch("/test/gitlab", "origin", "main", Ok(()));
        mock_backend.expect_get_commit_counts("/test/gitlab", Ok((5, 3)));

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) =
            updater.update_repositories(&mock_executor, &new_test_container(caproni_config));

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].repo_name, "gitlab");
        assert_eq!(results[0].status, UpdateStatus::Diverged);
        assert_eq!(results[0].notes, "5 behind, 3 ahead of origin/main");
        mock_backend.assert_not_called("MergeFFOnly");
    }

    // --- Ported from TestUpdateRepositories_DetachedHead ---

    #[test]
    fn update_repositories_detached_head() {
        let mock_backend = Arc::new(MockGitBackend::new());

        let mut caproni_config = empty_caproni_config();
        caproni_config.repositories.as_mut().unwrap().set(
            "gitlab".to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/gitlab.git".to_string(),
                directory: "gitlab".to_string(),
                ..Default::default()
            },
        );

        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: true,
                is_git_repo: true,
                is_detached: true,
                remote_matches: true,
                ..Default::default()
            }),
        );

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) =
            updater.update_repositories(&mock_executor, &new_test_container(caproni_config));

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].repo_name, "gitlab");
        assert_eq!(results[0].status, UpdateStatus::Detached);
        assert_eq!(results[0].notes, "Not on any branch");
    }

    // --- Ported from TestUpdateRepositories_FilterPredicate ---

    #[test]
    fn update_repositories_filter_predicate() {
        let mock_backend = Arc::new(MockGitBackend::new());

        let mut caproni_config = empty_caproni_config();
        caproni_config.repositories.as_mut().unwrap().set(
            "gitlab".to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/gitlab.git".to_string(),
                directory: "gitlab".to_string(),
                ..Default::default()
            },
        );
        caproni_config.repositories.as_mut().unwrap().set(
            "charts".to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/charts/gitlab.git".to_string(),
                directory: "charts".to_string(),
                ..Default::default()
            },
        );

        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: true,
                is_git_repo: true,
                current_branch: "main".to_string(),
                remote_matches: true,
                ..Default::default()
            }),
        );

        let filter: RepoFilterFn = Box::new(|repo_name: &str| repo_name == "gitlab");
        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                filter: Some(filter),
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) =
            updater.update_repositories(&mock_executor, &new_test_container(caproni_config));

        assert!(success);
        assert_eq!(results.len(), 2);

        assert_eq!(results[0].repo_name, "gitlab");
        assert_eq!(results[0].status, UpdateStatus::Updated);
        assert_eq!(results[0].notes, "Already up-to-date");

        assert_eq!(results[1].repo_name, "charts");
        assert_eq!(results[1].status, UpdateStatus::Skipped);
        assert_eq!(results[1].notes, "Filtered out");

        // No expectation was registered for "/test/charts": if the code
        // under test called `detect_state` for the filtered-out repo, the
        // mock would panic on an unmatched call rather than silently
        // succeed, which is the same guarantee Go's
        // `mockBackend.AssertNotCalled(t, "DetectState", ctx, "/test/charts", ...)`
        // gives (this mock's `assert_not_called` only tracks method names,
        // not per-argument calls; see PORT_NOTES.md).
    }

    // --- Ported from TestUpdateRepositories_FailureReturnsFailedStatus ---

    #[test]
    fn update_repositories_failure_returns_failed_status() {
        let mock_backend = Arc::new(MockGitBackend::new());

        let mut caproni_config = empty_caproni_config();
        caproni_config.repositories.as_mut().unwrap().set(
            "gitlab".to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/gitlab.git".to_string(),
                directory: "gitlab".to_string(),
                ..Default::default()
            },
        );
        caproni_config.deployers.as_mut().unwrap().set(
            "gitlab-deployer".to_string(),
            DeployerConfig {
                edit_mode: true,
                repository: Some(TEST_REPO_NAME.to_string()),
                ..Default::default()
            },
        );

        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: false,
                ..Default::default()
            }),
        );
        mock_backend.expect_ensure_cloned(
            "https://gitlab.com/gitlab-org/gitlab.git",
            "/test/gitlab",
            "on-demand",
            Err(err_test_clone_failed()),
        );

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) =
            updater.update_repositories(&mock_executor, &new_test_container(caproni_config));

        assert!(!success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].repo_name, "gitlab");
        assert_eq!(results[0].status, UpdateStatus::Failed);
        assert_eq!(
            results[0].notes,
            "Clone failed: clone failed: network error"
        );
        assert_eq!(
            results[0].error.as_ref().map(ToString::to_string),
            Some(err_test_clone_failed().to_string())
        );
    }

    // --- Ported from TestUpdateRepositories_MultipleReposPreservesOrder ---

    #[test]
    fn update_repositories_multiple_repos_preserves_order() {
        let mock_backend = Arc::new(MockGitBackend::new());

        let mut caproni_config = empty_caproni_config();
        let repos = ["first", "second", "third"];
        for name in repos {
            caproni_config.repositories.as_mut().unwrap().set(
                name.to_string(),
                RepositoryConfig {
                    repository: format!("https://example.com/{name}.git"),
                    directory: name.to_string(),
                    ..Default::default()
                },
            );

            mock_backend.expect_detect_state(
                &format!("/test/{name}"),
                &format!("https://example.com/{name}.git"),
                Ok(RepositoryState {
                    exists: true,
                    is_git_repo: true,
                    current_branch: "main".to_string(),
                    remote_matches: true,
                    ..Default::default()
                }),
            );
        }

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) =
            updater.update_repositories(&mock_executor, &new_test_container(caproni_config));

        assert!(success);
        assert_eq!(results.len(), 3);

        for (i, expected_name) in repos.iter().enumerate() {
            assert_eq!(results[i].repo_name, *expected_name);
        }
    }

    // --- Ported from TestUpdateRepositories_RemoteURLMismatch ---

    #[test]
    fn update_repositories_remote_url_mismatch() {
        let mock_backend = Arc::new(MockGitBackend::new());

        let mut caproni_config = empty_caproni_config();
        caproni_config.repositories.as_mut().unwrap().set(
            "gitlab".to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/gitlab.git".to_string(),
                directory: "gitlab".to_string(),
                ..Default::default()
            },
        );

        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: true,
                is_git_repo: true,
                remote_matches: false,
                remote_url: "https://github.com/other/repo.git".to_string(),
                ..Default::default()
            }),
        );

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) =
            updater.update_repositories(&mock_executor, &new_test_container(caproni_config));

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].repo_name, "gitlab");
        assert_eq!(results[0].status, UpdateStatus::Warning);
        assert_eq!(results[0].notes, "Remote URL mismatch");
    }

    // --- Ported from TestUpdateRepositories_NotGitRepository ---

    #[test]
    fn update_repositories_not_git_repository() {
        let mock_backend = Arc::new(MockGitBackend::new());

        let mut caproni_config = empty_caproni_config();
        caproni_config.repositories.as_mut().unwrap().set(
            "gitlab".to_string(),
            RepositoryConfig {
                repository: "https://gitlab.com/gitlab-org/gitlab.git".to_string(),
                directory: "gitlab".to_string(),
                ..Default::default()
            },
        );

        mock_backend.expect_detect_state(
            "/test/gitlab",
            "https://gitlab.com/gitlab-org/gitlab.git",
            Ok(RepositoryState {
                exists: true,
                is_git_repo: false,
                ..Default::default()
            }),
        );

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let mock_executor = MockCommandRunner::new();
        let (results, success) =
            updater.update_repositories(&mock_executor, &new_test_container(caproni_config));

        assert!(!success); // StatusFailed should result in success = false
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].repo_name, "gitlab");
        assert_eq!(results[0].status, UpdateStatus::Failed);
        assert_eq!(results[0].notes, "Not a Git repository");
    }

    // --- Ported from TestUpdateRepositories_Hooks ---
    //
    // Go's table test used one closure-typed struct field per optional mock
    // setup step; this port splits each case into its own test function
    // instead, since Rust closures capturing `&mut MockGitBackend`/
    // `&MockCommandRunner` with differing captures don't fit a single
    // homogeneous table row as cleanly as Go's `func(t, *mocks.Backend)`.

    const HOOKS_REPO_URL: &str = "https://gitlab.com/gitlab-org/gitlab.git";

    fn up_to_date_state() -> RepositoryState {
        RepositoryState {
            exists: true,
            is_git_repo: true,
            current_branch: "main".to_string(),
            remote_matches: true,
            ..Default::default()
        }
    }

    fn dirty_state() -> RepositoryState {
        RepositoryState {
            exists: true,
            is_git_repo: true,
            current_branch: "main".to_string(),
            remote_matches: true,
            has_uncommitted: true,
            ..Default::default()
        }
    }

    /// Ported from the per-case config construction shared by all
    /// `TestUpdateRepositories_Hooks` subtests.
    fn hooks_test_config(hooks: Vec<LifecycleHookConfig>) -> CaproniConfig {
        let mut cfg = empty_caproni_config();
        cfg.repositories.as_mut().unwrap().set(
            "gitlab".to_string(),
            RepositoryConfig {
                repository: HOOKS_REPO_URL.to_string(),
                directory: "gitlab".to_string(),
                ..Default::default()
            },
        );
        cfg.reloaders.as_mut().unwrap().set(
            "gitlab-reloader".to_string(),
            ReloaderConfig {
                repository: "gitlab".to_string(),
                mirror: Some(MirrorConfig {
                    lifecycle_hooks: hooks,
                    ..Default::default()
                }),
                ..Default::default()
            },
        );

        cfg
    }

    #[test]
    fn update_repositories_hooks_hook_runs_successfully() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state("/test/gitlab", HOOKS_REPO_URL, Ok(up_to_date_state()));

        let mock_executor = MockCommandRunner::new();
        mock_executor.expect_run_in_repository("/test/gitlab", "make", &["prepare"], Ok(()));

        let hooks = vec![LifecycleHookConfig {
            hook_type: "edit_mode_prepare".to_string(),
            script: "make prepare".to_string(),
            ..Default::default()
        }];

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(hooks_test_config(hooks)),
        );

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Updated);
    }

    #[test]
    fn update_repositories_hooks_hook_script_parsing_fails() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state("/test/gitlab", HOOKS_REPO_URL, Ok(up_to_date_state()));

        let mock_executor = MockCommandRunner::new();

        let hooks = vec![LifecycleHookConfig {
            hook_type: "edit_mode_prepare".to_string(),
            script: "unterminated 'single quote".to_string(),
            ..Default::default()
        }];

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(hooks_test_config(hooks)),
        );

        assert!(!success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Failed);
        assert!(results[0].notes.contains("parsing hook"));
    }

    #[test]
    fn update_repositories_hooks_hook_execution_fails() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state("/test/gitlab", HOOKS_REPO_URL, Ok(up_to_date_state()));

        let mock_executor = MockCommandRunner::new();
        mock_executor.expect_run_in_repository(
            "/test/gitlab",
            "make",
            &["prepare"],
            Err(err_test_exit_status1_exec()),
        );

        let hooks = vec![LifecycleHookConfig {
            hook_type: "edit_mode_prepare".to_string(),
            script: "make prepare".to_string(),
            ..Default::default()
        }];

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(hooks_test_config(hooks)),
        );

        assert!(!success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Failed);
        assert!(
            results[0]
                .notes
                .contains("running [make prepare] in repo gitlab")
        );
    }

    #[test]
    fn update_repositories_hooks_non_prepare_hooks_are_ignored() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state("/test/gitlab", HOOKS_REPO_URL, Ok(up_to_date_state()));

        let mock_executor = MockCommandRunner::new();
        mock_executor.expect_run_in_repository("/test/gitlab", "make", &["prepare"], Ok(()));

        let hooks = vec![
            LifecycleHookConfig {
                hook_type: "edit_mode_start".to_string(),
                script: "make start".to_string(),
                ..Default::default()
            },
            LifecycleHookConfig {
                hook_type: "edit_mode_prepare".to_string(),
                script: "make prepare".to_string(),
                ..Default::default()
            },
        ];

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(hooks_test_config(hooks)),
        );

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Updated);
    }

    #[test]
    fn update_repositories_hooks_multiple_hooks_second_fails() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state("/test/gitlab", HOOKS_REPO_URL, Ok(up_to_date_state()));

        let mock_executor = MockCommandRunner::new();
        mock_executor.expect_run_in_repository("/test/gitlab", "make", &["first"], Ok(()));
        mock_executor.expect_run_in_repository(
            "/test/gitlab",
            "make",
            &["second"],
            Err(err_test_exit_status1_exec()),
        );

        let hooks = vec![
            LifecycleHookConfig {
                hook_type: "edit_mode_prepare".to_string(),
                script: "make first".to_string(),
                ..Default::default()
            },
            LifecycleHookConfig {
                hook_type: "edit_mode_prepare".to_string(),
                script: "make second".to_string(),
                ..Default::default()
            },
        ];

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(hooks_test_config(hooks)),
        );

        assert!(!success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Failed);
        assert!(results[0].notes.contains("make second"));
    }

    #[test]
    fn update_repositories_hooks_not_run_when_repo_is_dirty() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state("/test/gitlab", HOOKS_REPO_URL, Ok(dirty_state()));

        let mock_executor = MockCommandRunner::new();

        let hooks = vec![LifecycleHookConfig {
            hook_type: "edit_mode_prepare".to_string(),
            script: "make prepare".to_string(),
            ..Default::default()
        }];

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(hooks_test_config(hooks)),
        );

        assert!(success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Dirty);
    }

    #[test]
    fn update_repositories_hooks_not_run_when_pull_fails() {
        let mock_backend = Arc::new(MockGitBackend::new());
        mock_backend.expect_detect_state(
            "/test/gitlab",
            HOOKS_REPO_URL,
            Ok(RepositoryState {
                exists: true,
                is_git_repo: true,
                current_branch: "main".to_string(),
                remote_matches: true,
                commits_behind: 1,
                ..Default::default()
            }),
        );
        mock_backend.expect_merge_ff_only("/test/gitlab", Err(err_test_pull_failed()));

        let mock_executor = MockCommandRunner::new();

        let hooks = vec![LifecycleHookConfig {
            hook_type: "edit_mode_prepare".to_string(),
            script: "make prepare".to_string(),
            ..Default::default()
        }];

        let updater = Updater::new(
            mock_backend.clone(),
            UpdateOptions {
                strategy: UpdateStrategy::FullUpdate,
                ..Default::default()
            },
        );
        let (results, success) = updater.update_repositories(
            &mock_executor,
            &new_test_container(hooks_test_config(hooks)),
        );

        assert!(!success);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].status, UpdateStatus::Failed);
        assert!(results[0].notes.contains("Pull failed"));
    }

    /// `xianyun_executor::exec::ExecError` stand-in for Go's
    /// `executor.ErrCommandFailed` sentinel used by the hooks execution
    /// tests.
    fn err_test_exit_status1_exec() -> xianyun_executor::exec::ExecError {
        xianyun_executor::exec::ExecError::CommandFailed(1)
    }
}