From 6ee082673b38ad8286eed7e96ddfa72a2b857fd4 Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Sun, 18 Oct 2026 23:03:26 +0200 Subject: [PATCH] test: qualify M13.3f extended MPRIS actions and persisted editing Verify: dbus-run-session -- cargo test -p fader_master private_bus -- --ignored --nocapture: 2 isolated fake-bus tests passed, including wire units, playlists, capability changes, timeout recovery and unique-owner replacement. cargo test -p fader_master --lib --quiet: 40 passed, 2 opt-in ignored. Save/restart/unbind/delete covered. Clippy -D warnings and formatting passed. --- fader_master/src/local.rs | 101 +++++++++ fader_master/src/media_runtime/native.rs | 250 +++++++++++++++++++++++ 2 files changed, 351 insertions(+) diff --git a/fader_master/src/local.rs b/fader_master/src/local.rs index a78df1b..bdcee14 100644 --- a/fader_master/src/local.rs +++ b/fader_master/src/local.rs @@ -897,6 +897,107 @@ mod tests { use fader_core::{AdapterEvent, ChannelGains, Mute, StreamHandle, StreamMetadata}; use tempfile::tempdir; + #[test] + fn media_draft_save_restart_unbind_and_delete_preserve_active_boundaries() { + let root = tempdir().unwrap(); + let source = include_str!("../../examples/profiles/desktop.toml"); + let path = root.path().join("desktop.toml"); + fs::write(&path, source).unwrap(); + let open = || { + LocalServer::pulse( + root.path().join("control.sock"), + Gain::UNITY, + ProfileDocument::parse(&fs::read_to_string(&path).unwrap()).unwrap(), + path.clone(), + root.path().join("config.toml"), + root.path().join("state.toml"), + ) + .unwrap() + }; + let mut server = open(); + let entry = media::Entry { + id: "qbz".into(), + label: "QBZ".into(), + selector: media::PlayerSelector { + field: media::PlayerField::BusName, + pattern: "org.mpris.MediaPlayer2.com.blitzfc.qbz".into(), + regex: false, + }, + feedback_enabled: false, + controls: vec![media::Control { + id: "play".into(), + action: media::Action::Play, + binding: Some(media::Binding { + surface: "desk-left".into(), + message: media::Message { + kind: media::MessageKind::Note, + channel: 1, + number: 40, + }, + feedback: None, + }), + }], + }; + let edit = |server: &mut LocalServer, edit| { + let response = direct_request( + server, + RequestCommand::EditConfiguration { + expected_revision: server.configuration.revision(), + edit, + }, + ); + assert!( + matches!(response.result, ResponseResult::Snapshot { .. }), + "{response:?}" + ); + }; + let save = |server: &mut LocalServer| { + let response = direct_request( + server, + RequestCommand::SaveConfiguration { + expected_revision: server.configuration.revision(), + }, + ); + assert!( + matches!(response.result, ResponseResult::Snapshot { .. }), + "{response:?}" + ); + }; + edit( + &mut server, + crate::ipc::ConfigurationEdit::SetMediaEntry { + entry: entry.clone(), + }, + ); + assert!(server.active_media.is_empty()); + save(&mut server); + assert_eq!(server.active_media, vec![entry.clone()]); + drop(server); + let mut server = open(); + assert_eq!(server.active_media, vec![entry]); + edit( + &mut server, + crate::ipc::ConfigurationEdit::SetMediaBinding { + entry: "qbz".into(), + control: "play".into(), + binding: None, + }, + ); + assert!(server.active_media[0].controls[0].binding.is_some()); + save(&mut server); + drop(server); + let mut server = open(); + assert!(server.active_media[0].controls[0].binding.is_none()); + edit( + &mut server, + crate::ipc::ConfigurationEdit::RemoveMediaEntry { id: "qbz".into() }, + ); + assert_eq!(server.active_media.len(), 1); + save(&mut server); + drop(server); + assert!(open().active_media.is_empty()); + } + #[test] fn startup_audio_snapshot_is_applied_before_queued_midi_motion() { let profile = fader_config::Profile::parse(include_str!( diff --git a/fader_master/src/media_runtime/native.rs b/fader_master/src/media_runtime/native.rs index 0c213fc..f4f1f5e 100644 --- a/fader_master/src/media_runtime/native.rs +++ b/fader_master/src/media_runtime/native.rs @@ -230,6 +230,256 @@ mod tests { message::MatchRule, }; + #[derive(Default)] + struct ExtendedState { + shuffle: bool, + repeat: String, + position: i64, + active: bool, + deny_seek: bool, + silent: bool, + calls: Vec, + } + + struct Fixture { + state: Arc>, + stop: Arc, + thread: Option>, + } + + impl Fixture { + fn start() -> Self { + let state = Arc::new(Mutex::new(ExtendedState { + repeat: "None".into(), + ..ExtendedState::default() + })); + let owned = state.clone(); + let stop = Arc::new(AtomicBool::new(false)); + let cancelled = stop.clone(); + let (ready, wait) = mpsc::sync_channel(1); + let thread = thread::spawn(move || { + let connection = Connection::new_session().unwrap(); + connection + .request_name( + "org.mpris.MediaPlayer2.extended_fixture", + false, + true, + false, + ) + .unwrap(); + connection.start_receive( + MatchRule::new_method_call(), + Box::new(move |message, connection| { + let mut state = owned.lock().unwrap(); + if state.silent { + return true; + } + let member = message.member().unwrap().to_string(); + let mut reply = message.method_return(); + let playlist = || { + ( + Path::new("/playlist/one").unwrap(), + "Favorites".to_owned(), + String::new(), + ) + }; + match member.as_str() { + "GetAll" => { + let interface: String = message.read1().unwrap(); + let mut props = PropMap::new(); + if interface == ROOT { + props.insert( + "Identity".into(), + Variant(Box::new("Extended fixture".to_owned())), + ); + props.insert( + "DesktopEntry".into(), + Variant(Box::new("extended_fixture".to_owned())), + ); + } else if interface == PLAYER { + props.insert( + "PlaybackStatus".into(), + Variant(Box::new("Paused".to_owned())), + ); + props + .insert("Shuffle".into(), Variant(Box::new(state.shuffle))); + props.insert( + "LoopStatus".into(), + Variant(Box::new(state.repeat.clone())), + ); + props.insert( + "Position".into(), + Variant(Box::new(state.position)), + ); + for key in [ + "CanControl", + "CanPlay", + "CanPause", + "CanGoNext", + "CanGoPrevious", + ] { + props.insert(key.into(), Variant(Box::new(true))); + } + props.insert( + "CanSeek".into(), + Variant(Box::new(!state.deny_seek)), + ); + } else if interface == PLAYLISTS { + props.insert("PlaylistCount".into(), Variant(Box::new(1u32))); + } + reply = reply.append1(props); + } + "Get" => { + let (_, property): (String, String) = message.read2().unwrap(); + reply = match property.as_str() { + "Metadata" => { + let mut metadata = PropMap::new(); + metadata.insert( + "mpris:trackid".into(), + Variant(Box::new(Path::new("/track/one").unwrap())), + ); + metadata.insert( + "mpris:length".into(), + Variant(Box::new(300_000_000i64)), + ); + reply.append1(Variant(metadata)) + } + "Orderings" => { + reply.append1(Variant(vec!["Alphabetical".to_owned()])) + } + "ActivePlaylist" => { + reply.append1(Variant((state.active, playlist()))) + } + _ => panic!("unexpected property {property}"), + }; + } + "GetPlaylists" => { + let (start, count, order, reverse): (u32, u32, String, bool) = + message.read4().unwrap(); + assert_eq!( + (start, count, order.as_str(), reverse), + (0, 1, "Alphabetical", false) + ); + reply = reply.append1(vec![playlist()]); + } + "Set" => { + let (_, property): (String, String) = message.read2().unwrap(); + if property == "Shuffle" { + let (_, _, value): (String, String, Variant) = + message.read3().unwrap(); + state.shuffle = value.0; + } else { + let (_, _, value): (String, String, Variant) = + message.read3().unwrap(); + state.repeat = value.0; + } + state.calls.push(property); + } + "Seek" => { + let offset: i64 = message.read1().unwrap(); + state.position += offset; + state.calls.push(member); + } + "SetPosition" => { + let (track, position): (Path<'static>, i64) = + message.read2().unwrap(); + assert_eq!(track.to_string(), "/track/one"); + state.position = position; + state.calls.push(member); + } + "ActivatePlaylist" => { + let id: Path<'static> = message.read1().unwrap(); + assert_eq!(id.to_string(), "/playlist/one"); + state.active = true; + state.calls.push(member); + } + _ => state.calls.push(member), + } + connection.send(reply).unwrap(); + true + }), + ); + ready.send(()).unwrap(); + while !cancelled.load(Ordering::Acquire) { + connection.process(Duration::from_millis(10)).unwrap(); + } + }); + wait.recv_timeout(Duration::from_secs(2)).unwrap(); + Self { + state, + stop, + thread: Some(thread), + } + } + } + + impl Drop for Fixture { + fn drop(&mut self) { + self.stop.store(true, Ordering::Release); + if let Some(thread) = self.thread.take() { + thread.join().unwrap(); + } + } + } + + #[test] + #[ignore = "run inside dbus-run-session; fake player only"] + fn private_bus_extended_controls_capabilities_timeouts_and_owner_changes() { + let fixture = Fixture::start(); + let mut adapter = DbusAdapter::default(); + let selector = PlayerSelector { + field: media::PlayerField::BusName, + pattern: "org.mpris.MediaPlayer2.extended_fixture".into(), + regex: false, + }; + let matcher = selector.compile().unwrap(); + let initial = adapter.discover().unwrap(); + let player = matcher.resolve(&initial).unwrap().clone(); + assert_eq!(player.duration_ms, Some(300_000)); + assert_eq!(player.playlists[0].name, "Favorites"); + for action in [ + Action::Seek { offset_ms: 5000 }, + Action::Seek { offset_ms: -2000 }, + Action::SetPosition { position_ms: 12000 }, + Action::ShuffleToggle, + Action::RepeatCycle, + Action::Playlist { + id: "/playlist/one".into(), + }, + Action::Next, + Action::Previous, + ] { + execute_selected(&mut adapter, &selector, &action).unwrap(); + } + let observed = adapter.discover().unwrap(); + let observed = matcher.resolve(&observed).unwrap(); + assert_eq!(observed.position_ms, Some(12000)); + assert_eq!(observed.shuffle, Some(true)); + assert_eq!(observed.repeat, Some(Repeat::Track)); + assert_eq!(observed.active_playlist.as_deref(), Some("/playlist/one")); + assert!(Action::ShuffleToggle.feedback(Some(observed))); + fixture.state.lock().unwrap().deny_seek = true; + let count = fixture.state.lock().unwrap().calls.len(); + assert!( + execute_selected(&mut adapter, &selector, &Action::Seek { offset_ms: 10 }).is_err() + ); + assert_eq!(fixture.state.lock().unwrap().calls.len(), count); + fixture.state.lock().unwrap().silent = true; + let started = Instant::now(); + assert!(execute_selected(&mut adapter, &selector, &Action::Play).is_err()); + assert!(started.elapsed() < Duration::from_secs(3)); + fixture.state.lock().unwrap().silent = false; + assert!(execute_selected(&mut adapter, &selector, &Action::Play).is_ok()); + drop(fixture); + assert!(matcher.resolve(&adapter.discover().unwrap()).is_err()); + let replacement = Fixture::start(); + let current = adapter.discover().unwrap(); + assert_ne!(matcher.resolve(¤t).unwrap().owner, player.owner); + assert!(adapter.execute(&player, &Action::Play).is_err()); // Never retarget an old owner. + assert!(replacement.state.lock().unwrap().calls.is_empty()); + assert!(execute_selected(&mut adapter, &selector, &Action::Play).is_ok()); + } + #[test] #[ignore = "run inside dbus-run-session; uses only a fake player"] fn private_bus_discovers_paused_player_and_confirms_play() {