@skyramp/skyramp 1.0.0-sha.b2dfe11 → 1.2.2

package/src/classes/AsyncScenario.js

@@ -0,0 +1,324 @@
+const RequestV2 = require('./RequestV2');
+
+/**
+ * Generates a REST path name from path and method
+ * @param {string} path - The REST path
+ * @param {string} method - The HTTP method
+ * @returns {string} The generated path name
+ */
+function getRestPathName(path, method) {
+  if (!path || !method) return '';
+  
+  // Remove leading slash and replace special characters
+  const cleanPath = path.replace(/^\//, '').replace(/[{}/]/g, '_');
+  return `${cleanPath}_${method.toLowerCase()}`;
+}
+
+/**
+ * Wrapper class for RequestV2 object in async scenarios
+ */
+class AsyncRequest {
+  /**
+   * Creates an AsyncRequest instance
+   * @param {AsyncScenario} scenario - The parent scenario
+   * @param {RequestV2} request - The request object
+   * @param {number} stepIndex - The step index in the scenario
+   */
+  constructor(scenario, request, stepIndex) {
+    this.scenario = scenario;
+    this.request = request;
+    this.stepIndex = stepIndex;
+  }
+
+  /**
+   * Returns request's response value construct for asynchronous backend
+   * @param {string|null} path - The path to the value
+   * @returns {string} The async request value reference
+   */
+  getAsyncRequestValue(path) {
+    if (path === null || path === undefined) {
+      return `requests.${this.request.name}.res`;
+    }
+    return `requests.${this.request.name}.res.${path}`;
+  }
+
+  /**
+   * Returns request's status check construct for asynchronous backend
+   * @param {string|number} code - The expected status code
+   * @returns {string} The status check expression
+   */
+  requestStatusCheck(code) {
+    return `requests.${this.request.name}.code == ${code}`;
+  }
+
+  /**
+   * Adds an assert to the request
+   * @param {string} jsonPath - The JSON path to the value
+   * @param {*} expectedValue - The expected value
+   */
+  assertEqual(jsonPath, expectedValue) {
+    this.scenario.steps[this.stepIndex].asyncAsserts.push(
+      `${this.getAsyncRequestValue(jsonPath)} == ${expectedValue}`
+    );
+  }
+
+  /**
+   * Adds a not equal assert to the request
+   * @param {string} jsonPath - The JSON path to the value
+   * @param {*} value - The value to compare against
+   */
+  assertNotEqual(jsonPath, value) {
+    this.scenario.steps[this.stepIndex].asyncAsserts.push(
+      `${this.getAsyncRequestValue(jsonPath)} != ${value}`
+    );
+  }
+}
+
+/**
+ * Represents a testing scenario for asynchronous operations
+ */
+class AsyncScenario {
+  /**
+   * Creates an AsyncScenario instance
+   * @param {Object} options - The scenario options
+   * @param {string} options.name - The name of the scenario
+   * @param {boolean} [options.ignoreFailure=false] - Whether to ignore failures
+   */
+  constructor(options) {
+    if (typeof options === 'string') {
+      // Backward compatibility: if a string is passed, treat it as the name
+      console.warn('Deprecated: AsyncScenario constructor now expects an object. Please use new AsyncScenario({name: "scenarioName"})');
+      options = { name: options, ignoreFailure: arguments[1] || false };
+    }
+    
+    const { name, ignoreFailure = false } = options;
+    
+    this.name = name;
+    this.steps = [];
+    this.vars = {};
+    this.until = "";
+    this.maxRetries = 5;
+    this.retryInterval = 1;
+    this.ignoreFailure = ignoreFailure;
+  }
+
+  /**
+   * Adds an asynchronous request to this scenario
+   * @param {Object} [options={}] - The request options
+   * @param {string} [options.name] - The name of the request
+   * @param {string} [options.url] - The URL of the request
+   * @param {string} [options.path] - The path of the request
+   * @param {string} [options.method] - The HTTP method of the request (e.g., GET, POST)
+   * @param {string} [options.body] - The body of the request
+   * @param {Object} [options.headers] - The headers of the request
+   * @param {Object} [options.pathParams] - The path parameters of the request
+   * @param {Object} [options.queryParams] - The query parameters of the request
+   * @param {Object} [options.formParams] - The form parameters of the request
+   * @param {Array} [options.multipartParams] - The multipart parameters of the request
+   * @param {Object} [options.dataOverride] - The data override for the request
+   * @param {string} [options.description] - The description of the request
+   * @param {string} [options.expectedCode] - The expected HTTP status code of the request
+   * @param {string} [options.if_=""] - The condition to execute the request
+   * @param {string} [options.until] - The condition to stop retrying
+   * @param {number} [options.maxRetries] - The maximum number of retries
+   * @param {number} [options.retryInterval] - The interval between retries
+   * @returns {AsyncRequest} The created async request object
+   */
+  addAsyncRequest(options = {}) {
+    const {
+      name,
+      url,
+      path,
+      method,
+      body,
+      headers,
+      pathParams,
+      queryParams,
+      formParams,
+      multipartParams,
+      dataOverride,
+      description,
+      expectedCode,
+      if_ = "",
+      until,
+      maxRetries,
+      retryInterval
+    } = options;
+
+    const request = new RequestV2({
+      name,
+      url,
+      path,
+      method,
+      body,
+      headers,
+      pathParams,
+      queryParams,
+      formParams,
+      multipartParams,
+      dataOverride,
+      description
+    });
+
+    if (!name && path && method) {
+      request.name = getRestPathName(path, method);
+    }
+
+    const stepRequest = request.asRequestDict();
+    if (if_ !== "") {
+      stepRequest.if = if_;
+    }
+    if (until !== "") {
+      stepRequest.repeat = {
+        until: until,
+        maxRetries: maxRetries,
+        interval: retryInterval
+      };
+    }
+    stepRequest.type = "request";
+    stepRequest.varOverride = {};
+    stepRequest.varExport = {};
+    stepRequest.asyncAsserts = [];
+    
+    if (expectedCode) {
+      stepRequest.asyncAsserts.push(
+        `requests.${request.name}.code == ${expectedCode}`
+      );
+    }
+    
+    this.steps.push(stepRequest);
+    const stepIndex = this.steps.length - 1;
+    return new AsyncRequest(this, request, stepIndex);
+  }
+
+  /**
+   * Adds an asynchronous nested scenario to this scenario
+   * @param {AsyncScenario} nestedScenario - The nested scenario to add
+   * @param {string} [until=""] - The condition to stop retrying
+   * @param {number} [maxRetries=5] - The maximum number of retries
+   * @param {number} [retryInterval=1] - The interval between retries
+   */
+  addAsyncScenario(nestedScenario, until = "", maxRetries = 5, retryInterval = 1) {
+    const stepScenario = {
+      type: "scenario",
+      scenario: nestedScenario
+    };
+    this.until = until;
+    if (this.until !== "") {
+      this.maxRetries = maxRetries;
+      this.retryInterval = retryInterval;
+    }
+    this.steps.push(stepScenario);
+  }
+
+  /**
+   * Sets a scenario level variable
+   * @param {string} varName - The name of the variable
+   * @param {*} value - The value of the variable
+   */
+  setAsyncVar(varName, value) {
+    if (this.vars === null || this.vars === undefined) {
+      this.vars = {};
+    }
+    this.vars[varName] = value;
+  }
+
+  /**
+   * Returns scenario's variable construct for asynchronous backend
+   * @param {string} varName - The name of the variable
+   * @returns {string} The variable reference
+   */
+  getAsyncVar(varName) {
+    return `vars.${varName}`;
+  }
+
+  /**
+   * Returns scenario's response value construct for asynchronous backend
+   * @param {string} varName - The name of the variable
+   * @returns {string} The scenario value reference
+   */
+  getAsyncScenarioValue(varName) {
+    return `scenarios.${this.name}.${varName}`;
+  }
+
+  /**
+   * Sets a scenario level variable for export
+   * @param {string} varName - The name of the variable
+   * @param {*} value - The value of the variable
+   */
+  exportAsyncVar(varName, value) {
+    this.steps.push({
+      type: "varExport",
+      name: varName,
+      value: value
+    });
+  }
+
+  /**
+   * Adds an assert to the scenario
+   * @param {string} value - The value to assert
+   */
+  addAssert(value) {
+    this.steps.push({
+      type: "assert",
+      assert: value
+    });
+  }
+
+  /**
+   * Converts this scenario to JSON
+   * @returns {Object} The JSON representation of the scenario
+   */
+  toJson() {
+    const steps = [];
+    for (const step of this.steps) {
+      if (step.type === "request") {
+        // Extract the request-specific fields and wrap them properly
+        const { varOverride, varExport, asyncAsserts, ...requestFields } = step;
+        
+        // Convert requestName back to name for proper format
+        if (requestFields.requestName) {
+          requestFields.name = requestFields.requestName;
+          delete requestFields.requestName;
+        }
+        
+        // Create the request object with varOverride and varExport
+        const requestObj = {
+          ...requestFields,
+          varOverride: varOverride || {},
+          varExport: varExport || {}
+        };
+        
+        // Add asyncAsserts if present
+        if (asyncAsserts && asyncAsserts.length > 0) {
+          requestObj.asyncAsserts = asyncAsserts;
+        }
+        
+        steps.push({ request: requestObj });
+      } else if (step.type === "scenario") {
+        if (step.scenario instanceof AsyncScenario) {
+          steps.push({ scenario: step.scenario.toJson() });
+        }
+      } else if (step.type === "varExport") {
+        const exportObj = {};
+        exportObj[step.name] = step.value;
+        steps.push({ varExport: exportObj });
+      }
+    }
+
+    return {
+      name: this.name,
+      steps: steps,
+      vars: this.vars,
+      until: this.until,
+      maxRetries: this.maxRetries,
+      interval: this.retryInterval,
+      ignoreFailure: this.ignoreFailure
+    };
+  }
+}
+
+module.exports = {
+  AsyncScenario,
+  AsyncRequest
+};

package/src/classes/AsyncTestStatus.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Unified AsyncTestStatus class for handling all test status operations
+ */
+declare class AsyncTestStatus {
+  testStatus: Record<string, object>;
+  testId: string;
+  testType: string;
+  scenarioDict: Record<string, AsyncTestStatus.AsyncScenarioStatus>;
+
+  /**
+   * Creates an AsyncTestStatus instance
+   * @param options The test status options
+   */
+  constructor(options: Record<string, object>);
+
+  /**
+   * Returns the test id
+   */
+  getTestId(): string;
+
+  /**
+   * Returns the test type
+   */
+  getTestType(): string;
+
+  /**
+   * Get the scenario by name
+   * @param scenarioName The scenario name
+   */
+  getScenario(scenarioName: string): AsyncTestStatus.AsyncScenarioStatus;
+
+  /**
+   * Get scenarios, optionally filtered by name
+   * @param scenarioName Optional scenario name filter
+   */
+  getScenarios(scenarioName?: string): AsyncTestStatus.AsyncScenarioStatus[];
+
+  /**
+   * Get request by scenario and request name
+   * @param scenarioName The scenario name
+   * @param requestName The request name
+   */
+  getRequest(scenarioName: string, requestName: string): AsyncTestStatus.AsyncRequestStatus;
+
+  /**
+   * Get the overall status
+   */
+  getOverallStatus(): Promise<string>;
+
+  /**
+   * Create the appropriate TestStatus object based on the options
+   * @param options The test status options
+   */
+  static create(options: Record<string, object>): AsyncTestStatus;
+
+  /**
+   * Sorts entries based on their ID structure
+   * @param entry1 First entry to compare
+   * @param entry2 Second entry to compare
+   */
+  static sortKeys(entry1: object, entry2: object): number;
+}
+
+declare namespace AsyncTestStatus {
+  /**
+   * AsyncScenarioStatus inner class
+   */
+  class AsyncScenarioStatus {
+    testType: string;
+    result: object;
+    name: string;
+    id: string;
+    overallStatus: Record<string, object>;
+    timeseries: Record<string, object>;
+    subScenarios: AsyncScenarioStatus[];
+    requests: AsyncRequestStatus[];
+    stats?: object;
+    status?: object;
+    error?: object;
+    stepDescription?: object;
+    stepName?: string;
+
+    /**
+     * Creates an AsyncScenarioStatus instance
+     * @param dataObject The data object containing scenario information
+     * @param testType The type of test (load or integration)
+     */
+    constructor(dataObject: object, testType: string);
+
+    /**
+     * Returns string representation of the scenario status
+     */
+    toString(): string;
+
+    /**
+     * Get sub scenarios
+     */
+    getSubScenarios(): AsyncScenarioStatus[];
+
+    /**
+     * Get request by name from this scenario
+     * @param requestName The request name to find
+     */
+    getRequest(requestName: string): AsyncRequestStatus;
+
+    /**
+     * Get all requests
+     */
+    getRequests(): AsyncRequestStatus[];
+
+    /**
+     * Get overall status of the scenario
+     */
+    getOverallStatus(): Promise<string>;
+
+    /**
+     * Assert status (for integration tests)
+     */
+    assertStatus(): object;
+  }
+
+  /**
+   * AsyncRequestStatus inner class
+   */
+  class AsyncRequestStatus {
+    testType: string;
+    name: string;
+    id: string;
+    resultObject: object;
+    jsonObject: string;
+    asserts: object[];
+    testStatus?: object;
+
+    /**
+     * Creates an AsyncRequestStatus instance
+     * @param resultObject The result object containing request data
+     * @param testType The type of test (load or integration)
+     */
+    constructor(resultObject: object, testType: string);
+
+    /**
+     * Returns string representation of the request status
+     */
+    toString(): string;
+
+    /**
+     * Converts the object to JSON
+     */
+    toJson(): Record<string, object>;
+
+    /**
+     * Get the response of the load test for a specific status code
+     * @param statusCode The HTTP status code
+     * @param jsonPath Optional JSON path to extract specific data
+     */
+    getLoadTestResponse(statusCode: string, jsonPath?: string | null): string | null;
+
+    /**
+     * Get the response of the request
+     * @param jsonPath Optional JSON path
+     */
+    getResponse(jsonPath?: string | null): string | null;
+
+    /**
+     * Get the value of the variable
+     * @param key The variable key
+     */
+    getVarValue(key: string): string;
+  }
+}
+
+export = AsyncTestStatus;