use async_trait::async_trait;
use chrono::{DateTime, Utc};
use gitflow_core::{
CoreError, Result,
pipeline::{JobData, PipelineProvider, PipelineReport, PipelineStatus, PipelineStatusEnum},
};
use serde::Deserialize;
use tracing::debug;
use crate::{
commit::encode_project_path,
error::parse_glab_error,
runner::{CommandRunner, RealCommandRunner},
};
#[derive(Debug, Clone)]
pub struct GitLabPipelineProvider<R: CommandRunner = RealCommandRunner> {
repo: String,
repo_target: String,
runner: R,
}
impl GitLabPipelineProvider<RealCommandRunner> {
#[must_use]
pub fn new(repo: impl Into<String>) -> Self {
let repo = repo.into();
Self {
repo_target: repo.clone(),
repo,
runner: RealCommandRunner,
}
}
#[must_use]
pub fn with_session(session: &gitflow_core::Session) -> Self {
let repo = session.repo.clone();
Self {
repo_target: repo.clone(),
repo,
runner: RealCommandRunner,
}
}
#[must_use]
pub fn with_remote_url(repo: impl Into<String>, remote_url: impl Into<String>) -> Self {
Self {
repo: repo.into(),
repo_target: remote_url.into(),
runner: RealCommandRunner,
}
}
}
impl<R: CommandRunner> GitLabPipelineProvider<R> {
#[must_use]
pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
let repo = repo.into();
Self {
repo_target: repo.clone(),
repo,
runner,
}
}
#[must_use]
pub fn with_runner_and_repo_target(
repo: impl Into<String>,
repo_target: impl Into<String>,
runner: R,
) -> Self {
Self {
repo: repo.into(),
repo_target: repo_target.into(),
runner,
}
}
}
#[derive(Debug, Clone, Deserialize)]
#[allow(
dead_code,
reason = "Used for deserialization; not all fields are read"
)]
struct PipelineApiResponse {
id: u64,
#[serde(default)]
ref_name: Option<String>,
#[serde(alias = "ref")]
#[serde(default)]
git_ref: Option<String>,
#[serde(default)]
status: String,
#[serde(default)]
created_at: Option<DateTime<Utc>>,
#[serde(default)]
updated_at: Option<DateTime<Utc>>,
#[serde(default)]
web_url: Option<String>,
#[serde(default)]
sha: Option<String>,
}
impl PipelineApiResponse {
fn effective_ref(&self) -> String {
self.ref_name
.clone()
.or_else(|| self.git_ref.clone())
.unwrap_or_default()
}
}
fn parse_pipeline_status(status: &str) -> PipelineStatusEnum {
match status {
"running" => PipelineStatusEnum::Running,
"success" => PipelineStatusEnum::Success,
"failed" => PipelineStatusEnum::Failed,
"canceled" | "cancelled" => PipelineStatusEnum::Cancelled,
_ => PipelineStatusEnum::Pending,
}
}
impl From<PipelineApiResponse> for PipelineStatus {
fn from(api: PipelineApiResponse) -> Self {
let status_enum = parse_pipeline_status(&api.status);
let conclusion = if api.status == "success" {
Some("success".into())
} else if api.status == "failed" {
Some("failure".into())
} else if api.status == "canceled" || api.status == "cancelled" {
Some("cancelled".into())
} else {
None
};
Self {
id: api.id,
ref_name: api.effective_ref(),
status: status_enum,
conclusion,
created_at: api.created_at,
updated_at: api.updated_at,
url: api.web_url.unwrap_or_default(),
}
}
}
#[derive(Debug, Clone, Deserialize)]
#[allow(
dead_code,
reason = "Used for deserialization; not all fields are read"
)]
struct JobApiResponse {
id: u64,
#[serde(default)]
name: String,
#[serde(default)]
status: String,
#[serde(default)]
stage: Option<String>,
#[serde(default)]
started_at: Option<DateTime<Utc>>,
#[serde(default)]
finished_at: Option<DateTime<Utc>>,
#[serde(default)]
web_url: Option<String>,
}
impl From<JobApiResponse> for JobData {
fn from(api: JobApiResponse) -> Self {
let conclusion = if api.status == "success" {
Some("success".into())
} else if api.status == "failed" {
Some("failure".into())
} else if api.status == "canceled" || api.status == "cancelled" {
Some("cancelled".into())
} else {
None
};
Self {
id: api.id,
name: api.name,
status: api.status,
conclusion,
started_at: api.started_at,
completed_at: api.finished_at,
url: api.web_url.unwrap_or_default(),
}
}
}
#[async_trait]
impl<R: CommandRunner + 'static> PipelineProvider for GitLabPipelineProvider<R> {
async fn status(&self, branch: &str) -> Result<Vec<PipelineStatus>> {
debug!(repo = %self.repo, branch, "spawning `glab ci list`");
let output = self
.runner
.run(
"glab",
&[
"ci",
"list",
"--repo",
&self.repo_target,
"--ref",
branch,
"--output",
"json",
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab ci list: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
let api_responses: Vec<PipelineApiResponse> =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(api_responses
.into_iter()
.map(PipelineStatus::from)
.collect())
}
async fn logs(&self, pipeline_id: u64) -> Result<String> {
debug!(repo = %self.repo, pipeline_id, "spawning `glab ci trace`");
let id_str = pipeline_id.to_string();
let output = self
.runner
.run(
"glab",
&["ci", "trace", &id_str, "--repo", &self.repo_target],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab ci trace: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
Ok(String::from_utf8_lossy(&output.stdout).into_owned())
}
async fn jobs(&self, pipeline_id: u64) -> Result<Vec<JobData>> {
debug!(repo = %self.repo, pipeline_id, "spawning `glab api` GET pipeline jobs");
let encoded_path = encode_project_path(&self.repo);
let api_path = format!("/projects/{encoded_path}/pipelines/{pipeline_id}/jobs");
let output = self
.runner
.run("glab", &["api", &api_path])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab api: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
let jobs: Vec<JobApiResponse> =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(jobs.into_iter().map(JobData::from).collect())
}
async fn report(&self, branch: &str, days: u32) -> Result<PipelineReport> {
debug!(
repo = %self.repo,
branch,
days,
"generating pipeline report"
);
let pipelines = self.status(branch).await?;
let cutoff = Utc::now() - chrono::Duration::days(i64::from(days));
let recent: Vec<&PipelineStatus> = pipelines
.iter()
.filter(|p| p.created_at.is_some_and(|c| c >= cutoff))
.collect();
let total_runs = recent.iter().filter(|p| p.status.is_terminal()).count() as u64;
if total_runs == 0 {
return Ok(PipelineReport {
total_runs: 0,
success_rate: 0.0,
avg_duration_secs: 0.0,
top_failures: vec![],
});
}
let success_count = recent
.iter()
.filter(|p| matches!(p.status, PipelineStatusEnum::Success))
.count() as u64;
let success_rate = {
#[allow(
clippy::cast_precision_loss,
reason = "Pipeline counts never exceed f64 precision"
)]
{
success_count as f64 / total_runs as f64
}
};
#[allow(
clippy::cast_precision_loss,
reason = "Duration values never exceed f64 precision"
)]
let durations: Vec<f64> = recent
.iter()
.filter_map(|p| {
let created = p.created_at?;
let updated = p.updated_at?;
Some((updated - created).num_seconds().max(0) as f64)
})
.filter(|d| *d > 0.0)
.collect();
let avg_duration_secs = if durations.is_empty() {
0.0
} else {
#[allow(
clippy::cast_precision_loss,
reason = "Duration length never exceeds f64 precision"
)]
{
durations.iter().sum::<f64>() / durations.len() as f64
}
};
let mut failure_refs: Vec<String> = recent
.iter()
.filter(|p| matches!(p.status, PipelineStatusEnum::Failed))
.map(|p| p.ref_name.clone())
.collect();
failure_refs.sort();
failure_refs.dedup();
Ok(PipelineReport {
total_runs,
success_rate,
avg_duration_secs,
top_failures: failure_refs,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::runner::MockCommandRunner;
#[test]
fn test_should_construct_gitlab_pipeline_provider() {
let provider = GitLabPipelineProvider::new("gitlab-org/gitlab");
assert_eq!(provider.repo, "gitlab-org/gitlab");
}
#[test]
fn test_should_construct_gitlab_pipeline_provider_from_string() {
let repo = String::from("gitlab-org/gitlab");
let provider = GitLabPipelineProvider::new(repo);
assert_eq!(provider.repo, "gitlab-org/gitlab");
}
#[tokio::test]
async fn test_should_use_explicit_repo_target_for_logs() {
let runner = MockCommandRunner::success("log output");
let provider = GitLabPipelineProvider::with_runner_and_repo_target(
"owner/repo",
"https://192.168.230.23/iproost/proxy/api-src.git",
runner.clone(),
);
let result = provider.logs(99).await;
assert!(result.is_ok(), "expected Ok, got {result:?}");
assert_eq!(
runner.recorded_calls()[0].1,
vec![
"ci",
"trace",
"99",
"--repo",
"https://192.168.230.23/iproost/proxy/api-src.git",
]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
#[test]
fn test_should_debug_format_pipeline_provider() {
let provider = GitLabPipelineProvider::new("owner/repo");
let debug = format!("{provider:?}");
assert!(debug.contains("GitLabPipelineProvider"));
assert!(debug.contains("owner/repo"));
}
#[test]
fn test_should_clone_gitlab_pipeline_provider() {
let original = GitLabPipelineProvider::new("owner/repo");
let cloned = original.clone();
assert_eq!(original.repo, cloned.repo);
}
#[test]
fn test_should_deserialize_pipeline_api_response() {
let json = br#"{
"id": 12345,
"ref_name": "main",
"status": "success",
"created_at": "2026-01-15T09:30:00Z",
"updated_at": "2026-01-15T09:35:00Z",
"web_url": "https://gitlab.com/gitlab-org/gitlab/-/pipelines/12345"
}"#;
let api: PipelineApiResponse =
serde_json::from_slice(json).expect("valid PipelineApiResponse");
assert_eq!(api.id, 12345);
assert_eq!(api.status, "success");
assert_eq!(api.effective_ref(), "main");
}
#[test]
fn test_should_deserialize_pipeline_with_ref_alias() {
let json = br#"{
"id": 12345,
"ref": "main",
"status": "success",
"created_at": "2026-01-15T09:30:00Z",
"updated_at": "2026-01-15T09:35:00Z"
}"#;
let api: PipelineApiResponse =
serde_json::from_slice(json).expect("valid PipelineApiResponse");
assert_eq!(api.effective_ref(), "main");
}
#[test]
fn test_should_convert_pipeline_to_status() {
let api = PipelineApiResponse {
id: 100,
ref_name: Some("main".into()),
git_ref: None,
status: "success".into(),
created_at: Some("2026-01-01T00:00:00Z".parse().expect("valid date")),
updated_at: Some("2026-01-01T00:05:00Z".parse().expect("valid date")),
web_url: Some("https://gitlab.com/org/project/-/pipelines/100".into()),
sha: None,
};
let status: PipelineStatus = api.into();
assert_eq!(status.id, 100);
assert_eq!(status.ref_name, "main");
assert_eq!(status.status, PipelineStatusEnum::Success);
assert_eq!(status.conclusion.as_deref(), Some("success"));
}
#[test]
fn test_should_keep_pipeline_timestamps_none_when_api_omits_them() {
let api = PipelineApiResponse {
id: 101,
ref_name: Some("main".into()),
git_ref: None,
status: "success".into(),
created_at: None,
updated_at: None,
web_url: None,
sha: None,
};
let status: PipelineStatus = api.into();
assert!(
status.created_at.is_none(),
"missing created_at must stay None, not fall back to Utc::now()"
);
assert!(
status.updated_at.is_none(),
"missing updated_at must stay None, not fall back to Utc::now()"
);
}
#[test]
fn test_should_parse_pipeline_status_enum() {
assert_eq!(
parse_pipeline_status("running"),
PipelineStatusEnum::Running
);
assert_eq!(
parse_pipeline_status("success"),
PipelineStatusEnum::Success
);
assert_eq!(parse_pipeline_status("failed"), PipelineStatusEnum::Failed);
assert_eq!(
parse_pipeline_status("canceled"),
PipelineStatusEnum::Cancelled
);
assert_eq!(
parse_pipeline_status("cancelled"),
PipelineStatusEnum::Cancelled
);
assert_eq!(
parse_pipeline_status("pending"),
PipelineStatusEnum::Pending
);
assert_eq!(
parse_pipeline_status("created"),
PipelineStatusEnum::Pending
);
assert_eq!(
parse_pipeline_status("unknown"),
PipelineStatusEnum::Pending
);
}
#[test]
fn test_should_deserialize_job_api_response() {
let json = br#"{
"id": 5001,
"name": "test-unit",
"status": "success",
"stage": "test",
"started_at": "2026-01-15T09:30:00Z",
"finished_at": "2026-01-15T09:35:00Z",
"web_url": "https://gitlab.com/org/project/-/jobs/5001"
}"#;
let api: JobApiResponse = serde_json::from_slice(json).expect("valid JobApiResponse");
let job: JobData = api.into();
assert_eq!(job.id, 5001);
assert_eq!(job.name, "test-unit");
assert_eq!(job.status, "success");
assert_eq!(job.conclusion.as_deref(), Some("success"));
}
#[test]
fn test_should_deserialize_failed_job() {
let json = br#"{
"id": 5002,
"name": "test-integration",
"status": "failed",
"started_at": "2026-01-15T09:30:00Z",
"finished_at": "2026-01-15T09:40:00Z",
"web_url": "https://gitlab.com/org/project/-/jobs/5002"
}"#;
let api: JobApiResponse = serde_json::from_slice(json).expect("valid JobApiResponse");
let job: JobData = api.into();
assert_eq!(job.conclusion.as_deref(), Some("failure"));
}
#[test]
fn test_should_deserialize_empty_pipeline_list() {
let json = b"[]";
let list: Vec<PipelineApiResponse> =
serde_json::from_slice(json).expect("valid empty list");
assert!(list.is_empty());
}
#[test]
fn test_should_deserialize_empty_job_list() {
let json = b"[]";
let list: Vec<JobApiResponse> = serde_json::from_slice(json).expect("valid empty list");
assert!(list.is_empty());
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_status() {
let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
let provider = GitLabPipelineProvider::with_runner("owner/repo", runner);
let result = provider.status("main").await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_serialization_error_on_invalid_json_for_status() {
let runner = MockCommandRunner::success("not valid json");
let provider = GitLabPipelineProvider::with_runner("owner/repo", runner);
let result = provider.status("main").await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_logs() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitLabPipelineProvider::with_runner("owner/repo", runner);
let result = provider.logs(12345).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_jobs() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitLabPipelineProvider::with_runner("owner/repo", runner);
let result = provider.jobs(12345).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_serialization_error_on_invalid_json_for_jobs() {
let runner = MockCommandRunner::success("not valid json");
let provider = GitLabPipelineProvider::with_runner("owner/repo", runner);
let result = provider.jobs(12345).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_fetch_jobs_via_glab_api() {
let runner = MockCommandRunner::success(
r#"[{"id":1,"name":"build","status":"success"},{"id":2,"name":"test","status":"running"}]"#,
);
let provider = GitLabPipelineProvider::with_runner("owner/repo", runner.clone());
let jobs = provider.jobs(5).await.expect("should fetch");
assert_eq!(jobs.len(), 2);
assert_eq!(
runner.recorded_calls()[0].1,
vec!["api", "/projects/owner%2Frepo/pipelines/5/jobs"]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
#[tokio::test]
async fn test_should_encode_nested_group_repo_path_for_pipeline_jobs() {
let runner = MockCommandRunner::success(
r#"[{"id":1,"name":"build","status":"success"},{"id":2,"name":"test","status":"running"}]"#,
);
let provider =
GitLabPipelineProvider::with_runner("group/subgroup/project", runner.clone());
let jobs = provider.jobs(5).await.expect("should fetch");
assert_eq!(jobs.len(), 2);
assert_eq!(
runner.recorded_calls()[0].1,
vec![
"api",
"/projects/group%2Fsubgroup%2Fproject/pipelines/5/jobs"
]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_report() {
let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
let provider = GitLabPipelineProvider::with_runner("owner/repo", runner);
let result = provider.report("main", 7).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_serialization_error_on_invalid_json_for_report() {
let runner = MockCommandRunner::success("not valid json");
let provider = GitLabPipelineProvider::with_runner("owner/repo", runner);
let result = provider.report("main", 7).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_exclude_non_terminal_pipelines_from_report_total_runs() {
let now = Utc::now();
let ts = |offset_secs: i64| (now - chrono::Duration::seconds(offset_secs)).to_rfc3339();
let json = format!(
r#"[
{{"id": 1, "ref_name": "main", "status": "success", "created_at": "{}", "updated_at": "{}"}},
{{"id": 2, "ref_name": "main", "status": "success", "created_at": "{}", "updated_at": "{}"}},
{{"id": 3, "ref_name": "main", "status": "failed", "created_at": "{}", "updated_at": "{}"}},
{{"id": 4, "ref_name": "main", "status": "running", "created_at": "{}", "updated_at": "{}"}}
]"#,
ts(600),
ts(300),
ts(500),
ts(200),
ts(400),
ts(100),
ts(60),
ts(30),
);
let runner = MockCommandRunner::success(&json);
let provider = GitLabPipelineProvider::with_runner("owner/repo", runner);
let report = provider
.report("main", 7)
.await
.expect("report should succeed");
assert_eq!(report.total_runs, 3);
assert!((report.success_rate - (2.0 / 3.0)).abs() < f64::EPSILON);
}
#[tokio::test]
async fn test_should_zero_report_when_all_pipelines_are_running() {
let now = Utc::now();
let ts = |offset_secs: i64| (now - chrono::Duration::seconds(offset_secs)).to_rfc3339();
let json = format!(
r#"[{{"id": 1, "ref_name": "main", "status": "running", "created_at": "{}", "updated_at": "{}"}}]"#,
ts(60),
ts(30),
);
let runner = MockCommandRunner::success(&json);
let provider = GitLabPipelineProvider::with_runner("owner/repo", runner);
let report = provider
.report("main", 7)
.await
.expect("report should succeed");
assert_eq!(report.total_runs, 0);
assert!((report.success_rate - 0.0).abs() < f64::EPSILON);
assert!(!report.success_rate.is_nan());
}
#[tokio::test]
async fn test_should_exclude_pipelines_with_missing_created_at_from_report_cutoff() {
let now = Utc::now();
let ts = |offset_secs: i64| (now - chrono::Duration::seconds(offset_secs)).to_rfc3339();
let json = format!(
r#"[
{{"id": 1, "ref_name": "main", "status": "success", "created_at": "{}", "updated_at": "{}"}},
{{"id": 2, "ref_name": "main", "status": "success"}}
]"#,
ts(600),
ts(300),
);
let runner = MockCommandRunner::success(&json);
let provider = GitLabPipelineProvider::with_runner("owner/repo", runner);
let report = provider
.report("main", 7)
.await
.expect("report should succeed");
assert_eq!(
report.total_runs, 1,
"pipeline #2 has no created_at and must be excluded from the report, not counted as \
in-window"
);
}
#[tokio::test]
async fn test_should_exclude_pipeline_with_missing_timestamp_from_duration_average() {
let now = Utc::now();
let ts = |offset_secs: i64| (now - chrono::Duration::seconds(offset_secs)).to_rfc3339();
let json = format!(
r#"[
{{"id": 1, "ref_name": "main", "status": "success", "created_at": "{}", "updated_at": "{}"}},
{{"id": 2, "ref_name": "main", "status": "success", "created_at": "{}"}}
]"#,
ts(600),
ts(300),
ts(500),
);
let runner = MockCommandRunner::success(&json);
let provider = GitLabPipelineProvider::with_runner("owner/repo", runner);
let report = provider
.report("main", 7)
.await
.expect("report should succeed");
assert!(
(report.avg_duration_secs - 300.0).abs() < 1.0,
"expected ~300s average from the one complete sample, got {}",
report.avg_duration_secs
);
}
}