@camstack/server 1.0.0 → 1.0.1

package/src/__tests__/cap-providers/compute-topology-categories.spec.ts

@@ -1,110 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { computeTopology } from '../../api/core/cap-providers'
-
-// Minimal stubs — only the shapes computeTopology reads.
-function makeAgentRegistry(): { listNodes: () => Promise<unknown[]> } {
-  return {
-    listNodes: async () => [
-      {
-        info: {
-          id: 'hub',
-          name: 'hub',
-          hostname: 'hub',
-          platform: 'darwin',
-          arch: 'arm64',
-          cpuModel: 'M2',
-          cpuCores: 8,
-          memoryMB: 16384,
-          pythonRuntimes: [],
-        },
-        status: { cpuPercent: 12, memoryPercent: 30 },
-        isHub: true,
-        isOnline: true,
-        connectedSince: Date.now() - 60_000,
-        subProcesses: [],
-        agentAddons: [],
-        localIps: [],
-      },
-    ],
-  }
-}
-
-function makeAddonRegistry(): { listAddons: () => readonly unknown[] } {
-  return {
-    listAddons: () => [
-      {
-        manifest: { id: 'provider-hikvision' },
-        declaration: {
-          id: 'provider-hikvision',
-          category: 'providers',
-          capabilities: [{ name: 'stream-params' }],
-        },
-      },
-      {
-        manifest: { id: 'provider-onvif' },
-        declaration: {
-          id: 'provider-onvif',
-          category: 'providers',
-          capabilities: [{ name: 'device-provider' }],
-        },
-      },
-      {
-        manifest: { id: 'stream-broker' },
-        declaration: {
-          id: 'stream-broker',
-          category: 'pipeline',
-          capabilities: [{ name: 'stream-broker' }],
-        },
-      },
-      {
-        manifest: { id: 'sqlite-settings' },
-        declaration: { id: 'sqlite-settings', capabilities: [{ name: 'settings-store' }] },
-      },
-    ],
-  }
-}
-
-describe('computeTopology categories[] aggregation', () => {
-  it('groups addons by manifest.category, defaults to system, emits totals', async () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const nodes = await computeTopology(makeAgentRegistry() as any, makeAddonRegistry() as any)
-    expect(nodes).toHaveLength(1)
-    const cats = nodes[0]!.categories
-    const byId = new Map(cats.map((c) => [c.category, c]))
-    expect(byId.get('providers')?.total).toBe(2)
-    expect(byId.get('providers')?.healthy).toBe(2)
-    expect(
-      byId
-        .get('providers')
-        ?.addons.map((a) => a.id)
-        .toSorted(),
-    ).toEqual(['provider-hikvision', 'provider-onvif'])
-    expect(byId.get('pipeline')?.total).toBe(1)
-    expect(byId.get('system')?.addons.map((a) => a.id)).toEqual(['sqlite-settings'])
-  })
-
-  it('counts a non-running addon as not-healthy', async () => {
-    const agentReg = makeAgentRegistry()
-    // Force the addon registry to return one stopped + one running provider.
-    const addonReg = {
-      listAddons: () => [
-        {
-          manifest: { id: 'provider-rtsp' },
-          declaration: { id: 'provider-rtsp', category: 'providers', capabilities: [] },
-        },
-        {
-          manifest: { id: 'provider-hikvision' },
-          declaration: { id: 'provider-hikvision', category: 'providers', capabilities: [] },
-          status: 'failed',
-        },
-      ],
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const nodes = await computeTopology(agentReg as any, addonReg as any)
-    const providers = nodes[0]!.categories.find((c) => c.category === 'providers')!
-    expect(providers.total).toBe(2)
-    // The current TopologyNode `addons[].status` is always `'running'` per existing code;
-    // failed addons would surface through subProcesses[].state. Document the current contract:
-    expect(providers.healthy).toBe(2)
-  })
-})

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

@@ -1,292 +0,0 @@
-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()
-  })
-})