cuenv 0.40.6

Event-driven CLI with inline TUI for cuenv
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
136

//! Performance regression tests for the export command.
//!
//! The export command is called on every shell prompt and must remain fast
//! for a good user experience. These tests ensure we don't regress.
//!
//! Note: Threshold is 100ms to account for CI/sandbox/coverage instrumentation variability.
//! In practice, export should complete in <25ms on fast systems.

// Integration tests can use unwrap/expect for cleaner assertions
#![allow(clippy::unwrap_used, clippy::expect_used)]

use std::ffi::OsStr;
use std::process::Command;
use std::time::Instant;
use tempfile::TempDir;

/// Create a Command with a clean environment (no CI vars leaking).
fn clean_environment_command(bin: impl AsRef<OsStr>) -> Command {
    let mut cmd = Command::new(bin);
    cmd.env_clear()
        .env("PATH", std::env::var("PATH").unwrap_or_default())
        .env("HOME", std::env::var("HOME").unwrap_or_default())
        .env("USER", std::env::var("USER").unwrap_or_default());
    cmd
}

/// Export with no env.cue must complete quickly.
///
/// This is the fastest possible path - no CUE evaluation, no state checks.
/// Threshold is 100ms to account for coverage instrumentation overhead.
#[test]
fn test_export_no_env_cue_fast() {
    let temp_dir = TempDir::new().unwrap();

    // Warm up (first run may be slower due to process/disk cache)
    let _ = clean_environment_command(env!("CARGO_BIN_EXE_cuenv"))
        .args(["export", "--shell", "fish", "--package", "cuenv"])
        .current_dir(temp_dir.path())
        .output();

    let start = Instant::now();
    let output = clean_environment_command(env!("CARGO_BIN_EXE_cuenv"))
        .args(["export", "--shell", "fish", "--package", "cuenv"])
        .current_dir(temp_dir.path())
        .output()
        .expect("Failed to run cuenv");
    let elapsed = start.elapsed();

    assert!(output.status.success(), "Export failed: {output:?}");

    // The output should be a no-op script that clears state
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(
        stdout.contains("set -e") || stdout.contains("true"),
        "Expected no-op fish script, got: {stdout}"
    );

    let elapsed_ms = elapsed.as_millis();
    assert!(
        elapsed_ms < 100,
        "PERFORMANCE REGRESSION: Export took {elapsed_ms}ms, expected <100ms for no-env-cue case"
    );
}

/// Export performance regression test - 100ms threshold.
///
/// Runs multiple iterations to get reliable timing and checks the median.
/// Threshold is relaxed to account for coverage instrumentation overhead.
#[test]
fn test_export_performance_threshold() {
    let temp_dir = TempDir::new().unwrap();

    // Warm up run
    let _ = clean_environment_command(env!("CARGO_BIN_EXE_cuenv"))
        .args(["export", "--shell", "fish", "--package", "cuenv"])
        .current_dir(temp_dir.path())
        .output();

    // Run 10 times and collect timings
    let mut times = Vec::new();
    for _ in 0..10 {
        let start = Instant::now();
        let _ = clean_environment_command(env!("CARGO_BIN_EXE_cuenv"))
            .args(["export", "--shell", "fish", "--package", "cuenv"])
            .current_dir(temp_dir.path())
            .output()
            .expect("Failed to run cuenv");
        times.push(start.elapsed().as_millis());
    }

    times.sort_unstable();
    let median = times[times.len() / 2];
    let min = times[0];

    // 100ms threshold - accounts for CI/sandbox/coverage variability while catching regressions
    assert!(
        median < 100,
        "PERFORMANCE REGRESSION: Median export time {median}ms exceeds 100ms threshold.\n\
         Min: {min}ms, All times: {times:?}\n\
         Export must be fast for shell prompt integration."
    );
}

/// Test export with different shell types to ensure consistent performance.
#[test]
fn test_export_all_shells_fast() {
    let temp_dir = TempDir::new().unwrap();
    let shells = ["fish", "bash", "zsh", "powershell"];

    for shell in shells {
        // Warm up
        let _ = clean_environment_command(env!("CARGO_BIN_EXE_cuenv"))
            .args(["export", "--shell", shell, "--package", "cuenv"])
            .current_dir(temp_dir.path())
            .output();

        let start = Instant::now();
        let output = clean_environment_command(env!("CARGO_BIN_EXE_cuenv"))
            .args(["export", "--shell", shell, "--package", "cuenv"])
            .current_dir(temp_dir.path())
            .output()
            .expect("Failed to run cuenv");
        let elapsed = start.elapsed();

        assert!(
            output.status.success(),
            "Export failed for shell {shell}: {output:?}"
        );

        let elapsed_ms = elapsed.as_millis();
        assert!(
            elapsed_ms < 100,
            "PERFORMANCE REGRESSION: Export for shell {shell} took {elapsed_ms}ms, expected <100ms"
        );
    }
}