@skyramp/skyramp 1.0.0-sha.b2dfe11 → 1.2.2

package/src/classes/SkyrampClient.js

@@ -1,24 +1,155 @@
 const lib = require('../lib');
-const yaml = require('js-yaml');
+const koffi = require('koffi');
+const TrafficConfig = require('./TrafficConfig');
+const RequestV2 = require('./RequestV2');
+const ResponseV2 = require('./ResponseV2');
 
+const workerInfoType = koffi.struct({
+  container_name: 'char*',
+  error: 'char*',
+});
+
+const testerInfoType = koffi.struct({
+  tester_id: 'char*',
+  error: 'char*',
+});
+
+const testerGenerateType = koffi.struct({
+  generated_files: 'char*',
+  error: 'char*',
+});
+
+const contractResponseType = koffi.struct({
+  response: 'char*',
+  error: 'char*',
+});
+
+const WORKER_URL = "public.ecr.aws/j1n2c2p2/rampup/worker";
+const WORKER_TAG = "latest";
+const CONTAINER_PORT = 35142;
+
+// k8s related
+const { createTestDescriptionFromScenario, getYamlBytes, readDataFromFile, SKYRAMP_YAML_VERSION } = require('../utils');
 const applyLocalWrapper = lib.func('applyLocalWrapper', 'string', []);
-const addKubeconfigWrapper = lib.func('addKubeconfigWrapper', 'string', ['string', 'bool', 'string', 'string']);
-const deleteSkyrampWorkerWrapper = lib.func('deleteSkyrampWorkerWrapper', 'string', ['string'])
-const deploySkyrampWorkerWrapper = lib.func('deploySkyrampWorkerWrapper', 'string', ['string', 'string', 'bool']);
+const addKubeconfigWrapper = lib.func('addKubeconfigWrapper', 'string', ['string', 'string', 'string']);
+const deleteSkyrampWorkerWrapper = lib.func('deleteSkyrampWorkerWrapper', 'string', ['string', 'string', 'string', 'string'])
+const deploySkyrampWorkerWrapper = lib.func('deploySkyrampWorkerWrapper', 'string', ['string', 'string', 'string', 'string', 'string', 'bool']);
 const getKubeConfigPath = lib.func('getKubeConfigPath', 'string', []);
 const removeLocalWrapper = lib.func('removeLocalWrapper', 'string', []);
 const removeClusterFromConfigWrapper = lib.func('removeClusterFromConfigWrapper', 'string', ['string']);
-const applyMockDescriptionWrapper = lib.func('applyMockDescriptionWrapper', 'string', ['string', 'string']);
+// docker related
+const newStartDockerSkyrampWorkerWrapper = lib.func('newStartDockerSkyrampWorkerWrapper', workerInfoType, ['string', 'string', 'int', 'string', 'string']);
+const newDeleteDockerSkyrampWorkerWrapper = lib.func('newDeleteDockerSkyrampWorkerWrapper', 'string', ['string']);
+// tester related
+const runTesterStartWrapper = lib.func('runTesterStartWrapper', testerInfoType, ['string', 'string', 'string', 'string', 'string', 'string', 'bool']);
+// mocker related
+const runTesterStartWrapperv1 = lib.func('runTesterStartWrapperWithGlobalHeaders', testerInfoType, ['string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'bool', 'bool', 'string', 'string', 'string']);
+const applyMockDescriptionWrapper = lib.func('applyMockDescriptionWrapper', 'string', ['string', 'string', 'string', 'string', 'string', 'string', 'string', 'string']);
+// NPM only: for VS code extension use
+const initTargetWrapper = lib.func('initTargetWrapper', 'string', ['string']);
+const deployTargetWrapper = lib.func('deployTargetWrapper', 'string', ['string', 'string', 'string', 'string', 'string', 'string', 'bool']);
+const deleteTargetWrapper = lib.func('deleteTargetWrapper', 'string', ['string', 'string', 'string', 'string', 'string']);
+const runTesterGenerateRestWrapper = lib.func('runTesterGenerateRestWrapper', testerGenerateType, ['string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'int', 'bool', 'bool', 'bool']);
+
+const generateRestTestWrapper = lib.func('generateRestTestWrapper', 'string', ['string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'bool', 'bool', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'bool', 'string', 'bool', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'bool', 'string', 'string']);
+const traceCollectWrapper = lib.func('traceCollectWrapper', 'string', ['string', 'string', 'bool', 'string']);
+const analyzeOpenapiWrapper = lib.func('analyzeOpenapiWrapper', 'string', ['string', 'string']);
+
+// Load test scenario support
+const sendScenarioWrapper = lib.func('sendScenarioWrapper', contractResponseType, ['string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'bool', 'bool', 'bool']);
+
+// contract test
+// func sendRequestWrapper(address, namespace, kubePath, kubeContext, clusterName, request, dockerNetwork, workerImage *C.char, localImage bool) *C.char {
+const sendRequestWrapper = lib.func('sendRequestWrapper', contractResponseType, ['string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'bool']);
 
+// dashboard
+const deployDockerDashboardWrapper = lib.func('deployDockerDashboardWrapper', 'string', ['string']);
+const deployK8sDashboardWrapper = lib.func('deployK8sDashboardWrapper', 'string', ['string']);
+
+/**
+ * The `SkyrampClient` class is the main client that provides methods for interacting with the Skyramp service.
+ * It allows users to manage Kubernetes clusters, deploy and delete workers and targets, apply mock descriptions, and start tests.
+ *
+ * @class
+ * @name SkyrampClient
+ */
 class SkyrampClient {
-  constructor(kubeconfigPath, clusterName, context, ingress) {
-    this.workerNamespaces = [];
-    this.mockedEndpoints = [];
-    if (kubeconfigPath || clusterName || context || ingress) {
-      this.addKubeconfig(clusterName, context, ingress, kubeconfigPath);
+  /**
+   * Initializes a new instance of the SkyrampClient class.
+   * @constructor
+   * @param {string|Object} kubeconfigPathOrOptions - Either the path to kubeconfig file or an options object
+   * @param {string} [kubeconfigPathOrOptions.kubeconfigPath] - The path to the kubeconfig file
+   * @param {string} [kubeconfigPathOrOptions.clusterName] - The name of the cluster
+   * @param {string} [kubeconfigPathOrOptions.context] - The context of the cluster
+   * @param {string} [kubeconfigPathOrOptions.userToken] - The user token for authentication
+   * @param {string} [kubeconfigPathOrOptions.address] - The address of the service
+   * @param {string} [kubeconfigPathOrOptions.dockerSkyrampPort] - The docker port for skyramp worker
+   * @param {string} [kubeconfigPathOrOptions.dockerNetwork] - The docker network for skyramp worker
+   * @param {string} [kubeconfigPathOrOptions.workerImage=""] - The worker image to use
+   * @param {string} [kubeconfigPathOrOptions.local_image=false] - The flag to indicate if the worker image is local
+   * @param {string} [clusterName] - The name of the cluster (when using individual parameters)
+   * @param {string} [context] - The context of the cluster (when using individual parameters)
+   * @param {string} [userToken] - The user token for authentication (when using individual parameters)
+   * @param {string} [directory=process.cwd()] - The working directory of the client.
+   */
+  constructor(kubeconfigPathOrOptions, clusterName, context, userToken, directory = process.cwd()) {
+    this.local_image = false;
+    if (typeof kubeconfigPathOrOptions === 'object') {
+      const options = kubeconfigPathOrOptions;
+      this.workerNamespaces = [];
+      this.userToken = options.userToken;
+      this.address = options.address;
+      // set docker params
+      if (options.runtime == "docker") {
+        if (options.dockerSkyrampPort) {
+          this.address = `localhost:${options.dockerSkyrampPort}`;
+        }
+        if (options.dockerNetwork) {
+          this.dockerNetwork = options.dockerNetwork;
+        }
+      }
+      // set k8s params
+      if (options.runtime == "k8s") {
+        if (options.k8SNamespace) {
+          this.namespace = options.k8SNamespace;
+        }
+        if (options.clusterName) {
+          this.clusterName = options.clusterName;
+        }
+        if (options.k8SContext) {
+          this.context = options.k8SContext;
+        }
+        if (options.k8SConfigPath) {
+          this.kubeconfigPath = options.k8SConfigPath;
+        }
+      }
+
+      if (this.kubeconfigPath || this.clusterName || this.context) {
+        this.addKubeConfig(this.context, this.clusterName, this.kubeconfigPath);
+      }
+      // set default worker image
+      if (options.workerImage) {
+        this.workerImage = options.workerImage;
+      }
+      if (options.local_image) {
+        this.local_image = options.local_image;
+      }
+    } else {
+      if (kubeconfigPathOrOptions || clusterName || context) {
+        this.addKubeConfig(context, clusterName, kubeconfigPathOrOptions);
+      }
+      this.workerNamespaces = [];
+      this.userToken = userToken;
+      this.projectPath = directory;
+      this.failedResponses = [];
     }
   }
 
+  /**
+   * Applies local changes to the Kubernetes cluster configuration.
+   *
+   * @returns {Promise} A promise that resolves when the local changes are successfully applied, or rejects with an error if any error occurs.
+   */
   async applyLocal() {
     return new Promise((resolve, reject) => {
       applyLocalWrapper.async((err, res) => {
@@ -29,15 +160,23 @@ class SkyrampClient {
         } else {
           this.kubeConfigPath = getKubeConfigPath();
           if (this.kubeConfigPath == "") {
-              reject(new Error("no kubeconfig found"));
+            reject(new Error("no kubeconfig found"));
           } else {
-              resolve();
+            resolve();
           }
         }
       });
     });
   }
 
+  /**
+   * Adds a Kubernetes configuration to the SkyrampClient object.
+   *
+   * @param {string} context - The context of the Kubernetes configuration.
+   * @param {string} clusterName - The name of the Kubernetes cluster.
+   * @param {string} kubeConfigPath - The path to the kubeconfig file.
+   * @returns {Promise} - A Promise that resolves if the operation is successful or rejects with an error if an error occurs.
+   */
   async addKubeConfig(context, clusterName, kubeConfigPath) {
     return new Promise((resolve, reject) => {
       addKubeconfigWrapper.async(context, clusterName, kubeConfigPath, (err, res) => {
@@ -53,14 +192,11 @@ class SkyrampClient {
     });
   }
 
-  async removeCluster(clusterName) {
-    if (clusterName) {
-      return this.removeClusterFromConfig(clusterName);
-    } else {
-      return this.removeLocal();
-    }
-  }
-
+  /**
+   * Removes the local configuration of the SkyrampClient.
+   *
+   * @returns {Promise<void>} A promise that resolves when the removal is successful, or rejects with an error if an error occurs during the removal process.
+   */
   async removeLocal() {
     return new Promise((resolve, reject) => {
       removeLocalWrapper.async((err, res) => {
@@ -75,7 +211,13 @@ class SkyrampClient {
     });
   }
 
-  async removeClusterFromConfig(clusterName) {
+  /**
+   * Asynchronously removes a cluster from the configuration.
+   *
+   * @param {string} clusterName - The name of the cluster to be removed from the configuration.
+   * @returns {Promise} A Promise that resolves if the cluster is successfully removed, or rejects with an error if the removal fails.
+   */
+  async removeCluster(clusterName) {
     return new Promise((resolve, reject) => {
       removeClusterFromConfigWrapper.async(clusterName, (err, res) => {
         if (err) {
@@ -89,12 +231,18 @@ class SkyrampClient {
     });
   }
 
-  async deploySkyrampWorker(namespace, workerImage='', localImage=false) {
-    if (this.kubeConfigPath === null) {
-      throw new Error('No cluster to deploy worker to.');
-    }
+  /**
+   * Deploys a worker to a Kubernetes cluster.
+   *
+   * @param {string} namespace - The namespace where the worker will be deployed.
+   * @param {string} [workerImage=''] - The image of the worker to be deployed.
+   * @param {boolean} [localImage=false] - Indicates whether the worker image is local or not.
+   * @returns {Promise} - A Promise that resolves if deployment is successful, and rejects with an error if any error occurs during deployment.
+   * @throws {Error} - If there is no cluster to deploy the worker to.
+   */
+  async deploySkyrampWorker(namespace, workerImage = '', localImage = false, kubePath = '', kubeContext = '', clusterName = '') {
     return new Promise((resolve, reject) => {
-      deploySkyrampWorkerWrapper.async(namespace, workerImage, localImage, (err, res) => {
+      deploySkyrampWorkerWrapper.async(namespace, kubePath, kubeContext, clusterName, workerImage, localImage, (err, res) => {
         if (err) {
           reject(err);
         } else if (res) {
@@ -107,7 +255,14 @@ class SkyrampClient {
     });
   }
 
-  async deleteSkyrampWorker(namespace) {
+  /**
+   * Deletes a worker from a specified namespace in the SkyrampClient class.
+   *
+   * @param {string} namespace - The namespace from which the worker should be deleted.
+   * @returns {Promise} - A promise that resolves with no value upon successful deletion.
+   * @throws {Error} - If there is no cluster to delete the worker from or if there is no worker to delete from the specified namespace.
+   */
+  async deleteSkyrampWorker(namespace, kubePath = '', kubeContext = '', clusterName = '') {
     if (this.kubeConfigPath === null) {
       throw new Error('No cluster to delete worker from.');
     }
@@ -116,7 +271,7 @@ class SkyrampClient {
       throw new Error(`No worker to delete from ${namespace} namespace.`);
     }
     return new Promise((resolve, reject) => {
-      deleteSkyrampWorkerWrapper.async(namespace, (err, res) => {
+      deleteSkyrampWorkerWrapper.async(namespace, kubePath, kubeContext, clusterName, (err, res) => {
         if (err) {
           reject(err);
         } else if (res) {
@@ -129,24 +284,603 @@ class SkyrampClient {
     });
   }
 
-  async apply(namespace, endpoint) {
-    try {
-      const yamlContent = yaml.dump(endpoint.mockDescription);
-      return new Promise((resolve, reject) => {
-        applyMockDescriptionWrapper.async(namespace, yamlContent, (err, res) => {
+  /**
+   * Asynchronous method that runs a Docker worker using the provided image, tag, port, and network name.
+   *
+   * @param {string} [workerImage=WORKER_URL] - The URL of the Docker worker image.
+   * @param {string} [workerTag=WORKER_TAG] - The tag of the Docker worker image.
+   * @param {number} [hostPort=CONTAINER_PORT] - The port on the host machine to expose for the Docker worker.
+   * @param {string} targetNetworkName - The name of the network to connect the Docker worker to.
+   * @returns {Promise} - A Promise that resolves if the Docker worker starts successfully and rejects if there is an error starting the worker.
+   */
+  async runDockerSkyrampWorker(workerImage = WORKER_URL, workerTag = WORKER_TAG, hostPost = CONTAINER_PORT, targetNetworkName = "", testServiceAlias = "") {
+    return new Promise((resolve, reject) => {
+      newStartDockerSkyrampWorkerWrapper.async(workerImage, workerTag, hostPost, targetNetworkName, testServiceAlias, (err, res) => {
+        if (err) {
+          reject(err);
+        } else if (res.error) {
+          reject(new Error(res.error));
+        } else {
+          resolve(res.container_name);
+        }
+      });
+    });
+  }
+
+  /**
+   * Asynchronous method that removes a Docker container running the Skyramp worker.
+   *
+   * @param {string} containerName - The name of the Docker container to be removed.
+   * @returns {Promise} A promise that resolves when the container is successfully removed.
+   * @throws {Error} If an error occurs during the removal process.
+   * @throws {Error} If a non-empty response is received.
+   */
+  async removeDockerSkyrampWorker(containerName) {
+    return new Promise((resolve, reject) => {
+      newDeleteDockerSkyrampWorkerWrapper.async(containerName, (err, res) => {
+        if (err) {
+          reject(err);
+        } else if (res) {
+          reject(new Error(res));
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  async mockerApply(namespace, kubeConfig, kubeContext, clusterName, address, endpoint) {
+    const yamlContent = getYamlBytes(endpoint.mockDescription);
+    return this.applyMockDescription(namespace, kubeConfig, kubeContext, clusterName, address, yamlContent);
+  }
+
+  /**
+   * Applies a mock description to a specified namespace and address.
+   *
+   * @param {string} namespace - The namespace where the mock description will be applied.
+   * @param {string} address - The address to which the mock description will be applied.
+   * @param {object} response - The details of the mock response.
+   * @param {object} trafficConfig - The traffic configuration parameters.
+   * @returns {Promise} A Promise that resolves when the mock description is successfully applied.
+   *
+   */
+  async mockerApplyV1(...args) {
+    let namespace, kubeConfig, kubeContext, clusterName, address, response, trafficConfig;
+
+    if (args.length === 1 && typeof args[0] === 'object') {
+      const options = args[0];
+      namespace = options.namespace;
+      kubeConfig = options.kubeConfig;
+      kubeContext = options.kubeContext;
+      clusterName = options.clusterName;
+      address = options.address;
+      response = options.response;
+      trafficConfig = options.trafficConfig;
+    } else {
+      [namespace, kubeConfig, kubeContext, clusterName, address, response, trafficConfig] = args;
+    }
+
+    const mockDescription = this.getMockDescriptionv1(response);
+    if (trafficConfig instanceof TrafficConfig) {
+      mockDescription.mock = { ...mockDescription.mock, ...trafficConfig.toJson() }
+    }
+
+    const yamlContent = getYamlBytes(mockDescription);
+    return this.applyMockDescription(namespace, kubeConfig, kubeContext, clusterName, address, yamlContent);
+  }
+
+  // NPM only: for VS code extension use
+  async mockerApplyFromFile(namespace, kubeConfig, kubeContext, clusterName, address, filepath) {
+    const yamlContent = getYamlBytes(readDataFromFile(filepath)[0]);
+    return this.applyMockDescription(namespace, kubeConfig, kubeContext, clusterName, address, yamlContent);
+  }
+
+  async applyMockDescription(namespace, kubeConfig, kubeContext, clusterName, address, yamlContent) {
+    return new Promise((resolve, reject) => {
+      applyMockDescriptionWrapper.async(namespace, kubeConfig, kubeContext, clusterName, address, yamlContent, '', '', (err, res) => {
+        if (err) {
+          reject(err);
+        } else if (res) {
+          reject(new Error(res));
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  async testerStart(namespace, kubePath, kubeContext, clusterName, address, scenario) {
+    const preparedScenario = scenario.prepareTestDescription();
+    const testDescription = createTestDescriptionFromScenario({ scenario: preparedScenario });
+    const testYamlContent = getYamlBytes(testDescription);
+    return this.runTesterStart(namespace, kubePath, kubeContext, clusterName, address, testYamlContent, false);
+  }
+
+  /**
+  * Starts a test scenario in a specified namespace.
+  *
+  * @param {string|object} namespaceOrOptions - The namespace in which to start the test scenario or an options object.
+  * @param {string} [address] - The address of the target service to test.
+  * @param {object} [scenario] - The scenario object that defines the test steps and assertions.
+  * @param {string} [testName] - The name of the test.
+  * @param {object} [globalHeaders] - Optional global headers to be included in the test requests.
+  * @param {boolean} [generateTestReport] - Optional flag to generate a test report. Default is false.
+  * @param {boolean} [isDockerenv] - Optional flag to indicate if the test is running in a Docker environment. Default is false.
+  *
+  * @returns {Promise} - A promise that resolves when the test scenario is started.
+  */
+  async testerStartV1(options = {}) {
+    const {
+      namespace = "",
+      address = "",
+      scenario,
+      testName,
+      globalHeaders = null,
+      globalVars = null,  // eslint-disable-line no-unused-vars
+      generateTestReport = false,
+      isDockerenv = false,
+      kubePath = "",
+      kubeContext = "",
+      clusterName = ""
+    } = typeof options === 'object' ? options : {
+      namespace: options,
+      address: arguments[1],
+      scenario: arguments[2],
+      testName: arguments[3],
+      globalHeaders: arguments[4] || null,
+      globalVars: arguments[5] || null,
+      generateTestReport: arguments[6] || false,
+      isDockerenv: arguments[7] || false
+    };
+
+    const scenarioToUse = scenario || this.scenario;
+    const preparedScenario = scenarioToUse ? scenarioToUse.prepareTestDescription() : null;
+
+    const testDescription = createTestDescriptionFromScenario({ ...options, scenario: preparedScenario });
+    const testYamlContent = getYamlBytes(testDescription);
+    const stringifiedHeaders = JSON.stringify(globalHeaders);
+
+    return this.runTesterStartv1(namespace,
+      kubePath,
+      kubeContext,
+      clusterName,
+      address,
+      testYamlContent,
+      testName,
+      stringifiedHeaders,
+      generateTestReport,
+      isDockerenv
+    );
+  }
+
+  // NPM only: for VS code extension use
+  async testerStartFromFile(namespace, kubePath, kubeContext, clusterName, address, filepath) {
+    const testDescription = readDataFromFile(filepath)[0]
+    const testYamlContent = getYamlBytes(testDescription);
+    return this.runTesterStart(namespace, kubePath, kubeContext, clusterName, address, testYamlContent, true);
+  }
+
+  async runTesterStart(namespace, kubePath, kubeContext, clusterName, address, testYamlContent, generateReport) {
+    return new Promise((resolve, reject) => {
+      runTesterStartWrapper.async(namespace, kubePath, kubeContext, clusterName, address, testYamlContent, generateReport, (err, res) => {
+        if (err) {
+          reject(err);
+        } else if (res.error) {
+          reject(new Error(res.error));
+        } else {
+          resolve(res.tester_id);
+        }
+      });
+    });
+  }
+
+  async runTesterStartv1(namespace, kubePath, kubeContext, clusterName, address, testYamlContent, testName, globalHeaders, generateReport = true) {
+    return new Promise((resolve, reject) => {
+      runTesterStartWrapperv1.async(namespace, kubePath, kubeContext, clusterName, address, testYamlContent, "", testName, globalHeaders, generateReport, true, "", "", "", (err, res) => {
+        if (err) {
+          reject(err);
+        } else if (res.error) {
+          reject(new Error(res.error));
+        } else {
+          resolve(res.tester_id);
+        }
+      });
+    });
+  }
+
+  // NPM only: for VS code extension use
+  async initTarget(taretName) {
+    return new Promise((resolve, reject) => {
+      initTargetWrapper.async(taretName, (err, res) => {
+        if (err) {
+          reject(err);
+        } else if (res) {
+          reject(new Error(res));
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  // NPM only: for VS code extension use
+  async deployTarget(targetDescription, namespace, workerImage = '', localImage = false) {
+    if (this.kubeConfigPath === null) {
+      throw new Error('No cluster to deploy target to.');
+    }
+    return new Promise((resolve, reject) => {
+      deployTargetWrapper.async(targetDescription, namespace, '', '', '', workerImage, localImage, (err, res) => {
+        if (err) {
+          reject(err);
+        } else if (res) {
+          reject(new Error(res));
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  // NPM only: for VS code extension use
+  async deleteTarget(targetDescription, namespace) {
+    if (this.kubeConfigPath === null) {
+      throw new Error('No cluster to delete target from.');
+    }
+    return new Promise((resolve, reject) => {
+      deleteTargetWrapper.async(targetDescription, namespace, '', '', '', (err, res) => {
+        if (err) {
+          reject(err);
+        } else if (res) {
+          reject(new Error(res));
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  getMockDescriptionv1(responseOrResponses) {
+    const mockDescription = {
+      version: SKYRAMP_YAML_VERSION,
+      services: [],
+      endpoints: [],
+      responses: [],
+      mock: { responses: [] }
+    };
+
+    const processResponse = (response) => {
+      const endpoint = response?.endpointDescriptor?.endpoint;
+      const service = response?.endpointDescriptor?.services[0];
+
+      if (!mockDescription?.endpoints.some(ep => ep.name === endpoint.name)) {
+        mockDescription?.endpoints.push(endpoint);
+      }
+
+      if (!mockDescription?.services?.some(s => s?.name === service?.name)) {
+        mockDescription?.services?.push(service);
+      }
+
+      mockDescription?.responses?.push(response?.toJson());
+      let mockRes = { "responseName": response?.name }
+      if (response?.trafficConfig && response?.trafficConfig instanceof TrafficConfig) {
+        mockRes = { ...mockRes, ...response?.trafficConfig?.toJson() }
+      }
+      mockDescription?.mock?.responses?.push(mockRes);
+    };
+    if (Array.isArray(responseOrResponses)) {
+      responseOrResponses.forEach(processResponse);
+    } else {
+      processResponse(responseOrResponses);
+    }
+
+    return mockDescription;
+  }
+
+  /**
+   * Generates test scenarios based on the provided parameters.
+   *
+   * @param {Protocol} protocol - The protocol to be used.
+   * @param {string} apiSchemaPath - The path to the API schema.
+   * @param {string} alias - The alias for the generated tests.
+   * @param {string} endpointPath - Endpoint REST path to filter for.
+   * @param {Language} language - The programming language for the generated tests.
+   * @param {string} tag - Tag to filter OpenAPI endpoint paths for.
+   * @param {string} sampleRequestPath - The path to the sample request.
+   * @param {int} port - The port number.
+   * @param {boolean} generateRobot - Whether to generate robot tests.
+   * @param {boolean} functionalScenario - Whether to generate functional scenarios.
+   * @param {boolean} negativeScenario - Whether to generate negative scenarios.
+   * @returns {Promise<string[]>} A promise that resolves with a list of generated test file paths.
+   */
+  async testerGenerate(protocol, apiSchemaPath, alias, endpointPath, language, tag, sampleRequestPath, port, generateRobot, functionalScenario, negativeScenario) {
+    return new Promise((resolve, reject) => {
+      runTesterGenerateRestWrapper.async(protocol, apiSchemaPath, alias, endpointPath, language, tag, sampleRequestPath, this.projectPath, port, generateRobot, functionalScenario, negativeScenario, (err, res) => {
+        if (err) {
+          console.error(`Error generating tests: ${err.name} - ${err.message}`);
+          reject(err);
+        } else if (res.error) {
+          console.error(`Error generating tests: ${res.error}`);
+          reject(new Error(res.error));
+        } else {
+          console.log(`Test generation completed successfully. Generated files: ${res.generated_files}`);
+
+          const generatedTestNames = res.generated_files.split(',');
+          resolve(generatedTestNames);
+        }
+      });
+    });
+  }
+
+  /**
+   * Sends a request to a Skyramp worker using the V2 API
+   * @param {Object} options - The options for sending the request
+   * @param {string} [options.address=""] - The address of the worker to send the request to
+   * @param {string} [options.namespace=""] - The namespace where the worker is deployed
+   * @param {string} [options.kubePath=""] - The path to the kubeconfig file
+   * @param {string} [options.kubeContext=""] - The kubernetes context to use
+   * @param {string} [options.clusterName=""] - The name of the kubernetes cluster
+   * @param {string} [options.dockerNetwork=""] - The docker network where the worker is deployed
+   * @param {string} [options.workerImage=""] - The worker image to use
+   * @param {string} [options.local_image=""] - The flag to indicate if the worker image is local
+   * @returns {Promise<string>} A promise that resolves with the response from the worker
+   */
+  async sendRequest(options) {
+    const req = new RequestV2(options);
+    return new Promise((resolve, reject) => {
+      const jsonRequest = req.toJson();
+      sendRequestWrapper.async(this.address, this.namespace, this.kubeconfigPath, this.context, this.clusterName, jsonRequest, this.dockerNetwork, this.workerImage, this.clientID, this.local_image, (err, res) => {
+        if (err) {
+          reject(err);
+        } else if (res) {
+          if (res.error != null) {
+            if (res.response != null) {
+              const jsonResponse = JSON.parse(res.response);
+              const response = new ResponseV2(jsonResponse);
+              this.failedResponses.push(response)
+            }
+            reject(res.error);
+          } else if (res.response != null) {
+            const jsonResponse = JSON.parse(res.response);
+            const response = new ResponseV2(jsonResponse);
+            if (response.error != "") {
+              this.failedResponses.push(response)
+            }
+            resolve(response);
+          } else {
+            reject(new Error('failed to send request'));
+          }
+        } else {
+          reject(new Error('failed to send request'));
+        }
+      });
+    });
+  }
+
+  isSuccess() {
+    return this.failedResponses.length == 0
+  }
+
+  getFailedResponses() {
+    return this.failedResponses
+  }
+
+  async deployDashboard(network) {
+    if (network === undefined || network === null || network === "") {
+      network = "skyramp-dashboard"
+    }
+
+    if (this.kubeconfigPath !== null || this.kubeconfigPath !== undefined) {
+      network = "skyramp"
+    }
+
+    return new Promise((resolve, reject) => {
+      if (this.kubeconfigPath === null || this.kubeconfigPath === undefined) {
+        deployDockerDashboardWrapper.async(network, (err, res) => {
           if (err) {
             reject(err);
-          } else if (res) {
-            reject(new Error(res));
           } else {
-            resolve();
-            this.mockedEndpoints.push(endpoint);
+            resolve(res);
           }
         });
-      });
-    } catch (err) {
-      throw new Error('Error converting to YAML bytes:', err);
+      } else {
+        deployK8sDashboardWrapper.async(network, (err, res) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(res);
+          }
+        });
+      }
+    });
+  }
+
+  /**
+ * Analyzes an OpenAPI schema and URI.
+ *
+ * @param {Object} options - The options for analysis.
+ * @param {string} options.apiSchema - The OpenAPI schema to analyze.
+ * @param {string} options.uri - The URI to analyze.
+ * @returns {Promise<string>} A promise that resolves with the analysis result.
+ */
+  async analyzeOpenapi(options) {
+    return new Promise((resolve, reject) => {
+      analyzeOpenapiWrapper.async(
+        options.apiSchema || "",
+        options.uri || "",
+        (err, res) => {
+          if (err) {
+            reject(err);
+          } else if (res.error) {
+            reject(new Error(res));
+          } else {
+            resolve(res);
+          }
+        }
+      );
+    });
+  }
+
+  async traceCollect(options) {
+    return new Promise((resolve, reject) => {
+      traceCollectWrapper.async(
+        options.output || "",
+        options.workerContainerName || "",
+        options.playwright || false,
+        options.playwrightOutput || "",
+        (err, res) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(res);
+          }
+        }
+      );
+    });
+  }
+
+  async generateRestTest(options) {
+    return new Promise((resolve, reject) => {
+      generateRestTestWrapper.async(
+        options.testType || "",
+        options.uri || "",
+        options.method || "",
+        options.language || "",
+        options.framework || "",
+        options.output || "",
+        options.outputDir || "",
+        options.runtime || "",
+        options.dockerNetwork || "",
+        options.dockerWorkerPort || 0,
+        options.k8sNamespace || "",
+        options.k8sConfig || "",
+        options.k8sContext || "",
+        options.authHeader || "",
+        options.authType || "",
+        options.requestData || "",
+        options.responseData || "",
+        options.responseStatusCode || "",
+        options.force || false,
+        options.deployDashboard || false,
+        options.formParams || "",
+        options.pathParams || "",
+        options.queryParams || "",
+        JSON.stringify(options.apiSchema || []),
+        options.traceFilePath || "",
+        JSON.stringify(options.generateInclude || []),
+        JSON.stringify(options.generateExclude || []),
+        JSON.stringify(options.generateNoProxy || []),
+        options.generateInsecure || false,
+        options.assertOption || "",
+        options.playwright || false,
+        options.playwrightOutput || "",
+        options.playwrightInput || "",
+        options.loadCount || "0",
+        options.loadDuration || "0",
+        options.loadNumThreads || "0",
+        options.loadRampupDuration || "0",
+        options.loadRampupInterval || "0",
+        options.loadTargetRPS || "0",
+        options.unblock || false,
+        options.entrypoint || "",
+        options.accessToken || "",
+        (err, res) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(res);
+          }
+        }
+      );
+    });
+  }
+
+  /**
+   * Sends a scenario for load testing using the V2 API
+   * @param {Object|Array} scenario - The scenario object or array of scenarios to run
+   * @param {Object} [options={}] - Additional options for the load test
+   * @param {string} [options.until] - The condition to terminate the test
+   * @param {LoadTestConfig} [options.loadTestConfig] - The load test configuration
+   * @param {string} [options.dependenciesFilepath=""] - The path to the dependencies file
+   * @param {boolean} [options.blocked=true] - Whether to block until test completion
+   * @param {boolean} [options.debug=true] - Whether to print debug information
+   * @param {boolean} [options.skipCertVerification=false] - Whether to skip SSL verification
+   * @returns {Promise<AsyncTestStatus>} A promise that resolves with the async test status
+   */
+  async sendScenario(scenario, options = {}) {
+    const {
+      until,
+      loadTestConfig,
+      dependenciesFilepath = "",
+      blocked = true,
+      debug = true,
+      skipCertVerification = false
+    } = options;
+
+    if (debug) { /* add to api for future use */}
+    let configJson = "";
+    if (loadTestConfig) {
+        configJson = loadTestConfig.toJson();
     }
+
+    // Ensure scenario is an array
+    const scenarioList = Array.isArray(scenario) ? scenario : [scenario];
+
+    // Process scenarios to match expected AsyncScenario format
+    const processedScenarios = scenarioList.map(_scenario => {
+      // If scenario has toJson method, use it for proper formatting
+      if (typeof _scenario.toJson === 'function') {
+        const scenarioJson = _scenario.toJson();
+        
+        return {
+          ...scenarioJson,
+          until: until || scenarioJson.until
+        };
+      }
+      
+      // Fallback for scenarios without toJson method
+      return {
+        name: _scenario.name,
+        steps: _scenario.steps || [],
+        vars: _scenario.vars || {},
+        until: until || _scenario.until || "",
+        maxRetries: _scenario.maxRetries || 5,
+        interval: _scenario.retryInterval || 1,
+        ignoreFailure: _scenario.ignoreFailure || false
+      };
+    });
+
+    return new Promise((resolve, reject) => {
+      sendScenarioWrapper.async(
+        this.address || "",
+        this.dockerNetwork || "",
+        this.namespace || "",
+        this.kubeconfigPath || "",
+        this.context || "",
+        this.clusterName || "",
+        JSON.stringify(processedScenarios),
+        "",
+        configJson,
+        dependenciesFilepath,
+        this.workerImage || "",
+        blocked,
+        this.local_image || false,
+        skipCertVerification,
+        (err, res) => {
+          if (err) {
+            reject(err);
+          } else if (res.error) {
+            reject(new Error(res.error));
+          } else if (res.response) {
+            const AsyncTestStatus = require('./AsyncTestStatus');
+            const jsonResponse = JSON.parse(res.response);
+            const testStatus = AsyncTestStatus.create(jsonResponse);
+            resolve(testStatus);
+          } else {
+            reject(new Error('Failed to send scenario'));
+          }
+        }
+      );
+    });
   }
 }