pipecrab_audio/
mock.rs

1//! Hardware-free [`AudioSource`] / [`AudioSink`] implementations for tests.
2//!
3//! [`MockSource`] replays a fixed script of chunks — build one straight from a
4//! ramp with [`MockSource::ramp`]. [`MockSink`] records everything it is asked
5//! to play so a test can assert on the samples that came out. No devices, no
6//! threads.
7
8use std::collections::VecDeque;
9use std::sync::Arc;
10
11use pipecrab_runtime::maybe_async_trait;
12
13use crate::{AudioChunk, AudioError, AudioFormat, AudioSink, AudioSource};
14
15/// An [`AudioSource`] that yields a predetermined list of chunks, then `None`.
16pub struct MockSource {
17    format: AudioFormat,
18    queue: VecDeque<AudioChunk>,
19}
20
21impl MockSource {
22    /// A source that yields each of `chunks` in order (restamped with `format`),
23    /// then `None`.
24    pub fn new(format: AudioFormat, chunks: impl IntoIterator<Item = Arc<[f32]>>) -> Self {
25        let queue = chunks
26            .into_iter()
27            .map(|samples| AudioChunk::new(samples, format))
28            .collect();
29        Self { format, queue }
30    }
31
32    /// A source whose entire output is the ramp `0.0, 1.0, 2.0, …` — one value
33    /// per sample — split into `chunks` chunks of `chunk_frames` samples each.
34    ///
35    /// The values are exact and monotonic, so a passthrough test can flatten the
36    /// sink's output and compare it to the same ramp.
37    pub fn ramp(format: AudioFormat, chunk_frames: usize, chunks: usize) -> Self {
38        let mut queue = VecDeque::with_capacity(chunks);
39        for c in 0..chunks {
40            let start = (c * chunk_frames) as u32;
41            let samples: Arc<[f32]> = (0..chunk_frames)
42                .map(|i| (start + i as u32) as f32)
43                .collect();
44            queue.push_back(AudioChunk::new(samples, format));
45        }
46        Self { format, queue }
47    }
48}
49
50maybe_async_trait! {
51    impl AudioSource for MockSource {
52        fn format(&self) -> AudioFormat {
53            self.format
54        }
55
56        async fn next_chunk(&mut self) -> Result<Option<AudioChunk>, AudioError> {
57            // A mock never fails: an empty queue is a graceful end of stream.
58            Ok(self.queue.pop_front())
59        }
60    }
61}
62
63/// An [`AudioSink`] that records every chunk it is asked to play.
64pub struct MockSink {
65    format: AudioFormat,
66    received: Vec<AudioChunk>,
67    cancels: usize,
68}
69
70impl MockSink {
71    /// A sink expecting chunks in `format`, with nothing recorded yet.
72    pub fn new(format: AudioFormat) -> Self {
73        Self {
74            format,
75            received: Vec::new(),
76            cancels: 0,
77        }
78    }
79
80    /// The chunks played so far, in arrival order. `cancel` does not clear
81    /// this — the record is the test's evidence.
82    pub fn chunks(&self) -> &[AudioChunk] {
83        &self.received
84    }
85
86    /// Every received sample, flattened into one buffer in arrival order.
87    pub fn samples(&self) -> Vec<f32> {
88        self.received
89            .iter()
90            .flat_map(|c| c.samples.iter().copied())
91            .collect()
92    }
93
94    /// How many times `cancel` was called.
95    pub fn cancels(&self) -> usize {
96        self.cancels
97    }
98}
99
100maybe_async_trait! {
101    impl AudioSink for MockSink {
102        fn format(&self) -> AudioFormat {
103            self.format
104        }
105
106        async fn play(&mut self, chunk: AudioChunk) -> Result<(), AudioError> {
107            self.received.push(chunk);
108            Ok(())
109        }
110
111        fn cancel(&mut self) {
112            self.cancels += 1;
113        }
114    }
115}
pipecrab_audio/mock.rs

pipecrab_audio/
mock.rs
