raps-cli 4.15.0

RAPS (rapeseed) - Rust Autodesk Platform Services CLI
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

use super::formatter::OutputFormatter;
use super::*;
use serde::Serialize;

#[derive(Serialize)]
struct TestData {
    name: String,
    value: i32,
}

#[test]
fn test_json_output() {
    let data = TestData {
        name: "test".to_string(),
        value: 42,
    };
    let mut buffer = Vec::new();

    OutputFormatter::print_output(&data, OutputFormat::Json, &mut buffer).unwrap();

    let output = String::from_utf8(buffer).unwrap();
    let expected = serde_json::to_string_pretty(&data).unwrap() + "\n";

    // Normalize newlines for cross-platform comparison
    assert_eq!(output.replace("\r\n", "\n"), expected.replace("\r\n", "\n"));
}

#[test]
fn test_yaml_output() {
    let data = TestData {
        name: "test".to_string(),
        value: 42,
    };
    let mut buffer = Vec::new();

    OutputFormatter::print_output(&data, OutputFormat::Yaml, &mut buffer).unwrap();

    let output = String::from_utf8(buffer).unwrap();
    let expected = serde_yaml::to_string(&data).unwrap();

    assert_eq!(output, expected);
}

#[test]
fn test_table_format_array_of_objects() {
    #[derive(Serialize)]
    struct Row {
        name: String,
        status: String,
        count: u32,
    }

    let data = vec![
        Row {
            name: "Alpha".to_string(),
            status: "active".to_string(),
            count: 42,
        },
        Row {
            name: "Beta".to_string(),
            status: "pending".to_string(),
            count: 7,
        },
    ];

    let mut output = Vec::new();
    OutputFormatter::print_output(&data, OutputFormat::Table, &mut output).unwrap();
    let result = String::from_utf8(output).unwrap();

    // Should contain headers and data
    assert!(result.contains("name"));
    assert!(result.contains("status"));
    assert!(result.contains("count"));
    assert!(result.contains("Alpha"));
    assert!(result.contains("Beta"));
    assert!(result.contains("active"));
    assert!(result.contains("2 row(s)"));
    // Should NOT be JSON
    assert!(!result.contains("{"));
}

#[test]
fn test_table_format_single_object() {
    #[derive(Serialize)]
    struct Info {
        id: String,
        name: String,
    }

    let data = Info {
        id: "123".to_string(),
        name: "Test".to_string(),
    };

    let mut output = Vec::new();
    OutputFormatter::print_output(&data, OutputFormat::Table, &mut output).unwrap();
    let result = String::from_utf8(output).unwrap();

    // Should be key-value format, NOT JSON
    assert!(result.contains("id"));
    assert!(result.contains("123"));
    assert!(result.contains("name"));
    assert!(result.contains("Test"));
    assert!(!result.contains("{"));
}

#[test]
fn test_table_format_empty_array() {
    let data: Vec<String> = vec![];

    let mut output = Vec::new();
    OutputFormatter::print_output(&data, OutputFormat::Table, &mut output).unwrap();
    let result = String::from_utf8(output).unwrap();

    assert!(result.contains("(empty)"));
}