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

package/template/tests/unit/api/query/queryPolicy.test.ts

@@ -0,0 +1,245 @@
+import { QueryClient } from '@tanstack/react-query'
+import { describe, expect, it, vi } from 'vitest'
+import {
+  fnApplyOptimisticQueryUpdate,
+  fnCreateAppMutationScope,
+  fnCreateAppQueryKeys,
+  fnCreateAppQueryScope,
+  fnRollbackOptimisticQueryUpdate,
+} from '@/api/query'
+
+const objScope = fnCreateAppQueryScope({
+  nSessionGeneration: 3,
+  strLocale: 'zh-CN',
+  strTenantId: ' tenant-a ',
+  strUserId: ' user-1 ',
+  strWorkspaceId: ' workspace-a ',
+})
+
+describe('application Query Key policy', () => {
+  it('normalizes and freezes the complete cache identity', () => {
+    expect(objScope).toEqual({
+      nSessionGeneration: 3,
+      strLocale: 'zh-CN',
+      strTenantId: 'tenant-a',
+      strUserId: 'user-1',
+      strWorkspaceId: 'workspace-a',
+    })
+    expect(Object.isFrozen(objScope)).toBe(true)
+    expect(() =>
+      fnCreateAppQueryScope({
+        nSessionGeneration: -1,
+        strLocale: 'zh-CN',
+        strUserId: 'user-1',
+      })
+    ).toThrow('会话版本必须是非负整数')
+    expect(() =>
+      fnCreateAppQueryScope({
+        nSessionGeneration: 0,
+        strLocale: 'zh-CN',
+        strUserId: ' ',
+      })
+    ).toThrow('strUserId 不能为空')
+  })
+
+  it('creates a predictable Feature, scope, resource and list/detail hierarchy', () => {
+    const objKeys = fnCreateAppQueryKeys(' employeeDirectory ', objScope)
+
+    expect(objKeys.arrAll).toEqual(['appQuery', 'employeeDirectory'])
+    expect(objKeys.arrScope).toEqual([
+      'appQuery',
+      'employeeDirectory',
+      objScope,
+    ])
+    expect(objKeys.fnResource('employees')).toEqual([
+      ...objKeys.arrScope,
+      'employees',
+    ])
+    expect(objKeys.fnLists('employees')).toEqual([
+      ...objKeys.arrScope,
+      'employees',
+      'list',
+    ])
+    expect(
+      objKeys.fnList('employees', { nPage: 1, strKeyword: 'Ada' })
+    ).toEqual([
+      ...objKeys.arrScope,
+      'employees',
+      'list',
+      { nPage: 1, strKeyword: 'Ada' },
+    ])
+    expect(objKeys.fnDetails('employees')).toEqual([
+      ...objKeys.arrScope,
+      'employees',
+      'detail',
+    ])
+    expect(objKeys.fnDetail('employees', 'employee-1')).toEqual([
+      ...objKeys.arrScope,
+      'employees',
+      'detail',
+      'employee-1',
+    ])
+  })
+
+  it('isolates user, tenant, locale, workspace and session changes', () => {
+    const arrBaseKey = fnCreateAppQueryKeys('example', objScope).arrScope
+    const arrChangedKeys = [
+      fnCreateAppQueryKeys('example', {
+        ...objScope,
+        strUserId: 'user-2',
+      }).arrScope,
+      fnCreateAppQueryKeys('example', {
+        ...objScope,
+        strTenantId: 'tenant-b',
+      }).arrScope,
+      fnCreateAppQueryKeys('example', {
+        ...objScope,
+        strLocale: 'en-US',
+      }).arrScope,
+      fnCreateAppQueryKeys('example', {
+        ...objScope,
+        strWorkspaceId: 'workspace-b',
+      }).arrScope,
+      fnCreateAppQueryKeys('example', {
+        ...objScope,
+        nSessionGeneration: 4,
+      }).arrScope,
+    ]
+
+    arrChangedKeys.forEach((arrChangedKey) => {
+      expect(arrChangedKey).not.toEqual(arrBaseKey)
+    })
+  })
+
+  it('canonicalizes top-level list parameters and rejects unstable identifiers', () => {
+    const objKeys = fnCreateAppQueryKeys('example', objScope)
+    const arrLeftKey = objKeys.fnList('employees', {
+      strKeyword: 'Ada',
+      nPage: 1,
+    })
+    const arrRightKey = objKeys.fnList('employees', {
+      nPage: 1,
+      strKeyword: 'Ada',
+    })
+
+    expect(arrLeftKey).toEqual(arrRightKey)
+    expect(Object.isFrozen(arrLeftKey)).toBe(true)
+    expect(() => objKeys.fnDetail('employees', Number.NaN)).toThrow(
+      '实体标识必须是有限数字或非空字符串'
+    )
+    expect(() =>
+      objKeys.fnList('employees', {
+        objFilter: { arrScores: [1, Number.POSITIVE_INFINITY] },
+      })
+    ).toThrow('objFilter.arrScores[1] 必须是可序列化的有限数字')
+    expect(() => objKeys.fnResource(' ')).toThrow('strResource 不能为空')
+  })
+
+  it('invalidates list and resource prefixes without crossing scope boundaries', async () => {
+    const objQueryClient = new QueryClient()
+    const objKeys = fnCreateAppQueryKeys('employeeDirectory', objScope)
+    const objOtherKeys = fnCreateAppQueryKeys('employeeDirectory', {
+      ...objScope,
+      strTenantId: 'tenant-b',
+    })
+    const arrListKey = objKeys.fnList('employees', { nPage: 1 })
+    const arrDetailKey = objKeys.fnDetail('employees', 'employee-1')
+    const arrOtherTenantKey = objOtherKeys.fnList('employees', { nPage: 1 })
+    objQueryClient.setQueryData(arrListKey, [])
+    objQueryClient.setQueryData(arrDetailKey, { strId: 'employee-1' })
+    objQueryClient.setQueryData(arrOtherTenantKey, [])
+
+    await objQueryClient.invalidateQueries({
+      queryKey: objKeys.fnLists('employees'),
+    })
+
+    expect(objQueryClient.getQueryState(arrListKey)?.isInvalidated).toBe(true)
+    expect(objQueryClient.getQueryState(arrDetailKey)?.isInvalidated).toBe(
+      false
+    )
+    expect(objQueryClient.getQueryState(arrOtherTenantKey)?.isInvalidated).toBe(
+      false
+    )
+
+    await objQueryClient.invalidateQueries({
+      queryKey: objKeys.fnResource('employees'),
+    })
+
+    expect(objQueryClient.getQueryState(arrDetailKey)?.isInvalidated).toBe(true)
+    expect(objQueryClient.getQueryState(arrOtherTenantKey)?.isInvalidated).toBe(
+      false
+    )
+  })
+})
+
+describe('application Mutation policy', () => {
+  it('serializes the same target while allowing different targets to run independently', () => {
+    const objKeys = fnCreateAppQueryKeys('employeeDirectory', objScope)
+
+    const objFirstScope = fnCreateAppMutationScope(
+      objKeys.fnDetail('employees', 'employee-1')
+    )
+    const objSameScope = fnCreateAppMutationScope(
+      objKeys.fnDetail('employees', 'employee-1')
+    )
+    const objOtherScope = fnCreateAppMutationScope(
+      objKeys.fnDetail('employees', 'employee-2')
+    )
+
+    expect(objFirstScope).toEqual(objSameScope)
+    expect(objFirstScope).not.toEqual(objOtherScope)
+  })
+
+  it('cancels a query, applies an optimistic value and restores the snapshot', async () => {
+    const objQueryClient = new QueryClient()
+    const arrQueryKey = fnCreateAppQueryKeys(
+      'employeeDirectory',
+      objScope
+    ).fnDetail('employees', 'employee-1')
+    const objPreviousEmployee = { bIsEnabled: false, strId: 'employee-1' }
+    objQueryClient.setQueryData(arrQueryKey, objPreviousEmployee)
+    const fnCancelQueries = vi.spyOn(objQueryClient, 'cancelQueries')
+
+    const objSnapshot = await fnApplyOptimisticQueryUpdate(
+      objQueryClient,
+      arrQueryKey,
+      (objEmployee: typeof objPreviousEmployee | undefined) => ({
+        ...objEmployee,
+        bIsEnabled: true,
+        strId: objEmployee?.strId ?? 'employee-1',
+      })
+    )
+
+    expect(fnCancelQueries).toHaveBeenCalledWith({
+      exact: true,
+      queryKey: arrQueryKey,
+    })
+    expect(objQueryClient.getQueryData(arrQueryKey)).toEqual({
+      bIsEnabled: true,
+      strId: 'employee-1',
+    })
+
+    fnRollbackOptimisticQueryUpdate(objQueryClient, objSnapshot)
+
+    expect(objQueryClient.getQueryData(arrQueryKey)).toEqual(
+      objPreviousEmployee
+    )
+  })
+
+  it('removes optimistic cache data when no query existed before the mutation', async () => {
+    const objQueryClient = new QueryClient()
+    const arrQueryKey = fnCreateAppQueryKeys(
+      'employeeDirectory',
+      objScope
+    ).fnDetail('employees', 'employee-new')
+
+    const objSnapshot = await fnApplyOptimisticQueryUpdate(
+      objQueryClient,
+      arrQueryKey,
+      () => ({ strId: 'employee-new' })
+    )
+    fnRollbackOptimisticQueryUpdate(objQueryClient, objSnapshot)
+
+    expect(objQueryClient.getQueryState(arrQueryKey)).toBeUndefined()
+  })
+})

package/template/tests/unit/api/query/useAppQueryScope.test.tsx

@@ -0,0 +1,74 @@
+import { LocaleProvider } from '@/locale'
+import { afterEach, describe, expect, it } from 'vitest'
+import { render } from 'vitest-browser-react'
+import { useAppQueryScope } from '@/api/query'
+import { useAuthStore } from '@/stores/authStore'
+
+function QueryScopeConsumer({ strWorkspaceId }: { strWorkspaceId?: string }) {
+  const objScope = useAppQueryScope({ strWorkspaceId })
+  return (
+    <output
+      data-generation={objScope.nSessionGeneration}
+      data-locale={objScope.strLocale}
+      data-tenant={objScope.strTenantId}
+      data-user={objScope.strUserId}
+      data-workspace={objScope.strWorkspaceId}
+    >
+      query scope
+    </output>
+  )
+}
+
+describe('useAppQueryScope', () => {
+  afterEach(() => {
+    useAuthStore.getState().fnClearSession()
+  })
+
+  it('derives user and tenant from auth while keeping locale in the same identity', async () => {
+    useAuthStore.getState().fnEstablishSession({
+      nAccessTokenExpiresAt: Date.now() + 60_000,
+      nRefreshTokenExpiresAt: Date.now() + 120_000,
+      objUser: {
+        arrPermissions: ['employee:read'],
+        arrRoleCodes: ['employee-reader'],
+        strAccount: 'reader',
+        strDisplayName: 'Reader',
+        strId: 'user-1',
+        strRole: 'admin',
+        strTenantId: 'tenant-a',
+      },
+      strAccessToken: 'access-token',
+      strRefreshToken: 'refresh-token',
+    })
+    const nSessionGeneration = useAuthStore.getState().nSessionGeneration
+    const objScreen = await render(
+      <LocaleProvider strLocale='en-US' strTimeZone='UTC'>
+        <QueryScopeConsumer strWorkspaceId='workspace-a' />
+      </LocaleProvider>
+    )
+    const objOutput = objScreen.getByRole('status')
+
+    await expect
+      .element(objOutput)
+      .toHaveAttribute('data-generation', String(nSessionGeneration))
+    await expect.element(objOutput).toHaveAttribute('data-locale', 'en-US')
+    await expect.element(objOutput).toHaveAttribute('data-tenant', 'tenant-a')
+    await expect.element(objOutput).toHaveAttribute('data-user', 'user-1')
+    await expect
+      .element(objOutput)
+      .toHaveAttribute('data-workspace', 'workspace-a')
+  })
+
+  it('uses an explicit anonymous identity before authentication', async () => {
+    useAuthStore.getState().fnClearSession()
+    const objScreen = await render(
+      <LocaleProvider strLocale='zh-CN' strTimeZone='Asia/Shanghai'>
+        <QueryScopeConsumer />
+      </LocaleProvider>
+    )
+
+    await expect
+      .element(objScreen.getByRole('status'))
+      .toHaveAttribute('data-user', 'anonymous')
+  })
+})

package/template/tests/unit/auditLogs/auditLogHooks.test.tsx

@@ -0,0 +1,194 @@
+import { useState, type ReactNode } from 'react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { ApiError } from '@/api'
+import {
+  fnCreateAuditLogSource,
+  useAuditLogExport,
+  useAuditLogList,
+  type IAuditLogExportSource,
+  type TAuditLogListRequest,
+} from '@/auditLogs'
+import { LocaleProvider } from '@/locale'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { render } from 'vitest-browser-react'
+import { useAuthStore } from '@/stores/authStore'
+
+function fnEstablishAuditSession(arrPermissions: string[]) {
+  useAuthStore.getState().fnEstablishSession({
+    nAccessTokenExpiresAt: Date.now() + 60_000,
+    nRefreshTokenExpiresAt: Date.now() + 120_000,
+    objUser: {
+      arrPermissions,
+      arrRoleCodes: ['auditor'],
+      strAccount: 'auditor',
+      strDisplayName: 'Auditor',
+      strId: 'user-1',
+      strRole: 'admin',
+      strTenantId: 'tenant-a',
+    },
+    strAccessToken: 'access-token',
+    strRefreshToken: 'refresh-token',
+  })
+}
+
+function AuditLogListConsumer({ fnList }: { fnList: TAuditLogListRequest }) {
+  const objQuery = useAuditLogList({
+    objFilter: { strAction: 'order.approve' },
+    objSource: fnCreateAuditLogSource({
+      fnGetDetail: async () => ({
+        arrChanges: [],
+        arrContextFields: [],
+        objEntry: {},
+      }),
+      fnList,
+    }),
+  })
+
+  return (
+    <output data-error={objQuery.error?.name}>
+      {objQuery.data?.arrEntries[0]?.strSummary ?? objQuery.status}
+    </output>
+  )
+}
+
+function AuditLogExportConsumer({
+  objSource,
+}: {
+  objSource: IAuditLogExportSource
+}) {
+  const { fnRun, objState } = useAuditLogExport({
+    objSource,
+  })
+
+  return (
+    <div>
+      <button
+        type='button'
+        onClick={() =>
+          void fnRun({
+            objFilter: { strAction: 'order.approve' },
+            strFormat: 'xlsx',
+          })
+        }
+      >
+        导出
+      </button>
+      <output>
+        {objState.strStatus === 'success'
+          ? objState.objResult.strFileName
+          : objState.strStatus}
+      </output>
+    </div>
+  )
+}
+
+function AuditTestShell({ children: objChildren }: { children: ReactNode }) {
+  const [objQueryClient] = useState(
+    () =>
+      new QueryClient({
+        defaultOptions: { queries: { retry: false } },
+      })
+  )
+  return (
+    <QueryClientProvider client={objQueryClient}>
+      <LocaleProvider strLocale='zh-CN' strTimeZone='Asia/Shanghai'>
+        {objChildren}
+      </LocaleProvider>
+    </QueryClientProvider>
+  )
+}
+
+describe('audit log React access', () => {
+  afterEach(() => {
+    useAuthStore.getState().fnClearSession()
+  })
+
+  it('loads a scoped list through the generated-client adapter', async () => {
+    fnEstablishAuditSession(['audit:read'])
+    const fnList = vi.fn<TAuditLogListRequest>(async () => ({
+      arrEntries: [
+        {
+          strAction: 'order.approve',
+          strActorType: 'user',
+          strAuditLogId: 'audit-1',
+          strOccurredAt: '2026-08-27T09:00:00.000Z',
+          strOutcome: 'succeeded',
+          strSummary: '订单审批成功',
+        },
+      ],
+      bHasMore: false,
+    }))
+    const objScreen = await render(
+      <AuditTestShell>
+        <AuditLogListConsumer fnList={fnList} />
+      </AuditTestShell>
+    )
+
+    await expect
+      .element(objScreen.getByRole('status'))
+      .toHaveTextContent('订单审批成功')
+    const objRequest = fnList.mock.calls[0]?.[0]
+    expect(objRequest?.objScope).toMatchObject({
+      strTenantId: 'tenant-a',
+      strUserId: 'user-1',
+    })
+    expect(objRequest?.objFilter).toMatchObject({
+      nPageSize: 50,
+      strAction: 'order.approve',
+    })
+  })
+
+  it('surfaces a backend authorization error from the list adapter', async () => {
+    fnEstablishAuditSession([])
+    const fnList = vi.fn<TAuditLogListRequest>(() =>
+      Promise.reject(
+        new ApiError({
+          bRetriable: false,
+          nStatus: 403,
+          strCode: 'FORBIDDEN',
+          strKind: 'http',
+          strMessage: '无权读取审计日志。',
+        })
+      )
+    )
+    const objScreen = await render(
+      <AuditTestShell>
+        <AuditLogListConsumer fnList={fnList} />
+      </AuditTestShell>
+    )
+    const objOutput = objScreen.getByRole('status')
+
+    await expect.element(objOutput).toHaveAttribute('data-error', 'ApiError')
+    expect(fnList).toHaveBeenCalledOnce()
+  })
+
+  it('reuses the file-task lifecycle and returns a sanitized file identity', async () => {
+    fnEstablishAuditSession(['audit:export'])
+    const fnStartExport = vi.fn<IAuditLogExportSource['fnStartExport']>(
+      async () => ({
+        objResult: {
+          strExportId: 'export-1',
+          strFileId: 'file-1',
+          strFileName: '../audit?.xlsx',
+        },
+        strMode: 'completed',
+      })
+    )
+    const objScreen = await render(
+      <AuditTestShell>
+        <AuditLogExportConsumer objSource={{ fnStartExport }} />
+      </AuditTestShell>
+    )
+
+    await objScreen.getByRole('button', { name: '导出' }).click()
+    await expect
+      .element(objScreen.getByRole('status'))
+      .toHaveTextContent('audit_.xlsx')
+    const objContext = fnStartExport.mock.calls[0]?.[0]
+    expect(objContext?.objScope).toMatchObject({ strUserId: 'user-1' })
+    expect(objContext?.objRequest).toMatchObject({
+      objFilter: { strAction: 'order.approve' },
+      strFormat: 'xlsx',
+    })
+  })
+})

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

@@ -0,0 +1,199 @@
+import {
+  AuditLogError,
+  fnCreateAuditLogSource,
+  fnNormalizeAuditLogDetail,
+  fnNormalizeAuditLogExportResult,
+  fnNormalizeAuditLogFilter,
+  fnNormalizeAuditLogPage,
+  type IAuditLogEntryInput,
+  type TAuditLogDetailRequest,
+  type TAuditLogListRequest,
+} from '@/auditLogs'
+import { describe, expect, it, vi } from 'vitest'
+
+function fnCreateAuditLogEntry(
+  objOverrides: Partial<IAuditLogEntryInput> = {}
+): IAuditLogEntryInput {
+  return {
+    strAction: 'order.approve',
+    strActorId: 'user-1',
+    strActorLabel: 'Auditor',
+    strActorType: 'user',
+    strAuditLogId: 'audit-1',
+    strOccurredAt: '2026-08-27T09:00:00.000Z',
+    strOutcome: 'succeeded',
+    strRequestId: 'request-1',
+    strSummary: '订单审批成功',
+    strTargetId: 'order-1',
+    strTargetType: 'order',
+    strTenantId: 'tenant-a',
+    ...objOverrides,
+  }
+}
+
+describe('audit log filters and response validation', () => {
+  it('normalizes a bounded cursor filter and rejects reversed time ranges', () => {
+    expect(
+      fnNormalizeAuditLogFilter({
+        strAction: ' order.approve ',
+        strEndedAt: '2026-08-27T10:00:00+00:00',
+        strStartedAt: '2026-08-27T08:00:00+00:00',
+      })
+    ).toEqual({
+      nPageSize: 50,
+      strAction: 'order.approve',
+      strActorId: undefined,
+      strCursor: undefined,
+      strEndedAt: '2026-08-27T10:00:00.000Z',
+      strOutcome: undefined,
+      strRequestId: undefined,
+      strStartedAt: '2026-08-27T08:00:00.000Z',
+      strTargetId: undefined,
+      strTargetType: undefined,
+      strTenantId: undefined,
+      strWorkspaceId: undefined,
+    })
+
+    expect(() =>
+      fnNormalizeAuditLogFilter({
+        strEndedAt: '2026-08-27T08:00:00.000Z',
+        strStartedAt: '2026-08-27T10:00:00.000Z',
+      })
+    ).toThrowError(AuditLogError)
+  })
+
+  it('sorts pages newest first and rejects pagination without a cursor', () => {
+    const objPage = fnNormalizeAuditLogPage({
+      arrEntries: [
+        fnCreateAuditLogEntry(),
+        fnCreateAuditLogEntry({
+          strAuditLogId: 'audit-2',
+          strOccurredAt: '2026-08-27T10:00:00.000Z',
+        }),
+      ],
+      bHasMore: true,
+      nTotal: 2,
+      strNextCursor: 'cursor-2',
+    })
+
+    expect(
+      objPage.arrEntries.map((objEntry) => objEntry.strAuditLogId)
+    ).toEqual(['audit-2', 'audit-1'])
+    expect(() =>
+      fnNormalizeAuditLogPage({
+        arrEntries: [],
+        bHasMore: true,
+      })
+    ).toThrowError(expect.objectContaining({ strCode: 'INVALID_PAGE' }))
+  })
+
+  it('accepts only bounded display fields in details', () => {
+    const objDetail = fnNormalizeAuditLogDetail({
+      arrChanges: [
+        {
+          strAfterDisplayValue: '已通过',
+          strBeforeDisplayValue: '待审批',
+          strDisplayMode: 'plain',
+          strField: 'status',
+          strFieldLabel: '状态',
+        },
+      ],
+      arrContextFields: [
+        {
+          strDisplayMode: 'masked',
+          strDisplayValue: '138****0000',
+          strKey: 'operatorPhone',
+          strLabel: '操作人手机号',
+        },
+      ],
+      objEntry: fnCreateAuditLogEntry(),
+    })
+
+    expect(objDetail.arrChanges[0]).toMatchObject({
+      strAfterDisplayValue: '已通过',
+      strField: 'status',
+    })
+    expect(objDetail.arrContextFields[0]).toMatchObject({
+      strDisplayMode: 'masked',
+      strDisplayValue: '138****0000',
+    })
+  })
+
+  it('sanitizes export file names and keeps only protected file identity', () => {
+    expect(
+      fnNormalizeAuditLogExportResult({
+        strExportId: 'export-1',
+        strFileId: 'file-1',
+        strFileName: '../../audit?.xlsx',
+      })
+    ).toEqual({
+      strExportId: 'export-1',
+      strFileId: 'file-1',
+      strFileName: 'audit_.xlsx',
+    })
+  })
+})
+
+describe('audit log Swagger source', () => {
+  it('passes cancellation and normalized filters to generated requests', async () => {
+    const fnList = vi.fn<TAuditLogListRequest>(async () => ({
+      arrEntries: [fnCreateAuditLogEntry()],
+      bHasMore: false,
+    }))
+    const fnGetDetail = vi.fn<TAuditLogDetailRequest>(async () => ({
+      arrChanges: [],
+      arrContextFields: [],
+      objEntry: fnCreateAuditLogEntry(),
+    }))
+    const objSource = fnCreateAuditLogSource({ fnGetDetail, fnList })
+    const objSignal = new AbortController().signal
+    const objScope = {
+      nSessionGeneration: 1,
+      strLocale: 'zh-CN' as const,
+      strTenantId: 'tenant-a',
+      strUserId: 'user-1',
+    }
+
+    await objSource.fnList({
+      objFilter: fnNormalizeAuditLogFilter({ strAction: ' order.approve ' }),
+      objScope,
+      objSignal,
+    })
+    const objListRequest = fnList.mock.calls[0]?.[0]
+    expect(objListRequest?.objFilter).toMatchObject({
+      nPageSize: 50,
+      strAction: 'order.approve',
+    })
+    expect(objListRequest?.objSignal).toBe(objSignal)
+
+    await objSource.fnGetDetail({
+      objScope,
+      objSignal,
+      strAuditLogId: 'audit-1',
+    })
+    expect(fnGetDetail).toHaveBeenCalledOnce()
+  })
+
+  it('rejects a detail whose returned identity differs from the request', async () => {
+    const objSource = fnCreateAuditLogSource({
+      fnGetDetail: async () => ({
+        arrChanges: [],
+        arrContextFields: [],
+        objEntry: fnCreateAuditLogEntry({ strAuditLogId: 'audit-other' }),
+      }),
+      fnList: async () => ({ arrEntries: [], bHasMore: false }),
+    })
+
+    await expect(
+      objSource.fnGetDetail({
+        objScope: {
+          nSessionGeneration: 1,
+          strLocale: 'zh-CN',
+          strUserId: 'user-1',
+        },
+        objSignal: new AbortController().signal,
+        strAuditLogId: 'audit-1',
+      })
+    ).rejects.toMatchObject({ strCode: 'INVALID_DETAIL' })
+  })
+})