euv-cli 0.37.2

The official CLI tool for the euv UI framework, providing dev/release profiles with run/build modes, hot reload, and wasm-pack integration.
Documentation
use super::*;

fn build_args(argv: &[&str]) -> BuildArgs {
    let mut full: Vec<String> = vec!["euv".to_string(), "build".to_string()];
    for arg in argv {
        full.push((*arg).to_string());
    }
    let cli: Cli = Cli::parse_from(full);
    match cli.get_command() {
        Mode::Build(args) => args.clone(),
        other => panic!("expected Build, got {other:?}"),
    }
}

fn mode_args(argv: &[&str]) -> ModeArgs {
    let mut full: Vec<String> = vec!["euv".to_string()];
    for arg in argv {
        full.push((*arg).to_string());
    }
    ModeArgs::parse_from(full)
}

#[test]
fn a_plain_build_keeps_the_ordinary_web_only_arguments() {
    let args: BuildArgs = build_args(&["--release", "--crate-path", "./example"]);
    assert!(!args.get_all(), "the flag is false by default");
    assert!(
        args.get_platforms().is_empty(),
        "no platform is selected by default"
    );
    assert!(!args.get_plan(), "the plan is not requested by default");
    let rendered: String = format!("{:?}", args.get_mode());
    assert!(
        rendered.contains("./example"),
        "the crate path is kept, got {rendered}"
    );
    assert!(
        rendered.contains("release: true"),
        "the release flag is kept, got {rendered}"
    );
}

#[test]
fn the_all_flag_reaches_the_build_arguments() {
    let args: BuildArgs = build_args(&["--all"]);
    assert!(args.get_all(), "--all must select the whole host plan");
}

#[test]
fn the_platforms_flag_accepts_a_comma_separated_list() {
    let args: BuildArgs = build_args(&["--platforms", "macos,android"]);
    assert_eq!(
        args.get_platforms().as_slice(),
        &[NativePlatform::Macos, NativePlatform::Android],
        "both platforms are selected, in the order they were written"
    );
}

#[test]
fn the_platforms_flag_accepts_a_repeated_flag() {
    let args: BuildArgs = build_args(&["--platforms", "macos", "--platforms", "ios"]);
    assert_eq!(
        args.get_platforms().as_slice(),
        &[NativePlatform::Macos, NativePlatform::Ios],
        "a repeated flag extends the selection"
    );
}

#[test]
fn an_unknown_platform_name_is_rejected_by_the_parser() {
    let outcome: Result<Cli, clap::Error> =
        Cli::try_parse_from(["euv", "build", "--platforms", "bogus"]);
    assert!(outcome.is_err(), "an unknown platform must not be accepted");
}

#[test]
fn the_native_path_flag_reaches_the_build_arguments() {
    let args: BuildArgs = build_args(&["--native-path", "/tmp/client"]);
    assert_eq!(
        args.try_get_native_path().as_deref(),
        Some(Path::new("/tmp/client")),
        "an external native layout must be selectable"
    );
}

#[test]
fn the_plan_flag_reaches_the_build_arguments() {
    let args: BuildArgs = build_args(&["--plan"]);
    assert!(args.get_plan(), "--plan must reach the build arguments");
}

#[test]
fn the_all_and_platforms_flags_cannot_be_combined() {
    let outcome: Result<Vec<NativePlatform>, EuvError> =
        resolve_requested_platforms(true, &[NativePlatform::Macos]);
    assert!(
        outcome.is_err(),
        "the two selectors name the same thing twice"
    );
    let error: EuvError = outcome.expect_err("the combination is rejected");
    let rendered: String = format!("{error}");
    assert!(
        rendered.contains("--all") && rendered.contains("--platforms"),
        "the message must name both flags, got {rendered}"
    );
}

#[test]
fn no_native_flag_means_no_native_request() {
    let observed: Vec<NativePlatform> =
        resolve_requested_platforms(false, &[]).expect("an empty request resolves");
    assert!(
        observed.is_empty(),
        "an ordinary build asks for no native platform"
    );
}

#[test]
fn a_repeated_platform_is_selected_once() {
    let observed: Vec<NativePlatform> =
        resolve_requested_platforms(false, &[NativePlatform::Macos, NativePlatform::Macos])
            .expect("a repeated platform resolves");
    assert_eq!(
        observed,
        vec![NativePlatform::Macos],
        "the same platform twice is one deliverable, not two builds"
    );
}

#[test]
fn the_whole_host_plan_names_every_deliverable_that_host_can_build() {
    let macos: Vec<NativePlatform> = host_platforms(HostOs::Macos);
    assert_eq!(
        macos,
        vec![
            NativePlatform::Macos,
            NativePlatform::Ios,
            NativePlatform::IosSimulator,
            NativePlatform::Android
        ],
        "a macOS host builds the Apple clients and the Android package"
    );
    let linux: Vec<NativePlatform> = host_platforms(HostOs::Linux);
    assert_eq!(
        linux,
        vec![NativePlatform::Linux, NativePlatform::Android],
        "a Linux host builds the Linux client and the Android package"
    );
    let windows: Vec<NativePlatform> = host_platforms(HostOs::Windows);
    assert_eq!(
        windows,
        vec![NativePlatform::Windows],
        "a Windows host builds the Windows client only"
    );
}

#[test]
fn the_android_builder_runs_on_both_hosts_that_support_it() {
    assert!(host_supports(HostOs::Macos, NativePlatform::Android));
    assert!(host_supports(HostOs::Linux, NativePlatform::Android));
    assert!(
        !host_supports(HostOs::Windows, NativePlatform::Android),
        "the Android builder has no Windows host"
    );
}

#[test]
fn every_apple_deliverable_requires_a_macos_host() {
    for platform in [
        NativePlatform::Macos,
        NativePlatform::Ios,
        NativePlatform::IosSimulator,
    ] {
        assert!(
            host_supports(HostOs::Macos, platform),
            "{platform:?} must be buildable on macOS"
        );
        assert!(
            !host_supports(HostOs::Linux, platform),
            "{platform:?} must not be buildable on Linux"
        );
        assert!(
            !host_supports(HostOs::Windows, platform),
            "{platform:?} must not be buildable on Windows"
        );
    }
}

#[test]
fn the_desktop_clients_each_require_their_own_host() {
    assert!(host_supports(HostOs::Linux, NativePlatform::Linux));
    assert!(!host_supports(HostOs::Macos, NativePlatform::Linux));
    assert!(host_supports(HostOs::Windows, NativePlatform::Windows));
    assert!(!host_supports(HostOs::Macos, NativePlatform::Windows));
}

#[test]
fn a_host_compatible_plan_names_its_builders_in_build_order() {
    let plan: NativePlan = resolve_native_plan(&host_platforms(HostOs::Macos), HostOs::Macos)
        .expect("a macOS host builds every requested platform");
    assert_eq!(plan.get_targets().len(), 4, "every deliverable is planned");
    assert_eq!(
        plan.get_targets()[0].platform,
        NativePlatform::Macos,
        "the desktop client is built first"
    );
    assert_eq!(
        plan.get_targets()[3].platform,
        NativePlatform::Android,
        "the Android package is built last"
    );
    assert_eq!(
        plan.get_targets()[3].task,
        NativeTask::Android,
        "the Android package is built by the Android builder"
    );
    assert_eq!(
        plan.get_targets()[0].task,
        NativeTask::Client,
        "the desktop client is built by the client builder"
    );
    assert!(plan.get_unsupported().is_empty(), "nothing is out of reach");
}

#[test]
fn an_incompatible_platform_fails_the_plan_before_any_build() {
    let outcome: Result<NativePlan, EuvError> =
        resolve_native_plan(&[NativePlatform::Windows], HostOs::Macos);
    let error: EuvError = outcome.expect_err("a Windows client cannot be built on macOS");
    let rendered: String = format!("{error}");
    assert!(
        rendered.contains("windows") && rendered.contains("macos"),
        "the message must name the platform and the host, got {rendered}"
    );
    assert!(
        rendered.contains("windows host"),
        "the message must say which host the platform needs, got {rendered}"
    );
}

#[test]
fn every_incompatible_platform_is_reported_together() {
    let outcome: Result<NativePlan, EuvError> = resolve_native_plan(
        &[NativePlatform::Linux, NativePlatform::Windows],
        HostOs::Macos,
    );
    let error: EuvError = outcome.expect_err("neither platform can be built here");
    let rendered: String = format!("{error}");
    assert!(
        rendered.contains("linux") && rendered.contains("windows"),
        "both unreachable platforms must be named, got {rendered}"
    );
}

#[test]
fn the_run_mode_rejects_the_native_only_flags() {
    for flag in ["--all", "--platforms", "--native-path", "--plan"] {
        let args: ModeArgs = mode_args(&["--", flag]);
        let outcome: Result<(), EuvError> = reject_native_flags_in_run(&args);
        assert!(
            outcome.is_err(),
            "{flag} selects a native build the run mode cannot do"
        );
        let error: EuvError = outcome.expect_err("the flag is rejected");
        let rendered: String = format!("{error}");
        assert!(
            rendered.contains(flag),
            "the message must name the flag the user typed, got {rendered}"
        );
    }
}

#[test]
fn the_run_mode_accepts_the_ordinary_arguments() {
    let args: ModeArgs = mode_args(&["--", "--target", "web", "--out-dir", "dist"]);
    let outcome: Result<(), EuvError> = reject_native_flags_in_run(&args);
    assert!(
        outcome.is_ok(),
        "a wasm-pack passthrough is not a native flag"
    );
}

#[test]
fn the_native_project_directory_defaults_to_the_repository_layout() {
    let base: PathBuf = PathBuf::from("/repo");
    let observed: PathBuf = resolve_native_project(&base, None);
    assert_eq!(
        observed,
        PathBuf::from("/repo/native/tauri"),
        "the default layout is the native client project inside the repository"
    );
}

#[test]
fn an_explicit_native_path_overrides_the_repository_layout() {
    let base: PathBuf = PathBuf::from("/repo");
    let override_path: PathBuf = PathBuf::from("/elsewhere/client");
    let observed: PathBuf = resolve_native_project(&base, Some(&override_path));
    assert_eq!(
        observed, override_path,
        "an external layout must be selectable without changing the repository"
    );
}

#[test]
fn a_relative_native_path_is_resolved_against_the_invocation_directory() {
    let base: PathBuf = PathBuf::from("/repo");
    let relative: PathBuf = PathBuf::from("clients/app");
    assert_eq!(
        resolve_native_project(&base, Some(&relative)),
        base.join(relative)
    );
}

#[test]
fn native_packaging_defaults_to_release() {
    let mut args: ModeArgs = mode_args(&[]);
    prepare_native_profile(&mut args).expect("default profile is valid");
    assert!(args.get_release());
}

#[test]
fn native_packaging_rejects_debug_and_profiling_before_building() {
    for flag in ["--dev", "--profiling"] {
        let mut args: ModeArgs = mode_args(&[flag]);
        assert!(prepare_native_profile(&mut args).is_err());
    }
}

#[test]
fn unsupported_hosts_are_not_treated_as_macos() {
    assert!(resolve_native_plan(&[], HostOs::Unsupported).is_err());
    assert!(!host_supports(HostOs::Unsupported, NativePlatform::Macos));
}

#[cfg(unix)]
#[tokio::test]
async fn a_native_builder_failure_stops_later_targets() {
    let root: PathBuf = temp_dir().join(format!("euv-native-failure-{}", process::id()));
    fs::create_dir_all(root.join("scripts/build")).expect("create fake builder directory");
    fs::write(root.join("scripts/build/build.sh"), "exit 17").expect("write failing test builder");
    fs::write(
        root.join("scripts/build/build-client.js"),
        r#"require('node:fs').writeFileSync('unexpected', 'ran')"#,
    )
    .expect("write later test builder");
    let plan: NativePlan = resolve_native_plan(
        &[NativePlatform::Android, NativePlatform::Macos],
        HostOs::Macos,
    )
    .expect("resolve test plan");
    let error: EuvError = run_native_builds(&plan, &root, &root.join("web"), "release")
        .await
        .expect_err("native failure must propagate");
    assert!(error.to_string().contains("17"));
    assert!(!root.join("unexpected").exists());
    fs::remove_dir_all(root).expect("remove test builders");
}

#[cfg(unix)]
#[tokio::test]
async fn the_native_builder_receives_the_exact_web_snapshot_and_release_mode() {
    let root: PathBuf = temp_dir().join(format!("euv-native-snapshot-{}", process::id()));
    fs::create_dir_all(root.join("scripts/build")).expect("create test builder directory");
    fs::write(
        root.join("scripts/build/build.sh"),
        r#"printf '%s\n' "$EUV_WEB_DIST" "$1" "$2" > received"#,
    )
    .expect("write snapshot test builder");
    let web: PathBuf = root.join("selected web output");
    let plan: NativePlan = resolve_native_plan(&[NativePlatform::Android], HostOs::Macos)
        .expect("resolve snapshot plan");
    run_native_builds(&plan, &root, &web, "release")
        .await
        .expect("run test builder");
    assert_eq!(
        fs::read_to_string(root.join("received")).expect("read builder input"),
        format!("{}\nandroid\nrelease\n", web.display())
    );
    fs::remove_dir_all(root).expect("remove test builder");
}

#[test]
fn a_missing_native_project_directory_is_reported_when_the_build_starts() {
    let missing: PathBuf = PathBuf::from("/definitely/not/a/repository");
    let outcome: Result<(), EuvError> = require_native_project(&missing);
    assert!(
        outcome.is_err(),
        "a directory that does not exist cannot be built in"
    );
    let error: EuvError = outcome.expect_err("the missing directory is reported");
    let rendered: String = format!("{error}");
    assert!(
        rendered.contains("--native-path"),
        "the message must point at the flag that fixes it, got {rendered}"
    );
}