mockforge-http 0.3.235

HTTP/REST protocol support for MockForge
Documentation 
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

//! Real HTTP publication controls for workspace-owned dynamic routes.
use axum::Router;
use mockforge_http::management::{dynamic_mock_fallback, management_router, ManagementState};
use serde_json::json;
use std::time::Duration;

struct Server {
    base: String,
    client: reqwest::Client,
    task: tokio::task::JoinHandle<()>,
}
impl Drop for Server {
    fn drop(&mut self) {
        self.task.abort();
    }
}
impl Server {
    async fn start() -> Self {
        let state = ManagementState::new(None, None, 0);
        let app = Router::new()
            .nest("/__mockforge/api", management_router(state.clone()))
            .fallback_service(axum::routing::any(dynamic_mock_fallback).with_state(state));
        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
        let address = listener.local_addr().unwrap();
        let task = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
        Self {
            base: format!("http://{address}"),
            client: reqwest::Client::builder().timeout(Duration::from_secs(5)).build().unwrap(),
            task,
        }
    }
}
#[tokio::test]
async fn workspace_publication_replaces_only_owned_routes_and_keeps_raw_body_bytes() {
    let server = Server::start().await;
    let unrelated = json!({"id":"unrelated","method":"GET","path":"/unrelated","response":{"body":{"kept":true}}});
    assert!(server
        .client
        .post(format!("{}/__mockforge/api/mocks", server.base))
        .json(&unrelated)
        .send()
        .await
        .unwrap()
        .status()
        .is_success());
    let mut own = json!({"id":"__workspace_live:fixture:req","method":"GET","path":"/workspace/fixture/live","response":{"body":" raw static response\n","headers":{"content-type":"text/plain"}},"status_code":201,"request_match":{}});
    let publish = format!("{}/__mockforge/api/workspaces/fixture/activate", server.base);
    assert!(server
        .client
        .post(&publish)
        .json(&json!([own]))
        .send()
        .await
        .unwrap()
        .status()
        .is_success());
    let response = server
        .client
        .get(format!("{}/workspace/fixture/live", server.base))
        .send()
        .await
        .unwrap();
    assert_eq!(response.status(), reqwest::StatusCode::CREATED);
    assert_eq!(response.bytes().await.unwrap().as_ref(), b" raw static response\n");
    let unrelated = server
        .client
        .get(format!("{}/unrelated", server.base))
        .send()
        .await
        .unwrap()
        .json::<serde_json::Value>()
        .await
        .unwrap();
    assert_eq!(unrelated, json!({"kept":true}));
    own["path"] = json!("/workspace/fixture/updated");
    assert!(server
        .client
        .post(&publish)
        .json(&json!([own]))
        .send()
        .await
        .unwrap()
        .status()
        .is_success());
    assert_eq!(
        server
            .client
            .get(format!("{}/workspace/fixture/live", server.base))
            .send()
            .await
            .unwrap()
            .status(),
        reqwest::StatusCode::NOT_FOUND
    );
    assert_eq!(
        server
            .client
            .get(format!("{}/workspace/fixture/updated", server.base))
            .send()
            .await
            .unwrap()
            .status(),
        reqwest::StatusCode::CREATED
    );
    let invalid =
        json!({"id":"unrelated","method":"GET","path":"/unrelated","response":{"body":"bad"}});
    assert_eq!(
        server
            .client
            .post(&publish)
            .json(&json!([invalid]))
            .send()
            .await
            .unwrap()
            .status(),
        reqwest::StatusCode::BAD_REQUEST
    );
    assert_eq!(
        server
            .client
            .get(format!("{}/workspace/fixture/updated", server.base))
            .send()
            .await
            .unwrap()
            .status(),
        reqwest::StatusCode::CREATED
    );
    assert_eq!(
        server
            .client
            .get(format!("{}/unrelated", server.base))
            .send()
            .await
            .unwrap()
            .json::<serde_json::Value>()
            .await
            .unwrap(),
        json!({"kept":true})
    );
}