coveralls 0.2.0

Send job to Coveralls (coveralls.io)
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

//! Integration tests for the public coverage report API ([`Coverage`]).
//!
//! These drive the crate as an external consumer would: parsing a Coveralls JSON report and
//! serializing it back, without any network access.

use coveralls::Coverage;
use std::io::Read;

/// Read everything produced by [`Coverage::new_reader`] into a string.
fn payload_of(coverage: &Coverage) -> String {
    let mut reader = coverage.new_reader().expect("serialize the coverage report");
    let mut buf = String::new();

    reader.read_to_string(&mut buf).expect("read the serialized payload");

    buf
}

#[test]
fn parsing_then_serializing_preserves_the_main_fields() {
    let report = r#"{
        "repo_token": "a-repo-token",
        "service_name": "circleci",
        "source_files": [
            {"name": "src/lib.rs", "source_digest": "deadbeef", "coverage": [1, null, 0]}
        ]
    }"#;

    let coverage = Coverage::from_reader(report.as_bytes()).expect("parse the report");
    let json: serde_json::Value = serde_json::from_str(&payload_of(&coverage)).expect("a valid JSON payload");

    assert_eq!(json["repo_token"], "a-repo-token");
    assert_eq!(json["service_name"], "circleci");
    assert_eq!(json["source_files"][0]["name"], "src/lib.rs");
    assert_eq!(json["source_files"][0]["source_digest"], "deadbeef");
    assert_eq!(json["source_files"][0]["coverage"][0], 1);
    assert!(json["source_files"][0]["coverage"][1].is_null());
    assert_eq!(json["source_files"][0]["coverage"][2], 0);
}

#[test]
fn git_metadata_is_exposed_when_present() {
    let report = r#"{
        "repo_token": "t",
        "service_name": "travis-ci",
        "git": {
            "head": {
                "id": "abc123",
                "author_name": "Ada",
                "author_email": "ada@example.com",
                "committer_name": "Ada",
                "committer_email": "ada@example.com",
                "message": "Initial commit"
            },
            "branch": "main",
            "remotes": [{"name": "origin", "url": "https://example.com/repo.git"}]
        },
        "source_files": []
    }"#;

    let coverage = Coverage::from_reader(report.as_bytes()).expect("parse the report");

    assert!(coverage.git().is_some(), "git metadata should be exposed");

    // The git object must survive the round-trip back to JSON.
    let json: serde_json::Value = serde_json::from_str(&payload_of(&coverage)).expect("a valid JSON payload");

    assert_eq!(json["git"]["head"]["id"], "abc123");
    assert_eq!(json["git"]["branch"], "main");
    assert_eq!(json["git"]["remotes"][0]["name"], "origin");
}

#[test]
fn git_metadata_is_absent_when_not_provided() {
    let report = r#"{"service_name": "jenkins", "source_files": []}"#;
    let coverage = Coverage::from_reader(report.as_bytes()).expect("parse the report");

    assert!(coverage.git().is_none(), "no git metadata should be exposed");
}

#[test]
fn invalid_json_is_rejected() {
    let result = Coverage::from_reader(b"this is not json".as_slice());

    assert!(result.is_err(), "invalid JSON must be rejected");
}