@api-client/core 0.9.4 → 0.9.5

package/src/runtime/http-runner/ConditionCheck.ts

@@ -1,5 +1,4 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { ActionOperatorEnum } from '../../models/http-actions/HttpActions.js';
+import { AssertionEnum } from "../../models/http-actions/HttpAssertion";
 
 /**
  * Checks if values equal.
@@ -7,7 +6,7 @@ import { ActionOperatorEnum } from '../../models/http-actions/HttpActions.js';
  * @param condition Comparator value
  * @returns True if objects matches.
  */
-export function isEqual(value: any, condition: any): boolean {
+export function isEqual(value: unknown, condition: unknown): boolean {
   if (value === condition || String(value) === String(condition)) {
     return true;
   }
@@ -34,7 +33,7 @@ export function isEqual(value: any, condition: any): boolean {
  * @param condition Comparator value
  * @return False if objects matches.
  */
-export function isNotEqual(value: any, condition: any): boolean {
+export function isNotEqual(value: unknown, condition: unknown): boolean {
   return !isEqual(value, condition);
 }
 
@@ -45,7 +44,7 @@ export function isNotEqual(value: any, condition: any): boolean {
  * @param condition Comparator value
  * @returns True if value is less than condition.
  */
-export function isLessThan(value: any, condition: any): boolean {
+export function isLessThan(value: unknown, condition: unknown): boolean {
   const valueNumber = Number(value);
   if (Number.isNaN(valueNumber)) {
     return false;
@@ -64,7 +63,7 @@ export function isLessThan(value: any, condition: any): boolean {
  * @param condition Comparator value
  * @returns True if value is less than or equal to `condition`.
  */
-export function isLessThanEqual(value: any, condition: any): boolean {
+export function isLessThanEqual(value: unknown, condition: unknown): boolean {
   const valueNumber = Number(value);
   if (Number.isNaN(valueNumber)) {
     return false;
@@ -83,7 +82,7 @@ export function isLessThanEqual(value: any, condition: any): boolean {
  * @param condition Comparator value
  * @returns True if value is greater than `condition`.
  */
-export function isGreaterThan(value: any, condition: any): boolean {
+export function isGreaterThan(value: unknown, condition: unknown): boolean {
   const valueNumber = Number(value);
   if (Number.isNaN(valueNumber)) {
     return false;
@@ -102,7 +101,7 @@ export function isGreaterThan(value: any, condition: any): boolean {
  * @param condition Comparator value
  * @returns True if value is greater than or equal to `condition`.
  */
-export function isGreaterThanEqual(value: any, condition: any): boolean {
+export function isGreaterThanEqual(value: unknown, condition: unknown): boolean {
   const valueNumber = Number(value);
   if (Number.isNaN(valueNumber)) {
     return false;
@@ -122,12 +121,12 @@ export function isGreaterThanEqual(value: any, condition: any): boolean {
  * @param condition Comparator value
  * @returns True if value contains the `condition`.
  */
-export function contains(value: any, condition: any): boolean {
+export function contains(value: unknown, condition: unknown): boolean {
   if (!value) {
     return false;
   }
   if (typeof value === 'string') {
-    return value.indexOf(condition) !== -1;
+    return value.indexOf(condition as string) !== -1;
   }
   if (Array.isArray(value)) {
     if (!Number.isNaN(condition) && typeof condition !== 'number') {
@@ -141,7 +140,7 @@ export function contains(value: any, condition: any): boolean {
   if (typeof value !== 'object') {
     return false;
   }
-  return condition in value;
+  return (condition as string) in value;
 }
 
 /**
@@ -151,10 +150,10 @@ export function contains(value: any, condition: any): boolean {
  * @param condition Comparator value - regex string.
  * @returns Value of calling `test()` function on string.
  */
-export function isRegex(value: any, condition: any): boolean {
+export function isRegex(value: unknown, condition: unknown): boolean {
   let re;
   try {
-    re = new RegExp(condition, 'm');
+    re = new RegExp(condition as string, 'm');
   } catch (e) {
     return false;
   }
@@ -170,7 +169,7 @@ export function isRegex(value: any, condition: any): boolean {
  * @param condition Value to compare.
  * @returns True if the condition is satisfied and false otherwise.
  */
-export function checkCondition(value: any, operator: ActionOperatorEnum, condition: string | undefined): boolean {
+export function checkCondition(value: unknown, operator: AssertionEnum, condition: string | undefined): boolean {
   switch (operator) {
     case 'equal':
       return isEqual(value, condition);

package/src/runtime/http-runner/HttpAssertionRunner.ts

@@ -0,0 +1,540 @@
+import { assert } from '@esm-bundle/chai';
+import { HttpRequest } from "../../models/HttpRequest.js";
+import { ISentRequest } from "../../models/SentRequest.js";
+import { IResponse } from "../../models/Response.js";
+import { ErrorResponse, IErrorResponse } from "../../models/ErrorResponse.js";
+import { AssertionResult, IHttpAssertion } from "../../models/http-actions/HttpAssertion.js";
+import { IHttpStep } from "../../models/http-actions/HttpStep.js";
+import { FlowValue } from "./HttpFlowRunner.js";
+import { FlowRequestDataEnum, FlowResponseDataEnum, FlowSourceEnum } from "../../models/http-actions/HttpFlows.js";
+import { IReadDataSourceStep, ReadDataSourceStep, ReadDataSourceStepKind } from "../../models/http-actions/steps/data/ReadDataSourceStep.js";
+import { IReadValueStep, ReadValueStep, ReadValueStepKind } from "../../models/http-actions/steps/data/ReadValueStep.js";
+import * as DataUtils from '../../data/DataUtils.js';
+import { HttpResponse } from "../../models/HttpResponse.js";
+import { Headers } from '../../lib/headers/Headers.js';
+import { DataReader } from "../../data/DataReader.js";
+import { JmespathReader } from "../../data/JmespathReader.js";
+import { XmlReader } from "../../data/XmlReader.js";
+import { UrlEncodedReader } from "../../data/UrlEncodedReader.js";
+import { AsLowerCaseStepKind } from "../../models/http-actions/steps/transformation/AsLowerCaseStep.js";
+import { AsUpperCaseStepKind } from "../../models/http-actions/steps/transformation/AsUpperCaseStep.js";
+import { AsNumberStepKind } from "../../models/http-actions/steps/transformation/AsNumberStep.js";
+import { IRoundStep, RoundStepKind } from "../../models/http-actions/steps/transformation/RoundStep.js";
+import { ISubstringStep, SubstringStepKind } from "../../models/http-actions/steps/transformation/SubstringStep.js";
+import { TrimStepKind } from "../../models/http-actions/steps/transformation/TrimStep.js";
+import { EqualAssertionKind, IEqualAssertion } from "../../models/http-actions/steps/assertion/EqualAssertion.js";
+import { INotEqualAssertion, NotEqualAssertionKind } from "../../models/http-actions/steps/assertion/NotEqualAssertion.js";
+import { ApiSchemaValues } from "../../amf/ApiSchemaValues.js";
+import { AssertionError } from "../../models/http-actions/AssertionError.js";
+import { GreaterThanAssertionKind, IGreaterThanAssertion } from "../../models/http-actions/steps/assertion/GreaterThanAssertion.js";
+import { ILessThanAssertion, LessThanAssertionKind } from "../../models/http-actions/steps/assertion/LessThanAssertion.js";
+import { IIncludesAssertion, IncludesAssertionKind } from "../../models/http-actions/steps/assertion/IncludesAssertion.js";
+import { INotIncludesAssertion, NotIncludesAssertionKind } from "../../models/http-actions/steps/assertion/NotIncludesAssertion.js";
+import { OkAssertionKind } from "../../models/http-actions/steps/assertion/OkAssertion.js";
+import { NotOkAssertionKind } from "../../models/http-actions/steps/assertion/NotOkAssertion.js";
+import { IToBeAssertion, ToBeAssertionKind, ToBeTypes } from '../../models/http-actions/steps/assertion/ToBeAssertion.js';
+import { INotToBeAssertion, NotToBeAssertionKind } from '../../models/http-actions/steps/assertion/NotToBeAssertion.js';
+import { IsEmptyAssertionKind } from '../../models/http-actions/steps/assertion/IsEmptyAssertion.js';
+import { IsNotEmptyAssertionKind } from '../../models/http-actions/steps/assertion/IsNotEmptyAssertion.js';
+import { ILengthOfAssertion, LengthOfAssertionKind } from '../../models/http-actions/steps/assertion/LengthOfAssertion.js';
+
+interface IStepValue {
+  value: FlowValue;
+  type?: FlowRequestDataEnum | FlowResponseDataEnum;
+  bodyMime?: string;
+}
+
+/**
+ * A class that perform assertions that have been defined on an HTTP request.
+ */
+export class HttpAssertionRunner {
+  report: AssertionResult[] = [];
+
+  /**
+   * 
+   * @param request The request object sent to the server
+   * @param response The generated response
+   * @param assertions The list of assertions to perform.
+   */
+  async run(request: ISentRequest, response: IResponse | IErrorResponse, assertions: IHttpAssertion[]): Promise<AssertionResult[]> {
+    this.report = [];
+    if (!assertions || !assertions.length) {
+      return [...this.report];
+    }
+
+    for (const assertion of assertions) {
+      await this.runAssertion(request, response, assertion);
+    }
+    return [...this.report];
+  }
+
+  protected async runAssertion(request: ISentRequest, response: IResponse | IErrorResponse, assertion: IHttpAssertion): Promise<void> {
+    const { steps } = assertion;
+
+    // this keeps a value from the last step to be passed to the next step.
+    let lastResult: IStepValue = {
+      value: undefined,
+    };
+    let error: AssertionError | undefined;
+    for (const step of steps) {
+      try {
+        lastResult = await this.runStep(request, response, step, lastResult);
+      } catch (e) {
+        const typed = e as AssertionError;
+        if (typed.name === 'AssertionError') {
+          error = typed;
+        } else {
+          const err = e as Error;
+          error = new AssertionError({
+            message: err.message,
+          });
+        }
+        break;
+      }
+    }
+    const description = assertion.description || this.createDescription(steps);
+    if (error) {
+      this.report.push({
+        ok: false,
+        description,
+        error: error.toJSON(),
+      });
+    } else {
+      this.report.push({
+        ok: true,
+        description,
+      });
+    }
+  }
+
+  protected createDescription(steps: IHttpStep[]): string {
+    const parts: string[] = [];
+    for (const step of steps) {
+      switch (step.kind) {
+        case ReadDataSourceStepKind: parts.push(this.getDataSourceStepLabel(step as IReadDataSourceStep)); break;
+        case ReadValueStepKind: parts.push(this.getValueStepLabel(step as IReadValueStep)); break;
+        case AsLowerCaseStepKind: parts.push('To lower case'); break;
+        case AsUpperCaseStepKind: parts.push('To upper case'); break;
+        case AsNumberStepKind: parts.push('As number'); break;
+        case RoundStepKind: parts.push('Round'); break;
+        case TrimStepKind: parts.push('Trim'); break;
+        case SubstringStepKind: parts.push('Substring'); break;
+        case EqualAssertionKind: parts.push(`Equals to ${(step as IEqualAssertion).value}`); break;
+        case NotEqualAssertionKind: parts.push(`Not equals to ${(step as INotEqualAssertion).value}`); break;
+        case GreaterThanAssertionKind: parts.push(`Is greater than ${(step as IGreaterThanAssertion).value}`); break;
+        case LessThanAssertionKind: parts.push(`Is less than ${(step as ILessThanAssertion).value}`); break;
+        case IncludesAssertionKind: parts.push(`Includes ${(step as IIncludesAssertion).value}`); break;
+        case NotIncludesAssertionKind: parts.push(`Not includes ${(step as INotIncludesAssertion).value}`); break;
+        case OkAssertionKind: parts.push(`Is OK`); break;
+        case NotOkAssertionKind: parts.push(`Is not OK`); break;
+        default: 
+      }
+    }
+    return parts.filter(i => !!i).join(' > ');
+  }
+
+  protected getDataSourceStepLabel(step: IReadDataSourceStep): string {
+    if (step.source === FlowSourceEnum.request) {
+      if (step.data === FlowRequestDataEnum.url) {
+        return 'Request URL';
+      }
+      if (step.data === FlowRequestDataEnum.headers) {
+        return 'Request headers';
+      }
+      if (step.data === FlowRequestDataEnum.method) {
+        return 'HTTP method';
+      }
+      if (step.data === FlowRequestDataEnum.body) {
+        return 'Request body';
+      }
+    }
+    if (step.source === FlowSourceEnum.response) {
+      if (step.data === FlowResponseDataEnum.url) {
+        return 'Response URL';
+      }
+      if (step.data === FlowResponseDataEnum.headers) {
+        return 'Response headers';
+      }
+      if (step.data === FlowResponseDataEnum.body) {
+        return 'Response body';
+      }
+      if (step.data === FlowResponseDataEnum.status) {
+        return 'Status code';
+      }
+      if (step.data === FlowResponseDataEnum.statusText) {
+        return 'Status message';
+      }
+    }
+    return 'Invalid step';
+  }
+
+  protected getValueStepLabel(step: IReadValueStep): string {
+    const { path } = step;
+    return path || '';
+  }
+
+  protected async runStep(request: ISentRequest, response: IResponse | IErrorResponse, step: IHttpStep, input: IStepValue): Promise<IStepValue> {
+    switch (step.kind) {
+      // data reading
+      case ReadDataSourceStepKind: return this.readDataSource(request, response, step);
+      case ReadValueStepKind: return this.readValue(input, step as IReadValueStep);
+      // transformations
+      case AsLowerCaseStepKind: return this.toLowerCase(input);
+      case AsUpperCaseStepKind: return this.toUpperCase(input);
+      case AsNumberStepKind: return this.asNumber(input);
+      case RoundStepKind: return this.round(input, step as IRoundStep);
+      case TrimStepKind: return this.trim(input);
+      case SubstringStepKind: return this.substring(input, step as ISubstringStep);
+      // assertions
+      case EqualAssertionKind: return this.assertEqual(input, step as IEqualAssertion);
+      case NotEqualAssertionKind: return this.assertNotEqual(input, step as INotEqualAssertion);
+      case GreaterThanAssertionKind: return this.assertGreaterThan(input, step as IGreaterThanAssertion);
+      case LessThanAssertionKind: return this.assertLessThan(input, step as ILessThanAssertion);
+      case IncludesAssertionKind: return this.assertIncludes(input, step as IIncludesAssertion);
+      case NotIncludesAssertionKind: return this.assertNotIncludes(input, step as INotIncludesAssertion);
+      case OkAssertionKind: return this.assertOk(input);
+      case NotOkAssertionKind: return this.assertNotOk(input);
+      case ToBeAssertionKind: return this.toBe(input, step as IToBeAssertion);
+      case NotToBeAssertionKind: return this.notToBe(input, step as INotToBeAssertion);
+      case IsEmptyAssertionKind: return this.isEmpty(input);
+      case IsNotEmptyAssertionKind: return this.isNotEmpty(input);
+      case LengthOfAssertionKind: return this.lengthOf(input, step as ILengthOfAssertion);
+      default: return { value: undefined };
+    }
+  }
+
+  /**
+   * Produces the data source.
+   */
+  protected async readDataSource(request: ISentRequest, response: IResponse | IErrorResponse, step: IReadDataSourceStep): Promise<IStepValue> {
+    const instance = new ReadDataSourceStep(step);
+    if (instance.enabled === false || !instance.checkValidity()) {
+      return { value: undefined };
+    }
+    const { source, data } = step;
+    if (source === FlowSourceEnum.request) {
+      if (data === FlowRequestDataEnum.url) {
+        return {
+          value: request.url,
+          type: data,
+        };
+      }
+      if (data === FlowRequestDataEnum.headers) {
+        return {
+          value: request.headers,
+          type: data,
+        };
+      }
+      if (data === FlowRequestDataEnum.method) {
+        return {
+          value: request.method,
+          type: data,
+        };
+      }
+      if (data === FlowRequestDataEnum.body) {
+        const instance = new HttpRequest(request);
+        const value = await this.processBody(instance);
+        return {
+          ...value,
+          type: data,
+        };
+      }
+    } 
+    if (source === FlowSourceEnum.response) {
+      if (data === FlowResponseDataEnum.url) {
+        return {
+          value: request.url,
+          type: data,
+        };
+      }
+      if (data === FlowResponseDataEnum.headers) {
+        return {
+          value: response.headers,
+          type: data,
+        };
+      }
+      if (data === FlowResponseDataEnum.status) {
+        return {
+          value: response.status,
+          type: data,
+        };
+      }
+      if (data === FlowResponseDataEnum.statusText) {
+        return {
+          value: response.statusText,
+          type: data,
+        };
+      }
+      if (data === FlowResponseDataEnum.body) {
+        let instance: ErrorResponse | HttpResponse;
+        if (ErrorResponse.isErrorResponse(response)) {
+          instance = new ErrorResponse(response as IErrorResponse);
+        } else {
+          instance = new HttpResponse(response);
+        }
+        const value = await this.processBody(instance);
+        return {
+          ...value,
+          type: data,
+        };
+      }
+    }
+    return { value: undefined };
+  }
+
+  protected async processBody(input: HttpRequest | HttpResponse | ErrorResponse): Promise<IStepValue> {
+    const { headers } = input;
+    if (!headers) {
+      return { value: undefined };
+    }
+    const body = await input.readPayloadAsString();
+    if (!body) {
+      return { value: undefined };
+    }
+
+    const parser = new Headers(headers);
+    const mime = parser.get('content-type');
+    if (!mime) {
+      return { value: undefined };
+    }
+    return {
+      value: body,
+      bodyMime: mime,
+    }
+  }
+
+  /**
+   * Produces the value from the current input.
+   */
+  protected async readValue(input: IStepValue, step: IReadValueStep): Promise<IStepValue> {
+    const instance = new ReadValueStep(step);
+    if (instance.enabled === false || !instance.checkValidity() || input.value === undefined || input.value === null) {
+      return { value: undefined };
+    }
+    
+    const { path } = step;
+    const { type, value } = input;
+    const args = path ? path.split('.') : [];
+    if (type === FlowRequestDataEnum.url || type === FlowResponseDataEnum.url) {
+      if (!value) {
+        return { value: undefined };
+      }
+      const v = String(input.value);
+      return {
+        value: DataUtils.getDataUrl(v, args),
+      };
+    }
+    if (type === FlowRequestDataEnum.headers || type === FlowResponseDataEnum.headers) {
+      if (!value) {
+        return { value: undefined };
+      }
+      const v = String(input.value);
+      return {
+        value: DataUtils.getDataHeaders(v, args),
+      }
+    }
+    if (type === FlowRequestDataEnum.body || type === FlowResponseDataEnum.body) {
+      if (!input.bodyMime || !path) {
+        return { value: undefined };
+      }
+      let reader: DataReader | undefined;
+      if (input.bodyMime.includes('json')) {
+        reader = new JmespathReader();
+      } else if (input.bodyMime.includes('xml')) {
+        reader = new XmlReader();
+      } else if (input.bodyMime.includes('x-www-form-urlencoded')) {
+        reader = new UrlEncodedReader();
+      }
+      if (!reader) {
+        return { value: undefined };
+      }
+      await reader.writePayload(String(value));
+      const readValue = await reader.getValue(path);
+      return {
+        value: readValue,
+      }
+    }
+    if (type === FlowResponseDataEnum.status) {
+      const v = Number(input.value);
+      if (Number.isNaN(v)) {
+        return { value: undefined };
+      }
+      return {
+        value: v,
+      }
+    }
+
+    if (type === FlowResponseDataEnum.statusText) {
+      if (!value) {
+        return { value: undefined };
+      }
+      return {
+        value,
+      }
+    }
+    return { value: undefined };
+  }
+
+  protected async toLowerCase(input: IStepValue): Promise<IStepValue> {
+    if (input.value === null || input.value === undefined) {
+      return { value: undefined };
+    }
+    const value = String(input.value);
+    return { value: value.toLowerCase() };
+  }
+
+  protected async toUpperCase(input: IStepValue): Promise<IStepValue> {
+    if (input.value === null || input.value === undefined) {
+      return { value: undefined };
+    }
+    const value = String(input.value);
+    return { value: value.toUpperCase() };
+  }
+
+  protected async asNumber(input: IStepValue): Promise<IStepValue> {
+    if (input.value === null || input.value === undefined) {
+      return { value: undefined };
+    }
+    const value = String(input.value);
+    const parsed = Number(value);
+    if (Number.isNaN(parsed)) {
+      return { value: undefined };
+    }
+    return { value: parsed };
+  }
+
+  protected async round(input: IStepValue, step: IRoundStep): Promise<IStepValue> {
+    if (input.value === null || input.value === undefined) {
+      return { value: undefined };
+    }
+    const value = String(input.value);
+    const parsed = typeof input.value === 'number' ? input.value : Number(value);
+    if (Number.isNaN(parsed)) {
+      return { value: undefined };
+    }
+    return { value: parsed.toFixed(step.precision) };
+  }
+
+  protected async trim(input: IStepValue): Promise<IStepValue> {
+    if (input.value === null || input.value === undefined) {
+      return { value: undefined };
+    }
+    const value = String(input.value);
+    return { ...input, value: value.trim() };
+  }
+
+  protected async substring(input: IStepValue, step: ISubstringStep): Promise<IStepValue> {
+    if (input.value === null || input.value === undefined) {
+      return { value: undefined };
+    }
+    if (typeof step.start !== 'number') {
+      return input;
+    }
+    const value = String(input.value);
+    return { ...input, value: value.substring(step.start, step.end) };
+  }
+
+  protected async assertEqual(input: IStepValue, step: IEqualAssertion): Promise<IStepValue> {
+    const { value } = input;
+    if (step.strict) {
+      const comparator = ApiSchemaValues.readTypedValue(step.value, step.dataType);
+      assert.strictEqual(value, comparator);
+    } else {
+      assert.equal(String(value), step.value);
+    }
+    return input;
+  }
+
+  protected async assertNotEqual(input: IStepValue, step: INotEqualAssertion): Promise<IStepValue> {
+    const { value } = input;
+    if (step.strict) {
+      const comparator = ApiSchemaValues.readTypedValue(step.value, step.dataType);
+      assert.notStrictEqual(value, comparator);
+    } else {
+      assert.notEqual(value, step.value);
+    }
+    return input;
+  }
+
+  protected async assertGreaterThan(input: IStepValue, step: IGreaterThanAssertion): Promise<IStepValue> {
+    assert.typeOf(input.value, 'number');
+    const value = input.value as number;
+    if (step.equal) {
+      assert.isAtLeast(value as number, step.value as number);
+    } else {
+      assert.isAbove(value as number, step.value as number);
+    }
+    return input;
+  }
+
+  protected async assertLessThan(input: IStepValue, step: ILessThanAssertion): Promise<IStepValue> {
+    assert.typeOf(input.value, 'number');
+    const value = input.value as number;
+    if (step.equal) {
+      assert.isAtMost(value, step.value as number);
+    } else {
+      assert.isBelow(value, step.value as number);
+    }
+    return input;
+  }
+
+  protected async assertIncludes(input: IStepValue, step: IIncludesAssertion): Promise<IStepValue> {
+    if (this.isPrimitive(input.value)) {
+      assert.include(String(input.value), String(step.value));
+    } else {
+      assert.include(JSON.stringify(input.value), String(step.value));
+    }
+    return input;
+  }
+
+  protected async assertNotIncludes(input: IStepValue, step: INotIncludesAssertion): Promise<IStepValue> {
+    if (this.isPrimitive(input.value)) {
+      assert.notInclude(String(input.value), String(step.value));
+    } else {
+      assert.notInclude(JSON.stringify(input.value), String(step.value));
+    }
+    return input;
+  }
+
+  protected async assertOk(input: IStepValue): Promise<IStepValue> {
+    assert.ok(input.value);
+    return input;
+  }
+
+  protected async assertNotOk(input: IStepValue): Promise<IStepValue> {
+    assert.notOk(input.value);
+    return input;
+  }
+
+  protected async toBe(input: IStepValue, step: IToBeAssertion): Promise<IStepValue> {
+    assert.typeOf(input.value, step.value as string);
+    return input;
+  }
+
+  protected async notToBe(input: IStepValue, step: INotToBeAssertion): Promise<IStepValue> {
+    if (Array.isArray(input.value) && step.value === ToBeTypes.object) {
+      assert(false, 'expected [Array] to be an object');
+    }
+    assert.notTypeOf(input.value, step.value as string);
+    return input;
+  }
+
+  protected async isEmpty(input: IStepValue): Promise<IStepValue> {
+    assert.isEmpty(input.value);
+    return input;
+  }
+
+  protected async isNotEmpty(input: IStepValue): Promise<IStepValue> {
+    assert.isNotEmpty(input.value);
+    return input;
+  }
+
+  protected async lengthOf(input: IStepValue, step: ILengthOfAssertion): Promise<IStepValue> {
+    assert.lengthOf(input.value as unknown[], step.value as number);
+    return input;
+  }
+
+  protected isPrimitive(value: unknown): boolean {
+    return (typeof value !== 'object' && typeof value !== 'function') || value === null;
+  }
+}