@gatling.io/core 3.11.7 → 3.12.0

package/src/structure/rendezVous.ts

@@ -0,0 +1,23 @@
+import JvmRendezVous = io.gatling.javaapi.core.pause.RendezVous;
+
+export interface RendezVousFunction<T extends RendezVous<T>> {
+  /**
+   * Make virtual users wait until enough of them reach this point
+   *
+   * @param users - the number of virtual users that must reach this point
+   * @returns a new StructureBuilder
+   */
+  (users: number): T;
+}
+
+export interface RendezVous<T extends RendezVous<T>> {
+  rendezVous: RendezVousFunction<T>;
+}
+
+export const rendezVousImpl =
+  <J2, J1 extends JvmRendezVous<J2, any>, T extends RendezVous<T>>(
+    jvmRendezVous: J1,
+    wrap: (wrapped: J2) => T
+  ): RendezVousFunction<T> =>
+  (users: number) =>
+    wrap(jvmRendezVous.rendezVous(users));

package/src/structure/repeat.ts

@@ -0,0 +1,64 @@
+import { SessionTo, underlyingSessionTo } from "../session";
+import { On, wrapOn } from "./on";
+
+import JvmRepeat = io.gatling.javaapi.core.loop.Repeat;
+
+export interface RepeatFunction<T extends Repeat<T>> {
+  /**
+   * Define a loop that will iterate for a given number of times.
+   *
+   * @param times - the number of iterations
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (times: number, counterName?: string): On<T>;
+
+  /**
+   * Define a loop that will iterate for a given number of times.
+   *
+   * @param times - the number of iterations, expressed as a Gatling Expression Language String that must evaluate to an integer
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (times: string, counterName?: string): On<T>;
+
+  /**
+   * Define a loop that will iterate for a given number of times.
+   *
+   * @param times - the number of iterations, expressed as a function
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (times: SessionTo<number>, counterName?: string): On<T>;
+}
+
+export interface Repeat<T extends Repeat<T>> {
+  repeat: RepeatFunction<T>;
+}
+
+export const repeatImpl =
+  <J2, J1 extends JvmRepeat<J2, any>, T extends Repeat<T>>(
+    jvmRepeat: J1,
+    wrap: (wrapped: J2) => T
+  ): RepeatFunction<T> =>
+  (times: number | string | SessionTo<number>, counterName?: string) => {
+    if (counterName !== undefined) {
+      // repeat(times, counterName
+      if (typeof times === "number") {
+        return wrapOn(jvmRepeat.repeat(times, counterName), wrap);
+      } else if (typeof times === "string") {
+        return wrapOn(jvmRepeat.repeat(times, counterName), wrap);
+      } else {
+        return wrapOn(jvmRepeat.repeat(underlyingSessionTo(times), counterName), wrap);
+      }
+    } else {
+      // repeat(times)
+      if (typeof times === "number") {
+        return wrapOn(jvmRepeat.repeat(times), wrap);
+      } else if (typeof times === "string") {
+        return wrapOn(jvmRepeat.repeat(times), wrap);
+      } else {
+        return wrapOn(jvmRepeat.repeat(underlyingSessionTo(times)), wrap);
+      }
+    }
+  };

package/src/structure/roundRobinSwitch.ts

@@ -0,0 +1,34 @@
+import { Executable } from "./execs";
+
+import JvmRoundRobinSwitch = io.gatling.javaapi.core.condition.RoundRobinSwitch;
+import JvmOn = io.gatling.javaapi.core.condition.RoundRobinSwitch$On;
+
+export interface On<T> {
+  on(executable: Executable<any>, ...executables: Executable<any>[]): T;
+}
+
+const wrapOn = <J, T>(jvmOn: JvmOn<J>, wrap: (underlying: J) => T): On<T> => ({
+  on: (executable: Executable<any>, ...executables: Executable<any>[]): T =>
+    wrap(jvmOn.on(executable._underlying, ...executables.map((e) => e._underlying)))
+});
+
+export interface RoundRobinSwitchFunction<T extends RoundRobinSwitch<T>> {
+  /**
+   * Execute one of the "choices" in a round-robin fashion. Round-robin is global, not per virtual user.
+   *
+   * @returns a new StructureBuilder
+   */
+  (): On<T>;
+}
+
+export interface RoundRobinSwitch<T extends RoundRobinSwitch<T>> {
+  roundRobinSwitch: RoundRobinSwitchFunction<T>;
+}
+
+export const roundRobinSwitchImpl =
+  <J2, J1 extends JvmRoundRobinSwitch<J2, any>, T extends RoundRobinSwitch<T>>(
+    jvmRoundRobinSwitch: J1,
+    wrap: (wrapped: J2) => T
+  ): RoundRobinSwitchFunction<T> =>
+  () =>
+    wrapOn(jvmRoundRobinSwitch.roundRobinSwitch(), wrap);

package/src/structure/uniformRandomSwitch.ts

@@ -0,0 +1,34 @@
+import { Executable } from "./execs";
+
+import JvmUniformRandomSwitch = io.gatling.javaapi.core.condition.UniformRandomSwitch;
+import JvmOn = io.gatling.javaapi.core.condition.UniformRandomSwitch$On;
+
+export interface On<T> {
+  on(executable: Executable<any>, ...executables: Executable<any>[]): T;
+}
+
+const wrapOn = <J, T>(jvmOn: JvmOn<J>, wrap: (underlying: J) => T): On<T> => ({
+  on: (executable: Executable<any>, ...executables: Executable<any>[]): T =>
+    wrap(jvmOn.on(executable._underlying, ...executables.map((e) => e._underlying)))
+});
+
+export interface UniformRandomSwitchFunction<T extends UniformRandomSwitch<T>> {
+  /**
+   * Execute one of the "choices" in a random fashion, with each having even weights.
+   *
+   * @returns a DSL component for defining the "choices"
+   */
+  (): On<T>;
+}
+
+export interface UniformRandomSwitch<T extends UniformRandomSwitch<T>> {
+  uniformRandomSwitch: UniformRandomSwitchFunction<T>;
+}
+
+export const uniformRandomSwitchImpl =
+  <J2, J1 extends JvmUniformRandomSwitch<J2, any>, T extends UniformRandomSwitch<T>>(
+    jvmUniformRandomSwitch: J1,
+    wrap: (wrapped: J2) => T
+  ): UniformRandomSwitchFunction<T> =>
+  () =>
+    wrapOn(jvmUniformRandomSwitch.uniformRandomSwitch(), wrap);

package/src/throttling.ts

@@ -0,0 +1,67 @@
+import { CoreDsl as JvmCoreDsl } from "@gatling.io/jvm-types";
+
+import { Duration, toJvmDuration } from "./utils/duration";
+import { Wrapper } from "./common";
+
+import JvmThrottleStep = io.gatling.javaapi.core.ThrottleStep;
+import JvmThrottleStepReachIntermediate = io.gatling.javaapi.core.ThrottleStep$ReachIntermediate;
+
+/**
+ * Bootstrap a new reachRps throttling profile, see {@link ThrottleStepReachIntermediate}
+ *
+ * @param target - the target requests per second
+ * @returns the next DSL step
+ */
+export const reachRps = (target: number): ThrottleStepReachIntermediate =>
+  wrapThrottleStepReachIntermediate(JvmCoreDsl.reachRps(target));
+
+/**
+ * Bootstrap a new holdFor throttling profile that limits rps to its current value
+ *
+ * @param duration - the duration of the plateau in seconds
+ * @returns the next DSL step
+ */
+export const holdFor = (duration: Duration): ThrottleStep =>
+  wrapThrottleStep(JvmCoreDsl.holdFor(toJvmDuration(duration)));
+
+/**
+ * Bootstrap a new jumpToRps throttling profile that change the rps limit to a new value
+ *
+ * @param target - the new limit
+ * @returns the next DSL step
+ */
+export const jumpToRps = (target: number): ThrottleStep => wrapThrottleStep(JvmCoreDsl.jumpToRps(target));
+
+export interface ThrottleStep extends Wrapper<JvmThrottleStep> {}
+
+const wrapThrottleStep = (_underlying: JvmThrottleStep): ThrottleStep => ({
+  _underlying
+});
+
+/**
+ * DSL step to define the duration of a throttling ramp.
+ */
+export interface ThrottleStepReachIntermediate {
+  /**
+   * Define the duration of a throttling ramp
+   *
+   * @param duration - the duration
+   * @returns a new ThrottleStep
+   */
+  in(duration: Duration): ThrottleStep;
+
+  /**
+   * Alias for `in` that's a reserved keyword in Kotlin
+   *
+   * @param duration - the duration
+   * @returns a new ThrottleStep
+   */
+  during(duration: Duration): ThrottleStep;
+}
+
+const wrapThrottleStepReachIntermediate = (
+  _underlying: JvmThrottleStepReachIntermediate
+): ThrottleStepReachIntermediate => ({
+  in: (duration) => wrapThrottleStep(_underlying.in(toJvmDuration(duration))),
+  during: (duration) => wrapThrottleStep(_underlying.during(toJvmDuration(duration)))
+});

package/src/utils/duration.ts

@@ -0,0 +1,28 @@
+import { Duration as JvmDuration } from "@gatling.io/jvm-types";
+
+export type TimeUnit = "milliseconds" | "seconds" | "minutes";
+
+export type Duration =
+  | number
+  | {
+      amount: number;
+      unit: TimeUnit;
+    };
+
+export const isDuration = (x: unknown): x is Duration =>
+  typeof x === "number" ||
+  (typeof x === "object" && typeof (x as any).amount === "number" && typeof (x as any).unit === "string");
+
+export const toJvmDuration = (duration: Duration): java.time.Duration => {
+  const { amount, unit } = typeof duration === "number" ? { amount: duration, unit: "seconds" } : duration;
+  switch (unit) {
+    case "milliseconds":
+      return JvmDuration.ofMillis(amount);
+    case "seconds":
+      return JvmDuration.ofSeconds(amount);
+    case "minutes":
+      return JvmDuration.ofMinutes(amount);
+    default:
+      return JvmDuration.ofSeconds(amount);
+  }
+};

package/target/structure/errors.d.ts

@@ -58,25 +58,26 @@ export interface ExitHereIfFailedFunction<T extends Errors<T>> {
      */
     (): T;
 }
-export interface StopInjectorFunction<T extends Errors<T>> {
+export interface StopLoadGeneratorFunction<T extends Errors<T>> {
     /**
-     * Have the virtual user abruptly stop the injector
+     * Have the virtual user abruptly stop the load generator with a successful status
      *
      * @param message - the message, expressed as a Gatling Expression Language String
      * @returns a new StructureBuilder
      */
     (message: string): T;
     /**
-     * Have the virtual user abruptly stop the injector
+     * Have the virtual user abruptly stop the load generator with a successful status
      *
      * @param message - the message, expressed as a function
      * @returns a new StructureBuilder
      */
     (message: SessionTo<string>): T;
 }
-export interface StopInjectorIfFunction<T extends Errors<T>> {
+export interface StopLoadGeneratorIfFunction<T extends Errors<T>> {
     /**
-     * Have the virtual user abruptly stop the injector if a condition is met
+     * Have the virtual user abruptly stop the load generator with a successful status if a condition
+     * is met
      *
      * @param message - the message, expressed as a Gatling Expression Language String
      * @param condition - the condition, expressed as a Gatling Expression Language String
@@ -84,7 +85,8 @@ export interface StopInjectorIfFunction<T extends Errors<T>> {
      */
     (message: string, condition: string): T;
     /**
-     * Have the virtual user abruptly stop the injector if a condition is met
+     * Have the virtual user abruptly stop the load generator with a successful status if a condition
+     * is met
      *
      * @param message - the message, expressed as a Gatling Expression Language String
      * @param condition - the condition, expressed as a function
@@ -92,7 +94,8 @@ export interface StopInjectorIfFunction<T extends Errors<T>> {
      */
     (message: string, condition: SessionTo<boolean>): T;
     /**
-     * Have the virtual user abruptly stop the injector if a condition is met
+     * Have the virtual user abruptly stop the load generator with a successful status if a condition
+     * is met
      *
      * @param message - the message, expressed as a function
      * @param condition - the condition, expressed as a Gatling Expression Language String
@@ -100,7 +103,62 @@ export interface StopInjectorIfFunction<T extends Errors<T>> {
      */
     (message: SessionTo<string>, condition: string): T;
     /**
-     * Have the virtual user abruptly stop the injector if a condition is met
+     * Have the virtual user abruptly stop the load generator with a successful status if a condition
+     * is met
+     *
+     * @param message - the message, expressed as a function
+     * @param condition - the condition, expressed as a function
+     * @returns a new StructureBuilder
+     */
+    (message: SessionTo<string>, condition: SessionTo<boolean>): T;
+}
+export interface CrashLoadGeneratorFunction<T extends Errors<T>> {
+    /**
+     * Have the virtual user abruptly stop the load generator with a failed status
+     *
+     * @param message - the message, expressed as a Gatling Expression Language String
+     * @returns a new StructureBuilder
+     */
+    (message: string): T;
+    /**
+     * Have the virtual user abruptly crash the load generator with a failed status
+     *
+     * @param message - the message, expressed as a function
+     * @returns a new StructureBuilder
+     */
+    (message: SessionTo<string>): T;
+}
+export interface CrashLoadGeneratorIfFunction<T extends Errors<T>> {
+    /**
+     * Have the virtual user abruptly crash the load generator with a failed status if a condition is
+     * met
+     *
+     * @param message - the message, expressed as a Gatling Expression Language String
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @returns a new StructureBuilder
+     */
+    (message: string, condition: string): T;
+    /**
+     * Have the virtual user abruptly crash the load generator with a failed status if a condition is
+     * met
+     *
+     * @param message - the message, expressed as a Gatling Expression Language String
+     * @param condition - the condition, expressed as a function
+     * @returns a new StructureBuilder
+     */
+    (message: string, condition: SessionTo<boolean>): T;
+    /**
+     * Have the virtual user abruptly crash the load generator with a failed status if a condition is
+     * met
+     *
+     * @param message - the message, expressed as a function
+     * @param condition - the condition, expressed as a Gatling Expression Language String
+     * @returns a new StructureBuilder
+     */
+    (message: SessionTo<string>, condition: string): T;
+    /**
+     * Have the virtual user abruptly crash the load generator with a failed status if a condition is
+     * met
      *
      * @param message - the message, expressed as a function
      * @param condition - the condition, expressed as a function
@@ -114,7 +172,9 @@ export interface Errors<T extends Errors<T>> {
     exitHereIf: ExitHereIfFunction<T>;
     exitHere: ExitHereFunction<T>;
     exitHereIfFailed: ExitHereIfFailedFunction<T>;
-    stopInjector: StopInjectorFunction<T>;
-    stopInjectorIf: StopInjectorIfFunction<T>;
+    stopLoadGenerator: StopLoadGeneratorFunction<T>;
+    stopLoadGeneratorIf: StopLoadGeneratorIfFunction<T>;
+    crashLoadGenerator: CrashLoadGeneratorFunction<T>;
+    crashLoadGeneratorIf: CrashLoadGeneratorIfFunction<T>;
 }
 export declare const errorsImpl: <J2, J1 extends JvmErrors<J2, any>, T extends Errors<T>>(jvmErrors: J1, wrap: (wrapped: J2) => T) => Errors<T>;

package/target/structure/errors.js

@@ -15,24 +15,45 @@ const errorsImpl = (jvmErrors, wrap) => ({
         : jvmErrors.exitHereIf(condition)),
     exitHere: () => wrap(jvmErrors.exitHere()),
     exitHereIfFailed: () => wrap(jvmErrors.exitHereIfFailed()),
-    stopInjector: (message) => wrap(typeof message === "function"
-        ? jvmErrors.stopInjector((0, session_1.underlyingSessionTo)(message))
-        : jvmErrors.stopInjector(message)),
-    stopInjectorIf: (message, condition) => {
+    stopLoadGenerator: (message) => wrap(typeof message === "function"
+        ? jvmErrors.stopLoadGenerator((0, session_1.underlyingSessionTo)(message))
+        : jvmErrors.stopLoadGenerator(message)),
+    stopLoadGeneratorIf: (message, condition) => {
         if (typeof message === "function") {
             if (typeof condition === "function") {
-                return wrap(jvmErrors.stopInjectorIf((0, session_1.underlyingSessionTo)(message), (0, session_1.underlyingSessionTo)(condition)));
+                return wrap(jvmErrors.stopLoadGeneratorIf((0, session_1.underlyingSessionTo)(message), (0, session_1.underlyingSessionTo)(condition)));
             }
             else {
-                return wrap(jvmErrors.stopInjectorIf((0, session_1.underlyingSessionTo)(message), condition));
+                return wrap(jvmErrors.stopLoadGeneratorIf((0, session_1.underlyingSessionTo)(message), condition));
             }
         }
         else {
             if (typeof condition === "function") {
-                return wrap(jvmErrors.stopInjectorIf(message, (0, session_1.underlyingSessionTo)(condition)));
+                return wrap(jvmErrors.stopLoadGeneratorIf(message, (0, session_1.underlyingSessionTo)(condition)));
             }
             else {
-                return wrap(jvmErrors.stopInjectorIf(message, condition));
+                return wrap(jvmErrors.stopLoadGeneratorIf(message, condition));
+            }
+        }
+    },
+    crashLoadGenerator: (message) => wrap(typeof message === "function"
+        ? jvmErrors.crashLoadGenerator((0, session_1.underlyingSessionTo)(message))
+        : jvmErrors.crashLoadGenerator(message)),
+    crashLoadGeneratorIf: (message, condition) => {
+        if (typeof message === "function") {
+            if (typeof condition === "function") {
+                return wrap(jvmErrors.crashLoadGeneratorIf((0, session_1.underlyingSessionTo)(message), (0, session_1.underlyingSessionTo)(condition)));
+            }
+            else {
+                return wrap(jvmErrors.crashLoadGeneratorIf((0, session_1.underlyingSessionTo)(message), condition));
+            }
+        }
+        else {
+            if (typeof condition === "function") {
+                return wrap(jvmErrors.crashLoadGeneratorIf(message, (0, session_1.underlyingSessionTo)(condition)));
+            }
+            else {
+                return wrap(jvmErrors.crashLoadGeneratorIf(message, condition));
             }
         }
     }

package/target/structure/index.d.ts

@@ -59,5 +59,7 @@ export declare const tryMax: import("./errors").TryMaxFunction<ChainBuilder>;
 export declare const exitHereIf: import("./errors").ExitHereIfFunction<ChainBuilder>;
 export declare const exitHere: import("./errors").ExitHereFunction<ChainBuilder>;
 export declare const exitHereIfFailed: import("./errors").ExitHereIfFailedFunction<ChainBuilder>;
-export declare const stopInjector: import("./errors").StopInjectorFunction<ChainBuilder>;
-export declare const stopInjectorIf: import("./errors").StopInjectorIfFunction<ChainBuilder>;
+export declare const stopLoadGenerator: import("./errors").StopLoadGeneratorFunction<ChainBuilder>;
+export declare const stopLoadGeneratorIf: import("./errors").StopLoadGeneratorIfFunction<ChainBuilder>;
+export declare const crashLoadGenerator: import("./errors").CrashLoadGeneratorFunction<ChainBuilder>;
+export declare const crashLoadGeneratorIf: import("./errors").CrashLoadGeneratorIfFunction<ChainBuilder>;

package/target/structure/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stopInjectorIf = exports.stopInjector = exports.exitHereIfFailed = exports.exitHere = exports.exitHereIf = exports.tryMax = exports.exitBlockOnFail = exports.roundRobinSwitch = exports.uniformRandomSwitch = exports.randomSwitchOrElse = exports.randomSwitch = exports.doSwitchOrElse = exports.doSwitch = exports.doIfEqualsOrElse = exports.doIfEquals = exports.doIfOrElse = exports.doIf = exports.doWhileDuring = exports.asLongAsDuring = exports.doWhile = exports.asLongAs = exports.forever = exports.during = exports.foreach = exports.repeat = exports.rendezVous = exports.pace = exports.pause = exports.feed = exports.group = exports.exec = exports.percent = exports.onCase = exports.wrapActionBuilder = exports.structureBuilderImpl = void 0;
+exports.crashLoadGeneratorIf = exports.crashLoadGenerator = exports.stopLoadGeneratorIf = exports.stopLoadGenerator = exports.exitHereIfFailed = exports.exitHere = exports.exitHereIf = exports.tryMax = exports.exitBlockOnFail = exports.roundRobinSwitch = exports.uniformRandomSwitch = exports.randomSwitchOrElse = exports.randomSwitch = exports.doSwitchOrElse = exports.doSwitch = exports.doIfEqualsOrElse = exports.doIfEquals = exports.doIfOrElse = exports.doIf = exports.doWhileDuring = exports.asLongAsDuring = exports.doWhile = exports.asLongAs = exports.forever = exports.during = exports.foreach = exports.repeat = exports.rendezVous = exports.pace = exports.pause = exports.feed = exports.group = exports.exec = exports.percent = exports.onCase = exports.wrapActionBuilder = exports.structureBuilderImpl = void 0;
 const jvm_types_1 = require("@gatling.io/jvm-types");
 const execs_1 = require("./execs");
 const groups_1 = require("./groups");
@@ -92,5 +92,7 @@ exports.tryMax = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder)
 exports.exitHereIf = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder).exitHereIf;
 exports.exitHere = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder).exitHere;
 exports.exitHereIfFailed = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder).exitHereIfFailed;
-exports.stopInjector = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder).stopInjector;
-exports.stopInjectorIf = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder).stopInjectorIf;
+exports.stopLoadGenerator = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder).stopLoadGenerator;
+exports.stopLoadGeneratorIf = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder).stopLoadGeneratorIf;
+exports.crashLoadGenerator = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder).crashLoadGenerator;
+exports.crashLoadGeneratorIf = (0, errors_1.errorsImpl)(jvm_types_1.CoreDsl, wrapChainBuilder).crashLoadGeneratorIf;

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "baseUrl": "./",
+    "rootDir": "src",
+    "outDir": "target",
+    "lib": ["es2021"],
+    "target": "es2021",
+    "module": "node16",
+    "esModuleInterop": true,
+    "moduleResolution": "node16",
+    "declaration": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["**/*.test.ts", "jest.config.ts"]
+}