vdev 0.3.1

CLI utilities for Vector (vector.dev) development and CI workflows
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

use anyhow::Result;
use std::collections::HashSet;

use crate::{testing::config::ComposeTestConfig, utils::environment::Environment};

use super::active_projects::{find_active_environment, load_active_projects};

pub fn exec(integration: Option<&String>, path: &str) -> Result<()> {
    let show = Show::new(path)?;
    match integration {
        None => show.show_all(),
        Some(integration) => show.show_one(integration),
    }
}

/// Print only the environment names for a single integration, one per line.
pub fn exec_environments_only(integration: &str, path: &str) -> Result<()> {
    let (_test_dir, config) = ComposeTestConfig::load(path, integration)?;
    for environment in config.environments().keys() {
        println!("{environment}");
    }
    Ok(())
}

struct Show {
    path: String,
    active_projects: HashSet<String>,
}

impl Show {
    fn new(path: &str) -> Result<Self> {
        Ok(Self {
            path: path.to_string(),
            active_projects: load_active_projects()?,
        })
    }

    fn show_all(&self) -> Result<()> {
        let entries = ComposeTestConfig::collect_all(&self.path)?;

        let width = entries
            .keys()
            .fold(16, |width, entry| width.max(entry.len()));
        println!("{:width$}  Environment Name(s)", "Integration Name");
        println!("{:width$}  -------------------", "----------------");
        for (integration, config) in entries {
            let prefix = format!("vector-{}-{integration}-", self.path);
            let active_env = find_active_environment(&self.active_projects, &prefix, &config);
            let environments = config
                .environments()
                .keys()
                .map(|environment| format_env(active_env.as_ref(), environment))
                .collect::<Vec<_>>()
                .join("  ");
            println!("{integration:width$}  {environments}");
        }
        Ok(())
    }

    fn show_one(&self, integration: &str) -> Result<()> {
        let (_test_dir, config) = ComposeTestConfig::load(&self.path, integration)?;
        let prefix = format!("vector-{}-{integration}-", self.path);
        let active_env = find_active_environment(&self.active_projects, &prefix, &config);

        if let Some(args) = &config.args {
            println!("Test args: {}", args.join(" "));
        } else {
            println!("Test args: N/A");
        }

        if config.features.is_empty() {
            println!("Features: N/A");
        } else {
            println!("Features: {}", config.features.join(","));
        }

        println!(
            "Test filter: {}",
            config.test_filter.as_deref().unwrap_or("N/A")
        );

        println!("Environment:");
        print_env("  ", &config.env);
        println!("Runner:");
        println!("  Environment:");
        print_env("    ", &config.runner.env);
        println!("  Volumes:");
        if config.runner.volumes.is_empty() {
            println!("    N/A");
        } else {
            for (target, mount) in &config.runner.volumes {
                println!("    {target} => {mount}");
            }
        }
        println!(
            "  Needs docker socket: {}",
            config.runner.needs_docker_socket
        );

        println!("Environments:");
        for environment in config.environments().keys() {
            println!("  {}", format_env(active_env.as_ref(), environment));
        }

        Ok(())
    }
}

fn print_env(prefix: &str, environment: &Environment) {
    if environment.is_empty() {
        println!("{prefix} N/A");
    } else {
        for (key, value) in environment {
            match value {
                Some(value) => println!("{prefix}{key}={value:?}"),
                None => println!("{prefix}{key} (passthrough)"),
            }
        }
    }
}

fn format_env(active_env: Option<&String>, environment: &str) -> String {
    match active_env {
        Some(active) if active == environment => format!("{environment} (active)"),
        _ => environment.into(),
    }
}