@gatling.io/core 3.11.7 → 3.12.0

package/src/structure/groups.ts

@@ -0,0 +1,23 @@
+import JvmGroups = io.gatling.javaapi.core.group.Groups;
+
+import { SessionTo, underlyingSessionTo } from "../session";
+import { On, wrapOn } from "./on";
+
+export interface GroupFunction<T extends Groups<T>> {
+  /**
+   * Define a group
+   *
+   * @param name - the name of the group, expressed as a Gatling Expression Language String or a function
+   * @returns a DSL component for defining the wrapped block
+   */
+  (name: string | SessionTo<string>): On<T>;
+}
+
+export interface Groups<T extends Groups<T>> {
+  group: GroupFunction<T>;
+}
+
+export const groupImpl =
+  <J2, J1 extends JvmGroups<J2, any>, T extends Groups<T>>(jvmGroups: J1, wrap: (wrapped: J2) => T): GroupFunction<T> =>
+  (group: string | SessionTo<string>) =>
+    wrapOn(typeof group === "function" ? jvmGroups.group(underlyingSessionTo(group)) : jvmGroups.group(group), wrap);

package/src/structure/index.ts

@@ -0,0 +1,130 @@
+import { CoreDsl as JvmCoreDsl } from "@gatling.io/jvm-types";
+
+import JvmChainBuilder = io.gatling.javaapi.core.ChainBuilder;
+
+import { JvmStructureBuilderLike } from "./jvmStructureBuilder";
+import { ExecFunction, Execs, execImpl, Executable } from "./execs";
+import { GroupFunction, Groups, groupImpl } from "./groups";
+import { FeedFunction, Feeds, feedImpl } from "./feeds";
+import { PauseFunction, Pauses, pauseImpl } from "./pauses";
+import { Paces, paceImpl } from "./paces";
+import { RendezVous, rendezVousImpl } from "./rendezVous";
+import { Repeat, repeatImpl } from "./repeat";
+import { ForEach, foreachImpl } from "./forEach";
+import { During, duringImpl } from "./during";
+import { Forever, foreverImpl } from "./forever";
+import { AsLongAs, asLongAsImpl } from "./asLongAs";
+import { DoWhile, doWhileImpl } from "./doWhile";
+import { AsLongAsDuring, asLongAsDuringImpl } from "./asLongAsDuring";
+import { DoWhileDuring, doWhileDuringImpl } from "./doWhileDuring";
+import { DoIf, DoIfEquals, doIfImpl, doIfEqualsImpl } from "./doIf";
+import { DoIfOrElse, DoIfEqualsOrElse, doIfOrElseImpl, doIfEqualsOrElseImpl } from "./doIfOrElse";
+import { DoSwitch, doSwitchImpl } from "./doSwitch";
+import { DoSwitchOrElse, doSwitchOrElseImpl } from "./doSwitchOrElse";
+import { RandomSwitch, randomSwitchImpl } from "./randomSwitch";
+import { RandomSwitchOrElse, randomSwitchOrElseImpl } from "./randomSwitchOrElse";
+import { UniformRandomSwitch, uniformRandomSwitchImpl } from "./uniformRandomSwitch";
+import { RoundRobinSwitch, roundRobinSwitchImpl } from "./roundRobinSwitch";
+import { Errors, errorsImpl } from "./errors";
+
+export interface StructureBuilder<T extends StructureBuilder<T>>
+  extends Execs<T>,
+    Groups<T>,
+    Feeds<T>,
+    Pauses<T>,
+    Paces<T>,
+    RendezVous<T>,
+    Repeat<T>,
+    ForEach<T>,
+    During<T>,
+    Forever<T>,
+    AsLongAs<T>,
+    DoWhile<T>,
+    AsLongAsDuring<T>,
+    DoWhileDuring<T>,
+    DoIf<T>,
+    DoIfOrElse<T>,
+    DoIfEquals<T>,
+    DoIfEqualsOrElse<T>,
+    DoSwitch<T>,
+    DoSwitchOrElse<T>,
+    RandomSwitch<T>,
+    RandomSwitchOrElse<T>,
+    UniformRandomSwitch<T>,
+    RoundRobinSwitch<T>,
+    Errors<T> {}
+
+export const structureBuilderImpl = <J2, J1 extends JvmStructureBuilderLike<J2, any>, T extends StructureBuilder<T>>(
+  jvm: J1,
+  wrap: (wrapped: J2) => T
+): StructureBuilder<T> => ({
+  exec: execImpl(jvm, wrap),
+  group: groupImpl(jvm, wrap),
+  feed: feedImpl(jvm, wrap),
+  pause: pauseImpl(jvm, wrap),
+  pace: paceImpl(jvm, wrap),
+  rendezVous: rendezVousImpl(jvm, wrap),
+  repeat: repeatImpl(jvm, wrap),
+  foreach: foreachImpl(jvm, wrap),
+  during: duringImpl(jvm, wrap),
+  forever: foreverImpl(jvm, wrap),
+  asLongAs: asLongAsImpl(jvm, wrap),
+  doWhile: doWhileImpl(jvm, wrap),
+  asLongAsDuring: asLongAsDuringImpl(jvm, wrap),
+  doWhileDuring: doWhileDuringImpl(jvm, wrap),
+  doIf: doIfImpl(jvm, wrap),
+  doIfOrElse: doIfOrElseImpl(jvm, wrap),
+  doIfEquals: doIfEqualsImpl(jvm, wrap),
+  doIfEqualsOrElse: doIfEqualsOrElseImpl(jvm, wrap),
+  doSwitch: doSwitchImpl(jvm, wrap),
+  doSwitchOrElse: doSwitchOrElseImpl(jvm, wrap),
+  randomSwitch: randomSwitchImpl(jvm, wrap),
+  randomSwitchOrElse: randomSwitchOrElseImpl(jvm, wrap),
+  uniformRandomSwitch: uniformRandomSwitchImpl(jvm, wrap),
+  roundRobinSwitch: roundRobinSwitchImpl(jvm, wrap),
+  ...errorsImpl(jvm, wrap)
+});
+
+export interface ChainBuilder extends StructureBuilder<ChainBuilder>, Executable<JvmChainBuilder> {}
+
+const wrapChainBuilder = (_underlying: JvmChainBuilder): ChainBuilder => ({
+  _underlying,
+  ...structureBuilderImpl(_underlying, wrapChainBuilder)
+});
+
+// CoreDsl elements
+export { ActionBuilder, wrapActionBuilder } from "./execs";
+export { onCase, percent } from "./choices";
+export const exec: ExecFunction<ChainBuilder> = execImpl(JvmCoreDsl, wrapChainBuilder);
+export const group: GroupFunction<ChainBuilder> = groupImpl(JvmCoreDsl, wrapChainBuilder);
+export const feed: FeedFunction<ChainBuilder> = feedImpl(JvmCoreDsl, wrapChainBuilder);
+export const pause: PauseFunction<ChainBuilder> = pauseImpl(JvmCoreDsl, wrapChainBuilder);
+export const pace = paceImpl(JvmCoreDsl, wrapChainBuilder);
+export const rendezVous = rendezVousImpl(JvmCoreDsl, wrapChainBuilder);
+export const repeat = repeatImpl(JvmCoreDsl, wrapChainBuilder);
+export const foreach = foreachImpl(JvmCoreDsl, wrapChainBuilder);
+export const during = duringImpl(JvmCoreDsl, wrapChainBuilder);
+export const forever = foreverImpl(JvmCoreDsl, wrapChainBuilder);
+export const asLongAs = asLongAsImpl(JvmCoreDsl, wrapChainBuilder);
+export const doWhile = doWhileImpl(JvmCoreDsl, wrapChainBuilder);
+export const asLongAsDuring = asLongAsDuringImpl(JvmCoreDsl, wrapChainBuilder);
+export const doWhileDuring = doWhileDuringImpl(JvmCoreDsl, wrapChainBuilder);
+export const doIf = doIfImpl(JvmCoreDsl, wrapChainBuilder);
+export const doIfOrElse = doIfOrElseImpl(JvmCoreDsl, wrapChainBuilder);
+export const doIfEquals = doIfEqualsImpl(JvmCoreDsl, wrapChainBuilder);
+export const doIfEqualsOrElse = doIfEqualsOrElseImpl(JvmCoreDsl, wrapChainBuilder);
+export const doSwitch = doSwitchImpl(JvmCoreDsl, wrapChainBuilder);
+export const doSwitchOrElse = doSwitchOrElseImpl(JvmCoreDsl, wrapChainBuilder);
+export const randomSwitch = randomSwitchImpl(JvmCoreDsl, wrapChainBuilder);
+export const randomSwitchOrElse = randomSwitchOrElseImpl(JvmCoreDsl, wrapChainBuilder);
+export const uniformRandomSwitch = uniformRandomSwitchImpl(JvmCoreDsl, wrapChainBuilder);
+export const roundRobinSwitch = roundRobinSwitchImpl(JvmCoreDsl, wrapChainBuilder);
+export const exitBlockOnFail = errorsImpl(JvmCoreDsl, wrapChainBuilder).exitBlockOnFail;
+export const tryMax = errorsImpl(JvmCoreDsl, wrapChainBuilder).tryMax;
+export const exitHereIf = errorsImpl(JvmCoreDsl, wrapChainBuilder).exitHereIf;
+export const exitHere = errorsImpl(JvmCoreDsl, wrapChainBuilder).exitHere;
+export const exitHereIfFailed = errorsImpl(JvmCoreDsl, wrapChainBuilder).exitHereIfFailed;
+export const stopLoadGenerator = errorsImpl(JvmCoreDsl, wrapChainBuilder).stopLoadGenerator;
+export const stopLoadGeneratorIf = errorsImpl(JvmCoreDsl, wrapChainBuilder).stopLoadGeneratorIf;
+export const crashLoadGenerator = errorsImpl(JvmCoreDsl, wrapChainBuilder).crashLoadGenerator;
+export const crashLoadGeneratorIf = errorsImpl(JvmCoreDsl, wrapChainBuilder).crashLoadGeneratorIf;

package/src/structure/jvmStructureBuilder.ts

@@ -0,0 +1,52 @@
+import JvmExecs = io.gatling.javaapi.core.exec.Execs;
+import JvmGroups = io.gatling.javaapi.core.group.Groups;
+import JvmFeeds = io.gatling.javaapi.core.feed.Feeds;
+import JvmPauses = io.gatling.javaapi.core.pause.Pauses;
+import JvmPaces = io.gatling.javaapi.core.pause.Paces;
+import JvmRendezVous = io.gatling.javaapi.core.pause.RendezVous;
+import JvmRepeat = io.gatling.javaapi.core.loop.Repeat;
+import JvmForEach = io.gatling.javaapi.core.loop.ForEach;
+import JvmDuring = io.gatling.javaapi.core.loop.During;
+import JvmForever = io.gatling.javaapi.core.loop.Forever;
+import JvmAsLongAs = io.gatling.javaapi.core.loop.AsLongAs;
+import JvmDoWhile = io.gatling.javaapi.core.loop.DoWhile;
+import JvmAsLongAsDuring = io.gatling.javaapi.core.loop.AsLongAsDuring;
+import JvmDoWhileDuring = io.gatling.javaapi.core.loop.DoWhileDuring;
+import JvmDoIf = io.gatling.javaapi.core.condition.DoIf;
+import JvmDoIfOrElse = io.gatling.javaapi.core.condition.DoIfOrElse;
+import JvmDoIfEquals = io.gatling.javaapi.core.condition.DoIfEquals;
+import JvmDoIfEqualsOrElse = io.gatling.javaapi.core.condition.DoIfEqualsOrElse;
+import JvmDoSwitch = io.gatling.javaapi.core.condition.DoSwitch;
+import JvmDoSwitchOrElse = io.gatling.javaapi.core.condition.DoSwitchOrElse;
+import JvmRandomSwitch = io.gatling.javaapi.core.condition.RandomSwitch;
+import JvmRandomSwitchOrElse = io.gatling.javaapi.core.condition.RandomSwitchOrElse;
+import JvmUniformRandomSwitch = io.gatling.javaapi.core.condition.UniformRandomSwitch;
+import JvmRoundRobinSwitch = io.gatling.javaapi.core.condition.RoundRobinSwitch;
+import JvmErrors = io.gatling.javaapi.core.error.Errors;
+
+export interface JvmStructureBuilderLike<T, W>
+  extends JvmExecs<T, W>,
+    JvmGroups<T, W>,
+    JvmFeeds<T, W>,
+    JvmPauses<T, W>,
+    JvmPaces<T, W>,
+    JvmRendezVous<T, W>,
+    JvmRepeat<T, W>,
+    JvmForEach<T, W>,
+    JvmDuring<T, W>,
+    JvmForever<T, W>,
+    JvmAsLongAs<T, W>,
+    JvmDoWhile<T, W>,
+    JvmAsLongAsDuring<T, W>,
+    JvmDoWhileDuring<T, W>,
+    JvmDoIf<T, W>,
+    JvmDoIfOrElse<T, W>,
+    JvmDoIfEquals<T, W>,
+    JvmDoIfEqualsOrElse<T, W>,
+    JvmDoSwitch<T, W>,
+    JvmDoSwitchOrElse<T, W>,
+    JvmRandomSwitch<T, W>,
+    JvmRandomSwitchOrElse<T, W>,
+    JvmUniformRandomSwitch<T, W>,
+    JvmRoundRobinSwitch<T, W>,
+    JvmErrors<T, W> {}

package/src/structure/on.ts

@@ -0,0 +1,20 @@
+import JvmExecutable = io.gatling.javaapi.core.exec.Executable;
+
+import { Executable } from "./execs";
+
+interface JvmOn<T> {
+  // In the Java DSL, there is a different On class for each type of condition/loop, but the signature of the on method
+  // remains the same.
+  on(arg0: JvmExecutable, ...arg1: JvmExecutable[]): T;
+  equals(arg0: any /*java.lang.Object*/): boolean;
+  toString(): string;
+}
+
+export interface On<T> {
+  on(executable: Executable<any>, ...executables: Executable<any>[]): T;
+}
+
+export 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)))
+});

package/src/structure/paces.ts

@@ -0,0 +1,156 @@
+import { Duration, isDuration, toJvmDuration } from "../utils/duration";
+import { SessionTo, underlyingSessionToDuration } from "../session";
+
+import JvmPaces = io.gatling.javaapi.core.pause.Paces;
+
+export interface PaceFunction<T extends Paces<T>> {
+  /**
+   * Attach a pace action
+   *
+   * @param duration - the duration of the pace, in seconds or with an explicit time unit
+   * @returns a new StructureBuilder
+   */
+  (duration: Duration): T;
+
+  /**
+   * Attach a pace action where the duration is defined as a Gatling Expression Language string. This expression must
+   * resolve to either a number, then the unit will be seconds, or an object with an explicit time unit.
+   *
+   * @param duration - the duration of the pace
+   * @returns a new StructureBuilder
+   */
+  (duration: string): T;
+
+  /**
+   * Attach a pace action
+   *
+   * @param duration - the duration of the pace as a function
+   * @returns a new StructureBuilder
+   */
+  (duration: SessionTo<Duration>): T;
+
+  /**
+   * Attach a pace action
+   *
+   * @param duration - the duration of the pace, in seconds or with an explicit time unit
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a new StructureBuilder
+   */
+  (duration: Duration, counterName: string): T;
+
+  /**
+   * Attach a pace action where the duration is defined as a Gatling Expression Language string. This expression must
+   * resolve to either a number, then the unit will be seconds, or an object with an explicit time unit.
+   *
+   * @param duration - the duration of the pace
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a new StructureBuilder
+   */
+  (duration: string, counterName: string): T;
+
+  /**
+   * Attach a pace action
+   *
+   * @param duration - the duration of the pace as a function
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a new StructureBuilder
+   */
+  (duration: SessionTo<Duration>, counterName: string): T;
+
+  /**
+   * Attach a pace action where the duration is random between 2 bounds
+   *
+   * @param min - the duration of the pace, in seconds or with an explicit time unit
+   * @param max - the duration of the pace, in seconds or with an explicit time unit
+   * @returns a new StructureBuilder
+   */
+  (min: Duration, max: Duration): T;
+
+  /**
+   * Attach a pace action where the duration is random between 2 bounds
+   *
+   * @param min - the duration of the pace as a function
+   * @param max - the duration of the pace as a function
+   * @returns a new StructureBuilder
+   */
+  (min: SessionTo<Duration>, max: SessionTo<Duration>): T;
+
+  /**
+   * Attach a pace action where the duration is random between 2 bounds
+   *
+   * @param min - the duration of the pace, in seconds or with an explicit time unit
+   * @param max - the duration of the pace, in seconds or with an explicit time unit
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a new StructureBuilder
+   */
+  (min: Duration, max: Duration, counterName: string): T;
+
+  /**
+   * Attach a pace action where the duration is random between 2 bounds as Gatling Expression Language strings. These
+   * expressions must resolve to either a number, then the unit will be seconds, or an object with an explicit time unit.
+   *
+   * @param min - the duration of the pace
+   * @param max - the duration of the pace
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a new StructureBuilder
+   */
+  (min: string, max: string, counterName: string): T;
+
+  /**
+   * Attach a pace action where the duration is random between 2 bounds
+   *
+   * @param min - the duration of the pace as a function
+   * @param max - the duration of the pace as a function
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a new StructureBuilder
+   */
+  (min: SessionTo<Duration>, max: SessionTo<Duration>, counterName: string): T;
+}
+
+export interface Paces<T extends Paces<T>> {
+  pace: PaceFunction<T>;
+}
+
+export const paceImpl =
+  <J2, J1 extends JvmPaces<J2, any>, T extends Paces<T>>(jvmGroups: J1, wrap: (wrapped: J2) => T): PaceFunction<T> =>
+  (arg0: Duration | SessionTo<Duration> | string, arg1?: Duration | SessionTo<Duration> | string, arg2?: string) => {
+    if (arg2 !== undefined) {
+      // pace(min, max, counterName)
+      if (typeof arg0 === "string" && typeof arg1 === "string") {
+        return wrap(jvmGroups.pace(arg0, arg1, arg2));
+      } else if (typeof arg0 === "function" && typeof arg1 === "function") {
+        return wrap(jvmGroups.pace(underlyingSessionToDuration(arg0), underlyingSessionToDuration(arg1), arg2));
+      } else if (isDuration(arg0) && isDuration(arg1)) {
+        return wrap(jvmGroups.pace(toJvmDuration(arg0), toJvmDuration(arg1), arg2));
+      }
+    } else if (arg1 !== undefined) {
+      if (typeof arg1 === "string") {
+        // pace(duration, counterName)
+        if (typeof arg0 === "string") {
+          return wrap(jvmGroups.pace(arg0, arg1));
+        } else if (typeof arg0 === "function") {
+          return wrap(jvmGroups.pace(underlyingSessionToDuration(arg0), arg1));
+        } else if (isDuration(arg0)) {
+          return wrap(jvmGroups.pace(toJvmDuration(arg0), arg1));
+        }
+      } else {
+        // pace(min, max)
+        if (typeof arg0 === "function" && typeof arg1 === "function") {
+          return wrap(jvmGroups.pace(underlyingSessionToDuration(arg0), underlyingSessionToDuration(arg1)));
+        } else if (isDuration(arg0) && isDuration(arg1)) {
+          return wrap(jvmGroups.pace(toJvmDuration(arg0), toJvmDuration(arg1)));
+        }
+      }
+    } else {
+      // pace(duration)
+      if (typeof arg0 === "string") {
+        return wrap(jvmGroups.pace(arg0));
+      } else if (typeof arg0 === "function") {
+        return wrap(jvmGroups.pace(underlyingSessionToDuration(arg0)));
+      } else if (isDuration(arg0)) {
+        return wrap(jvmGroups.pace(toJvmDuration(arg0)));
+      }
+    }
+
+    throw Error(`pace() called with invalid arguments ${arg0}, ${arg1}, ${arg2}`);
+  };

package/src/structure/pauses.ts

@@ -0,0 +1,211 @@
+import { CoreDsl as JvmCoreDsl } from "@gatling.io/jvm-types";
+import JvmPauses = io.gatling.javaapi.core.pause.Pauses;
+import JvmPauseType = io.gatling.javaapi.core.PauseType;
+
+import { Duration, isDuration, toJvmDuration } from "../utils/duration";
+import { SessionTo, underlyingSessionTo, underlyingSessionToDuration } from "../session";
+
+export type PauseType =
+  | "Disabled"
+  | "Constant"
+  | "Exponential"
+  | { type: "NormalWithPercentageDuration"; stdDev: number }
+  | { type: "NormalWithStdDevDuration"; stdDev: Duration }
+  | { type: "Custom"; f: SessionTo<number> }
+  | { type: "UniformPercentage"; plusOrMinus: number }
+  | { type: "UniformDuration"; plusOrMinus: Duration };
+
+const isPauseType = (x: unknown): x is PauseType =>
+  x === "Disabled" || x === "Constant" || x === "Exponential" || typeof (x as any).type === "string";
+
+export const toJvmPauseType = (pauseType: PauseType): JvmPauseType => {
+  if (pauseType === "Disabled") {
+    // FIXME find better solution for generating static field definitions in java2typescript (without conflicting
+    //  with methods of the same name, e.g. 'JvmHttpDsl.http' vs. 'JvmHttpDsl.http(String)')
+    return (JvmCoreDsl as any).disabledPauses;
+  } else if (pauseType === "Constant") {
+    return (JvmCoreDsl as any).constantPauses;
+  } else if (pauseType === "Exponential") {
+    return (JvmCoreDsl as any).exponentialPauses;
+  } else if (pauseType.type === "NormalWithPercentageDuration") {
+    return JvmCoreDsl.normalPausesWithPercentageDuration(pauseType.stdDev);
+  } else if (pauseType.type === "NormalWithStdDevDuration") {
+    return JvmCoreDsl.normalPausesWithStdDevDuration(toJvmDuration(pauseType.stdDev));
+  } else if (pauseType.type === "Custom") {
+    return JvmCoreDsl.customPauses(underlyingSessionTo(pauseType.f));
+  } else if (pauseType.type === "UniformPercentage") {
+    return JvmCoreDsl.uniformPausesPlusOrMinusPercentage(pauseType.plusOrMinus);
+  } else if (pauseType.type === "UniformDuration") {
+    return JvmCoreDsl.uniformPausesPlusOrMinusDuration(toJvmDuration(pauseType.plusOrMinus));
+  }
+  throw Error(`Unhandled pause type ${pauseType}`);
+};
+
+export interface PauseFunction<T extends Pauses<T>> {
+  /**
+   * Attach a pause
+   *
+   * @param duration - the pause duration, in seconds or with an explicit time unit
+   * @returns a new StructureBuilder
+   */
+  (duration: Duration): T;
+
+  /**
+   * Attach a pause as a Gatling Expression Language string. This expression must resolve to either a number, then the
+   * unit will be seconds, or an object with an explicit time unit.
+   *
+   * @param duration - the pause duration as a Gatling Expression Language string
+   * @returns a new StructureBuilder
+   */
+  (duration: string): T;
+
+  /**
+   * Attach a pause
+   *
+   * @param duration - the pause duration as a function
+   * @returns a new StructureBuilder
+   */
+  (duration: SessionTo<Duration>): T;
+
+  /**
+   * Attach a pause
+   *
+   * @param duration - the pause duration, in seconds or with an explicit time unit
+   * @param pauseType - the type of pause
+   * @returns a new StructureBuilder
+   */
+  (duration: Duration, pauseType: PauseType): T;
+
+  /**
+   * Attach a pause as a Gatling Expression Language string. This expression must resolve to either a number, then the
+   * unit will be seconds, or an object with an explicit time unit.
+   *
+   * @param duration - the pause duration as a Gatling Expression Language string
+   * @param pauseType - the type of pause
+   * @returns a new StructureBuilder
+   */
+  (duration: string, pauseType: PauseType): T;
+
+  /**
+   * Attach a pause
+   *
+   * @param duration - the pause duration as a function
+   * @param pauseType - the type of pause
+   * @returns a new StructureBuilder
+   */
+  (duration: SessionTo<Duration>, pauseType: PauseType): T;
+
+  /**
+   * Attach a pause computed randomly between 2 values
+   *
+   * @param min the pause minimum, in seconds or with an explicit time unit
+   * @param max the pause maximum, in seconds or with an explicit time unit
+   * @return a new StructureBuilder
+   */
+  (min: Duration, max: Duration): T;
+  /**
+   * Attach a pause computed randomly between 2 values as a Gatling Expression Language string. These expressions must
+   * resolve to either a number, then the unit will be seconds, or an object with an explicit time unit.
+   *
+   * @param min the pause minimum as a Gatling Expression Language string
+   * @param max the pause maximum as a Gatling Expression Language string
+   * @return a new StructureBuilder
+   */
+  (min: string, max: string): T;
+
+  /**
+   * Attach a pause computed randomly between 2 values
+   *
+   * @param min the pause minimum as a function
+   * @param max the pause maximum as a function
+   * @return a new StructureBuilder
+   */
+  (min: SessionTo<Duration>, max: SessionTo<Duration>): T;
+
+  /**
+   * Attach a pause computed randomly between 2 values
+   *
+   * @param min the pause minimum, in seconds or with an explicit time unit
+   * @param max the pause maximum, in seconds or with an explicit time unit
+   * @param pauseType - the type of pause
+   * @return a new StructureBuilder
+   */
+  (min: Duration, max: Duration, pauseType: PauseType): T;
+
+  /**
+   * Attach a pause computed randomly between 2 values as a Gatling Expression Language string. These expressions must
+   * resolve to either a number, then the unit will be seconds, or an object with an explicit time unit.
+   *
+   * @param min the pause minimum as a Gatling Expression Language string
+   * @param max the pause maximum as a Gatling Expression Language string
+   * @param pauseType - the type of pause
+   * @return a new StructureBuilder
+   */
+  (min: string, max: string, pauseType: PauseType): T;
+
+  /**
+   * Attach a pause computed randomly between 2 values
+   *
+   * @param min the pause minimum as a function
+   * @param max the pause maximum as a function
+   * @param pauseType - the type of pause
+   * @return a new StructureBuilder
+   */
+  (min: SessionTo<Duration>, max: SessionTo<Duration>, pauseType: PauseType): T;
+}
+
+export interface Pauses<T extends Pauses<T>> {
+  pause: PauseFunction<T>;
+}
+
+export const pauseImpl =
+  <J2, J1 extends JvmPauses<J2, any>, T extends Pauses<T>>(jvmGroups: J1, wrap: (wrapped: J2) => T): PauseFunction<T> =>
+  (
+    arg0: Duration | SessionTo<Duration> | string,
+    arg1?: Duration | SessionTo<Duration> | string | PauseType,
+    arg2?: PauseType
+  ) => {
+    if (arg2 !== undefined) {
+      // pause(min, max, pauseType)
+      if (typeof arg0 === "string" && typeof arg1 === "string") {
+        return wrap(jvmGroups.pause(arg0, arg1, toJvmPauseType(arg2)));
+      } else if (typeof arg0 === "function" && typeof arg1 === "function") {
+        return wrap(
+          jvmGroups.pause(underlyingSessionToDuration(arg0), underlyingSessionToDuration(arg1), toJvmPauseType(arg2))
+        );
+      } else if (isDuration(arg0) && isDuration(arg1)) {
+        return wrap(jvmGroups.pause(toJvmDuration(arg0), toJvmDuration(arg1), toJvmPauseType(arg2)));
+      }
+    } else if (arg1 !== undefined) {
+      if (isPauseType(arg1)) {
+        // pause(duration, pauseType)
+        if (typeof arg0 === "string") {
+          return wrap(jvmGroups.pause(arg0, toJvmPauseType(arg1)));
+        } else if (typeof arg0 === "function") {
+          return wrap(jvmGroups.pause(underlyingSessionToDuration(arg0), toJvmPauseType(arg1)));
+        } else if (isDuration(arg0)) {
+          return wrap(jvmGroups.pause(toJvmDuration(arg0), toJvmPauseType(arg1)));
+        }
+      } else {
+        // pause(min, max)
+        if (typeof arg0 === "string" && typeof arg1 === "string") {
+          return wrap(jvmGroups.pause(arg0, arg1));
+        } else if (typeof arg0 === "function" && typeof arg1 === "function") {
+          return wrap(jvmGroups.pause(underlyingSessionToDuration(arg0), underlyingSessionToDuration(arg1)));
+        } else if (isDuration(arg0) && isDuration(arg1)) {
+          return wrap(jvmGroups.pause(toJvmDuration(arg0), toJvmDuration(arg1)));
+        }
+      }
+    } else {
+      // pause(duration)
+      if (typeof arg0 === "string") {
+        return wrap(jvmGroups.pause(arg0));
+      } else if (typeof arg0 === "function") {
+        return wrap(jvmGroups.pause(underlyingSessionToDuration(arg0)));
+      } else if (isDuration(arg0)) {
+        return wrap(jvmGroups.pause(toJvmDuration(arg0)));
+      }
+    }
+
+    throw Error(`pause() called with invalid arguments ${arg0}, ${arg1}, ${arg2}`);
+  };

package/src/structure/randomSwitch.ts

@@ -0,0 +1,34 @@
+import { ChoiceWithWeight } from "./choices";
+
+import JvmRandomSwitch = io.gatling.javaapi.core.condition.RandomSwitch;
+import JvmOn = io.gatling.javaapi.core.condition.RandomSwitch$On;
+
+export interface On<T> {
+  on(...choices: ChoiceWithWeight[]): T;
+}
+
+const wrapOn = <J, T>(jvmOn: JvmOn<J>, wrap: (underlying: J) => T): On<T> => ({
+  on: (...choices: ChoiceWithWeight[]): T => wrap(jvmOn.on(choices.map((c) => c._underlying)))
+});
+
+export interface RandomSwitchFunction<T extends RandomSwitch<T>> {
+  /**
+   * Execute one of the "choices" randomly based on their respective weight. Weights are expressed
+   * in percents so their sum must be <= 100%.
+   *
+   * @returns a DSL component for defining the "choices"
+   */
+  (): On<T>;
+}
+
+export interface RandomSwitch<T extends RandomSwitch<T>> {
+  randomSwitch: RandomSwitchFunction<T>;
+}
+
+export const randomSwitchImpl =
+  <J2, J1 extends JvmRandomSwitch<J2, any>, T extends RandomSwitch<T>>(
+    jvmRandomSwitch: J1,
+    wrap: (wrapped: J2) => T
+  ): RandomSwitchFunction<T> =>
+  () =>
+    wrapOn(jvmRandomSwitch.randomSwitch(), wrap);

package/src/structure/randomSwitchOrElse.ts

@@ -0,0 +1,45 @@
+import { ChoiceWithWeight } from "./choices";
+import { Executable } from "./execs";
+
+import JvmRandomSwitchOrElse = io.gatling.javaapi.core.condition.RandomSwitchOrElse;
+import JvmOn = io.gatling.javaapi.core.condition.RandomSwitchOrElse$On;
+import JvmOrElse = io.gatling.javaapi.core.condition.RandomSwitchOrElse$OrElse;
+
+export interface On<T> {
+  on(...choices: ChoiceWithWeight[]): OrElse<T>;
+}
+
+const wrapOn = <J, T>(jvmOn: JvmOn<J>, wrap: (underlying: J) => T): On<T> => ({
+  on: (...choices: ChoiceWithWeight[]): OrElse<T> => wrapOrElse(jvmOn.on(choices.map((c) => c._underlying)), wrap)
+});
+
+export interface OrElse<T> {
+  orElse(executable: Executable<any>, ...executables: Executable<any>[]): T;
+}
+
+const wrapOrElse = <J, T>(jvmOrElse: JvmOrElse<J>, wrap: (underlying: J) => T): OrElse<T> => ({
+  orElse: (executable: Executable<any>, ...executables: Executable<any>[]): T =>
+    wrap(jvmOrElse.orElse(executable._underlying, ...executables.map((e) => e._underlying)))
+});
+
+export interface RandomSwitchOrElseFunction<T extends RandomSwitchOrElse<T>> {
+  /**
+   * Execute one of the "choices" randomly based on their respective weight. Weights are expressed
+   * in percents so their sum must be <= 100%.
+   *
+   * @returns the DSL component for defining the "else" block
+   */
+  (): On<T>;
+}
+
+export interface RandomSwitchOrElse<T extends RandomSwitchOrElse<T>> {
+  randomSwitchOrElse: RandomSwitchOrElseFunction<T>;
+}
+
+export const randomSwitchOrElseImpl =
+  <J2, J1 extends JvmRandomSwitchOrElse<J2, any>, T extends RandomSwitchOrElse<T>>(
+    jvmRandomSwitch: J1,
+    wrap: (wrapped: J2) => T
+  ): RandomSwitchOrElseFunction<T> =>
+  () =>
+    wrapOn(jvmRandomSwitch.randomSwitchOrElse(), wrap);