webdriverio/build/utils/interception/devtools.js

Next-gen browser and mobile automation test framework for Node.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _fs = _interopRequireDefault(require("fs"));

var _path = _interopRequireDefault(require("path"));

var _atob = _interopRequireDefault(require("atob"));

var _minimatch = _interopRequireDefault(require("minimatch"));

var _utils = require("@wdio/utils");

var _ = _interopRequireDefault(require("./"));

var _2 = require("..");

var _constants = require("../../constants");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

class DevtoolsInterception extends _.default {
  static handleRequestInterception(client, mocks) {
    return async event => {
      const responseHeaders = event.responseHeaders.reduce((headers, {
        name,
        value
      }) => {
        headers[name] = value;
        return headers;
      }, {});
      const {
        requestId,
        request
      } = event;

      for (const mock of mocks) {
        if (!(0, _minimatch.default)(request.url, mock.url)) {
          continue;
        }

        if (mock.filterOptions.method && mock.filterOptions.method.toLowerCase() !== request.method.toLowerCase() || mock.filterOptions.headers && (0, _2.containsHeaderObject)(responseHeaders, mock.filterOptions.headers)) {
          continue;
        }

        const {
          body,
          base64Encoded
        } = await client.send('Fetch.getResponseBody', {
          requestId
        }).catch(() => ({}));
        request.body = base64Encoded ? (0, _atob.default)(body) : body;
        request.body = responseHeaders['Content-Type'] && responseHeaders['Content-Type'].includes('application/json') ? JSON.parse(request.body) : request.body;
        mock.matches.push(request);

        if (mock.respondOverwrites.length === 0) {
          continue;
        }

        const {
          errorReason,
          overwrite,
          params
        } = mock.respondOverwrites[0].sticky ? mock.respondOverwrites[0] : mock.respondOverwrites.shift();

        if (overwrite !== undefined) {
          let newBody = overwrite;

          if (typeof overwrite === 'function') {
            newBody = await overwrite(request, client);
          }

          if (typeof newBody !== 'string') {
            newBody = JSON.stringify(newBody);
          }

          let responseCode = params.statusCode || event.responseStatusCode;
          let responseHeaders = [...event.responseHeaders, ...Object.entries(params.headers || {}).map(([key, value]) => {
            key, value;
          })];
          const responseFilePath = _path.default.isAbsolute(newBody) ? newBody : _path.default.join(process.cwd(), newBody);

          if (_fs.default.existsSync(responseFilePath) && (0, _utils.canAccess)(responseFilePath)) {
            newBody = _fs.default.readFileSync(responseFilePath).toString();
          } else if (newBody.startsWith('http')) {
            responseCode = 301;
            responseHeaders = responseHeaders.filter(({
              name
            }) => name.toLowerCase() !== 'location');
            responseHeaders.push({
              name: 'Location',
              value: newBody
            });
          }

          request.mockedResponse = newBody;
          return client.send('Fetch.fulfillRequest', {
            requestId,
            responseCode,
            responseHeaders,
            body: Buffer.from(newBody).toString('base64')
          });
        }

        if (errorReason) {
          return client.send('Fetch.failRequest', {
            requestId,
            errorReason
          });
        }
      }

      return client.send('Fetch.continueRequest', {
        requestId
      });
    };
  }

  get calls() {
    return this.matches;
  }

  clear() {
    this.matches = [];
  }

  restore() {
    this.clear();
    this.respondOverwrites = [];
  }

  respond(overwrite, params = {}) {
    this.respondOverwrites.push({
      overwrite,
      params,
      sticky: true
    });
  }

  respondOnce(overwrite, params = {}) {
    this.respondOverwrites.push({
      overwrite,
      params
    });
  }

  abort(errorReason, sticky = true) {
    if (typeof errorReason !== 'string' || !_constants.ERROR_REASON.includes(errorReason)) {
      throw new Error(`Invalid value for errorReason, allowed are: ${_constants.ERROR_REASON.join(', ')}`);
    }

    this.respondOverwrites.push({
      errorReason,
      sticky
    });
  }

  abortOnce(errorReason) {
    this.abort(errorReason, false);
  }

}

exports.default = DevtoolsInterception;