use async_trait::async_trait;
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use crate::Result;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PipelineStatusEnum {
Running,
Success,
Failed,
Cancelled,
Pending,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PipelineStatus {
pub id: u64,
pub ref_name: String,
pub status: PipelineStatusEnum,
#[serde(skip_serializing_if = "Option::is_none")]
pub conclusion: Option<String>,
pub created_at: DateTime<Utc>,
pub updated_at: DateTime<Utc>,
pub url: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct JobData {
pub id: u64,
pub name: String,
pub status: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub conclusion: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub started_at: Option<DateTime<Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub completed_at: Option<DateTime<Utc>>,
pub url: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PipelineReport {
pub total_runs: u64,
pub success_rate: f64,
pub avg_duration_secs: f64,
#[serde(default)]
pub top_failures: Vec<String>,
}
#[async_trait]
pub trait PipelineProvider: std::fmt::Debug + Send + Sync {
async fn status(&self, branch: &str) -> Result<Vec<PipelineStatus>>;
async fn logs(&self, pipeline_id: u64) -> Result<String>;
async fn jobs(&self, pipeline_id: u64) -> Result<Vec<JobData>>;
async fn report(&self, branch: &str, days: u32) -> Result<PipelineReport>;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_should_serialize_pipeline_status_enum_to_snake_case() {
assert_eq!(
serde_json::to_string(&PipelineStatusEnum::Running).expect("serialize"),
"\"running\""
);
assert_eq!(
serde_json::to_string(&PipelineStatusEnum::Success).expect("serialize"),
"\"success\""
);
assert_eq!(
serde_json::to_string(&PipelineStatusEnum::Failed).expect("serialize"),
"\"failed\""
);
assert_eq!(
serde_json::to_string(&PipelineStatusEnum::Cancelled).expect("serialize"),
"\"cancelled\""
);
assert_eq!(
serde_json::to_string(&PipelineStatusEnum::Pending).expect("serialize"),
"\"pending\""
);
}
#[test]
fn test_should_deserialize_pipeline_status_enum_from_snake_case() {
assert_eq!(
serde_json::from_str::<PipelineStatusEnum>("\"running\"").expect("deserialize"),
PipelineStatusEnum::Running
);
assert_eq!(
serde_json::from_str::<PipelineStatusEnum>("\"success\"").expect("deserialize"),
PipelineStatusEnum::Success
);
assert_eq!(
serde_json::from_str::<PipelineStatusEnum>("\"failed\"").expect("deserialize"),
PipelineStatusEnum::Failed
);
assert_eq!(
serde_json::from_str::<PipelineStatusEnum>("\"cancelled\"").expect("deserialize"),
PipelineStatusEnum::Cancelled
);
assert_eq!(
serde_json::from_str::<PipelineStatusEnum>("\"pending\"").expect("deserialize"),
PipelineStatusEnum::Pending
);
}
fn sample_pipeline_status_json() -> &'static str {
r#"{
"id": 12345,
"refName": "main",
"status": "success",
"conclusion": "all checks passed",
"createdAt": "2026-07-01T10:00:00Z",
"updatedAt": "2026-07-01T10:05:30Z",
"url": "https://github.com/example/repo/actions/runs/12345"
}"#
}
#[test]
fn test_should_deserialize_pipeline_status_from_json() {
let json = sample_pipeline_status_json();
let status: PipelineStatus = serde_json::from_str(json).expect("valid PipelineStatus JSON");
assert_eq!(status.id, 12345);
assert_eq!(status.ref_name, "main");
assert_eq!(status.status, PipelineStatusEnum::Success);
assert_eq!(status.conclusion.as_deref(), Some("all checks passed"));
assert_eq!(
status.url,
"https://github.com/example/repo/actions/runs/12345"
);
}
#[test]
fn test_should_deserialize_pipeline_status_with_null_conclusion() {
let json = r#"{
"id": 1,
"refName": "develop",
"status": "running",
"conclusion": null,
"createdAt": "2026-07-02T08:00:00Z",
"updatedAt": "2026-07-02T08:00:00Z",
"url": "https://example.com/1"
}"#;
let status: PipelineStatus = serde_json::from_str(json).expect("deserialize");
assert!(status.conclusion.is_none());
assert_eq!(status.status, PipelineStatusEnum::Running);
}
#[test]
fn test_should_omit_none_conclusion_on_serialize() {
let json = sample_pipeline_status_json();
let mut status: PipelineStatus = serde_json::from_str(json).expect("deserialize");
status.conclusion = None;
let serialized = serde_json::to_string(&status).expect("serialize");
assert!(!serialized.contains("\"conclusion\":null"));
assert!(!serialized.contains("\"conclusion\": null"));
}
fn sample_job_json() -> &'static str {
r#"{
"id": 98765,
"name": "build",
"status": "completed",
"conclusion": "success",
"startedAt": "2026-07-01T10:00:00Z",
"completedAt": "2026-07-01T10:03:00Z",
"url": "https://github.com/example/repo/actions/runs/12345/job/98765"
}"#
}
#[test]
fn test_should_deserialize_job_data_from_json() {
let json = sample_job_json();
let job: JobData = serde_json::from_str(json).expect("valid JobData JSON");
assert_eq!(job.id, 98765);
assert_eq!(job.name, "build");
assert_eq!(job.status, "completed");
assert_eq!(job.conclusion.as_deref(), Some("success"));
assert_eq!(
job.url,
"https://github.com/example/repo/actions/runs/12345/job/98765"
);
}
#[test]
fn test_should_deserialize_job_data_with_null_optional_fields() {
let json = r#"{
"id": 1,
"name": "test",
"status": "queued",
"conclusion": null,
"startedAt": null,
"completedAt": null,
"url": "https://example.com/job/1"
}"#;
let job: JobData = serde_json::from_str(json).expect("deserialize");
assert!(job.conclusion.is_none());
assert!(job.started_at.is_none());
assert!(job.completed_at.is_none());
assert_eq!(job.status, "queued");
}
#[test]
fn test_should_deserialize_job_data_and_roundtrip() {
let json = sample_job_json();
let job: JobData = serde_json::from_str(json).expect("deserialize");
let re_serialized = serde_json::to_string(&job).expect("serialize");
let round_tripped: JobData = serde_json::from_str(&re_serialized).expect("re-deserialize");
assert_eq!(round_tripped.id, job.id);
assert_eq!(round_tripped.name, job.name);
assert_eq!(round_tripped.status, job.status);
assert_eq!(round_tripped.conclusion, job.conclusion);
assert_eq!(round_tripped.url, job.url);
}
#[test]
fn test_should_build_pipeline_report_and_access_fields() {
let report = PipelineReport {
total_runs: 100,
success_rate: 0.95,
avg_duration_secs: 180.5,
top_failures: vec!["timeout".into(), "compile error".into()],
};
assert_eq!(report.total_runs, 100);
assert!((report.success_rate - 0.95).abs() < f64::EPSILON);
assert!((report.avg_duration_secs - 180.5).abs() < f64::EPSILON);
assert_eq!(report.top_failures.len(), 2);
assert_eq!(report.top_failures[0], "timeout");
assert_eq!(report.top_failures[1], "compile error");
}
#[test]
fn test_should_serialize_pipeline_report_to_camel_case() {
let report = PipelineReport {
total_runs: 42,
success_rate: 0.8,
avg_duration_secs: 120.0,
top_failures: vec!["flaky test".into()],
};
let serialized = serde_json::to_string(&report).expect("serialize");
assert!(serialized.contains("\"totalRuns\""));
assert!(serialized.contains("\"successRate\""));
assert!(serialized.contains("\"avgDurationSecs\""));
assert!(serialized.contains("\"topFailures\""));
}
#[test]
fn test_should_deserialize_pipeline_report_with_missing_top_failures() {
let json = r#"{
"totalRuns": 10,
"successRate": 1.0,
"avgDurationSecs": 60.0
}"#;
let report: PipelineReport = serde_json::from_str(json).expect("deserialize");
assert_eq!(report.total_runs, 10);
assert!(report.top_failures.is_empty());
}
}