goldrust 0.1.10

A Rust library for testing HTTP clients with golden files.
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

//! This example demonstrates how to use Goldrust to test a simple GET request.
//! The⭐️s indicate where manual implementation is required.

use goldrust::{goldrust, Content, Goldrust, ResponseSource};
use std::path::Path;
use tracing_subscriber::EnvFilter;
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};

#[tokio::test]
async fn main() {
    tracing_subscriber::fmt::fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .pretty()
        .init();

    let mut goldrust = goldrust!("json");

    let mock_server = MockServer::start().await;

    // ⭐️ Set the domain to the mock server uri
    let domain = match goldrust.response_source {
        ResponseSource::Local => mock_server.uri(),
        ResponseSource::External => "https://some-external-api.com".to_string(),
    };

    let url_path = "/api/actual";

    // ⭐️ Configure the mock server to return a local response
    match goldrust.response_source {
        ResponseSource::Local => {
            Mock::given(method("GET"))
                .and(path(url_path))
                .respond_with({
                    tracing::debug!("Responding with local file");
                    create_response_template(&goldrust.golden_file_path)
                })
                .mount(&mock_server)
                .await;
        }
        ResponseSource::External => {}
    }

    let response = reqwest::Client::new()
        .get(format!("{}{}", domain, url_path))
        .send()
        .await
        .expect("Failed to send request");
    tracing::debug!(response = ?response, "Got response");

    #[derive(Debug, serde::Serialize, serde::Deserialize, PartialEq)]
    struct Data {
        name: String,
        age: u16,
    }
    // The response body
    let response_body: Data = response.json().await.expect("Failed to get bytes");
    tracing::debug!(?response_body, "Response body");

    let golden_file_text =
        std::fs::read_to_string(&goldrust.golden_file_path).expect("Failed to read golden file");

    // The response body should match the golden file
    assert_eq!(
        serde_json::to_string(&response_body).expect("Failed to serialize"),
        normalize_json(&golden_file_text)
    );

    // ⭐️ Using the closure to save content to the golden file
    goldrust
        .save(Content::Json(
            serde_json::to_value(response_body).expect("Failed to convert to serde_json::Value"),
        ))
        .expect("Failed to save");
}

fn normalize_json(json: &str) -> String {
    json.replace("\r\n", "\n")
        .replace(" ", "")
        .replace("\n", "")
}

#[tracing::instrument]
fn create_response_template<P: AsRef<Path> + std::fmt::Debug>(path: P) -> ResponseTemplate {
    let path = path.as_ref();
    let body = std::fs::read_to_string(path).expect("Failed to read file");
    ResponseTemplate::new(200).set_body_string(body)
}