//! 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 = 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); }