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

package/lib/esm/client/shared/helpers.js

@@ -0,0 +1,424 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+import { themes } from '@storybook/theming';
+import { parse, stringify } from 'qs';
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
+import { isTest, isDefined } from '../../types';
+var statusUpdatesMap = new Map([[undefined, /(unknown|success|failed|pending|running)/], ['unknown', /(success|failed|pending|running)/], ['success', /(failed|pending|running)/], ['failed', /(pending|running)/], ['pending', /running/]]);
+
+function makeEmptySuiteNode() {
+  var path = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return {
+    path: path,
+    skip: true,
+    opened: false,
+    checked: true,
+    indeterminate: false,
+    children: {}
+  };
+}
+
+export function calcStatus(oldStatus, newStatus) {
+  var _statusUpdatesMap$get;
+
+  return newStatus && (_statusUpdatesMap$get = statusUpdatesMap.get(oldStatus)) !== null && _statusUpdatesMap$get !== void 0 && _statusUpdatesMap$get.test(newStatus) ? newStatus : oldStatus;
+}
+export function getTestPath(test) {
+  var browser = test.browser,
+      testName = test.testName,
+      storyPath = test.storyPath;
+  return [].concat(_toConsumableArray(storyPath), [testName, browser]).filter(isDefined);
+}
+export function getSuiteByPath(suite, path) {
+  return path.reduce(function (suiteOrTest, pathToken) {
+    return isTest(suiteOrTest) ? suiteOrTest : suiteOrTest === null || suiteOrTest === void 0 ? void 0 : suiteOrTest.children[pathToken];
+  }, suite);
+}
+export function getTestByPath(suite, path) {
+  var _getSuiteByPath;
+
+  var test = (_getSuiteByPath = getSuiteByPath(suite, path)) !== null && _getSuiteByPath !== void 0 ? _getSuiteByPath : suite;
+  return isTest(test) ? test : null;
+}
+export function getTestsByStoryId(suite, storyId) {
+  return Object.values(suite.children).filter(isDefined).flatMap(function (suiteOrTest) {
+    if (isTest(suiteOrTest)) return suiteOrTest.storyId === storyId ? suiteOrTest : [];
+    return getTestsByStoryId(suiteOrTest, storyId);
+  }).filter(isDefined);
+}
+
+function checkTests(suiteOrTest, checked) {
+  suiteOrTest.checked = checked;
+
+  if (!isTest(suiteOrTest)) {
+    suiteOrTest.indeterminate = false;
+    Object.values(suiteOrTest.children).filter(isDefined).forEach(function (child) {
+      return checkTests(child, checked);
+    });
+  }
+}
+
+function updateChecked(suite) {
+  var children = Object.values(suite.children).filter(isDefined).filter(function (child) {
+    return !child.skip;
+  });
+  var checkedEvery = children.every(function (test) {
+    return test.checked;
+  });
+  var checkedSome = children.some(function (test) {
+    return test.checked;
+  });
+  var indeterminate = children.some(function (test) {
+    return isTest(test) ? false : test.indeterminate;
+  }) || !checkedEvery && checkedSome;
+  var checked = indeterminate || suite.checked == checkedEvery ? suite.checked : checkedEvery;
+  suite.checked = checked;
+  suite.indeterminate = indeterminate;
+}
+
+export function checkSuite(suite, path, checked) {
+  var subSuite = getSuiteByPath(suite, path);
+  if (subSuite) checkTests(subSuite, checked);
+  path.slice(0, -1).map(function (_, index, tokens) {
+    return tokens.slice(0, tokens.length - index);
+  }).forEach(function (parentPath) {
+    var parentSuite = getSuiteByPath(suite, parentPath);
+    if (isTest(parentSuite)) return;
+    if (parentSuite) updateChecked(parentSuite);
+  });
+  updateChecked(suite);
+}
+export function treeifyTests(testsById) {
+  var rootSuite = makeEmptySuiteNode();
+  rootSuite.opened = true;
+  Object.values(testsById).forEach(function (test) {
+    if (!test) return;
+
+    var _getTestPath$reverse = getTestPath(test).reverse(),
+        _getTestPath$reverse2 = _toArray(_getTestPath$reverse),
+        browser = _getTestPath$reverse2[0],
+        testPath = _getTestPath$reverse2.slice(1);
+
+    var lastSuite = testPath.reverse().reduce(function (suite, token) {
+      var subSuite = suite.children[token] || makeEmptySuiteNode([].concat(_toConsumableArray(suite.path), [token]));
+      subSuite.status = calcStatus(subSuite.status, test.status);
+      if (!test.skip) subSuite.skip = false;
+      if (!subSuite.skip) suite.skip = false;
+      suite.children[token] = subSuite;
+      suite.status = calcStatus(suite.status, subSuite.status);
+
+      if (isTest(subSuite)) {
+        throw new Error("Suite and Test should not have same path '".concat(JSON.stringify(getTestPath(subSuite)), "'"));
+      }
+
+      return subSuite;
+    }, rootSuite);
+    lastSuite.children[browser] = _objectSpread(_objectSpread({}, test), {}, {
+      checked: true
+    });
+  });
+  return rootSuite;
+}
+export function getCheckedTests(suite) {
+  return Object.values(suite.children).filter(isDefined).flatMap(function (suiteOrTest) {
+    if (isTest(suiteOrTest)) return suiteOrTest.checked ? suiteOrTest : [];
+    if (!suiteOrTest.checked && !suiteOrTest.indeterminate) return [];
+    return getCheckedTests(suiteOrTest);
+  });
+}
+export function updateTestStatus(suite, path, update) {
+  var _suite$children$title;
+
+  var title = path.shift();
+  if (!title) return;
+  var suiteOrTest = (_suite$children$title = suite.children[title]) !== null && _suite$children$title !== void 0 ? _suite$children$title : suite.children[title] = _objectSpread(_objectSpread({}, path.length == 0 ? update : makeEmptySuiteNode([].concat(_toConsumableArray(suite.path), [title]))), {}, {
+    checked: suite.checked
+  });
+
+  if (isTest(suiteOrTest)) {
+    var _test$results;
+
+    var test = suiteOrTest;
+    var skip = update.skip,
+        status = update.status,
+        results = update.results,
+        approved = update.approved;
+    if (isDefined(skip)) test.skip = skip;
+    if (isDefined(status)) test.status = status;
+    if (isDefined(results)) test.results ? (_test$results = test.results).push.apply(_test$results, _toConsumableArray(results)) : test.results = results;
+    if (isDefined(approved)) Object.entries(approved).forEach(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+          image = _ref2[0],
+          retry = _ref2[1];
+
+      return retry !== undefined && ((test.approved = test.approved || {})[image] = retry);
+    });
+  } else {
+    var subSuite = suiteOrTest;
+    updateTestStatus(subSuite, path, update);
+  }
+
+  suite.skip = Object.values(suite.children).filter(isDefined).map(function (_ref3) {
+    var skip = _ref3.skip;
+    return skip;
+  }).every(Boolean);
+  suite.status = Object.values(suite.children).filter(isDefined).map(function (_ref4) {
+    var status = _ref4.status;
+    return status;
+  }).reduce(calcStatus);
+}
+export function removeTests(suite, path) {
+  var _suiteOrTest$children;
+
+  var title = path.shift();
+  if (!title) return;
+  var suiteOrTest = suite.children[title];
+  if (suiteOrTest && !isTest(suiteOrTest)) removeTests(suiteOrTest, path);
+  if (isTest(suiteOrTest) || Object.keys((_suiteOrTest$children = suiteOrTest === null || suiteOrTest === void 0 ? void 0 : suiteOrTest.children) !== null && _suiteOrTest$children !== void 0 ? _suiteOrTest$children : {}).length == 0) delete suite.children[title];
+  if (Object.keys(suite.children).length == 0) return;
+  updateChecked(suite);
+  suite.skip = Object.values(suite.children).filter(isDefined).map(function (_ref5) {
+    var skip = _ref5.skip;
+    return skip;
+  }).every(Boolean);
+  suite.status = Object.values(suite.children).filter(isDefined).map(function (_ref6) {
+    var status = _ref6.status;
+    return status;
+  }).reduce(calcStatus);
+}
+export function filterTests(suite, filter) {
+  var status = filter.status,
+      subStrings = filter.subStrings;
+  if (!status && !subStrings.length) return suite;
+
+  var filteredSuite = _objectSpread(_objectSpread({}, suite), {}, {
+    children: {}
+  });
+
+  Object.entries(suite.children).forEach(function (_ref7) {
+    var _ref8 = _slicedToArray(_ref7, 2),
+        title = _ref8[0],
+        suiteOrTest = _ref8[1];
+
+    if (!suiteOrTest || suiteOrTest.skip) return;
+
+    if (!status && subStrings.some(function (subString) {
+      return title.toLowerCase().includes(subString);
+    })) {
+      filteredSuite.children[title] = suiteOrTest;
+    } else if (isTest(suiteOrTest)) {
+      if (status && suiteOrTest.status && ['pending', 'running', status].includes(suiteOrTest.status)) filteredSuite.children[title] = suiteOrTest;
+    } else {
+      var filteredSubSuite = filterTests(suiteOrTest, filter);
+      if (Object.keys(filteredSubSuite.children).length == 0) return;
+      filteredSuite.children[title] = filteredSubSuite;
+    }
+  });
+  return filteredSuite;
+}
+export function openSuite(suite, path, opened) {
+  var subSuite = path.reduce(function (suiteOrTest, pathToken) {
+    if (suiteOrTest && !isTest(suiteOrTest)) {
+      if (opened) suiteOrTest.opened = opened;
+      return suiteOrTest.children[pathToken];
+    }
+  }, suite);
+  if (subSuite && !isTest(subSuite)) subSuite.opened = opened;
+}
+export function flattenSuite(suite) {
+  if (!suite.opened) return [];
+  return Object.entries(suite.children).flatMap(function (_ref9) {
+    var _ref10 = _slicedToArray(_ref9, 2),
+        title = _ref10[0],
+        subSuite = _ref10[1];
+
+    return subSuite ? [{
+      title: title,
+      suite: subSuite
+    }].concat(_toConsumableArray(isTest(subSuite) ? [] : flattenSuite(subSuite))) : [];
+  });
+}
+export function countTestsStatus(suite) {
+  var successCount = 0;
+  var failedCount = 0;
+  var skippedCount = 0;
+  var pendingCount = 0;
+  var cases = Object.values(suite.children).filter(isDefined);
+  var suiteOrTest;
+
+  while (suiteOrTest = cases.pop()) {
+    if (isTest(suiteOrTest)) {
+      if (suiteOrTest.skip) skippedCount++;
+      if (suiteOrTest.status === 'success') successCount++;
+      if (suiteOrTest.status === 'failed') failedCount++;
+      if (suiteOrTest.status === 'pending') pendingCount++;
+    } else {
+      cases.push.apply(cases, _toConsumableArray(Object.values(suiteOrTest.children).filter(isDefined)));
+    }
+  }
+
+  return {
+    successCount: successCount,
+    failedCount: failedCount,
+    skippedCount: skippedCount,
+    pendingCount: pendingCount
+  };
+}
+export function getConnectionUrl() {
+  return [typeof __CREEVEY_SERVER_HOST__ == 'undefined' ? window.location.hostname : __CREEVEY_SERVER_HOST__, typeof __CREEVEY_SERVER_PORT__ == 'undefined' ? window.location.port : __CREEVEY_SERVER_PORT__].filter(Boolean).join(':');
+}
+export function getImageUrl(path, imageName) {
+  // path => [kind, story, test, browser]
+  var browser = path.slice(-1)[0];
+  var imagesUrl = window.location.host ? "".concat(window.location.protocol, "//").concat(getConnectionUrl()).concat(window.location.pathname == '/' ? '/report' : window.location.pathname.split('/').slice(0, -1).join('/'), "/").concat(encodeURI(path.slice(0, -1).join('/'))) : encodeURI(path.slice(0, -1).join('/'));
+  return imageName == browser ? imagesUrl : "".concat(imagesUrl, "/").concat(encodeURI(browser));
+}
+export function getBorderSize(element) {
+  // NOTE Firefox returns empty string for `borderWidth` prop
+  var borderSize = parseFloat(getComputedStyle(element).borderTopWidth);
+  return Number.isNaN(borderSize) ? 0 : borderSize;
+}
+export function useLoadImages(s1, s2, s3) {
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      loaded = _useState2[0],
+      setLoaded = _useState2[1];
+
+  useEffect(function () {
+    setLoaded(false);
+    void Promise.all([s1, s2, s3].map(function (url) {
+      return new Promise(function (resolve) {
+        var image = document.createElement('img');
+        image.src = url;
+        image.onload = resolve;
+        image.onerror = resolve;
+      });
+    })).then(function () {
+      return setLoaded(true);
+    });
+  }, [s1, s2, s3]);
+  return loaded;
+}
+/**
+ * Uses the ResizeObserver API to observe changes within the given HTML Element DOM Rect.
+ *
+ * @returns dimensions of element's content box (which means without paddings and border width)
+ */
+
+export function useResizeObserver(elementRef, onResize) {
+  var debounceTimeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 16;
+  var observerRef = useRef(null);
+  useEffect(function () {
+    if (!elementRef.current) return;
+    observerRef.current = new ResizeObserver(onResize);
+    observerRef.current.observe(elementRef.current);
+    return function () {
+      var _observerRef$current;
+
+      return (_observerRef$current = observerRef.current) === null || _observerRef$current === void 0 ? void 0 : _observerRef$current.disconnect();
+    };
+  }, [debounceTimeout, elementRef, onResize]);
+}
+export function useApplyScale(imageRef, scale, dependency) {
+  useLayoutEffect(function () {
+    if (!imageRef.current) return;
+    var image = imageRef.current;
+    var borderSize = getBorderSize(image);
+    image.style.height = "".concat(image.naturalHeight * scale + borderSize * 2, "px");
+  }, [imageRef, scale, dependency]);
+}
+export function useCalcScale(diffImageRef, loaded) {
+  var _useState3 = useState(1),
+      _useState4 = _slicedToArray(_useState3, 2),
+      scale = _useState4[0],
+      setScale = _useState4[1];
+
+  var calcScale = useCallback(function () {
+    var diffImage = diffImageRef.current;
+    if (!diffImage || !loaded) return setScale(1);
+    var borderSize = getBorderSize(diffImage);
+    var ratio = (diffImage.getBoundingClientRect().width - borderSize * 2) / diffImage.naturalWidth;
+    setScale(Math.min(1, ratio));
+  }, [diffImageRef, loaded]);
+  useResizeObserver(diffImageRef, calcScale);
+  useLayoutEffect(calcScale, [calcScale]);
+  return scale;
+}
+var CREEVEY_THEME = 'Creevey_theme';
+
+function isTheme(theme) {
+  return isDefined(theme) && Object.prototype.hasOwnProperty.call(themes, theme);
+}
+
+function initialTheme() {
+  var theme = localStorage.getItem(CREEVEY_THEME);
+  return isTheme(theme) ? theme : 'light';
+}
+
+export function useTheme() {
+  var _useState5 = useState(initialTheme()),
+      _useState6 = _slicedToArray(_useState5, 2),
+      theme = _useState6[0],
+      setTheme = _useState6[1];
+
+  useEffect(function () {
+    localStorage.setItem(CREEVEY_THEME, theme);
+  }, [theme]);
+  return [theme, setTheme];
+}
+export function setSearchParams(testPath) {
+  var pageUrl = "?".concat(stringify({
+    testPath: testPath
+  }));
+  window.history.pushState({
+    testPath: testPath
+  }, '', pageUrl);
+}
+export function getTestPathFromSearch() {
+  var _parse = parse(window.location.search.slice(1)),
+      testPath = _parse.testPath; //@ts-expect-error: This expression is not callable.
+
+
+  if (Array.isArray(testPath) && testPath.every(function (token) {
+    return typeof token == 'string';
+  })) {
+    return testPath;
+  }
+
+  return [];
+}
+export function useForceUpdate() {
+  var _useState7 = useState({}),
+      _useState8 = _slicedToArray(_useState7, 2),
+      update = _useState8[1];
+
+  return useCallback(function () {
+    return update({});
+  }, []);
+}

package/lib/esm/client/shared/viewMode.js

@@ -0,0 +1,6 @@
+export var VIEW_MODE_KEY = 'Creevey_view_mode';
+export var viewModes = ['side-by-side', 'swap', 'slide', 'blend'];
+export var getViewMode = function getViewMode() {
+  var item = localStorage.getItem(VIEW_MODE_KEY);
+  return item && viewModes.includes(item) ? item : 'side-by-side';
+};

package/lib/esm/creevey.js

@@ -0,0 +1,54 @@
+import cluster from 'cluster';
+import minimist from 'minimist';
+import creevey from './server';
+import { noop } from './types';
+import { emitWorkerMessage } from './server/messages';
+import { isShuttingDown, shutdown, shutdownWorkers } from './server/utils';
+import { setDefaultLevel, levels } from 'loglevel';
+import { logger } from './server/logger';
+
+function shutdownOnException(reason) {
+  if (isShuttingDown.current) return;
+  const error = reason instanceof Error ? reason.stack ?? reason.message : reason;
+  logger.error(error);
+  process.exitCode = -1;
+  if (cluster.isWorker) emitWorkerMessage({
+    type: 'error',
+    payload: {
+      error
+    }
+  });
+  if (cluster.isPrimary && !isShuttingDown.current) void shutdownWorkers();
+}
+
+process.on('uncaughtException', shutdownOnException);
+process.on('unhandledRejection', shutdownOnException);
+if (cluster.isWorker) process.on('SIGINT', noop);
+if (cluster.isPrimary) process.on('SIGINT', shutdown);
+const argv = minimist(process.argv.slice(2), {
+  string: ['browser', 'config', 'reporter', 'reportDir', 'screenDir'],
+  boolean: ['debug', 'ui', 'saveReport', 'webpack', 'tests'],
+  default: {
+    port: 3000,
+    saveReport: true
+  },
+  alias: {
+    port: 'p',
+    config: 'c',
+    debug: 'd',
+    update: 'u',
+    extract: 'e'
+  }
+}); // @ts-expect-error: define log level for storybook
+
+global.LOGLEVEL = argv.debug ? 'debug' : 'warn';
+
+if (argv.debug) {
+  logger.setDefaultLevel(levels.DEBUG);
+  setDefaultLevel(levels.DEBUG);
+} else {
+  logger.setDefaultLevel(levels.INFO);
+  setDefaultLevel(levels.INFO);
+}
+
+void creevey(argv);

package/lib/esm/index.js

@@ -0,0 +1,5 @@
+export * from './types';
+export { loadStories as browserStoriesProvider } from './server/storybook/providers/browser';
+export { loadStories as nodejsStoriesProvider } from './server/storybook/providers/nodejs';
+export { loadStories as hybridStoriesProvider } from './server/storybook/providers/hybrid';
+export * from './server/testsFiles/parser';

package/lib/esm/server/config.js

@@ -0,0 +1,73 @@
+import fs from 'fs';
+import path from 'path';
+import { isCSFv3Enabled, isStorybookVersionGreaterThan, isStorybookVersionLessThan, storybookDirRef } from './storybook/helpers';
+import { loadStories as nodejsStoriesProvider } from './storybook/providers/nodejs';
+import { loadStories as browserStoriesProvider } from './storybook/providers/browser';
+import { isDefined } from '../types';
+export const defaultBrowser = 'chrome';
+export const defaultConfig = {
+  useDocker: true,
+  useWebpackToExtractTests: false,
+  dockerImage: 'aerokube/selenoid:latest-release',
+  dockerImagePlatform: '',
+  pullImages: true,
+  failFast: false,
+  storybookUrl: 'http://localhost:6006',
+  screenDir: path.resolve('images'),
+  reportDir: path.resolve('report'),
+  storybookDir: path.resolve('.storybook'),
+  maxRetries: 0,
+  diffOptions: {
+    threshold: 0,
+    includeAA: true
+  },
+  browsers: {
+    [defaultBrowser]: true
+  },
+  hooks: {},
+  babelOptions: _ => _,
+  testsRegex: /\.creevey\.(t|j)s$/
+};
+
+function normalizeBrowserConfig(name, config) {
+  if (typeof config == 'boolean') return {
+    browserName: name
+  };
+  if (typeof config == 'string') return {
+    browserName: config
+  };
+  return config;
+}
+
+function resolveConfigPath(configPath) {
+  const rootDir = process.cwd();
+  const configDir = path.resolve('.creevey');
+
+  if (isDefined(configPath)) {
+    configPath = path.resolve(configPath);
+  } else if (fs.existsSync(configDir)) {
+    configPath = path.join(configDir, 'config'); // TODO We already find file with extension, why not use it?
+  } else if (fs.readdirSync(rootDir).find(filename => filename.startsWith('creevey.config'))) {
+    configPath = path.join(rootDir, 'creevey.config');
+  }
+
+  return configPath;
+}
+
+export async function readConfig(options) {
+  const configPath = resolveConfigPath(options.config);
+  const userConfig = { ...defaultConfig
+  };
+  if (isDefined(configPath)) Object.assign(userConfig, (await import(configPath)).default);
+  storybookDirRef.current = userConfig.storybookDir;
+  if (isStorybookVersionLessThan(6, 2)) userConfig.useWebpackToExtractTests = true;
+  if (!userConfig.storiesProvider) userConfig.storiesProvider = (await isCSFv3Enabled()) && isStorybookVersionGreaterThan(5) ? browserStoriesProvider : nodejsStoriesProvider;
+  if (userConfig.storiesProvider == browserStoriesProvider && isStorybookVersionLessThan(6)) throw new Error("Creevey browser stories provider doesn't support Storybook 5.x or older versions");
+  if (options.failFast != undefined) userConfig.failFast = Boolean(options.failFast);
+  if (options.reportDir) userConfig.reportDir = path.resolve(options.reportDir);
+  if (options.screenDir) userConfig.screenDir = path.resolve(options.screenDir); // NOTE: Hack to pass typescript checking
+
+  const config = userConfig;
+  Object.entries(config.browsers).forEach(([browser, browserConfig]) => config.browsers[browser] = normalizeBrowserConfig(browser, browserConfig));
+  return config;
+}

package/lib/esm/server/docker.js

@@ -0,0 +1,123 @@
+import cluster from 'cluster';
+import { isDockerMessage } from '../types';
+import { subscribeOn, sendDockerMessage, emitDockerMessage } from './messages';
+import { isInsideDocker, LOCALHOST_REGEXP } from './utils';
+import Dockerode from 'dockerode';
+import { Writable } from 'stream';
+import ora from 'ora';
+import { logger } from './logger';
+const docker = new Dockerode();
+
+class DevNull extends Writable {
+  _write(_chunk, _encoding, callback) {
+    setImmediate(callback);
+  }
+
+}
+
+export async function pullImages(images, {
+  auth,
+  platform
+} = {}) {
+  const args = {};
+  if (auth) args.authconfig = auth;
+  if (platform) args.platform = platform;
+  logger.info('Pull docker images');
+
+  for (const image of images) {
+    await new Promise((resolve, reject) => {
+      const spinner = ora(`${image}: Pull start`).start(); // eslint-disable-next-line @typescript-eslint/no-floating-promises
+
+      docker.pull(image, args, function (pullError, stream) {
+        if (pullError) {
+          spinner.fail();
+          return reject(pullError);
+        } // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+
+
+        docker.modem.followProgress(stream, onFinished, onProgress);
+
+        function onFinished(error) {
+          if (error) {
+            spinner.fail();
+            return reject(error);
+          }
+
+          spinner.succeed(`${image}: Pull complete`);
+          resolve();
+        }
+
+        function onProgress(event) {
+          if (!/^[a-z0-9]{12}$/i.test(event.id)) return;
+          spinner.text = `${image}: [${event.id}] ${event.status} ${event.progress ? `${event.progress}` : ''}`;
+        }
+      });
+    });
+  }
+}
+export async function runImage(image, args, options, debug) {
+  await Promise.all((await docker.listContainers({
+    all: true,
+    filters: {
+      ancestor: [image]
+    }
+  })).map(async info => {
+    const container = docker.getContainer(info.Id);
+
+    try {
+      await container.stop();
+    } catch (_) {
+      /* noop */
+    }
+
+    await container.remove();
+  }));
+  const hub = docker.run(image, args, debug ? process.stdout : new DevNull(), options, error => {
+    if (error) throw error;
+  });
+  return new Promise(resolve => {
+    hub.once('container', container => {
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
+      subscribeOn('shutdown', async () => {
+        try {
+          await container.stop();
+          await container.remove();
+        } catch (error) {
+          /* noop */
+        }
+      });
+    });
+    hub.once('start', container => void container.inspect().then(info => resolve(info.NetworkSettings.Networks.bridge.IPAddress)));
+  });
+}
+export default async function (config, browser, startContainer) {
+  if (cluster.isPrimary) {
+    const host = await startContainer();
+    let gridUrl = 'http://localhost:4444/wd/hub';
+    gridUrl = isInsideDocker ? gridUrl.replace(LOCALHOST_REGEXP, host) : gridUrl;
+    cluster.on('message', (worker, message) => {
+      if (!isDockerMessage(message)) return;
+      const dockerMessage = message;
+      if (dockerMessage.type != 'start') return;
+      sendDockerMessage(worker, {
+        type: 'success',
+        payload: {
+          gridUrl
+        }
+      });
+    });
+  } else {
+    if (browser && config.browsers[browser].gridUrl) return Promise.resolve();
+    return new Promise(resolve => {
+      subscribeOn('docker', message => {
+        if (message.type == 'success') {
+          config.gridUrl = message.payload.gridUrl;
+          resolve();
+        }
+      });
+      emitDockerMessage({
+        type: 'start'
+      });
+    });
+  }
+}