pmat 3.11.0

// pdmt_service_tests.rs — unit tests and property tests
// Included by pdmt_service.rs — shares parent module scope (no `use` imports here)

#[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();

        // Verify deterministic generation (same seed produces similar structure)
        assert_eq!(result1.todos.len(), result2.todos.len());
        assert_eq!(result1.deterministic_seed, result2.deterministic_seed);
    }

    #[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();

        // High granularity should create more todos
        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 ".*") {
            // Basic property test for coverage
            prop_assert!(true);
        }

        #[test]
        fn module_consistency_check(_x in 0u32..1000) {
            // Module consistency verification
            prop_assert!(_x < 1001);
        }
    }
}