testcontainers 0.27.3

A library for integration-testing against docker containers from within Rust.
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

use crate::{
    compose::{
        client::{ComposeInterface, DownCommand, UpCommand},
        error::Result,
        ContainerisedComposeOptions,
    },
    core::{CmdWaitFor, ExecCommand},
    images::docker_cli::DockerCli,
    runners::AsyncRunner,
    ContainerAsync, ContainerRequest, ImageExt,
};

pub(crate) struct ContainerisedComposeCli {
    container: ContainerAsync<DockerCli>,
    compose_files_in_container: Vec<String>,
    project_directory: Option<String>,
}

impl ContainerisedComposeCli {
    pub(super) async fn new(options: ContainerisedComposeOptions) -> Result<Self> {
        let (compose_files, project_directory) = options.into_parts();
        let mut image = ContainerRequest::from(DockerCli::new("/var/run/docker.sock"));

        let compose_files_in_container: Vec<String> = compose_files
            .iter()
            .enumerate()
            .map(|(i, _)| format!("/docker-compose-{i}.yml"))
            .collect();
        for (path, file_name) in compose_files
            .into_iter()
            .zip(compose_files_in_container.iter())
        {
            image = image.with_copy_to(file_name, path);
        }

        let container = image.start().await?;
        let project_directory = project_directory.map(|path| path.to_string_lossy().into_owned());

        Ok(Self {
            container,
            compose_files_in_container,
            project_directory,
        })
    }
}

impl ComposeInterface for ContainerisedComposeCli {
    async fn up(&self, command: UpCommand) -> Result<()> {
        let mut cmd_parts = vec!["docker".to_string(), "compose".to_string()];

        if let Some(project_directory) = &self.project_directory {
            cmd_parts.push("--project-directory".to_string());
            cmd_parts.push(project_directory.clone());
        }

        cmd_parts.push("--project-name".to_string());
        cmd_parts.push(command.project_name.clone());

        for file in &self.compose_files_in_container {
            cmd_parts.push("-f".to_string());
            cmd_parts.push(file.to_string());
        }

        cmd_parts.push("up".to_string());
        cmd_parts.push("-d".to_string());

        if command.build {
            cmd_parts.push("--build".to_string());
        }

        if command.pull {
            cmd_parts.push("--pull".to_string());
            cmd_parts.push("always".to_string());
        }

        if command.wait {
            cmd_parts.push("--wait".to_string());
            cmd_parts.push("--wait-timeout".to_string());
            cmd_parts.push(command.wait_timeout.as_secs().to_string());
        }

        let exec = ExecCommand::new(cmd_parts)
            .with_cmd_ready_condition(CmdWaitFor::exit_code(0))
            .with_env_vars(command.env_vars);
        self.container.exec(exec).await?;

        Ok(())
    }

    async fn down(&self, command: DownCommand) -> Result<()> {
        let mut cmd = vec!["docker".to_string(), "compose".to_string()];

        if let Some(project_directory) = &self.project_directory {
            cmd.push("--project-directory".to_string());
            cmd.push(project_directory.clone());
        }

        cmd.extend([
            "--project-name".to_string(),
            command.project_name.clone(),
            "down".to_string(),
        ]);

        if command.volumes {
            cmd.push("--volumes".to_string());
        }
        if command.rmi {
            cmd.push("--rmi".to_string());
        }

        let exec = ExecCommand::new(cmd).with_cmd_ready_condition(CmdWaitFor::exit_code(0));
        self.container.exec(exec).await?;
        Ok(())
    }
}