trz-gateway-server 0.2.13

Secure Proxy / Agents implementation in Rust
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

#![cfg(test)]

use instant_acme::LetsEncrypt;
use trz_gateway_common::crypto_provider::crypto_provider;
use trz_gateway_common::tracing::test_utils::enable_tracing_for_tests;

use crate::server::acme::active_challenges::ActiveChallenges;

#[allow(unused)]
// #[tokio::test]
async fn get_certificate() {
    enable_tracing_for_tests();
    crypto_provider();
    let result = super::AcmeConfig {
        environment: LetsEncrypt::Staging,
        credentials: None.into(),
        contact: "mailto:info@pavy.one".into(),
        domains: vec!["pavy.one".into()],
        certificate: None,
    }
    .get_certificate(&ActiveChallenges::default())
    .await
    .unwrap();
    println!(
        "{}",
        serde_json::to_string_pretty(&result.credentials).unwrap()
    );
}

#[test]
fn environment_serialize_deserialize() {
    use super::environment_serde;

    #[derive(serde::Serialize, serde::Deserialize)]
    struct LetsEncryptConfig {
        #[serde(with = "environment_serde")]
        environment: LetsEncrypt,
    }

    const PROD_VALUE: &str = "{\"environment\":\"Production\"}";
    const STAGE_VALUE: &str = "{\"environment\":\"Staging\"}";
    assert_eq!(
        PROD_VALUE,
        serde_json::to_string(&LetsEncryptConfig {
            environment: LetsEncrypt::Production
        })
        .unwrap()
    );
    assert_eq!(
        STAGE_VALUE,
        serde_json::to_string(&LetsEncryptConfig {
            environment: LetsEncrypt::Staging
        })
        .unwrap()
    );

    assert!(matches!(
        serde_json::from_str::<LetsEncryptConfig>(PROD_VALUE)
            .unwrap()
            .environment,
        LetsEncrypt::Production,
    ));
    assert!(matches!(
        serde_json::from_str::<LetsEncryptConfig>(STAGE_VALUE)
            .unwrap()
            .environment,
        LetsEncrypt::Staging,
    ));
}

#[test]
fn domains_serialize_deserialize() {
    let legacy = serde_json::from_str::<super::AcmeConfig>(
        r#"{
            "environment": "Staging",
            "credentials": null,
            "contact": "mailto:info@pavy.one",
            "domain": "pavy.one",
            "certificate": null
        }"#,
    )
    .unwrap();
    assert_eq!(vec!["pavy.one"], legacy.domains);

    let config = serde_json::from_str::<super::AcmeConfig>(
        r#"{
            "environment": "Staging",
            "credentials": null,
            "contact": "mailto:info@pavy.one",
            "domains": ["pavy.one", "www.pavy.one"],
            "certificate": null
        }"#,
    )
    .unwrap();
    assert_eq!(vec!["pavy.one", "www.pavy.one"], config.domains);

    let serialized = serde_json::to_value(config).unwrap();
    assert_eq!(
        serde_json::json!(["pavy.one", "www.pavy.one"]),
        serialized["domains"]
    );
    assert!(serialized.get("domain").is_none());
}