arch-toolkit 0.3.0

Complete Rust toolkit for Arch Linux package management
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

//! Deterministic integration tests for optional metadata capabilities.

#[cfg(all(feature = "aur", feature = "index"))]
mod tests {
    use arch_toolkit::aur::{
        MetadataFetchLimits, check_mirror_health, fetch_official_package_detail_from,
    };
    use arch_toolkit::types::index::{MirrorInfo, OfficialPackage};
    use arch_toolkit::{MirrorHealthLimits, MirrorHealthStatus};
    use wiremock::matchers::{method, path, query_param};
    use wiremock::{Mock, MockServer, ResponseTemplate};

    #[tokio::test]
    /// What: Fetch one official package detail through caller-owned HTTP transport.
    ///
    /// Inputs:
    /// - A local wiremock Arch Packages-shaped response and an index package selector.
    ///
    /// Output:
    /// - An enriched `OfficialPackage` with deterministic version and metadata.
    ///
    /// Details:
    /// - The test proves no system package command or external endpoint is used.
    async fn official_detail_uses_existing_index_model_and_caller_client() {
        let server = MockServer::start().await;
        Mock::given(method("GET"))
            .and(path("/packages/search/json/"))
            .and(query_param("name", "ripgrep"))
            .and(query_param("repo", "extra"))
            .and(query_param("arch", "x86_64"))
            .respond_with(ResponseTemplate::new(200).set_body_string(
                r#"{"results":[{"pkgname":"ripgrep","repo":"extra","arch":"x86_64","pkgver":"14.1.0","pkgrel":"2","pkgdesc":"Fast grep"}]}"#,
            ))
            .expect(1)
            .mount(&server)
            .await;

        let selector = OfficialPackage {
            name: "ripgrep".to_string(),
            repo: "extra".to_string(),
            arch: "x86_64".to_string(),
            version: String::new(),
            description: String::new(),
        };
        let endpoint = format!("{}/packages/search/json/", server.uri());
        let detail = fetch_official_package_detail_from(
            &reqwest::Client::new(),
            &endpoint,
            &selector,
            MetadataFetchLimits {
                max_response_bytes: 4 * 1024,
                max_candidates: 4,
            },
        )
        .await
        .expect("fetch fixture")
        .expect("exact package detail");

        assert_eq!(detail.version, "14.1.0-2");
        assert_eq!(detail.description, "Fast grep");
    }

    #[tokio::test]
    /// What: Report mirror reachability through bounded, caller-selected probes.
    ///
    /// Inputs:
    /// - Two local mirror URLs with success and failure status responses.
    ///
    /// Output:
    /// - Ordered per-mirror health records with status evidence.
    ///
    /// Details:
    /// - Wiremock makes network behavior deterministic and proves checks do not
    ///   apply generated mirror configuration or execute a system command.
    async fn mirror_health_uses_existing_mirror_models_and_bounded_probes() {
        let server = MockServer::start().await;
        Mock::given(method("GET"))
            .and(path("/healthy/core/os/x86_64/core.db"))
            .respond_with(ResponseTemplate::new(200))
            .expect(1)
            .mount(&server)
            .await;
        Mock::given(method("GET"))
            .and(path("/unhealthy/core/os/x86_64/core.db"))
            .respond_with(ResponseTemplate::new(503))
            .expect(1)
            .mount(&server)
            .await;

        let mirrors = vec![
            MirrorInfo {
                url: format!("{}/healthy/", server.uri()),
                active: true,
                protocols: vec!["http".to_string()],
            },
            MirrorInfo {
                url: format!("{}/unhealthy/", server.uri()),
                active: true,
                protocols: vec!["http".to_string()],
            },
        ];
        let health = check_mirror_health(
            &reqwest::Client::new(),
            &mirrors,
            "/core/os/x86_64/core.db",
            MirrorHealthLimits { max_mirrors: 2 },
        )
        .await
        .expect("probe fixture");

        assert_eq!(health.len(), 2);
        assert_eq!(health[0].status, MirrorHealthStatus::Reachable);
        assert_eq!(health[0].status_code, Some(200));
        assert_eq!(health[1].status, MirrorHealthStatus::Unreachable);
        assert_eq!(health[1].status_code, Some(503));
    }
}