@gatling.io/http 3.11.7 → 3.12.0

package/src/checks.ts

@@ -0,0 +1,142 @@
+import { HttpDsl, HttpDsl as JvmHttpDsl } from "@gatling.io/jvm-types";
+import {
+  underlyingSessionTo,
+  wrapCheckBuilderCaptureGroup,
+  wrapCheckBuilderFind,
+  wrapCheckBuilderMultipleFind,
+  CheckBuilderCaptureGroup,
+  CheckBuilderFind,
+  CheckBuilderMultipleFind,
+  Expression,
+  Session
+} from "@gatling.io/core";
+
+import JvmCheckBuilderFind = io.gatling.javaapi.core.CheckBuilder$Find;
+
+/**
+ * Bootstrap a check that capture the response location, eg the landing url in a chain of
+ * redirects
+ *
+ * @returns the next step in the check DSL
+ */
+export const currentLocation = (): CheckBuilderFind<string> => wrapCheckBuilderFind(JvmHttpDsl.currentLocation());
+
+export interface CurrentLocationRegexFunction {
+  /**
+   * Bootstrap a check that capture some <a
+   * href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html">Java Regular
+   * Expression</a> capture groups on the response location, eg the landing url in a chain of
+   * redirects
+   *
+   * @param pattern - the regular expression, expressed as a Gatling Expression Language String
+   * @returns the next step in the check DSL
+   */
+  (pattern: string): CheckBuilderCaptureGroup;
+
+  /**
+   * Bootstrap a check that capture some <a
+   * href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html">Java Regular
+   * Expression</a> capture groups on the response location, eg the landing url in a chain of
+   * redirects
+   *
+   * @param pattern - the regular expression, expressed as a function
+   * @returns the next step in the check DSL
+   */
+  (pattern: (session: Session) => string): CheckBuilderCaptureGroup;
+}
+
+export const currentLocationRegex: CurrentLocationRegexFunction = (pattern: Expression<string>) =>
+  wrapCheckBuilderCaptureGroup(
+    typeof pattern === "function"
+      ? JvmHttpDsl.currentLocationRegex(underlyingSessionTo(pattern))
+      : JvmHttpDsl.currentLocationRegex(pattern)
+  );
+
+export interface HeaderFunction {
+  /**
+   * Bootstrap a check that capture the value of a HTTP header
+   *
+   * @param name the name of the HTTP header, expressed as a Gatling Expression Language String
+   * @return the next step in the check DSL
+   */
+  (name: string): CheckBuilderMultipleFind<string>;
+
+  /**
+   * Bootstrap a check that capture the value of a HTTP header
+   *
+   * @param name - the name of the HTTP header, expressed as a function
+   * @returns the next step in the check DSL
+   */
+  (name: (session: Session) => string): CheckBuilderMultipleFind<string>;
+}
+
+export const header: HeaderFunction = (name: Expression<string>) =>
+  wrapCheckBuilderMultipleFind(
+    typeof name === "function" ? JvmHttpDsl.header(underlyingSessionTo(name)) : JvmHttpDsl.header(name)
+  );
+
+export interface HeaderRegexFunction {
+  /**
+   * Bootstrap a check that capture some <a
+   * href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html">Java Regular
+   * Expression</a> capture groups on a response header
+   *
+   * @param name - the name of the HTTP header, expressed as a Gatling Expression Language String
+   * @param pattern - the regular expression, expressed as a Gatling Expression Language String
+   * @returns the next step in the check DSL
+   */
+  (name: string, pattern: string): CheckBuilderCaptureGroup;
+
+  /**
+   * Bootstrap a check that capture some <a
+   * href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html">Java Regular
+   * Expression</a> capture groups on a response header
+   *
+   * @param name - the name of the HTTP header, expressed as a function
+   * @param pattern - the regular expression, expressed as a Gatling Expression Language String
+   * @returns the next step in the check DSL
+   */
+  (name: (session: Session) => string, pattern: string): CheckBuilderCaptureGroup;
+
+  /**
+   * Bootstrap a check that capture some <a
+   * href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html">Java Regular
+   * Expression</a> capture groups on a response header
+   *
+   * @param name - the name of the HTTP header, expressed as a Gatling Expression Language String
+   * @param pattern - the regular expression, expressed as a function
+   * @returns the next step in the check DSL
+   */
+  (name: string, pattern: (session: Session) => string): CheckBuilderCaptureGroup;
+
+  /**
+   * Bootstrap a check that capture some <a
+   * href="https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html">Java Regular
+   * Expression</a> capture groups on a response header
+   *
+   * @param name the name of the HTTP header, expressed as a function
+   * @param pattern the regular expression, expressed as a function
+   * @return the next step in the check DSL
+   */
+  (name: (session: Session) => string, pattern: (session: Session) => string): CheckBuilderCaptureGroup;
+}
+
+export const headerRegex: HeaderRegexFunction = (name: Expression<string>, pattern: Expression<string>) =>
+  wrapCheckBuilderCaptureGroup(
+    typeof name === "function"
+      ? typeof pattern === "function"
+        ? HttpDsl.headerRegex(underlyingSessionTo(name), underlyingSessionTo(pattern))
+        : HttpDsl.headerRegex(underlyingSessionTo(name), pattern)
+      : typeof pattern === "function"
+        ? HttpDsl.headerRegex(name, underlyingSessionTo(pattern))
+        : // FIXME forced to use the charsequence version
+          HttpDsl.headerRegex(name, pattern)
+  );
+
+/**
+ * Bootstrap a check that capture the response HTTP status code
+ *
+ * @returns the next step in the check DSL
+ */
+export const status = (): CheckBuilderFind<number> =>
+  wrapCheckBuilderFind(JvmHttpDsl.status() as JvmCheckBuilderFind<number>);

package/src/cookies.ts

@@ -0,0 +1,227 @@
+import { ActionBuilder, Expression, Session, underlyingSessionTo, wrapActionBuilder, Wrapper } from "@gatling.io/core";
+import { HttpDsl as JvmHttpDsl } from "@gatling.io/jvm-types";
+
+import JvmAddCookie = io.gatling.javaapi.http.AddCookie;
+import JvmGetCookie = io.gatling.javaapi.http.GetCookie;
+
+/**
+ * DSL for adding a <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies">cookie</a>
+ * in the virtual user's CookieJar instead of having the server send a Set-Cookie header.
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
+export interface AddCookie extends Wrapper<JvmAddCookie> {
+  /**
+   * Define the domain of the cookie. If undefined, will try to use the domain of {@link
+   * HttpProtocolBuilder#baseUrl(String)}
+   *
+   * @param domain - the cookie domain
+   * @returns a new AddCookie
+   */
+  withDomain(domain: string): AddCookie;
+
+  /**
+   * Define the path of the cookie.
+   *
+   * @param path - the cookie path
+   * @returns a new AddCookie
+   */
+  withPath(path: string): AddCookie;
+
+  /**
+   * Define the maxAge attribute of the cookie.
+   *
+   * @param maxAge - the cookie maxAge
+   * @returns a new AddCookie
+   */
+  withMaxAge(maxAge: number): AddCookie;
+
+  /**
+   * Define the secure attribute of the cookie.
+   *
+   * @param secure - if the cookie must only be sent with HTTPS requests
+   * @returns a new AddCookie
+   */
+  withSecure(secure: boolean): AddCookie;
+}
+
+const wrapAddCookie = (_underlying: JvmAddCookie): AddCookie => ({
+  _underlying,
+  withDomain: (domain: string): AddCookie => wrapAddCookie(_underlying.withDomain(domain)),
+  withPath: (path: string): AddCookie => wrapAddCookie(_underlying.withPath(path)),
+  withMaxAge: (maxAge: number): AddCookie => wrapAddCookie(_underlying.withMaxAge(maxAge)),
+  withSecure: (secure: boolean): AddCookie => wrapAddCookie(_underlying.withSecure(secure))
+});
+
+/**
+ * DSL for fetching the value of a <a
+ * href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies">cookie</a> from the virtual
+ * user's CookieJar into its {@link Session}.
+ *
+ * <p>Immutable, so all methods return a new occurrence and leave the original unmodified.
+ */
+export interface GetCookie extends Wrapper<JvmGetCookie> {
+  /**
+   * Define the domain of the cookie. If undefined, will try to use the domain of {@link
+   * HttpProtocolBuilder#baseUrl(String)}
+   *
+   * @param domain - the cookie domain, expressed as a Gatling Expression Language String
+   * @returns a new GetCookie
+   */
+  withDomain(domain: string): GetCookie;
+
+  /**
+   * Define the domain of the cookie. If undefined, will try to use the domain of {@link
+   * HttpProtocolBuilder#baseUrl(String)}
+   *
+   * @param domain - the cookie domain, expressed as a function
+   * @returns a new GetCookie
+   */
+  withDomain(domain: (session: Session) => string): GetCookie;
+
+  /**
+   * Define the path of the cookie.
+   *
+   * @param path - the cookie path
+   * @returns a new GetCookie
+   */
+  withPath(path: string): GetCookie;
+
+  /**
+   * Define the secure attribute of the cookie.
+   *
+   * @param secure - the cookie secure attribute
+   * @returns a new GetCookie
+   */
+  withSecure(secure: boolean): GetCookie;
+
+  /**
+   * Define the {@link Session} key to save the cookie value. If undefined, will use the cookie name
+   *
+   * @param saveAs - the key
+   * @returns a new GetCookie
+   */
+  saveAs(saveAs: string): GetCookie;
+}
+
+const wrapGetCookie = (_underlying: JvmGetCookie): GetCookie => ({
+  _underlying,
+  withDomain: (domain: Expression<string>): GetCookie =>
+    wrapGetCookie(
+      typeof domain === "function" ? _underlying.withDomain(underlyingSessionTo(domain)) : _underlying.withPath(domain)
+    ),
+  withPath: (path: string): GetCookie => wrapGetCookie(_underlying.withPath(path)),
+  withSecure: (secure: boolean): GetCookie => wrapGetCookie(_underlying.withSecure(secure)),
+  saveAs: (saveAs: string): GetCookie => wrapGetCookie(_underlying.saveAs(saveAs))
+});
+
+/**
+ * Create an action to add a Cookie
+ *
+ * @param cookie - the DSL for adding a cookie
+ * @returns an ActionBuilder
+ */
+export const addCookie = (cookie: AddCookie): ActionBuilder =>
+  wrapActionBuilder(JvmHttpDsl.addCookie(cookie._underlying));
+
+/**
+ * Create an action to get a Cookie value into the Session
+ *
+ * @param cookie - the DSL for getting a cookie
+ * @returns an ActionBuilder
+ */
+export const getCookieValue = (cookie: GetCookie): ActionBuilder =>
+  wrapActionBuilder(JvmHttpDsl.getCookieValue(cookie._underlying));
+
+/**
+ * Create an action to flush the Session (non-persistent) Cookies of the user
+ *
+ * @returns an ActionBuilder
+ */
+export const flushSessionCookies = (): ActionBuilder => wrapActionBuilder(JvmHttpDsl.flushSessionCookies());
+
+/**
+ * Create an action to flush all the Cookies of the user
+ *
+ * @returns an ActionBuilder
+ */
+export const flushCookieJar = (): ActionBuilder => wrapActionBuilder(JvmHttpDsl.flushCookieJar());
+
+/**
+ * Create an action to flush the HTTP cache of the user
+ *
+ * @returns an ActionBuilder
+ */
+export const flushHttpCache = (): ActionBuilder => wrapActionBuilder(JvmHttpDsl.flushHttpCache());
+
+export interface CookieApply {
+  /**
+   * Bootstrap the DSL for defining a Cookie to add
+   *
+   * @param name - the name of the cookie, expressed as a Gatling Expression Language String
+   * @param value - the value of the cookie, expressed as a Gatling Expression Language String
+   * @returns the next DSL step
+   */
+  (name: string, value: string): AddCookie;
+
+  /**
+   * Bootstrap the DSL for defining a Cookie to add
+   *
+   * @param name - the name of the cookie, expressed as a function
+   * @param value - the value of the cookie, expressed as a Gatling Expression Language String
+   * @returns the next DSL step
+   */
+  (name: string, value: (session: Session) => string): AddCookie;
+
+  /**
+   * Bootstrap the DSL for defining a Cookie to add
+   *
+   * @param name - the name of the cookie, expressed as a Gatling Expression Language String
+   * @param value - the value of the cookie, expressed as a function
+   * @returns the next DSL step
+   */
+  (name: (session: Session) => string, value: string): AddCookie;
+
+  /**
+   * Bootstrap the DSL for defining a Cookie to add
+   *
+   * @param name - the name of the cookie, expressed as a function
+   * @param value - the value of the cookie, expressed as a function
+   * @returns the next DSL step
+   */
+  (name: (session: Session) => string, value: (session: Session) => string): AddCookie;
+}
+
+export const Cookie: CookieApply = (name: Expression<string>, value: Expression<string>): AddCookie =>
+  wrapAddCookie(
+    typeof name === "function"
+      ? typeof value === "function"
+        ? JvmHttpDsl.Cookie(underlyingSessionTo(name), underlyingSessionTo(value))
+        : JvmHttpDsl.Cookie(underlyingSessionTo(name), value)
+      : typeof value === "function"
+        ? JvmHttpDsl.Cookie(name, underlyingSessionTo(value))
+        : JvmHttpDsl.Cookie(name, value)
+  );
+
+export interface CookieKeyApply {
+  /**
+   * Bootstrap the DSL for defining a Cookie to get
+   *
+   * @param name - the name of the cookie, expressed as a Gatling Expression Language String
+   * @returns the next DSL step
+   */
+  (name: string): GetCookie;
+
+  /**
+   * Bootstrap the DSL for defining a Cookie to get
+   *
+   * @param name - the name of the cookie, expressed as a function
+   * @returns the next DSL step
+   */
+  (name: (session: Session) => string): GetCookie;
+}
+
+export const CookieKey: CookieKeyApply = (name: Expression<string>): GetCookie =>
+  wrapGetCookie(
+    typeof name === "function" ? JvmHttpDsl.CookieKey(underlyingSessionTo(name)) : JvmHttpDsl.CookieKey(name)
+  );

package/src/feeders.ts

@@ -0,0 +1,13 @@
+import { HttpDsl as JvmHttpDsl } from "@gatling.io/jvm-types";
+
+import { FileBasedFeederBuilder, wrapFileBasedFeederBuilder } from "@gatling.io/core";
+
+/**
+ * Bootstrap a feeder that reads from a sitemap XML file
+ *
+ * @param filePath - the path of the file, either relative to the root of the classpath, or absolute, expressed as a
+ * Gatling Expression Language String
+ * @returns the next DSL step
+ */
+export const sitemap = (filePath: string): FileBasedFeederBuilder<string> =>
+  wrapFileBasedFeederBuilder(JvmHttpDsl.sitemap(filePath));

package/src/headers.ts

@@ -0,0 +1,32 @@
+import { Wrapper } from "@gatling.io/core";
+
+import JvmHttpHeaders = io.netty.handler.codec.http.HttpHeaders;
+
+/**
+ * Provides the constants for the standard HTTP header names and values and
+ * commonly used utility methods that accesses an {@link HttpMessage}.
+ * <p>
+ * Concrete instances of this class are most easily obtained from its default factory:
+ * {@link DefaultHttpHeadersFactory#headersFactory()}.
+ */
+export interface HttpHeaders extends Wrapper<JvmHttpHeaders> {
+  /**
+   * Adds a new header with the specified name and value.
+   *
+   * If the specified value is not a {@link String}, it is converted
+   * into a {@link String} by {@link Object#toString()}, except in the cases
+   * of {@link Date} and {@link Calendar}, which are formatted to the date
+   * format defined in <a href="https://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3.1">RFC2616</a>.
+   *
+   * @param name - The name of the header being added
+   * @param value - The value of the header being added
+   *
+   * @returns {@code this}
+   */
+  add(name: string, value: any): HttpHeaders;
+}
+
+export const wrapHttpHeaders = (_underlying: JvmHttpHeaders): HttpHeaders => ({
+  _underlying,
+  add: (name: string, value: any): HttpHeaders => wrapHttpHeaders(_underlying.add(name, value))
+});