create-react-admin-template 0.0.0-stage → 0.1.0

package/template/tests/unit/optionalEditors/optionalEditors.test.ts

@@ -0,0 +1,313 @@
+import {
+  fnCreateOptionalEditorController,
+  fnMigrateOptionalEditorDocument,
+  OptionalEditorError,
+  type IOptionalEditorAdapter,
+  type IOptionalEditorMountInput,
+  type IOptionalEditorSession,
+  type TOptionalEditorSessionEvent,
+} from '@/optionalEditors'
+import { describe, expect, it, vi } from 'vitest'
+import type { IAppQueryScope } from '@/api/query'
+
+interface ITestDocument {
+  readonly arrNodes: readonly string[]
+}
+
+interface ITestBinding {
+  readonly strBindingId: string
+}
+
+interface ITestSessionHarness {
+  readonly fnEmit: (objEvent: TOptionalEditorSessionEvent) => void
+  readonly objDestroyMock: ReturnType<typeof vi.fn>
+  readonly objSession: IOptionalEditorSession<ITestDocument, ITestBinding>
+  readonly objUnsubscribeMock: ReturnType<typeof vi.fn>
+}
+
+const objScope: IAppQueryScope = {
+  nSessionGeneration: 1,
+  strLocale: 'zh-CN',
+  strTenantId: 'tenant-a',
+  strUserId: 'user-1',
+  strWorkspaceId: 'workspace-a',
+}
+
+function fnValidateTestDocument(objDocument: ITestDocument): ITestDocument {
+  if (!objDocument.arrNodes.length) {
+    throw new Error('invalid document')
+  }
+  return Object.freeze({ arrNodes: Object.freeze([...objDocument.arrNodes]) })
+}
+
+function fnCreateSessionHarness(
+  strBindingId: string,
+  objDocument: ITestDocument = { arrNodes: ['node-1'] }
+): ITestSessionHarness {
+  let fnOnEvent: ((objEvent: TOptionalEditorSessionEvent) => void) | undefined
+  const fnDestroy = vi.fn()
+  const fnUnsubscribe = vi.fn()
+  return {
+    fnEmit: (objEvent) => fnOnEvent?.(objEvent),
+    objDestroyMock: fnDestroy,
+    objSession: {
+      fnDestroy,
+      fnReadDocument: () => objDocument,
+      fnSubscribe: (fnNextOnEvent) => {
+        fnOnEvent = fnNextOnEvent
+        return fnUnsubscribe
+      },
+      objBinding: { strBindingId },
+    },
+    objUnsubscribeMock: fnUnsubscribe,
+  }
+}
+
+function fnCreateAdapter(
+  fnMount: IOptionalEditorAdapter<ITestDocument, ITestBinding>['fnMount']
+): IOptionalEditorAdapter<ITestDocument, ITestBinding> {
+  return {
+    fnMount,
+    fnValidateDocument: fnValidateTestDocument,
+    strEditorKind: 'diagram',
+  }
+}
+
+function fnCreateMountInput(
+  strDocumentId: string
+): IOptionalEditorMountInput<ITestDocument> {
+  return {
+    objContainer: document.createElement('div'),
+    objDocument: {
+      objDocument: { arrNodes: ['node-1'] },
+      strDocumentId,
+      strEditorKind: 'diagram',
+      strSchemaVersion: 'v1',
+    },
+    objScope,
+    strMode: 'edit',
+  }
+}
+
+function fnCreateDeferred<TValue>() {
+  let fnResolvePromise: (objValue: TValue) => void = () => undefined
+  const objPromise = new Promise<TValue>((fnResolve) => {
+    fnResolvePromise = fnResolve
+  })
+  return { fnResolve: fnResolvePromise, objPromise }
+}
+
+describe('optional editor controller', () => {
+  it('publishes binding, dirty state, validated export and saved state', async () => {
+    const objHarness = fnCreateSessionHarness('binding-1', {
+      arrNodes: ['exported-node'],
+    })
+    const objController = fnCreateOptionalEditorController(
+      fnCreateAdapter(async () => objHarness.objSession)
+    )
+
+    await objController.fnMount(fnCreateMountInput('document-1'))
+    expect(objController.fnGetSnapshot()).toMatchObject({
+      bIsDirty: false,
+      objBinding: { strBindingId: 'binding-1' },
+      strStatus: 'active',
+    })
+
+    objHarness.fnEmit({ bIsDirty: true, strType: 'dirtyChanged' })
+    expect(objController.fnGetSnapshot()).toMatchObject({ bIsDirty: true })
+    await expect(objController.fnExportDocument()).resolves.toMatchObject({
+      objDocument: { arrNodes: ['exported-node'] },
+      strDocumentId: 'document-1',
+      strSchemaVersion: 'v1',
+    })
+    expect(objController.fnMarkSaved()).toMatchObject({ bIsDirty: false })
+  })
+
+  it('lets only the latest route mount become active', async () => {
+    const objFirstDeferred =
+      fnCreateDeferred<IOptionalEditorSession<ITestDocument, ITestBinding>>()
+    const objSecondDeferred =
+      fnCreateDeferred<IOptionalEditorSession<ITestDocument, ITestBinding>>()
+    const objFirstHarness = fnCreateSessionHarness('binding-first')
+    const objSecondHarness = fnCreateSessionHarness('binding-second')
+    const arrSignals: AbortSignal[] = []
+    const objController = fnCreateOptionalEditorController(
+      fnCreateAdapter((objRequest) => {
+        arrSignals.push(objRequest.objSignal)
+        return objRequest.objDocument.strDocumentId === 'document-1'
+          ? objFirstDeferred.objPromise
+          : objSecondDeferred.objPromise
+      })
+    )
+
+    const objFirstMount = objController.fnMount(
+      fnCreateMountInput('document-1')
+    )
+    const objSecondMount = objController.fnMount(
+      fnCreateMountInput('document-2')
+    )
+    expect(arrSignals[0]?.aborted).toBe(true)
+
+    objSecondDeferred.fnResolve(objSecondHarness.objSession)
+    await objSecondMount
+    objFirstDeferred.fnResolve(objFirstHarness.objSession)
+    await objFirstMount
+
+    expect(objController.fnGetSnapshot()).toMatchObject({
+      objBinding: { strBindingId: 'binding-second' },
+      strDocumentId: 'document-2',
+      strStatus: 'active',
+    })
+    expect(objFirstHarness.objDestroyMock).toHaveBeenCalledOnce()
+    expect(objSecondHarness.objDestroyMock).not.toHaveBeenCalled()
+  })
+
+  it('unsubscribes and destroys the SDK session on close', async () => {
+    const objHarness = fnCreateSessionHarness('binding-1')
+    const objController = fnCreateOptionalEditorController(
+      fnCreateAdapter(async () => objHarness.objSession)
+    )
+    await objController.fnMount(fnCreateMountInput('document-1'))
+
+    expect(objController.fnClose()).toMatchObject({ strStatus: 'idle' })
+    expect(objHarness.objUnsubscribeMock).toHaveBeenCalledOnce()
+    expect(objHarness.objDestroyMock).toHaveBeenCalledOnce()
+  })
+
+  it('rejects an export result after its editor session closes', async () => {
+    const objDocumentDeferred = fnCreateDeferred<ITestDocument>()
+    const objHarness = fnCreateSessionHarness('binding-1')
+    const objController = fnCreateOptionalEditorController(
+      fnCreateAdapter(async () => ({
+        ...objHarness.objSession,
+        fnReadDocument: () => objDocumentDeferred.objPromise,
+      }))
+    )
+    await objController.fnMount(fnCreateMountInput('document-1'))
+
+    const objExportPromise = objController.fnExportDocument()
+    objController.fnClose()
+    objDocumentDeferred.fnResolve({ arrNodes: ['late-node'] })
+
+    await expect(objExportPromise).rejects.toMatchObject({
+      strCode: 'SESSION_INACTIVE',
+    })
+  })
+
+  it('rejects a document kind that does not match the Adapter', async () => {
+    const fnMount =
+      vi.fn<IOptionalEditorAdapter<ITestDocument, ITestBinding>['fnMount']>()
+    const objController = fnCreateOptionalEditorController(
+      fnCreateAdapter(fnMount)
+    )
+    const objInput = fnCreateMountInput('document-1')
+
+    await expect(
+      objController.fnMount({
+        ...objInput,
+        objDocument: { ...objInput.objDocument, strEditorKind: 'map' },
+      })
+    ).resolves.toMatchObject({
+      objError: { strCode: 'INVALID_DOCUMENT' },
+      strStatus: 'error',
+    })
+    expect(fnMount).not.toHaveBeenCalled()
+  })
+
+  it('closes the session when the SDK emits a fatal failure', async () => {
+    const objHarness = fnCreateSessionHarness('binding-1')
+    const objController = fnCreateOptionalEditorController(
+      fnCreateAdapter(async () => objHarness.objSession)
+    )
+    await objController.fnMount(fnCreateMountInput('document-1'))
+
+    objHarness.fnEmit({
+      strReasonCode: 'WORKER_CRASHED',
+      strType: 'sessionFailed',
+    })
+
+    expect(objController.fnGetSnapshot()).toMatchObject({
+      objError: {
+        strCode: 'ADAPTER_FAILED',
+        strReasonCode: 'WORKER_CRASHED',
+      },
+      strStatus: 'error',
+    })
+    expect(objHarness.objDestroyMock).toHaveBeenCalledOnce()
+  })
+})
+
+describe('optional editor document migration', () => {
+  it('runs a validated linear migration without changing document identity', () => {
+    const objResult = fnMigrateOptionalEditorDocument({
+      arrMigrations: [
+        {
+          fnMigrate: (objDocument) => ({
+            arrNodes: [...objDocument.arrNodes, 'node-v2'],
+          }),
+          strFromVersion: 'v1',
+          strToVersion: 'v2',
+        },
+        {
+          fnMigrate: (objDocument) => ({
+            arrNodes: [...objDocument.arrNodes, 'node-v3'],
+          }),
+          strFromVersion: 'v2',
+          strToVersion: 'v3',
+        },
+      ],
+      fnValidateDocument: fnValidateTestDocument,
+      objDocument: {
+        objDocument: { arrNodes: ['node-v1'] },
+        strDocumentId: 'document-1',
+        strEditorKind: 'diagram',
+        strSchemaVersion: 'v1',
+      },
+      strTargetVersion: 'v3',
+    })
+
+    expect(objResult).toEqual({
+      objDocument: { arrNodes: ['node-v1', 'node-v2', 'node-v3'] },
+      strDocumentId: 'document-1',
+      strEditorKind: 'diagram',
+      strSchemaVersion: 'v3',
+    })
+  })
+
+  it('rejects missing and cyclic migration paths', () => {
+    const objDocument = {
+      objDocument: { arrNodes: ['node-v1'] },
+      strDocumentId: 'document-1',
+      strEditorKind: 'diagram',
+      strSchemaVersion: 'v1',
+    }
+
+    expect(() =>
+      fnMigrateOptionalEditorDocument({
+        arrMigrations: [],
+        fnValidateDocument: fnValidateTestDocument,
+        objDocument,
+        strTargetVersion: 'v2',
+      })
+    ).toThrowError(OptionalEditorError)
+    expect(() =>
+      fnMigrateOptionalEditorDocument({
+        arrMigrations: [
+          {
+            fnMigrate: fnValidateTestDocument,
+            strFromVersion: 'v1',
+            strToVersion: 'v2',
+          },
+          {
+            fnMigrate: fnValidateTestDocument,
+            strFromVersion: 'v2',
+            strToVersion: 'v1',
+          },
+        ],
+        fnValidateDocument: fnValidateTestDocument,
+        objDocument,
+        strTargetVersion: 'v3',
+      })
+    ).toThrowError(OptionalEditorError)
+  })
+})

package/template/tests/unit/optionalEditors/useOptionalEditor.test.tsx

@@ -0,0 +1,141 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { LocaleProvider } from '@/locale'
+import {
+  useOptionalEditor,
+  type IOptionalEditorAdapter,
+} from '@/optionalEditors'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { render } from 'vitest-browser-react'
+import { useAuthStore } from '@/stores/authStore'
+
+interface ITestDocument {
+  readonly strText: string
+}
+
+interface ITestBinding {
+  readonly strBindingId: string
+}
+
+function fnEstablishSession(arrPermissions: string[]) {
+  useAuthStore.getState().fnEstablishSession({
+    nAccessTokenExpiresAt: Date.now() + 60_000,
+    nRefreshTokenExpiresAt: Date.now() + 120_000,
+    objUser: {
+      arrPermissions,
+      arrRoleCodes: ['editor'],
+      strAccount: 'editor',
+      strDisplayName: 'Editor',
+      strId: 'user-1',
+      strRole: 'admin',
+      strTenantId: 'tenant-a',
+    },
+    strAccessToken: 'access-token',
+    strRefreshToken: 'refresh-token',
+  })
+}
+
+function OptionalEditorConsumer({
+  objAdapter,
+}: {
+  objAdapter: IOptionalEditorAdapter<ITestDocument, ITestBinding>
+}) {
+  const { fnSetContainer, ...objEditorSnapshot } = useOptionalEditor({
+    objAdapter,
+    objDocument: {
+      objDocument: { strText: 'content' },
+      strDocumentId: 'document-1',
+      strEditorKind: 'richText',
+      strSchemaVersion: 'v1',
+    },
+    strMode: 'edit',
+  })
+
+  return (
+    <section>
+      <div ref={fnSetContainer} aria-label='富文本编辑器' />
+      <output
+        data-error={
+          'objError' in objEditorSnapshot ? objEditorSnapshot.objError.name : ''
+        }
+      >
+        {objEditorSnapshot.strStatus === 'active'
+          ? objEditorSnapshot.objBinding.strBindingId
+          : objEditorSnapshot.strStatus}
+      </output>
+    </section>
+  )
+}
+
+function fnCreateTestRoot(objChildren: React.ReactNode) {
+  const objQueryClient = new QueryClient()
+  return (
+    <QueryClientProvider client={objQueryClient}>
+      <LocaleProvider strLocale='zh-CN' strTimeZone='Asia/Shanghai'>
+        {objChildren}
+      </LocaleProvider>
+    </QueryClientProvider>
+  )
+}
+
+describe('useOptionalEditor', () => {
+  afterEach(() => {
+    useAuthStore.getState().fnClearSession()
+  })
+
+  it('mounts a route-scoped SDK into the dedicated host with permission', async () => {
+    fnEstablishSession(['document:richText:edit'])
+    const fnMount = vi.fn<
+      IOptionalEditorAdapter<ITestDocument, ITestBinding>['fnMount']
+    >(async () => ({
+      fnDestroy: () => undefined,
+      fnReadDocument: () => ({ strText: 'content' }),
+      fnSubscribe: () => () => undefined,
+      objBinding: { strBindingId: 'binding-1' },
+    }))
+    const objScreen = await render(
+      fnCreateTestRoot(
+        <OptionalEditorConsumer
+          objAdapter={{
+            fnMount,
+            fnValidateDocument: (objDocument) => objDocument,
+            strEditorKind: 'richText',
+          }}
+        />
+      )
+    )
+
+    await expect
+      .element(objScreen.getByRole('status'))
+      .toHaveTextContent('binding-1')
+    expect(fnMount).toHaveBeenCalledOnce()
+    expect(fnMount.mock.calls[0]?.[0].objContainer).toHaveAttribute(
+      'aria-label',
+      '富文本编辑器'
+    )
+  })
+
+  it('surfaces an authorization failure returned by the project SDK', async () => {
+    fnEstablishSession([])
+    const fnMount = vi.fn<
+      IOptionalEditorAdapter<ITestDocument, ITestBinding>['fnMount']
+    >(() => Promise.reject(new Error('backend denied editor access')))
+    const objScreen = await render(
+      fnCreateTestRoot(
+        <OptionalEditorConsumer
+          objAdapter={{
+            fnMount,
+            fnValidateDocument: (objDocument) => objDocument,
+            strEditorKind: 'richText',
+          }}
+        />
+      )
+    )
+    const objOutput = objScreen.getByRole('status')
+
+    await expect.element(objOutput).toHaveTextContent('error')
+    await expect
+      .element(objOutput)
+      .toHaveAttribute('data-error', 'OptionalEditorError')
+    expect(fnMount).toHaveBeenCalledOnce()
+  })
+})

package/template/tests/unit/realtimeCollaboration/collaboration.test.ts

@@ -0,0 +1,240 @@
+import {
+  CollaborationError,
+  fnCreateCollaborationController,
+  fnNormalizeCollaborationParticipants,
+  type ICollaborationAdapter,
+  type ICollaborationConnection,
+  type TCollaborationSessionEvent,
+} from '@/realtimeCollaboration'
+import { describe, expect, it, vi } from 'vitest'
+import type { IAppQueryScope } from '@/api/query'
+
+interface ITestBinding {
+  readonly strBindingId: string
+}
+
+interface ITestConnectionHarness {
+  readonly objDisconnectMock: ReturnType<typeof vi.fn>
+  readonly fnEmit: (objEvent: TCollaborationSessionEvent) => void
+  readonly objSetPresenceStateMock: ReturnType<typeof vi.fn>
+  readonly objUnsubscribeMock: ReturnType<typeof vi.fn>
+  readonly objConnection: ICollaborationConnection<ITestBinding>
+}
+
+const objScope: IAppQueryScope = {
+  nSessionGeneration: 1,
+  strLocale: 'zh-CN',
+  strTenantId: 'tenant-a',
+  strUserId: 'user-1',
+  strWorkspaceId: 'workspace-a',
+}
+
+function fnCreateConnectionHarness(
+  strBindingId: string
+): ITestConnectionHarness {
+  let fnOnEvent: ((objEvent: TCollaborationSessionEvent) => void) | undefined
+  const fnDisconnect = vi.fn()
+  const fnSetPresenceState = vi.fn()
+  const fnUnsubscribe = vi.fn()
+  return {
+    objDisconnectMock: fnDisconnect,
+    fnEmit: (objEvent) => fnOnEvent?.(objEvent),
+    objSetPresenceStateMock: fnSetPresenceState,
+    objUnsubscribeMock: fnUnsubscribe,
+    objConnection: {
+      arrParticipants: [
+        {
+          strDisplayName: 'Current User',
+          strParticipantId: 'participant-1',
+          strPresenceState: 'active',
+          strUserId: 'user-1',
+        },
+      ],
+      fnDisconnect,
+      fnSetPresenceState,
+      fnSubscribe: (fnNextOnEvent) => {
+        fnOnEvent = fnNextOnEvent
+        return fnUnsubscribe
+      },
+      objBinding: { strBindingId },
+      strInitialSyncState: 'syncing',
+    },
+  }
+}
+
+function fnCreateDeferred<TValue>() {
+  let fnResolvePromise: (value: TValue) => void = () => undefined
+  const objPromise = new Promise<TValue>((fnResolve) => {
+    fnResolvePromise = fnResolve
+  })
+  return { fnResolve: fnResolvePromise, objPromise }
+}
+
+describe('realtime collaboration controller', () => {
+  it('publishes SDK connection, sync, presence and participant states', async () => {
+    const objHarness = fnCreateConnectionHarness('binding-1')
+    const objController = fnCreateCollaborationController<ITestBinding>({
+      fnConnect: async () => objHarness.objConnection,
+    })
+
+    const objConnected = await objController.fnOpen({
+      objScope,
+      strDocumentId: 'document-1',
+      strDocumentType: 'contract',
+      strMode: 'edit',
+    })
+    expect(objConnected).toMatchObject({
+      arrParticipants: [{ bIsCurrentUser: true }],
+      objBinding: { strBindingId: 'binding-1' },
+      strConnectionState: 'connected',
+      strStatus: 'active',
+      strSyncState: 'syncing',
+    })
+
+    objHarness.fnEmit({
+      strConnectionState: 'reconnecting',
+      strType: 'connectionChanged',
+    })
+    objHarness.fnEmit({ strSyncState: 'synced', strType: 'syncChanged' })
+    objHarness.fnEmit({
+      arrParticipants: [
+        {
+          strDisplayName: 'Reviewer',
+          strParticipantId: 'participant-2',
+          strPresenceState: 'idle',
+          strUserId: 'user-2',
+        },
+      ],
+      strType: 'participantsChanged',
+    })
+
+    expect(objController.fnGetSnapshot()).toMatchObject({
+      arrParticipants: [
+        {
+          bIsCurrentUser: false,
+          strDisplayName: 'Reviewer',
+          strPresenceState: 'idle',
+        },
+      ],
+      strConnectionState: 'reconnecting',
+      strSyncState: 'synced',
+    })
+    await expect(objController.fnSetPresenceState('idle')).resolves.toBe(true)
+    expect(objHarness.objSetPresenceStateMock).toHaveBeenCalledWith('idle')
+  })
+
+  it('lets only the latest document connection become active', async () => {
+    const objFirstDeferred =
+      fnCreateDeferred<ICollaborationConnection<ITestBinding>>()
+    const objSecondDeferred =
+      fnCreateDeferred<ICollaborationConnection<ITestBinding>>()
+    const objFirstHarness = fnCreateConnectionHarness('binding-first')
+    const objSecondHarness = fnCreateConnectionHarness('binding-second')
+    const arrSignals: AbortSignal[] = []
+    const objAdapter: ICollaborationAdapter<ITestBinding> = {
+      fnConnect: (objRequest) => {
+        arrSignals.push(objRequest.objSignal)
+        return objRequest.strDocumentId === 'document-1'
+          ? objFirstDeferred.objPromise
+          : objSecondDeferred.objPromise
+      },
+    }
+    const objController = fnCreateCollaborationController(objAdapter)
+
+    const objFirstOpen = objController.fnOpen({
+      objScope,
+      strDocumentId: 'document-1',
+      strDocumentType: 'contract',
+      strMode: 'edit',
+    })
+    const objSecondOpen = objController.fnOpen({
+      objScope,
+      strDocumentId: 'document-2',
+      strDocumentType: 'contract',
+      strMode: 'edit',
+    })
+    expect(arrSignals[0]?.aborted).toBe(true)
+
+    objSecondDeferred.fnResolve(objSecondHarness.objConnection)
+    await objSecondOpen
+    objFirstDeferred.fnResolve(objFirstHarness.objConnection)
+    await objFirstOpen
+
+    expect(objController.fnGetSnapshot()).toMatchObject({
+      objBinding: { strBindingId: 'binding-second' },
+      strDocumentId: 'document-2',
+      strStatus: 'active',
+    })
+    expect(objFirstHarness.objDisconnectMock).toHaveBeenCalledOnce()
+    expect(objSecondHarness.objDisconnectMock).not.toHaveBeenCalled()
+  })
+
+  it('unsubscribes and disconnects when the route closes', async () => {
+    const objHarness = fnCreateConnectionHarness('binding-1')
+    const objController = fnCreateCollaborationController<ITestBinding>({
+      fnConnect: async () => objHarness.objConnection,
+    })
+    await objController.fnOpen({
+      objScope,
+      strDocumentId: 'document-1',
+      strDocumentType: 'contract',
+      strMode: 'view',
+    })
+
+    expect(objController.fnClose()).toMatchObject({ strStatus: 'idle' })
+    expect(objHarness.objUnsubscribeMock).toHaveBeenCalledOnce()
+    expect(objHarness.objDisconnectMock).toHaveBeenCalledOnce()
+
+    objHarness.fnEmit({ strSyncState: 'synced', strType: 'syncChanged' })
+    expect(objController.fnGetSnapshot().strStatus).toBe('idle')
+  })
+
+  it('closes a session when the SDK emits invalid participant data', async () => {
+    const objHarness = fnCreateConnectionHarness('binding-1')
+    const objController = fnCreateCollaborationController<ITestBinding>({
+      fnConnect: async () => objHarness.objConnection,
+    })
+    await objController.fnOpen({
+      objScope,
+      strDocumentId: 'document-1',
+      strDocumentType: 'contract',
+      strMode: 'edit',
+    })
+
+    objHarness.fnEmit({
+      arrParticipants: [
+        {
+          strDisplayName: 'Duplicate One',
+          strParticipantId: 'duplicate',
+          strPresenceState: 'active',
+        },
+        {
+          strDisplayName: 'Duplicate Two',
+          strParticipantId: 'duplicate',
+          strPresenceState: 'active',
+        },
+      ],
+      strType: 'participantsChanged',
+    })
+
+    expect(objController.fnGetSnapshot()).toMatchObject({
+      objError: { strCode: 'invalid_event' },
+      strStatus: 'error',
+    })
+    expect(objHarness.objDisconnectMock).toHaveBeenCalledOnce()
+  })
+})
+
+describe('collaboration participant validation', () => {
+  it('rejects more than the bounded participant count', () => {
+    const arrParticipants = [...Array(201).keys()].map((nIndex) => ({
+      strDisplayName: `User ${nIndex}`,
+      strParticipantId: `participant-${nIndex}`,
+      strPresenceState: 'active',
+    }))
+
+    expect(() =>
+      fnNormalizeCollaborationParticipants(arrParticipants, 'user-1')
+    ).toThrowError(CollaborationError)
+  })
+})