feat: generate "X-Request-ID" header for each browser request

gemini-testing · Dec 25, 2023 · b5a8ae4 · b5a8ae4
1 parent 2abd043
commit b5a8ae4
Show file tree

Hide file tree

Showing 23 changed files with 248 additions and 98 deletions.
diff --git a/src/browser-pool/basic-pool.js b/src/browser-pool/basic-pool.js
@@ -23,8 +23,7 @@ module.exports = class BasicPool extends Pool {
     }
 
     async getBrowser(id, opts = {}) {
-        const { version } = opts;
-        const browser = Browser.create(this._config, id, version);
+        const browser = Browser.create(this._config, { ...opts, id });
 
         try {
             await browser.init();

diff --git a/src/browser/browser.js b/src/browser/browser.js
@@ -1,5 +1,6 @@
 "use strict";
 
+const crypto = require("crypto");
 const _ = require("lodash");
 const { SAVE_HISTORY_MODE } = require("../constants/config");
 const history = require("./history");
@@ -19,13 +20,14 @@ const CUSTOM_SESSION_OPTS = [
 ];
 
 module.exports = class Browser {
-    static create(config, id, version) {
-        return new this(config, id, version);
+    static create(config, opts) {
+        return new this(config, opts);
     }
 
-    constructor(config, id, version) {
-        this.id = id;
-        this.version = version;
+    constructor(config, opts) {
+        this.id = opts.id;
+        this.version = opts.version;
+        this.testXReqId = opts.testXReqId;
 
         this._config = config.forBrowser(this.id);
         this._debug = config.system.debug;
@@ -82,7 +84,15 @@ module.exports = class Browser {
 
     _getSessionOptsFromConfig(optNames = CUSTOM_SESSION_OPTS) {
         return optNames.reduce((options, optName) => {
-            if (!_.isNull(this._config[optName])) {
+            if (optName === "transformRequest") {
+                options[optName] = req => {
+                    if (!req.headers["X-Request-ID"]) {
+                        req.headers["X-Request-ID"] = `${this.testXReqId}_${crypto.randomUUID()}`;
+                    }
+
+                    return !_.isNull(this._config[optName]) ? this._config[optName](req) : req;
+                };
+            } else if (!_.isNull(this._config[optName])) {
                 options[optName] = this._config[optName];
             }
 

diff --git a/src/browser/existing-browser.js b/src/browser/existing-browser.js
@@ -19,14 +19,14 @@ const { isSupportIsolation } = require("../utils/browser");
 const OPTIONAL_SESSION_OPTS = ["transformRequest", "transformResponse"];
 
 module.exports = class ExistingBrowser extends Browser {
-    static create(config, id, version, emitter) {
-        return new this(config, id, version, emitter);
+    static create(config, opts) {
+        return new this(config, opts);
     }
 
-    constructor(config, id, version, emitter) {
-        super(config, id, version);
+    constructor(config, opts) {
+        super(config, opts);
 
-        this._emitter = emitter;
+        this._emitter = opts.emitter;
         this._camera = Camera.create(this._config.screenshotMode, () => this._takeScreenshot());
 
         this._meta = this._initMeta();
@@ -166,12 +166,17 @@ module.exports = class ExistingBrowser extends Browser {
     }
 
     _initMeta() {
-        return {
+        const meta = {
             pid: process.pid,
             browserVersion: this.version,
-            "X-Request-ID": this._config.headers["X-Request-ID"],
             ...this._config.meta,
         };
+
+        if (!meta.testXReqId && !_.get(this._config.headers, "X-Request-ID")) {
+            meta.testXReqId = this.testXReqId;
+        }
+
+        return meta;
     }
 
     _takeScreenshot() {

diff --git a/src/browser/new-browser.js b/src/browser/new-browser.js
@@ -31,8 +31,8 @@ const headlessBrowserOptions = {
 };
 
 module.exports = class NewBrowser extends Browser {
-    constructor(config, id, version) {
-        super(config, id, version);
+    constructor(config, opts) {
+        super(config, opts);
 
         signalHandler.on("exit", () => this.quit());
     }

diff --git a/src/runner/browser-agent.js b/src/runner/browser-agent.js
@@ -1,11 +1,11 @@
 "use strict";
 
 module.exports = class BrowserAgent {
-    static create(id, version, pool) {
-        return new this(id, version, pool);
+    static create(opts = {}) {
+        return new this(opts);
     }
 
-    constructor(id, version, pool) {
+    constructor({ id, version, pool }) {
         this.browserId = id;
 
         this._version = version;

diff --git a/src/runner/browser-runner.ts b/src/runner/browser-runner.ts
@@ -60,7 +60,11 @@ export class BrowserRunner extends Runner {
     }
 
     private async _runTest(test: Test): Promise<void> {
-        const browserAgent = BrowserAgent.create(this._browserId, test.browserVersion, this.browserPool);
+        const browserAgent = BrowserAgent.create({
+            id: this._browserId,
+            version: test.browserVersion,
+            pool: this.browserPool,
+        });
         const runner = TestRunner.create(test, this.config, browserAgent);
 
         runner.on(MasterEvents.TEST_BEGIN, (test: Test) => this.suiteMonitor.testBegin(test));

diff --git a/src/runner/test-runner/regular-test-runner.js b/src/runner/test-runner/regular-test-runner.js
@@ -1,5 +1,6 @@
 "use strict";
 
+const crypto = require("crypto");
 const _ = require("lodash");
 const { Runner } = require("../runner");
 const logger = require("../../utils/logger");
@@ -64,6 +65,7 @@ module.exports = class RegularTestRunner extends Runner {
             sessionCaps: this._browser.capabilities,
             sessionOpts: this._browser.publicAPI.options,
             file: this._test.file,
+            testXReqId: this._browser.testXReqId,
         });
     }
 
@@ -80,7 +82,7 @@ module.exports = class RegularTestRunner extends Runner {
 
     async _getBrowser() {
         try {
-            this._browser = await this._browserAgent.getBrowser();
+            this._browser = await this._browserAgent.getBrowser({ testXReqId: crypto.randomUUID() });
             this._test.sessionId = this._browser.sessionId;
 
             return this._browser;

diff --git a/src/worker/hermione.ts b/src/worker/hermione.ts
@@ -11,6 +11,7 @@ export interface WorkerRunTestOpts {
     sessionId: string;
     sessionCaps: WdioBrowser["capabilities"];
     sessionOpts: WdioBrowser["options"];
+    testXReqId: string;
 }
 
 export interface AssertViewResultsSuccess {

diff --git a/src/worker/runner/browser-agent.js b/src/worker/runner/browser-agent.js
@@ -1,24 +1,25 @@
 "use strict";
 
 module.exports = class BrowserAgent {
-    static create(browserId, browserVersion, pool) {
-        return new BrowserAgent(browserId, browserVersion, pool);
+    static create(opts) {
+        return new this(opts);
     }
 
-    constructor(browserId, browserVersion, pool) {
-        this.browserId = browserId;
-        this.browserVersion = browserVersion;
+    constructor({ id, version, pool }) {
+        this.browserId = id;
+        this.browserVersion = version;
 
         this._pool = pool;
     }
 
-    getBrowser({ sessionId, sessionCaps, sessionOpts }) {
+    getBrowser({ sessionId, sessionCaps, sessionOpts, testXReqId }) {
         return this._pool.getBrowser({
             browserId: this.browserId,
             browserVersion: this.browserVersion,
             sessionId,
             sessionCaps,
             sessionOpts,
+            testXReqId,
         });
     }
 

diff --git a/src/worker/runner/browser-pool.js b/src/worker/runner/browser-pool.js
@@ -16,8 +16,13 @@ module.exports = class BrowserPool {
         this._calibrator = new Calibrator();
     }
 
-    async getBrowser({ browserId, browserVersion, sessionId, sessionCaps, sessionOpts }) {
-        const browser = Browser.create(this._config, browserId, browserVersion, this._emitter);
+    async getBrowser({ browserId, browserVersion, sessionId, sessionCaps, sessionOpts, testXReqId }) {
+        const browser = Browser.create(this._config, {
+            id: browserId,
+            version: browserVersion,
+            testXReqId,
+            emitter: this._emitter,
+        });
 
         try {
             await browser.init({ sessionId, sessionCaps, sessionOpts }, this._calibrator);

diff --git a/src/worker/runner/index.js b/src/worker/runner/index.js
@@ -27,12 +27,12 @@ module.exports = class Runner extends AsyncEmitter {
         ]);
     }
 
-    async runTest(fullTitle, { browserId, browserVersion, file, sessionId, sessionCaps, sessionOpts }) {
+    async runTest(fullTitle, { browserId, browserVersion, file, sessionId, sessionCaps, sessionOpts, testXReqId }) {
         const tests = await this._testParser.parse({ file, browserId });
         const test = tests.find(t => t.fullTitle() === fullTitle);
-        const browserAgent = BrowserAgent.create(browserId, browserVersion, this._browserPool);
+        const browserAgent = BrowserAgent.create({ id: browserId, version: browserVersion, pool: this._browserPool });
         const runner = TestRunner.create(test, this._config.forBrowser(browserId), browserAgent);
 
-        return runner.run({ sessionId, sessionCaps, sessionOpts });
+        return runner.run({ sessionId, sessionCaps, sessionOpts, testXReqId });
     }
 };
diff --git a/src/worker/runner/test-runner/index.js b/src/worker/runner/test-runner/index.js
@@ -22,14 +22,14 @@ module.exports = class TestRunner {
         this._browserAgent = browserAgent;
     }
 
-    async run({ sessionId, sessionCaps, sessionOpts }) {
+    async run({ sessionId, sessionCaps, sessionOpts, testXReqId }) {
         const test = this._test;
         const hermioneCtx = test.hermioneCtx || {};
 
         let browser;
 
         try {
-            browser = await this._browserAgent.getBrowser({ sessionId, sessionCaps, sessionOpts });
+            browser = await this._browserAgent.getBrowser({ sessionId, sessionCaps, sessionOpts, testXReqId });
         } catch (e) {
             throw Object.assign(e, { hermioneCtx });
         }

diff --git a/test/src/browser-pool/basic-pool.js b/test/src/browser-pool/basic-pool.js
@@ -33,13 +33,13 @@ describe("browser-pool/basic-pool", () => {
 
         await mkPool_({ config }).getBrowser("broId");
 
-        assert.calledWith(Browser.create, config, "broId");
+        assert.calledWith(Browser.create, config, { id: "broId" });
     });
 
     it("should create new browser with specified version when requested", async () => {
         await mkPool_().getBrowser("broId", { version: "1.0" });
 
-        assert.calledWith(Browser.create, sinon.match.any, "broId", "1.0");
+        assert.calledWith(Browser.create, sinon.match.any, { id: "broId", version: "1.0" });
     });
 
     it("should init browser", async () => {

diff --git a/test/src/browser/existing-browser.js b/test/src/browser/existing-browser.js
@@ -1,6 +1,7 @@
 "use strict";
 
 const { EventEmitter } = require("events");
+const crypto = require("crypto");
 const _ = require("lodash");
 const Promise = require("bluebird");
 const webdriverio = require("webdriverio");
@@ -56,7 +57,7 @@ describe("ExistingBrowser", () => {
         it("should set emitter", () => {
             const emitter = new EventEmitter();
 
-            const browser = mkBrowser_({}, "bro", null, emitter);
+            const browser = mkBrowser_({}, { emitter });
 
             assert.deepEqual(browser.emitter, emitter);
         });
@@ -69,7 +70,7 @@ describe("ExistingBrowser", () => {
             });
 
             it("should extend meta-info with browserVersion by default", () => {
-                const browser = mkBrowser_({}, "bro-id", "10.1");
+                const browser = mkBrowser_({}, { id: "bro-id", version: "10.1" });
 
                 assert.propertyVal(browser.meta, "browserVersion", "10.1");
             });
@@ -79,6 +80,26 @@ describe("ExistingBrowser", () => {
 
                 assert.propertyVal(browser.meta, "k1", "v1");
             });
+
+            describe("testXReqId field", () => {
+                it("should not override if field is already exists in meta config", () => {
+                    const browser = mkBrowser_({ meta: { testXReqId: "54321" } }, { testXReqId: "12345" });
+
+                    assert.propertyVal(browser.meta, "testXReqId", "54321");
+                });
+
+                it('should not add if "X-Request-ID" is specified in header config', () => {
+                    const browser = mkBrowser_({ headers: { "X-Request-ID": "54321" } }, { testXReqId: "12345" });
+
+                    assert.isUndefined(browser.meta.testXReqId);
+                });
+
+                it('should extend meta-info with "testXReqId"', () => {
+                    const browser = mkBrowser_({}, { testXReqId: "12345" });
+
+                    assert.propertyVal(browser.meta, "testXReqId", "12345");
+                });
+            });
         });
 
         describe("Camera", () => {
@@ -136,21 +157,61 @@ describe("ExistingBrowser", () => {
             assert.calledWithMatch(webdriverio.attach, { foo: "bar" });
         });
 
-        it('should attach to browser with "transform*" options from browser config', async () => {
-            const transformRequestStub = sinon.stub();
-            const transformResponseStub = sinon.stub();
+        describe("transformRequest option", () => {
+            beforeEach(() => {
+                sandbox.stub(crypto, "randomUUID").returns("00000");
+            });
+
+            it('should not add "X-Request-ID" header if it is already exists in request', async () => {
+                crypto.randomUUID.returns("67890");
+                const testXReqId = "12345";
+                const request = { headers: { "X-Request-ID": "100500" } };
 
-            await initBrowser_(
-                mkBrowser_({
-                    transformRequest: transformRequestStub,
-                    transformResponse: transformResponseStub,
-                }),
-            );
+                await initBrowser_(mkBrowser_({}, { testXReqId }));
 
-            assert.calledOnce(webdriverio.attach);
-            assert.calledWithMatch(webdriverio.attach, {
-                transformRequest: transformRequestStub,
-                transformResponse: transformResponseStub,
+                const { transformRequest } = webdriverio.attach.lastCall.args[0];
+                transformRequest(request);
+
+                assert.equal(request.headers["X-Request-ID"], "100500");
+            });
+
+            it('should add "X-Request-ID" header if it is not exists in request', async () => {
+                crypto.randomUUID.returns("67890");
+                const testXReqId = "12345";
+                const request = { headers: {} };
+
+                await initBrowser_(mkBrowser_({}, { testXReqId }));
+
+                const { transformRequest } = webdriverio.attach.lastCall.args[0];
+                transformRequest(request);
+
+                assert.equal(request.headers["X-Request-ID"], "12345_67890");
+            });
+
+            it("should call user handler from config", async () => {
+                const transformRequestStub = sinon.stub();
+                const request = { headers: {} };
+
+                await initBrowser_(mkBrowser_({ transformRequest: transformRequestStub }));
+
+                const { transformRequest } = webdriverio.attach.lastCall.args[0];
+                transformRequest(request);
+
+                assert.calledOnceWith(transformRequestStub, request);
+            });
+        });
+
+        describe("transformResponse option", () => {
+            it("should call user handler from config", async () => {
+                const transformResponseStub = sinon.stub();
+                const response = {};
+
+                await initBrowser_(mkBrowser_({ transformResponse: transformResponseStub }));
+
+                const { transformResponse } = webdriverio.attach.lastCall.args[0];
+                transformResponse(response);
+
+                assert.calledOnceWith(transformResponseStub, response);
             });
         });