beffroi-tools/crates/canvas-pilot/tests/device.rs

356 lines
14 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

use canvas_pilot::device::Snapshot;
use serde_json::{Value, json};
fn fixture() -> (Value, Value) {
let layer = json!({"position":{"pp":{"posH":1436,"posV":540}},"size":{"pp":{"sizeH":967,"sizeV":544}},"source":{"pp":{"input":"INPUT_4"}},"crop":{"pp":{"left":0,"right":0,"top":0,"bottom":0}},"mask":{"pp":{"left":0,"right":0,"top":0,"bottom":0}}});
let screen = json!({
"canvas": {"status": {"size": {"pp": {"sizeH": 1920, "sizeV": 1080}}}},
"presetList": {"items": {"UP": {"liveLayerList": {"items": {"1": layer}}}}}
});
let raw = json!({"device": {
"preconfig":{"status":{"stateList":{"items":{"CURRENT":{"screenList":{"items":{"2":{"pp":{"layerCount":2}}}}}}}}},
"transition": {"screenList": {"items": {"2": {"status": {"pp": {"transition": "AT_DOWN"}}}}}},
"screenList": {"items": {"2": screen}}
}});
(
json!({"type":"Eikos 4K","version":{"major":3,"minor":3,"patch":10}}),
raw,
)
}
#[test]
fn preview_read_retains_half_pixels_and_maps_source_label() {
let (identity, raw) = fixture();
let snapshot = Snapshot::parse(&identity, &raw).unwrap();
assert_eq!(snapshot.identity, "Eikos 4K · firmware 3.3.10");
let screen = &snapshot.screens[0];
assert_eq!(screen.preview_bank, "UP");
let doc = screen.import(&[0]).unwrap();
assert_eq!(doc.shapes[0].geometry.x, 952.5);
assert_eq!(doc.shapes[0].geometry.y, 268.0);
assert!(doc.shapes[0].id.contains("INPUT_4"));
assert!(screen.import(&[]).is_err());
assert!(screen.import(&[0, 0]).is_err());
assert!(screen.import(&[9]).is_err());
}
#[test]
fn reject_transition_and_missing_preview_without_falling_back_to_program() {
let (identity, mut raw) = fixture();
let state = "/device/transition/screenList/items/2/status/pp/transition";
*raw.pointer_mut(state).unwrap() = json!("EFFECT_FROM_DOWN");
assert!(
Snapshot::parse(&identity, &raw)
.unwrap_err()
.contains("transitioning")
);
*raw.pointer_mut(state).unwrap() = json!("AT_UP");
assert!(Snapshot::parse(&identity, &raw).is_err());
let up = raw
.pointer("/device/screenList/items/2/presetList/items/UP")
.unwrap()
.clone();
raw["device"]["screenList"]["items"]["2"]["presetList"]["items"]["DOWN"] = up;
assert_eq!(
Snapshot::parse(&identity, &raw).unwrap().screens[0].preview_bank,
"DOWN"
);
}
#[test]
fn unsupported_framing_is_visible_but_not_importable() {
let (identity, mut raw) = fixture();
raw["device"]["screenList"]["items"]["2"]["presetList"]["items"]["UP"]["liveLayerList"]["items"]
["1"]["crop"]["pp"]["left"] = json!(18350);
let s = Snapshot::parse(&identity, &raw).unwrap();
assert_eq!(s.screens[0].layers.len(), 1);
assert!(s.screens[0].import(&[0]).unwrap_err().contains("crop"));
}
#[test]
fn malformed_device_state_fails_before_import() {
let (mut identity, mut raw) = fixture();
identity["type"] = json!("different device");
assert!(Snapshot::parse(&identity, &raw).is_err());
identity["type"] = json!("Eikos 4K");
raw["device"]["screenList"]["items"]["2"]["canvas"]["status"]["size"]["pp"]["sizeH"] =
json!(1920.5);
assert!(Snapshot::parse(&identity, &raw).is_err());
assert!(canvas_pilot::device::fetch("http://localhost/").is_err());
}
#[test]
fn disabled_screen_slots_are_ignored() {
let (identity, mut raw) = fixture();
let mut disabled = raw["device"]["screenList"]["items"]["2"].clone();
disabled["canvas"]["status"]["size"]["pp"] = json!({"sizeH":0,"sizeV":0});
raw["device"]["screenList"]["items"]["3"] = disabled;
raw["device"]["transition"]["screenList"]["items"]["3"] =
json!({"status":{"pp":{"transition":"AT_DOWN"}}});
assert_eq!(Snapshot::parse(&identity, &raw).unwrap().screens.len(), 1);
}
#[test]
fn mapped_import_ignores_selection_and_undoes_new_layers_together() {
let mut layout = canvas_pilot::Layout::default();
layout.select(None);
let before = layout.layers().clone();
let id = layout.layer_info(0).id;
let geometry = canvas_pilot::Geometry {
x: 12.5,
y: 27.0,
width: 945.0,
height: 531.58,
};
layout
.import_mapped_layers(&[(Some(id), geometry), (None, geometry), (None, geometry)])
.unwrap();
assert_eq!(layout.layers().len(), 4);
assert_eq!(layout.layers()[0], geometry);
let new_id = layout.layer_info(3).id;
layout.undo();
assert_eq!(*layout.layers(), before);
layout.redo();
assert_eq!(layout.layers().len(), 4);
assert_eq!(layout.layer_info(3).id, new_id);
let added = layout.add_layer().unwrap();
assert!(layout.layer_info(added).id > new_id);
}
#[test]
fn invalid_mapping_never_partially_imports() {
let mut layout = canvas_pilot::Layout::default();
let before = layout.layers().clone();
let geometry = before[1];
let id = layout.layer_info(0).id;
for values in [
vec![],
vec![(None, geometry), (Some(999), geometry)],
vec![(Some(id), geometry), (Some(id), geometry)],
] {
assert!(layout.import_mapped_layers(&values).is_err());
assert_eq!(*layout.layers(), before);
}
layout.set_locked(0, true);
assert!(
layout
.import_mapped_layers(&[(None, geometry), (Some(id), geometry)])
.is_err()
);
assert_eq!(*layout.layers(), before);
layout.set_locked(0, false);
layout.set_visible(0, false);
assert!(
layout
.import_mapped_layers(&[(Some(id), geometry)])
.is_err()
);
}
#[test]
fn existing_layers_remain_available_without_source_assignment() {
let (identity, mut raw) = fixture();
let entries = raw
.pointer_mut("/device/screenList/items/2/presetList/items/UP/liveLayerList/items")
.unwrap();
entries["1"]["status"] = json!({"pp": {"state": "OFF"}});
entries["2"] = entries["1"].clone();
entries["2"]["crop"]["pp"]["aspectOverride"] = json!("CENTERED");
entries["2"]["status"]["pp"]["contentWidth"] = json!(0);
entries["2"]["status"]["pp"]["contentHeight"] = json!(0);
for input in [json!("NONE"), json!(""), Value::Null] {
raw["device"]["screenList"]["items"]["2"]["presetList"]["items"]["UP"]["liveLayerList"]["items"]
["2"]["source"]["pp"]["input"] = input;
let snapshot = Snapshot::parse(&identity, &raw).unwrap();
let screen = &snapshot.screens[0];
assert_eq!(screen.layers.len(), 2);
assert!(screen.layers.iter().all(|l| l.unsupported.is_none()));
assert_eq!(screen.import(&[0, 1]).unwrap().shapes.len(), 2);
}
}
#[test]
fn allocation_filters_firmware_slots_independently_of_input_routing() {
let (identity, mut raw) = fixture();
let entries = raw
.pointer_mut("/device/screenList/items/2/presetList/items/UP/liveLayerList/items")
.unwrap();
for id in 2..=8 {
entries[id.to_string()] = entries["1"].clone();
}
// Ignore staged NEW configuration and use only the active CURRENT allocation.
raw["device"]["preconfig"]["status"]["stateList"]["items"]["NEW"] =
json!({"screenList":{"items":{"2":{"pp":{"layerCount":8}}}}});
for count in [0, 1, 2] {
raw["device"]["preconfig"]["status"]["stateList"]["items"]["CURRENT"]["screenList"]["items"]
["2"]["pp"]["layerCount"] = json!(count);
let snapshot = Snapshot::parse(&identity, &raw).unwrap();
assert_eq!(snapshot.screens[0].layers.len(), count);
assert!(
snapshot.screens[0]
.layers
.iter()
.all(|l| l.id.parse::<usize>().unwrap() <= count)
);
}
for invalid in [Value::Null, json!(-1), json!(2.5), json!(9)] {
raw["device"]["preconfig"]["status"]["stateList"]["items"]["CURRENT"]["screenList"]["items"]
["2"]["pp"]["layerCount"] = invalid;
assert!(Snapshot::parse(&identity, &raw).is_err());
}
}
#[test]
fn all_midra_4k_models_use_reported_layer_allocations() {
let (mut identity, raw) = fixture();
let expected = Snapshot::parse(&identity, &raw).unwrap();
for model in ["Eikos 4K", "Pulse 4K", "QuickVu 4K", "QuickMatrix 4K"] {
identity["type"] = json!(model);
let parsed = Snapshot::parse(&identity, &raw).unwrap();
assert!(parsed.identity.starts_with(model));
assert_eq!(parsed.screens.len(), expected.screens.len());
for (actual, expected) in parsed.screens.iter().zip(&expected.screens) {
assert_eq!(actual.layers.len(), expected.layers.len());
assert_eq!(actual.resolution, expected.resolution);
}
}
}
#[test]
fn device_addresses_support_ports_and_ipv6() {
use canvas_pilot::device::address;
for (input, expected) in [
("192.168.10.146", "192.168.10.146:80"),
(" 192.168.10.146:3000 ", "192.168.10.146:3000"),
("::1", "[::1]:80"),
("[::1]:3000", "[::1]:3000"),
] {
assert_eq!(address(input).unwrap().to_string(), expected);
}
for input in [
"",
"localhost",
"http://127.0.0.1:3000",
"127.0.0.1:0",
"127.0.0.1:65536",
"127.0.0.1:abc",
"127.0.0.1:3000/path",
] {
assert!(address(input).is_err(), "{input}");
}
}
#[test]
fn fetch_uses_custom_port_for_identity_and_state() {
use std::io::{BufRead, BufReader, Write};
let (identity, raw) = fixture();
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let host = listener.local_addr().unwrap().to_string();
let server = std::thread::spawn(move || {
for (path, payload) in [
("/api/tpp/v1/system", identity),
("/api/stores/device", raw),
] {
let (mut stream, _) = listener.accept().unwrap();
stream
.set_read_timeout(Some(std::time::Duration::from_secs(5)))
.unwrap();
let mut reader = BufReader::new(stream.try_clone().unwrap());
let mut line = String::new();
reader.read_line(&mut line).unwrap();
assert_eq!(line, format!("GET {path} HTTP/1.1\r\n"));
loop {
line.clear();
reader.read_line(&mut line).unwrap();
if line == "\r\n" {
break;
}
}
let body = payload.to_string();
write!(
stream,
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
)
.unwrap();
}
});
let result = canvas_pilot::device::fetch(&host);
server.join().unwrap();
assert!(result.unwrap().identity.starts_with("Eikos 4K"));
}
#[test]
fn fractional_device_content_rounds_with_a_nonblocking_warning() {
let (identity, mut raw) = fixture();
let path = "/device/screenList/items/2/presetList/items/UP/liveLayerList/items/1";
let layer = raw.pointer_mut(path).unwrap();
layer["crop"]["pp"]["aspectOverride"] = json!("CENTERED");
layer["crop"]["pp"]["left"] = json!(500);
layer["status"] = json!({"pp":{"contentWidth":1919.7,"contentHeight":1080.2}});
let state = Snapshot::parse(&identity, &raw).unwrap();
let layer = &state.screens[0].layers[0];
assert!(layer.unsupported.is_none());
assert_eq!(layer.framing.unwrap().0.native, [1920, 1080]);
assert!(
layer
.warning
.as_ref()
.unwrap()
.contains("1919.7 × 1080.2 to 1920 × 1080")
);
assert!(state.screens[0].import(&[0]).is_ok());
assert_eq!(state.raw, raw, "Keep the original device snapshot intact");
for width in [0.5, 16384.1, 20000.0] {
raw.pointer_mut(path).unwrap()["status"]["pp"]["contentWidth"] = json!(width);
let invalid = Snapshot::parse(&identity, &raw).unwrap();
assert!(invalid.screens[0].layers[0].unsupported.is_some());
assert!(invalid.screens[0].import(&[0]).is_err());
}
raw.pointer_mut(path).unwrap()["status"]["pp"] =
json!({"contentWidth":1920,"contentHeight":1080});
assert!(
Snapshot::parse(&identity, &raw).unwrap().screens[0].layers[0]
.warning
.is_none()
);
}
#[test]
fn unsupported_aquilon_profile_is_rejected_before_requesting_large_state() {
use std::io::{BufRead, BufReader, Write};
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let host = listener.local_addr().unwrap().to_string();
let server = std::thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
let mut reader = BufReader::new(stream.try_clone().unwrap());
let mut line = String::new();
reader.read_line(&mut line).unwrap();
assert_eq!(line, "GET /api/tpp/v1/system HTTP/1.1\r\n");
loop {
line.clear();
reader.read_line(&mut line).unwrap();
if line == "\r\n" {
break;
}
}
let body =
r#"{"type":"AQL Cmax","isLinked":false,"version":{"major":5,"minor":2,"patch":79}}"#;
write!(
stream,
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
)
.unwrap();
listener
});
let error = canvas_pilot::device::fetch(&host).unwrap_err();
let listener = server.join().unwrap();
assert!(error.contains("Unsupported Aquilon profile"), "{error}");
assert!(error.contains("6.2.x"), "{error}");
listener.set_nonblocking(true).unwrap();
assert_eq!(
listener.accept().unwrap_err().kind(),
std::io::ErrorKind::WouldBlock
);
assert!(
Snapshot::parse(&json!({"type":"AQL Cmax"}), &json!({}))
.unwrap_err()
.contains("Missing device field")
);
}