pmat 3.26.0

PMAT - Zero-config AI context generation and code quality toolkit (CLI, MCP, HTTP)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

//! Technical debt analysis handlers

use crate::cli::commands::AnalyzeCommands;
use anyhow::Result;

/// Handle TDG analysis
#[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
pub async fn handle_tdg(cmd: AnalyzeCommands) -> Result<()> {
    // Route to existing working handler
    crate::cli::handlers::route_analyze_command(cmd).await
}

#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod unit_tests {
    use super::*;

    /// Test that handle_tdg function exists and has correct signature
    #[test]
    fn test_handle_tdg_signature() {
        let _fn_ref: fn(AnalyzeCommands) -> _ = handle_tdg;
    }

    /// Test module exports the TDG handler
    #[test]
    fn test_module_exports_handler() {
        fn _verify_export() {
            let _tdg: fn(AnalyzeCommands) -> _ = handle_tdg;
        }
    }

    /// Test that Result type is properly used (anyhow::Result)
    #[test]
    fn test_result_type_compatibility() {
        fn _check_result_type() -> Result<()> {
            Ok(())
        }
        assert!(_check_result_type().is_ok());
    }

    /// Test that the handler is async
    #[test]
    fn test_handler_is_async() {
        fn _verify_async_nature() {
            // handle_tdg is async - verified at compile time
        }
    }
}

#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod coverage_tests {
    use super::*;
    use crate::cli::enums::TdgOutputFormat;
    use std::path::PathBuf;

    /// Test handle_tdg delegates to route_analyze_command with default options
    #[tokio::test]
    async fn test_handle_tdg_basic() {
        let cmd = AnalyzeCommands::Tdg {
            path: PathBuf::from("/nonexistent/path/for/tdg/test"),
            threshold: 1.5,
            top_files: 10,
            format: TdgOutputFormat::Table,
            include_components: false,
            output: None,
            critical_only: false,
            verbose: false,
            ml: false,
        };

        let result = handle_tdg(cmd).await;
        // Delegation should work regardless of outcome
        assert!(result.is_ok() || result.is_err());
    }

    /// Test handle_tdg with critical_only and verbose options
    #[tokio::test]
    async fn test_handle_tdg_critical_verbose() {
        let cmd = AnalyzeCommands::Tdg {
            path: PathBuf::from("/tmp/test-tdg"),
            threshold: 2.5,
            top_files: 5,
            format: TdgOutputFormat::Json,
            include_components: true,
            output: Some(PathBuf::from("/tmp/tdg-output.json")),
            critical_only: true,
            verbose: true,
            ml: false,
        };

        let result = handle_tdg(cmd).await;
        assert!(result.is_ok() || result.is_err());
    }

    /// Test handle_tdg with ML-based scoring enabled
    #[tokio::test]
    async fn test_handle_tdg_with_ml() {
        let cmd = AnalyzeCommands::Tdg {
            path: PathBuf::from("/nonexistent"),
            threshold: 1.0,
            top_files: 20,
            format: TdgOutputFormat::Markdown,
            include_components: false,
            output: None,
            critical_only: false,
            verbose: false,
            ml: true,
        };

        let result = handle_tdg(cmd).await;
        assert!(result.is_ok() || result.is_err());
    }

    /// Test handle_tdg with include_components for detailed breakdown
    #[tokio::test]
    async fn test_handle_tdg_with_components() {
        let cmd = AnalyzeCommands::Tdg {
            path: PathBuf::from("/tmp/test-tdg-components"),
            threshold: 0.5,
            top_files: 0,
            format: TdgOutputFormat::Table,
            include_components: true,
            output: Some(PathBuf::from("/tmp/tdg-components.txt")),
            critical_only: false,
            verbose: true,
            ml: false,
        };

        let result = handle_tdg(cmd).await;
        assert!(result.is_ok() || result.is_err());
    }

    /// Test handle_tdg with high threshold (only severe debt)
    #[tokio::test]
    async fn test_handle_tdg_high_threshold() {
        let cmd = AnalyzeCommands::Tdg {
            path: PathBuf::from("/nonexistent"),
            threshold: 5.0,
            top_files: 3,
            format: TdgOutputFormat::Markdown,
            include_components: false,
            output: None,
            critical_only: true,
            verbose: false,
            ml: true,
        };

        let result = handle_tdg(cmd).await;
        assert!(result.is_ok() || result.is_err());
    }

    /// Test that handler is async and returns proper Result type
    #[test]
    fn test_handler_function_signature() {
        // Verify the function exists and has correct return type
        let _: fn(AnalyzeCommands) -> _ = handle_tdg;
    }
}