2a91e2b083
Pure move: cli definition, per-group handlers (session, bulk, bench, events, galaxy, smoke, batch) and shared output/parse/connect helpers now live in their own modules. No behaviour or CLI surface change; --help of all 33 commands is byte-identical, clippy clean, tests unchanged. Claude-Session: https://claude.ai/code/session_01GT67AEHd2Acv1YPwGfXEoV
456 lines
13 KiB
Rust
456 lines
13 KiB
Rust
//! Unit tests for the CLI.
|
|
use clap::Parser;
|
|
|
|
use crate::cli::{Cli, Command};
|
|
|
|
/// Pull the flattened `ConnectionArgs` out of a parsed `ping` command so
|
|
/// `ConnectionArgs::options()` can be exercised directly.
|
|
fn connection_from_ping(args: &[&str]) -> crate::cli::ConnectionArgs {
|
|
let mut full = vec!["mxgw", "ping"];
|
|
full.extend_from_slice(args);
|
|
match Cli::try_parse_from(full).expect("ping parse").command {
|
|
Command::Ping { connection, .. } => connection,
|
|
other => panic!("expected ping command, got {other:?}"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn parses_version_json_command() {
|
|
let parsed = Cli::try_parse_from(["mxgw", "version", "--json"]);
|
|
assert!(parsed.is_ok());
|
|
}
|
|
|
|
#[test]
|
|
fn connection_defaults_to_plaintext() {
|
|
let options = connection_from_ping(&[]).options();
|
|
assert!(options.plaintext(), "default channel should be plaintext");
|
|
}
|
|
|
|
#[test]
|
|
fn connection_tls_flag_disables_plaintext() {
|
|
let options = connection_from_ping(&["--tls"]).options();
|
|
assert!(
|
|
!options.plaintext(),
|
|
"--tls must select an encrypted channel"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn connection_plaintext_flag_selects_plaintext() {
|
|
let options = connection_from_ping(&["--plaintext"]).options();
|
|
assert!(options.plaintext());
|
|
}
|
|
|
|
#[test]
|
|
fn connection_rejects_tls_and_plaintext_together() {
|
|
let parsed = Cli::try_parse_from(["mxgw", "ping", "--tls", "--plaintext"]);
|
|
assert!(
|
|
parsed.is_err(),
|
|
"--tls and --plaintext must conflict so TLS cannot be silently downgraded"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn parses_write_command() {
|
|
let parsed = Cli::try_parse_from([
|
|
"mxgw",
|
|
"write",
|
|
"--session-id",
|
|
"session-1",
|
|
"--server-handle",
|
|
"12",
|
|
"--item-handle",
|
|
"34",
|
|
"--value-type",
|
|
"int32",
|
|
"--value",
|
|
"123",
|
|
]);
|
|
assert!(parsed.is_ok());
|
|
}
|
|
|
|
#[test]
|
|
fn version_json_output_has_protocol_versions() {
|
|
let value = crate::output::version_json();
|
|
|
|
assert_eq!(value["gatewayProtocolVersion"], 3);
|
|
assert_eq!(value["workerProtocolVersion"], 1);
|
|
}
|
|
|
|
#[test]
|
|
fn parses_authenticate_user_command_with_password_env() {
|
|
let parsed = Cli::try_parse_from([
|
|
"mxgw",
|
|
"authenticate-user",
|
|
"--session-id",
|
|
"session-1",
|
|
"--server-handle",
|
|
"7",
|
|
"--verify-user",
|
|
"verifier",
|
|
"--password-env",
|
|
"MY_PW_VAR",
|
|
]);
|
|
assert!(parsed.is_ok(), "parse failed: {parsed:?}");
|
|
}
|
|
|
|
/// CLI-45: `--password-env` must default to the canonical
|
|
/// `MXGATEWAY_VERIFY_PASSWORD` shared by every official client CLI.
|
|
#[test]
|
|
fn authenticate_user_password_env_defaults_to_canonical_name() {
|
|
let parsed = Cli::try_parse_from([
|
|
"mxgw",
|
|
"authenticate-user",
|
|
"--session-id",
|
|
"session-1",
|
|
"--server-handle",
|
|
"7",
|
|
"--verify-user",
|
|
"verifier",
|
|
])
|
|
.expect("parse");
|
|
match parsed.command {
|
|
Command::AuthenticateUser { password_env, .. } => {
|
|
assert_eq!(password_env, "MXGATEWAY_VERIFY_PASSWORD");
|
|
}
|
|
other => panic!("expected authenticate-user, got {other:?}"),
|
|
}
|
|
}
|
|
|
|
/// CLI-45: a credential that resolves to an empty string — whether from the
|
|
/// flag or from the named environment variable — is treated as missing, so
|
|
/// the CLI never sends a fabricated empty password to the wire. The usage
|
|
/// error names the flag and the variable, never a value.
|
|
#[test]
|
|
fn resolve_verify_user_password_rejects_missing_and_empty_values() {
|
|
const ABSENT: &str = "MXGW_CLI45_ABSENT_PASSWORD_VAR";
|
|
const EMPTY: &str = "MXGW_CLI45_EMPTY_PASSWORD_VAR";
|
|
const PRESENT: &str = "MXGW_CLI45_PRESENT_PASSWORD_VAR";
|
|
std::env::remove_var(ABSENT);
|
|
std::env::set_var(EMPTY, "");
|
|
std::env::set_var(PRESENT, "env-sourced-credential");
|
|
|
|
for (password, env_name) in [
|
|
(None, ABSENT),
|
|
(Some(String::new()), ABSENT),
|
|
(None, EMPTY),
|
|
(Some(String::new()), EMPTY),
|
|
] {
|
|
let error = crate::parse::resolve_verify_user_password(password, env_name)
|
|
.expect_err("empty or missing credential must be a usage error");
|
|
let rendered = error.to_string();
|
|
assert!(rendered.contains("--password"), "{rendered}");
|
|
assert!(rendered.contains(env_name), "{rendered}");
|
|
}
|
|
|
|
assert_eq!(
|
|
crate::parse::resolve_verify_user_password(None, PRESENT).expect("env credential"),
|
|
"env-sourced-credential"
|
|
);
|
|
assert_eq!(
|
|
crate::parse::resolve_verify_user_password(Some("flag-credential".to_owned()), EMPTY)
|
|
.expect("flag credential"),
|
|
"flag-credential"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn parses_write_secured_command() {
|
|
let parsed = Cli::try_parse_from([
|
|
"mxgw",
|
|
"write-secured",
|
|
"--session-id",
|
|
"session-1",
|
|
"--server-handle",
|
|
"12",
|
|
"--item-handle",
|
|
"34",
|
|
"--value-type",
|
|
"int32",
|
|
"--value",
|
|
"5",
|
|
"--current-user-id",
|
|
"1",
|
|
"--verifier-user-id",
|
|
"2",
|
|
]);
|
|
assert!(parsed.is_ok(), "parse failed: {parsed:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn parses_unregister_command() {
|
|
let parsed = Cli::try_parse_from([
|
|
"mxgw",
|
|
"unregister",
|
|
"--session-id",
|
|
"session-1",
|
|
"--server-handle",
|
|
"12",
|
|
]);
|
|
assert!(parsed.is_ok(), "parse failed: {parsed:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn parses_stream_alarms_command() {
|
|
let parsed = Cli::try_parse_from([
|
|
"mxgw",
|
|
"stream-alarms",
|
|
"--filter-prefix",
|
|
"Tank01",
|
|
"--max-events",
|
|
"3",
|
|
"--json",
|
|
]);
|
|
assert!(parsed.is_ok(), "parse failed: {parsed:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn parses_stream_alarms_command_without_filter_prefix() {
|
|
let parsed = Cli::try_parse_from(["mxgw", "stream-alarms"]);
|
|
assert!(parsed.is_ok(), "parse failed: {parsed:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn parses_acknowledge_alarm_command() {
|
|
let parsed = Cli::try_parse_from([
|
|
"mxgw",
|
|
"acknowledge-alarm",
|
|
"--reference",
|
|
"Tank01.Level.HiHi",
|
|
"--comment",
|
|
"ack from cli",
|
|
"--operator",
|
|
"operator1",
|
|
]);
|
|
assert!(parsed.is_ok(), "parse failed: {parsed:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn acknowledge_alarm_requires_operator() {
|
|
let parsed = Cli::try_parse_from([
|
|
"mxgw",
|
|
"acknowledge-alarm",
|
|
"--reference",
|
|
"Tank01.Level.HiHi",
|
|
]);
|
|
assert!(parsed.is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn acknowledge_alarm_requires_reference() {
|
|
let parsed = Cli::try_parse_from(["mxgw", "acknowledge-alarm"]);
|
|
assert!(parsed.is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn parses_galaxy_watch_command_with_last_seen_and_max_events() {
|
|
let parsed = Cli::try_parse_from([
|
|
"mxgw",
|
|
"galaxy",
|
|
"watch",
|
|
"--last-seen-deploy-time",
|
|
"2026-04-28T15:30:00Z",
|
|
"--max-events",
|
|
"5",
|
|
"--json",
|
|
]);
|
|
assert!(parsed.is_ok(), "parse failed: {parsed:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn parses_galaxy_watch_deploy_events_alias() {
|
|
let parsed = Cli::try_parse_from(["mxgw", "galaxy", "watch-deploy-events"]);
|
|
assert!(parsed.is_ok(), "parse failed: {parsed:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn parses_galaxy_browse_command_with_filters_and_depth() {
|
|
let parsed = Cli::try_parse_from([
|
|
"mxgw",
|
|
"galaxy",
|
|
"browse",
|
|
"--parent-gobject-id",
|
|
"42",
|
|
"--category-id",
|
|
"3",
|
|
"--category-id",
|
|
"5",
|
|
"--template-contains",
|
|
"$DelmiaReceiver",
|
|
"--tag-name-glob",
|
|
"Recv_*",
|
|
"--include-attributes",
|
|
"--alarm-bearing-only",
|
|
"--depth",
|
|
"2",
|
|
"--json",
|
|
]);
|
|
assert!(parsed.is_ok(), "parse failed: {parsed:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn parses_galaxy_browse_command_with_defaults() {
|
|
let parsed = Cli::try_parse_from(["mxgw", "galaxy", "browse"]);
|
|
assert!(parsed.is_ok(), "parse failed: {parsed:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn parses_batch_command() {
|
|
let parsed = Cli::try_parse_from(["mxgw", "batch"]);
|
|
assert!(parsed.is_ok(), "parse failed: {parsed:?}");
|
|
}
|
|
|
|
#[test]
|
|
fn batch_eor_marker_is_stable() {
|
|
assert_eq!(crate::batch::BATCH_EOR, "__MXGW_BATCH_EOR__");
|
|
}
|
|
|
|
#[test]
|
|
fn bench_percentile_summary_matches_hand_built_sample() {
|
|
// Hand-built sample with 5 values: 1, 2, 3, 4, 5.
|
|
let sample: Vec<f64> = vec![1.0, 2.0, 3.0, 4.0, 5.0];
|
|
let summary = crate::bench::percentile_summary(&sample);
|
|
|
|
assert_eq!(summary.max, 5.0);
|
|
// Mean = 15/5 = 3.0
|
|
assert!((summary.mean - 3.0).abs() < f64::EPSILON);
|
|
// p50: rank = 0.5 * 4 = 2 -> sorted[2] = 3.0
|
|
assert!((summary.p50 - 3.0).abs() < f64::EPSILON);
|
|
// p95: rank = 0.95 * 4 = 3.8 -> 4.0 + 0.8 * (5.0 - 4.0) = 4.8
|
|
assert!((summary.p95 - 4.8).abs() < f64::EPSILON);
|
|
// p99: rank = 0.99 * 4 = 3.96 -> 4.0 + 0.96 * 1.0 = 4.96
|
|
assert!((summary.p99 - 4.96).abs() < f64::EPSILON);
|
|
}
|
|
|
|
#[test]
|
|
fn bench_percentile_summary_handles_empty_sample() {
|
|
let summary = crate::bench::percentile_summary(&[]);
|
|
assert_eq!(summary.p50, 0.0);
|
|
assert_eq!(summary.p95, 0.0);
|
|
assert_eq!(summary.p99, 0.0);
|
|
assert_eq!(summary.max, 0.0);
|
|
assert_eq!(summary.mean, 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn bench_percentile_summary_handles_single_value_sample() {
|
|
let summary = crate::bench::percentile_summary(&[42.0]);
|
|
assert_eq!(summary.p50, 42.0);
|
|
assert_eq!(summary.p95, 42.0);
|
|
assert_eq!(summary.p99, 42.0);
|
|
assert_eq!(summary.max, 42.0);
|
|
assert_eq!(summary.mean, 42.0);
|
|
}
|
|
|
|
#[test]
|
|
fn register_page_token_accepts_distinct_tokens_and_rejects_repeats() {
|
|
let mut seen = std::collections::HashSet::new();
|
|
assert!(crate::galaxy::register_page_token(&mut seen, "tok-1").is_ok());
|
|
assert!(crate::galaxy::register_page_token(&mut seen, "tok-2").is_ok());
|
|
|
|
let repeated = crate::galaxy::register_page_token(&mut seen, "tok-1");
|
|
match repeated {
|
|
Err(zb_mom_ww_mxgateway_client::Error::InvalidArgument { name, detail }) => {
|
|
assert_eq!(name, "page_token");
|
|
assert!(detail.contains("tok-1"), "detail: {detail}");
|
|
}
|
|
other => panic!("expected InvalidArgument on repeated token, got {other:?}"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn rfc3339_parser_rejects_trailing_characters() {
|
|
let err = crate::parse::parse_rfc3339_timestamp("2026-04-28T15:30:00Zextra");
|
|
assert!(err.is_err(), "trailing chars after Z must be rejected");
|
|
}
|
|
|
|
#[test]
|
|
fn rfc3339_parser_rejects_day_zero() {
|
|
let err = crate::parse::parse_rfc3339_timestamp("2026-04-00T15:30:00Z");
|
|
assert!(err.is_err(), "day 0 must be rejected");
|
|
}
|
|
|
|
#[test]
|
|
fn rfc3339_parser_rejects_month_thirteen() {
|
|
let err = crate::parse::parse_rfc3339_timestamp("2026-13-01T15:30:00Z");
|
|
assert!(err.is_err(), "month 13 must be rejected");
|
|
}
|
|
|
|
#[test]
|
|
fn rfc3339_parser_rejects_day_out_of_range_for_month() {
|
|
// April has 30 days.
|
|
let err = crate::parse::parse_rfc3339_timestamp("2026-04-31T15:30:00Z");
|
|
assert!(err.is_err(), "April 31 must be rejected");
|
|
// February 29 in a non-leap year.
|
|
let feb = crate::parse::parse_rfc3339_timestamp("2025-02-29T00:00:00Z");
|
|
assert!(feb.is_err(), "Feb 29 in a non-leap year must be rejected");
|
|
}
|
|
|
|
#[test]
|
|
fn rfc3339_parser_round_trips_z_and_offset_inputs() {
|
|
// 2026-04-28T15:30:00Z = 1_777_995_000 (sanity-checked once below)
|
|
let utc = crate::parse::parse_rfc3339_timestamp("2026-04-28T15:30:00Z").unwrap();
|
|
let plus = crate::parse::parse_rfc3339_timestamp("2026-04-28T16:30:00+01:00").unwrap();
|
|
let frac = crate::parse::parse_rfc3339_timestamp("2026-04-28T15:30:00.250Z").unwrap();
|
|
|
|
assert_eq!(utc.seconds, plus.seconds);
|
|
assert_eq!(utc.nanos, 0);
|
|
assert_eq!(frac.seconds, utc.seconds);
|
|
assert_eq!(frac.nanos, 250_000_000);
|
|
}
|
|
|
|
#[test]
|
|
fn alarm_feed_provider_status_renders_in_summary_and_json() {
|
|
use zb_mom_ww_mxgateway_client::generated::mxaccess_gateway::v1::{
|
|
alarm_feed_message, AlarmFeedMessage, AlarmProviderMode, AlarmProviderStatus,
|
|
};
|
|
|
|
let message = AlarmFeedMessage {
|
|
payload: Some(alarm_feed_message::Payload::ProviderStatus(
|
|
AlarmProviderStatus {
|
|
mode: AlarmProviderMode::Subtag as i32,
|
|
degraded: true,
|
|
reason: "alarmmgr unavailable".to_owned(),
|
|
since: Some(prost_types::Timestamp {
|
|
seconds: 1_777_995_000,
|
|
nanos: 0,
|
|
}),
|
|
},
|
|
)),
|
|
};
|
|
|
|
let summary = crate::events::alarm_feed_message_summary(&message);
|
|
assert!(summary.contains("provider-status"), "summary: {summary}");
|
|
assert!(
|
|
summary.contains("ALARM_PROVIDER_MODE_SUBTAG"),
|
|
"summary: {summary}"
|
|
);
|
|
assert!(summary.contains("degraded=true"), "summary: {summary}");
|
|
|
|
let value = crate::events::alarm_feed_message_to_json(&message);
|
|
let provider = &value["providerStatus"];
|
|
assert_eq!(provider["mode"], "ALARM_PROVIDER_MODE_SUBTAG");
|
|
assert_eq!(provider["degraded"], true);
|
|
assert_eq!(provider["reason"], "alarmmgr unavailable");
|
|
assert_eq!(provider["since"]["seconds"], 1_777_995_000_i64);
|
|
}
|
|
|
|
#[test]
|
|
fn alarm_feed_snapshot_status_renders_in_summary_and_json() {
|
|
use zb_mom_ww_mxgateway_client::generated::mxaccess_gateway::v1::{
|
|
alarm_feed_message, AlarmFeedMessage, AlarmSnapshotStatus,
|
|
};
|
|
|
|
let message = AlarmFeedMessage {
|
|
payload: Some(alarm_feed_message::Payload::SnapshotStatus(
|
|
AlarmSnapshotStatus { truncated: true },
|
|
)),
|
|
};
|
|
|
|
let summary = crate::events::alarm_feed_message_summary(&message);
|
|
assert_eq!(summary, "snapshot-status truncated=true");
|
|
|
|
let value = crate::events::alarm_feed_message_to_json(&message);
|
|
assert_eq!(value["snapshotStatus"]["truncated"], true);
|
|
}
|