@serenity-js/protractor 2.33.1 → 3.0.0-rc.11

package/src/screenplay/interactions/Wait.ts

@@ -1,267 +0,0 @@
-import { Answerable, AnswersQuestions, AssertionError, Duration, Expectation, ExpectationMet, ExpectationOutcome, Interaction, UsesAbilities } from '@serenity-js/core';
-import { formatted } from '@serenity-js/core/lib/io';
-
-import { BrowseTheWeb } from '../abilities';
-import { WaitBuilder } from './WaitBuilder';
-
-/**
- * @desc
- *  Instructs the {@link @serenity-js/core/lib/screenplay/actor~Actor} to
- *  wait before proceeding either for a set {@link @serenity-js/core/lib/model~Duration}
- *  or until a given {@link @serenity-js/core/lib/screenplay/questions~Expectation} is met.
- *
- *  Useful when a test scenario can't take advantage of automatic synchronisation between
- *  Protractor and Angular (see {@link UseAngular}), or when the application under test is animation-heavy.
- *
- * @example <caption>Example widget</caption>
- *  <!--
- *      After about 1 second, the text will change from 'Loading...' to 'Ready!'
- *  -->
- *  <h1 id="status">Loading...</h1>
- *  <script>
- *      (function () {
- *          setTimeout(function () {
- *              document.getElementById('status').textContent = 'Ready!'
- *          }, 1000);
- *      })();
- *  </script>
- *
- * @example <caption>Lean Page Object describing the widget</caption>
- *  import { Target } from '@serenity-js/protractor';
- *  import { by } from 'protractor';
- *
- *  class App {
- *      static status = Target.the('status widget')
- *          .located(by.id('status'));
- *  }
- *
- * @example <caption>Waiting for a set amount of time</caption>
- *  import { actorCalled, Duration } from '@serenity-js/core';
- *  import { BrowseTheWeb, Wait } from '@serenity-js/protractor';
- *  import { Ensure, equals } from '@serenity-js/assertions';
- *  import { protractor } from 'protractor';
- *
- *  actorCalled('Aurora')
- *      .whoCan(BrowseTheWeb.using(protractor.browser))
- *      .attemptsTo(
- *          Wait.for(Duration.ofSeconds(1.5)),
- *          Ensure.that(App.status, equals('Ready!')),
- *      );
- *
- *  // Please note that while the above implementation works,
- *  // this approach is inefficient because at best
- *  // the actor might wait too long and at worst the test
- *  // might become "flaky" if any external interference
- *  // (like network glitches, animations taking a bit too long etc.)
- *  // makes the actor wait not long enough.
- *
- * @example <caption>Waiting until a condition is met</caption>
- *  import { actorCalled } from '@serenity-js/core';
- *  import { BrowseTheWeb, Wait, Text } from '@serenity-js/protractor';
- *  import { equals } from '@serenity-js/assertions';
- *  import { protractor } from 'protractor';
- *
- *  actorCalled('Aurora')
- *      .whoCan(BrowseTheWeb.using(protractor.browser))
- *      .attemptsTo(
- *          Wait.until(Text.of(App.status), equals('Ready!')),
- *          // app is ready, proceed with the scenario
- *      );
- *
- *  // Wait.until makes the Actor keep asking a Question,
- *  // in this case Text.of(App.status), until the answer meets
- *  // the expectation, or a timeout expires (default: 5s).
- *  //
- *  // Please note that both Ensure and Wait can be used with
- *  // the same expectations, like `equals`.
- *
- * @example <caption>Changing the default timeout</caption>
- *  import { actorCalled, Duration } from '@serenity-js/core';
- *  import { BrowseTheWeb, Wait, Text } from '@serenity-js/protractor';
- *  import { equals } from '@serenity-js/assertions';
- *  import { protractor } from 'protractor';
- *
- *  actorCalled('Aurora')
- *      .whoCan(BrowseTheWeb.using(protractor.browser))
- *      .attemptsTo(
- *          Wait.upTo(Duration.ofSeconds(3))
- *              .until(Text.of(App.status), equals('Ready!')),
- *          // app is ready, proceed with the scenario
- *      );
- *
- * @see {@link BrowseTheWeb}
- * @see {@link Target}
- * @see {@link Text}
- * @see {@link @serenity-js/assertions~Ensure}
- * @see {@link @serenity-js/assertions/lib/expectations~equals}
- * @see {@link @serenity-js/core/lib/model~Duration}
- *
- * @extends {@serenity-js/core/lib/screenplay~Interaction}
- */
-export class Wait {
-
-    /**
-     * @desc
-     *  Default timeout of 5 seconds used with {@link Wait.until}.
-     *
-     * @type {@serenity-js/core~Duration}
-     */
-    static readonly Default_Timeout = Duration.ofSeconds(5);
-
-    /**
-     * @desc
-     *  Instantiates a version of this {@link @serenity-js/core/lib/screenplay~Interaction}
-     *  configured to wait for a set duration.
-     *
-     * @param {Answerable<Duration>} duration
-     *  A set duration the {@link @serenity-js/core/lib/screenplay/actor~Actor} should wait for
-     *  before proceeding
-     *
-     * @returns {@serenity-js/core/lib/screenplay~Interaction}
-     */
-    static for(duration: Answerable<Duration>): Interaction {
-        return new WaitFor(duration);
-    }
-
-    /**
-     * @desc
-     *  Instantiates a version of this {@link @serenity-js/core/lib/screenplay~Interaction}
-     *  configured to wait until the answer to the question (`actual`) meets the `expectation`,
-     *  or a custom timeout expires.
-     *
-     * @param {Duration} duration
-     *  Custom timeout to override {@link Wait.Default_Timeout}
-     *
-     * @returns {WaitBuilder}
-     */
-    static upTo(duration: Duration): WaitBuilder {
-        return {
-            until: <Actual>(actual: Answerable<Actual>, expectation: Expectation<any, Actual>): Interaction =>
-                new WaitUntil(actual, expectation, duration),
-        };
-    }
-
-    /**
-     * @desc
-     *  Instantiates a version of this {@link @serenity-js/core/lib/screenplay~Interaction}
-     *  configured to wait until the answer to the question (`actual`) meets the `expectation`,
-     *  or a {@link Wait.Default_Timeout} expires.
-     *
-     * @param {Answerable<Actual>} actual
-     *  A {@link @serenity-js/core/lib/screenplay~Question}
-     *  that the {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     *  will keep asking until the answer meets
-     *  the {@link @serenity-js/core/lib/screenplay/questions~Expectation} provided
-     *
-     * @param {@serenity-js/core/lib/screenplay/questions~<any,Actual>} expectation
-     *  An {@link @serenity-js/core/lib/screenplay/questions~Expectation} to be met before proceeding
-     *
-     * @returns {@serenity-js/core/lib/screenplay~Interaction}
-     */
-    static until<Actual>(actual: Answerable<Actual>, expectation: Expectation<any, Actual>): Interaction {
-        return new WaitUntil(actual, expectation, Wait.Default_Timeout);
-    }
-}
-
-/**
- * @package
- */
-class WaitFor extends Interaction {
-    constructor(private readonly duration: Answerable<Duration>) {
-        super();
-    }
-
-    /**
-     * @desc
-     *  Makes the provided {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     *  perform this {@link @serenity-js/core/lib/screenplay~Interaction}.
-     *
-     * @param {UsesAbilities & AnswersQuestions} actor
-     * @returns {Promise<void>}
-     *
-     * @see {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~UsesAbilities}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~AnswersQuestions}
-     */
-    performAs(actor: UsesAbilities & AnswersQuestions): PromiseLike<void> {
-        return actor.answer(this.duration)
-            .then(duration => BrowseTheWeb.as(actor).sleep(duration.inMilliseconds()));
-    }
-
-    /**
-     * @desc
-     *  Generates a description to be used when reporting this {@link @serenity-js/core/lib/screenplay~Activity}.
-     *
-     * @returns {string}
-     */
-    toString(): string {
-        return formatted`#actor waits for ${ this.duration }`;
-    }
-}
-
-/**
- * @package
- */
-class WaitUntil<Actual> extends Interaction {
-    constructor(
-        private readonly actual: Answerable<Actual>,
-        private readonly expectation: Expectation<any, Actual>,
-        private readonly timeout: Duration,
-    ) {
-        super();
-    }
-
-    /**
-     * @desc
-     *  Makes the provided {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     *  perform this {@link @serenity-js/core/lib/screenplay~Interaction}.
-     *
-     * @param {UsesAbilities & AnswersQuestions} actor
-     * @returns {Promise<void>}
-     *
-     * @see {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~UsesAbilities}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~AnswersQuestions}
-     */
-    performAs(actor: UsesAbilities & AnswersQuestions): PromiseLike<void> {
-        const
-            actual      = this.actual,
-            expectation = this.expectation.answeredBy(actor);
-
-        let expectationOutcome: ExpectationOutcome<any, Actual>;
-
-        return BrowseTheWeb.as(actor)
-            .wait(function () {
-                return actor.answer(actual)
-                    .then(act => expectation(act))
-                    .then(outcome => {
-                        expectationOutcome = outcome;
-
-                        return outcome instanceof ExpectationMet;
-                    });
-            }, this.timeout.inMilliseconds())
-            .then(_ => void 0)
-            .catch(error => {
-                if (expectationOutcome) {
-                    throw new AssertionError(
-                        `Waited ${ this.timeout.toString() } for ${ formatted `${ this.actual }` } to ${ this.expectation.toString() }`,
-                        expectationOutcome.expected,
-                        expectationOutcome.actual,
-                        error,
-                    );
-                }
-
-                throw error;
-            });
-    }
-
-    /**
-     * @desc
-     *  Generates a description to be used when reporting this {@link @serenity-js/core/lib/screenplay~Activity}.
-     *
-     * @returns {string}
-     */
-    toString(): string {
-        return formatted`#actor waits up to ${ this.timeout } until ${ this.actual } does ${ this.expectation }`;
-    }
-}

package/src/screenplay/interactions/WaitBuilder.ts

@@ -1,35 +0,0 @@
-import { Answerable, Expectation } from '@serenity-js/core';
-import { Interaction } from '@serenity-js/core/lib/screenplay';
-
-/**
- * @desc
- *  Fluent interface to make the instantiation of
- *  the {@link @serenity-js/core/lib/screenplay~Interaction}
- *  to {@link Wait} more readable.
- *
- * @see {@link Wait}
- *
- * @interface
- */
-export interface WaitBuilder {
-
-    /**
-     * @desc
-     *  Instantiates an {@link @serenity-js/core/lib/screenplay~Interaction}
-     *  to {@link Wait}.
-     *
-     * @param {Answerable<Actual>} actual
-     *  A {@link @serenity-js/core/lib/screenplay~Question}
-     *  that the {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     *  will keep asking until the answer meets
-     *  the {@link @serenity-js/core/lib/screenplay/questions~Expectation} provided
-     *
-     * @param {@serenity-js/core/lib/screenplay/questions~Expectation<any,Actual>} expectation
-     *  An {@link @serenity-js/assertions~Expectation} to be met before proceeding
-     *
-     * @returns {Interaction}
-     *
-     * @see {@link Target}
-     */
-    until: <Actual>(actual: Answerable<Actual>, expectation: Expectation<any, Actual>) => Interaction;
-}

package/src/screenplay/questions/Attribute.ts

@@ -1,67 +0,0 @@
-import { Answerable, AnswersQuestions, Question, UsesAbilities } from '@serenity-js/core';
-import { formatted } from '@serenity-js/core/lib/io';
-import { ElementFinder } from 'protractor';
-
-import { BrowseTheWeb } from '../abilities';
-import { withAnswerOf } from '../withAnswerOf';
-
-// todo: it might be better to swap the order of arguments
-//  - Attribute.called('href').of(link) to make it work with ArrayListFilter
-
-export class Attribute extends Question<Promise<string>> {
-    /**
-     * @param {Question<ElementFinder> | ElementFinder} target
-     * @returns {AttributeBuilder}
-     */
-    static of(target: Question<ElementFinder> | ElementFinder): AttributeBuilder {
-        return {
-            called: (name: Answerable<string>) => new Attribute(target, name),
-        };
-    }
-
-    constructor(
-        private readonly target: Question<ElementFinder> | ElementFinder,
-        private readonly name: Answerable<string>,
-    ) {
-        super(formatted `the value of the ${ name } attribute of ${ target}`);
-    }
-
-    /**
-     * @desc
-     *  Makes the provided {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     *  answer this {@link @serenity-js/core/lib/screenplay~Question}.
-     *
-     * @param {AnswersQuestions & UsesAbilities} actor
-     * @returns {Promise<void>}
-     *
-     * @see {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~AnswersQuestions}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~UsesAbilities}
-     */
-    answeredBy(actor: AnswersQuestions & UsesAbilities): Promise<string> {
-        return actor.answer(this.name)
-            .then(name => withAnswerOf(actor, this.target, (elf: ElementFinder) =>
-                elf.getAttribute(name).then(value => {
-                    return value !== null               // workaround for bug in Chromium 91 - https://bugs.chromium.org/p/chromium/issues/detail?id=1205107&start=300
-                        ? value
-                        : BrowseTheWeb.as(actor).executeFunction(
-                            /* istanbul ignore next */
-                            function getAttribute(webElement, attributeName: string) {
-                                // eslint-disable-next-line no-var
-                                var value = (webElement[attributeName] || webElement.getAttribute(attributeName));
-                                if (value !== null && value !== undefined) {
-                                    return '' + value;
-                                }
-                                return value;
-                            },
-                            elf.getWebElement(),
-                            name
-                        );
-                })
-            ));
-    }
-}
-
-interface AttributeBuilder {
-    called(name: Answerable<string>): Attribute;
-}

package/src/screenplay/questions/Browser.ts

@@ -1,55 +0,0 @@
-import { Question } from '@serenity-js/core';
-import { logging } from 'selenium-webdriver';
-
-import { promiseOf } from '../../promiseOf';
-import { BrowseTheWeb } from '../abilities';
-
-export class Browser {
-
-    /**
-     * @desc
-     *  Creates a {@link Question} that reads the entries of the browser log
-     *  so that they can be asserted on.
-     *
-     *  Please note that in order to ensure that the automated test has access to the browser log,
-     *  Protractor needs to be configured with the desired logging level, as per the example below.
-     *
-     * @example <caption>Enabling Protractor browser logging</caption>
-     * // protractor.conf.js
-     * exports.config = {
-     *   capabilities: {
-     *     loggingPrefs: {
-     *         // available options: OFF, SEVERE, WARNING, INFO, CONFIG, FINE, FINER, FINEST, ALL
-     *         browser: 'SEVERE'
-     *     },
-     *   }
-     * }
-     *
-     * @example <caption>Ensure the app didn't log anything to the console during the test</caption>
-     * import { Actor, BrowseTheWeb, Browser } from '@serenity-js/core';
-     * import { Ensure, property, equals } from '@serenity-js/assertions';
-     *
-     * actor.attemptsTo(
-     *   Ensure.that(Browser.log(), property('length', equals(0))),
-     * );
-     *
-     * @example <caption>Mark the test as "compromised" if the server responds with a 500 to any AJAX request during the test</caption>
-     * import { Actor, BrowseTheWeb, Browser, TestCompromisedError } from '@serenity-js/core';
-     * import { Ensure, property, equals, not, contrainAtLeastOneItemThat } from '@serenity-js/assertions'
-     *
-     * actor.attemptsTo(
-     *   Ensure.that(Browser.log(),
-     *     not(contrainAtLeastOneItemThat(
-     *       property('message', includes('the server responded with a status of 500'))
-     *     ))
-     *   ).otherwiseFailWith(TestCompromisedError, 'The server is down'),
-     * );
-     *
-     * @see https://github.com/SeleniumHQ/selenium/wiki/DesiredCapabilities#loggingpreferences-json-object
-     * @returns {Question<Promise<logging.Entry[]>>}
-     */
-    static log(): Question<Promise<logging.Entry[]>> {
-        return Question.about<Promise<logging.Entry[]>>(`browser log`, actor =>
-            promiseOf(BrowseTheWeb.as(actor).manage().logs().get('browser')));
-    }
-}

package/src/screenplay/questions/CSSClasses.ts

@@ -1,121 +0,0 @@
-import { AnswersQuestions, MetaQuestion, Question, UsesAbilities } from '@serenity-js/core';
-import { formatted } from '@serenity-js/core/lib/io';
-import { ElementFinder } from 'protractor';
-
-import { Attribute } from './Attribute';
-import { TargetNestedElement } from './targets';
-
-/**
- * @desc
- *  Resolves to an array of [CSS classes](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes#attr-class)
- *  of a given {@link WebElement}, represented by {@link ElementFinder} or `Question<ElementFinder>`.
- *
- * @example <caption>Example widget</caption>
- *  <ul id="shopping-list" class="active favourite">
- *    <li class="bought">Coffee<li>
- *    <li class="buy">Honey<li>
- *    <li class="buy">Chocolate<li>
- *  </ul>
- *
- * @example <caption>Retrieve CSS classes of a given WebElement</caption>
- *  import { actorCalled } from '@serenity-js/core';
- *  import { Ensure, equals } from '@serenity-js/assertions';
- *  import { BrowseTheWeb, CSSClasses, Target } from '@serenity-js/protractor';
- *  import { by } from 'protractor';
- *
- *  const shoppingList = () =>
- *      Target.the('shopping list').located(by.id('shopping-list'))
- *
- *  actorCalled('Lisa')
- *      .whoCan(BrowseTheWeb.using(protractor.browser))
- *      .attemptsTo(
- *          Ensure.that(CSSClasses.of(shoppingList()), equals([ 'active', 'favourite' ])),
- *      )
- *
- * @example <caption>Find WebElements with a given class</caption>
- *  import { actorCalled } from '@serenity-js/core';
- *  import { Ensure, equals } from '@serenity-js/assertions';
- *  import { BrowseTheWeb, CSSClasses, Target } from '@serenity-js/protractor';
- *  import { by } from 'protractor';
- *
- *  class ShoppingList {
- *      static items = () =>
- *          Target.all('items')
- *              .located(by.css('#shopping-list li'))
- *
- *      static outstandingItems = () =>
- *          ShoppingList.items
- *              .where(CSSClasses, contain('buy'))
- *  }
- *
- *  actorCalled('Lisa')
- *      .whoCan(BrowseTheWeb.using(protractor.browser))
- *      .attemptsTo(
- *          Ensure.that(
- *              Text.ofAll(ShoppingList.outstandingItems()),
- *              equals([ 'Honey', 'Chocolate' ])
- *          ),
- *      )
- *
- * @extends {@serenity-js/core/lib/screenplay~Question}
- * @implements {@serenity-js/core/lib/screenplay/questions~MetaQuestion}
- */
-export class CSSClasses
-    extends Question<Promise<string[]>>
-    implements MetaQuestion<Question<ElementFinder> | ElementFinder, Promise<string[]>>
-{
-    /**
-     * @param {Question<ElementFinder> | ElementFinder} target
-     * @returns {CSSClasses}
-     */
-    static of(target: Question<ElementFinder> | ElementFinder): CSSClasses {
-        return new CSSClasses(target);
-    }
-
-    /**
-     * @param {Question<ElementFinder> | ElementFinder} target
-     */
-    constructor(private readonly target: Question<ElementFinder> | ElementFinder) {
-        super(formatted `CSS classes of ${ target}`);
-    }
-
-    /**
-     * @desc
-     *  Resolves to an array of CSS classes of the `target` element,
-     *  located in the context of a `parent` element.
-     *
-     * @param {Question<ElementFinder> | ElementFinder} parent
-     * @returns {Question<Promise<string[]>>}
-     *
-     * @see {@link Target.all}
-     * @see {@link @serenity-js/core/lib/screenplay/questions~MetaQuestion}
-     */
-    of(parent: Question<ElementFinder> | ElementFinder): Question<Promise<string[]>> {
-        return new CSSClasses(new TargetNestedElement(parent, this.target));
-    }
-
-    /**
-     * @desc
-     *  Makes the provided {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     *  answer this {@link @serenity-js/core/lib/screenplay~Question}.
-     *
-     * @param {AnswersQuestions & UsesAbilities} actor
-     * @returns {Promise<void>}
-     *
-     * @see {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~AnswersQuestions}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~UsesAbilities}
-     */
-    answeredBy(actor: AnswersQuestions & UsesAbilities): Promise<string[]> {
-        return Attribute.of(this.target).called('class').answeredBy(actor)
-            .then(value => {
-                return typeof value !== 'string'
-                    ? []
-                    : value
-                        .replace(/\s+/, ' ')
-                        .trim()
-                        .split(' ')
-                        .filter(cssClass => !!cssClass);
-            });
-    }
-}

package/src/screenplay/questions/Cookie.ts

@@ -1,70 +0,0 @@
-/* eslint-disable unicorn/consistent-function-scoping */
-import { Answerable, AnswersQuestions, Question, Transform, UsesAbilities } from '@serenity-js/core';
-import { IWebDriverOptionsCookie } from 'selenium-webdriver';
-
-import { BrowseTheWeb } from '../abilities';
-
-export class Cookie {
-    static valueOf(cookieName: Answerable<string>): Question<Promise<string>> {
-        return Transform.the(new CookieDetails(cookieName), details => details && details.value)
-            .as(`the value of the "${ cookieName }" cookie`);
-    }
-
-    static pathOf(cookieName: Answerable<string>): Question<Promise<string>> {
-        return Transform.the(new CookieDetails(cookieName), details => details && details.path)
-            .as(`the path of the "${ cookieName }" cookie`);
-    }
-
-    static domainOf(cookieName: string): Question<Promise<string>> {
-        return new CookieDetails(cookieName)
-            .map(actor => details => details?.domain)
-            .describedAs(`the domain of the "${ cookieName }" cookie`);
-    }
-
-    static isHTTPOnly(cookieName: string): Question<Promise<boolean>> {
-        return new CookieDetails(cookieName)
-            .map(actor => details => details && !! details.httpOnly)
-            .describedAs(`the HTTP-only status of the "${ cookieName }" cookie`);
-    }
-
-    static isSecure(cookieName: string): Question<Promise<boolean>> {
-        return new CookieDetails(cookieName)
-            .map(actor => details => details && !! details.secure)
-            .describedAs(`the "secure" status of the "${ cookieName }" cookie`);
-    }
-
-    static expiryDateOf(cookieName: string): Question<Promise<Date>> {
-        return new CookieDetails(cookieName)
-            .map(actor => details =>
-                details?.expiry && new Date(Number(details.expiry) * 1000) // expiry date coming from webdriver is expressed in seconds
-            )
-            .describedAs(`the expiry date of the "${ cookieName }" cookie`);
-    }
-}
-
-/**
- * @package
- */
-class CookieDetails extends Question<Promise<IWebDriverOptionsCookie>> {
-    constructor(private readonly name: Answerable<string>) {
-        super(`the details of the "${ name } cookie`);
-    }
-
-    /**
-     * @desc
-     *  Makes the provided {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     *  answer this {@link @serenity-js/core/lib/screenplay~Question}.
-     *
-     * @param {AnswersQuestions & UsesAbilities} actor
-     * @returns {Promise<void>}
-     *
-     * @see {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~AnswersQuestions}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~UsesAbilities}
-     */
-    answeredBy(actor: AnswersQuestions & UsesAbilities): Promise<IWebDriverOptionsCookie> {
-        return actor.answer(this.name)
-            .then(name => BrowseTheWeb.as(actor).manage().getCookie(name))
-            .then(details => details ? details : undefined);
-    }
-}

package/src/screenplay/questions/LastScriptExecution.ts

@@ -1,21 +0,0 @@
-import { Question } from '@serenity-js/core';
-
-import { BrowseTheWeb } from '../abilities';
-
-/**
- * @desc
- *  Returns the result of last script executed via {@link ExecuteScript}
- */
-export class LastScriptExecution {
-
-    /**
-     * @desc
-     *  Enables asserting on the result of a function executed via {@link ExecuteScript}.
-     *
-     * @returns {Question<R>}
-     */
-    static result<R>(): Question<R> {
-        return Question.about(`last script execution result`, actor =>
-            BrowseTheWeb.as(actor).getLastScriptExecutionResult());
-    }
-}