@serenity-js/assertions 3.41.1 → 3.42.0

package/esm/expectations/isBefore.js

@@ -0,0 +1,50 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the actual value of type `Date`
+ * is before the expected `Date`.
+ *
+ * ## Ensuring that a given date is after the expected date
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, isBefore } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(new Date('1995-01-01'), isBefore(new Date('2022-01-01'))),
+ * )
+ * ```
+ *
+ * ## Ensuring that a given date is within the expected date range
+ *
+ * ```ts
+ * import { actorCalled, Expectation, d } from '@serenity-js/core'
+ * import { Ensure, and, isAfter, isBefore } from '@serenity-js/assertions'
+ *
+ * const isWithinDateRange = (lowerBound: Answerable<Date>, upperBound: Answerable<Date>) =>
+ *   Expectation.to(d`have value that is between ${ lowerBound } and ${ upperBound }`)
+ *     .soThatActual(
+ *       and(isAfter(lowerBound), isBefore(upperBound))
+ *     ),
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(
+ *     new Date('2022-01-01'),
+ *     isWithinDateRange(new Date('1995-01-01'), new Date('2025-01-01'))
+ *   ),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+export const isBefore = Expectation.define('isBefore', 'have value that is before', (actual, expected) => {
+    const actualInMilliseconds = actual instanceof Date
+        ? actual.getTime()
+        : actual.toMilliseconds();
+    const expectedInMilliseconds = expected instanceof Date
+        ? expected.getTime()
+        : expected.toMilliseconds();
+    return actualInMilliseconds < expectedInMilliseconds;
+});
+//# sourceMappingURL=isBefore.js.map

package/esm/expectations/isBefore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBefore.js","sourceRoot":"","sources":["../../src/expectations/isBefore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,WAAW,CAAC,MAAM,CACtC,UAAU,EAAE,2BAA2B,EACvC,CAAC,MAAwB,EAAE,QAA0B,EAAE,EAAE;IAErD,MAAM,oBAAoB,GAAG,MAAM,YAAY,IAAI;QAC/C,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE;QAClB,CAAC,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;IAE9B,MAAM,sBAAsB,GAAG,QAAQ,YAAY,IAAI;QACnD,CAAC,CAAC,QAAQ,CAAC,OAAO,EAAE;QACpB,CAAC,CAAC,QAAQ,CAAC,cAAc,EAAE,CAAC;IAEhC,OAAO,oBAAoB,GAAG,sBAAsB,CAAC;AACzD,CAAC,CACJ,CAAC"}

package/esm/expectations/isCloseTo.d.ts

@@ -0,0 +1,24 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Produces an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the actual value
+ * is within a given ± `absoluteTolerance` range of the `expected` value.
+ *
+ * ## Ensuring that a given floating point number is close to the expected number
+ *
+ * ```ts
+ *  import { actorCalled } from '@serenity-js/core'
+ *  import { Ensure, isCloseTo } from '@serenity-js/assertions'
+ *
+ *  await actorCalled('Iris').attemptsTo(
+ *      Ensure.that(10.123, isCloseTo(10, 0.2))
+ *  )
+ * ```
+ *
+ * @param expected
+ * @param [absoluteTolerance=1e-9]
+ *  Absolute ± tolerance range, defaults to `1e-9`
+ *
+ * @group Expectations
+ */
+export declare const isCloseTo: (expected: import("@serenity-js/core").Answerable<number>, absoluteTolerance?: import("@serenity-js/core").Answerable<number>) => Expectation<number>;
+//# sourceMappingURL=isCloseTo.d.ts.map

package/esm/expectations/isCloseTo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isCloseTo.d.ts","sourceRoot":"","sources":["../../src/expectations/isCloseTo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,SAAS,uJAiBrB,CAAA"}

package/esm/expectations/isCloseTo.js

@@ -0,0 +1,34 @@
+import { d, Expectation } from '@serenity-js/core';
+/**
+ * Produces an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the actual value
+ * is within a given ± `absoluteTolerance` range of the `expected` value.
+ *
+ * ## Ensuring that a given floating point number is close to the expected number
+ *
+ * ```ts
+ *  import { actorCalled } from '@serenity-js/core'
+ *  import { Ensure, isCloseTo } from '@serenity-js/assertions'
+ *
+ *  await actorCalled('Iris').attemptsTo(
+ *      Ensure.that(10.123, isCloseTo(10, 0.2))
+ *  )
+ * ```
+ *
+ * @param expected
+ * @param [absoluteTolerance=1e-9]
+ *  Absolute ± tolerance range, defaults to `1e-9`
+ *
+ * @group Expectations
+ */
+export const isCloseTo = Expectation.define('isCloseTo', (expected, absoluteTolerance = 1e-9) => d `have value close to ${expected} ±${absoluteTolerance}`, (actual, expected, absoluteTolerance = 1e-9) => {
+    // short-circuit exact equality
+    if (actual === expected) {
+        return true;
+    }
+    if (!(Number.isFinite(actual) && Number.isFinite(expected))) {
+        return false;
+    }
+    const difference = Math.abs(actual - expected);
+    return difference <= absoluteTolerance;
+});
+//# sourceMappingURL=isCloseTo.js.map

package/esm/expectations/isCloseTo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isCloseTo.js","sourceRoot":"","sources":["../../src/expectations/isCloseTo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,WAAW,CAAC,MAAM,CACvC,WAAW,EAAE,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,EAAE,EAAE,CAAC,CAAC,CAAA,uBAAwB,QAAS,KAAM,iBAAkB,EAAE,EAEjH,CAAC,MAAc,EAAE,QAAgB,EAAE,oBAA4B,IAAI,EAAE,EAAE;IACnE,+BAA+B;IAC/B,IAAI,MAAM,KAAK,QAAQ,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,IAAI,CAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC;QAC3D,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAA;IAE9C,OAAO,UAAU,IAAI,iBAAiB,CAAC;AAC3C,CAAC,CACJ,CAAA"}

package/esm/expectations/isFalse.d.ts

@@ -0,0 +1,21 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the actual `boolean` value
+ * is `false`.
+ *
+ * ## Ensuring that a given value is false
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, isFalse } from '@serenity-js/assertions'
+ * import { Cookie } from '@serenity-js/web'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(Cookie.called('example-regular-cookie').isSecure(), isFalse()),
+ * )
+ * ```
+ *
+ * @group Expectations
+ */
+export declare function isFalse(): Expectation<boolean>;
+//# sourceMappingURL=isFalse.d.ts.map

package/esm/expectations/isFalse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isFalse.d.ts","sourceRoot":"","sources":["../../src/expectations/isFalse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIhD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,CAE9C"}

package/esm/expectations/isFalse.js

@@ -0,0 +1,24 @@
+import { Expectation } from '@serenity-js/core';
+import { equals } from './equals.js';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the actual `boolean` value
+ * is `false`.
+ *
+ * ## Ensuring that a given value is false
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, isFalse } from '@serenity-js/assertions'
+ * import { Cookie } from '@serenity-js/web'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(Cookie.called('example-regular-cookie').isSecure(), isFalse()),
+ * )
+ * ```
+ *
+ * @group Expectations
+ */
+export function isFalse() {
+    return Expectation.to(`equal false`).soThatActual(equals(false));
+}
+//# sourceMappingURL=isFalse.js.map

package/esm/expectations/isFalse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isFalse.js","sourceRoot":"","sources":["../../src/expectations/isFalse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,OAAO;IACnB,OAAO,WAAW,CAAC,EAAE,CAAU,aAAa,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;AAC9E,CAAC"}

package/esm/expectations/isGreaterThan.d.ts

@@ -0,0 +1,45 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the actual value of type `number`
+ * is greater than the expected `number`.
+ *
+ * ## Ensuring that a given number is greater than the expected number
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, isGreaterThan } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(10, isGreaterThan(5)),
+ * )
+ * ```
+ *
+ * ## Ensuring that a given number is within the expected range
+ *
+ * ```ts
+ * import { actorCalled, Expectation, d } from '@serenity-js/core'
+ * import { Ensure, and, equals, isGreaterThan, isLessThan, or } from '@serenity-js/assertions'
+ *
+ * const isWithinRange = (lowerBound: Answerable<number>, upperBound: Answerable<number>) =>
+ *   Expectation.to(d`have value that is between ${ lowerBound } and ${ upperBound }`)
+ *     .soThatActual(
+ *       and(
+ *         or(equals(lowerBound), isGreaterThan(lowerBound)),
+ *         or(equals(upperBound), isLessThan(upperBound)),
+ *       )
+ *     ),
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(
+ *     7,
+ *     isWithinRange(5, 10)
+ *   ),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+export declare const isGreaterThan: (expected: import("@serenity-js/core").Answerable<number>) => Expectation<number>;
+//# sourceMappingURL=isGreaterThan.d.ts.map

package/esm/expectations/isGreaterThan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isGreaterThan.d.ts","sourceRoot":"","sources":["../../src/expectations/isGreaterThan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,aAAa,mFAIzB,CAAA"}

package/esm/expectations/isGreaterThan.js

@@ -0,0 +1,45 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the actual value of type `number`
+ * is greater than the expected `number`.
+ *
+ * ## Ensuring that a given number is greater than the expected number
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, isGreaterThan } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(10, isGreaterThan(5)),
+ * )
+ * ```
+ *
+ * ## Ensuring that a given number is within the expected range
+ *
+ * ```ts
+ * import { actorCalled, Expectation, d } from '@serenity-js/core'
+ * import { Ensure, and, equals, isGreaterThan, isLessThan, or } from '@serenity-js/assertions'
+ *
+ * const isWithinRange = (lowerBound: Answerable<number>, upperBound: Answerable<number>) =>
+ *   Expectation.to(d`have value that is between ${ lowerBound } and ${ upperBound }`)
+ *     .soThatActual(
+ *       and(
+ *         or(equals(lowerBound), isGreaterThan(lowerBound)),
+ *         or(equals(upperBound), isLessThan(upperBound)),
+ *       )
+ *     ),
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(
+ *     7,
+ *     isWithinRange(5, 10)
+ *   ),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+export const isGreaterThan = Expectation.define('isGreaterThan', 'have value greater than', (actual, expected) => actual > expected);
+//# sourceMappingURL=isGreaterThan.js.map

package/esm/expectations/isGreaterThan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isGreaterThan.js","sourceRoot":"","sources":["../../src/expectations/isGreaterThan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,WAAW,CAAC,MAAM,CAC3C,eAAe,EAAE,yBAAyB,EAC1C,CAAC,MAAc,EAAE,QAAgB,EAAE,EAAE,CACjC,MAAM,GAAG,QAAQ,CACxB,CAAA"}

package/esm/expectations/isLessThan.d.ts

@@ -0,0 +1,45 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the actual value of type `number`
+ * is less than the expected `number`.
+ *
+ * ## Ensuring that a given number is less than the expected number
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, isLessThan } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(5, isLessThan(10)),
+ * )
+ * ```
+ *
+ * ## Ensuring that a given number is within the expected range
+ *
+ * ```ts
+ * import { actorCalled, Expectation, d } from '@serenity-js/core'
+ * import { Ensure, and, equals, isGreaterThan, isLessThan, or } from '@serenity-js/assertions'
+ *
+ * const isWithinRange = (lowerBound: Answerable<number>, upperBound: Answerable<number>) =>
+ *   Expectation.to(d`have value that is between ${ lowerBound } and ${ upperBound }`)
+ *     .soThatActual(
+ *       and(
+ *         or(equals(lowerBound), isGreaterThan(lowerBound)),
+ *         or(equals(upperBound), isLessThan(upperBound)),
+ *       )
+ *     ),
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(
+ *     7,
+ *     isWithinRange(5, 10)
+ *   ),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+export declare const isLessThan: (expected: import("@serenity-js/core").Answerable<number>) => Expectation<number>;
+//# sourceMappingURL=isLessThan.d.ts.map

package/esm/expectations/isLessThan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isLessThan.d.ts","sourceRoot":"","sources":["../../src/expectations/isLessThan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,UAAU,mFAItB,CAAC"}

package/esm/expectations/isLessThan.js

@@ -0,0 +1,45 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the actual value of type `number`
+ * is less than the expected `number`.
+ *
+ * ## Ensuring that a given number is less than the expected number
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, isLessThan } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(5, isLessThan(10)),
+ * )
+ * ```
+ *
+ * ## Ensuring that a given number is within the expected range
+ *
+ * ```ts
+ * import { actorCalled, Expectation, d } from '@serenity-js/core'
+ * import { Ensure, and, equals, isGreaterThan, isLessThan, or } from '@serenity-js/assertions'
+ *
+ * const isWithinRange = (lowerBound: Answerable<number>, upperBound: Answerable<number>) =>
+ *   Expectation.to(d`have value that is between ${ lowerBound } and ${ upperBound }`)
+ *     .soThatActual(
+ *       and(
+ *         or(equals(lowerBound), isGreaterThan(lowerBound)),
+ *         or(equals(upperBound), isLessThan(upperBound)),
+ *       )
+ *     ),
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(
+ *     7,
+ *     isWithinRange(5, 10)
+ *   ),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+export const isLessThan = Expectation.define('isLessThan', `have value that's less than`, (actual, expected) => actual < expected);
+//# sourceMappingURL=isLessThan.js.map

package/esm/expectations/isLessThan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isLessThan.js","sourceRoot":"","sources":["../../src/expectations/isLessThan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,WAAW,CAAC,MAAM,CACxC,YAAY,EAAE,6BAA6B,EAC3C,CAAC,MAAc,EAAE,QAAgB,EAAE,EAAE,CACjC,MAAM,GAAG,QAAQ,CACxB,CAAC"}

package/esm/expectations/isPresent.d.ts

@@ -0,0 +1,65 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the `actual` value is not undefined or null.
+ *
+ * Also, when the `actual` implements [`Optional`](https://serenity-js.org/api/core/interface/Optional/),
+ * the expectation is met when calling [`Optional.isPresent`](https://serenity-js.org/api/core/interface/Optional/#isPresent)
+ * returns an [`Answerable`](https://serenity-js.org/api/core/#Answerable) that resolves to `true`
+ *
+ * ## Ensuring that a value is defined
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { CallAnApi, Send, GetRequest, LastResponse } from '@serenity-js/rest'
+ * import { Ensure, isPresent } from '@serenity-js/assertions'
+ *
+ * interface Product {
+ *     name: string;
+ * }
+ *
+ * interface ProductsResponse {
+ *     products: Product[];
+ * }
+ *
+ * await actorCalled('Apisitt')
+ *   .whoCan(CallAnApi.at('https://api.example.org'))
+ *   .attemptsTo(
+ *     Send.a(GetRequest.to('/products')),
+ *     Ensure.that(LastResponse.body<ProductsResponse>().products[0], isPresent()),
+ *   )
+ * ```
+ *
+ * ## Checking if a PageElement is present
+ *
+ * ```ts
+ * import { actorCalled, Check } from '@serenity-js/core';
+ * import { BrowseTheWebWithPlaywright } from '@serenity-js/playwright';
+ * import { By, Click, Navigate, PageElement } from '@serenity-js/web';
+ * import { Browser, chromium } from 'playwright';
+ *
+ * class NewsletterSubscription {
+ *   static modal = () =>
+ *     PageElement.located(By.id('newsletter-subscription'))
+ *       .describedAs('newsletter subscription modal')
+ *
+ *   static closeButton = () =>
+ *     PageElement.located(By.class('.close'))
+ *       .of(NewsletterSubscription.modal())
+ *       .describedAs('close button')
+ * }
+ *
+ * const browser = await chromium.launch({ headless: true });
+ *
+ * await actorCalled('Isabela')
+ *   .whoCan(BrowseTheWebWithPlaywright.using(browser))
+ *   .attemptsTo(
+ *     Navigate.to(`https://example.org`),
+ *     Check.whether(NewsletterSubscription.modal(), isPresent())
+ *       .andIfSo(Click.on(NewsletterSubscription.closeButton())),
+ *   )
+ * ```
+ *
+ * @group Expectations
+ */
+export declare function isPresent<Actual>(): Expectation<Actual>;
+//# sourceMappingURL=isPresent.d.ts.map

package/esm/expectations/isPresent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPresent.d.ts","sourceRoot":"","sources":["../../src/expectations/isPresent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAyD,MAAM,mBAAmB,CAAC;AAEvG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,wBAAgB,SAAS,CAAC,MAAM,KAAK,WAAW,CAAC,MAAM,CAAC,CAEvD"}

package/esm/expectations/isPresent.js

@@ -0,0 +1,96 @@
+import { Expectation, ExpectationDetails, ExpectationMet, ExpectationNotMet } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the `actual` value is not undefined or null.
+ *
+ * Also, when the `actual` implements [`Optional`](https://serenity-js.org/api/core/interface/Optional/),
+ * the expectation is met when calling [`Optional.isPresent`](https://serenity-js.org/api/core/interface/Optional/#isPresent)
+ * returns an [`Answerable`](https://serenity-js.org/api/core/#Answerable) that resolves to `true`
+ *
+ * ## Ensuring that a value is defined
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { CallAnApi, Send, GetRequest, LastResponse } from '@serenity-js/rest'
+ * import { Ensure, isPresent } from '@serenity-js/assertions'
+ *
+ * interface Product {
+ *     name: string;
+ * }
+ *
+ * interface ProductsResponse {
+ *     products: Product[];
+ * }
+ *
+ * await actorCalled('Apisitt')
+ *   .whoCan(CallAnApi.at('https://api.example.org'))
+ *   .attemptsTo(
+ *     Send.a(GetRequest.to('/products')),
+ *     Ensure.that(LastResponse.body<ProductsResponse>().products[0], isPresent()),
+ *   )
+ * ```
+ *
+ * ## Checking if a PageElement is present
+ *
+ * ```ts
+ * import { actorCalled, Check } from '@serenity-js/core';
+ * import { BrowseTheWebWithPlaywright } from '@serenity-js/playwright';
+ * import { By, Click, Navigate, PageElement } from '@serenity-js/web';
+ * import { Browser, chromium } from 'playwright';
+ *
+ * class NewsletterSubscription {
+ *   static modal = () =>
+ *     PageElement.located(By.id('newsletter-subscription'))
+ *       .describedAs('newsletter subscription modal')
+ *
+ *   static closeButton = () =>
+ *     PageElement.located(By.class('.close'))
+ *       .of(NewsletterSubscription.modal())
+ *       .describedAs('close button')
+ * }
+ *
+ * const browser = await chromium.launch({ headless: true });
+ *
+ * await actorCalled('Isabela')
+ *   .whoCan(BrowseTheWebWithPlaywright.using(browser))
+ *   .attemptsTo(
+ *     Navigate.to(`https://example.org`),
+ *     Check.whether(NewsletterSubscription.modal(), isPresent())
+ *       .andIfSo(Click.on(NewsletterSubscription.closeButton())),
+ *   )
+ * ```
+ *
+ * @group Expectations
+ */
+export function isPresent() {
+    return new IsPresent();
+}
+class IsPresent extends Expectation {
+    static isOptional(value) {
+        return value !== undefined
+            && value !== null
+            && typeof value.isPresent === 'function';
+    }
+    static valueToCheck(actual, actor) {
+        if (IsPresent.isOptional(actual)) {
+            return actual;
+        }
+        return actor.answer(actual);
+    }
+    static async isPresent(value, actor) {
+        if (IsPresent.isOptional(value)) {
+            return actor.answer(value.isPresent());
+        }
+        return value !== undefined
+            && value !== null;
+    }
+    constructor() {
+        super('isPresent', 'become present', async (actor, actual) => {
+            const value = await IsPresent.valueToCheck(actual, actor);
+            const result = await IsPresent.isPresent(value, actor);
+            return result
+                ? new ExpectationMet('become present', ExpectationDetails.of('isPresent'), true, actual)
+                : new ExpectationNotMet('become present', ExpectationDetails.of('isPresent'), true, actual);
+        });
+    }
+}
+//# sourceMappingURL=isPresent.js.map

package/esm/expectations/isPresent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPresent.js","sourceRoot":"","sources":["../../src/expectations/isPresent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEvG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,MAAM,UAAU,SAAS;IACrB,OAAO,IAAI,SAAS,EAAU,CAAC;AACnC,CAAC;AAED,MAAM,SAAkB,SAAQ,WAAmB;IACvC,MAAM,CAAC,UAAU,CAAC,KAAU;QAChC,OAAO,KAAK,KAAK,SAAS;eACnB,KAAK,KAAK,IAAI;eACd,OAAO,KAAK,CAAC,SAAS,KAAK,UAAU,CAAC;IACjD,CAAC;IAEO,MAAM,CAAC,YAAY,CAAI,MAAqB,EAAE,KAAuB;QACzE,IAAI,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YAC/B,OAAO,MAAM,CAAC;QAClB,CAAC;QAED,OAAO,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAEO,MAAM,CAAC,KAAK,CAAC,SAAS,CAAI,KAAoB,EAAE,KAAuB;QAC3E,IAAI,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9B,OAAO,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC;QAC3C,CAAC;QAED,OAAO,KAAK,KAAK,SAAS;eACnB,KAAK,KAAK,IAAI,CAAC;IAC1B,CAAC;IAED;QACI,KAAK,CACD,WAAW,EACX,gBAAgB,EAChB,KAAK,EAAE,KAAuB,EAAE,MAA0B,EAAE,EAAE;YAE1D,MAAM,KAAK,GAAI,MAAM,SAAS,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;YAC3D,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YAEvD,OAAO,MAAM;gBACT,CAAC,CAAC,IAAI,cAAc,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC;gBACxF,CAAC,CAAC,IAAI,iBAAiB,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,EAAE,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QACpG,CAAC,CACJ,CAAC;IACN,CAAC;CACJ"}

package/esm/expectations/isTrue.d.ts

@@ -0,0 +1,21 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the actual `boolean` value
+ * is `true`.
+ *
+ * ## Ensuring that a given value is true
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, isTrue } from '@serenity-js/assertions'
+ * import { Cookie } from '@serenity-js/web'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(Cookie.called('example-secure-cookie').isSecure(), isTrue()),
+ * )
+ * ```
+ *
+ * @group Expectations
+ */
+export declare function isTrue(): Expectation<boolean>;
+//# sourceMappingURL=isTrue.d.ts.map

package/esm/expectations/isTrue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTrue.d.ts","sourceRoot":"","sources":["../../src/expectations/isTrue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIhD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,IAAI,WAAW,CAAC,OAAO,CAAC,CAE7C"}

package/esm/expectations/isTrue.js

@@ -0,0 +1,24 @@
+import { Expectation } from '@serenity-js/core';
+import { equals } from './equals.js';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the actual `boolean` value
+ * is `true`.
+ *
+ * ## Ensuring that a given value is true
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, isTrue } from '@serenity-js/assertions'
+ * import { Cookie } from '@serenity-js/web'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that(Cookie.called('example-secure-cookie').isSecure(), isTrue()),
+ * )
+ * ```
+ *
+ * @group Expectations
+ */
+export function isTrue() {
+    return Expectation.to(`equal true`).soThatActual(equals(true));
+}
+//# sourceMappingURL=isTrue.js.map

package/esm/expectations/isTrue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTrue.js","sourceRoot":"","sources":["../../src/expectations/isTrue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,MAAM;IAClB,OAAO,WAAW,CAAC,EAAE,CAAU,YAAY,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AAC5E,CAAC"}

package/esm/expectations/matches.d.ts

@@ -0,0 +1,22 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the actual `string` value
+ * matches the `expected` regular expression.
+ *
+ * ## Ensuring that a given string matches a regular expression
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, includes } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that('Hello World!', matches(/[Ww]orld/)),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+export declare const matches: (expected: import("@serenity-js/core").Answerable<RegExp>) => Expectation<string>;
+//# sourceMappingURL=matches.d.ts.map

package/esm/expectations/matches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matches.d.ts","sourceRoot":"","sources":["../../src/expectations/matches.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,OAAO,mFAInB,CAAC"}

package/esm/expectations/matches.js

@@ -0,0 +1,22 @@
+import { Expectation } from '@serenity-js/core';
+/**
+ * Creates an [expectation](https://serenity-js.org/api/core/class/Expectation/) that is met when the actual `string` value
+ * matches the `expected` regular expression.
+ *
+ * ## Ensuring that a given string matches a regular expression
+ *
+ * ```ts
+ * import { actorCalled } from '@serenity-js/core'
+ * import { Ensure, includes } from '@serenity-js/assertions'
+ *
+ * await actorCalled('Ester').attemptsTo(
+ *   Ensure.that('Hello World!', matches(/[Ww]orld/)),
+ * )
+ * ```
+ *
+ * @param expected
+ *
+ * @group Expectations
+ */
+export const matches = Expectation.define('matches', 'match', (actual, expected) => expected.test(actual));
+//# sourceMappingURL=matches.js.map

package/esm/expectations/matches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matches.js","sourceRoot":"","sources":["../../src/expectations/matches.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,CACrC,SAAS,EAAE,OAAO,EAClB,CAAC,MAAc,EAAE,QAAgB,EAAE,EAAE,CACjC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAC5B,CAAC"}