mycelium-http-tools 8.3.1-beta.4

Provide HTTP related elements to the mycelium project.
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

use crate::responses::GatewayError;

use base64::{engine::general_purpose, Engine};
use myc_core::domain::dtos::profile::Profile;
use tracing::{error, warn};
use zstd::decode_all;

/// Decode and decompress profile from Base64
///
/// This function is used to decode and decompress the profile from Base64. The
/// decompression is done using ZSTD.
///
#[tracing::instrument(
    name = "decode_and_decompress_profile_from_base64",
    skip_all
)]
pub fn decode_and_decompress_profile_from_base64(
    profile: String,
) -> Result<Profile, GatewayError> {
    //
    // Decode from Base64
    //
    let decoded_profile =
        general_purpose::STANDARD.decode(profile).map_err(|e| {
            warn!("Failed to decode base64 profile: {e}");

            GatewayError::InternalServerError(format!(
                "Failed to decode base64 profile: {e}"
            ))
        })?;

    //
    // Decompress profile from ZSTD
    //
    let decompressed_profile =
        decode_all(decoded_profile.as_slice()).map_err(|e| {
            error!("Failed to decompress profile: {e}");

            GatewayError::InternalServerError(format!(
                "Failed to decompress profile: {e}"
            ))
        })?;

    //
    // Deserialize from JSON
    //
    let profile_string =
        String::from_utf8(decompressed_profile).map_err(|e| {
            warn!("Failed to convert decompressed profile to string: {e}");

            GatewayError::InternalServerError(format!(
                "Failed to convert decompressed profile to string: {e}"
            ))
        })?;

    let profile = serde_json::from_str(&profile_string).map_err(|e| {
        warn!("Failed to deserialize profile: {e}");

        GatewayError::InternalServerError(format!(
            "Failed to deserialize profile: {e}"
        ))
    })?;

    Ok(profile)
}

// * ---------------------------------------------------------------------------
// * TESTS
// * ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;
    use crate::functions::compress_and_encode_profile_to_base64;
    use myc_core::domain::dtos::profile::Profile;

    /// Load large profile from JSON file
    fn load_large_profile() -> Profile {
        let json_content = include_str!("../../test/mock/large-profile.json");
        serde_json::from_str(json_content)
            .expect("Failed to deserialize large profile from JSON file")
    }

    #[test]
    fn test_decode_and_decompress_profile_roundtrip() {
        let original_profile = load_large_profile();

        // Compress and encode the profile
        let encoded =
            compress_and_encode_profile_to_base64(original_profile.clone())
                .expect("Failed to compress and encode profile");

        // Decode and decompress the profile
        let decoded_profile =
            decode_and_decompress_profile_from_base64(encoded)
                .expect("Failed to decode and decompress profile");

        // Verify that the decoded profile matches the original
        assert_eq!(
            original_profile.acc_id, decoded_profile.acc_id,
            "Account ID should match"
        );
        assert_eq!(
            original_profile.owners.len(),
            decoded_profile.owners.len(),
            "Number of owners should match"
        );
        assert_eq!(
            original_profile.is_subscription, decoded_profile.is_subscription,
            "Subscription status should match"
        );
        assert_eq!(
            original_profile.is_manager, decoded_profile.is_manager,
            "Manager status should match"
        );
        assert_eq!(
            original_profile.is_staff, decoded_profile.is_staff,
            "Staff status should match"
        );

        // Compare the full profiles by serializing to JSON
        let original_json = serde_json::to_string(&original_profile)
            .expect("Failed to serialize original profile");
        let decoded_json = serde_json::to_string(&decoded_profile)
            .expect("Failed to serialize decoded profile");

        println!("Original JSON: {}", original_json);
        println!("Decoded JSON: {}", decoded_json);

        assert_eq!(
            original_json, decoded_json,
            "Full profile JSON should match exactly"
        );
    }
}