pipedash-plugin-azure-devops 0.14.0

use super::*;

const STAMP: &str = "2024-01-01T10:00:00.1234567Z";

fn parse(line: &str) -> ParsedLine<'_> {
    AzureDevOpsLogDialect.parse(line.as_bytes())
}

fn stamped(text: &str) -> String {
    format!("{STAMP} {text}")
}

#[test]
fn timestamp_has_seven_fraction_digits_and_a_z_suffix() {
    let line = stamped("plain output");
    let parsed = parse(&line);

    assert_eq!(
        parsed.timestamp.unwrap().to_rfc3339(),
        "2024-01-01T10:00:00.123456700+00:00"
    );
    assert_eq!(parsed.marker, LineMarker::Plain);
    assert_eq!(parsed.body, b"plain output");
}

#[test]
fn line_without_a_timestamp_keeps_its_text() {
    let parsed = parse("##[error]no stamp");

    assert_eq!(parsed.timestamp, None);
    assert_eq!(parsed.marker, LineMarker::Error);
    assert_eq!(parsed.body, b"no stamp");
}

#[test]
fn byte_order_mark_at_the_start_of_a_page_is_dropped() {
    let line = format!("\u{feff}{}", stamped("##[section]Starting: Initialize job"));
    let parsed = parse(&line);

    assert!(parsed.timestamp.is_some());
    assert_eq!(parsed.marker, LineMarker::SectionStart { open: false });
    assert_eq!(parsed.body, b"Starting: Initialize job");
}

#[test]
fn section_starts_a_collapsed_section_titled_by_the_text() {
    for title in [
        "Starting: Initialize job",
        "Async Command Start: DetectDockerContainer",
    ] {
        let line = stamped(&format!("##[section]{title}"));
        let parsed = parse(&line);

        assert_eq!(parsed.marker, LineMarker::SectionStart { open: false });
        assert_eq!(parsed.body, title.as_bytes());
        assert!(parsed.timestamp.is_some());
    }
}

#[test]
fn finishing_a_task_stays_a_plain_line_inside_its_section() {
    let line = stamped("##[section]Finishing: Checkout acme/app@main to s");
    let parsed = parse(&line);

    assert_eq!(parsed.marker, LineMarker::Plain);
    assert_eq!(parsed.body, b"Finishing: Checkout acme/app@main to s");
    assert!(parsed.timestamp.is_some());
}

#[test]
fn group_and_endgroup_open_and_close_a_group() {
    let open = stamped("##[group]Run tests");
    let close = stamped("##[endgroup]");

    let opened = parse(&open);
    let closed = parse(&close);

    assert_eq!(opened.marker, LineMarker::GroupStart);
    assert_eq!(opened.body, b"Run tests");
    assert_eq!(closed.marker, LineMarker::GroupEnd);
    assert_eq!(closed.body, b"");
}

#[test]
fn error_warning_command_and_debug_keep_their_text() {
    let cases = [
        ("##[error]Bash exited with code '1'.", LineMarker::Error),
        ("##[warning]Deprecated task", LineMarker::Warning),
        ("##[command]git fetch --prune", LineMarker::Command),
        ("##[debug]Evaluating: variables", LineMarker::Debug),
    ];
    for (text, marker) in cases {
        let line = stamped(text);
        let parsed = parse(&line);

        assert_eq!(parsed.marker, marker, "{text}");
        assert_eq!(
            parsed.body,
            text.split_once(']').unwrap().1.as_bytes(),
            "{text}"
        );
        assert!(parsed.timestamp.is_some(), "{text}");
    }
}

#[test]
fn task_output_commands_without_the_hashes_are_commands() {
    let line = stamped("[command]/usr/bin/git version");
    let parsed = parse(&line);

    assert_eq!(parsed.marker, LineMarker::Command);
    assert_eq!(parsed.body, b"/usr/bin/git version");
}

#[test]
fn only_a_starting_section_starts_a_step() {
    let starts = |text: &str| AzureDevOpsLogDialect.is_step_start(&parse(&stamped(text)));

    assert!(starts("##[section]Starting: Initialize job"));
    assert!(starts("##[section]Starting: CmdLine"));
    assert!(!starts("##[section]Finishing: CmdLine"));
    assert!(!starts("##[section]Async Command Start: Foo"));
    assert!(!starts("Starting: CmdLine"));
    assert!(!starts("##[group]Starting: CmdLine"));
    assert!(!starts("##[error]Starting: CmdLine"));
    assert!(!starts("##[debug]Starting: CmdLine"));
}

#[test]
fn section_marker_in_the_middle_of_a_line_is_output() {
    let line = stamped("echo ##[section]not a marker");
    let parsed = parse(&line);

    assert_eq!(parsed.marker, LineMarker::Plain);
    assert_eq!(parsed.body, b"echo ##[section]not a marker");
}