med_core 0.6.4

A Rust Powered Core Engine for M.E.D. Masking, Encryption, and Decryption CSV/JSON
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

use std::path::Path;

use crate::utils::{
    config::JobConfig,
    crypto::Cypher,
    error::{MedError, MedErrorType},
};

#[tokio::test]
async fn test_message() {
    let msg = "Io Error message".to_string();

    let err = MedError {
        message: Some(msg.to_string()),
        cause: None,
        error_type: MedErrorType::IoError,
    };
    assert_eq!(err.message(), msg, "Io Error message");
}

#[tokio::test]
async fn test_serde_yaml_error() {
    let test_config_path = Path::new("../demo/conf/invalid_conf.yaml");
    let test_config = JobConfig::new(test_config_path).await;
    match test_config {
        Ok(_) => {
            unimplemented!()
        }
        Err(err) => {
            assert_eq!(err.error_type, MedErrorType::ConfigError);
        }
    }
}

#[tokio::test]
async fn test_magic_crypt_error() {
    // let sparkle_heart: Vec<i32> = vec![0, 159, 146, 150];

    let expect_magic_crypt_err = MedError {
        message: Some("Invalid byte 240, offset 0.".to_string()),
        cause: Some("magic_crypt error".to_string()),
        error_type: MedErrorType::CryptoError,
    };

    let key = "key".to_string();
    let new_cypto = Cypher::new(&key);

    // let sparkle_heart = vec![0, 159, 146, 150];
    let sparkle_heart = vec![240, 159, 146, 150];

    // We know these bytes are valid, so we'll use `unwrap()`.
    let sparkle_heart_str = String::from_utf8(sparkle_heart).unwrap();

    // testing the decryption failed.
    match new_cypto.decrypt(&sparkle_heart_str, &crate::models::enums::Standard::DES64) {
        Ok(_) => {
            unimplemented!()
        }
        Err(err) => {
            assert_eq!(err, expect_magic_crypt_err);
        }
    }
}

// #[tokio::test]
// async fn test_io_error() {
//     let data = r#"
//         {
//             "name": "John Doe",
//             "age": 43,
//             "phones": [
//                 "+44 1234567",
//                 "+44 2345678"
//             ]
//         }"#;

//     // Parse the string of data into serde_json::Value.
//     let v: Value = serde_json::from_str(data).unwrap();
//     match write_json(&v, "") {
//         Ok(_) => {
//             unimplemented!()
//         }
//         Err(e) => {
//             assert_eq!(e.error_type, MedErrorType::IoError);
//         }
//     }
// }

// #[tokio::test]
// async fn test_rayon_thread_pool_error() {
//     match Worker::new(0).await {
//         Ok(_) => unimplemented!(),
//         Err(e) => {
//             assert_eq!(e.error_type, MedErrorType::WorkerError);
//         }
//     }
// }