@itmetsam/samurai-framework 0.21.1 → 0.21.2

package/README.md

@@ -2,7 +2,9 @@
 
 A browser test framework written in TypeScript. It drives a real browser over the [WebDriver BiDi](https://www.w3.org/TR/webdriver-bidi/) protocol, with no Playwright or Puppeteer underneath. Firefox speaks BiDi itself; Chrome is driven through its own `chromedriver`, which the framework starts for you.
 
-[![CI](https://github.com/degrootsam/samurai-framework/actions/workflows/ci.yml/badge.svg)](https://github.com/degrootsam/samurai-framework/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/@itmetsam/samurai-framework)](https://www.npmjs.com/package/@itmetsam/samurai-framework)
+
+> This repository is a read-only mirror of `packages/framework` in the SAMURAI monorepo. Issues are welcome; pull requests aren't merged here. See [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ```ts
 import { expect, test } from "../api.js";
@@ -56,6 +58,8 @@ cd samurai-framework
 bun install
 ```
 
+The clone is the mirror described in [CONTRIBUTING.md](CONTRIBUTING.md). It has no lockfile of its own (the monorepo keeps one for all its packages), so `bun install` resolves the ranges in `package.json`.
+
 ### 3. Write a test
 
 Tests live in the folder `srcDir` points to (`./src/tests` in `samurai.config.ts`) and end in `.spec.ts`. This repository has one as `src/tests/example.spec.ts`:
@@ -138,7 +142,8 @@ Read it in a test as `secrets.TEST_PASSWORD`. Real environment variables win ove
 | [Running tests and reports](https://github.com/degrootsam/samurai-framework/wiki/Running-tests-and-reports) | What a run does, `report.json`, page logs, timeouts                                                   |
 | [Steps and the recorder](https://github.com/degrootsam/samurai-framework/wiki/Steps-and-the-recorder)       | The step codec, the recording engine and the recorder toolbar                                         |
 | [Embedding the framework](https://github.com/degrootsam/samurai-framework/wiki/Embedding-the-framework)     | Using the package from another app (such as the Electron UI): build, entry points, `runTests`, events |
-| [Contributing](docs/contributing.md)                                                                        | Project layout, running the framework's own tests, conventions                                        |
+| [Contributing](CONTRIBUTING.md)                                                                             | Issues and pull requests on this mirror                                                               |
+| [Developer guide](docs/contributing.md)                                                                     | Project layout, running the framework's own tests, conventions                                        |
 | [Roadmap](https://github.com/degrootsam/samurai-framework/wiki/Roadmap)                                     | What is built and what is still open                                                                  |
 
 The [documentation index](https://github.com/degrootsam/samurai-framework/wiki/Home) lists every guide by topic.

package/dist/network/network-tracker.d.ts

@@ -11,6 +11,12 @@ export interface TrackerOptions {
  * Follows the network activity of one page (its frames included): which requests are in flight,
  * and `request` / `response` / `requestfailed` events. In-flight is keyed by `request id:redirect count`,
  * so a redirect chain is one live request at a time.
+ *
+ * Chrome (chromium-bidi) reports a redirect response only once the browser has started the next hop, and it can
+ * leave out that hop's `beforeRequestSent`: when the hop's `requestWillBeSentExtraInfo` reaches it before the
+ * redirect's `requestWillBeSent`, it files the extra info under the previous hop and never announces the new one.
+ * So on Chrome a redirect keeps the chain in flight until the next hop shows itself, and a hop that first shows up
+ * with its response or error is announced then.
  */
 export declare class NetworkTracker {
     private tree;
@@ -21,13 +27,16 @@ export declare class NetworkTracker {
     private subscription;
     /**
      * Every hop that is in flight or may still be the source of a redirect, by hop key. A redirect response ends a
-     * hop's flight (`live` false) but keeps it, for the next hop's `redirectedFrom`.
+     * hop's flight (`live` false; on Chrome `answered`, live until the next hop shows) but keeps it, for the next
+     * hop's `redirectedFrom`.
      */
     private hops;
     /** Rejects a pending `waitForIdle`; each wait adds its own */
     private waiters;
     private disposed;
     private constructor();
+    /** Whether a redirect response means the next hop has already started (Chrome), see the class comment */
+    private get redirectsStartNextHop();
     static start(connector: BiDiConnector, tree: ContextTree, contextId: string, options?: TrackerOptions): Promise<NetworkTracker>;
     /** Requests currently in flight */
     get inflight(): number;
@@ -52,6 +61,13 @@ export declare class NetworkTracker {
     private owns;
     private static key;
     private onBeforeRequestSent;
+    /** Tracks a new hop and emits its `request`; the hop it was redirected from is done with */
+    private startHop;
+    /**
+     * The hop a response or error is for. A hop Chrome never announced (see the class comment) is started here,
+     * when the hop it was redirected from is known.
+     */
+    private hopOf;
     private onResponseCompleted;
     private onFetchError;
     /**

package/dist/network/network-tracker.js

@@ -12,6 +12,12 @@ const URLS_IN_MESSAGE = 5;
  * Follows the network activity of one page (its frames included): which requests are in flight,
  * and `request` / `response` / `requestfailed` events. In-flight is keyed by `request id:redirect count`,
  * so a redirect chain is one live request at a time.
+ *
+ * Chrome (chromium-bidi) reports a redirect response only once the browser has started the next hop, and it can
+ * leave out that hop's `beforeRequestSent`: when the hop's `requestWillBeSentExtraInfo` reaches it before the
+ * redirect's `requestWillBeSent`, it files the extra info under the previous hop and never announces the new one.
+ * So on Chrome a redirect keeps the chain in flight until the next hop shows itself, and a hop that first shows up
+ * with its response or error is announced then.
  */
 export class NetworkTracker {
     constructor(tree, contextId, ignore, connector) {
@@ -22,7 +28,8 @@ export class NetworkTracker {
         this.events = new EventEmitter();
         /**
          * Every hop that is in flight or may still be the source of a redirect, by hop key. A redirect response ends a
-         * hop's flight (`live` false) but keeps it, for the next hop's `redirectedFrom`.
+         * hop's flight (`live` false; on Chrome `answered`, live until the next hop shows) but keeps it, for the next
+         * hop's `redirectedFrom`.
          */
         this.hops = new Map();
         /** Rejects a pending `waitForIdle`; each wait adds its own */
@@ -31,30 +38,22 @@ export class NetworkTracker {
         this.onBeforeRequestSent = (params) => {
             if (!this.owns(params.context))
                 return;
-            const key = NetworkTracker.key(params.request, params.redirectCount);
-            const { redirectCount } = params;
-            const previousKey = `${params.request.request}:${redirectCount - 1}`;
-            const redirectedFrom = redirectCount > 0 ? (this.hops.get(previousKey)?.request ?? null) : null;
-            this.hops.delete(previousKey);
-            const request = toRequest(params.request, params.navigation, params.isBlocked, redirectedFrom);
-            if (this.ignore(request))
-                return;
-            this.hops.set(key, { request, context: params.context, live: true });
-            this.emit("request", request);
-            this.events.emit("change");
+            this.startHop(params);
         };
         this.onResponseCompleted = (params) => {
             if (!this.owns(params.context))
                 return;
             const key = NetworkTracker.key(params.request, params.redirectCount);
-            const hop = this.hops.get(key);
-            if (!hop?.live)
+            const hop = this.hopOf(params);
+            if (!hop?.live || hop.answered)
                 return;
             const { request } = hop;
             const { response } = params;
             // A redirect response keeps its request around: the next hop links back to it
             if (response.status < 300 || response.status >= 400)
                 this.hops.delete(key);
+            else if (this.redirectsStartNextHop && hasLocation(response))
+                hop.answered = true;
             else
                 hop.live = false;
             this.emit("response", {
@@ -71,11 +70,13 @@ export class NetworkTracker {
             if (!this.owns(params.context))
                 return;
             const key = NetworkTracker.key(params.request, params.redirectCount);
-            const hop = this.hops.get(key);
+            const hop = this.hopOf(params);
             if (!hop?.live)
                 return;
             this.hops.delete(key);
-            this.emit("requestfailed", Object.assign(hop.request, { errorText: params.errorText }));
+            // A hop that has its response already did not fail
+            if (!hop.answered)
+                this.emit("requestfailed", Object.assign(hop.request, { errorText: params.errorText }));
             this.events.emit("change");
         };
         /**
@@ -86,19 +87,24 @@ export class NetworkTracker {
             if (!this.owns(params.context))
                 return;
             let changed = false;
-            for (const [key, { request, context, live }] of [...this.hops]) {
+            for (const [key, { request, context, live, answered }] of [...this.hops]) {
                 if (!live || request.navigation === params.navigation)
                     continue;
                 if (!this.tree.isWithin(context, params.context))
                     continue;
                 this.hops.delete(key);
-                this.emit("requestfailed", Object.assign(request, { errorText: ABORTED_BY_NAVIGATION }));
+                if (!answered)
+                    this.emit("requestfailed", Object.assign(request, { errorText: ABORTED_BY_NAVIGATION }));
                 changed = true;
             }
             if (changed)
                 this.events.emit("change");
         };
     }
+    /** Whether a redirect response means the next hop has already started (Chrome), see the class comment */
+    get redirectsStartNextHop() {
+        return this.connector.browserName === "chrome";
+    }
     static async start(connector, tree, contextId, options = {}) {
         const tracker = new NetworkTracker(tree, contextId, options.ignore ?? (() => false), connector);
         // Listen first, then subscribe: nothing can arrive in between
@@ -189,6 +195,41 @@ export class NetworkTracker {
     static key(data, redirectCount) {
         return `${data.request}:${redirectCount}`;
     }
+    /** Tracks a new hop and emits its `request`; the hop it was redirected from is done with */
+    startHop(params) {
+        const key = NetworkTracker.key(params.request, params.redirectCount);
+        const { redirectCount } = params;
+        const previousKey = `${params.request.request}:${redirectCount - 1}`;
+        const previous = redirectCount > 0 ? this.hops.get(previousKey) : undefined;
+        this.hops.delete(previousKey);
+        const request = toRequest(params.request, params.navigation, params.isBlocked, previous?.request ?? null);
+        if (this.ignore(request)) {
+            if (previous?.live)
+                this.events.emit("change");
+            return undefined;
+        }
+        const hop = {
+            request,
+            context: params.context,
+            live: true,
+            answered: false,
+        };
+        this.hops.set(key, hop);
+        this.emit("request", request);
+        this.events.emit("change");
+        return hop;
+    }
+    /**
+     * The hop a response or error is for. A hop Chrome never announced (see the class comment) is started here,
+     * when the hop it was redirected from is known.
+     */
+    hopOf(params) {
+        const hop = this.hops.get(NetworkTracker.key(params.request, params.redirectCount));
+        if (hop || params.redirectCount === 0)
+            return hop;
+        const previousKey = `${params.request.request}:${params.redirectCount - 1}`;
+        return this.hops.has(previousKey) ? this.startHop(params) : undefined;
+    }
     /** A listener that throws must not stop the tracker or the other listeners */
     emit(event, ...args) {
         for (const listener of this.events.listeners(event)) {
@@ -201,3 +242,7 @@ export class NetworkTracker {
         }
     }
 }
+/** Whether a 3xx response says where to go next: only then does the browser follow it */
+function hasLocation(response) {
+    return response.headers.some((header) => header.name.toLowerCase() === "location");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itmetsam/samurai-framework",
-  "version": "0.21.1",
+  "version": "0.21.2",
   "description": "Browser test framework over WebDriver BiDi: auto-waiting locators, environments and secrets, a recorder, and a command line.",
   "main": "dist/api.js",
   "exports": {