junobuild-didc 0.1.0

A CLI tool for generating JavaScript or TypeScript content from a DID file using the didc tool.
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

use std::fs::{read_to_string, remove_file};
use std::path::Path;
use std::process::Command;

fn normalize_output(output: &str) -> String {
    output
        .lines()
        .map(str::trim)
        .collect::<Vec<&str>>()
        .join("\n")
}

fn run_test_for_target(target: &str, expected_output_file: &str, output_file: Option<&str>) {
    let input_path = "tests/data/satellite.did";

    let binary_path = Path::new("target/debug/junobuild-didc");

    let mut command = Command::new(binary_path);
    command
        .arg("--input")
        .arg(input_path)
        .arg("--target")
        .arg(target);

    if let Some(output_path) = output_file {
        command.arg("--output").arg(output_path);
    }

    let output = command.output().expect("Failed to execute command");

    let stdout = String::from_utf8(output.stdout).expect("Invalid UTF-8 in output");

    let expected_output =
        read_to_string(expected_output_file).expect("Failed to read expected output file");

    let normalized_stdout = normalize_output(&stdout);
    let normalized_expected_output = normalize_output(&expected_output);

    if output_file.is_none() {
        assert_eq!(
            normalized_stdout, normalized_expected_output,
            "Mismatch for target: {}",
            target
        );
    }

    if let Some(output_path) = output_file {
        let file_output = read_to_string(output_path).expect("Failed to read from output file");

        let normalized_file_output = normalize_output(&file_output);

        assert_eq!(
            normalized_file_output, normalized_expected_output,
            "Mismatch in file output for target: {}",
            target
        );

        remove_file(output_path).expect("Failed to remove output file");
    }
}

#[test]
fn test_js_target() {
    run_test_for_target("js", "tests/data/satellite.js", None);
}

#[test]
fn test_ts_target() {
    run_test_for_target("ts", "tests/data/satellite.ts", None);
}

#[test]
fn test_did_target() {
    run_test_for_target("did", "tests/data/output.did", None);
}

#[test]
fn test_js_target_with_output_file() {
    run_test_for_target(
        "js",
        "tests/data/satellite.js",
        Some("target/test/output.js"),
    );
}

#[test]
fn test_ts_target_with_output_file() {
    run_test_for_target(
        "ts",
        "tests/data/satellite.ts",
        Some("target/test/output.ts"),
    );
}

#[test]
fn test_did_target_with_output_file() {
    run_test_for_target(
        "did",
        "tests/data/output.did",
        Some("target/test/custom_output.did"),
    );
}