@skyramp/skyramp 0.4.91 → 0.4.93

package/lib/dev-darwin-amd64.h

@@ -123,7 +123,7 @@ extern char* registerUserWrapper(char* provider, char* email, char* code);
 extern struct oauthresponse runOAuthLoopback(char* provider, GoInt port);
 extern char* validateTokenWrapper(char* userToken);
 extern char* generateUserTokenWrapper(char* provider, char* email, char* oauthToken);
-extern struct worker_info newStartDockerSkyrampWorkerWrapper(char* image, char* tag, GoInt hostPort, char* targetNetworkName);
+extern struct worker_info newStartDockerSkyrampWorkerWrapper(char* image, char* tag, GoInt hostPort, char* targetNetworkName, char* testServiceAlias);
 extern char* newDeleteDockerSkyrampWorkerWrapper(char* containerName);
 extern char* runTesterCurlWrapper(char* namespace, char* kubePath, char* kubeContext, char* clusterName, char* address, char* request);
 extern char* newGrpcEndpointWrapper(char* name, char* serviceName, GoInt port, char* inputFile);

package/lib/dev-darwin-arm64.h

@@ -123,7 +123,7 @@ extern char* registerUserWrapper(char* provider, char* email, char* code);
 extern struct oauthresponse runOAuthLoopback(char* provider, GoInt port);
 extern char* validateTokenWrapper(char* userToken);
 extern char* generateUserTokenWrapper(char* provider, char* email, char* oauthToken);
-extern struct worker_info newStartDockerSkyrampWorkerWrapper(char* image, char* tag, GoInt hostPort, char* targetNetworkName);
+extern struct worker_info newStartDockerSkyrampWorkerWrapper(char* image, char* tag, GoInt hostPort, char* targetNetworkName, char* testServiceAlias);
 extern char* newDeleteDockerSkyrampWorkerWrapper(char* containerName);
 extern char* runTesterCurlWrapper(char* namespace, char* kubePath, char* kubeContext, char* clusterName, char* address, char* request);
 extern char* newGrpcEndpointWrapper(char* name, char* serviceName, GoInt port, char* inputFile);

package/lib/dev-linux-386.h

@@ -123,7 +123,7 @@ extern char* registerUserWrapper(char* provider, char* email, char* code);
 extern struct oauthresponse runOAuthLoopback(char* provider, GoInt port);
 extern char* validateTokenWrapper(char* userToken);
 extern char* generateUserTokenWrapper(char* provider, char* email, char* oauthToken);
-extern struct worker_info newStartDockerSkyrampWorkerWrapper(char* image, char* tag, GoInt hostPort, char* targetNetworkName);
+extern struct worker_info newStartDockerSkyrampWorkerWrapper(char* image, char* tag, GoInt hostPort, char* targetNetworkName, char* testServiceAlias);
 extern char* newDeleteDockerSkyrampWorkerWrapper(char* containerName);
 extern char* runTesterCurlWrapper(char* namespace, char* kubePath, char* kubeContext, char* clusterName, char* address, char* request);
 extern char* newGrpcEndpointWrapper(char* name, char* serviceName, GoInt port, char* inputFile);

package/lib/dev-linux-amd64.h

@@ -123,7 +123,7 @@ extern char* registerUserWrapper(char* provider, char* email, char* code);
 extern struct oauthresponse runOAuthLoopback(char* provider, GoInt port);
 extern char* validateTokenWrapper(char* userToken);
 extern char* generateUserTokenWrapper(char* provider, char* email, char* oauthToken);
-extern struct worker_info newStartDockerSkyrampWorkerWrapper(char* image, char* tag, GoInt hostPort, char* targetNetworkName);
+extern struct worker_info newStartDockerSkyrampWorkerWrapper(char* image, char* tag, GoInt hostPort, char* targetNetworkName, char* testServiceAlias);
 extern char* newDeleteDockerSkyrampWorkerWrapper(char* containerName);
 extern char* runTesterCurlWrapper(char* namespace, char* kubePath, char* kubeContext, char* clusterName, char* address, char* request);
 extern char* newGrpcEndpointWrapper(char* name, char* serviceName, GoInt port, char* inputFile);

package/lib/dev-windows-amd64.h

@@ -123,7 +123,7 @@ extern __declspec(dllexport) char* registerUserWrapper(char* provider, char* ema
 extern __declspec(dllexport) struct oauthresponse runOAuthLoopback(char* provider, GoInt port);
 extern __declspec(dllexport) char* validateTokenWrapper(char* userToken);
 extern __declspec(dllexport) char* generateUserTokenWrapper(char* provider, char* email, char* oauthToken);
-extern __declspec(dllexport) struct worker_info newStartDockerSkyrampWorkerWrapper(char* image, char* tag, GoInt hostPort, char* targetNetworkName);
+extern __declspec(dllexport) struct worker_info newStartDockerSkyrampWorkerWrapper(char* image, char* tag, GoInt hostPort, char* targetNetworkName, char* testServiceAlias);
 extern __declspec(dllexport) char* newDeleteDockerSkyrampWorkerWrapper(char* containerName);
 extern __declspec(dllexport) char* runTesterCurlWrapper(char* namespace, char* kubePath, char* kubeContext, char* clusterName, char* address, char* request);
 extern __declspec(dllexport) char* newGrpcEndpointWrapper(char* name, char* serviceName, GoInt port, char* inputFile);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/skyramp",
-  "version": "0.4.91",
+  "version": "0.4.93",
   "description": "module for leveraging skyramp cli functionality",
   "scripts": {
     "lint": "eslint 'src/**/*.js' 'src/**/*.ts' --fix",

package/src/classes/Asserts.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @typedef {Object} AssertOptions
+ * @property {string} assertValue - The value to be asserted.
+ * @property {string} expectedValue - The expected value for the assertion.
+ * @property {string} assertStepName - The name of the step.
+ * @property {string} description - The description of the assertion.
+ */
+interface AssertOptions {
+    assertValue: string;
+    expectedValue: string;
+    assertStepName: string;
+    description: string;
+}
+export declare class Asserts {
+    constructor(options: AssertOptions);
+}

package/src/classes/Asserts.js

@@ -0,0 +1,41 @@
+/**
+ * The `Assert` class represents an assertion to be used in a test step.
+ * @class
+ */
+class Assert {
+  /**
+   * Initialize a new instance of an Assert.
+   * @constructor
+   * @param {Object} option - The options for initializing the Assert object.
+   * @param {*} option.assertValue - The value to be asserted.
+   * @param {*} option.assertExpectedValue - The expected value for the assertion.
+   * @param {string} option.stepName - The name of the step.
+   * @param {string} option.description - The description of the assertion.
+   */
+  constructor(option) {
+    this.assertValue = option.assertValue;
+    this.expectedValue = option.assertExpectedValue;
+    this.name = option.stepName;
+    this.description = option.description;
+  }
+
+  /**
+   * Convert the assertion to a JSON object.
+   * @returns {Object} The JSON representation of the assertion.
+   */
+  toJson() {
+    return {
+      asserts: `${this.assertValue} == ${this.expectedValue}`,
+    };
+  }
+  
+  /**
+   * Convert the assertion to a string representation.
+   * @returns {string} The string representation of the assertion.
+   */
+  toAssert() {
+    return `${this.assertValue} == ${this.expectedValue}`
+  }
+}
+
+module.exports = Assert;

package/src/classes/GrpcEndpoint.js

@@ -16,9 +16,17 @@ class GrpcEndpoint extends Endpoint {
    * @param {string} pbFile - The protocol buffer file containing the API schema definition.
    * @param {string} endpointAddress - The endpoint address.
    */
-  constructor(name, service, port, pbFile, endpointAddress) {
-    const response = newGrpcEndpointWrapper(name, service, port, pbFile, endpointAddress);
-    super(response, endpointAddress);
+  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/RequestValue.d.ts

@@ -8,14 +8,14 @@ interface RequestValueOptions {
   methodName?: string;
   params?: RestParam[];
   headers?: {[headerName: string]: string},
-  vars?: Map<string, string | number>;
+  vars?: {[ var_: string]: string | number};
   blob?: string;
   graphqlParam?: string;
   javascriptPath?: string;
   javascriptFunction?: string;
 }
 export declare class RequestValue {
-  constructor(options: RequestValue) 
+  constructor(options: RequestValueOptions) 
   asRequestDict() : RequestValue 
   setCookieValue(cookieValue: string) : void
   setResponse(responseValue: ResponseValue)  : void

package/src/classes/RequestValue.js

@@ -30,7 +30,7 @@ class RequestValue {
     this.params = options.params;
     this.headers = options.headers;
     this.vars = options.vars;
-    this.blob = options.blob;
+    this.blob = options.blob ? JSON.stringify(options.blob) : undefined;
     this.graphqlParam = options.graphqlParam;
     this.javascriptPath = options.javascriptPath;
     this.javascript = options.javascriptFunction;

package/src/classes/ResponseValue.js

@@ -30,7 +30,7 @@ class ResponseValue {
     this.params = options.params;
     this.headers = options.headers;
     this.vars = options.vars;
-    this.blob = options.blob;
+    this.blob = options.blob ? JSON.stringify(options.blob) : undefined;
     this.javascriptPath = options.javascriptPath;
     this.javascript = options.javascriptFunction;
 

package/src/classes/Scenario.d.ts

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

package/src/classes/Scenario.js

@@ -1,5 +1,8 @@
 const lib = require('../lib');
-const { createTestDescriptionFromScenario, getYamlBytes, readDataFromFile, SKYRAMP_YAML_VERSION } = require('../utils');
+const { createTestDescriptionFromScenario, getYamlBytes, readDataFromFile } = require('../utils');
+const Asserts = require('./Asserts');
+const RequestValue = require('./RequestValue');
+const Step = require('./Step');
 const buildRequestsWrapper = lib.func('buildRequestsWrapper', 'string', ['string']);
 const writeTestDescriptionWrapper = lib.func('writeTestDescriptionWrapper', 'string', ['string', 'string']);
 
@@ -8,50 +11,121 @@ const writeTestDescriptionWrapper = lib.func('writeTestDescriptionWrapper', 'str
  * @class
  */
 class Scenario {
+  static requests = [];
+  static scenarios = [];
+  static services = [];
+  static endpoints = [];
+
   /**
    * Initializes a new instance of the Scenario class with the given name.
    * @constructor
+   * 
    * @param {string} name - The name of the scenario.
    */
-  constructor(name) {
-    this.name = name;
+  constructor(...args) {
+    if (args.length === 1 && typeof args[0] === 'object') {
+      const { name, startAt = 1, headers, vars, ignore } = args[0];
+      Object.assign(this, { name, startAt, headers, vars, ignore });
+    } else if (args.length === 1 && typeof args[0] === 'string') {
+      this.name = args[0];
+    }
     this.steps = [];
-    this.services = [];
-    this.endpoints = [];
-    this.requests = [];
-
-    this.testDescriptionV1 = {
-      version: SKYRAMP_YAML_VERSION, 
-      services: [],
-      endpoints: [],
-      steps: [],
-      requestss: [],
-    };
   }
 
   /**
-   * Adds a request to the scenario and updates the list of services and endpoints.
-   * @param {Request} request - The request to add to the scenario.
-   * @returns {string} - The name of the added request.
+   * Adds a request to the scenario.
+   * 
+   * @param {AddRequestOption} option - The options for adding the request.
+   * @returns {string} - The name of the request.
+   * @throws {Error} - Throws an error if the option is not of type RequestValue or an object with a request property of type RequestValue.
    */
-  addRequestV1(request) {
-    this.steps.push({ requestName: request.name });
-    this.requests.push(request.asRequestDict());
+  addRequestV1(option) {
+    if (!(option instanceof RequestValue) && !(option.request instanceof RequestValue)) {
+      throw new Error('Invalid argument: option must be of type RequestValue or an object with a request property of type RequestValue');
+    }
 
-    if (!this.services.find(s => s === request.endpointDescriptor.services)) {
-      this.services.push(request.endpointDescriptor.services[0]);
+    const request = option instanceof RequestValue ? option : option.request;
+    option = { ...option, step: request };
+
+    const step = new Step(option);
+    this.steps.push(step.toJson());
+    Scenario.requests.push(request.asRequestDict());
+
+    const newService = request.endpointDescriptor.services[0];
+    if (!Scenario.services.some(s => s.name === newService.name)) {
+      Scenario.services.push(newService);
     }
 
-    if (!this.endpoints.find(ep => ep === request.endpointDescriptor.endpoint)) {
-      this.endpoints.push(request.endpointDescriptor.endpoint);
+    if (!Scenario.endpoints.find(ep => ep === request.endpointDescriptor.endpoint)) {
+      Scenario.endpoints.push(request.endpointDescriptor.endpoint);
     }
 
     return request.name;
   }
 
-  addRequest(endpoint, methodName, requestObject=undefined, dynamic=false) {
+
+  /**
+   * Prepares a test description by creating a data structure with a root scenario and child scenarios for a test description.
+   * 
+   * @returns {Object} - The test description object containing the root scenario, child scenarios, endpoints, services, and requests.
+   */
+  prepareTestDescription() {
+    let scenarios = []
+    // add ourself as root scenario
+    scenarios.push({
+      name: this.name,
+      ...(this.vars != undefined && { vars: this.vars }),
+      ...(this.headers != undefined && { headers: this.headers }),
+      ...(this.ignore != undefined && { ignore: this.ignore }),
+      steps: this.steps,
+    })
+    // add all client scenarios
+    Scenario.scenarios.forEach((scenario) => {
+      const s = {
+        name: scenario.name,
+        ...(scenario.vars != undefined && { vars: scenario.vars }),
+        ...(scenario.headers != undefined && { headers: scenario.headers }),
+        ...(scenario.ignore != undefined && { ignore: scenario.ignore }),
+        steps: scenario.steps,
+      }
+      scenarios.push(s);
+    })
+    return {
+      name: this.name,
+      scenarios: scenarios,
+      endpoints: Scenario.endpoints,
+      services: Scenario.services,
+      requests: Scenario.requests,
+    };
+  }
+
+  addScenarioV1(option) {
+    let scenario = option.scenario;
+    if (!(option.scenario instanceof Scenario)) {
+      throw new Error('Invalid argument: option.scenario must be of type Scenario');
+    }
+
+    option.step = scenario;
+    const step = new Step(option);
+    this.steps.push(step.toJson());
+
+    if (!Scenario.scenarios.find(s => s === scenario)) {
+      Scenario.scenarios.push(scenario);
+    }
+  }
+
+  toJson() {
+    return {
+      steps: this.steps,
+      services: this.services,
+      endpoints: this.endpoints,
+      requests: this.requests,
+    };
+  }
+
+  addRequest(endpoint, methodName, requestObject = undefined, dynamic = false) {
     this.buildRequestsFromEndpoint(endpoint);
-    for (const request of this.requests) {
+    for (const request of Scenario.requests) {
       if (request.methodName === methodName) {
         if (dynamic) {
           request.javascriptPath = requestObject;
@@ -72,18 +146,18 @@ class Scenario {
   }
 
   buildRequestsFromEndpoint(endpoint) {
-    if (this.endpoints.indexOf(endpoint.endpoint) !== -1) {
+    if (Scenario.endpoints.indexOf(endpoint.endpoint) !== -1) {
       return;
     }
-    
-    this.services.push(...endpoint.services);
-    this.endpoints.push(endpoint.endpoint);
+
+    Scenario.services.push(...endpoint.services);
+    Scenario.endpoints.push(endpoint.endpoint);
 
     const yamlContent = getYamlBytes(endpoint.mockDescription);
     const response = buildRequestsWrapper(yamlContent);
     try {
       const requests = JSON.parse(response);
-      this.requests.push(requests[0]);
+      Scenario.requests.push(requests[0]);
     } catch (error) {
       throw new Error(response);
     }
@@ -101,8 +175,21 @@ class Scenario {
     return assertion;
   }
 
+  addAssertV1(option) {
+    let assert = new Asserts(option);
+    const step = new Step({
+      stepName: option.stepName,
+      description: option.description,
+      if: option.if_,
+      step: assert,
+    });
+    this.steps.push(step.toJson());
+  }
+
   writeTestConfigurationToFile() {
-    const testDescription = createTestDescriptionFromScenario(this);
+    const testDescription = createTestDescriptionFromScenario({
+      scenario: this.prepareTestDescription()
+    });
     const yamlContent = getYamlBytes(testDescription);
     return new Promise((resolve, reject) => {
       writeTestDescriptionWrapper.async(yamlContent, this.name, (err, res) => {
@@ -118,4 +205,4 @@ class Scenario {
   }
 }
 
-module.exports = Scenario;
+module.exports = Scenario;

package/src/classes/SkyrampClient.d.ts

@@ -2,6 +2,28 @@ import { ResponseValue } from '..';
 import { Endpoint } from './Endpoint';
 import { Scenario } from './Scenario';
 import {TrafficConfig} from './TrafficConfig';
+
+interface testerStartV1Options {
+  namespace?: string;
+  kubePath?: string;
+  kubeContext?: string;
+  clusterName?: string;
+  address?: string;
+  scenario: Scenario | [Scenario];
+  testName: string;
+  globalHeaders?: {[headerName: string]: string};
+  generateTestReport?: boolean;
+  isDockerenv?: boolean;
+}
+interface MockerApplyV1Options {
+  namespace: string;
+  kubeConfig: string;
+  kubeContext: string;
+  clusterName: string;
+  address: string;
+  response: ResponseValue | ResponseValue[];
+  trafficConfig: TrafficConfig;
+}
 export declare class SkyrampClient {
   constructor(kubeconfigPath?: string, clusterName?: string, context?: string, userToken?: string);
   applyLocal(): Promise<void>;
@@ -11,6 +33,7 @@ export declare class SkyrampClient {
   mockerApply(namespace: string, kubePath: string, kubeContext: string, clusterName: string, address: string, endpoint: Endpoint): Promise<void>;
   runDockerSkyrampWorker(workerImage?:string, workerTag?:string, hostPost?:int, targetNetworkName?:string): Promise<void>
   removeDockerSkyrampWorker() : Promise<void>
+  mockerApplyV1(options: MockerApplyV1Options): Promise<void>;
   mockerApplyV1(namespace: string, kubePath: string, kubeContext: string, clusterName: string, address: string, response: ResponseValue | ResponseValue[], trafficConfig: TrafficConfig): Promise<void>;
   mockerApplyFromFile(namespace: string, kubePath: string, kubeContext: string, clusterName: string, address: string, filePath: string): Promise<void>;
   applyMockDescription(namespace: string, address: string, mockYamlContent: string): Promise<void>;
@@ -25,22 +48,9 @@ export declare class SkyrampClient {
     globalHeaders: {[headerName: string]: string},
     generateTestReport: boolean,
     isDockerenv: boolean): Promise<void>;
-  testerStartFromFile(namespace: string, kubePath: string, kubeContext: string, clusterName: string, address: string, filePath: string): Promise<void>;
-  runTesterStart(namespace: string, kubePath: string, kubeContext: string, clusterName: string, address: string, testYamlContent: string, generateReport: boolean): Promise<void>;
-  initTarget(targetName: string): Promise<void>;
-  deployTarget(targetDescription: string, namespace: string, workerImage?: string, localImage?: boolean): Promise<void>;
-  deleteTarget(targetDescription: string, namespace: string): Promise<void>;
-
-  // login / oauth related
-  userEmail: string;
-  userToken: string;
-  userProvider: string;
-  getUserToken(): string;
-  getUserEmail(): string;
-  getUserProvider(): string;
-
-  setUserToken(userToken: string): void;
-  validateToken(userToken: string): Promise<void>;
+  
+  testerStartV1(options: testerStartV1Options): Promise<void>;
+  testerStartvalidateToken(userToken: string): Promise<void>;
   readCredential(): Promise<credResponseType>;
   getOAuthURL(provider: string, port: number): string;
   runOAuthLoopback(provider: string, port: number): Promise<oauthResponseType>;

package/src/classes/SkyrampClient.js

@@ -40,7 +40,7 @@ const getKubeConfigPath = lib.func('getKubeConfigPath', 'string', []);
 const removeLocalWrapper = lib.func('removeLocalWrapper', 'string', []);
 const removeClusterFromConfigWrapper = lib.func('removeClusterFromConfigWrapper', 'string', ['string']);
 // docker related
-const newStartDockerSkyrampWorkerWrapper = lib.func('newStartDockerSkyrampWorkerWrapper', workerInfoType, ['string', 'string', 'int', 'string']);
+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']);
@@ -317,9 +317,9 @@ class SkyrampClient {
    * @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 = "") {
+  async runDockerSkyrampWorker(workerImage = WORKER_URL, workerTag = WORKER_TAG, hostPost = CONTAINER_PORT, targetNetworkName = "", testServiceAlias = "") {
     return new Promise((resolve, reject) => {
-      newStartDockerSkyrampWorkerWrapper.async(workerImage, workerTag, hostPost, targetNetworkName, (err, res) => {
+      newStartDockerSkyrampWorkerWrapper.async(workerImage, workerTag, hostPost, targetNetworkName, testServiceAlias, (err, res) => {
         if (err) {
           reject(err);
         } else if (res.error) {
@@ -366,12 +366,29 @@ class SkyrampClient {
    * @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(namespace, kubeConfig, kubeContext, clusterName, address, response, trafficConfig) {
+  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);
   }
@@ -397,31 +414,65 @@ class SkyrampClient {
   }
 
   async testerStart(namespace, kubePath, kubeContext, clusterName, address, scenario) {
-    const testDescription = createTestDescriptionFromScenario(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} namespace - The namespace in which to start the test scenario.
-   * @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(namespace, address, scenario, testName, globalHeaders, generateTestReport = false) {
-    const testDescription = createTestDescriptionFromScenario(scenario);
+  * 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,
+      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,
+      generateTestReport: arguments[5] || false,
+      isDockerenv: arguments[6] || false
+    };
+
+    const scenarioToUse = scenario || this.scenario;
+    const preparedScenario = scenarioToUse ? scenarioToUse.prepareTestDescription() : null;
+
+    const testDescription = createTestDescriptionFromScenario({ ...options, scenario: preparedScenario });
     const testYamlContent = getYamlBytes(testDescription);
-    if (globalHeaders !== undefined && globalHeaders !== null) {
-      globalHeaders = JSON.stringify(globalHeaders);
-    }
-    return this.runTesterStartv1(namespace, '', '', '', address, testYamlContent, testName, globalHeaders, generateTestReport);
+    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

package/src/classes/Step.d.ts

@@ -0,0 +1,28 @@
+import Scenario from './Scenario';
+import Asserts from './Asserts';
+import RequestValue from './RequestValue';
+
+export interface StepConfig {
+    stepName: string;
+    maxRetries?: number;
+    interval?: string;
+    until?: string;
+    blobOverride?: {[blobName: string]: string};
+    override?: {[varName: string]: string | number};
+    description?: string;
+    break?: boolean;
+    ignore?: boolean;
+    if_?: string;
+    export?: {[exportName: string]: string | number};
+    untilFunc?: CallableFunction;
+    wait?: string;
+    with_?: string;
+}
+
+export interface StepOptions extends StepConfig {
+    step: Scenario | Asserts | RequestValue;
+}
+
+export declare class Step {
+    constructor(options: StepOptions);
+}

package/src/classes/Step.js

@@ -0,0 +1,113 @@
+
+const RequestValue = require('./RequestValue');
+const Asserts = require('./Asserts');
+
+/**
+ * Represents a step in a scenario.
+ * @class
+ */
+class Step {
+  /**
+   * Initialize a new instance of a Step.
+   * @constructor
+   * @param {Object} options - The options for initializing the Step object.
+   * @param {Object} options.step - The step object, which can be an instance of RequestValue, Asserts, or Scenario.
+   * @param {number} [options.maxRetries=0] - The maximum number of retries for the step.
+   * @param {number} [options.interval] - The interval between retries.
+   * @param {string} [options.until] - The condition to wait until.
+   * @param {Object} [options.blobOverride] - The blob override for the step.
+   * @param {Object} [options.override] - The override for the step.
+   * @param {string} [options.description] - The description of the step.
+   * @param {string} [options.stepName] - The name of the step.
+   * @param {boolean} [options.break] - Whether to break the step.
+   * @param {boolean} [options.ignore] - Whether to ignore the step.
+   * @param {boolean} [options.if_] - The condition to check before executing the step.
+   * @param {boolean} [options.export] - Whether to export the step.
+   * @param {Function} [options.untilFunc] - The function to call until the condition is met.
+   * @param {number} [options.wait] - The wait time for the step.
+   * @param {Object} [options.with_] - Additional options for the step.
+   */
+  constructor(options) {
+    const { step,
+      maxRetries,
+      interval,
+      until,
+      blobOverride,
+      override,
+      description,
+      stepName,
+      break: breakStep,
+      ignore,
+      if_,
+      export: exportStep,
+      untilFunc,
+      wait,
+      with_ } = options;
+    this.step = step;
+    this.maxRetries = maxRetries;
+    if (interval) this.interval = interval;
+    if (until) this.until = until;
+    if (blobOverride) this.blobOverride = blobOverride;
+    if (override) this.override = override;
+    this.description = description;
+    this.stepName = stepName;
+    if (breakStep) this.break = breakStep;
+    if (ignore) this.ignore = ignore;
+    if (if_) this.if = if_;
+    if (exportStep) this.export = exportStep;
+    if (untilFunc) this.untilFunc = untilFunc;
+    if (wait) this.wait = wait;
+    if (with_) this.with = with_;
+  }
+
+  getRepeatConfig() {
+    return {
+      ...(this.maxRetries !== undefined && { maxRetries: this.maxRetries }),
+      ...(this.interval !== undefined && { interval: this.interval }),
+      ...(this.until !== undefined && { until: this.until }),
+      ...(this.untilFunc !== undefined && { untilFunc: this.untilFunc }),
+      ...(this.with !== undefined && { with: this.with }),
+    }
+  }
+  /**
+   * Convert the step to a JSON object.
+   * @returns {Object} The JSON representation of the step.
+   */
+  toJson() {
+    const step = {};
+    try {
+      if (this.step instanceof RequestValue) {
+        step.requestName = this.step.name;
+      } else if (this.step instanceof Asserts) {
+        step.asserts = this.step.toAssert();
+      } else {
+        if (this.step && this.step.constructor && this.step.constructor.name === 'Scenario') {
+          step.scenarioName = this.step.name;
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    }
+
+    const additional = {
+      description: this.description,
+      name: this.stepName,
+      ...(this.blobOverride !== undefined && { blobOverride: this.blobOverride }),
+      ...(this.break !== undefined && { break: this.break }),
+      ...(this.export !== undefined && { export: this.export }),
+      ...(this.if !== undefined && { if: this.if }),
+      ...(this.ignore !== undefined && { ignore: this.ignore }),
+      ...(this.override !== undefined && { override: this.override }),
+      ...(this.untilFunc !== undefined && { untilFunc: this.untilFunc }),
+      ...(this.wait !== undefined && { wait: this.wait }),
+    };
+
+    return {
+      ...step,
+      ...additional,
+      ...(this.maxRetries !== undefined && { repeat: this.getRepeatConfig() }),
+    };
+  }
+}
+
+module.exports = Step;

package/src/index.d.ts

@@ -8,4 +8,4 @@ export * from './classes/ResponseValue';
 export * from './classes/RestParam';
 export * from './classes/TrafficConfig';
 export * from './classes/DelayConfig';
-export * from './classes/Protocol';
+export * from './classes/Protocol';

package/src/index.js

@@ -8,6 +8,8 @@ const RestParam = require('./classes/RestParam');
 const TrafficConfig = require('./classes/TrafficConfig');
 const DelayConfig = require('./classes/DelayConfig');
 const Protocol = require('./classes/Protocol');
+const Asserts= require('./classes/Asserts');
+const Step = require('./classes/Step');
 
 module.exports = {
   SkyrampClient,
@@ -20,4 +22,6 @@ module.exports = {
   TrafficConfig,
   DelayConfig,
   Protocol,
+  Asserts,
+  Step
 }

package/src/utils.js

@@ -12,23 +12,24 @@ function getYamlBytes(jsonObject) {
   }
 }
 
-function createTestDescriptionFromScenario(scenario) {
-  return {
+function createTestDescriptionFromScenario({ scenario, globalVars }) {
+  const { name, startsAt = 1, scenarios, services, endpoints, requests } = scenario;
+  const testDescription = {
     version: SKYRAMP_YAML_VERSION,
     test: {
+      ...(globalVars !== undefined && { globalVars }),
       testPattern: [{
-          startAt: 1,
-          scenarioName: scenario.name
+        startAt: startsAt,
+        scenarioName: name
       }]
     },
-    services: scenario.services,
-    endpoints: scenario.endpoints,
-    scenarios: [{
-      name: scenario.name,
-      steps: scenario.steps
-    }],
-    requests: scenario.requests
+    services: services,
+    endpoints: endpoints,
+    scenarios: scenarios, 
+    requests: requests
   };
+
+  return testDescription;
 }
 
 function readDataFromFile(filename) {