@editframe/elements 0.18.3-beta.0 → 0.18.8-beta.0

package/src/gui/services/PlaybackController.browsertest.ts

@@ -1,437 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { ElementConnectionManager } from "./ElementConnectionManager.js";
-import {
-  PlaybackController,
-  type PlaybackControllerOptions,
-} from "./PlaybackController.js";
-
-// Create a lightweight AudioContext mock that simulates state transitions
-// without real audio hardware interactions
-class MockAudioContext {
-  public state: "suspended" | "running" | "closed" = "suspended";
-  public currentTime = 0;
-  public destination = {};
-  public sampleRate = 44100;
-
-  async resume(): Promise<void> {
-    if (this.state === "suspended") {
-      this.state = "running";
-    }
-    return Promise.resolve();
-  }
-
-  async suspend(): Promise<void> {
-    if (this.state === "running") {
-      this.state = "suspended";
-    }
-    return Promise.resolve();
-  }
-
-  async close(): Promise<void> {
-    this.state = "closed";
-    return Promise.resolve();
-  }
-
-  createBuffer(
-    channels: number,
-    frameCount: number,
-    sampleRate: number,
-  ): AudioBuffer {
-    // Return a minimal mock AudioBuffer without real audio processing
-    return {
-      numberOfChannels: channels,
-      length: frameCount,
-      sampleRate: sampleRate,
-      duration: frameCount / sampleRate,
-      getChannelData: () => new Float32Array(frameCount),
-      copyFromChannel: () => {},
-      copyToChannel: () => {},
-    } as AudioBuffer;
-  }
-
-  createBufferSource(): AudioBufferSourceNode {
-    const mockSource = {
-      buffer: null,
-      connect: vi.fn(),
-      start: vi.fn(),
-      stop: vi.fn(),
-      onended: null as ((event: Event) => void) | null,
-    };
-
-    // Simulate immediate completion for fast tests
-    setTimeout(() => {
-      if (mockSource.onended) {
-        mockSource.onended({} as Event);
-      }
-    }, 0);
-
-    return mockSource as any;
-  }
-}
-
-describe("PlaybackController", () => {
-  let controller: PlaybackController;
-  let mockTimegroup: any;
-  let mockConnectionManager: ElementConnectionManager;
-  let onTimeUpdate: any;
-  let onPlayStateChange: any;
-  let onError: any;
-
-  beforeEach(() => {
-    // Mock AudioContext globally to prevent real audio hardware interactions
-    vi.stubGlobal("AudioContext", MockAudioContext);
-
-    // Create mock callbacks
-    onTimeUpdate = vi.fn();
-    onPlayStateChange = vi.fn();
-    onError = vi.fn();
-
-    const options: PlaybackControllerOptions = {
-      fps: 30,
-      onTimeUpdate,
-      onPlayStateChange,
-      onError,
-    };
-
-    controller = new PlaybackController(options);
-    mockConnectionManager = new ElementConnectionManager();
-
-    // Mock timegroup with fast, lightweight audio buffer creation
-    mockTimegroup = {
-      currentTimeMs: 0,
-      endTimeMs: 10000,
-      waitForMediaDurations: vi.fn().mockResolvedValue(undefined),
-      renderAudio: vi
-        .fn()
-        .mockImplementation(async (startMs: number, endMs: number) => {
-          // Create a lightweight mock AudioBuffer without real audio processing
-          const duration = (endMs - startMs) / 1000; // Convert ms to seconds
-          const sampleRate = 44100;
-          const frameCount = Math.floor(duration * sampleRate);
-
-          return {
-            numberOfChannels: 2,
-            length: frameCount,
-            sampleRate: sampleRate,
-            duration: duration,
-            getChannelData: () => new Float32Array(frameCount),
-            copyFromChannel: () => {},
-            copyToChannel: () => {},
-          } as AudioBuffer;
-        }),
-    };
-
-    // Spy on connection manager
-    vi.spyOn(
-      mockConnectionManager,
-      "updateConnectedElements",
-    ).mockResolvedValue();
-    vi.spyOn(mockConnectionManager, "clearAll").mockImplementation(() => {});
-  });
-
-  afterEach(async () => {
-    await controller.stopPlayback();
-    vi.clearAllMocks();
-    vi.unstubAllGlobals();
-  });
-
-  describe("Constructor and Configuration", () => {
-    test("should initialize with default options", () => {
-      const defaultController = new PlaybackController();
-
-      expect(defaultController.isPlaying()).toBe(false);
-      expect(defaultController.getCurrentTime()).toBe(0);
-      expect(defaultController.getAudioContext()).toBeNull();
-    });
-
-    test("should initialize with custom options", () => {
-      const customOptions = { fps: 60 };
-      const customController = new PlaybackController(customOptions);
-
-      expect(customController.isPlaying()).toBe(false);
-    });
-
-    test("should allow updating options", () => {
-      const newTimeUpdate = vi.fn();
-      controller.updateOptions({ onTimeUpdate: newTimeUpdate, fps: 60 });
-
-      // The options should be updated (we can't easily test this directly,
-      // but we can test that the controller doesn't break)
-      expect(() => controller.updateOptions({ fps: 60 })).not.toThrow();
-    });
-  });
-
-  describe("Playback Control", () => {
-    test("should start playback successfully", async () => {
-      await controller.startPlayback(mockTimegroup);
-
-      expect(controller.isPlaying()).toBe(true);
-      expect(controller.getAudioContext()).not.toBeNull();
-      expect(controller.isAudioContextReady()).toBe(true);
-      expect(onPlayStateChange).toHaveBeenCalledWith(true);
-    });
-
-    test("should handle timegroup without waitForMediaDurations", async () => {
-      const simpleMockTimegroup = {
-        currentTimeMs: 0,
-        endTimeMs: 5000,
-        // No waitForMediaDurations method
-      };
-
-      await expect(
-        controller.startPlayback(simpleMockTimegroup),
-      ).resolves.not.toThrow();
-    });
-
-    test("should not start playback when currentTimeMs >= endTimeMs", async () => {
-      mockTimegroup.currentTimeMs = 15000; // Past the end
-
-      await controller.startPlayback(mockTimegroup);
-
-      expect(controller.isPlaying()).toBe(false);
-      expect(onPlayStateChange).toHaveBeenCalledWith(false);
-    });
-
-    test("should handle null timegroup gracefully", async () => {
-      await controller.startPlayback(null);
-
-      expect(controller.isPlaying()).toBe(false);
-      expect(onError).toHaveBeenCalledWith(expect.any(Error));
-    });
-
-    test("should stop playback and clean up resources", async () => {
-      await controller.startPlayback(mockTimegroup);
-      expect(controller.isPlaying()).toBe(true);
-
-      await controller.stopPlayback();
-
-      expect(controller.isPlaying()).toBe(false);
-      expect(controller.getAudioContext()).toBeNull();
-      // ElementConnectionManager is no longer used in unified audio approach
-      // expect(mockConnectionManager.clearAll).toHaveBeenCalled();
-      expect(onPlayStateChange).toHaveBeenCalledWith(false);
-    });
-
-    test("should pause and resume playback", async () => {
-      await controller.startPlayback(mockTimegroup);
-      expect(controller.isPlaying()).toBe(true);
-
-      await controller.pausePlayback();
-      expect(controller.isPlaying()).toBe(false);
-
-      await controller.resumePlayback();
-      expect(controller.isPlaying()).toBe(true);
-    });
-  });
-
-  describe("Time Management", () => {
-    test("should handle seek operations", async () => {
-      const seekTime = 5000;
-
-      await controller.seekTo(seekTime);
-
-      expect(controller.getCurrentTime()).toBe(seekTime);
-      expect(onTimeUpdate).toHaveBeenCalledWith(seekTime);
-    });
-
-    test("should update time during playback", async () => {
-      // Note: Testing the animation frame timing is complex in a test environment
-      // This test verifies the basic setup works
-      await controller.startPlayback(mockTimegroup);
-
-      expect(onTimeUpdate).toHaveBeenCalled();
-      expect(typeof controller.getCurrentTime()).toBe("number");
-    });
-
-    test("should call connection manager during time updates", async () => {
-      await controller.startPlayback(mockTimegroup);
-
-      // Wait a brief moment for the animation frame to potentially fire
-      await new Promise((resolve) => setTimeout(resolve, 50));
-
-      // The connection manager should be called during time sync
-      // Note: In test environment, animation frames may not fire reliably
-      // ElementConnectionManager is no longer used in unified audio approach
-      // expect(
-      //   mockConnectionManager.updateConnectedElements,
-      // ).toHaveBeenCalledWith(
-      //   expect.any(AudioContext),
-      //   mockTimegroup,
-      //   expect.any(Number),
-      // );
-    });
-  });
-
-  describe("AudioContext Management", () => {
-    test("should create AudioContext on start", async () => {
-      expect(controller.getAudioContext()).toBeNull();
-
-      await controller.startPlayback(mockTimegroup);
-
-      const audioContext = controller.getAudioContext();
-      expect(audioContext).toBeInstanceOf(AudioContext);
-      // In browser test environment, AudioContext may remain suspended
-      expect(audioContext?.state).not.toBe("closed");
-    });
-
-    test("should close AudioContext on stop", async () => {
-      await controller.startPlayback(mockTimegroup);
-      const audioContext = controller.getAudioContext();
-
-      await controller.stopPlayback();
-
-      expect(controller.getAudioContext()).toBeNull();
-      expect(audioContext?.state).toBe("closed");
-    });
-
-    test("should handle AudioContext suspend/resume", async () => {
-      await controller.startPlayback(mockTimegroup);
-      const audioContext = controller.getAudioContext();
-
-      await controller.pausePlayback();
-      expect(audioContext?.state).toBe("suspended");
-
-      await controller.resumePlayback();
-      // In browser test environment, AudioContext may remain suspended
-      expect(audioContext?.state).not.toBe("closed");
-    });
-
-    test("should handle suspended AudioContext on start", async () => {
-      // Our MockAudioContext already starts in suspended state, which is perfect for this test
-      await controller.startPlayback(mockTimegroup);
-
-      // In browser test environment, playback may still be considered active even with suspended AudioContext
-      expect(typeof controller.isPlaying()).toBe("boolean");
-      expect(controller.getAudioContext()).not.toBeNull();
-      expect(controller.getAudioContext()?.state).not.toBe("closed");
-    });
-  });
-
-  describe("Error Handling", () => {
-    test("should handle AudioContext creation errors", async () => {
-      // Mock AudioContext to throw during construction
-      const ThrowingAudioContext = class {
-        constructor() {
-          throw new Error("AudioContext creation failed");
-        }
-      };
-
-      vi.stubGlobal("AudioContext", ThrowingAudioContext);
-
-      await controller.startPlayback(mockTimegroup);
-
-      expect(controller.isPlaying()).toBe(false);
-      expect(onError).toHaveBeenCalledWith(expect.any(Error));
-    });
-
-    test("should handle connection manager errors gracefully", async () => {
-      mockConnectionManager.updateConnectedElements = vi
-        .fn()
-        .mockRejectedValue(new Error("Connection update failed"));
-
-      await controller.startPlayback(mockTimegroup);
-
-      // Should not prevent playback from starting
-      expect(controller.isPlaying()).toBe(true);
-    });
-
-    test("should handle multiple stop calls gracefully", async () => {
-      await controller.startPlayback(mockTimegroup);
-
-      await controller.stopPlayback();
-      await controller.stopPlayback(); // Second call
-      await controller.stopPlayback(); // Third call
-
-      expect(controller.isPlaying()).toBe(false);
-    });
-  });
-
-  describe("Integration with ElementConnectionManager", () => {
-    test("should work without connection manager", () => {
-      const standaloneController = new PlaybackController();
-
-      expect(() =>
-        standaloneController.startPlayback(mockTimegroup),
-      ).not.toThrow();
-    });
-
-    test("should coordinate with connection manager when set", async () => {
-      await controller.startPlayback(mockTimegroup);
-
-      // ElementConnectionManager is no longer used in unified audio approach
-      // expect(mockConnectionManager.updateConnectedElements).toHaveBeenCalled();
-    });
-
-    test("should clear connection manager on stop", async () => {
-      await controller.startPlayback(mockTimegroup);
-      await controller.stopPlayback();
-
-      // ElementConnectionManager is no longer used in unified audio approach
-      // expect(mockConnectionManager.clearAll).toHaveBeenCalled();
-    });
-  });
-
-  describe("Playback Info and Debugging", () => {
-    test("should provide accurate playback info when stopped", () => {
-      const info = controller.getPlaybackInfo();
-
-      expect(info).toEqual({
-        playing: false,
-        currentTimeMs: 0,
-        audioContextState: null,
-        hasElementManager: false, // ElementConnectionManager no longer used
-      });
-    });
-
-    test("should provide accurate playback info when playing", async () => {
-      await controller.startPlayback(mockTimegroup);
-      const info = controller.getPlaybackInfo();
-
-      expect(info.playing).toBe(true);
-      // In browser test environment, AudioContext may remain suspended
-      expect(info.audioContextState).not.toBe("closed");
-      expect(info.hasElementManager).toBe(false); // ElementConnectionManager no longer used
-      expect(typeof info.currentTimeMs).toBe("number");
-    });
-  });
-
-  describe("Lifecycle and State Management", () => {
-    test("should handle rapid start/stop cycles", async () => {
-      for (let i = 0; i < 3; i++) {
-        await controller.startPlayback(mockTimegroup);
-        expect(controller.isPlaying()).toBe(true);
-
-        await controller.stopPlayback();
-        expect(controller.isPlaying()).toBe(false);
-      }
-    });
-
-    test("should maintain state consistency during transitions", async () => {
-      // Start
-      await controller.startPlayback(mockTimegroup);
-      let info = controller.getPlaybackInfo();
-      // In browser test environment, AudioContext may remain suspended, so playing may be false
-      expect(typeof info.playing).toBe("boolean");
-      expect(info.audioContextState).not.toBe("closed");
-
-      // Pause
-      await controller.pausePlayback();
-      info = controller.getPlaybackInfo();
-      expect(info.playing).toBe(false);
-      expect(info.audioContextState).toBe("suspended");
-
-      // Resume
-      await controller.resumePlayback();
-      info = controller.getPlaybackInfo();
-      // In browser test environment, AudioContext may remain suspended, so playing may be false
-      expect(typeof info.playing).toBe("boolean");
-      expect(info.audioContextState).not.toBe("closed");
-
-      // Stop
-      await controller.stopPlayback();
-      info = controller.getPlaybackInfo();
-      expect(info.playing).toBe(false);
-      expect(info.audioContextState).toBe(null);
-    });
-  });
-});