#[cfg(all(test, feature = "broken-tests"))]
mod coverage_tests_part1 {
use super::*;
use chrono::TimeZone;
use std::fs;
use tempfile::TempDir;
fn create_test_config(temp_dir: &TempDir) -> RoadmapConfig {
RoadmapConfig {
enabled: true,
path: temp_dir.path().join("roadmap.md"),
auto_generate_todos: true,
enforce_quality_gates: true,
require_task_ids: true,
task_id_pattern: "PMAT-[0-9]{4}".to_string(),
quality_gates: QualityGateConfig::default(),
git: GitConfig {
create_branches: false, branch_pattern: "feature/{task_id}".to_string(),
commit_pattern: "{task_id}: {message}".to_string(),
require_quality_check: false, },
tracking: TrackingConfig::default(),
}
}
fn create_sample_roadmap(path: &Path) -> Roadmap {
let task = Task {
id: "PMAT-0001".to_string(),
description: "Test task description".to_string(),
status: TaskStatus::Planned,
complexity: Complexity::Medium,
priority: Priority::P1,
assignee: Some("developer".to_string()),
started_at: None,
completed_at: None,
};
let sprint = Sprint {
version: "v1.0.0".to_string(),
title: "Test Sprint".to_string(),
start_date: Utc.with_ymd_and_hms(2025, 1, 1, 0, 0, 0).unwrap(),
end_date: Utc.with_ymd_and_hms(2025, 1, 15, 0, 0, 0).unwrap(),
priority: Priority::P0,
tasks: vec![task],
definition_of_done: vec![
"All tests pass".to_string(),
"Documentation updated".to_string(),
],
quality_gates: vec!["Coverage > 80%".to_string()],
};
let mut roadmap = Roadmap {
current_sprint: Some("v1.0.0".to_string()),
sprints: HashMap::new(),
backlog: Vec::new(),
completed_sprints: Vec::new(),
};
roadmap.sprints.insert("v1.0.0".to_string(), sprint);
roadmap.to_file(path).expect("Failed to write roadmap");
roadmap
}
#[test]
fn test_status_subcommand_parsing_with_sprint() {
let cmd = RoadmapCommand::try_parse_from([
"roadmap", "status", "--sprint", "v1.0.0", "--format", "json",
]);
assert!(cmd.is_ok());
if let Ok(parsed) = cmd {
match parsed.command {
RoadmapSubcommand::Status {
sprint,
task,
format,
} => {
assert_eq!(sprint, Some("v1.0.0".to_string()));
assert!(task.is_none());
assert_eq!(format, OutputFormat::Json);
}
_ => panic!("Expected Status subcommand"),
}
}
}
#[test]
fn test_status_subcommand_parsing_with_task() {
let cmd = RoadmapCommand::try_parse_from([
"roadmap",
"status",
"--task",
"PMAT-0001",
"--format",
"json",
]);
assert!(cmd.is_ok());
if let Ok(parsed) = cmd {
match parsed.command {
RoadmapSubcommand::Status {
sprint,
task,
format,
} => {
assert!(sprint.is_none());
assert_eq!(task, Some("PMAT-0001".to_string()));
assert_eq!(format, OutputFormat::Json);
}
_ => panic!("Expected Status subcommand"),
}
}
}
#[test]
fn test_validate_subcommand_parsing() {
let cmd = RoadmapCommand::try_parse_from([
"roadmap", "validate", "--sprint", "v1.0.0", "--strict",
]);
assert!(cmd.is_ok());
if let Ok(parsed) = cmd {
match parsed.command {
RoadmapSubcommand::Validate { sprint, strict } => {
assert_eq!(sprint, "v1.0.0");
assert!(strict);
}
_ => panic!("Expected Validate subcommand"),
}
}
}
#[test]
fn test_validate_subcommand_without_strict() {
let cmd = RoadmapCommand::try_parse_from(["roadmap", "validate", "--sprint", "v2.0.0"]);
assert!(cmd.is_ok());
if let Ok(parsed) = cmd {
match parsed.command {
RoadmapSubcommand::Validate { sprint, strict } => {
assert_eq!(sprint, "v2.0.0");
assert!(!strict);
}
_ => panic!("Expected Validate subcommand"),
}
}
}
#[test]
fn test_quality_check_subcommand_parsing() {
let cmd =
RoadmapCommand::try_parse_from(["roadmap", "quality-check", "--task-id", "PMAT-1234"]);
assert!(cmd.is_ok());
if let Ok(parsed) = cmd {
match parsed.command {
RoadmapSubcommand::QualityCheck { task_id } => {
assert_eq!(task_id, "PMAT-1234");
}
_ => panic!("Expected QualityCheck subcommand"),
}
}
}
#[test]
fn test_init_subcommand_with_defaults() {
let cmd = RoadmapCommand::try_parse_from([
"roadmap",
"init",
"--version",
"v3.0.0",
"--title",
"New Sprint",
]);
assert!(cmd.is_ok());
if let Ok(parsed) = cmd {
match parsed.command {
RoadmapSubcommand::Init {
version,
title,
duration_days,
priority,
} => {
assert_eq!(version, "v3.0.0");
assert_eq!(title, "New Sprint");
assert_eq!(duration_days, 14); assert_eq!(priority, "P0"); }
_ => panic!("Expected Init subcommand"),
}
}
}
#[test]
fn test_todos_subcommand_defaults() {
let cmd = RoadmapCommand::try_parse_from(["roadmap", "todos"]);
assert!(cmd.is_ok());
if let Ok(parsed) = cmd {
match parsed.command {
RoadmapSubcommand::Todos {
sprint,
output,
include_quality_gates,
} => {
assert!(sprint.is_none());
assert_eq!(output, PathBuf::from("todos.md")); assert!(!include_quality_gates); }
_ => panic!("Expected Todos subcommand"),
}
}
}
#[test]
fn test_start_subcommand_defaults() {
let cmd = RoadmapCommand::try_parse_from(["roadmap", "start", "PMAT-5001"]);
assert!(cmd.is_ok());
if let Ok(parsed) = cmd {
match parsed.command {
RoadmapSubcommand::Start {
task_id,
create_branch,
} => {
assert_eq!(task_id, "PMAT-5001");
assert!(!create_branch); }
_ => panic!("Expected Start subcommand"),
}
}
}
#[test]
fn test_complete_subcommand_defaults() {
let cmd = RoadmapCommand::try_parse_from(["roadmap", "complete", "PMAT-6001"]);
assert!(cmd.is_ok());
if let Ok(parsed) = cmd {
match parsed.command {
RoadmapSubcommand::Complete {
task_id,
skip_quality_check,
} => {
assert_eq!(task_id, "PMAT-6001");
assert!(!skip_quality_check); }
_ => panic!("Expected Complete subcommand"),
}
}
}
#[tokio::test]
async fn test_init_sprint_creates_new_roadmap() {
let temp_dir = TempDir::new().unwrap();
let roadmap_path = temp_dir.path().join("new_roadmap.md");
let result = init_sprint(&roadmap_path, "v1.0.0", "Initial Sprint", 14, "P0").await;
assert!(result.is_ok());
assert!(roadmap_path.exists());
let roadmap = Roadmap::from_file(&roadmap_path).unwrap();
assert_eq!(roadmap.current_sprint, Some("v1.0.0".to_string()));
assert!(roadmap.sprints.contains_key("v1.0.0"));
}
#[tokio::test]
async fn test_init_sprint_adds_to_existing_roadmap() {
let temp_dir = TempDir::new().unwrap();
let roadmap_path = temp_dir.path().join("existing_roadmap.md");
create_sample_roadmap(&roadmap_path);
let result = init_sprint(&roadmap_path, "v2.0.0", "Second Sprint", 7, "P1").await;
assert!(result.is_ok());
let roadmap = Roadmap::from_file(&roadmap_path).unwrap();
assert!(roadmap.sprints.contains_key("v1.0.0"));
assert!(roadmap.sprints.contains_key("v2.0.0"));
assert_eq!(roadmap.current_sprint, Some("v1.0.0".to_string()));
}
#[tokio::test]
async fn test_init_sprint_with_invalid_priority() {
let temp_dir = TempDir::new().unwrap();
let roadmap_path = temp_dir.path().join("roadmap.md");
let result = init_sprint(&roadmap_path, "v1.0.0", "Test", 14, "INVALID").await;
assert!(result.is_ok());
let roadmap = Roadmap::from_file(&roadmap_path).unwrap();
let sprint = roadmap.get_sprint("v1.0.0").unwrap();
assert_eq!(sprint.priority, Priority::P0); }
#[tokio::test]
async fn test_start_task_updates_status() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let result = start_task(&config.path, "PMAT-0001", false, &config).await;
assert!(result.is_ok());
let roadmap = Roadmap::from_file(&config.path).unwrap();
let task = roadmap.get_task("PMAT-0001").unwrap();
assert_eq!(task.status, TaskStatus::InProgress);
}
#[tokio::test]
async fn test_start_task_nonexistent() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let result = start_task(&config.path, "PMAT-9999", false, &config).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_complete_task_with_skip_quality_check() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
start_task(&config.path, "PMAT-0001", false, &config)
.await
.unwrap();
let result = complete_task(&config.path, "PMAT-0001", true, &config).await;
assert!(result.is_ok());
let roadmap = Roadmap::from_file(&config.path).unwrap();
let task = roadmap.get_task("PMAT-0001").unwrap();
assert_eq!(task.status, TaskStatus::Completed);
}
#[tokio::test]
async fn test_show_status_with_sprint() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let result = show_status(&config.path, Some("v1.0.0"), None, OutputFormat::Json).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_show_status_with_task() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let result = show_status(&config.path, None, Some("PMAT-0001"), OutputFormat::Json).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_show_status_uses_current_sprint() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let result = show_status(&config.path, None, None, OutputFormat::Json).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_show_status_nonexistent_sprint() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let result = show_status(&config.path, Some("v99.0.0"), None, OutputFormat::Json).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_validate_sprint_all_completed() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
let roadmap_path = &config.path;
let task = Task {
id: "PMAT-0001".to_string(),
description: "Test task".to_string(),
status: TaskStatus::Completed,
complexity: Complexity::Medium,
priority: Priority::P1,
assignee: None,
started_at: Some(Utc::now()),
completed_at: Some(Utc::now()),
};
let sprint = Sprint {
version: "v1.0.0".to_string(),
title: "Complete Sprint".to_string(),
start_date: Utc::now(),
end_date: Utc::now(),
priority: Priority::P0,
tasks: vec![task],
definition_of_done: vec!["All tests pass".to_string()],
quality_gates: vec!["Coverage > 80%".to_string()],
};
let mut roadmap = Roadmap {
current_sprint: Some("v1.0.0".to_string()),
sprints: HashMap::new(),
backlog: Vec::new(),
completed_sprints: Vec::new(),
};
roadmap.sprints.insert("v1.0.0".to_string(), sprint);
roadmap.to_file(roadmap_path).unwrap();
let result = validate_sprint(roadmap_path, "v1.0.0", false, &config).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_validate_sprint_incomplete_strict() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let result = validate_sprint(&config.path, "v1.0.0", true, &config).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_validate_sprint_incomplete_non_strict() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let result = validate_sprint(&config.path, "v1.0.0", false, &config).await;
assert!(result.is_ok());
}
}