@api-client/core 0.9.4 → 0.9.6

package/src/models/Request.ts

@@ -13,7 +13,8 @@ import { ARCSavedRequest, ARCHistoryRequest } from './legacy/request/ArcRequest.
 import { ErrorResponse as LegacyErrorResponse, Response as LegacyResponse } from './legacy/request/ArcResponse.js';
 import { PayloadSerializer } from '../lib/transformers/PayloadSerializer.js';
 import { Normalizer } from './legacy/Normalizer.js';
-import { IHttpActionFlow } from './http-actions/HttpActions.js';
+import { IHttpFlow } from './http-actions/HttpFlows.js';
+import { IHttpAssertion } from './http-actions/HttpAssertion.js';
 import { LegacyTranslator } from './http-actions/LegacyTranslator.js';
 
 export const Kind = 'Core#Request';
@@ -63,7 +64,7 @@ export interface IRequest {
    * Http action flows.
    * In ARC this was "actions",
    */
-  flows?: IHttpActionFlow[];
+  flows?: IHttpFlow[];
   /**
    * The certificate to use with the request.
    * Note, the certificate defined on the certificate authorization 
@@ -71,6 +72,11 @@ export interface IRequest {
    * this certificate and update the configuration.
    */
   clientCertificate?: HttpCertificate;
+
+  /**
+   * The list of assertions (tests) to perform after the response is ready.
+   */
+  assertions?: IHttpAssertion[];
 }
 
 export class Request {
@@ -102,7 +108,7 @@ export class Request {
    * Http action flows.
    * In ARC this was "actions",
    */
-  flows?: IHttpActionFlow[];
+  flows?: IHttpFlow[];
   /**
    * The certificate to use with the request.
    * Note, the certificate defined on the certificate authorization 
@@ -111,6 +117,11 @@ export class Request {
    */
   clientCertificate?: Certificate;
 
+  /**
+   * The list of assertions (tests) to perform after the response is ready.
+   */
+  assertions?: IHttpAssertion[];
+
   /**
    * Creates a request from an URL.
    * 
@@ -340,7 +351,7 @@ export class Request {
   }
 
   new(init: IRequest): void {
-    const { expects, log, updated, created = Date.now(), midnight, config, authorization, flows, clientCertificate, info } = init;
+    const { expects, log, updated, created = Date.now(), midnight, config, authorization, flows, clientCertificate, info, assertions } = init;
     if (expects) {
       this.expects = new HttpRequest(expects);
     } else {
@@ -383,6 +394,11 @@ export class Request {
     } else {
       this.flows = undefined;
     }
+    if (Array.isArray(assertions)) {
+      this.assertions = assertions.map(i => JsonCore.clone(i));
+    } else {
+      this.assertions = undefined;
+    }
     if (clientCertificate) {
       this.clientCertificate = new Certificate(clientCertificate);
     } else {
@@ -411,6 +427,9 @@ export class Request {
     if (Array.isArray(this.flows)) {
       result.flows = this.flows.map(i => JsonCore.clone(i))
     }
+    if (Array.isArray(this.assertions)) {
+      result.assertions = this.assertions.map(i => JsonCore.clone(i))
+    }
     if (this.clientCertificate) {
       result.clientCertificate = this.clientCertificate.toJSON();
     }

package/src/models/RequestAuthorization.ts

@@ -64,7 +64,7 @@ export class RequestAuthorization {
     }
     return new RequestAuthorization({
       kind: Kind,
-      config: (info.config as any),
+      config: info.config as IAuthorizationSettingsUnion,
       enabled: true,
       type: info.type as AuthorizationType,
       valid: info.valid,

package/src/models/RequestLog.ts

@@ -4,6 +4,7 @@ import { IErrorResponse, ErrorResponse } from './ErrorResponse.js';
 import { IResponse, Response } from './Response.js';
 import { IRequestsSize, RequestsSize } from './RequestsSize.js';
 import { ResponseRedirect as LegacyRedirect } from './legacy/request/ArcResponse.js';
+import { AssertionResult } from './http-actions/HttpAssertion.js';
 
 export const Kind = 'Core#ResponseLog';
 
@@ -32,6 +33,11 @@ export interface IRequestLog {
    * Optional request ID defined on an HTTP project that triggered this log.
    */
   requestId?: string;
+  /**
+   * The assertions result performed on the response.
+   * Note, Error response can also be passed through tests.
+   */
+  assertions?: AssertionResult[];
 }
 
 /**
@@ -60,6 +66,12 @@ export class RequestLog {
    */
   requestId?: string;
 
+  /**
+   * The assertions result performed on the response.
+   * Note, Error response can also be passed through tests.
+   */
+  assertions?: AssertionResult[];
+
   static fromRequest(request: ISentRequest): RequestLog {
     return new RequestLog({
       kind: Kind,
@@ -96,7 +108,7 @@ export class RequestLog {
    * Creates a new response clearing anything that is so far defined.
    */
   new(init: IRequestLog): void {
-    const { request, response, redirects, size, requestId } = init;
+    const { request, response, redirects, size, requestId, assertions } = init;
     this.kind = Kind;
     if (request) {
       this.request = new SentRequest(request);
@@ -125,6 +137,11 @@ export class RequestLog {
     } else {
       this.requestId = undefined;
     }
+    if (Array.isArray(assertions) && assertions.length) {
+      this.assertions = assertions.map(i => ({ ...i }));
+    } else {
+      this.assertions = undefined;
+    }
   }
 
   toJSON(): IRequestLog {
@@ -146,6 +163,9 @@ export class RequestLog {
     if (this.requestId) {
       result.requestId = this.requestId;
     }
+    if (Array.isArray(this.assertions) && this.assertions.length) {
+      result.assertions = this.assertions.map(i => ({ ...i }));
+    }
     return result;
   }
 

package/src/models/SerializablePayload.ts

@@ -14,7 +14,7 @@ export interface SerializablePayloadOptions {
   mime?: string;
 }
 
-export class SerializablePayload {
+export interface ISerializablePayload {
   /**
    * The serialized payload message.
    */
@@ -24,6 +24,12 @@ export class SerializablePayload {
    * Optional meta of the payload
    */
   payloadOptions?: SerializablePayloadOptions;
+}
+
+export class SerializablePayload implements ISerializablePayload {
+  payload?: Payload;
+
+  payloadOptions?: SerializablePayloadOptions;
 
   /**
    * The payload in its original format.
@@ -90,4 +96,15 @@ export class SerializablePayload {
     const decoder = new TextDecoder();
     return decoder.decode(dataView);
   }
+
+  toJSON(): ISerializablePayload {
+    const result: ISerializablePayload = {};
+    if (this.payload) {
+      result.payload = this.payload;
+    }
+    if (this.payloadOptions) {
+      result.payloadOptions = { ...this.payloadOptions };
+    }
+    return result;
+  }
 }

package/src/models/http-actions/AssertionError.ts

@@ -0,0 +1,57 @@
+export interface IAssertionError {
+  /**
+   * Set with assertions to show the actual value at the time of testing.
+   */
+  actual?: unknown;
+  /**
+   * Set with assertions to show the expected value at the time of testing.
+   */
+  expected?: unknown;
+  /**
+   * The operator used to make the assertion.
+   */
+  operator?: string;
+  /**
+   * The error message, if any.
+   * Assertions usually don't set error messages. Instead they set other fields.
+   */
+  message?: string;
+}
+
+export class AssertionError extends Error {
+  /**
+   * Set with assertions to show the actual value at the time of testing.
+   */
+  actual: unknown;
+  /**
+   * Set with assertions to show the expected value at the time of testing.
+   */
+  expected: unknown;
+  /**
+   * The operator used to make the assertion.
+   */
+  operator: string;
+
+  code = 'ERR_ASSERTION';
+
+  constructor(options: IAssertionError = {}) {
+    super(options.message || 'Unspecified AssertionError');
+    this.name = 'AssertionError';
+    this.actual = options.actual;
+    this.expected = options.expected;
+    this.operator = options.operator || '[unknown]';
+  }
+
+  toJSON(): IAssertionError {
+    const result: IAssertionError = {};
+    if (this.message) {
+      result.message = this.message;
+    }
+    result.actual = this.actual;
+    result.expected = this.expected;
+    if (this.operator) {
+      result.operator = this.operator;
+    }
+    return result;
+  }
+}

package/src/models/http-actions/HttpAssertion.ts

@@ -0,0 +1,89 @@
+import { IAssertionError } from "./AssertionError.js";
+import { IHttpStep } from "./HttpStep.js";
+
+export enum AssertionEnum {
+  equal = "equal",
+  notEqual = "not-equal",
+  greaterThan = "greater-than",
+  greaterThanEqual = "greater-than-equal",
+  lessThan = "less-than",
+  lessThanEqual = "less-than-equal",
+  contains = "contains",
+  regex = "regex",
+  ok = 'ok',
+  notOk = 'notOk',
+  toBe = 'toBe',
+  notToBe = 'notToBe',
+}
+
+export enum TransformationEnum {
+  /**
+   * Transformation of the data that reads a value from the given path.
+   * For example, for a body it can be xpath for XML or JSON path for JSON data.
+   */
+  readValue = 'readValue',
+  /**
+   * Transforms the value from the previous step to a number.
+   */
+  asNumber = 'asNumber',
+  /**
+   * Rounds the input value to a nearest numeric value.
+   * If the value is not a number it tries to convert it to a number. When it 
+   * can't ba casted to a number then the transformation throws an error.
+   */
+  round = 'round',
+  /**
+   * Transforms the value to a lowercase value.
+   */
+  toLowerCase = 'toLowerCase',
+  /**
+   * Transforms the value to a uppercase value.
+   */
+  toUpperCase = 'toUpperCase',
+  /**
+   * Trims the string value.
+   */
+  trim = 'trim',
+  /**
+   * Transforms the part of the string from the start index up to and excluding the end index, or to the end of the string if no end index is supplied.
+   * 
+   * `substring(indexStart, indexEnd)`
+   */
+  substring = 'substring',
+}
+
+export interface IHttpAssertion {
+  /**
+   * The description of the assertion reported to the UI.
+   */
+  description?: string;
+
+  /**
+   * The list of steps to perform. This is an ordered list of action tasks.
+   * Each step is described by the `kind` property which tells the runner what action to perform.
+   */
+  steps: IHttpStep[];
+  /**
+   * Whether the assertions is enabled. By default it is enabled. It is only not enabled when this is set to false.
+   */
+  enabled?: boolean;
+}
+
+/**
+ * An object representing a result of running a single assertion.
+ */
+export interface AssertionResult {
+  /**
+   * Indicates whether assertion result is positive (not failed) or negative (failed).
+   */
+  ok: boolean;
+  /**
+   * The description of the association.
+   */
+  description: string;
+  /**
+   * This is always set when `ok` is false.
+   * This is also never set when `ok` is true.
+   */
+  error?: IAssertionError;
+}

package/src/models/http-actions/HttpFlows.ts

@@ -0,0 +1,115 @@
+import { AssertionEnum } from './HttpAssertion.js';
+import { IHttpStep } from './HttpStep.js';
+
+export enum FlowSourceEnum {
+  /**
+   * The request object.
+   */
+  request = 'request',
+  /**
+   * The response object.
+   */
+  response = 'response',
+  /**
+   * A variable from the current environment.
+   */
+  variable = 'variable',
+}
+
+export enum FlowRequestDataEnum {
+  url = "url",
+  method = "method",
+  headers = "headers",
+  body = "body"
+}
+
+export enum FlowResponseDataEnum {
+  url = "url",
+  status = "status",
+  statusText = "statusText",
+  headers = "headers",
+  body = "body"
+}
+
+/**
+ * A flow represents a series of actions to be performed one-by-one after the HTTP request is sent or when the response 
+ * is ready.
+ */
+export interface IHttpFlow {
+  /**
+   * The description of the flow
+   */
+  description?: string;
+  /**
+   * Describes when the flow is executed.
+   * The `request` means the flow is executed before the request is sent to the HTTP engine.
+   * The `response` means the flow is executed after the response has been received in full, but before reporting 
+   * the response to the UI.
+   */
+  trigger: 'request' | 'response';
+  /**
+   * The ordered list of actions to execute.
+   */
+  actions: IHttpAction[];
+}
+
+/**
+ * Describes a single action in a flow.
+ * An action can have a condition that is checked against the current context.
+ * Action is not executed when the condition is not meet.
+ * 
+ * Each action has one or more steps (when 0 items then the action is ignored). Each step performs a task.
+ * The result of a task is passed to the next step as an input. The result of a task may be `void`, `null`, or `undefined` which is treated as `void`.
+ */
+export interface IHttpAction {
+  /**
+   * The description of the action
+   */
+  description?: string;
+  /**
+   * A condition to check before performing the action.
+   */
+  condition?: IHttpCondition;
+  /**
+   * The list of steps to perform. This is an ordered list of action tasks.
+   * Each step is described by the `kind` property which tells the runner what action to perform.
+   */
+  steps: IHttpStep[];
+}
+
+/**
+ * A condition to execute for an action.
+ */
+export interface IHttpCondition {
+  /**
+   * The main data source.
+   * In the legacy actions this was `type`.
+   */
+  source?: FlowSourceEnum;
+  /**
+   * Source of the data.
+   * In the legacy actions this was `source`.
+   * This is not required when the source is not `request` or `response`.
+   */
+  data?: FlowRequestDataEnum | FlowResponseDataEnum;
+  /**
+   * The path to the data.
+   * For JSON value use https://jmespath.org/ syntax.
+   * For XML use xpath.
+   * For any other use a simple path to the data separated by dot (e.g. headers.content-type)
+   */
+  path?: string;
+  /**
+   * The comparison operator.
+   */
+  operator?: AssertionEnum;
+  /**
+   * The value to compare the read result.
+   * In runtime, the type is casted to the same type as read value.
+   * 
+   * When this is not set it compares to an empty string value or `0`.
+   * 
+   * In ARC actions this was the `predictedValue`.
+   */
+  value?: string;
+}

package/src/models/http-actions/HttpStep.ts

@@ -0,0 +1,50 @@
+/**
+ * The action that can be taken on the data.
+ */
+export interface IHttpStep {
+  /**
+   * The kind of the action to perform.
+   */
+  kind: string;
+  /**
+   * Whether the step is disabled in the flow.
+   */
+  enabled?: boolean;
+}
+
+export abstract class HttpStep {
+  /**
+   * The kind of the action to perform.
+   */
+  kind = '';
+
+  /**
+   * Whether the step is disabled in the flow.
+   */
+  enabled?: boolean;
+
+  new(init: IHttpStep): void {
+    const { kind, enabled } = init;
+    this.kind = kind;
+    if (typeof enabled === 'boolean') {
+      this.enabled = enabled
+    } else {
+      this.enabled = undefined;
+    }
+  }
+
+  toJSON(): IHttpStep {
+    const result: IHttpStep = {
+      kind: this.kind,
+    }
+    if (typeof this.enabled === 'boolean') {
+      result.enabled = this.enabled;
+    }
+    return result;
+  }
+
+  /**
+   * A function that returns true when the step is valid and can be executed.
+   */
+  abstract checkValidity(): boolean;
+}

package/src/models/http-actions/LegacyTranslator.ts

@@ -1,18 +1,30 @@
 import { RequestActions as LegacyRequestActions } from '../../models/legacy/request/ArcRequest.js';
-import { RunnableAction as LegacyRunnable, Condition as LegacyCondition, Action as LegacyAction, SetCookieConfig, SetVariableConfig, DeleteCookieConfig, DataSourceConfiguration } from '../../models/legacy/actions/Actions.js';
-import { IHttpActionFlow, IHttpAction, IHttpCondition, ActionSourceEnum, ActionRequestDataEnum, ActionResponseDataEnum, ActionOperatorEnum, IActionStep, ISetDataStep, SetDataStepKind, IReadDataStep, ReadDataStepKind, ISetCookieStep, SetCookieStepKind, IDeleteCookieStep, DeleteCookieStepKind } from './HttpActions.js';
+import { 
+  RunnableAction as LegacyRunnable, Condition as LegacyCondition, Action as LegacyAction, 
+  SetCookieConfig, SetVariableConfig, DeleteCookieConfig, DataSourceConfiguration 
+} from '../../models/legacy/actions/Actions.js';
+import { 
+  IHttpFlow, IHttpAction, IHttpCondition, FlowSourceEnum, FlowRequestDataEnum, 
+  FlowResponseDataEnum,
+} from './HttpFlows.js';
 import { AmfNamespace } from '../../amf/definitions/Namespace.js';
+import { AssertionEnum } from './HttpAssertion.js';
+import { IHttpStep } from './HttpStep.js';
+import { IReadDataStep, ReadDataStepKind } from './steps/data/ReadDataStep.js';
+import { ISetDataStep, SetDataStepKind } from './steps/data/SetDataStep.js';
+import { ISetCookieStep, SetCookieStepKind } from './steps/data/SetCookieStep.js';
+import { DeleteCookieStepKind, IDeleteCookieStep } from './steps/data/DeleteCookieStep.js';
 
 /**
  * Allows to translate the old ARC actions into Action flows.
  */
 export class LegacyTranslator {
-  static translate(action: LegacyRequestActions): IHttpActionFlow[] {
+  static translate(action: LegacyRequestActions): IHttpFlow[] {
     const { request, response } = action;
-    const result: IHttpActionFlow[] = [];
+    const result: IHttpFlow[] = [];
 
     if (Array.isArray(request) && request.length) {
-      const flow: IHttpActionFlow = {
+      const flow: IHttpFlow = {
         trigger: 'request',
         actions: this._translateRunnables(request),
       };
@@ -20,7 +32,7 @@ export class LegacyTranslator {
     }
 
     if (Array.isArray(response) && response.length) {
-      const flow: IHttpActionFlow = {
+      const flow: IHttpFlow = {
         trigger: 'response',
         actions: this._translateRunnables(response),
       };
@@ -66,16 +78,16 @@ export class LegacyTranslator {
     }
     if (type) {
       switch (type) {
-        case 'request': result.source = ActionSourceEnum.request; break;
-        case 'response': result.source = ActionSourceEnum.response; break;
+        case 'request': result.source = FlowSourceEnum.request; break;
+        case 'response': result.source = FlowSourceEnum.response; break;
       }
     }
     if (type && source) {
       if (type === 'request') {
-        result.data = source as ActionRequestDataEnum;
+        result.data = source as FlowRequestDataEnum;
       }
       if (type === 'response') {
-        result.data = source as ActionResponseDataEnum;
+        result.data = source as FlowResponseDataEnum;
       }
     }
     if (predictedValue) {
@@ -83,20 +95,20 @@ export class LegacyTranslator {
     }
     if (operator) {
       switch (operator) {
-        case 'contains': result.operator = ActionOperatorEnum.contains; break;
-        case 'equal': result.operator = ActionOperatorEnum.equal; break;
-        case 'greater-than': result.operator = ActionOperatorEnum.greaterThan; break;
-        case 'greater-than-equal': result.operator = ActionOperatorEnum.greaterThanEqual; break;
-        case 'less-than': result.operator = ActionOperatorEnum.lessThan; break;
-        case 'less-than-equal': result.operator = ActionOperatorEnum.lessThanEqual; break;
-        case 'not-equal': result.operator = ActionOperatorEnum.notEqual; break;
-        case 'regex': result.operator = ActionOperatorEnum.regex; break;
+        case 'contains': result.operator = AssertionEnum.contains; break;
+        case 'equal': result.operator = AssertionEnum.equal; break;
+        case 'greater-than': result.operator = AssertionEnum.greaterThan; break;
+        case 'greater-than-equal': result.operator = AssertionEnum.greaterThanEqual; break;
+        case 'less-than': result.operator = AssertionEnum.lessThan; break;
+        case 'less-than-equal': result.operator = AssertionEnum.lessThanEqual; break;
+        case 'not-equal': result.operator = AssertionEnum.notEqual; break;
+        case 'regex': result.operator = AssertionEnum.regex; break;
       }
     }
     return result;
   }
 
-  protected static _translateAction(item: LegacyAction): IActionStep[] {
+  protected static _translateAction(item: LegacyAction): IHttpStep[] {
     switch (item.name) {
       case 'set-cookie': return this._translateSetCookieAction(item);
       case 'set-variable': return this._translateSetVariableAction(item);
@@ -105,10 +117,10 @@ export class LegacyTranslator {
     }
   }
 
-  protected static _translateSetCookieAction(item: LegacyAction): IActionStep[] {
+  protected static _translateSetCookieAction(item: LegacyAction): IHttpStep[] {
     const legacy = item.config as SetCookieConfig;
 
-    const steps: IActionStep[] = [];
+    const steps: IHttpStep[] = [];
     const ds = this._translateDataSource(legacy.source);
     steps.push(ds);
 
@@ -142,10 +154,10 @@ export class LegacyTranslator {
     return steps;
   }
 
-  protected static _translateSetVariableAction(item: LegacyAction): IActionStep[] {
+  protected static _translateSetVariableAction(item: LegacyAction): IHttpStep[] {
     const legacy = item.config as SetVariableConfig;
 
-    const steps: IActionStep[] = [];
+    const steps: IHttpStep[] = [];
     const ds = this._translateDataSource(legacy.source);
     steps.push(ds);
 
@@ -161,10 +173,10 @@ export class LegacyTranslator {
     return steps;
   }
 
-  protected static _translateDeleteCookieAction(item: LegacyAction): IActionStep[] {
+  protected static _translateDeleteCookieAction(item: LegacyAction): IHttpStep[] {
     const legacy = item.config as DeleteCookieConfig;
 
-    const steps: IActionStep[] = [];
+    const steps: IHttpStep[] = [];
     
     const action: IDeleteCookieStep = {
       kind: DeleteCookieStepKind,
@@ -183,7 +195,7 @@ export class LegacyTranslator {
     return steps;
   }
 
-  protected static _translateDataSource(source: DataSourceConfiguration): IActionStep {
+  protected static _translateDataSource(source: DataSourceConfiguration): IHttpStep {
     if (source.value) {
       const dataSet: ISetDataStep = {
         kind: SetDataStepKind,
@@ -206,16 +218,16 @@ export class LegacyTranslator {
     }
     if (type) {
       switch (type) {
-        case 'request': result.source = ActionSourceEnum.request; break;
-        case 'response': result.source = ActionSourceEnum.response; break;
+        case 'request': result.source = FlowSourceEnum.request; break;
+        case 'response': result.source = FlowSourceEnum.response; break;
       }
     }
     if (type && legacySource) {
       if (type === 'request') {
-        result.data = legacySource as ActionRequestDataEnum;
+        result.data = legacySource as FlowRequestDataEnum;
       }
       if (type === 'response') {
-        result.data = legacySource as ActionResponseDataEnum;
+        result.data = legacySource as FlowResponseDataEnum;
       }
     }
     return result;