test(audio+store): add pitch, transport and mixer reducer tests (#16)

* test(audio): add pitch playback rate tests

* test(store): add transport reducer tests for BPM, playback and playhead

* test(store): add mixer reducer tests for inserts, FX slots and meters

Author: 808StaN

src/audio/domain/pitch.test.js

@@ -0,0 +1,37 @@
+import { describe, it, expect } from "vitest";
+import {
+  midiPitchToPlaybackRate,
+  DEFAULT_SAMPLE_MIDI_PITCH,
+} from "./pitch";
+import { MIN_PLAYBACK_RATE, MAX_PLAYBACK_RATE } from "./constants";
+
+describe("midiPitchToPlaybackRate", () => {
+  it("returns 1 for default pitch (72)", () => {
+    expect(midiPitchToPlaybackRate(DEFAULT_SAMPLE_MIDI_PITCH)).toBe(1);
+  });
+
+  it("returns 1 for null/undefined", () => {
+    expect(midiPitchToPlaybackRate(null)).toBe(1);
+    expect(midiPitchToPlaybackRate(undefined)).toBe(1);
+  });
+
+  it("doubles rate for +12 semitones", () => {
+    expect(midiPitchToPlaybackRate(84)).toBeCloseTo(2, 5);
+  });
+
+  it("halves rate for -12 semitones", () => {
+    expect(midiPitchToPlaybackRate(60)).toBeCloseTo(0.5, 5);
+  });
+
+  it("returns 2^(1/12) for +1 semitone", () => {
+    expect(midiPitchToPlaybackRate(73)).toBeCloseTo(Math.pow(2, 1 / 12), 5);
+  });
+
+  it("clamps to MIN_PLAYBACK_RATE for very low pitches", () => {
+    expect(midiPitchToPlaybackRate(-100)).toBe(MIN_PLAYBACK_RATE);
+  });
+
+  it("clamps to MAX_PLAYBACK_RATE for very high pitches", () => {
+    expect(midiPitchToPlaybackRate(200)).toBe(MAX_PLAYBACK_RATE);
+  });
+});

src/store/reducers/mixer.test.js

@@ -0,0 +1,177 @@
+import { describe, it, expect } from "vitest";
+import { mixerReducers } from "./mixer";
+
+function createMixerState(inserts = []) {
+  return {
+    mixer: {
+      inserts,
+      selectedInsertId: inserts[0]?.id || null,
+    },
+  };
+}
+
+function makeInsert(id) {
+  return {
+    id,
+    name: "Insert " + id,
+    isMaster: false,
+    active: true,
+    pan: 0,
+    stereoSeparation: 0,
+    fader: 1,
+    meter: 0,
+    meterSpectrum: [],
+    meterWaveform: [],
+    maximizerReduction: 0,
+    maximizerOutputDb: -96,
+    maximizerStereoMeter: {},
+    routesTo: ["master"],
+    fxSlots: Array.from({ length: 10 }, (_, i) => ({
+      id: `slot-${i + 1}`,
+      name: `Slot ${i + 1}`,
+      enabled: false,
+      effectType: "none",
+      params: null,
+    })),
+  };
+}
+
+describe("mixerReducers", () => {
+  describe("selectInsert", () => {
+    it("sets selected insert", () => {
+      const state = createMixerState([makeInsert("insert-1")]);
+      mixerReducers.selectInsert(state, { payload: "insert-1" });
+      expect(state.mixer.selectedInsertId).toBe("insert-1");
+    });
+  });
+
+  describe("addMixerTrack", () => {
+    it("adds a new insert with incremented number", () => {
+      const state = createMixerState([makeInsert("insert-1")]);
+      mixerReducers.addMixerTrack(state);
+      expect(state.mixer.inserts.length).toBe(2);
+      expect(state.mixer.inserts[1].id).toBe("insert-2");
+      expect(state.mixer.inserts[1].fxSlots.length).toBe(10);
+      expect(state.mixer.selectedInsertId).toBe("insert-2");
+    });
+
+    it("creates insert-1 when list is empty", () => {
+      const state = createMixerState([]);
+      mixerReducers.addMixerTrack(state);
+      expect(state.mixer.inserts[0].id).toBe("insert-1");
+    });
+  });
+
+  describe("setInsertActive", () => {
+    it("toggles insert active state", () => {
+      const state = createMixerState([makeInsert("insert-1")]);
+      mixerReducers.setInsertActive(state, { payload: { insertId: "insert-1", value: false } });
+      expect(state.mixer.inserts[0].active).toBe(false);
+    });
+
+    it("ignores missing insert", () => {
+      const state = createMixerState([makeInsert("insert-1")]);
+      mixerReducers.setInsertActive(state, { payload: { insertId: "missing", value: false } });
+      expect(state.mixer.inserts[0].active).toBe(true);
+    });
+  });
+
+  describe("setInsertPan", () => {
+    it("sets pan within [-1, 1]", () => {
+      const state = createMixerState([makeInsert("insert-1")]);
+      mixerReducers.setInsertPan(state, { payload: { insertId: "insert-1", value: 0.5 } });
+      expect(state.mixer.inserts[0].pan).toBe(0.5);
+    });
+
+    it("clamps pan to [-1, 1]", () => {
+      const state = createMixerState([makeInsert("insert-1")]);
+      mixerReducers.setInsertPan(state, { payload: { insertId: "insert-1", value: 2 } });
+      expect(state.mixer.inserts[0].pan).toBe(1);
+    });
+  });
+
+  describe("setInsertStereo", () => {
+    it("sets stereo separation", () => {
+      const state = createMixerState([makeInsert("insert-1")]);
+      mixerReducers.setInsertStereo(state, { payload: { insertId: "insert-1", value: -0.5 } });
+      expect(state.mixer.inserts[0].stereoSeparation).toBe(-0.5);
+    });
+  });
+
+  describe("setInsertFader", () => {
+    it("sets fader within [0, 1.25]", () => {
+      const state = createMixerState([makeInsert("insert-1")]);
+      mixerReducers.setInsertFader(state, { payload: { insertId: "insert-1", value: 0.8 } });
+      expect(state.mixer.inserts[0].fader).toBe(0.8);
+    });
+
+    it("clamps fader to max 1.25", () => {
+      const state = createMixerState([makeInsert("insert-1")]);
+      mixerReducers.setInsertFader(state, { payload: { insertId: "insert-1", value: 2 } });
+      expect(state.mixer.inserts[0].fader).toBe(1.25);
+    });
+  });
+
+  describe("toggleFxSlot", () => {
+    it("does nothing for empty slot", () => {
+      const state = createMixerState([makeInsert("insert-1")]);
+      mixerReducers.toggleFxSlot(state, { payload: { insertId: "insert-1", slotId: "slot-1" } });
+      expect(state.mixer.inserts[0].fxSlots[0].enabled).toBe(false);
+    });
+
+    it("toggles enabled for loaded effect", () => {
+      const state = createMixerState([makeInsert("insert-1")]);
+      state.mixer.inserts[0].fxSlots[0].effectType = "graphic-eq";
+      mixerReducers.toggleFxSlot(state, { payload: { insertId: "insert-1", slotId: "slot-1" } });
+      expect(state.mixer.inserts[0].fxSlots[0].enabled).toBe(true);
+      mixerReducers.toggleFxSlot(state, { payload: { insertId: "insert-1", slotId: "slot-1" } });
+      expect(state.mixer.inserts[0].fxSlots[0].enabled).toBe(false);
+    });
+  });
+
+  describe("setFxSlotEffectType", () => {
+    it("sets effect type and name for Graphic EQ", () => {
+      const state = createMixerState([makeInsert("insert-1")]);
+      mixerReducers.setFxSlotEffectType(state, {
+        payload: { insertId: "insert-1", slotId: "slot-1", effectType: "graphic-eq" },
+      });
+      expect(state.mixer.inserts[0].fxSlots[0].effectType).toBe("graphic-eq");
+      expect(state.mixer.inserts[0].fxSlots[0].name).toBe("Graphic EQ");
+    });
+
+    it("clears effect when type is none", () => {
+      const state = createMixerState([makeInsert("insert-1")]);
+      state.mixer.inserts[0].fxSlots[0].effectType = "reverb";
+      mixerReducers.setFxSlotEffectType(state, {
+        payload: { insertId: "insert-1", slotId: "slot-1", effectType: "none" },
+      });
+      expect(state.mixer.inserts[0].fxSlots[0].effectType).toBe("none");
+      expect(state.mixer.inserts[0].fxSlots[0].enabled).toBe(false);
+    });
+  });
+
+  describe("setInsertMeter", () => {
+    it("sets meter value clamped to [0, 1]", () => {
+      const state = createMixerState([makeInsert("insert-1")]);
+      mixerReducers.setInsertMeter(state, { payload: { insertId: "insert-1", meter: 1.5 } });
+      expect(state.mixer.inserts[0].meter).toBe(1);
+    });
+
+    it("updates spectrum and waveform arrays", () => {
+      const state = createMixerState([makeInsert("insert-1")]);
+      mixerReducers.setInsertMeter(state, {
+        payload: { insertId: "insert-1", meter: 0.5, spectrum: [0.2, 1.5], waveform: [-1.2, 0.8] },
+      });
+      expect(state.mixer.inserts[0].meterSpectrum).toEqual([0.2, 1]);
+      expect(state.mixer.inserts[0].meterWaveform).toEqual([-1, 0.8]);
+    });
+
+    it("clamps maximizerReduction", () => {
+      const state = createMixerState([makeInsert("insert-1")]);
+      mixerReducers.setInsertMeter(state, {
+        payload: { insertId: "insert-1", meter: 0, maximizerReduction: 50 },
+      });
+      expect(state.mixer.inserts[0].maximizerReduction).toBe(36);
+    });
+  });
+});

src/store/reducers/transport.test.js

@@ -0,0 +1,109 @@
+import { describe, it, expect } from "vitest";
+import { transportReducers } from "./transport";
+
+function createTransportState() {
+  return {
+    transport: {
+      bpm: 140,
+      isPlaying: false,
+      isRecording: false,
+      mode: "pattern",
+      songLoopEnabled: false,
+      currentStep16: 0,
+    },
+  };
+}
+
+describe("transportReducers", () => {
+  describe("setBpm", () => {
+    it("updates bpm within range", () => {
+      const state = createTransportState();
+      transportReducers.setBpm(state, { payload: 128 });
+      expect(state.transport.bpm).toBe(128);
+    });
+
+    it("clamps bpm to minimum 40", () => {
+      const state = createTransportState();
+      transportReducers.setBpm(state, { payload: 20 });
+      expect(state.transport.bpm).toBe(40);
+    });
+
+    it("clamps bpm to maximum 300", () => {
+      const state = createTransportState();
+      transportReducers.setBpm(state, { payload: 400 });
+      expect(state.transport.bpm).toBe(300);
+    });
+
+    it("rounds fractional bpm", () => {
+      const state = createTransportState();
+      transportReducers.setBpm(state, { payload: 140.7 });
+      expect(state.transport.bpm).toBe(141);
+    });
+  });
+
+  describe("setPlaying", () => {
+    it("sets playing to true", () => {
+      const state = createTransportState();
+      transportReducers.setPlaying(state, { payload: true });
+      expect(state.transport.isPlaying).toBe(true);
+    });
+
+    it("resets currentStep16 when stopping", () => {
+      const state = createTransportState();
+      state.transport.currentStep16 = 8;
+      transportReducers.setPlaying(state, { payload: false });
+      expect(state.transport.isPlaying).toBe(false);
+      expect(state.transport.currentStep16).toBe(0);
+    });
+  });
+
+  describe("setRecording", () => {
+    it("toggles recording state", () => {
+      const state = createTransportState();
+      transportReducers.setRecording(state, { payload: true });
+      expect(state.transport.isRecording).toBe(true);
+    });
+  });
+
+  describe("setTransportMode", () => {
+    it("changes mode to song", () => {
+      const state = createTransportState();
+      transportReducers.setTransportMode(state, { payload: "song" });
+      expect(state.transport.mode).toBe("song");
+    });
+  });
+
+  describe("setSongLoopEnabled", () => {
+    it("enables loop", () => {
+      const state = createTransportState();
+      transportReducers.setSongLoopEnabled(state, { payload: 1 });
+      expect(state.transport.songLoopEnabled).toBe(true);
+    });
+
+    it("disables loop with falsy value", () => {
+      const state = createTransportState();
+      transportReducers.setSongLoopEnabled(state, { payload: false });
+      expect(state.transport.songLoopEnabled).toBe(false);
+    });
+  });
+
+  describe("setPlayheadStep", () => {
+    it("sets step to requested value", () => {
+      const state = createTransportState();
+      transportReducers.setPlayheadStep(state, { payload: 16 });
+      expect(state.transport.currentStep16).toBe(16);
+    });
+
+    it("clamps negative step to 0", () => {
+      const state = createTransportState();
+      transportReducers.setPlayheadStep(state, { payload: -5 });
+      expect(state.transport.currentStep16).toBe(0);
+    });
+
+    it("rounds fractional steps", () => {
+      const state = createTransportState();
+      transportReducers.setPlayheadStep(state, { payload: 7.8 });
+      expect(state.transport.currentStep16).toBe(8);
+    });
+  });
+});