Import AITURK IDE 1.0.0-beta.1 from Hermes 63279301; preserve MIT license

apps/desktop/electron/window-reveal.test.ts

@@ -0,0 +1,188 @@
+import assert from 'node:assert/strict'
+
+import { test } from 'vitest'
+
+import { createWindowRevealController } from './window-reveal'
+
+function createHarness({ visible = false }: { visible?: boolean } = {}) {
+  let destroyed = false
+  let isVisible = visible
+  let revealCalls = 0
+  let showCalls = 0
+  let scheduledCallback: (() => void) | null = null
+  let scheduledDelay: number | null = null
+  let clearCalls = 0
+
+  const controller = createWindowRevealController(
+    {
+      isDestroyed: () => destroyed,
+      isVisible: () => isVisible,
+      show: () => {
+        showCalls += 1
+        isVisible = true
+      }
+    },
+    {
+      onRevealed: () => {
+        revealCalls += 1
+      },
+      setTimer: (callback, delay) => {
+        scheduledCallback = callback
+        scheduledDelay = delay
+
+        return 1 as unknown as ReturnType<typeof setTimeout>
+      },
+      clearTimer: () => {
+        clearCalls += 1
+      }
+    }
+  )
+
+  return {
+    controller,
+    destroy: () => {
+      destroyed = true
+    },
+    get clearCalls() {
+      return clearCalls
+    },
+    get revealCalls() {
+      return revealCalls
+    },
+    get scheduledCallback() {
+      return scheduledCallback
+    },
+    get scheduledDelay() {
+      return scheduledDelay
+    },
+    get showCalls() {
+      return showCalls
+    }
+  }
+}
+
+test('reveals immediately when Electron emits ready-to-show', () => {
+  const harness = createHarness()
+
+  assert.equal(harness.controller.reveal(), true)
+  assert.equal(harness.showCalls, 1)
+  assert.equal(harness.revealCalls, 1)
+  assert.equal(harness.scheduledCallback, null)
+})
+
+test('reveals through the fallback when ready-to-show never arrives', () => {
+  const harness = createHarness()
+
+  harness.controller.scheduleFallback()
+
+  assert.equal(harness.scheduledDelay, 4_000)
+  assert.ok(harness.scheduledCallback)
+  harness.scheduledCallback()
+
+  assert.equal(harness.showCalls, 1)
+  assert.equal(harness.revealCalls, 1)
+})
+
+test('ready-to-show cancels the fallback and settles only once', () => {
+  const harness = createHarness()
+
+  harness.controller.scheduleFallback()
+  const scheduledCallback = harness.scheduledCallback
+
+  assert.equal(harness.controller.reveal(), true)
+  assert.equal(harness.clearCalls, 1)
+  scheduledCallback?.()
+
+  assert.equal(harness.showCalls, 1)
+  assert.equal(harness.revealCalls, 1)
+  assert.equal(harness.controller.reveal(), false)
+})
+
+test('finalizes an already visible window without showing it again', () => {
+  const harness = createHarness({ visible: true })
+
+  assert.equal(harness.controller.reveal(), true)
+  assert.equal(harness.showCalls, 0)
+  assert.equal(harness.revealCalls, 1)
+})
+
+test('dispose cancels a pending fallback and prevents a late reveal', () => {
+  const harness = createHarness()
+
+  harness.controller.scheduleFallback()
+  const scheduledCallback = harness.scheduledCallback
+  harness.controller.dispose()
+  scheduledCallback?.()
+
+  assert.equal(harness.clearCalls, 1)
+  assert.equal(harness.showCalls, 0)
+  assert.equal(harness.revealCalls, 0)
+})
+
+test('does not reveal a destroyed window', () => {
+  const harness = createHarness()
+
+  harness.destroy()
+
+  assert.equal(harness.controller.reveal(), false)
+  harness.controller.scheduleFallback()
+  assert.equal(harness.scheduledCallback, null)
+})
+
+// The pet overlay reveals with showInactive() and the HUD with show() + focus(),
+// so the fallback has to run the caller's action rather than a plain show().
+test('the fallback runs the caller reveal action, not a plain show', () => {
+  const actions: string[] = []
+  let scheduled: (() => void) | null = null
+
+  const controller = createWindowRevealController(
+    {
+      isDestroyed: () => false,
+      isVisible: () => false,
+      show: () => actions.push('showInactive')
+    },
+    {
+      onRevealed: () => actions.push('revealed'),
+      setTimer: callback => {
+        scheduled = callback
+
+        return 1 as unknown as ReturnType<typeof setTimeout>
+      },
+      clearTimer: () => {}
+    }
+  )
+
+  controller.scheduleFallback()
+  scheduled?.()
+
+  assert.deepEqual(actions, ['showInactive', 'revealed'])
+})
+
+// The HUD hides the main window from onRevealed — whichever path wins, that
+// side effect has to happen exactly once.
+test('onRevealed side effects run once when both paths fire', () => {
+  const harness = createHarness()
+
+  harness.controller.scheduleFallback()
+  harness.controller.reveal()
+  harness.scheduledCallback?.()
+  harness.controller.reveal()
+
+  assert.equal(harness.revealCalls, 1)
+})
+
+// Session and instance windows have no post-visible work to do.
+test('reveals without an onRevealed callback', () => {
+  let shown = false
+
+  const controller = createWindowRevealController({
+    isDestroyed: () => false,
+    isVisible: () => shown,
+    show: () => {
+      shown = true
+    }
+  })
+
+  assert.equal(controller.reveal(), true)
+  assert.equal(shown, true)
+})