syster-cli 0.4.5-alpha

Command-line interface for SysML v2 and KerML analysis
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! Integration tests for CLI import-workspace command.
//!
//! Tests that the `--import-workspace` flag properly loads XMI/KPAR files
//! into the analysis workspace with preserved element IDs.

#[cfg(feature = "interchange")]
#[test]
fn test_cli_import_workspace_xmi() {
    use std::fs;
    use std::process::Command;
    use syster::interchange::{Element, ElementId, ElementKind, Model, ModelFormat, Xmi};
    use tempfile::TempDir;

    // Create a simple XMI file
    let temp_dir = TempDir::new().unwrap();
    let xmi_path = temp_dir.path().join("test_model.xmi");

    let mut model = Model::new();
    let pkg = Element::new(ElementId::new("xmi-pkg-001"), ElementKind::Package)
        .with_name("TestPackage")
        .with_qualified_name("TestPackage");
    model.add_element(pkg);

    let part = Element::new(ElementId::new("xmi-part-001"), ElementKind::PartDefinition)
        .with_name("TestPart")
        .with_qualified_name("TestPackage::TestPart")
        .with_owner(ElementId::new("xmi-pkg-001"));
    model.add_element(part);

    // Write XMI file
    let xmi_bytes = Xmi.write(&model).expect("Should write XMI");
    fs::write(&xmi_path, xmi_bytes).expect("Should write file");

    // Run CLI command
    let output = Command::new(env!("CARGO_BIN_EXE_syster"))
        .arg("--import-workspace")
        .arg(&xmi_path)
        .arg("--no-stdlib") // Skip stdlib for faster test
        .output()
        .expect("Should run CLI");

    // Check output
    let stdout = String::from_utf8_lossy(&output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);

    println!("STDOUT:\n{}", stdout);
    println!("STDERR:\n{}", stderr);

    assert!(output.status.success(), "CLI should exit successfully");
    assert!(
        stdout.contains("Imported"),
        "Should report imported elements"
    );
    assert!(
        stdout.contains("symbols") && stdout.contains("workspace"),
        "Should mention symbols and workspace"
    );
    assert!(
        stdout.contains("Element IDs preserved"),
        "Should preserve element IDs"
    );
}

#[cfg(feature = "interchange")]
#[test]
fn test_cli_import_workspace_with_stdlib() {
    use std::fs;
    use std::process::Command;
    use syster::interchange::{Element, ElementId, ElementKind, Model, ModelFormat, Xmi};
    use tempfile::TempDir;

    // Create a simple XMI file
    let temp_dir = TempDir::new().unwrap();
    let xmi_path = temp_dir.path().join("model.xmi");

    let mut model = Model::new();
    let pkg = Element::new(ElementId::new("pkg-1"), ElementKind::Package)
        .with_name("MyModel")
        .with_qualified_name("MyModel");
    model.add_element(pkg);

    let xmi_bytes = Xmi.write(&model).expect("Should write XMI");
    fs::write(&xmi_path, xmi_bytes).expect("Should write file");

    // Run with stdlib enabled (default)
    let output = Command::new(env!("CARGO_BIN_EXE_syster"))
        .arg("--import-workspace")
        .arg(&xmi_path)
        .arg("--verbose")
        .output()
        .expect("Should run CLI");

    let stdout = String::from_utf8_lossy(&output.stdout);

    assert!(output.status.success(), "CLI should succeed with stdlib");
    assert!(
        stdout.contains("Imported 1 elements"),
        "Should import model"
    );
    assert!(
        stdout.contains("Total symbols in workspace"),
        "Should show workspace stats"
    );
}

#[cfg(feature = "interchange")]
#[test]
fn test_cli_import_vs_import_workspace() {
    use std::fs;
    use std::process::Command;
    use syster::interchange::{Element, ElementId, ElementKind, Model, ModelFormat, Xmi};
    use tempfile::TempDir;

    // Create XMI file
    let temp_dir = TempDir::new().unwrap();
    let xmi_path = temp_dir.path().join("test.xmi");

    let mut model = Model::new();
    let pkg = Element::new(ElementId::new("id-1"), ElementKind::Package)
        .with_name("Pkg")
        .with_qualified_name("Pkg");
    model.add_element(pkg);

    let xmi_bytes = Xmi.write(&model).expect("Should write XMI");
    fs::write(&xmi_path, xmi_bytes).expect("Should write file");

    // Test --import (validation only)
    let output_import = Command::new(env!("CARGO_BIN_EXE_syster"))
        .arg("--import")
        .arg(&xmi_path)
        .output()
        .expect("Should run --import");

    let stdout_import = String::from_utf8_lossy(&output_import.stdout);
    assert!(output_import.status.success());
    assert!(stdout_import.contains("Imported 1 elements"));
    assert!(
        !stdout_import.contains("workspace"),
        "--import should not mention workspace"
    );

    // Test --import-workspace (load into workspace)
    let output_workspace = Command::new(env!("CARGO_BIN_EXE_syster"))
        .arg("--import-workspace")
        .arg(&xmi_path)
        .arg("--no-stdlib")
        .output()
        .expect("Should run --import-workspace");

    let stdout_workspace = String::from_utf8_lossy(&output_workspace.stdout);
    assert!(output_workspace.status.success());
    assert!(
        stdout_workspace.contains("workspace"),
        "--import-workspace should mention workspace"
    );
    assert!(stdout_workspace.contains("Element IDs preserved"));
}