@open-mercato/enterprise 0.4.5-develop-2e9903a57a → 0.4.5-develop-754ef4d2f0

package/src/modules/record_locks/__tests__/recordLockWidgetHeaders.test.ts

@@ -1,127 +0,0 @@
-import widget from '../widgets/injection/record-locking/widget'
-import {
-  clearRecordLockFormState,
-  getRecordLockFormState,
-  setRecordLockFormState,
-} from '@open-mercato/enterprise/modules/record_locks/lib/clientLockStore'
-import { validateBeforeSave } from '../widgets/injection/record-locking/widget.client'
-
-jest.mock('../widgets/injection/record-locking/widget.client', () => ({
-  __esModule: true,
-  default: () => null,
-  validateBeforeSave: jest.fn(),
-}))
-
-const mockedValidateBeforeSave = validateBeforeSave as jest.MockedFunction<typeof validateBeforeSave>
-
-describe('record lock widget resolution headers', () => {
-  const formId = 'record-lock:test-form'
-  const conflictId = 'a0000000-0000-4000-8000-000000000001'
-
-  beforeEach(() => {
-    clearRecordLockFormState(formId)
-    mockedValidateBeforeSave.mockReset()
-    mockedValidateBeforeSave.mockResolvedValue({ ok: true })
-  })
-
-  test('blocks save when resolution intent is not armed', async () => {
-    setRecordLockFormState(formId, {
-      formId,
-      resourceKind: 'customers.deal',
-      resourceId: 'b0000000-0000-4000-8000-000000000001',
-      conflict: {
-        id: conflictId,
-        resourceKind: 'customers.deal',
-        resourceId: 'b0000000-0000-4000-8000-000000000001',
-        baseActionLogId: null,
-        incomingActionLogId: null,
-        allowIncomingOverride: true,
-        canOverrideIncoming: true,
-        resolutionOptions: ['accept_mine'],
-        changes: [],
-      },
-      pendingConflictId: conflictId,
-      pendingResolution: 'accept_mine',
-      pendingResolutionArmed: false,
-    })
-
-    const result = await widget.eventHandlers.onBeforeSave({}, { formId } as any)
-    expect(result.ok).toBe(false)
-    expect(mockedValidateBeforeSave).not.toHaveBeenCalled()
-  })
-
-  test('does not call validate before save while conflict is unresolved', async () => {
-    setRecordLockFormState(formId, {
-      formId,
-      resourceKind: 'customers.deal',
-      resourceId: 'b0000000-0000-4000-8000-000000000001',
-      conflict: {
-        id: conflictId,
-        resourceKind: 'customers.deal',
-        resourceId: 'b0000000-0000-4000-8000-000000000001',
-        baseActionLogId: null,
-        incomingActionLogId: null,
-        allowIncomingOverride: true,
-        canOverrideIncoming: true,
-        resolutionOptions: ['accept_mine'],
-        changes: [],
-      },
-      pendingConflictId: conflictId,
-      pendingResolution: 'normal',
-      pendingResolutionArmed: false,
-    })
-
-    const result = await widget.eventHandlers.onBeforeSave({}, { formId } as any)
-    expect(result.ok).toBe(false)
-    expect(mockedValidateBeforeSave).not.toHaveBeenCalled()
-  })
-
-  test('sends resolution header once and disarms it immediately', async () => {
-    setRecordLockFormState(formId, {
-      formId,
-      resourceKind: 'customers.deal',
-      resourceId: 'b0000000-0000-4000-8000-000000000001',
-      conflict: {
-        id: conflictId,
-        resourceKind: 'customers.deal',
-        resourceId: 'b0000000-0000-4000-8000-000000000001',
-        baseActionLogId: null,
-        incomingActionLogId: null,
-        allowIncomingOverride: true,
-        canOverrideIncoming: true,
-        resolutionOptions: ['accept_mine'],
-        changes: [],
-      },
-      pendingConflictId: conflictId,
-      pendingResolution: 'accept_mine',
-      pendingResolutionArmed: true,
-    })
-
-    const first = await widget.eventHandlers.onBeforeSave({}, { formId } as any)
-    expect(first.ok).toBe(true)
-    if (!first.ok) throw new Error('Expected successful first result')
-    expect(first.requestHeaders?.['x-om-record-lock-resolution']).toBe('accept_mine')
-
-    const consumedState = getRecordLockFormState(formId)
-    expect(consumedState?.pendingResolution).toBe('normal')
-    expect(consumedState?.pendingResolutionArmed).toBe(false)
-
-    const second = await widget.eventHandlers.onBeforeSave({}, { formId } as any)
-    expect(second.ok).toBe(false)
-  })
-
-  test('blocks save when record was deleted by another user', async () => {
-    setRecordLockFormState(formId, {
-      formId,
-      resourceKind: 'customers.deal',
-      resourceId: 'b0000000-0000-4000-8000-000000000001',
-      recordDeleted: true,
-    })
-
-    const result = await widget.eventHandlers.onBeforeSave({}, { formId } as any)
-    expect(result.ok).toBe(false)
-    if (result.ok) throw new Error('Expected blocked save result')
-    expect(result.message).toContain('deleted')
-    expect(mockedValidateBeforeSave).not.toHaveBeenCalled()
-  })
-})

package/src/modules/record_locks/api/__tests__/acquire.route.test.ts

@@ -1,175 +0,0 @@
-import { POST } from '@open-mercato/enterprise/modules/record_locks/api/acquire/route'
-import { resolveRecordLocksApiContext, resolveRequestIp } from '@open-mercato/enterprise/modules/record_locks/api/utils'
-
-jest.mock('@open-mercato/enterprise/modules/record_locks/api/utils', () => ({
-  resolveRecordLocksApiContext: jest.fn(),
-  resolveRequestIp: jest.fn(() => '127.0.0.1'),
-}))
-
-function makeContext(overrides: Record<string, unknown> = {}) {
-  const emInstance = {
-    fork: () => ({
-      findOne: async () => null,
-    }),
-  }
-  const rbacServiceInstance = {
-    userHasAllFeatures: jest.fn().mockResolvedValue(true),
-  }
-
-  return {
-    auth: {
-      sub: '10000000-0000-4000-8000-000000000001',
-      tenantId: '20000000-0000-4000-8000-000000000001',
-    },
-    organizationId: '30000000-0000-4000-8000-000000000001',
-    container: {
-      resolve: (key: string) => {
-        if (key === 'em') return emInstance
-        if (key === 'rbacService') return rbacServiceInstance
-        return null
-      },
-    },
-    ...overrides,
-  }
-}
-
-function makeRequest(body: unknown) {
-  return new Request('http://localhost/api/record_locks/acquire', {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify(body),
-  })
-}
-
-describe('record_locks acquire route', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  test('returns 400 for invalid payload', async () => {
-    ;(resolveRecordLocksApiContext as jest.Mock).mockResolvedValue(makeContext({
-      recordLockService: { acquire: jest.fn() },
-    }))
-
-    const response = await POST(makeRequest({}))
-    expect(response.status).toBe(400)
-  })
-
-  test('returns lock error payload when service reports lock', async () => {
-    const acquire = jest.fn().mockResolvedValue({
-      ok: false,
-      status: 423,
-      error: 'Record is currently locked by another user',
-      code: 'record_locked',
-      allowForceUnlock: false,
-      lock: null,
-    })
-
-    ;(resolveRecordLocksApiContext as jest.Mock).mockResolvedValue(makeContext({
-      recordLockService: { acquire },
-    }))
-
-    const response = await POST(
-      makeRequest({
-        resourceKind: 'sales.quote',
-        resourceId: '40000000-0000-4000-8000-000000000001',
-      }),
-    )
-
-    expect(response.status).toBe(423)
-    const body = await response.json()
-    expect(body).toMatchObject({
-      code: 'record_locked',
-      error: 'Record is currently locked by another user',
-      allowForceUnlock: false,
-    })
-    expect(resolveRequestIp).toHaveBeenCalled()
-  })
-
-  test('returns successful acquire response', async () => {
-    const acquire = jest.fn().mockResolvedValue({
-      ok: true,
-      enabled: true,
-      resourceEnabled: true,
-      strategy: 'optimistic',
-      allowForceUnlock: true,
-      heartbeatSeconds: 30,
-      acquired: true,
-      latestActionLogId: null,
-      lock: null,
-    })
-
-    ;(resolveRecordLocksApiContext as jest.Mock).mockResolvedValue(makeContext({
-      recordLockService: { acquire },
-    }))
-
-    const response = await POST(
-      makeRequest({
-        resourceKind: 'sales.quote',
-        resourceId: '40000000-0000-4000-8000-000000000001',
-      }),
-    )
-
-    expect(response.status).toBe(200)
-    const body = await response.json()
-    expect(body).toMatchObject({
-      ok: true,
-      resourceEnabled: true,
-      strategy: 'optimistic',
-      allowForceUnlock: true,
-    })
-  })
-
-  test('hides force unlock when user lacks force-release feature', async () => {
-    const acquire = jest.fn().mockResolvedValue({
-      ok: true,
-      enabled: true,
-      resourceEnabled: true,
-      strategy: 'optimistic',
-      allowForceUnlock: true,
-      heartbeatSeconds: 30,
-      acquired: false,
-      latestActionLogId: null,
-      lock: null,
-    })
-    const rbacService = {
-      userHasAllFeatures: jest.fn().mockResolvedValue(false),
-    }
-
-    ;(resolveRecordLocksApiContext as jest.Mock).mockResolvedValue(makeContext({
-      recordLockService: { acquire },
-      container: {
-        resolve: (key: string) => {
-          if (key === 'rbacService') return rbacService
-          if (key === 'em') {
-            return {
-              fork: () => ({
-                findOne: async () => null,
-              }),
-            }
-          }
-          return null
-        },
-      },
-    }))
-
-    const response = await POST(
-      makeRequest({
-        resourceKind: 'sales.quote',
-        resourceId: '40000000-0000-4000-8000-000000000001',
-      }),
-    )
-
-    expect(response.status).toBe(200)
-    const body = await response.json()
-    expect(body.allowForceUnlock).toBe(false)
-    expect(rbacService.userHasAllFeatures).toHaveBeenCalledWith(
-      '10000000-0000-4000-8000-000000000001',
-      ['record_locks.force_release'],
-      {
-        tenantId: '20000000-0000-4000-8000-000000000001',
-        organizationId: '30000000-0000-4000-8000-000000000001',
-      },
-    )
-  })
-})

package/src/modules/record_locks/api/__tests__/release.route.test.ts

@@ -1,135 +0,0 @@
-import { POST } from '@open-mercato/enterprise/modules/record_locks/api/release/route'
-import { resolveRecordLocksApiContext } from '@open-mercato/enterprise/modules/record_locks/api/utils'
-
-jest.mock('@open-mercato/enterprise/modules/record_locks/api/utils', () => ({
-  resolveRecordLocksApiContext: jest.fn(),
-}))
-
-function makeRequest(body: unknown) {
-  return new Request('http://localhost/api/record_locks/release', {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify(body),
-  })
-}
-
-describe('record_locks release route', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  test('returns 400 when reason=conflict_resolved but conflict payload is missing', async () => {
-    ;(resolveRecordLocksApiContext as jest.Mock).mockResolvedValue({
-      auth: {
-        sub: '10000000-0000-4000-8000-000000000001',
-        tenantId: '20000000-0000-4000-8000-000000000001',
-      },
-      organizationId: '30000000-0000-4000-8000-000000000001',
-      recordLockService: { release: jest.fn() },
-    })
-
-    const response = await POST(
-      makeRequest({
-        resourceKind: 'sales.quote',
-        resourceId: '40000000-0000-4000-8000-000000000001',
-        token: '50000000-0000-4000-8000-000000000001',
-        reason: 'conflict_resolved',
-      }),
-    )
-
-    expect(response.status).toBe(400)
-  })
-
-  test('passes explicit conflict resolution payload to service and returns result', async () => {
-    const release = jest.fn().mockResolvedValue({
-      ok: true,
-      released: true,
-      conflictResolved: true,
-    })
-
-    ;(resolveRecordLocksApiContext as jest.Mock).mockResolvedValue({
-      auth: {
-        sub: '10000000-0000-4000-8000-000000000001',
-        tenantId: '20000000-0000-4000-8000-000000000001',
-      },
-      organizationId: '30000000-0000-4000-8000-000000000001',
-      recordLockService: { release },
-    })
-
-    const response = await POST(
-      makeRequest({
-        resourceKind: 'sales.quote',
-        resourceId: '40000000-0000-4000-8000-000000000001',
-        token: '50000000-0000-4000-8000-000000000001',
-        reason: 'conflict_resolved',
-        conflictId: '60000000-0000-4000-8000-000000000001',
-        resolution: 'accept_incoming',
-      }),
-    )
-
-    expect(response.status).toBe(200)
-    const body = await response.json()
-    expect(body).toEqual({
-      ok: true,
-      released: true,
-      conflictResolved: true,
-    })
-    expect(release).toHaveBeenCalledWith({
-      token: '50000000-0000-4000-8000-000000000001',
-      resourceKind: 'sales.quote',
-      resourceId: '40000000-0000-4000-8000-000000000001',
-      reason: 'conflict_resolved',
-      conflictId: '60000000-0000-4000-8000-000000000001',
-      resolution: 'accept_incoming',
-      tenantId: '20000000-0000-4000-8000-000000000001',
-      organizationId: '30000000-0000-4000-8000-000000000001',
-      userId: '10000000-0000-4000-8000-000000000001',
-    })
-  })
-
-  test('accepts conflict_resolved payload without token and passes it to service', async () => {
-    const release = jest.fn().mockResolvedValue({
-      ok: true,
-      released: false,
-      conflictResolved: true,
-    })
-
-    ;(resolveRecordLocksApiContext as jest.Mock).mockResolvedValue({
-      auth: {
-        sub: '10000000-0000-4000-8000-000000000001',
-        tenantId: '20000000-0000-4000-8000-000000000001',
-      },
-      organizationId: '30000000-0000-4000-8000-000000000001',
-      recordLockService: { release },
-    })
-
-    const response = await POST(
-      makeRequest({
-        resourceKind: 'sales.quote',
-        resourceId: '40000000-0000-4000-8000-000000000001',
-        reason: 'conflict_resolved',
-        conflictId: '60000000-0000-4000-8000-000000000001',
-        resolution: 'accept_incoming',
-      }),
-    )
-
-    expect(response.status).toBe(200)
-    const body = await response.json()
-    expect(body).toEqual({
-      ok: true,
-      released: false,
-      conflictResolved: true,
-    })
-    expect(release).toHaveBeenCalledWith({
-      token: undefined,
-      resourceKind: 'sales.quote',
-      resourceId: '40000000-0000-4000-8000-000000000001',
-      reason: 'conflict_resolved',
-      conflictId: '60000000-0000-4000-8000-000000000001',
-      resolution: 'accept_incoming',
-      tenantId: '20000000-0000-4000-8000-000000000001',
-      organizationId: '30000000-0000-4000-8000-000000000001',
-      userId: '10000000-0000-4000-8000-000000000001',
-    })
-  })
-})

package/src/modules/record_locks/api/__tests__/settings.route.test.ts

@@ -1,85 +0,0 @@
-import { GET, POST } from '@open-mercato/enterprise/modules/record_locks/api/settings/route'
-import { resolveRecordLocksApiContext } from '@open-mercato/enterprise/modules/record_locks/api/utils'
-
-jest.mock('@open-mercato/enterprise/modules/record_locks/api/utils', () => ({
-  resolveRecordLocksApiContext: jest.fn(),
-}))
-
-function makeRequest(body: unknown) {
-  return new Request('http://localhost/api/record_locks/settings', {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify(body),
-  })
-}
-
-describe('record_locks settings route', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  test('GET returns current settings', async () => {
-    const settings = {
-      enabled: false,
-      strategy: 'optimistic',
-      timeoutSeconds: 300,
-      heartbeatSeconds: 30,
-      enabledResources: [],
-      allowForceUnlock: true,
-      allowIncomingOverride: true,
-      notifyOnConflict: true,
-    }
-
-    ;(resolveRecordLocksApiContext as jest.Mock).mockResolvedValue({
-      recordLockService: {
-        getSettings: jest.fn().mockResolvedValue(settings),
-      },
-    })
-
-    const response = await GET(new Request('http://localhost/api/record_locks/settings'))
-    expect(response.status).toBe(200)
-    const body = await response.json()
-    expect(body).toEqual({ settings })
-  })
-
-  test('POST returns 400 when payload is invalid', async () => {
-    ;(resolveRecordLocksApiContext as jest.Mock).mockResolvedValue({
-      recordLockService: { saveSettings: jest.fn() },
-    })
-
-    const response = await POST(makeRequest({ enabled: 'yes' }))
-    expect(response.status).toBe(400)
-  })
-
-  test('POST saves and returns settings', async () => {
-    const settings = {
-      enabled: true,
-      strategy: 'pessimistic',
-      timeoutSeconds: 600,
-      heartbeatSeconds: 30,
-      enabledResources: ['sales.quote'],
-      allowForceUnlock: true,
-      allowIncomingOverride: true,
-      notifyOnConflict: true,
-    }
-
-    const saveSettings = jest.fn().mockResolvedValue(settings)
-    ;(resolveRecordLocksApiContext as jest.Mock).mockResolvedValue({
-      recordLockService: { saveSettings },
-    })
-
-    const response = await POST(makeRequest(settings))
-    expect(response.status).toBe(200)
-    const body = await response.json()
-    expect(body).toEqual({ settings })
-    expect(saveSettings).toHaveBeenCalledWith(expect.objectContaining({
-      enabled: true,
-      strategy: 'pessimistic',
-      timeoutSeconds: 600,
-      heartbeatSeconds: 30,
-      enabledResources: ['sales.quote'],
-      allowForceUnlock: true,
-      notifyOnConflict: true,
-    }))
-  })
-})