creevey 0.9.0-beta.1 → 0.9.0-non-webpack.0

package/lib/cjs/server/utils.js

@@ -0,0 +1,183 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extensions = exports.downloadBinary = exports.LOCALHOST_REGEXP = void 0;
+exports.getCreeveyCache = getCreeveyCache;
+exports.isShuttingDown = exports.isInsideDocker = void 0;
+exports.readDirRecursive = readDirRecursive;
+exports.removeProps = removeProps;
+exports.runSequence = runSequence;
+exports.shouldSkip = shouldSkip;
+exports.shutdown = shutdown;
+exports.shutdownWorkers = shutdownWorkers;
+exports.skipOptionKeys = void 0;
+exports.testsToImages = testsToImages;
+
+var _fs = require("fs");
+
+var _cluster = _interopRequireDefault(require("cluster"));
+
+var _types = require("../types");
+
+var _messages = require("./messages");
+
+var _findCacheDir = _interopRequireDefault(require("find-cache-dir"));
+
+var _https = require("https");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const isShuttingDown = {
+  current: false
+};
+exports.isShuttingDown = isShuttingDown;
+const LOCALHOST_REGEXP = /(localhost|127\.0\.0\.1)/i;
+exports.LOCALHOST_REGEXP = LOCALHOST_REGEXP;
+const extensions = ['.js', '.jsx', '.ts', '.tsx'];
+exports.extensions = extensions;
+const skipOptionKeys = ['in', 'kinds', 'stories', 'tests', 'reason'];
+exports.skipOptionKeys = skipOptionKeys;
+
+function matchBy(pattern, value) {
+  return typeof pattern == 'string' && pattern == value || Array.isArray(pattern) && pattern.includes(value) || pattern instanceof RegExp && pattern.test(value) || !(0, _types.isDefined)(pattern);
+}
+
+function shouldSkip(browser, meta, skipOptions, test) {
+  if (typeof skipOptions != 'object') {
+    return skipOptions;
+  }
+
+  if (Array.isArray(skipOptions)) {
+    for (const skip of skipOptions) {
+      const reason = shouldSkip(browser, meta, skip, test);
+      if (reason) return reason;
+    }
+
+    return false;
+  }
+
+  let hasSkipOptionKeys = false;
+
+  for (const skipKey in skipOptions) {
+    if (skipOptionKeys.includes(skipKey)) {
+      hasSkipOptionKeys = true;
+      continue;
+    }
+
+    const reason = shouldSkip(browser, meta, {
+      reason: skipKey,
+      ...skipOptions[skipKey]
+    }, test);
+    if (reason) return reason;
+  }
+
+  if (!hasSkipOptionKeys) return false;
+  const {
+    in: browsers,
+    kinds,
+    stories,
+    tests,
+    reason = true
+  } = skipOptions;
+  const {
+    kind,
+    story
+  } = meta;
+  const skipByBrowser = matchBy(browsers, browser);
+  const skipByKind = matchBy(kinds, kind);
+  const skipByStory = matchBy(stories, story);
+  const skipByTest = !(0, _types.isDefined)(test) || matchBy(tests, test);
+  return skipByBrowser && skipByKind && skipByStory && skipByTest && reason;
+}
+
+async function shutdownWorkers() {
+  isShuttingDown.current = true;
+  await Promise.all(Object.values(_cluster.default.workers ?? {}).filter(_types.isDefined).filter(worker => worker.isConnected()).map(worker => new Promise(resolve => {
+    const timeout = setTimeout(() => worker.kill(), 10000);
+    worker.on('exit', () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+    (0, _messages.sendShutdownMessage)(worker);
+  })));
+  (0, _messages.emitShutdownMessage)();
+}
+
+function shutdown() {
+  // eslint-disable-next-line no-process-exit
+  process.exit();
+}
+
+function getCreeveyCache() {
+  return (0, _findCacheDir.default)({
+    name: 'creevey',
+    cwd: __dirname
+  });
+}
+
+async function runSequence(seq, predicate) {
+  for (const fn of seq) {
+    if (predicate()) await fn();
+  }
+}
+
+function testsToImages(tests) {
+  return new Set([].concat(...tests.filter(_types.isDefined).map(({
+    browser,
+    testName,
+    storyPath,
+    results
+  }) => {
+    var _results$slice$;
+
+    return Object.keys((results === null || results === void 0 ? void 0 : (_results$slice$ = results.slice(-1)[0]) === null || _results$slice$ === void 0 ? void 0 : _results$slice$.images) ?? {}).map(image => `${[...storyPath, testName, browser, browser == image ? undefined : image].filter(_types.isDefined).join('/')}.png`);
+  })));
+} // https://tuhrig.de/how-to-know-you-are-inside-a-docker-container/
+
+
+const isInsideDocker = (0, _fs.existsSync)('/proc/1/cgroup') && /docker/.test((0, _fs.readFileSync)('/proc/1/cgroup', 'utf8'));
+exports.isInsideDocker = isInsideDocker;
+
+const downloadBinary = (downloadUrl, destination) => new Promise((resolve, reject) => (0, _https.get)(downloadUrl, response => {
+  if (response.statusCode == 302) {
+    const {
+      location
+    } = response.headers;
+    if (!location) return reject(new Error(`Couldn't download selenoid. Status code: ${response.statusCode ?? 'UNKNOWN'}`));
+    return resolve(downloadBinary(location, destination));
+  }
+
+  if (response.statusCode != 200) return reject(new Error(`Couldn't download selenoid. Status code: ${response.statusCode ?? 'UNKNOWN'}`));
+  const fileStream = (0, _fs.createWriteStream)(destination);
+  response.pipe(fileStream);
+  fileStream.on('finish', () => {
+    fileStream.close();
+    resolve();
+  });
+  fileStream.on('error', error => {
+    (0, _fs.unlink)(destination, _types.noop);
+    reject(error);
+  });
+}));
+
+exports.downloadBinary = downloadBinary;
+
+function removeProps(obj, propPath) {
+  const [prop, ...restPath] = propPath;
+
+  if (restPath.length > 0) {
+    if (typeof prop == 'string') obj[prop] && removeProps(obj[prop], restPath);
+    if ((0, _types.isFunction)(prop)) Object.keys(obj).filter(prop).forEach(key => obj[key] && removeProps(obj[key], restPath));
+  } else {
+    if (typeof prop == 'string') delete obj[prop];
+    if ((0, _types.isFunction)(prop)) Object.keys(obj).filter(prop).forEach(key => delete obj[key]);
+  }
+}
+
+function readDirRecursive(dirPath) {
+  return [].concat(...(0, _fs.readdirSync)(dirPath, {
+    withFileTypes: true
+  }).map(dirent => dirent.isDirectory() ? readDirRecursive(`${dirPath}/${dirent.name}`) : [`${dirPath}/${dirent.name}`]));
+}

package/lib/cjs/server/worker/chai-image.js

@@ -0,0 +1,142 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _pngjs = require("pngjs");
+
+var _pixelmatch = _interopRequireDefault(require("pixelmatch"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function normalizeImageSize(image, width, height) {
+  const normalizedImage = Buffer.alloc(4 * width * height);
+
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const i = (y * width + x) * 4;
+
+      if (x < image.width && y < image.height) {
+        const j = (y * image.width + x) * 4;
+        normalizedImage[i + 0] = image.data[j + 0];
+        normalizedImage[i + 1] = image.data[j + 1];
+        normalizedImage[i + 2] = image.data[j + 2];
+        normalizedImage[i + 3] = image.data[j + 3];
+      } else {
+        normalizedImage[i + 0] = 0;
+        normalizedImage[i + 1] = 0;
+        normalizedImage[i + 2] = 0;
+        normalizedImage[i + 3] = 0;
+      }
+    }
+  }
+
+  return normalizedImage;
+}
+
+function hasDiffPixels(diff) {
+  for (let i = 0; i < diff.length; i += 4) {
+    if (diff[i + 0] == 255 && diff[i + 1] == 0 && diff[i + 2] == 0 && diff[i + 3] == 255) return true;
+  }
+
+  return false;
+}
+
+function compareImages(expect, actual, diffOptions) {
+  const expectImage = _pngjs.PNG.sync.read(expect);
+
+  const actualImage = _pngjs.PNG.sync.read(actual);
+
+  const width = Math.max(actualImage.width, expectImage.width);
+  const height = Math.max(actualImage.height, expectImage.height);
+  const diffImage = new _pngjs.PNG({
+    width,
+    height
+  });
+  let actualImageData = actualImage.data;
+
+  if (actualImage.width < width || actualImage.height < height) {
+    actualImageData = normalizeImageSize(actualImage, width, height);
+  }
+
+  let expectImageData = expectImage.data;
+
+  if (expectImage.width < width || expectImage.height < height) {
+    expectImageData = normalizeImageSize(expectImage, width, height);
+  }
+
+  (0, _pixelmatch.default)(expectImageData, actualImageData, diffImage.data, width, height, diffOptions);
+  return {
+    isEqual: !hasDiffPixels(diffImage.data),
+    diff: _pngjs.PNG.sync.write(diffImage)
+  };
+}
+
+function _default(getExpected, diffOptions) {
+  return function chaiImage({
+    Assertion
+  }, utils) {
+    async function assertImage(actual, imageName) {
+      let onCompare = () => Promise.resolve();
+
+      let expected = await getExpected(imageName);
+      if (!(expected instanceof Buffer) && expected != null) ({
+        expected,
+        onCompare
+      } = expected);
+
+      if (expected == null) {
+        await onCompare(actual);
+        return imageName ? `Expected image '${imageName}' does not exists` : 'Expected image does not exists';
+      }
+
+      if (actual.equals(expected)) return await onCompare(actual);
+      const {
+        isEqual,
+        diff
+      } = compareImages(expected, actual, diffOptions);
+      if (isEqual) return await onCompare(actual);
+      await onCompare(actual, expected, diff);
+      return imageName ? `Expected image '${imageName}' to match` : 'Expected image to match';
+    }
+
+    utils.addMethod(Assertion.prototype, 'matchImage', async function matchImage(imageName) {
+      const actual = utils.flag(this, 'object');
+      const errorMessage = await assertImage(typeof actual == 'string' ? Buffer.from(actual, 'base64') : actual, imageName);
+
+      if (errorMessage) {
+        throw createImageError(imageName ? {
+          [imageName]: errorMessage
+        } : errorMessage);
+      }
+    });
+    utils.addMethod(Assertion.prototype, 'matchImages', async function matchImages() {
+      const errors = {};
+      await Promise.all(Object.entries(utils.flag(this, 'object')).map(async ([imageName, imageOrBase64]) => {
+        let errorMessage;
+
+        try {
+          errorMessage = await assertImage(typeof imageOrBase64 == 'string' ? Buffer.from(imageOrBase64, 'base64') : imageOrBase64, imageName);
+        } catch (error) {
+          errorMessage = error.stack;
+        }
+
+        if (errorMessage) {
+          errors[imageName] = errorMessage;
+        }
+      }));
+
+      if (Object.keys(errors).length > 0) {
+        throw createImageError(errors);
+      }
+    });
+  };
+}
+
+function createImageError(imageErrors) {
+  const error = new Error('Expected image to match');
+  error.images = imageErrors;
+  return error;
+}

package/lib/cjs/server/worker/helpers.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addTestsFromStories = addTestsFromStories;
+
+var _mocha = require("mocha");
+
+var _types = require("../../types");
+
+var _stories = require("../stories");
+
+function findOrCreateSuite(name, parent) {
+  const suite = parent.suites.find(({
+    title
+  }) => title == name) || new _mocha.Suite(name, parent.ctx);
+
+  if (!suite.parent) {
+    suite.parent = parent;
+    parent.addSuite(suite);
+  }
+
+  return suite;
+}
+
+function createTest(name, fn, skip = false) {
+  const test = new _mocha.Test(name, skip ? undefined : fn);
+  test.pending = Boolean(skip); // NOTE Can't define skip reason in mocha https://github.com/mochajs/mocha/issues/2026
+
+  test.skipReason = skip;
+  return test;
+}
+
+function addTest(rootSuite, test) {
+  const [testName, ...suitePath] = [...test.storyPath, test.testName].reverse().filter(_types.isDefined);
+  const suite = suitePath.reduceRight((subSuite, suiteName) => findOrCreateSuite(suiteName, subSuite), rootSuite);
+  const mochaTest = createTest(testName, test.fn, test.skip);
+  suite.addTest(mochaTest);
+  mochaTest.ctx = Object.setPrototypeOf({
+    id: test.id,
+    story: test.story
+  }, suite.ctx);
+  return mochaTest;
+}
+
+function removeTestOrSuite(testOrSuite) {
+  const {
+    parent
+  } = testOrSuite;
+  if (!parent) return;
+  if (testOrSuite instanceof _mocha.Test) parent.tests = parent.tests.filter(test => test != testOrSuite);
+  if (testOrSuite instanceof _mocha.Suite) parent.suites = parent.suites.filter(suite => suite != testOrSuite);
+  if (parent.tests.length == 0 && parent.suites.length == 0) removeTestOrSuite(parent);
+}
+
+async function addTestsFromStories(rootSuite, config, {
+  browser,
+  ...options
+}) {
+  const mochaTestsById = new Map();
+  const tests = await (0, _stories.loadTestsFromStories)([browser], listener => config.storiesProvider(config, options, listener), testsDiff => Object.entries(testsDiff).forEach(([id, newTest]) => {
+    const oldTest = mochaTestsById.get(id);
+    mochaTestsById.delete(id);
+    if (oldTest) removeTestOrSuite(oldTest);
+    if (newTest) mochaTestsById.set(id, addTest(rootSuite, newTest));
+  }));
+  Object.values(tests).filter(_types.isDefined).forEach(test => mochaTestsById.set(test.id, addTest(rootSuite, test)));
+}

package/lib/cjs/server/worker/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _worker.default;
+  }
+});
+
+var _worker = _interopRequireDefault(require("./worker"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/lib/cjs/server/worker/reporter.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TeamcityReporter = exports.CreeveyReporter = void 0;
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _mocha = require("mocha");
+
+var _loglevelPluginPrefix = _interopRequireDefault(require("loglevel-plugin-prefix"));
+
+var _types = require("../../types");
+
+var _logger = require("../logger");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const testLevels = {
+  INFO: _chalk.default.green('PASS'),
+  WARN: _chalk.default.yellow('START'),
+  ERROR: _chalk.default.red('FAIL')
+};
+
+class CreeveyReporter extends _mocha.reporters.Base {
+  constructor(runner, options) {
+    super(runner);
+    const {
+      sessionId,
+      topLevelSuite
+    } = options.reporterOptions;
+    const testLogger = (0, _logger.getLogger)(topLevelSuite);
+
+    _loglevelPluginPrefix.default.apply(testLogger, {
+      format(level) {
+        return `${testLevels[level]} => (${topLevelSuite}:${_chalk.default.gray(sessionId)})`;
+      }
+
+    });
+
+    runner.on('test', test => testLogger.warn(_chalk.default.cyan(test.titlePath().join('/'))));
+    runner.on('pass', test => testLogger.info(_chalk.default.cyan(test.titlePath().join('/'))));
+    runner.on('fail', (test, error) => testLogger.error(_chalk.default.cyan(test.titlePath().join('/')), '\n  ', getErrors(error, (error, imageName) => `${_chalk.default.bold(imageName ?? topLevelSuite)}:${error}`, error => `${error.stack ?? error.message}`).join('\n  ')));
+  }
+
+}
+
+exports.CreeveyReporter = CreeveyReporter;
+
+class TeamcityReporter extends _mocha.reporters.Base {
+  constructor(runner, options) {
+    super(runner);
+    const topLevelSuite = this.escape(options.reporterOptions.topLevelSuite);
+    const reporterOptions = options.reporterOptions;
+    runner.on('suite', suite => suite.root ? console.log(`##teamcity[testSuiteStarted name='${topLevelSuite}' flowId='${process.pid}']`) : console.log(`##teamcity[testSuiteStarted name='${this.escape(suite.title)}' flowId='${process.pid}']`));
+    runner.on('test', test => console.log(`##teamcity[testStarted name='${this.escape(test.title)}' flowId='${process.pid}']`));
+    runner.on('fail', (test, error) => {
+      Object.entries(reporterOptions.images).forEach(([name, image]) => {
+        if (!image) return;
+        const filePath = test.titlePath().concat(name == topLevelSuite ? [] : [topLevelSuite]).map(this.escape).join('/'); // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+        const {
+          error,
+          ...rest
+        } = image;
+        Object.values(rest).filter(_types.isDefined).forEach(fileName => {
+          console.log(`##teamcity[publishArtifacts '${reporterOptions.reportDir}/${filePath}/${fileName} => report/${filePath}']`);
+          console.log(`##teamcity[testMetadata testName='${this.escape(test.title)}' type='image' value='report/${filePath}/${fileName}' flowId='${process.pid}']`);
+        });
+      }); // Output failed test as passed due TC don't support retry mechanic
+      // https://teamcity-support.jetbrains.com/hc/en-us/community/posts/207216829-Count-test-as-successful-if-at-least-one-try-is-successful?page=1#community_comment_207394125
+
+      reporterOptions.willRetry ? console.log(`##teamcity[testFinished name='${this.escape(test.title)}' flowId='${process.pid}']`) : console.log(`##teamcity[testFailed name='${this.escape(test.title)}' message='${this.escape(error.message)}' details='${this.escape(error.stack ?? '')}' flowId='${process.pid}']`);
+    });
+    runner.on('pending', test => console.log(`##teamcity[testIgnored name='${this.escape(test.title)}' message='${this.escape(typeof test.skipReason == 'boolean' ? test.title : test.skipReason)}' flowId='${process.pid}']`));
+    runner.on('test end', test => console.log(`##teamcity[testFinished name='${this.escape(test.title)}' flowId='${process.pid}']`));
+    runner.on('suite end', suite => suite.root || console.log(`##teamcity[testSuiteFinished name='${this.escape(suite.title)}' flowId='${process.pid}']`));
+    runner.on('end', () => console.log(`##teamcity[testSuiteFinished name='${topLevelSuite}' flowId='${process.pid}']`));
+  }
+
+  escape = str => {
+    if (!str) return '';
+    return str.toString() // eslint-disable-next-line no-control-regex
+    .replace(/\x1B.*?m/g, '').replace(/\|/g, '||').replace(/\n/g, '|n').replace(/\r/g, '|r').replace(/\[/g, '|[').replace(/\]/g, '|]').replace(/\u0085/g, '|x').replace(/\u2028/g, '|l').replace(/\u2029/g, '|p').replace(/'/g, "|'");
+  };
+}
+
+exports.TeamcityReporter = TeamcityReporter;
+
+function getErrors(error, imageErrorToString, errorToString) {
+  const errors = [];
+
+  if (!(error instanceof Error)) {
+    errors.push(error);
+  } else if (!(0, _types.isImageError)(error)) {
+    errors.push(errorToString(error));
+  } else if (typeof error.images == 'string') {
+    errors.push(imageErrorToString(error.images));
+  } else {
+    const imageErrors = error.images;
+    Object.keys(imageErrors).forEach(imageName => {
+      errors.push(imageErrorToString(imageErrors[imageName] ?? '', imageName));
+    });
+  }
+
+  return errors;
+}