Coverage: read Cobertura XML reports too 7fff30c4f5e2

//! gcov/lcov write) or Cobertura XML has it parsed when it is uploaded. The totals and each

/// Parse a report in either format the hub reads: Cobertura XML (it

/// starts with `<`) or LCOV. Returns the files, those outside the

/// repository, and the format's name.

pub fn parse(text: &str) -> Result<(Vec<FileCoverage>, usize, &'static str), String> {

    if text.trim_start().starts_with('<') {

        parse_cobertura(text).map(|(f, o)| (f, o, "cobertura"))

    } else {

        parse_lcov(text).map(|(f, o)| (f, o, "lcov"))

    }

}

fn xml_attr(e: &quick_xml::events::BytesStart, name: &str) -> String {

    e.try_get_attribute(name)

        .ok()

        .flatten()

        .and_then(|a| a.normalized_value(quick_xml::XmlVersion::Implicit1_0).ok().map(|v| v.into_owned()))

        .unwrap_or_default()

}

/// Parse a Cobertura XML report (coverage.py `coverage xml`, JaCoCo via

/// cover2cover, .NET Coverlet, `cargo llvm-cov --cobertura`): each

/// `<class>`'s `<line number hits>` by file, with `branch` lines'

/// `condition-coverage="50% (1/2)"` as branches and `<method>`s as

/// functions (one is hit when any of its lines ran). A file named by

/// several classes is added together. A `<source>` is tried as the base of

/// a relative filename, the workspace's `/src` among them.

pub fn parse_cobertura(text: &str) -> Result<(Vec<FileCoverage>, usize), String> {

    use quick_xml::events::Event;

    let mut r = quick_xml::Reader::from_str(text);

    let mut sources: Vec<String> = Vec::new();

    let mut in_source = false;

    let mut source_text = String::new();

    // Files as the classes name them, resolved once the sources are known.

    let mut raw: BTreeMap<String, Acc> = BTreeMap::new();

    let mut file: Option<String> = None;

    let mut method: Option<(String, bool)> = None;

    let mut seen_root = false;

    loop {

        let ev = r.read_event().map_err(|e| format!("this is not a Cobertura report: {e}"))?;

        match ev {

            Event::Start(ref e) | Event::Empty(ref e) => {

                let tag = e.local_name().as_ref().to_string();

                match tag.as_str() {

                    "coverage" => seen_root = true,

                    "source" if matches!(ev, Event::Start(_)) => {

                        in_source = true;

                        source_text.clear();

                    }

                    "class" => {

                        let f = xml_attr(e, "filename");

                        raw.entry(f.clone()).or_default().records += 1;

                        file = Some(f);

                    }

                    "method" => method = Some((xml_attr(e, "name") + &xml_attr(e, "signature"), false)),

                    "line" => {

                        let Some(f) = &file else { continue };

                        let Ok(n) = xml_attr(e, "number").trim().parse::<u32>() else { continue };

                        let hits = xml_attr(e, "hits").trim().parse::<u64>().unwrap_or(0);

                        if let Some((_, hit)) = &mut method {

                            *hit |= hits > 0;

                            // A method's lines repeat the class's; count them once.

                            continue;

                        }

                        let acc = raw.entry(f.clone()).or_default();

                        *acc.lines.entry(n).or_default() += hits;

                        if xml_attr(e, "branch") == "true" {

                            // "50% (1/2)": covered of total conditions.

                            let cc = xml_attr(e, "condition-coverage");

                            if let Some((hit, total)) = cc

                                .split_once('(')

                                .and_then(|(_, rest)| rest.trim_end_matches(')').split_once('/'))

                                .and_then(|(h, t)| Some((h.trim().parse::<u64>().ok()?, t.trim().parse::<u64>().ok()?)))

                            {

                                for i in 0..total {

                                    let b = acc.branches.entry((n, "0".into(), i.to_string())).or_default();

                                    *b = (*b).max(u64::from(i < hit));

                                }

                            }

                        }

                    }

                    _ => {}

                }

                if matches!(ev, Event::Empty(_)) && tag == "method" {

                    if let (Some(f), Some((name, hit))) = (&file, method.take()) {

                        *raw.entry(f.clone()).or_default().functions.entry(name).or_default() += u64::from(hit);

                    }

                }

            }

            Event::Text(t) if in_source => source_text.push_str(&t.xml10_content()),

            Event::End(e) => match e.local_name().as_ref() {

                "source" => {

                    in_source = false;

                    sources.push(source_text.trim().trim_end_matches('/').to_string());

                }

                "class" => file = None,

                "method" => {

                    if let (Some(f), Some((name, hit))) = (&file, method.take()) {

                        *raw.entry(f.clone()).or_default().functions.entry(name).or_default() += u64::from(hit);

                    }

                }

                _ => {}

            },

            Event::Eof => break,

            _ => {}

        }

    }

    if !seen_root {

        return Err("this is not a Cobertura report: no <coverage> element".into());

    }

    if raw.is_empty() {

        return Err("this Cobertura report names no source file (no <class filename>)".into());

    }

    // A filename relative to one of the sources, or to the workspace.

    let resolve = |f: &str| -> Option<String> {

        if f.starts_with('/') {

            return relative(f);

        }

        sources.iter().filter(|s| !s.is_empty() && *s != ".").find_map(|s| relative(&format!("{s}/{f}"))).or_else(|| relative(f))

    };

    let mut files: BTreeMap<String, Acc> = BTreeMap::new();

    let mut outside = HashSet::new();

    for (f, a) in raw {

        let Some(path) = resolve(&f) else {

            outside.insert(f);

            continue;

        };

        let into = files.entry(path).or_default();

        for (l, n) in a.lines {

            *into.lines.entry(l).or_default() += n;

        }

        for (k, n) in a.functions {

            *into.functions.entry(k).or_default() += n;

        }

        for (k, n) in a.branches {

            let b = into.branches.entry(k).or_default();

            *b = (*b).max(n);

        }

    }

    let out = files

        .into_iter()

        .map(|(path, a)| FileCoverage {

            path,

            functions_found: a.functions.len() as u64,

            functions_hit: a.functions.values().filter(|n| **n > 0).count() as u64,

            branches_found: a.branches.len() as u64,

            branches_hit: a.branches.values().filter(|n| **n > 0).count() as u64,

            lines: a.lines,

            declared_lines: None,

        })

        .collect();

    Ok((out, outside.len()))

}

    /// `lcov` or `cobertura`.

    pub format: &'a str,

         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id",

    .bind(o.format)

    }

    #[test]

    fn cobertura_from_coverage_py_and_coverlet() {

        // coverage.py: a source to resolve against, branches by condition.

        let py = r#"<?xml version="1.0" ?>

<coverage version="7.4" line-rate="0.6" branch-rate="0.5">

  <sources><source>/src/app</source></sources>

  <packages><package name="app"><classes>

    <class name="main.py" filename="main.py" line-rate="0.66">

      <methods/>

      <lines>

        <line number="1" hits="1"/>

        <line number="2" hits="0"/>

        <line number="3" hits="4" branch="true" condition-coverage="50% (1/2)"/>

      </lines>

    </class>

    <class name="gone.py" filename="/usr/lib/python3/x.py"><lines><line number="1" hits="1"/></lines></class>

  </classes></package></packages>

</coverage>"#;

        let (files, outside, format) = parse(py).unwrap();

        assert_eq!((format, outside), ("cobertura", 1));

        let f = &files[0];

        assert_eq!(f.path, "app/main.py");

        assert_eq!((f.lines_found(), f.lines_hit(), f.hits()), (3, 2, 5));

        assert_eq!((f.branches_found, f.branches_hit), (2, 1));

        // Coverlet: methods with their own lines, two classes in one file.

        let net = r#"<coverage><sources><source>/src/</source></sources><packages><package name="Lib"><classes>

<class name="Lib.A" filename="Lib/A.cs"><methods><method name="Run" signature="()"><lines><line number="5" hits="2"/></lines></method><method name="Idle" signature="()"><lines><line number="9" hits="0"/></lines></method></methods>

<lines><line number="5" hits="2"/><line number="9" hits="0"/></lines></class>

<class name="Lib.A/Inner" filename="Lib/A.cs"><methods/><lines><line number="12" hits="1"/></lines></class>

</classes></package></packages></coverage>"#;

        let (files, _, _) = parse(net).unwrap();

        let f = &files[0];

        assert_eq!(f.path, "Lib/A.cs");

        assert_eq!((f.lines_found(), f.lines_hit()), (3, 2));

        assert_eq!((f.functions_found, f.functions_hit), (2, 1));

        assert!(parse("<html/>").unwrap_err().contains("Cobertura"));

        assert_eq!(parse("SF:/src/a.rs\nDA:1,1\nend_of_record\n").unwrap().2, "lcov");

    let text = String::from_utf8(bytes.to_vec())

        .map_err(|_| "coverage: the report is not text (LCOV or Cobertura XML is expected)".to_string())?;

    let (files, outside, format) = tokio::task::spawn_blocking(move || crate::coverage::parse(&text))

        format,

        coverage::parse(&text).ok().map(|(files, _, _)| files.into_iter().map(|f| (f.path, f.lines)).collect::<BTreeMap<_, _>>())

- **Reports.** A job's artifact named `coverage` in LCOV format (`cargo llvm-cov --lcov`, Istanbul's `lcov` reporter, `coverage lcov`, gcov with lcov) or Cobertura XML (`coverage xml`, `cargo llvm-cov --cobertura`, Coverlet, JaCoCo through cover2cover; a report starting with `<`) is read when the job uploads it. In Cobertura a filename is tried against each `<source>`, a `branch` line's `condition-coverage` counts its branches, and a `<method>` is a function, hit when any of its lines ran. The hub writes what it found into the job's log (`coverage: 88.6% of lines (951 of 1073) in 5 files`), or why it could not read it; a bad report never fails the upload. At most 64 MiB is read.

- **Next:** the API.

  <p class="small mute">Istanbul (<code>--reporter=lcov</code>), coverage.py (<code>coverage lcov</code>) and gcov with lcov write LCOV too; Cobertura XML (<code>coverage xml</code>, Coverlet, JaCoCo through cover2cover) is read as well. Paths are read relative to the job's <code>/src</code>.</p>