@telefonica/acceptance-testing 3.0.0 → 4.0.0

package/README.md

@@ -251,26 +251,63 @@ await elementHandle.uploadFile(prepareFile('/path/to/file'));
 
 ## Collecting coverage
 
-This library automatically collects code coverage after each test by reading the `window.__coverage__` object
-if available.
+Set the `COLLECT_ACCEPTANCE_COVERAGE` environment variable to enable coverage collection.
 
-To create that object you should instrument the code with an `istanbul` compatible tool (for example
-[babel-plugin-istanbul](https://github.com/istanbuljs/babel-plugin-istanbul)).
+The code must be instrumented with [nyc](https://github.com/istanbuljs/nyc/blob/main/docs/instrument.md),
+[babel-plugin-istanbul](https://github.com/istanbuljs/babel-plugin-istanbul) or any
+[istanbul](https://github.com/istanbuljs/istanbuljs) compatible tool.
 
-The coverage report for each test will be saved as `json` files. To change the destination folder, set the
-`coveragePath` property in your config. The default value is `reports/coverage-acceptance`.
+### Frontend coverage information
+
+After each test the coverage information will be collected by reading the `window.__coverage__` object from
+the opened page.
+
+### Backend coverage information
+
+To collect coverage from your backend, you must create an endpoint that serves the coverage information and
+specify it the `coverageUrls` property in your config. The library will make a `GET` request to each URL and
+save the report from the response as a `json` file. The default value is `[]`.
+
+The backend coverage will be collected after all the tests in the suite have run.
+
+The response must be a JSON with the following structure: `{coverage: data}`.
+
+Example route in NextJS to serve coverage information:
+
+```ts
+import {NextResponse} from 'next/server';
+
+export const GET = (): NextResponse => {
+  const coverage = (globalThis as any).__coverage__;
+  if (coverage) {
+    return NextResponse.json({coverage});
+  }
+  return NextResponse.json({error: 'Not found'}, {status: 404});
+};
+
+export const dynamic = 'force-dynamic';
+```
+
+### Configuration
+
+The coverage information will be saved as `json` files. To change the destination folder, set the
+`coveragePath` property in your config. The default value is `reports/coverage-acceptance`. The `json` files
+will be stored inside `<coveragePath>/.nyc_output`.
 
 Example config:
 
 ```json
 {
   "acceptanceTests": {
-    "coveragePath": "coverage/acceptance"
+    "coveragePath": "coverage/acceptance",
+    "coverageUrls": ["http://localhost:3000/api/coverage"]
   }
 }
 ```
 
-After running the tests, you can use a tool like `nyc` to generate the coverage summaries.
+### Generate coverage reports
+
+After running the tests, you can use a tool like `nyc` to generate the coverage reports.
 
 ## Troubleshooting
 

package/dist/acceptance-testing.cjs.development.js

@@ -11,6 +11,7 @@ var pptrTestingLibrary = require('pptr-testing-library');
 var jestImageSnapshot = require('jest-image-snapshot');
 var globToRegExp = _interopDefault(require('glob-to-regexp'));
 var child_process = require('child_process');
+var istanbul = _interopDefault(require('istanbul-lib-coverage'));
 
 function _regeneratorRuntime() {
   _regeneratorRuntime = function () {
@@ -370,6 +371,27 @@ function _objectWithoutPropertiesLoose(source, excluded) {
   return target;
 }
 
+/**
+ * Debug function that logs to the console if the DEBUG_ACCEPTANCE_TESTING environment variable is set
+ */
+var debug = function debug() {
+  if (process.env.DEBUG_ACCEPTANCE_TESTING) {
+    var _console;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    (_console = console).debug.apply(_console, ['[acceptance-testing]'].concat(args));
+  }
+};
+/**
+ * Returns true if the current path matches the spied path, including parameters
+ */
+var matchPath = function matchPath(spiedPath, currentPath) {
+  var normalizedCurrentPath = path.normalize(currentPath);
+  var pattern = globToRegExp(spiedPath);
+  return pattern.test(normalizedCurrentPath);
+};
+
 var getGlobalPage = function getGlobalPage() {
   return global.page;
 };
@@ -391,80 +413,148 @@ var getRootPath = function getRootPath() {
 var prepareCoverageReportPath = function prepareCoverageReportPath(_ref) {
   var coveragePath = _ref.coveragePath;
   var ppidFile = path.join(coveragePath, '.ppid');
+  var nycOutputPath = path.join(coveragePath, '.nyc_output');
   var ppid = process.ppid.toString();
   if (!fs.existsSync(ppidFile) || fs.readFileSync(ppidFile, 'utf-8') !== ppid) {
     // the condition is just to make sure we don't remove files outside the repo
     if (getRootPath() === process.cwd() && path.normalize(coveragePath).startsWith(process.cwd())) {
-      fs.rmSync(coveragePath, {
+      fs.rmSync(nycOutputPath, {
         recursive: true,
         force: true
       });
     }
-    fs.mkdirSync(coveragePath, {
+    fs.mkdirSync(nycOutputPath, {
       recursive: true
     });
     fs.writeFileSync(ppidFile, ppid);
   }
 };
+var workerId = process.env.JEST_WORKER_ID || '0';
+/**
+ * Writes the coverage reports into single files, one per each coverage object (path). This makes it easier to merge them.
+ * The `workerId` from jest is used to avoid race conditions when multiple workers are running in parallel.
+ */
+var writeCombinedCoverage = function writeCombinedCoverage(nycOutputPath, coverage) {
+  Object.values(coverage).forEach(function (value) {
+    if (value && value.path && value.hash) {
+      var _currentCoverage;
+      var filename = path.join(nycOutputPath, value.hash + "-" + workerId + ".json");
+      var currentCoverage = (_currentCoverage = {}, _currentCoverage[value.path] = value, _currentCoverage);
+      var previousCoverage = fs.existsSync(filename) ? JSON.parse(fs.readFileSync(filename, 'utf8')) : {};
+      var mergedCoverage = istanbul.createCoverageMap(previousCoverage);
+      mergedCoverage.merge(currentCoverage);
+      debug('Writing merged coverage:', value.path, value.hash);
+      fs.writeFileSync(filename, JSON.stringify(mergedCoverage.toJSON(), null, 2));
+    } else {
+      debug('Skip write coverage. Missing path or hash:', value);
+    }
+  });
+};
 /**
- * Asumes the code was instrumented with istanbul and the coverage report stored in `window.__coverage__`.
+ * Assumes the code was instrumented with istanbul/nyc and the coverage report stored in `window.__coverage__`.
  * If not, this function does nothing.
  */
-var collectCoverageIfAvailable = /*#__PURE__*/function () {
+var collectFrontendCoverage = /*#__PURE__*/function () {
   var _ref3 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(_ref2) {
-    var coveragePath, coverage, nycOutputPath;
+    var coveragePath, nycOutputPath, coverage;
     return _regeneratorRuntime().wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
         case 0:
           coveragePath = _ref2.coveragePath;
-          _context.next = 3;
+          nycOutputPath = path.join(coveragePath, '.nyc_output');
+          _context.next = 4;
           return getGlobalPage().evaluate(function () {
             return window.__coverage__;
           });
-        case 3:
+        case 4:
           coverage = _context.sent;
           if (coverage) {
-            _context.next = 6;
+            _context.next = 8;
             break;
           }
+          debug('Skipping coverage collection. No coverage found.');
           return _context.abrupt("return");
-        case 6:
+        case 8:
+          debug('Frontend coverage found');
           prepareCoverageReportPath({
             coveragePath: coveragePath
           });
-          nycOutputPath = path.join(coveragePath, '.nyc_output');
           fs.mkdirSync(nycOutputPath, {
             recursive: true
           });
-          Object.values(coverage).forEach(function (cov) {
-            if (cov && cov.path && cov.hash) {
-              var _JSON$stringify;
-              fs.writeFileSync(path.join(nycOutputPath, cov.hash + '.json'), JSON.stringify((_JSON$stringify = {}, _JSON$stringify[cov.path] = cov, _JSON$stringify)));
-            }
-          });
-        case 10:
+          writeCombinedCoverage(nycOutputPath, coverage);
+        case 12:
         case "end":
           return _context.stop();
       }
     }, _callee);
   }));
-  return function collectCoverageIfAvailable(_x) {
+  return function collectFrontendCoverage(_x) {
     return _ref3.apply(this, arguments);
   };
 }();
-
+var writeCoverage = function writeCoverage(nycOutputPath, nameSuffix, coverage) {
+  Object.values(coverage).forEach(function (value) {
+    if (value && value.path && value.hash) {
+      var _JSON$stringify;
+      var filename = path.join(nycOutputPath, "" + value.hash + nameSuffix + ".json");
+      debug('Writing coverage:', value.path, value.hash);
+      fs.writeFileSync(filename, JSON.stringify((_JSON$stringify = {}, _JSON$stringify[value.path] = value, _JSON$stringify), null, 2));
+    } else {
+      debug('Skip write coverage. Missing path or hash:', value);
+    }
+  });
+};
 /**
- * Returns true if the current path matches the spied path, including parameters
+ * Collects backend coverage reports from the provided URLs and stores them in the coverage folder
  */
-var matchPath = function matchPath(spiedPath, currentPath) {
-  var normalizedCurrentPath = path.normalize(currentPath);
-  var pattern = globToRegExp(spiedPath);
-  return pattern.test(normalizedCurrentPath);
-};
+var collectBackendCoverage = /*#__PURE__*/function () {
+  var _ref5 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref4) {
+    var coveragePath, coverageUrls, nycOutputPath, serverReports;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          coveragePath = _ref4.coveragePath, coverageUrls = _ref4.coverageUrls;
+          nycOutputPath = path.join(coveragePath, '.nyc_output');
+          debug('Collecting backend coverage reports', coverageUrls);
+          _context2.next = 5;
+          return Promise.all(coverageUrls.map(function (url) {
+            return fetch(url).then(function (res) {
+              var _res$headers$get;
+              if (res.ok && res.status === 200 && (_res$headers$get = res.headers.get('content-type')) != null && _res$headers$get.includes('application/json')) {
+                return res.json();
+              }
+              debug('Error fetching coverage report:', {
+                url: url,
+                status: res.status
+              });
+              return null;
+            })["catch"](function () {
+              debug('Error fetching coverage report:', {
+                url: url
+              });
+              return null;
+            });
+          }));
+        case 5:
+          serverReports = _context2.sent;
+          serverReports.forEach(function (report, index) {
+            writeCoverage(nycOutputPath, "-backend" + index, report.coverage);
+          });
+        case 7:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function collectBackendCoverage(_x2) {
+    return _ref5.apply(this, arguments);
+  };
+}();
 
 var _excluded = ["captureBeyondViewport"],
   _excluded2 = ["userAgent", "isDarkMode", "viewport", "cookies"];
-var _pkg$acceptanceTests, _ref, _projectConfig$covera;
+var _pkg$acceptanceTests, _ref, _projectConfig$covera, _projectConfig$covera2;
 var LINUX_DOCKER_HOST_IP = '172.17.0.1';
 var getGlobalBrowser = function getGlobalBrowser() {
   return global.browser;
@@ -536,8 +626,10 @@ var serverHostName = /*#__PURE__*/function () {
 var rootDir = /*#__PURE__*/findRoot( /*#__PURE__*/process.cwd());
 var pkg = /*#__PURE__*/JSON.parse( /*#__PURE__*/fs.readFileSync( /*#__PURE__*/path.join(rootDir, 'package.json'), 'utf-8'));
 var projectConfig = (_pkg$acceptanceTests = pkg.acceptanceTests) != null ? _pkg$acceptanceTests : {};
+debug('Project config:', projectConfig);
 var server = (_ref = isCi ? projectConfig.ciServer : projectConfig.devServer) != null ? _ref : projectConfig.server;
 var coveragePath = /*#__PURE__*/path.join(rootDir, (_projectConfig$covera = projectConfig.coveragePath) != null ? _projectConfig$covera : 'reports/coverage-acceptance');
+var coverageUrls = (_projectConfig$covera2 = projectConfig.coverageUrls) != null ? _projectConfig$covera2 : [];
 var serverPort = server == null ? void 0 : server.port;
 var toMatchImageSnapshot = /*#__PURE__*/jestImageSnapshot.configureToMatchImageSnapshot({
   failureThreshold: 0,
@@ -889,45 +981,46 @@ var openPage = /*#__PURE__*/function () {
             }
             return protocol + "://" + hostname + ":" + port + path;
           }();
+          debug('Opening page:', url);
           _context7.t0 = userAgent;
           if (_context7.t0) {
-            _context7.next = 7;
+            _context7.next = 8;
             break;
           }
-          _context7.next = 6;
+          _context7.next = 7;
           return getGlobalBrowser().userAgent();
-        case 6:
-          _context7.t0 = _context7.sent;
         case 7:
+          _context7.t0 = _context7.sent;
+        case 8:
           currentUserAgent = _context7.t0;
           page = getGlobalPage$1();
-          _context7.next = 11;
+          _context7.next = 12;
           return page.bringToFront();
-        case 11:
+        case 12:
           if (!viewport) {
-            _context7.next = 14;
+            _context7.next = 15;
             break;
           }
-          _context7.next = 14;
+          _context7.next = 15;
           return page.setViewport(viewport);
-        case 14:
+        case 15:
           if (!cookies) {
-            _context7.next = 17;
+            _context7.next = 18;
             break;
           }
-          _context7.next = 17;
+          _context7.next = 18;
           return page.setCookie.apply(page, cookies);
-        case 17:
-          _context7.next = 19;
+        case 18:
+          _context7.next = 20;
           return page.setUserAgent(currentUserAgent + " acceptance-test");
-        case 19:
-          _context7.next = 21;
+        case 20:
+          _context7.next = 22;
           return page.emulateMediaFeatures([{
             name: 'prefers-color-scheme',
             value: isDarkMode ? 'dark' : 'light'
           }]);
-        case 21:
-          _context7.next = 23;
+        case 22:
+          _context7.next = 24;
           return page.evaluateOnNewDocument(function (viewport) {
             var _viewport$safeAreaIns;
             var overriddenSafeAreaInsets = !viewport ? [] : Object.keys((_viewport$safeAreaIns = viewport == null ? void 0 : viewport.safeAreaInset) != null ? _viewport$safeAreaIns : {}).map(function (key) {
@@ -941,44 +1034,44 @@ var openPage = /*#__PURE__*/function () {
               document.head.appendChild(style);
             });
           }, viewport);
-        case 23:
+        case 24:
           if (!needsRequestInterception) {
-            _context7.next = 27;
+            _context7.next = 28;
             break;
           }
-          _context7.next = 26;
+          _context7.next = 27;
           return page.setRequestInterception(true);
-        case 26:
-          page.on('request', requestInterceptor);
         case 27:
-          _context7.prev = 27;
-          _context7.next = 30;
+          page.on('request', requestInterceptor);
+        case 28:
+          _context7.prev = 28;
+          _context7.next = 31;
           return page["goto"](url);
-        case 30:
-          _context7.next = 41;
+        case 31:
+          _context7.next = 42;
           break;
-        case 32:
-          _context7.prev = 32;
-          _context7.t1 = _context7["catch"](27);
+        case 33:
+          _context7.prev = 33;
+          _context7.t1 = _context7["catch"](28);
           if (!_context7.t1.message.includes('net::ERR_CONNECTION_REFUSED')) {
-            _context7.next = 40;
+            _context7.next = 41;
             break;
           }
           connectionError = new Error("Could not connect to " + url + ". Is the server running?");
           Error.captureStackTrace(connectionError, openPage);
           throw connectionError;
-        case 40:
-          throw _context7.t1;
         case 41:
-          _context7.next = 43;
+          throw _context7.t1;
+        case 42:
+          _context7.next = 44;
           return page.waitForFunction('document.fonts.status === "loaded"');
-        case 43:
-          return _context7.abrupt("return", getPageApi(page));
         case 44:
+          return _context7.abrupt("return", getPageApi(page));
+        case 45:
         case "end":
           return _context7.stop();
       }
-    }, _callee7, null, [[27, 32]]);
+    }, _callee7, null, [[28, 33]]);
   }));
   return function openPage(_x11) {
     return _ref16.apply(this, arguments);
@@ -1156,30 +1249,53 @@ afterEach( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().ma
   return _regeneratorRuntime().wrap(function _callee14$(_context14) {
     while (1) switch (_context14.prev = _context14.next) {
       case 0:
-        _context14.next = 2;
-        return collectCoverageIfAvailable({
+        if (!process.env.COLLECT_ACCEPTANCE_COVERAGE) {
+          _context14.next = 3;
+          break;
+        }
+        _context14.next = 3;
+        return collectFrontendCoverage({
           coveragePath: coveragePath
         });
-      case 2:
-        _context14.prev = 2;
+      case 3:
+        _context14.prev = 3;
         page = getGlobalPage$1();
         requestHandlers = [];
         needsRequestInterception = false;
         page.off('request', requestInterceptor);
         // clear tab, this way we clear the DOM and stop js execution or pending requests
-        _context14.next = 9;
+        _context14.next = 10;
         return page["goto"]('about:blank');
-      case 9:
-        _context14.next = 13;
+      case 10:
+        _context14.next = 14;
         break;
-      case 11:
-        _context14.prev = 11;
-        _context14.t0 = _context14["catch"](2);
-      case 13:
+      case 12:
+        _context14.prev = 12;
+        _context14.t0 = _context14["catch"](3);
+      case 14:
       case "end":
         return _context14.stop();
     }
-  }, _callee14, null, [[2, 11]]);
+  }, _callee14, null, [[3, 12]]);
+})));
+afterAll( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee15() {
+  return _regeneratorRuntime().wrap(function _callee15$(_context15) {
+    while (1) switch (_context15.prev = _context15.next) {
+      case 0:
+        if (!process.env.COLLECT_ACCEPTANCE_COVERAGE) {
+          _context15.next = 3;
+          break;
+        }
+        _context15.next = 3;
+        return collectBackendCoverage({
+          coveragePath: coveragePath,
+          coverageUrls: coverageUrls
+        });
+      case 3:
+      case "end":
+        return _context15.stop();
+    }
+  }, _callee15);
 })));
 /**
  * Returns a new path to the file that can be used by chromium in acceptance tests
@@ -1255,44 +1371,44 @@ var waitForElementToBeRemoved = function waitForElementToBeRemoved(element, time
   }
   var startStack = new Error().stack;
   var wait = /*#__PURE__*/function () {
-    var _ref25 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee15() {
+    var _ref26 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee16() {
       var t0, box;
-      return _regeneratorRuntime().wrap(function _callee15$(_context15) {
-        while (1) switch (_context15.prev = _context15.next) {
+      return _regeneratorRuntime().wrap(function _callee16$(_context16) {
+        while (1) switch (_context16.prev = _context16.next) {
           case 0:
             t0 = Date.now();
           case 1:
             if (!(Date.now() - t0 < timeout)) {
-              _context15.next = 11;
+              _context16.next = 11;
               break;
             }
-            _context15.next = 4;
+            _context16.next = 4;
             return element.boundingBox();
           case 4:
-            box = _context15.sent;
+            box = _context16.sent;
             if (box) {
-              _context15.next = 7;
+              _context16.next = 7;
               break;
             }
-            return _context15.abrupt("return");
+            return _context16.abrupt("return");
           case 7:
-            _context15.next = 9;
+            _context16.next = 9;
             return new Promise(function (resolve) {
               return setTimeout(resolve, interval);
             });
           case 9:
-            _context15.next = 1;
+            _context16.next = 1;
             break;
           case 11:
             throw new Error('Element not removed');
           case 12:
           case "end":
-            return _context15.stop();
+            return _context16.stop();
         }
-      }, _callee15);
+      }, _callee16);
     }));
     return function wait() {
-      return _ref25.apply(this, arguments);
+      return _ref26.apply(this, arguments);
     };
   }();
   return wait()["catch"](function (error) {