Add tests to sound

Author: leeyi45

src/bundles/sound/package.json

@@ -8,7 +8,10 @@
   },
   "devDependencies": {
     "@sourceacademy/modules-buildtools": "workspace:^",
-    "typescript": "^5.8.2"
+    "@sourceacademy/modules-lib": "workspace:^",
+    "playwright": "^1.54.1",
+    "typescript": "^5.8.2",
+    "vitest": "^3.2.3"
   },
   "type": "module",
   "exports": {

src/bundles/sound/src/__tests__/recording.test.ts

@@ -0,0 +1,132 @@
+// @vitest-environment jsdom
+import { stringify } from 'js-slang/dist/utils/stringify';
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  test,
+  vi,
+  type Mock
+} from 'vitest';
+import * as funcs from '../functions';
+import { mockAudioContext, mockMediaRecorder } from './utils';
+
+const mockStream = {} as MediaStream;
+const mockedGetUserMedia: Mock<typeof navigator.mediaDevices.getUserMedia> = vi.fn()
+  .mockResolvedValue(mockStream);
+
+vi.spyOn(global, 'navigator', 'get').mockReturnValue({
+  get mediaDevices() {
+    return {
+      getUserMedia: mockedGetUserMedia
+    };
+  }
+} as any);
+
+Object.defineProperty(global, 'AudioContext', {
+  value: () => mockAudioContext
+});
+
+Object.defineProperty(global, 'MediaRecorder', {
+  value: () => mockMediaRecorder
+});
+
+beforeEach(() => {
+  funcs.globalVars.recordedSound = null;
+  funcs.globalVars.stream = null;
+  funcs.globalVars.isPlaying = false;
+  funcs.globalVars.audioplayer = null;
+});
+
+describe(funcs.init_record, () => {
+  test('sets stream correctly when permission is accepted', async () => {
+    expect(funcs.init_record()).toEqual('obtaining recording permission');
+    await expect.poll(() => funcs.globalVars.stream).toBe(mockStream);
+  });
+
+  test('sets stream to false when permission is rejected', async () => {
+    mockedGetUserMedia.mockRejectedValueOnce('');
+    expect(funcs.init_record()).toEqual('obtaining recording permission');
+    await expect.poll(() => funcs.globalVars.stream).toEqual(false);
+  });
+});
+
+describe('Recording functions', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.runOnlyPendingTimers();
+    vi.useRealTimers();
+  });
+
+  describe(funcs.record, () => {
+    test('throws error if called without init_record', () => {
+      expect(() => funcs.record(0)).toThrowError('Call init_record(); to obtain permission to use microphone');
+    });
+
+    test('throws error if called concurrently with another sound', () => {
+      funcs.play_wave(() => 0, 10);
+      expect(() => funcs.record(1)).toThrowError('record: Cannot record while another sound is playing!');
+    });
+
+    test(`${funcs.record.name} works`, async () => {
+      funcs.init_record();
+      await expect.poll(() => funcs.globalVars.stream).toBe(mockStream);
+
+      const stop = funcs.record(1);
+      await vi.advanceTimersByTimeAsync(1200); // Mock waiting for the buffer duration
+      expect(mockAudioContext.bufferSource.start).toHaveBeenCalledOnce(); // Assert that the recording signal was played
+      mockAudioContext.close(); // End the recording signal playing
+
+      await vi.advanceTimersByTimeAsync(100); // Advance past the end of the recording signal
+      expect(mockMediaRecorder.start).toHaveBeenCalledOnce(); // Assert that recording started
+      const soundPromise = stop(); // Call stop to stop recording
+
+      expect(mockMediaRecorder.stop).toHaveBeenCalledOnce();
+      expect(mockAudioContext.bufferSource.start).toHaveBeenCalledTimes(2); // Assert that the recording signal was played again
+      mockAudioContext.close(); // End the recording signal playing
+
+      // Resolving the promise before processing is done throws an error
+      expect(soundPromise).toThrowError('recording still being processed');
+      expect(stringify(soundPromise)).toEqual('<SoundPromise>');
+      const mockRecordedSound = funcs.silence_sound(0);
+
+      // Resolving the promise after processing is done doesn't throw an error
+      funcs.globalVars.recordedSound = mockRecordedSound;
+      expect(soundPromise()).toBe(mockRecordedSound);
+    });
+  });
+
+  describe(funcs.record_for, () => {
+    test('throws error if called without init_record', () => {
+      expect(() => funcs.record_for(0, 0)).toThrowError('Call init_record(); to obtain permission to use microphone');
+    });
+
+    test('throws error if called concurrently with another sound', () => {
+      funcs.play_wave(() => 0, 10);
+      expect(() => funcs.record_for(1, 1)).toThrowError('record_for: Cannot record while another sound is playing!');
+    });
+
+    test(`${funcs.record_for.name} works`, async () => {
+      funcs.init_record();
+      await expect.poll(() => funcs.globalVars.stream).toBe(mockStream);
+
+      const promise = funcs.record_for(5, 1);
+      expect(stringify(promise)).toEqual('<SoundPromise>');
+      await vi.advanceTimersByTimeAsync(200); // Advance time by the pre-record buffer duration (in ms)
+      expect(mockAudioContext.bufferSource.start).toHaveBeenCalledOnce(); // Assert that the recording signal was played
+      mockAudioContext.close(); // End the recording signal playing
+
+      await vi.advanceTimersByTimeAsync(1100); // Advance time by recording signal and buffer duration
+      expect(mockMediaRecorder.start).toHaveBeenCalledOnce(); // Assert that recording began
+
+      await vi.advanceTimersByTimeAsync(5000); // Advance time by recording duration
+      expect(mockMediaRecorder.stop).toHaveBeenCalledOnce(); // Assert that recording stopped
+      expect(mockAudioContext.bufferSource.start).toHaveBeenCalledTimes(2); // Assert that the recording signal was played again
+      mockAudioContext.close(); // End the recording signal playing
+    });
+  });
+});

src/bundles/sound/src/__tests__/sound.test.ts

@@ -1,6 +1,11 @@
-import { describe, expect, it } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, test } from 'vitest';
 import * as funcs from '../functions';
-import type { Sound } from '../types';
+import type { Sound, Wave } from '../types';
+import { mockAudioContext } from './utils';
+
+Object.defineProperty(global, 'AudioContext', {
+  value: () => mockAudioContext
+});
 
 describe(funcs.make_sound, () => {
   it('Should error gracefully when duration is negative', () => {
@@ -18,37 +23,72 @@ describe(funcs.make_sound, () => {
   });
 });
 
-describe(funcs.play, () => {
-  it('Should error gracefully when duration is negative', () => {
-    const sound: Sound = [() => 0, -1];
-    expect(() => funcs.play(sound))
-      .toThrow('play: duration of sound is negative');
+describe('Concurrent playback functions', () => {
+  beforeEach(() => {
+    funcs.globalVars.audioplayer = null;
   });
 
-  it('Should not error when duration is zero', () => {
-    const sound = funcs.make_sound(() => 0, 0);
-    expect(() => funcs.play(sound)).not.toThrow();
+  afterEach(() => {
+    funcs.globalVars.isPlaying = false;
   });
 
-  it('Should throw error when given not a sound', () => {
-    expect(() => funcs.play(0 as any)).toThrow('play is expecting sound, but encountered 0');
+  describe(funcs.play, () => {
+    it('Should error gracefully when duration is negative', () => {
+      const sound: Sound = [() => 0, -1];
+      expect(() => funcs.play(sound))
+        .toThrow('play: duration of sound is negative');
+    });
+
+    it('Should not error when duration is zero', () => {
+      const sound = funcs.make_sound(() => 0, 0);
+      expect(() => funcs.play(sound)).not.toThrow();
+    });
+
+    it('Should throw error when given not a sound', () => {
+      expect(() => funcs.play(0 as any)).toThrow('play is expecting sound, but encountered 0');
+    });
+
+    test.only('Concurrently playing two sounds should error', () => {
+      console.log(AudioContext);
+      const sound = funcs.silence_sound(10);
+      expect(() => funcs.play(sound)).not.toThrow();
+      expect(() => funcs.play(sound)).toThrowError('play: Previous sound still playing');
+    });
   });
-});
 
-describe(funcs.play_wave, () => {
-  it('Should error gracefully when duration is negative', () => {
-    expect(() => funcs.play_wave(() => 0, -1))
-      .toThrow('play_wave: Sound duration must be greater than or equal to 0');
+  describe(funcs.play_wave, () => {
+    it('Should error gracefully when duration is negative', () => {
+      expect(() => funcs.play_wave(() => 0, -1))
+        .toThrow('play_wave: Sound duration must be greater than or equal to 0');
+    });
+
+    it('Should error gracefully when duration is not a number', () => {
+      expect(() => funcs.play_wave(() => 0, true as any))
+        .toThrow('play_wave expects a number for duration, got true');
+    });
+
+    it('Should error gracefully when wave is not a function', () => {
+      expect(() => funcs.play_wave(true as any, 0))
+        .toThrow('play_wave expects a wave, got true');
+    });
+
+    test('Concurrently playing two sounds should error', () => {
+      const wave: Wave = () => 0;
+      expect(() => funcs.play_wave(wave, 10)).not.toThrow();
+      expect(() => funcs.play_wave(wave, 10)).toThrowError('play: Previous sound still playing');
+    });
   });
 
-  it('Should error gracefully when duration is not a number', () => {
-    expect(() => funcs.play_wave(() => 0, true as any))
-      .toThrow('play_wave expects a number for duration, got true');
-  });
+  describe(funcs.stop, () => {
+    test('Calling stop without ever calling any playback functions should not throw an error', () => {
+      expect(funcs.stop).not.toThrowError();
+    });
 
-  it('Should error gracefully when wave is not a function', () => {
-    expect(() => funcs.play_wave(true as any, 0))
-      .toThrow('play_wave expects a wave, got true');
+    it('sets isPlaying to false', () => {
+      funcs.globalVars.isPlaying = true;
+      funcs.stop();
+      expect(funcs.globalVars.isPlaying).toEqual(false);
+    });
   });
 });
 
@@ -67,6 +107,13 @@ describe(funcs.play_in_tab, () => {
   it('Should throw error when given not a sound', () => {
     expect(() => funcs.play_in_tab(0 as any)).toThrow('play_in_tab is expecting sound, but encountered 0');
   });
+
+  test('Multiple calls does not cause an error', () => {
+    const sound = funcs.silence_sound(10);
+    expect(() => funcs.play_in_tab(sound)).not.toThrow();
+    expect(() => funcs.play_in_tab(sound)).not.toThrow();
+    expect(() => funcs.play_in_tab(sound)).not.toThrow();
+  });
 });
 
 function evaluateSound(sound: Sound) {

src/bundles/sound/src/__tests__/utils.ts

@@ -0,0 +1,71 @@
+import { vi, type Mock } from 'vitest';
+
+interface MockMediaRecorder {
+  stop: () => void;
+  start: Mock<() => void>;
+  onstop?: () => void;
+  ondataavailable?: () => void;
+}
+
+interface MockAudioBufferSource {
+  buffer: MockAudioBuffer | null;
+  node: AudioNode | null;
+  isPlaying: boolean;
+  connect: (node: AudioNode) => void;
+  disconnect: (node: AudioNode) => void;
+  start: () => void;
+  stop: () => void;
+  onended?: () => void;
+}
+
+interface MockAudioBuffer {
+  getChannelData: (channel: number) => Float32Array<ArrayBuffer>;
+}
+
+interface MockAudioContext {
+  bufferSource: MockAudioBufferSource;
+  createBufferSource: () => MockAudioBufferSource;
+  createBuffer: (channels: number, length: number, sampleRate: number) => MockAudioBuffer;
+  decodeAudioData: (buffer: ArrayBuffer) => Promise<MockAudioBuffer>;
+  close: () => void;
+}
+
+export const mockBufferSource: MockAudioBufferSource = {
+  isPlaying: false,
+  buffer: null,
+  node: null,
+  connect(node) {
+    this.node = node;
+  },
+  disconnect: () => {},
+  start() {
+    this.isPlaying = true;
+  },
+  stop() {
+    this.isPlaying = false;
+    this.onended?.();
+  }
+};
+vi.spyOn(mockBufferSource, 'start');
+
+export const mockAudioContext: MockAudioContext = {
+  bufferSource: mockBufferSource,
+  createBufferSource: () => mockBufferSource,
+  createBuffer: (channels, length) => ({
+    getChannelData: () => new Float32Array<ArrayBuffer>(new ArrayBuffer(4 * length)),
+  }),
+  close() {
+    return this.bufferSource.stop();
+  },
+  decodeAudioData() {
+    return Promise.resolve(this.bufferSource.buffer!);
+  },
+};
+
+export const mockMediaRecorder: MockMediaRecorder = {
+  start: vi.fn(),
+  stop() {
+    this.onstop?.();
+  }
+};
+vi.spyOn(mockMediaRecorder, 'stop');