@api-client/core 0.9.22 → 0.9.24

package/src/models/http-flows/steps/data/DeleteVariableStep.ts

@@ -0,0 +1,78 @@
+import { HttpStep, IHttpStep } from "../../HttpStep.js";
+
+export const DeleteVariableStepKind = 'HttpAction#DeleteVariable';
+
+/**
+ * A step that deletes a variable.
+ */
+export interface IDeleteVariableStep extends IHttpStep {
+  kind: typeof DeleteVariableStepKind;
+  /**
+   * The name of the variable to delete
+   */
+  name: string;
+}
+
+
+export class DeleteVariableStep extends HttpStep {
+  override kind = DeleteVariableStepKind;
+
+  /**
+   * The name of the variable to delete
+   */
+  name = '';
+
+  /**
+   * Creates the step from values.
+   * @param name The name of the variable to delete
+   */
+  constructor(name: string);
+
+  /**
+   * Creates the step from serialized schema.
+   * @param init The serialized step values.
+   */
+  constructor(init: IDeleteVariableStep);
+
+  /**
+   * Creates an empty step.
+   */
+  constructor();
+
+  constructor(nameOrInit?: string | IDeleteVariableStep) {
+    super();
+    if (!nameOrInit) {
+      return;
+    }
+    if (typeof nameOrInit === 'object') {
+      const typed = nameOrInit as IDeleteVariableStep;
+      this.new(typed);
+    } else if (typeof nameOrInit === 'string') {
+      this.new({
+        kind: DeleteVariableStepKind,
+        name: nameOrInit,
+        enabled: true,
+      });
+    }
+  }
+
+  override new(init: IDeleteVariableStep): void {
+    super.new(init);
+    this.kind = DeleteVariableStepKind;
+    this.name = init.name;
+  }
+
+  checkValidity(): boolean {
+    const { name } = this;
+    return !!name;
+  }
+
+  override toJSON(): IDeleteVariableStep {
+    const result: IDeleteVariableStep = {
+      ...super.toJSON(),
+      kind: DeleteVariableStepKind,
+      name: this.name,
+    };
+    return result;
+  }
+}

package/src/models/{http-actions → http-flows}/steps/data/SetCookieStep.ts

@@ -97,8 +97,9 @@ export class SetCookieStep extends HttpStep {
   /**
    * Creates the step from values.
    * @param name The name of the variable to set
+   * @param url Optional URL of the cookie to set.
    */
-  constructor(name: string);
+  constructor(name: string, url?: string);
 
   /**
    * Creates the step from serialized schema.
@@ -111,7 +112,7 @@ export class SetCookieStep extends HttpStep {
    */
   constructor();
 
-  constructor(nameOrInit?: string | ISetCookieStepInit) {
+  constructor(nameOrInit?: string | ISetCookieStepInit, url?: string) {
     super();
     if (!nameOrInit) {
       return;
@@ -124,6 +125,7 @@ export class SetCookieStep extends HttpStep {
         kind: SetCookieStepKind,
         name: nameOrInit,
         enabled: true,
+        url,
       });
     }
   }

package/src/proxy/RequestProxy.ts

@@ -3,12 +3,12 @@ import { IRequestAuthorization } from '../models/RequestAuthorization.js';
 import { IRequestConfig } from '../models/RequestConfig.js';
 import Proxy, { IProxyResult } from "./Proxy.js";
 import { HttpCertificate } from '../models/ClientCertificate.js';
-import { IHttpFlow } from '../models/http-actions/HttpFlows.js';
 import { ApiError } from '../runtime/store/Errors.js';
 import { DummyLogger } from '../lib/logging/DummyLogger.js';
 import { HttpRequestRunner } from '../runtime/http-runner/HttpRequestRunner.js';
 import { IRequestLog } from "../models/RequestLog.js";
-import { IHttpAssertion } from '../models/http-actions/HttpAssertion.js';
+import { IHttpFlow } from '../models/http-flows/HttpFlows.js';
+import { IHttpAssertion } from '../models/http-flows/HttpAssertion.js';
 
 export interface IRequestProxyInit {
   kind: typeof HttpRequestKind;

package/src/runtime/http-engine/HttpEngine.ts

@@ -810,7 +810,7 @@ Check your request parameters.`);
         options.pfx = [];
       }
       const struct: tls.PxfObject = {
-        buf: Buffer.from(cert.cert.data as string),
+        buf: Buffer.from(cert.cert.data as ArrayBuffer | Buffer | Uint8Array),
       };
       if (cert.cert.passphrase) {
         struct.passphrase = cert.cert.passphrase;
@@ -835,7 +835,7 @@ Check your request parameters.`);
           options.cert = [];
         }
       }
-      const added = Buffer.from(typed.cert.data as string);
+      const added = Buffer.from(typed.cert.data as ArrayBuffer | Buffer | Uint8Array);
       options.cert.push(added);
       if (typed.certKey) {
         if (!Array.isArray(options.key)) {
@@ -846,7 +846,7 @@ Check your request parameters.`);
           }
         }
         const struct: tls.KeyObject = {
-          pem: Buffer.from(typed.certKey.data as string),
+          pem: Buffer.from(typed.certKey.data as ArrayBuffer | Buffer | Uint8Array),
         };
         if (typed.certKey.passphrase) {
           struct.passphrase = typed.certKey.passphrase;

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

@@ -1,4 +1,4 @@
-import { AssertionEnum } from "../../models/http-actions/HttpAssertion";
+import { AssertionEnum } from "../../models/http-flows/HttpAssertion";
 
 /**
  * Checks if values equal.

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

@@ -1,53 +1,32 @@
-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;
-}
+import { IErrorResponse } from "../../models/ErrorResponse.js";
+import { AssertionResult, IHttpAssertion } from "../../models/http-flows/HttpAssertion.js";
+import { IHttpStep } from "../../models/http-flows/HttpStep.js";
+import { FlowRequestDataEnum, FlowResponseDataEnum, FlowSourceEnum } from "../../models/http-flows/HttpFlows.js";
+import { IReadDataSourceStep, ReadDataSourceStepKind } from "../../models/http-flows/steps/data/ReadDataSourceStep.js";
+import { IReadValueStep, ReadValueStepKind } from "../../models/http-flows/steps/data/ReadValueStep.js";
+import { AsLowerCaseStepKind } from "../../models/http-flows/steps/transformation/AsLowerCaseStep.js";
+import { AsUpperCaseStepKind } from "../../models/http-flows/steps/transformation/AsUpperCaseStep.js";
+import { AsNumberStepKind } from "../../models/http-flows/steps/transformation/AsNumberStep.js";
+import { RoundStepKind } from "../../models/http-flows/steps/transformation/RoundStep.js";
+import { SubstringStepKind } from "../../models/http-flows/steps/transformation/SubstringStep.js";
+import { TrimStepKind } from "../../models/http-flows/steps/transformation/TrimStep.js";
+import { EqualAssertionKind, IEqualAssertion } from "../../models/http-flows/steps/assertion/EqualAssertion.js";
+import { INotEqualAssertion, NotEqualAssertionKind } from "../../models/http-flows/steps/assertion/NotEqualAssertion.js";
+import { AssertionError } from "../../models/http-flows/AssertionError.js";
+import { GreaterThanAssertionKind, IGreaterThanAssertion } from "../../models/http-flows/steps/assertion/GreaterThanAssertion.js";
+import { ILessThanAssertion, LessThanAssertionKind } from "../../models/http-flows/steps/assertion/LessThanAssertion.js";
+import { IIncludesAssertion, IncludesAssertionKind } from "../../models/http-flows/steps/assertion/IncludesAssertion.js";
+import { INotIncludesAssertion, NotIncludesAssertionKind } from "../../models/http-flows/steps/assertion/NotIncludesAssertion.js";
+import { OkAssertionKind } from "../../models/http-flows/steps/assertion/OkAssertion.js";
+import { NotOkAssertionKind } from "../../models/http-flows/steps/assertion/NotOkAssertion.js";
+import { HttpFlows, IStepValue } from './HttpFlows.js';
 
 /**
  * A class that perform assertions that have been defined on an HTTP request.
  */
-export class HttpAssertionRunner {
+export class HttpAssertionRunner extends HttpFlows {
   report: AssertionResult[] = [];
 
   /**
@@ -71,6 +50,10 @@ export class HttpAssertionRunner {
   protected async runAssertion(request: ISentRequest, response: IResponse | IErrorResponse, assertion: IHttpAssertion): Promise<void> {
     const { steps } = assertion;
 
+    if (!Array.isArray(steps) || !steps.length) {
+      return;
+    }
+
     // this keeps a value from the last step to be passed to the next step.
     let lastResult: IStepValue = {
       value: undefined,
@@ -78,7 +61,7 @@ export class HttpAssertionRunner {
     let error: AssertionError | undefined;
     for (const step of steps) {
       try {
-        lastResult = await this.runStep(request, response, step, lastResult);
+        lastResult = await this.runStep(request, step, lastResult, response);
       } catch (e) {
         const typed = e as AssertionError;
         if (typed.name === 'AssertionError') {
@@ -172,369 +155,4 @@ export class HttpAssertionRunner {
     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;
-  }
 }