moonlight-cli 0.1.2

Compare command behavior against one or two reference commands.
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
118
119
120
121

use crate::{
    command::run_command,
    types::{Case, PreparedCase, TargetCommand},
};
use chrono::Utc;
use moonlight_core::{
    compare::capture_body,
    run::{build_comparison_run, CapturedTargets, RunMetadata},
    Adapter, ComparisonRun, RunInput,
};
use std::collections::BTreeMap;
use uuid::Uuid;

pub(crate) async fn execute_case(prepared: PreparedCase, serial_targets: bool) -> ComparisonRun {
    let PreparedCase {
        case,
        compare_config,
    } = prepared;
    let targets = run_targets(&case, serial_targets).await;
    let metadata = RunMetadata {
        id: Uuid::new_v4(),
        timestamp: Utc::now(),
        adapter: Adapter::Cli,
        input: RunInput::Cli {
            primary_command: case.primary.display(),
            candidate_command: case.candidate.display(),
            secondary_command: case.secondary.as_ref().map(TargetCommand::display),
        },
        request_headers: BTreeMap::new(),
        request_body: capture_body(&[], case.max_body_capture_bytes),
    };

    build_comparison_run(metadata, targets, &compare_config)
}

async fn run_targets(case: &Case, serial_targets: bool) -> CapturedTargets {
    if serial_targets {
        let primary = run_command(
            "primary",
            &case.primary,
            case.max_body_capture_bytes,
            case.target_timeout_ms,
        )
        .await;
        let candidate = run_command(
            "candidate",
            &case.candidate,
            case.max_body_capture_bytes,
            case.target_timeout_ms,
        )
        .await;
        let secondary = match &case.secondary {
            Some(command) => Some(
                run_command(
                    "secondary",
                    command,
                    case.max_body_capture_bytes,
                    case.target_timeout_ms,
                )
                .await,
            ),
            None => None,
        };
        return CapturedTargets {
            primary,
            candidate,
            secondary,
        };
    }

    match &case.secondary {
        Some(secondary_command) => {
            let (primary, candidate, secondary) = tokio::join!(
                run_command(
                    "primary",
                    &case.primary,
                    case.max_body_capture_bytes,
                    case.target_timeout_ms
                ),
                run_command(
                    "candidate",
                    &case.candidate,
                    case.max_body_capture_bytes,
                    case.target_timeout_ms
                ),
                run_command(
                    "secondary",
                    secondary_command,
                    case.max_body_capture_bytes,
                    case.target_timeout_ms
                ),
            );
            CapturedTargets {
                primary,
                candidate,
                secondary: Some(secondary),
            }
        }
        None => {
            let (primary, candidate) = tokio::join!(
                run_command(
                    "primary",
                    &case.primary,
                    case.max_body_capture_bytes,
                    case.target_timeout_ms
                ),
                run_command(
                    "candidate",
                    &case.candidate,
                    case.max_body_capture_bytes,
                    case.target_timeout_ms
                ),
            );
            CapturedTargets {
                primary,
                candidate,
                secondary: None,
            }
        }
    }
}