creevey 0.9.0-beta.1 → 0.9.0-beta.10.timeouts.0

package/lib/esm/server/selenium/selenoid.js

@@ -0,0 +1,149 @@
+import path from 'path';
+import { promisify } from 'util';
+import { mkdir, writeFile, copyFile, lstatSync, existsSync } from 'fs';
+import { downloadBinary, getCreeveyCache } from '../utils';
+import { pullImages, runImage } from '../docker';
+import { Octokit } from '@octokit/core';
+import { subscribeOn } from '../messages';
+import cluster from 'cluster';
+import { chmod, exec } from 'shelljs';
+const mkdirAsync = promisify(mkdir);
+const writeFileAsync = promisify(writeFile);
+const copyFileAsync = promisify(copyFile);
+
+async function createSelenoidConfig(browsers, {
+  useDocker
+}) {
+  const selenoidConfig = {};
+  const selenoidConfigDir = path.join(getCreeveyCache(), 'selenoid');
+  browsers.forEach(({
+    browserName,
+    version = 'latest',
+    dockerImage = `selenoid/${browserName}:${version}`,
+    webdriverCommand = []
+  }) => {
+    if (!selenoidConfig[browserName]) selenoidConfig[browserName] = {
+      default: version,
+      versions: {}
+    };
+    if (!useDocker && webdriverCommand.length == 0) throw new Error('Please specify "webdriverCommand" browser option with path to browser webdriver');
+    selenoidConfig[browserName].versions[version] = {
+      image: useDocker ? dockerImage : webdriverCommand,
+      port: '4444',
+      path: !useDocker || ['chrome', 'opera', 'webkit', 'MicrosoftEdge'].includes(browserName) ? '/' : '/wd/hub'
+    };
+  });
+  await mkdirAsync(selenoidConfigDir, {
+    recursive: true
+  });
+  await writeFileAsync(path.join(selenoidConfigDir, 'browsers.json'), JSON.stringify(selenoidConfig));
+  return selenoidConfigDir;
+}
+
+async function downloadSelenoidBinary(destination) {
+  const platformNameMapping = {
+    darwin: 'selenoid_darwin_amd64',
+    linux: 'selenoid_linux_amd64',
+    win32: 'selenoid_windows_amd64.exe'
+  };
+  const octokit = new Octokit();
+  const response = await octokit.request('GET /repos/{owner}/{repo}/releases/latest', {
+    owner: 'aerokube',
+    repo: 'selenoid'
+  });
+  const {
+    assets
+  } = response.data;
+  const {
+    browser_download_url: downloadUrl,
+    size: binarySize
+  } = assets.find(({
+    name
+  }) => platformNameMapping[process.platform] == name) ?? {};
+  if (existsSync(destination) && lstatSync(destination).size == binarySize) return;
+
+  if (!downloadUrl) {
+    throw new Error(`Couldn't get download url for selenoid binary. Please download it manually from "https://github.com/aerokube/selenoid/releases/latest" and define "selenoidPath" option in the Creevey config`);
+  }
+
+  return downloadBinary(downloadUrl, destination);
+}
+
+export async function startSelenoidStandalone(config, debug) {
+  config.gridUrl = 'http://localhost:4444/wd/hub';
+  if (cluster.isWorker) return;
+  const browsers = Object.values(config.browsers).filter(browser => !browser.gridUrl);
+  const selenoidConfigDir = await createSelenoidConfig(browsers, {
+    useDocker: false
+  });
+  const binaryPath = path.join(selenoidConfigDir, process.platform == 'win32' ? 'selenoid.exe' : 'selenoid');
+
+  if (config.selenoidPath) {
+    await copyFileAsync(path.resolve(config.selenoidPath), binaryPath);
+  } else {
+    await downloadSelenoidBinary(binaryPath);
+  } // TODO Download browser webdrivers
+
+
+  try {
+    if (process.platform != 'win32') chmod('+x', binaryPath);
+  } catch (_) {
+    /* noop */
+  }
+
+  const selenoidProcess = exec(`${binaryPath} -conf ./browsers.json -disable-docker`, {
+    async: true,
+    cwd: selenoidConfigDir
+  });
+
+  if (debug) {
+    var _selenoidProcess$stdo, _selenoidProcess$stde;
+
+    (_selenoidProcess$stdo = selenoidProcess.stdout) === null || _selenoidProcess$stdo === void 0 ? void 0 : _selenoidProcess$stdo.pipe(process.stdout);
+    (_selenoidProcess$stde = selenoidProcess.stderr) === null || _selenoidProcess$stde === void 0 ? void 0 : _selenoidProcess$stde.pipe(process.stderr);
+  }
+
+  subscribeOn('shutdown', () => selenoidProcess.kill());
+}
+export async function startSelenoidContainer(config, debug) {
+  const browsers = Object.values(config.browsers).filter(browser => !browser.gridUrl);
+  const images = [];
+  let limit = 0;
+  browsers.forEach(({
+    browserName,
+    version = 'latest',
+    limit: browserLimit = 1,
+    dockerImage = `selenoid/${browserName}:${version}`
+  }) => {
+    limit += browserLimit;
+    images.push(dockerImage);
+  });
+  const selenoidImage = config.dockerImage;
+  const pullOptions = {
+    auth: config.dockerAuth,
+    platform: config.dockerImagePlatform
+  };
+
+  if (config.pullImages) {
+    await pullImages([selenoidImage], pullOptions);
+    await pullImages(images, pullOptions);
+  } // TODO Allow pass custom options
+
+
+  const selenoidOptions = {
+    ExposedPorts: {
+      '4444/tcp': {}
+    },
+    HostConfig: {
+      PortBindings: {
+        '4444/tcp': [{
+          HostPort: '4444'
+        }]
+      },
+      Binds: ['/var/run/docker.sock:/var/run/docker.sock', `${await createSelenoidConfig(browsers, {
+        useDocker: true
+      })}:/etc/selenoid/:ro`]
+    }
+  };
+  return runImage(selenoidImage, ['-limit', String(limit)], selenoidOptions, debug);
+}

package/lib/esm/server/stories.js

@@ -0,0 +1,135 @@
+import path from 'path';
+import { mkdirSync, writeFileSync } from 'fs';
+import { createHash } from 'crypto';
+import { mapValues, pick } from 'lodash';
+import { isDefined, isFunction, isObject } from '../types';
+import { shouldSkip, removeProps } from './utils';
+
+function storyTestFabric(delay, testFn) {
+  return async function storyTest() {
+    delay ? await new Promise(resolve => setTimeout(resolve, delay)) : void 0;
+    await (testFn ? testFn.call(this) : this.screenshots.length > 0 ? this.expect(this.screenshots.reduce((screenshots, {
+      imageName,
+      screenshot
+    }, index) => ({ ...screenshots,
+      [imageName ?? `screenshot_${index}`]: screenshot
+    }), {})).to.matchImages() : this.expect(await this.takeScreenshot()).to.matchImage());
+  };
+}
+
+function createCreeveyTest(browser, storyMeta, skipOptions, testName) {
+  const {
+    kind,
+    name: story,
+    id: storyId
+  } = storyMeta;
+  const path = [kind, story, testName, browser].filter(isDefined);
+  const skip = skipOptions ? shouldSkip(browser, {
+    kind,
+    story
+  }, skipOptions, testName) : false;
+  const id = createHash('sha1').update(path.join('/')).digest('hex');
+  return {
+    id,
+    skip,
+    browser,
+    testName,
+    storyPath: [...kind.split('/').map(x => x.trim()), story],
+    storyId
+  };
+}
+
+function convertStories(browserName, stories) {
+  const tests = {};
+  (Array.isArray(stories) ? stories : Object.values(stories)).forEach(storyMeta => {
+    // TODO Skip docsOnly stories for now
+    if (storyMeta.parameters.docsOnly) return;
+    const {
+      delay: delayParam,
+      tests: storyTests,
+      skip
+    } = storyMeta.parameters.creevey ?? {};
+    const delay = typeof delayParam == 'number' ? delayParam : delayParam !== null && delayParam !== void 0 && delayParam.for.includes(browserName) ? delayParam.ms : 0; // typeof tests === "undefined" => rootSuite -> kindSuite -> storyTest -> [browsers.png]
+    // typeof tests === "function"  => rootSuite -> kindSuite -> storyTest -> browser -> [images.png]
+    // typeof tests === "object"    => rootSuite -> kindSuite -> storySuite -> test -> [browsers.png]
+    // typeof tests === "object"    => rootSuite -> kindSuite -> storySuite -> test -> browser -> [images.png]
+
+    if (!storyTests) {
+      const test = createCreeveyTest(browserName, storyMeta, skip);
+      tests[test.id] = { ...test,
+        storyId: storyMeta.id,
+        story: storyMeta,
+        fn: storyTestFabric(delay)
+      };
+      return;
+    }
+
+    Object.entries(storyTests).forEach(([testName, testFn]) => {
+      const test = createCreeveyTest(browserName, storyMeta, skip, testName);
+      tests[test.id] = { ...test,
+        storyId: storyMeta.id,
+        story: storyMeta,
+        fn: storyTestFabric(delay, testFn)
+      };
+    });
+  });
+  return tests;
+}
+
+export async function loadTestsFromStories(browsers, provider, update) {
+  const testIdsByFiles = new Map();
+  const stories = await provider(storiesByFiles => {
+    const testsDiff = {};
+    const tests = {};
+    browsers.forEach(browser => {
+      Array.from(storiesByFiles.entries()).forEach(([filename, stories]) => {
+        var _testIdsByFiles$get;
+
+        Object.assign(tests, convertStories(browser, stories));
+        const changed = Object.keys(tests);
+        const removed = ((_testIdsByFiles$get = testIdsByFiles.get(filename)) === null || _testIdsByFiles$get === void 0 ? void 0 : _testIdsByFiles$get.filter(testId => !tests[testId])) ?? [];
+        if (changed.length == 0) testIdsByFiles.delete(filename);else testIdsByFiles.set(filename, changed);
+        Object.assign(testsDiff, tests);
+        removed.forEach(testId => testsDiff[testId] = undefined);
+      });
+    });
+    update === null || update === void 0 ? void 0 : update(testsDiff);
+  });
+  const tests = browsers.reduce((tests, browser) => Object.assign(tests, convertStories(browser, stories)), {});
+  Object.values(tests).filter(isDefined).forEach(({
+    id,
+    story: {
+      parameters: {
+        fileName
+      }
+    }
+  }) => // TODO Don't use filename as a key, due possible collisions if two require.context with same structure of modules are defined
+  testIdsByFiles.set(fileName, [...(testIdsByFiles.get(fileName) ?? []), id]));
+  return tests;
+}
+export function saveStoriesJson(storiesData, extract) {
+  const outputDir = typeof extract == 'boolean' ? 'storybook-static' : extract; // NOTE Copy-pasted from Storybook's `getStoriesJsonData` method
+
+  const allowed = ['fileName', 'docsOnly', 'framework', '__id', '__isArgsStory'];
+  storiesData.globalParameters = pick(storiesData.globalParameters, allowed); // @ts-expect-error ignore error
+
+  storiesData.kindParameters = mapValues(storiesData.kindParameters, v => pick(v, allowed)); // @ts-expect-error ignore error
+
+  storiesData.stories = mapValues(storiesData.stories, v => ({ ...pick(v, ['id', 'name', 'kind', 'story']),
+    parameters: pick(v.parameters, allowed)
+  })); // TODO Fix args stories
+
+  removeProps(storiesData ?? {}, ['stories', () => true, 'parameters', '__isArgsStory']);
+  Object.values((storiesData === null || storiesData === void 0 ? void 0 : storiesData.stories) ?? {}).forEach(story => isObject(story) && 'parameters' in story && isObject(story.parameters) && delete story.parameters.__isArgsStory);
+  mkdirSync(outputDir, {
+    recursive: true
+  });
+  writeFileSync(path.join(outputDir, 'stories.json'), JSON.stringify(storiesData, null, 2));
+}
+export function saveTestsJson(tests, dstPath = process.cwd()) {
+  mkdirSync(dstPath, {
+    recursive: true
+  });
+  writeFileSync(path.join(dstPath, 'tests.json'), // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  JSON.stringify(tests, (_, value) => isFunction(value) ? value.toString() : value, 2));
+}

package/lib/esm/server/storybook/entry.js

@@ -0,0 +1,27 @@
+import { addons } from '@storybook/addons';
+import { getStorybookFramework, resolveFromStorybook } from './helpers';
+const framework = getStorybookFramework(); // eslint-disable-next-line @typescript-eslint/no-var-requires
+
+const core = require(resolveFromStorybook('@storybook/core-client'));
+
+const start = core.start;
+const api = start(() => void 0);
+export const channel = addons.getChannel();
+export const clientApi = api.clientApi;
+export const forceReRender = api.forceReRender;
+export const storiesOf = (kind, m) => {
+  return clientApi.storiesOf(kind, m).addParameters({
+    framework
+  });
+};
+export const configure = (...args) => {
+  //NOTE Storybook 6.x pass `framework` as first argument
+  //@ts-expect-error: ignore it
+  return api.configure(framework, ...args);
+};
+export const addDecorator = clientApi.addDecorator;
+export const addParameters = clientApi.addParameters;
+export const clearDecorators = clientApi.clearDecorators;
+export const setAddon = clientApi.setAddon;
+export const getStorybook = clientApi.getStorybook;
+export const raw = clientApi.raw;

package/lib/esm/server/storybook/helpers.js

@@ -0,0 +1,97 @@
+import path from 'path';
+import resolveFrom from 'resolve-from';
+const supportedFrameworks = ['react', 'vue', 'vue3', 'angular', 'marionette', 'mithril', 'marko', 'html', 'svelte', 'riot', 'ember', 'preact', 'rax', 'aurelia', 'server', 'web-components'];
+export const storybookDirRef = {
+  current: path.resolve('.storybook')
+};
+export const resolveFromStorybook = modulePath => resolveFrom(storybookDirRef.current, modulePath);
+export const resolveFromStorybookAddonDocs = modulePath => resolveFrom(resolveFromStorybook('@storybook/addon-docs'), modulePath);
+export const resolveFromStorybookBuilderWebpack4 = modulePath => resolveFrom(resolveFromStorybook('@storybook/builder-webpack4'), modulePath);
+export const resolveFromStorybookCoreClient = modulePath => resolveFrom(resolveFromStorybook('@storybook/core-client'), modulePath);
+export const resolveFromStorybookCoreServer = modulePath => resolveFrom(resolveFromStorybook('@storybook/core-server'), modulePath);
+
+const importFromStorybook = modulePath => import(resolveFromStorybook(modulePath));
+
+export const importStorybookClientLogger = () => importFromStorybook('@storybook/client-logger');
+export const importStorybookCoreCommon = () => importFromStorybook('@storybook/core-common');
+export const importStorybookCoreEvents = () => importFromStorybook('@storybook/core-events');
+export function hasDocsAddon() {
+  try {
+    resolveFromStorybook('@storybook/addon-docs');
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+export function hasSvelteCSFAddon() {
+  try {
+    resolveFromStorybook('@storybook/addon-svelte-csf');
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+export function getStorybookVersion() {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const {
+    version
+  } = require(resolveFromStorybook('@storybook/core-server/package.json'));
+
+  return version;
+}
+export function isStorybookVersionLessThan(major, minor) {
+  const [sbMajor, sbMinor] = (process.env.__CREEVEY_STORYBOOK_VERSION__ ?? getStorybookVersion()).split('.');
+  return Number(sbMajor) < major || minor != undefined && Number(sbMajor) == major && Number(sbMinor) < minor;
+}
+export function isStorybookVersionGreaterThan(major, minor) {
+  const [sbMajor, sbMinor] = (process.env.__CREEVEY_STORYBOOK_VERSION__ ?? getStorybookVersion()).split('.');
+  return Number(sbMajor) > major || minor != undefined && Number(sbMajor) == major && Number(sbMinor) > minor;
+}
+export function isStorybookVersion(major, minor) {
+  const [sbMajor, sbMinor] = (process.env.__CREEVEY_STORYBOOK_VERSION__ ?? getStorybookVersion()).split('.');
+  return Number(sbMajor) == major || minor != undefined && Number(sbMajor) == major && Number(sbMinor) == minor;
+}
+export function getStorybookFramework() {
+  const framework = process.env.__CREEVEY_STORYBOOK_FRAMEWORK__ ?? supportedFrameworks.find(framework => {
+    try {
+      return require.resolve(resolveFromStorybook(`@storybook/${framework}`));
+    } catch (_) {
+      return false;
+    }
+  });
+  if (!framework) throw new Error("Couldn't detect used Storybook framework. Please ensure that you install `@storybook/<framework>` package");
+  return framework;
+}
+export const storybookConfigRef = {
+  current: {
+    stories: []
+  }
+};
+export async function importStorybookConfig() {
+  const configPath = `${storybookDirRef.current}/main`;
+
+  try {
+    return storybookConfigRef.current = (await import(require.resolve(configPath))).default;
+  } catch (_) {
+    const storybookUtilsPath = '@storybook/core-common/dist/cjs/utils';
+    const serverRequireModule = 'interpret-require'; // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+
+    const {
+      getInterpretedFile
+    } = await import(resolveFromStorybook(`${storybookUtilsPath}/interpret-files`)); // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+
+    const {
+      default: serverRequireFallback,
+      serverRequire = serverRequireFallback
+    } = await import(resolveFromStorybook(`${storybookUtilsPath}/${serverRequireModule}`)); // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
+
+    const mainConfigFile = getInterpretedFile(configPath); // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
+
+    return storybookConfigRef.current = serverRequire(mainConfigFile);
+  }
+}
+export async function isCSFv3Enabled() {
+  var _await$importStoryboo, _await$importStoryboo2;
+
+  return ((_await$importStoryboo = await importStorybookConfig()) === null || _await$importStoryboo === void 0 ? void 0 : (_await$importStoryboo2 = _await$importStoryboo.features) === null || _await$importStoryboo2 === void 0 ? void 0 : _await$importStoryboo2.previewCsfV3) ?? false;
+}

package/lib/esm/server/storybook/providers/browser.js

@@ -0,0 +1,58 @@
+import cluster from 'cluster';
+import { loadStoriesFromBrowser } from '../../selenium';
+import { emitStoriesMessage, sendStoriesMessage, subscribeOn, subscribeOnWorker } from '../../messages';
+import { isDefined } from '../../../types';
+import { logger } from '../../logger';
+export const loadStories = async (_config, _options, storiesListener) => {
+  if (cluster.isPrimary) {
+    return new Promise(resolve => {
+      const worker = Object.values(cluster.workers ?? {}).filter(isDefined).find(worker => worker.isConnected());
+
+      if (worker) {
+        const unsubscribe = subscribeOnWorker(worker, 'stories', message => {
+          if (message.type == 'set') {
+            const {
+              stories,
+              oldTests
+            } = message.payload;
+            if (oldTests.length > 0) logger.warn(`If you use browser stories provider of CSFv3 Storybook feature\n` + `Creevey will not load tests defined in story parameters from following stories:\n` + oldTests.join('\n'));
+            unsubscribe();
+            resolve(stories);
+          }
+        });
+        sendStoriesMessage(worker, {
+          type: 'get'
+        });
+      }
+
+      subscribeOn('stories', message => {
+        // TODO updates only one browser :(
+        if (message.type == 'update') storiesListener(new Map(message.payload));
+      });
+    });
+  } else {
+    subscribeOn('stories', message => {
+      if (message.type == 'get') emitStoriesMessage({
+        type: 'set',
+        payload: {
+          stories,
+          oldTests: storiesWithOldTests
+        }
+      });
+      if (message.type == 'update') storiesListener(new Map(message.payload));
+    });
+    const stories = await loadStoriesFromBrowser();
+    const storiesWithOldTests = [];
+    Object.values(stories).forEach(story => {
+      var _parameters, _parameters$creevey;
+
+      if ((_parameters = story.parameters) !== null && _parameters !== void 0 && (_parameters$creevey = _parameters.creevey) !== null && _parameters$creevey !== void 0 && _parameters$creevey.tests) {
+        var _parameters2, _parameters2$creevey;
+
+        (_parameters2 = story.parameters) === null || _parameters2 === void 0 ? true : (_parameters2$creevey = _parameters2.creevey) === null || _parameters2$creevey === void 0 ? true : delete _parameters2$creevey.tests;
+        storiesWithOldTests.push(`${story.kind}/${story.name}`);
+      }
+    });
+    return stories;
+  }
+};

package/lib/esm/server/storybook/providers/hybrid.js

@@ -0,0 +1,60 @@
+import chokidar from 'chokidar';
+import { loadStories as browserProvider } from './browser';
+import { logger } from '../../logger';
+import parse from '../../testsFiles/parser';
+import { readDirRecursive } from '../../../server/utils';
+import { combineParameters } from '../../../shared';
+export const loadStories = async (_config, _options, storiesListener) => {
+  let creeveyParamsByStoryId = {};
+
+  const mergeParamsFromTestsToStory = (story, creeveyParams) => {
+    if (story.parameters) {
+      story.parameters.creevey = combineParameters(story.parameters.creevey || {}, creeveyParams);
+    }
+  };
+
+  const stories = await browserProvider(_config, {}, updatedStoriesByFiles => {
+    Array.from(updatedStoriesByFiles.entries()).forEach(([, storiesArray]) => {
+      storiesArray.forEach(story => {
+        const creeveyParams = creeveyParamsByStoryId[story.id];
+
+        if (creeveyParams) {
+          mergeParamsFromTestsToStory(story, creeveyParams);
+        }
+      });
+    });
+    storiesListener(updatedStoriesByFiles);
+  }); // TODO fix test files hot reloading
+
+  creeveyParamsByStoryId = await parseParams(_config
+  /*, (data) => console.log(data) */
+  );
+  Object.entries(stories).forEach(([storyId, story]) => {
+    mergeParamsFromTestsToStory(story, creeveyParamsByStoryId[storyId]);
+  });
+  return stories;
+};
+
+async function parseParams(config, listener) {
+  if (!config.testsDir) {
+    return Promise.resolve({});
+  }
+
+  const testFiles = readDirRecursive(config.testsDir).filter(file => {
+    var _config$testsRegex;
+
+    return (_config$testsRegex = config.testsRegex) === null || _config$testsRegex === void 0 ? void 0 : _config$testsRegex.test(file);
+  });
+  await (await import('../../testsFiles/register')).default(config);
+
+  if (listener) {
+    chokidar.watch(testFiles).on('change', filePath => {
+      logger.debug(`changed: ${filePath}`); // doesn't work, always returns {} due modules caching
+      // see https://github.com/nodejs/modules/issues/307
+
+      void parse(testFiles).then(data => listener(data));
+    });
+  }
+
+  return parse(testFiles);
+}