scte35 0.2.0

A Rust library for creating and parsing SCTE-35 (Society of Cable Telecommunications Engineers) messages with zero-dependency.
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

//! Integration tests for CLI functionality to validate README examples

#[cfg(feature = "cli")]
#[cfg(test)]
mod tests {
    use assert_cmd::Command;
    use predicates::prelude::*;

    // Base64 payload used in README examples
    const README_EXAMPLE_PAYLOAD: &str =
        "/DAvAAAAAAAA///wFAVIAACPf+/+c2nALv4AUsz1AAAAAAAKAAhDVUVJAAABNWLbowo=";

    #[test]
    fn test_cli_text_output_works() {
        let mut cmd = Command::cargo_bin("scte35").unwrap();
        let output = cmd
            .arg(README_EXAMPLE_PAYLOAD)
            .output()
            .expect("Failed to execute CLI command");

        assert!(output.status.success(), "CLI command should succeed");

        let stdout = String::from_utf8(output.stdout).expect("Output should be valid UTF-8");

        // Verify key elements from README are present
        assert!(stdout.contains("Successfully parsed SpliceInfoSection"));
        assert!(stdout.contains("Table ID: 252"));
        assert!(stdout.contains("Splice Command: SpliceInsert"));
        assert!(stdout.contains("Splice Event ID: 0x4800008f"));
        assert!(stdout.contains("seconds"));
        assert!(stdout.contains("CRC-32:"));
    }

    #[test]
    fn test_cli_json_output_works() {
        let mut cmd = Command::cargo_bin("scte35").unwrap();
        let output = cmd
            .args(&["-o", "json", README_EXAMPLE_PAYLOAD])
            .output()
            .expect("Failed to execute CLI command");

        assert!(output.status.success(), "CLI command should succeed");

        let stdout = String::from_utf8(output.stdout).expect("Output should be valid UTF-8");
        let json: serde_json::Value =
            serde_json::from_str(&stdout).expect("Output should be valid JSON");

        // Verify JSON structure matches README examples
        assert_eq!(json["status"], "success");
        assert_eq!(json["data"]["table_id"], 252);
        assert_eq!(json["data"]["splice_command"]["type"], "SpliceInsert");
        assert_eq!(
            json["data"]["splice_command"]["splice_event_id"],
            1207959695
        );
        assert!(json["crc_validation"]["valid"].as_bool().unwrap());
    }

    #[test]
    fn test_cli_json_output_long_flag() {
        let mut cmd = Command::cargo_bin("scte35").unwrap();
        let output = cmd
            .args(&["--output", "json", README_EXAMPLE_PAYLOAD])
            .output()
            .expect("Failed to execute CLI command");

        assert!(output.status.success(), "CLI command should succeed");

        let stdout = String::from_utf8(output.stdout).expect("Output should be valid UTF-8");
        let _json: serde_json::Value =
            serde_json::from_str(&stdout).expect("Output should be valid JSON");
    }

    #[test]
    fn test_cli_help_contains_expected_text() {
        let mut cmd = Command::cargo_bin("scte35").unwrap();
        cmd.arg("--help")
            .assert()
            .success()
            .stdout(predicate::str::contains(
                "Parse SCTE-35 messages from base64-encoded payloads",
            ))
            .stdout(predicate::str::contains("Base64-encoded SCTE-35 payload"))
            .stdout(predicate::str::contains("Output format"));
    }

    #[test]
    fn test_cli_version_works() {
        let mut cmd = Command::cargo_bin("scte35").unwrap();
        cmd.arg("--version")
            .assert()
            .success()
            .stdout(predicate::str::starts_with("scte35"))
            .stderr("");
    }

    #[test]
    fn test_cli_handles_invalid_base64() {
        let mut cmd = Command::cargo_bin("scte35").unwrap();
        cmd.arg("invalid_base64!")
            .assert()
            .failure()
            .stderr(predicate::str::contains("Error decoding base64 string"));
    }

    #[test]
    fn test_cli_handles_invalid_base64_json() {
        let mut cmd = Command::cargo_bin("scte35").unwrap();
        let output = cmd
            .args(&["-o", "json", "invalid_base64!"])
            .output()
            .expect("Failed to execute CLI command");

        assert!(!output.status.success(), "CLI command should fail");

        let stdout = String::from_utf8(output.stdout).expect("Output should be valid UTF-8");
        let json: serde_json::Value =
            serde_json::from_str(&stdout).expect("Error output should be valid JSON");

        // Verify error structure
        assert_eq!(json["status"], "error");
        assert!(
            json["error"]
                .as_str()
                .unwrap()
                .contains("Error decoding base64 string")
        );
    }
}