oxdock-cli 0.5.0-alpha

CLI tooling for executing OxDock's Docker-inspired language on native platforms.
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

use oxdock_cli::{Step, StepKind, run_script};
use oxdock_fs::{GuardedPath, PathResolver};

#[cfg_attr(
    miri,
    ignore = "spawns subprocesses; process spawning not supported under Miri"
)]
#[test]
fn script_runs_copy_and_symlink() {
    let temp = GuardedPath::tempdir().unwrap();
    let root = temp.as_guarded_path().clone();

    // Prepare minimal workspace structure using the PathResolver to avoid
    // calling `std::fs` directly from non-fs crates.
    let resolver = PathResolver::new(root.as_path(), root.as_path()).unwrap();
    resolver
        .create_dir_all(&root.join("client/dist").unwrap())
        .unwrap();
    resolver
        .create_dir_all(&root.join("server").unwrap())
        .unwrap();
    // Seed dist with a file
    resolver
        .write_file(&root.join("client/dist/test.txt").unwrap(), b"hello\n")
        .unwrap();

    let steps = vec![
        Step {
            guards: Vec::new(),
            kind: StepKind::Workdir("client".into()),
            scope_enter: 0,
            scope_exit: 0,
        },
        Step {
            guards: Vec::new(),
            kind: StepKind::Run("echo ok".into()),
            scope_enter: 0,
            scope_exit: 0,
        },
        Step {
            guards: Vec::new(),
            kind: StepKind::Workdir("/".into()),
            scope_enter: 0,
            scope_exit: 0,
        },
        Step {
            guards: Vec::new(),
            kind: StepKind::Copy {
                from: "./client/dist".into(),
                to: "./client/dist-copy".into(),
            },
            scope_enter: 0,
            scope_exit: 0,
        },
        Step {
            guards: Vec::new(),
            kind: StepKind::Symlink {
                from: "./client/dist".into(),
                to: "./server/dist".into(),
            },
            scope_enter: 0,
            scope_exit: 0,
        },
        Step {
            guards: Vec::new(),
            kind: StepKind::Run("echo ok".into()),
            scope_enter: 0,
            scope_exit: 0,
        },
    ];

    run_script(&root, &steps).unwrap();

    // Copy should exist and contain the file
    let copied = root.join("client/dist-copy/test.txt").unwrap();
    assert!(copied.as_path().exists());
    let contents = resolver.read_to_string(&copied).unwrap();
    assert!(contents.contains("hello"));

    // Symlink should resolve to dist (on Unix); on non-Unix we copied.
    #[cfg(unix)]
    {
        let linked = root.join("server/dist/test.txt").unwrap();
        assert!(linked.as_path().exists());
    }
    #[cfg(not(unix))]
    {
        // On non-Unix, symlink_dir may not be available; ensure copy fallback works.
        let linked_copy = root.join("server/dist/test.txt").unwrap();
        assert!(linked_copy.as_path().exists());
    }
}