@gatling.io/core 3.11.7 → 3.12.0

package/src/feeders.ts

@@ -0,0 +1,279 @@
+import { CoreDsl as JvmCoreDsl } from "@gatling.io/jvm-types";
+import JvmFeederBuilder = io.gatling.javaapi.core.FeederBuilder;
+import JvmFeederBuilderFileBased = io.gatling.javaapi.core.FeederBuilder$FileBased;
+import JvmFeederBuilderBatchable = io.gatling.javaapi.core.FeederBuilder$Batchable;
+
+import { Wrapper } from "./common";
+
+export interface FeederBuilder<T> extends Wrapper<JvmFeederBuilder<T>> {
+  /**
+   * Set a queue strategy. Records will be provided in the same order as defined in the underlying
+   * source. A given record will only be provided once. The run will be immediately stopped if the
+   * feeder runs out of records.
+   *
+   * @returns a new FeederBuilder
+   */
+  queue(): FeederBuilder<T>;
+
+  /**
+   * Set a random strategy. Records will be provided in a random order, unrelated to the order in
+   * the underlying source. A given record can be provided multiple times. Such feeder will never
+   * run out of records.
+   *
+   * @returns a new FeederBuilder
+   */
+  random(): FeederBuilder<T>;
+
+  /**
+   * Set a shuffle strategy. Records will be provided in a random order, unrelated to the order in
+   * the underlying source. A given record will only be provided once. The run will be immediately
+   * stopped if the feeder runs out of records.
+   *
+   * @returns a new FeederBuilder
+   */
+  shuffle(): FeederBuilder<T>;
+
+  /**
+   * Set a circular strategy. Records will be provided in the same order as defined in the
+   * underlying source. Once the last record of the underlying source is reached, the feeder will go
+   * back to the first record. A given record can be provided multiple times. Such feeder will never
+   * run out of records.
+   *
+   * @returns a new FeederBuilder
+   */
+  circular(): FeederBuilder<T>;
+
+  /**
+   * Provide a function to transform records as defined in the underlying source
+   *
+   * @param f - the transformation function
+   * @returns a new FeederBuilder
+   */
+  transform(f: (name: string, value: T) => unknown): FeederBuilder<unknown>;
+
+  // TODO
+  // /**
+  //  * Read all the records of the underlying source.
+  //  *
+  //  * @return the whole data
+  //  */
+  // @NonNull
+  // List<Map<String, Object>> readRecords();
+
+  /**
+   * Return the number of records more efficiantly than readRecords().size().
+   *
+   * @returns the number of recordss
+   */
+  recordsCount(): number;
+
+  /**
+   * Distribute data evenly amongst all the injectors of a Gatling Enterprise cluster. Only
+   * effective when the test is running with Gatling Enterprise, noop otherwise.
+   *
+   * @returns a new FeederBuilder
+   */
+  shard(): FeederBuilder<T>;
+}
+
+const wrapFeederBuilder = <T>(_underlying: JvmFeederBuilder<T>): FeederBuilder<T> => ({
+  _underlying,
+  queue: () => wrapFeederBuilder(_underlying.queue()),
+  random: () => wrapFeederBuilder(_underlying.random()),
+  shuffle: () => wrapFeederBuilder(_underlying.shuffle()),
+  circular: () => wrapFeederBuilder(_underlying.circular()),
+  transform: (f: (name: string, value: T) => unknown) => wrapFeederBuilder(_underlying.transform(f)),
+  recordsCount: () => _underlying.recordsCount(),
+  shard: () => wrapFeederBuilder(_underlying.shard())
+});
+
+export interface FileBasedFeederBuilder<T> extends FeederBuilder<T> {
+  /**
+   * Advice to unzip the underlying source because it's a zip or tar file
+   *
+   * @returns a new FileBased
+   */
+  unzip(): FileBasedFeederBuilder<T>;
+}
+
+export const wrapFileBasedFeederBuilder = <T>(
+  _underlying: JvmFeederBuilderFileBased<T>
+): FileBasedFeederBuilder<T> => ({
+  _underlying,
+  queue: () => wrapFileBasedFeederBuilder(_underlying.queue()),
+  random: () => wrapFileBasedFeederBuilder(_underlying.random()),
+  shuffle: () => wrapFileBasedFeederBuilder(_underlying.shuffle()),
+  circular: () => wrapFileBasedFeederBuilder(_underlying.circular()),
+  transform: (f: (name: string, value: T) => unknown) => wrapFeederBuilder(_underlying.transform(f)),
+  recordsCount: () => _underlying.recordsCount(),
+  shard: () => wrapFileBasedFeederBuilder(_underlying.shard()),
+  unzip: () => wrapFileBasedFeederBuilder(_underlying.unzip())
+});
+
+export interface BatchableFeederBuilder<T> extends FileBasedFeederBuilder<T> {
+  /**
+   * Force loading the whole data in memory from the underlying source at once. Faster runtime but
+   * slower boot time and higher heap usage.
+   *
+   * @returns a new Batchable
+   */
+  eager(): BatchableFeederBuilder<T>;
+
+  /**
+   * Force loading small chunks of data from the underlying source one by one. Slower runtime but
+   * faster boot time and lower memory consumption.
+   *
+   * @returns a new Batchable
+   */
+  batch(): BatchableFeederBuilder<T>;
+
+  /**
+   * Force loading small chunks of data from the underlying source one by one Slower runtime but
+   * faster boot time and lower memory consumption.
+   *
+   * @param lines - the number of buffered lines
+   * @returns a new Batchable
+   */
+  batch(lines: number): BatchableFeederBuilder<T>;
+}
+
+const wrapBatchableFeederBuilder = <T>(_underlying: JvmFeederBuilderBatchable<T>): BatchableFeederBuilder<T> => ({
+  _underlying,
+  queue: () => wrapBatchableFeederBuilder(_underlying.queue()),
+  random: () => wrapBatchableFeederBuilder(_underlying.random()),
+  shuffle: () => wrapBatchableFeederBuilder(_underlying.shuffle()),
+  circular: () => wrapBatchableFeederBuilder(_underlying.circular()),
+  transform: (f: (name: string, value: T) => unknown) => wrapFeederBuilder(_underlying.transform(f)),
+  recordsCount: () => _underlying.recordsCount(),
+  shard: () => wrapBatchableFeederBuilder(_underlying.shard()),
+  unzip: () => wrapBatchableFeederBuilder(_underlying.unzip()),
+  eager: () => wrapBatchableFeederBuilder(_underlying.eager()),
+  batch: (lines?: number) =>
+    wrapBatchableFeederBuilder(lines !== undefined ? _underlying.batch(lines) : _underlying.batch())
+});
+
+export interface CsvFunction {
+  /**
+   * Bootstrap a new {@link https://datatracker.ietf.org/doc/html/rfc4180 | CSV file} based feeder
+   *
+   * @param filePath - the path of the file, relative to the root of the resources folder
+   * @returns a new feeder
+   */
+  (filePath: string): BatchableFeederBuilder<string>;
+
+  /**
+   * Bootstrap a new {@link https://datatracker.ietf.org/doc/html/rfc4180 | CSV file} based feeder
+   *
+   * @param filePath - the path of the file, relative to the root of the resources folder
+   * @param quoteChar - the quote char to wrap values containing special characters
+   * @returns a new feeder
+   */
+  (filePath: string, quoteChar: string): BatchableFeederBuilder<string>;
+}
+
+export const csv: CsvFunction = (filePath: string, quoteChar?: string): BatchableFeederBuilder<string> =>
+  wrapBatchableFeederBuilder(quoteChar !== undefined ? JvmCoreDsl.csv(filePath, quoteChar) : JvmCoreDsl.csv(filePath));
+
+export interface SsvFunction {
+  /**
+   * Bootstrap a new {@link https://datatracker.ietf.org/doc/html/rfc4180 | CSV file} based feeder, where the separator
+   * is a semi-colon
+   *
+   * @param filePath - the path of the file, relative to the root of the resources folder
+   * @returns a new feeder
+   */
+  (filePath: string): BatchableFeederBuilder<string>;
+
+  /**
+   * Bootstrap a new {@link https://datatracker.ietf.org/doc/html/rfc4180 | CSV file} based feeder, where the separator
+   * is a semi-colon
+   *
+   * @param filePath - the path of the file, relative to the root of the resources folder
+   * @param quoteChar - the quote char to wrap values containing special characters (must be a single character)
+   * @returns a new feeder
+   */
+  (filePath: string, quoteChar: string): BatchableFeederBuilder<string>;
+}
+
+export const ssv: SsvFunction = (filePath: string, quoteChar?: string) =>
+  wrapBatchableFeederBuilder(quoteChar !== undefined ? JvmCoreDsl.ssv(filePath, quoteChar) : JvmCoreDsl.ssv(filePath));
+
+export interface TsvFunction {
+  /**
+   * Bootstrap a new {@link https://datatracker.ietf.org/doc/html/rfc4180 | CSV file} based feeder, where the separator
+   * is a tab
+   *
+   * @param filePath - the path of the file, relative to the root of the resources folder
+   * @returns a new feeder
+   */
+  (filePath: string): BatchableFeederBuilder<string>;
+
+  /**
+   * Bootstrap a new {@link https://datatracker.ietf.org/doc/html/rfc4180 | CSV file} based feeder, where the separator
+   * is a tab
+   *
+   * @param filePath - the path of the file, relative to the root of the resources folder
+   * @param quoteChar - the quote char to wrap values containing special characters (must be a single character)
+   * @returns a new feeder
+   */
+  (filePath: string, quoteChar: string): BatchableFeederBuilder<string>;
+}
+
+export const tsv: TsvFunction = (filePath: string, quoteChar?: string) =>
+  wrapBatchableFeederBuilder(quoteChar !== undefined ? JvmCoreDsl.tsv(filePath, quoteChar) : JvmCoreDsl.tsv(filePath));
+
+export interface SeparatedValuesFunction {
+  /**
+   * Bootstrap a new {@link https://datatracker.ietf.org/doc/html/rfc4180 | CSV file} based feeder, where the separator
+   * is a tab
+   *
+   * @param filePath - the path of the file, relative to the root of the resources folder
+   * @param separator - the provided separator char (must be a single character)
+   * @returns a new feeder
+   */
+  (filePath: string, separator: string): BatchableFeederBuilder<string>;
+
+  /**
+   * Bootstrap a new {@link https://datatracker.ietf.org/doc/html/rfc4180 | CSV file} based feeder, where the separator
+   * is a tab
+   *
+   * @param filePath - the path of the file, relative to the root of the resources folder
+   * @param separator - the provided separator char (must be a single character)
+   * @param quoteChar - the quote char to wrap values containing special characters (must be a single character)
+   * @returns a new feeder
+   */
+  (filePath: string, separator: string, quoteChar: string): BatchableFeederBuilder<string>;
+}
+
+export const separatedValues: SeparatedValuesFunction = (filePath: string, separator: string, quoteChar?: string) =>
+  wrapBatchableFeederBuilder(
+    quoteChar !== undefined
+      ? JvmCoreDsl.separatedValues(filePath, separator, quoteChar)
+      : JvmCoreDsl.separatedValues(filePath, separator)
+  );
+
+/**
+ * Bootstrap a new JSON file based feeder
+ *
+ * @param filePath - the path of the file, relative to the root of the resources folder
+ * @returns a new feeder
+ */
+export const jsonFile = (filePath: string): FileBasedFeederBuilder<any> =>
+  wrapFileBasedFeederBuilder(JvmCoreDsl.jsonFile(filePath));
+
+/**
+ * Bootstrap a new JSON API based feeder
+ *
+ * @param url - the url of the API
+ * @returns a new feeder
+ */
+export const jsonUrl = (url: string): FeederBuilder<any> => wrapFeederBuilder(JvmCoreDsl.jsonUrl(url));
+
+/**
+ * Bootstrap a new in-memory array of Maps based feeder
+ *
+ * @param data - the in-memory data
+ * @returns a new feeder
+ */
+export const arrayFeeder = (data: Array<Record<string, unknown>>): FeederBuilder<unknown> =>
+  wrapFeederBuilder(JvmCoreDsl.arrayFeeder(data));

package/src/filters.ts

@@ -0,0 +1,49 @@
+import { CoreDsl as JvmCoreDsl } from "@gatling.io/jvm-types";
+import JvmFilter = io.gatling.javaapi.core.Filter;
+import JvmFilterAllowList = io.gatling.javaapi.core.Filter$AllowList;
+import JvmFilterDenyList = io.gatling.javaapi.core.Filter$DenyList;
+
+import { Wrapper } from "./common";
+
+export interface Filter<T extends JvmFilter<unknown>> extends Wrapper<T> {
+  type: "allow" | "deny";
+}
+
+export interface AllowListFilter extends Filter<JvmFilterAllowList> {
+  type: "allow";
+}
+
+export interface DenyListFilter extends Filter<JvmFilterDenyList> {
+  type: "deny";
+}
+
+const wrapAllowListFilter = (_underlying: JvmFilterAllowList): AllowListFilter => ({
+  _underlying,
+  type: "allow"
+});
+
+const wrapDenyListFilter = (_underlying: JvmFilterDenyList): DenyListFilter => ({
+  _underlying,
+  type: "deny"
+});
+
+/**
+ * Create a new AllowList based on some <a
+ * href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html">Java regular
+ * expression patterns</a>. Typically used to filter HTTP resources.
+ *
+ * @param patterns some Java regex patterns
+ * @return a new AllowList
+ */
+export const AllowList = (...patterns: string[]): AllowListFilter =>
+  wrapAllowListFilter(JvmCoreDsl.AllowList(patterns));
+
+/**
+ * Create a new DenyList based on some <a
+ * href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html">Java regular
+ * expression patterns</a> Typically used to filter HTTP resources.
+ *
+ * @param patterns some Java regex patterns
+ * @return a new DenyList
+ */
+export const DenyList = (...patterns: string[]): DenyListFilter => wrapDenyListFilter(JvmCoreDsl.DenyList(patterns));

package/src/gatlingJvm/app.ts

@@ -0,0 +1,5 @@
+import JvmPopulationBuilder = io.gatling.javaapi.core.PopulationBuilder;
+import JvmSetUp = io.gatling.javaapi.core.Simulation$SetUp;
+
+export type SetUpFunction = (populationBuilders: JvmPopulationBuilder[]) => JvmSetUp;
+export type Simulation = (setUp: SetUpFunction) => void;

package/src/gatlingJvm/byteArrays.ts

@@ -0,0 +1,14 @@
+import JvmSession = io.gatling.javaapi.core.Session;
+
+type JvmExpression<T> = (arg: JvmSession) => T;
+
+interface ByteArrays {
+  asByteArray(v: number[]): number[];
+  asByteArrayFunction(f: JvmExpression<number[]>): JvmExpression<number[]>;
+}
+
+const ByteArrays = Java.type<ByteArrays>("io.gatling.js.callbacks.ByteArrays");
+
+export const asByteArray = (v: number[]) => ByteArrays.asByteArray(v);
+
+export const asByteArrayFunction = (f: JvmExpression<number[]>) => ByteArrays.asByteArrayFunction(f);

package/src/gatlingJvm/collections.ts

@@ -0,0 +1,28 @@
+const ArrayList = Java.type<any>("java.util.ArrayList");
+const HashMap = Java.type<any>("java.util.HashMap");
+
+const asJavaList = (elements: unknown[]): unknown => {
+  const javaList = new ArrayList();
+  for (let i = 0; i < elements.length; i++) {
+    javaList.add(asJava(elements[i]));
+  }
+  return javaList;
+};
+
+const asJavaMap = (records: object): unknown => {
+  const javaMap = new HashMap();
+  Object.entries(records).forEach(([key, value]) => {
+    javaMap.put(key, asJava(value));
+  });
+  return javaMap;
+};
+
+export const asJava = (value: unknown): unknown => {
+  if (Array.isArray(value)) {
+    return asJavaList(value);
+  } else if (typeof value === "object" && value !== null) {
+    return asJavaMap(value);
+  } else {
+    return value;
+  }
+};

package/src/globalStore.ts

@@ -0,0 +1,104 @@
+const ConcurrentHashMap = Java.type<ConcurrentHashMapStatic>("java.util.concurrent.ConcurrentHashMap");
+
+interface ConcurrentHashMapStatic {
+  new <K, V>(): ConcurrentHashMap<K, V>;
+}
+
+interface ConcurrentHashMap<K, V> {
+  put(key: K, value: V): V | null;
+  remove(key: K): V | null;
+  get(key: K): V | null;
+  getOrDefault(key: K, defaultValue: V): V;
+  containsKey(key: K): boolean;
+  compute(key: K, remappingFunction: (k: K, v: V | null) => V | null): V | null;
+  clear(): void;
+}
+
+const javaStore = new ConcurrentHashMap<string, any>();
+
+export interface GlobalStore {
+  /**
+   * Maps the specified key to the specified value in the global store. Neither the key nor the value can be null or
+   * undefined.
+   *
+   * @param key - key with which the specified value is to be associated
+   * @param value - value to be associated with the specified key
+   * @returns the previous value associated with key, or `null` if there was no mapping for key
+   */
+  put<T>(key: string, value: T): T | undefined;
+
+  /**
+   * Attempts to compute a new value for the specified key and its currently mapped value (or `null` if there is no
+   * current value). The entire method invocation is performed atomically. The supplied function is invoked exactly once
+   * per invocation of this method.  Some attempted update operations on this map by other threads may be blocked while
+   * computation is in progress, so the computation should be short and simple.
+   *
+   * The updateFunction function must not modify the global store during computation.
+   *
+   * @param key - key with which the specified value is to be associated
+   * @param updateFunction - the function to compute a new value to update the mapping; if it returns `null`, the
+   * mapping will be removed
+   * @returns the new value associated with the specified key, or `null` if none
+   */
+  update<T>(key: string, updateFunction: (oldValue: T | undefined) => T | undefined): T | undefined;
+
+  /**
+   * Returns the value to which the specified key is mapped, or `null` if the global store contains no mapping for the
+   * key.
+   *
+   * @param key - the key whose associated value is to be returned
+   * @returns the mapping for the key, if present; else `null`
+   */
+  get<T>(key: string): T | undefined;
+
+  /**
+   * Returns the value to which the specified key is mapped, or the given default value if the global store contains no
+   * mapping for the key.
+   *
+   * @param key - the key whose associated value is to be returned
+   * @param defaultValue - the value to return if the global store contains no mapping for the given key
+   * @returns the mapping for the key, if present; else the default value
+   */
+  getOrDefault<T>(key: string, defaultValue: T): T;
+
+  /**
+   * Tests if the key is present in the global store.
+   *
+   * @param key - possible key
+   * @returns `true` if and only if the key  is present in the global store; `false` otherwise
+   */
+  containsKey(key: string): boolean;
+
+  /**
+   * Removes the mapping for a key from the global store if it is present.
+   *
+   * @param key - key whose mapping is to be removed from the map
+   * @returns the previous value associated with `key`, or `null` if there was no mapping for `key`.
+   */
+  remove<T>(key: string): T;
+
+  /**
+   * Removes all of the mappings from the global store.
+   */
+  clear(): void;
+}
+
+/**
+ * A global store which can be used to share data between different virtual users.
+ */
+export const GlobalStore: GlobalStore = {
+  put: (key, value) => nullToUndefined(javaStore.put(key, value)),
+  update: (key, updateFunction) =>
+    nullToUndefined(
+      javaStore.compute(key, (_, oldValue) => undefinedToNull(updateFunction(nullToUndefined(oldValue))))
+    ),
+  get: (key) => nullToUndefined(javaStore.get(key)),
+  getOrDefault: (key, defaultValue) => javaStore.getOrDefault(key, defaultValue),
+  containsKey: (key) => javaStore.containsKey(key),
+  remove: (key) => nullToUndefined(javaStore.remove(key)),
+  clear: () => javaStore.clear()
+};
+
+const nullToUndefined = <T>(x: T | null): T | undefined => (x === null ? undefined : x);
+
+const undefinedToNull = <T>(x: T | undefined): T | null => (x === undefined ? null : x);