@checkly/playwright-core 1.42.17 → 1.47.11

package/lib/client/browserType.js

@@ -142,28 +142,36 @@ class BrowserType extends _channelOwner.ChannelOwner {
       connection.on('close', closePipe);
       let browser;
       let closeError;
-      const onPipeClosed = () => {
-        var _browser2;
+      const onPipeClosed = reason => {
         // Emulate all pages, contexts and the browser closing upon disconnect.
         for (const context of ((_browser = browser) === null || _browser === void 0 ? void 0 : _browser.contexts()) || []) {
           var _browser;
           for (const page of context.pages()) page._onClose();
           context._onClose();
         }
-        (_browser2 = browser) === null || _browser2 === void 0 || _browser2._didClose();
-        connection.close(closeError);
+        connection.close(reason || closeError);
+        // Give a chance to any API call promises to reject upon page/context closure.
+        // This happens naturally when we receive page.onClose and browser.onClose from the server
+        // in separate tasks. However, upon pipe closure we used to dispatch them all synchronously
+        // here and promises did not have a chance to reject.
+        // The order of rejects vs closure is a part of the API contract and our test runner
+        // relies on it to attribute rejections to the right test.
+        setTimeout(() => {
+          var _browser2;
+          return (_browser2 = browser) === null || _browser2 === void 0 ? void 0 : _browser2._didClose();
+        }, 0);
       };
-      pipe.on('closed', onPipeClosed);
-      connection.onmessage = message => pipe.send({
+      pipe.on('closed', params => onPipeClosed(params.reason));
+      connection.onmessage = message => this._wrapApiCall(() => pipe.send({
         message
-      }).catch(onPipeClosed);
+      }).catch(() => onPipeClosed()), /* isInternal */true);
       pipe.on('message', ({
         message
       }) => {
         try {
           connection.dispatch(message);
         } catch (e) {
-          closeError = e;
+          closeError = String(e);
           closePipe();
         }
       });
@@ -180,7 +188,7 @@ class BrowserType extends _channelOwner.ChannelOwner {
         this._didLaunchBrowser(browser, {}, logger);
         browser._shouldCloseConnectionOnClose = true;
         browser._connectHeaders = connectHeaders;
-        browser.on(_events.Events.Browser.Disconnected, closePipe);
+        browser.on(_events.Events.Browser.Disconnected, () => this._wrapApiCall(() => closePipe(), /* isInternal */true));
         return browser;
       }, deadline);
       if (!result.timedOut) {
@@ -223,11 +231,11 @@ class BrowserType extends _channelOwner.ChannelOwner {
     context._setOptions(contextOptions, browserOptions);
     if (this._defaultContextTimeout !== undefined) context.setDefaultTimeout(this._defaultContextTimeout);
     if (this._defaultContextNavigationTimeout !== undefined) context.setDefaultNavigationTimeout(this._defaultContextNavigationTimeout);
-    await this._instrumentation.onDidCreateBrowserContext(context);
+    await this._instrumentation.runAfterCreateBrowserContext(context);
   }
   async _willCloseContext(context) {
     this._contexts.delete(context);
-    await this._instrumentation.onWillCloseBrowserContext(context);
+    await this._instrumentation.runBeforeCloseBrowserContext(context);
   }
 }
 exports.BrowserType = BrowserType;

package/lib/client/channelOwner.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ChannelOwner = void 0;
-var _events = require("events");
+var _eventEmitter = require("./eventEmitter");
 var _validator = require("../protocol/validator");
 var _debugLogger = require("../utils/debugLogger");
 var _stackTrace = require("../utils/stackTrace");
@@ -26,7 +26,7 @@ var _zones = require("../utils/zones");
  * limitations under the License.
  */
 
-class ChannelOwner extends _events.EventEmitter {
+class ChannelOwner extends _eventEmitter.EventEmitter {
   constructor(parent, type, guid, initializer) {
     super();
     this._connection = void 0;
@@ -51,7 +51,7 @@ class ChannelOwner extends _events.EventEmitter {
       this._parent._objects.set(guid, this);
       this._logger = this._parent._logger;
     }
-    this._channel = this._createChannel(new _events.EventEmitter());
+    this._channel = this._createChannel(new _eventEmitter.EventEmitter());
     this._initializer = initializer;
   }
   _setEventToSubscriptionMapping(mapping) {
@@ -127,20 +127,25 @@ class ChannelOwner extends _events.EventEmitter {
                   frames,
                   csi,
                   callCookie,
-                  wallTime
+                  stepId
                 } = apiZone.reported ? {
                   apiName: undefined,
                   csi: undefined,
                   callCookie: undefined,
                   frames: [],
-                  wallTime: undefined
+                  stepId: undefined
                 } : apiZone;
                 apiZone.reported = true;
-                if (csi && apiName) csi.onApiCallBegin(apiName, params, frames, wallTime, callCookie);
+                let currentStepId = stepId;
+                if (csi && apiName) {
+                  const out = {};
+                  csi.onApiCallBegin(apiName, params, frames, callCookie, out);
+                  currentStepId = out.stepId;
+                }
                 return await this._connection.sendMessageToServer(this, prop, validator(params, '', {
                   tChannelImpl: tChannelImplToWire,
                   binary: this._connection.rawBuffers() ? 'buffer' : 'toBase64'
-                }), apiName, frames, wallTime);
+                }), apiName, frames, currentStepId);
               });
             };
           }
@@ -153,18 +158,17 @@ class ChannelOwner extends _events.EventEmitter {
   }
   async _wrapApiCall(func, isInternal = false) {
     const logger = this._logger;
-    const stack = (0, _stackTrace.captureRawStack)();
-    const apiZone = _zones.zones.zoneData('apiZone', stack);
+    const apiZone = _zones.zones.zoneData('apiZone');
     if (apiZone) return await func(apiZone);
-    const stackTrace = (0, _stackTrace.captureLibraryStackTrace)(stack);
+    const stackTrace = (0, _stackTrace.captureLibraryStackTrace)();
     let apiName = stackTrace.apiName;
     const frames = stackTrace.frames;
     isInternal = isInternal || this._type === 'LocalUtils';
     if (isInternal) apiName = undefined;
 
     // Enclosing zone could have provided the apiName and wallTime.
-    const expectZone = _zones.zones.zoneData('expectZone', stack);
-    const wallTime = expectZone ? expectZone.wallTime : Date.now();
+    const expectZone = _zones.zones.zoneData('expectZone');
+    const stepId = expectZone === null || expectZone === void 0 ? void 0 : expectZone.stepId;
     if (!isInternal && expectZone) apiName = expectZone.title;
 
     // If we are coming from the expectZone, there is no need to generate a new
@@ -180,11 +184,10 @@ class ChannelOwner extends _events.EventEmitter {
         reported: false,
         csi,
         callCookie,
-        wallTime
+        stepId
       };
-      const result = await _zones.zones.run('apiZone', apiZone, async () => {
-        return await func(apiZone);
-      });
+      const result = await _zones.zones.run('apiZone', apiZone, async () => await func(apiZone));
+      // @ts-ignore
       csi === null || csi === void 0 || csi.onApiCallEnd(callCookie, null, result);
       logApiCall(logger, `<= ${apiName} succeeded`, isInternal);
       return result;

package/lib/client/clientInstrumentation.js

@@ -28,13 +28,23 @@ function createInstrumentation() {
       if (prop === 'addListener') return listener => listeners.push(listener);
       if (prop === 'removeListener') return listener => listeners.splice(listeners.indexOf(listener), 1);
       if (prop === 'removeAllListeners') return () => listeners.splice(0, listeners.length);
-      if (!prop.startsWith('on')) return obj[prop];
-      return async (...params) => {
-        for (const listener of listeners) {
-          var _prop, _ref;
-          await ((_prop = (_ref = listener)[prop]) === null || _prop === void 0 ? void 0 : _prop.call(_ref, ...params));
-        }
-      };
+      if (prop.startsWith('run')) {
+        return async (...params) => {
+          for (const listener of listeners) {
+            var _prop, _ref;
+            await ((_prop = (_ref = listener)[prop]) === null || _prop === void 0 ? void 0 : _prop.call(_ref, ...params));
+          }
+        };
+      }
+      if (prop.startsWith('on')) {
+        return (...params) => {
+          for (const listener of listeners) {
+            var _prop2, _ref2;
+            (_prop2 = (_ref2 = listener)[prop]) === null || _prop2 === void 0 || _prop2.call(_ref2, ...params);
+          }
+        };
+      }
+      return obj[prop];
     }
   });
 }

package/lib/client/clock.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Clock = void 0;
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class Clock {
+  constructor(browserContext) {
+    this._browserContext = void 0;
+    this._browserContext = browserContext;
+  }
+  async install(options = {}) {
+    await this._browserContext._channel.clockInstall(options.time !== undefined ? parseTime(options.time) : {});
+  }
+  async fastForward(ticks) {
+    await this._browserContext._channel.clockFastForward(parseTicks(ticks));
+  }
+  async pauseAt(time) {
+    await this._browserContext._channel.clockPauseAt(parseTime(time));
+  }
+  async resume() {
+    await this._browserContext._channel.clockResume({});
+  }
+  async runFor(ticks) {
+    await this._browserContext._channel.clockRunFor(parseTicks(ticks));
+  }
+  async setFixedTime(time) {
+    await this._browserContext._channel.clockSetFixedTime(parseTime(time));
+  }
+  async setSystemTime(time) {
+    await this._browserContext._channel.clockSetSystemTime(parseTime(time));
+  }
+}
+exports.Clock = Clock;
+function parseTime(time) {
+  if (typeof time === 'number') return {
+    timeNumber: time
+  };
+  if (typeof time === 'string') return {
+    timeString: time
+  };
+  if (!isFinite(time.getTime())) throw new Error(`Invalid date: ${time}`);
+  return {
+    timeNumber: time.getTime()
+  };
+}
+function parseTicks(ticks) {
+  return {
+    ticksNumber: typeof ticks === 'number' ? ticks : undefined,
+    ticksString: typeof ticks === 'string' ? ticks : undefined
+  };
+}

package/lib/client/connection.js

@@ -104,7 +104,7 @@ class Connection extends _events.EventEmitter {
   setIsTracing(isTracing) {
     if (isTracing) this._tracingCount++;else this._tracingCount--;
   }
-  async sendMessageToServer(object, method, params, apiName, frames, wallTime) {
+  async sendMessageToServer(object, method, params, apiName, frames, stepId) {
     var _this$_localUtils;
     if (this._closedError) throw this._closedError;
     if (object._wasCollected) throw new Error('The object has been collected to prevent unbounded heap growth.');
@@ -127,10 +127,10 @@ class Connection extends _events.EventEmitter {
       column: frames[0].column
     } : undefined;
     const metadata = {
-      wallTime,
       apiName,
       location,
-      internal: !apiName
+      internal: !apiName,
+      stepId
     };
     if (this._tracingCount && frames && type !== 'LocalUtils') (_this$_localUtils = this._localUtils) === null || _this$_localUtils === void 0 || _this$_localUtils._channel.addStackToTracingNoReply({
       callData: {
@@ -138,10 +138,12 @@ class Connection extends _events.EventEmitter {
         id
       }
     }).catch(() => {});
-    this.onmessage({
+    // We need to exit zones before calling into the server, otherwise
+    // when we receive events from the server, we would be in an API zone.
+    _utils.zones.exitZones(() => this.onmessage({
       ...message,
       metadata
-    });
+    }));
     return await new Promise((resolve, reject) => this._callbacks.set(id, {
       resolve,
       reject,
@@ -203,7 +205,8 @@ class Connection extends _events.EventEmitter {
     }));
   }
   close(cause) {
-    this._closedError = new _errors.TargetClosedError(cause === null || cause === void 0 ? void 0 : cause.toString());
+    if (this._closedError) return;
+    this._closedError = new _errors.TargetClosedError(cause);
     for (const callback of this._callbacks.values()) callback.reject(this._closedError);
     this._callbacks.clear();
     this.emit('close');

package/lib/client/electron.js

@@ -43,7 +43,7 @@ class Electron extends _channelOwner.ChannelOwner {
       tracesDir: options.tracesDir
     };
     const app = ElectronApplication.from((await this._channel.launch(params)).electronApplication);
-    app._context._options = params;
+    app._context._setOptions(params, options);
     return app;
   }
 }
@@ -58,12 +58,10 @@ class ElectronApplication extends _channelOwner.ChannelOwner {
     this._context = void 0;
     this._windows = new Set();
     this._timeoutSettings = new _timeoutSettings.TimeoutSettings();
-    this._isClosed = false;
     this._context = _browserContext.BrowserContext.from(initializer.context);
     for (const page of this._context._pages) this._onPage(page);
     this._context.on(_events.Events.BrowserContext.Page, page => this._onPage(page));
     this._channel.on('close', () => {
-      this._isClosed = true;
       this.emit(_events.Events.ElectronApplication.Close);
     });
     this._channel.on('console', event => this.emit(_events.Events.ElectronApplication.Console, new _consoleMessage.ConsoleMessage(event)));
@@ -92,8 +90,12 @@ class ElectronApplication extends _channelOwner.ChannelOwner {
     await this.close();
   }
   async close() {
-    if (this._isClosed) return;
-    await this._channel.close().catch(() => {});
+    try {
+      await this._context.close();
+    } catch (e) {
+      if ((0, _errors.isTargetClosedError)(e)) return;
+      throw e;
+    }
   }
   async waitForEvent(event, optionsOrPredicate = {}) {
     return await this._wrapApiCall(async () => {

package/lib/client/elementHandle.js

@@ -250,29 +250,59 @@ function convertSelectOptionValues(values) {
 function filePayloadExceedsSizeLimit(payloads) {
   return payloads.reduce((size, item) => size + (item.buffer ? item.buffer.byteLength : 0), 0) >= _fileUtils.fileUploadSizeLimit;
 }
+async function resolvePathsAndDirectoryForInputFiles(items) {
+  var _localPaths2;
+  let localPaths;
+  let localDirectory;
+  for (const item of items) {
+    const stat = await _fs.default.promises.stat(item);
+    if (stat.isDirectory()) {
+      if (localDirectory) throw new Error('Multiple directories are not supported');
+      localDirectory = _path.default.resolve(item);
+    } else {
+      var _localPaths;
+      (_localPaths = localPaths) !== null && _localPaths !== void 0 ? _localPaths : localPaths = [];
+      localPaths.push(_path.default.resolve(item));
+    }
+  }
+  if ((_localPaths2 = localPaths) !== null && _localPaths2 !== void 0 && _localPaths2.length && localDirectory) throw new Error('File paths must be all files or a single directory');
+  return [localPaths, localDirectory];
+}
 async function convertInputFiles(files, context) {
   const items = Array.isArray(files) ? files.slice() : [files];
   if (items.some(item => typeof item === 'string')) {
     if (!items.every(item => typeof item === 'string')) throw new Error('File paths cannot be mixed with buffers');
+    const [localPaths, localDirectory] = await resolvePathsAndDirectoryForInputFiles(items);
     if (context._connection.isRemote()) {
-      const streams = await Promise.all(items.map(async item => {
-        const lastModifiedMs = (await _fs.default.promises.stat(item)).mtimeMs;
-        const {
-          writableStream: stream
-        } = await context._wrapApiCall(() => context._channel.createTempFile({
-          name: _path.default.basename(item),
-          lastModifiedMs
-        }), true);
-        const writable = _writableStream.WritableStream.from(stream);
-        await pipelineAsync(_fs.default.createReadStream(item), writable.stream());
-        return stream;
-      }));
+      const files = localDirectory ? (await _fs.default.promises.readdir(localDirectory, {
+        withFileTypes: true,
+        recursive: true
+      })).filter(f => f.isFile()).map(f => _path.default.join(f.path, f.name)) : localPaths;
+      const {
+        writableStreams,
+        rootDir
+      } = await context._wrapApiCall(async () => context._channel.createTempFiles({
+        rootDirName: localDirectory ? _path.default.basename(localDirectory) : undefined,
+        items: await Promise.all(files.map(async file => {
+          const lastModifiedMs = (await _fs.default.promises.stat(file)).mtimeMs;
+          return {
+            name: localDirectory ? _path.default.relative(localDirectory, file) : _path.default.basename(file),
+            lastModifiedMs
+          };
+        }))
+      }), true);
+      for (let i = 0; i < files.length; i++) {
+        const writable = _writableStream.WritableStream.from(writableStreams[i]);
+        await pipelineAsync(_fs.default.createReadStream(files[i]), writable.stream());
+      }
       return {
-        streams
+        directoryStream: rootDir,
+        streams: localDirectory ? undefined : writableStreams
       };
     }
     return {
-      localPaths: items.map(f => _path.default.resolve(f))
+      localPaths,
+      localDirectory
     };
   }
   const payloads = items;