@api-client/core 0.9.4 → 0.9.5

package/src/models/Environment.ts

@@ -3,6 +3,7 @@ import { Server, IServer } from './Server.js';
 import { IThing, Thing, Kind as ThingKind } from './Thing.js';
 import v4 from '../lib/uuid.js';
 import { ARCVariable } from './legacy/models/Variable.js';
+import { IRequestAuthorization, RequestAuthorization } from './RequestAuthorization.js';
 
 export const Kind = 'Core#Environment';
 
@@ -46,7 +47,7 @@ export interface IEnvironment {
   /**
    * The security to be applied to all requests that are going to this environment.
    */
-  security?: unknown;
+  authorization?: IRequestAuthorization[];
 }
 
 /**
@@ -82,7 +83,7 @@ export class Environment {
   /**
    * The security to be applied to all requests that are going to this server.
    */
-  security?: unknown;
+  authorization?: RequestAuthorization[];
 
   /**
    * Creates a new Environment object from a name.
@@ -151,11 +152,15 @@ export class Environment {
     if (!Environment.isEnvironment(init)) {
       throw new Error(`Not an environment.`);
     }
-    const { key = v4(), variables, info, server, encapsulated = false, security } = init;
+    const { key = v4(), variables, info, server, encapsulated = false, authorization } = init;
     this.kind = Kind;
     this.key = key;
     this.encapsulated = encapsulated;
-    this.security = security;
+    if (Array.isArray(authorization)) {
+      this.authorization = authorization.map(i => new RequestAuthorization(i));
+    } else {
+      this.authorization = undefined;
+    }
     if (Array.isArray(variables)) {
       this.variables = variables.map(i => new Property(i))
     } else {
@@ -196,9 +201,8 @@ export class Environment {
     if (server) {
       result.server = server.toJSON();
     }
-    if (this.security) {
-      // TODO: When this is defined then call toJSON().
-      result.security = this.security;
+    if (Array.isArray(this.authorization)) {
+      result.authorization = this.authorization.map(i => i.toJSON());
     }
     return result;
   }

package/src/models/ErrorResponse.ts

@@ -66,7 +66,7 @@ export class ErrorResponse extends HttpResponse {
   /**
    * @param input The request definition used to restore the state.
    */
-  constructor(input?: string|IErrorResponse) {
+  constructor(input?: string | IErrorResponse) {
     super(input);
     let init: IErrorResponse;
     if (typeof input === 'string') {

package/src/models/HttpRequest.ts

@@ -1,11 +1,10 @@
-import { SerializablePayload, SerializablePayloadOptions } from './SerializablePayload.js';
-import { Payload } from '../lib/transformers/PayloadSerializer.js';
+import { ISerializablePayload, SerializablePayload, SerializablePayloadOptions } from './SerializablePayload.js';
 import { IProperty } from './Property.js';
 import { HeadersArray } from './HeadersArray.js';
 
 export const Kind = 'Core#HttpRequest';
 
-export interface IBaseHttpRequest {
+export interface IBaseHttpRequest extends ISerializablePayload {
   /**
    * The request URL
    */
@@ -19,10 +18,6 @@ export interface IBaseHttpRequest {
    * HTTP headers string
    */
   headers?: string;
-  /**
-   * The request payload.
-   */
-  payload?: Payload;
 }
 
 /**
@@ -136,8 +131,9 @@ export class HttpRequest extends SerializablePayload {
     return true;
   }
 
-  toJSON(): IHttpRequest {
+  override toJSON(): IHttpRequest {
     const result: IHttpRequest = {
+      ...super.toJSON(),
       kind: this.kind,
       url: this.url,
       method: this.method,
@@ -145,15 +141,9 @@ export class HttpRequest extends SerializablePayload {
     if (this.headers) {
       result.headers = this.headers;
     }
-    if (this.payload) {
-      result.payload = this.payload;
-    }
     if (this.headersModel) {
       result.headersModel = this.headersModel.toJSON();
     }
-    if (this.payloadOptions) {
-      result.payloadOptions = { ...this.payloadOptions };
-    }
     return result;
   }
 

package/src/models/HttpResponse.ts

@@ -1,11 +1,11 @@
-import { SerializablePayload } from './SerializablePayload.js';
-import { Payload, PayloadSerializer } from '../lib/transformers/PayloadSerializer.js';
+import { ISerializablePayload, SerializablePayload } from './SerializablePayload.js';
+import { PayloadSerializer } from '../lib/transformers/PayloadSerializer.js';
 import { HTTPResponse as LegacyHttpResponse } from './legacy/request/ArcResponse.js';
 import { Normalizer } from './legacy/Normalizer.js';
 
 export const Kind = 'Core#HttpResponse';
 
-export interface IHttpResponse {
+export interface IHttpResponse extends ISerializablePayload {
   kind?: string;
   /**
    * The response status code
@@ -19,10 +19,6 @@ export interface IHttpResponse {
    * The response headers
    */
   headers?: string;
-  /**
-   * The response message
-   */
-  payload?: Payload;
 }
 
 export class HttpResponse extends SerializablePayload {
@@ -116,8 +112,9 @@ export class HttpResponse extends SerializablePayload {
     return true;
   }
 
-  toJSON(): IHttpResponse {
+  override toJSON(): IHttpResponse {
     const result: IHttpResponse = {
+      ...super.toJSON(),
       kind: this.kind,
       status: this.status,
     };
@@ -127,9 +124,6 @@ export class HttpResponse extends SerializablePayload {
     if (this.headers) {
       result.headers = this.headers;
     }
-    if (this.payload) {
-      result.payload = this.payload;
-    }
     return result;
   }
 

package/src/models/ProjectRequest.ts

@@ -9,6 +9,7 @@ import { Environment } from './Environment.js';
 import { Property } from './Property.js';
 import { Server } from './Server.js';
 import { UriTemplate } from '../lib/parsers/UriTemplate.js';
+import { RequestAuthorization } from './RequestAuthorization.js';
 
 export const Kind = 'Core#ProjectRequest';
 
@@ -485,4 +486,57 @@ export class ProjectRequest extends Request implements ProjectDefinitionProperty
     }
     return result;
   }
+
+  /**
+   * Reads the authorization that should be applied to the request.
+   * 
+   * 1) First it returns the locally (on the request) defined authorization.
+   * 2) Then it returns authorization defined on the selected environment.
+   * 3) If has defined environment but no authorization on it, then it returns empty array.
+   * 4) Only if the request has no selected environment then it reads first environment
+   * that has authorization (from the request up to the project's root).
+   */
+  readAuthorization(): RequestAuthorization[] {
+    if (Array.isArray(this.authorization) && this.authorization.length) {
+      return this.authorization;
+    }
+    const envAuth = this.readEnvironmentAuthorization();
+    if (envAuth) {
+      return envAuth;
+    }
+    if (this.environment) {
+      return [];
+    }
+    const inherited = this.readEnvironmentsAuthorization();
+    if (inherited) {
+      return inherited;
+    }
+    return [];
+  }
+
+  /**
+   * @returns Authorization defined on the selected environment or undefined.
+   */
+  protected readEnvironmentAuthorization(): RequestAuthorization[] | undefined {
+    const selfEnv = this.getEnvironment();
+    if (!selfEnv) {
+      return undefined;
+    }
+    if (Array.isArray(selfEnv.authorization) && selfEnv.authorization.length) {
+      return selfEnv.authorization;
+    }
+    return undefined;
+  }
+
+  /**
+   * @returns Authorization defined on any inherited environment or undefined.
+   */
+  protected readEnvironmentsAuthorization(): RequestAuthorization[] | undefined {
+    const envs = this.readEnvironments();
+    const authEnv = envs.find(i => Array.isArray(i.authorization) && !!i.authorization.length);
+    if (authEnv) {
+      return authEnv.authorization as RequestAuthorization[];
+    }
+    return undefined;
+  }
 }

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;
+}