oximedia-cli 0.1.8

Command-line interface for OxiMedia
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

//! End-to-end tests for the `normalize` subcommand.
//!
//! These tests verify that `oximedia normalize analyze` can accept real WAV
//! files without panicking and produces meaningful LUFS output.

mod common;

#[test]
fn normalize_analyze_wav_exits_zero() {
    let (_dir, wav_path) = common::write_wav_fixture(1000.0, 44100, 1, 5.0);

    let output = std::process::Command::new(assert_cmd::cargo::cargo_bin("oximedia"))
        .args([
            "normalize",
            "analyze",
            "--input",
            wav_path.to_str().expect("path is UTF-8"),
            "--standard",
            "ebu",
        ])
        .output()
        .expect("failed to run oximedia normalize analyze");

    let stderr = String::from_utf8_lossy(&output.stderr);
    let stdout = String::from_utf8_lossy(&output.stdout);

    // Must not panic
    assert!(
        !stderr.contains("thread 'main' panicked"),
        "normalize analyze must not panic: {stderr}"
    );

    // Must not contain unimplemented stubs
    let all_output = format!("{stdout}{stderr}");
    assert!(
        !all_output.to_lowercase().contains("not yet implemented"),
        "must not contain unimplemented: {all_output}"
    );

    // Command should succeed
    assert!(
        output.status.success(),
        "normalize analyze should succeed on valid WAV, stdout={stdout}, stderr={stderr}"
    );

    // Output should mention LUFS
    assert!(
        stdout.contains("LUFS") || stdout.contains("lufs"),
        "successful normalize should mention LUFS, stdout: {stdout}"
    );

    // A 1 kHz full-scale sine should produce a loud reading (not -inf / not positive)
    // EBU R128 integrated loudness for a 1 kHz near-full-scale sine over 5s is
    // typically around -3 LUFS. We just verify it's a finite numeric value.
    assert!(
        !stdout.contains("-inf") && !stdout.contains("inf LUFS"),
        "LUFS should be a finite number, not infinite: {stdout}"
    );
}

#[test]
fn normalize_analyze_wav_json_output() {
    let (_dir, wav_path) = common::write_wav_fixture(1000.0, 44100, 1, 3.0);

    let output = std::process::Command::new(assert_cmd::cargo::cargo_bin("oximedia"))
        .args([
            "--json",
            "normalize",
            "analyze",
            "--input",
            wav_path.to_str().expect("path is UTF-8"),
            "--standard",
            "ebu",
        ])
        .output()
        .expect("failed to run oximedia normalize analyze --json");

    let stderr = String::from_utf8_lossy(&output.stderr);
    let stdout = String::from_utf8_lossy(&output.stdout);

    // Must not panic
    assert!(
        !stderr.contains("thread 'main' panicked"),
        "normalize analyze --json must not panic: {stderr}"
    );

    // If it succeeds, output should be parseable JSON
    if output.status.success() {
        let parsed: Result<serde_json::Value, _> = serde_json::from_str(&stdout);
        assert!(parsed.is_ok(), "JSON output must be valid JSON: {stdout}");
        let obj = parsed.expect("already checked");
        // Should contain integrated_lufs field
        assert!(
            obj.get("analysis")
                .and_then(|a| a.get("integrated_lufs"))
                .is_some(),
            "JSON should contain analysis.integrated_lufs: {obj}"
        );
    }
}

#[test]
fn normalize_analyze_missing_file_exits_nonzero() {
    let missing_wav = std::env::temp_dir()
        .join("this_file_does_not_exist_oximedia_normalize_test.wav")
        .display()
        .to_string();
    let output = std::process::Command::new(assert_cmd::cargo::cargo_bin("oximedia"))
        .args(["normalize", "analyze", "--input", &missing_wav])
        .output()
        .expect("failed to run oximedia normalize analyze on missing file");

    let stderr = String::from_utf8_lossy(&output.stderr);

    // Must not panic
    assert!(
        !stderr.contains("thread 'main' panicked"),
        "must not panic on missing file: {stderr}"
    );

    // Must exit non-zero
    assert!(
        !output.status.success(),
        "should fail on missing input file"
    );
}

#[test]
fn normalize_targets_lists_standards() {
    let output = std::process::Command::new(assert_cmd::cargo::cargo_bin("oximedia"))
        .args(["normalize", "targets"])
        .output()
        .expect("failed to run oximedia normalize targets");

    let stderr = String::from_utf8_lossy(&output.stderr);
    let stdout = String::from_utf8_lossy(&output.stdout);

    assert!(
        !stderr.contains("thread 'main' panicked"),
        "normalize targets must not panic: {stderr}"
    );
    assert!(
        output.status.success(),
        "normalize targets should succeed, stderr: {stderr}"
    );
    // Should list at least one platform
    assert!(
        stdout.contains("EBU") || stdout.contains("ebu") || stdout.contains("Spotify"),
        "targets output should list platforms: {stdout}"
    );
}