test: start refactor tests based on mutation tests from cosmic-ray

tests/events/test_empty.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8b8fbafe8679076454429756fa72f11d5f442c87381cc6a4285451d826a9e629
+size 44

tests/lambdas/test_lambdaSpeechToScore_librosa.py

@@ -0,0 +1,96 @@
+import unittest
+
+from aip_trainer.lambdas import lambdaSpeechToScore
+from aip_trainer.utils.utilities import hash_calculate
+from tests import EVENTS_FOLDER
+
+
+input_file_test_de = EVENTS_FOLDER / "test_de.wav"
+hash_input = hash_calculate(input_file_test_de, is_file=True)
+assert hash_input == b'tGNDknDQRwCAx4LJ88Ft3y2+YAxcqXW7GAqasxxZoBw='
+
+
+class TestCalcStartEnd(unittest.TestCase):
+
+    def test_calc_start_end_zero_offset(self):
+        output = lambdaSpeechToScore.calc_start_end(48000, 0.0, 2)
+        self.assertEqual(output, 0)
+
+    def test_calc_start_end_non_zero_offset(self):
+        output = lambdaSpeechToScore.calc_start_end(48000, 1.0, 2)
+        self.assertEqual(output, 96000)
+
+    def test_calc_start_end_fractional_offset(self):
+        output = lambdaSpeechToScore.calc_start_end(48000, 0.5, 2)
+        self.assertEqual(output, 48000)
+
+    def test_calc_start_end_high_sample_rate(self):
+        output = lambdaSpeechToScore.calc_start_end(96000, 1.0, 2)
+        self.assertEqual(output, 192000)
+
+    def test_calc_start_end_low_sample_rate(self):
+        output = lambdaSpeechToScore.calc_start_end(24000, 1.0, 2)
+        self.assertEqual(output, 48000)
+
+    def test_calc_start_end_very_low_sample_rate(self):
+        output = lambdaSpeechToScore.calc_start_end(8000, 1.0, 2)
+        self.assertEqual(output, 16000)
+
+    def test_calc_start_end_single_channel(self):
+        output = lambdaSpeechToScore.calc_start_end(48000, 1.0, 1)
+        self.assertEqual(output, 48000)
+
+    def test_calc_start_end_multiple_channels(self):
+        output = lambdaSpeechToScore.calc_start_end(48000, 1.0, 4)
+        self.assertEqual(output, 48000 * 4)
+
+
+class TestAudioReadLoad(unittest.TestCase):
+
+    def test_audioread_load_full_file(self):
+        signal, sr_native = lambdaSpeechToScore.audioread_load(input_file_test_de)
+        self.assertEqual(sr_native, 44100)
+        self.assertEqual(
+            signal.shape[0], 129653
+        )  # Assuming the audio file is ~2,93 seconds long (107603 / 44100)
+        hash_output = hash_calculate(signal, is_file=False)
+        self.assertEqual(hash_output, b'3bfNuuMk0ov5+E77cUZmzjijfBUaMxuy1mrPmyjFyeo=')
+        
+    def test_audioread_load_with_offset(self):
+        signal, sr_native = lambdaSpeechToScore.audioread_load(input_file_test_de, offset=0.5)
+        self.assertEqual(sr_native, 44100)
+        self.assertAlmostEqual(signal.shape[0], 107603)  # audio file is ~2.44 seconds long (107603 / 44100), offset is 0.5 seconds
+        hash_output = hash_calculate(signal, is_file=False)
+        self.assertEqual(hash_output, b'QiDTDSZ4xAUniANNz4M43oa2FwpTSjvzW3IsKyqCVeE=')
+
+    def test_audioread_load_with_duration(self):
+        signal, sr_native = lambdaSpeechToScore.audioread_load(input_file_test_de, duration=129653 / 44100)
+        self.assertEqual(sr_native, 44100)
+        self.assertEqual(signal.shape[0], 129653)  # Assuming the duration is ~2,93 seconds long (129653 / 44100)
+        hash_output = hash_calculate(signal, is_file=False)
+        self.assertEqual(hash_output, b'3bfNuuMk0ov5+E77cUZmzjijfBUaMxuy1mrPmyjFyeo=')
+
+    def test_audioread_load_with_offset_and_duration(self):
+        signal, sr_native = lambdaSpeechToScore.audioread_load(input_file_test_de, offset=0.5, duration=129653 / 44100)
+        self.assertEqual(sr_native, 44100)
+        self.assertEqual(signal.shape[0], 107603)  # Assuming the duration is 5 seconds starting from 2 seconds offset
+        hash_output = hash_calculate(signal, is_file=False)
+        self.assertEqual(hash_output, b'QiDTDSZ4xAUniANNz4M43oa2FwpTSjvzW3IsKyqCVeE=')
+
+    def test_audioread_load_empty_file(self):
+        # import soundfile as sf
+        # import numpy as np
+        # signal, sr_native = lambdaSpeechToScore.audioread_load(input_file_test_de, offset=5, duration=129653 / 44100)
+        # sf.write(EVENTS_FOLDER / "test_empty.wav", data=signal, samplerate=44100)
+        input_empty = EVENTS_FOLDER / "test_empty.wav"
+        hash_input_empty = hash_calculate(input_empty, is_file=True)
+        self.assertEqual(hash_input_empty, b'i4+6/oZ5B2RUQpdW+nLxHV9ELIc4HMakKFRR2Cap5ik=')
+        signal, sr_native = lambdaSpeechToScore.audioread_load(input_empty)
+        self.assertEqual(sr_native, 44100)
+        self.assertEqual(signal.shape, (0, ))  # Assuming the file is empty
+        hash_output = hash_calculate(signal, is_file=False)
+        self.assertEqual(hash_output, b'47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=')
+
+
+if __name__ == "__main__":
+    unittest.main()