@checkly/playwright-core 1.42.17 → 1.47.20-alpha

package/lib/server/dom.js

@@ -8,6 +8,7 @@ exports.assertDone = assertDone;
 exports.isNonRecoverableDOMError = isNonRecoverableDOMError;
 exports.kUnableToAdoptErrorMessage = void 0;
 exports.throwRetargetableDOMError = throwRetargetableDOMError;
+var _fs = _interopRequireDefault(require("fs"));
 var injectedScriptSource = _interopRequireWildcard(require("../generated/injectedScriptSource"));
 var _protocolError = require("./protocolError");
 var js = _interopRequireWildcard(require("./javascript"));
@@ -16,6 +17,7 @@ var _utils = require("../utils");
 var _fileUploadUtils = require("./fileUploadUtils");
 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; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -217,6 +219,7 @@ class ElementHandle extends js.JSHandle {
       width: innerWidth,
       height: innerHeight
     })))]);
+    if (quads === 'error:notconnected') return quads;
     if (!quads || !quads.length) return 'error:notvisible';
 
     // Allow 1x1 elements. Compensate for rounding errors by comparing with 0.99 instead.
@@ -399,20 +402,22 @@ class ElementHandle extends js.JSHandle {
         hitTargetInterceptionHandle.dispose();
       });
     }
-    const actionResult = await this._page._frameManager.waitForSignalsCreatedBy(progress, options.noWaitAfter, async () => {
+    const actionResult = await this._page._frameManager.waitForSignalsCreatedBy(progress, options.waitAfter === true, async () => {
       if (options.__testHookBeforePointerAction) await options.__testHookBeforePointerAction();
       progress.throwIfAborted(); // Avoid action that has side-effects.
       let restoreModifiers;
-      if (options && options.modifiers) restoreModifiers = await this._page.keyboard._ensureModifiers(options.modifiers);
+      if (options && options.modifiers) restoreModifiers = await this._page.keyboard.ensureModifiers(options.modifiers);
       progress.log(`  performing ${actionName} action`);
       await action(point);
-      if (restoreModifiers) await this._page.keyboard._ensureModifiers(restoreModifiers);
+      if (restoreModifiers) await this._page.keyboard.ensureModifiers(restoreModifiers);
       if (hitTargetInterceptionHandle) {
-        const stopHitTargetInterception = hitTargetInterceptionHandle.evaluate(h => h.stop()).catch(e => 'done').finally(() => {
+        const stopHitTargetInterception = this._frame.raceAgainstEvaluationStallingEvents(() => {
+          return hitTargetInterceptionHandle.evaluate(h => h.stop());
+        }).catch(e => 'done').finally(() => {
           var _hitTargetInterceptio;
           (_hitTargetInterceptio = hitTargetInterceptionHandle) === null || _hitTargetInterceptio === void 0 || _hitTargetInterceptio.dispose();
         });
-        if (!options.noWaitAfter) {
+        if (options.waitAfter !== false) {
           // When noWaitAfter is passed, we do not want to accidentally stall on
           // non-committed navigation blocking the evaluate.
           const hitTargetResult = await stopHitTargetInterception;
@@ -423,7 +428,7 @@ class ElementHandle extends js.JSHandle {
       progress.log('  waiting for scheduled navigations to finish');
       if (options.__testHookAfterPointerAction) await options.__testHookAfterPointerAction();
       return 'done';
-    }, 'input');
+    });
     if (actionResult !== 'done') return actionResult;
     progress.log('  navigations have finished');
     return 'done';
@@ -436,12 +441,18 @@ class ElementHandle extends js.JSHandle {
     }, this._page._timeoutSettings.timeout(options));
   }
   _hover(progress, options) {
-    return this._retryPointerAction(progress, 'hover', false /* waitForEnabled */, point => this._page.mouse.move(point.x, point.y), options);
+    return this._retryPointerAction(progress, 'hover', false /* waitForEnabled */, point => this._page.mouse.move(point.x, point.y), {
+      ...options,
+      waitAfter: 'disabled'
+    });
   }
   async click(metadata, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      const result = await this._click(progress, options);
+      const result = await this._click(progress, {
+        ...options,
+        waitAfter: !options.noWaitAfter
+      });
       return assertDone(throwRetargetableDOMError(result));
     }, this._page._timeoutSettings.timeout(options));
   }
@@ -456,7 +467,10 @@ class ElementHandle extends js.JSHandle {
     }, this._page._timeoutSettings.timeout(options));
   }
   _dblclick(progress, options) {
-    return this._retryPointerAction(progress, 'dblclick', true /* waitForEnabled */, point => this._page.mouse.dblclick(point.x, point.y, options), options);
+    return this._retryPointerAction(progress, 'dblclick', true /* waitForEnabled */, point => this._page.mouse.dblclick(point.x, point.y, options), {
+      ...options,
+      waitAfter: 'disabled'
+    });
   }
   async tap(metadata, options = {}) {
     const controller = new _progress.ProgressController(metadata, this);
@@ -466,7 +480,10 @@ class ElementHandle extends js.JSHandle {
     }, this._page._timeoutSettings.timeout(options));
   }
   _tap(progress, options) {
-    return this._retryPointerAction(progress, 'tap', true /* waitForEnabled */, point => this._page.touchscreen.tap(point.x, point.y), options);
+    return this._retryPointerAction(progress, 'tap', true /* waitForEnabled */, point => this._page.touchscreen.tap(point.x, point.y), {
+      ...options,
+      waitAfter: 'disabled'
+    });
   }
   async selectOption(metadata, elements, values, options) {
     const controller = new _progress.ProgressController(metadata, this);
@@ -514,29 +531,27 @@ class ElementHandle extends js.JSHandle {
     progress.log(`  fill("${value}")`);
     return await this._retryAction(progress, 'fill', async () => {
       await progress.beforeInputAction(this);
-      return this._page._frameManager.waitForSignalsCreatedBy(progress, options.noWaitAfter, async () => {
-        if (!options.force) progress.log('  waiting for element to be visible, enabled and editable');
-        const result = await this.evaluateInUtility(async ([injected, node, {
-          value,
-          force
-        }]) => {
-          if (!force) {
-            const checkResult = await injected.checkElementStates(node, ['visible', 'enabled', 'editable']);
-            if (checkResult) return checkResult;
-          }
-          return injected.fill(node, value);
-        }, {
-          value,
-          force: options.force
-        });
-        progress.throwIfAborted(); // Avoid action that has side-effects.
-        if (result === 'needsinput') {
-          if (value) await this._page.keyboard.insertText(value);else await this._page.keyboard.press('Delete');
-          return 'done';
-        } else {
-          return result;
+      if (!options.force) progress.log('  waiting for element to be visible, enabled and editable');
+      const result = await this.evaluateInUtility(async ([injected, node, {
+        value,
+        force
+      }]) => {
+        if (!force) {
+          const checkResult = await injected.checkElementStates(node, ['visible', 'enabled', 'editable']);
+          if (checkResult) return checkResult;
         }
-      }, 'input');
+        return injected.fill(node, value);
+      }, {
+        value,
+        force: options.force
+      });
+      progress.throwIfAborted(); // Avoid action that has side-effects.
+      if (result === 'needsinput') {
+        if (value) await this._page.keyboard.insertText(value);else await this._page.keyboard.press('Delete');
+        return 'done';
+      } else {
+        return result;
+      }
     }, options);
   }
   async selectText(metadata, options = {}) {
@@ -563,30 +578,51 @@ class ElementHandle extends js.JSHandle {
     const inputFileItems = await (0, _fileUploadUtils.prepareFilesForUpload)(this._frame, params);
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
-      const result = await this._setInputFiles(progress, inputFileItems, params);
+      const result = await this._setInputFiles(progress, inputFileItems);
       return assertDone(throwRetargetableDOMError(result));
     }, this._page._timeoutSettings.timeout(params));
   }
-  async _setInputFiles(progress, items, options) {
+  async _setInputFiles(progress, items) {
     const {
       filePayloads,
-      localPaths
+      localPaths,
+      localDirectory
     } = items;
     const multiple = filePayloads && filePayloads.length > 1 || localPaths && localPaths.length > 1;
-    const result = await this.evaluateHandleInUtility(([injected, node, multiple]) => {
+    const result = await this.evaluateHandleInUtility(([injected, node, {
+      multiple,
+      directoryUpload
+    }]) => {
       const element = injected.retarget(node, 'follow-label');
       if (!element) return;
       if (element.tagName !== 'INPUT') throw injected.createStacklessError('Node is not an HTMLInputElement');
-      if (multiple && !element.multiple) throw injected.createStacklessError('Non-multiple file input can only accept single file');
-      return element;
-    }, multiple);
+      const inputElement = element;
+      if (multiple && !inputElement.multiple && !inputElement.webkitdirectory) throw injected.createStacklessError('Non-multiple file input can only accept single file');
+      if (directoryUpload && !inputElement.webkitdirectory) throw injected.createStacklessError('File input does not support directories, pass individual files instead');
+      if (!directoryUpload && inputElement.webkitdirectory) throw injected.createStacklessError('[webkitdirectory] input requires passing a path to a directory');
+      return inputElement;
+    }, {
+      multiple,
+      directoryUpload: !!localDirectory
+    });
     if (result === 'error:notconnected' || !result.asElement()) return 'error:notconnected';
     const retargeted = result.asElement();
     await progress.beforeInputAction(this);
-    await this._page._frameManager.waitForSignalsCreatedBy(progress, options.noWaitAfter, async () => {
-      progress.throwIfAborted(); // Avoid action that has side-effects.
-      if (localPaths) await this._page._delegate.setInputFilePaths(progress, retargeted, localPaths);else await this._page._delegate.setInputFiles(retargeted, filePayloads);
-    });
+    progress.throwIfAborted(); // Avoid action that has side-effects.
+    if (localPaths || localDirectory) {
+      const localPathsOrDirectory = localDirectory ? [localDirectory] : localPaths;
+      await Promise.all(localPathsOrDirectory.map(localPath => _fs.default.promises.access(localPath, _fs.default.constants.F_OK)));
+      // Browsers traverse the given directory asynchronously and we want to ensure all files are uploaded.
+      const waitForInputEvent = localDirectory ? this.evaluate(node => new Promise(fulfill => {
+        node.addEventListener('input', fulfill, {
+          once: true
+        });
+      })).catch(() => {}) : Promise.resolve();
+      await this._page._delegate.setInputFilePaths(retargeted, localPathsOrDirectory);
+      await waitForInputEvent;
+    } else {
+      await this._page._delegate.setInputFiles(retargeted, filePayloads);
+    }
     return 'done';
   }
   async focus(metadata) {
@@ -614,13 +650,11 @@ class ElementHandle extends js.JSHandle {
   async _type(progress, text, options) {
     progress.log(`elementHandle.type("${text}")`);
     await progress.beforeInputAction(this);
-    return this._page._frameManager.waitForSignalsCreatedBy(progress, options.noWaitAfter, async () => {
-      const result = await this._focus(progress, true /* resetSelectionIfNotFocused */);
-      if (result !== 'done') return result;
-      progress.throwIfAborted(); // Avoid action that has side-effects.
-      await this._page.keyboard.type(text, options);
-      return 'done';
-    }, 'input');
+    const result = await this._focus(progress, true /* resetSelectionIfNotFocused */);
+    if (result !== 'done') return result;
+    progress.throwIfAborted(); // Avoid action that has side-effects.
+    await this._page.keyboard.type(text, options);
+    return 'done';
   }
   async press(metadata, key, options) {
     const controller = new _progress.ProgressController(metadata, this);
@@ -632,13 +666,13 @@ class ElementHandle extends js.JSHandle {
   async _press(progress, key, options) {
     progress.log(`elementHandle.press("${key}")`);
     await progress.beforeInputAction(this);
-    return this._page._frameManager.waitForSignalsCreatedBy(progress, options.noWaitAfter, async () => {
+    return this._page._frameManager.waitForSignalsCreatedBy(progress, !options.noWaitAfter, async () => {
       const result = await this._focus(progress, true /* resetSelectionIfNotFocused */);
       if (result !== 'done') return result;
       progress.throwIfAborted(); // Avoid action that has side-effects.
       await this._page.keyboard.press(key, options);
       return 'done';
-    }, 'input');
+    });
   }
   async check(metadata, options) {
     const controller = new _progress.ProgressController(metadata, this);
@@ -660,7 +694,10 @@ class ElementHandle extends js.JSHandle {
       return throwRetargetableDOMError(result);
     };
     if ((await isChecked()) === state) return 'done';
-    const result = await this._click(progress, options);
+    const result = await this._click(progress, {
+      ...options,
+      waitAfter: 'disabled'
+    });
     if (result !== 'done') return result;
     if (options.trial) return 'done';
     if ((await isChecked()) !== state) throw new NonRecoverableDOMError('Clicking the checkbox did not change its state');

package/lib/server/electron/electron.js

@@ -156,7 +156,7 @@ class Electron extends _instrumentation.SdkObject {
     return controller.run(async progress => {
       let app = undefined;
       // --remote-debugging-port=0 must be the last playwright's argument, loader.ts relies on it.
-      const electronArguments = ['--inspect=0', '--remote-debugging-port=0', ...args];
+      let electronArguments = ['--inspect=0', '--remote-debugging-port=0', ...args];
       if (_os.default.platform() === 'linux') {
         const runningAsRoot = process.geteuid && process.geteuid() === 0;
         if (runningAsRoot && electronArguments.indexOf('--no-sandbox') === -1) electronArguments.unshift('--no-sandbox');
@@ -182,6 +182,16 @@ class Electron extends _instrumentation.SdkObject {
         // Packaged apps might have their own command line handling.
         electronArguments.unshift('-r', require.resolve('./loader'));
       }
+      let shell = false;
+      if (process.platform === 'win32') {
+        // On Windows in order to run .cmd files, shell: true is required.
+        // https://github.com/nodejs/node/issues/52554
+        shell = true;
+        // On Windows, we need to quote the executable path due to shell: true.
+        command = `"${command}"`;
+        // On Windows, we need to quote the arguments due to shell: true.
+        electronArguments = electronArguments.map(arg => `"${arg}"`);
+      }
 
       // When debugging Playwright test that runs Electron, NODE_OPTIONS
       // will make the debugger attach to Electron's Node. But Playwright
@@ -199,6 +209,7 @@ class Electron extends _instrumentation.SdkObject {
           progress.log(message);
           browserLogsCollector.log(message);
         },
+        shell,
         stdio: 'pipe',
         cwd: options.cwd,
         tempDirectories: [artifactsDir],
@@ -211,18 +222,24 @@ class Electron extends _instrumentation.SdkObject {
           return (_app = app) === null || _app === void 0 ? void 0 : _app.emit(ElectronApplication.Events.Close);
         }
       });
+
+      // All waitForLines must be started immediately.
+      // Otherwise the lines might come before we are ready.
       const waitForXserverError = new Promise(async (resolve, reject) => {
         waitForLine(progress, launchedProcess, /Unable to open X display/).then(() => reject(new Error(['Unable to open X display!', `================================`, 'Most likely this is because there is no X server available.', "Use 'xvfb-run' on Linux to launch your tests with an emulated display server.", "For example: 'xvfb-run npm run test:e2e'", `================================`, progress.metadata.log].join('\n')))).catch(() => {});
       });
-      const nodeMatch = await waitForLine(progress, launchedProcess, /^Debugger listening on (ws:\/\/.*)$/);
+      const nodeMatchPromise = waitForLine(progress, launchedProcess, /^Debugger listening on (ws:\/\/.*)$/);
+      const chromeMatchPromise = waitForLine(progress, launchedProcess, /^DevTools listening on (ws:\/\/.*)$/);
+      const debuggerDisconnectPromise = waitForLine(progress, launchedProcess, /Waiting for the debugger to disconnect\.\.\./);
+      const nodeMatch = await nodeMatchPromise;
       const nodeTransport = await _transport.WebSocketTransport.connect(progress, nodeMatch[1]);
       const nodeConnection = new _crConnection.CRConnection(nodeTransport, _helper.helper.debugProtocolLogger(), browserLogsCollector);
 
       // Immediately release exiting process under debug.
-      waitForLine(progress, launchedProcess, /Waiting for the debugger to disconnect\.\.\./).then(() => {
+      debuggerDisconnectPromise.then(() => {
         nodeTransport.close();
       }).catch(() => {});
-      const chromeMatch = await Promise.race([waitForLine(progress, launchedProcess, /^DevTools listening on (ws:\/\/.*)$/), waitForXserverError]);
+      const chromeMatch = await Promise.race([chromeMatchPromise, waitForXserverError]);
       const chromeTransport = await _transport.WebSocketTransport.connect(progress, chromeMatch[1]);
       const browserProcess = {
         onclose: undefined,

package/lib/server/fetch.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.GlobalAPIRequestContext = exports.BrowserContextAPIRequestContext = exports.APIRequestContext = void 0;
-var http = _interopRequireWildcard(require("http"));
-var https = _interopRequireWildcard(require("https"));
+var _http = _interopRequireDefault(require("http"));
+var _https = _interopRequireDefault(require("https"));
 var _stream = require("stream");
 var _url = _interopRequireDefault(require("url"));
 var _zlib = _interopRequireDefault(require("zlib"));
@@ -22,10 +22,9 @@ var _instrumentation = require("./instrumentation");
 var _progress = require("./progress");
 var _tracing = require("./trace/recorder/tracing");
 var _network = require("./network");
+var _socksClientCertificatesInterceptor = require("./socksClientCertificatesInterceptor");
 var _fetch = require("../checkly/fetch");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-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; }
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -74,7 +73,7 @@ class APIRequestContext extends _instrumentation.SdkObject {
     return uid;
   }
   async fetch(params, metadata) {
-    var _params$method;
+    var _params$method, _defaults$clientCerti;
     const defaults = this._defaultOptions();
     const headers = {
       'user-agent': defaults.userAgent,
@@ -98,12 +97,17 @@ class APIRequestContext extends _instrumentation.SdkObject {
       for (const {
         name,
         value
-      } of params.params) requestUrl.searchParams.set(name, value);
+      } of params.params) requestUrl.searchParams.append(name, value);
     }
+    const credentials = this._getHttpCredentials(requestUrl);
+    if ((credentials === null || credentials === void 0 ? void 0 : credentials.send) === 'always') setBasicAuthorizationHeader(headers, credentials);
     const method = ((_params$method = params.method) === null || _params$method === void 0 ? void 0 : _params$method.toUpperCase()) || 'GET';
     const proxy = defaults.proxy;
     let agent;
-    if (proxy && proxy.server !== 'per-context' && !shouldBypassProxy(requestUrl, proxy.bypass)) {
+    // When `clientCertificates` is present, we set the `proxy` property to our own socks proxy
+    // for the browser to use. However, we don't need it here, because we already respect
+    // `clientCertificates` when fetching from Node.js.
+    if (proxy && !((_defaults$clientCerti = defaults.clientCertificates) !== null && _defaults$clientCerti !== void 0 && _defaults$clientCerti.length) && proxy.server !== 'per-context' && !shouldBypassProxy(requestUrl, proxy.bypass)) {
       var _proxyOpts$protocol;
       const proxyOpts = _url.default.parse(proxy.server);
       if ((_proxyOpts$protocol = proxyOpts.protocol) !== null && _proxyOpts$protocol !== void 0 && _proxyOpts$protocol.startsWith('socks')) {
@@ -126,21 +130,30 @@ class APIRequestContext extends _instrumentation.SdkObject {
       maxRedirects: params.maxRedirects === 0 ? -1 : params.maxRedirects === undefined ? 20 : params.maxRedirects,
       timeout,
       deadline,
+      ...(0, _socksClientCertificatesInterceptor.getMatchingTLSOptionsForOrigin)(this._defaultOptions().clientCertificates, requestUrl.origin),
       __testHookLookup: params.__testHookLookup,
       tokenizedURL: params.tokenizedURL,
       ...(0, _fetch.getClientCertificates)(params)
     };
-    // rejectUnauthorized = undefined is treated as true in node 12.
+    // rejectUnauthorized = undefined is treated as true in Node.js 12.
     if (params.ignoreHTTPSErrors || defaults.ignoreHTTPSErrors) options.rejectUnauthorized = false;
     const postData = serializePostData(params, headers);
     if (postData) setHeader(headers, 'content-length', String(postData.byteLength));
     const controller = new _progress.ProgressController(metadata, this);
     const fetchResponse = await controller.run(progress => {
-      return this._sendRequest(progress, requestUrl, options, postData);
+      return this._sendRequestWithRetries(progress, requestUrl, options, postData, params.maxRetries);
     });
     const fetchUid = this._storeResponseBody(fetchResponse.body);
     this.fetchLog.set(fetchUid, controller.metadata.log);
-    if (params.failOnStatusCode && (fetchResponse.status < 200 || fetchResponse.status >= 400)) throw new Error(`${fetchResponse.status} ${fetchResponse.statusText}`);
+    if (params.failOnStatusCode && (fetchResponse.status < 200 || fetchResponse.status >= 400)) {
+      let responseText = '';
+      if (fetchResponse.body.byteLength) {
+        let text = fetchResponse.body.toString('utf8');
+        if (text.length > 1000) text = text.substring(0, 997) + '...';
+        responseText = `\nResponse text:\n${text}`;
+      }
+      throw new Error(`${fetchResponse.status} ${fetchResponse.statusText}${responseText}`);
+    }
     return {
       ...fetchResponse,
       fetchUid,
@@ -181,6 +194,25 @@ class APIRequestContext extends _instrumentation.SdkObject {
       setHeader(headers, 'cookie', valueArray.join('; '));
     }
   }
+  async _sendRequestWithRetries(progress, url, options, postData, maxRetries) {
+    var _maxRetries;
+    (_maxRetries = maxRetries) !== null && _maxRetries !== void 0 ? _maxRetries : maxRetries = 0;
+    let backoff = 250;
+    for (let i = 0; i <= maxRetries; i++) {
+      try {
+        return await this._sendRequest(progress, url, options, postData);
+      } catch (e) {
+        if (maxRetries === 0) throw e;
+        if (i === maxRetries || options.deadline && (0, _utils.monotonicTime)() + backoff > options.deadline) throw new Error(`Failed after ${i + 1} attempt(s): ${e}`);
+        // Retry on connection reset only.
+        if (e.code !== 'ECONNRESET') throw e;
+        progress.log(`  Received ECONNRESET, will retry after ${backoff}ms.`);
+        await new Promise(f => setTimeout(f, backoff));
+        backoff *= 2;
+      }
+    }
+    throw new Error('Unreachable');
+  }
   async _sendRequest(progress, url, options, postData) {
     var _getHeader;
     await this._updateRequestCookieHeader(url, options.headers);
@@ -200,7 +232,7 @@ class APIRequestContext extends _instrumentation.SdkObject {
     };
     this.emit(APIRequestContext.Events.Request, requestEvent);
     return new Promise((fulfill, reject) => {
-      const requestConstructor = (url.protocol === 'https:' ? https : http).request;
+      const requestConstructor = (url.protocol === 'https:' ? _https.default : _http.default).request;
       // If we have a proxy agent already, do not override it.
       const agent = options.agent || (url.protocol === 'https:' ? _happyEyeballs.httpsHappyEyeballsAgent : _happyEyeballs.httpHappyEyeballsAgent);
       const requestOptions = {
@@ -236,6 +268,7 @@ class APIRequestContext extends _instrumentation.SdkObject {
           }
         }
         if (redirectStatus.includes(response.statusCode) && options.maxRedirects >= 0) {
+          var _response$headers$loc;
           if (!options.maxRedirects) {
             reject(new Error('Max redirect count exceeded'));
             request.destroy();
@@ -265,18 +298,22 @@ class APIRequestContext extends _instrumentation.SdkObject {
             maxRedirects: options.maxRedirects - 1,
             timeout: options.timeout,
             deadline: options.deadline,
+            ...(0, _socksClientCertificatesInterceptor.getMatchingTLSOptionsForOrigin)(this._defaultOptions().clientCertificates, url.origin),
             __testHookLookup: options.__testHookLookup
           };
           // rejectUnauthorized = undefined is treated as true in node 12.
           if (options.rejectUnauthorized === false) redirectOptions.rejectUnauthorized = false;
 
           // HTTP-redirect fetch step 4: If locationURL is null, then return response.
-          if (response.headers.location) {
+          // Best-effort UTF-8 decoding, per spec it's US-ASCII only, but browsers are more lenient.
+          // Node.js parses it as Latin1 via std::v8::String, so we convert it to UTF-8.
+          const locationHeaderValue = Buffer.from((_response$headers$loc = response.headers.location) !== null && _response$headers$loc !== void 0 ? _response$headers$loc : '', 'latin1').toString('utf8');
+          if (locationHeaderValue) {
             let locationURL;
             try {
-              locationURL = new URL(response.headers.location, url);
+              locationURL = new URL(locationHeaderValue, url);
             } catch (error) {
-              reject(new Error(`uri requested responds with an invalid redirect URL: ${response.headers.location}`));
+              reject(new Error(`uri requested responds with an invalid redirect URL: ${locationHeaderValue}`));
               request.destroy();
               return;
             }
@@ -291,12 +328,7 @@ class APIRequestContext extends _instrumentation.SdkObject {
           const auth = response.headers['www-authenticate'];
           const credentials = this._getHttpCredentials(url);
           if (auth !== null && auth !== void 0 && auth.trim().startsWith('Basic') && credentials) {
-            const {
-              username,
-              password
-            } = credentials;
-            const encoded = Buffer.from(`${username || ''}:${password || ''}`).toString('base64');
-            setHeader(options.headers, 'authorization', `Basic ${encoded}`);
+            setBasicAuthorizationHeader(options.headers, credentials);
             notifyRequestFinished();
             fulfill(this._sendRequest(progress, url, options, postData));
             request.destroy();
@@ -334,7 +366,10 @@ class APIRequestContext extends _instrumentation.SdkObject {
             finishFlush: _zlib.default.constants.Z_SYNC_FLUSH
           });
         } else if (encoding === 'br') {
-          transform = _zlib.default.createBrotliDecompress();
+          transform = _zlib.default.createBrotliDecompress({
+            flush: _zlib.default.constants.BROTLI_OPERATION_FLUSH,
+            finishFlush: _zlib.default.constants.BROTLI_OPERATION_FLUSH
+          });
         } else if (encoding === 'deflate') {
           transform = _zlib.default.createInflate();
         }
@@ -351,8 +386,8 @@ class APIRequestContext extends _instrumentation.SdkObject {
         body.on('data', chunk => chunks.push(chunk));
         body.on('end', notifyBodyFinished);
       });
+      request.on('error', error => reject((0, _socksClientCertificatesInterceptor.rewriteOpenSSLErrorIfNeeded)(error)));
       (0, _fetch.addRequestListeners)(request, timings);
-      request.on('error', reject);
       const disposeListener = () => {
         reject(new Error('Request context disposed.'));
         request.destroy();
@@ -417,7 +452,8 @@ class BrowserContextAPIRequestContext extends APIRequestContext {
   tracing() {
     return this._context.tracing;
   }
-  async dispose() {
+  async dispose(options) {
+    this._closeReason = options.reason;
     this.fetchResponses.clear();
   }
   _defaultOptions() {
@@ -428,7 +464,8 @@ class BrowserContextAPIRequestContext extends APIRequestContext {
       proxy: this._context._options.proxy || this._context._browser.options.proxy,
       timeoutSettings: this._context._timeoutSettings,
       ignoreHTTPSErrors: this._context._options.ignoreHTTPSErrors,
-      baseURL: this._context._options.baseURL
+      baseURL: this._context._options.baseURL,
+      clientCertificates: this._context._options.clientCertificates
     };
   }
   async _addCookies(cookies) {
@@ -457,17 +494,20 @@ class GlobalAPIRequestContext extends APIRequestContext {
       let url = proxy === null || proxy === void 0 ? void 0 : proxy.server.trim();
       if (!/^\w+:\/\//.test(url)) url = 'http://' + url;
       proxy.server = url;
+      if (options.clientCertificates) throw new Error('Cannot specify both proxy and clientCertificates');
     }
     if (options.storageState) {
       this._origins = options.storageState.origins;
       this._cookieStore.addCookies(options.storageState.cookies || []);
     }
+    (0, _browserContext.verifyClientCertificates)(options.clientCertificates);
     this._options = {
       baseURL: options.baseURL,
       userAgent: options.userAgent || (0, _userAgent.getUserAgent)(),
       extraHTTPHeaders: options.extraHTTPHeaders,
       ignoreHTTPSErrors: !!options.ignoreHTTPSErrors,
       httpCredentials: options.httpCredentials,
+      clientCertificates: options.clientCertificates,
       proxy,
       timeoutSettings
     };
@@ -476,7 +516,8 @@ class GlobalAPIRequestContext extends APIRequestContext {
   tracing() {
     return this._tracing;
   }
-  async dispose() {
+  async dispose(options) {
+    this._closeReason = options.reason;
     await this._tracing.flush();
     await this._tracing.deleteTmpTracesDir();
     this._disposeImpl();
@@ -632,4 +673,12 @@ function shouldBypassProxy(url, bypass) {
   });
   const domain = '.' + url.hostname;
   return domains.some(d => domain.endsWith(d));
+}
+function setBasicAuthorizationHeader(headers, credentials) {
+  const {
+    username,
+    password
+  } = credentials;
+  const encoded = Buffer.from(`${username || ''}:${password || ''}`).toString('base64');
+  setHeader(headers, 'authorization', `Basic ${encoded}`);
 }

package/lib/server/fileUploadUtils.js

@@ -33,13 +33,16 @@ async function prepareFilesForUpload(frame, params) {
   var _fileBuffers;
   const {
     payloads,
-    streams
+    streams,
+    directoryStream
   } = params;
   let {
-    localPaths
+    localPaths,
+    localDirectory
   } = params;
-  if ([payloads, localPaths, streams].filter(Boolean).length !== 1) throw new Error('Exactly one of payloads, localPaths and streams must be provided');
+  if ([payloads, localPaths, localDirectory, streams, directoryStream].filter(Boolean).length !== 1) throw new Error('Exactly one of payloads, localPaths and streams must be provided');
   if (streams) localPaths = streams.map(c => c.path());
+  if (directoryStream) localDirectory = directoryStream.path();
   if (localPaths) {
     for (const p of localPaths) (0, _utils.assert)(_path.default.isAbsolute(p) && _path.default.resolve(p) === p, 'Paths provided to localPaths must be absolute and fully resolved.');
   }
@@ -66,6 +69,7 @@ async function prepareFilesForUpload(frame, params) {
   }));
   return {
     localPaths,
+    localDirectory,
     filePayloads
   };
 }