@raydiant/playlist-window-manager 0.29.2 → 0.30.0

package/src/testUtils.ts

@@ -11,6 +11,21 @@ import {
   Logger,
   CreateWindowOptions,
 } from './types';
+import {
+  Rect,
+  SurfaceHost,
+  VideoEvent,
+  VideoOptions,
+  VideoSurface,
+} from './surfaces';
+
+// Orders calls recorded by the renderer and the fake surface host against
+// each other.
+let sequence = 0;
+const nextSequence = () => {
+  sequence += 1;
+  return sequence;
+};
 
 export function createPresentationWindow(
   overrides: Partial<PresentationWindowOptions> = {}
@@ -24,7 +39,7 @@ export function createPresentationWindow(
       overrides.playlistWindowManagerState ??
       createPlaylistWindowManagerState(),
     ruleEngineState: overrides.ruleEngineState ?? createRuleEngineState(),
-    logger: createLogger(),
+    logger: overrides.logger ?? createLogger(),
     workerState: overrides.workerState ?? {},
     renderer: overrides.renderer ?? {
       createWindow() {},
@@ -41,6 +56,7 @@ export function createPresentationWindow(
     getTerminal: overrides.getTerminal,
     isPreview: overrides.isPreview,
     device: overrides.device,
+    surfaceBroker: overrides.surfaceBroker,
   });
 }
 
@@ -161,3 +177,321 @@ export function createRenderer() {
     },
   };
 }
+
+export interface RecordedCall {
+  method: string;
+  windowId: string;
+  args: unknown[];
+  seq: number;
+}
+
+// A renderer that records every call in order, across every window, and lets
+// a test play the app's side of the message channel through its hooks.
+export function createRecordingRenderer() {
+  const calls: RecordedCall[] = [];
+  // Messages the apps sent the window manager, in the same order as calls.
+  const received: RecordedCall[] = [];
+  const callbacks: Record<string, (type: string, payload?: any) => void> = {};
+  const errorCallbacks: Record<string, (err: any) => void> = {};
+  const hooks: {
+    onLoad?: (windowId: string) => void;
+    onMessage?: (windowId: string, type: string, payload?: any) => void;
+  } = {};
+
+  const record = (method: string, windowId: string, ...args: unknown[]) => {
+    calls.push({ method, windowId, args, seq: nextSequence() });
+  };
+
+  const renderer = {
+    createWindow(opts: CreateWindowOptions) {
+      callbacks[opts.windowId] = opts.receiveMessageCallback || (() => null);
+      errorCallbacks[opts.windowId] = opts.errorCallback;
+      record('createWindow', opts.windowId, opts.backgroundColor);
+    },
+    async loadWindow(windowId: string) {
+      record('loadWindow', windowId);
+      if (hooks.onLoad) hooks.onLoad(windowId);
+    },
+    updateWindowBounds(windowId: string, bounds: unknown) {
+      record('updateWindowBounds', windowId, bounds);
+    },
+    showWindow(windowId: string, isFocused: boolean) {
+      record('showWindow', windowId, isFocused);
+    },
+    hideWindow(windowId: string) {
+      record('hideWindow', windowId);
+    },
+    async removeWindow(windowId: string) {
+      record('removeWindow', windowId);
+      delete callbacks[windowId];
+    },
+    sendMessageString(windowId: string, message: string) {
+      const { type, payload } = JSON.parse(message);
+      record('sendMessageString', windowId, type, payload);
+      if (hooks.onMessage) hooks.onMessage(windowId, type, payload);
+    },
+    sendMessageObject(windowId: string, type: string, payload?: unknown) {
+      record('sendMessageObject', windowId, type, payload);
+    },
+    muteWindow(windowId: string) {
+      record('muteWindow', windowId);
+    },
+    unMuteWindow(windowId: string) {
+      record('unMuteWindow', windowId);
+    },
+    setWindowBackground(windowId: string, color: string) {
+      record('setWindowBackground', windowId, color);
+    },
+  };
+
+  return {
+    renderer,
+    calls,
+    received,
+    hooks,
+    // Deliver a message from the app in a window to the window manager.
+    receive(windowId: string, type: string, payload?: any) {
+      const callback = callbacks[windowId];
+      if (!callback) return;
+      received.push({
+        method: type,
+        windowId,
+        args: [payload],
+        seq: nextSequence(),
+      });
+      callback(type, payload);
+    },
+    // Report a window as crashed or unresponsive, as a renderer would.
+    fail(windowId: string, err: Error) {
+      const callback = errorCallbacks[windowId];
+      if (callback && callbacks[windowId]) callback(err);
+    },
+    // Windows created and not yet removed, oldest first.
+    liveWindowIds() {
+      return Object.keys(callbacks);
+    },
+  };
+}
+
+export interface FakeSurfaceCall {
+  id?: number;
+  method: string;
+  args: unknown[];
+  seq: number;
+}
+
+interface FakeSurfaceState {
+  id: number;
+  live: boolean;
+  firstFrame: boolean;
+  muted: boolean;
+  shown: boolean;
+  listener: ((e: VideoEvent) => void) | null;
+  buffered: VideoEvent[];
+}
+
+// A stand-in for the Signage Stick host's video surface, typed to the video
+// contract. It records every call in order and records a rule break, rather
+// than throwing, so a test can play a whole playlist and then assert that no
+// rule was broken.
+export function createFakeSurfaceHost(
+  opts: {
+    decoders?: number; // default 4, as measured on the Stick
+    refuse?: 'no_decoder' | 'unsupported'; // the next open
+    hang?: boolean; // the next open never resolves, until releaseHung()
+    hangShow?: boolean; // the next show() never resolves
+    // Each play() raises playing this long after, as the Stick's host does
+    // 15-35 ms after; unset, playing is raised only by emit().
+    playingAfterMs?: number;
+  } = {}
+) {
+  const decoders = opts.decoders ?? 4;
+  let refuseNext = opts.refuse;
+  let hangNext = opts.hang ?? false;
+  let hangShowNext = opts.hangShow ?? false;
+  const calls: FakeSurfaceCall[] = [];
+  const violations: string[] = [];
+  const states: Record<number, FakeSurfaceState> = {};
+  const hung: Array<() => void> = [];
+  let lastId = 0;
+
+  const record = (method: string, args: unknown[], id?: number) => {
+    calls.push({ id, method, args, seq: nextSequence() });
+  };
+  const emit = (id: number, event: VideoEvent) => {
+    const state = states[id];
+    if (!state) throw new Error(`No fake surface ${id}`);
+    if (event.type === 'first_frame') state.firstFrame = true;
+    if (state.listener) {
+      state.listener(event);
+    } else {
+      state.buffered.push(event);
+    }
+  };
+  const live = () =>
+    Object.keys(states)
+      .map((key) => states[Number(key)])
+      .filter((s) => s.live);
+  const checkBounds = (bounds: Rect) => {
+    const values = [bounds.x, bounds.y, bounds.width, bounds.height];
+    if (values.some((v) => Math.round(v) !== v)) {
+      violations.push(`fractional bounds ${JSON.stringify(bounds)}`);
+    }
+  };
+
+  const createSurface = (): VideoSurface => {
+    lastId += 1;
+    const id = lastId;
+    const state: FakeSurfaceState = {
+      id,
+      live: true,
+      firstFrame: false,
+      muted: true,
+      shown: false,
+      listener: null,
+      buffered: [],
+    };
+    states[id] = state;
+
+    return {
+      id,
+      show(showOpts?: { fadeMs?: number }) {
+        record('show', [showOpts], id);
+        if (!state.live) return Promise.resolve();
+        if (!state.firstFrame) {
+          violations.push(`surface ${id} shown before first_frame`);
+        }
+        live()
+          .filter((s) => s !== state && s.shown && !s.muted)
+          .forEach((s) => {
+            violations.push(
+              `surface ${id} shown before surface ${s.id} was muted`
+            );
+          });
+        state.shown = true;
+        if (hangShowNext) {
+          hangShowNext = false;
+          return new Promise<void>(() => undefined);
+        }
+        return Promise.resolve();
+      },
+      hide(hideOpts?: { fadeMs?: number }) {
+        record('hide', [hideOpts], id);
+        state.shown = false;
+        return Promise.resolve();
+      },
+      play() {
+        record('play', [], id);
+        if (opts.playingAfterMs !== undefined) {
+          setTimeout(() => {
+            if (state.live) emit(id, { type: 'playing' });
+          }, opts.playingAfterMs);
+        }
+        return Promise.resolve();
+      },
+      pause() {
+        record('pause', [], id);
+        return Promise.resolve();
+      },
+      seek(seconds: number) {
+        record('seek', [seconds], id);
+        return Promise.resolve();
+      },
+      setBounds(r: Rect) {
+        record('setBounds', [r], id);
+        checkBounds(r);
+        return Promise.resolve();
+      },
+      setMuted(m: boolean) {
+        record('setMuted', [m], id);
+        if (!m && state.live) {
+          live()
+            .filter((s) => s !== state && !s.muted)
+            .forEach((s) => {
+              violations.push(
+                `surface ${id} unmuted while surface ${s.id} sounds`
+              );
+            });
+        }
+        if (state.live) state.muted = m;
+        return Promise.resolve();
+      },
+      close() {
+        record('close', [], id);
+        state.live = false;
+        return Promise.resolve();
+      },
+      onEvent(fn: (e: VideoEvent) => void) {
+        state.listener = fn;
+        const buffered = state.buffered;
+        state.buffered = [];
+        buffered.forEach((e) => fn(e));
+      },
+    };
+  };
+
+  const surfaces: SurfaceHost = {
+    openVideo(videoOpts: VideoOptions) {
+      record('openVideo', [videoOpts]);
+      checkBounds(videoOpts.bounds);
+      if (hangNext) {
+        hangNext = false;
+        return new Promise<VideoSurface>((resolve) => {
+          hung.push(() => resolve(createSurface()));
+        });
+      }
+      if (refuseNext) {
+        const reason = refuseNext;
+        refuseNext = undefined;
+        return Promise.reject(new Error(reason));
+      }
+      if (live().length >= decoders) {
+        return Promise.reject(new Error('no_decoder'));
+      }
+      if (live().length >= 2) {
+        violations.push('a third live surface');
+      }
+      const surface = createSurface();
+      calls[calls.length - 1].id = surface.id;
+      return Promise.resolve(surface);
+    },
+    onHole(open: boolean) {
+      record('onHole', [open]);
+    },
+  };
+
+  return {
+    surfaces,
+    calls,
+    violations,
+    // Raises an event on a surface, as the host would.
+    emit,
+    // Lets a hung open resolve, late.
+    releaseHung() {
+      hung.splice(0).forEach((release) => release());
+    },
+    liveIds() {
+      return live().map((s) => s.id);
+    },
+    lastId() {
+      return lastId;
+    },
+    // The next open is refused, as the host would refuse it.
+    refuseNext(reason: 'no_decoder' | 'unsupported') {
+      refuseNext = reason;
+    },
+    hangNextOpen() {
+      hangNext = true;
+    },
+    hangNextShow() {
+      hangShowNext = true;
+    },
+  };
+}
+
+// Lets pending promise callbacks and zero-delay timers run.
+export async function flush(times = 5) {
+  for (let i = 0; i < times; i += 1) {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+}

package/src/types.ts

@@ -144,6 +144,11 @@ export interface PresentationWindowRenderer {
   // the navigator.isOnline property in the inner window. This is only defined for Electron
   // renderers. Browser renderers do not need to override navigator.isOnline.
   sendOnlineStatus?(windowId: string, isOnline: boolean): void;
+
+  // Called to set a window's own background colour, so a video surface under
+  // the window can show through it. Only renderers that can be paired with a
+  // video surface host define it.
+  setWindowBackground?(windowId: string, color: string): void;
 }
 
 export interface OpenChildWindowOptions {