#![cfg(feature = "cli")]
mod common;
use std::process::{Command as Proc, Output};
use std::time::Duration;
use clap::{CommandFactory, Parser};
use common::mock_bulb::{MockBulb, Personality};
use serde_json::Value;
use wizlight::cli::{Cli, Command, Target, render_failure};
use wizlight::{DEFAULT_WAIT, RetryPolicy, Scene};
fn wizlight(args: &[&str]) -> Output {
Proc::new(env!("CARGO_BIN_EXE_wizlight"))
.args(args)
.output()
.expect("the binary was built by the test harness")
}
fn scan(args: &[&str]) -> Output {
scan_at("127.0.0.1", "0.05", args, &[])
}
fn scan_with_env(args: &[&str], key: &str, value: &str) -> Output {
scan_at("127.0.0.1", "0.05", args, &[(key, value)])
}
fn scan_at(broadcast: &str, wait: &str, args: &[&str], env: &[(&str, &str)]) -> Output {
let mut full = vec!["--broadcast", broadcast, "--wait", wait];
full.extend_from_slice(args);
let mut proc = Proc::new(env!("CARGO_BIN_EXE_wizlight"));
proc.args(&full);
for (key, value) in env {
proc.env(key, value);
}
proc.output()
.expect("the binary was built by the test harness")
}
fn target(name: &str) -> Target {
Target {
target: Some(name.parse().expect("a valid target")),
all: false,
}
}
#[test]
fn global_flags_and_subcommand_are_parsed() {
let cli = Cli::try_parse_from([
"wizlight",
"--json",
"--timeout",
"7",
"--broadcast",
"192.168.1.255:38899",
"discover",
])
.expect("discover should parse");
assert!(cli.json);
assert_eq!(cli.timeout, Duration::from_secs(7));
assert_eq!(
cli.broadcast,
["192.168.1.255:38899".parse().expect("a socket address")]
);
assert_eq!(cli.command, Command::Discover);
}
#[test]
fn a_broadcast_address_may_omit_the_port_and_may_repeat() {
let cli = Cli::try_parse_from([
"wizlight",
"--broadcast",
"192.168.0.255",
"--broadcast",
"10.0.0.255",
"discover",
])
.expect("both parse");
let ports: Vec<u16> = cli.broadcast.iter().map(|addr| addr.port()).collect();
assert_eq!(ports, [wizlight::PORT, wizlight::PORT]);
let ips: Vec<String> = cli
.broadcast
.iter()
.map(|addr| addr.ip().to_string())
.collect();
assert_eq!(ips, ["192.168.0.255", "10.0.0.255"]);
}
#[test]
fn durations_may_be_fractional_and_may_not_be_negative() {
let cli = Cli::try_parse_from(["wizlight", "--wait", "0.25", "discover"]).expect("parses");
assert_eq!(cli.wait, Duration::from_millis(250));
assert!(Cli::try_parse_from(["wizlight", "--timeout", "-1", "discover"]).is_err());
assert!(Cli::try_parse_from(["wizlight", "--wait", "soon", "discover"]).is_err());
}
#[test]
fn the_scan_window_defaults_to_the_measured_one() {
let cli = Cli::try_parse_from(["wizlight", "discover"]).expect("parses");
assert_eq!(cli.wait, DEFAULT_WAIT);
}
#[test]
fn the_cli_is_more_patient_than_the_library_default() {
let cli = Cli::try_parse_from(["wizlight", "discover"]).expect("parses");
let policy = cli.policy();
let default = RetryPolicy::default();
assert_eq!(policy.attempt_timeout, Duration::from_secs(2));
assert!(policy.attempt_timeout > default.attempt_timeout);
assert_eq!(policy.attempts, default.attempts);
assert_eq!(policy.min_interval, default.min_interval);
}
#[test]
fn a_target_is_parsed_and_reported_by_the_command() {
let cli = Cli::try_parse_from(["wizlight", "status", "192.168.0.5"]).expect("status parses");
assert_eq!(cli.command, Command::Status(target("192.168.0.5")));
assert_eq!(cli.command.name(), "status");
assert_eq!(cli.command.target(), Some("192.168.0.5"));
assert_eq!(Command::Discover.target(), None);
}
#[test]
fn a_global_flag_is_accepted_after_the_subcommand() {
let cli = Cli::try_parse_from(["wizlight", "status", "192.168.0.5", "--json"])
.expect("global flags are global");
assert!(cli.json);
}
#[test]
fn output_renderer_formats_typed_data_as_json() {
let json = wizlight::cli::render_json(&serde_json::json!({"ok": true, "value": 3}));
assert_eq!(json.trim(), "{\"ok\":true,\"value\":3}");
}
#[test]
fn a_human_failure_is_a_plain_line_not_json() {
let rendered = render_failure(Some(&Command::Status(target("1.2.3.4"))), "boom", false);
assert_eq!(rendered, "error: boom");
}
#[test]
fn a_json_failure_carries_the_command_and_target() {
let rendered = render_failure(Some(&Command::Status(target("1.2.3.4"))), "boom", true);
let value: Value = serde_json::from_str(&rendered).expect("valid JSON");
assert_eq!(value["ok"], Value::Bool(false));
assert_eq!(value["command"], "status");
assert_eq!(value["target"], "1.2.3.4");
assert_eq!(value["error"], "boom");
let rendered = render_failure(Some(&Command::Discover), "boom", true);
let value: Value = serde_json::from_str(&rendered).expect("valid JSON");
assert_eq!(value["command"], "discover");
assert_eq!(value["target"], Value::Null);
}
#[tokio::test(flavor = "multi_thread")]
async fn bench_ramps_rate_probes_latency_and_interpolation_and_restores_state() {
let bulb = MockBulb::builder()
.mac("9877d5230f0a")
.pilot(serde_json::json!({
"mac": "9877d5230f0a",
"state": true,
"r": 255,
"g": 80,
"b": 0,
"dimming": 40,
"sceneId": 0,
"rssi": -52
}))
.start()
.await;
let addr = bulb.addr().to_string();
let human = against(
&bulb,
&addr,
&[
"bench",
"--min-rate",
"10",
"--max-rate",
"20",
"--steps",
"2",
"--hold",
"0.05",
],
)
.await;
assert_eq!(human.status.code(), Some(0));
let stdout = String::from_utf8(human.stdout).expect("utf-8");
assert!(stdout.contains("ESP25_SHRGB_01"), "{stdout}");
assert!(stdout.contains("rate (Hz)"), "{stdout}");
assert!(stdout.contains("latency"), "{stdout}");
assert!(stdout.contains("interpolate"), "{stdout}");
assert!(stdout.contains("restored yes"), "{stdout}");
let stderr = String::from_utf8(human.stderr).expect("utf-8");
assert!(
stderr.contains("warning: benchmarking will visibly flash"),
"{stderr}"
);
let json = stdout_json(
&against(
&bulb,
&addr,
&[
"--json",
"bench",
"--min-rate",
"10",
"--max-rate",
"20",
"--steps",
"2",
"--hold",
"0.05",
],
)
.await,
);
assert_eq!(json["ok"], Value::Bool(true));
assert_eq!(json["command"], "bench");
assert_eq!(json["result"]["device"]["model"], "ESP25_SHRGB_01");
assert_eq!(json["result"]["restored"], Value::Bool(true));
let steps = json["result"]["rate_sweep"].as_array().expect("steps list");
assert_eq!(steps.len(), 2);
assert_eq!(steps[0]["rate_hz"], 10.0);
assert_eq!(steps[1]["rate_hz"], 20.0);
assert!(steps[0]["rtt_ms"]["median"].is_number(), "{steps:?}");
assert_eq!(
json["result"]["latency_probe"]["pattern"],
"black_to_white_step"
);
assert_eq!(
json["result"]["interpolation_probe"]["abrupt_step"]["pattern"],
"red_to_blue_step"
);
let restored = bulb.pilot();
assert_eq!(restored["state"], Value::Bool(true));
assert_eq!(restored["r"], 255);
assert_eq!(restored["g"], 80);
assert_eq!(restored["b"], 0);
assert_eq!(restored["dimming"], 40);
}
#[test]
fn bench_rejects_invalid_rate_and_step_arguments() {
for args in [
&["bench", "192.168.0.5", "--min-rate", "0"][..],
&["bench", "192.168.0.5", "--max-rate", "-5"][..],
&["bench", "192.168.0.5", "--steps", "0"][..],
&["bench", "192.168.0.5", "--hold", "0"][..],
&[
"bench",
"192.168.0.5",
"--min-rate",
"40",
"--max-rate",
"10",
][..],
&["bench", "192.168.0.5", "--rates", "0,5"][..],
&[
"bench",
"192.168.0.5",
"--rates",
"1,2,4",
"--min-rate",
"1",
][..],
&["bench", "192.168.0.5", "--pulse-durations", "0,100"][..],
&["bench", "192.168.0.5", "--pulse-delta", "0"][..],
] {
let output = wizlight(args);
assert_eq!(output.status.code(), Some(2), "{args:?}");
}
}
#[tokio::test(flavor = "multi_thread")]
async fn bench_supports_explicit_rates_dimming_set_state_and_pulse_sweeps() {
let bulb = MockBulb::builder()
.mac("9877d5230f0a")
.pilot(serde_json::json!({
"mac": "9877d5230f0a",
"state": true,
"sceneId": 11,
"temp": 2700,
"dimming": 75,
"rssi": -50
}))
.start()
.await;
let addr = bulb.addr().to_string();
let json = stdout_json(
&against(
&bulb,
&addr,
&[
"--json",
"bench",
"--mode",
"set-state",
"--rates",
"2,4,8",
"--hold",
"0.05",
"--pulse-durations",
"50,150",
"--pulse-delta",
"-60",
],
)
.await,
);
assert_eq!(json["ok"], Value::Bool(true));
assert_eq!(json["result"]["config"]["mode"], "set_state");
assert_eq!(json["result"]["config"]["method"], "setState");
let steps = json["result"]["rate_sweep"].as_array().expect("rate steps");
let rates: Vec<f64> = steps
.iter()
.map(|s| s["rate_hz"].as_f64().unwrap())
.collect();
assert_eq!(rates, vec![2.0, 4.0, 8.0]);
assert_eq!(
json["result"]["interpolation_probe"]["abrupt_step"]["pattern"],
"dim_10_to_100_step"
);
let pulses = json["result"]["pulse_sweep"]
.as_array()
.expect("pulse steps");
assert_eq!(pulses.len(), 2);
assert_eq!(pulses[0]["delta"], -60);
assert_eq!(pulses[0]["duration_ms"], 50);
assert_eq!(pulses[0]["responses"], 1);
assert_eq!(pulses[1]["duration_ms"], 150);
assert_eq!(pulses[1]["responses"], 1);
assert_eq!(json["result"]["restored"], Value::Bool(true));
assert_eq!(bulb.pilot()["sceneId"], 11);
assert_eq!(bulb.pilot()["dimming"], 75);
}
#[tokio::test(flavor = "multi_thread")]
async fn pulse_command_sends_pulse_and_rejects_non_dimmable_devices() {
let bulb = MockBulb::start().await;
let addr = bulb.addr().to_string();
let human = against(
&bulb,
&addr,
&["pulse", "--delta", "-80", "--duration", "150"],
)
.await;
assert_eq!(human.status.code(), Some(0));
assert_eq!(
String::from_utf8(human.stdout).unwrap().trim(),
"pulse -80% 150 ms"
);
let json = stdout_json(
&against(
&bulb,
&addr,
&["--json", "pulse", "--delta", "50", "--duration", "200"],
)
.await,
);
assert_eq!(json["ok"], Value::Bool(true));
assert_eq!(json["command"], "pulse");
assert_eq!(json["result"]["delta"], 50);
assert_eq!(json["result"]["duration"], 200);
let socket = MockBulb::builder()
.personality(Personality::socket())
.start()
.await;
let sock_addr = socket.addr().to_string();
let failed = against(
&socket,
&sock_addr,
&["pulse", "--delta", "-50", "--duration", "100"],
)
.await;
assert_eq!(failed.status.code(), Some(1));
let stderr = String::from_utf8(failed.stderr).unwrap();
assert!(stderr.contains("cannot pulse brightness"), "{stderr}");
for bad in [
&["pulse", "192.168.0.5", "--delta", "0", "--duration", "100"][..],
&[
"pulse",
"192.168.0.5",
"--delta",
"-101",
"--duration",
"100",
][..],
&["pulse", "192.168.0.5", "--delta", "-50", "--duration", "0"][..],
] {
assert_eq!(wizlight(bad).status.code(), Some(2), "{bad:?}");
}
}
async fn deaf_bulb() -> MockBulb {
let bulb = MockBulb::start().await;
bulb.drop_next(usize::MAX);
bulb
}
#[tokio::test(flavor = "multi_thread")]
async fn a_failure_goes_to_stderr_and_stdout_stays_empty() {
let bulb = deaf_bulb().await;
let addr = bulb.addr().to_string();
let output =
tokio::task::spawn_blocking(move || wizlight(&["--timeout", "0.05", "status", &addr]))
.await
.expect("the command ran");
assert_eq!(output.status.code(), Some(4), "a timeout has its own code");
assert!(
output.stdout.is_empty(),
"results go to stdout, errors do not"
);
let stderr = String::from_utf8(output.stderr).expect("utf-8");
assert!(stderr.starts_with("error: "), "{stderr}");
assert!(stderr.contains("getPilot"), "{stderr}");
}
#[tokio::test(flavor = "multi_thread")]
async fn a_json_failure_goes_to_stderr_as_json_and_only_once() {
let bulb = deaf_bulb().await;
let addr = bulb.addr().to_string();
let target = addr.clone();
let output = tokio::task::spawn_blocking(move || {
wizlight(&["--json", "--timeout", "0.05", "status", &addr])
})
.await
.expect("the command ran");
assert_eq!(output.status.code(), Some(4));
assert!(
output.stdout.is_empty(),
"results go to stdout, errors do not"
);
let stderr = String::from_utf8(output.stderr).expect("utf-8");
assert_eq!(stderr.lines().count(), 1, "rendered twice: {stderr}");
let value: Value = serde_json::from_str(stderr.trim()).expect("stderr is JSON under --json");
assert_eq!(value["ok"], Value::Bool(false));
assert_eq!(value["command"], "status");
assert_eq!(value["target"], target);
}
const SCAN: &str = "0.4";
#[tokio::test(flavor = "multi_thread")]
async fn discover_lists_what_answered() {
let bulb = MockBulb::builder().mac("9877d5230f0a").start().await;
let addr = bulb.addr().to_string();
let output = tokio::task::spawn_blocking(move || scan_at(&addr, SCAN, &["discover"], &[]))
.await
.expect("the scan ran");
assert_eq!(output.status.code(), Some(0));
let stdout = String::from_utf8(output.stdout).expect("utf-8");
let line = stdout.trim();
assert!(line.starts_with("9877d5230f0a"), "{line}");
assert!(line.contains("127.0.0.1"), "{line}");
assert!(line.contains("ESP25_SHRGB_01"), "{line}");
assert!(line.contains("1.38.0"), "{line}");
}
#[tokio::test(flavor = "multi_thread")]
async fn discover_json_carries_the_envelope_and_one_object_per_bulb() {
let bulb = MockBulb::builder().mac("9877d5230f0a").start().await;
let addr = bulb.addr().to_string();
let port = bulb.port();
let output =
tokio::task::spawn_blocking(move || scan_at(&addr, SCAN, &["--json", "discover"], &[]))
.await
.expect("the scan ran");
let stdout = String::from_utf8(output.stdout).expect("utf-8");
let value: Value = serde_json::from_str(stdout.trim()).expect("stdout is JSON under --json");
assert_eq!(value["ok"], Value::Bool(true));
assert_eq!(value["command"], "discover");
assert_eq!(value["target"], Value::Null);
let bulbs = value["result"].as_array().expect("result is a list");
assert_eq!(bulbs.len(), 1);
assert_eq!(bulbs[0]["mac"], "9877d5230f0a");
assert_eq!(bulbs[0]["ip"], "127.0.0.1");
assert_eq!(bulbs[0]["port"], port);
assert_eq!(bulbs[0]["model"], "ESP25_SHRGB_01");
assert_eq!(bulbs[0]["firmware"], "1.38.0");
}
#[tokio::test(flavor = "multi_thread")]
async fn discover_finding_nothing_is_a_success_with_an_empty_list() {
let output = tokio::task::spawn_blocking(|| scan(&["--json", "discover"]))
.await
.expect("the scan ran");
assert_eq!(output.status.code(), Some(0));
let stdout = String::from_utf8(output.stdout).expect("utf-8");
let value: Value = serde_json::from_str(stdout.trim()).expect("JSON");
assert_eq!(value["ok"], Value::Bool(true));
assert_eq!(value["result"], serde_json::json!([]));
let human = String::from_utf8(scan(&["discover"]).stdout).expect("utf-8");
assert!(human.trim().starts_with("no bulbs answered"), "{human}");
}
#[tokio::test(flavor = "multi_thread")]
async fn discover_reports_a_bulb_that_will_not_describe_itself() {
let bulb = MockBulb::builder()
.personality(Personality::rgb().with_system_config(
r#"{"env":"pro","error":{"code":-32601,"message":"Method not found"}}"#,
))
.mac("9877d523a4da")
.start()
.await;
let addr = bulb.addr().to_string();
let output =
tokio::task::spawn_blocking(move || scan_at(&addr, SCAN, &["--json", "discover"], &[]))
.await
.expect("the scan ran");
let stdout = String::from_utf8(output.stdout).expect("utf-8");
let value: Value = serde_json::from_str(stdout.trim()).expect("JSON");
let bulbs = value["result"].as_array().expect("result is a list");
assert_eq!(bulbs.len(), 1, "{value}");
assert_eq!(bulbs[0]["mac"], "9877d523a4da");
assert_eq!(bulbs[0]["model"], Value::Null);
assert_eq!(bulbs[0]["firmware"], Value::Null);
let addr = bulb.addr().to_string();
let human = String::from_utf8(
tokio::task::spawn_blocking(move || scan_at(&addr, SCAN, &["discover"], &[]))
.await
.expect("the scan ran")
.stdout,
)
.expect("utf-8");
assert_eq!(human.trim(), "9877d523a4da 127.0.0.1 - -");
}
async fn against(bulb: &MockBulb, target: &str, args: &[&str]) -> Output {
let addr = bulb.addr().to_string();
let target = target.to_owned();
let mut owned: Vec<String> = vec![
"--broadcast".into(),
addr,
"--wait".into(),
SCAN.into(),
"--timeout".into(),
"0.5".into(),
];
owned.extend(args.iter().map(|arg| (*arg).to_string()));
owned.push(target);
tokio::task::spawn_blocking(move || {
let borrowed: Vec<&str> = owned.iter().map(String::as_str).collect();
wizlight(&borrowed)
})
.await
.expect("the command ran")
}
async fn goes_quiet_once_scanned(bulb: &MockBulb) {
for _ in 0..400 {
if !bulb.requests().is_empty() {
break;
}
tokio::time::sleep(Duration::from_millis(5)).await;
}
bulb.drop_next(usize::MAX);
}
fn stdout_json(output: &Output) -> Value {
let stdout = std::str::from_utf8(&output.stdout).expect("utf-8");
serde_json::from_str(stdout.trim()).unwrap_or_else(|err| panic!("{err}: {stdout}"))
}
#[tokio::test(flavor = "multi_thread")]
async fn status_reports_what_the_bulb_says_it_is_doing() {
let bulb = MockBulb::builder()
.mac("9877d5230f0a")
.pilot(serde_json::json!({
"state": true, "r": 255, "g": 80, "b": 0, "dimming": 40, "sceneId": 0, "rssi": -52
}))
.start()
.await;
let addr = bulb.addr().to_string();
let human = against(&bulb, &addr, &["status"]).await;
assert_eq!(human.status.code(), Some(0));
let line = String::from_utf8(human.stdout).expect("utf-8");
assert_eq!(line.trim(), "on rgb 255,80,0 40% -52 dBm");
let json = stdout_json(&against(&bulb, &addr, &["--json", "status"]).await);
assert_eq!(json["ok"], Value::Bool(true));
assert_eq!(json["command"], "status");
assert_eq!(json["result"]["state"], Value::Bool(true));
assert_eq!(json["result"]["r"], 255);
assert_eq!(json["result"]["dimming"], 40);
}
#[tokio::test(flavor = "multi_thread")]
async fn status_names_a_running_scene() {
let bulb = MockBulb::builder()
.pilot(serde_json::json!({"state": true, "sceneId": 4, "speed": 100, "dimming": 100}))
.start()
.await;
let addr = bulb.addr().to_string();
let human = String::from_utf8(against(&bulb, &addr, &["status"]).await.stdout).expect("utf-8");
assert!(human.contains("scene Party (4)"), "{human}");
let json = stdout_json(&against(&bulb, &addr, &["--json", "status"]).await);
assert_eq!(json["result"]["sceneId"], 4);
assert_eq!(json["result"]["scene"], "Party");
}
#[tokio::test(flavor = "multi_thread")]
async fn info_describes_the_model_and_what_it_can_do() {
let bulb = MockBulb::start().await;
let addr = bulb.addr().to_string();
let human = String::from_utf8(against(&bulb, &addr, &["info"]).await.stdout).expect("utf-8");
assert!(human.contains("ESP25_SHRGB_01"), "{human}");
assert!(human.contains("1.38.0"), "{human}");
assert!(human.contains("2200-6500 K"), "{human}");
assert!(human.contains("colour"), "{human}");
let json = stdout_json(&against(&bulb, &addr, &["--json", "info"]).await);
assert_eq!(json["result"]["class"], "RGB");
assert_eq!(json["result"]["features"]["color"], Value::Bool(true));
assert_eq!(json["result"]["kelvin_range"]["min"], 2200);
}
#[tokio::test(flavor = "multi_thread")]
async fn scenes_lists_only_what_that_class_plays() {
let colour = MockBulb::start().await;
let white = MockBulb::builder()
.personality(Personality::tunable_white())
.start()
.await;
let colour_addr = colour.addr().to_string();
let white_addr = white.addr().to_string();
let listed =
String::from_utf8(against(&colour, &colour_addr, &["scenes"]).await.stdout).expect("utf-8");
assert!(listed.contains("Party"), "{listed}");
let listed =
String::from_utf8(against(&white, &white_addr, &["scenes"]).await.stdout).expect("utf-8");
assert!(!listed.contains("Party"), "{listed}");
assert!(listed.contains("Cozy"), "{listed}");
let json = stdout_json(&against(&white, &white_addr, &["--json", "scenes"]).await);
let scenes = json["result"].as_array().expect("a list");
assert!(scenes.iter().all(|scene| scene["name"] != "Party"));
}
#[tokio::test(flavor = "multi_thread")]
async fn on_sends_the_colour_it_was_given() {
let bulb = MockBulb::start().await;
let addr = bulb.addr().to_string();
let output = against(&bulb, &addr, &["on", "--rgb", "255,80,0", "-b", "40"]).await;
assert_eq!(output.status.code(), Some(0));
let request = bulb.last_request().expect("a write arrived");
assert_eq!(request["method"], "setPilot");
assert_eq!(request["params"]["state"], Value::Bool(true));
assert_eq!(request["params"]["r"], 255);
assert_eq!(request["params"]["g"], 80);
assert_eq!(request["params"]["b"], 0);
assert_eq!(request["params"]["dimming"], 40);
}
#[tokio::test(flavor = "multi_thread")]
async fn hsv_is_converted_because_the_protocol_has_none() {
let bulb = MockBulb::start().await;
let addr = bulb.addr().to_string();
against(&bulb, &addr, &["on", "--hsv", "0,100,100"]).await;
let request = bulb.last_request().expect("a write arrived");
assert_eq!(request["params"]["r"], 255);
assert_eq!(request["params"]["g"], 0);
assert_eq!(request["params"]["b"], 0);
against(&bulb, &addr, &["on", "--hsv", "120,100,50"]).await;
let request = bulb.last_request().expect("a write arrived");
assert_eq!(request["params"]["g"], 128);
assert_eq!(request["params"]["dimming"], Value::Null);
}
#[tokio::test(flavor = "multi_thread")]
async fn the_white_emitters_compose_with_a_colour() {
let bulb = MockBulb::start().await;
let addr = bulb.addr().to_string();
let output = against(
&bulb,
&addr,
&[
"--json", "on", "--rgb", "255,80,0", "--cold", "12", "--warm", "34",
],
)
.await;
assert_eq!(output.status.code(), Some(0));
let request = bulb.last_request().expect("a write arrived");
assert_eq!(request["params"]["r"], 255);
assert_eq!(request["params"]["g"], 80);
assert_eq!(request["params"]["b"], 0);
assert_eq!(request["params"]["c"], 12);
assert_eq!(request["params"]["w"], 34);
let json = stdout_json(&output);
assert_eq!(json["result"]["c"], 12);
assert_eq!(json["result"]["w"], 34);
against(&bulb, &addr, &["on", "--hsv", "0,100,100", "--warm", "64"]).await;
let request = bulb.last_request().expect("a write arrived");
assert_eq!(request["params"]["r"], 255);
assert_eq!(request["params"]["w"], 64);
assert_eq!(request["params"]["c"], Value::Null);
}
#[tokio::test(flavor = "multi_thread")]
async fn a_white_emitter_can_be_sent_on_its_own() {
let bulb = MockBulb::start().await;
let addr = bulb.addr().to_string();
against(&bulb, &addr, &["on", "--rgb", "255,80,0"]).await;
let output = against(&bulb, &addr, &["set", "--warm", "128"]).await;
assert_eq!(output.status.code(), Some(0));
let request = bulb.last_request().expect("a write arrived");
assert_eq!(request["method"], "setState");
assert_eq!(request["params"]["w"], 128);
assert_eq!(request["params"]["r"], Value::Null);
let json = stdout_json(&against(&bulb, &addr, &["--json", "status"]).await);
assert_eq!(json["result"]["w"], 128);
assert_eq!(json["result"]["r"], 0, "the colour it replaced went dark");
}
#[tokio::test(flavor = "multi_thread")]
async fn a_colour_with_nothing_lit_in_it_is_refused_before_it_is_sent() {
let bulb = MockBulb::start().await;
let addr = bulb.addr().to_string();
for args in [
vec!["on", "--rgb", "0,0,0"],
vec!["set", "--rgb", "0,0,0"],
vec!["on", "--warm", "0"],
vec!["on", "--hsv", "120,100,0"],
vec!["on", "--cold", "0", "--warm", "0"],
] {
let output = against(&bulb, &addr, &args).await;
assert_eq!(output.status.code(), Some(2), "{args:?}");
let stderr = String::from_utf8(output.stderr).expect("utf-8");
assert!(
stderr.contains("asks for no light at all"),
"{args:?}: {stderr}"
);
assert!(bulb.requests().is_empty(), "{args:?} reached the bulb");
}
let output = against(&bulb, &addr, &["on", "--rgb", "0,0,0", "--warm", "128"]).await;
assert_eq!(output.status.code(), Some(0));
let request = bulb.last_request().expect("a write arrived");
assert_eq!(request["params"]["r"], 0);
assert_eq!(request["params"]["w"], 128);
}
#[tokio::test(flavor = "multi_thread")]
async fn a_white_emitter_conflicts_with_temp_and_scene_but_not_with_a_colour() {
let bulb = MockBulb::start().await;
let addr = bulb.addr().to_string();
for pair in [
vec!["--cold", "12", "--kelvin", "2700"],
vec!["--warm", "34", "--scene", "Party"],
] {
let mut args = vec!["on"];
args.extend(pair.iter().copied());
let output = against(&bulb, &addr, &args).await;
assert_eq!(output.status.code(), Some(2), "{pair:?}");
assert!(bulb.requests().is_empty(), "{pair:?} reached the bulb");
}
let output = against(&bulb, &addr, &["on", "--cold", "12", "--warm", "34"]).await;
assert_eq!(output.status.code(), Some(0));
}
#[tokio::test(flavor = "multi_thread")]
async fn status_shows_a_white_emitter_only_when_it_is_lit() {
let bulb = MockBulb::builder()
.pilot(serde_json::json!({
"state": true, "r": 255, "g": 80, "b": 0, "c": 0, "w": 64,
"dimming": 100, "sceneId": 0
}))
.start()
.await;
let addr = bulb.addr().to_string();
let line = String::from_utf8(against(&bulb, &addr, &["status"]).await.stdout).expect("utf-8");
assert_eq!(line.trim(), "on rgb 255,80,0 warm 64 100%");
let json = stdout_json(&against(&bulb, &addr, &["--json", "status"]).await);
assert_eq!(json["result"]["c"], 0);
assert_eq!(json["result"]["w"], 64);
}
#[tokio::test(flavor = "multi_thread")]
async fn a_scene_is_named_or_numbered_and_matched_leniently() {
let bulb = MockBulb::start().await;
let addr = bulb.addr().to_string();
for spelling in ["Deep dive", "deep-dive", "DEEPDIVE", "23"] {
against(&bulb, &addr, &["on", "--scene", spelling]).await;
let request = bulb.last_request().expect("a write arrived");
assert_eq!(request["params"]["sceneId"], 23, "{spelling}");
}
let output = against(&bulb, &addr, &["on", "--scene", "41"]).await;
assert_eq!(
output.status.code(),
Some(2),
"a bad value is a usage error"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn off_and_toggle_write_the_power_state() {
let bulb = MockBulb::builder()
.pilot(serde_json::json!({"state": true, "dimming": 100}))
.start()
.await;
let addr = bulb.addr().to_string();
against(&bulb, &addr, &["off"]).await;
assert_eq!(
bulb.last_request().expect("a write")["params"]["state"],
Value::Bool(false)
);
let output = against(&bulb, &addr, &["toggle"]).await;
assert_eq!(output.status.code(), Some(0));
assert_eq!(
bulb.last_request().expect("a write")["params"]["state"],
Value::Bool(true)
);
assert_eq!(
String::from_utf8(output.stdout).expect("utf-8").trim(),
"on"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn set_uses_set_state_and_needs_something_to_set() {
let bulb = MockBulb::start().await;
let addr = bulb.addr().to_string();
against(&bulb, &addr, &["set", "--kelvin", "2700"]).await;
let request = bulb.last_request().expect("a write arrived");
assert_eq!(request["method"], "setState");
assert_eq!(request["params"]["temp"], 2700);
let output = against(&bulb, &addr, &["set"]).await;
assert_eq!(output.status.code(), Some(2));
let stderr = String::from_utf8(output.stderr).expect("utf-8");
assert!(stderr.contains("needs something to set"), "{stderr}");
assert!(stderr.contains("Usage:"), "{stderr}");
}
#[tokio::test(flavor = "multi_thread")]
async fn two_ways_of_saying_a_colour_is_a_usage_error() {
let bulb = MockBulb::start().await;
let addr = bulb.addr().to_string();
for pair in [
vec!["--rgb", "255,0,0", "--kelvin", "2700"],
vec!["--rgb", "255,0,0", "--hsv", "0,100,100"],
vec!["--scene", "Party", "--kelvin", "2700"],
] {
let mut args = vec!["on"];
args.extend(pair.iter().copied());
let output = against(&bulb, &addr, &args).await;
assert_eq!(output.status.code(), Some(2), "{pair:?}");
assert!(bulb.requests().is_empty(), "{pair:?} reached the bulb");
}
}
#[tokio::test(flavor = "multi_thread")]
async fn asking_a_bulb_for_what_it_has_no_hardware_for_names_its_class() {
let bulb = MockBulb::builder()
.personality(Personality::dimmable_white())
.start()
.await;
let addr = bulb.addr().to_string();
let output = against(&bulb, &addr, &["on", "--rgb", "255,0,0"]).await;
assert_eq!(output.status.code(), Some(1));
let stderr = String::from_utf8(output.stderr).expect("utf-8");
assert!(stderr.contains("ESP06_SHDW9_01"), "{stderr}");
assert!(stderr.contains("Dimmable White"), "{stderr}");
assert!(stderr.contains("cannot show a colour"), "{stderr}");
assert!(
bulb.requests().iter().all(|raw| !raw.contains("setPilot")),
"{:?}",
bulb.requests()
);
let output = against(&bulb, &addr, &["on", "--warm", "64"]).await;
assert_eq!(output.status.code(), Some(1));
let stderr = String::from_utf8(output.stderr).expect("utf-8");
assert!(
stderr.contains("cannot be given raw white channels"),
"{stderr}"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn a_target_may_be_a_mac_in_any_spelling() {
let bulb = MockBulb::builder().mac("9877d5230f0a").start().await;
for spelling in ["9877d5230f0a", "98:77:d5:23:0f:0a", "9877D5230F0A"] {
let output = against(&bulb, spelling, &["--json", "status"]).await;
assert_eq!(output.status.code(), Some(0), "{spelling}");
assert_eq!(stdout_json(&output)["target"], spelling);
}
}
#[tokio::test(flavor = "multi_thread")]
async fn a_mac_nothing_answers_to_is_not_found_rather_than_a_failure() {
let bulb = MockBulb::builder().mac("9877d5230f0a").start().await;
let output = against(&bulb, "aabbccddeeff", &["status"]).await;
assert_eq!(output.status.code(), Some(3), "not found has its own code");
let stderr = String::from_utf8(output.stderr).expect("utf-8");
assert!(stderr.contains("aabbccddeeff"), "{stderr}");
assert!(stderr.contains("powered off"), "{stderr}");
}
#[test]
fn a_target_that_is_neither_an_address_nor_a_mac_is_a_usage_error() {
let output = wizlight(&["status", "kitchen"]);
assert_eq!(output.status.code(), Some(2));
let stderr = String::from_utf8(output.stderr).expect("utf-8");
assert!(
stderr.contains("neither an IP address nor a MAC"),
"{stderr}"
);
}
#[test]
fn a_command_needs_a_target_or_all_and_not_both() {
assert_eq!(wizlight(&["status"]).status.code(), Some(2));
assert_eq!(
wizlight(&["status", "--all", "9877d5230f0a"]).status.code(),
Some(2)
);
}
#[tokio::test(flavor = "multi_thread")]
async fn all_fans_out_and_one_failure_does_not_hide_the_others() {
let working = MockBulb::builder()
.mac("9877d5230f0a")
.pilot(serde_json::json!({"state": true, "dimming": 100}))
.start()
.await;
let deaf = MockBulb::builder().mac("9877d523a4da").start().await;
let addrs = [working.addr().to_string(), deaf.addr().to_string()];
let output = tokio::task::spawn_blocking(move || {
wizlight(&[
"--json",
"--broadcast",
&addrs[0],
"--broadcast",
&addrs[1],
"--wait",
SCAN,
"--timeout",
"0.05",
"status",
"--all",
])
});
goes_quiet_once_scanned(&deaf).await;
let output = output.await.expect("the command ran");
assert_eq!(output.status.code(), Some(1), "a partial failure is not 0");
let json = stdout_json(&output);
assert_eq!(json["ok"], Value::Bool(false));
assert_eq!(json["target"], Value::Null);
let results = json["result"].as_array().expect("one entry per bulb");
assert_eq!(results.len(), 2);
assert_eq!(results[0]["target"], "9877d5230f0a");
assert_eq!(results[0]["ok"], Value::Bool(true));
assert_eq!(results[0]["result"]["state"], Value::Bool(true));
assert_eq!(results[1]["target"], "9877d523a4da");
assert_eq!(results[1]["ok"], Value::Bool(false));
assert!(
results[1]["error"]
.as_str()
.expect("a message")
.contains("no reply"),
"{}",
results[1]["error"]
);
}
#[tokio::test(flavor = "multi_thread")]
async fn a_fan_out_labels_every_line_with_the_bulb_it_came_from() {
let one = MockBulb::builder()
.mac("9877d5230f0a")
.pilot(serde_json::json!({"state": true, "dimming": 100}))
.start()
.await;
let two = MockBulb::builder()
.mac("9877d523a4da")
.pilot(serde_json::json!({"state": false, "dimming": 40}))
.start()
.await;
let addrs = [one.addr().to_string(), two.addr().to_string()];
let output = tokio::task::spawn_blocking(move || {
wizlight(&[
"--broadcast",
&addrs[0],
"--broadcast",
&addrs[1],
"--wait",
SCAN,
"status",
"--all",
])
})
.await
.expect("the command ran");
assert_eq!(output.status.code(), Some(0));
let stdout = String::from_utf8(output.stdout).expect("utf-8");
assert_eq!(
stdout.trim(),
"9877d5230f0a on 100%\n9877d523a4da off 40%"
);
}
#[test]
fn no_subcommand_is_a_usage_error_not_a_success() {
let output = wizlight(&[]);
assert_eq!(output.status.code(), Some(2));
let stderr = String::from_utf8(output.stderr).expect("utf-8");
assert!(stderr.contains("Usage:"), "{stderr}");
}
#[test]
fn an_unknown_subcommand_is_a_usage_error() {
let output = wizlight(&["nosuchcommand"]);
assert_eq!(output.status.code(), Some(2));
}
#[test]
fn help_succeeds_and_is_printed_to_stdout() {
for flag in ["--help", "-h"] {
let output = wizlight(&[flag]);
assert_eq!(output.status.code(), Some(0), "{flag}");
let stdout = String::from_utf8(output.stdout).expect("utf-8");
assert!(stdout.contains("Usage:"), "{flag}: {stdout}");
}
}
#[test]
fn help_leaks_no_rustdoc_at_either_length() {
let long = String::from_utf8(wizlight(&["--help"]).stdout).expect("utf-8");
let short = String::from_utf8(wizlight(&["-h"]).stdout).expect("utf-8");
for help in [&long, &short] {
assert!(help.starts_with("Control Philips WiZ bulbs"), "{help}");
assert!(!help.contains("Global CLI flags"), "{help}");
for command in [
"discover", "status", "on", "off", "info", "set", "toggle", "pulse", "scenes", "watch",
"bench",
] {
assert!(help.contains(command), "{command} missing from {help}");
}
assert!(
!help.contains("completions"),
"hidden command leaked: {help}"
);
}
assert!(long.contains("multi-homed"), "{long}");
assert!(long.contains("Start with:"), "{long}");
assert!(
long.lines().count() <= 80,
"help is taller than a terminal: {long}"
);
let commands = long
.split_once("Commands:")
.and_then(|(_, rest)| rest.split_once("Options:"))
.map(|(commands, _)| commands)
.expect("commands section");
for pair in [
("discover", "status"),
("status", "on"),
("on", "off"),
("off", "info"),
] {
assert!(
commands.find(&format!(" {}", pair.0)) < commands.find(&format!(" {}", pair.1)),
"wrong command order: {commands}"
);
}
assert!(short.len() < long.len(), "-h should be the summary");
}
#[test]
fn on_set_and_bench_long_help_include_working_examples() {
for command in ["on", "set", "pulse", "bench"] {
let output = wizlight(&[command, "--help"]);
assert_eq!(output.status.code(), Some(0), "{command}");
let help = String::from_utf8(output.stdout).expect("utf-8");
assert!(help.contains("Examples:"), "{command}: {help}");
assert!(
help.contains(&format!("wizlight {command}")),
"{command}: {help}"
);
}
}
#[test]
fn every_command_and_flag_has_help_text() {
fn check(command: &clap::Command) {
assert!(
command.get_about().is_some(),
"{} has no about",
command.get_name()
);
for argument in command.get_arguments() {
assert!(
argument.get_help().is_some(),
"{} {} has no help",
command.get_name(),
argument.get_id()
);
}
for subcommand in command.get_subcommands() {
check(subcommand);
}
}
check(&Cli::command());
}
#[test]
fn completions_generate_for_every_supported_shell_with_scene_hints() {
for scene in Scene::all() {
let hint = scene.name().to_ascii_lowercase().replace(' ', "-");
Cli::try_parse_from(["wizlight", "on", "192.168.0.5", "--scene", &hint])
.unwrap_or_else(|error| panic!("completion `{hint}` does not parse: {error}"));
}
for shell in ["bash", "zsh", "fish", "powershell", "elvish"] {
let output = wizlight(&["completions", shell]);
assert_eq!(output.status.code(), Some(0), "{shell}");
assert!(output.stderr.is_empty(), "{shell}: {:?}", output.stderr);
let script = String::from_utf8(output.stdout).expect("utf-8");
assert!(script.contains("wizlight"), "{shell}: {script}");
if matches!(shell, "bash" | "zsh" | "fish") {
assert!(
script.contains("deep-dive"),
"scene hints missing from {shell}"
);
}
}
}
#[test]
fn version_reports_the_crate_version() {
let expected = format!("wizlight {}", env!("CARGO_PKG_VERSION"));
for flag in ["--version", "-V"] {
let output = wizlight(&[flag]);
assert_eq!(output.status.code(), Some(0), "{flag}");
let stdout = String::from_utf8(output.stdout).expect("utf-8");
assert_eq!(stdout.trim(), expected, "{flag}");
}
}
#[test]
fn version_does_not_need_a_subcommand() {
assert_eq!(wizlight(&["--version"]).status.code(), Some(0));
}
#[test]
fn the_command_tree_is_internally_consistent() {
Cli::command().debug_assert();
}
#[test]
fn verbosity_controls_the_log_output() {
let quiet = String::from_utf8(scan(&["discover"]).stderr).expect("utf-8");
assert!(
!quiet.contains("parsed invocation"),
"logs at the default level: {quiet}"
);
let loud =
String::from_utf8(scan(&["-vv", "--timeout", "9", "discover"]).stderr).expect("utf-8");
assert!(loud.contains("parsed invocation"), "{loud}");
assert!(loud.contains("timeout=9s"), "{loud}");
}
#[test]
fn rust_log_overrides_the_verbosity_flag() {
let output = scan_with_env(&["discover"], "RUST_LOG", "debug");
let stderr = String::from_utf8(output.stderr).expect("utf-8");
assert!(stderr.contains("parsed invocation"), "{stderr}");
}
#[test]
fn logging_never_lands_on_stdout() {
let stdout = String::from_utf8(scan(&["-vvv", "--json", "discover"]).stdout).expect("utf-8");
let value: Value = serde_json::from_str(stdout.trim()).expect("stdout is only the payload");
assert_eq!(value["command"], "discover");
}
#[test]
fn output_is_not_coloured_when_it_is_not_going_to_a_terminal() {
let stderr = String::from_utf8(scan(&["-vv", "discover"]).stderr).expect("utf-8");
assert!(stderr.contains("parsed invocation"), "{stderr}");
assert!(
!stderr.contains('\x1b'),
"ANSI escape in a pipe: {stderr:?}"
);
}
#[test]
fn no_color_suppresses_colour() {
let output = scan_with_env(&["-vv", "discover"], "NO_COLOR", "1");
let stderr = String::from_utf8(output.stderr).expect("utf-8");
assert!(!stderr.contains('\x1b'), "{stderr:?}");
}