@checkly/playwright-core 1.41.2-beta.0

package/lib/server/trace/viewer/traceViewer.js

@@ -0,0 +1,229 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.openTraceInBrowser = openTraceInBrowser;
+exports.openTraceViewerApp = openTraceViewerApp;
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+var _httpServer = require("../../../utils/httpServer");
+var _utils = require("../../../utils");
+var _launchApp = require("../../launchApp");
+var _instrumentation = require("../../instrumentation");
+var _playwright = require("../../playwright");
+var _progress = require("../../progress");
+var _utilsBundle = require("../../../utilsBundle");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * 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.
+ */
+
+async function startTraceViewerServer(traceUrls, options) {
+  for (const traceUrl of traceUrls) {
+    let traceFile = traceUrl;
+    // If .json is requested, we'll synthesize it.
+    if (traceUrl.endsWith('.json')) traceFile = traceUrl.substring(0, traceUrl.length - '.json'.length);
+    if (!traceUrl.startsWith('http://') && !traceUrl.startsWith('https://') && !_fs.default.existsSync(traceFile) && !_fs.default.existsSync(traceFile + '.trace')) {
+      // eslint-disable-next-line no-console
+      console.error(`Trace file ${traceUrl} does not exist!`);
+      (0, _utils.gracefullyProcessExitDoNotHang)(1);
+    }
+  }
+  const server = new _httpServer.HttpServer();
+  server.routePrefix('/trace', (request, response) => {
+    const url = new URL('http://localhost' + request.url);
+    const relativePath = url.pathname.slice('/trace'.length);
+    if (relativePath.endsWith('/stall.js')) return true;
+    if (relativePath.startsWith('/file')) {
+      try {
+        const filePath = url.searchParams.get('path');
+        if (_fs.default.existsSync(filePath)) return server.serveFile(request, response, url.searchParams.get('path'));
+
+        // If .json is requested, we'll synthesize it for zip-less operation.
+        if (filePath.endsWith('.json')) {
+          const traceName = filePath.substring(0, filePath.length - '.json'.length);
+          response.statusCode = 200;
+          response.setHeader('Content-Type', 'application/json');
+          response.end(JSON.stringify(traceDescriptor(traceName)));
+          return true;
+        }
+      } catch (e) {}
+      response.statusCode = 404;
+      response.end();
+      return true;
+    }
+    const absolutePath = _path.default.join(__dirname, '..', '..', '..', 'vite', 'traceViewer', ...relativePath.split('/'));
+    return server.serveFile(request, response, absolutePath);
+  });
+  const params = traceUrls.map(t => `trace=${encodeURIComponent(t)}`);
+  const transport = (options === null || options === void 0 ? void 0 : options.transport) || (options !== null && options !== void 0 && options.isServer ? new StdinServer() : undefined);
+  if (transport) {
+    const guid = (0, _utils.createGuid)();
+    params.push('ws=' + guid);
+    const wss = new _utilsBundle.wsServer({
+      server: server.server(),
+      path: '/' + guid
+    });
+    wss.on('connection', ws => {
+      transport.sendEvent = (method, params) => ws.send(JSON.stringify({
+        method,
+        params
+      }));
+      transport.close = () => ws.close();
+      ws.on('message', async message => {
+        const {
+          id,
+          method,
+          params
+        } = JSON.parse(message);
+        const result = await transport.dispatch(method, params);
+        ws.send(JSON.stringify({
+          id,
+          result
+        }));
+      });
+      ws.on('close', () => transport.onclose());
+      ws.on('error', () => transport.onclose());
+    });
+  }
+  if (options !== null && options !== void 0 && options.isServer) params.push('isServer');
+  if ((0, _utils.isUnderTest)()) params.push('isUnderTest=true');
+  const {
+    host,
+    port
+  } = options || {};
+  const url = await server.start({
+    preferredPort: port,
+    host
+  });
+  const {
+    app
+  } = options || {};
+  const searchQuery = params.length ? '?' + params.join('&') : '';
+  const urlPath = `/trace/${app || 'index.html'}${searchQuery}`;
+  server.routePath('/', (request, response) => {
+    response.statusCode = 302;
+    response.setHeader('Location', urlPath + request.url.substring(1));
+    response.end();
+    return true;
+  });
+  return {
+    server,
+    url
+  };
+}
+async function openTraceViewerApp(traceUrls, browserName, options) {
+  const {
+    url
+  } = await startTraceViewerServer(traceUrls, options);
+  const traceViewerPlaywright = (0, _playwright.createPlaywright)({
+    sdkLanguage: 'javascript',
+    isInternalPlaywright: true
+  });
+  const traceViewerBrowser = (0, _utils.isUnderTest)() ? 'chromium' : browserName;
+  const {
+    context,
+    page
+  } = await (0, _launchApp.launchApp)(traceViewerPlaywright[traceViewerBrowser], {
+    // TODO: store language in the trace.
+    sdkLanguage: traceViewerPlaywright.options.sdkLanguage,
+    windowSize: {
+      width: 1280,
+      height: 800
+    },
+    persistentContextOptions: {
+      ...(options === null || options === void 0 ? void 0 : options.persistentContextOptions),
+      useWebSocket: (0, _utils.isUnderTest)(),
+      headless: options === null || options === void 0 ? void 0 : options.headless
+    }
+  });
+  const controller = new _progress.ProgressController((0, _instrumentation.serverSideCallMetadata)(), context._browser);
+  await controller.run(async progress => {
+    await context._browser._defaultContext._loadDefaultContextAsIs(progress);
+  });
+  if (process.env.PWTEST_PRINT_WS_ENDPOINT) process.stderr.write('DevTools listening on: ' + context._browser.options.wsEndpoint + '\n');
+  if (!(0, _utils.isUnderTest)()) await (0, _launchApp.syncLocalStorageWithSettings)(page, 'traceviewer');
+  if ((0, _utils.isUnderTest)()) page.on('close', () => context.close({
+    reason: 'Trace viewer closed'
+  }).catch(() => {}));
+  await page.mainFrame().goto((0, _instrumentation.serverSideCallMetadata)(), url);
+  return page;
+}
+async function openTraceInBrowser(traceUrls, options) {
+  const {
+    url
+  } = await startTraceViewerServer(traceUrls, options);
+  // eslint-disable-next-line no-console
+  console.log('\nListening on ' + url);
+  if (!(0, _utils.isUnderTest)()) await (0, _utilsBundle.open)(url.replace('0.0.0.0', 'localhost')).catch(() => {});
+}
+class StdinServer {
+  constructor() {
+    this._pollTimer = void 0;
+    this._traceUrl = void 0;
+    this.sendEvent = void 0;
+    this.close = void 0;
+    process.stdin.on('data', data => {
+      const url = data.toString().trim();
+      if (url === this._traceUrl) return;
+      if (url.endsWith('.json')) this._pollLoadTrace(url);else this._loadTrace(url);
+    });
+    process.stdin.on('close', () => (0, _utils.gracefullyProcessExitDoNotHang)(0));
+  }
+  async dispatch(method, params) {
+    if (method === 'ready') {
+      if (this._traceUrl) this._loadTrace(this._traceUrl);
+    }
+  }
+  onclose() {
+    (0, _utils.gracefullyProcessExitDoNotHang)(0);
+  }
+  _loadTrace(url) {
+    var _this$sendEvent;
+    this._traceUrl = url;
+    clearTimeout(this._pollTimer);
+    (_this$sendEvent = this.sendEvent) === null || _this$sendEvent === void 0 || _this$sendEvent.call(this, 'loadTrace', {
+      url
+    });
+  }
+  _pollLoadTrace(url) {
+    this._loadTrace(url);
+    this._pollTimer = setTimeout(() => {
+      this._pollLoadTrace(url);
+    }, 500);
+  }
+}
+function traceDescriptor(traceName) {
+  const result = {
+    entries: []
+  };
+  const traceDir = _path.default.dirname(traceName);
+  const traceFile = _path.default.basename(traceName);
+  for (const name of _fs.default.readdirSync(traceDir)) {
+    if (name.startsWith(traceFile)) result.entries.push({
+      name,
+      path: _path.default.join(traceDir, name)
+    });
+  }
+  const resourcesDir = _path.default.join(traceDir, 'resources');
+  if (_fs.default.existsSync(resourcesDir)) {
+    for (const name of _fs.default.readdirSync(resourcesDir)) result.entries.push({
+      name: 'resources/' + name,
+      path: _path.default.join(resourcesDir, name)
+    });
+  }
+  return result;
+}

package/lib/server/transport.js

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.perMessageDeflate = exports.WebSocketTransport = void 0;
+var _utilsBundle = require("../utilsBundle");
+var _utils = require("../utils");
+var _happyEyeballs = require("../utils/happy-eyeballs");
+/**
+ * Copyright 2018 Google Inc. All rights reserved.
+ * Modifications 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.
+ */
+
+const perMessageDeflate = exports.perMessageDeflate = {
+  zlibDeflateOptions: {
+    level: 3
+  },
+  zlibInflateOptions: {
+    chunkSize: 10 * 1024
+  },
+  threshold: 10 * 1024
+};
+class WebSocketTransport {
+  static async connect(progress, url, headers, followRedirects, debugLogHeader) {
+    return await WebSocketTransport._connect(progress, url, headers || {}, {
+      follow: !!followRedirects,
+      hadRedirects: false
+    }, debugLogHeader);
+  }
+  static async _connect(progress, url, headers, redirect, debugLogHeader) {
+    const logUrl = stripQueryParams(url);
+    progress === null || progress === void 0 || progress.log(`<ws connecting> ${logUrl}`);
+    const transport = new WebSocketTransport(progress, url, logUrl, headers, redirect.follow && redirect.hadRedirects, debugLogHeader);
+    let success = false;
+    progress === null || progress === void 0 || progress.cleanupWhenAborted(async () => {
+      if (!success) await transport.closeAndWait().catch(e => null);
+    });
+    const result = await new Promise((fulfill, reject) => {
+      transport._ws.on('open', async () => {
+        progress === null || progress === void 0 || progress.log(`<ws connected> ${logUrl}`);
+        fulfill({
+          transport
+        });
+      });
+      transport._ws.on('error', event => {
+        progress === null || progress === void 0 || progress.log(`<ws connect error> ${logUrl} ${event.message}`);
+        reject(new Error('WebSocket error: ' + event.message));
+        transport._ws.close();
+      });
+      transport._ws.on('unexpected-response', (request, response) => {
+        if (redirect.follow && !redirect.hadRedirects && (response.statusCode === 301 || response.statusCode === 302 || response.statusCode === 307 || response.statusCode === 308)) {
+          fulfill({
+            redirect: response
+          });
+          transport._ws.close();
+          return;
+        }
+        for (let i = 0; i < response.rawHeaders.length; i += 2) {
+          if (debugLogHeader && response.rawHeaders[i] === debugLogHeader) progress === null || progress === void 0 || progress.log(response.rawHeaders[i + 1]);
+        }
+        const chunks = [];
+        const errorPrefix = `${logUrl} ${response.statusCode} ${response.statusMessage}`;
+        response.on('data', chunk => chunks.push(chunk));
+        response.on('close', () => {
+          const error = chunks.length ? `${errorPrefix}\n${Buffer.concat(chunks)}` : errorPrefix;
+          progress === null || progress === void 0 || progress.log(`<ws unexpected response> ${error}`);
+          reject(new Error('WebSocket error: ' + error));
+          transport._ws.close();
+        });
+      });
+    });
+    if (result.redirect) {
+      // Strip authorization headers from the redirected request.
+      const newHeaders = Object.fromEntries(Object.entries(headers || {}).filter(([name]) => {
+        return !name.includes('access-key') && name.toLowerCase() !== 'authorization';
+      }));
+      return WebSocketTransport._connect(progress, result.redirect.headers.location, newHeaders, {
+        follow: true,
+        hadRedirects: true
+      }, debugLogHeader);
+    }
+    success = true;
+    return transport;
+  }
+  constructor(progress, url, logUrl, headers, followRedirects, debugLogHeader) {
+    var _progress$timeUntilDe;
+    this._ws = void 0;
+    this._progress = void 0;
+    this._logUrl = void 0;
+    this.onmessage = void 0;
+    this.onclose = void 0;
+    this.wsEndpoint = void 0;
+    this.headers = [];
+    this.wsEndpoint = url;
+    this._logUrl = logUrl;
+    this._ws = new _utilsBundle.ws(url, [], {
+      maxPayload: 256 * 1024 * 1024,
+      // 256Mb,
+      // Prevent internal http client error when passing negative timeout.
+      handshakeTimeout: Math.max((_progress$timeUntilDe = progress === null || progress === void 0 ? void 0 : progress.timeUntilDeadline()) !== null && _progress$timeUntilDe !== void 0 ? _progress$timeUntilDe : 30_000, 1),
+      headers,
+      followRedirects,
+      agent: /^(https|wss):\/\//.test(url) ? _happyEyeballs.httpsHappyEyeballsAgent : _happyEyeballs.httpHappyEyeballsAgent,
+      perMessageDeflate
+    });
+    this._ws.on('upgrade', response => {
+      for (let i = 0; i < response.rawHeaders.length; i += 2) {
+        this.headers.push({
+          name: response.rawHeaders[i],
+          value: response.rawHeaders[i + 1]
+        });
+        if (debugLogHeader && response.rawHeaders[i] === debugLogHeader) progress === null || progress === void 0 || progress.log(response.rawHeaders[i + 1]);
+      }
+    });
+    this._progress = progress;
+    // The 'ws' module in node sometimes sends us multiple messages in a single task.
+    // In Web, all IO callbacks (e.g. WebSocket callbacks)
+    // are dispatched into separate tasks, so there's no need
+    // to do anything extra.
+    const messageWrap = (0, _utils.makeWaitForNextTask)();
+    this._ws.addEventListener('message', event => {
+      messageWrap(() => {
+        const eventData = event.data;
+        let parsedJson;
+        try {
+          parsedJson = JSON.parse(eventData);
+        } catch (e) {
+          var _this$_progress;
+          (_this$_progress = this._progress) === null || _this$_progress === void 0 || _this$_progress.log(`<closing ws> Closing websocket due to malformed JSON. eventData=${eventData} e=${e === null || e === void 0 ? void 0 : e.message}`);
+          this._ws.close();
+          return;
+        }
+        try {
+          if (this.onmessage) this.onmessage.call(null, parsedJson);
+        } catch (e) {
+          var _this$_progress2;
+          (_this$_progress2 = this._progress) === null || _this$_progress2 === void 0 || _this$_progress2.log(`<closing ws> Closing websocket due to failed onmessage callback. eventData=${eventData} e=${e === null || e === void 0 ? void 0 : e.message}`);
+          this._ws.close();
+        }
+      });
+    });
+    this._ws.addEventListener('close', event => {
+      var _this$_progress3;
+      (_this$_progress3 = this._progress) === null || _this$_progress3 === void 0 || _this$_progress3.log(`<ws disconnected> ${logUrl} code=${event.code} reason=${event.reason}`);
+      if (this.onclose) this.onclose.call(null);
+    });
+    // Prevent Error: read ECONNRESET.
+    this._ws.addEventListener('error', error => {
+      var _this$_progress4;
+      return (_this$_progress4 = this._progress) === null || _this$_progress4 === void 0 ? void 0 : _this$_progress4.log(`<ws error> ${logUrl} ${error.type} ${error.message}`);
+    });
+  }
+  send(message) {
+    this._ws.send(JSON.stringify(message));
+  }
+  close() {
+    var _this$_progress5;
+    (_this$_progress5 = this._progress) === null || _this$_progress5 === void 0 || _this$_progress5.log(`<ws disconnecting> ${this._logUrl}`);
+    this._ws.close();
+  }
+  async closeAndWait() {
+    if (this._ws.readyState === _utilsBundle.ws.CLOSED) return;
+    const promise = new Promise(f => this._ws.once('close', f));
+    this.close();
+    await promise; // Make sure to await the actual disconnect.
+  }
+}
+exports.WebSocketTransport = WebSocketTransport;
+function stripQueryParams(url) {
+  try {
+    const u = new URL(url);
+    u.search = '';
+    u.hash = '';
+    return u.toString();
+  } catch {
+    return url;
+  }
+}

package/lib/server/types.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.kLifecycleEvents = void 0;
+/**
+ * Copyright 2018 Google Inc. All rights reserved.
+ * Modifications 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.
+ */
+
+const kLifecycleEvents = exports.kLifecycleEvents = new Set(['load', 'domcontentloaded', 'networkidle', 'commit']);