@serenity-js/playwright-test 3.0.0-rc.38 → 3.0.0-rc.40

package/src/api/SerenityFixtures.ts

@@ -0,0 +1,130 @@
+import { Actor, Cast, Serenity } from '@serenity-js/core';
+
+/**
+ * Serenity/JS-specific [Playwright Test fixtures](https://playwright.dev/docs/test-fixtures)
+ * injected into your {@apilink it|test scenarios}.
+ *
+ * ## Example test scenario
+ *
+ * ```typescript
+ * import { Ensure, equals } from '@serenity-js/assertions'
+ * import { describe, it, test } from '@serenity-js/playwright-test'
+ * import { Photographer, TakePhotosOfFailures } from '@serenity-js/web'
+ *
+ * describe(`Recording items`, () => {
+ *
+ *     test.use({
+ *         defaultActorName: 'Serena',
+ *         crew: [
+ *             Photographer.whoWill(TakePhotosOfFailures),
+ *         ],
+ *     })
+ *
+ *     describe(`Todo List App`, () => {
+ *
+ *         it(`should allow me to add a todo item`, async ({ actor }) => {
+ *             await actor.attemptsTo(
+ *                 startWithAnEmptyList(),
+ *
+ *                 recordItem('Buy some milk'),
+ *
+ *                 Ensure.that(itemNames(), equals([
+ *                     'Buy some milk',
+ *                 ])),
+ *             )
+ *         })
+ *     })
+ * })
+ * ```
+ *
+ * ## Learn more
+ * - Declaring a Serenity/JS {@apilink it|test scenario}
+ * - {@apilink describe|Grouping test scenarios}
+ * - [Serenity/JS + Playwright Test project template](https://github.com/serenity-js/serenity-js-playwright-test-template/)
+ */
+export interface SerenityFixtures {
+
+    /**
+     * Retrieves the root object of the Serenity/JS framework.
+     */
+    serenity: Serenity;
+
+    /**
+     * Name and version of the operating system that Playwright Test worker process runs on.
+     */
+    platform: { name: string, version: string };
+
+    /**
+     * A cast of Serenity/JS actors to be used instead of the default cast
+     * when instantiating {@apilink SerenityFixtures.actor|actor}
+     * and invoking {@apilink SerenityFixtures.actorCalled|actorCalled}.
+     *
+     * #### Overriding the default cast of Serenity/JS actors
+     *
+     * ```typescript
+     * import { Cast, TakeNotes } from '@serenity-js/core'
+     * import { Ensure, equals } from '@serenity-js/assertions'
+     * import { BrowseTheWebWithPlaywright } from '@serenity-js/playwright'
+     * import { describe, it, test } from '@serenity-js/playwright-test'
+     *
+     * describe(`Recording items`, () => {
+     *
+     *     test.use({
+     *         defaultActorName: 'Serena',
+     *         actors: ({ browser, contextOptions }, use) => {
+     *             const cast = Cast.whereEveryoneCan(
+     *                 BrowseTheWebWithPlaywright.using(browser, contextOptions),
+     *                 TakeNotes.usingAnEmptyNotepad(),
+     *             )
+     *
+     *             // Make sure to pass your custom cast to Playwright `use` callback
+     *             use(cast)
+     *         },
+     *     })
+     *
+     *     describe(`Todo List App`, () => {
+     *
+     *         it(`should allow me to add a todo item`, async ({ actor }) => {
+     *             await actor.attemptsTo(
+     *                 startWithAnEmptyList(),
+     *
+     *                 recordItem('Buy some milk'),
+     *
+     *                 Ensure.that(itemNames(), equals([
+     *                     'Buy some milk',
+     *                 ])),
+     *             )
+     *         })
+     *     })
+     * })
+     * ```
+     */
+    actors: Cast;
+
+    /**
+     * Uses the provided {@apilink Cast} of {@apilink SerenityFixtures.actors|actors} to instantiate an {@apilink Actor} called `name`
+     * and inject it into a {@apilink it|test scenario}.
+     *
+     * Retrieves an existing actor if one has already been instantiated.
+     *
+     * #### Learn more
+     * - Declaring a Serenity/JS {@apilink it|test scenario}
+     * - {@apilink SerenityOptions.actors}
+     * - {@apilink SerenityFixtures.actors}
+     *
+     * @param name
+     */
+    actorCalled: (name: string) => Actor;
+
+    /**
+     * Default {@apilink SerenityFixtures.actor|actor} injected into a {@apilink it|test scenario}.
+     *
+     * Using `actor` fixture is equivalent to invoking {@apilink SerenityFixtures.actorCalled|actorCalled} with {@apilink SerenityOptions.defaultActorName|defaultActorName}.
+     *
+     * #### Learn more
+     * - {@apilink SerenityFixtures.actorCalled|actorCalled}
+     * - {@apilink SerenityOptions.defaultActorName}
+     * - Declaring a Serenity/JS {@apilink it|test scenario}
+     */
+    actor: Actor;
+}

package/src/api/SerenityOptions.ts

@@ -0,0 +1,261 @@
+import { PlaywrightTestOptions, PlaywrightWorkerArgs, TestFixture } from '@playwright/test';
+import { Cast, ClassDescription, Duration, StageCrewMember, StageCrewMemberBuilder } from '@serenity-js/core';
+import { PlaywrightOptions } from '@serenity-js/playwright';
+
+/**
+ * Configuration object accepted by `@serenity-js/playwright-test`.
+ *
+ * ## Example
+ *
+ * ```typescript
+ * // playwright.config.ts
+ * import type { Cast, TakeNotes } from '@serenity-js/core'
+ * import type { BrowseTheWebWithPlaywright } from '@serenity-js/playwright'
+ * import type { PlaywrightTestConfig } from '@serenity-js/playwright-test'
+ * import type { CallAnApi } from '@serenity-js/rest'
+ *
+ * // Define any custom configuration options, if needed
+ * interface MyCustomOptions {
+ *     apiUrl: string;
+ * }
+ *
+ * const config: PlaywrightTestConfig<MyCustomOptions> = {
+ *
+ *     // Register Serenity/JS reporter for Playwright Test
+ *     // to enable integration with Serenity/JS stage crew members
+ *     // and have them instantiated in the Playwright reporter process
+ *     reporter: [
+ *         [ '@serenity-js/playwright-test', {
+ *             // Stage crew members instantiated in the test reporter process
+ *             crew: [
+ *                 '@serenity-js/serenity-bdd',
+ *                 '@serenity-js/console-reporter',
+ *                 [ '@serenity-js/core:ArtifactArchiver', { outputDirectory: 'target/site/serenity' } ],
+ *             ]
+ *         }]
+ *     ],
+ *
+ *     use: {
+ *
+ *         // Register Serenity/JS stage crew members
+ *         // and have them instantiated in Playwright Test worker processes
+ *         crew: [
+ *             [ '@serenity-js/web:Photographer', { strategy: 'TakePhotosOfFailures' } ]
+ *         ],
+ *
+ *         // Register a custom cast of Serenity/JS actors
+ *         // if you don't want to use the default one
+ *         actors: ({ browser, contextOptions, apiUrl }, use) => {
+ *              const cast = Cast.whereEveryoneCan(
+ *                  BrowseTheWebWithPlaywright.using(browser, contextOptions),
+ *                  TakeNotes.usingAnEmptyNotepad(),
+ *                  CallAnApi.at(apiUrl),
+ *              )
+ *
+ *              use(cast)
+ *         },
+ *
+ *         // Name to be given to an actor injected via `actor` fixture
+ *         defaultActorName: 'Alice',
+ *
+ *         // Any custom options, as per the MyCustomOptions interface
+ *         apiUrl: 'https://api.serenity-js.org/v1'
+ *
+ *         // Any other Playwright options
+ *         baseURL: 'https://todo-app.serenity-js.org/',
+ *         video: 'on-first-retry',
+ *         trace: 'on-first-retry',
+ *     },
+ * }
+ *
+ * export default config
+ * ```
+ *
+ * ## Learn more
+ * - {@apilink PlaywrightTestConfig}
+ * - {@apilink Cast}
+ * - {@apilink SerenityFixtures}
+ */
+export interface SerenityOptions {
+
+    /**
+     * Configures the {@apilink Cast} of {@apilink SerenityConfig.actors|actors} to be used when injecting an {@apilink SerenityFixtures.actor|actor}
+     * or invoking {@apilink SerenityFixtures.actorCalled|actorCalled} in a {@apilink it|test scenario}.
+     *
+     * :::info Did you know?
+     * When you use `@serenity-js/playwright-test` {@apilink it|test APIs}, Serenity/JS already provides a default cast of actors for you.
+     * Each one of the default actors receives {@apilink Ability|abilities} to {@apilink BrowseTheWebWithPlaywright} and {@apilink TakeNotes.usingAnEmptyNotepad}.
+     *
+     * The default abilities should be sufficient in most web testing scenarios. However, you might want to override this default configuration
+     * when you need your actors to {@apilink CallAnApi|interact with REST APIs}, {@apilink ManageALocalServer|manage local servers},
+     * start with a notepad that has some {@apilink TakeNotes.using|initial state}, or receive {@apilink Ability|custom abilities}.
+     * :::
+     *
+     * #### Using a custom crew of Serenity/JS actors
+     *
+     * ```typescript
+     * // playwright.config.ts
+     * import type { PlaywrightTestConfig } from '@serenity-js/playwright-test'
+     * import { Cast, TakeNotes } from '@serenity-js/core'
+     * import { BrowseTheWebWithPlaywright } from '@serenity-js/playwright'
+     * import { CallAnApi } from '@serenity-js/rest'
+     *
+     * // Define any custom configuration options, if needed
+     * interface MyCustomOptions {
+     *     apiUrl: string;
+     * }
+     *
+     * // Parameterise PlaywrightTestConfig with MyCustomOptions
+     * // to enable type checking of any custom properties
+     * const config: PlaywrightTestConfig<MyCustomOptions> = {
+     *     use: {
+     *         contextOptions: {
+     *             defaultNavigationTimeout: 30_000,
+     *         },
+     *
+     *         // custom properties
+     *         apiUrl: 'https://api.serenity-js.org/v1',
+     *
+     *         // Custom cast of actors receives `contextOptions`
+     *         // with the additional Serenity/JS properties (see `PlaywrightOptions`),
+     *         // as well as any other custom properties you define in the destructuring expression,
+     *         // such as `apiUrl`.
+     *         actors: ({ browser, contextOptions, apiUrl }, use) => {
+     *             const cast = Cast.whereEveryoneCan(
+     *                 BrowseTheWebWithPlaywright.using(browser, contextOptions),
+     *                 TakeNotes.usingAnEmptyNotepad(),
+     *                 CallAnApi.at(apiUrl),
+     *             )
+     *
+     *             // Make sure to pass your custom cast to Playwright `use` callback
+     *             use(cast)
+     *         },
+     *     },
+     * };
+     * export default config
+     * ```
+     *
+     * #### Learn more
+     * - Declaring a Serenity/JS {@apilink it|test scenario}
+     * - {@apilink SerenityFixtures}
+     */
+    actors: TestFixture<Cast, PlaywrightTestOptions & PlaywrightWorkerArgs>
+
+    /**
+     * Configures the name given to the default Serenity/JS {@apilink SerenityFixtures.actor|actor}
+     * injected into a {@apilink it|test scenario}.
+     *
+     * #### Learn more
+     * - Declaring a Serenity/JS {@apilink it|test scenario}
+     * - {@apilink SerenityFixtures}
+     */
+    defaultActorName: string;
+
+    /**
+     * Configures the {@apilink SerenityConfig.crew|stage crew members}
+     * to be instantiated in Playwright Test worker processes.
+     *
+     * :::info Did you know?
+     * By default, Serenity/JS registers a {@apilink Photographer}.whoWill({@apilink TakePhotosOfFailures}),
+     * so that any test failures are automatically accompanied by a screenshot.
+     *
+     * If you prefer a different behaviour, you can configure the `crew` with an empty array to disable taking screenshots altogether (`crew: []`),
+     * or with a {@apilink Photographer} who uses a different {@apilink PhotoTakingStrategy}, like to {@apilink TakePhotosOfInteractions}.
+     * :::
+     *
+     * #### Example
+     *
+     * ```typescript
+     * // playwright.config.ts
+     * import type { PlaywrightTestConfig } from '@serenity-js/playwright-test'
+     *
+     * const config: PlaywrightTestConfig = {
+     *     use: {
+     *         crew: [
+     *             [ '@serenity-js/web:Photographer', { strategy: 'TakePhotosOfFailures' } ]
+     *         ],
+     *     },
+     * };
+     * export default config
+     * ```
+     *
+     * #### Learn more
+     * - {@apilink SerenityConfig.crew}
+     */
+    crew: Array<ClassDescription | StageCrewMember | StageCrewMemberBuilder>;
+
+    /**
+     * Sets the {@apilink SerenityConfig.cueTimeout|cueTimeout} to a given {@apilink Duration|duration} or a numeric value in milliseconds.
+     * Defaults to **5 seconds**.
+     *
+     * #### Learn more
+     * - {@apilink SerenityConfig.cueTimeout}
+     * - {@apilink Discardable}
+     * - {@apilink Ability}
+     */
+    cueTimeout: number | Duration;
+
+    /**
+     * Playwright [BrowserContextOptions](https://playwright.dev/docs/api/class-testoptions#test-options-context-options),
+     * augmented with several convenience properties to be used with the {@apilink Ability|ability} to {@apilink BrowseTheWebWithPlaywright}.
+     *
+     * Additional convenience properties include:
+     * - {@apilink PlaywrightOptions.defaultNavigationTimeout}
+     * - {@apilink PlaywrightOptions.defaultNavigationWaitUntil}
+     * - {@apilink PlaywrightOptions.defaultTimeout}
+     *
+     * #### Using `contextOptions` with the default cast of Serenity/JS actors
+     *
+     * ```typescript
+     * // playwright.config.ts
+     * import type { PlaywrightTestConfig } from '@serenity-js/playwright-test'
+     *
+     * const config: PlaywrightTestConfig = {
+     *     use: {
+     *         contextOptions: {
+     *             defaultNavigationTimeout: 30_000,
+     *         }
+     *
+     *         // Since `actors` property is not defined,
+     *         // `contextOptions` will be passed to the default cast of Serenity/JS actors
+     *         // and injected into the ability to `BrowseTheWebWithPlaywright`
+     *         // that each actor receives.
+     *     },
+     * };
+     * export default config;
+     * ```
+     *
+     * #### Using `contextOptions` with a custom cast of Serenity/JS actors
+     *
+     * ```typescript
+     * // playwright.config.ts
+     * import type { PlaywrightTestConfig } from '@serenity-js/playwright-test'
+     *
+     * const config: PlaywrightTestConfig = {
+     *     use: {
+     *         contextOptions: {
+     *             defaultNavigationTimeout: 30_000,
+     *         }
+     *
+     *         // Custom cast of actors receives `contextOptions` with the
+     *         // additional Serenity/JS properties.
+     *         actors: ({ browser, contextOptions }, use) => {
+     *             const cast = Cast.whereEveryoneCan(
+     *                 BrowseTheWebWithPlaywright.using(browser, contextOptions),
+     *                 TakeNotes.usingAnEmptyNotepad(),
+     *             )
+     *
+     *             use(cast)
+     *         },
+     *     },
+     * };
+     * export default config;
+     * ```
+     *
+     * #### Learn more
+     * - {@apilink SerenityFixtures}
+     * - [Playwright Browser Context options](https://playwright.dev/docs/api/class-testoptions#test-options-context-options)
+     * - [Playwright Test fixtures](https://playwright.dev/docs/test-fixtures)
+     */
+    contextOptions: PlaywrightOptions;
+}

package/src/api/SerenityTestType.ts

@@ -0,0 +1,12 @@
+import { PlaywrightTestArgs, PlaywrightTestOptions, PlaywrightWorkerArgs, PlaywrightWorkerOptions, TestType } from '@playwright/test';
+
+import { SerenityFixtures } from './SerenityFixtures';
+import { SerenityOptions } from './SerenityOptions';
+
+/* eslint-disable @typescript-eslint/indent */
+export type SerenityTestType =
+    TestType<
+        PlaywrightTestArgs & PlaywrightTestOptions & Omit<SerenityOptions, 'actors'> & SerenityFixtures,
+        PlaywrightWorkerArgs & PlaywrightWorkerOptions
+    >;
+/* eslint-enable @typescript-eslint/indent */

package/src/api/index.ts

@@ -0,0 +1,5 @@
+export * from './PlaywrightTestConfig';
+export * from './SerenityFixtures';
+export * from './SerenityOptions';
+export * from './SerenityTestType';
+export * from './test-api';

package/src/{api.ts → api/test-api.ts}

@@ -1,115 +1,16 @@
-import { PlaywrightTestArgs, PlaywrightTestOptions, PlaywrightWorkerArgs, PlaywrightWorkerOptions, test as base, TestInfo, TestType } from '@playwright/test';
-import { Actor, Cast, Duration, Serenity, serenity as serenityInstance, StageCrewMember } from '@serenity-js/core';
+import { test as base, TestInfo } from '@playwright/test';
+import { Cast, Duration, serenity as serenityInstance, TakeNotes } from '@serenity-js/core';
 import { SceneFinishes, SceneTagged } from '@serenity-js/core/lib/events';
 import { BrowserTag, PlatformTag } from '@serenity-js/core/lib/model';
-import { BrowseTheWebWithPlaywright } from '@serenity-js/playwright';
+import { BrowseTheWebWithPlaywright, PlaywrightPage } from '@serenity-js/playwright';
+import { Photographer, TakePhotosOfFailures } from '@serenity-js/web';
 import * as os from 'os';
-import { JSONValue } from 'tiny-types';
+import { ensure, isFunction, JSONValue, property } from 'tiny-types';
 
-import { DomainEventBuffer, PlaywrightStepReporter, SERENITY_JS_DOMAIN_EVENTS_ATTACHMENT_CONTENT_TYPE } from './reporter';
-
-/**
- * Serenity/JS-specific [Playwright Test fixtures](https://playwright.dev/docs/test-fixtures).
- *
- * ## Example test scenario
- *
- * ```typescript
- * import { Ensure, equals } from '@serenity-js/assertions'
- * import { describe, it, test } from '@serenity-js/playwright-test'
- * import { Photographer, TakePhotosOfFailures } from '@serenity-js/web'
- *
- * describe(`Recording items`, () => {
- *
- *     test.use({
- *         defaultActorName: 'Serena',
- *         crew: [
- *             Photographer.whoWill(TakePhotosOfFailures),
- *         ],
- *     })
- *
- *     describe(`Todo List App`, () => {
- *
- *         it(`should allow me to add a todo item`, async ({ actor }) => {
- *             await actor.attemptsTo(
- *                 startWithAnEmptyList(),
- *
- *                 recordItem('Buy some milk'),
- *
- *                 Ensure.that(itemNames(), equals([
- *                     'Buy some milk',
- *                 ])),
- *             )
- *         })
- *     })
- * })
- * ```
- *
- * ## Learn more
- * - Declaring a test scenario using {@apilink it}
- * - Grouping test scenarios using {@apilink describe}
- * - [Serenity/JS + Playwright Test project template](https://github.com/serenity-js/serenity-js-playwright-test-template/)
- */
-export interface SerenityFixtures {
-
-    /**
-     * Configures the {@apilink Cast} of {@apilink SerenityConfig.actors|actors} to be used when injecting an {@apilink SerenityFixtures.actor|actor}
-     * or invoking {@apilink SerenityFixtures.actorCalled|actorCalled} in a {@apilink it|test scenario}.
-     *
-     * #### Learn more
-     * - Declaring a test scenario using {@apilink it}
-     */
-    actors: Cast;
-
-    /**
-     * Configures the {@apilink SerenityConfig.crew|stage crew}
-     */
-    crew: StageCrewMember[];
-
-    /**
-     * Configures the {@apilink SerenityConfig.cueTimeout|cueTimeout}
-     */
-    cueTimeout: Duration;
-
-    /**
-     * Retrieves the root object of the Serenity/JS framework.
-     */
-    serenity: Serenity;
-
-    /**
-     * Name and version of the operating system the Playwright Test runs on.
-     */
-    platform: { name: string, version: string };
-
-    /**
-     * Uses the provided {@apilink Cast} of {@apilink SerenityFixtures.actors|actors} to instantiate an {@apilink Actor} called `name`
-     * and inject it into a {@apilink it|test scenario}.
-     * Retrieves an existing actor if one has already been instantiated.
-     *
-     * #### Learn more
-     * - Declaring a test scenario using {@apilink it}
-     *
-     * @param name
-     */
-    actorCalled: (name: string) => Actor;
-
-    /**
-     * Configures the name given to the default {@apilink SerenityFixtures.actor|actor} injected into the {@apilink it|test scenario}.
-     *
-     * #### Learn more
-     * - Declaring a test scenario using {@apilink it}
-     */
-    defaultActorName: string;
-    /**
-     * Default {@apilink SerenityFixtures.actor|actor} injected into a {@apilink it|test scenario}.
-     *
-     * #### Learn more
-     * - {@apilink SerenityFixtures.actorCalled|actorCalled}
-     * - Declaring a test scenario using {@apilink it}
-     */
-    actor: Actor;
-}
-
-export type SerenityTestType = TestType<PlaywrightTestArgs & PlaywrightTestOptions & SerenityFixtures, PlaywrightWorkerArgs & PlaywrightWorkerOptions>;
+import { DomainEventBuffer, PlaywrightStepReporter, SERENITY_JS_DOMAIN_EVENTS_ATTACHMENT_CONTENT_TYPE } from '../reporter';
+import { SerenityFixtures } from './SerenityFixtures';
+import { SerenityOptions } from './SerenityOptions';
+import { SerenityTestType } from './SerenityTestType';
 
 /**
  * Declares a single test scenario.
@@ -163,15 +64,38 @@ export type SerenityTestType = TestType<PlaywrightTestArgs & PlaywrightTestOptio
  * ```
  *
  * ## Learn more
- * - Grouping test scenarios using {@apilink describe}
+ * - {@apilink describe|Grouping test scenarios}
  * - {@apilink SerenityFixtures}
  * - [Playwright Test `test` function](https://playwright.dev/docs/api/class-test#test-call)
  * - [Serenity/JS + Playwright Test project template](https://github.com/serenity-js/serenity-js-playwright-test-template/)
  */
-export const it: SerenityTestType = base.extend<SerenityFixtures>({
-    cueTimeout: Duration.ofSeconds(5),
-
-    crew: [],
+export const it: SerenityTestType = base.extend<Omit<SerenityOptions, 'actors'> & SerenityFixtures>({
+
+    actors: [
+        ({ browser, contextOptions }, use) =>
+            use(Cast.whereEveryoneCan(
+                BrowseTheWebWithPlaywright.using(browser, contextOptions),
+                TakeNotes.usingAnEmptyNotepad(),
+            )),
+        { option: true },
+    ],
+
+    defaultActorName: [
+        'Serena',
+        { option: true },
+    ],
+
+    cueTimeout: [
+        Duration.ofSeconds(5),
+        { option: true },
+    ],
+
+    crew: [
+        [
+            Photographer.whoWill(TakePhotosOfFailures)
+        ],
+        { option: true },
+    ],
 
     // eslint-disable-next-line no-empty-pattern
     platform: ({}, use) => {
@@ -190,7 +114,7 @@ export const it: SerenityTestType = base.extend<SerenityFixtures>({
         const domainEventBuffer = new DomainEventBuffer();
 
         serenityInstance.configure({
-            cueTimeout: cueTimeout,
+            cueTimeout: asDuration(cueTimeout),
             crew: [
                 ...crew,
                 domainEventBuffer,
@@ -225,22 +149,12 @@ export const it: SerenityTestType = base.extend<SerenityFixtures>({
         });
     },
 
-    actors: async ({ browser }, use) => {
-        await use(Cast.whereEveryoneCan(BrowseTheWebWithPlaywright.using(browser)));
-    },
-
-    defaultActorName: 'Serena',
-
-    actor: async ({ actorCalled, defaultActorName }, use) => {
-        await use(actorCalled(defaultActorName));
-    },
-
-    actorCalled: async ({ serenity, actors, browser, browserName }, use) => {
-
-        serenity.engage(actors);
+    actorCalled: async ({ serenity, actors, browser, browserName, contextOptions }, use) => {
 
         const sceneId = serenity.currentSceneId();
 
+        serenity.engage(asCast(actors));
+
         const actorCalled = serenity.theActorCalled.bind(serenity);
 
         serenity.announce(new SceneTagged(
@@ -257,8 +171,29 @@ export const it: SerenityTestType = base.extend<SerenityFixtures>({
 
         await serenityInstance.waitForNextCue();
     },
+
+    actor: async ({ actorCalled, defaultActorName }, use) => {
+        await use(actorCalled(defaultActorName));
+    },
+
+    page: async ({ actor }, use) => {
+        const page = (await BrowseTheWebWithPlaywright.as(actor).currentPage()) as PlaywrightPage;
+        const nativePage = await page.nativePage();
+
+        await use(nativePage);
+    },
 });
 
+function asDuration(maybeDuration: number | Duration): Duration {
+    return maybeDuration instanceof Duration
+        ? maybeDuration
+        : Duration.ofMilliseconds(maybeDuration);
+}
+
+function asCast(maybeCast: unknown): Cast {
+    return ensure('actors', maybeCast as Cast, property('prepare', isFunction()));
+}
+
 export const test: SerenityTestType = it;
 
 /**
@@ -305,7 +240,7 @@ export const test: SerenityTestType = it;
  * ```
  *
  * ## Learn more
- * - Declaring a test scenario using {@apilink it}
+ * - Declaring a Serenity/JS {@apilink it|test scenario}
  * - [Playwright Test `describe` function](https://playwright.dev/docs/api/class-test#test-describe-1)
  * - [Serenity/JS + Playwright Test project template](https://github.com/serenity-js/serenity-js-playwright-test-template/)
  */

package/src/index.ts

@@ -1,3 +1,2 @@
 export *  from './api';
-export *  from './PlaywrightTestConfig';
-export { SerenityReporterForPlaywrightTest as default } from './reporter';
+export { SerenityReporterForPlaywrightTest as default, SerenityReporterForPlaywrightTestConfig } from './reporter';