#[cfg(all(test, feature = "broken-tests"))]
mod coverage_tests_part2 {
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
}
#[tokio::test]
async fn test_generate_todos_with_quality_gates() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let output_path = temp_dir.path().join("todos_output.md");
let result = generate_todos(
&config.path,
Some("v1.0.0"),
&output_path,
true, &config,
)
.await;
assert!(result.is_ok());
assert!(output_path.exists());
let content = fs::read_to_string(&output_path).unwrap();
assert!(content.contains("Quality") || content.contains("Max Complexity"));
}
#[tokio::test]
async fn test_generate_todos_without_quality_gates() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let output_path = temp_dir.path().join("simple_todos.md");
let result = generate_todos(
&config.path,
Some("v1.0.0"),
&output_path,
false, &config,
)
.await;
assert!(result.is_ok());
assert!(output_path.exists());
}
#[tokio::test]
async fn test_generate_todos_uses_current_sprint() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let output_path = temp_dir.path().join("todos.md");
let result = generate_todos(&config.path, None, &output_path, false, &config).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_generate_todos_nonexistent_sprint() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let output_path = temp_dir.path().join("todos.md");
let result =
generate_todos(&config.path, Some("v99.0.0"), &output_path, false, &config).await;
assert!(result.is_err());
}
#[test]
fn test_show_task_status_json() {
let task = Task {
id: "PMAT-0001".to_string(),
description: "Test task".to_string(),
status: TaskStatus::InProgress,
complexity: Complexity::High,
priority: Priority::P0,
assignee: Some("dev".to_string()),
started_at: Some(Utc::now()),
completed_at: None,
};
let mut roadmap = Roadmap {
current_sprint: None,
sprints: HashMap::new(),
backlog: vec![task],
completed_sprints: Vec::new(),
};
let result = show_task_status(&roadmap, "PMAT-0001", OutputFormat::Json);
assert!(result.is_ok());
}
#[test]
fn test_show_task_status_table() {
let task = Task {
id: "PMAT-0002".to_string(),
description: "Another task".to_string(),
status: TaskStatus::Completed,
complexity: Complexity::Low,
priority: Priority::P2,
assignee: None,
started_at: Some(Utc::now()),
completed_at: Some(Utc::now()),
};
let mut roadmap = Roadmap {
current_sprint: None,
sprints: HashMap::new(),
backlog: vec![task],
completed_sprints: Vec::new(),
};
let result = show_task_status(&roadmap, "PMAT-0002", OutputFormat::Table);
assert!(result.is_ok());
}
#[test]
fn test_show_task_status_not_found() {
let roadmap = Roadmap {
current_sprint: None,
sprints: HashMap::new(),
backlog: Vec::new(),
completed_sprints: Vec::new(),
};
let result = show_task_status(&roadmap, "PMAT-9999", OutputFormat::Json);
assert!(result.is_err());
}
#[test]
fn test_display_task_details() {
let task = Task {
id: "PMAT-0003".to_string(),
description: "Display test".to_string(),
status: TaskStatus::Blocked,
complexity: Complexity::Medium,
priority: Priority::P1,
assignee: Some("tester".to_string()),
started_at: Some(Utc::now()),
completed_at: None,
};
display_task_details(&task);
}
#[test]
fn test_display_task_details_with_completed() {
let task = Task {
id: "PMAT-0004".to_string(),
description: "Completed task".to_string(),
status: TaskStatus::Completed,
complexity: Complexity::High,
priority: Priority::P0,
assignee: None,
started_at: Some(Utc::now()),
completed_at: Some(Utc::now()),
};
display_task_details(&task);
}
#[test]
fn test_calculate_sprint_progress() {
let tasks = vec![
Task {
id: "PMAT-0001".to_string(),
description: "Completed".to_string(),
status: TaskStatus::Completed,
complexity: Complexity::Low,
priority: Priority::P1,
assignee: None,
started_at: None,
completed_at: None,
},
Task {
id: "PMAT-0002".to_string(),
description: "In Progress".to_string(),
status: TaskStatus::InProgress,
complexity: Complexity::Low,
priority: Priority::P1,
assignee: None,
started_at: None,
completed_at: None,
},
Task {
id: "PMAT-0003".to_string(),
description: "Planned".to_string(),
status: TaskStatus::Planned,
complexity: Complexity::Low,
priority: Priority::P1,
assignee: None,
started_at: None,
completed_at: None,
},
];
let sprint = Sprint {
version: "v1.0.0".to_string(),
title: "Test".to_string(),
start_date: Utc::now(),
end_date: Utc::now(),
priority: Priority::P0,
tasks,
definition_of_done: Vec::new(),
quality_gates: Vec::new(),
};
let (completed, in_progress, total) = calculate_sprint_progress(&sprint);
assert_eq!(completed, 1);
assert_eq!(in_progress, 1);
assert_eq!(total, 3);
}
#[test]
fn test_calculate_sprint_progress_empty() {
let sprint = Sprint {
version: "v1.0.0".to_string(),
title: "Empty Sprint".to_string(),
start_date: Utc::now(),
end_date: Utc::now(),
priority: Priority::P0,
tasks: Vec::new(),
definition_of_done: Vec::new(),
quality_gates: Vec::new(),
};
let (completed, in_progress, total) = calculate_sprint_progress(&sprint);
assert_eq!(completed, 0);
assert_eq!(in_progress, 0);
assert_eq!(total, 0);
}
#[test]
fn test_display_sprint_details() {
let sprint = Sprint {
version: "v2.0.0".to_string(),
title: "Feature 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 {
id: "PMAT-0001".to_string(),
description: "Task 1".to_string(),
status: TaskStatus::Planned,
complexity: Complexity::Medium,
priority: Priority::P1,
assignee: None,
started_at: None,
completed_at: None,
}],
definition_of_done: vec!["Done".to_string()],
quality_gates: vec!["Gate".to_string()],
};
display_sprint_details(&sprint);
}
#[test]
fn test_display_sprint_tasks() {
let sprint = Sprint {
version: "v3.0.0".to_string(),
title: "Sprint with tasks".to_string(),
start_date: Utc::now(),
end_date: Utc::now(),
priority: Priority::P1,
tasks: vec![
Task {
id: "PMAT-0001".to_string(),
description: "First task".to_string(),
status: TaskStatus::Completed,
complexity: Complexity::Low,
priority: Priority::P2,
assignee: None,
started_at: None,
completed_at: None,
},
Task {
id: "PMAT-0002".to_string(),
description: "Second task".to_string(),
status: TaskStatus::InProgress,
complexity: Complexity::High,
priority: Priority::P0,
assignee: None,
started_at: None,
completed_at: None,
},
],
definition_of_done: Vec::new(),
quality_gates: Vec::new(),
};
display_sprint_tasks(&sprint);
}
#[tokio::test]
async fn test_execute_init_command() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
let cmd = RoadmapCommand {
command: RoadmapSubcommand::Init {
version: "v1.0.0".to_string(),
title: "Test Sprint".to_string(),
duration_days: 14,
priority: "P0".to_string(),
},
};
let result = execute(cmd, config.clone()).await;
assert!(result.is_ok());
assert!(config.path.exists());
}
#[tokio::test]
async fn test_execute_start_command() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let cmd = RoadmapCommand {
command: RoadmapSubcommand::Start {
task_id: "PMAT-0001".to_string(),
create_branch: false,
},
};
let result = execute(cmd, config).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_execute_complete_command() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let cmd = RoadmapCommand {
command: RoadmapSubcommand::Complete {
task_id: "PMAT-0001".to_string(),
skip_quality_check: true,
},
};
let result = execute(cmd, config).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_execute_status_command() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let cmd = RoadmapCommand {
command: RoadmapSubcommand::Status {
sprint: Some("v1.0.0".to_string()),
task: None,
format: OutputFormat::Json,
},
};
let result = execute(cmd, config).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_execute_todos_command() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let output_path = temp_dir.path().join("generated_todos.md");
let cmd = RoadmapCommand {
command: RoadmapSubcommand::Todos {
sprint: Some("v1.0.0".to_string()),
output: output_path.clone(),
include_quality_gates: false,
},
};
let result = execute(cmd, config).await;
assert!(result.is_ok());
assert!(output_path.exists());
}
#[tokio::test]
async fn test_execute_validate_command() {
let temp_dir = TempDir::new().unwrap();
let config = create_test_config(&temp_dir);
create_sample_roadmap(&config.path);
let cmd = RoadmapCommand {
command: RoadmapSubcommand::Validate {
sprint: "v1.0.0".to_string(),
strict: false,
},
};
let result = execute(cmd, config).await;
assert!(result.is_ok());
}
}