fader_master/core/tests/server_reducer.rs

168 lines
5.3 KiB
Rust

use fader_core::{
AdapterCommand, AdapterEvent, BackendEpoch, ChannelGains, CommandOrigin, Gain, Mute, Revision,
ServerCommand, ServerReducer, StreamHandle,
};
fn stream() -> StreamHandle {
StreamHandle::new(BackendEpoch::new(1), 7, 1)
}
fn channels(left: f64, right: f64) -> ChannelGains {
ChannelGains::new(vec![Gain::new(left).unwrap(), Gain::new(right).unwrap()]).unwrap()
}
fn observe(reducer: &mut ServerReducer, gain: ChannelGains, muted: Mute) {
reducer
.event(AdapterEvent::Observed {
stream: stream(),
channels: gain,
muted,
operation: None,
})
.unwrap();
}
#[test]
fn intent_is_recorded_before_dispatch_and_only_observation_confirms_it() {
let mut reducer = ServerReducer::new(Gain::UNITY);
observe(&mut reducer, channels(0.25, 0.5), Mute::Unmuted);
let transition = reducer
.command(ServerCommand::SetVolume {
origin: CommandOrigin::Client { request: 9 },
expected_revision: reducer.revision(),
stream: stream(),
target: Gain::new(0.8).unwrap(),
})
.unwrap();
let AdapterCommand::SetVolume { operation, .. } = &transition.adapter[0] else {
panic!("volume effect expected");
};
let pending = reducer.view(stream()).unwrap();
assert_eq!(pending.desired_gain, Some(Gain::new(0.8).unwrap()));
assert_eq!(pending.channels, channels(0.25, 0.5));
assert!(pending.pending);
let accepted = reducer
.event(AdapterEvent::WriteAccepted {
operation: *operation,
})
.unwrap();
assert!(matches!(
accepted.adapter.as_slice(),
[AdapterCommand::Readback { .. }]
));
assert_eq!(
reducer.view(stream()).unwrap().channels,
channels(0.25, 0.5)
);
reducer
.event(AdapterEvent::Observed {
stream: stream(),
channels: channels(0.4, 0.8),
muted: Mute::Unmuted,
operation: Some(*operation),
})
.unwrap();
let confirmed = reducer.view(stream()).unwrap();
assert_eq!(confirmed.channels, channels(0.4, 0.8));
assert!(!confirmed.pending);
}
#[test]
fn failure_keeps_observed_state_truthful() {
let mut reducer = ServerReducer::new(Gain::UNITY);
observe(&mut reducer, channels(0.3, 0.6), Mute::Unmuted);
let transition = reducer
.command(ServerCommand::SetMute {
origin: CommandOrigin::Midi {
surface: "desk".into(),
sequence: 1,
},
expected_revision: reducer.revision(),
stream: stream(),
muted: Mute::Muted,
})
.unwrap();
let AdapterCommand::SetMute { operation, .. } = transition.adapter[0] else {
panic!("mute effect expected");
};
reducer
.event(AdapterEvent::WriteFailed {
operation,
message: "adapter rejected write".into(),
})
.unwrap();
let view = reducer.view(stream()).unwrap();
assert_eq!(view.muted, Mute::Unmuted);
assert_eq!(view.desired_mute, Some(Mute::Muted));
assert!(!view.pending);
assert_eq!(view.error.as_deref(), Some("adapter rejected write"));
}
#[test]
fn external_observation_updates_views_without_an_audio_effect() {
let mut reducer = ServerReducer::new(Gain::UNITY);
let transition = reducer
.event(AdapterEvent::Observed {
stream: stream(),
channels: channels(0.2, 0.4),
muted: Mute::Muted,
operation: None,
})
.unwrap();
assert!(transition.adapter.is_empty());
assert_eq!(transition.confirmed.len(), 1);
assert_eq!(transition.confirmed[0].revision, Revision::new(1));
assert_eq!(transition.confirmed[0].muted, Mute::Muted);
}
#[test]
fn older_completion_cannot_clear_newer_pending_intent() {
let mut reducer = ServerReducer::new(Gain::UNITY);
observe(&mut reducer, channels(0.2, 0.4), Mute::Unmuted);
let first = reducer
.command(ServerCommand::SetVolume {
origin: CommandOrigin::Client { request: 1 },
expected_revision: reducer.revision(),
stream: stream(),
target: Gain::new(0.5).unwrap(),
})
.unwrap();
let second = reducer
.command(ServerCommand::SetVolume {
origin: CommandOrigin::Client { request: 2 },
expected_revision: reducer.revision(),
stream: stream(),
target: Gain::new(0.8).unwrap(),
})
.unwrap();
let AdapterCommand::SetVolume {
operation: first, ..
} = first.adapter[0]
else {
panic!("first volume operation");
};
let AdapterCommand::SetVolume {
operation: second, ..
} = second.adapter[0]
else {
panic!("second volume operation");
};
reducer
.event(AdapterEvent::Observed {
stream: stream(),
channels: channels(0.25, 0.5),
muted: Mute::Unmuted,
operation: Some(first),
})
.unwrap();
assert!(reducer.view(stream()).unwrap().pending);
reducer
.event(AdapterEvent::Observed {
stream: stream(),
channels: channels(0.4, 0.8),
muted: Mute::Unmuted,
operation: Some(second),
})
.unwrap();
assert!(!reducer.view(stream()).unwrap().pending);
}