Xiaohan-Tian
846 lines
31 KiB
TypeScript
846 lines
31 KiB
TypeScript
import { describe, it, expect, vi, beforeEach } from 'vitest';
|
|
import { act } from '@testing-library/react';
|
|
import { KGTrack } from '../core/track/KGTrack';
|
|
import { KGMidiTrack } from '../core/track/KGMidiTrack';
|
|
import { KGAudioTrack } from '../core/track/KGAudioTrack';
|
|
import { KGAudioRegion } from '../core/region/KGAudioRegion';
|
|
import { KGMidiRegion } from '../core/region/KGMidiRegion';
|
|
import { KGMidiNote } from '../core/midi/KGMidiNote';
|
|
import { createDefaultGlobalTracks } from '../core/global-track';
|
|
import { getAudioRegionDisplayLengthBeats } from '../util/globalTrackUtil';
|
|
|
|
const pianoRollStateMocks = vi.hoisted(() => ({
|
|
setSheetMusicViewEnabled: vi.fn(),
|
|
setPianoRollZoom: vi.fn(),
|
|
}));
|
|
|
|
const audioStorageMocks = vi.hoisted(() => ({
|
|
loadAudioFile: vi.fn(),
|
|
}));
|
|
|
|
const toneMocks = vi.hoisted(() => {
|
|
const decodeAudioData = vi.fn();
|
|
const toneBufferSet = vi.fn();
|
|
|
|
class MockToneAudioBuffer {
|
|
public set = toneBufferSet;
|
|
}
|
|
|
|
return {
|
|
decodeAudioData,
|
|
toneBufferSet,
|
|
ToneAudioBuffer: MockToneAudioBuffer,
|
|
};
|
|
});
|
|
|
|
let mockTracks: KGTrack[] = [new KGMidiTrack('Track 1', 0, 'acoustic_grand_piano')];
|
|
let mockIsMetronomeEnabled = false;
|
|
let mockShowGlobalTracks = false;
|
|
let mockPlayheadPosition = 0;
|
|
let mockSelectedItems: Array<{ getId: () => string; select: () => void; deselect: () => void; isSelected: () => boolean }> = [];
|
|
let mockCopiedItems: Array<{ getId: () => string }> = [];
|
|
const selectionChangedCallbacks: Array<() => void> = [];
|
|
const mockProject = {
|
|
getTimeSignature: () => ({ numerator: 4, denominator: 4 }),
|
|
getMaxBars: () => 32,
|
|
getBarWidthMultiplier: () => 1,
|
|
getTracks: () => mockTracks,
|
|
getGlobalTracks: () => createDefaultGlobalTracks(),
|
|
getBpm: () => 120,
|
|
getKeySignature: () => 'C major',
|
|
getName: () => 'Test Project',
|
|
getSelectedMode: () => 'major',
|
|
getIsLooping: () => false,
|
|
getIsMetronomeEnabled: () => mockIsMetronomeEnabled,
|
|
setIsMetronomeEnabled: vi.fn((value: boolean) => {
|
|
mockIsMetronomeEnabled = value;
|
|
}),
|
|
getShowGlobalTracks: () => mockShowGlobalTracks,
|
|
setShowGlobalTracks: vi.fn((value: boolean) => {
|
|
mockShowGlobalTracks = value;
|
|
}),
|
|
getPlayheadPosition: () => mockPlayheadPosition,
|
|
setPlayheadPosition: vi.fn((position: number) => {
|
|
mockPlayheadPosition = position;
|
|
}),
|
|
getLoopingRange: () => [0, 0] as [number, number],
|
|
getPianoRollZoom: () => 1,
|
|
};
|
|
let currentProject = mockProject;
|
|
|
|
const mockAudioInterface = {
|
|
getTransportPosition: vi.fn().mockReturnValue(8),
|
|
startAudioRecording: vi.fn().mockResolvedValue({ usedDeviceId: 'default', fellBackToDefault: false }),
|
|
stopAudioRecording: vi.fn().mockResolvedValue(null),
|
|
cancelAudioRecording: vi.fn().mockResolvedValue(undefined),
|
|
removeTrackSynth: vi.fn(),
|
|
removeTrackAudioPlayerBus: vi.fn(),
|
|
createTrackAudioPlayerBus: vi.fn().mockResolvedValue(undefined),
|
|
hasTrackAudioPlayerBus: vi.fn().mockReturnValue(true),
|
|
hasAudioBufferForTrack: vi.fn().mockReturnValue(false),
|
|
getAudioBuffer: vi.fn(),
|
|
loadAudioBufferForTrack: vi.fn(),
|
|
createTrackSynth: vi.fn(),
|
|
setTrackVolume: vi.fn(),
|
|
setTrackMute: vi.fn(),
|
|
setTrackSolo: vi.fn(),
|
|
setMetronomeEnabled: vi.fn(),
|
|
};
|
|
|
|
const configValues = new Map<string, unknown>([
|
|
['audio.input_device_id', 'default'],
|
|
]);
|
|
|
|
const mockCore = {
|
|
getCurrentProject: () => currentProject,
|
|
setCurrentProject: vi.fn((project: typeof mockProject) => {
|
|
currentProject = project;
|
|
}),
|
|
setPlayheadUpdateCallback: vi.fn(),
|
|
setPlaybackStateChangeCallback: vi.fn(),
|
|
setLoopBoundaryReachedCallback: vi.fn(),
|
|
getSelectedItems: () => mockSelectedItems,
|
|
getCopiedItems: () => mockCopiedItems,
|
|
onSelectionChanged: vi.fn((callback: () => void) => {
|
|
selectionChangedCallbacks.push(callback);
|
|
}),
|
|
canUndo: () => false,
|
|
canRedo: () => false,
|
|
getUndoDescription: () => '',
|
|
getRedoDescription: () => '',
|
|
setOnCommandHistoryChanged: vi.fn(),
|
|
executeCommand: vi.fn(),
|
|
undo: vi.fn(() => true),
|
|
redo: vi.fn(() => true),
|
|
clearSelectedItems: vi.fn(() => {
|
|
mockSelectedItems = [];
|
|
selectionChangedCallbacks.forEach(callback => callback());
|
|
}),
|
|
addSelectedItems: vi.fn((items: Array<{ getId: () => string; select: () => void; deselect: () => void; isSelected: () => boolean }>) => {
|
|
const incomingIds = new Set(items.map(item => item.getId()));
|
|
mockSelectedItems = mockSelectedItems.filter(item => !incomingIds.has(item.getId()));
|
|
mockSelectedItems.push(...items);
|
|
selectionChangedCallbacks.forEach(callback => callback());
|
|
}),
|
|
getStatus: () => 'Ready',
|
|
setStatus: vi.fn(),
|
|
getPlayheadPosition: () => mockPlayheadPosition,
|
|
setPlayheadPosition: vi.fn((position: number) => {
|
|
mockPlayheadPosition = position;
|
|
}),
|
|
getIsPlaying: () => false,
|
|
startPlaying: vi.fn().mockResolvedValue(undefined),
|
|
stopPlaying: vi.fn().mockResolvedValue(undefined),
|
|
};
|
|
|
|
vi.mock('../core/KGCore', () => ({
|
|
KGCore: {
|
|
instance: () => mockCore,
|
|
},
|
|
}));
|
|
|
|
vi.mock('../core/audio-interface/KGAudioInterface', () => ({
|
|
KGAudioInterface: {
|
|
instance: () => mockAudioInterface,
|
|
},
|
|
}));
|
|
|
|
vi.mock('../core/io/KGAudioFileStorage', () => ({
|
|
KGAudioFileStorage: {
|
|
loadAudioFile: audioStorageMocks.loadAudioFile,
|
|
},
|
|
}));
|
|
|
|
vi.mock('tone', () => ({
|
|
getContext: () => ({
|
|
rawContext: {
|
|
decodeAudioData: toneMocks.decodeAudioData,
|
|
},
|
|
}),
|
|
ToneAudioBuffer: toneMocks.ToneAudioBuffer,
|
|
}));
|
|
|
|
vi.mock('../core/config/ConfigManager', () => ({
|
|
ConfigManager: {
|
|
instance: () => ({
|
|
getIsInitialized: () => true,
|
|
get: (key: string) => configValues.get(key),
|
|
set: vi.fn(async (key: string, value: unknown) => {
|
|
configValues.set(key, value);
|
|
}),
|
|
}),
|
|
},
|
|
}));
|
|
|
|
vi.mock('../core/state/KGPianoRollState', () => ({
|
|
KGPianoRollState: {
|
|
instance: () => pianoRollStateMocks,
|
|
},
|
|
}));
|
|
|
|
describe('projectStore piano roll state', () => {
|
|
beforeEach(() => {
|
|
vi.useFakeTimers();
|
|
vi.resetModules();
|
|
pianoRollStateMocks.setSheetMusicViewEnabled.mockReset();
|
|
pianoRollStateMocks.setPianoRollZoom.mockReset();
|
|
mockTracks = [new KGMidiTrack('Track 1', 0, 'acoustic_grand_piano')];
|
|
currentProject = mockProject;
|
|
mockPlayheadPosition = 0;
|
|
mockCore.startPlaying.mockReset();
|
|
mockCore.startPlaying.mockResolvedValue(undefined);
|
|
mockCore.stopPlaying.mockReset();
|
|
mockCore.stopPlaying.mockResolvedValue(undefined);
|
|
mockCore.executeCommand.mockReset();
|
|
mockCore.setPlayheadPosition.mockClear();
|
|
mockCore.undo.mockReset();
|
|
mockCore.undo.mockReturnValue(true);
|
|
mockCore.redo.mockReset();
|
|
mockCore.redo.mockReturnValue(true);
|
|
mockCore.setLoopBoundaryReachedCallback.mockReset();
|
|
mockAudioInterface.startAudioRecording.mockReset();
|
|
mockAudioInterface.startAudioRecording.mockResolvedValue({ usedDeviceId: 'default', fellBackToDefault: false });
|
|
mockAudioInterface.stopAudioRecording.mockReset();
|
|
mockAudioInterface.stopAudioRecording.mockResolvedValue(null);
|
|
mockAudioInterface.cancelAudioRecording.mockReset();
|
|
mockAudioInterface.cancelAudioRecording.mockResolvedValue(undefined);
|
|
mockAudioInterface.getTransportPosition.mockReset();
|
|
mockAudioInterface.getTransportPosition.mockReturnValue(8);
|
|
mockAudioInterface.hasTrackAudioPlayerBus.mockReset();
|
|
mockAudioInterface.hasTrackAudioPlayerBus.mockReturnValue(true);
|
|
mockAudioInterface.hasAudioBufferForTrack.mockReset();
|
|
mockAudioInterface.hasAudioBufferForTrack.mockReturnValue(false);
|
|
mockAudioInterface.getAudioBuffer.mockReset();
|
|
mockAudioInterface.createTrackAudioPlayerBus.mockReset();
|
|
mockAudioInterface.createTrackAudioPlayerBus.mockResolvedValue(undefined);
|
|
mockAudioInterface.loadAudioBufferForTrack.mockReset();
|
|
mockAudioInterface.setMetronomeEnabled.mockReset();
|
|
audioStorageMocks.loadAudioFile.mockReset();
|
|
toneMocks.decodeAudioData.mockReset();
|
|
toneMocks.toneBufferSet.mockReset();
|
|
mockSelectedItems = [];
|
|
mockCopiedItems = [];
|
|
selectionChangedCallbacks.length = 0;
|
|
mockCore.onSelectionChanged.mockClear();
|
|
mockCore.clearSelectedItems.mockClear();
|
|
mockCore.addSelectedItems.mockClear();
|
|
mockIsMetronomeEnabled = false;
|
|
mockShowGlobalTracks = false;
|
|
mockProject.setIsMetronomeEnabled.mockClear();
|
|
mockProject.setShowGlobalTracks.mockClear();
|
|
mockProject.setPlayheadPosition.mockClear();
|
|
configValues.set('audio.input_device_id', 'default');
|
|
});
|
|
|
|
it('clears hybrid state when opening a MIDI region', async () => {
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().openHybridMode('midi-a', 'audio-a');
|
|
});
|
|
|
|
let state = useProjectStore.getState();
|
|
expect(state.pianoRollMode).toBe('hybrid');
|
|
expect(state.activeRegionId).toBe('midi-a');
|
|
expect(state.hybridAudioRegionId).toBe('audio-a');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().openMidiPianoRoll('midi-b');
|
|
});
|
|
|
|
state = useProjectStore.getState();
|
|
expect(pianoRollStateMocks.setSheetMusicViewEnabled).toHaveBeenCalledWith(false);
|
|
expect(state.showPianoRoll).toBe(true);
|
|
expect(state.pianoRollMode).toBe('midi-edit');
|
|
expect(state.activeRegionId).toBe('midi-b');
|
|
expect(state.hybridAudioRegionId).toBeNull();
|
|
expect(state.requestedSheetMusicViewEnabled).toBe(false);
|
|
expect(state.pianoRollViewRequestVersion).toBe(1);
|
|
});
|
|
|
|
it('opens a MIDI region in sheet music view when requested', async () => {
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().openHybridMode('midi-a', 'audio-a');
|
|
});
|
|
|
|
act(() => {
|
|
useProjectStore.getState().openMidiPianoRollWithSheetMusicView('midi-b', true);
|
|
});
|
|
|
|
const state = useProjectStore.getState();
|
|
expect(pianoRollStateMocks.setSheetMusicViewEnabled).toHaveBeenCalledWith(true);
|
|
expect(state.showPianoRoll).toBe(true);
|
|
expect(state.pianoRollMode).toBe('midi-edit');
|
|
expect(state.activeRegionId).toBe('midi-b');
|
|
expect(state.hybridAudioRegionId).toBeNull();
|
|
expect(state.requestedSheetMusicViewEnabled).toBe(true);
|
|
expect(state.pianoRollViewRequestVersion).toBe(1);
|
|
});
|
|
|
|
it('opens an audio region in waveform view and clears hybrid state', async () => {
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().openHybridMode('midi-a', 'audio-a');
|
|
});
|
|
|
|
act(() => {
|
|
useProjectStore.getState().openAudioWaveformViewer('audio-b');
|
|
});
|
|
|
|
const state = useProjectStore.getState();
|
|
expect(state.showPianoRoll).toBe(true);
|
|
expect(state.pianoRollMode).toBe('audio-waveform');
|
|
expect(state.activeRegionId).toBe('audio-b');
|
|
expect(state.hybridAudioRegionId).toBeNull();
|
|
expect(state.requestedSheetMusicViewEnabled).toBe(false);
|
|
});
|
|
|
|
it('initializes persisted metronome and global-track visibility state from the project', async () => {
|
|
mockIsMetronomeEnabled = true;
|
|
mockShowGlobalTracks = true;
|
|
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
const state = useProjectStore.getState();
|
|
expect(state.isMetronomeEnabled).toBe(true);
|
|
expect(state.showGlobalTracks).toBe(true);
|
|
});
|
|
|
|
it('persists metronome toggles to the project and audio interface', async () => {
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().toggleMetronome();
|
|
});
|
|
|
|
const state = useProjectStore.getState();
|
|
expect(mockProject.setIsMetronomeEnabled).toHaveBeenCalledWith(true);
|
|
expect(mockAudioInterface.setMetronomeEnabled).toHaveBeenCalledWith(true);
|
|
expect(state.isMetronomeEnabled).toBe(true);
|
|
});
|
|
|
|
it('persists global-track visibility changes to the project', async () => {
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().setShowGlobalTracks(true);
|
|
});
|
|
|
|
const state = useProjectStore.getState();
|
|
expect(mockProject.setShowGlobalTracks).toHaveBeenCalledWith(true);
|
|
expect(state.showGlobalTracks).toBe(true);
|
|
});
|
|
|
|
it('tracks playback preparation around startPlaying success', async () => {
|
|
let resolveStart: (() => void) | null = null;
|
|
mockCore.startPlaying.mockImplementationOnce(() => new Promise<void>((resolve) => {
|
|
resolveStart = resolve;
|
|
}));
|
|
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
const startPromise = useProjectStore.getState().startPlaying();
|
|
expect(useProjectStore.getState().isPreparingPlayback).toBe(true);
|
|
|
|
await act(async () => {
|
|
resolveStart?.();
|
|
await startPromise;
|
|
});
|
|
|
|
const state = useProjectStore.getState();
|
|
expect(state.isPreparingPlayback).toBe(false);
|
|
expect(state.isPlaying).toBe(true);
|
|
});
|
|
|
|
it('clears playback preparation if startPlaying fails', async () => {
|
|
mockCore.startPlaying.mockRejectedValueOnce(new Error('prepare failed'));
|
|
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
await expect(useProjectStore.getState().startPlaying()).rejects.toThrow('prepare failed');
|
|
expect(useProjectStore.getState().isPreparingPlayback).toBe(false);
|
|
});
|
|
|
|
it('ignores repeated startPlaying calls while already preparing', async () => {
|
|
let resolveStart: (() => void) | null = null;
|
|
mockCore.startPlaying.mockImplementationOnce(() => new Promise<void>((resolve) => {
|
|
resolveStart = resolve;
|
|
}));
|
|
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
const firstStart = useProjectStore.getState().startPlaying();
|
|
const secondStart = useProjectStore.getState().startPlaying();
|
|
|
|
expect(mockCore.startPlaying).toHaveBeenCalledTimes(1);
|
|
|
|
await act(async () => {
|
|
resolveStart?.();
|
|
await Promise.all([firstStart, secondStart]);
|
|
});
|
|
});
|
|
|
|
it('clears playback preparation when stopTransport is called during prepare', async () => {
|
|
let resolveStart: (() => void) | null = null;
|
|
mockCore.startPlaying.mockImplementationOnce(() => new Promise<void>((resolve) => {
|
|
resolveStart = resolve;
|
|
}));
|
|
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
const startPromise = useProjectStore.getState().startPlaying();
|
|
expect(useProjectStore.getState().isPreparingPlayback).toBe(true);
|
|
|
|
await act(async () => {
|
|
await useProjectStore.getState().stopTransport();
|
|
});
|
|
|
|
expect(useProjectStore.getState().isPreparingPlayback).toBe(false);
|
|
|
|
await act(async () => {
|
|
resolveStart?.();
|
|
await startPromise;
|
|
});
|
|
});
|
|
|
|
it('starts and stops audio-track recording without requiring a selected region', async () => {
|
|
const { KGAudioTrack } = await import('../core/track/KGAudioTrack');
|
|
const audioTrack = new KGAudioTrack('Audio 1', 1);
|
|
audioTrack.setTrackIndex(0);
|
|
mockTracks = [audioTrack];
|
|
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().setSelectedTrack('1');
|
|
useProjectStore.getState().setPlayheadPosition(8);
|
|
});
|
|
|
|
await act(async () => {
|
|
await useProjectStore.getState().startRecording();
|
|
});
|
|
|
|
await act(async () => {
|
|
vi.advanceTimersByTime(2000);
|
|
await Promise.resolve();
|
|
});
|
|
|
|
expect(mockCore.startPlaying).toHaveBeenCalledWith({ preserveLoopPreroll: false });
|
|
expect(mockAudioInterface.startAudioRecording).toHaveBeenCalled();
|
|
expect(useProjectStore.getState().recordingMode).toBe('audio');
|
|
expect(useProjectStore.getState().recordingCommitStartBeatAbsolute).toBe(8);
|
|
|
|
await act(async () => {
|
|
await useProjectStore.getState().stopTransport();
|
|
});
|
|
|
|
expect(mockAudioInterface.stopAudioRecording).toHaveBeenCalled();
|
|
expect(useProjectStore.getState().isRecording).toBe(false);
|
|
expect(useProjectStore.getState().recordingMode).toBeNull();
|
|
expect(useProjectStore.getState().playheadPosition).toBe(8);
|
|
});
|
|
|
|
it('bumps track automation redraw version on undo and redo', async () => {
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
const initialVersion = useProjectStore.getState().trackAutomationRedrawVersion;
|
|
|
|
act(() => {
|
|
useProjectStore.getState().undo();
|
|
});
|
|
|
|
expect(useProjectStore.getState().trackAutomationRedrawVersion).toBe(initialVersion + 1);
|
|
|
|
act(() => {
|
|
useProjectStore.getState().redo();
|
|
});
|
|
|
|
expect(useProjectStore.getState().trackAutomationRedrawVersion).toBe(initialVersion + 2);
|
|
});
|
|
|
|
it('rehydrates missing audio buffers during refreshProjectState', async () => {
|
|
const audioTrack = new KGAudioTrack('Audio 1', 1);
|
|
audioTrack.setTrackIndex(0);
|
|
audioTrack.setRegions([
|
|
new KGAudioRegion('audio-region-1', '1', 0, 'clip.wav', 0, 4, 'audio-file-1.wav', 'clip.wav', 2.5),
|
|
]);
|
|
mockTracks = [audioTrack];
|
|
|
|
const decodedBuffer = { duration: 2.5 } as AudioBuffer;
|
|
audioStorageMocks.loadAudioFile.mockResolvedValue(new ArrayBuffer(16));
|
|
toneMocks.decodeAudioData.mockResolvedValue(decodedBuffer);
|
|
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
await act(async () => {
|
|
useProjectStore.getState().refreshProjectState();
|
|
await Promise.resolve();
|
|
await Promise.resolve();
|
|
});
|
|
|
|
expect(audioStorageMocks.loadAudioFile).toHaveBeenCalledWith('Test Project', 'audio-file-1.wav');
|
|
expect(toneMocks.decodeAudioData).toHaveBeenCalled();
|
|
expect(mockAudioInterface.loadAudioBufferForTrack).toHaveBeenCalledWith(
|
|
'1',
|
|
'audio-file-1.wav',
|
|
expect.any(toneMocks.ToneAudioBuffer),
|
|
);
|
|
});
|
|
|
|
it('reloads a restored audio track buffer on undo', async () => {
|
|
const restoredTrack = new KGAudioTrack('Audio 1', 1);
|
|
restoredTrack.setTrackIndex(0);
|
|
const restoredRegion = new KGAudioRegion(
|
|
'audio-region-1',
|
|
'1',
|
|
0,
|
|
'clip.wav',
|
|
0,
|
|
4,
|
|
'audio-file-1.wav',
|
|
'clip.wav',
|
|
2.5,
|
|
);
|
|
restoredTrack.setRegions([restoredRegion]);
|
|
|
|
mockTracks = [];
|
|
mockCore.undo.mockImplementationOnce(() => {
|
|
mockTracks = [restoredTrack];
|
|
return true;
|
|
});
|
|
|
|
const decodedBuffer = { duration: 2.5 } as AudioBuffer;
|
|
audioStorageMocks.loadAudioFile.mockResolvedValue(new ArrayBuffer(16));
|
|
toneMocks.decodeAudioData.mockResolvedValue(decodedBuffer);
|
|
|
|
const { useProjectStore } = await import('./projectStore');
|
|
const initialWaveformVersion = useProjectStore.getState().audioWaveformRedrawVersion;
|
|
|
|
await act(async () => {
|
|
useProjectStore.getState().undo();
|
|
await Promise.resolve();
|
|
await Promise.resolve();
|
|
});
|
|
|
|
const state = useProjectStore.getState();
|
|
expect(state.tracks).toHaveLength(1);
|
|
const restoredTrackState = state.tracks[0] as KGAudioTrack;
|
|
expect((restoredTrackState.getRegions()[0] as KGAudioRegion).getAudioFileId()).toBe('audio-file-1.wav');
|
|
expect(mockAudioInterface.loadAudioBufferForTrack).toHaveBeenCalledWith(
|
|
'1',
|
|
'audio-file-1.wav',
|
|
expect.any(toneMocks.ToneAudioBuffer),
|
|
);
|
|
expect(state.audioWaveformRedrawVersion).toBeGreaterThan(initialWaveformVersion);
|
|
});
|
|
|
|
it('does not attempt audio buffer hydration for MIDI-only undo', async () => {
|
|
mockTracks = [new KGMidiTrack('Track 1', 1, 'acoustic_grand_piano')];
|
|
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
await act(async () => {
|
|
useProjectStore.getState().undo();
|
|
await Promise.resolve();
|
|
});
|
|
|
|
expect(audioStorageMocks.loadAudioFile).not.toHaveBeenCalled();
|
|
expect(mockAudioInterface.loadAudioBufferForTrack).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('restores Chat after closing Settings when Chat was active on entry', async () => {
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().toggleChatBox();
|
|
useProjectStore.getState().setShowSettings(true);
|
|
});
|
|
|
|
let state = useProjectStore.getState();
|
|
expect(state.showSettings).toBe(true);
|
|
expect(state.settingsReturnSidePanel).toBe('chat');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().setShowSettings(false);
|
|
});
|
|
|
|
state = useProjectStore.getState();
|
|
expect(state.showSettings).toBe(false);
|
|
expect(state.showChatBox).toBe(true);
|
|
expect(state.showKGOnePanel).toBe(false);
|
|
expect(state.showEventListPanel).toBe(false);
|
|
});
|
|
|
|
it('restores K.G.One after closing Settings when K.G.One was active on entry', async () => {
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().toggleKGOnePanel();
|
|
useProjectStore.getState().setShowSettings(true);
|
|
useProjectStore.getState().setShowSettings(false);
|
|
});
|
|
|
|
const state = useProjectStore.getState();
|
|
expect(state.showSettings).toBe(false);
|
|
expect(state.showKGOnePanel).toBe(true);
|
|
expect(state.showChatBox).toBe(false);
|
|
expect(state.showEventListPanel).toBe(false);
|
|
});
|
|
|
|
it('restores no side panel after closing Settings when none was active on entry', async () => {
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().toggleChatBox();
|
|
useProjectStore.getState().toggleChatBox();
|
|
useProjectStore.getState().setShowSettings(true);
|
|
useProjectStore.getState().setShowSettings(false);
|
|
});
|
|
|
|
const state = useProjectStore.getState();
|
|
expect(state.showSettings).toBe(false);
|
|
expect(state.showChatBox).toBe(false);
|
|
expect(state.showKGOnePanel).toBe(false);
|
|
expect(state.showEventListPanel).toBe(false);
|
|
expect(state.settingsReturnSidePanel).toBeNull();
|
|
expect(state.lastActiveSidePanel).toBe('chat');
|
|
});
|
|
|
|
it('opens Event List and exits Settings when Event List is activated from Settings', async () => {
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().toggleChatBox();
|
|
useProjectStore.getState().setShowSettings(true);
|
|
useProjectStore.getState().activateSidePanel('eventList');
|
|
});
|
|
|
|
const state = useProjectStore.getState();
|
|
expect(state.showSettings).toBe(false);
|
|
expect(state.showEventListPanel).toBe(true);
|
|
expect(state.showChatBox).toBe(false);
|
|
expect(state.showKGOnePanel).toBe(false);
|
|
expect(state.settingsReturnSidePanel).toBeNull();
|
|
expect(state.lastActiveSidePanel).toBe('eventList');
|
|
});
|
|
|
|
it('refreshes expanded max bars after BPM reduction', async () => {
|
|
const { KGAudioTrack: TestAudioTrack } = await import('../core/track/KGAudioTrack');
|
|
const { KGAudioRegion: TestAudioRegion } = await import('../core/region/KGAudioRegion');
|
|
|
|
const audioTrack = new TestAudioTrack('Audio 1', 1);
|
|
audioTrack.setTrackIndex(0);
|
|
const audioRegion = new TestAudioRegion('audio-region-1', '1', 0, 'clip.wav', 124, 4, 'audio-file-1.wav', 'clip.wav', 8, 0);
|
|
audioTrack.setRegions([audioRegion]);
|
|
|
|
let projectName = 'Test Project';
|
|
let bpm = 120;
|
|
let maxBars = 32;
|
|
let currentBars = 0;
|
|
let timeSignature = { numerator: 4, denominator: 4 };
|
|
let keySignature = 'C major';
|
|
let selectedMode = 'major';
|
|
const project = {
|
|
getName: () => projectName,
|
|
setName: (value: string) => { projectName = value; },
|
|
getMaxBars: () => maxBars,
|
|
setMaxBars: (value: number) => { maxBars = value; },
|
|
getCurrentBars: () => currentBars,
|
|
setCurrentBars: (value: number) => { currentBars = value; },
|
|
getTimeSignature: () => timeSignature,
|
|
setTimeSignature: (value: { numerator: number; denominator: number }) => { timeSignature = value; },
|
|
getBarWidthMultiplier: () => 1,
|
|
getTracks: () => [audioTrack],
|
|
getGlobalTracks: () => createDefaultGlobalTracks(),
|
|
getBpm: () => bpm,
|
|
setBpm: (value: number) => { bpm = value; },
|
|
getKeySignature: () => keySignature,
|
|
setKeySignature: (value: string) => { keySignature = value; },
|
|
getSelectedMode: () => selectedMode,
|
|
setSelectedMode: (value: string) => { selectedMode = value; },
|
|
getIsLooping: () => false,
|
|
getIsMetronomeEnabled: () => false,
|
|
setIsMetronomeEnabled: vi.fn(),
|
|
getShowGlobalTracks: () => false,
|
|
setShowGlobalTracks: vi.fn(),
|
|
getLoopingRange: () => [0, 0] as [number, number],
|
|
getPianoRollZoom: () => 1,
|
|
};
|
|
currentProject = project as unknown as typeof mockProject;
|
|
mockCore.executeCommand.mockImplementation((command: { execute: () => void }) => command.execute());
|
|
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().setBpm(60);
|
|
});
|
|
|
|
const state = useProjectStore.getState();
|
|
expect(bpm).toBe(60);
|
|
expect(maxBars).toBe(33);
|
|
expect(state.maxBars).toBe(33);
|
|
expect(audioRegion.getLength()).toBeCloseTo(8);
|
|
expect(getAudioRegionDisplayLengthBeats(project as any, audioRegion)).toBeCloseTo(8);
|
|
});
|
|
|
|
it('does not auto-shrink max bars after BPM increase', async () => {
|
|
const { KGAudioTrack: TestAudioTrack } = await import('../core/track/KGAudioTrack');
|
|
const { KGAudioRegion: TestAudioRegion } = await import('../core/region/KGAudioRegion');
|
|
|
|
const audioTrack = new TestAudioTrack('Audio 1', 1);
|
|
audioTrack.setTrackIndex(0);
|
|
audioTrack.setRegions([
|
|
new TestAudioRegion('audio-region-1', '1', 0, 'clip.wav', 124, 8, 'audio-file-1.wav', 'clip.wav', 4, 0),
|
|
]);
|
|
|
|
let projectName = 'Test Project';
|
|
let bpm = 120;
|
|
let maxBars = 40;
|
|
let currentBars = 0;
|
|
let timeSignature = { numerator: 4, denominator: 4 };
|
|
let keySignature = 'C major';
|
|
let selectedMode = 'major';
|
|
const project = {
|
|
getName: () => projectName,
|
|
setName: (value: string) => { projectName = value; },
|
|
getMaxBars: () => maxBars,
|
|
setMaxBars: (value: number) => { maxBars = value; },
|
|
getCurrentBars: () => currentBars,
|
|
setCurrentBars: (value: number) => { currentBars = value; },
|
|
getTimeSignature: () => timeSignature,
|
|
setTimeSignature: (value: { numerator: number; denominator: number }) => { timeSignature = value; },
|
|
getBarWidthMultiplier: () => 1,
|
|
getTracks: () => [audioTrack],
|
|
getGlobalTracks: () => createDefaultGlobalTracks(),
|
|
getBpm: () => bpm,
|
|
setBpm: (value: number) => { bpm = value; },
|
|
getKeySignature: () => keySignature,
|
|
setKeySignature: (value: string) => { keySignature = value; },
|
|
getSelectedMode: () => selectedMode,
|
|
setSelectedMode: (value: string) => { selectedMode = value; },
|
|
getIsLooping: () => false,
|
|
getIsMetronomeEnabled: () => false,
|
|
setIsMetronomeEnabled: vi.fn(),
|
|
getShowGlobalTracks: () => false,
|
|
setShowGlobalTracks: vi.fn(),
|
|
getLoopingRange: () => [0, 0] as [number, number],
|
|
getPianoRollZoom: () => 1,
|
|
};
|
|
currentProject = project as unknown as typeof mockProject;
|
|
mockCore.executeCommand.mockImplementation((command: { execute: () => void }) => command.execute());
|
|
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().setBpm(180);
|
|
});
|
|
|
|
const state = useProjectStore.getState();
|
|
expect(bpm).toBe(180);
|
|
expect(maxBars).toBe(40);
|
|
expect(state.maxBars).toBe(40);
|
|
expect((audioTrack.getRegions()[0] as KGAudioRegion).getLength()).toBeCloseTo(12);
|
|
});
|
|
|
|
it('moves the playhead to the song end when max bars shrink past it', async () => {
|
|
const { KGProject } = await import('../core/KGProject');
|
|
mockPlayheadPosition = 124;
|
|
|
|
currentProject = new KGProject('Test Project', 32, 0, 120) as unknown as typeof mockProject;
|
|
mockCore.executeCommand.mockImplementation((command: { execute: () => void }) => command.execute());
|
|
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().setMaxBars(16);
|
|
});
|
|
|
|
const state = useProjectStore.getState();
|
|
expect(currentProject.getMaxBars()).toBe(16);
|
|
expect(mockPlayheadPosition).toBe(64);
|
|
expect(mockCore.setPlayheadPosition).toHaveBeenCalledWith(64);
|
|
expect(state.maxBars).toBe(16);
|
|
expect(state.playheadPosition).toBe(64);
|
|
});
|
|
|
|
it('selects only the newly pasted notes after pasting into the active MIDI region', async () => {
|
|
const { KGMidiTrack: TestMidiTrack } = await import('../core/track/KGMidiTrack');
|
|
const { KGMidiRegion: TestMidiRegion } = await import('../core/region/KGMidiRegion');
|
|
const { KGMidiNote: TestMidiNote } = await import('../core/midi/KGMidiNote');
|
|
const track = new TestMidiTrack('Track 1', 1, 'acoustic_grand_piano');
|
|
track.setTrackIndex(0);
|
|
const region = new TestMidiRegion('region-1', '1', 0, 'Region 1', 0, 16);
|
|
const existingSelectedNote = new TestMidiNote('existing-note', 0, 1, 60, 100);
|
|
existingSelectedNote.select();
|
|
region.addNote(existingSelectedNote);
|
|
track.setRegions([region]);
|
|
|
|
mockTracks = [track];
|
|
currentProject = {
|
|
...mockProject,
|
|
getTracks: () => mockTracks,
|
|
} as typeof mockProject;
|
|
|
|
mockSelectedItems = [existingSelectedNote];
|
|
mockCopiedItems = [
|
|
new TestMidiNote('copied-a', 2, 3, 64, 110),
|
|
new TestMidiNote('copied-b', 3, 4, 67, 120),
|
|
];
|
|
mockCore.executeCommand.mockImplementation((command: { execute: () => void }) => command.execute());
|
|
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().pasteNotesToActiveRegion(region.getId(), 8);
|
|
});
|
|
|
|
const pastedNotes = region.getNotes().filter(note => note.getId() !== existingSelectedNote.getId());
|
|
const pastedNoteIds = pastedNotes.map(note => note.getId());
|
|
const state = useProjectStore.getState();
|
|
|
|
expect(mockCore.executeCommand).toHaveBeenCalledTimes(1);
|
|
expect(existingSelectedNote.isSelected()).toBe(false);
|
|
expect(pastedNotes).toHaveLength(2);
|
|
expect(pastedNotes.every(note => note.isSelected())).toBe(true);
|
|
expect(mockCore.clearSelectedItems).toHaveBeenCalledTimes(1);
|
|
expect(mockCore.addSelectedItems).toHaveBeenCalledWith(pastedNotes);
|
|
expect(state.selectedNoteIds).toEqual(pastedNoteIds);
|
|
});
|
|
|
|
it('keeps selection unchanged when note paste has no clipboard notes', async () => {
|
|
const { KGMidiTrack: TestMidiTrack } = await import('../core/track/KGMidiTrack');
|
|
const { KGMidiRegion: TestMidiRegion } = await import('../core/region/KGMidiRegion');
|
|
const { KGMidiNote: TestMidiNote } = await import('../core/midi/KGMidiNote');
|
|
const track = new TestMidiTrack('Track 1', 1, 'acoustic_grand_piano');
|
|
track.setTrackIndex(0);
|
|
const region = new TestMidiRegion('region-1', '1', 0, 'Region 1', 0, 16);
|
|
const existingSelectedNote = new TestMidiNote('existing-note', 0, 1, 60, 100);
|
|
existingSelectedNote.select();
|
|
region.addNote(existingSelectedNote);
|
|
track.setRegions([region]);
|
|
|
|
mockTracks = [track];
|
|
currentProject = {
|
|
...mockProject,
|
|
getTracks: () => mockTracks,
|
|
} as typeof mockProject;
|
|
|
|
mockSelectedItems = [existingSelectedNote];
|
|
mockCopiedItems = [];
|
|
|
|
const { useProjectStore } = await import('./projectStore');
|
|
|
|
act(() => {
|
|
useProjectStore.getState().pasteNotesToActiveRegion(region.getId(), 8);
|
|
});
|
|
|
|
expect(mockCore.executeCommand).not.toHaveBeenCalled();
|
|
expect(mockCore.clearSelectedItems).not.toHaveBeenCalled();
|
|
expect(mockCore.addSelectedItems).not.toHaveBeenCalled();
|
|
expect(existingSelectedNote.isSelected()).toBe(true);
|
|
});
|
|
});
|