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.
This commit is contained in:
Dandaedre 2026-10-18 23:03:26 +02:00
parent f7acaf3ba4
commit 6ee082673b
Signed by: Dandaedre
GPG Key ID: 440C6592E8A26D99
2 changed files with 351 additions and 0 deletions

View File

@ -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!(

View File

@ -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<String>,
}
struct Fixture {
state: Arc<Mutex<ExtendedState>>,
stop: Arc<AtomicBool>,
thread: Option<JoinHandle<()>>,
}
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<bool>) =
message.read3().unwrap();
state.shuffle = value.0;
} else {
let (_, _, value): (String, String, Variant<String>) =
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(&current).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() {