test(sound): check sound files in rust tests

instead of invoking soxi
check that all files are present in the assets
check bits per sample (16 bits)
SOUNDS_DIR can be overwritten at runtime with an env variable
tests are run with all other rust tests

.github/workflows/rust-ci.yaml

@@ -149,7 +149,7 @@ jobs:
       - name: Cargo Test
         run: |
           nix develop -c \
-            cargo test --all --all-features --all-targets $EXCLUDES
+          SOUNDS_DIR=$(pwd)/ui/sounds/assets >>${GITHUB_ENV} cargo test --all --all-features --all-targets $EXCLUDES
 
   build:
     name: Build

ui/Cargo.toml

@@ -46,6 +46,7 @@ path = "examples/ui-replay.rs"
 # dependencies for the dbus-client example
 [dev-dependencies]
 chrono = "0.4.35"
+hound = "3.5.1"
 
 [package.metadata.deb]
 maintainer-scripts = "debian/"

ui/sound/examples/queue.rs

@@ -16,9 +16,8 @@ impl AsRef<[u8]> for Sound {
 async fn main() -> Result<()> {
     let queue = Queue::spawn("default")?;
 
-    let connected = Sound(Arc::new(fs::read("sound/examples/voice_connected.wav")?));
-    let overheating =
-        Sound(Arc::new(fs::read("sound/examples/voice_overheating.wav")?));
+    let connected = Sound(Arc::new(fs::read("sound/assets/voice_connected.wav")?));
+    let timeout = Sound(Arc::new(fs::read("sound/assets/voice_timeout.wav")?));
 
     // Said firstly because the queue starts playing immediately.
     queue
@@ -40,19 +39,13 @@ async fn main() -> Result<()> {
     // Said secondly because it has a higher priority than all pending sounds in
     // the queue.
     queue
-        .sound(
-            Some(Cursor::new(overheating.clone())),
-            "overheating".to_string(),
-        )
+        .sound(Some(Cursor::new(timeout.clone())), "timeout".to_string())
         .priority(1)
         .push()?;
     // Not said because it doesn't meet the `max_delay`.
     assert!(
         !queue
-            .sound(
-                Some(Cursor::new(overheating.clone())),
-                "overheating".to_string()
-            )
+            .sound(Some(Cursor::new(timeout.clone())), "timeout".to_string())
             .priority(1)
             .max_delay(Duration::from_secs(1))
             .push()?
@@ -72,7 +65,7 @@ async fn main() -> Result<()> {
     );
 
     // In result the queue should be played in the following order: connected,
-    // overheating, connected, connected.
+    // timeout, connected, connected.
 
     Ok(())
 }

ui/sound/examples/wav.rs

@@ -6,7 +6,7 @@ fn main() -> Result<()> {
     let mut device = Device::open("default")?;
     let mut hw_params = HwParams::new()?;
 
-    let mut wav = File::open("sound/examples/voice_connected.wav")?;
+    let mut wav = File::open("sound/assets/voice_connected.wav")?;
     device.play_wav(&mut wav, &mut hw_params, 1.0)?;
     device.drain()?;
 

ui/src/sound/mod.rs

@@ -295,7 +295,10 @@ async fn load_sound_file(
     language: Option<&str>,
     ignore_missing: bool,
 ) -> Result<SoundFile> {
-    let sounds_dir = Path::new(SOUNDS_DIR);
+    let path = std::env::var("SOUNDS_DIR")
+        .unwrap_or(SOUNDS_DIR.to_string())
+        .clone();
+    let sounds_dir = Path::new(&path);
     if let Some(language) = language {
         let file = sounds_dir.join(format!("{sound}__{language}.wav"));
         if file.exists() {
@@ -320,6 +323,22 @@ async fn load_sound_file(
             }
         }
     };
+
+    // we have had errors with reading files encoded over 24 bits, so
+    // this test ensure that wav files are sampled on 16 bits, for full Jetson compatibility.
+    // remove this test if different sampling are supported.
+    #[cfg(test)]
+    {
+        let reader = hound::WavReader::open(&file)
+            .map_err(|e| eyre::eyre!("hound: {:?}: {:#?}", &file, e))?;
+        assert_eq!(
+            reader.spec().bits_per_sample,
+            16,
+            "Only 16-bit sounds are supported: {:?}",
+            &file
+        );
+    }
+
     Ok(SoundFile(Arc::new(data)))
 }
 
@@ -328,3 +347,108 @@ impl fmt::Debug for Jetson {
         f.debug_struct("Sound").finish()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{Melody, Player, SoundFile, Type, Voice};
+    use dashmap::DashMap;
+    use orb_sound::SoundBuilder;
+    use std::fmt::{Debug, Formatter};
+    use std::future::Future;
+    use std::pin::Pin;
+    use std::sync::Arc;
+    use std::time::Duration;
+
+    struct MockJetson {
+        sound_files: Arc<DashMap<Type, SoundFile>>,
+    }
+
+    impl Debug for MockJetson {
+        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+            f.debug_struct("MockJetson").finish()
+        }
+    }
+
+    impl Player for MockJetson {
+        fn load_sound_files(
+            &self,
+            language: Option<&str>,
+            ignore_missing_sounds: bool,
+        ) -> Pin<Box<dyn Future<Output = eyre::Result<()>> + Send + '_>> {
+            let sound_files = Arc::clone(&self.sound_files);
+            let language = language.map(ToOwned::to_owned);
+            Box::pin(async move {
+                Voice::load_sound_files(
+                    &sound_files,
+                    language.as_deref(),
+                    ignore_missing_sounds,
+                )
+                .await?;
+                Melody::load_sound_files(
+                    &sound_files,
+                    language.as_deref(),
+                    ignore_missing_sounds,
+                )
+                .await?;
+                let count = sound_files.len();
+                tracing::debug!("Sound files for language {language:?} loaded successfully ({count:?} files)");
+                Ok(())
+            })
+        }
+
+        fn build(&mut self, _sound_type: Type) -> eyre::Result<SoundBuilder> {
+            unimplemented!()
+        }
+
+        fn clone(&self) -> Box<dyn Player> {
+            Box::new(MockJetson {
+                sound_files: self.sound_files.clone(),
+            })
+        }
+
+        fn volume(&self) -> u64 {
+            unimplemented!()
+        }
+
+        fn set_master_volume(&mut self, _level: u64) {
+            unimplemented!()
+        }
+
+        fn queue(&mut self, _sound_type: Type, _delay: Duration) -> eyre::Result<()> {
+            unimplemented!()
+        }
+
+        fn try_queue(&mut self, _sound_type: Type) -> eyre::Result<bool> {
+            unimplemented!()
+        }
+    }
+
+    /// This test allows us to check that all files that can be pulled by the UI
+    /// are present in the repository and are all encoded over 16 bits
+    #[tokio::test]
+    async fn test_load_sound_file() {
+        let sound = MockJetson {
+            sound_files: Arc::new(DashMap::new()),
+        };
+
+        let language = None;
+        let res = sound.load_sound_files(language, false).await;
+        if let Err(e) = &res {
+            println!("{:?}", e);
+        }
+        assert!(res.is_ok(), "Default (None) failed");
+
+        let language = Some("EN-en");
+        let res = sound.load_sound_files(language, false).await;
+        assert!(res.is_ok(), "EN-en failed");
+
+        let language = Some("ES-es");
+        let res = sound.load_sound_files(language, false).await;
+        assert!(res.is_ok(), "ES-en failed");
+
+        // unsupported / missing voice files
+        let language = Some("FR-fr");
+        let res = sound.load_sound_files(language, false).await;
+        assert!(res.is_ok(), "ES-en failed");
+    }
+}