@open-mercato/core 0.4.5-develop-2e9903a57a → 0.4.5-develop-eeccf7adf4

package/src/modules/api_keys/api/__tests__/keys.route.test.ts

@@ -1,244 +0,0 @@
-/** @jest-environment node */
-
-import { features } from '../../acl'
-
-const secretFixture = { secret: 'omk_test.secret', prefix: 'omk_testpref' }
-
-type QueueEntry = { entity?: unknown }
-type OrmEntityInput = { data: Record<string, unknown>; [key: string]: unknown }
-
-interface MockEntityManager {
-  findOne: jest.Mock<Promise<unknown>, [unknown, Record<string, unknown>?]>
-  find: jest.Mock<Promise<unknown[]>, [unknown, Record<string, unknown>?]>
-  fork: jest.Mock<MockEntityManager, []>
-}
-
-interface MockDataEngine {
-  __queue: QueueEntry[]
-  createOrmEntity: jest.Mock<Promise<Record<string, unknown>>, [OrmEntityInput]>
-  emitOrmEntityEvent: jest.Mock<Promise<void>, [QueueEntry | undefined]>
-  markOrmEntityChange: jest.Mock<void, [QueueEntry | undefined]>
-  flushOrmEntityChanges: jest.Mock<Promise<void>, []>
-}
-
-interface MockRbacService {
-  invalidateUserCache: jest.Mock<Promise<void>, [string]>
-  loadAcl: jest.Mock<Promise<{ isSuperAdmin: boolean } | null>, [string, { tenantId: string | null; organizationId: string | null }]>
-}
-
-interface MockContainer {
-  resolve: jest.Mock<unknown, [string]>
-}
-
-const queue: QueueEntry[] = []
-
-const mockGetAuthFromCookies = jest.fn()
-const mockGetAuthFromRequest = jest.fn()
-const mockResolveScope = jest.fn()
-const mockEm: MockEntityManager = {
-  findOne: jest.fn<Promise<unknown>, [unknown, Record<string, unknown>?]>(),
-  find: jest.fn<Promise<unknown[]>, [unknown, Record<string, unknown>?]>(),
-  fork: jest.fn<MockEntityManager, []>(),
-}
-const mockDataEngine: MockDataEngine = {
-  __queue: queue,
-  createOrmEntity: jest.fn<Promise<Record<string, unknown>>, [OrmEntityInput]>(),
-  emitOrmEntityEvent: jest.fn<Promise<void>, [QueueEntry | undefined]>(),
-  markOrmEntityChange: jest.fn<void, [QueueEntry | undefined]>(),
-  flushOrmEntityChanges: jest.fn<Promise<void>, []>(),
-}
-const mockRbac: MockRbacService = {
-  invalidateUserCache: jest.fn<Promise<void>, [string]>(),
-  loadAcl: jest.fn<Promise<{ isSuperAdmin: boolean } | null>, [string, { tenantId: string | null; organizationId: string | null }]>(),
-}
-const mockContainer: MockContainer = {
-  resolve: jest.fn((token: string) => {
-    if (token === 'em') return mockEm
-    if (token === 'dataEngine') return mockDataEngine
-    if (token === 'rbacService') return mockRbac
-    return undefined
-  }),
-}
-const mockHashApiKey = jest.fn<Promise<string>, [string]>((secret) => Promise.resolve(`hashed:${secret}`))
-
-jest.mock('@open-mercato/shared/lib/di/container', () => ({
-  createRequestContainer: jest.fn(async () => mockContainer),
-}))
-
-jest.mock('@open-mercato/shared/lib/auth/server', () => ({
-  getAuthFromCookies: jest.fn(() => mockGetAuthFromCookies()),
-  getAuthFromRequest: jest.fn((request: Request) => mockGetAuthFromRequest(request)),
-}))
-
-jest.mock('@open-mercato/core/modules/directory/utils/organizationScope', () => ({
-  resolveOrganizationScopeForRequest: jest.fn((args) => mockResolveScope(args)),
-}))
-
-jest.mock('@open-mercato/shared/lib/i18n/server', () => ({
-  resolveTranslations: jest.fn(async () => ({
-    translate: (_key: string, fallback: string) => fallback,
-  })),
-}))
-
-jest.mock('../../services/apiKeyService', () => {
-  const actual = jest.requireActual('../../services/apiKeyService')
-  return {
-    ...actual,
-    generateApiKeySecret: jest.fn(() => secretFixture),
-    hashApiKey: jest.fn((secret: string) => mockHashApiKey(secret)),
-  }
-})
-
-type RouteModule = typeof import('../keys/route')
-let routeMetadata: RouteModule['metadata']
-let postHandler: RouteModule['POST']
-
-beforeAll(async () => {
-  const routeModule = await import('../keys/route')
-  routeMetadata = routeModule.metadata
-  postHandler = routeModule.POST
-})
-
-describe('API Keys route', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-    mockDataEngine.__queue.length = 0
-    mockEm.fork.mockReturnValue(mockEm)
-    mockGetAuthFromCookies.mockResolvedValue({
-      sub: 'user-1',
-      tenantId: '123e4567-e89b-12d3-a456-426614174000',
-      orgId: null,
-    })
-    mockGetAuthFromRequest.mockResolvedValue({
-      sub: 'user-1',
-      tenantId: '123e4567-e89b-12d3-a456-426614174000',
-      orgId: null,
-    })
-    mockResolveScope.mockResolvedValue({
-      selectedId: 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
-      filterIds: ['aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'],
-      allowedIds: ['aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'],
-    })
-    mockEm.findOne.mockResolvedValue(null)
-    mockEm.find.mockImplementation(async (_entity: unknown, criteria: Record<string, unknown> = {}) => {
-      const nameValue = typeof criteria.name === 'string' ? criteria.name : null
-      if (nameValue && nameValue.toLowerCase() === 'manager') {
-        return [
-          {
-            id: 'role-123',
-            name: 'Manager',
-            tenantId: '123e4567-e89b-12d3-a456-426614174000',
-          },
-        ]
-      }
-      if (criteria && typeof criteria === 'object' && 'id' in criteria) {
-        const idCandidate = (criteria as { id?: unknown }).id
-        if (idCandidate && typeof idCandidate === 'object' && '$in' in idCandidate) {
-          const ids = (idCandidate as { $in?: unknown }).$in
-          if (Array.isArray(ids)) {
-            return ids.map((id) => ({
-              id: String(id),
-              name: id === 'role-123' ? 'Manager' : null,
-              tenantId: '123e4567-e89b-12d3-a456-426614174000',
-            }))
-          }
-        }
-      }
-      return []
-    })
-    mockDataEngine.createOrmEntity.mockImplementation(async ({ data }: OrmEntityInput) => ({
-      id: 'key-1',
-      ...data,
-    }))
-    mockDataEngine.emitOrmEntityEvent.mockResolvedValue(undefined)
-    mockDataEngine.markOrmEntityChange.mockImplementation((entry: QueueEntry | undefined) => {
-      if (!entry?.entity) return
-      mockDataEngine.__queue.push(entry)
-    })
-    mockDataEngine.flushOrmEntityChanges.mockImplementation(async () => {
-      while (mockDataEngine.__queue.length > 0) {
-        const next = mockDataEngine.__queue.shift()
-        await mockDataEngine.emitOrmEntityEvent(next)
-      }
-    })
-    mockRbac.invalidateUserCache.mockResolvedValue(undefined)
-    mockRbac.loadAcl.mockResolvedValue({ isSuperAdmin: false })
-    mockHashApiKey.mockClear()
-  })
-
-  it('exports the expected ACL features', () => {
-    const featureIds = features.map((entry) => entry.id)
-    expect(featureIds).toEqual(expect.arrayContaining(['api_keys.view', 'api_keys.create', 'api_keys.delete']))
-  })
-
-  it('declares authorization metadata for GET/POST/DELETE', () => {
-    expect(routeMetadata.GET?.requireAuth).toBe(true)
-    expect(routeMetadata.GET?.requireFeatures).toEqual(['api_keys.view'])
-    expect(routeMetadata.POST?.requireAuth).toBe(true)
-    expect(routeMetadata.POST?.requireFeatures).toEqual(['api_keys.create'])
-    expect(routeMetadata.DELETE?.requireAuth).toBe(true)
-    expect(routeMetadata.DELETE?.requireFeatures).toEqual(['api_keys.delete'])
-  })
-
-  it('creates API keys with organization scope, hashed secret, and role mapping', async () => {
-    const body = {
-      name: 'Integration key',
-      description: 'Machine access',
-      roles: ['manager'],
-    }
-    const res = await postHandler(
-      new Request('http://localhost/api/api_keys/keys', {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify(body),
-      }),
-    )
-    expect(res.status).toBe(201)
-    const payload = await res.json()
-    expect(payload).toMatchObject({
-      id: 'key-1',
-      name: 'Integration key',
-      keyPrefix: secretFixture.prefix,
-      secret: secretFixture.secret,
-      organizationId: 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
-      tenantId: '123e4567-e89b-12d3-a456-426614174000',
-    })
-    expect(payload.roles).toEqual([{ id: 'role-123', name: 'Manager' }])
-    expect(mockDataEngine.createOrmEntity).toHaveBeenCalledTimes(1)
-    const createArgs = mockDataEngine.createOrmEntity.mock.calls[0][0]
-    expect(createArgs.data).toMatchObject({
-      name: 'Integration key',
-      description: 'Machine access',
-      organizationId: 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
-      tenantId: '123e4567-e89b-12d3-a456-426614174000',
-      createdBy: 'user-1',
-      rolesJson: ['role-123'],
-      keyPrefix: secretFixture.prefix,
-      keyHash: `hashed:${secretFixture.secret}`,
-    })
-    expect(mockHashApiKey).toHaveBeenCalledWith(secretFixture.secret)
-    expect(mockRbac.invalidateUserCache).toHaveBeenCalledWith('api_key:key-1')
-  })
-
-  it('rejects creation when organization is outside the allowed scope', async () => {
-    mockResolveScope.mockResolvedValueOnce({
-      selectedId: null,
-      filterIds: ['aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'],
-      allowedIds: ['aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'],
-    })
-    const res = await postHandler(
-      new Request('http://localhost/api/api_keys/keys', {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({
-          name: 'Forbidden key',
-          organizationId: 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
-        }),
-      }),
-    )
-    expect(res.status).toBe(403)
-    const payload = await res.json()
-    expect(payload.error).toBe('Organization out of scope')
-    expect(mockDataEngine.createOrmEntity).not.toHaveBeenCalled()
-  })
-})

package/src/modules/attachments/api/__tests__/attachments.api.test.ts

@@ -1,240 +0,0 @@
-/** @jest-environment node */
-import { GET as list, POST as upload } from '@open-mercato/core/modules/attachments/api/route'
-
-const partitions = [
-  { id: 'p-private', code: 'privateAttachments', title: 'Private', isPublic: false, storageDriver: 'local', requiresOcr: true },
-  { id: 'p-products', code: 'productsMedia', title: 'Products', isPublic: true, storageDriver: 'local', requiresOcr: false },
-]
-
-const mockEm = {
-  findOne: jest.fn(async (entity: any, where: any) => {
-    if (entity?.name === 'AttachmentPartition') {
-      return partitions.find((p) => p.code === where?.code) ?? null
-    }
-    if (entity?.name === 'CustomFieldDef') {
-      return { configJson: { maxAttachmentSizeMb: 0.001, acceptExtensions: ['pdf', 'docx'] } }
-    }
-    return null
-  }),
-  create: jest.fn((_cls: any, data: any) => ({ ...data })),
-  persistAndFlush: jest.fn(async () => {}),
-  getRepository: jest.fn(() => ({
-    findAll: jest.fn(async () => partitions),
-    create: jest.fn((data: any) => data),
-  })),
-  persist: jest.fn(),
-  flush: jest.fn(),
-  find: jest.fn(),
-}
-
-const mockDataEngine = {
-  setCustomFields: jest.fn(async () => {}),
-  markOrmEntityChange: jest.fn(),
-  flushOrmEntityChanges: jest.fn(async () => {}),
-}
-
-jest.mock('@open-mercato/shared/lib/di/container', () => ({
-  createRequestContainer: async () => ({
-    resolve: (k: string) => {
-      if (k === 'em') return mockEm
-      if (k === 'dataEngine') return mockDataEngine
-      return null
-    },
-  }),
-}))
-
-jest.mock('@open-mercato/shared/lib/auth/server', () => ({ getAuthFromRequest: () => ({ orgId: 'org', tenantId: 't1', roles: ['admin'] }) }))
-
-// Avoid touching disk
-import { promises as fsp } from 'fs'
-jest.spyOn(fsp, 'mkdir').mockResolvedValue(undefined as any)
-jest.spyOn(fsp, 'writeFile').mockResolvedValue(undefined as any)
-
-jest.mock('@open-mercato/core/modules/attachments/lib/textExtraction', () => ({
-  extractAttachmentContent: jest.fn(),
-}))
-const mockExtractAttachmentContent = jest.requireMock('@open-mercato/core/modules/attachments/lib/textExtraction')
-  .extractAttachmentContent as jest.Mock
-
-// Avoid loading MikroORM decorators in tests
-jest.mock('@open-mercato/core/modules/attachments/data/entities', () => ({
-  Attachment: class Attachment {},
-  AttachmentPartition: class AttachmentPartition {},
-}))
-
-function fdWith(file: File, extra: Record<string, string> = {}) {
-  const fd = new FormData()
-  fd.set('entityId', 'example:todo')
-  fd.set('recordId', 'r1')
-  fd.set('fieldKey', 'attachments')
-  for (const [k, v] of Object.entries(extra)) fd.set(k, v)
-  fd.set('file', file)
-  return fd
-}
-
-describe('attachments API', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-    mockEm.find.mockReset()
-    mockEm.find.mockResolvedValue([])
-    mockExtractAttachmentContent.mockReset()
-    delete process.env.OPENMERCATO_DEFAULT_ATTACHMENT_OCR_ENABLED
-  })
-
-  it('rejects disallowed extension', async () => {
-    const file = new File([new Uint8Array([1,2,3])], 'img.png', { type: 'image/png' })
-    const req = new Request('http://x/api/attachments', { method: 'POST', body: fdWith(file) as any })
-    const res = await upload(req)
-    expect(res.status).toBe(400)
-    const j = await res.json()
-    expect(j.error).toMatch(/not allowed/i)
-  })
-
-  it('accepts allowed small pdf', async () => {
-    const file = new File([new Uint8Array([1,2,3])], 'doc.pdf', { type: 'application/pdf' })
-    const req = new Request('http://x/api/attachments', {
-      method: 'POST',
-      body: fdWith(file, { customFields: JSON.stringify({ altText: 'Product spec' }) }) as any,
-    })
-    const res = await upload(req)
-    expect(res.status).toBe(200)
-    const j = await res.json()
-    expect(j?.ok).toBe(true)
-    expect(j?.item?.customFields).toEqual({ altText: 'Product spec' })
-    const payload = mockEm.create.mock.calls[mockEm.create.mock.calls.length - 1]?.[1]
-    expect(payload?.storageMetadata?.assignments).toEqual([{ type: 'example:todo', id: 'r1' }])
-    expect(mockDataEngine.setCustomFields).toHaveBeenCalledWith(
-      expect.objectContaining({
-        entityId: expect.any(String),
-        recordId: expect.any(String),
-        values: { altText: 'Product spec' },
-      }),
-    )
-  })
-
-  it('rejects files that exceed configured size limit', async () => {
-    const oversized = new Uint8Array(2048)
-    const file = new File([oversized], 'doc.pdf', { type: 'application/pdf' })
-    const req = new Request('http://x/api/attachments', { method: 'POST', body: fdWith(file) as any })
-    const res = await upload(req)
-    expect(res.status).toBe(400)
-    const payload = await res.json()
-    expect(payload.error).toMatch(/exceeds/i)
-  })
-
-  it('extracts content when partition requires OCR', async () => {
-    mockExtractAttachmentContent.mockResolvedValue('extracted text')
-    const file = new File(
-      [new Uint8Array([1, 2, 3])],
-      'doc.docx',
-      { type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' },
-    )
-    const req = new Request('http://x/api/attachments', { method: 'POST', body: fdWith(file) as any })
-    const res = await upload(req)
-    expect(res.status).toBe(200)
-    expect(mockExtractAttachmentContent).toHaveBeenCalled()
-    const payload = mockEm.create.mock.calls.find((call) => call[0].name === 'Attachment')?.[1]
-    expect(payload?.content).toBe('extracted text')
-  })
-
-  it('skips OCR when partition disables it', async () => {
-    const disabledPartition = { ...partitions[0], requiresOcr: false }
-    mockEm.findOne.mockImplementation(async (entity: any, where: any) => {
-      if (entity?.name === 'AttachmentPartition') return disabledPartition
-      if (entity?.name === 'CustomFieldDef') {
-        return { configJson: { maxAttachmentSizeMb: 0.001, acceptExtensions: ['pdf'] } }
-      }
-      return null
-    })
-    const file = new File([new Uint8Array([1, 2, 3])], 'doc.pdf', { type: 'application/pdf' })
-    const req = new Request('http://x/api/attachments', { method: 'POST', body: fdWith(file) as any })
-    const res = await upload(req)
-    expect(res.status).toBe(200)
-    expect(mockExtractAttachmentContent).not.toHaveBeenCalled()
-    const payload = mockEm.create.mock.calls.find((call) => call[0].name === 'Attachment')?.[1]
-    expect(payload?.content ?? null).toBeNull()
-  })
-
-  it('uses env default when partition flag is undefined', async () => {
-    delete process.env.OPENMERCATO_DEFAULT_ATTACHMENT_OCR_ENABLED
-    mockExtractAttachmentContent.mockResolvedValue('default text')
-    const partitionWithoutFlag = { ...partitions[0] }
-    delete (partitionWithoutFlag as any).requiresOcr
-    mockEm.findOne.mockImplementation(async (entity: any, where: any) => {
-      if (entity?.name === 'AttachmentPartition') return partitionWithoutFlag
-      if (entity?.name === 'CustomFieldDef') {
-        return { configJson: { maxAttachmentSizeMb: 0.001, acceptExtensions: ['pdf', 'docx'] } }
-      }
-      return null
-    })
-    const file = new File(
-      [new Uint8Array([1, 2, 3])],
-      'doc.docx',
-      { type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' },
-    )
-    const req = new Request('http://x/api/attachments', { method: 'POST', body: fdWith(file) as any })
-    const res = await upload(req)
-    expect(res.status).toBe(200)
-    expect(mockExtractAttachmentContent).toHaveBeenCalled()
-  })
-
-  it('applies normalized tags and assignments from form payload', async () => {
-    const file = new File([new Uint8Array([1, 2, 3])], 'doc.pdf', { type: 'application/pdf' })
-    const fd = fdWith(file)
-    fd.set('tags', '["primary","primary ",""]')
-    fd.set(
-      'assignments',
-      JSON.stringify([
-        { type: 'catalog.products', id: 'prod-1', href: '/products/1', label: '' },
-        { type: 'catalog.products', id: 'prod-1', href: '/products/1', label: ' Spec Sheet ' },
-      ]),
-    )
-    const req = new Request('http://x/api/attachments', { method: 'POST', body: fd as any })
-    const res = await upload(req)
-    expect(res.status).toBe(200)
-    const body = await res.json()
-    expect(body.item.tags).toEqual(['primary'])
-    expect(body.item.assignments).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ type: 'catalog.products', id: 'prod-1', href: '/products/1', label: 'Spec Sheet' }),
-        expect.objectContaining({ type: 'example:todo', id: 'r1' }),
-      ]),
-    )
-  })
-
-  it('lists attachments with sanitized metadata via GET', async () => {
-    mockEm.find.mockResolvedValue([
-      {
-        id: 'att-1',
-        entityId: 'example:todo',
-        recordId: 'r1',
-        organizationId: 'org',
-        tenantId: 't1',
-        fileName: ' doc.pdf ',
-        url: 'http://cdn.local/doc.pdf',
-        fileSize: 10,
-        createdAt: '2024-01-01T00:00:00.000Z',
-        partitionCode: 'privateAttachments',
-        storageMetadata: { tags: ['primary', 'primary'], assignments: [{ type: 'catalog.products', id: 'prod-1' }] },
-      },
-    ])
-    const req = new Request('http://x/api/attachments?entityId=example:todo&recordId=r1')
-    const res = await list(req)
-    expect(res.status).toBe(200)
-    const payload = await res.json()
-    expect(payload.items).toHaveLength(1)
-    expect(payload.items[0]).toEqual(
-      expect.objectContaining({
-        id: 'att-1',
-        tags: ['primary'],
-        assignments: [{ type: 'catalog.products', id: 'prod-1' }],
-        thumbnailUrl: expect.stringContaining('att-1'),
-      }),
-    )
-    expect(mockEm.find).toHaveBeenCalledWith(
-      expect.any(Function),
-      expect.objectContaining({ entityId: 'example:todo', recordId: 'r1' }),
-      expect.any(Object),
-    )
-  })
-})

package/src/modules/attachments/components/__tests__/AttachmentContentPreview.test.tsx

@@ -1,45 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-jest.mock('react-markdown', () => ({
-  __esModule: true,
-  default: (props: any) => <div data-testid="markdown-preview">{props.children}</div>,
-}))
-
-jest.mock('remark-gfm', () => ({
-  __esModule: true,
-  default: 'remark-gfm',
-}))
-
-import { render, screen, fireEvent } from '@testing-library/react'
-import { AttachmentContentPreview } from '../AttachmentContentPreview'
-describe('AttachmentContentPreview', () => {
-  it('shows placeholder when content is missing', () => {
-    render(<AttachmentContentPreview content={null} />)
-    expect(screen.getByText(/no text extracted/i)).toBeInTheDocument()
-  })
-
-  it('renders inline content when short', () => {
-    render(<AttachmentContentPreview content="hello world" />)
-    expect(screen.getByText('hello world')).toBeInTheDocument()
-  })
-
-  it('truncates long content and can expand', () => {
-    const longText = 'lorem ipsum '.repeat(80)
-    render(<AttachmentContentPreview content={longText} />)
-    const preview = screen.getByTestId('attachment-content-preview')
-    expect(preview.textContent).toContain('lorem ipsum')
-    expect(preview.textContent?.length).toBeLessThan(longText.length)
-    const toggle = screen.getByRole('button', { name: /show more/i })
-    fireEvent.click(toggle)
-    expect(preview.textContent).toContain(longText.trim())
-  })
-
-  it('renders markdown preview when tab is selected', () => {
-    const { container } = render(<AttachmentContentPreview content="**bold** text" />)
-    const previewTab = screen.getByRole('tab', { name: /preview/i })
-    fireEvent.click(previewTab)
-    expect(previewTab).toHaveAttribute('aria-selected', 'true')
-    expect(container.querySelector('[data-testid="markdown-preview"]')?.textContent).toContain('bold')
-  })
-})

package/src/modules/attachments/data/__tests__/entities-ocr.test.ts

@@ -1,15 +0,0 @@
-import { Attachment, AttachmentPartition } from '../entities'
-
-describe('attachments entities', () => {
-  it('exposes a nullable content field on Attachment', () => {
-    const att = new Attachment() as any
-    expect('content' in att).toBe(true)
-    expect(att.content).toBeNull()
-  })
-
-  it('exposes requiresOcr flag on AttachmentPartition with boolean default', () => {
-    const partition = new AttachmentPartition() as any
-    expect('requiresOcr' in partition).toBe(true)
-    expect(typeof partition.requiresOcr).toBe('boolean')
-  })
-})

package/src/modules/attachments/lib/__tests__/ocr-config.test.ts

@@ -1,27 +0,0 @@
-describe('attachments OCR config default', () => {
-  const ENV_KEY = 'OPENMERCATO_DEFAULT_ATTACHMENT_OCR_ENABLED'
-
-  afterEach(() => {
-    delete process.env[ENV_KEY]
-    jest.resetModules()
-  })
-
-  it('defaults to true when env is missing', async () => {
-    const { resolveDefaultAttachmentOcrEnabled } = await import('../ocrConfig')
-    expect(resolveDefaultAttachmentOcrEnabled()).toBe(true)
-  })
-
-  it('reads boolean true when env set to "true"', async () => {
-    process.env[ENV_KEY] = 'true'
-    jest.resetModules()
-    const { resolveDefaultAttachmentOcrEnabled } = await import('../ocrConfig')
-    expect(resolveDefaultAttachmentOcrEnabled()).toBe(true)
-  })
-
-  it('reads boolean false when env set to "false"', async () => {
-    process.env[ENV_KEY] = 'false'
-    jest.resetModules()
-    const { resolveDefaultAttachmentOcrEnabled } = await import('../ocrConfig')
-    expect(resolveDefaultAttachmentOcrEnabled()).toBe(false)
-  })
-})

package/src/modules/attachments/lib/__tests__/textExtraction.test.ts

@@ -1,64 +0,0 @@
-import { promises as fs } from 'fs'
-import { join } from 'path'
-import { tmpdir } from 'os'
-
-jest.mock('child_process', () => ({
-  execFile: jest.fn(),
-}))
-
-const mockExecFile = jest.requireMock('child_process').execFile as jest.Mock
-
-async function writeTempFile(name: string, content: string): Promise<string> {
-  const filePath = join(tmpdir(), name)
-  await fs.writeFile(filePath, content, 'utf8')
-  return filePath
-}
-
-describe('extractAttachmentContent', () => {
-  afterEach(() => {
-    mockExecFile.mockReset()
-  })
-
-  it('runs markitdown for non-image files and returns text', async () => {
-    const filePath = await writeTempFile('sample.txt', 'hello world')
-    mockExecFile.mockImplementation((_bin, _args, cb) => cb(null, 'converted text'))
-    const { extractAttachmentContent } = await import('../textExtraction')
-    const result = await extractAttachmentContent({ filePath, mimeType: 'text/plain' })
-    expect(mockExecFile).toHaveBeenCalled()
-    expect(result).toBe('converted text')
-  })
-
-  it('skips extraction for images', async () => {
-    const filePath = await writeTempFile('image.png', 'binary')
-    const { extractAttachmentContent } = await import('../textExtraction')
-    const result = await extractAttachmentContent({ filePath, mimeType: 'image/png' })
-    expect(mockExecFile).not.toHaveBeenCalled()
-    expect(result).toBeNull()
-  })
-
-  it('returns null when markitdown fails', async () => {
-    const filePath = await writeTempFile('doc.pdf', 'pdf')
-    mockExecFile.mockImplementation((_bin, _args, cb) => cb(new Error('boom')))
-    const { extractAttachmentContent } = await import('../textExtraction')
-    const result = await extractAttachmentContent({ filePath, mimeType: 'application/pdf' })
-    expect(mockExecFile).toHaveBeenCalled()
-    expect(result).toBeNull()
-  })
-
-  it('allows markitdown for supported office/pdf/outlook types', async () => {
-    const filePath = await writeTempFile('slides.pptx', 'content')
-    mockExecFile.mockImplementation((_bin, _args, cb) => cb(null, 'converted text'))
-    const { extractAttachmentContent } = await import('../textExtraction')
-    const result = await extractAttachmentContent({ filePath, mimeType: 'application/vnd.openxmlformats-officedocument.presentationml.presentation' })
-    expect(mockExecFile).toHaveBeenCalled()
-    expect(result).toBe('converted text')
-  })
-
-  it('skips unsupported binary mime types', async () => {
-    const filePath = await writeTempFile('binary.bin', 'bin')
-    const { extractAttachmentContent } = await import('../textExtraction')
-    const result = await extractAttachmentContent({ filePath, mimeType: 'application/x-custom-binary' })
-    expect(mockExecFile).not.toHaveBeenCalled()
-    expect(result).toBeNull()
-  })
-})