@skyramp/skyramp 1.0.0-sha.b2dfe11 → 1.2.2

package/src/classes/RequestValue.js

@@ -0,0 +1,113 @@
+/**
+ * @typedef {Object} RequestValueOptions
+ * @property {string} name - The name of the request.
+ * @property {Object} endpoint - The descriptor for the endpoint of the request.
+ * @property {string} methodType - The type of HTTP method for the request.
+ * @property {string} methodName - The name of the method for the request.
+ * @property {Object} params - The parameters for the request.
+ * @property {Object} headers - The headers for the request.
+ * @property {Object} vars - The variables for the request.
+ * @property {Object} blob - The blob data for the request.
+ * @property {string} javascriptPath - The path to the JavaScript file for the request.
+ * @property {string} javascriptFunction - The JavaScript function for the request.
+ */
+
+/**
+ * The `RequestValue` class represents a request value to use for testing API endpoint methods.
+ * @class
+ */
+class RequestValue {
+  /**
+   * Initialize a new instance of a RequestValue.
+   * @constructor
+   * @param {RequestValueOptions} options - The options for initializing the RequestValue object.
+   */
+  constructor(options) {
+    this.name = options.name;
+    this.endpointDescriptor = options.endpoint;
+    this.methodType = options.methodType;
+    this.methodName = options.methodName
+    this.params = options.params;
+    this.headers = options.headers;
+    this.vars = options.vars;
+    this.blob = options.blob ? JSON.stringify(options.blob) : undefined;
+    this.graphqlParam = options.graphqlParam;
+    this.javascriptPath = options.javascriptPath;
+    this.javascript = options.javascriptFunction;
+  }
+
+  setCookieValue(cookieValue) {
+    this.cookieValue = cookieValue
+  }
+
+  setResponse(responseValue) {
+    this.responseValue = responseValue
+  }
+
+  toJson() {
+    return this.name
+  }
+
+  asRequestDict(globalHeaders=undefined) {
+    if (this.endpointDescriptor === undefined || this.endpointDescriptor === null) {
+      throw new Error(`endpoint descriptor not found. Request descriptor: ${this}`)
+    }
+    const descriptor = this.endpointDescriptor;
+    const endpoint = descriptor.endpoint;
+    const endpointName = endpoint.name;
+    if (endpointName === undefined || endpointName === null) {
+      throw new Error(`endpoint name not found. Endpoint descriptor: ${descriptor}`)
+    }
+    let methodName = this.methodName;
+    if (this.methodName === undefined || this.methodName === null) {
+      methodName = descriptor.getMethodNameForMethodType(this.methodType)
+    }
+    const requestDict = {
+      name: this.name,
+      endpointName: endpointName,
+      methodName: methodName,
+    }
+    if (globalHeaders !== undefined && globalHeaders !== null) {
+      requestDict.headers = {};
+    }
+    if (globalHeaders !== undefined && globalHeaders !== null) {
+      requestDict.headers = globalHeaders;
+    }
+    if (this.headers !== undefined && this.headers !== null) {
+      // Merge requestDict.headers and this.headers
+      requestDict.headers = {...requestDict.headers, ...this.headers};
+    }
+    if (this.params !== undefined && this.params !== null) {
+      requestDict.params = this.params;
+    }
+    if (this.blob !== undefined && this.blob !== null) {
+      requestDict.blob = this.blob;
+    }
+    if (this.graphqlParam!== undefined && this.graphqlParam!== null) {
+      requestDict.graphqlParam = this.graphqlParam;
+    }
+    if (this.vars !== undefined && this.vars !== null) {
+      requestDict.vars = this.vars;
+    }
+    if (this.javascriptPath !== undefined && this.javascriptPath !== null) {
+      requestDict.javascriptPath = this.javascriptPath;
+    }
+    if (this.javascript !== undefined && this.javascript !== null) {
+      requestDict.javascript = this.javascript;
+    }
+    return requestDict;
+  }
+
+  setOverrides(requestDict) {
+    // Sets the override value for this step
+    if (this.cookieValue !== undefined && this.cookieValue !== null) {
+        requestDict["cookies"] = this.cookieValue;
+    }
+
+    if (this.responseValue !== undefined && this.responseValue !== null) {
+        requestDict["override"] = this.responseValue;
+    }
+  }
+}
+
+module.exports = RequestValue;

package/src/classes/ResponseV2.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Represents a REST response.
+ */
+interface ResponseV2Options {
+    description?: string;
+    error?: string;
+    path?: string;
+    method?: string;
+    statusCode?: string;
+    responseHeaders?:  {[headerName: string]: string};
+    responseBody?: string;
+    requestHeaders?:  {[headerName: string]: string};
+    requestBody?: string;
+    duration?: string;
+}
+
+export declare class ResponseV2 {
+    /**
+     * Creates a new instance of ResponseV2.
+     * @param options - The options for creating the response.
+     */
+    constructor(options?: ResponseV2Options);
+    toYaml(): string;
+}

package/src/classes/ResponseV2.js

@@ -0,0 +1,96 @@
+const yaml = require('js-yaml');
+/**
+ * Represents a REST response.
+ */
+class ResponseV2 {
+
+    /**
+     * Creates a new ResponseV2 instance
+     * @param {Object} options - The options for creating the response
+     * @param {string} [options.path=''] - The request path
+     * @param {string} [options.method=''] - The HTTP method used
+     * @param {string} [options.status_code=''] - The HTTP status code of the response
+     * @param {Object} [options.response_headers={}] - Headers included in the response
+     * @param {string} [options.response_body=''] - Body of the response
+     * @param {Object} [options.request_headers={}] - Headers included in the request
+     * @param {string} [options.request_body=''] - Body of the request
+     * @param {string} [options.duration=''] - Duration of the request/response cycle
+     */
+    constructor(options = {}) {
+        this.path = options.path || '';
+        this.method = options.method || '';
+        this.statusCode = options.status_code || '';
+        this.responseHeaders = options.response_headers || {};
+        this.responseBody = options.response_body || '';
+        this.requestHeaders = options.request_headers || {};
+        this.requestBody = options.request_body || '';
+        this.duration = options.duration || '';
+        this.error = options.error || '';
+        this.description = options.description || '';
+    }
+
+    toYaml() {
+        // Map of camelCase to snake_case field names
+        const fieldMappings = {
+          path: 'path',
+          method: 'method',
+          statusCode: 'status_code',
+          responseHeaders: 'response_headers',
+          responseBody: 'response_body',
+          requestHeaders: 'request_headers',
+          requestBody: 'request_body',
+          duration: 'duration',
+          error: 'error',
+          description: 'description'
+        };
+
+        const { body, ...rest } = this;
+        // Create object with non-empty values and convert to snake_case
+        const yamlObject = Object.entries(rest).reduce((acc, [key, value]) => {
+          // Include field only if it's not empty (empty string, empty object, or empty array)
+          if (value && (typeof value !== 'object' || Object.keys(value).length > 0)) {
+            // Use snake_case key if mapping exists, otherwise use original key
+            const snakeKey = fieldMappings[key] || key;
+            acc[snakeKey] = value;
+          }
+          return acc;
+        }, {});
+
+        // Add body if it exists
+        if (body) {
+          yamlObject.body = JSON.stringify(body, null, 2);
+        }
+
+        return yaml.dump(yamlObject);
+    }
+
+    toJson() {
+      // Use the same field mappings as toYaml for consistency
+      const fieldMappings = {
+        path: 'path',
+        method: 'method',
+        statusCode: 'status_code',
+        responseHeaders: 'response_headers',
+        responseBody: 'response_body',
+        requestHeaders: 'request_headers',
+        requestBody: 'request_body',
+        duration: 'duration',
+        error: 'error',
+        description: 'description'
+      };
+
+      const { ...rest } = this;
+      // Create object with non-empty values and convert to snake_case
+      const jsonObject = Object.entries(rest).reduce((acc, [key, value]) => {
+        if (value && (typeof value !== 'object' || Object.keys(value).length > 0)) {
+          const snakeKey = fieldMappings[key] || key;
+          acc[snakeKey] = value;
+        }
+        return acc;
+      }, {});
+      return JSON.stringify(jsonObject, null, 2);
+    }
+}
+
+
+module.exports = ResponseV2;

package/src/classes/ResponseValue.d.ts

@@ -0,0 +1,21 @@
+import { Endpoint } from './Endpoint';
+import { RestParam } from './RestParam';
+interface ResponseValueOptions {
+  name: string;
+  endpoint: Endpoint;
+  methodType?: string;
+  methodName?: string;
+  params?: RestParam[];
+  headers?: Map<string, string>;
+  vars?: Map<string, string | number>;
+  blob?: string;
+  javascriptPath?: string;
+  javascriptFunction?: string;
+}
+
+export declare class ResponseValue {
+  constructor(options: ResponseValueOptions) 
+  toJson() : ResponseValue
+  setCookieValue(cookieValue: string) : void
+  setResponse(responseValue: ResponseValue)  : void
+}

package/src/classes/ResponseValue.js

@@ -0,0 +1,93 @@
+/**
+ * @typedef {Object} ResponseValueOptions
+ * @property {string} name - The name of the response value.
+ * @property {Object} endpoint - The descriptor of the endpoint associated with the response.
+ * @property {string} methodType - The type of the HTTP method used for the response.
+ * @property {string} methodName - The name of the method used for the response.
+ * @property {Object} params - The parameters of the response.
+ * @property {Object} headers - The headers of the response.
+ * @property {Object} vars - The variables of the response.
+ * @property {string} blob - The blob data of the response.
+ * @property {string} javascriptPath - The path to the JavaScript file associated with the response.
+ * @property {string} javascriptFunction - The JavaScript function associated with the response.
+ */
+
+/**
+ * The `ResponseValue` class represents a response value to use for mocking API endpoint methods.
+ * @class
+ */
+class ResponseValue {
+  /**
+   * Initialize a new instance of a ResponseValue.
+   * @constructor
+   * @param {ResponseValueOptions} options - The options for initializing the ResponseValue object.
+   */
+  constructor(options) {
+    this.name = options.name;
+    this.endpointDescriptor = options.endpoint;
+    this.methodType = options.methodType;
+    this.methodName = options.methodName
+    this.params = options.params;
+    this.headers = options.headers;
+    this.vars = options.vars;
+    this.blob = options.blob ? JSON.stringify(options.blob) : undefined;
+    this.javascriptPath = options.javascriptPath;
+    this.javascript = options.javascriptFunction;
+
+    this.trafficConfig = null;
+}
+
+  setTrafficConfig(trafficConfig) {
+    this.trafficConfig = trafficConfig;
+  }
+
+  setCookieValue(cookieValue) {
+    this.cookieValue = cookieValue
+  }
+
+  setResponse(responseValue) {
+    this.responseValue = responseValue
+  }
+
+  toJson() {
+    if (this.endpointDescriptor === undefined || this.endpointDescriptor === null) {
+      throw new Error(`endpoint descriptor not found. Endpoint descriptor: ${this}`)
+    }
+    const descriptor = this.endpointDescriptor;
+    const endpoint = descriptor.endpoint;
+    const endpointName = endpoint.name;
+    if (endpointName === undefined || endpointName === null) {
+      throw new Error(`endpoint name not found. Endpoint descriptor: ${descriptor}`)
+    }
+    let methodName = this.methodName;
+    if (this.methodName === undefined || this.methodName === null) {
+      methodName = descriptor.getMethodNameForMethodType(this.methodType)
+    }
+    const response = {
+      name: this.name,
+      endpointName: endpointName,
+      methodName: methodName,
+    }
+    if (this.headers !== undefined && this.headers !== null) {
+      response.headers = this.headers;
+    }
+    if (this.params !== undefined && this.params !== null) {
+      response.params = this.params;
+    }
+    if (this.blob !== undefined && this.blob !== null) {
+      response.blob = this.blob;
+    }
+    if (this.vars !== undefined && this.vars !== null) {
+      response.vars = this.vars;
+    }
+    if (this.javascriptPath !== undefined && this.javascriptPath !== null) {
+      response.javascriptPath = this.javascriptPath;
+    }
+    if (this.javascript !== undefined && this.javascript !== null) {
+      response.javascript = this.javascript;
+    }
+    return response;
+  }
+}
+
+module.exports = ResponseValue;

package/src/classes/RestEndpoint.d.ts

@@ -1,4 +1,13 @@
 import { Endpoint } from './Endpoint';
+interface RestEndpointOptions {
+  serviceName: string,
+  port: number,
+  restPath?: string,
+  methodType?: string[], // GET, POST, PUT, DELETE, PATCH
+  endpointAddress?: string,
+  subProtocol?: string,
+}
 export declare class RestEndpoint extends Endpoint {
-  constructor(name: string, openApiTag: string, port: number, openapiFile: string);
-}
+  constructor(name: string, openApiTag: string, port: number, openapiFile: string, endpointAddress: string);
+  constructor(options: RestEndpointOptions);
+}

package/src/classes/RestEndpoint.js

@@ -1,12 +1,97 @@
 const Endpoint = require('./Endpoint');
 const lib = require('../lib');
-const newRestEndpointWrapper = lib.func('newRestEndpointWrapper', 'string', ['string', 'string', 'int', 'string']);
+const newRestEndpointWrapper = lib.func('newRestEndpointWrapper', 'string', ['string', 'string', 'int', 'string', 'string']);
 
+/**
+ * The `RestEndpoint` class represents a REST API Endpoint.
+ * @class
+ */
 class RestEndpoint extends Endpoint {
-  constructor(name, openApiTag, port, openapiFile) {
-    const response = newRestEndpointWrapper(name, openApiTag, port, openapiFile);
-    super(response);
+  /**
+   * Intialize a new instance of a REST endpoint.
+   * @extends Endpoint
+   * @constructor
+   * @param {...*} args - The arguments to create the REST endpoint.
+   * @throws {Error} If the arguments are invalid.
+   */
+  constructor(...args) {
+    let restEndPointData;
+    let endpointAddress;
+    if (args.length === 1 && typeof args[0] === 'object') {
+      restEndPointData = createEndpoint(args[0]);
+      endpointAddress = args[0].endpointAddress;
+    } else if (args.length >= 4) {
+      // eslint-disable-next-line no-unused-vars
+      const [name, openApiTag, port, openapiFile, endpointAddress] = args;
+
+      // TODO: Add restPath support
+      restEndPointData = newRestEndpointWrapper(name, openApiTag, port, openapiFile, "");
+    }
+    super(restEndPointData, endpointAddress);
+  }
+}
+
+function createEndpoint({ serviceName, port, restPath, methodTypes, subProtocol }) {
+  // Validate required arguments
+  if (typeof serviceName !== 'string' || serviceName.length === 0) {
+    throw new Error('serviceName must be a non-empty string');
+  }
+  if (typeof port !== 'number' || isNaN(port) || port <= 0) {
+    throw new Error('port must be a positive number');
+  }
+  if (!Array.isArray(methodTypes) || methodTypes.length === 0) {
+    throw new Error('methodTypes must be a non-empty array');
   }
+  if (restPath !== undefined && typeof restPath !== 'string') {
+    throw new Error('restPath must be a string');
+  }
+
+  // Validate subProtocol
+  const allowedProtocols = ['graphql', 'jsonrpc-http', 'jsonrpc-ws'];
+  let protocol = 'rest';
+  if (subProtocol !== undefined) {
+    if (typeof subProtocol !== 'string' || !allowedProtocols.includes(subProtocol.toLowerCase())) {
+      throw new Error('Invalid subProtocol. It must not be "graphql" or "jsonrpc".');
+    }
+    protocol = subProtocol;
+  }
+
+  // allowed HTTP methods
+  const allowedMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'];
+
+  let endpoint = {
+    services: [{
+      name: serviceName,
+      port: port,
+      alias: serviceName,
+      protocol: protocol,
+    }],
+    endpoints: [{
+      name: serviceName + '-endpoint', 
+      methods: [],
+      path: restPath,
+      serviceName: serviceName,
+    }],
+    responses: [],
+    mocks: []
+  };
+
+  methodTypes.forEach(methodType => {
+    // Check if methodType is allowed
+    if (!allowedMethods.includes(methodType)) {
+      throw new Error(`Invalid method type: ${methodType}. Allowed methods are: ${allowedMethods.join(', ')}`);
+    }
+    endpoint.endpoints[0].methods.push({
+      type: methodType,
+      name: methodType,
+    });
+    endpoint.responses.push({
+      name: serviceName + "-" + methodType + "-response",
+      endpointName: serviceName + '-endpoint',
+      methodName: methodType + '-method',
+    });
+  });
+  return JSON.stringify(endpoint);
 }
 
-module.exports = RestEndpoint;
+module.exports = RestEndpoint;

package/src/classes/RestParam.d.ts

@@ -0,0 +1,4 @@
+export declare class RestParam {
+  constructor(name: string, in_: string, type_: string, value: string)
+}
+

package/src/classes/RestParam.js

@@ -0,0 +1,32 @@
+
+/**
+ * The `RestParam` class represents a REST (query, path, etc) param.
+ * @class
+ */
+class RestParam {
+  /**
+   * Initializes a new instance of the RestParam class.
+   * @constructor
+   * @param {string} name - The name of the parameter.
+   * @param {string} in_ - The location of the parameter (e.g., 'query', 'header', 'path').
+   * @param {string} type_ - The data type of the parameter.
+   * @param {*} value - The value of the parameter.
+   */
+  constructor(name, in_, type_, value) {
+    this.name = name
+    this.in = in_
+    this.type = type_
+    this.value = value
+  }
+
+  toJson() {
+    return {
+      name: this.name,
+      in: this.in,
+      type: this.type,
+      value: this.value
+    }
+  }
+}
+
+module.exports = RestParam;

package/src/classes/Scenario.d.ts

@@ -0,0 +1,48 @@
+import { Asserts } from './Asserts';
+import { RequestValue } from './RequestValue';
+import { Endpoint } from './Endpoint';
+import { StepConfig } from './Step';
+
+interface ScenarioOptions {
+  name: string,
+  startAt?: string,
+  headers?: {[headerName: string]: string},
+  vars?: {[ var_: string]: string | number},
+  ignore?: boolean,
+}
+
+interface RequestOption {
+	request: RequestValue
+}
+
+interface AssertOption {
+	assert: Asserts
+}
+
+interface ScenarioOption {
+	scenario: Scenario
+}
+
+
+interface AddRequestOption extends RequestOption, StepConfig {
+}
+
+export interface AddAssertOption extends AssertOption, StepConfig {
+}
+
+export interface AddScenarioOption extends ScenarioOption, StepConfig {
+}
+
+export declare class Scenario {
+  constructor(name: string);
+  constructor(options: ScenarioOptions);
+  addRequest(endpoint: Endpoint, methodName: string, requestObject?: string, dynamic?: boolean): string;
+  addRequestFromFile(endpoint: Endpoint, methodName: string, requestFile: string): string;
+  buildRequestsFromEndpoint(endpoint: Endpoint): void;
+  addAssertEqual(value1: string, value2: string): string;
+  writeTestConfigurationToFile(): Promise<void>;
+  addRequestV1(request: RequestValue): string;
+  addRequestV2(options: AddRequestOption): string;
+  addScenarioV2(options: AddScenarioOption): string;
+  addAssertV2(options: AddAssertOption): string;
+}