use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
use std::path::PathBuf;
use crate::serial::{PortInfo, PortTransport};
pub const MAX_PROFILE_REVISIONS: usize = 5;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum IdentityConfidence {
High,
Medium,
Low,
None,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ProfilePersistenceState {
Persisted,
NotNeeded,
Transient,
Failed,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ProfilePersistenceOperation {
OpenOverride,
Learned,
CloseSnapshot,
Rollback,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct ProfilePersistenceResult {
pub state: ProfilePersistenceState,
pub operation: ProfilePersistenceOperation,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub profile_name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(schema_with = "crate::schema_helpers::option_uint_schema")]
pub revision: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ProfileSelectionSource {
Automatic,
Explicit,
Generated,
Transient,
Disabled,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct ProfileSessionResult {
pub profile_name: String,
pub source: ProfileSelectionSource,
pub confidence: IdentityConfidence,
pub persistent: bool,
pub generated: bool,
#[schemars(schema_with = "crate::schema_helpers::option_uint_schema")]
pub revision: Option<u64>,
pub dirty: bool,
pub stale: bool,
pub candidates: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_persistence_error: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ProfileMode {
Auto,
None,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct HighIdentity {
pub transport: String,
pub vid: u16,
pub pid: u16,
pub serial_number: String,
pub interface: Option<u8>,
}
pub fn high_identity(port: &PortInfo) -> Option<HighIdentity> {
if port.transport != PortTransport::Usb {
return None;
}
let vid = port.vid?;
let pid = port.pid?;
let serial_number = port
.serial_number
.as_deref()
.filter(|s| !s.is_empty())?
.to_string();
Some(HighIdentity {
transport: port.transport.to_string(),
vid,
pid,
serial_number,
interface: port.interface,
})
}
pub fn identity_confidence(port: &PortInfo) -> IdentityConfidence {
if port.transport == PortTransport::Usb
&& port.vid.is_some()
&& port.pid.is_some()
&& port.serial_number.as_deref().is_some_and(|s| !s.is_empty())
{
return IdentityConfidence::High;
}
if port.transport == PortTransport::Usb && port.vid.is_some() && port.pid.is_some() {
return IdentityConfidence::Medium;
}
let has_any_identity = port.vid.is_some()
|| port.pid.is_some()
|| port.serial_number.as_deref().is_some_and(|s| !s.is_empty())
|| port.manufacturer.is_some()
|| port.product.is_some()
|| port.interface.is_some()
|| port.hardware_id.is_some();
if has_any_identity {
IdentityConfidence::Low
} else {
IdentityConfidence::None
}
}
pub fn canonical_high_selector(port: &PortInfo) -> Option<ProfileSelector> {
let id = high_identity(port)?;
Some(ProfileSelector {
vid: Some(id.vid),
pid: Some(id.pid),
serial_number: Some(id.serial_number),
manufacturer: None,
product: None,
interface: id.interface,
port_pattern: None,
description_pattern: None,
transport: Some(id.transport),
hardware_id: None,
})
}
pub fn selector_matches_high_identity(selector: &ProfileSelector, id: &HighIdentity) -> bool {
selector.transport.as_deref() == Some(id.transport.as_str())
&& selector.vid == Some(id.vid)
&& selector.pid == Some(id.pid)
&& selector.serial_number.as_deref() == Some(id.serial_number.as_str())
&& id
.interface
.is_none_or(|iface| selector.interface == Some(iface))
}
pub fn rank_candidates(mut candidates: Vec<Profile>) -> Vec<Profile> {
candidates.sort_by(|a, b| {
let a_ts = a.metadata.last_used_at_ms.unwrap_or(0);
let b_ts = b.metadata.last_used_at_ms.unwrap_or(0);
b_ts.cmp(&a_ts)
});
candidates
}
pub fn normalize_generated_label(label: &str) -> String {
let mut out = String::new();
let mut pending_sep = false;
for c in label.chars() {
if c.is_ascii_alphanumeric() {
if pending_sep && !out.is_empty() {
out.push('-');
}
pending_sep = false;
out.push(c.to_ascii_lowercase());
} else {
pending_sep = true;
}
}
let out = out.trim_matches('-');
let capped: String = out.chars().take(32).collect();
let capped = capped.trim_end_matches('-');
if capped.is_empty() {
"serial-device".to_string()
} else {
capped.to_string()
}
}
pub fn allocate_generated_name(existing: &[Profile], base: &str) -> String {
let taken: HashSet<&str> = existing.iter().map(|p| p.name.as_str()).collect();
if !taken.contains(base) {
return base.to_string();
}
let mut suffix = 2u32;
loop {
let candidate = format!("{base}-{suffix}");
if !taken.contains(candidate.as_str()) {
return candidate;
}
suffix += 1;
}
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct Profile {
pub name: String,
#[serde(default)]
pub selector: ProfileSelector,
#[serde(default)]
pub defaults: ProfileDefaults,
#[serde(default)]
pub metadata: ProfileMetadata,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub revisions: Vec<ProfileRevision>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
pub struct ProfileMetadata {
pub generated: bool,
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
pub revision: u64,
#[schemars(schema_with = "crate::schema_helpers::option_uint_schema")]
pub created_at_ms: Option<u64>,
#[schemars(schema_with = "crate::schema_helpers::option_uint_schema")]
pub updated_at_ms: Option<u64>,
#[schemars(schema_with = "crate::schema_helpers::option_uint_schema")]
pub last_used_at_ms: Option<u64>,
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
pub use_count: u64,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct ProfileRevision {
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
pub revision: u64,
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
pub saved_at_ms: u64,
pub selector: ProfileSelector,
pub defaults: ProfileDefaults,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, JsonSchema)]
pub struct ProfileSelector {
#[schemars(schema_with = "crate::schema_helpers::option_uint_schema")]
pub vid: Option<u16>,
#[schemars(schema_with = "crate::schema_helpers::option_uint_schema")]
pub pid: Option<u16>,
pub serial_number: Option<String>,
pub manufacturer: Option<String>,
pub product: Option<String>,
#[schemars(schema_with = "crate::schema_helpers::option_uint_schema")]
pub interface: Option<u8>,
pub port_pattern: Option<String>,
pub description_pattern: Option<String>,
pub transport: Option<String>,
pub hardware_id: Option<String>,
}
impl ProfileSelector {
pub fn is_empty(&self) -> bool {
self.vid.is_none()
&& self.pid.is_none()
&& self.serial_number.is_none()
&& self.manufacturer.is_none()
&& self.product.is_none()
&& self.interface.is_none()
&& self.port_pattern.is_none()
&& self.description_pattern.is_none()
&& self.transport.is_none()
&& self.hardware_id.is_none()
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
pub struct ProfileDefaults {
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
#[serde(default = "default_baud")]
pub baud_rate: u32,
#[serde(default = "default_data_bits")]
pub data_bits: String,
#[serde(default = "default_stop_bits")]
pub stop_bits: String,
#[serde(default = "default_parity")]
pub parity: String,
#[serde(default = "default_flow_control")]
pub flow_control: String,
pub name: Option<String>,
#[serde(default)]
pub tx_framing: Option<crate::framing::TxFramingConfig>,
#[serde(default)]
pub rx_framing: Option<crate::framing::RxFramingConfig>,
#[serde(default)]
pub rx_parser: Option<crate::framing::ParserConfig>,
#[serde(default)]
pub protocol: Option<crate::framing::ProtocolPreset>,
#[serde(default = "default_rx_buffer_size_profile")]
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
pub rx_buffer_size: usize,
#[serde(default = "default_max_buffered_bytes_profile")]
#[schemars(schema_with = "crate::schema_helpers::read_max_buffered_bytes_schema")]
pub max_buffered_bytes: usize,
#[serde(default)]
pub reconnect_policy: crate::serial::ReconnectPolicy,
#[serde(default = "default_log_capacity_profile")]
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
pub log_capacity: usize,
#[serde(default = "default_true_profile")]
pub log_enabled: bool,
}
fn default_baud() -> u32 {
115200
}
fn default_data_bits() -> String {
"8".into()
}
fn default_stop_bits() -> String {
"1".into()
}
fn default_parity() -> String {
"none".into()
}
fn default_flow_control() -> String {
"none".into()
}
fn default_rx_buffer_size_profile() -> usize {
crate::limits::DEFAULT_RX_BUFFER_SIZE
}
fn default_max_buffered_bytes_profile() -> usize {
32768
}
fn default_log_capacity_profile() -> usize {
1024
}
fn default_true_profile() -> bool {
true
}
impl Default for ProfileDefaults {
fn default() -> Self {
Self {
baud_rate: default_baud(),
data_bits: default_data_bits(),
stop_bits: default_stop_bits(),
parity: default_parity(),
flow_control: default_flow_control(),
name: None,
tx_framing: None,
rx_framing: None,
rx_parser: None,
protocol: None,
rx_buffer_size: default_rx_buffer_size_profile(),
max_buffered_bytes: default_max_buffered_bytes_profile(),
reconnect_policy: crate::serial::ReconnectPolicy::default(),
log_capacity: default_log_capacity_profile(),
log_enabled: default_true_profile(),
}
}
}
impl Profile {
pub fn matches(&self, port: &PortInfo) -> bool {
let s = &self.selector;
if let Some(vid) = s.vid {
if port.vid != Some(vid) {
return false;
}
}
if let Some(pid) = s.pid {
if port.pid != Some(pid) {
return false;
}
}
if let Some(ref want) = s.serial_number {
if port.serial_number.as_deref() != Some(want.as_str()) {
return false;
}
}
if let Some(ref want) = s.manufacturer {
if port.manufacturer.as_deref() != Some(want.as_str()) {
return false;
}
}
if let Some(ref want) = s.product {
if port.product.as_deref() != Some(want.as_str()) {
return false;
}
}
if let Some(iface) = s.interface {
if port.interface != Some(iface) {
return false;
}
}
if let Some(ref pattern) = s.port_pattern {
if !glob::Pattern::new(pattern)
.map(|p| p.matches(&port.name))
.unwrap_or(false)
{
return false;
}
}
if let Some(ref pattern) = s.description_pattern {
if !glob::Pattern::new(pattern)
.map(|p| p.matches(&port.description))
.unwrap_or(false)
{
return false;
}
}
if let Some(ref want) = s.transport {
if port.transport.to_string().as_str() != want.as_str() {
return false;
}
}
if let Some(ref want) = s.hardware_id {
if port.hardware_id.as_deref() != Some(want.as_str()) {
return false;
}
}
true
}
}
pub fn default_profiles_path() -> Result<PathBuf, String> {
let dir = dirs::config_dir().ok_or_else(|| {
"OS user config directory is unavailable; pass --profiles-path".to_string()
})?;
Ok(dir.join("serial-mcp").join("profiles.toml"))
}
#[cfg(test)]
mod tests {
use super::*;
fn make_port(name: &str, vid: Option<u16>, pid: Option<u16>, serial: Option<&str>) -> PortInfo {
PortInfo {
name: name.into(),
display_name: name.rsplit('/').next().unwrap_or(name).into(),
description: "Test Port".into(),
hardware_id: None,
transport: crate::serial::PortTransport::Usb,
vid,
pid,
serial_number: serial.map(str::to_string),
manufacturer: None,
product: None,
interface: None,
}
}
#[test]
fn empty_selector_matches_any_port() {
let p = Profile {
name: "any".into(),
selector: ProfileSelector::default(),
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata::default(),
revisions: Vec::new(),
};
assert!(p.matches(&make_port("/dev/ttyUSB0", Some(0x1234), Some(0x5678), None)));
assert!(p.matches(&make_port("/dev/ttyACM0", None, None, None)));
}
#[test]
fn empty_selector_is_detected() {
assert!(ProfileSelector::default().is_empty());
assert!(!ProfileSelector {
vid: Some(0x1234),
..Default::default()
}
.is_empty());
assert!(!ProfileSelector {
port_pattern: Some("/dev/ttyACM*".into()),
..Default::default()
}
.is_empty());
assert!(!ProfileSelector {
transport: Some("usb".into()),
..Default::default()
}
.is_empty());
}
#[test]
fn exact_vid_pid_match() {
let p = Profile {
name: "my-device".into(),
selector: ProfileSelector {
vid: Some(0x1234),
pid: Some(0x5678),
..Default::default()
},
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata::default(),
revisions: Vec::new(),
};
assert!(p.matches(&make_port("/dev/ttyUSB0", Some(0x1234), Some(0x5678), None)));
assert!(!p.matches(&make_port("/dev/ttyUSB0", Some(0xAAAA), Some(0x5678), None)));
assert!(!p.matches(&make_port("/dev/ttyUSB0", None, None, None)));
}
#[test]
fn serial_number_match() {
let p = Profile {
name: "by-serial".into(),
selector: ProfileSelector {
serial_number: Some("0001".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata::default(),
revisions: Vec::new(),
};
assert!(p.matches(&make_port("/dev/ttyUSB0", None, None, Some("0001"))));
assert!(!p.matches(&make_port("/dev/ttyUSB0", None, None, Some("0002"))));
assert!(!p.matches(&make_port("/dev/ttyUSB0", None, None, None)));
}
#[test]
fn port_pattern_glob_match() {
let p = Profile {
name: "acm-only".into(),
selector: ProfileSelector {
port_pattern: Some("/dev/ttyACM*".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata::default(),
revisions: Vec::new(),
};
assert!(p.matches(&make_port("/dev/ttyACM0", None, None, None)));
assert!(!p.matches(&make_port("/dev/ttyUSB0", None, None, None)));
}
#[test]
fn multiple_fields_all_must_match() {
let p = Profile {
name: "specific".into(),
selector: ProfileSelector {
vid: Some(0x1234),
serial_number: Some("0001".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata::default(),
revisions: Vec::new(),
};
assert!(p.matches(&make_port(
"/dev/ttyUSB0",
Some(0x1234),
Some(0x9999),
Some("0001")
)));
assert!(!p.matches(&make_port(
"/dev/ttyUSB0",
Some(0x1234),
Some(0x9999),
Some("0002")
)));
assert!(!p.matches(&make_port(
"/dev/ttyUSB0",
Some(0xAAAA),
Some(0x9999),
Some("0001")
)));
}
#[test]
fn manufacturer_match() {
let p = Profile {
name: "by-mfg".into(),
selector: ProfileSelector {
manufacturer: Some("STMicro".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata::default(),
revisions: Vec::new(),
};
let mut port = make_port("/dev/ttyACM0", None, None, None);
port.manufacturer = Some("STMicro".into());
assert!(p.matches(&port));
port.manufacturer = Some("Other".into());
assert!(!p.matches(&port));
}
#[test]
fn product_match() {
let p = Profile {
name: "by-prod".into(),
selector: ProfileSelector {
product: Some("VirtualCom".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata::default(),
revisions: Vec::new(),
};
let mut port = make_port("/dev/ttyACM0", None, None, None);
port.product = Some("VirtualCom".into());
assert!(p.matches(&port));
port.product = Some("Other".into());
assert!(!p.matches(&port));
}
#[test]
fn interface_match() {
let p = Profile {
name: "by-iface".into(),
selector: ProfileSelector {
interface: Some(2),
..Default::default()
},
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata::default(),
revisions: Vec::new(),
};
let mut port = make_port("/dev/ttyACM0", None, None, None);
port.interface = Some(2);
assert!(p.matches(&port));
port.interface = Some(0);
assert!(!p.matches(&port));
}
#[test]
fn description_pattern_match() {
let p = Profile {
name: "by-desc".into(),
selector: ProfileSelector {
description_pattern: Some("*CP210*".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata::default(),
revisions: Vec::new(),
};
let port = PortInfo {
description: "Silicon Labs CP2102 USB to UART Bridge Controller".into(),
..make_port("/dev/ttyUSB0", None, None, None)
};
assert!(p.matches(&port));
assert!(!p.matches(&make_port("/dev/ttyUSB0", None, None, None)));
}
#[test]
fn invalid_glob_pattern_returns_false() {
let p = Profile {
name: "bad-glob".into(),
selector: ProfileSelector {
port_pattern: Some("[unclosed".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata::default(),
revisions: Vec::new(),
};
assert!(!p.matches(&make_port("/dev/ttyUSB0", None, None, None)));
}
#[test]
fn transport_match_usb() {
let p = Profile {
name: "usb-only".into(),
selector: ProfileSelector {
transport: Some("usb".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata::default(),
revisions: Vec::new(),
};
assert!(p.matches(&make_port("/dev/ttyACM0", None, None, None)));
let mut pci_port = make_port("/dev/ttyS0", None, None, None);
pci_port.transport = crate::serial::PortTransport::Pci;
assert!(!p.matches(&pci_port));
}
#[test]
fn transport_match_unknown() {
let p = Profile {
name: "unknown-only".into(),
selector: ProfileSelector {
transport: Some("unknown".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata::default(),
revisions: Vec::new(),
};
let mut unknown_port = make_port("/dev/ttyX", None, None, None);
unknown_port.transport = crate::serial::PortTransport::Unknown;
assert!(p.matches(&unknown_port));
}
#[test]
fn transport_match_case_sensitive() {
let p = Profile {
name: "usb-exact".into(),
selector: ProfileSelector {
transport: Some("USB".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata::default(),
revisions: Vec::new(),
};
assert!(!p.matches(&make_port("/dev/ttyACM0", None, None, None)));
}
#[test]
fn hardware_id_match() {
let p = Profile {
name: "by-hwid".into(),
selector: ProfileSelector {
hardware_id: Some("USB\\VID_1234&PID_5678".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata::default(),
revisions: Vec::new(),
};
let mut port = make_port("/dev/ttyACM0", None, None, None);
port.hardware_id = Some("USB\\VID_1234&PID_5678".into());
assert!(p.matches(&port));
port.hardware_id = Some("USB\\VID_AAAA&PID_BBBB".into());
assert!(!p.matches(&port));
}
#[test]
fn hardware_id_no_match_when_port_has_none() {
let p = Profile {
name: "hwid-required".into(),
selector: ProfileSelector {
hardware_id: Some("USB\\VID_1234&PID_5678".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata::default(),
revisions: Vec::new(),
};
assert!(!p.matches(&make_port("/dev/ttyACM0", None, None, None)));
}
#[test]
fn profile_defaults_has_no_dead_fields() {
let json = serde_json::json!({
"decoder": "y",
"safety_policy": "z"
});
let _: ProfileDefaults =
serde_json::from_value(json).expect("dead fields must be silently ignored");
let value = serde_json::to_value(ProfileDefaults::default())
.expect("ProfileDefaults must serialize");
let obj = value
.as_object()
.expect("serialized ProfileDefaults must be an object");
assert!(!obj.contains_key("decoder"));
assert!(!obj.contains_key("safety_policy"));
}
fn usb_port(name: &str, vid: Option<u16>, pid: Option<u16>, serial: Option<&str>) -> PortInfo {
let mut port = make_port(name, vid, pid, serial);
port.transport = crate::serial::PortTransport::Usb;
port
}
#[test]
fn confidence_tiers() {
let high = usb_port("/dev/ttyACM0", Some(0x1234), Some(0x5678), Some("SN-1"));
assert_eq!(identity_confidence(&high), IdentityConfidence::High);
let empty_serial = usb_port("/dev/ttyACM0", Some(0x1234), Some(0x5678), Some(""));
assert_eq!(
identity_confidence(&empty_serial),
IdentityConfidence::Medium
);
let no_serial = usb_port("/dev/ttyACM0", Some(0x1234), Some(0x5678), None);
assert_eq!(identity_confidence(&no_serial), IdentityConfidence::Medium);
let partial = usb_port("/dev/ttyACM0", None, None, Some("SN-1"));
assert_eq!(identity_confidence(&partial), IdentityConfidence::Low);
let mut pci = make_port("/dev/ttyS0", None, None, None);
pci.transport = crate::serial::PortTransport::Pci;
pci.hardware_id = Some("PCI".into());
assert_eq!(identity_confidence(&pci), IdentityConfidence::Low);
let unknown = make_port("/dev/pts/3", None, None, None);
assert_eq!(identity_confidence(&unknown), IdentityConfidence::None);
}
#[test]
fn high_identity_requires_full_usb_identity() {
let high = usb_port("/dev/ttyACM0", Some(0x1234), Some(0x5678), Some("SN-1"));
assert!(high_identity(&high).is_some());
assert!(
high_identity(&usb_port("/dev/ttyACM0", Some(0x1234), Some(0x5678), None)).is_none()
);
assert!(
high_identity(&usb_port("/dev/ttyACM0", Some(0x1234), None, Some("SN-1"))).is_none()
);
assert!(high_identity(&make_port("/dev/ttyS0", None, None, None)).is_none());
}
#[test]
fn canonical_high_selector_survives_path_change() {
let mut port = usb_port("/dev/ttyACM0", Some(0x1234), Some(0x5678), Some("SN-1"));
port.interface = Some(2);
port.product = Some("Widget".into());
port.manufacturer = Some("Acme".into());
port.hardware_id = Some("USB VID:1234 PID:5678".into());
let selector = canonical_high_selector(&port).expect("high identity selector");
assert_eq!(selector.port_pattern, None);
assert_eq!(selector.description_pattern, None);
assert_eq!(selector.manufacturer, None);
assert_eq!(selector.product, None);
assert_eq!(selector.hardware_id, None);
assert_eq!(selector.vid, Some(0x1234));
assert_eq!(selector.pid, Some(0x5678));
assert_eq!(selector.serial_number.as_deref(), Some("SN-1"));
assert_eq!(selector.interface, Some(2));
assert_eq!(selector.transport.as_deref(), Some("usb"));
let mut same_device = port.clone();
same_device.name = "/dev/ttyACM7".into();
same_device.display_name = "ttyACM7".into();
let selector = canonical_high_selector(&same_device).unwrap();
let id = high_identity(&same_device).unwrap();
assert!(selector_matches_high_identity(&selector, &id));
assert!(Profile {
name: "x".into(),
selector,
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata::default(),
revisions: Vec::new(),
}
.matches(&port));
}
#[test]
fn selector_matches_high_identity_rejects_weak_and_foreign_selectors() {
let id = HighIdentity {
transport: "usb".into(),
vid: 0x1234,
pid: 0x5678,
serial_number: "SN-1".into(),
interface: Some(2),
};
let mut port = usb_port("/dev/ttyACM0", Some(0x1234), Some(0x5678), Some("SN-1"));
port.interface = Some(2);
assert!(selector_matches_high_identity(
&canonical_high_selector(&port).unwrap(),
&id
));
assert!(!selector_matches_high_identity(
&ProfileSelector::default(),
&id
));
let wrong_serial = ProfileSelector {
vid: Some(0x1234),
pid: Some(0x5678),
transport: Some("usb".into()),
serial_number: Some("OTHER".into()),
..Default::default()
};
assert!(!selector_matches_high_identity(&wrong_serial, &id));
let no_interface = ProfileSelector {
vid: Some(0x1234),
pid: Some(0x5678),
transport: Some("usb".into()),
serial_number: Some("SN-1".into()),
..Default::default()
};
assert!(!selector_matches_high_identity(&no_interface, &id));
let no_iface_id = HighIdentity {
interface: None,
..id.clone()
};
assert!(selector_matches_high_identity(&no_interface, &no_iface_id));
}
fn ranked_profile(name: &str, last_used: Option<u64>) -> Profile {
Profile {
name: name.into(),
selector: ProfileSelector::default(),
defaults: ProfileDefaults::default(),
metadata: ProfileMetadata {
last_used_at_ms: last_used,
..Default::default()
},
revisions: Vec::new(),
}
}
#[test]
fn ranking_picks_unique_newest_first_and_none_sorts_oldest() {
let ranked = rank_candidates(vec![
ranked_profile("old", Some(100)),
ranked_profile("never", None),
ranked_profile("new", Some(200)),
]);
let names: Vec<&str> = ranked.iter().map(|p| p.name.as_str()).collect();
assert_eq!(names, vec!["new", "old", "never"]);
}
#[test]
fn ranking_equal_timestamps_tie() {
let ranked = rank_candidates(vec![
ranked_profile("a", Some(500)),
ranked_profile("b", Some(500)),
]);
assert_eq!(ranked.len(), 2);
let top_ts = ranked[0].metadata.last_used_at_ms;
let next_ts = ranked[1].metadata.last_used_at_ms;
assert_eq!(top_ts, next_ts, "equal top timestamps must tie");
}
#[test]
fn generated_label_normalization() {
assert_eq!(
normalize_generated_label("Fake USB Serial"),
"fake-usb-serial"
);
assert_eq!(normalize_generated_label(" Acme Widget "), "acme-widget");
assert_eq!(normalize_generated_label("USB__Port_1"), "usb-port-1");
assert_eq!(normalize_generated_label("---"), "serial-device");
assert_eq!(normalize_generated_label(""), "serial-device");
assert_eq!(normalize_generated_label("ΓnΓ―code"), "n-code");
assert_eq!(normalize_generated_label("A###B"), "a-b");
}
#[test]
fn generated_label_truncation_caps_at_32_and_trims_dash() {
let long = normalize_generated_label(&"x".repeat(60));
assert_eq!(long.len(), 32, "label capped at 32 chars: {long:?}");
let cut_dash = normalize_generated_label(&format!("{}!!!", "a".repeat(30)));
assert_eq!(cut_dash.len(), 30, "cap must not leave a trailing dash");
assert!(!cut_dash.ends_with('-'));
}
#[test]
fn generated_label_usb_vid_pid_fallback() {
assert_eq!(normalize_generated_label("usb-1234-5678"), "usb-1234-5678");
}
#[test]
fn generated_name_allocation_never_overwrites() {
let existing = vec![
ranked_profile("auto-device", None),
ranked_profile("auto-device-2", None),
ranked_profile("auto-device-3", None),
];
assert_eq!(
allocate_generated_name(&existing, "auto-device"),
"auto-device-4"
);
assert_eq!(allocate_generated_name(&[], "auto-fresh"), "auto-fresh");
let with_gap = vec![
ranked_profile("auto-device", None),
ranked_profile("auto-device-2", None),
];
assert_eq!(
allocate_generated_name(&with_gap, "auto-device"),
"auto-device-3"
);
}
}