molock 0.2.0

High-performance mock server for CI/CD pipelines and testing
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

// SPDX-FileCopyrightText: 2026 Molock Team
// SPDX-License-Identifier: Apache-2.0

use crate::config::Config;
use crate::rules::RuleEngine;
use crate::server::openapi::ApiDoc;
use crate::telemetry::tracer::tracing_middleware;
use actix_web::dev::Server;
use actix_web::http::header;
use actix_web::web;
use actix_web::App;
use actix_web::HttpResponse;
use actix_web::HttpServer;
use actix_web::Responder;
use std::sync::Arc;
use tracing::info;
use utoipa::OpenApi;
use utoipa_swagger_ui::{SwaggerUi, Url};

/// Runs the Molock HTTP server.
///
/// # Errors
///
/// Returns an error if the server fails to bind to the specified address or if worker startup fails.
pub async fn run_server(config: Config, rule_engine: Arc<RuleEngine>) -> anyhow::Result<Server> {
    let server_config = config.server.clone();
    let addr = format!("{}:{}", server_config.host, server_config.port);

    info!("Starting server on {addr}");
    info!("Server workers: {}", server_config.workers);
    info!("Max request size: {} bytes", server_config.max_request_size);

    let openapi = ApiDoc::openapi();
    let swagger_urls = vec![(Url::new("Molock API", "/api-docs/openapi.json"), openapi)];

    let server = HttpServer::new(move || {
        let app_state = web::Data::new(AppState {
            config: config.clone(),
            rule_engine: rule_engine.clone(),
        });

        App::new()
            .wrap(tracing_middleware())
            .app_data(app_state)
            .app_data(web::JsonConfig::default().limit(config.server.max_request_size))
            .service(web::resource("/health").to(crate::server::health_handler))
            .service(web::resource("/metrics").to(crate::server::metrics_handler))
            .service(SwaggerUi::new("/swagger-ui/{_:.*}").urls(swagger_urls.clone()))
            .service(web::resource("/api-docs/openapi.json").to(openapi_json_handler))
            .default_service(web::to(crate::server::request_handler))
    })
    .workers(server_config.workers)
    .bind(addr)?
    .run();

    Ok(server)
}

async fn openapi_json_handler() -> impl Responder {
    let openapi = ApiDoc::openapi();
    let json = serde_json::to_string(&openapi).unwrap();
    HttpResponse::Ok()
        .insert_header(header::ContentType::json())
        .body(json)
}

#[derive(Clone)]
pub struct AppState {
    pub config: Config,
    pub rule_engine: Arc<RuleEngine>,
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::types::{Endpoint, Response};
    use std::collections::HashMap;

    #[test]
    fn test_app_state() {
        let config = Config {
            endpoints: vec![Endpoint {
                name: "Test".to_string(),
                method: "GET".to_string(),
                path: "/test".to_string(),
                stateful: false,
                state_key: None,
                responses: vec![Response {
                    status: 200,
                    delay: None,
                    body: Some("OK".to_string()),
                    headers: HashMap::new(),
                    condition: None,
                    probability: None,
                    default: false,
                }],
                schema: None,
                schema_file: None,
                path_regex: None,
                headers_regex: None,
                query_regex: None,
            }],
            ..Config::default()
        };

        let rule_engine = Arc::new(RuleEngine::new(&config.endpoints));
        let app_state = AppState {
            config: config.clone(),
            rule_engine: rule_engine.clone(),
        };

        assert_eq!(app_state.config.endpoints.len(), 1);
        assert_eq!(app_state.config.endpoints[0].name, "Test");
    }

    #[actix_web::test]
    async fn test_openapi_json_handler() {
        let resp = openapi_json_handler()
            .await
            .respond_to(&actix_web::test::TestRequest::default().to_http_request());
        assert_eq!(resp.status(), 200);
        assert_eq!(
            resp.headers().get(header::CONTENT_TYPE).unwrap(),
            "application/json"
        );
    }
}