@api-client/core 0.18.39 → 0.18.41

package/tests/unit/mocking/current/DataCatalog.spec.ts

@@ -0,0 +1,449 @@
+import { test } from '@japa/runner'
+import sinon from 'sinon'
+import { DataCatalog } from '../../../../src/mocking/lib/DataCatalog.js'
+import { DataCatalogKind, DataCatalogVersionKind } from '../../../../src/models/kinds.js'
+import type {
+  DataCatalogSchema,
+  DataCatalogSchemaWithVersion,
+  DataCatalogVersionInfo,
+} from '../../../../src/models/DataCatalog.js'
+import type { DataCatalogVersionSchema } from '../../../../src/models/DataCatalogVersion.js'
+
+test.group('dataCatalog()', (group) => {
+  let catalog: DataCatalog
+
+  group.each.setup(() => {
+    catalog = new DataCatalog()
+  })
+
+  test('returns an object', ({ assert }) => {
+    const result = catalog.dataCatalog()
+    assert.typeOf(result, 'object')
+  })
+
+  test('has the {property} property of a type {type}')
+    .with([
+      { property: 'kind', type: 'string' },
+      { property: 'key', type: 'string' },
+      { property: 'name', type: 'string' },
+      { property: 'organization', type: 'string' },
+      { property: 'file', type: 'string' },
+      { property: 'scope', type: 'string' },
+      { property: 'description', type: 'string' },
+      { property: 'publishedBy', type: 'string' },
+      { property: 'publishedAt', type: 'number' },
+      { property: 'createdAt', type: 'number' },
+      { property: 'updatedAt', type: 'number' },
+      { property: 'tags', type: 'array' },
+    ])
+    .run(({ assert }, { property, type }) => {
+      const result = catalog.dataCatalog()
+      assert.typeOf(result[property as keyof DataCatalogSchema], type)
+    })
+
+  test('has the correct kind', ({ assert }) => {
+    const result = catalog.dataCatalog()
+    assert.equal(result.kind, DataCatalogKind)
+  })
+
+  test('scope is one of the valid values', ({ assert }) => {
+    const result = catalog.dataCatalog()
+    assert.include(['public', 'private', 'organization'], result.scope)
+  })
+
+  test('uses passed key', ({ assert }) => {
+    const result = catalog.dataCatalog({ key: 'custom-key' })
+    assert.equal(result.key, 'custom-key')
+  })
+
+  test('uses passed name', ({ assert }) => {
+    const result = catalog.dataCatalog({ name: 'Custom Catalog' })
+    assert.equal(result.name, 'Custom Catalog')
+  })
+
+  test('uses passed organization', ({ assert }) => {
+    const result = catalog.dataCatalog({ organization: 'org-123' })
+    assert.equal(result.organization, 'org-123')
+  })
+
+  test('uses passed file', ({ assert }) => {
+    const result = catalog.dataCatalog({ file: 'file-456' })
+    assert.equal(result.file, 'file-456')
+  })
+
+  test('uses passed scope', ({ assert }) => {
+    const result = catalog.dataCatalog({ scope: 'private' })
+    assert.equal(result.scope, 'private')
+  })
+
+  test('uses passed description', ({ assert }) => {
+    const result = catalog.dataCatalog({ description: 'Test description' })
+    assert.equal(result.description, 'Test description')
+  })
+
+  test('uses passed publishedBy', ({ assert }) => {
+    const result = catalog.dataCatalog({ publishedBy: 'user-789' })
+    assert.equal(result.publishedBy, 'user-789')
+  })
+
+  test('uses passed publishedAt', ({ assert }) => {
+    const timestamp = Date.now()
+    const result = catalog.dataCatalog({ publishedAt: timestamp })
+    assert.equal(result.publishedAt, timestamp)
+  })
+
+  test('uses passed createdAt', ({ assert }) => {
+    const timestamp = Date.now()
+    const result = catalog.dataCatalog({ createdAt: timestamp })
+    assert.equal(result.createdAt, timestamp)
+  })
+
+  test('uses passed updatedAt', ({ assert }) => {
+    const timestamp = Date.now()
+    const result = catalog.dataCatalog({ updatedAt: timestamp })
+    assert.equal(result.updatedAt, timestamp)
+  })
+
+  test('uses passed tags', ({ assert }) => {
+    const tags = ['tag1', 'tag2', 'tag3']
+    const result = catalog.dataCatalog({ tags })
+    assert.deepEqual(result.tags, tags)
+  })
+})
+
+test.group('dataCatalogs()', (group) => {
+  let catalog: DataCatalog
+
+  group.each.setup(() => {
+    catalog = new DataCatalog()
+  })
+
+  test('returns an array', ({ assert }) => {
+    const result = catalog.dataCatalogs()
+    assert.typeOf(result, 'array')
+  })
+
+  test('list has default number of items', ({ assert }) => {
+    const result = catalog.dataCatalogs()
+    assert.lengthOf(result, 25)
+  })
+
+  test('returns requested number of items', ({ assert }) => {
+    const result = catalog.dataCatalogs(10)
+    assert.lengthOf(result, 10)
+  })
+
+  test('calls dataCatalog()', ({ assert }) => {
+    const spy = sinon.spy(catalog, 'dataCatalog')
+    catalog.dataCatalogs(5)
+    assert.equal(spy.callCount, 5)
+  })
+})
+
+test.group('dataCatalogVersion()', (group) => {
+  let catalog: DataCatalog
+
+  group.each.setup(() => {
+    catalog = new DataCatalog()
+  })
+
+  test('returns an object', ({ assert }) => {
+    const result = catalog.dataCatalogVersion()
+    assert.typeOf(result, 'object')
+  })
+
+  test('has the {property} property of a type {type}')
+    .with([
+      { property: 'kind', type: 'string' },
+      { property: 'key', type: 'string' },
+      { property: 'catalogKey', type: 'string' },
+      { property: 'scope', type: 'string' },
+      { property: 'lifecycle', type: 'string' },
+      { property: 'version', type: 'string' },
+      { property: 'publishedBy', type: 'string' },
+      { property: 'createdAt', type: 'number' },
+      { property: 'updatedAt', type: 'number' },
+      { property: 'changelog', type: 'string' },
+    ])
+    .run(({ assert }, { property, type }) => {
+      const result = catalog.dataCatalogVersion()
+      assert.typeOf(result[property as keyof DataCatalogVersionSchema], type)
+    })
+
+  test('has the correct kind', ({ assert }) => {
+    const result = catalog.dataCatalogVersion()
+    assert.equal(result.kind, DataCatalogVersionKind)
+  })
+
+  test('scope is one of the valid values', ({ assert }) => {
+    const result = catalog.dataCatalogVersion()
+    assert.include(['public', 'private', 'organization'], result.scope)
+  })
+
+  test('lifecycle is one of the valid values', ({ assert }) => {
+    const result = catalog.dataCatalogVersion()
+    assert.include(['stable', 'beta', 'dev'], result.lifecycle)
+  })
+
+  test('version starts with v', ({ assert }) => {
+    const result = catalog.dataCatalogVersion()
+    assert.isTrue(result.version.startsWith('v'))
+  })
+
+  test('uses passed key', ({ assert }) => {
+    const result = catalog.dataCatalogVersion({ key: 'version-key' })
+    assert.equal(result.key, 'version-key')
+  })
+
+  test('uses passed catalogKey', ({ assert }) => {
+    const result = catalog.dataCatalogVersion({ catalogKey: 'catalog-123' })
+    assert.equal(result.catalogKey, 'catalog-123')
+  })
+
+  test('uses passed scope', ({ assert }) => {
+    const result = catalog.dataCatalogVersion({ scope: 'private' })
+    assert.equal(result.scope, 'private')
+  })
+
+  test('uses passed lifecycle', ({ assert }) => {
+    const result = catalog.dataCatalogVersion({ lifecycle: 'beta' })
+    assert.equal(result.lifecycle, 'beta')
+  })
+
+  test('uses passed version', ({ assert }) => {
+    const result = catalog.dataCatalogVersion({ version: 'v2.0.0' })
+    assert.equal(result.version, 'v2.0.0')
+  })
+
+  test('uses passed publishedBy', ({ assert }) => {
+    const result = catalog.dataCatalogVersion({ publishedBy: 'user-999' })
+    assert.equal(result.publishedBy, 'user-999')
+  })
+
+  test('uses passed createdAt', ({ assert }) => {
+    const timestamp = Date.now()
+    const result = catalog.dataCatalogVersion({ createdAt: timestamp })
+    assert.equal(result.createdAt, timestamp)
+  })
+
+  test('uses passed updatedAt', ({ assert }) => {
+    const timestamp = Date.now()
+    const result = catalog.dataCatalogVersion({ updatedAt: timestamp })
+    assert.equal(result.updatedAt, timestamp)
+  })
+
+  test('uses passed changelog', ({ assert }) => {
+    const result = catalog.dataCatalogVersion({ changelog: 'Custom changelog' })
+    assert.equal(result.changelog, 'Custom changelog')
+  })
+})
+
+test.group('dataCatalogVersions()', (group) => {
+  let catalog: DataCatalog
+
+  group.each.setup(() => {
+    catalog = new DataCatalog()
+  })
+
+  test('returns an array', ({ assert }) => {
+    const result = catalog.dataCatalogVersions()
+    assert.typeOf(result, 'array')
+  })
+
+  test('list has default number of items', ({ assert }) => {
+    const result = catalog.dataCatalogVersions()
+    assert.lengthOf(result, 25)
+  })
+
+  test('returns requested number of items', ({ assert }) => {
+    const result = catalog.dataCatalogVersions(7)
+    assert.lengthOf(result, 7)
+  })
+
+  test('calls dataCatalogVersion()', ({ assert }) => {
+    const spy = sinon.spy(catalog, 'dataCatalogVersion')
+    catalog.dataCatalogVersions(3)
+    assert.equal(spy.callCount, 3)
+  })
+})
+
+test.group('dataCatalogWithVersion()', (group) => {
+  let catalog: DataCatalog
+
+  group.each.setup(() => {
+    catalog = new DataCatalog()
+  })
+
+  test('returns an object', ({ assert }) => {
+    const result = catalog.dataCatalogWithVersion()
+    assert.typeOf(result, 'object')
+  })
+
+  test('has the {property} property of a type {type}')
+    .with([
+      { property: 'kind', type: 'string' },
+      { property: 'key', type: 'string' },
+      { property: 'name', type: 'string' },
+      { property: 'organization', type: 'string' },
+      { property: 'file', type: 'string' },
+      { property: 'scope', type: 'string' },
+      { property: 'description', type: 'string' },
+      { property: 'publishedBy', type: 'string' },
+      { property: 'publishedAt', type: 'number' },
+      { property: 'createdAt', type: 'number' },
+      { property: 'updatedAt', type: 'number' },
+      { property: 'tags', type: 'array' },
+      { property: 'versions', type: 'array' },
+    ])
+    .run(({ assert }, { property, type }) => {
+      const result = catalog.dataCatalogWithVersion()
+      assert.typeOf(result[property as keyof DataCatalogSchemaWithVersion], type)
+    })
+
+  test('has at least one version', ({ assert }) => {
+    const result = catalog.dataCatalogWithVersion()
+    assert.isAtLeast(result.versions.length, 1)
+  })
+
+  test('has at most 20 versions', ({ assert }) => {
+    const result = catalog.dataCatalogWithVersion()
+    assert.isAtMost(result.versions.length, 20)
+  })
+
+  test('each version has required properties', ({ assert }) => {
+    const result = catalog.dataCatalogWithVersion()
+    result.versions.forEach((version) => {
+      assert.typeOf(version.version, 'string')
+      assert.typeOf(version.lifecycle, 'string')
+      assert.include(['stable', 'beta', 'dev'], version.lifecycle)
+    })
+  })
+
+  test('versions follow semantic versioning pattern', ({ assert }) => {
+    const result = catalog.dataCatalogWithVersion()
+    result.versions.forEach((version) => {
+      assert.match(version.version, /^v\d+\.\d+\.\d+$/)
+    })
+  })
+
+  test('uses passed initialization values', ({ assert }) => {
+    const result = catalog.dataCatalogWithVersion({
+      key: 'custom-key',
+      name: 'Custom Name',
+    })
+    assert.equal(result.key, 'custom-key')
+    assert.equal(result.name, 'Custom Name')
+    assert.isArray(result.versions)
+  })
+})
+
+test.group('dataCatalogsWithVersion()', (group) => {
+  let catalog: DataCatalog
+
+  group.each.setup(() => {
+    catalog = new DataCatalog()
+  })
+
+  test('returns an array', ({ assert }) => {
+    const result = catalog.dataCatalogsWithVersion()
+    assert.typeOf(result, 'array')
+  })
+
+  test('list has default number of items', ({ assert }) => {
+    const result = catalog.dataCatalogsWithVersion()
+    assert.lengthOf(result, 3)
+  })
+
+  test('returns requested number of items', ({ assert }) => {
+    const result = catalog.dataCatalogsWithVersion(5)
+    assert.lengthOf(result, 5)
+  })
+
+  test('calls dataCatalogWithVersion()', ({ assert }) => {
+    const spy = sinon.spy(catalog, 'dataCatalogWithVersion')
+    catalog.dataCatalogsWithVersion(4)
+    assert.equal(spy.callCount, 4)
+  })
+
+  test('each item has versions array', ({ assert }) => {
+    const result = catalog.dataCatalogsWithVersion(2)
+    result.forEach((item) => {
+      assert.isArray(item.versions)
+      assert.isAtLeast(item.versions.length, 1)
+    })
+  })
+})
+
+test.group('versionInfo()', (group) => {
+  let catalog: DataCatalog
+
+  group.each.setup(() => {
+    catalog = new DataCatalog()
+  })
+
+  test('returns an object', ({ assert }) => {
+    const result = catalog.versionInfo()
+    assert.typeOf(result, 'object')
+  })
+
+  test('has the {property} property of a type {type}')
+    .with([
+      { property: 'key', type: 'string' },
+      { property: 'version', type: 'string' },
+      { property: 'published', type: 'number' },
+    ])
+    .run(({ assert }, { property, type }) => {
+      const result = catalog.versionInfo()
+      assert.typeOf(result[property as keyof DataCatalogVersionInfo], type)
+    })
+
+  test('version starts with v', ({ assert }) => {
+    const result = catalog.versionInfo()
+    assert.isTrue(result.version.startsWith('v'))
+  })
+
+  test('uses passed key', ({ assert }) => {
+    const result = catalog.versionInfo({ key: 'info-key' })
+    assert.equal(result.key, 'info-key')
+  })
+
+  test('uses passed version', ({ assert }) => {
+    const result = catalog.versionInfo({ version: 'v3.0.0' })
+    assert.equal(result.version, 'v3.0.0')
+  })
+
+  test('uses passed published timestamp', ({ assert }) => {
+    const timestamp = Date.now()
+    const result = catalog.versionInfo({ published: timestamp })
+    assert.equal(result.published, timestamp)
+  })
+})
+
+test.group('versionInfos()', (group) => {
+  let catalog: DataCatalog
+
+  group.each.setup(() => {
+    catalog = new DataCatalog()
+  })
+
+  test('returns an array', ({ assert }) => {
+    const result = catalog.versionInfos()
+    assert.typeOf(result, 'array')
+  })
+
+  test('list has default number of items', ({ assert }) => {
+    const result = catalog.versionInfos()
+    assert.lengthOf(result, 5)
+  })
+
+  test('returns requested number of items', ({ assert }) => {
+    const result = catalog.versionInfos(8)
+    assert.lengthOf(result, 8)
+  })
+
+  test('calls versionInfo()', ({ assert }) => {
+    const spy = sinon.spy(catalog, 'versionInfo')
+    catalog.versionInfos(6)
+    assert.equal(spy.callCount, 6)
+  })
+})

package/TESTING_READY.md

@@ -1,114 +0,0 @@
-# Testing Setup Complete! 🎉
-
-Your API Client Core project now has a comprehensive testing setup with documentation and utilities.
-
-## What's Been Added
-
-### 📚 Documentation
-
-- **`TESTING_SETUP.md`** - Complete testing guide and reference
-- **Test Templates** - Ready-to-use templates for new tests
-
-### 🛠️ Utilities
-
-- **`tests/test-utils.ts`** - Common testing utilities and helpers
-- **`tests/example-test-setup.ts`** - Working examples of test patterns
-- **`tests/template-node.spec.ts`** - Template for Node.js tests
-- **`test/template-browser.test.ts`** - Template for browser tests
-
-### ⚡ VS Code Tasks
-
-- **Test: Run All Tests** - Runs both Node.js and browser tests
-- Additional test tasks available in the Command Palette
-
-## Quick Start
-
-### Run All Tests
-
-```bash
-npm test
-```
-
-### Run Node.js Tests Only
-
-```bash
-npm run test:node
-```
-
-### Run Browser Tests Only  
-
-```bash
-npm run test:browser
-```
-
-### Run Tests with Coverage
-
-```bash
-npm run test:coverage
-```
-
-### Run Tests in Watch Mode
-
-```bash
-npm run test:browser:watch
-```
-
-## Your Testing Stack
-
-### Node.js Tests (Japa)
-
-- **Location**: `tests/unit/**/*.spec.ts`
-- **Framework**: Japa with Assert plugin
-- **Features**: Sinon mocking, API client testing, type checking
-- **Run with**: `npm run test:node`
-
-### Browser Tests (Web Test Runner)  
-
-- **Location**: `test/**/*.browser.test.ts` or `test/**/*.spec.ts`
-- **Framework**: Web Test Runner with Chai
-- **Features**: Playwright automation, OAuth2 mock server, DOM testing
-- **Run with**: `npm run test:browser`
-
-## File Naming Conventions
-
-- **Node.js tests**: `*.spec.ts` in `tests/unit/`
-- **Browser tests**: `*.browser.test.ts` or `*.spec.ts` in `test/`
-- **Shared utilities**: Place in `test/` directory
-
-## Next Steps
-
-1. **Review the documentation** in `TESTING_SETUP.md`
-2. **Explore the examples** in `test/example-test-setup.ts`
-3. **Use the templates** to create new tests:
-   - Copy `test/template-node.spec.ts` for Node.js tests
-   - Copy `test/template-browser.test.ts` for browser tests
-4. **Run the existing tests** to ensure everything works
-5. **Write tests for your modules** using the patterns shown
-
-## Testing Best Practices
-
-✅ **Separate Node.js and browser tests** - Use appropriate file naming  
-✅ **Use test utilities** - Leverage `TestUtils` for common operations  
-✅ **Mock external dependencies** - Use Sinon for consistent mocking  
-✅ **Test both success and error cases** - Ensure comprehensive coverage  
-✅ **Group related tests** - Use test groups for better organization  
-✅ **Clean up after tests** - Restore mocks and clean up resources  
-
-## Available Test Utilities
-
-- `TestUtils.createMockResponse()` - HTTP response mocking
-- `TestUtils.createTestRequest()` - HTTP request creation  
-- `TestUtils.generateTestData()` - Random test data
-- `TestUtils.assertThrows()` - Error testing
-- `TestUtils.mockFetch()` - Fetch API mocking
-- `BrowserTestUtils.waitForElement()` - DOM element waiting
-- `BrowserTestUtils.createMockLocalStorage()` - Storage mocking
-
-## Need Help?
-
-- Check `TESTING_SETUP.md` for detailed documentation
-- Look at existing tests in `tests/unit/` for examples
-- Review the templates for common patterns
-- Run tests with `--verbose` flag for more output
-
-Happy testing! 🚀