rootle-github 0.13.1

rootle's in-tree reference provider: GitHub REST client, sha-keyed disk cache, ETag revalidation
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

use super::*;

fn commit(index: usize) -> HistoryCommit {
    HistoryCommit {
        sha: format!("revision-{index}"),
        commit: HistoryMetadata {
            message: format!("commit {index}\nbody"),
            author: HistoryAuthor {
                name: "author".into(),
                date: "2026-11-12".into(),
            },
        },
    }
}

#[test]
fn history_pages_past_ninety_nine_and_pins_the_original_revision() {
    for total in [100usize, 245, 500, 501] {
        let mut received = Vec::new();
        let mut calls = 0;
        let truncated = stream_history(
            reqwest::Url::parse("https://example.test/repos/o/r/commits").unwrap(),
            Some("src/文字.cpp"),
            Some("resolved-head"),
            500,
            &mut |entries| received.extend(entries),
            |url| {
                calls += 1;
                let url = reqwest::Url::parse(url).unwrap();
                let query: std::collections::HashMap<_, _> =
                    url.query_pairs().into_owned().collect();
                assert_eq!(query["per_page"], "100");
                assert_eq!(query["path"], "src/文字.cpp");
                // A path-filtered first item is not necessarily an ancestor
                // of commits on another merged branch. Never repin to it.
                assert_eq!(query["sha"], "resolved-head");
                let start = (calls - 1) * 100;
                let end = (start + 100).min(total);
                Ok(Page {
                    body: (start..end).map(commit).collect(),
                    has_next: end < total,
                })
            },
        )
        .unwrap();
        assert_eq!(
            received
                .iter()
                .map(|entry| entry.sha.as_str())
                .collect::<Vec<_>>(),
            (0..total.min(500))
                .map(|index| format!("revision-{index}"))
                .collect::<Vec<_>>()
        );
        assert_eq!(truncated, total > 500);
        assert_eq!(calls, total.min(500).div_ceil(100));
    }
}

#[test]
fn empty_or_repeated_pages_fail_without_discarding_delivered_history() {
    for repeat in [false, true] {
        let mut delivered = Vec::new();
        let mut calls = 0;
        let result = stream_history(
            reqwest::Url::parse("https://example.test/commits").unwrap(),
            None,
            None,
            500,
            &mut |entries| delivered.extend(entries),
            |_| {
                calls += 1;
                Ok(Page {
                    body: if calls == 1 || repeat {
                        vec![commit(0)]
                    } else {
                        Vec::new()
                    },
                    has_next: true,
                })
            },
        );
        assert!(result.is_err());
        assert_eq!(delivered[0].sha, "revision-0");
        assert_eq!(delivered.len(), 1);
        assert_eq!(calls, 2);
    }
}

#[test]
fn zero_limit_probes_without_emitting_a_commit() {
    let mut received = Vec::new();
    let truncated = stream_history(
        reqwest::Url::parse("https://example.test/commits").unwrap(),
        None,
        None,
        0,
        &mut |entries| received.extend(entries),
        |_| {
            Ok(Page {
                body: vec![commit(0)],
                has_next: false,
            })
        },
    )
    .unwrap();
    assert!(truncated);
    assert!(received.is_empty());
}