@checkly/playwright-core 1.41.26 → 1.42.12

package/lib/server/frames.js

@@ -15,7 +15,7 @@ var _browserContext = require("./browserContext");
 var _progress = require("./progress");
 var _utils = require("../utils");
 var _manualPromise = require("../utils/manualPromise");
-var _debugLogger = require("../common/debugLogger");
+var _debugLogger = require("../utils/debugLogger");
 var _instrumentation = require("./instrumentation");
 var _protocolError = require("./protocolError");
 var _selectorParser = require("../utils/isomorphic/selectorParser");
@@ -930,9 +930,10 @@ class Frame extends _instrumentation.SdkObject {
     // Retry upon all other errors.
     return false;
   }
-  async _retryWithProgressIfNotConnected(progress, selector, strict, action) {
+  async _retryWithProgressIfNotConnected(progress, selector, strict, performLocatorHandlersCheckpoint, action) {
     progress.log(`waiting for ${this._asLocator(selector)}`);
     return this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
+      if (performLocatorHandlersCheckpoint) await this._page.performLocatorHandlersCheckpoint(progress);
       const resolved = await this.selectors.resolveInjectedForSelector(selector, {
         strict
       });
@@ -985,7 +986,7 @@ class Frame extends _instrumentation.SdkObject {
     });
   }
   async rafrafTimeoutScreenshotElementWithProgress(progress, selector, timeout, options) {
-    return await this._retryWithProgressIfNotConnected(progress, selector, true /* strict */, async handle => {
+    return await this._retryWithProgressIfNotConnected(progress, selector, true /* strict */, true /* performLocatorHandlersCheckpoint */, async handle => {
       await handle._frame.rafrafTimeout(timeout);
       return await this._page._screenshotter.screenshotElement(progress, handle, options);
     });
@@ -993,19 +994,19 @@ class Frame extends _instrumentation.SdkObject {
   async click(metadata, selector, options) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._click(progress, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._click(progress, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async dblclick(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._dblclick(progress, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._dblclick(progress, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async dragAndDrop(metadata, source, target, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     await controller.run(async progress => {
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options.strict, async handle => {
+      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, source, options.strict, !options.force /* performLocatorHandlersCheckpoint */, async handle => {
         return handle._retryPointerAction(progress, 'move and down', false, async point => {
           await this._page.mouse.move(point.x, point.y);
           await this._page.mouse.down();
@@ -1015,7 +1016,8 @@ class Frame extends _instrumentation.SdkObject {
           timeout: progress.timeUntilDeadline()
         });
       }));
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, async handle => {
+      // Note: do not perform locator handlers checkpoint to avoid moving the mouse in the middle of a drag operation.
+      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, target, options.strict, false /* performLocatorHandlersCheckpoint */, async handle => {
         return handle._retryPointerAction(progress, 'move and up', false, async point => {
           await this._page.mouse.move(point.x, point.y);
           await this._page.mouse.up();
@@ -1031,25 +1033,25 @@ class Frame extends _instrumentation.SdkObject {
     if (!this._page._browserContext._options.hasTouch) throw new Error('The page does not support tap. Use hasTouch context option to enable touch support.');
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._tap(progress, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._tap(progress, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async fill(metadata, selector, value, options) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._fill(progress, value, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._fill(progress, value, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async focus(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     await controller.run(async progress => {
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._focus(progress)));
+      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._focus(progress)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async blur(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     await controller.run(async progress => {
-      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._blur(progress)));
+      dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._blur(progress)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async textContent(metadata, selector, options = {}, scope) {
@@ -1108,6 +1110,11 @@ class Frame extends _instrumentation.SdkObject {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
       progress.log(`  checking visibility of ${this._asLocator(selector)}`);
+      return await this.isVisibleInternal(selector, options, scope);
+    }, this._page._timeoutSettings.timeout({}));
+  }
+  async isVisibleInternal(selector, options = {}, scope) {
+    try {
       const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
       if (!resolved) return false;
       return await resolved.injected.evaluate((injected, {
@@ -1121,10 +1128,10 @@ class Frame extends _instrumentation.SdkObject {
         info: resolved.info,
         root: resolved.frame === this ? scope : undefined
       });
-    }, this._page._timeoutSettings.timeout({})).catch(e => {
+    } catch (e) {
       if (js.isJavaScriptErrorInEvaluate(e) || (0, _selectorParser.isInvalidSelectorError)(e) || (0, _protocolError.isSessionClosedError)(e)) throw e;
       return false;
-    });
+    }
   }
   async isHidden(metadata, selector, options = {}, scope) {
     return !(await this.isVisible(metadata, selector, options, scope));
@@ -1144,44 +1151,44 @@ class Frame extends _instrumentation.SdkObject {
   async hover(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._hover(progress, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._hover(progress, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async selectOption(metadata, selector, elements, values, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._selectOption(progress, elements, values, options));
+      return await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._selectOption(progress, elements, values, options));
     }, this._page._timeoutSettings.timeout(options));
   }
   async setInputFiles(metadata, selector, params) {
     const inputFileItems = await (0, _fileUploadUtils.prepareFilesForUpload)(this, params);
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, handle => handle._setInputFiles(progress, inputFileItems, params)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, params.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._setInputFiles(progress, inputFileItems, params)));
     }, this._page._timeoutSettings.timeout(params));
   }
   async type(metadata, selector, text, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._type(progress, text, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._type(progress, text, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async press(metadata, selector, key, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._press(progress, key, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true /* performLocatorHandlersCheckpoint */, handle => handle._press(progress, key, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async check(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._setChecked(progress, true, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._setChecked(progress, true, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async uncheck(metadata, selector, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, handle => handle._setChecked(progress, false, options)));
+      return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, !options.force /* performLocatorHandlersCheckpoint */, handle => handle._setChecked(progress, false, options)));
     }, this._page._timeoutSettings.timeout(options));
   }
   async waitForTimeout(metadata, timeout) {
@@ -1191,6 +1198,17 @@ class Frame extends _instrumentation.SdkObject {
     });
   }
   async expect(metadata, selector, options) {
+    const result = await this._expectImpl(metadata, selector, options);
+    // Library mode special case for the expect errors which are return values, not exceptions.
+    if (result.matches === options.isNot) metadata.error = {
+      error: {
+        name: 'Expect',
+        message: 'Expect failed'
+      }
+    };
+    return result;
+  }
+  async _expectImpl(metadata, selector, options) {
     let timeout = this._page._timeoutSettings.timeout(options);
     const start = timeout > 0 ? (0, _utils.monotonicTime)() : 0;
     const lastIntermediateResult = {
@@ -1219,6 +1237,7 @@ class Frame extends _instrumentation.SdkObject {
       }
       return await this.retryWithProgressAndTimeouts(progress, [100, 250, 500, 1000], async continuePolling => {
         var _info$world;
+        await this._page.performLocatorHandlersCheckpoint(progress);
         const selectorInFrame = await this.selectors.resolveFrameForSelector(selector, {
           strict: true
         });

package/lib/server/helper.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.helper = void 0;
-var _debugLogger = require("../common/debugLogger");
+var _debugLogger = require("../utils/debugLogger");
 var _eventsHelper = require("../utils/eventsHelper");
 /**
  * Copyright 2017 Google Inc. All rights reserved.

package/lib/server/page.js

@@ -17,12 +17,13 @@ var _fileChooser = require("./fileChooser");
 var _progress = require("./progress");
 var _utils = require("../utils");
 var _manualPromise = require("../utils/manualPromise");
-var _debugLogger = require("../common/debugLogger");
+var _debugLogger = require("../utils/debugLogger");
 var _comparators = require("../utils/comparators");
 var _instrumentation = require("./instrumentation");
 var _selectorParser = require("../utils/isomorphic/selectorParser");
 var _utilityScriptSerializers = require("./isomorphic/utilityScriptSerializers");
 var _errors = require("./errors");
+var _locatorGenerators = require("../utils/isomorphic/locatorGenerators");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 /**
@@ -76,6 +77,9 @@ class Page extends _instrumentation.SdkObject {
     this._video = null;
     this._opener = void 0;
     this._isServerSideOnly = false;
+    this._locatorHandlers = new Map();
+    this._lastLocatorHandlerUid = 0;
+    this._locatorHandlerRunningCounter = 0;
     // Aiming at 25 fps by default - each frame is 40ms, but we give some slack with 35ms.
     // When throttling for tracing, 200ms between frames, except for 10 frames around the action.
     this._frameThrottler = new FrameThrottler(10, 35, 200);
@@ -139,6 +143,7 @@ class Page extends _instrumentation.SdkObject {
   async resetForReuse(metadata) {
     this.setDefaultNavigationTimeout(undefined);
     this.setDefaultTimeout(undefined);
+    this._locatorHandlers.clear();
     await this._removeExposedBindings();
     await this._removeInitScripts();
     await this.setClientRequestInterceptor(undefined);
@@ -282,6 +287,43 @@ class Page extends _instrumentation.SdkObject {
       return response;
     }), this._timeoutSettings.navigationTimeout(options));
   }
+  registerLocatorHandler(selector) {
+    const uid = ++this._lastLocatorHandlerUid;
+    this._locatorHandlers.set(uid, {
+      selector
+    });
+    return uid;
+  }
+  resolveLocatorHandler(uid) {
+    const handler = this._locatorHandlers.get(uid);
+    if (handler) {
+      var _handler$resolved;
+      (_handler$resolved = handler.resolved) === null || _handler$resolved === void 0 || _handler$resolved.resolve();
+      handler.resolved = undefined;
+    }
+  }
+  async performLocatorHandlersCheckpoint(progress) {
+    // Do not run locator handlers from inside locator handler callbacks to avoid deadlocks.
+    if (this._locatorHandlerRunningCounter) return;
+    for (const [uid, handler] of this._locatorHandlers) {
+      if (!handler.resolved) {
+        if (await this.mainFrame().isVisibleInternal(handler.selector, {
+          strict: true
+        })) {
+          handler.resolved = new _manualPromise.ManualPromise();
+          this.emit(Page.Events.LocatorHandlerTriggered, uid);
+        }
+      }
+      if (handler.resolved) {
+        ++this._locatorHandlerRunningCounter;
+        progress.log(`  found ${(0, _locatorGenerators.asLocator)(this.attribution.playwright.options.sdkLanguage, handler.selector)}, intercepting action to run the handler`);
+        await this.openScope.race(handler.resolved).finally(() => --this._locatorHandlerRunningCounter);
+        // Avoid side-effects after long-running operation.
+        progress.throwIfAborted();
+        progress.log(`  interception handler has finished, continuing`);
+      }
+    }
+  }
   async emulateMedia(options) {
     if (options.media !== undefined) this._emulatedMedia.media = options.media;
     if (options.colorScheme !== undefined) this._emulatedMedia.colorScheme = options.colorScheme;
@@ -347,10 +389,11 @@ class Page extends _instrumentation.SdkObject {
   async expectScreenshot(metadata, options = {}) {
     const locator = options.locator;
     const rafrafScreenshot = locator ? async (progress, timeout) => {
-      return await locator.frame.rafrafTimeoutScreenshotElementWithProgress(progress, locator.selector, timeout, options.screenshotOptions || {});
+      return await locator.frame.rafrafTimeoutScreenshotElementWithProgress(progress, locator.selector, timeout, options || {});
     } : async (progress, timeout) => {
+      await this.performLocatorHandlersCheckpoint(progress);
       await this.mainFrame().rafrafTimeout(timeout);
-      return await this._screenshotter.screenshotPage(progress, options.screenshotOptions || {});
+      return await this._screenshotter.screenshotPage(progress, options || {});
     };
     const comparator = (0, _comparators.getComparator)('image/png');
     const controller = new _progress.ProgressController(metadata, this);
@@ -358,7 +401,7 @@ class Page extends _instrumentation.SdkObject {
       errorMessage: '"not" matcher requires expected result'
     };
     try {
-      const format = (0, _screenshotter.validateScreenshotOptions)(options.screenshotOptions || {});
+      const format = (0, _screenshotter.validateScreenshotOptions)(options || {});
       if (format !== 'png') throw new Error('Only PNG screenshots are supported');
     } catch (error) {
       return {
@@ -367,7 +410,7 @@ class Page extends _instrumentation.SdkObject {
     }
     let intermediateResult = undefined;
     const areEqualScreenshots = (actual, expected, previous) => {
-      const comparatorResult = actual && expected ? comparator(actual, expected, options.comparatorOptions) : undefined;
+      const comparatorResult = actual && expected ? comparator(actual, expected, options) : undefined;
       if (comparatorResult !== undefined && !!comparatorResult === !!options.isNot) return true;
       if (comparatorResult) intermediateResult = {
         errorMessage: comparatorResult.errorMessage,
@@ -520,6 +563,7 @@ Page.Events = {
   FrameAttached: 'frameattached',
   FrameDetached: 'framedetached',
   InternalFrameNavigatedToNewDocument: 'internalframenavigatedtonewdocument',
+  LocatorHandlerTriggered: 'locatorhandlertriggered',
   ScreencastFrame: 'screencastframe',
   Video: 'video',
   WebSocket: 'websocket',

package/lib/server/pipeTransport.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PipeTransport = void 0;
 var _utils = require("../utils");
-var _debugLogger = require("../common/debugLogger");
+var _debugLogger = require("../utils/debugLogger");
 /**
  * Copyright 2018 Google Inc. All rights reserved.
  * Modifications copyright (c) Microsoft Corporation.

package/lib/server/playwright.js

@@ -13,7 +13,7 @@ var _firefox = require("./firefox/firefox");
 var _selectors = require("./selectors");
 var _webkit = require("./webkit/webkit");
 var _instrumentation = require("./instrumentation");
-var _debugLogger = require("../common/debugLogger");
+var _debugLogger = require("../utils/debugLogger");
 var _debugController = require("./debugController");
 /**
  * Copyright (c) Microsoft Corporation.

package/lib/server/progress.js

@@ -57,17 +57,9 @@ class ProgressController {
     (_this$sdkObject$attri = this.sdkObject.attribution.context) === null || _this$sdkObject$attri === void 0 || _this$sdkObject$attri._activeProgressControllers.add(this);
     const progress = {
       log: message => {
-        progress.logEntry({
-          message
-        });
-      },
-      logEntry: entry => {
-        if ('message' in entry) {
-          const message = entry.message;
-          if (this._state === 'running') this.metadata.log.push(message);
-          // Note: we might be sending logs after progress has finished, for example browser logs.
-          this.instrumentation.onCallLog(this.sdkObject, this.metadata, this._logName, message);
-        }
+        if (this._state === 'running') this.metadata.log.push(message);
+        // Note: we might be sending logs after progress has finished, for example browser logs.
+        this.instrumentation.onCallLog(this.sdkObject, this.metadata, this._logName, message);
       },
       timeUntilDeadline: () => this._deadline ? this._deadline - (0, _utils.monotonicTime)() : 2147483647,
       // 2^31-1 safe setTimeout in Node.

package/lib/server/recorder/csharp.js

@@ -138,7 +138,7 @@ class CSharpLanguageGenerator {
         return `await Expect(${subject}.${this._asLocator(action.selector)}).ToBeVisibleAsync();`;
       case 'assertValue':
         {
-          const assertion = action.value ? `ToHaveValueAsync(${quote(action.value)})` : `ToBeEmpty()`;
+          const assertion = action.value ? `ToHaveValueAsync(${quote(action.value)})` : `ToBeEmptyAsync()`;
           return `await Expect(${subject}.${this._asLocator(action.selector)}).${assertion};`;
         }
     }

package/lib/server/recorder/java.js

@@ -27,16 +27,29 @@ var _locatorGenerators = require("../../utils/isomorphic/locatorGenerators");
 
 const deviceDescriptors = require('../deviceDescriptorsSource.json');
 class JavaLanguageGenerator {
-  constructor() {
-    this.id = 'java';
+  constructor(mode) {
+    this.id = void 0;
     this.groupName = 'Java';
-    this.name = 'Library';
+    this.name = void 0;
     this.highlighter = 'java';
+    this._mode = void 0;
+    if (mode === 'library') {
+      this.name = 'Library';
+      this.id = 'java';
+    } else if (mode === 'junit') {
+      this.name = 'JUnit';
+      this.id = 'java-junit';
+    } else {
+      throw new Error(`Unknown Java language mode: ${mode}`);
+    }
+    this._mode = mode;
   }
   generateAction(actionInContext) {
     const action = actionInContext.action;
     const pageAlias = actionInContext.frame.pageAlias;
-    const formatter = new _javascript.JavaScriptFormatter(6);
+    const offset = this._mode === 'junit' ? 4 : 6;
+    const formatter = new _javascript.JavaScriptFormatter(offset);
+    if (this._mode !== 'library' && (action.name === 'openPage' || action.name === 'closePage')) return '';
     if (action.name === 'openPage') {
       formatter.add(`Page ${pageAlias} = context.newPage();`);
       if (action.url && action.url !== 'about:blank' && action.url !== 'chrome://newtab/') formatter.add(`${pageAlias}.navigate(${quote(action.url)});`);
@@ -127,6 +140,21 @@ class JavaLanguageGenerator {
   }
   generateHeader(options) {
     const formatter = new _javascript.JavaScriptFormatter();
+    if (this._mode === 'junit') {
+      formatter.add(`
+      import com.microsoft.playwright.junit.UsePlaywright;
+      import com.microsoft.playwright.Page;
+      import com.microsoft.playwright.options.*;
+
+      import org.junit.jupiter.api.*;
+      import static com.microsoft.playwright.assertions.PlaywrightAssertions.*;
+
+      @UsePlaywright
+      public class TestExample {
+        @Test
+        void test(Page page) {`);
+      return formatter.format();
+    }
     formatter.add(`
     import com.microsoft.playwright.*;
     import com.microsoft.playwright.options.*;
@@ -142,6 +170,10 @@ class JavaLanguageGenerator {
   }
   generateFooter(saveStorage) {
     const storageStateLine = saveStorage ? `\n      context.storageState(new BrowserContext.StorageStateOptions().setPath(${quote(saveStorage)}));\n` : '';
+    if (this._mode === 'junit') {
+      return `${storageStateLine}  }
+}`;
+    }
     return `${storageStateLine}    }
   }
 }`;

package/lib/server/recorder.js

@@ -403,7 +403,7 @@ class ContextRecorder extends _events.EventEmitter {
   }
   setOutput(codegenId, outputFile) {
     var _this$_generator;
-    const languages = new Set([new _java.JavaLanguageGenerator(), new _javascript.JavaScriptLanguageGenerator( /* isPlaywrightTest */false), new _javascript.JavaScriptLanguageGenerator( /* isPlaywrightTest */true), new _python.PythonLanguageGenerator( /* isAsync */false, /* isPytest */true), new _python.PythonLanguageGenerator( /* isAsync */false, /* isPytest */false), new _python.PythonLanguageGenerator( /* isAsync */true, /* isPytest */false), new _csharp.CSharpLanguageGenerator('mstest'), new _csharp.CSharpLanguageGenerator('nunit'), new _csharp.CSharpLanguageGenerator('library'), new _jsonl.JsonlLanguageGenerator()]);
+    const languages = new Set([new _java.JavaLanguageGenerator('junit'), new _java.JavaLanguageGenerator('library'), new _javascript.JavaScriptLanguageGenerator( /* isPlaywrightTest */false), new _javascript.JavaScriptLanguageGenerator( /* isPlaywrightTest */true), new _python.PythonLanguageGenerator( /* isAsync */false, /* isPytest */true), new _python.PythonLanguageGenerator( /* isAsync */false, /* isPytest */false), new _python.PythonLanguageGenerator( /* isAsync */true, /* isPytest */false), new _csharp.CSharpLanguageGenerator('mstest'), new _csharp.CSharpLanguageGenerator('nunit'), new _csharp.CSharpLanguageGenerator('library'), new _jsonl.JsonlLanguageGenerator()]);
     const primaryLanguage = [...languages].find(l => l.id === codegenId);
     if (!primaryLanguage) throw new Error(`\n===============================\nUnsupported language: '${codegenId}'\n===============================\n`);
     languages.delete(primaryLanguage);
@@ -690,7 +690,7 @@ async function findFrameSelector(frame) {
     const utility = await parent._utilityContext();
     const injected = await utility.injectedScript();
     const selector = await injected.evaluate((injected, element) => {
-      return injected.generateSelector(element, {
+      return injected.generateSelectorSimple(element, {
         testIdAttributeName: '',
         omitInternalEngines: true
       });

package/lib/server/registry/browserFetcher.js

@@ -10,7 +10,7 @@ var _os = _interopRequireDefault(require("os"));
 var _path = _interopRequireDefault(require("path"));
 var _child_process = _interopRequireDefault(require("child_process"));
 var _fileUtils = require("../../utils/fileUtils");
-var _debugLogger = require("../../common/debugLogger");
+var _debugLogger = require("../../utils/debugLogger");
 var _manualPromise = require("../../utils/manualPromise");
 var _utilsBundle = require("../../utilsBundle");
 var _ = require(".");

package/lib/server/registry/dependencies.js

@@ -166,7 +166,7 @@ async function validateDependenciesWindows(windowsExeAndDllDirectories) {
   }
 }
 async function validateDependenciesLinux(sdkLanguage, linuxLddDirectories, dlOpenLibraries) {
-  var _deps$hostPlatform;
+  var _deps$hostPlatform, _process$getuid, _process;
   const directoryPaths = linuxLddDirectories;
   const lddPaths = [];
   for (const directoryPath of directoryPaths) lddPaths.push(...(await executablesOrSharedLibraries(directoryPath)));
@@ -192,7 +192,7 @@ async function validateDependenciesLinux(sdkLanguage, linuxLddDirectories, dlOpe
       missingDeps.delete(missingDep);
     }
   }
-  const maybeSudo = process.getuid() !== 0 && os.platform() !== 'win32' ? 'sudo ' : '';
+  const maybeSudo = (_process$getuid = (_process = process).getuid) !== null && _process$getuid !== void 0 && _process$getuid.call(_process) && os.platform() !== 'win32' ? 'sudo ' : '';
   const dockerInfo = readDockerVersionSync();
   const errorLines = [`Host system is missing dependencies to run browsers.`];
   // Ignore patch versions when comparing docker container version and Playwright version:
@@ -202,7 +202,7 @@ async function validateDependenciesLinux(sdkLanguage, linuxLddDirectories, dlOpe
     // In this case, we know how to install dependencies in it.
     const pwVersion = (0, _userAgent.getPlaywrightVersion)();
     const requiredDockerImage = dockerInfo.dockerImageName.replace(dockerInfo.driverVersion, pwVersion);
-    errorLines.push(...[`This is most likely due to docker image version not matching Playwright version:`, `- Playwright: ${pwVersion}`, `-     Docker: ${dockerInfo.driverVersion}`, ``, `Either:`, `- (recommended) use docker image "${requiredDockerImage}"`, `- (alternative 1) run the following command inside docker to install missing dependencies:`, ``, `    ${maybeSudo}${(0, _.buildPlaywrightCLICommand)(sdkLanguage, 'install-deps')}`, ``, `- (alternative 2) use apt inside docker:`, ``, `    ${maybeSudo}apt-get install ${[...missingPackages].join('\\\n        ')}`, ``, `<3 Playwright Team`]);
+    errorLines.push(...[`This is most likely due to Docker image version not matching Playwright version:`, `- Playwright  : ${pwVersion}`, `- Docker image: ${dockerInfo.driverVersion}`, ``, `Either:`, `- (recommended) use Docker image "${requiredDockerImage}"`, `- (alternative 1) run the following command inside Docker to install missing dependencies:`, ``, `    ${maybeSudo}${(0, _.buildPlaywrightCLICommand)(sdkLanguage, 'install-deps')}`, ``, `- (alternative 2) use apt inside Docker:`, ``, `    ${maybeSudo}apt-get install ${[...missingPackages].join('\\\n        ')}`, ``, `<3 Playwright Team`]);
   } else if (missingPackages.size && !missingDeps.size) {
     // Only known dependencies are missing for browsers.
     // Suggest installation with a Playwright CLI.
@@ -301,7 +301,8 @@ function quoteProcessArgs(args) {
   });
 }
 async function transformCommandsForRoot(commands) {
-  const isRoot = process.getuid() === 0;
+  var _process$getuid2, _process2;
+  const isRoot = ((_process$getuid2 = (_process2 = process).getuid) === null || _process$getuid2 === void 0 ? void 0 : _process$getuid2.call(_process2)) === 0;
   if (isRoot) return {
     command: 'sh',
     args: ['-c', `${commands.join('&& ')}`],