chio-conformance 0.1.0

Scenario loading and report generation for Chio cross-language conformance
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

use std::path::PathBuf;

use chio_conformance::{
    default_run_options, run_conformance_harness, ConformanceAuthMode, ConformanceRunSummary,
    PeerTarget,
};

fn main() {
    if let Err(error) = run() {
        eprintln!("error: {error}");
        std::process::exit(1);
    }
}

fn run() -> Result<(), Box<dyn std::error::Error>> {
    let mut options = default_run_options();
    let mut args = std::env::args().skip(1);
    while let Some(flag) = args.next() {
        match flag.as_str() {
            "--scenarios-dir" => options.scenarios_dir = next_path(&mut args, &flag)?,
            "--results-dir" => options.results_dir = next_path(&mut args, &flag)?,
            "--report-output" => options.report_output = next_path(&mut args, &flag)?,
            "--policy" => options.policy_path = next_path(&mut args, &flag)?,
            "--upstream-server" => options.upstream_server_script = next_path(&mut args, &flag)?,
            "--auth-mode" => {
                options.auth_mode =
                    parse_auth_mode(&next_string(&mut args, &flag)?).ok_or_else(|| {
                        format!("invalid value for {flag}: expected static-bearer or oauth-local")
                    })?;
            }
            "--auth-token" => options.auth_token = next_string(&mut args, &flag)?,
            "--admin-token" => options.admin_token = next_string(&mut args, &flag)?,
            "--auth-scope" => options.auth_scope = next_string(&mut args, &flag)?,
            "--listen" => options.listen = Some(next_string(&mut args, &flag)?.parse()?),
            "--peer" => {
                options.peers = parse_peers(&next_string(&mut args, &flag)?).ok_or_else(|| {
                    format!("invalid value for {flag}: expected js, python, go, or all")
                })?;
            }
            other => return Err(format!("unexpected flag: {other}").into()),
        }
    }

    let summary = run_conformance_harness(&options)?;
    print_summary(&summary);
    Ok(())
}

fn print_summary(summary: &ConformanceRunSummary) {
    println!("results: {}", summary.results_dir.display());
    println!("report:  {}", summary.report_output.display());
    println!("listen:  {}", summary.listen);
    for result in &summary.peer_result_files {
        println!("peer:    {}", result.display());
    }
}

fn parse_peers(value: &str) -> Option<Vec<PeerTarget>> {
    match value {
        "all" => Some(vec![PeerTarget::Js, PeerTarget::Python, PeerTarget::Go]),
        "js" => Some(vec![PeerTarget::Js]),
        "python" => Some(vec![PeerTarget::Python]),
        "go" => Some(vec![PeerTarget::Go]),
        _ => None,
    }
}

fn parse_auth_mode(value: &str) -> Option<ConformanceAuthMode> {
    match value {
        "static-bearer" => Some(ConformanceAuthMode::StaticBearer),
        "oauth-local" => Some(ConformanceAuthMode::LocalOAuth),
        _ => None,
    }
}

fn next_path(
    args: &mut impl Iterator<Item = String>,
    flag: &str,
) -> Result<PathBuf, Box<dyn std::error::Error>> {
    Ok(PathBuf::from(next_string(args, flag)?))
}

fn next_string(
    args: &mut impl Iterator<Item = String>,
    flag: &str,
) -> Result<String, Box<dyn std::error::Error>> {
    args.next()
        .ok_or_else(|| format!("missing value for {flag}").into())
}