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

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

@@ -0,0 +1,268 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = worker;
+
+var _util = require("util");
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _chai = _interopRequireDefault(require("chai"));
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _mocha = _interopRequireDefault(require("mocha"));
+
+var _seleniumWebdriver = require("selenium-webdriver");
+
+var _types = require("../../types");
+
+var _messages = require("../messages");
+
+var _chaiImage = _interopRequireDefault(require("./chai-image"));
+
+var _selenium = require("../selenium");
+
+var _reporter = require("./reporter");
+
+var _helpers = require("./helpers");
+
+var _logger = require("../logger");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const statAsync = (0, _util.promisify)(_fs.default.stat);
+const readdirAsync = (0, _util.promisify)(_fs.default.readdir);
+const readFileAsync = (0, _util.promisify)(_fs.default.readFile);
+const writeFileAsync = (0, _util.promisify)(_fs.default.writeFile);
+const mkdirAsync = (0, _util.promisify)(_fs.default.mkdir);
+
+async function getStat(filePath) {
+  try {
+    return await statAsync(filePath);
+  } catch (error) {
+    if (typeof error == 'object' && error && error.code === 'ENOENT') {
+      return null;
+    }
+
+    throw error;
+  }
+}
+
+async function getLastImageNumber(imageDir, imageName) {
+  const actualImagesRegexp = new RegExp(`${imageName}-actual-(\\d+)\\.png`);
+
+  try {
+    return (await readdirAsync(imageDir)).map(filename => filename.replace(actualImagesRegexp, '$1')).map(Number).filter(x => !isNaN(x)).sort((a, b) => b - a)[0] ?? 0;
+  } catch (_error) {
+    return 0;
+  }
+} // FIXME browser options hotfix
+
+
+async function worker(config, options) {
+  var _await$browser$getSes;
+
+  let retries = 0;
+  let images = {};
+  let error = undefined;
+  const screenshots = [];
+  const testScope = [];
+
+  function runHandler(failures) {
+    if (failures > 0 && (error || Object.values(images).some(image => (image === null || image === void 0 ? void 0 : image.error) != null))) {
+      const isTimeout = hasTimeout(error) || Object.values(images).some(image => hasTimeout(image === null || image === void 0 ? void 0 : image.error));
+      const payload = {
+        status: 'failed',
+        images,
+        error
+      };
+      isTimeout ? (0, _messages.emitWorkerMessage)({
+        type: 'error',
+        payload: {
+          error: error ?? 'Unknown error'
+        }
+      }) : (0, _messages.emitTestMessage)({
+        type: 'end',
+        payload
+      });
+    } else {
+      (0, _messages.emitTestMessage)({
+        type: 'end',
+        payload: {
+          status: 'success',
+          images
+        }
+      });
+    }
+  }
+
+  async function saveImages(imageDir, images) {
+    await mkdirAsync(imageDir, {
+      recursive: true
+    });
+
+    for (const {
+      name,
+      data
+    } of images) {
+      await writeFileAsync(_path.default.join(imageDir, name), data);
+    }
+  }
+
+  async function getExpected(assertImageName) {
+    // context => [kind, story, test, browser]
+    // rootSuite -> kindSuite -> storyTest -> [browsers.png]
+    // rootSuite -> kindSuite -> storySuite -> test -> [browsers.png]
+    const testPath = [...testScope];
+    const imageName = assertImageName ?? testPath.pop();
+    const imagesMeta = [];
+
+    const reportImageDir = _path.default.join(config.reportDir, ...testPath);
+
+    const imageNumber = (await getLastImageNumber(reportImageDir, imageName)) + 1;
+    const actualImageName = `${imageName}-actual-${imageNumber}.png`;
+    const image = images[imageName] = images[imageName] ?? {
+      actual: actualImageName
+    };
+
+    const onCompare = async (actual, expect, diff) => {
+      imagesMeta.push({
+        name: image.actual,
+        data: actual
+      });
+
+      if (diff && expect) {
+        image.expect = `${imageName}-expect-${imageNumber}.png`;
+        image.diff = `${imageName}-diff-${imageNumber}.png`;
+        imagesMeta.push({
+          name: image.expect,
+          data: expect
+        });
+        imagesMeta.push({
+          name: image.diff,
+          data: diff
+        });
+      }
+
+      if (options.saveReport) {
+        await saveImages(reportImageDir, imagesMeta);
+      }
+    };
+
+    const expectImageDir = _path.default.join(config.screenDir, ...testPath);
+
+    const expectImageStat = await getStat(_path.default.join(expectImageDir, `${imageName}.png`));
+    if (!expectImageStat) return {
+      expected: null,
+      onCompare
+    };
+    const expected = await readFileAsync(_path.default.join(expectImageDir, `${imageName}.png`));
+    return {
+      expected,
+      onCompare
+    };
+  }
+
+  const mochaOptions = {
+    timeout: 30000,
+    reporter: process.env.TEAMCITY_VERSION ? _reporter.TeamcityReporter : options.reporter || _reporter.CreeveyReporter,
+    reporterOptions: {
+      reportDir: config.reportDir,
+      topLevelSuite: options.browser,
+
+      get willRetry() {
+        return retries < config.maxRetries;
+      },
+
+      get images() {
+        return images;
+      },
+
+      get sessionId() {
+        return sessionId;
+      }
+
+    }
+  };
+  const mocha = new _mocha.default(mochaOptions);
+  mocha.cleanReferencesAfterRun(false);
+
+  _chai.default.use((0, _chaiImage.default)(getExpected, config.diffOptions));
+
+  if ((await (0, _selenium.getBrowser)(config, options.browser)) == null) return;
+  await (0, _helpers.addTestsFromStories)(mocha.suite, config, {
+    browser: options.browser,
+    watch: options.ui,
+    debug: options.debug,
+    port: options.port
+  });
+
+  try {
+    var _await$getBrowser;
+
+    await ((_await$getBrowser = await (0, _selenium.getBrowser)(config, options.browser)) === null || _await$getBrowser === void 0 ? void 0 : _await$getBrowser.getCurrentUrl());
+  } catch (_) {
+    await (0, _selenium.closeBrowser)();
+  }
+
+  const browser = await (0, _selenium.getBrowser)(config, options.browser);
+  const sessionId = (_await$browser$getSes = await (browser === null || browser === void 0 ? void 0 : browser.getSession())) === null || _await$browser$getSes === void 0 ? void 0 : _await$browser$getSes.getId();
+  if (browser == null) return;
+  const interval = setInterval(() => void browser.getCurrentUrl().then(url => {
+    if (options.debug) _logger.logger.debug(`${options.browser}:${_chalk.default.gray(sessionId)}`, 'current url', _chalk.default.magenta(url));
+  }), 10 * 1000);
+  (0, _messages.subscribeOn)('shutdown', () => clearInterval(interval));
+  mocha.suite.beforeAll(function () {
+    this.config = config;
+    this.browser = browser;
+    this.until = _seleniumWebdriver.until;
+    this.keys = _seleniumWebdriver.Key;
+    this.expect = _chai.default.expect;
+    this.browserName = options.browser;
+    this.testScope = testScope;
+    this.screenshots = screenshots;
+  });
+  mocha.suite.beforeEach(_selenium.switchStory);
+  (0, _messages.subscribeOn)('test', message => {
+    if (message.type != 'start') return;
+    const test = message.payload;
+    const testPath = test.path.join(' ').replace(/[|\\{}()[\]^$+*?.-]/g, '\\$&');
+    images = {};
+    error = undefined;
+    retries = test.retries;
+    mocha.grep(new RegExp(`^${testPath}$`));
+    const runner = mocha.run(runHandler); // TODO How handle browser corruption?
+
+    runner.on('fail', (_test, reason) => {
+      if (!(reason instanceof Error)) {
+        error = reason;
+      } else if (!(0, _types.isImageError)(reason)) {
+        error = reason.stack ?? reason.message;
+      } else if (typeof reason.images == 'string') {
+        const image = images[testScope.slice(-1)[0]];
+        if (image) image.error = reason.images;
+      } else {
+        const imageErrors = reason.images;
+        Object.keys(imageErrors).forEach(imageName => {
+          const image = images[imageName];
+          if (image) image.error = imageErrors[imageName];
+        });
+      }
+    });
+  });
+
+  _logger.logger.info(`${options.browser}:${_chalk.default.gray(sessionId)} is ready`);
+
+  (0, _messages.emitWorkerMessage)({
+    type: 'ready'
+  });
+}
+
+function hasTimeout(str) {
+  return str != null && str.toLowerCase().includes('timeout');
+}

package/lib/cjs/shared/index.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serializeRawStories = exports.deserializeStory = exports.deserializeRawStories = exports.denormalizeStoryParameters = exports.combineParameters = void 0;
+
+var _lodash = require("lodash");
+
+var _serializeRegExp = require("./serializeRegExp");
+
+// NOTE: Copy-paste from storybook/api
+const combineParameters = (...parameterSets) => // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+(0, _lodash.mergeWith)({}, ...parameterSets, (_, srcValue) => {
+  // Treat arrays as scalars:
+  if (Array.isArray(srcValue)) return srcValue;
+  return undefined;
+}); // NOTE: Copy-paste from storybook/api
+
+
+exports.combineParameters = combineParameters;
+
+const denormalizeStoryParameters = ({
+  globalParameters,
+  kindParameters,
+  stories
+}) => {
+  return (0, _lodash.mapValues)(stories, storyData => ({ ...storyData,
+    parameters: combineParameters(globalParameters, kindParameters[storyData.kind] ?? {}, storyData.parameters)
+  }));
+};
+
+exports.denormalizeStoryParameters = denormalizeStoryParameters;
+
+const serializeRawStories = stories => {
+  return (0, _lodash.mapValues)(stories, storyData => {
+    const creevey = storyData.parameters.creevey;
+
+    if (creevey !== null && creevey !== void 0 && creevey.skip) {
+      return { ...storyData,
+        parameters: { ...storyData.parameters,
+          creevey: { ...creevey,
+            skip: (0, _lodash.cloneDeepWith)(creevey.skip, value => {
+              if ((0, _serializeRegExp.isRegExp)(value)) {
+                return (0, _serializeRegExp.serializeRegExp)(value);
+              }
+
+              return undefined;
+            })
+          }
+        }
+      };
+    }
+
+    return storyData;
+  });
+};
+
+exports.serializeRawStories = serializeRawStories;
+
+const deserializeRawStories = stories => {
+  return (0, _lodash.mapValues)(stories, deserializeStory);
+};
+
+exports.deserializeRawStories = deserializeRawStories;
+
+const deserializeStory = story => {
+  const creevey = story.parameters.creevey;
+
+  if (creevey !== null && creevey !== void 0 && creevey.skip) {
+    return { ...story,
+      parameters: { ...story.parameters,
+        creevey: { ...creevey,
+          skip: (0, _lodash.cloneDeepWith)(creevey.skip, value => {
+            if ((0, _serializeRegExp.isSerializedRegExp)(value)) {
+              return (0, _serializeRegExp.deserializeRegExp)(value);
+            }
+
+            return undefined;
+          })
+        }
+      }
+    };
+  }
+
+  return story;
+};
+
+exports.deserializeStory = deserializeStory;

package/lib/cjs/shared/serializeRegExp.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serializeRegExp = exports.isSerializedRegExp = exports.isRegExp = exports.deserializeRegExp = void 0;
+
+const isRegExp = exp => {
+  return exp instanceof RegExp;
+};
+
+exports.isRegExp = isRegExp;
+
+const isSerializedRegExp = exp => {
+  return typeof exp === 'object' && exp !== null && Reflect.get(exp, '__regexp') === true;
+};
+
+exports.isSerializedRegExp = isSerializedRegExp;
+
+const serializeRegExp = exp => {
+  const {
+    source,
+    flags
+  } = exp;
+  return {
+    __regexp: true,
+    source,
+    flags
+  };
+};
+
+exports.serializeRegExp = serializeRegExp;
+
+const deserializeRegExp = ({
+  source,
+  flags
+}) => {
+  return new RegExp(source, flags);
+};
+
+exports.deserializeRegExp = deserializeRegExp;

package/lib/cjs/types.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDefined = isDefined;
+exports.isDockerMessage = isDockerMessage;
+exports.isFunction = isFunction;
+exports.isImageError = isImageError;
+exports.isObject = isObject;
+exports.isProcessMessage = isProcessMessage;
+exports.isStoriesMessage = isStoriesMessage;
+exports.isString = isString;
+exports.isTest = isTest;
+exports.isTestMessage = isTestMessage;
+exports.isWebpackMessage = isWebpackMessage;
+exports.isWorkerMessage = isWorkerMessage;
+exports.noop = noop;
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/* eslint-enable @typescript-eslint/no-explicit-any */
+function noop() {
+  /* noop */
+}
+
+function isDefined(value) {
+  return value !== null && value !== undefined;
+}
+
+function isTest(x) {
+  return isDefined(x) && 'id' in x && 'storyId' in x && typeof x.id == 'string' && typeof x.storyId == 'string';
+}
+
+function isObject(x) {
+  return typeof x == 'object' && x != null;
+}
+
+function isString(x) {
+  return typeof x == 'string';
+} // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+
+function isFunction(x) {
+  return typeof x == 'function';
+}
+
+function isImageError(error) {
+  return error instanceof Error && 'images' in error;
+}
+
+function isProcessMessage(message) {
+  return isObject(message) && 'scope' in message;
+}
+
+function isWorkerMessage(message) {
+  return isProcessMessage(message) && message.scope == 'worker';
+}
+
+function isStoriesMessage(message) {
+  return isProcessMessage(message) && message.scope == 'stories';
+}
+
+function isTestMessage(message) {
+  return isProcessMessage(message) && message.scope == 'test';
+}
+
+function isWebpackMessage(message) {
+  return isProcessMessage(message) && message.scope == 'webpack';
+}
+
+function isDockerMessage(message) {
+  return isProcessMessage(message) && message.scope == 'docker';
+}

package/lib/esm/cli.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+// eslint-disable-next-line node/shebang
+
+require('./creevey');