@api-client/core 0.19.9 → 0.19.11

package/tests/unit/modeling/validation/api_model_rules.spec.ts

@@ -0,0 +1,324 @@
+import { test } from '@japa/runner'
+import { ApiModel } from '../../../../src/modeling/ApiModel.js'
+import { DataDomain } from '../../../../src/modeling/DataDomain.js'
+
+import {
+  validateApiModelInfo,
+  validateApiModelDependency,
+  validateApiModelSecurity,
+  validateApiModelMetadata,
+  validateExposedEntity,
+  validateAction,
+  validateApiModel,
+} from '../../../../src/modeling/validation/api_model_rules.js'
+import { ExposedEntity } from '../../../../src/modeling/ExposedEntity.js'
+import { ListAction } from '../../../../src/modeling/actions/ListAction.js'
+import { DeleteAction } from '../../../../src/modeling/actions/DeleteAction.js'
+import { ReadAction } from '../../../../src/modeling/actions/ReadAction.js'
+import { SearchAction } from '../../../../src/modeling/actions/SearchAction.js'
+import { UpdateAction } from '../../../../src/modeling/actions/UpdateAction.js'
+import { RolesBasedAccessControl, UsernamePasswordConfiguration } from '../../../../src/modeling/types.js'
+import { SemanticType } from '../../../../src/modeling/Semantics.js'
+
+test.group('ApiModel Validation', () => {
+  test('validateApiModelInfo - success', ({ assert }) => {
+    const model = new ApiModel({
+      info: { name: 'Valid API', description: 'A test definition' },
+    })
+    const issues = validateApiModelInfo(model)
+    assert.isEmpty(issues)
+  })
+
+  test('validateApiModelInfo - missing required', ({ assert }) => {
+    const model = new ApiModel({
+      info: { name: '' },
+    })
+    const issues = validateApiModelInfo(model)
+    // Expect missing name and missing description
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_NAME'))
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_DESCRIPTION' && i.severity === 'warning'))
+  })
+
+  test('validateApiModelDependency - missing domain', ({ assert }) => {
+    const model = new ApiModel()
+    const issues = validateApiModelDependency(model)
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_DOMAIN'))
+  })
+
+  test('validateApiModelDependency - valid domain', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const model = new ApiModel({}, domain)
+    const issues = validateApiModelDependency(model)
+    assert.isEmpty(issues)
+  })
+
+  test('validateApiModelSecurity - success', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const modelNode = domain.addModel({ key: 'users' })
+    const userEntity = domain.addEntity(modelNode.key, { info: { name: 'User' } })
+    userEntity.addProperty({ key: 'pass', semantics: [{ id: SemanticType.Password }] })
+    userEntity.addProperty({ key: 'role', semantics: [{ id: SemanticType.UserRole }] })
+    userEntity.addProperty({ key: 'name', semantics: [{ id: SemanticType.Username }] })
+
+    const model = new ApiModel(
+      {
+        authentication: { strategy: 'UsernamePassword', passwordKey: 'pass' } as UsernamePasswordConfiguration,
+        authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+        session: {
+          secret: 'super-secret',
+          properties: ['id', 'role'],
+          cookie: {
+            enabled: true,
+            kind: 'cookie',
+            lifetime: '7d',
+            httpOnly: true,
+            secure: true,
+            sameSite: 'none',
+            name: 'as',
+          },
+        },
+        user: { key: userEntity.key, domain: domain.key },
+      },
+      domain
+    )
+
+    const issues = validateApiModelSecurity(model)
+    assert.isEmpty(issues)
+  })
+
+  test('validateApiModelSecurity - missing session properties', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const model = new ApiModel(
+      {
+        authentication: { strategy: 'UsernamePassword', passwordKey: 'pass' } as UsernamePasswordConfiguration,
+        authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+        session: {
+          secret: 'super-secret',
+          properties: [],
+          cookie: {
+            enabled: true,
+            kind: 'cookie',
+            lifetime: '7d',
+            httpOnly: true,
+            secure: true,
+            sameSite: 'none',
+            name: 'as',
+          },
+        },
+        user: { key: 'nonexistent', domain: domain.key },
+      },
+      domain
+    )
+
+    const issues = validateApiModelSecurity(model)
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_SESSION_PROPERTIES'))
+    assert.isTrue(issues.some((i) => i.code === 'API_INVALID_USER_ENTITY'))
+  })
+
+  test('validateApiModelSecurity - missing password semantic', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const modelNode = domain.addModel({ key: 'users' })
+    const userEntity = domain.addEntity(modelNode.key, { info: { name: 'User' } })
+    userEntity.addProperty({ key: 'pass' }) // missing password semantic
+    userEntity.addProperty({ key: 'role', semantics: [{ id: SemanticType.UserRole }] })
+    userEntity.addProperty({ key: 'name', semantics: [{ id: SemanticType.Username }] })
+
+    const model = new ApiModel(
+      {
+        authentication: { strategy: 'UsernamePassword', passwordKey: 'pass' } as UsernamePasswordConfiguration,
+        authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+        session: { secret: 'secret', properties: [] },
+        user: { key: userEntity.key, domain: domain.key },
+      },
+      domain
+    )
+
+    const issues = validateApiModelSecurity(model)
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_PASSWORD_SEMANTIC'))
+  })
+
+  test('validateApiModelSecurity - missing username semantic', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const modelNode = domain.addModel({ key: 'users' })
+    const userEntity = domain.addEntity(modelNode.key, { info: { name: 'User' } })
+    userEntity.addProperty({ key: 'pass', semantics: [{ id: SemanticType.Password }] })
+    userEntity.addProperty({ key: 'role', semantics: [{ id: SemanticType.UserRole }] })
+    userEntity.addProperty({ key: 'name' }) // no username semantic
+
+    const model = new ApiModel(
+      {
+        authentication: { strategy: 'UsernamePassword', passwordKey: 'pass' } as UsernamePasswordConfiguration,
+        authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+        session: { secret: 'secret', properties: [] },
+        user: { key: userEntity.key, domain: domain.key },
+      },
+      domain
+    )
+
+    const issues = validateApiModelSecurity(model)
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_USERNAME_SEMANTIC'))
+  })
+
+  test('validateApiModelSecurity - missing role semantic', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const modelNode = domain.addModel({ key: 'users' })
+    const userEntity = domain.addEntity(modelNode.key, { info: { name: 'User' } })
+    userEntity.addProperty({ key: 'pass', semantics: [{ id: SemanticType.Password }] })
+    userEntity.addProperty({ key: 'role' }) // missing role semantic
+    userEntity.addProperty({ key: 'name', semantics: [{ id: SemanticType.Username }] })
+
+    const model = new ApiModel(
+      {
+        authentication: { strategy: 'UsernamePassword', passwordKey: 'pass' } as UsernamePasswordConfiguration,
+        authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+        session: { secret: 'secret', properties: [] },
+        user: { key: userEntity.key, domain: domain.key },
+      },
+      domain
+    )
+
+    const issues = validateApiModelSecurity(model)
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_ROLE_SEMANTIC'))
+  })
+
+  test('validateApiModelMetadata - contact warnings', ({ assert }) => {
+    const model = new ApiModel()
+    const issues = validateApiModelMetadata(model)
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_CONTACT' && i.severity === 'info'))
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_LICENSE' && i.severity === 'info'))
+    assert.isTrue(issues.some((i) => i.code === 'API_MISSING_TOS' && i.severity === 'info'))
+  })
+
+  test('validateApiModelMetadata - invalid urls and emails', ({ assert }) => {
+    const model = new ApiModel({
+      contact: { email: 'invalid-email', url: 'invalid-url' },
+      license: { name: 'MIT', url: 'invalid-url' },
+    })
+    const issues = validateApiModelMetadata(model)
+    assert.isTrue(issues.some((i) => i.code === 'API_INVALID_CONTACT_EMAIL'))
+    assert.isTrue(issues.some((i) => i.code === 'API_INVALID_CONTACT_URL'))
+    assert.isTrue(issues.some((i) => i.code === 'API_INVALID_LICENSE_URL'))
+  })
+
+  test('validateExposedEntity - missing actions', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const model = new ApiModel({}, domain)
+    const exposure = new ExposedEntity(model, {
+      entity: { key: 'fake' },
+      collectionPath: '/items',
+      resourcePath: '/items/{id}',
+      hasCollection: true,
+    })
+    exposure.actions = [] // Override default behaviour
+
+    // override collectionPath/resourcePath defaults since exposure sets it if missing
+    exposure.collectionPath = '/items'
+    exposure.resourcePath = '/items/{id}'
+
+    const issues = validateExposedEntity(exposure, model)
+    assert.isTrue(issues.some((i) => i.code === 'EXPOSURE_MISSING_ACTIONS'))
+    assert.isTrue(issues.some((i) => i.code === 'EXPOSURE_INVALID_ENTITY_REF')) // because fake entity doesn't exist
+  })
+
+  test('validateExposedEntity - path integrity (has collection)', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const model = new ApiModel({}, domain)
+    const exposure = new ExposedEntity(model, {
+      entity: { key: 'fake' },
+      hasCollection: true,
+    })
+    exposure.collectionPath = 'invalid_no_slash'
+    exposure.resourcePath = '/invalid_no_slash_resource'
+    exposure.actions = [new ReadAction(exposure)]
+    const issues = validateExposedEntity(exposure, model)
+    assert.isTrue(issues.some((i) => i.code === 'EXPOSURE_INVALID_COLLECTION_PATH'))
+    assert.isTrue(issues.some((i) => i.code === 'EXPOSURE_INVALID_RESOURCE_PATH_FORMAT'))
+  })
+
+  test('validateAction - List needs pagination', ({ assert }) => {
+    const model = new ApiModel()
+    const exposure = new ExposedEntity(model, { entity: { key: '1' } })
+    const action = new ListAction(exposure)
+    // @ts-expect-error testing undefined pagination
+    action.pagination = undefined
+
+    const issues = validateAction(action, exposure, model.key)
+    assert.isTrue(issues.some((i) => i.code === 'ACTION_LIST_MISSING_PAGINATION'))
+  })
+
+  test('validateAction - Search needs fields', ({ assert }) => {
+    const model = new ApiModel()
+    const exposure = new ExposedEntity(model, { entity: { key: '1' } })
+    const action = new SearchAction(exposure)
+    action.fields = []
+
+    const issues = validateAction(action, exposure, model.key)
+    assert.isTrue(issues.some((i) => i.code === 'ACTION_SEARCH_MISSING_FIELDS'))
+  })
+
+  test('validateAction - Delete needs strategy', ({ assert }) => {
+    const model = new ApiModel()
+    const exposure = new ExposedEntity(model, { entity: { key: '1' } })
+    const action = new DeleteAction(exposure)
+    // @ts-expect-error testing undefined strategy
+    action.strategy = undefined
+
+    const issues = validateAction(action, exposure, model.key)
+    assert.isTrue(issues.some((i) => i.code === 'ACTION_DELETE_MISSING_STRATEGY'))
+  })
+
+  test('validateAction - Update needs methods', ({ assert }) => {
+    const model = new ApiModel()
+    const exposure = new ExposedEntity(model, { entity: { key: '1' } })
+    const action = new UpdateAction(exposure)
+    action.allowedMethods = []
+
+    const issues = validateAction(action, exposure, model.key)
+    assert.isTrue(issues.some((i) => i.code === 'ACTION_UPDATE_MISSING_METHODS'))
+  })
+  test('validateApiModel - success aggregates without issues', ({ assert }) => {
+    const domain = new DataDomain({ info: { version: '1.0.0' } })
+    const modelNode = domain.addModel({ key: 'users' })
+    const userEntity = domain.addEntity(modelNode.key, { info: { name: 'User' } })
+    userEntity.addProperty({ key: 'pass', semantics: [{ id: SemanticType.Password }] })
+    userEntity.addProperty({ key: 'role', semantics: [{ id: SemanticType.UserRole }] })
+    userEntity.addProperty({ key: 'name', semantics: [{ id: SemanticType.Username }] })
+    const model = new ApiModel(
+      {
+        info: { name: 'Valid API', description: 'A test definition' },
+        authentication: { strategy: 'UsernamePassword', passwordKey: 'pass' } as UsernamePasswordConfiguration,
+        authorization: { strategy: 'RBAC', roleKey: 'role' } as RolesBasedAccessControl,
+        session: {
+          secret: 'super-secret',
+          properties: ['id', 'role'],
+          cookie: {
+            enabled: true,
+            kind: 'cookie',
+            lifetime: '7d',
+            httpOnly: true,
+            secure: true,
+            sameSite: 'none',
+            name: 'as',
+          },
+        },
+        user: { key: userEntity.key, domain: domain.key },
+      },
+      domain
+    )
+    const result = validateApiModel(model)
+    assert.isTrue(result.isValid)
+    assert.isEmpty(result.issues.filter((i) => i.severity === 'error'))
+  })
+
+  test('validateApiModel - fails on multiple errors', ({ assert }) => {
+    const model = new ApiModel({
+      info: { name: '' },
+    })
+    // Now it's missing name, missing domain, missing security context, missing contact.
+    const result = validateApiModel(model)
+    assert.isFalse(result.isValid)
+    assert.isTrue(result.issues.some((i) => i.code === 'API_MISSING_NAME'))
+    assert.isTrue(result.issues.some((i) => i.code === 'API_MISSING_DOMAIN'))
+    assert.isTrue(result.issues.some((i) => i.code === 'API_MISSING_AUTHENTICATION'))
+  })
+})

package/tests/unit/runtime/runners/http_assertion_runner.spec.ts

@@ -4,7 +4,6 @@ import {
   FlowResponseDataEnum,
   FlowSourceEnum,
   EqualAssertion,
-  AmfNamespace as ns,
   ISentRequest,
   IncludesAssertion,
   IResponse,
@@ -30,6 +29,7 @@ import {
 } from '../../../../src/index.js'
 import { HttpAssertionRunner } from '../../../../src/runtime/http-runner/HttpAssertionRunner.js'
 import driveList from '../../../resources/http/drive-list.js'
+import { AmfNamespace as ns } from '@api-client/amf-core'
 
 const request: ISentRequest = Object.freeze({
   startTime: 0,

package/tests/unit/runtime/runners/http_flow_runner.spec.ts

@@ -8,7 +8,6 @@ import {
   SetVariableStep,
   FlowRequestDataEnum,
   InMemoryCookieJar,
-  AmfNamespace as ns,
   IHttpRequest,
   ISentRequest,
   Property,
@@ -24,6 +23,7 @@ import {
 } from '../../../../src/index.js'
 import { clearStore } from '../../../../src/cookies/InMemoryCookieJar.js'
 import { HttpFlowRunner } from '../../../../src/runtime/http-runner/HttpFlowRunner.js'
+import { AmfNamespace as ns } from '@api-client/amf-core'
 
 test.group('Request flows', (group) => {
   let variables: Record<string, string>

package/tests/unit/runtime/runners/project_runner.spec.ts

@@ -15,7 +15,6 @@ import {
   SetVariableStep,
   FlowRequestDataEnum,
   InMemoryCookieJar,
-  AmfNamespace as ns,
   createLogger,
   ProjectRequestRunner,
   Environment,
@@ -23,6 +22,7 @@ import {
   RequestAuthorization,
   IBasicAuthorization,
 } from '../../../../src/index.js'
+import { AmfNamespace as ns } from '@api-client/amf-core'
 
 const logger = createLogger()
 

package/tests/unit/runtime/runners/request_runner.spec.ts

@@ -8,7 +8,6 @@ import {
   SetVariableStep,
   FlowRequestDataEnum,
   InMemoryCookieJar,
-  AmfNamespace as ns,
   createLogger,
   HttpRequestRunner,
   IHttpRequest,
@@ -23,6 +22,7 @@ import {
   SetCookieStep,
   RequestAuthorizationKind,
 } from '../../../../src/index.js'
+import { AmfNamespace as ns } from '@api-client/amf-core'
 
 const logger = createLogger()
 

package/tests/unit/runtime/runners/serial_runner.spec.ts

@@ -20,8 +20,8 @@ import {
   SetVariableStep,
   FlowRequestDataEnum,
   InMemoryCookieJar,
-  AmfNamespace as ns,
 } from '../../../../src/index.js'
+import { AmfNamespace as ns } from '@api-client/amf-core'
 
 test.group('projects requests', (group) => {
   let project: HttpProject

package/tsconfig.browser.json

@@ -30,5 +30,5 @@
     "incremental": true
   },
   "include": ["src/**/*", "test/**/*"],
-  "exclude": ["node_modules", "build", "coverage", ".tmp", ".wireit", "amf-models", "bin", "data", "docs", "scripts"],
+  "exclude": ["node_modules", "build", "coverage", ".tmp", "amf-models", "bin", "data", "docs", "scripts"],
 }

package/tsconfig.node.json

@@ -32,5 +32,5 @@
     "incremental": true
   },
   "include": ["src/**/*", "tests/**/*", "bin/test.ts"],
-  "exclude": ["node_modules", "build", "coverage", ".tmp", ".wireit", "amf-models", "data", "docs", "scripts"],
+  "exclude": ["node_modules", "build", "coverage", ".tmp", "amf-models", "data", "docs", "scripts"],
 }

package/bin/test-web.ts

@@ -1,6 +0,0 @@
-import { startTestRunner } from '@web/test-runner'
-
-await startTestRunner({
-  autoExitProcess: true,
-  readCliArgs: true,
-})