agenterra 0.2.1

Generate production-ready MCP (Model Context Protocol) servers and clients from OpenAPI specs
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

//! Application layer - orchestrates use cases and coordinates between domains

pub mod commands;
pub mod errors;
pub mod generate_client;
pub mod generate_server;
pub mod template_management;
pub mod traits;

pub use commands::*;
pub use errors::*;
pub use template_management::*;
pub use traits::*;

#[cfg(test)]
mod tests {
    use super::*;
    use crate::generation::Language;
    use crate::protocols::Protocol;
    use std::collections::HashMap;
    use std::path::PathBuf;

    #[test]
    fn test_generate_server_request_validation() {
        // Valid request
        let request = GenerateServerRequest {
            protocol: Protocol::Mcp,
            language: Language::Rust,
            project_name: "test-server".to_string(),
            schema_path: Some("/path/to/openapi.yaml".to_string()),
            output_dir: PathBuf::from("/output"),
            options: HashMap::new(),
        };

        assert!(request.validate().is_ok());

        // Empty project name
        let mut invalid_request = request.clone();
        invalid_request.project_name = "".to_string();
        assert!(invalid_request.validate().is_err());
    }

    #[test]
    fn test_generate_client_request_validation() {
        // Valid request
        let request = GenerateClientRequest {
            protocol: Protocol::Mcp,
            language: Language::Rust,
            project_name: "test-client".to_string(),
            output_dir: PathBuf::from("/output"),
            options: HashMap::new(),
        };

        assert!(request.validate().is_ok());

        // Invalid protocol for client
        let mut invalid_request = request.clone();
        invalid_request.protocol = Protocol::Anp; // Assuming ANP doesn't support client
        assert!(invalid_request.validate().is_err());
    }

    #[tokio::test]
    async fn test_generate_server_use_case_success() {
        // We'll test this with infrastructure implementations
        // For now, just ensure the types compile correctly
        let request = GenerateServerRequest {
            protocol: Protocol::Mcp,
            language: Language::Rust,
            project_name: "test-server".to_string(),
            schema_path: Some("/path/to/openapi.yaml".to_string()),
            output_dir: PathBuf::from("/output"),
            options: HashMap::new(),
        };

        // Ensure request validates correctly
        assert!(request.validate().is_ok());

        // Test ACP server (doesn't require OpenAPI)
        let acp_request = GenerateServerRequest {
            protocol: Protocol::Acp,
            language: Language::Rust,
            project_name: "test-acp-server".to_string(),
            schema_path: None,
            output_dir: PathBuf::from("/output"),
            options: HashMap::new(),
        };

        // Should validate successfully without schema_path
        assert!(acp_request.validate().is_ok());

        // Test MCP server without OpenAPI should fail validation
        let invalid_mcp = GenerateServerRequest {
            protocol: Protocol::Mcp,
            language: Language::Rust,
            project_name: "test-mcp-server".to_string(),
            schema_path: None,
            output_dir: PathBuf::from("/output"),
            options: HashMap::new(),
        };

        let result = invalid_mcp.validate();
        assert!(result.is_err());
        match result.unwrap_err() {
            ValidationError::MissingField(msg) => {
                assert!(msg.contains("MCP server requires OpenAPI"));
            }
            _ => panic!("Expected MissingField error"),
        }
    }

    #[test]
    fn test_application_error_types() {
        // Test that error types are correctly defined
        let error = ApplicationError::ProtocolError(
            crate::protocols::ProtocolError::NotImplemented(Protocol::Mcp),
        );
        match error {
            ApplicationError::ProtocolError(crate::protocols::ProtocolError::NotImplemented(p)) => {
                assert_eq!(p, Protocol::Mcp)
            }
            _ => panic!("Expected ProtocolError::NotImplemented"),
        }

        let validation_error = ValidationError::EmptyProjectName;
        match validation_error {
            ValidationError::EmptyProjectName => {}
            _ => panic!("Expected EmptyProjectName"),
        }
    }

    #[test]
    fn test_generate_client_use_case_types() {
        // We'll test this with infrastructure implementations
        // For now, just ensure the types compile correctly
        let request = GenerateClientRequest {
            protocol: Protocol::Mcp,
            language: Language::Rust,
            project_name: "test-client".to_string(),
            output_dir: PathBuf::from("/output"),
            options: HashMap::new(),
        };

        // Ensure request validates correctly
        assert!(request.validate().is_ok());
    }
}