@api-client/core 0.20.10 → 0.21.1

package/src/sdk/StoreSdkNode.ts

@@ -1,13 +1,10 @@
 import { HttpNode } from './HttpNode.js'
-import { WsClientNode } from './WsClientNode.js'
 import { Sdk } from './Sdk.js'
 import { Http } from './Http.js'
-import { WsClient } from './WsClient.js'
 
 /**
  * NodeJS API for API Client's net-store module.
  */
 export class StoreSdk extends Sdk {
   http: Http = new HttpNode(this)
-  ws: WsClient = new WsClientNode(this)
 }

package/src/sdk/StoreSdkWeb.ts

@@ -1,13 +1,10 @@
 import { HttpWeb } from './HttpWeb.js'
-import { WsClientWeb } from './WsClientWeb.js'
 import { Sdk } from './Sdk.js'
 import { Http } from './Http.js'
-import { WsClient } from './WsClient.js'
 
 /**
  * API Client's web store module.
  */
 export class StoreSdk extends Sdk {
   http: Http = new HttpWeb(this)
-  ws: WsClient = new WsClientWeb(this)
 }

package/tests/client/env.ts

@@ -0,0 +1,11 @@
+interface Oauth2env {
+  port: number
+  issuer: string
+}
+
+export default {
+  oauth2: {
+    port: 0,
+    issuer: '',
+  } as Oauth2env,
+}

package/tests/client/lib/dom_purify.spec.ts

@@ -0,0 +1,12 @@
+import { test } from '@pawel-up/lupa/testing'
+import DOMPurify from '../../../src/lib/dom_purify.js'
+
+test('DOMPurify is initialized correctly', ({ assert }) => {
+  assert.isFunction(DOMPurify.sanitize, 'DOMPurify should have a sanitize function')
+})
+
+test('should sanitize input correctly', ({ assert }) => {
+  const unsafeInput = '<script>alert("XSS")</script>'
+  const safeOutput = DOMPurify.sanitize(unsafeInput)
+  assert.equal(safeOutput, '', 'Sanitized output should be empty for unsafe input')
+})

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

@@ -0,0 +1,565 @@
+import { test } from '@pawel-up/lupa/testing'
+import { DataCatalogKind, DataCatalogVersionKind } from '../../../src/models/kinds.js'
+import type { DataCatalogSchema } from '../../../src/models/DataCatalog.js'
+import type { DataCatalogVersionSchema } from '../../../src/models/DataCatalogVersion.js'
+import { StoreSdk } from '../../../src/sdk/StoreSdkWeb.js'
+import { SdkNetworkMock } from '../../../src/sdk/SdkNetworkMock.js'
+
+test.group('list', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk('http://localhost:8080')
+    mocker = new SdkNetworkMock()
+  })
+
+  test('mocks dataCatalog.list() with random data', async ({ assert, network }) => {
+    await mocker.dataCatalog.list(network, { size: 3 })
+    const result = await sdk.dataCatalog.list()
+
+    assert.isArray(result.data, 'has data')
+    assert.lengthOf(result.data, 3, 'has three data')
+    result.data.forEach((catalog) => {
+      assert.equal(catalog.kind, DataCatalogKind, 'has correct kind')
+      assert.isString(catalog.key, 'has key')
+      assert.isString(catalog.name, 'has name')
+      assert.isString(catalog.organization, 'has organization')
+      assert.isString(catalog.file, 'has file')
+      assert.include(['public', 'private', 'organization'], catalog.scope, 'has valid scope')
+      assert.isString(catalog.description, 'has description')
+      assert.isString(catalog.publishedBy, 'has publishedBy')
+      assert.isNumber(catalog.publishedAt, 'has publishedAt timestamp')
+      assert.isNumber(catalog.createdAt, 'has createdAt timestamp')
+      assert.isNumber(catalog.updatedAt, 'has updatedAt timestamp')
+      assert.isArray(catalog.tags, 'has tags array')
+      assert.isArray(catalog.versions, 'has versions array')
+      assert.isAtLeast(catalog.versions.length, 1, 'has at least one version')
+    })
+  })
+
+  test('mocks dataCatalog.list() with custom data', async ({ assert, network }) => {
+    const customCatalogs = mocker.gen.dataCatalog.dataCatalogsWithVersion(2)
+
+    await mocker.dataCatalog.list(network, {
+      response: {
+        body: JSON.stringify({ data: customCatalogs, cursor: undefined }),
+      },
+    })
+
+    const result = await sdk.dataCatalog.list()
+    assert.deepEqual(result.data, customCatalogs)
+  })
+
+  test('mocks dataCatalog.list() with pagination cursor', async ({ assert, network }) => {
+    await mocker.dataCatalog.list(network, { size: 2, cursor: true })
+    const result = await sdk.dataCatalog.list()
+
+    assert.isArray(result.data)
+    assert.lengthOf(result.data, 2)
+    assert.isString(result.cursor, 'has pagination cursor')
+  })
+
+  test('mocks dataCatalog.list() without pagination cursor', async ({ assert, network }) => {
+    await mocker.dataCatalog.list(network, { size: 2, cursor: false })
+    const result = await sdk.dataCatalog.list()
+
+    assert.isArray(result.data)
+    assert.lengthOf(result.data, 2)
+    assert.isUndefined(result.cursor, 'has no pagination cursor')
+  })
+
+  test('dataCatalog.list() throws with error status', async ({ assert, network }) => {
+    await mocker.dataCatalog.list(network, { response: { status: 500 } })
+    await assert.rejects(async () => await sdk.dataCatalog.list())
+  })
+})
+
+test.group('listVersions', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk('http://localhost:8080')
+    mocker = new SdkNetworkMock()
+  })
+
+  test('mocks dataCatalog.listVersions() with random data', async ({ assert, network }) => {
+    await mocker.dataCatalog.listVersions(network, { size: 5 })
+    const result = await sdk.dataCatalog.listVersions('catalog-123')
+
+    assert.isArray(result.data, 'has data')
+    assert.lengthOf(result.data, 5, 'has five data')
+    result.data.forEach((version) => {
+      assert.isString(version.key, 'has key')
+      assert.isString(version.version, 'has version')
+      assert.isNumber(version.published, 'has published timestamp')
+    })
+  })
+
+  test('mocks dataCatalog.listVersions() with custom data', async ({ assert, network }) => {
+    const customVersions = mocker.gen.dataCatalog.versionInfos(3)
+
+    await mocker.dataCatalog.listVersions(network, {
+      response: {
+        body: JSON.stringify({ data: customVersions, cursor: undefined }),
+      },
+    })
+
+    const result = await sdk.dataCatalog.listVersions('catalog-123')
+    assert.deepEqual(result.data, customVersions)
+  })
+
+  test('dataCatalog.listVersions() throws with error status', async ({ assert, network }) => {
+    await mocker.dataCatalog.listVersions(network, { response: { status: 404 } })
+    await assert.rejects(async () => await sdk.dataCatalog.listVersions('catalog-123'))
+  })
+})
+
+test.group('publish', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk('http://localhost:8080')
+    mocker = new SdkNetworkMock()
+  })
+
+  test('mocks dataCatalog.publish() with random data', async ({ assert, network }) => {
+    await mocker.dataCatalog.publish(network)
+    const entry: DataCatalogSchema = {
+      kind: DataCatalogKind,
+      key: 'test-catalog',
+      name: 'Test Catalog',
+      organization: 'org-123',
+      file: 'file-123',
+      scope: 'public',
+      description: 'Test description',
+      publishedBy: 'user-123',
+      publishedAt: Date.now(),
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      tags: ['test'],
+    }
+    const result = await sdk.dataCatalog.publish(entry)
+
+    assert.isString(result.key, 'has key in response')
+    assert.equal(result.kind, DataCatalogKind, 'has correct kind')
+    assert.isObject(result.item, 'has item')
+    assert.isDefined(result.item, 'item is defined')
+    if (result.item) {
+      assert.equal(result.item.kind, DataCatalogKind, 'item has correct kind')
+    }
+  })
+
+  test('mocks dataCatalog.publish() with custom data', async ({ assert, network }) => {
+    const customCatalog = mocker.gen.dataCatalog.dataCatalog()
+    const customResponse = {
+      key: customCatalog.key,
+      item: customCatalog,
+      kind: customCatalog.kind,
+    }
+
+    await mocker.dataCatalog.publish(network, {
+      response: { body: mocker.gen.wrapResource(customResponse) },
+    })
+
+    const entry: DataCatalogSchema = {
+      kind: DataCatalogKind,
+      key: 'ignored',
+      name: 'Ignored',
+      organization: 'org-456',
+      file: 'file-456',
+      scope: 'private',
+      description: 'Will be ignored',
+      publishedBy: 'user-456',
+      publishedAt: Date.now(),
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      tags: [],
+    }
+    const result = await sdk.dataCatalog.publish(entry)
+
+    assert.deepEqual(result, customResponse)
+  })
+
+  test('dataCatalog.publish() throws with error status', async ({ assert, network }) => {
+    await mocker.dataCatalog.publish(network, { response: { status: 403 } })
+
+    const entry: DataCatalogSchema = {
+      kind: DataCatalogKind,
+      key: 'test',
+      name: 'Test',
+      organization: 'org-123',
+      file: 'file-123',
+      scope: 'public',
+      description: 'Test',
+      publishedBy: 'user-123',
+      publishedAt: Date.now(),
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      tags: [],
+    }
+    await assert.rejects(async () => await sdk.dataCatalog.publish(entry))
+  })
+})
+
+test.group('read', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk('http://localhost:8080')
+    mocker = new SdkNetworkMock()
+  })
+
+  test('mocks dataCatalog.read() with random data', async ({ assert, network }) => {
+    await mocker.dataCatalog.read(network)
+    const result = await sdk.dataCatalog.read('catalog-123')
+
+    assert.equal(result.kind, DataCatalogKind, 'has correct kind')
+    assert.isString(result.key, 'has key')
+    assert.isString(result.name, 'has name')
+    assert.isString(result.organization, 'has organization')
+    assert.isString(result.file, 'has file')
+    assert.include(['public', 'private', 'organization'], result.scope, 'has valid scope')
+  })
+
+  test('mocks dataCatalog.read() with matching key', async ({ assert, network }) => {
+    await mocker.dataCatalog.read(network)
+    const result = await sdk.dataCatalog.read('specific-key')
+
+    assert.equal(result.key, 'specific-key', 'returns catalog with requested key')
+  })
+
+  test('mocks dataCatalog.read() with custom data', async ({ assert, network }) => {
+    const customCatalog = mocker.gen.dataCatalog.dataCatalog({
+      key: 'custom-catalog',
+      name: 'Custom Catalog',
+    })
+
+    await mocker.dataCatalog.read(network, {
+      response: { body: mocker.gen.wrapResource(customCatalog) },
+    })
+
+    const result = await sdk.dataCatalog.read('custom-catalog')
+    assert.deepEqual(result, customCatalog)
+  })
+
+  test('dataCatalog.read() throws with error status', async ({ assert, network }) => {
+    await mocker.dataCatalog.read(network, { response: { status: 404 } })
+    await assert.rejects(async () => await sdk.dataCatalog.read('catalog-123'))
+  })
+})
+
+test.group('deprecate', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk('http://localhost:8080')
+    mocker = new SdkNetworkMock()
+  })
+
+  test('mocks dataCatalog.deprecate() with random data', async ({ assert, network }) => {
+    await mocker.dataCatalog.deprecate(network)
+    const result = await sdk.dataCatalog.deprecate('catalog-123', 'Outdated')
+
+    assert.isString(result.key, 'has key')
+    assert.equal(result.kind, DataCatalogKind, 'has correct kind')
+    assert.isObject(result.item, 'has item')
+    assert.isDefined(result.item, 'item is defined')
+    if (result.item) {
+      assert.equal(result.item.kind, DataCatalogKind, 'item has correct kind')
+    }
+  })
+
+  test('mocks dataCatalog.deprecate() with matching key', async ({ assert, network }) => {
+    await mocker.dataCatalog.deprecate(network)
+    const result = await sdk.dataCatalog.deprecate('specific-key', 'Reason')
+
+    assert.equal(result.key, 'specific-key', 'returns response with requested key')
+  })
+
+  test('dataCatalog.deprecate() throws with error status', async ({ assert, network }) => {
+    await mocker.dataCatalog.deprecate(network, { response: { status: 403 } })
+    await assert.rejects(async () => await sdk.dataCatalog.deprecate('catalog-123', 'Reason'))
+  })
+})
+
+test.group('unpublish', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk('http://localhost:8080')
+    mocker = new SdkNetworkMock()
+  })
+
+  test('mocks dataCatalog.unpublish() with random data', async ({ assert, network }) => {
+    await mocker.dataCatalog.unpublish(network)
+    const result = await sdk.dataCatalog.unpublish('catalog-123')
+
+    assert.isString(result.key, 'has key')
+    assert.equal(result.kind, DataCatalogKind, 'has correct kind')
+    assert.isObject(result.item, 'has item')
+    assert.isDefined(result.item, 'item is defined')
+    if (result.item) {
+      assert.equal(result.item.kind, DataCatalogKind, 'item has correct kind')
+    }
+  })
+
+  test('mocks dataCatalog.unpublish() with matching key', async ({ assert, network }) => {
+    await mocker.dataCatalog.unpublish(network)
+    const result = await sdk.dataCatalog.unpublish('specific-key')
+
+    assert.equal(result.key, 'specific-key', 'returns response with requested key')
+  })
+
+  test('dataCatalog.unpublish() throws with error status', async ({ assert, network }) => {
+    await mocker.dataCatalog.unpublish(network, { response: { status: 404 } })
+    await assert.rejects(async () => await sdk.dataCatalog.unpublish('catalog-123'))
+  })
+})
+
+test.group('publishVersion', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk('http://localhost:8080')
+    mocker = new SdkNetworkMock()
+  })
+
+  test('mocks dataCatalog.publishVersion() with random data', async ({ assert, network }) => {
+    await mocker.dataCatalog.publishVersion(network)
+    const version: DataCatalogVersionSchema = {
+      kind: DataCatalogVersionKind,
+      key: 'version-key',
+      catalogKey: 'catalog-123',
+      scope: 'public',
+      lifecycle: 'stable',
+      version: 'v1.0.0',
+      publishedBy: 'user-123',
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      changelog: 'Initial release',
+    }
+    const result = await sdk.dataCatalog.publishVersion('catalog-123', version)
+
+    assert.isString(result.key, 'has key')
+    assert.equal(result.kind, DataCatalogVersionKind, 'has correct kind')
+    assert.isObject(result.item, 'has item')
+    assert.isDefined(result.item, 'item is defined')
+    if (result.item) {
+      assert.equal(result.item.kind, DataCatalogVersionKind, 'item has correct kind')
+    }
+  })
+
+  test('dataCatalog.publishVersion() throws with error status', async ({ assert, network }) => {
+    await mocker.dataCatalog.publishVersion(network, { response: { status: 400 } })
+
+    const version: DataCatalogVersionSchema = {
+      kind: DataCatalogVersionKind,
+      key: 'version-key',
+      catalogKey: 'catalog-123',
+      scope: 'public',
+      lifecycle: 'stable',
+      version: 'v1.0.0',
+      publishedBy: 'user-123',
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      changelog: 'Test',
+    }
+    await assert.rejects(async () => await sdk.dataCatalog.publishVersion('catalog-123', version))
+  })
+})
+
+test.group('readVersion', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk('http://localhost:8080')
+    mocker = new SdkNetworkMock()
+  })
+
+  test('mocks dataCatalog.readVersion() with random data', async ({ assert, network }) => {
+    await mocker.dataCatalog.readVersion(network)
+    const result = await sdk.dataCatalog.readVersion('catalog-123', 'v1.0.0')
+
+    assert.equal(result.kind, DataCatalogVersionKind, 'has correct kind')
+    assert.isString(result.key, 'has key')
+    assert.isString(result.catalogKey, 'has catalogKey')
+    assert.isString(result.version, 'has version')
+    assert.include(['public', 'private', 'organization'], result.scope, 'has valid scope')
+    assert.include(['stable', 'beta', 'dev'], result.lifecycle, 'has valid lifecycle')
+    assert.isString(result.publishedBy, 'has publishedBy')
+    assert.isNumber(result.createdAt, 'has createdAt')
+    assert.isNumber(result.updatedAt, 'has updatedAt')
+  })
+
+  test('mocks dataCatalog.readVersion() with matching keys', async ({ assert, network }) => {
+    await mocker.dataCatalog.readVersion(network)
+    const result = await sdk.dataCatalog.readVersion('specific-catalog', 'specific-version')
+
+    assert.equal(result.key, 'specific-version', 'returns version with requested key')
+    assert.equal(result.catalogKey, 'specific-catalog', 'returns version with requested catalog key')
+  })
+
+  test('dataCatalog.readVersion() throws with error status', async ({ assert, network }) => {
+    await mocker.dataCatalog.readVersion(network, { response: { status: 404 } })
+    await assert.rejects(async () => await sdk.dataCatalog.readVersion('catalog-123', 'v1.0.0'))
+  })
+})
+
+test.group('listDependencies', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk('http://localhost:8080')
+    mocker = new SdkNetworkMock()
+  })
+
+  test('mocks dataCatalog.listDependencies() with random data', async ({ assert, network }) => {
+    await mocker.dataCatalog.listDependencies(network)
+    const result = await sdk.dataCatalog.listDependencies([
+      { key: 'dep-1', version: 'v1.0.0' },
+      { key: 'dep-2', version: 'v2.0.0' },
+    ])
+
+    assert.isArray(result.data, 'has data')
+    assert.lengthOf(result.data, 2, 'has two data matching dependencies')
+    result.data.forEach((domain) => {
+      assert.isString(domain.key, 'has key')
+      assert.isObject(domain.info, 'has info')
+      assert.isString(domain.info.name, 'has name')
+      assert.isString(domain.info.version, 'has version')
+    })
+  })
+
+  test('dataCatalog.listDependencies() throws with error status', async ({ assert, network }) => {
+    await mocker.dataCatalog.listDependencies(network, { response: { status: 500 } })
+    await assert.rejects(async () => await sdk.dataCatalog.listDependencies([{ key: 'dep-1', version: 'v1.0.0' }]))
+  })
+})
+
+test.group('deprecateVersion', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk('http://localhost:8080')
+    mocker = new SdkNetworkMock()
+  })
+
+  test('mocks dataCatalog.deprecateVersion() with random data', async ({ assert, network }) => {
+    await mocker.dataCatalog.deprecateVersion(network)
+    const result = await sdk.dataCatalog.deprecateVersion('catalog-123', 'v1.0.0', 'Security issue')
+
+    assert.isString(result.key, 'has key')
+    assert.equal(result.kind, DataCatalogVersionKind, 'has correct kind')
+    assert.isObject(result.item, 'has item')
+    assert.isDefined(result.item, 'item is defined')
+    if (result.item) {
+      assert.equal(result.item.kind, DataCatalogVersionKind, 'item has correct kind')
+      assert.isTrue(result.item.deprecated, 'version is marked as deprecated')
+      assert.isNumber(result.item.deprecatedAt, 'has deprecatedAt timestamp')
+      assert.isString(result.item.deprecatedBy, 'has deprecatedBy')
+      assert.equal(result.item.deprecationReason, 'Security issue', 'has deprecation reason')
+    }
+  })
+
+  test('dataCatalog.deprecateVersion() throws with error status', async ({ assert, network }) => {
+    await mocker.dataCatalog.deprecateVersion(network, { response: { status: 403 } })
+    await assert.rejects(async () => await sdk.dataCatalog.deprecateVersion('catalog-123', 'v1.0.0', 'Reason'))
+  })
+})
+
+test.group('unpublishVersion', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk('http://localhost:8080')
+    mocker = new SdkNetworkMock()
+  })
+
+  test('mocks dataCatalog.unpublishVersion() with random data', async ({ assert, network }) => {
+    await mocker.dataCatalog.unpublishVersion(network)
+    const result = await sdk.dataCatalog.unpublishVersion('catalog-123', 'v1.0.0')
+
+    assert.isString(result.key, 'has key')
+    assert.equal(result.kind, DataCatalogVersionKind, 'has correct kind')
+    assert.isObject(result.item, 'has item')
+    assert.isDefined(result.item, 'item is defined')
+    if (result.item) {
+      assert.equal(result.item.kind, DataCatalogVersionKind, 'item has correct kind')
+      assert.isNumber(result.item.unpublishedAt, 'has unpublishedAt timestamp')
+      assert.equal(result.item.scope, 'private', 'scope is set to private')
+    }
+  })
+
+  test('dataCatalog.unpublishVersion() throws with error status', async ({ assert, network }) => {
+    await mocker.dataCatalog.unpublishVersion(network, { response: { status: 404 } })
+    await assert.rejects(async () => await sdk.dataCatalog.unpublishVersion('catalog-123', 'v1.0.0'))
+  })
+})
+
+test.group('checkPublicationStatus', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk('http://localhost:8080')
+    mocker = new SdkNetworkMock()
+  })
+
+  test('mocks dataCatalog.checkPublicationStatus() with random data', async ({ assert, network }) => {
+    await mocker.dataCatalog.checkPublicationStatus(network)
+    const result = await sdk.dataCatalog.checkPublicationStatus('domain-123')
+
+    assert.equal(result.kind, DataCatalogKind, 'has correct kind')
+    assert.isString(result.key, 'has key')
+    assert.isString(result.name, 'has name')
+    assert.isArray(result.versions, 'has versions array')
+    assert.lengthOf(result.versions, 1, 'has one version')
+    assert.isString(result.versions[0].key, 'version has key')
+    assert.isString(result.versions[0].version, 'version has version string')
+    assert.isNumber(result.versions[0].published, 'version has published timestamp')
+  })
+
+  test('dataCatalog.checkPublicationStatus() throws with error status', async ({ assert, network }) => {
+    await mocker.dataCatalog.checkPublicationStatus(network, { response: { status: 404 } })
+    await assert.rejects(async () => await sdk.dataCatalog.checkPublicationStatus('domain-123'))
+  })
+})
+
+test.group('mock lifecycle', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.setup(() => {
+    sdk = new StoreSdk('http://localhost:8080')
+    mocker = new SdkNetworkMock()
+  })
+
+  test('reset clears intercepts and allows reconfiguration', async ({ assert, network }) => {
+    const first = mocker.gen.dataCatalog.dataCatalogsWithVersion(1)
+    const handle = await mocker.dataCatalog.list(network, {
+      response: { body: JSON.stringify({ data: first, cursor: undefined }) },
+    })
+    const res1 = await sdk.dataCatalog.list()
+    assert.deepEqual(res1.data, first)
+
+    await handle.restore()
+
+    const second = mocker.gen.dataCatalog.dataCatalogsWithVersion(1)
+    await mocker.dataCatalog.list(network, {
+      response: { body: JSON.stringify({ data: second, cursor: undefined }) },
+    })
+    const res2 = await sdk.dataCatalog.list()
+    assert.deepEqual(res2.data, second)
+  })
+})