pmat 3.11.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

//! TDD Test for run_mcp_server refactoring (Sprint 79)
//!
//! Following Toyota Way TDD principles:
//! 1. Write test FIRST (Red)
//! 2. Make it pass (Green)
//! 3. Refactor to reduce cognitive complexity from 49 to ≤10 (Refactor)
//!
//! Current: Cognitive complexity 49, Cyclomatic complexity 11
//! Target: Cognitive complexity ≤10, maintain functionality

use anyhow::Result;
use pmat::models::template::{TemplateCategory, Toolchain};
use pmat::{
    models::template::TemplateResource, ContentCache, MetadataCache,
    PublicTemplateRenderer as TemplateRenderer, S3Client, TemplateServerTrait,
};
use std::sync::Arc;

// Mock template server for testing
struct MockTemplateServer {
    renderer: TemplateRenderer,
}

#[async_trait::async_trait]
impl TemplateServerTrait for MockTemplateServer {
    async fn get_template_metadata(&self, _uri: &str) -> Result<Arc<TemplateResource>> {
        let resource = TemplateResource {
            uri: "mock://template".to_string(),
            name: "Mock Template".to_string(),
            description: "Mock template for testing".to_string(),
            toolchain: Toolchain::RustCli {
                cargo_features: vec![],
            },
            category: TemplateCategory::Context,
            parameters: vec![],
            s3_object_key: "mock-key".to_string(),
            content_hash: "abc123".to_string(),
            semantic_version: semver::Version::new(1, 0, 0),
            dependency_graph: vec![],
        };
        Ok(Arc::new(resource))
    }

    async fn get_template_content(&self, _s3_key: &str) -> Result<Arc<str>> {
        Ok(Arc::from("Mock template content"))
    }

    async fn list_templates(&self, _prefix: &str) -> Result<Vec<Arc<TemplateResource>>> {
        Ok(vec![])
    }

    fn get_renderer(&self) -> &TemplateRenderer {
        &self.renderer
    }

    fn get_metadata_cache(&self) -> Option<&MetadataCache> {
        None
    }

    fn get_content_cache(&self) -> Option<&ContentCache> {
        None
    }

    fn get_s3_client(&self) -> Option<&S3Client> {
        None
    }

    fn get_bucket_name(&self) -> Option<&str> {
        None
    }
}

/// Test MCP server basic structure and initialization
#[tokio::test]
async fn test_run_mcp_server_structure() {
    // Test that run_mcp_server can be called with mock server
    // Note: This test focuses on the refactoring structure, not full I/O testing

    // Create a real renderer for testing
    let renderer = TemplateRenderer::new().expect("Failed to create renderer");
    let mock_server = Arc::new(MockTemplateServer { renderer });

    // Verify the mock server implements the trait correctly
    let _metadata_future = mock_server.get_template_metadata("test");
    let _content_future = mock_server.get_template_content("test");
    let _list_future = mock_server.list_templates("test");

    // Verify accessors work
    assert!(!std::ptr::addr_of!(*mock_server.get_renderer()).is_null());
    assert!(mock_server.get_metadata_cache().is_none());
    assert!(mock_server.get_content_cache().is_none());
    assert!(mock_server.get_s3_client().is_none());
    assert!(mock_server.get_bucket_name().is_none());
}

/// Test error handling patterns that will be preserved during refactoring
#[test]
fn test_run_mcp_server_error_patterns() {
    // Test JSON parsing error handling
    let invalid_json = "{ invalid json }";
    let parse_result = serde_json::from_str::<serde_json::Value>(invalid_json);
    assert!(parse_result.is_err());

    // Test response serialization
    let response = serde_json::json!({
        "jsonrpc": "2.0",
        "id": null,
        "error": {
            "code": -32700,
            "message": "Parse error"
        }
    });
    let serialized = serde_json::to_string(&response);
    assert!(serialized.is_ok());
}

/// Test the MCP request/response cycle structure
#[test]
fn test_mcp_request_response_structure() {
    // Test basic MCP request structure
    let request_json = r#"{
        "jsonrpc": "2.0",
        "method": "test",
        "id": 1,
        "params": {}
    }"#;

    let parse_result = serde_json::from_str::<serde_json::Value>(request_json);
    assert!(parse_result.is_ok());

    let parsed = parse_result.unwrap();
    assert_eq!(parsed["method"], "test");
    assert_eq!(parsed["id"], 1);
}