#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn invalid_status_frame_does_not_partially_mutate_device() {
        let client = GreeClient::new(
            "test-controller".into(),
            None,
            None,
            Arc::new(AtomicBool::new(false)),
        );
        let mut device = Device::simulated_default();
        device.power = true;
        device.mode = "heat".into();
        device.target_temperature = 24.0;
        let before = device.clone();

        let response = json!({
            "cols": ["Pow", "Mod", "SetTem"],
            "dat": [0, null, "not-a-number"]
        });
        assert!(client.apply_status(&mut device, &response).is_err());
        assert_eq!(device.power, before.power);
        assert_eq!(device.mode, before.mode);
        assert_eq!(device.target_temperature, before.target_temperature);
    }

    #[test]
    fn thermostat_standby_setpoint_low_fan_quiet_and_sleep_share_one_frame() {
        let payload = GreeClient::command_payload(
            &DeviceCommand {
                target_temperature: Some(19.0),
                fan_speed: Some(1),
                quiet: Some(true),
                sleep: Some(true),
                ..DeviceCommand::default()
            },
            false,
            1,
        )
        .expect("thermostat command payload");

        assert_eq!(
            payload.get("opt").cloned(),
            Some(serde_json::json!(["SetTem", "WdSpd", "Quiet", "SwhSlp"]))
        );
        assert_eq!(
            payload.get("p").cloned(),
            Some(serde_json::json!([19, 1, 1, 1]))
        );
    }

    #[test]
    fn quiet_status_accepts_multistate_value_and_remembers_wire_mode() {
        let client = GreeClient::new(
            "test-controller".into(),
            None,
            None,
            Arc::new(AtomicBool::new(false)),
        );
        let mut device = Device::simulated_default();
        device.quiet = false;
        device.quiet_wire_value = None;

        let response = json!({
            "cols": ["Pow", "Quiet"],
            "dat": [1, 2]
        });
        client
            .apply_status(&mut device, &response)
            .expect("Quiet=2 status");

        assert!(device.power);
        assert!(device.quiet);
        assert_eq!(device.quiet_wire_value, Some(2));
        assert_eq!(device.supports_quiet, Some(true));
    }

    #[test]
    fn quiet_command_can_preserve_learned_wire_mode() {
        let payload = GreeClient::command_payload(
            &DeviceCommand {
                quiet: Some(true),
                ..DeviceCommand::default()
            },
            false,
            2,
        )
        .expect("quiet command payload");

        assert_eq!(
            payload.get("opt").cloned(),
            Some(serde_json::json!(["Quiet"]))
        );
        assert_eq!(payload.get("p").cloned(), Some(serde_json::json!([2])));
    }

    #[test]
    fn optional_multistate_feature_does_not_reject_whole_status() {
        let client = GreeClient::new(
            "test-controller".into(),
            None,
            None,
            Arc::new(AtomicBool::new(false)),
        );
        let mut device = Device::simulated_default();

        let response = json!({
            "cols": ["Pow", "Air"],
            "dat": [1, 3]
        });
        client
            .apply_status(&mut device, &response)
            .expect("Air=3 status");

        assert!(device.power);
        assert!(device.air);
        assert_eq!(device.supports_air, Some(true));
    }
}