loukai-app 0.3.0

package/src/shared/services/mixerService.test.js

@@ -0,0 +1,399 @@
+/**
+ * Mixer Service Tests
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import * as mixerService from './mixerService.js';
+
+// Mock AppState
+class MockAppState {
+  constructor() {
+    this.state = {
+      mixer: {
+        PA: { gain: 0, muted: false },
+        IEM: { gain: 0, muted: false },
+        mic: { gain: -6, muted: false },
+      },
+    };
+    this.updateMixerState = vi.fn();
+  }
+
+  getSnapshot() {
+    return { ...this.state };
+  }
+}
+
+// Mock MainApp for testing
+class MockMainApp {
+  constructor() {
+    this.appState = new MockAppState();
+    this.sendToRenderer = vi.fn();
+  }
+}
+
+describe('mixerService', () => {
+  let mainApp;
+  let appState;
+
+  beforeEach(() => {
+    mainApp = new MockMainApp();
+    appState = mainApp.appState;
+  });
+
+  describe('getMixerState', () => {
+    it('should return mixer state successfully', () => {
+      const result = mixerService.getMixerState(appState);
+
+      expect(result.success).toBe(true);
+      expect(result.mixer).toBeDefined();
+      expect(result.mixer.PA).toEqual({ gain: 0, muted: false });
+      expect(result.mixer.IEM).toEqual({ gain: 0, muted: false });
+      expect(result.mixer.mic).toEqual({ gain: -6, muted: false });
+    });
+
+    it('should handle getSnapshot errors', () => {
+      appState.getSnapshot = vi.fn(() => {
+        throw new Error('Snapshot failed');
+      });
+
+      const result = mixerService.getMixerState(appState);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Snapshot failed');
+    });
+
+    it('should return mixer even if empty', () => {
+      appState.state.mixer = {};
+
+      const result = mixerService.getMixerState(appState);
+
+      expect(result.success).toBe(true);
+      expect(result.mixer).toEqual({});
+    });
+  });
+
+  describe('setMasterGain', () => {
+    it('should set PA gain successfully', () => {
+      const result = mixerService.setMasterGain(mainApp, 'PA', 3);
+
+      expect(result.success).toBe(true);
+      expect(result.bus).toBe('PA');
+      expect(result.gainDb).toBe(3);
+      expect(appState.updateMixerState).toHaveBeenCalledWith(
+        expect.objectContaining({
+          PA: expect.objectContaining({
+            gain: 3,
+            muted: false,
+          }),
+        })
+      );
+      expect(mainApp.sendToRenderer).toHaveBeenCalledWith('mixer:setMasterGain', {
+        bus: 'PA',
+        gainDb: 3,
+      });
+    });
+
+    it('should set IEM gain successfully', () => {
+      const result = mixerService.setMasterGain(mainApp, 'IEM', -2);
+
+      expect(result.success).toBe(true);
+      expect(result.bus).toBe('IEM');
+      expect(result.gainDb).toBe(-2);
+    });
+
+    it('should set mic gain successfully', () => {
+      const result = mixerService.setMasterGain(mainApp, 'mic', -10);
+
+      expect(result.success).toBe(true);
+      expect(result.bus).toBe('mic');
+      expect(result.gainDb).toBe(-10);
+    });
+
+    it('should preserve other mixer state when updating', () => {
+      appState.state.mixer.PA.muted = true;
+
+      mixerService.setMasterGain(mainApp, 'PA', 5);
+
+      expect(appState.updateMixerState).toHaveBeenCalledWith(
+        expect.objectContaining({
+          PA: {
+            gain: 5,
+            muted: true, // Preserved
+          },
+        })
+      );
+    });
+
+    it('should return error when bus is missing', () => {
+      const result = mixerService.setMasterGain(mainApp, '', 0);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('bus (PA/IEM/mic) and gainDb required');
+      expect(appState.updateMixerState).not.toHaveBeenCalled();
+      expect(mainApp.sendToRenderer).not.toHaveBeenCalled();
+    });
+
+    it('should return error when gainDb is not a number', () => {
+      const result = mixerService.setMasterGain(mainApp, 'PA', 'loud');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('bus (PA/IEM/mic) and gainDb required');
+    });
+
+    it('should handle zero gain', () => {
+      const result = mixerService.setMasterGain(mainApp, 'PA', 0);
+
+      expect(result.success).toBe(true);
+      expect(result.gainDb).toBe(0);
+    });
+
+    it('should handle negative gain', () => {
+      const result = mixerService.setMasterGain(mainApp, 'PA', -12);
+
+      expect(result.success).toBe(true);
+      expect(result.gainDb).toBe(-12);
+    });
+
+    it('should handle large positive gain', () => {
+      const result = mixerService.setMasterGain(mainApp, 'PA', 20);
+
+      expect(result.success).toBe(true);
+      expect(result.gainDb).toBe(20);
+    });
+
+    it('should handle unknown bus gracefully', () => {
+      const result = mixerService.setMasterGain(mainApp, 'unknownBus', 0);
+
+      expect(result.success).toBe(true);
+      expect(appState.updateMixerState).not.toHaveBeenCalled();
+      expect(mainApp.sendToRenderer).toHaveBeenCalled();
+    });
+
+    it('should handle sendToRenderer errors', () => {
+      mainApp.sendToRenderer = vi.fn(() => {
+        throw new Error('Renderer not available');
+      });
+
+      const result = mixerService.setMasterGain(mainApp, 'PA', 0);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Renderer not available');
+    });
+  });
+
+  describe('toggleMasterMute', () => {
+    it('should toggle PA mute from false to true', () => {
+      appState.state.mixer.PA.muted = false;
+
+      const result = mixerService.toggleMasterMute(mainApp, 'PA');
+
+      expect(result.success).toBe(true);
+      expect(result.bus).toBe('PA');
+      expect(result.muted).toBe(true);
+      expect(appState.updateMixerState).toHaveBeenCalledWith(
+        expect.objectContaining({
+          PA: expect.objectContaining({
+            muted: true,
+          }),
+        })
+      );
+      expect(mainApp.sendToRenderer).toHaveBeenCalledWith('mixer:toggleMasterMute', {
+        bus: 'PA',
+        muted: true,
+      });
+    });
+
+    it('should toggle PA mute from true to false', () => {
+      appState.state.mixer.PA.muted = true;
+
+      const result = mixerService.toggleMasterMute(mainApp, 'PA');
+
+      expect(result.success).toBe(true);
+      expect(result.muted).toBe(false);
+    });
+
+    it('should toggle IEM mute', () => {
+      appState.state.mixer.IEM.muted = false;
+
+      const result = mixerService.toggleMasterMute(mainApp, 'IEM');
+
+      expect(result.success).toBe(true);
+      expect(result.bus).toBe('IEM');
+      expect(result.muted).toBe(true);
+    });
+
+    it('should toggle mic mute', () => {
+      appState.state.mixer.mic.muted = false;
+
+      const result = mixerService.toggleMasterMute(mainApp, 'mic');
+
+      expect(result.success).toBe(true);
+      expect(result.bus).toBe('mic');
+      expect(result.muted).toBe(true);
+    });
+
+    it('should preserve gain when toggling mute', () => {
+      appState.state.mixer.PA.gain = 5;
+      appState.state.mixer.PA.muted = false;
+
+      mixerService.toggleMasterMute(mainApp, 'PA');
+
+      expect(appState.updateMixerState).toHaveBeenCalledWith(
+        expect.objectContaining({
+          PA: {
+            gain: 5, // Preserved
+            muted: true,
+          },
+        })
+      );
+    });
+
+    it('should return error when bus is missing', () => {
+      const result = mixerService.toggleMasterMute(mainApp, '');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('bus (PA/IEM/mic) required');
+      expect(appState.updateMixerState).not.toHaveBeenCalled();
+      expect(mainApp.sendToRenderer).not.toHaveBeenCalled();
+    });
+
+    it('should return error when bus is null', () => {
+      const result = mixerService.toggleMasterMute(mainApp, null);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('bus (PA/IEM/mic) required');
+    });
+
+    it('should handle unknown bus gracefully', () => {
+      const result = mixerService.toggleMasterMute(mainApp, 'unknownBus');
+
+      expect(result.success).toBe(true);
+      expect(result.muted).toBe(false); // Default when bus doesn't exist
+      expect(appState.updateMixerState).not.toHaveBeenCalled();
+    });
+
+    it('should handle sendToRenderer errors', () => {
+      mainApp.sendToRenderer = vi.fn(() => {
+        throw new Error('Renderer error');
+      });
+
+      const result = mixerService.toggleMasterMute(mainApp, 'PA');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Renderer error');
+    });
+  });
+
+  describe('setMasterMute', () => {
+    it('should mute PA bus', () => {
+      appState.state.mixer.PA.muted = false;
+
+      const result = mixerService.setMasterMute(mainApp, 'PA', true);
+
+      expect(result.success).toBe(true);
+      expect(result.bus).toBe('PA');
+      expect(result.muted).toBe(true);
+      expect(appState.updateMixerState).toHaveBeenCalledWith(
+        expect.objectContaining({
+          PA: expect.objectContaining({
+            muted: true,
+          }),
+        })
+      );
+      expect(mainApp.sendToRenderer).toHaveBeenCalledWith('mixer:setMasterMute', {
+        bus: 'PA',
+        muted: true,
+      });
+    });
+
+    it('should unmute PA bus', () => {
+      appState.state.mixer.PA.muted = true;
+
+      const result = mixerService.setMasterMute(mainApp, 'PA', false);
+
+      expect(result.success).toBe(true);
+      expect(result.bus).toBe('PA');
+      expect(result.muted).toBe(false);
+      expect(appState.updateMixerState).toHaveBeenCalledWith(
+        expect.objectContaining({
+          PA: expect.objectContaining({
+            muted: false,
+          }),
+        })
+      );
+    });
+
+    it('should mute IEM bus', () => {
+      const result = mixerService.setMasterMute(mainApp, 'IEM', true);
+
+      expect(result.success).toBe(true);
+      expect(result.bus).toBe('IEM');
+      expect(result.muted).toBe(true);
+    });
+
+    it('should mute mic bus', () => {
+      const result = mixerService.setMasterMute(mainApp, 'mic', true);
+
+      expect(result.success).toBe(true);
+      expect(result.bus).toBe('mic');
+      expect(result.muted).toBe(true);
+    });
+
+    it('should preserve gain when setting mute', () => {
+      appState.state.mixer.PA.gain = 10;
+
+      mixerService.setMasterMute(mainApp, 'PA', true);
+
+      expect(appState.updateMixerState).toHaveBeenCalledWith(
+        expect.objectContaining({
+          PA: {
+            gain: 10, // Preserved
+            muted: true,
+          },
+        })
+      );
+    });
+
+    it('should return error when bus is missing', () => {
+      const result = mixerService.setMasterMute(mainApp, '', true);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('bus (PA/IEM/mic) and muted status required');
+      expect(appState.updateMixerState).not.toHaveBeenCalled();
+      expect(mainApp.sendToRenderer).not.toHaveBeenCalled();
+    });
+
+    it('should return error when muted is not boolean', () => {
+      const result = mixerService.setMasterMute(mainApp, 'PA', 'yes');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('bus (PA/IEM/mic) and muted status required');
+    });
+
+    it('should return error when muted is null', () => {
+      const result = mixerService.setMasterMute(mainApp, 'PA', null);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('bus (PA/IEM/mic) and muted status required');
+    });
+
+    it('should handle unknown bus gracefully', () => {
+      const result = mixerService.setMasterMute(mainApp, 'unknownBus', true);
+
+      expect(result.success).toBe(true);
+      expect(appState.updateMixerState).not.toHaveBeenCalled();
+      expect(mainApp.sendToRenderer).toHaveBeenCalled();
+    });
+
+    it('should handle sendToRenderer errors', () => {
+      mainApp.sendToRenderer = vi.fn(() => {
+        throw new Error('Communication error');
+      });
+
+      const result = mixerService.setMasterMute(mainApp, 'PA', true);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Communication error');
+    });
+  });
+});

package/src/shared/services/playerService.js

@@ -0,0 +1,221 @@
+/**
+ * Player Service - Shared business logic for playback control
+ *
+ * Used by both IPC handlers (Electron) and REST endpoints (Web Server)
+ * to ensure consistent player control across all interfaces.
+ */
+
+/**
+ * Send play command to renderer
+ * @param {Object} mainApp - Main application instance
+ * @returns {Object} Result with success status
+ */
+export function play(mainApp) {
+  if (mainApp.mainWindow && !mainApp.mainWindow.isDestroyed()) {
+    // Send IPC event to renderer
+    mainApp.mainWindow.webContents.send('player:togglePlayback');
+    return { success: true, message: 'Play command sent' };
+  }
+
+  return {
+    success: false,
+    error: 'Main window not available',
+  };
+}
+
+/**
+ * Send pause command to renderer
+ * @param {Object} mainApp - Main application instance
+ * @returns {Object} Result with success status
+ */
+export function pause(mainApp) {
+  if (mainApp.mainWindow && !mainApp.mainWindow.isDestroyed()) {
+    // Send IPC event to renderer
+    mainApp.mainWindow.webContents.send('player:togglePlayback');
+    return { success: true, message: 'Pause command sent' };
+  }
+
+  return {
+    success: false,
+    error: 'Main window not available',
+  };
+}
+
+/**
+ * Send restart command to renderer
+ * @param {Object} mainApp - Main application instance
+ * @returns {Object} Result with success status
+ */
+export function restart(mainApp) {
+  if (mainApp.mainWindow && !mainApp.mainWindow.isDestroyed()) {
+    // Send IPC event to renderer
+    mainApp.mainWindow.webContents.send('player:restart');
+    return { success: true, message: 'Restart command sent' };
+  }
+
+  return {
+    success: false,
+    error: 'Main window not available',
+  };
+}
+
+/**
+ * Send seek command to renderer
+ * @param {Object} mainApp - Main application instance
+ * @param {number} positionSec - Position in seconds to seek to
+ * @returns {Object} Result with success status
+ */
+export function seek(mainApp, positionSec) {
+  if (typeof positionSec !== 'number') {
+    return {
+      success: false,
+      error: 'Position must be a number',
+    };
+  }
+
+  if (mainApp.mainWindow && !mainApp.mainWindow.isDestroyed()) {
+    // Send IPC event to renderer with position parameter
+    mainApp.mainWindow.webContents.send('player:setPosition', positionSec);
+    return { success: true, message: 'Seek command sent', position: positionSec };
+  }
+
+  return {
+    success: false,
+    error: 'Main window not available',
+  };
+}
+
+/**
+ * Load and play a song file
+ * @param {Object} mainApp - Main application instance
+ * @param {string} filePath - Path to the song file
+ * @returns {Promise<Object>} Result with success status and song data
+ */
+export async function loadSong(mainApp, filePath) {
+  try {
+    if (!filePath) {
+      return {
+        success: false,
+        error: 'File path is required',
+      };
+    }
+
+    const result = await mainApp.loadKaiFile(filePath);
+
+    if (result && result.success) {
+      return {
+        success: true,
+        song: result.song || result,
+        message: 'Song loaded successfully',
+      };
+    }
+
+    return {
+      success: false,
+      error: 'Failed to load song',
+    };
+  } catch (error) {
+    console.error('Error loading song:', error);
+    return {
+      success: false,
+      error: error.message,
+    };
+  }
+}
+
+/**
+ * Skip to next song in queue
+ * @param {Object} mainApp - Main application instance
+ * @returns {Promise<Object>} Result with success status and next song
+ */
+export async function playNext(mainApp) {
+  try {
+    const queue = mainApp.appState.getQueue();
+
+    if (queue.length === 0) {
+      return {
+        success: false,
+        error: 'Queue is empty',
+      };
+    }
+
+    // Remove first song from queue
+    const currentSong = queue[0];
+    if (currentSong && currentSong.id) {
+      mainApp.appState.removeFromQueue(currentSong.id);
+    }
+
+    // Update legacy queue
+    mainApp.songQueue = mainApp.appState.getQueue();
+
+    // Load next song if there is one
+    const newQueue = mainApp.appState.getQueue();
+    if (newQueue.length > 0) {
+      const nextSong = newQueue[0];
+      await mainApp.loadKaiFile(nextSong.path, nextSong.id);
+
+      return {
+        success: true,
+        song: nextSong,
+        message: 'Playing next song',
+      };
+    }
+
+    return {
+      success: true,
+      song: null,
+      message: 'No more songs in queue',
+    };
+  } catch (error) {
+    console.error('Error playing next song:', error);
+    return {
+      success: false,
+      error: error.message,
+    };
+  }
+}
+
+/**
+ * Get current playback state
+ * @param {Object} mainApp - Main application instance
+ * @returns {Object} Current playback state
+ */
+export function getPlaybackState(mainApp) {
+  const state = mainApp.appState.state;
+
+  return {
+    success: true,
+    playback: {
+      isPlaying: state.playback.isPlaying,
+      position: state.playback.position,
+      duration: state.playback.duration,
+      songPath: state.playback.songPath,
+      lastUpdate: state.playback.lastUpdate,
+    },
+    currentSong: state.currentSong,
+  };
+}
+
+/**
+ * Get current song
+ * @param {Object} mainApp - Main application instance
+ * @returns {Object} Current song or null
+ */
+export function getCurrentSong(mainApp) {
+  if (mainApp.currentSong && mainApp.currentSong.metadata) {
+    return {
+      success: true,
+      song: {
+        path: mainApp.currentSong.metadata.path || mainApp.currentSong.filePath,
+        title: mainApp.currentSong.metadata.title,
+        artist: mainApp.currentSong.metadata.artist,
+        requester: mainApp.currentSong.requester || 'KJ',
+      },
+    };
+  }
+
+  return {
+    success: true,
+    song: null,
+  };
+}