@api-client/core 0.19.22 → 0.19.24

package/tests/unit/models/store/Deployment.spec.ts

@@ -0,0 +1,134 @@
+import { test } from '@japa/runner'
+import { Deployment, DeploymentStatus } from '../../../../src/models/store/Deployment.js'
+import type { DeploymentSchema } from '../../../../src/models/store/Deployment.js'
+
+test.group('Deployment model', () => {
+  test('createSchema() returns default values', ({ assert }) => {
+    const result = Deployment.createSchema()
+    assert.isString(result.id)
+    assert.equal(result.orgId, '')
+    assert.equal(result.apiId, '')
+    assert.equal(result.deploymentVersion, 'v0')
+    assert.equal(result.apiModelVersion, '0.0.0')
+    assert.equal(result.status, DeploymentStatus.Pending)
+    assert.isUndefined(result.stagingPath)
+    assert.isUndefined(result.mongoModelId)
+    assert.isNumber(result.createdAt)
+    assert.isNumber(result.updatedAt)
+  })
+
+  test('createSchema(init) assigns values', ({ assert }) => {
+    const init: Partial<DeploymentSchema> = {
+      id: 'test-id',
+      orgId: 'org-1',
+      apiId: 'api-1',
+      deploymentVersion: 'v1',
+      apiModelVersion: '1.0.0',
+      status: DeploymentStatus.Active,
+      stagingPath: '/stage',
+      mongoModelId: 'mongo-1',
+      createdAt: 12345,
+      updatedAt: 67890,
+    }
+    const result = Deployment.createSchema(init)
+    assert.equal(result.id, 'test-id')
+    assert.equal(result.orgId, 'org-1')
+    assert.equal(result.apiId, 'api-1')
+    assert.equal(result.deploymentVersion, 'v1')
+    assert.equal(result.apiModelVersion, '1.0.0')
+    assert.equal(result.status, DeploymentStatus.Active)
+    assert.equal(result.stagingPath, '/stage')
+    assert.equal(result.mongoModelId, 'mongo-1')
+    assert.equal(result.createdAt, 12345)
+    assert.equal(result.updatedAt, 67890)
+  })
+
+  test('constructor() initializes with default values', ({ assert }) => {
+    const deployment = new Deployment()
+    assert.isString(deployment.id)
+    assert.equal(deployment.orgId, '')
+    assert.equal(deployment.apiId, '')
+    assert.equal(deployment.deploymentVersion, 'v0')
+    assert.equal(deployment.apiModelVersion, '0.0.0')
+    assert.equal(deployment.status, DeploymentStatus.Pending)
+    assert.isUndefined(deployment.stagingPath)
+    assert.isUndefined(deployment.mongoModelId)
+    assert.isNumber(deployment.createdAt)
+    assert.isNumber(deployment.updatedAt)
+  })
+
+  test('constructor(init) assigns values', ({ assert }) => {
+    const init: Partial<DeploymentSchema> = {
+      orgId: 'org-1',
+      apiId: 'api-1',
+      stagingPath: '/stage',
+    }
+    const deployment = new Deployment(init)
+    assert.equal(deployment.orgId, 'org-1')
+    assert.equal(deployment.apiId, 'api-1')
+    assert.equal(deployment.stagingPath, '/stage')
+  })
+
+  test('toJSON() returns the schema representation', ({ assert }) => {
+    const init: Partial<DeploymentSchema> = {
+      id: 'test-id',
+      orgId: 'org-1',
+      apiId: 'api-1',
+      deploymentVersion: 'v1',
+      apiModelVersion: '1.0.0',
+      status: DeploymentStatus.Active,
+      stagingPath: '/stage',
+      mongoModelId: 'mongo-1',
+      createdAt: 12345,
+      updatedAt: 67890,
+    }
+    const deployment = new Deployment(init)
+    const result = deployment.toJSON()
+    assert.deepEqual(result, {
+      id: 'test-id',
+      orgId: 'org-1',
+      apiId: 'api-1',
+      deploymentVersion: 'v1',
+      apiModelVersion: '1.0.0',
+      status: DeploymentStatus.Active,
+      stagingPath: '/stage',
+      mongoModelId: 'mongo-1',
+      createdAt: 12345,
+      updatedAt: 67890,
+    })
+  })
+
+  test('validate() returns errors for empty fields', ({ assert }) => {
+    const deployment = new Deployment({
+      orgId: '',
+      apiId: '',
+    })
+    deployment.deploymentVersion = ''
+    deployment.apiModelVersion = ''
+    const errors = deployment.validate()
+    assert.lengthOf(errors, 4)
+    assert.deepEqual(errors[0], { field: 'orgId', message: 'Org ID must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[1], { field: 'apiId', message: 'API ID must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[2], {
+      field: 'deploymentVersion',
+      message: 'Deployment version must not be empty',
+      rule: 'notEmpty',
+    })
+    assert.deepEqual(errors[3], {
+      field: 'apiModelVersion',
+      message: 'API model version must not be empty',
+      rule: 'notEmpty',
+    })
+  })
+
+  test('validate() returns no errors for valid model', ({ assert }) => {
+    const deployment = new Deployment({
+      orgId: 'org-1',
+      apiId: 'api-1',
+      deploymentVersion: 'v1',
+      apiModelVersion: '1.0.0',
+    })
+    const errors = deployment.validate()
+    assert.lengthOf(errors, 0)
+  })
+})

package/tests/unit/models/store/DeploymentCustomDomain.spec.ts

@@ -0,0 +1,122 @@
+import { test } from '@japa/runner'
+import { DeploymentCustomDomainModel, SslStatus } from '../../../../src/models/store/DeploymentCustomDomain.js'
+import type { DeploymentCustomDomainSchema } from '../../../../src/models/store/DeploymentCustomDomain.js'
+
+test.group('DeploymentCustomDomain model', () => {
+  test('createSchema() returns default values', ({ assert }) => {
+    const result = DeploymentCustomDomainModel.createSchema()
+    assert.isString(result.id)
+    assert.equal(result.deploymentId, '')
+    assert.equal(result.customDomainId, '')
+    assert.equal(result.basePath, '/')
+    assert.equal(result.sslStatus, SslStatus.PendingDns)
+    assert.isNumber(result.createdAt)
+    assert.isNumber(result.updatedAt)
+  })
+
+  test('createSchema(init) assigns values', ({ assert }) => {
+    const init: Partial<DeploymentCustomDomainSchema> = {
+      id: 'test-id',
+      deploymentId: 'dep-1',
+      customDomainId: 'dom-1',
+      basePath: '/api',
+      sslStatus: SslStatus.Active,
+      createdAt: 12345,
+      updatedAt: 67890,
+    }
+    const result = DeploymentCustomDomainModel.createSchema(init)
+    assert.equal(result.id, 'test-id')
+    assert.equal(result.deploymentId, 'dep-1')
+    assert.equal(result.customDomainId, 'dom-1')
+    assert.equal(result.basePath, '/api')
+    assert.equal(result.sslStatus, SslStatus.Active)
+    assert.equal(result.createdAt, 12345)
+    assert.equal(result.updatedAt, 67890)
+  })
+
+  test('constructor() initializes with default values', ({ assert }) => {
+    const model = new DeploymentCustomDomainModel()
+    assert.isString(model.id)
+    assert.equal(model.deploymentId, '')
+    assert.equal(model.customDomainId, '')
+    assert.equal(model.basePath, '/')
+    assert.equal(model.sslStatus, SslStatus.PendingDns)
+    assert.isNumber(model.createdAt)
+    assert.isNumber(model.updatedAt)
+  })
+
+  test('constructor(init) assigns values', ({ assert }) => {
+    const init: Partial<DeploymentCustomDomainSchema> = {
+      deploymentId: 'dep-1',
+      customDomainId: 'dom-1',
+      basePath: '/api',
+    }
+    const model = new DeploymentCustomDomainModel(init)
+    assert.equal(model.deploymentId, 'dep-1')
+    assert.equal(model.customDomainId, 'dom-1')
+    assert.equal(model.basePath, '/api')
+  })
+
+  test('toJSON() returns the schema representation', ({ assert }) => {
+    const init: Partial<DeploymentCustomDomainSchema> = {
+      id: 'test-id',
+      deploymentId: 'dep-1',
+      customDomainId: 'dom-1',
+      basePath: '/api',
+      sslStatus: SslStatus.Active,
+      createdAt: 12345,
+      updatedAt: 67890,
+    }
+    const model = new DeploymentCustomDomainModel(init)
+    const result = model.toJSON()
+    assert.deepEqual(result, {
+      id: 'test-id',
+      deploymentId: 'dep-1',
+      customDomainId: 'dom-1',
+      basePath: '/api',
+      sslStatus: SslStatus.Active,
+      createdAt: 12345,
+      updatedAt: 67890,
+    })
+  })
+
+  test('validate() returns errors for empty and invalid fields', ({ assert }) => {
+    const model = new DeploymentCustomDomainModel({
+      basePath: '',
+      deploymentId: '',
+      customDomainId: '',
+    })
+    let errors = model.validate()
+    assert.lengthOf(errors, 3)
+    assert.deepEqual(errors[0], { field: 'basePath', message: 'Base path must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[1], { field: 'deploymentId', message: 'Deployment ID must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[2], {
+      field: 'customDomainId',
+      message: 'Custom domain ID must not be empty',
+      rule: 'notEmpty',
+    })
+
+    const modelInvalidPath = new DeploymentCustomDomainModel({
+      basePath: 'api/path',
+      deploymentId: 'dep-1',
+      customDomainId: 'dom-1',
+    })
+    errors = modelInvalidPath.validate()
+    assert.lengthOf(errors, 1)
+    assert.deepEqual(errors[0], {
+      field: 'basePath',
+      message: 'Base path must start with a slash',
+      rule: 'startsWithSlash',
+    })
+  })
+
+  test('validate() returns no errors for valid model', ({ assert }) => {
+    const model = new DeploymentCustomDomainModel({
+      deploymentId: 'dep-1',
+      customDomainId: 'dom-1',
+      basePath: '/api',
+    })
+    const errors = model.validate()
+    assert.lengthOf(errors, 0)
+  })
+})