168 lines
5.3 KiB
Rust
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);
|
|
}
|