oak-editor/crates/oak-cli/tests/cli.rs

// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

//! End-to-end tests for the built `oak-cli` binary (the C++ ctest suite
//! `oak_cli_info`/`oak_cli_render`/`oak_cli_probe`/`oak_cli_transcode`
//! equivalents, as far as the deferred facade allows).
//!
//! All four subcommands depend on facade families that are still deferred in
//! oakfacade (see `src/deferred.rs`), so the data-producing paths assert the
//! documented "not yet available" behavior with the C++-compatible exit
//! codes; the argument-validation paths assert the exact C++ messages and
//! exit code 64.

use std::process::Command;

fn bin() -> &'static str {
	env!("CARGO_BIN_EXE_oak-cli")
}

fn run(args: &[&str]) -> (i32, String, String) {
	let out = Command::new(bin())
		.args(args)
		.output()
		.expect("spawn oak-cli");
	(
		out.status.code().expect("exit code"),
		String::from_utf8_lossy(&out.stdout).into_owned(),
		String::from_utf8_lossy(&out.stderr).into_owned(),
	)
}

#[test]
fn help_prints_the_cpp_usage_text_and_exits_zero() {
	let (code, stdout, stderr) = run(&["--help"]);
	assert_eq!(code, 0);
	assert!(stderr.is_empty());
	assert!(stdout.starts_with("oak-cli - headless consumer of the liboakengine C ABI\n"));
	assert!(stdout.contains("oak-cli transcode <input_media> <out> [width] [--format ppm|mp4]"));
	assert!(stdout.contains("Exit codes:"));
	assert!(stdout.contains("64  usage error"));
}

#[test]
fn no_arguments_is_a_usage_error() {
	let (code, _stdout, stderr) = run(&[]);
	assert_eq!(code, 64);
	assert!(stderr.contains("Usage:"));
}

#[test]
fn unknown_command_is_a_usage_error() {
	let (code, _stdout, stderr) = run(&["frobnicate"]);
	assert_eq!(code, 64);
	assert!(stderr.contains("error: unknown command \"frobnicate\""));
}

#[test]
fn info_on_a_fixture_reports_not_yet_available() {
	// The fixture mirrors the ctest invocation; the deferred gate fires
	// before any file access.
	let (code, _stdout, stderr) = run(&["info", "tests/project_with_footage.ove"]);
	assert_eq!(code, 1);
	assert!(
		stderr.contains("error: info: not yet available"),
		"stderr: {stderr}"
	);
	// The crate was renamed oakfacade -> oakengine; the deferral reason
	// names the current crate.
	assert!(stderr.contains("oakengine"));
}

#[test]
fn info_with_missing_argument_is_a_usage_error() {
	let (code, _stdout, stderr) = run(&["info"]);
	assert_eq!(code, 64);
	assert!(stderr.contains("Usage:"));
}

#[test]
fn probe_reports_not_yet_available() {
	let (code, _stdout, stderr) = run(&["probe", "tests/demo.mp4"]);
	assert_eq!(code, 1);
	assert!(
		stderr.contains("error: probe: not yet available"),
		"stderr: {stderr}"
	);
}

#[test]
fn render_reports_render_unavailable() {
	let (code, _stdout, stderr) = run(&["render", "p.ove", "0", "1", "out"]);
	assert_eq!(code, 2);
	assert!(
		stderr.contains("error: render: not yet available"),
		"stderr: {stderr}"
	);
}

#[test]
fn render_bad_seconds_is_a_usage_error() {
	let (code, _stdout, stderr) = run(&["render", "p.ove", "abc", "1", "out"]);
	assert_eq!(code, 64);
	assert!(
		stderr.contains("error: invalid start seconds \"abc\""),
		"stderr: {stderr}"
	);
}

#[test]
fn render_end_not_after_start_is_a_usage_error() {
	let (code, _stdout, stderr) = run(&["render", "p.ove", "2", "1", "out"]);
	assert_eq!(code, 64);
	assert!(
		stderr.contains("error: invalid end seconds \"1\""),
		"stderr: {stderr}"
	);
}

#[test]
fn transcode_reports_render_unavailable() {
	let (code, _stdout, stderr) = run(&["transcode", "in.mp4", "out.mp4", "960"]);
	assert_eq!(code, 2);
	assert!(
		stderr.contains("error: transcode: not yet available"),
		"stderr: {stderr}"
	);
}

#[test]
fn transcode_bad_width_is_a_usage_error() {
	let (code, _stdout, stderr) = run(&["transcode", "in.mp4", "out.mp4", "banana"]);
	assert_eq!(code, 64);
	assert!(
		stderr.contains("error: invalid width \"banana\""),
		"stderr: {stderr}"
	);
}

#[test]
fn transcode_nonpositive_width_is_a_usage_error() {
	let (code, _stdout, stderr) = run(&["transcode", "in.mp4", "out.mp4", "0"]);
	assert_eq!(code, 64);
	assert!(
		stderr.contains("error: invalid width \"0\""),
		"stderr: {stderr}"
	);
}

#[test]
fn transcode_unknown_format_is_a_usage_error() {
	let (code, _stdout, stderr) = run(&["transcode", "in.mp4", "out.mp4", "--format", "webm"]);
	assert_eq!(code, 64);
	assert!(
		stderr.contains("error: unknown --format \"webm\" (ppm|mp4)"),
		"stderr: {stderr}"
	);
}

#[test]
fn transcode_ppm_format_is_accepted_then_reports_not_available() {
	let (code, _stdout, stderr) = run(&["transcode", "in.mp4", "outdir", "960", "--format", "ppm"]);
	assert_eq!(code, 2);
	assert!(
		stderr.contains("error: transcode: not yet available"),
		"stderr: {stderr}"
	);
}