@skyramp/skyramp 1.0.0-sha.b2dfe11 → 1.2.2

package/src/classes/GrpcEndpoint.js

@@ -2,10 +2,31 @@ const Endpoint = require('./Endpoint');
 const lib = require('../lib');
 const newGrpcEndpointWrapper = lib.func('newGrpcEndpointWrapper', 'string', ['string', 'string', 'int', 'string']);
 
+/**
+ * The `GrpcEndpoint` class represents a gRPC API Endpoint.
+ * @class
+ */
 class GrpcEndpoint extends Endpoint {
-  constructor(name, service, port, pbFile) {
-    const response = newGrpcEndpointWrapper(name, service, port, pbFile);
-    super(response);
+  /**
+   * Intialize a new instance of a gRPC endpoint.
+   * @constructor
+   * @param {string} name - The name of the endpoint.
+   * @param {string} service - The name of the service.
+   * @param {number} port - The port number.
+   * @param {string} pbFile - The protocol buffer file containing the API schema definition.
+   * @param {string} endpointAddress - The endpoint address.
+   */
+  constructor(...args) {
+    let name, service, port, pbFile, endpointAddress;
+    if (args.length === 1 && typeof args[0] === 'object') {
+      ({ name, service, port, pbFile, endpointAddress } = args[0]);
+    } else if (args.length >= 4) {
+      [name, service, port, pbFile, endpointAddress] = args;
+    } else {
+      throw new Error('Invalid arguments for GrpcEndpoint constructor');
+    }
+    const grpcEndPointData = newGrpcEndpointWrapper(name, service, port, pbFile, endpointAddress);
+    super(grpcEndPointData, endpointAddress);
   }
 }
 

package/src/classes/LoadTestConfig.d.ts

@@ -0,0 +1,131 @@
+export interface LoadTestConfigOptions {
+  loadDuration?: number;
+  loadNumThreads?: number;
+  loadTargetRPS?: number;
+  loadCount?: number;
+  loadAtOnce?: number;
+  loadStopOnFailure?: boolean;
+  loadRampupDuration?: number;
+  loadRampupInterval?: number;
+}
+
+
+export class LoadTestConfig {
+  duration?: number;
+  numThreads?: number;
+  targetRPS?: number;
+  count?: number;
+  atOnce?: number;
+  stopOnFailure?: boolean;
+  rampupDuration?: number;
+  rampupInterval?: number;
+
+  /**
+   * Constructor for LoadTestConfig with options object
+   * @param options Configuration options
+   */
+  constructor(options?: LoadTestConfigOptions);
+
+  // Getters
+  /**
+   * Gets the duration of the load test
+   * @returns The duration in seconds
+   */
+  getDuration(): number | undefined;
+
+  /**
+   * Gets the number of threads
+   * @returns The number of threads
+   */
+  getNumThreads(): number | undefined;
+
+  /**
+   * Gets the target requests per second
+   * @returns The target RPS
+   */
+  getTargetRPS(): number | undefined;
+
+  /**
+   * Gets the count of requests
+   * @returns The request count
+   */
+  getCount(): number | undefined;
+
+  /**
+   * Gets the atOnce value
+   * @returns The atOnce value
+   */
+  getAtOnce(): number | undefined;
+
+  /**
+   * Gets whether to stop on failure
+   * @returns The stopOnFailure boolean
+   */
+  getStopOnFailure(): boolean | undefined;
+
+  /**
+   * Gets the ramp up duration
+   * @returns The ramp up duration in seconds
+   */
+  getRampupDuration(): number | undefined;
+
+  /**
+   * Gets the ramp up interval
+   * @returns The ramp up interval in seconds
+   */
+  getRampupInterval(): number | undefined;
+
+  // Setters
+  /**
+   * Sets the duration of the load test
+   * @param duration The duration in seconds
+   */
+  setDuration(duration: number): void;
+
+  /**
+   * Sets the number of threads
+   * @param numThreads The number of threads
+   */
+  setNumThreads(numThreads: number): void;
+
+  /**
+   * Sets the target requests per second
+   * @param targetRPS The target RPS
+   */
+  setTargetRPS(targetRPS: number): void;
+
+  /**
+   * Sets the count of requests
+   * @param count The request count
+   */
+  setCount(count: number): void;
+
+  /**
+   * Sets the atOnce value
+   * @param atOnce The atOnce value
+   */
+  setAtOnce(atOnce: number): void;
+
+  /**
+   * Sets whether to stop on failure
+   * @param stopOnFailure The stopOnFailure boolean
+   */
+  setStopOnFailure(stopOnFailure: boolean): void;
+
+  /**
+   * Sets the ramp up duration
+   * @param rampUpDuration The ramp up duration in seconds
+   */
+  setRampupDuration(rampUpDuration: number): void;
+
+  /**
+   * Sets the ramp up interval
+   * @param rampUpInterval The ramp up interval in seconds
+   */
+  setRampupInterval(rampUpInterval: number): void;
+
+  /**
+   * Converts the configuration to JSON string
+   */
+  toJson(): string;
+}

package/src/classes/LoadTestConfig.js

@@ -0,0 +1,186 @@
+/**
+ * Configuration class for load testing parameters
+ */
+class LoadTestConfig {
+  /**
+   * Creates a new LoadTestConfig instance
+   * @param {Object} options - Configuration options
+   * @param {number} [options.duration] - Duration of the load test in seconds
+   * @param {number} [options.numThreads] - Number of threads to use for the load test
+   * @param {number} [options.targetRPS] - Target requests per second
+   * @param {number} [options.count] - Number of requests to make
+   * @param {number} [options.atOnce] - Number of requests to send at once
+   * @param {boolean} [options.stopOnFailure=true] - Whether to stop on failure
+   * @param {number} [options.rampUpDuration] - Duration of the ramp up period in seconds
+   * @param {number} [options.rampUpInterval] - Interval between ramp up steps in seconds
+   */
+  constructor(options = {}) {
+   {
+      this.duration = options.loadDuration;
+      this.numThreads = options.loadNumThreads; 
+      this.targetRPS = options.loadTargetRPS;
+      this.count = options.loadCount;
+      this.atOnce = options.loadAtOnce;
+      this.stopOnFailure = options.loadStopOnFailure || true;
+      this.rampupDuration = options.loadRampupDuration;
+      this.rampupInterval = options.loadRampupInterval;
+    }
+  }
+
+  // Getters
+  /**
+   * Gets the duration of the load test
+   * @returns {number|undefined} The duration in seconds
+   */
+  getDuration() {
+    return this.duration;
+  }
+
+  /**
+   * Gets the number of threads
+   * @returns {number|undefined} The number of threads
+   */
+  getNumThreads() {
+    return this.numThreads;
+  }
+
+  /**
+   * Gets the target requests per second
+   * @returns {number|undefined} The target RPS
+   */
+  getTargetRPS() {
+    return this.targetRPS;
+  }
+
+  /**
+   * Gets the count of requests
+   * @returns {number|undefined} The request count
+   */
+  getCount() {
+    return this.count;
+  }
+
+  /**
+   * Gets the atOnce value
+   * @returns {number|undefined} The atOnce value
+   */
+  getAtOnce() {
+    return this.atOnce;
+  }
+
+  /**
+   * Gets whether to stop on failure
+   * @returns {boolean|undefined} The stopOnFailure boolean
+   */
+  getStopOnFailure() {
+    return this.stopOnFailure;
+  }
+
+  /**
+   * Gets the ramp up duration
+   * @returns {number|undefined} The ramp up duration in seconds
+   */
+  getRampupDuration() {
+    return this.rampupDuration;
+  }
+
+  /**
+   * Gets the ramp up interval
+   * @returns {number|undefined} The ramp up interval in seconds
+   */
+  getRampupInterval() {
+    return this.rampupInterval;
+  }
+
+  // Setters
+  /**
+   * Sets the duration of the load test
+   * @param {number} duration - The duration in seconds
+   */
+  setDuration(duration) {
+    this.duration = duration;
+  }
+
+  /**
+   * Sets the number of threads
+   * @param {number} numThreads - The number of threads
+   */
+  setNumThreads(numThreads) {
+    this.numThreads = numThreads;
+  }
+
+  /**
+   * Sets the target requests per second
+   * @param {number} targetRPS - The target RPS
+   */
+  setTargetRPS(targetRPS) {
+    this.targetRPS = targetRPS;
+  }
+
+  /**
+   * Sets the count of requests
+   * @param {number} count - The request count
+   */
+  setCount(count) {
+    this.count = count;
+  }
+
+  /**
+   * Sets the atOnce value
+   * @param {number} atOnce - The atOnce value
+   */
+  setAtOnce(atOnce) {
+    this.atOnce = atOnce;
+  }
+
+  /**
+   * Sets whether to stop on failure
+   * @param {boolean} stopOnFailure - The stopOnFailure boolean
+   */
+  setStopOnFailure(stopOnFailure) {
+    this.stopOnFailure = stopOnFailure;
+  }
+
+  /**
+   * Sets the ramp up duration
+   * @param {number} rampupDuration - The ramp up duration in seconds
+   */
+  setRampupDuration(rampupDuration) {
+    this.rampupDuration = rampupDuration;
+  }
+
+  /**
+   * Sets the ramp up interval
+   * @param {number} rampUpInterval - The ramp up interval in seconds
+   */
+  setRampupInterval(rampupInterval) {
+    this.rampupInterval = rampupInterval;
+  }
+
+  /**
+   * Converts the configuration to JSON string
+   * @returns {string} JSON string representation of the configuration
+   */
+  toJson() {
+    const result = {
+      duration: this.duration,
+      numThreads: this.numThreads,
+      targetRPS: this.targetRPS,
+      count: this.count,
+      atOnce: this.atOnce,
+      stopOnFailure: this.stopOnFailure,
+    };
+    if (this.rampupDuration || this.rampupInterval) {
+      result.rampUp = {
+        duration: this.rampupDuration,
+        interval: this.rampupInterval
+      };
+    }
+    return JSON.stringify(result);
+  }
+}
+
+
+module.exports = {
+  LoadTestConfig
+};

package/src/classes/Protocol.d.ts

@@ -0,0 +1,5 @@
+export enum Protocol {
+  REST = 'rest',
+  GRAPHQL = 'graphql',
+  GRPC = 'grpc'
+}

package/src/classes/Protocol.js

@@ -0,0 +1,8 @@
+const Protocol = Object.freeze({
+  REST: 'rest',
+  GRAPHQL: 'graphql',
+  GRPC: 'grpc'
+})
+
+module.exports=Protocol;
+

package/src/classes/RequestV2.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Represents a REST request.
+ */
+interface RequestV2Options {
+  name?: string;
+  url: string;
+  path: string;
+  method: string;
+  body?: string;
+  headers?: {[headerName: string]: string};
+  cookies?: {[cookieName: string]: string};
+  dataOverride?: {[dataName: string]: string | number | boolean | object};
+  pathParams?: {[pathName: string]: string | number | boolean | object};
+  queryParams?: {[queryName: string]: string | number | boolean | object};
+  formParams?: {[formParamName: string]: string | number | boolean | object};
+  expectedCode?: string;
+  funcHandler?: string;
+  funcHandlerType?: string;
+  insecure?: boolean;
+}
+export declare class RequestV2 {
+  /**
+   * Creates a new instance of RequestV2.
+   * @param options - The options for creating the request.
+   */
+  constructor(options: RequestV2Options);
+  toYaml(): string;
+  toJson(): string;
+  asRequestDict(): {[key: string]: string | number | boolean | object | null};
+}

package/src/classes/RequestV2.js

@@ -0,0 +1,181 @@
+const yaml = require('js-yaml');
+
+/**
+ * Represents a REST request.
+ */
+class RequestV2 {
+  /**
+   * Creates a new instance of RequestV2.
+   * @param {Object} [options={}] - The options for creating the request.
+   * @param {string} [options.name=''] - The name of the request.
+   * @param {string} [options.url=''] - The URL of the request.
+   * @param {string} [options.path=''] - The REST path of the request.
+   * @param {string} [options.method=''] - The HTTP method of the request.
+   * @param {string} [options.body=''] - The request body in JSON format.
+   * @param {Object.<string, string>} [options.headers={}] - The HTTP headers of the request.
+   * @param {Object.<string, string>} [options.cookies={}] - The HTTP cookies of the request.
+   * @param {Object.<string, *>} [options.dataOverride={}] - The data override for the request.
+   * @param {Object.<string, *>} [options.pathParams={}] - The path parameters for the request.
+   * @param {Object.<string, *>} [options.queryParams={}] - The query parameters for the request.
+   * @param {Object.<string, *>} [options.formParams={}] - The form parameters of the request.
+   * @param {string} [options.expectedCode=''] - The expected HTTP status code of the response.
+   * @param {string} [options.funcHandler=''] - The dynamic handler function for the request.
+   * @param {string} [options.funcHandlerType=''] - The type of the dynamic handler (e.g., 'python', 'javascript').
+   * @param {boolean} [options.insecure=false] - Skip cert verification if set.
+   */
+  constructor(options = {}) {
+    this.name = options.name || '';
+    this.url = options.url || '';
+    this.path = options.path || '';
+    this.method = options.method || '';
+    this.body = options.body || '';
+    this.headers = options.headers || {};
+    this.cookies = options.cookies || {};
+    this.dataOverride = options.dataOverride || {};
+    this.pathParams = options.pathParams || {};
+    this.queryParams = options.queryParams || {};
+    this.formParams = options.formParams || {};
+    this.expectedCode = options.expectedCode || '';
+    this.description = options.description || '';
+    this.insecure = options.insecure || false;
+    this.funcHandler = options.funcHandler || '';
+    this.funcHandlerType = options.funcHandlerType || '';
+  }
+
+  toYaml() {
+    // Map of camelCase to snake_case field names
+    const fieldMappings = {
+      name: 'name',
+      url: 'url',
+      path: 'path',
+      method: 'method',
+      body: 'body',
+      headers: 'headers',
+      cookies: 'cookies',
+      dataOverride: 'data_override',
+      pathParams: 'path_params',
+      queryParams: 'query_params',
+      formParams: 'form_params',
+      expectedCode: 'expected_code',
+      description: 'description',
+      insecure: 'insecure',
+      funcHandler: 'func_handler',
+      funcHandlerType: 'func_handler_type'
+    };
+
+    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 = {
+      name: 'name',
+      url: 'url',
+      path: 'path',
+      method: 'method',
+      body: 'body',
+      headers: 'headers',
+      cookies: 'cookies',
+      dataOverride: 'data_override',
+      pathParams: 'path_params',
+      queryParams: 'query_params',
+      formParams: 'form_params',
+      expectedCode: 'expected_code',
+      description: 'description',
+      insecure: 'insecure',
+      funcHandler: 'func_handler',
+      funcHandlerType: 'func_handler_type'
+    };
+
+    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);
+  }
+
+  /**
+   * Returns the request as a dictionary object suitable for async scenarios
+   * @param {Object} [globalHeaders] - Global headers to merge with request headers
+   * @returns {Object} The request dictionary
+   */
+  asRequestDict(globalHeaders = undefined) {
+    const requestDict = {
+      requestName: this.name,
+      url: this.url,
+      path: this.path,
+      method: this.method
+    };
+
+    // Add description if available
+    if (this.description !== undefined && this.description !== null && this.description !== '') {
+      requestDict.description = this.description;
+    }
+
+    // Handle headers
+    if (globalHeaders !== undefined && globalHeaders !== null) {
+      requestDict.headers = { ...globalHeaders };
+    }
+    if (this.headers !== undefined && this.headers !== null && Object.keys(this.headers).length > 0) {
+      requestDict.headers = { ...requestDict.headers, ...this.headers };
+    }
+
+    // Add other fields if they exist
+    if (this.body !== undefined && this.body !== null && this.body !== '') {
+      requestDict.body = this.body;
+    }
+    if (this.cookies !== undefined && this.cookies !== null && Object.keys(this.cookies).length > 0) {
+      requestDict.cookies = this.cookies;
+    }
+    if (this.dataOverride !== undefined && this.dataOverride !== null && Object.keys(this.dataOverride).length > 0) {
+      requestDict.dataOverride = this.dataOverride;
+    }
+    if (this.pathParams !== undefined && this.pathParams !== null && Object.keys(this.pathParams).length > 0) {
+      requestDict.pathParams = this.pathParams;
+    }
+    if (this.queryParams !== undefined && this.queryParams !== null && Object.keys(this.queryParams).length > 0) {
+      requestDict.queryParams = this.queryParams;
+    }
+    if (this.formParams !== undefined && this.formParams !== null && Object.keys(this.formParams).length > 0) {
+      requestDict.formParams = this.formParams;
+    }
+    if (this.expectedCode !== undefined && this.expectedCode !== null && this.expectedCode !== '') {
+      requestDict.expectedCode = this.expectedCode;
+    }
+    if (this.funcHandler !== undefined && this.funcHandler !== null && this.funcHandler !== '') {
+      requestDict.funcHandler = this.funcHandler;
+    }
+    if (this.funcHandlerType !== undefined && this.funcHandlerType !== null && this.funcHandlerType !== '') {
+      requestDict.funcHandlerType = this.funcHandlerType;
+    }
+    if (this.insecure !== undefined && this.insecure !== null && this.insecure !== false) {
+      requestDict.insecure = this.insecure;
+    }
+
+    return requestDict;
+  }
+}
+
+module.exports = RequestV2;

package/src/classes/RequestValue.d.ts

@@ -0,0 +1,24 @@
+import { Endpoint } from './Endpoint';
+import { RestParam } from './RestParam';
+import { ResponseValue } from './ResponseValue';
+interface RequestValueOptions {
+  name: string;
+  endpoint: Endpoint;
+  methodType?: string;
+  methodName?: string;
+  params?: RestParam[];
+  headers?: {[headerName: string]: string},
+  vars?: {[ var_: string]: string | number};
+  blob?: string;
+  graphqlParam?: string;
+  javascriptPath?: string;
+  javascriptFunction?: string;
+}
+export declare class RequestValue {
+  constructor(options: RequestValueOptions) 
+  asRequestDict() : RequestValue 
+  setCookieValue(cookieValue: string) : void
+  setResponse(responseValue: ResponseValue)  : void
+  toJson() : string
+  setOverrides(requestDict: RequestValue  ) : void
+}