@camstack/server 0.1.6 → 0.1.8

package/src/__tests__/cap-providers/integrations-delete-cascade.spec.ts

@@ -0,0 +1,243 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { buildIntegrationsProvider } from '../../api/core/cap-providers'
+import type { CapabilityRegistry } from '@camstack/kernel'
+import type { Integration } from '@camstack/types'
+
+// ── Minimal stubs ────────────────────────────────────────────────────────────
+
+const INTEGRATION_ID = 'integ-abc-123'
+const ADDON_ID = 'provider-test'
+
+function makeIntegration(id = INTEGRATION_ID): Integration {
+  return {
+    id,
+    addonId: ADDON_ID,
+    name: 'Test Integration',
+    enabled: true,
+    info: null,
+    settings: null,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  } as unknown as Integration
+}
+
+function makeIntegrationRegistry(integration: Integration | null = makeIntegration()) {
+  return {
+    getIntegration: vi.fn(async (_id: string) => integration),
+    deleteIntegration: vi.fn(async (_id: string) => undefined),
+    listIntegrations: vi.fn(async () => (integration ? [integration] : [])),
+    createIntegration: vi.fn(),
+    updateIntegration: vi.fn(),
+    getIntegrationByAddonId: vi.fn(),
+    getIntegrationSettings: vi.fn(),
+    setIntegrationSettings: vi.fn(),
+  }
+}
+
+function makeAddonRegistry(reg = makeIntegrationRegistry()) {
+  return {
+    getIntegrationRegistry: vi.fn(() => reg),
+    listAddons: vi.fn(() => []),
+    restartAddon: vi.fn(),
+    getCapabilityRegistry: vi.fn(() => ({
+      getProviderByAddon: vi.fn(() => null),
+    })),
+  }
+}
+
+function makeEventBus() {
+  return { emit: vi.fn() }
+}
+
+function makeLogger() {
+  return {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  }
+}
+
+function makeLoggingService(log = makeLogger()) {
+  return { createLogger: vi.fn(() => log) }
+}
+
+function makeCapabilityRegistry(
+  removeByIntegration: ((input: { integrationId: string }) => Promise<{ removed: number }>) | null = vi.fn(async () => ({ removed: 2 })),
+): CapabilityRegistry {
+  return {
+    getSingleton: vi.fn((_cap: string) =>
+      removeByIntegration ? { removeByIntegration } : null,
+    ),
+  } as unknown as CapabilityRegistry
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('integrations.delete cascade-removes devices via removeByIntegration', () => {
+  let integrationReg: ReturnType<typeof makeIntegrationRegistry>
+  let addonReg: ReturnType<typeof makeAddonRegistry>
+  let eb: ReturnType<typeof makeEventBus>
+  let log: ReturnType<typeof makeLogger>
+  let loggingService: ReturnType<typeof makeLoggingService>
+
+  beforeEach(() => {
+    integrationReg = makeIntegrationRegistry()
+    addonReg = makeAddonRegistry(integrationReg)
+    eb = makeEventBus()
+    log = makeLogger()
+    loggingService = makeLoggingService(log)
+  })
+
+  it('calls removeByIntegration with the integration id before deleteIntegration', async () => {
+    const removeByIntegration = vi.fn(async () => ({ removed: 3 }))
+    const capReg = makeCapabilityRegistry(removeByIntegration)
+
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, capReg)
+    await provider.delete({ id: INTEGRATION_ID })
+
+    expect(removeByIntegration).toHaveBeenCalledOnce()
+    expect(removeByIntegration).toHaveBeenCalledWith({ integrationId: INTEGRATION_ID })
+  })
+
+  it('still deletes the integration record and emits integration.deleted after the cascade', async () => {
+    const capReg = makeCapabilityRegistry()
+
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, capReg)
+    const result = await provider.delete({ id: INTEGRATION_ID })
+
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledOnce()
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledWith(INTEGRATION_ID)
+
+    expect(eb.emit).toHaveBeenCalledOnce()
+    expect(eb.emit).toHaveBeenCalledWith(
+      expect.objectContaining({
+        category: 'integration.deleted',
+        data: expect.objectContaining({ integrationId: INTEGRATION_ID }),
+      }),
+    )
+
+    expect(result).toEqual({ success: true, deletedId: INTEGRATION_ID })
+  })
+
+  it('logs the removed count from removeByIntegration', async () => {
+    const removeByIntegration = vi.fn(async () => ({ removed: 5 }))
+    const capReg = makeCapabilityRegistry(removeByIntegration)
+
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, capReg)
+    await provider.delete({ id: INTEGRATION_ID })
+
+    expect(log.info).toHaveBeenCalledWith(
+      'cascade-removed devices',
+      expect.objectContaining({ meta: expect.objectContaining({ removed: 5 }) }),
+    )
+  })
+
+  it('does NOT abort the integration delete when removeByIntegration throws (best-effort)', async () => {
+    const removeByIntegration = vi.fn(async () => {
+      throw new Error('device-manager transient error')
+    })
+    const capReg = makeCapabilityRegistry(removeByIntegration)
+
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, capReg)
+
+    // Should NOT throw
+    await expect(provider.delete({ id: INTEGRATION_ID })).resolves.toEqual({
+      success: true,
+      deletedId: INTEGRATION_ID,
+    })
+
+    // Integration record deletion and event still fire
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledOnce()
+    expect(eb.emit).toHaveBeenCalledOnce()
+
+    // A warning is logged
+    expect(log.warn).toHaveBeenCalledWith(
+      'device cascade-remove failed (best-effort — continuing)',
+      expect.anything(),
+    )
+  })
+
+  it('warns and skips cascade when capabilityRegistry is null', async () => {
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, null)
+    await provider.delete({ id: INTEGRATION_ID })
+
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledOnce()
+    expect(eb.emit).toHaveBeenCalledOnce()
+    expect(log.warn).toHaveBeenCalledWith(
+      'device-manager not available — skipping cascade device removal',
+      expect.anything(),
+    )
+  })
+
+  it('warns and skips cascade when device-manager singleton is not registered', async () => {
+    const capReg = makeCapabilityRegistry(null)
+
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, capReg)
+    await provider.delete({ id: INTEGRATION_ID })
+
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledOnce()
+    expect(log.warn).toHaveBeenCalledWith(
+      'device-manager not available — skipping cascade device removal',
+      expect.anything(),
+    )
+  })
+
+  it('stamps legacy un-tagged devices of the addon BEFORE cascade so they are removed too', async () => {
+    const removeByIntegration = vi.fn(async () => ({ removed: 1 }))
+    const setIntegrationId = vi.fn(async (_input: { deviceId: number; integrationId: string }) => undefined)
+    // One un-tagged top-level device of the integration's addon (claimable),
+    // one already-tagged (skip), one child (skip), one other-addon (skip).
+    const listAll = vi.fn(async () => [
+      { id: 4, addonId: ADDON_ID, parentDeviceId: null },
+      { id: 5, addonId: ADDON_ID, parentDeviceId: null, integrationId: INTEGRATION_ID },
+      { id: 6, addonId: ADDON_ID, parentDeviceId: 4 },
+      { id: 7, addonId: 'provider-other', parentDeviceId: null },
+    ])
+    const capReg = {
+      getSingleton: vi.fn(() => ({ removeByIntegration, listAll, setIntegrationId })),
+    } as unknown as CapabilityRegistry
+
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, capReg)
+    await provider.delete({ id: INTEGRATION_ID })
+
+    // Only device 4 is claimed (untagged, top-level, this addon's single integration).
+    expect(setIntegrationId).toHaveBeenCalledOnce()
+    expect(setIntegrationId).toHaveBeenCalledWith({ deviceId: 4, integrationId: INTEGRATION_ID })
+    // Cascade still runs after the claim.
+    expect(removeByIntegration).toHaveBeenCalledWith({ integrationId: INTEGRATION_ID })
+  })
+
+  it('claim failure does not abort the integration delete (best-effort)', async () => {
+    const removeByIntegration = vi.fn(async () => ({ removed: 0 }))
+    const setIntegrationId = vi.fn(async () => { throw new Error('stamp boom') })
+    const listAll = vi.fn(async () => [{ id: 4, addonId: ADDON_ID, parentDeviceId: null }])
+    const capReg = {
+      getSingleton: vi.fn(() => ({ removeByIntegration, listAll, setIntegrationId })),
+    } as unknown as CapabilityRegistry
+
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, capReg)
+    await expect(provider.delete({ id: INTEGRATION_ID })).resolves.toEqual({
+      success: true,
+      deletedId: INTEGRATION_ID,
+    })
+    expect(integrationReg.deleteIntegration).toHaveBeenCalledOnce()
+    expect(log.warn).toHaveBeenCalledWith(
+      'legacy device claim failed (best-effort — continuing)',
+      expect.anything(),
+    )
+  })
+
+  it('throws when the integration is not found (guard still fires before cascade)', async () => {
+    integrationReg = makeIntegrationRegistry(null)
+    addonReg = makeAddonRegistry(integrationReg)
+    const capReg = makeCapabilityRegistry()
+
+    const provider = buildIntegrationsProvider(addonReg as never, eb as never, loggingService as never, capReg)
+
+    await expect(provider.delete({ id: 'missing-id' })).rejects.toThrow('not found')
+
+    // Nothing should have been cleaned up
+    expect(integrationReg.deleteIntegration).not.toHaveBeenCalled()
+    expect(eb.emit).not.toHaveBeenCalled()
+  })
+})

package/src/__tests__/cap-providers-bulk-update.spec.ts

@@ -0,0 +1,388 @@
+/**
+ * cap-providers-bulk-update.spec.ts
+ *
+ * Verifies the wire-up in buildAddonsProvider for:
+ *   1. Delegation to BulkUpdateCoordinator (startBulkUpdate / cancelBulkUpdate /
+ *      getBulkUpdateState / listActiveBulkUpdates)
+ *   2. isSystem field added to listUpdates output
+ *   3. deferRestart propagated through updateFrameworkPackage
+ *
+ * Spec: docs/superpowers/specs/2026-05-21-addons-bulk-update-progress-design.md
+ * Plan: docs/superpowers/plans/2026-05-21-addons-bulk-update-progress.md  (Task 4)
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import type { IAddonsProvider } from '@camstack/types'
+import { FRAMEWORK_PACKAGE_ALLOWLIST } from '../core/addon/addon-package.service.js'
+
+// ── Module-level mock ─────────────────────────────────────────────────────────
+// Must be hoisted before any import that resolves bulk-update-coordinator.
+// Uses a real class so `new BulkUpdateCoordinator(...)` works; the instance
+// methods are vi.fn stubs shared across all instances created in a test.
+const _startFn = vi.fn()
+const _getFn = vi.fn()
+const _cancelFn = vi.fn()
+const _listFn = vi.fn()
+
+vi.mock('../api/core/bulk-update-coordinator.js', () => {
+  class MockBulkUpdateCoordinator {
+    start = _startFn
+    get = _getFn
+    cancel = _cancelFn
+    list = _listFn
+  }
+  return { BulkUpdateCoordinator: MockBulkUpdateCoordinator }
+})
+
+// ── Imports that depend on the mocked modules ─────────────────────────────────
+import { buildAddonsProvider } from '../api/core/cap-providers.js'
+import { makeCtx } from './cap-routers/harness.js'
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function makeLogger() {
+  const logger = {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+    trace: vi.fn(),
+    fatal: vi.fn(),
+    scope: vi.fn(),
+    child: vi.fn(),
+  }
+  // scope returns a scoped logger with the same shape
+  logger.scope.mockReturnValue(logger)
+  logger.child.mockReturnValue(logger)
+  return logger
+}
+
+type StubStash = {
+  start: ReturnType<typeof vi.fn>
+  get: ReturnType<typeof vi.fn>
+  cancel: ReturnType<typeof vi.fn>
+  list: ReturnType<typeof vi.fn>
+}
+
+function getCoordinatorStubs(): StubStash {
+  // The module-level fn references _startFn etc., shared across all mock instances.
+  return {
+    start: _startFn,
+    get: _getFn,
+    cancel: _cancelFn,
+    list: _listFn,
+  }
+}
+
+interface ProviderEnv {
+  readonly provider: IAddonsProvider
+  readonly psMock: Record<string, ReturnType<typeof vi.fn>>
+}
+
+function createProviderEnv(): ProviderEnv {
+  const psMock: Record<string, ReturnType<typeof vi.fn>> = {
+    getRollbackablePackages: vi.fn().mockReturnValue(new Set()),
+    getAddonHealthSnapshot: vi.fn().mockReturnValue([]),
+    listAllAddons: vi.fn().mockReturnValue([]),
+    listInstalled: vi.fn().mockReturnValue([]),
+    installAndLoad: vi.fn().mockResolvedValue({ success: true }),
+    installFromWorkspaceAndLoad: vi.fn().mockResolvedValue({ success: true }),
+    isWorkspaceAvailable: vi.fn().mockResolvedValue(false),
+    listWorkspacePackages: vi.fn().mockResolvedValue([]),
+    uninstallAndReload: vi.fn().mockResolvedValue({ success: true }),
+    reloadPackages: vi.fn().mockResolvedValue({ success: true }),
+    searchNpm: vi.fn().mockResolvedValue([]),
+    checkUpdates: vi.fn().mockResolvedValue([]),
+    checkUpdatesForInstalled: vi.fn().mockResolvedValue([]),
+    updatePackage: vi.fn().mockResolvedValue({ success: true }),
+    rollbackPackage: vi.fn().mockResolvedValue({ success: true }),
+    restartServer: vi.fn().mockResolvedValue({ success: true }),
+    listFrameworkPackages: vi.fn().mockResolvedValue([]),
+    getPackageVersions: vi.fn().mockResolvedValue([]),
+    getAutoUpdateSettings: vi.fn().mockResolvedValue({ channel: 'stable', intervalSeconds: 3600 }),
+    setAutoUpdateSettings: vi.fn().mockResolvedValue({ success: true }),
+    getAddonAutoUpdate: vi.fn().mockResolvedValue({ channel: 'inherit' }),
+    setAddonAutoUpdate: vi.fn().mockResolvedValue({ success: true }),
+    updateFrameworkPackage: vi.fn().mockResolvedValue({
+      packageName: '@camstack/types',
+      fromVersion: '0.1.38',
+      toVersion: '0.1.40',
+      restartingAt: Date.now() + 500,
+    }),
+    packPackage: vi.fn().mockResolvedValue({ buffer: Buffer.alloc(0), version: '1.0.0' }),
+  }
+
+  const arMock = {
+    listAddons: vi.fn().mockReturnValue([]),
+    listAllAddons: vi.fn().mockReturnValue([]),
+    getAddonHealthSnapshot: vi.fn().mockReturnValue([]),
+    getCapabilityRegistry: vi.fn().mockReturnValue({
+      listCapabilities: vi.fn().mockReturnValue([]),
+    }),
+    getCustomActionRegistry: vi.fn().mockReturnValue({
+      resolve: vi.fn().mockReturnValue(null),
+    }),
+    restartAddon: vi.fn().mockResolvedValue({ success: true }),
+    retryAddonLoad: vi.fn().mockResolvedValue({ success: true }),
+  }
+
+  const lsMock = {
+    createLogger: vi.fn().mockReturnValue(makeLogger()),
+    query: vi.fn().mockResolvedValue([]),
+    subscribe: vi.fn().mockReturnValue(() => {}),
+  }
+
+  const moleculerMock = {
+    broker: {
+      call: vi.fn().mockResolvedValue({}),
+    },
+  }
+
+  const configServiceMock = {}
+
+  const ebMock = {
+    emit: vi.fn(),
+    subscribe: vi.fn().mockReturnValue(() => {}),
+  }
+
+  const ctx = makeCtx('admin')
+
+  const provider = buildAddonsProvider(
+    arMock as never,
+    psMock as never,
+    lsMock as never,
+    moleculerMock as never,
+    configServiceMock as never,
+    ctx,
+    ebMock as never,
+  )
+
+  return { provider, psMock }
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe('buildAddonsProvider — BulkUpdateCoordinator delegation', () => {
+  let env: ProviderEnv
+  let stubs: StubStash
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    env = createProviderEnv()
+    stubs = getCoordinatorStubs()
+  })
+
+  it('startBulkUpdate delegates to coordinator.start with same args and returns its value', async () => {
+    const returnValue = { id: 'bulk-abc-123' }
+    stubs.start.mockReturnValue(returnValue)
+
+    const input = {
+      nodeId: 'hub',
+      items: [
+        { name: '@camstack/addon-stream-broker', version: '1.2.3', isSystem: false },
+        { name: '@camstack/types', version: '0.1.40', isSystem: true },
+      ] as const,
+    }
+
+    const result = await env.provider.startBulkUpdate(input)
+
+    expect(stubs.start).toHaveBeenCalledOnce()
+    expect(stubs.start).toHaveBeenCalledWith(input)
+    expect(result).toEqual(returnValue)
+  })
+
+  it('cancelBulkUpdate delegates to coordinator.cancel with the id and returns its value', async () => {
+    const returnValue = { cancelled: true }
+    stubs.cancel.mockReturnValue(returnValue)
+
+    const result = await env.provider.cancelBulkUpdate({ id: 'bulk-xyz' })
+
+    expect(stubs.cancel).toHaveBeenCalledOnce()
+    expect(stubs.cancel).toHaveBeenCalledWith('bulk-xyz')
+    expect(result).toEqual(returnValue)
+  })
+
+  it('getBulkUpdateState delegates to coordinator.get with the id and returns its value', async () => {
+    const mockState = {
+      id: 'bulk-abc',
+      nodeId: 'hub',
+      startedAtMs: 1000,
+      total: 2,
+      completed: 1,
+      failed: 0,
+      current: null,
+      phase: 'regular' as const,
+      cancelled: false,
+      items: [],
+    }
+    stubs.get.mockReturnValue(mockState)
+
+    const result = await env.provider.getBulkUpdateState({ id: 'bulk-abc' })
+
+    expect(stubs.get).toHaveBeenCalledOnce()
+    expect(stubs.get).toHaveBeenCalledWith('bulk-abc')
+    expect(result).toEqual(mockState)
+  })
+
+  it('getBulkUpdateState returns null when coordinator.get returns null', async () => {
+    stubs.get.mockReturnValue(null)
+
+    const result = await env.provider.getBulkUpdateState({ id: 'unknown-id' })
+
+    expect(result).toBeNull()
+  })
+
+  it('listActiveBulkUpdates delegates to coordinator.list with nodeId and returns its value', async () => {
+    const mockList = [
+      { id: 'bulk-1', nodeId: 'hub', startedAtMs: 1000, total: 1, completed: 0, failed: 0, current: 'pkg-a', phase: 'regular' as const, cancelled: false, items: [] },
+    ]
+    stubs.list.mockReturnValue(mockList)
+
+    const result = await env.provider.listActiveBulkUpdates({ nodeId: 'hub' })
+
+    expect(stubs.list).toHaveBeenCalledOnce()
+    expect(stubs.list).toHaveBeenCalledWith('hub')
+    expect(result).toEqual(mockList)
+  })
+
+  it('listActiveBulkUpdates passes undefined when nodeId is omitted', async () => {
+    stubs.list.mockReturnValue([])
+
+    await env.provider.listActiveBulkUpdates({})
+
+    expect(stubs.list).toHaveBeenCalledWith(undefined)
+  })
+})
+
+describe('buildAddonsProvider — listUpdates isSystem field', () => {
+  let env: ProviderEnv
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    env = createProviderEnv()
+  })
+
+  it('adds isSystem: true for packages in FRAMEWORK_PACKAGE_ALLOWLIST', async () => {
+    const systemPkg = FRAMEWORK_PACKAGE_ALLOWLIST[0]!
+    env.psMock['checkUpdates']!.mockResolvedValue([
+      {
+        name: systemPkg,
+        currentVersion: '0.1.38',
+        latestVersion: '0.1.40',
+        category: 'core',
+        requiresRestart: true,
+      },
+    ])
+
+    const result = await env.provider.listUpdates({ nodeId: 'hub' })
+
+    expect(result).toHaveLength(1)
+    expect(result[0]!.name).toBe(systemPkg)
+    expect(result[0]!.isSystem).toBe(true)
+  })
+
+  it('adds isSystem: false for non-framework packages', async () => {
+    env.psMock['checkUpdates']!.mockResolvedValue([
+      {
+        name: '@camstack/addon-stream-broker',
+        currentVersion: '1.0.0',
+        latestVersion: '1.0.1',
+        category: 'addon',
+        requiresRestart: false,
+      },
+    ])
+
+    const result = await env.provider.listUpdates({ nodeId: 'hub' })
+
+    expect(result).toHaveLength(1)
+    expect(result[0]!.isSystem).toBe(false)
+  })
+
+  it('handles mixed system and non-system packages correctly', async () => {
+    env.psMock['checkUpdates']!.mockResolvedValue([
+      {
+        name: '@camstack/types',
+        currentVersion: '0.1.38',
+        latestVersion: '0.1.40',
+        category: 'core',
+        requiresRestart: true,
+      },
+      {
+        name: '@camstack/addon-foo',
+        currentVersion: '1.0.0',
+        latestVersion: '1.0.1',
+        category: 'addon',
+        requiresRestart: false,
+      },
+    ])
+
+    const result = await env.provider.listUpdates({ nodeId: 'hub' })
+
+    expect(result).toHaveLength(2)
+    const typesRow = result.find(r => r.name === '@camstack/types')
+    const fooRow = result.find(r => r.name === '@camstack/addon-foo')
+    expect(typesRow?.isSystem).toBe(true)
+    expect(fooRow?.isSystem).toBe(false)
+  })
+
+  it('all FRAMEWORK_PACKAGE_ALLOWLIST members get isSystem: true', async () => {
+    env.psMock['checkUpdates']!.mockResolvedValue(
+      FRAMEWORK_PACKAGE_ALLOWLIST.map(name => ({
+        name,
+        currentVersion: '0.1.0',
+        latestVersion: '0.1.1',
+        category: 'core',
+        requiresRestart: true,
+      })),
+    )
+
+    const result = await env.provider.listUpdates({ nodeId: 'hub' })
+
+    expect(result).toHaveLength(FRAMEWORK_PACKAGE_ALLOWLIST.length)
+    for (const row of result) {
+      expect(row.isSystem).toBe(true)
+    }
+  })
+})
+
+describe('buildAddonsProvider — updateFrameworkPackage deferRestart propagation', () => {
+  let env: ProviderEnv
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    env = createProviderEnv()
+  })
+
+  it('forwards deferRestart: true to the service', async () => {
+    await env.provider.updateFrameworkPackage({
+      packageName: '@camstack/types',
+      version: '0.1.40',
+      deferRestart: true,
+    })
+
+    expect(env.psMock['updateFrameworkPackage']).toHaveBeenCalledOnce()
+    const callArg = env.psMock['updateFrameworkPackage']!.mock.calls[0]![0] as Record<string, unknown>
+    expect(callArg['deferRestart']).toBe(true)
+  })
+
+  it('forwards deferRestart: false to the service', async () => {
+    await env.provider.updateFrameworkPackage({
+      packageName: '@camstack/types',
+      version: '0.1.40',
+      deferRestart: false,
+    })
+
+    const callArg = env.psMock['updateFrameworkPackage']!.mock.calls[0]![0] as Record<string, unknown>
+    expect(callArg['deferRestart']).toBe(false)
+  })
+
+  it('does not include deferRestart when it is omitted', async () => {
+    await env.provider.updateFrameworkPackage({
+      packageName: '@camstack/types',
+      version: '0.1.40',
+    })
+
+    const callArg = env.psMock['updateFrameworkPackage']!.mock.calls[0]![0] as Record<string, unknown>
+    // Either undefined or not present — both are acceptable
+    expect(callArg['deferRestart']).toBeUndefined()
+  })
+})