@api-client/core 0.20.10 → 0.21.1

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

@@ -0,0 +1,83 @@
+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'
+
+const baseUri = globalThis.location.protocol + '//' + globalThis.location.host
+const baseToken = 'test-token'
+
+test.group('groups', (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 groups.list() with random data', async ({ network, assert }) => {
+    await mocker.groups.list(network, { size: 2 })
+    const result = await sdk.groups.list('org-123')
+
+    assert.isArray(result.data)
+    assert.lengthOf(result.data, 2)
+    result.data.forEach((group) => {
+      assert.equal(group.kind, GroupKind)
+      assert.isString(group.key)
+      assert.isString(group.name)
+      assert.isString(group.owner)
+      assert.isString(group.oid)
+      assert.isArray(group.users)
+      assert.isNumber(group.createdAt)
+      assert.isNumber(group.updatedAt)
+    })
+  })
+
+  test('mocks groups.create() with random data', async ({ network, assert }) => {
+    await mocker.groups.create(network)
+    const result = await sdk.groups.create('org-123', { name: 'Test Group' })
+
+    assert.equal(result.kind, GroupKind)
+    assert.isString(result.key)
+    assert.isString(result.name)
+    assert.isString(result.owner)
+    assert.isString(result.oid)
+  })
+
+  test('mocks groups.create() with custom data and status', async ({ network, assert }) => {
+    const customGroup = {
+      kind: GroupKind,
+      key: 'group-custom',
+      name: 'Custom Group',
+      owner: 'user-123',
+      oid: 'org-456',
+      users: ['user-1', 'user-2'],
+      createdAt: 1234567890,
+      updatedAt: 1234567891,
+    }
+
+    await mocker.groups.create(network, {
+      response: {
+        status: 201,
+        body: mocker.gen.wrapResource(customGroup),
+      },
+    })
+    const result = await sdk.groups.create('org-123', { name: 'Ignored' })
+
+    assert.deepEqual(result, customGroup)
+  })
+
+  test('mocks groups.addUsers()', async ({ network, assert }) => {
+    await mocker.groups.addUsers(network)
+    const result = await sdk.groups.addUsers('org-123', 'grp-1', ['user-1'])
+    assert.equal(result.kind, GroupKind)
+  })
+
+  test('mocks groups.removeUsers()', async ({ network, assert }) => {
+    await mocker.groups.removeUsers(network)
+    const result = await sdk.groups.removeUsers('org-123', 'grp-1', ['user-1'])
+    assert.equal(result.kind, GroupKind)
+  })
+})

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

@@ -0,0 +1,129 @@
+import { test } from '@pawel-up/lupa/testing'
+import { SdkNetworkMock } from '../../../../src/sdk/SdkNetworkMock.js'
+import { StoreSdk } from '../../../../src/sdk/StoreSdkWeb.js'
+import { OrganizationKind, InvitationKind, UserKind } from '../../../../src/models/kinds.js'
+import type { OrganizationSchema } from '../../../../src/models/store/Organization.js'
+import { Exception } from '../../../../src/exceptions/exception.js'
+
+const baseUri = globalThis.location.protocol + '//' + globalThis.location.host
+const baseToken = 'test-token'
+
+test.group('organizations', (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 organizations.list() with random data', async ({ network, assert }) => {
+    await mocker.organizations.list(network, { size: 2 })
+    const result = await sdk.organizations.list()
+
+    assert.isArray(result.data, 'has data')
+    assert.lengthOf(result.data, 2, 'has two data')
+    result.data.forEach((org) => {
+      assert.equal(org.kind, OrganizationKind)
+      assert.isString(org.key)
+      assert.isString(org.name, 'has name')
+      assert.isString(org.createdBy)
+      assert.isNumber(org.createdDate)
+      assert.include(['owner', 'manager', 'editor', 'viewer'], org.grantType)
+    })
+  })
+
+  test('mocks organizations.list() with custom data', async ({ network, assert }) => {
+    const customOrgs = mocker.gen.organization.organizations(2)
+
+    await mocker.organizations.list(network, {
+      response: {
+        body: mocker.gen.wrapList(customOrgs, { cursor: false }),
+      },
+    })
+
+    const result = await sdk.organizations.list()
+    assert.deepEqual(result.data, customOrgs)
+  })
+
+  test('mocks organizations.create() with random data', async ({ network, assert }) => {
+    await mocker.organizations.create(network)
+    const result = await sdk.organizations.create('Test Org', 'test-org')
+
+    assert.equal(result.kind, OrganizationKind)
+    assert.isString(result.key)
+    assert.isString(result.name)
+    assert.isString(result.createdBy)
+    assert.isNumber(result.createdDate)
+    assert.include(['owner', 'manager', 'editor', 'viewer'], result.grantType)
+  })
+
+  test('mocks organizations.create() with custom data', async ({ network, assert }) => {
+    const customOrg: OrganizationSchema = {
+      kind: OrganizationKind,
+      key: 'org-custom',
+      name: 'My Custom Org',
+      slug: 'my-custom-org',
+      createdBy: 'user-custom',
+      createdDate: 9876543210,
+      grantType: 'owner' as const,
+    }
+
+    await mocker.organizations.create(network, { response: { body: mocker.gen.wrapResource(customOrg) } })
+    const result = await sdk.organizations.create('Ignored Name', 'ignored-slug')
+
+    assert.deepEqual(result, customOrg)
+  })
+
+  test('mocks organizations.create() with error status', async ({ network, assert }) => {
+    await mocker.organizations.create(network, { response: { status: 403 } })
+    await assert.rejects(async () => sdk.organizations.create('Test Org', 'test-org'), Exception)
+  })
+
+  test('mocks organizations.invitations.list()', async ({ network, assert }) => {
+    await mocker.organizations.invitations.list(network, { size: 3 })
+    const result = await sdk.organizations.invitations.list('org-123')
+    assert.isArray(result.data)
+    assert.lengthOf(result.data, 3)
+    result.data.forEach((inv) => {
+      assert.equal(inv.kind, InvitationKind)
+      assert.isString(inv.key)
+      assert.isString(inv.email)
+    })
+  })
+
+  test('mocks organizations.invitations.create()', async ({ network, assert }) => {
+    await mocker.organizations.invitations.create(network)
+    const result = await sdk.organizations.invitations.create('org-123', 'test@example.com', 'viewer')
+    assert.equal(result.kind, InvitationKind)
+    assert.isString(result.key)
+  })
+
+  test('mocks organizations.users.list()', async ({ network, assert }) => {
+    await mocker.organizations.users.list(network)
+    const result = await sdk.organizations.users.list('org-123')
+    assert.isArray(result.data)
+    assert.isAtLeast(result.data.length, 1)
+  })
+
+  test('mocks organizations.users.read()', async ({ network, assert }) => {
+    await mocker.organizations.users.read(network)
+    const result = await sdk.organizations.users.read('org-123', 'user-1')
+    assert.equal(result.kind, UserKind)
+  })
+
+  test('mocks organizations.slugs.generate()', async ({ network, assert }) => {
+    await mocker.organizations.slugs.generate(network)
+    const result = await sdk.organizations.slugs.generate('Test Org')
+    assert.isString(result)
+  })
+
+  test('mocks organizations.slugs.validate()', async ({ network, assert }) => {
+    await mocker.organizations.slugs.validate(network)
+    const result = await sdk.organizations.slugs.validate('test-org')
+    assert.isObject(result)
+    assert.isBoolean(result.valid)
+  })
+})

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

@@ -0,0 +1,25 @@
+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('shared', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(async () => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+
+  test('mocks shared.list()', async ({ network, assert }) => {
+    await mocker.shared.list(network)
+    const res = await sdk.shared.list('org-1')
+    assert.isArray(res.data)
+    assert.isAtLeast(res.data.length, 1)
+  })
+})

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

@@ -0,0 +1,43 @@
+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('trash', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(async () => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+
+  test('mocks trash.list()', async ({ network, assert }) => {
+    await mocker.trash.list(network)
+    const res = await sdk.trash.list('org-1', {})
+    assert.isArray(res.data)
+    assert.isAtLeast(res.data.length, 1)
+  })
+
+  test('mocks trash.delete()', async ({ network, assert }) => {
+    await mocker.trash.delete(network)
+    const res = await sdk.trash.delete('org-1', ['t1'])
+    assert.isUndefined(res)
+  })
+
+  test('mocks trash.restore()', async ({ network, assert }) => {
+    await mocker.trash.restore(network)
+    const res = await sdk.trash.restore('org-1', ['t1'])
+    assert.isUndefined(res)
+  })
+
+  test('mocks trash.empty()', async ({ network, assert }) => {
+    await mocker.trash.empty(network)
+    const res = await sdk.trash.empty('org-1')
+    assert.isUndefined(res)
+  })
+})

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

@@ -0,0 +1,79 @@
+import { test } from '@pawel-up/lupa/testing'
+import { SdkNetworkMock } from '../../../../src/sdk/SdkNetworkMock.js'
+import { StoreSdk } from '../../../../src/sdk/StoreSdkWeb.js'
+import { UserKind } from '../../../../src/models/kinds.js'
+import { Exception } from '../../../../src/exceptions/exception.js'
+import { UserSchema } from '../../../../src/models/store/User.js'
+
+const baseUri = globalThis.location.protocol + '//' + globalThis.location.host
+const baseToken = 'test-token'
+
+test.group('users', (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 user.me() with random data', async ({ network, assert }) => {
+    await mocker.users.me(network)
+    const result = await sdk.users.me()
+
+    assert.equal(result.kind, UserKind, 'has correct kind')
+    assert.isString(result.key, 'has key')
+    assert.isString(result.name, 'has name')
+    assert.isArray(result.email, 'has email array')
+    assert.lengthOf(result.email, 1, 'has one email')
+    assert.isString(result.email[0].email, 'email has email string')
+    assert.isBoolean(result.email[0].verified, 'email is or not verified')
+    assert.include(['active', 'deleted', 'suspended', 'pending'], result.status, 'has the status')
+    assert.isNumber(result.created, 'has created timestamp')
+    assert.isNumber(result.updated, 'has updated timestamp')
+  })
+
+  test('mocks user.me() with custom data', async ({ network, assert }) => {
+    const customUser: UserSchema = {
+      kind: UserKind,
+      key: 'user-custom',
+      name: 'John Doe',
+      email: [{ email: 'john.doe@example.com', verified: true }],
+      status: 'active' as const,
+      created: 1234567890,
+      updated: 1234567891,
+    }
+
+    await mocker.users.me(network, { response: { body: mocker.gen.wrapResource(customUser) } })
+    const result = await sdk.users.me()
+
+    assert.deepEqual(result, customUser)
+  })
+
+  test('mocks user.me() with custom headers', async ({ network, assert }) => {
+    const customHeaders = {
+      'X-Custom-Header': 'custom-value',
+      'X-Request-Id': 'request-123',
+    }
+
+    await mocker.users.me(network, { response: { headers: customHeaders }, forceBody: true })
+    const result = await sdk.users.me()
+
+    // The result should still be a valid user
+    assert.equal(result.kind, UserKind)
+    assert.isString(result.key)
+  })
+
+  test('user.me() throws with non 200 status code', async ({ network, assert }) => {
+    await mocker.users.me(network, { response: { status: 500 } })
+    await assert.rejects(() => sdk.users.me(), Exception)
+  })
+
+  test('user.me() throws with network error', async ({ network, assert }) => {
+    await mocker.users.me(network, { response: { error: network.error.ConnectionFailed } })
+    const err = await assert.rejects(() => sdk.users.me(), Exception)
+    assert.equal(err.code, 'E_NETWORK_ERROR')
+  })
+})