@gatling.io/core 3.13.103 → 3.13.104-M10

package/src/structure/rendezVous.ts

@@ -1,23 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "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"]
-}