holger-server-lib 0.4.0

Holger server library: config, wiring, gRPC service, Rust API
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Unit tests for holger-server-lib config parsing and wiring.

use holger_server_lib::{read_ron_config, wire_holger};
use std::io::Write;
use tempfile::NamedTempFile;

const MINIMAL_CONFIG: &str = r#"(
    repositories: [
        (
            ron_name: "rust-test",
            ron_repo_type: "rust",
            ron_upstreams: [],
            ron_in: None,
            ron_out: Some((
                ron_storage_endpoint: "test-storage",
                ron_exposed_endpoint: "test-ep",
            )),
        ),
    ],
    exposed_endpoints: [
        (
            ron_name: "test-ep",
            ron_url: "127.0.0.1:50051",
        ),
    ],
    storage_endpoints: [
        (
            ron_name: "test-storage",
            ron_storage_type: "rocksdb",
            ron_path: "/tmp/holger-test-data",
        ),
    ],
)"#;

#[test]
fn test_parse_minimal_config() {
    let mut f = NamedTempFile::new().unwrap();
    f.write_all(MINIMAL_CONFIG.as_bytes()).unwrap();

    let holger = read_ron_config(f.path()).unwrap();
    assert_eq!(holger.repositories.len(), 1);
    assert_eq!(holger.exposed_endpoints.len(), 1);
    assert_eq!(holger.storage_endpoints.len(), 1);
    assert_eq!(holger.repositories[0].ron_name, "rust-test");
}

#[test]
fn test_wire_holger() {
    let mut f = NamedTempFile::new().unwrap();
    f.write_all(MINIMAL_CONFIG.as_bytes()).unwrap();

    let mut holger = read_ron_config(f.path()).unwrap();
    holger.instantiate_backends().unwrap();
    wire_holger(&mut holger).unwrap();

    // Route table should be built
    let ep = &holger.exposed_endpoints[0];
    assert!(ep.aggregated_routes.is_some());
}

#[test]
fn test_rust_api_fetch() {
    let mut f = NamedTempFile::new().unwrap();
    f.write_all(MINIMAL_CONFIG.as_bytes()).unwrap();

    let mut holger = read_ron_config(f.path()).unwrap();
    holger.instantiate_backends().unwrap();
    wire_holger(&mut holger).unwrap();

    // Fetch non-existent artifact returns None
    let id = holger_traits::ArtifactId {
        namespace: None,
        name: "nonexistent".into(),
        version: "0.0.0".into(),
    };
    let result = holger.fetch("rust-test", &id).unwrap();
    assert!(result.is_none());
}

#[test]
fn test_list_repositories() {
    let mut f = NamedTempFile::new().unwrap();
    f.write_all(MINIMAL_CONFIG.as_bytes()).unwrap();

    let mut holger = read_ron_config(f.path()).unwrap();
    holger.instantiate_backends().unwrap();
    wire_holger(&mut holger).unwrap();

    let repos = holger.list_repositories();
    assert_eq!(repos, vec!["rust-test"]);
}

#[test]
fn test_fetch_unknown_repo_errors() {
    let mut f = NamedTempFile::new().unwrap();
    f.write_all(MINIMAL_CONFIG.as_bytes()).unwrap();

    let mut holger = read_ron_config(f.path()).unwrap();
    holger.instantiate_backends().unwrap();
    wire_holger(&mut holger).unwrap();

    let id = holger_traits::ArtifactId {
        namespace: None,
        name: "x".into(),
        version: "1".into(),
    };
    assert!(holger.fetch("nonexistent-repo", &id).is_err());
}

#[test]
fn test_maven_config() {
    let config = r#"(
        repositories: [
            (
                ron_name: "maven-prod",
                ron_repo_type: "maven3",
                ron_upstreams: [],
                ron_archive_path: Some("/tmp/nonexistent.znippy"),
                ron_in: None,
                ron_out: Some((
                    ron_storage_endpoint: "storage",
                    ron_exposed_endpoint: "grpc-ep",
                )),
            ),
        ],
        exposed_endpoints: [
            (
                ron_name: "grpc-ep",
                ron_url: "0.0.0.0:50051",
            ),
        ],
        storage_endpoints: [
            (
                ron_name: "storage",
                ron_storage_type: "znippy",
                ron_path: "/tmp/holger-maven",
            ),
        ],
    )"#;

    let mut f = NamedTempFile::new().unwrap();
    f.write_all(config.as_bytes()).unwrap();

    let mut holger = read_ron_config(f.path()).unwrap();
    // instantiate_backends will fail because archive doesn't exist
    let result = holger.instantiate_backends();
    assert!(result.is_err());
}