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::{
error::parse_glab_error,
runner::{CommandRunner, RealCommandRunner},
};
#[derive(Debug, Clone)]
pub struct GitLabPipelineProvider<R: CommandRunner = RealCommandRunner> {
repo: String,
runner: R,
}
impl GitLabPipelineProvider<RealCommandRunner> {
#[must_use]
pub fn new(repo: impl Into<String>) -> Self {
Self {
repo: repo.into(),
runner: RealCommandRunner,
}
}
}
impl<R: CommandRunner> GitLabPipelineProvider<R> {
#[must_use]
pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
Self {
repo: repo.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.unwrap_or_else(Utc::now),
updated_at: api.updated_at.unwrap_or_else(Utc::now),
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(),
}
}
}
#[derive(Debug, Deserialize)]
struct PipelineWithJobs {
#[serde(default)]
jobs: Vec<JobApiResponse>,
}
#[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, "--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])
.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 ci view`");
let id_str = pipeline_id.to_string();
let output = self
.runner
.run(
"glab",
&[
"ci", "view", &id_str, "--repo", &self.repo, "--output", "json",
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab ci view: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
if let Ok(jobs) = serde_json::from_slice::<Vec<JobApiResponse>>(&output.stdout) {
return Ok(jobs.into_iter().map(JobData::from).collect());
}
let pipeline: PipelineWithJobs =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(pipeline.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 >= cutoff)
.collect();
let total_runs = recent.len() 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()
.map(|p| (p.updated_at - p.created_at).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");
}
#[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_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_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(_)
));
}
}