@skyramp/skyramp 1.0.0-sha.b2dfe11 → 1.2.2

package/src/classes/Scenario.js

@@ -0,0 +1,208 @@
+const lib = require('../lib');
+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']);
+
+/**
+ * The `Scenario` class allows you to define test scenarios by adding requests and asserts.
+ * @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(...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 = [];
+  }
+
+  /**
+   * 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(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');
+    }
+
+    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 (!Scenario.endpoints.find(ep => ep === request.endpointDescriptor.endpoint)) {
+      Scenario.endpoints.push(request.endpointDescriptor.endpoint);
+    }
+
+    return request.name;
+  }
+
+
+  /**
+   * 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 Scenario.requests) {
+      if (request.methodName === methodName) {
+        if (dynamic) {
+          request.javascriptPath = requestObject;
+          delete request.blob;
+        } else if (requestObject !== undefined) {
+          request.blob = requestObject.requestValue.blob;
+        }
+        this.steps.push({ requestName: request.name });
+        return request.name;
+      }
+    }
+    throw new Error(`Method ${methodName} not found`);
+  }
+
+  addRequestFromFile(endpoint, methodName, requestFile) {
+    const [jsonData, dynamic] = readDataFromFile(requestFile);
+    return this.addRequest(endpoint, methodName, jsonData, dynamic);
+  }
+
+  buildRequestsFromEndpoint(endpoint) {
+    if (Scenario.endpoints.indexOf(endpoint.endpoint) !== -1) {
+      return;
+    }
+
+    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);
+      Scenario.requests.push(requests[0]);
+    } catch (error) {
+      throw new Error(response);
+    }
+  }
+
+  /**
+   * Adds an assertion to the scenario that checks if the value of value1 is equal to value2.
+   * @param {string} value1 - The first value to compare.
+   * @param {string} value2 - The second value to compare.
+   * @returns {string} - The assertion string.
+   */
+  addAssertEqual(value1, value2) {
+    const assertion = `requests.${value1} == "${value2}"`;
+    this.steps.push({ asserts: assertion });
+    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({
+      scenario: this.prepareTestDescription()
+    });
+    const yamlContent = getYamlBytes(testDescription);
+    return new Promise((resolve, reject) => {
+      writeTestDescriptionWrapper.async(yamlContent, this.name, (err, res) => {
+        if (err) {
+          reject(err);
+        } else if (res) {
+          reject(new Error(res));
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+}
+
+module.exports = Scenario;

package/src/classes/SkyrampClient.d.ts

@@ -1,10 +1,190 @@
+import { ResponseValue } from '..';
 import { Endpoint } from './Endpoint';
+import { Scenario } from './Scenario';
+import {TrafficConfig} from './TrafficConfig';
+import { Protocol } from './Protocol';
+import { AsyncScenario } from './AsyncScenario';
+import { LoadTestConfig } from './LoadTestConfig';
+import { AsyncTestStatus } from './AsyncTestStatus';
+
+export enum Language {
+  PYTHON = 'python'
+}
+
+interface testerStartV1Options {
+  namespace?: string;
+  kubePath?: string;
+  kubeContext?: string;
+  clusterName?: string;
+  address?: string;
+  scenario: Scenario | [Scenario];
+  testName: string;
+  globalHeaders?: {[headerName: string]: string};
+  globalVars?: {[variableName: string]: string};
+  generateTestReport?: boolean;
+  isDockerenv?: boolean;
+}
+interface MockerApplyV1Options {
+  namespace: string;
+  kubeConfig: string;
+  kubeContext: string;
+  clusterName: string;
+  address: string;
+  response: ResponseValue | ResponseValue[];
+  trafficConfig: TrafficConfig;
+}
+interface SendRequestV2Options {
+  url: string;
+  path: string;
+  method: string;
+  body?: string;
+  headers?: {[headerName: string]: string};
+  cookies?: {[cookieName: string]: string};
+  dataOverride?: {[dataName: string]: string | number | boolean | object | null};
+  pathParams?: {[pathName: string]: string | number | boolean | object | null};
+  queryParams?: {[queryName: string]: string | number | boolean | object | null};
+  formParams?: {[formParamName: string]: string | number | boolean | object | null};
+  expectedCode?: string;
+  description?: string;
+  insecure?: boolean;
+  funcHandler?: string;
+  funcHandlerType?: string;
+}
+
+interface SkyrampClientOptions {
+  runtime?: string;
+  dockerNetwork?: string;
+  dockerSkyrampPort?: number;
+  k8SNamespace?: string;
+  k8SConfigPath?: string;
+  clusterName?: string;
+  k8SContext?: string;
+  userToken?: string;
+  address?: string;
+  workerImage?: string;
+  local_image?: boolean;
+}
+
+interface AnalyzeOpenAPIOptions {
+  apiSchema: string;
+  uri: string;
+}
+
+interface TraceCollectOptions {
+  output?: string;
+  workerContainerName?: string;
+  playwright?: boolean;
+  playwrightOutput?: string;
+}
+
+interface GenerateRestTestOptions {
+  testType?: string;
+  uri?: string;
+  method?: string;
+  language?: string;
+  framework?: string;
+  output?: string;
+  outputDir?: string;
+  runtime?: string;
+  dockerNetwork?: string;
+  dockerWorkerPort?: string;
+  k8sNamespace?: string;
+  k8sConfig?: string;
+  k8sContext?: string;
+  authHeader?: string;
+  authType?: string;
+  requestData?: string;
+  responseData?: string;
+  responseStatusCode?: string;
+  force?: boolean;
+  deployDashboard?: boolean;
+  formParams?: string;
+  pathParams?: string;
+  queryParams?: string;
+  apiSchema?: string[];
+  traceFilePath?: string;
+  generateInclude?: string[];
+  generateExclude?: string[];
+  generateNoProxy?: string[];
+  generateInsecure?: boolean;
+  assertOption?: string;
+  playwright?: boolean;
+  playwrightOutput?: string;
+  playwrightInput?: string;
+  loadCount?: string;
+  loadDuration?: string;
+  loadNumThreads?: string;
+  loadRampupDuration?: string;
+  loadRampupInterval?: string;
+  loadTargetRPS?: string;
+  unblock?: boolean;
+  entrypoint?: string;
+  accessToken?: string;
+}
+
+interface SendScenarioOptions {
+  until?: string;
+  loadTestConfig?: LoadTestConfig;
+  dependenciesFilepath?: string;
+  blocked?: boolean;
+  debug?: boolean;
+  skipCertVerification?: boolean;
+}
+
 export declare class SkyrampClient {
-  constructor(kubeconfigPath?: string, clusterName?: string, context?: string, ingress?: string);
+  constructor(kubeconfigPath?: string, clusterName?: string, context?: string, userToken?: string);
+  constructor(options: SkyrampClientOptions);
   applyLocal(): Promise<void>;
   addKubeconfig(context: string, clusterName: string, kubeconfigPath: string): Promise<void>;
-  removeCluster(clusterName?: string): Promise<void>;
   removeLocal(): Promise<void>;
-  removeClusterFromConfig(clusterName: string): Promise<void>;
-  apply(namespace: string, endpoint: Endpoint): Promise<void>;
+  removeCluster(clusterName?: string): Promise<void>;
+  mockerApply(namespace: string, kubePath: string, kubeContext: string, clusterName: string, address: string, endpoint: Endpoint): Promise<void>;
+  deploySkyrampWorker(namespace?: string, workerImage?: string, localImage?: boolean, kubePath?: string, kubeContext?: string, clusterName?: string): Promise<void>
+  deleteSkyrampWorker(namespace?: string, kubePath:string, kubeContext?: string, clusterName?: string): 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>;
+  testerStart(namespace: string, kubePath: string, kubeContext: string, clusterName: string, address: string, scenario: Scenario): Promise<void>;
+  testerStartV1(namespace: string,
+    kubePath: string,
+    kubeContext: string,
+    clusterName: string,
+    address: string,
+    scenario: Scenario,
+    testName: string,
+    globalHeaders: {[headerName: string]: string},
+    generateTestReport: boolean,
+    isDockerenv: boolean): Promise<void>;
+  
+  testerStartV1(options: testerStartV1Options): Promise<void>;
+
+  testerGenerate(
+    protocol: Protocol,
+    apiSchemaPath: string,
+    alias: string,
+    endpointPath: string,
+    language: Language,
+    tag: string,
+    sampleRequestPath: string,
+    port: int,
+    generateRobot: boolean,
+    functionalScenario: boolean,
+    negativeScenario: boolean): Promise<string[]>; 
+
+  sendRequest(options: SendRequestV2Options): Promise<void>;
+  deployDashboard(network: string): Promise<void>;
+
+  generateRestTest(options: GenerateRestTestOptions): Promise<string>;
+  traceCollect(options: TraceCollectOptions): Promise<string>;
+  analyzeOpenapi(options: AnalyzeOpenAPIOptions): Promise<string>;
+
+  /**
+   * Sends a scenario for load testing using the V2 API
+   * @param scenario The scenario object or array of scenarios to run
+   * @param options Additional options for the load test
+   */
+  sendScenario(scenario: AsyncScenario | AsyncScenario[], options?: SendScenarioOptions): Promise<AsyncTestStatus>;
 }