use serde::{Deserialize, Serialize};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ContentLoadState {
Started,
HeadParsed,
#[default]
Complete,
}
impl ContentLoadState {
pub fn is_interactive(self) -> bool {
matches!(self, Self::HeadParsed | Self::Complete)
}
pub fn is_complete(self) -> bool {
matches!(self, Self::Complete)
}
pub fn persisted_name(self) -> &'static str {
match self {
Self::Started => "started",
Self::HeadParsed => "head-parsed",
Self::Complete => "complete",
}
}
pub fn from_persisted_name(raw: &str) -> Option<Self> {
match raw {
"started" => Some(Self::Started),
"head-parsed" => Some(Self::HeadParsed),
"complete" => Some(Self::Complete),
_ => None,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_is_complete() {
assert_eq!(ContentLoadState::default(), ContentLoadState::Complete);
}
#[test]
fn is_interactive_matches_head_parsed_and_complete() {
assert!(!ContentLoadState::Started.is_interactive());
assert!(ContentLoadState::HeadParsed.is_interactive());
assert!(ContentLoadState::Complete.is_interactive());
}
#[test]
fn is_complete_only_matches_complete() {
assert!(!ContentLoadState::Started.is_complete());
assert!(!ContentLoadState::HeadParsed.is_complete());
assert!(ContentLoadState::Complete.is_complete());
}
#[test]
fn persisted_name_round_trips_all_variants() {
for state in [
ContentLoadState::Started,
ContentLoadState::HeadParsed,
ContentLoadState::Complete,
] {
let name = state.persisted_name();
assert_eq!(
ContentLoadState::from_persisted_name(name),
Some(state),
"persisted_name round-trip failed for {state:?} (name={name})",
);
}
}
#[test]
fn from_persisted_name_rejects_unknown_values() {
assert_eq!(ContentLoadState::from_persisted_name(""), None);
assert_eq!(ContentLoadState::from_persisted_name("Complete"), None); assert_eq!(ContentLoadState::from_persisted_name("loading"), None); }
#[test]
fn persisted_names_are_lowercase_kebab() {
for state in [
ContentLoadState::Started,
ContentLoadState::HeadParsed,
ContentLoadState::Complete,
] {
let name = state.persisted_name();
assert_eq!(
name,
name.to_ascii_lowercase(),
"persisted name {name} must be lowercase"
);
assert!(
!name.contains('_'),
"persisted name {name} must use '-' (kebab), not '_' (snake)"
);
}
}
#[test]
fn serde_json_round_trips_all_variants() {
for state in [
ContentLoadState::Started,
ContentLoadState::HeadParsed,
ContentLoadState::Complete,
] {
let encoded = serde_json::to_string(&state).expect("serialize");
let decoded: ContentLoadState = serde_json::from_str(&encoded).expect("deserialize");
assert_eq!(decoded, state);
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ViewerInstanceId {
Servo(String),
#[doc(hidden)]
Wry(u64),
#[doc(hidden)]
IcedWebview(u64),
#[doc(hidden)]
MiddlenetDirect(u32),
}
impl ViewerInstanceId {
pub fn provider_name(&self) -> &'static str {
match self {
Self::Servo(_) => "servo",
Self::Wry(_) => "wry",
Self::IcedWebview(_) => "iced_webview",
Self::MiddlenetDirect(_) => "middlenet_direct",
}
}
}
#[cfg(test)]
mod viewer_instance_id_tests {
use super::*;
use std::collections::HashSet;
#[test]
fn provider_name_covers_all_variants() {
assert_eq!(
ViewerInstanceId::Servo(String::new()).provider_name(),
"servo"
);
assert_eq!(ViewerInstanceId::Wry(0).provider_name(), "wry");
assert_eq!(
ViewerInstanceId::IcedWebview(0).provider_name(),
"iced_webview"
);
assert_eq!(
ViewerInstanceId::MiddlenetDirect(0).provider_name(),
"middlenet_direct"
);
}
#[test]
fn different_providers_with_same_payload_dont_collide() {
let a = ViewerInstanceId::Wry(0);
let b = ViewerInstanceId::IcedWebview(0);
assert_ne!(a, b);
let mut set = HashSet::new();
set.insert(a);
assert!(!set.contains(&b));
set.insert(b);
assert_eq!(set.len(), 2);
}
#[test]
fn servo_equal_payloads_are_equal() {
let a = ViewerInstanceId::Servo("TEST-ENCODING-1".to_string());
let b = ViewerInstanceId::Servo("TEST-ENCODING-1".to_string());
assert_eq!(a, b);
let c = ViewerInstanceId::Servo("TEST-ENCODING-2".to_string());
assert_ne!(a, c);
}
#[test]
fn hashset_membership_works_across_clone() {
let id = ViewerInstanceId::Servo("MVP-123".to_string());
let mut set = HashSet::new();
set.insert(id.clone());
assert!(set.contains(&id));
assert!(set.contains(&ViewerInstanceId::Servo("MVP-123".to_string())));
set.remove(&ViewerInstanceId::Servo("MVP-123".to_string()));
assert!(set.is_empty());
}
#[test]
fn serde_json_roundtrip_preserves_variant_and_payload() {
let samples = [
ViewerInstanceId::Servo("{encoded-servo-id}".to_string()),
ViewerInstanceId::Wry(42),
ViewerInstanceId::IcedWebview(99),
ViewerInstanceId::MiddlenetDirect(7),
];
for id in samples {
let encoded = serde_json::to_string(&id).expect("serialize");
let decoded: ViewerInstanceId = serde_json::from_str(&encoded).expect("deserialize");
assert_eq!(decoded, id);
}
}
}