@api-client/core 0.20.10 → 0.21.0

package/tests/client/sdk/FilesSdk.spec.ts

@@ -0,0 +1,716 @@
+import { test } from '@pawel-up/lupa/testing'
+import { SdkNetworkMock } from '../../../src/sdk/SdkNetworkMock.js'
+import { StoreSdk } from '../../../src/sdk/StoreSdkWeb.js'
+import { FolderKind } from '../../../src/models/kinds.js'
+import { AccessPatchInfo, MediaPatchInfo, PatchInfo } from '../../../src/patch/index.js'
+import { DomainFile } from '../../../src/modeling/DomainFile.js'
+
+const baseUri = globalThis.location.protocol + '//' + globalThis.location.host
+
+test.group('list', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk('http://localhost:8080')
+    mocker = new SdkNetworkMock()
+  })
+  test('retrieves files from an organization', async ({ assert, network }) => {
+    const expectedFiles = mocker.gen.files.files(5)
+    await mocker.files.list(network, {
+      response: {
+        body: mocker.gen.wrapList(expectedFiles, { cursor: false }),
+      },
+    })
+
+    const result = await sdk.files.list('org-123')
+
+    assert.isArray(result.data, 'data is array')
+    assert.lengthOf(result.data, 5, 'has five data')
+    assert.isUndefined(result.cursor, 'cursor is undefined')
+    result.data.forEach((file) => {
+      assert.isString(file.key, 'file has key')
+      assert.isString(file.info.name, 'file has name')
+      assert.isString(file.kind, 'file has kind')
+    })
+  })
+
+  test('supports pagination with cursor', async ({ assert, network }) => {
+    const files = mocker.gen.files.files(3)
+    const cursor = 'next-page-cursor'
+    await mocker.files.list(network, {
+      response: {
+        body: mocker.gen.wrapList(files, { cursor }),
+      },
+    })
+
+    const result = await sdk.files.list('org-123', { limit: 3 })
+
+    assert.lengthOf(result.data, 3)
+    assert.equal(result.cursor, cursor, 'cursor is present for pagination')
+  })
+
+  test('throws on 500 error status', async ({ assert, network }) => {
+    await mocker.files.list(network, { response: { status: 500 } })
+    await assert.rejects(async () => await sdk.files.list('org-123'))
+  })
+
+  test('throws on 400 error status', async ({ assert, network }) => {
+    await mocker.files.list(network, { response: { status: 400 } })
+    await assert.rejects(async () => await sdk.files.list('org-123'))
+  })
+})
+
+test.group('create', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  test('creates both meta and media for a file', async ({ assert, network }) => {
+    const expectedMeta = mocker.gen.files.file()
+    await mocker.files.createMeta(network, {
+      response: {
+        body: mocker.gen.wrapResource(expectedMeta),
+        status: 201,
+      },
+    })
+    await mocker.files.createMedia(network)
+
+    const inputMeta = mocker.gen.files.file()
+    const inputContents = { data: 'test content' }
+    const result = await sdk.files.create(inputMeta, inputContents, 'org-123')
+
+    assert.isString(result.key, 'returned file has key')
+    assert.isString(result.info.name, 'returned file has name')
+    assert.equal(result.kind, expectedMeta.kind, 'preserves file kind')
+  })
+
+  test('throws when create meta fails', async ({ assert, network }) => {
+    await mocker.files.createMeta(network, { response: { status: 400 } })
+    const meta = mocker.gen.files.file()
+    await assert.rejects(async () => await sdk.files.create(meta, {}, 'org-123'))
+  })
+})
+
+test.group('createMeta', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  test('creates file metadata', async ({ assert, network }) => {
+    const generatedFile = mocker.gen.files.file()
+    await mocker.files.createMeta(network, {
+      response: {
+        body: mocker.gen.wrapResource(generatedFile),
+        status: 201,
+      },
+    })
+
+    const inputFile = mocker.gen.files.file()
+    const result = await sdk.files.createMeta(inputFile, 'org-123')
+
+    assert.isString(result.key, 'created file has key')
+    assert.isString(result.info.name, 'created file has name')
+    assert.isString(result.kind, 'created file has kind')
+  })
+
+  test('creates file meta with parent option', async ({ assert, network }) => {
+    const generatedFile = mocker.gen.files.file()
+    await mocker.files.createMeta(network, {
+      response: {
+        body: mocker.gen.wrapResource(generatedFile),
+        status: 201,
+      },
+    })
+
+    const inputFile = mocker.gen.files.file()
+    const result = await sdk.files.createMeta(inputFile, 'org-123', { parent: 'parent-id' })
+
+    assert.isString(result.key, 'created file has key')
+  })
+
+  test('throws on server error', async ({ assert, network }) => {
+    await mocker.files.createMeta(network, { response: { status: 500 } })
+    const meta = mocker.gen.files.file()
+    await assert.rejects(async () => await sdk.files.createMeta(meta, 'org-123'))
+  })
+})
+
+test.group('createMedia', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  test('uploads file media content', async ({ network }) => {
+    const handle = await mocker.files.createMedia(network)
+
+    const contents = { foo: 'bar', data: 'test' }
+    await sdk.files.createMedia(contents, 'org-123', 'file-key')
+    // No assertion on return value since createMedia returns void
+    await handle.assert.calledOnce()
+  })
+
+  test('uploads media with custom mime type', async ({ network }) => {
+    const handle = await mocker.files.createMedia(network)
+
+    const contents = 'text content'
+    await sdk.files.createMedia(contents, 'org-123', 'file-key', { mime: 'text/plain' })
+
+    await handle.assert.calledOnce()
+  })
+
+  test('throws on upload failure', async ({ assert, network }) => {
+    await mocker.files.createMedia(network, { response: { status: 500 } })
+    await assert.rejects(async () => await sdk.files.createMedia({}, 'org-123', 'file-key'))
+  })
+})
+
+test.group('createFolder', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  test('creates a folder with specified name', async ({ assert, network }) => {
+    const folderName = 'Test Folder'
+    const generatedFolder = mocker.gen.files.folder({ info: { name: folderName } })
+    await mocker.files.createFolder(network, {
+      response: {
+        body: mocker.gen.wrapResource(generatedFolder),
+        status: 201,
+      },
+    })
+
+    const result = await sdk.files.createFolder(folderName, 'org-123')
+
+    assert.equal(result.kind, FolderKind, 'created item is a folder')
+    assert.isString(result.key, 'folder has key')
+    assert.equal(result.info.name, folderName, 'folder has correct name')
+  })
+
+  test('creates folder with parent', async ({ assert, network }) => {
+    const generatedFolder = mocker.gen.files.folder()
+    await mocker.files.createFolder(network, {
+      response: {
+        body: mocker.gen.wrapResource(generatedFolder),
+        status: 201,
+      },
+    })
+
+    const result = await sdk.files.createFolder('Subfolder', 'org-123', { parent: 'parent-id' })
+    assert.equal(result.kind, FolderKind)
+  })
+})
+
+test.group('read', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  test('retrieves file metadata by key', async ({ assert, network }) => {
+    const expectedFile = mocker.gen.files.file()
+    await mocker.files.read(network, {
+      response: {
+        body: mocker.gen.wrapResource(expectedFile),
+      },
+    })
+
+    const result = await sdk.files.read('org-123', 'file-123')
+
+    assert.equal(result.key, expectedFile.key, 'returns correct file key')
+    assert.equal(result.kind, expectedFile.kind, 'returns correct file kind')
+    assert.deepEqual(result.info, expectedFile.info, 'returns correct file info')
+  })
+
+  test('throws 404 error when file not found', async ({ assert, network }) => {
+    await mocker.files.read(network, { response: { status: 404 } })
+    await assert.rejects(async () => await sdk.files.read('org-123', 'nonexistent-id'))
+  })
+
+  test('throws 403 error when unauthorized', async ({ assert, network }) => {
+    await mocker.files.read(network, { response: { status: 403 } })
+    await assert.rejects(async () => await sdk.files.read('org-123', 'file-123'))
+  })
+})
+
+test.group('readMedia', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    mocker = new SdkNetworkMock(baseUri)
+  })
+
+  test('retrieves file media content', async ({ assert, network }) => {
+    const mediaContent = { data: 'file content', version: '1.0' }
+    const version = 5
+    await mocker.files.readMedia(network, {
+      response: {
+        body: mocker.gen.wrapResource(mediaContent),
+        headers: {
+          'content-type': 'application/json',
+          'x-version': String(version),
+        },
+      },
+    })
+
+    const result = await sdk.files.readMedia('org-123', 'file-123')
+
+    assert.deepEqual(result.media, mediaContent, 'returns correct media content')
+    assert.equal(result.version, version, 'returns correct version')
+  })
+
+  test('throws when media not found', async ({ assert, network }) => {
+    await mocker.files.readMedia(network, { response: { status: 404 } })
+    await assert.rejects(async () => await sdk.files.readMedia('org-123', 'file-123'))
+  })
+
+  test('parses version header correctly', async ({ assert, network }) => {
+    const version = 42
+    await mocker.files.readMedia(network, {
+      response: {
+        body: mocker.gen.wrapResource({ data: 'test' }),
+        headers: {
+          'content-type': 'application/json',
+          'x-version': String(version),
+        },
+      },
+    })
+
+    const result = await sdk.files.readMedia('org-123', 'file-123')
+    assert.equal(result.version, version, 'version header is parsed correctly')
+  })
+})
+
+test.group('readBulk', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  test('retrieves multiple files in a single call', async ({ assert, network }) => {
+    const expectedFiles = mocker.gen.files.files(3)
+    await mocker.files.readBulk(network, {
+      response: {
+        body: mocker.gen.wrapResource(expectedFiles),
+      },
+    })
+
+    const keys = ['k1', 'k2', 'k3']
+    const result = await sdk.files.readBulk('org-123', keys)
+
+    assert.isArray(result.data, 'data is array')
+    assert.lengthOf(result.data, 3, 'returns all requested files')
+    result.data.forEach((file) => {
+      assert.isString(file!.key, 'each item has key')
+    })
+  })
+
+  test('handles missing files in bulk response', async ({ assert, network }) => {
+    const files = [mocker.gen.files.file(), undefined, mocker.gen.files.file()]
+    await mocker.files.readBulk(network, {
+      response: {
+        body: mocker.gen.wrapList(files),
+      },
+    })
+
+    const result = await sdk.files.readBulk('org-123', ['k1', 'k2', 'k3'])
+    assert.lengthOf(result.data, 3, 'returns array with missing data as undefined')
+  })
+
+  test('throws on server error', async ({ assert, network }) => {
+    await mocker.files.readBulk(network, { response: { status: 500 } })
+    await assert.rejects(async () => await sdk.files.readBulk('org-123', ['k1']))
+  })
+})
+
+test.group('patch', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  test('applies metadata patch to file', async ({ assert, network }) => {
+    const patchedFile = mocker.gen.files.file()
+    await mocker.files.patch(network, {
+      response: {
+        body: mocker.gen.wrapResource(patchedFile),
+      },
+    })
+
+    const patch: PatchInfo = {
+      patch: [],
+      id: 'patch-id',
+      timestamp: Date.now(),
+    }
+    const result = await sdk.files.patch('org-123', 'file-123', patch)
+
+    assert.isString(result.key, 'patched file has key')
+    assert.isString(result.info.name, 'patched file has name')
+  })
+
+  test('requires all patch fields', async ({ assert, network }) => {
+    const patch = {
+      patch: [],
+      id: 'patch-id',
+      timestamp: Date.now(),
+    }
+
+    // This test verifies SDK accepts properly formed patches
+    await mocker.files.patch(network, {
+      response: {
+        body: mocker.gen.wrapResource(mocker.gen.files.file()),
+      },
+    })
+
+    const result = await sdk.files.patch('org-123', 'file-123', patch)
+    assert.isString(result.key)
+  })
+
+  test('throws on patch error', async ({ assert, network }) => {
+    await mocker.files.patch(network, { response: { status: 409 } })
+    const patch = { patch: [], id: 'patch-id', timestamp: Date.now() }
+    await assert.rejects(async () => await sdk.files.patch('org-123', 'file-123', patch))
+  })
+})
+
+test.group('patchMedia', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  test('applies content patch to file media', async ({ assert, network }) => {
+    const newVersion = 10
+    await mocker.files.patchMedia(network, {
+      response: {
+        body: mocker.gen.wrapResource({
+          id: 'patch-id',
+          newVersion,
+          revert: [],
+          patch: [],
+          timestamp: Date.now(),
+          version: 1,
+        }),
+      },
+    })
+
+    const patch: MediaPatchInfo = {
+      patch: [{ op: 'add', path: '/newField', value: 'value' }],
+      id: 'patch-id',
+      timestamp: Date.now(),
+      version: 1,
+    }
+    const result = await sdk.files.patchMedia('org-123', 'file-123', patch)
+
+    assert.equal(result.newVersion, newVersion, 'returns new version number')
+  })
+
+  test('tracks version for conflict detection', async ({ assert, network }) => {
+    const newVersion = 5
+    await mocker.files.patchMedia(network, {
+      response: {
+        body: mocker.gen.wrapResource({
+          id: 'patch-id',
+          newVersion,
+          revert: [],
+          patch: [],
+          timestamp: Date.now(),
+          version: 4,
+        }),
+      },
+    })
+
+    const patch: MediaPatchInfo = {
+      patch: [],
+      id: 'patch-id',
+      timestamp: Date.now(),
+      version: 4,
+    }
+    const result = await sdk.files.patchMedia('org-123', 'file-123', patch)
+    assert.equal(result.newVersion, newVersion, 'increments version')
+  })
+
+  test('throws on version conflict', async ({ assert, network }) => {
+    await mocker.files.patchMedia(network, { response: { status: 409 } })
+    const patch = {
+      patch: [],
+      id: 'patch-id',
+      timestamp: Date.now(),
+      version: 1,
+    }
+    await assert.rejects(async () => await sdk.files.patchMedia('org-123', 'file-123', patch))
+  })
+})
+
+test.group('delete', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  test('deletes a single file', async ({ network }) => {
+    const handle = await mocker.files.delete(network)
+    await sdk.files.delete('org-123', 'file-123')
+    // Successful delete returns no content (204)
+    await handle.assert.calledOnce()
+  })
+
+  test('throws when file not found', async ({ assert, network }) => {
+    await mocker.files.delete(network, { response: { status: 404 } })
+    await assert.rejects(async () => await sdk.files.delete('org-123', 'nonexistent-id'))
+  })
+
+  test('throws when unauthorized', async ({ assert, network }) => {
+    await mocker.files.delete(network, { response: { status: 403 } })
+    await assert.rejects(async () => await sdk.files.delete('org-123', 'file-123'))
+  })
+})
+
+test.group('deleteBulk', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  test('deletes multiple files in single call', async ({ network }) => {
+    const handle = await mocker.files.deleteBulk(network)
+    const fileIds = ['file-1', 'file-2', 'file-3']
+    await sdk.files.deleteBulk('org-123', fileIds)
+    // Successful bulk delete returns no content (204)
+    handle.assert.calledOnce()
+  })
+
+  test('deletes multiple files regardless of individual failures', async ({ network }) => {
+    const handle = await mocker.files.deleteBulk(network)
+    const fileIds = ['file-1', 'file-2', 'file-3']
+    // SDK may attempt deletion even if some fail
+    await sdk.files.deleteBulk('org-123', fileIds)
+    await handle.assert.calledOnce()
+  })
+
+  test('throws on server error', async ({ assert, network }) => {
+    await mocker.files.deleteBulk(network, { response: { status: 500 } })
+    await assert.rejects(async () => await sdk.files.deleteBulk('org-123', ['file-1', 'file-2']))
+  })
+})
+
+test.group('patchUsers', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  test('updates file access control list', async ({ assert, network }) => {
+    const updatedFile = mocker.gen.files.file()
+    await mocker.files.patchUsers(network, {
+      response: {
+        body: mocker.gen.wrapResource(updatedFile),
+      },
+    })
+
+    const patch: AccessPatchInfo = {
+      patch: [
+        {
+          op: 'add',
+          type: 'user',
+          value: 'reader',
+          id: 'user-456',
+        },
+      ],
+      id: 'access-patch-id',
+    }
+    const result = await sdk.files.patchUsers('org-123', 'file-123', patch)
+
+    assert.isString(result.key, 'returns updated file with key')
+    assert.isString(result.info.name, 'returns file metadata')
+  })
+
+  test('throws on invalid access patch', async ({ assert, network }) => {
+    await mocker.files.patchUsers(network, { response: { status: 400 } })
+    const patch: AccessPatchInfo = { patch: [], id: 'patch-id' }
+    await assert.rejects(async () => await sdk.files.patchUsers('org-123', 'file-123', patch))
+  })
+})
+
+test.group('addUser', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  test('grants file access to a user', async ({ assert, network }) => {
+    const updatedFile = mocker.gen.files.file()
+    await mocker.files.addUser(network, {
+      response: {
+        body: mocker.gen.wrapResource(updatedFile),
+      },
+    })
+
+    const result = await sdk.files.addUser('org-123', 'file-123', 'user-456', 'reader')
+
+    assert.isString(result.key, 'returns updated file')
+    assert.isString(result.info.name, 'file has metadata')
+  })
+
+  test('grants file access with expiration', async ({ assert, network }) => {
+    const updatedFile = mocker.gen.files.file()
+    await mocker.files.addUser(network, {
+      response: {
+        body: mocker.gen.wrapResource(updatedFile),
+      },
+    })
+
+    const expirationTime = Date.now() + 7 * 24 * 60 * 60 * 1000 // 7 days
+    const result = await sdk.files.addUser('org-123', 'file-123', 'user-456', 'commenter', expirationTime)
+    assert.isString(result.key)
+  })
+})
+
+test.group('removeUser', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  test('revokes file access from a user', async ({ assert, network }) => {
+    const updatedFile = mocker.gen.files.file()
+    await mocker.files.removeUser(network, {
+      response: {
+        body: mocker.gen.wrapResource(updatedFile),
+      },
+    })
+
+    const result = await sdk.files.removeUser('org-123', 'file-123', 'user-456')
+
+    assert.isString(result.key, 'returns updated file')
+    assert.isString(result.info.name, 'file has metadata')
+  })
+})
+
+test.group('listUsers', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  test('retrieves list of users with file access', async ({ assert, network }) => {
+    const users = mocker.gen.users.users(3)
+    await mocker.files.listUsers(network, {
+      response: {
+        body: mocker.gen.wrapList(users, { cursor: false }),
+      },
+    })
+
+    const result = await sdk.files.listUsers('org-123', 'file-123')
+
+    assert.isArray(result.data, 'data is array')
+    assert.lengthOf(result.data, 3, 'has three users')
+    result.data.forEach((user) => {
+      assert.isString(user.key, 'user has key')
+    })
+  })
+
+  test('supports pagination in user list', async ({ assert, network }) => {
+    const users = mocker.gen.users.users(2)
+    const cursor = 'next-page'
+    await mocker.files.listUsers(network, {
+      response: {
+        body: mocker.gen.wrapList(users, { cursor }),
+      },
+    })
+
+    const result = await sdk.files.listUsers('org-123', 'file-123')
+    assert.equal(result.cursor, cursor, 'includes pagination cursor')
+  })
+
+  test('throws on access denied', async ({ assert, network }) => {
+    await mocker.files.listUsers(network, { response: { status: 403 } })
+    await assert.rejects(async () => await sdk.files.listUsers('org-123', 'file-123'))
+  })
+})
+
+test.group('breadcrumbs', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  test('retrieves breadcrumb path to a file', async ({ assert, network }) => {
+    const breadcrumbs = mocker.gen.files.fileBreadcrumbs(4)
+    await mocker.files.breadcrumbs(network, {
+      response: {
+        body: mocker.gen.wrapList(breadcrumbs, { cursor: false }),
+      },
+    })
+
+    const result = await sdk.files.breadcrumbs('org-123', 'file-123')
+
+    assert.isArray(result.data, 'data is array')
+    assert.lengthOf(result.data, 4, 'has four breadcrumb data')
+    result.data.forEach((crumb, index) => {
+      assert.isString(crumb.key, `crumb ${index} has key`)
+      assert.isString(crumb.name, `crumb ${index} has name`)
+      assert.isString(crumb.kind, `crumb ${index} has kind`)
+    })
+  })
+
+  test('returns breadcrumbs in order from root to file', async ({ assert, network }) => {
+    const breadcrumbs = [
+      { key: 'org-key', name: 'Organization', kind: 'Organization' },
+      { key: 'folder-1', name: 'Folder 1', kind: FolderKind },
+      { key: 'folder-2', name: 'Folder 2', kind: FolderKind },
+      { key: 'file-123', name: 'File Name', kind: DomainFile },
+    ]
+    await mocker.files.breadcrumbs(network, {
+      response: {
+        body: mocker.gen.wrapList(breadcrumbs, { cursor: false }),
+      },
+    })
+
+    const result = await sdk.files.breadcrumbs('org-123', 'file-123')
+
+    assert.equal(result.data[0].name, 'Organization', 'first breadcrumb is organization')
+    assert.equal(result.data[result.data.length - 1].name, 'File Name', 'last breadcrumb is file')
+  })
+
+  test('throws when file not found', async ({ assert, network }) => {
+    await mocker.files.breadcrumbs(network, { response: { status: 404 } })
+    await assert.rejects(async () => await sdk.files.breadcrumbs('org-123', 'nonexistent-id'))
+  })
+})