@api-client/core 0.20.10 → 0.21.1

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

@@ -0,0 +1,244 @@
+import { test } from '@pawel-up/lupa/testing'
+import { SdkNetworkMock } from '../../../src/sdk/SdkNetworkMock.js'
+import { StoreSdk } from '../../../src/sdk/StoreSdkWeb.js'
+import { GroupKind } from '../../../src/models/kinds.js'
+import type { GroupSchema } from '../../../src/models/store/Group.js'
+import type { ContextListResult } from '../../../src/events/BaseEvents.js'
+import { Exception } from '../../../src/exceptions/exception.js'
+
+const baseUri = globalThis.location.protocol + '//' + globalThis.location.host
+const baseToken = 'test-token'
+const organizationId = 'org-test-123'
+const groupId = 'group-test-456'
+const ownerId = 'user-test-456'
+
+test.group('list()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+  let mockGroup: GroupSchema
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true // Suppress console output for cleaner test output
+    mocker = new SdkNetworkMock(baseUri)
+
+    mockGroup = {
+      key: groupId,
+      name: 'Test Group',
+      kind: GroupKind,
+      oid: organizationId,
+      createdAt: new Date().getTime(),
+      updatedAt: new Date().getTime(),
+      owner: ownerId,
+      users: [ownerId],
+    }
+  })
+
+  test('should list groups for an organization', async ({ network, assert }) => {
+    const listResult: ContextListResult<GroupSchema> = {
+      data: [mockGroup],
+    }
+    const handle = await mocker.groups.list(network, {
+      response: {
+        body: mocker.gen.wrapList([mockGroup], { cursor: false }),
+      },
+    })
+
+    const result = await sdk.groups.list(organizationId, { limit: 10 })
+
+    assert.deepEqual(result, listResult)
+    await handle.assert.calledOnce()
+
+    await handle.assert.calledOnceWith({
+      headers: { Authorization: `Bearer ${baseToken}` },
+    })
+  })
+
+  test('should handle API errors when listing groups', async ({ network, assert }) => {
+    await mocker.groups.list(network, {
+      response: {
+        status: 500,
+        body: JSON.stringify({ message: 'Server Error', status: 500 }),
+      },
+    })
+    const error = await assert.rejects<Exception>(async () => await sdk.groups.list(organizationId))
+    assert.instanceOf(error, Exception)
+    assert.strictEqual(error.status, 500)
+  })
+})
+
+test.group('create()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+  let createdGroup: GroupSchema
+  const groupCreatePayload: Partial<GroupSchema> = { name: 'New Group', oid: organizationId }
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true // Suppress console output for cleaner test output
+    mocker = new SdkNetworkMock(baseUri)
+
+    createdGroup = {
+      key: 'new-group-key',
+      name: 'Test Group',
+      kind: GroupKind,
+      oid: organizationId,
+      createdAt: new Date().getTime(),
+      updatedAt: new Date().getTime(),
+      owner: ownerId,
+      users: [ownerId],
+      ...groupCreatePayload,
+    }
+  })
+
+  test('should create a new group', async ({ network, assert }) => {
+    const handle = await mocker.groups.create(network, {
+      response: {
+        body: mocker.gen.wrapResource(createdGroup),
+      },
+    })
+
+    const result = await sdk.groups.create(organizationId, groupCreatePayload)
+    assert.deepEqual(result, createdGroup)
+
+    await handle.assert.calledOnce()
+    await handle.assert.calledOnceWith({
+      headers: { Authorization: `Bearer ${baseToken}` },
+      body: JSON.stringify(groupCreatePayload),
+    })
+  })
+
+  test('should throw if API returns non-201 status', async ({ network, assert }) => {
+    await mocker.groups.create(network, {
+      response: {
+        status: 400,
+        body: JSON.stringify({ message: 'Error', status: 400 }),
+      },
+    })
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.groups.create(organizationId, groupCreatePayload)
+    )
+    assert.instanceOf(error, Exception)
+    assert.strictEqual(error.status, 400)
+  })
+
+  test('should throw if response body is empty', async ({ network, assert }) => {
+    await mocker.groups.create(network, {
+      response: { status: 201 },
+    })
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.groups.create(organizationId, groupCreatePayload)
+    )
+    assert.instanceOf(error, Exception)
+    assert.strictEqual(error.status, 201)
+  })
+
+  test('should throw if response body is invalid JSON', async ({ network, assert }) => {
+    await mocker.groups.create(network, {
+      response: { status: 201 },
+    })
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.groups.create(organizationId, groupCreatePayload)
+    )
+    assert.instanceOf(error, Exception)
+    assert.strictEqual(error.status, 201)
+  })
+})
+
+test.group('update()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+  let mockGroup: GroupSchema
+  let groupUpdatePayload: GroupSchema
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true // Suppress console output for cleaner test output
+    mocker = new SdkNetworkMock(baseUri)
+
+    mockGroup = {
+      key: groupId,
+      name: 'Test Group',
+      kind: GroupKind,
+      oid: organizationId,
+      createdAt: new Date().getTime(),
+      updatedAt: new Date().getTime(),
+      owner: ownerId,
+      users: [ownerId],
+    }
+    groupUpdatePayload = { ...mockGroup, name: 'Updated Group Name' }
+  })
+
+  test('should update an existing group', async ({ network, assert }) => {
+    const handle = await mocker.groups.update(network, {
+      response: {
+        status: 200,
+        body: mocker.gen.wrapResource(groupUpdatePayload),
+      },
+    })
+
+    const result = await sdk.groups.update(organizationId, groupUpdatePayload)
+    assert.deepEqual(result, groupUpdatePayload)
+
+    await handle.assert.calledOnceWith({
+      method: 'PUT',
+      headers: { Authorization: `Bearer ${baseToken}` },
+      body: JSON.stringify(groupUpdatePayload),
+    })
+  })
+
+  test('should throw if API returns non-200 status', async ({ network, assert }) => {
+    await mocker.groups.update(network, {
+      response: {
+        status: 400,
+        body: JSON.stringify({ message: 'Error', status: 400 }),
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.groups.update(organizationId, groupUpdatePayload)
+    )
+    assert.instanceOf(error, Exception)
+    assert.strictEqual(error.status, 400)
+    assert.include(error.message, 'Error')
+  })
+})
+
+test.group('delete()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true // Suppress console output for cleaner test output
+    mocker = new SdkNetworkMock(baseUri)
+  })
+
+  test('should delete a group', async ({ network }) => {
+    const handle = await mocker.groups.delete(network)
+
+    await sdk.groups.delete(organizationId, groupId)
+
+    handle.assert.calledOnceWith({
+      method: 'DELETE',
+      headers: { Authorization: `Bearer ${baseToken}` },
+    })
+  })
+
+  test('should throw if API returns non-204 status', async ({ network, assert }) => {
+    await mocker.groups.delete(network, {
+      response: {
+        status: 400,
+        body: JSON.stringify({ message: 'Error', status: 400 }),
+      },
+    })
+    const error = await assert.rejects<Exception>(async () => await sdk.groups.delete(organizationId, groupId))
+    assert.instanceOf(error, Exception)
+    assert.strictEqual(error.status, 400)
+    assert.include(error.message, 'Error')
+  })
+})

package/tests/client/sdk/network-mock/ai-mock.spec.ts

@@ -0,0 +1,124 @@
+import { test } from '@pawel-up/lupa/testing'
+import { SdkNetworkMock } from '../../../../src/sdk/SdkNetworkMock.js'
+import { StoreSdk } from '../../../../src/sdk/StoreSdkWeb.js'
+
+const baseUri = globalThis.location.protocol + '//' + globalThis.location.host
+const baseToken = 'test-token'
+
+test.group('ai.sessions', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+
+  test('mocks sessions.list() with random data', async ({ network, assert }) => {
+    await mocker.ai.sessions.list(network, { size: 2 })
+    const result = await sdk.ai.sessions.list('org-1', 'general')
+
+    assert.isArray(result.data)
+    assert.lengthOf(result.data, 2)
+    result.data.forEach((session) => {
+      assert.equal(session.kind, 'Core#AiSession')
+      assert.isString(session.key)
+      assert.equal(session.app, 'general')
+    })
+  })
+
+  test('mocks sessions.create()', async ({ network, assert }) => {
+    await mocker.ai.sessions.create(network)
+    const sessionToCreate = mocker.gen.ai.session()
+    const result = await sdk.ai.sessions.create('org-1', 'general', sessionToCreate)
+    assert.equal(result.kind, 'Core#AiSession')
+    assert.isString(result.key)
+  })
+
+  test('mocks sessions.read()', async ({ network, assert }) => {
+    await mocker.ai.sessions.read(network)
+    const result = await sdk.ai.sessions.read('org-1', 'general', 'session-1')
+    assert.equal(result.kind, 'Core#AiSession')
+  })
+
+  test('mocks sessions.update()', async ({ network, assert }) => {
+    await mocker.ai.sessions.update(network)
+    const sessionToUpdate = mocker.gen.ai.session()
+    const result = await sdk.ai.sessions.update('org-1', 'general', sessionToUpdate)
+    assert.equal(result.kind, 'Core#AiSession')
+  })
+
+  test('mocks sessions.delete()', async ({ network, assert }) => {
+    await mocker.ai.sessions.delete(network)
+    const result = await sdk.ai.sessions.delete('org-1', 'general', 'session-1')
+    assert.isUndefined(result)
+  })
+})
+
+test.group('messages', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+
+  test('mocks messages.list() with random data', async ({ network, assert }) => {
+    await mocker.ai.messages.list(network, { size: 3 })
+    const result = await sdk.ai.messages.list('org-1', 'session-1')
+
+    assert.isArray(result.data)
+    assert.lengthOf(result.data, 3)
+    result.data.forEach((message) => {
+      assert.equal(message.kind, 'Core#AiMessage')
+      assert.isString(message.key)
+      assert.isString(message.session)
+    })
+  })
+
+  test('mocks messages.update()', async ({ network, assert }) => {
+    await mocker.ai.messages.update(network)
+    const messageToUpdate = mocker.gen.ai.message()
+    const result = await sdk.ai.messages.update('org-1', 'session-1', messageToUpdate)
+    assert.equal(result.kind, 'Core#AiMessage')
+  })
+
+  test('mocks messages.delete()', async ({ network, assert }) => {
+    await mocker.ai.messages.delete(network)
+    const result = await sdk.ai.messages.delete('org-1', 'session-1', 'msg-1')
+    assert.isUndefined(result)
+  })
+})
+
+test.group('modifyDomain', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+
+  test('mocks modifyDomain() with SSE completion stream', async ({ network, assert }) => {
+    await mocker.ai.modifyDomain(network)
+    // To verify the SSE stream is correctly set up as returning `event: done\ndata: {}\n\n`
+    const iter = sdk.ai.modifyDomain('org-1', 'fid-1', 'Apply changes')
+
+    const chunks = []
+    for await (const chunk of iter) {
+      chunks.push(chunk)
+    }
+
+    assert.isArray(chunks)
+    assert.lengthOf(chunks, 1)
+    // @ts-expect-error It is what the mock returns.
+    assert.deepEqual(chunks[0], { event: 'done', data: {} })
+  })
+})

package/tests/client/sdk/network-mock/deployments-mock.spec.ts

@@ -0,0 +1,182 @@
+import { test } from '@pawel-up/lupa/testing'
+import { SdkNetworkMock } from '../../../../src/sdk/SdkNetworkMock.js'
+import { StoreSdk } from '../../../../src/sdk/StoreSdkWeb.js'
+import { DeploymentKind } from '../../../../src/models/kinds.js'
+import { DeploymentEnvironment } from '../../../../src/models/store/Deployment.js'
+import { Exception } from '../../../../src/exceptions/exception.js'
+
+const baseUri = globalThis.location.protocol + '//' + globalThis.location.host
+const baseToken = 'test-token'
+
+test.group('list', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+
+  test('mocks deployments.list() with random data', async ({ network, assert }) => {
+    await mocker.deployments.list(network, { size: 3 })
+    const result = await sdk.deployments.list('org-1', {})
+
+    assert.isArray(result.data)
+    assert.lengthOf(result.data, 3)
+    result.data.forEach((d) => {
+      assert.equal(d.kind, DeploymentKind)
+      assert.isString(d.key)
+      assert.isString(d.orgId)
+      assert.isString(d.apiId)
+      assert.isString(d.orgSlug)
+      assert.isString(d.apiSlug)
+      assert.isString(d.modelVersion)
+      assert.isNumber(d.createdAt)
+      assert.isNumber(d.updatedAt)
+      if (d.env === DeploymentEnvironment.PROD) {
+        assert.isString(d.version, 'PROD has version')
+      }
+    })
+  })
+
+  test('mocks deployments.list() with custom data', async ({ network, assert }) => {
+    const custom = mocker.gen.deployments.deployments(2, { orgId: 'org-1' })
+    await mocker.deployments.list(network, {
+      response: {
+        body: mocker.gen.wrapList(custom, { cursor: false }),
+      },
+    })
+    const result = await sdk.deployments.list('org-1', {})
+    assert.deepEqual(result.data, custom)
+  })
+
+  test('mocks deployments.list() with error status', async ({ network, assert }) => {
+    await mocker.deployments.list(network, { response: { status: 500 } })
+    await assert.rejects(async () => sdk.deployments.list('org-1', {}), Exception)
+  })
+
+  test('mocks deployments.list() with pagination cursor', async ({ network, assert }) => {
+    await mocker.deployments.list(network, { size: 2, cursor: true })
+    const result = await sdk.deployments.list('org-1', {})
+
+    assert.isArray(result.data)
+    assert.lengthOf(result.data, 2)
+    assert.isString(result.cursor, 'has pagination cursor')
+  })
+
+  test('mocks deployments.list() without pagination cursor', async ({ network, assert }) => {
+    await mocker.deployments.list(network, { size: 2, cursor: false })
+    const result = await sdk.deployments.list('org-1', {})
+
+    assert.isArray(result.data)
+    assert.lengthOf(result.data, 2)
+    assert.isUndefined(result.cursor, 'has no pagination cursor')
+  })
+})
+
+test.group('read', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+
+  test('mocks deployments.read() with key from path', async ({ network, assert }) => {
+    await mocker.deployments.read(network)
+    const result = await sdk.deployments.read('org-1', 'dep-key-1')
+    assert.equal(result.kind, DeploymentKind)
+    assert.equal(result.key, 'dep-key-1')
+    assert.equal(result.orgId, 'org-1')
+  })
+})
+
+test.group('create', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+
+  test('mocks create for non-production with payload', async ({ network, assert }) => {
+    await mocker.deployments.create(network)
+    const result = await sdk.deployments.create('org-1', {
+      fid: 'file-1',
+      modelVersion: '2.0.0',
+      env: DeploymentEnvironment.DEV,
+    })
+    assert.equal(result.kind, DeploymentKind)
+    assert.equal(result.orgId, 'org-1')
+    assert.equal(result.apiId, 'file-1')
+    assert.equal(result.modelVersion, '2.0.0')
+    assert.isUndefined(result.version)
+  })
+
+  test('mocks create for production with version', async ({ network, assert }) => {
+    await mocker.deployments.create(network)
+    const result = await sdk.deployments.create('org-1', {
+      fid: 'file-2',
+      modelVersion: '1.0.0',
+      env: DeploymentEnvironment.PROD,
+      version: 'v2',
+    })
+    assert.equal(result.env, DeploymentEnvironment.PROD)
+    assert.equal(result.version, 'v2')
+  })
+})
+
+test.group('deactivate', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+
+  test('mocks deployments.deactivate()', async ({ network }) => {
+    await mocker.deployments.deactivate(network)
+    await sdk.deployments.deactivate('org-1', 'dep-1')
+  })
+})
+
+test.group('mock lifecycle', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+
+  test('reset clears intercepts and allows reconfiguration', async ({ network, assert }) => {
+    const first = mocker.gen.deployments.deployments(1, { orgId: 'org-1' })
+    const handle = await mocker.deployments.list(network, {
+      response: { body: mocker.gen.wrapList(first, { cursor: false }) },
+    })
+    const res1 = await sdk.deployments.list('org-1', {})
+    assert.deepEqual(res1.data, first)
+
+    await handle.restore()
+
+    const second = mocker.gen.deployments.deployments(1, { orgId: 'org-1' })
+    await mocker.deployments.list(network, {
+      response: { body: mocker.gen.wrapList(second, { cursor: false }) },
+    })
+    const res2 = await sdk.deployments.list('org-1', {})
+    assert.deepEqual(res2.data, second)
+  })
+})

package/tests/client/sdk/network-mock/files-mock.spec.ts

@@ -0,0 +1,119 @@
+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 { Exception } from '../../../../src/exceptions/exception.js'
+import { FileSchema } from '../../../../src/models/store/File.js'
+import { MediaPatchRevision } from '../../../../src/patch/types.js'
+
+const baseUri = globalThis.location.protocol + '//' + globalThis.location.host
+const baseToken = 'test-token'
+
+test.group('files', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+
+  test('mocks file.list() with random data', async ({ network, assert }) => {
+    await mocker.files.list(network, { size: 2 })
+    const result = await sdk.files.list('org-1')
+    assert.isArray(result.data)
+    assert.lengthOf(result.data, 2)
+    result.data.forEach((f) => {
+      assert.isString(f.key)
+      assert.isString(f.kind)
+      assert.isObject(f.info)
+    })
+  })
+
+  test('mocks file.createMeta() and enforces 201', async ({ network, assert }) => {
+    await mocker.files.createMeta(network)
+    const created = await sdk.files.createMeta({} as unknown as FileSchema, 'org-1')
+    assert.isString(created.key)
+  })
+
+  test('file.createMeta() throws on wrong status', async ({ network, assert }) => {
+    await mocker.files.createMeta(network, { response: { status: 400 } })
+    await assert.rejects(async () => sdk.files.createMeta({} as unknown as FileSchema, 'org-1'), Exception)
+  })
+
+  test('mocks file.createMedia() as void and enforces 200', async ({ network, assert }) => {
+    await mocker.files.createMedia(network)
+    const res = await sdk.files.createMedia({ a: 1 }, 'org-1', 'fid-1')
+    assert.isUndefined(res)
+  })
+
+  test('mocks file.create()', async ({ network, assert }) => {
+    await mocker.files.create(network)
+    const created = await sdk.files.create({} as unknown as FileSchema, { x: 1 }, 'org-1')
+    assert.isString(created.key)
+  })
+
+  test('mocks file.createFolder()', async ({ network, assert }) => {
+    await mocker.files.createFolder(network)
+    const folder = await sdk.files.createFolder('Test', 'org-1')
+    assert.equal(folder.kind, FolderKind)
+  })
+
+  test('mocks file.read()', async ({ network, assert }) => {
+    await mocker.files.read(network)
+    const read = await sdk.files.read('org-1', 'fid-1')
+    assert.isString(read.key)
+  })
+
+  test('mocks file.readMedia()', async ({ network, assert }) => {
+    await mocker.files.readMedia(network)
+    const { media, version } = await sdk.files.readMedia('org-1', 'fid-1')
+    assert.exists(media)
+    assert.isNumber(version)
+  })
+
+  test('mocks file.readBulk()', async ({ network, assert }) => {
+    await mocker.files.readBulk(network)
+    const res = await sdk.files.readBulk('org-1', ['a', 'b'])
+    assert.isArray(res.data)
+  })
+
+  test('mocks file.patch()', async ({ network, assert }) => {
+    await mocker.files.patch(network)
+    const patched = await sdk.files.patch('org-1', 'fid-1', { id: 'x', timestamp: Date.now(), patch: [] })
+    assert.isString(patched.key)
+  })
+
+  test('mocks file.patchMedia()', async ({ network, assert }) => {
+    await mocker.files.patchMedia(network)
+    const res = (await sdk.files.patchMedia('org-1', 'fid-1', {
+      id: 'x',
+      timestamp: Date.now(),
+      patch: [],
+      version: 1,
+    })) as MediaPatchRevision
+    assert.isNumber(res.newVersion)
+  })
+
+  test('mocks file.delete() and enforces 204', async ({ network, assert }) => {
+    await mocker.files.delete(network)
+    const res = await sdk.files.delete('org-1', 'fid-1')
+    assert.isUndefined(res)
+  })
+
+  test('mocks file.listUsers()', async ({ network, assert }) => {
+    await mocker.files.listUsers(network)
+    const res = await sdk.files.listUsers('org-1', 'fid-1')
+    assert.isArray(res.data)
+    assert.isAtLeast(res.data.length, 1)
+  })
+
+  test('mocks file.breadcrumbs()', async ({ network, assert }) => {
+    await mocker.files.breadcrumbs(network)
+    const res = await sdk.files.breadcrumbs('org-1', 'fid-1')
+    assert.isArray(res.data)
+    assert.isAtLeast(res.data.length, 2)
+  })
+})