#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_generate_todos_deterministic() {
let service = PdmtService::new();
let requirements = vec![
"implement user authentication".to_string(),
"add logging system".to_string(),
];
let config = PdmtQualityConfig::default();
let result1 = service
.generate_todos(
requirements.clone(),
Some("test_project".to_string()),
"high",
config.clone(),
)
.unwrap();
let result2 = service
.generate_todos(
requirements,
Some("test_project".to_string()),
"high",
config,
)
.unwrap();
let json1 = serde_json::to_string(&result1).unwrap();
let json2 = serde_json::to_string(&result2).unwrap();
assert_eq!(
json1, json2,
"identical inputs must produce byte-identical output"
);
let ids1: Vec<&str> = result1.todos.iter().map(|t| t.id.as_str()).collect();
let ids2: Vec<&str> = result2.todos.iter().map(|t| t.id.as_str()).collect();
assert_eq!(ids1, ids2);
assert_eq!(result1.todos.len(), result2.todos.len());
assert_eq!(result1.deterministic_seed, result2.deterministic_seed);
}
#[test]
fn test_todo_ids_stable_across_service_instances() {
let requirements = vec!["implement user authentication".to_string()];
let make = || {
PdmtService::new()
.generate_todos(
requirements.clone(),
Some("test".to_string()),
"high",
PdmtQualityConfig::default(),
)
.unwrap()
};
let first = make();
let second = make();
assert_eq!(
serde_json::to_string(&first).unwrap(),
serde_json::to_string(&second).unwrap(),
"fresh service instances must produce byte-identical output"
);
}
#[test]
fn test_todo_ids_are_valid_uuids_and_unique() {
let service = PdmtService::new();
let requirements = vec![
"implement caching".to_string(),
"implement caching".to_string(),
];
let result = service
.generate_todos(requirements, None, "high", PdmtQualityConfig::default())
.unwrap();
let mut seen = std::collections::HashSet::new();
for todo in &result.todos {
let parsed = Uuid::parse_str(&todo.id).expect("todo id must be uuid-formatted");
assert_eq!(parsed.get_version_num(), 8, "deterministic ids use UUIDv8");
assert!(seen.insert(todo.id.clone()), "todo ids must be unique");
}
}
#[test]
fn test_generated_at_is_deterministic() {
let service = PdmtService::new();
let result = service
.generate_todos(
vec!["add logging".to_string()],
None,
"medium",
PdmtQualityConfig::default(),
)
.unwrap();
assert_eq!(result.generated_at, DETERMINISTIC_GENERATED_AT);
}
#[test]
fn test_fnv1a_128_stable_known_values() {
assert_eq!(fnv1a_128(b""), FNV128_OFFSET_BASIS);
assert_eq!(fnv1a_128(b"pdmt"), fnv1a_128(b"pdmt"));
assert_ne!(fnv1a_128(b"pdmt"), fnv1a_128(b"pdmt2"));
}
#[test]
fn test_quality_config_enforcement() {
let service = PdmtService::new();
let requirements = vec!["fix critical bug".to_string()];
let config = PdmtQualityConfig {
coverage_threshold: 90.0,
max_complexity: 5,
..Default::default()
};
let result = service
.generate_todos(requirements, None, "medium", config)
.unwrap();
let todo = &result.todos[0];
assert_eq!(todo.quality_gates.coverage_requirement, 90.0);
assert_eq!(todo.quality_gates.complexity_limit, 5);
assert!(!todo.quality_gates.satd_tolerance);
}
#[test]
fn test_pdmt_service_new() {
let service = PdmtService::new();
assert_eq!(service.deterministic_seed, 42);
}
#[test]
fn test_pdmt_service_default() {
let service = PdmtService::default();
assert_eq!(service.deterministic_seed, 42);
}
#[test]
fn test_generate_todos_low_granularity() {
let service = PdmtService::new();
let requirements = vec!["implement feature".to_string()];
let config = PdmtQualityConfig::default();
let result = service
.generate_todos(requirements, Some("test".to_string()), "low", config)
.unwrap();
assert!(!result.todos.is_empty());
assert_eq!(result.project_name, "test");
}
#[test]
fn test_generate_todos_medium_granularity() {
let service = PdmtService::new();
let requirements = vec!["add logging".to_string()];
let config = PdmtQualityConfig::default();
let result = service
.generate_todos(requirements, None, "medium", config)
.unwrap();
assert!(!result.todos.is_empty());
}
#[test]
fn test_generate_todos_high_granularity() {
let service = PdmtService::new();
let requirements = vec!["create API endpoint".to_string()];
let config = PdmtQualityConfig::default();
let result = service
.generate_todos(requirements, None, "high", config)
.unwrap();
assert!(!result.todos.is_empty());
}
#[test]
fn test_generate_todos_empty_requirements() {
let service = PdmtService::new();
let requirements: Vec<String> = vec![];
let config = PdmtQualityConfig::default();
let result = service
.generate_todos(requirements, None, "medium", config)
.unwrap();
assert!(result.todos.is_empty());
}
#[test]
fn test_generate_todos_fix_type() {
let service = PdmtService::new();
let requirements = vec!["fix authentication bug".to_string()];
let config = PdmtQualityConfig::default();
let result = service
.generate_todos(requirements, None, "medium", config)
.unwrap();
assert!(!result.todos.is_empty());
}
#[test]
fn test_generate_todos_refactor_type() {
let service = PdmtService::new();
let requirements = vec!["refactor database layer".to_string()];
let config = PdmtQualityConfig::default();
let result = service
.generate_todos(requirements, None, "medium", config)
.unwrap();
assert!(!result.todos.is_empty());
}
#[test]
fn test_generate_todos_default_project_name() {
let service = PdmtService::new();
let requirements = vec!["implement feature".to_string()];
let config = PdmtQualityConfig::default();
let result = service
.generate_todos(requirements, None, "medium", config)
.unwrap();
assert_eq!(result.project_name, "project");
}
#[test]
fn test_pdmt_quality_config_default() {
let config = PdmtQualityConfig::default();
assert!(config.coverage_threshold >= 0.0);
assert!(config.max_complexity > 0);
}
#[test]
fn test_pdmt_todo_list_structure() {
let service = PdmtService::new();
let requirements = vec!["test feature".to_string()];
let config = PdmtQualityConfig::default();
let result = service
.generate_todos(
requirements,
Some("my_project".to_string()),
"medium",
config,
)
.unwrap();
assert_eq!(result.project_name, "my_project");
assert_eq!(result.deterministic_seed, 42);
assert!(!result.generated_at.is_empty());
}
}
#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod property_tests {
use proptest::prelude::*;
proptest! {
#[test]
fn basic_property_stability(_input in ".*") {
prop_assert!(true);
}
#[test]
fn module_consistency_check(_x in 0u32..1000) {
prop_assert!(_x < 1001);
}
}
}