@api-client/core 0.19.24 → 0.19.26

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

@@ -1,58 +1,62 @@
 import { test } from '@japa/runner'
-import { Deployment, DeploymentStatus } from '../../../../src/models/store/Deployment.js'
+import { Deployment, DeploymentEnvironment, 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.isString(result.key)
     assert.equal(result.orgId, '')
     assert.equal(result.apiId, '')
-    assert.equal(result.deploymentVersion, 'v0')
-    assert.equal(result.apiModelVersion, '0.0.0')
+    assert.equal(result.orgSlug, '')
+    assert.equal(result.apiSlug, '')
+    assert.equal(result.env, DeploymentEnvironment.DEV)
+    assert.isUndefined(result.version)
+    assert.equal(result.modelVersion, '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',
+      key: 'test-id',
       orgId: 'org-1',
       apiId: 'api-1',
-      deploymentVersion: 'v1',
-      apiModelVersion: '1.0.0',
+      orgSlug: 'org-slug',
+      apiSlug: 'api-slug',
+      env: DeploymentEnvironment.PROD,
+      version: 'v1',
+      modelVersion: '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.key, '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.orgSlug, 'org-slug')
+    assert.equal(result.apiSlug, 'api-slug')
+    assert.equal(result.env, DeploymentEnvironment.PROD)
+    assert.equal(result.version, 'v1')
+    assert.equal(result.modelVersion, '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.isString(deployment.key)
     assert.equal(deployment.orgId, '')
     assert.equal(deployment.apiId, '')
-    assert.equal(deployment.deploymentVersion, 'v0')
-    assert.equal(deployment.apiModelVersion, '0.0.0')
+    assert.equal(deployment.orgSlug, '')
+    assert.equal(deployment.apiSlug, '')
+    assert.equal(deployment.env, DeploymentEnvironment.DEV)
+    assert.isUndefined(deployment.version)
+    assert.equal(deployment.modelVersion, '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)
   })
@@ -61,38 +65,39 @@ test.group('Deployment model', () => {
     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',
+      key: 'test-id',
       orgId: 'org-1',
       apiId: 'api-1',
-      deploymentVersion: 'v1',
-      apiModelVersion: '1.0.0',
+      orgSlug: 'org-slug',
+      apiSlug: 'api-slug',
+      env: DeploymentEnvironment.PROD,
+      version: 'v1',
+      modelVersion: '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',
+      kind: 'Core#Deployment',
+      key: 'test-id',
       orgId: 'org-1',
       apiId: 'api-1',
-      deploymentVersion: 'v1',
-      apiModelVersion: '1.0.0',
+      orgSlug: 'org-slug',
+      apiSlug: 'api-slug',
+      env: DeploymentEnvironment.PROD,
+      version: 'v1',
+      modelVersion: '1.0.0',
       status: DeploymentStatus.Active,
-      stagingPath: '/stage',
-      mongoModelId: 'mongo-1',
       createdAt: 12345,
       updatedAt: 67890,
     })
@@ -102,21 +107,64 @@ test.group('Deployment model', () => {
     const deployment = new Deployment({
       orgId: '',
       apiId: '',
+      orgSlug: '',
+      apiSlug: '',
+      env: '' as any, // Force empty env
     })
-    deployment.deploymentVersion = ''
-    deployment.apiModelVersion = ''
+    deployment.version = ''
+    deployment.modelVersion = ''
     const errors = deployment.validate()
-    assert.lengthOf(errors, 4)
+    // It should now return errors for orgId, apiId, orgSlug, apiSlug, env, modelVersion
+    // Note: Since env is empty, the version-prod logic won't hit the first branch, but might hit the second branch
+    // if version is present. Since version='', neither branch hits.
+    assert.lengthOf(errors, 6)
     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',
+    assert.deepEqual(errors[2], { field: 'orgSlug', message: 'Org slug must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[3], { field: 'apiSlug', message: 'API slug must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[4], { field: 'env', message: 'Environment tag must not be empty', rule: 'notEmpty' })
+    assert.deepEqual(errors[5], {
+      field: 'modelVersion',
+      message: 'API model version must not be empty',
       rule: 'notEmpty',
     })
-    assert.deepEqual(errors[3], {
-      field: 'apiModelVersion',
-      message: 'API model version must not be empty',
+  })
+
+  test('validate() returns error if version is empty for PROD environment', ({ assert }) => {
+    const deployment = new Deployment({
+      orgId: 'org-1',
+      apiId: 'api-1',
+      orgSlug: 'org-slug',
+      apiSlug: 'api-slug',
+      env: DeploymentEnvironment.PROD,
+      modelVersion: '1.0.0',
+    })
+    // Version is undefined by default, or we can explicitly set it to empty string
+    deployment.version = ''
+    const errors = deployment.validate()
+    assert.lengthOf(errors, 1)
+    assert.deepEqual(errors[0], {
+      field: 'version',
+      message: 'Version must not be empty for production environment',
+      rule: 'notEmpty',
+    })
+  })
+
+  test('validate() returns error if version is present for non-PROD environment', ({ assert }) => {
+    const deployment = new Deployment({
+      orgId: 'org-1',
+      apiId: 'api-1',
+      orgSlug: 'org-slug',
+      apiSlug: 'api-slug',
+      env: DeploymentEnvironment.DEV,
+      version: 'v1',
+      modelVersion: '1.0.0',
+    })
+    const errors = deployment.validate()
+    assert.lengthOf(errors, 1)
+    assert.deepEqual(errors[0], {
+      field: 'version',
+      message: 'Version must not be present for non-production environment',
       rule: 'notEmpty',
     })
   })
@@ -125,8 +173,24 @@ test.group('Deployment model', () => {
     const deployment = new Deployment({
       orgId: 'org-1',
       apiId: 'api-1',
-      deploymentVersion: 'v1',
-      apiModelVersion: '1.0.0',
+      version: 'v1',
+      modelVersion: '1.0.0',
+      orgSlug: 'org-slug',
+      apiSlug: 'api-slug',
+      env: DeploymentEnvironment.PROD,
+    })
+    const errors = deployment.validate()
+    assert.lengthOf(errors, 0)
+  })
+
+  test('validate() returns no errors for valid non-PROD model', ({ assert }) => {
+    const deployment = new Deployment({
+      orgId: 'org-1',
+      apiId: 'api-1',
+      modelVersion: '1.0.0',
+      orgSlug: 'org-slug',
+      apiSlug: 'api-slug',
+      env: DeploymentEnvironment.DEV,
     })
     const errors = deployment.validate()
     assert.lengthOf(errors, 0)