shun 0.6.21

Flow-driven payload delivery runtime — installers, flashers, and portable modes
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

//! `install.launch-after-install` — the policy resolution against the
//! wizard answers, and the `launch` helper's contract.
//!
//! The spawn path itself is never exercised (a test must not start a real
//! application process): the helper's arms are pinned through the
//! disabled no-op and the missing-entry error instead.

mod common;

use shun::ShunError;
use shun::config::{InstallConfig, ShortcutPolicy};
use shun::targets::install::{InstallContext, WizardAnswers, launch};

/// `WizardAnswers` with the launch answer under test; the other policies
/// keep their default-checked values.
fn answers(launch: bool) -> WizardAnswers {
    WizardAnswers {
        launch_after_install: launch,
        ..WizardAnswers::defaults()
    }
}

/// An install config carrying only the launch policy under test.
fn config(policy: ShortcutPolicy) -> InstallConfig {
    InstallConfig {
        launch_after_install: policy,
        ..InstallConfig::default()
    }
}

#[test]
fn wizard_defaults_check_the_launch_box() {
    assert!(
        WizardAnswers::defaults().launch_after_install,
        "the done-page default is checked (the NSIS convention)"
    );
}

#[test]
fn a_hand_built_context_launches_nothing() {
    let dir = tempfile::tempdir().unwrap();
    let context = common::ctx("ShunDemo-Test-Launch", dir.path().join("app"), false);
    assert!(
        !context.launch_after_install,
        "the no-op baseline launches nothing"
    );
}

#[test]
fn ask_consults_the_wizard_answer() {
    let dir = tempfile::tempdir().unwrap();
    let mut context = common::ctx("ShunDemo-Test-Launch", dir.path().join("app"), false);

    context.apply_config(&config(ShortcutPolicy::Ask), answers(true));
    assert!(context.launch_after_install, "ask follows a checked box");
    context.apply_config(&config(ShortcutPolicy::Ask), answers(false));
    assert!(
        !context.launch_after_install,
        "ask follows an unchecked box"
    );
}

#[test]
fn always_and_never_pin_the_policy() {
    let dir = tempfile::tempdir().unwrap();
    let mut context = common::ctx("ShunDemo-Test-Launch", dir.path().join("app"), false);

    context.apply_config(&config(ShortcutPolicy::Always), answers(false));
    assert!(
        context.launch_after_install,
        "always wins over the wizard answer"
    );
    context.apply_config(&config(ShortcutPolicy::Never), answers(true));
    assert!(
        !context.launch_after_install,
        "never wins over the wizard answer"
    );
}

#[test]
fn launch_is_a_no_op_without_the_flag_or_an_entry_point() {
    let dir = tempfile::tempdir().unwrap();
    let install_dir = dir.path().join("app");

    // The entry point is declared but absent on disk (the common fixture
    // stages no files): the resolved-false flag short-circuits before the
    // entry-point check.
    let context = common::ctx("ShunDemo-Test-Launch", install_dir.clone(), false);
    assert!(launch(&context).is_ok());

    // Enabled, but no entry point declared at all: still a no-op.
    let mut bare = InstallContext::new(
        "ShunDemo-Test-Launch".into(),
        "0.0.1".into(),
        install_dir,
        false,
    );
    bare.launch_after_install = true;
    assert!(launch(&bare).is_ok());
}

#[test]
fn launch_reports_the_missing_entry_point() {
    let dir = tempfile::tempdir().unwrap();
    let install_dir = dir.path().join("app");
    let mut context = common::ctx("ShunDemo-Test-Launch", install_dir.clone(), false);
    context.launch_after_install = true;

    match launch(&context) {
        Err(ShunError::MissingEntry(path)) => {
            assert_eq!(path, install_dir.join("bin/shun-demo.exe"));
        }
        other => panic!("expected the missing entry point, got {other:?}"),
    }
}