@skyramp/skyramp 1.0.0-sha.b2dfe11 → 1.2.2

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/classes/TrafficConfig.d.ts

@@ -0,0 +1,6 @@
+import { DelayConfig } from './DelayConfig';
+
+export declare class TrafficConfig { 
+  constructor(lossPercentage: int, delayConfig: DelayConfig);
+  toJson() : JSON;
+}

package/src/classes/TrafficConfig.js

@@ -0,0 +1,28 @@
+const DelayConfig = require('./DelayConfig');
+/**
+ * Represents a configuration for traffic values.
+ */
+class TrafficConfig {
+    /**
+     * Initializes a new TrafficConfig object with the specified loss percentage and delay configuration.
+     * @constructor
+     * @param {number} lossPercentage - The loss percentage for traffic configuration.
+     * @param {DelayConfig} delayConfig - The delay configuration for traffic. It is an optional field and can be set using an instance of the DelayConfig class.
+     */
+    constructor(lossPercentage, delayConfig) {
+        this.lossPercentage = lossPercentage;
+        this.delayConfig = delayConfig;
+    }
+
+    toJson() {
+        let trafficConfig = {
+            lossPercentage: this.lossPercentage,
+        };
+        if (this.delayConfig && this.delayConfig instanceof DelayConfig) {
+            trafficConfig.delayConfig = this.delayConfig.toJson();
+        }
+        return trafficConfig;
+    }
+}
+
+module.exports = TrafficConfig;

package/src/function.js

@@ -0,0 +1,46 @@
+const ResponseV2 = require('./classes/ResponseV2');
+const lib = require('./lib');
+
+// func checkStatusCodeWrapper(actualStatus C.int, expectedStatus *C.char) (*C.char, *C.char) {
+const checkStatusCodeWrapper = lib.func('checkStatusCodeWrapper', 'int', ['int', 'string']);
+
+
+ /**
+  * Checks if the response's status code matches the expected status code (with support for wildcards).
+  *
+  * The expected status can include 'x' as a wildcard for a single digit.
+  * Examples:
+  *   - "200" matches exactly 200
+  *   - "20x" matches any status code in the range 200 to 209
+  *   - "2xx" matches any status code in the range 200 to 299
+  *
+  * @param {ResponseV2} response - The response object containing a `status_code` attribute.
+  * @param {string} expectedStatus - The expected status code as a string with optional 'x' wildcards.
+  * @returns {boolean} True if the status code matches, false otherwise.
+  * @throws {Error} If the response object lacks a 'status_code' attribute.
+  */
+ function checkStatusCode(response, expectedStatus) {
+    if (!(response instanceof ResponseV2)) {
+      throw new Error('Response must be an instance of ResponseV2');
+    }
+
+    if (!expectedStatus || typeof expectedStatus !== 'string') {
+      throw new Error('Expected status must be a string');
+    }
+
+    try {
+      const result = checkStatusCodeWrapper(response.statusCode, expectedStatus);
+      if (result == 1) {
+          return true
+      }
+      return false
+
+    } catch (err) {
+      console.error(`Error in checkStatusCode: ${err.message}`);
+      throw err; // Re-throw to allow caller to handle errors
+    }
+  }
+
+  module.exports = {
+    checkStatusCode
+  };

package/src/index.d.ts

@@ -1,5 +1,18 @@
 export * from './classes/Endpoint';
 export * from './classes/GrpcEndpoint';
 export * from './classes/RestEndpoint';
+export * from './classes/Scenario';
 export * from './classes/SkyrampClient';
-export * from './utils';
+export * from './classes/RequestValue';
+export * from './classes/ResponseValue';
+export * from './classes/RestParam';
+export * from './classes/TrafficConfig';
+export * from './classes/DelayConfig';
+export * from './classes/Protocol';
+export * from './classes/RequestV2';
+export * from './classes/ResponseV2';
+export * from './classes/AsyncScenario';
+export * from './classes/LoadTestConfig';
+export * from './classes/AsyncTestStatus';
+export * from './utils';
+export * from './function';

package/src/index.js

@@ -1,11 +1,44 @@
 const SkyrampClient = require('./classes/SkyrampClient');
 const GrpcEndpoint = require('./classes/GrpcEndpoint');
 const RestEndpoint = require('./classes/RestEndpoint');
-const { runTesterStart } = require('./utils');
+const Scenario = require('./classes/Scenario');
+const RequestValue = require('./classes/RequestValue');
+const ResponseValue = require('./classes/ResponseValue');
+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');
+const RequestV2 = require('./classes/RequestV2');
+const ResponseV2 = require('./classes/ResponseV2');
+const { AsyncScenario, AsyncRequest } = require('./classes/AsyncScenario');
+const { LoadTestConfig } = require('./classes/LoadTestConfig');
+const AsyncTestStatus = require('./classes/AsyncTestStatus');
+const { getValue, checkSchema, iterate } = require('./utils');
+const { checkStatusCode } = require('./function');
 
 module.exports = {
   SkyrampClient,
+  RequestV2,
+  ResponseV2,
   GrpcEndpoint,
   RestEndpoint,
-  runTesterStart
-}
+  Scenario,
+  RequestValue,
+  ResponseValue,
+  RestParam,
+  TrafficConfig,
+  DelayConfig,
+  Protocol,
+  Asserts,
+  Step,
+  AsyncScenario,
+  AsyncRequest,
+  LoadTestConfig,
+  AsyncTestStatus,
+  getValue,
+  checkStatusCode,
+  checkSchema,
+  iterate,
+}

package/src/lib.js

@@ -7,18 +7,18 @@ let libPath = '';
 
 if (platform === 'linux') {
   if (arch === 'x64') {
-    libPath = 'dev-linux-amd64.so';
+    libPath = 'skyramp-linux-amd64.so';
   } else if (arch === 'ia32') {
-    libPath = 'dev-linux-386.so';
+    libPath = 'skyramp-linux-386.so';
   }
 } else if (platform === 'darwin') {
   if (arch === 'x64') {
-    libPath = 'dev-darwin-amd64.dylib';
+    libPath = 'skyramp-darwin-amd64.dylib';
   } else if (arch === 'arm64') {
-    libPath = 'dev-darwin-arm64.dylib';
+    libPath = 'skyramp-darwin-arm64.dylib';
   }
 } else if (platform === 'win32') {
-  libPath = 'dev-windows-amd64.dll';
+  libPath = 'skyramp-windows-amd64.dll';
 }
 
 if (!libPath) {
@@ -27,4 +27,4 @@ if (!libPath) {
 const libFullPath = path.join(__dirname, '..', 'lib', libPath);
 const lib = koffi.load(libFullPath);
 
-module.exports = lib;
+module.exports = lib;

package/src/utils.js

@@ -1,22 +1,63 @@
 const fs = require('fs');
-const lib = require('./lib');
+const koffi = require('koffi');
 const path = require('path');
 const yaml = require('js-yaml');
+const lib = require('./lib');
+const SKYRAMP_YAML_VERSION = "v1"
 
-runTesterStartWrapper = lib.func('runTesterStartWrapper', 'string', ['string', 'string']);
-
-async function runTesterStart(namespace, testDescription) {
-  return new Promise((resolve, reject) => {
-    runTesterStartWrapper.async(namespace, testDescription, (err, res) => {
-      if (err) {
-        reject(err);
-      } else if (res) {
-        reject(new Error(res));
-      } else {
-        resolve();
-      }
-    });
-  });
+const responseType = koffi.struct({
+  response: 'char*',
+  error: 'char*',
+});
+
+const getJSONValueWrapper = lib.func('getJSONValueWrapper', responseType, ['string', 'string']);
+const checkSchemaWrapper = lib.func('checkSchemaWrapper', responseType, ['string', 'string']);
+const iterateWrapper = lib.func('generateJsonTreePathsFromBlob', 'string', ['string']);
+
+function isJSONString(value) {
+  if (typeof value !== "string") {
+      return false; // It's not a string, so it can't be JSON
+  }
+
+  try {
+      const parsed = JSON.parse(value);
+      return typeof parsed === "object" && parsed !== null;
+  } catch (e) {
+      return false; // JSON.parse failed, so it's not a JSON string
+  }
+}
+
+function safeStringify(value) {
+    return typeof value === "string" && isJSONString(value) ? value : JSON.stringify(value);
+}
+
+function getYamlBytes(jsonObject) {
+  try {
+    const yamlContent = yaml.dump(jsonObject, { lineWidth: 100 });
+    return yamlContent;
+  } catch (error) {
+    throw new Error('Error converting to YAML bytes:', error);
+  }
+}
+
+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: startsAt,
+        scenarioName: name
+      }]
+    },
+    services: services,
+    endpoints: endpoints,
+    scenarios: scenarios,
+    requests: requests
+  };
+
+  return testDescription;
 }
 
 function readDataFromFile(filename) {
@@ -34,14 +75,133 @@ function readDataFromFile(filename) {
     } else {
       throw new Error('Unsupported file format. Only .json, .yaml, and .js files are supported.');
     }
-    const jsonString = JSON.stringify(jsonData, null, 2)
-    return [jsonString, false];
-  } catch(error) {
+    return [jsonData, false];
+  } catch (error) {
     throw new Error('Error reading or parsing file: ', error);
   }
 }
 
+/**
+ * Extracts and parses a value from a JS object or JSON string using a JSON path expression
+ * @param {Object} jsonInput - A JS object or JSON string
+ * @param {string} path - The JSON path expression to extract the value (e.g. "$.data.id")
+ * @returns {*} The extracted value converted to the appropriate JavaScript type:
+ *   - For primitive types (string, number, boolean), returns the converted value
+ *   - For null values, returns null
+ *   - For complex types (arrays, objects) or errors, returns null
+ * @example
+ * const json = {
+ *   body: '{"type": "string", "value": "hello"}'
+ * };
+ * etResponseValue(response, "$.value"); // Returns "hello"
+ */
+function getValue(jsonInput, path) {
+  const jsonString = safeStringify(jsonInput);
+  const result = getJSONValueWrapper(jsonString, path);
+
+  // 1. If result is null/undefined, return null.
+  if (!result || result.error !== null) {
+    return null;
+  }
+
+  try {
+    // 2. Parse the returned JSON string.
+    const parsed = JSON.parse(result.response);
+
+    // 3. If parsed is an object of the shape { type, value }, handle typed values:
+    //    e.g., { "type": "string", "value": "hello" }
+    if (
+      parsed &&
+      typeof parsed === 'object' &&
+      !Array.isArray(parsed) &&
+      Object.prototype.hasOwnProperty.call(parsed, 'type') &&
+      Object.prototype.hasOwnProperty.call(parsed, 'value')
+    ) {
+      const { type: valueType, value } = parsed;
+
+      // Return null for complex types (arrays and objects)
+      if (['array', 'object', '[]interface {}'].includes(valueType)) {
+        return null;
+      }
+
+      // Convert to the appropriate JavaScript type
+      switch (valueType) {
+        case 'string':
+          return String(value);
+        case "float64", "float32", "int64", "int32", "int16", "int8", "uint64", "uint32", "uint16", "uint8":
+          return value;
+        case 'boolean':
+          return Boolean(value);
+        case 'null':
+          return null;
+        default:
+          // For unrecognized or fallback:
+          return value;
+      }
+    }
+
+    // 4. If the result is not of the form { type, value }, return it directly.
+    return parsed;
+  } catch (err) {
+    // 5. If JSON.parse fails or something else goes wrong, log the error and return null.
+    console.error(`Error processing JSONValue: ${err}`);
+    return null;
+  }
+}
+
+/**
+ * Validates the response body against the expected schema.
+ *
+ * @param {Object} response - An object containing a `body` property (JSON string).
+ * @param {Object|string} expectedSchema - The JSON schema (object or JSON string) to validate against.
+ * @returns {boolean} True if validation succeeds, false otherwise.
+ */
+/**
+ * Validates the response body against the expected schema.
+ *
+ * @param {Object} response - The response object containing the body to validate
+ * @param {string} response.body - The response body as a JSON string
+ * @param {Object|string} expectedSchema - The JSON schema to validate against. Can be either:
+ *   - A JSON schema object with type definitions and validation rules
+ *   - A JSON string containing a schema definition
+ * @returns {boolean} True if validation succeeds, false otherwise.
+ */
+function checkSchema(response, expectedSchema) {
+  const result = checkSchemaWrapper(response.responseBody, expectedSchema);
+  if (result.error) {
+    return false;
+  }
+  if (!result.response) {
+    return false;
+  }
+  const parsed = JSON.parse(result.response);
+  return parsed.result;
+}
+
+/**
+ * Iterate over json blob and generates list of json paths
+ *
+ * @param {Object} Dict - an object the represents json blob
+ * @returns {array} list of json paths
+ */
+function iterate(fuzz_body) {
+    const jsonString = JSON.stringify(fuzz_body);
+    const result = iterateWrapper(jsonString);
+
+    if (!result) {
+        return []
+    }
+
+    const parsed = JSON.parse(result);
+    return parsed
+}
+
 module.exports = {
-  runTesterStart,
-  readDataFromFile
+  createTestDescriptionFromScenario,
+  getYamlBytes,
+  readDataFromFile,
+  getValue,
+  checkSchema,
+  iterate,
+  SKYRAMP_YAML_VERSION
 }

package/src/utils.d.ts

@@ -1,5 +0,0 @@
-declare function runTesterStart(namespace: string, testDescription: string): Promise<void>;
-
-export {
-  runTesterStart
-};