@skyramp/skyramp 1.0.0-sha.b2dfe11 → 1.2.2

package/src/classes/AsyncTestStatus.js

@@ -0,0 +1,488 @@
+const lib = require('../lib');
+const getOverallStatusWrapper = lib.func('getOverallStatusWrapper', 'string', ['string']);
+
+/**
+ * Unified AsyncTestStatus class for handling all test status operations
+ */
+class AsyncTestStatus {
+  /**
+   * Creates an AsyncTestStatus instance
+   * @param {Object} options - The test status options
+   */
+  constructor(options) {
+    // Store the original JSON response for getOverallStatusWrapper
+    this.jsonResponse = options || {};
+    this.testStatus = options || {};
+    this.testId = options.id || "";
+    this.testType = "";
+    this.scenarioDict = {};
+
+    // Initialize based on test type
+    if (options && options.results && options.results.length > 1) {
+      if (options.results[1].type === "load") {
+        this._initializeLoadTest(options);
+      } else {
+        this._initializeIntegrationTest(options);
+      }
+    }
+  }
+
+  /**
+   * Initialize load test specific data
+   * @private
+   */
+  _initializeLoadTest(options) {
+    this.testType = "load";
+    const results = options.results;
+
+    for (let i = 1; i < results.length; i++) {
+      const result = results[i];
+      const rawResult = result;
+      const stats = rawResult.stat || {};
+
+      for (const [key, resultData] of Object.entries(stats)) {
+        const resultStat = resultData;
+        resultData.id = key;
+        const resultId = resultStat.description;
+
+        if (resultStat.type === "scenario") {
+          const newScenario = new AsyncTestStatus.AsyncScenarioStatus(resultData, "load");
+          this.scenarioDict[resultId] = newScenario;
+        } else if (resultStat.type === "request") {
+          const itemList = resultId.split('.');
+          for (let j = itemList.length - 1; j >= 0; j--) {
+            itemList.pop();
+            const parentScenario = itemList.slice(0, -1).join('.');
+            if (this.scenarioDict[parentScenario]) {
+              const request = new AsyncTestStatus.AsyncRequestStatus(resultData, "load");
+              this.scenarioDict[parentScenario].requests.push(request);
+              break;
+            }
+          }
+        } else if (resultStat.assertStatement) {
+          const itemList = resultStat.description.split('.');
+          let scenarioId = "";
+          let requestId = "";
+
+          if (itemList.length > 4) {
+            scenarioId = itemList.slice(0, -4).join('.');
+            requestId = itemList.slice(0, -2).join('.');
+          }
+
+          if (this.scenarioDict[scenarioId]) {
+            const scenario = this.scenarioDict[scenarioId];
+            for (const request of scenario.getRequests()) {
+              if (request.resultObject.description === requestId) {
+                request.asserts.push(resultStat);
+                break;
+              }
+            }
+          }
+        }
+      }
+
+      if (rawResult.type === "load") {
+        const timeseriesList = rawResult.timeseries || [];
+        if (this.scenarioDict[rawResult.description]) {
+          this.scenarioDict[rawResult.description].timeseries = timeseriesList;
+        }
+      }
+    }
+  }
+
+  /**
+   * Initialize integration test specific data
+   * @private
+   */
+  _initializeIntegrationTest(options) {
+    this.testType = "integration";
+
+    for (let i = 1; i < options.results.length; i++) {
+      const result = options.results[i];
+      const resultObject = result;
+
+      if (resultObject.type === "scenario") {
+        this.scenarioDict[resultObject.nestedInfo] = new AsyncTestStatus.AsyncScenarioStatus(result, "integration");
+        if (resultObject.parent && resultObject.parent !== "") {
+          if (this.scenarioDict[resultObject.parent]) {
+            this.scenarioDict[resultObject.parent].subScenarios.push(
+              this.scenarioDict[resultObject.nestedInfo]
+            );
+          }
+        }
+      } else if (resultObject.type === "request") {
+        if (!this.scenarioDict[resultObject.parent]) {
+          this.scenarioDict[resultObject.parent] = new AsyncTestStatus.AsyncScenarioStatus(result, "integration");
+        }
+        this.scenarioDict[resultObject.parent].requests.push(
+          new AsyncTestStatus.AsyncRequestStatus(result, "integration")
+        );
+      }
+    }
+  }
+
+  /**
+   * Returns the test id
+   * @returns {string} The test id
+   */
+  getTestId() {
+    return this.testId;
+  }
+
+  /**
+   * Returns the test type
+   * @returns {string} The test type
+   */
+  getTestType() {
+    return this.testType;
+  }
+
+  /**
+   * Get the scenario by name
+   * @param {string} scenarioName - The scenario name
+   * @returns {AsyncTestStatus.AsyncScenarioStatus} The scenario status object
+   */
+  getScenario(scenarioName) {
+    const scenarioList = this.getScenarios(scenarioName);
+    if (scenarioList.length === 1) {
+      return scenarioList[0];
+    }
+    if (scenarioList.length === 0) {
+      throw new Error(`Scenario ${scenarioName} not found in the test`);
+    }
+    if (scenarioList.length > 1) {
+      throw new Error(`Multiple scenarios found with the name ${scenarioName}, please iterate over the scenarios`);
+    }
+    return null;
+  }
+
+  /**
+   * Get scenarios, optionally filtered by name
+   * @param {string} [scenarioName=""] - Optional scenario name filter
+   * @returns {AsyncTestStatus.AsyncScenarioStatus[]} Array of scenario status objects
+   */
+  getScenarios(scenarioName = "") {
+    const scenarioList = Object.values(this.scenarioDict).sort(AsyncTestStatus.sortKeys);
+    if (scenarioName === "") {
+      return scenarioList;
+    }
+    const scenarios = [];
+    for (const scenario of scenarioList) {
+      if (scenario.name === scenarioName) {
+        scenarios.push(scenario);
+      }
+    }
+    return scenarios;
+  }
+
+  /**
+   * Get request by scenario and request name
+   * @param {string} scenarioName - The scenario name
+   * @param {string} requestName - The request name
+   * @returns {AsyncTestStatus.AsyncRequestStatus} The request status object
+   */
+  getRequest(scenarioName, requestName) {
+    const scenario = this.getScenario(scenarioName);
+    return scenario.getRequest(requestName);
+  }
+
+  /**
+   * Get the overall status
+   * @returns {Promise<Object>} The overall status as parsed JSON object
+   */
+  async getOverallStatus() {
+    return new Promise((resolve, reject) => {
+      getOverallStatusWrapper.async(
+        JSON.stringify(this.jsonResponse),
+        (err, res) => {
+          if (err) {
+            reject(err);
+          } else if (res.error) {
+            reject(new Error(res));
+          } else {
+            resolve(JSON.parse(res));
+          }
+        }
+      );
+    });
+  }
+
+  /**
+   * Create the appropriate TestStatus object based on the options
+   * @param {Object} options - The test status options
+   * @returns {AsyncTestStatus} The appropriate test status instance
+   */
+  static create(options) {
+    return new AsyncTestStatus(options);
+  }
+
+  /**
+   * Sorts entries based on their ID structure
+   * @param {Object} entry1 - First entry to compare
+   * @param {Object} entry2 - Second entry to compare
+   * @returns {number} Sort comparison result
+   */
+  static sortKeys(entry1, entry2) {
+    const entry1List = entry1.id.split('.');
+    const entry2List = entry2.id.split('.');
+
+    for (let i = 0; i < Math.min(entry1List.length, entry2List.length); i++) {
+      const part1 = entry1List[i];
+      const part2 = entry2List[i];
+
+      let part1Num, part2Num;
+      try {
+        part1Num = part1.substring(1).match(/^\d+$/) ? parseInt(part1.substring(1)) : part1;
+        part2Num = part2.substring(1).match(/^\d+$/) ? parseInt(part2.substring(1)) : part2;
+      } catch (e) {
+        part1Num = part1;
+        part2Num = part2;
+      }
+
+      if (part1Num !== part2Num) {
+        return part1Num < part2Num ? -1 : 1;
+      }
+    }
+
+    return entry1List.length - entry2List.length;
+  }
+}
+
+/**
+ * AsyncScenarioStatus inner class
+ */
+AsyncTestStatus.AsyncScenarioStatus = class {
+  /**
+   * Creates an AsyncScenarioStatus instance
+   * @param {Object} dataObject - The data object containing scenario information
+   * @param {string} testType - The type of test (load or integration)
+   */
+  constructor(dataObject, testType) {
+    this.testType = testType;
+    this.result = dataObject;
+    this.name = "";
+    this.overallStatus = {};
+    this.timeseries = [];
+    this.subScenarios = [];
+    this.requests = [];
+
+    if (testType === "load") {
+      const testStat = dataObject;
+      this.result = testStat;
+      this.name = testStat.description ? testStat.description.split('.').pop() : '';
+      this.id = testStat.id;
+      this.stats = testStat;
+      this.timeseries = null;
+    } else {
+      const rawResult = dataObject;
+      const descList = rawResult.description ? rawResult.description.split('.') : [''];
+      this.name = descList[descList.length - 1];
+      this.id = rawResult.id;
+      this.status = rawResult.status;
+      this.error = rawResult.error;
+      this.stepDescription = rawResult.stepDescription;
+      this.stepName = rawResult.stepName;
+    }
+  }
+
+  /**
+   * Returns string representation of the scenario status
+   * @returns {string} String representation
+   */
+  toString() {
+    if (this.testType === "load") {
+      return `AsyncScenarioStatus(name=${this.name}, status=${JSON.stringify(this.stats)}, sub_scenarios=${JSON.stringify(this.subScenarios)}, requests=${JSON.stringify(this.requests)})`;
+    }
+    return `AsyncScenarioStatus(name=${this.name}, status=${JSON.stringify(this.status)}, error=${this.error})`;
+  }
+
+  /**
+   * Get sub scenarios
+   * @returns {AsyncTestStatus.AsyncScenarioStatus[]} Array of sub scenarios
+   */
+  getSubScenarios() {
+    if (this.testType === "load") {
+      this.subScenarios.sort(AsyncTestStatus.sortKeys);
+    }
+    return this.subScenarios;
+  }
+
+  /**
+   * Get request by name from this scenario
+   * @param {string} requestName - The request name to find
+   * @returns {AsyncTestStatus.AsyncRequestStatus} The request status object
+   */
+  getRequest(requestName) {
+    const requestList = [];
+    for (const request of this.requests) {
+      if (request.resultObject.description && request.resultObject.description.endsWith('.' + requestName)) {
+        requestList.push(request);
+      }
+    }
+    if (requestList.length === 1) {
+      return requestList[0];
+    }
+    if (requestList.length === 0) {
+      throw new Error(`Request ${requestName} not found in the scenario`);
+    }
+    if (requestList.length > 1) {
+      throw new Error(`Multiple requests found with the name ${requestName}, please iterate over the requests`);
+    }
+    return null;
+  }
+
+  /**
+   * Get all requests
+   * @returns {AsyncTestStatus.AsyncRequestStatus[]} Array of request status objects
+   */
+  getRequests() {
+    this.requests.sort(AsyncTestStatus.sortKeys);
+    return this.requests;
+  }
+
+  /**
+   * Get overall status of the scenario
+   * @returns {Promise<string>} The overall status as JSON string
+   */
+  async getOverallStatus() {
+    // This method should not be used on scenario level, it should be called on the main AsyncTestStatus
+    throw new Error('getOverallStatus should be called on the main AsyncTestStatus object, not on individual scenarios');
+  }
+
+  /**
+   * Assert status (for integration tests)
+   * @returns {*} The status
+   */
+  assertStatus() {
+    return this.status;
+  }
+};
+
+/**
+ * AsyncRequestStatus inner class
+ */
+AsyncTestStatus.AsyncRequestStatus = class {
+  /**
+   * Creates an AsyncRequestStatus instance
+   * @param {Object} resultObject - The result object containing request data
+   * @param {string} testType - The type of test (load or integration)
+   */
+  constructor(resultObject, testType) {
+    this.testType = testType;
+    this.name = "";
+    this.id = "";
+    this.resultObject = resultObject;
+    this.jsonObject = resultObject;
+    this.asserts = [];
+
+    if (testType === "load") {
+      const testStat = resultObject;
+      this.testStatus = testStat;
+      this.name = testStat.description ? testStat.description.split('.').pop() : '';
+      this.id = testStat.id;
+    } else {
+      const rawResult = resultObject;
+      this.id = rawResult.id;
+      this.name = rawResult.description ? rawResult.description.split('.').pop() : '';
+    }
+  }
+
+  /**
+   * Returns string representation of the request status
+   * @returns {string} String representation
+   */
+  toString() {
+    if (this.testType === "load") {
+      return `AsyncRequestStatus(name=${this.name}, status=${JSON.stringify(this.resultObject)}, asserts=${JSON.stringify(this.asserts)})`;
+    }
+    return `AsyncRequestStatus(name=${this.resultObject.name}, status=${this.resultObject.status})`;
+  }
+
+  /**
+   * Converts the object to JSON
+   * @returns {Object} JSON representation of the request status
+   */
+  toJson() {
+    return {
+      name: this.name,
+      status: this.resultObject,
+      asserts: this.asserts.map(assert => assert.toJson ? assert.toJson() : assert)
+    };
+  }
+
+  /**
+   * Get the response of the load test for a specific status code
+   * @param {string} statusCode - The HTTP status code
+   * @param {string|null} [jsonPath=null] - Optional JSON path to extract specific data
+   * @returns {string|null} The response data or null if not found
+   */
+  getLoadTestResponse(statusCode, jsonPath = null) {
+    if (this.testType !== "load") {
+      throw new Error('getLoadTestResponse not implemented for integration test request status');
+    }
+
+    const jsonData = this.resultObject.logTable ? this.resultObject.logTable[statusCode] : null;
+    if (!jsonData) {
+      return null;
+    }
+    const jsonResponse = jsonData.Response;
+    if (jsonResponse) {
+      const payload = jsonResponse.payload;
+      if (!payload) {
+        return null;
+      }
+      if (jsonPath === null) {
+        return JSON.stringify(payload, null, 2);
+      }
+      return payload[jsonPath];
+    }
+    return null;
+  }
+
+  /**
+   * Get the response of the request
+   * @param {string|null} [jsonPath=null] - Optional JSON path
+   * @returns {string|null} The response data
+   */
+  getResponse(jsonPath = null) {
+    if (this.testType === "load") {
+      throw new Error('getResponse not implemented for load test request status');
+    }
+
+    const output = this.resultObject.output;
+    if (!output) {
+      return null;
+    }
+    if (jsonPath === null) {
+      return JSON.stringify(output.payload, null, 2);
+    }
+    return output.payload[jsonPath];
+  }
+
+  /**
+   * Get the value of the variable
+   * @param {string} key - The variable key
+   * @returns {string} The variable value
+   */
+  getVarValue(key) {
+    if (this.testType === "load") {
+      throw new Error('getVarValue not implemented for load test request status');
+    }
+
+    const stateObject = this.resultObject.state;
+    if (stateObject) {
+      if (stateObject.exports && key in stateObject.exports && stateObject.exports[key] !== null) {
+        return stateObject.exports[key];
+      }
+      if (stateObject.vars && key in stateObject.vars && stateObject.vars[key] !== null) {
+        return stateObject.vars[key];
+      }
+      if (stateObject.scenarioVars && key in stateObject.scenarioVars && stateObject.scenarioVars[key] !== null) {
+        return stateObject.scenarioVars[key];
+      }
+    }
+    throw new Error(`Key ${key} not found in the async data`);
+  }
+};
+
+module.exports = AsyncTestStatus;

package/src/classes/DelayConfig.d.ts

@@ -0,0 +1,4 @@
+export declare class DelayConfig { 
+  constructor(minDelay: number, maxDelay: number);
+  toJson(): JSON;
+}

package/src/classes/DelayConfig.js

@@ -0,0 +1,25 @@
+/**
+ * The `DelayConfig` class represents a configuration for delay values.
+ * @class
+ */
+class DelayConfig {    
+    /**
+     * Initializes a new instance of the DelayConfig class with the provided minimum and maximum delay values.
+     * @constructor
+     * @param {number} minDelay - The minimum delay value.
+     * @param {number} maxDelay - The maximum delay value.
+     */
+    constructor(minDelay, maxDelay) {
+        this.minDelay = minDelay;
+        this.maxDelay = maxDelay;
+    }
+
+    toJson() {
+        return {
+            minDelay: this.minDelay,
+            maxDelay: this.maxDelay,
+        };
+    }
+}
+
+module.exports = DelayConfig;

package/src/classes/Endpoint.d.ts

@@ -1,6 +1,6 @@
 export declare class Endpoint {
-  constructor(endpointData: string);
-  mockMethod(methodName: string, mockData: string, dynamic?: boolean): void;
+  constructor(endpointData: string, endpointAddress: string);
+  mockMethod(methodName: string, mockObject: string, dynamic?: boolean): void;
   mockMethodFromFile(methodName: string, fileName: string): void;
   writeMockConfigurationToFile(kubernetesService: string): Promise<void>;
 }

package/src/classes/Endpoint.js

@@ -1,73 +1,111 @@
 const lib = require('../lib');
-const yaml = require('js-yaml');
+const { getYamlBytes, readDataFromFile, SKYRAMP_YAML_VERSION } = require('../utils');
 const writeMockDescriptionWrapper = lib.func('writeMockDescriptionWrapper', 'string', ['string', 'string']);
-const { readDataFromFile } = require('../utils');
 
+/**
+ * The `Endpoint` class represents an endpoint object to manage endpoint data and generate mock configurations.
+ * @class
+ */
 class Endpoint {
-  constructor(endpointData) {
+  /**
+   * Intialize a new instance of an endpoint.
+   * @private
+   * @constructor
+   * @param {string} endpointData - The endpoint data in JSON format.
+   * @param {string} endpointAddress - The address of the endpoint.
+   * @throws {Error} If the endpoint data is invalid JSON.
+   */
+  constructor(endpointData, endpointAddress) {
     try {
       const endpoint = JSON.parse(endpointData);
       this.services = endpoint.services;
       this.endpoint = endpoint.endpoints[0];
-      for (const method of this.endpoint.methods) {
-        method.proxy = true;
+
+      if (endpointAddress && this.services.length > 0) {
+        for (const service of this.services) {
+          service.addr = endpointAddress;
+          delete service.alias;
+        }
       }
-      this.responseValues = endpoint.responseValues;
+      this.responses = endpoint.responses;
+
       this.mockDescription = {
+        version: SKYRAMP_YAML_VERSION,
         services: this.services,
         endpoints: [this.endpoint],
-        responseValues: this.responseValues
+        responses: this.responses
       };
-    } catch(error) {
+    } catch (error) {
       throw new Error(endpointData);
     }
   }
 
-  mockMethod(methodName, mockData, dynamic=false) {
-    for (const method of this.endpoint.methods) {
-      if (method.name === methodName || method.type === methodName) {
-        const responseName = method.responseValue;
-        delete method.proxy;
-        for (const responseValue of this.responseValues) {
-          if (responseValue.name === responseName) {
-            if (dynamic) {
-              responseValue.javascriptPath = mockData;
-              delete responseValue.blob;
-            } else {
-              responseValue.blob = mockData;
-              delete responseValue.javascriptPath;
-            }
-            return;
-          }
+  getMethodNameForMethodType(method_type) {
+    const matchingMethod = this.endpoint.methods.find(method => method.type === method_type);
+    if (!matchingMethod) {
+      throw new Error(`Method ${method_type} not found`);
+    }
+    return matchingMethod.name;
+  }
+
+  mockMethod(methodName, mockObject, dynamic = false) {
+    if (!this.endpoint.methods.some(method => method.name === methodName)) {
+      throw new Error(`Method ${methodName} not found`);
+    }
+
+    for (const response of this.responses) {
+      if (response.methodName === methodName && response.endpointName === this.endpoint.name) {
+        if (dynamic) {
+          response.javascriptPath = mockObject;
+          delete response.blob;
+        } else {
+          response.blob = mockObject.responseValue.blob;
+          delete response.javascriptPath;
         }
+
+        return;
       }
     }
-    throw new Error(`Method ${methodName} not found`);
+
+    let newResponse = {
+      methodName: methodName,
+      endpointName: this.endpoint.name
+    };
+
+    if (dynamic) {
+      if (mockObject.responseValue.javascriptPath !== undefined
+          && mockObject.responseValue.javascriptPath !== null) {
+        newResponse.javascriptPath = mockObject.responseValue.javascriptPath
+      } else if (mockObject.responseValue.javascript !== undefined
+          && mockObject.responseValue.javascript !== null) {
+        newResponse.javascript = mockObject.responseValue.javascript;
+      }
+    } else {
+      newResponse.blob = mockObject.responseValue.blob;
+    }
+
+    this.responses.append(newResponse);
   }
 
   mockMethodFromFile(methodName, fileName) {
-    const [jsonString, dynamic] = readDataFromFile(fileName);
-    return this.mockMethod(methodName, jsonString, dynamic);
+    const [jsonData, dynamic] = readDataFromFile(fileName);
+    return this.mockMethod(methodName, jsonData, dynamic);
   }
 
   writeMockConfigurationToFile(kubernetesService) {
-    try {
-      const yamlContent = yaml.dump(this.mockDescription);
-      return new Promise((resolve, reject) => {
-        writeMockDescriptionWrapper.async(yamlContent, kubernetesService, (err, res) => {
-          if (err) {
-            reject(err);
-          } else if (res) {
-            reject(new Error(res));
-          } else {
-            resolve();
-          }
-        });
+    const yamlContent = getYamlBytes(this.mockDescription);
+    return new Promise((resolve, reject) => {
+      writeMockDescriptionWrapper.async(yamlContent, kubernetesService, (err, res) => {
+        if (err) {
+          reject(err);
+        } else if (res) {
+          reject(new Error(res));
+        } else {
+          resolve();
+        }
       });
-    } catch (error) {
-      throw new Error('Error converting to YAML bytes:', error);
-    }
+    });
   }
 }
 
-module.exports = Endpoint;
+module.exports = Endpoint;

package/src/classes/GrpcEndpoint.d.ts

@@ -1,4 +1,4 @@
 import { Endpoint } from './Endpoint';
 export declare class GrpcEndpoint extends Endpoint {
-  constructor(name: string, service: string, port: number, pbFile: string);
+  constructor(name: string, service: string, port: number, pbFile: string, endpointAddress: string);
 }