@gatling.io/core 3.11.7 → 3.12.0

package/src/checks/jsonOfTypeMultipleFind.ts

@@ -0,0 +1,84 @@
+import { CheckBuilderMultipleFind, wrapCheckBuilderMultipleFind } from "./multipleFind";
+
+import JvmCheckBuilderJsonOfTypeMultipleFind = io.gatling.javaapi.core.CheckBuilder$JsonOfTypeMultipleFind;
+import JvmCheckBuilderMultipleFind = io.gatling.javaapi.core.CheckBuilder$MultipleFind;
+
+/**
+ * A special {@link CheckBuilderFind<string>} that works on JSON
+ */
+export interface CheckBuilderJsonOfTypeMultipleFind extends CheckBuilderMultipleFind<string> {
+  /**
+   * Define that the extracted value is a String
+   *
+   * @returns a new MultipleFind
+   */
+  ofString(): CheckBuilderMultipleFind<string>;
+
+  /**
+   * Define that the extracted value is a Boolean
+   *
+   * @returns a new MultipleFind
+   */
+  ofBoolean(): CheckBuilderMultipleFind<boolean>;
+
+  /**
+   * Define that the extracted value is an Integer
+   *
+   * @returns a new MultipleFind
+   */
+  ofInt(): CheckBuilderMultipleFind<number>;
+
+  /**
+   * Define that the extracted value is a Long
+   *
+   * @returns a new MultipleFind
+   */
+  ofLong(): CheckBuilderMultipleFind<number>;
+
+  /**
+   * Define that the extracted value is a Double
+   *
+   * @returns a new MultipleFind
+   */
+  ofDouble(): CheckBuilderMultipleFind<number>;
+
+  /**
+   * Define that the extracted value is a List (a JSON array)
+   *
+   * @returns a new MultipleFind
+   */
+  ofList(): CheckBuilderMultipleFind<unknown[]>;
+
+  /**
+   * Define that the extracted value is a Map (a JSON object)
+   *
+   * @returns a new MultipleFind
+   */
+  ofMap(): CheckBuilderMultipleFind<Record<string, unknown>>;
+
+  /**
+   * Define that the extracted value is an untyped object
+   *
+   * @returns a new MultipleFind
+   */
+  ofObject(): CheckBuilderMultipleFind<unknown>;
+}
+
+export const wrapCheckBuilderJsonOfTypeMultipleFind = (
+  _underlying: JvmCheckBuilderJsonOfTypeMultipleFind
+): CheckBuilderJsonOfTypeMultipleFind => ({
+  ...wrapCheckBuilderMultipleFind<string>(_underlying),
+  ofString: (): CheckBuilderMultipleFind<string> => wrapCheckBuilderMultipleFind(_underlying.ofString()),
+  ofBoolean: (): CheckBuilderMultipleFind<boolean> =>
+    wrapCheckBuilderMultipleFind(_underlying.ofBoolean() as JvmCheckBuilderMultipleFind<boolean>),
+  ofInt: (): CheckBuilderMultipleFind<number> =>
+    wrapCheckBuilderMultipleFind(_underlying.ofInt() as JvmCheckBuilderMultipleFind<number>),
+  ofLong: (): CheckBuilderMultipleFind<number> =>
+    wrapCheckBuilderMultipleFind(_underlying.ofLong() as JvmCheckBuilderMultipleFind<number>),
+  ofDouble: (): CheckBuilderMultipleFind<number> =>
+    wrapCheckBuilderMultipleFind(_underlying.ofDouble() as JvmCheckBuilderMultipleFind<number>),
+  ofList: (): CheckBuilderMultipleFind<unknown[]> => wrapCheckBuilderMultipleFind(_underlying.ofList()),
+  ofMap: (): CheckBuilderMultipleFind<Record<string, unknown>> =>
+    wrapCheckBuilderMultipleFind(_underlying.ofMap() as JvmCheckBuilderMultipleFind<any>),
+  ofObject: (): CheckBuilderMultipleFind<unknown> => wrapCheckBuilderMultipleFind(_underlying.ofObject())
+});

package/src/checks/multipleFind.ts

@@ -0,0 +1,87 @@
+import { CheckBuilderValidate, wrapCheckBuilderValidate } from "./validate";
+
+import JvmCheckBuilderMultipleFind = io.gatling.javaapi.core.CheckBuilder$MultipleFind;
+
+/**
+ * Step 1 of the Check DSL when the check can return multiple values Immutable, so all methods
+ * return a new occurrence and leave the original unmodified.
+ *
+ * @typeParam X - the type of Java values the check can extract
+ */
+export interface CheckBuilderMultipleFind<X> extends CheckBuilderValidate<X> {
+  /**
+   * Target a single/first value
+   *
+   * @returns the next Check DSL step
+   */
+  find(): CheckBuilderValidate<X>;
+
+  /**
+   * Target the occurrence-th occurrence in the extracted values
+   *
+   * @param occurrence - the rank of the target value in the extracted values list
+   * @returns the next Check DSL step
+   */
+  find(occurrence: number): CheckBuilderValidate<X>;
+
+  /**
+   * Target all the occurrences of the extracted values
+   *
+   * @returns the next Check DSL step
+   */
+  findAll(): CheckBuilderValidate<X[]>;
+
+  /**
+   * Target a random occurrence in the extracted values
+   *
+   * @returns the next Check DSL step
+   */
+  findRandom(): CheckBuilderValidate<X>;
+
+  /**
+   * Target multiple random occurrences in the extracted values
+   *
+   * @param num - the number of occurrences to collect
+   * @returns the next Check DSL step
+   */
+  findRandom(num: number): CheckBuilderValidate<X[]>;
+
+  /**
+   * Target multiple random occurrences in the extracted values
+   *
+   * @param num - the number of occurrences to collect
+   * @param failIfLess - fail if num is greater than the number of extracted values
+   * @returns the next Check DSL step
+   */
+  findRandom(num: number, failIfLess: boolean): CheckBuilderValidate<X[]>;
+
+  /**
+   * Target the count of extracted values
+   *
+   * @returns the next Check DSL step
+   */
+  count(): CheckBuilderValidate<number>;
+}
+
+export const wrapCheckBuilderMultipleFind = <X>(
+  _underlying: JvmCheckBuilderMultipleFind<X>
+): CheckBuilderMultipleFind<X> => ({
+  ...wrapCheckBuilderValidate<X>(_underlying),
+  find: (occurrence?: number) =>
+    wrapCheckBuilderValidate(occurrence !== undefined ? _underlying.find(occurrence) : _underlying.find()),
+  findAll: () => wrapCheckBuilderValidate(_underlying.findAll()),
+  findRandom: (num?: number, failIfLess?: boolean): any => {
+    if (num !== undefined) {
+      if (failIfLess !== undefined) {
+        return wrapCheckBuilderValidate(_underlying.findRandom(num, failIfLess));
+      } else {
+        return wrapCheckBuilderValidate(_underlying.findRandom(num));
+      }
+    } else {
+      return wrapCheckBuilderValidate(_underlying.findRandom());
+    }
+  },
+  count: function (): CheckBuilderValidate<number> {
+    throw new Error("Function not implemented.");
+  }
+});

package/src/checks/validate.ts

@@ -0,0 +1,336 @@
+import { Session, SessionTo, underlyingSessionTo, underlyingXWithSessionTo } from "../session";
+import { CheckBuilderFinal, wrapCheckBuilderFinal } from "./final";
+
+import JvmCheckBuilderValidate = io.gatling.javaapi.core.CheckBuilder$Validate;
+
+/**
+ * Step 2 of the Check DSL where we define how to validate the extracted value. Immutable, so all
+ * methods return a new occurrence and leave the original unmodified.
+ *
+ * @typeParam X - the type of the extracted value
+ */
+export interface CheckBuilderValidate<X> extends CheckBuilderFinal {
+  /**
+   * Transform the extracted value
+   *
+   * @param f - the transformation function
+   * @typeParam X2 - the transformed value
+   * @returns a new CheckBuilderValidate
+   */
+  transform<X2>(f: (x: X) => X2): CheckBuilderValidate<X2>;
+
+  /**
+   * Transform the extracted value, whith access to the current Session
+   *
+   * @param f - the transformation function
+   * @typeParam X2 - the transformed value
+   * @returns a new CheckBuilderValidate
+   */
+  transformWithSession<X2>(f: (x: X, session: Session) => X2): CheckBuilderValidate<X2>;
+
+  /**
+   * Provide a default value if the check wasn't able to extract anything
+   *
+   * @param value - the default value
+   * @returns a new Validate
+   */
+  withDefault(value: X): CheckBuilderValidate<X>;
+
+  /**
+   * Provide a default Gatling Expression Language value if the check wasn't able to extract
+   * anything
+   *
+   * @param value - the default value as a Gatling Expression Language String
+   * @returns a new Validate
+   */
+  withDefaultEL(value: string): CheckBuilderValidate<X>;
+
+  /**
+   * Provide a default value if the check wasn't able to extract anything
+   *
+   * @param value - the default value as a function
+   * @returns a new Validate
+   */
+  withDefault(value: SessionTo<X>): CheckBuilderValidate<X>;
+
+  /**
+   * Provide a custom validation strategy
+   *
+   * @param name - the name of the validation, in case of a failure
+   * @param f - the custom validation function, must throw to trigger a failure
+   * @returns a new CheckBuilderFinal
+   */
+  validate(name: string, f: (x: X, session: Session) => X): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is equal to an expected value
+   *
+   * @param expected - the expected value
+   * @returns a new CheckBuilderFinal
+   */
+  is(expected: X): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is equal to an expected value, passed as a Gatling Expression
+   * Language String
+   *
+   * @param expected - the expected value as a Gatling Expression Language String
+   * @returns a new CheckBuilderFinal
+   */
+  isEL(expected: string): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is equal to an expected value, passed as a function
+   *
+   * @param expected - the expected value as a function
+   * @returns a new CheckBuilderFinal
+   */
+  is(expected: SessionTo<X>): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is null
+   *
+   * @returns a new CheckBuilderFinal
+   */
+  isNull(): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is not an expected value
+   *
+   * @param expected - the unexpected value
+   * @returns a new CheckBuilderFinal
+   */
+  not(expected: X): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is not an expected value, passed as a Gatling Expression
+   * Language String
+   *
+   * @param expected - the unexpected value as a Gatling Expression Language String
+   * @returns a new CheckBuilderFinal
+   */
+  notEL(expected: string): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is not an expected value, passed as a function
+   *
+   * @param expected - the unexpected value as a function
+   * @returns a new CheckBuilderFinal
+   */
+  not(expected: SessionTo<X>): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is not null
+   *
+   * @returns a new CheckBuilderFinal
+   */
+  notNull(): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value belongs to an expected set
+   *
+   * @param expected - the set of possible values
+   * @returns a new Final
+   */
+  in(...expected: X[]): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value belongs to an expected set, passed as a Gatling Expression
+   * Language String
+   *
+   * @param expected - the set of possible values, as a Gatling Expression Language String
+   * @returns a new CheckBuilderFinal
+   */
+  inEL(expected: string): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value belongs to an expected set, passed as a function
+   *
+   * @param expected - the set of possible values, as a function
+   * @returns a new CheckBuilderFinal
+   */
+  in(expected: SessionTo<X[]>): CheckBuilderFinal;
+
+  /**
+   * Validate the check was able to extract any value
+   *
+   * @returns a new CheckBuilderFinal
+   */
+  exists(): CheckBuilderFinal;
+
+  /**
+   * Validate the check was not able to extract any value
+   *
+   * @returns a new CheckBuilderFinal
+   */
+  notExists(): CheckBuilderFinal;
+
+  /**
+   * Make the check is successful whenever it was able to extract something or not
+   *
+   * @returns a new CheckBuilderFinal
+   */
+  optional(): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is less than a given value
+   *
+   * @param value - the value
+   * @returns a new CheckBuilderFinal
+   */
+  lt(value: X): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is less than a given value, passed as a Gatling Expression
+   * Language String
+   *
+   * @param value - the value, as a Gatling Expression Language String
+   * @returns a new CheckBuilderFinal
+   */
+  ltEL(value: string): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is less than a given value, passed as a function
+   *
+   * @param value - the value, as a function
+   * @returns a new CheckBuilderFinal
+   */
+  lt(value: SessionTo<X>): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is less than or equal to a given value
+   *
+   * @param value - the value
+   * @returns a new CheckBuilderFinal
+   */
+  lte(value: X): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is less than or equal to a given value, passed as a Gatling
+   * Expression Language String
+   *
+   * @param value - the value, as a Gatling Expression Language String
+   * @returns a new CheckBuilderFinal
+   */
+  lteEL(value: string): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is less than or equal to a given value, passed as a function
+   *
+   * @param value - the value, as a function
+   * @returns a new CheckBuilderFinal
+   */
+  lte(value: SessionTo<X>): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is greater than a given value
+   *
+   * @param value - the value
+   * @returns a new CheckBuilderFinal
+   */
+  gt(value: X): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is greater than a given value, passed as a Gatling Expression
+   * Language String
+   *
+   * @param value - the value, as a Gatling Expression Language String
+   * @returns a new CheckBuilderFinal
+   */
+  gtEL(value: string): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is greater than a given value, passed as a function
+   *
+   * @param value - the value, as a function
+   * @returns a new CheckBuilderFinal
+   */
+  gt(value: SessionTo<X>): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is greater than or equal to a given value
+   *
+   * @param value - the value
+   * @returns a new CheckBuilderFinal
+   */
+  gte(value: X): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is greater than or equal to a given value, passed as a Gatling
+   * Expression Language String
+   *
+   * @param value - the value, as a Gatling Expression Language String
+   * @returns a new CheckBuilderFinal
+   */
+  gteEL(value: string): CheckBuilderFinal;
+
+  /**
+   * Validate the extracted value is greater than or equal to a given value, passed as a function
+   *
+   * @param value - the value, as a function
+   * @returns a new CheckBuilderFinal
+   */
+  gte(value: SessionTo<X>): CheckBuilderFinal;
+}
+
+export const wrapCheckBuilderValidate = <X>(_underlying: JvmCheckBuilderValidate<X>): CheckBuilderValidate<X> => ({
+  ...wrapCheckBuilderFinal(_underlying),
+  transform: <X2>(f: (x: X) => X2) => wrapCheckBuilderValidate(_underlying.transform(f)),
+  transformWithSession: <X2>(f: (x: X, session: Session) => X2) =>
+    wrapCheckBuilderValidate(_underlying.transformWithSession(underlyingXWithSessionTo(f))),
+  withDefault: (value: X | SessionTo<X>) =>
+    wrapCheckBuilderValidate(
+      typeof value === "function"
+        ? _underlying.withDefault(underlyingSessionTo(value as SessionTo<X>))
+        : _underlying.withDefault(value)
+    ),
+  withDefaultEL: (value: string) => wrapCheckBuilderValidate(_underlying.withDefaultEl(value)),
+  validate: (name: string, f: (x: X, session: Session) => X) =>
+    wrapCheckBuilderFinal(_underlying.validate(name, underlyingXWithSessionTo(f))),
+  is: (expected: X | SessionTo<X>) =>
+    wrapCheckBuilderFinal(
+      typeof expected === "function"
+        ? _underlying.is(underlyingSessionTo(expected as SessionTo<X>))
+        : _underlying.is(expected)
+    ),
+  isEL: (expected: string) => wrapCheckBuilderFinal(_underlying.isEL(expected)),
+  isNull: (): CheckBuilderFinal => wrapCheckBuilderFinal(_underlying.isNull()),
+  not: (expected: X | SessionTo<X>) =>
+    wrapCheckBuilderFinal(
+      typeof expected === "function"
+        ? _underlying.not(underlyingSessionTo(expected as SessionTo<X>))
+        : _underlying.not(expected)
+    ),
+  notEL: (expected: string) => wrapCheckBuilderFinal(_underlying.notEL(expected)),
+  notNull: (): CheckBuilderFinal => wrapCheckBuilderFinal(_underlying.notNull()),
+  in: (expected: X | SessionTo<X[]>, ...rest: X[]) =>
+    wrapCheckBuilderFinal(
+      typeof expected === "function"
+        ? _underlying.in(underlyingSessionTo(expected as SessionTo<X[]>))
+        : _underlying.in([expected, ...rest])
+    ),
+  inEL: (expected: string) => wrapCheckBuilderFinal(_underlying.inEL(expected)),
+  exists: () => wrapCheckBuilderFinal(_underlying.exists()),
+  notExists: () => wrapCheckBuilderFinal(_underlying.notExists()),
+  optional: () => wrapCheckBuilderFinal(_underlying.optional()),
+  lt: (value: X | SessionTo<X>) =>
+    wrapCheckBuilderFinal(
+      typeof value === "function" ? _underlying.lt(underlyingSessionTo(value as SessionTo<X>)) : _underlying.lt(value)
+    ),
+  ltEL: (value: string) => wrapCheckBuilderFinal(_underlying.ltEL(value)),
+  lte: (value: X | SessionTo<X>) =>
+    wrapCheckBuilderFinal(
+      typeof value === "function" ? _underlying.lte(underlyingSessionTo(value as SessionTo<X>)) : _underlying.lte(value)
+    ),
+  lteEL: (value: string) => wrapCheckBuilderFinal(_underlying.lteEL(value)),
+  gt: (value: X | SessionTo<X>) =>
+    wrapCheckBuilderFinal(
+      typeof value === "function" ? _underlying.gt(underlyingSessionTo(value as SessionTo<X>)) : _underlying.gt(value)
+    ),
+  gtEL: (value: string) => wrapCheckBuilderFinal(_underlying.gtEL(value)),
+  gte: (value: X | SessionTo<X>) =>
+    wrapCheckBuilderFinal(
+      typeof value === "function" ? _underlying.gte(underlyingSessionTo(value as SessionTo<X>)) : _underlying.gte(value)
+    ),
+  gteEL: (value: string) => wrapCheckBuilderFinal(_underlying.gteEL(value))
+});

package/src/closedInjection.ts

@@ -0,0 +1,182 @@
+import { CoreDsl as JvmCoreDsl } from "@gatling.io/jvm-types";
+
+import { Wrapper } from "./common";
+import { Duration, toJvmDuration } from "./utils/duration";
+
+import JvmClosedInjectionStep = io.gatling.javaapi.core.ClosedInjectionStep;
+import JvmClosedInjectionStepConstant = io.gatling.javaapi.core.ClosedInjectionStep$Constant;
+import JvmClosedInjectionStepRamp = io.gatling.javaapi.core.ClosedInjectionStep$Ramp;
+import JvmClosedInjectionStepRampTo = io.gatling.javaapi.core.ClosedInjectionStep$RampTo;
+import JvmClosedInjectionStepStairs = io.gatling.javaapi.core.ClosedInjectionStep$Stairs;
+import JvmClosedInjectionStepStairsWithTime = io.gatling.javaapi.core.ClosedInjectionStep$StairsWithTime;
+import JvmClosedInjectionStepComposite = io.gatling.javaapi.core.ClosedInjectionStep$Composite;
+
+/**
+ * An injection profile step for using a closed workload model where you control the concurrent
+ * number of users. Only use if your system has a queue limiting entry. Don't use otherwise or your
+ * test will not match any production use case.
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
+export interface ClosedInjectionStep extends Wrapper<JvmClosedInjectionStep> {}
+
+const wrapClosedInjectionStep = (_underlying: JvmClosedInjectionStep): ClosedInjectionStep => ({ _underlying });
+
+/**
+ * DSL component for building a {@link ClosedInjectionStep} that will inject new users in a way to
+ * maintain a constant number of concurrent users for a given duration.
+ */
+export interface ClosedInjectionStepConstant extends Wrapper<JvmClosedInjectionStepConstant> {
+  /**
+   * Define the duration of the step
+   *
+   * @param duration - the duration
+   * @returns a new ClosedInjectionStep
+   */
+  during(duration: Duration): ClosedInjectionStep;
+}
+
+const wrapClosedInjectionStepConstant = (_underlying: JvmClosedInjectionStepConstant): ClosedInjectionStepConstant => ({
+  _underlying,
+  during: (duration: Duration) => wrapClosedInjectionStep(_underlying.during(toJvmDuration(duration)))
+});
+
+/**
+ * DSL step for building a {@link ClosedInjectionStep} that will inject new users in a way to ramp
+ * the number of concurrent users for a given duration.
+ */
+export interface ClosedInjectionStepRamp extends Wrapper<JvmClosedInjectionStepRamp> {
+  /**
+   * Define the target number of concurrent users at the end of the ramp.
+   *
+   * @param t - the target number
+   * @returns a RampConcurrentUsersInjectionTo
+   */
+  to(t: number): ClosedInjectionStepRampTo;
+}
+
+const wrapClosedInjectionStepRamp = (_underlying: JvmClosedInjectionStepRamp): ClosedInjectionStepRamp => ({
+  _underlying,
+  to: (t: number) => wrapClosedInjectionStepRampTo(_underlying.to(t))
+});
+
+/**
+ * DSL step for building a {@link ClosedInjectionStep} that will inject new users in a way to ramp
+ * the number of concurrent users for a given duration.
+ */
+export interface ClosedInjectionStepRampTo extends Wrapper<JvmClosedInjectionStepRampTo> {
+  /**
+   * Define the duration of the ramp.
+   *
+   * @param duration - the duration
+   * @returns a complete ClosedInjectionStep
+   */
+  during(duration: Duration): ClosedInjectionStep;
+}
+
+const wrapClosedInjectionStepRampTo = (_underlying: JvmClosedInjectionStepRampTo): ClosedInjectionStepRampTo => ({
+  _underlying,
+  during: (duration: Duration) => wrapClosedInjectionStep(_underlying.during(toJvmDuration(duration)))
+});
+
+/**
+ * DSL step for building a {@link ClosedInjectionStep} that will inject new users in a way to ramp
+ * the number of concurrent users in a stairs fashion
+ */
+export interface ClosedInjectionStepStairs extends Wrapper<JvmClosedInjectionStepStairs> {
+  /**
+   * Define the number of levels
+   *
+   * @param levels - the number of levels in the stairs
+   * @returns the next DSL step
+   */
+  times(levels: number): ClosedInjectionStepStairsWithTime;
+}
+
+const wrapClosedInjectionStepStairs = (_underlying: JvmClosedInjectionStepStairs): ClosedInjectionStepStairs => ({
+  _underlying,
+  times: (levels: number) => wrapClosedInjectionStepStairsWithTime(_underlying.times(levels))
+});
+
+/**
+ * DSL step for building a {@link ClosedInjectionStep} that will inject new users in a way to ramp
+ * the number of concurrent users in a stairs fashion
+ */
+export interface ClosedInjectionStepStairsWithTime extends Wrapper<JvmClosedInjectionStepStairsWithTime> {
+  /**
+   * Define the duration of each level
+   *
+   * @param duration - the duration
+   * @returns the next DSL step
+   */
+  eachLevelLasting(duration: Duration): ClosedInjectionStepComposite;
+}
+
+const wrapClosedInjectionStepStairsWithTime = (
+  _underlying: JvmClosedInjectionStepStairsWithTime
+): ClosedInjectionStepStairsWithTime => ({
+  _underlying,
+  eachLevelLasting: (duration: Duration) =>
+    wrapClosedInjectionStepComposite(_underlying.eachLevelLasting(toJvmDuration(duration)))
+});
+
+/**
+ * DSL step for building a {@link ClosedInjectionStep} that will inject new users in a way to ramp
+ * the number of concurrent users in a stairs fashion
+ */
+export interface ClosedInjectionStepComposite extends ClosedInjectionStep {
+  /**
+   * Define the initial number of concurrent users (optional)
+   *
+   * @param startingUsers - the initial number of concurrent users
+   * @returns a usable {@link ClosedInjectionStep}
+   */
+  startingFrom(startingUsers: number): ClosedInjectionStepComposite;
+
+  /**
+   * Define ramps separating levels (optional)
+   *
+   * @param duration - the duration of the ramps
+   * @returns a usable {@link ClosedInjectionStep}
+   */
+  separatedByRampsLasting(duration: Duration): ClosedInjectionStepComposite;
+}
+
+const wrapClosedInjectionStepComposite = (
+  _underlying: JvmClosedInjectionStepComposite
+): ClosedInjectionStepComposite => ({
+  _underlying,
+  startingFrom: (startingUsers: number) => wrapClosedInjectionStepComposite(_underlying.startingFrom(startingUsers)),
+  separatedByRampsLasting: (duration: Duration) =>
+    wrapClosedInjectionStepComposite(_underlying.separatedByRampsLasting(toJvmDuration(duration)))
+});
+
+/**
+ * Bootstrap a new closed workload constantConcurrentUsers injection profile, see {@link
+ * ClosedInjectionStepConstant}
+ *
+ * @param users - the number of concurrent users
+ * @returns the next DSL step
+ */
+export const constantConcurrentUsers = (users: number): ClosedInjectionStepConstant =>
+  wrapClosedInjectionStepConstant(JvmCoreDsl.constantConcurrentUsers(users));
+
+/**
+ * Bootstrap a new closed workload rampConcurrentUsers injection profile, see {@link
+ * ClosedInjectionStepRamp}
+ *
+ * @param from - the number of concurrent users at the start of the ramp
+ * @returns the next DSL step
+ */
+export const rampConcurrentUsers = (from: number): ClosedInjectionStepRamp =>
+  wrapClosedInjectionStepRamp(JvmCoreDsl.rampConcurrentUsers(from));
+
+/**
+ * Bootstrap a new closed workload incrementConcurrentUsers injection profile, see {@link
+ * ClosedInjectionStepStairs}
+ *
+ * @param usersIncrement - the difference of concurrent users between levels of the stairs
+ * @returns the next DSL step
+ */
+export const incrementConcurrentUsers = (usersIncrement: number): ClosedInjectionStepStairs =>
+  wrapClosedInjectionStepStairs(JvmCoreDsl.incrementConcurrentUsers(usersIncrement));

package/src/common.ts

@@ -0,0 +1,3 @@
+export interface Wrapper<T> {
+  _underlying: T;
+}