merka-vault 0.3.2

Vault provisioning and management crate integrating with merka-core
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

use log::info;
use serial_test::serial;

mod test_utils;
use test_utils::{setup_logging, DockerComposeEnv};

#[cfg(test)]
mod tests {
    use super::*;
    use std::process::{Child, Command};
    use std::thread;
    use std::time::Duration;
    use tokio::runtime::Runtime;

    // Helper function to start a process and return its handle
    fn start_process(command: &str, args: &[&str]) -> Child {
        Command::new(command)
            .args(args)
            .spawn()
            .expect("Failed to start process")
    }

    #[test]
    #[serial]
    fn test_example_web_server() {
        // Setup logging
        setup_logging();
        info!("Starting example web server test");

        // Start docker-compose environment
        let mut docker = DockerComposeEnv::new();
        match docker.start() {
            Ok(_) => info!("Docker environment started successfully"),
            Err(e) => {
                info!("Docker environment start failed: {}. Test skipped.", e);
                return;
            }
        };

        // Ensure the example binaries are built
        let status = Command::new("cargo")
            .args([
                "build",
                "--example",
                "web_server",
                "--example",
                "test_client",
            ])
            .status()
            .expect("Failed to build examples");

        assert!(status.success(), "Failed to build examples");

        // Start the web server
        let mut web_server = start_process("cargo", &["run", "--example", "web_server"]);

        // Sleep to let the server start up
        thread::sleep(Duration::from_secs(5));

        // Create a runtime for the test client
        let rt = Runtime::new().unwrap();

        // Run the test client to verify functionality
        let result = rt.block_on(async {
            // Start the test client
            let mut test_client = start_process(
                "cargo",
                &[
                    "run",
                    "--example",
                    "test_client",
                    "--",
                    "--restart-sub-vault",
                ],
            );

            // Wait for test client to complete
            thread::sleep(Duration::from_secs(35));

            let client_status = test_client.try_wait().expect("Failed to get client status");

            // Terminate test client if it's still running
            if client_status.is_none() {
                test_client.kill().expect("Failed to kill test client");
                test_client
                    .wait()
                    .expect("Failed to wait for test client to exit");
            }

            // Return success if client didn't exit with an error
            client_status.map_or(true, |s| s.success())
        });

        // Terminate web server
        web_server.kill().expect("Failed to kill web server");
        web_server
            .wait()
            .expect("Failed to wait for web server to exit");

        // Explicitly stop Docker at the end of the test
        if let Err(e) = docker.stop() {
            info!("Failed to stop Docker Compose: {}", e);
        } else {
            info!("Docker Compose environment stopped successfully");
        }

        // Check if the test was successful
        assert!(result, "Example test failed");
    }
}