Skip to content

The agent that grows with you

10.5 KB
Raw Blame
/**
 * Unit tests for the pure window-state geometry helpers. These cover the logic
 * that protects the user: garbage rejection, off-screen fallback, oversized
 * clamping, and the debounce that collapses mid-drag write storms.
 */

import assert from 'node:assert/strict'
import { EventEmitter } from 'node:events'

import { test, vi } from 'vitest'

import {
  bindGeometryPersistence,
  computeWindowOptions,
  debounce,
  matchingWorkArea,
  MIN_HEIGHT,
  MIN_WIDTH,
  sanitizeWindowState
} from './window-state'

// A single 1920×1080 monitor (work area trimmed for the taskbar).
const PRIMARY = [{ workArea: { x: 0, y: 0, width: 1920, height: 1040 } }]
// A laptop panel left behind after a bigger external monitor is unplugged.
const LAPTOP = [{ workArea: { x: 0, y: 0, width: 1366, height: 728 } }]

// ─── sanitizeWindowState ───────────────────────────────────────────────────

test('sanitizeWindowState rejects missing/garbage input', () => {
  for (const bad of [
    null,
    undefined,
    'nope',
    42,
    {},
    { width: 'x', height: 800 },
    { width: NaN, height: 800 },
    { width: 1000 }
  ]) {
    assert.equal(sanitizeWindowState(bad), null)
  }
})

test('sanitizeWindowState keeps a valid full state and rounds HiDPI fractions', () => {
  assert.deepEqual(sanitizeWindowState({ x: 100.6, y: 50.2, width: 1400.4, height: 900.7, isMaximized: true }), {
    x: 101,
    y: 50,
    width: 1400,
    height: 901,
    isMaximized: true
  })
})

test('sanitizeWindowState floors size to the minimums', () => {
  const state = sanitizeWindowState({ width: 10, height: 10 })
  assert.equal(state.width, MIN_WIDTH)
  assert.equal(state.height, MIN_HEIGHT)
})

test('sanitizeWindowState drops a partial position but keeps the size', () => {
  assert.deepEqual(sanitizeWindowState({ x: 100, width: 1400, height: 900 }), {
    width: 1400,
    height: 900,
    isMaximized: false
  })
})

test('sanitizeWindowState treats isMaximized strictly', () => {
  assert.equal(sanitizeWindowState({ width: 1400, height: 900, isMaximized: 'yes' }).isMaximized, false)
})

test('sanitizeWindowState treats boundsCapturedFullScreen strictly and stays optional', () => {
  assert.equal(
    sanitizeWindowState({ width: 1400, height: 900, boundsCapturedFullScreen: true }).boundsCapturedFullScreen,
    true
  )
  assert.equal(
    sanitizeWindowState({ width: 1400, height: 900, boundsCapturedFullScreen: 'yes' }).boundsCapturedFullScreen,
    undefined
  )
  assert.equal(sanitizeWindowState({ width: 1400, height: 900 }).boundsCapturedFullScreen, undefined)
})

// ─── matchingWorkArea ──────────────────────────────────────────────────────────────

test('matchingWorkArea accepts a window on the primary or a secondary display', () => {
  const dual = [...PRIMARY, { workArea: { x: 1920, y: 0, width: 2560, height: 1400 } }]
  assert.notEqual(matchingWorkArea({ x: 100, y: 100, width: 1220, height: 800 }, PRIMARY), null)
  assert.notEqual(matchingWorkArea({ x: 2200, y: 200, width: 1220, height: 800 }, dual), null)
})

test('matchingWorkArea rejects off-screen, slivers, and bad input', () => {
  assert.equal(matchingWorkArea({ x: 3000, y: 100, width: 1220, height: 800 }, PRIMARY), null) // past right edge
  assert.equal(matchingWorkArea({ x: 100, y: -900, width: 1220, height: 800 }, PRIMARY), null) // above top
  assert.equal(matchingWorkArea({ x: 1910, y: 100, width: 1220, height: 800 }, PRIMARY), null) // ~10px sliver
  assert.equal(matchingWorkArea({ x: 0, y: 0, width: 1220, height: 800 }, []), null)
  assert.equal(matchingWorkArea({ x: 0, y: 0, width: 1220, height: 800 }, null), null)
})

// ─── computeWindowOptions ──────────────────────────────────────────────────

test('computeWindowOptions restores an on-screen position', () => {
  const saved = sanitizeWindowState({ x: 200, y: 100, width: 1400, height: 900 })
  assert.deepEqual(computeWindowOptions(saved, PRIMARY), { width: 1400, height: 900, x: 200, y: 100 })
})

test('computeWindowOptions clamps a trusted saved position fully inside its display work area', () => {
  const saved = sanitizeWindowState({ x: -102, y: 175, width: 960, height: 1032 })
  assert.deepEqual(computeWindowOptions(saved, PRIMARY), { width: 960, height: 1032, x: 0, y: 8 })
})

test('computeWindowOptions caps a positioned window to the display it overlaps', () => {
  const dual = [
    { workArea: { x: 0, y: 0, width: 2560, height: 1400 } },
    { workArea: { x: 2560, y: 0, width: 1366, height: 728 } }
  ]

  const saved = sanitizeWindowState({ x: 2700, y: 100, width: 1400, height: 900 })
  assert.deepEqual(computeWindowOptions(saved, dual), { width: 1366, height: 728, x: 2560, y: 0 })
})

test('computeWindowOptions keeps the size but drops an off-screen position', () => {
  const saved = sanitizeWindowState({ x: 5000, y: 150, width: 1400, height: 900 })
  assert.deepEqual(computeWindowOptions(saved, PRIMARY), { width: 1400, height: 900 })
})

test('computeWindowOptions clamps a size larger than the only display', () => {
  const saved = sanitizeWindowState({ width: 2560, height: 1440 })
  assert.deepEqual(computeWindowOptions(saved, LAPTOP), { width: 1366, height: 728 })
})

test('computeWindowOptions keeps the MIN floor on a sub-minimum display', () => {
  const tiny = [{ workArea: { x: 0, y: 0, width: 360, height: 480 } }]
  const saved = sanitizeWindowState({ width: 2000, height: 1500 })
  assert.deepEqual(computeWindowOptions(saved, tiny), { width: MIN_WIDTH, height: MIN_HEIGHT })
})

test('computeWindowOptions does not clamp when displays are unknown', () => {
  const saved = sanitizeWindowState({ width: 2560, height: 1440 })
  assert.deepEqual(computeWindowOptions(saved, []), { width: 2560, height: 1440 })
})

test('computeWindowOptions recovers stale fullscreen normal bounds to a centered windowed size on Windows', () => {
  const saved = sanitizeWindowState({
    x: 0,
    y: 0,
    width: 1920,
    height: 1040,
    isMaximized: false,
    boundsCapturedFullScreen: true
  })

  assert.deepEqual(computeWindowOptions(saved, PRIMARY, 'win32'), { width: 1536, height: 832 })
})

test('computeWindowOptions recovers a legacy exact-work-area snapshot written before the provenance flag', () => {
  // Pre-boundsCapturedFullScreen snapshot: fullscreen bounds persisted as
  // normal, matching the work area to the pixel. Unambiguous, so recovered.
  const saved = sanitizeWindowState({ x: 0, y: 0, width: 1920, height: 1040, isMaximized: false })
  assert.deepEqual(computeWindowOptions(saved, PRIMARY, 'win32'), { width: 1536, height: 832 })
})

test('computeWindowOptions recovers a legacy snapshot matching the full display bounds', () => {
  // A fullscreen window over a hidden taskbar reports the display's full
  // bounds, not the work area. Still an exact match, so still recovered.
  const displays = [
    { workArea: { x: 0, y: 0, width: 1920, height: 1040 }, bounds: { x: 0, y: 0, width: 1920, height: 1080 } }
  ]

  const saved = sanitizeWindowState({ x: 0, y: 0, width: 1920, height: 1080, isMaximized: false })
  assert.deepEqual(computeWindowOptions(saved, displays, 'win32'), { width: 1536, height: 832 })
})

test('computeWindowOptions preserves a deliberate near-fullscreen normal window near the origin on Windows', () => {
  // The reviewer's case: a valid normal window the user sized on purpose,
  // satisfying the old ≥90% + near-origin predicates. It must survive
  // restore untouched (position clamped inside the work area).
  const saved = sanitizeWindowState({ x: 0, y: 0, width: 1824, height: 988, isMaximized: false })
  assert.deepEqual(computeWindowOptions(saved, PRIMARY, 'win32'), {
    width: 1824,
    height: 988,
    x: 0,
    y: 0
  })
})

test('computeWindowOptions preserves deliberate near-fullscreen normal bounds outside Windows', () => {
  const saved = sanitizeWindowState({ x: 0, y: 0, width: 1920, height: 1040, isMaximized: false })
  assert.deepEqual(computeWindowOptions(saved, PRIMARY, 'darwin'), {
    width: 1920,
    height: 1040,
    x: 0,
    y: 0
  })
})

test('computeWindowOptions preserves full bounds when the saved state is actually maximized', () => {
  const saved = sanitizeWindowState({ x: 0, y: 0, width: 1920, height: 1040, isMaximized: true })
  assert.deepEqual(computeWindowOptions(saved, PRIMARY, 'win32'), { width: 1920, height: 1040, x: 0, y: 0 })
})

test('computeWindowOptions does not shrink a large normal window away from the work-area origin', () => {
  const saved = sanitizeWindowState({ x: 240, y: 120, width: 1740, height: 950, isMaximized: false })
  assert.deepEqual(computeWindowOptions(saved, PRIMARY, 'win32'), { width: 1740, height: 950, x: 180, y: 90 })
})

// ─── debounce ──────────────────────────────────────────────────────────────

test('debounce coalesces a burst into one trailing run', () => {
  vi.useFakeTimers()
  let calls = 0

  const d = debounce(() => {
    calls += 1
  }, 250)

  d()
  d()
  d()
  assert.equal(calls, 0)
  vi.advanceTimersByTime(249)
  assert.equal(calls, 0)
  vi.advanceTimersByTime(1)
  assert.equal(calls, 1)

  vi.useRealTimers()
})

test('debounce.flush runs now and cancels the pending timer', () => {
  vi.useFakeTimers()
  let calls = 0

  const d = debounce(() => {
    calls += 1
  }, 250)

  d()
  d.flush()
  assert.equal(calls, 1)
  vi.advanceTimersByTime(1000)
  assert.equal(calls, 1)

  vi.useRealTimers()
})

// ─── bindGeometryPersistence ───────────────────────────────────────────────

test('bindGeometryPersistence saves on drag and on resize', () => {
  const win = new EventEmitter()
  let saves = 0

  bindGeometryPersistence(win, () => {
    saves += 1
  })

  win.emit('move')
  win.emit('resize')
  assert.equal(saves, 2)
})

// The regression this exists for: `moved`/`resized` never fire on Linux, so a
// window bound only to those pretends to persist and silently forgets its place
// every launch. A window that emits nothing else must still save.
test('a window that never emits moved/resized still saves its geometry', () => {
  const win = new EventEmitter()
  let saves = 0

  bindGeometryPersistence(win, () => {
    saves += 1
  })

  win.emit('move')
  assert.ok(saves > 0)
})