@zohodesk/testinglibrary 0.1.8-exp-bdd-v2 → 0.1.8-exp-bdd-v4

package/build/bdd-framework/playwright/testTypeImpl.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isParentChildTest = isParentChildTest;
+exports.isTestContainsSubtest = isTestContainsSubtest;
 exports.runStepWithCustomLocation = runStepWithCustomLocation;
 var _test = require("@playwright/test");
 var _utils = require("../utils");
@@ -39,13 +39,17 @@ async function runStepWithCustomLocation(test, stepText, location, body) {
   });
 }
 /**
- * Returns true if all fixtures of parent test found in child test.
+ * Returns true if test contains all fixtures of subtest.
+ * - test was extended from subtest
+ * - test is a result of mergeTests(subtest, ...)
  */
-function isParentChildTest(parent, child) {
-  if (parent === child) return false;
-  const childLocationsSet = new Set(getTestFixtures(child).map(f => locationToString(f.location)));
-  return getTestFixtures(parent).every(f => {
-    return childLocationsSet.has(locationToString(f.location));
+function isTestContainsSubtest(test, subtest) {
+  if (test === subtest) {
+    return true;
+  }
+  const testFixtures = new Set(getTestFixtures(test).map(f => locationToString(f.location)));
+  return getTestFixtures(subtest).every(f => {
+    return testFixtures.has(locationToString(f.location));
   });
 }
 function locationToString({

package/build/bdd-framework/playwright/transform.js

@@ -30,13 +30,17 @@ function installTransform() {
   function resolveFilename(specifier, parent, ...rest) {
     if (!reverted && parent) {
       const resolved = resolveHook(parent.filename, specifier);
-      if (resolved !== undefined) specifier = resolved;
+      if (resolved !== undefined) {
+        specifier = resolved;
+      }
     }
     return originalResolveFilename.call(this, specifier, parent, ...rest);
   }
   _module.default._resolveFilename = resolveFilename;
   const revertPirates = pirates.addHook((code, filename) => {
-    if (!shouldTransform(filename)) return code;
+    if (!shouldTransform(filename)) {
+      return code;
+    }
     return transformHook(code, filename);
   }, {
     exts: ['.ts', '.tsx', '.js', '.jsx', '.mjs']

package/build/bdd-framework/playwright/utils.js

@@ -28,10 +28,7 @@ function getPlaywrightRoot() {
     // See: https://github.com/microsoft/playwright/pull/26946
     const playwrightTestRoot = (0, _utils.resolvePackageRoot)('@playwright/test');
     const libDir = _path.default.join(playwrightTestRoot, 'lib');
-
-    // Recently added functionality in playwright
-    const playwrightDir = _path.default.join(playwrightTestRoot, 'node_modules', 'playwright');
-    playwrightRoot = _fs.default.existsSync(libDir) ? playwrightTestRoot : playwrightDir;
+    playwrightRoot = _fs.default.existsSync(libDir) ? playwrightTestRoot : (0, _utils.resolvePackageRoot)('playwright');
   }
   return playwrightRoot;
 }

package/build/bdd-framework/run/StepInvoker.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StepInvoker = void 0;
+var _loadSteps = require("../cucumber/loadSteps");
+var _getLocationInFile = require("../playwright/getLocationInFile");
+var _testTypeImpl = require("../playwright/testTypeImpl");
+var _defineStep = require("../stepDefinitions/defineStep");
+var _lang = require("../config/lang");
+/**
+ * Class to invoke steps in generated files.
+ */
+
+class StepInvoker {
+  world;
+  keyword;
+  text = '';
+  argument;
+  constructor(world, keyword) {
+    this.world = world;
+    this.keyword = keyword;
+    this.invoke = this.invoke.bind(this);
+  }
+  async invoke(text, argument, stepFixtures) {
+    this.text = text;
+    this.argument = argument;
+    const {
+      world
+    } = this;
+    world.stepFixtures = stepFixtures || {};
+    const stepDefinition = this.getStepDefinition();
+    // Get location of step call in generated test file.
+    // This call must be exactly here to have correct call stack (before async calls)
+    const location = (0, _getLocationInFile.getLocationInFile)(world.test.info().file);
+    const stepTitle = this.getStepTitle();
+    const code = (0, _defineStep.getStepCode)(stepDefinition);
+    const parameters = await this.getStepParameters(stepDefinition);
+    return (0, _testTypeImpl.runStepWithCustomLocation)(world.test, stepTitle, location, () => code.apply(world, parameters));
+  }
+  getStepDefinition() {
+    const stepDefinition = (0, _loadSteps.findStepDefinition)(this.world.options.supportCodeLibrary, this.text, this.world.testInfo.file);
+    if (!stepDefinition) {
+      throw new Error(`Undefined step: "${this.text}"`);
+    }
+    return stepDefinition;
+  }
+  async getStepParameters(stepDefinition) {
+    const {
+      text,
+      argument,
+      world
+    } = this;
+    const {
+      parameters
+    } = await stepDefinition.getInvocationParameters({
+      hookParameter: {},
+      step: {
+        text,
+        argument
+      },
+      world
+    });
+    return parameters;
+  }
+  getStepTitle() {
+    // Currently prepend keyword only for English.
+    // For other langs it's more complex as we need to pass original keyword from step.
+    return (0, _lang.isEnglish)(this.world.options.lang) ? `${this.keyword} ${this.text}` : this.text;
+  }
+}
+exports.StepInvoker = StepInvoker;

package/build/bdd-framework/run/bddFixtures.js

@@ -13,12 +13,15 @@ var _config = require("../config");
 var _env = require("../config/env");
 var _steps = require("../stepDefinitions/decorators/steps");
 var _dir = require("../config/dir");
-const test = _test.test.extend({
-  $bddWorldBase: async ({
-    $tags,
-    $test
-  }, use, testInfo) => {
-    const config = (0, _env.getConfigFromEnv)(testInfo.project.testDir);
+var _scenario = require("../hooks/scenario");
+var _worker = require("../hooks/worker");
+var _StepInvoker = require("./StepInvoker");
+const test = exports.test = _test.test.extend({
+  // load cucumber once per worker (auto-fixture)
+  // todo: maybe remove caching in cucumber/loadConfig.ts and cucumber/loadSteps.ts
+  // as we call it once per worker. Check generation phase.
+  $cucumber: [async ({}, use, workerInfo) => {
+    const config = (0, _env.getConfigFromEnv)(workerInfo.project.testDir);
     const environment = {
       cwd: (0, _dir.getPlaywrightConfigDir)()
     };
@@ -30,11 +33,37 @@ const test = _test.test.extend({
     const supportCodeLibrary = await (0, _loadSteps.loadSteps)(runConfiguration, environment);
     (0, _steps.appendDecoratorSteps)(supportCodeLibrary);
     const World = (0, _bddWorld.getWorldConstructor)(supportCodeLibrary);
+    await use({
+      runConfiguration,
+      supportCodeLibrary,
+      World
+    });
+  }, {
+    auto: true,
+    scope: 'worker'
+  }],
+  $lang: ({}, use) => use(''),
+  // init $bddWorldFixtures with empty object, will be owerwritten in test file for cucumber-style
+  $bddWorldFixtures: ({}, use) => use({}),
+  $bddWorld: async ({
+    $tags,
+    $test,
+    $bddWorldFixtures,
+    $cucumber,
+    $lang
+  }, use, testInfo) => {
+    const {
+      runConfiguration,
+      supportCodeLibrary,
+      World
+    } = $cucumber;
     const world = new World({
       testInfo,
       supportCodeLibrary,
       $tags,
       $test,
+      $bddWorldFixtures,
+      lang: $lang,
       parameters: runConfiguration.runtime.worldParameters || {},
       log: () => {},
       attach: async () => {}
@@ -43,65 +72,98 @@ const test = _test.test.extend({
     await use(world);
     await world.destroy();
   },
-  $bddWorld: async ({
-    $bddWorldBase,
-    page,
-    context,
-    browser,
-    browserName,
-    request
-  }, use) => {
-    $bddWorldBase.builtinFixtures = {
-      page,
-      context,
-      browser,
-      browserName,
-      request
-    };
-    await use($bddWorldBase);
-  },
-  // below fixtures are used in playwright-style
-  // and does not automatically init Playwright builtin fixtures
   Given: ({
-    $bddWorldBase
-  }, use) => use($bddWorldBase.invokeStep),
-  When: ({
-    $bddWorldBase
-  }, use) => use($bddWorldBase.invokeStep),
-  Then: ({
-    $bddWorldBase
-  }, use) => use($bddWorldBase.invokeStep),
-  And: ({
-    $bddWorldBase
-  }, use) => use($bddWorldBase.invokeStep),
-  But: ({
-    $bddWorldBase
-  }, use) => use($bddWorldBase.invokeStep),
-  // below fixtures are used in cucumber-style
-  // and automatically init Playwright builtin fixtures
-  Given_: ({
     $bddWorld
-  }, use) => use($bddWorld.invokeStep),
-  When_: ({
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'Given').invoke),
+  When: ({
     $bddWorld
-  }, use) => use($bddWorld.invokeStep),
-  Then_: ({
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'When').invoke),
+  Then: ({
     $bddWorld
-  }, use) => use($bddWorld.invokeStep),
-  And_: ({
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'Then').invoke),
+  And: ({
     $bddWorld
-  }, use) => use($bddWorld.invokeStep),
-  But_: ({
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'And').invoke),
+  But: ({
     $bddWorld
-  }, use) => use($bddWorld.invokeStep),
-  // Init $tags fixture with empty array. Can be owerwritten in test file
-  // eslint-disable-next-line
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'But').invoke),
+  // init $tags with empty array, can be owerwritten in test file
   $tags: ({}, use) => use([]),
-  // Init $test fixture with base test, but it will be always overwritten in test file
-  // eslint-disable-next-line
-  $test: ({}, use) => use(_test.test)
+  // init $test with base test, but it will be always overwritten in test file
+  $test: ({}, use) => use(_test.test),
+  // can be owerwritten in test file if there are scenario hooks
+  $scenarioHookFixtures: ({}, use) => use({}),
+  $before: [
+  // Unused dependencies are important:
+  // 1. $beforeAll / $afterAll: in pw < 1.39 worker-scoped auto-fixtures were called after test-scoped
+  // 2. $after: to call after hooks in case of errors in before hooks
+  async ({
+    $scenarioHookFixtures,
+    $bddWorld,
+    $tags,
+    $beforeAll,
+    $afterAll,
+    $after
+  }, use, $testInfo) => {
+    await (0, _scenario.runScenarioHooks)('before', {
+      $bddWorld,
+      $tags,
+      $testInfo,
+      ...$scenarioHookFixtures
+    });
+    await use();
+  }, {
+    auto: true
+  }],
+  $after: [async ({
+    $scenarioHookFixtures,
+    $bddWorld,
+    $tags
+  }, use, $testInfo) => {
+    await use();
+    await (0, _scenario.runScenarioHooks)('after', {
+      $bddWorld,
+      $tags,
+      $testInfo,
+      ...$scenarioHookFixtures
+    });
+  }, {
+    auto: true
+  }],
+  // can be owerwritten in test file if there are worker hooks
+  $workerHookFixtures: [({}, use) => use({}), {
+    scope: 'worker'
+  }],
+  $beforeAll: [
+  // Important unused dependencies:
+  // 1. $afterAll: in pw < 1.39 worker-scoped auto-fixtures are called in incorrect order
+  // 2. $cucumber: to load hooks before this fixtures
+  async ({
+    $workerHookFixtures,
+    $cucumber
+  }, use, $workerInfo) => {
+    await (0, _worker.runWorkerHooks)('beforeAll', {
+      $workerInfo,
+      ...$workerHookFixtures
+    });
+    await use();
+  }, {
+    auto: true,
+    scope: 'worker'
+  }],
+  $afterAll: [async ({
+    $workerHookFixtures
+  }, use, $workerInfo) => {
+    await use();
+    await (0, _worker.runWorkerHooks)('afterAll', {
+      $workerInfo,
+      ...$workerHookFixtures
+    });
+  }, {
+    auto: true,
+    scope: 'worker'
+  }]
 });
-exports.test = test;
 const BDD_AUTO_INJECT_FIXTURES = ['$testInfo', '$test', '$tags'];
 function isBddAutoInjectFixture(name) {
   return BDD_AUTO_INJECT_FIXTURES.includes(name);

package/build/bdd-framework/run/bddWorld.js

@@ -6,58 +6,46 @@ Object.defineProperty(exports, "__esModule", {
 exports.BddWorld = void 0;
 exports.getWorldConstructor = getWorldConstructor;
 var _cucumber = require("@cucumber/cucumber");
-var _loadSteps = require("../cucumber/loadSteps");
-var _getLocationInFile = require("../playwright/getLocationInFile");
-var _testTypeImpl = require("../playwright/testTypeImpl");
-var _defineStep = require("../stepDefinitions/defineStep");
 class BddWorld extends _cucumber.World {
   options;
-  builtinFixtures;
-  customFixtures;
+  stepFixtures = {};
   constructor(options) {
     super(options);
     this.options = options;
-    this.invokeStep = this.invokeStep.bind(this);
   }
-  async invokeStep(text, argument, customFixtures) {
-    const stepDefinition = (0, _loadSteps.findStepDefinition)(this.options.supportCodeLibrary, text, this.testInfo.file);
-    if (!stepDefinition) {
-      throw new Error(`Undefined step: "${text}"`);
-    }
-    // attach custom fixtures to world - the only way to pass them to cucumber step fn
-    this.customFixtures = customFixtures;
-    const code = (0, _defineStep.getStepCode)(stepDefinition);
-    // Get location of step call in generated test file.
-    // This call must be exactly here to have correct call stack.
-    const location = (0, _getLocationInFile.getLocationInFile)(this.test.info().file);
-    const {
-      parameters
-    } = await stepDefinition.getInvocationParameters({
-      hookParameter: {},
-      step: {
-        text,
-        argument
-      },
-      world: this
-    });
-    const res = await (0, _testTypeImpl.runStepWithCustomLocation)(this.test, text, location, () => code.apply(this, parameters));
-    delete this.customFixtures;
-    return res;
+  /**
+     * Use particular fixture in cucumber-style steps.
+     *
+     * Note: TS does not support partial generic inference,
+     * that's why we can't use this.useFixture<typeof test>('xxx');
+     * The solution is to pass TestType as a generic to BddWorld
+     * and call useFixture without explicit generic params.
+     * Finally, it looks even better as there is no need to pass `typeof test`
+     * in every `this.useFixture` call.
+     *
+     * The downside - it's impossible to pass fixtures type directly to `this.useFixture`
+     * like it's done in @Fixture decorator.
+     *
+     * See: https://stackoverflow.com/questions/45509621/specify-only-first-type-argument
+     * See: https://github.com/Microsoft/TypeScript/pull/26349
+     */
+  useFixture(fixtureName) {
+    return this.stepFixtures[fixtureName];
   }
   get page() {
-    return this.builtinFixtures.page;
+    return this.options.$bddWorldFixtures.page;
   }
   get context() {
-    return this.builtinFixtures.context;
+    return this.options.$bddWorldFixtures.context;
   }
   get browser() {
-    return this.builtinFixtures.browser;
+    return this.options.$bddWorldFixtures.browser;
   }
   get browserName() {
-    return this.builtinFixtures.browserName;
+    return this.options.$bddWorldFixtures.browserName;
   }
   get request() {
-    return this.builtinFixtures.request;
+    return this.options.$bddWorldFixtures.request;
   }
   get testInfo() {
     return this.options.testInfo;

package/build/bdd-framework/snippets/index.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Snippets = void 0;
+var _url = require("url");
 var _loadSnippetBuilder = require("../cucumber/loadSnippetBuilder");
 var _logger = require("../utils/logger");
 var _stepConfig = require("../stepDefinitions/stepConfig");
@@ -30,7 +31,6 @@ class Snippets {
     this.printFooter(snippets);
     // exit();
   }
-
   async createSnippetBuilder() {
     const {
       snippetInterface
@@ -44,7 +44,8 @@ class Snippets {
     } = this.runConfiguration.formats.options;
     if (!snippetSyntax && this.isPlaywrightStyle()) {
       this.bddBuiltInSyntax = true;
-      return this.isDecorators() ? require.resolve('./snippetSyntaxDecorators.js') : this.isTypeScript() ? require.resolve('./snippetSyntaxTs.js') : require.resolve('./snippetSyntax.js');
+      const filePath = this.isDecorators() ? require.resolve('./snippetSyntaxDecorators.js') : this.isTypeScript() ? require.resolve('./snippetSyntaxTs.js') : require.resolve('./snippetSyntax.js');
+      return (0, _url.pathToFileURL)(filePath).toString();
     } else {
       return snippetSyntax;
     }

package/build/bdd-framework/snippets/snippetSyntax.js

@@ -27,7 +27,9 @@ class _default {
     });
     const allParameterNames = ['{}', ...expressionParameters, ...stepParameters];
     const functionSignature = `${functionName}('${this.escapeSpecialCharacters(generatedExpression)}', async (${allParameterNames.join(', ')}) => {`;
-    return [functionSignature, `  // ...`, '});'].join('\n');
+    return [functionSignature,
+    // prettier-ignore
+    `  // ...`, '});'].join('\n');
   }
   escapeSpecialCharacters(generatedExpression) {
     let source = generatedExpression.source;

package/build/bdd-framework/stepDefinitions/createBdd.js

@@ -4,27 +4,42 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createBdd = createBdd;
-exports.extractFixtureNames = extractFixtureNames;
-var _fixtureParameterNames = require("../playwright/fixtureParameterNames");
+exports.hasCustomTest = void 0;
 var _bddFixtures = require("../run/bddFixtures");
 var _testTypeImpl = require("../playwright/testTypeImpl");
 var _defineStep = require("./defineStep");
 var _exit = require("../utils/exit");
+var _scenario = require("../hooks/scenario");
+var _worker = require("../hooks/worker");
 /**
  * Stuff related to writing steps in Playwright-style.
  */
 
+// Global flag showing that custom test was passed.
+// Used when checking 'importTestFrom' config option.
+// todo: https://github.com/vitalets/playwright-bdd/issues/46
+let hasCustomTest = exports.hasCustomTest = false;
 function createBdd(customTest) {
-  const hasCustomTest = isCustomTest(customTest);
+  if (!hasCustomTest) {
+    exports.hasCustomTest = hasCustomTest = isCustomTest(customTest);
+  }
   const Given = defineStepCtor('Given', hasCustomTest);
   const When = defineStepCtor('When', hasCustomTest);
   const Then = defineStepCtor('Then', hasCustomTest);
   const Step = defineStepCtor('Unknown', hasCustomTest);
+  const Before = (0, _scenario.scenarioHookFactory)('before');
+  const After = (0, _scenario.scenarioHookFactory)('after');
+  const BeforeAll = (0, _worker.workerHookFactory)('beforeAll');
+  const AfterAll = (0, _worker.workerHookFactory)('afterAll');
   return {
     Given,
     When,
     Then,
-    Step
+    Step,
+    Before,
+    After,
+    BeforeAll,
+    AfterAll
   };
 }
 function defineStepCtor(keyword, hasCustomTest) {
@@ -37,13 +52,15 @@ function defineStepCtor(keyword, hasCustomTest) {
     });
   };
 }
-function extractFixtureNames(fn) {
-  return (0, _fixtureParameterNames.fixtureParameterNames)(fn).filter(name => !(0, _bddFixtures.isBddAutoInjectFixture)(name));
-}
 function isCustomTest(customTest) {
-  const isCustomTest = Boolean(customTest && customTest !== _bddFixtures.test);
-  if (isCustomTest && customTest && !(0, _testTypeImpl.isParentChildTest)(_bddFixtures.test, customTest)) {
-    (0, _exit.exit)(`createBdd() should use test extended from "@zohodesk/testinglibrary"`);
+  if (!customTest || customTest === _bddFixtures.test) {
+    return false;
+  }
+  assertTestHasBddFixtures(customTest);
+  return true;
+}
+function assertTestHasBddFixtures(customTest) {
+  if (!(0, _testTypeImpl.isTestContainsSubtest)(customTest, _bddFixtures.test)) {
+    (0, _exit.exit)(`createBdd() should use 'test' extended from "playwright-bdd"`);
   }
-  return isCustomTest;
 }

package/build/bdd-framework/stepDefinitions/decorators/{poms.js → class.js}

@@ -8,7 +8,7 @@ exports.getPomNodeByFixtureName = getPomNodeByFixtureName;
 var _steps = require("./steps");
 var _exit = require("../../utils/exit");
 /**
- * POM classes marked with @Fixture
+ * Class level @Fixture decorator.
  */
 
 /**
@@ -51,7 +51,9 @@ function ensureUniqueFixtureName({
 }
 function linkParentWithPomNode(Ctor, pomNode) {
   const parentCtor = Object.getPrototypeOf(Ctor);
-  if (!parentCtor) return;
+  if (!parentCtor) {
+    return;
+  }
   // if parentCtor is not in pomGraph, add it.
   // Case: parent class is not marked with @Fixture, but has decorator steps (base class)
   const parentPomNode = pomGraph.get(parentCtor) || createPomNode(parentCtor, '');
@@ -59,6 +61,8 @@ function linkParentWithPomNode(Ctor, pomNode) {
 }
 function getPomNodeByFixtureName(fixtureName) {
   for (const pomNode of pomGraph.values()) {
-    if (pomNode.fixtureName === fixtureName) return pomNode;
+    if (pomNode.fixtureName === fixtureName) {
+      return pomNode;
+    }
   }
 }

package/build/bdd-framework/stepDefinitions/decorators/steps.js

@@ -36,11 +36,15 @@ function createStepDecorator(keyword) {
   };
 }
 function linkStepsWithPomNode(Ctor, pomNode) {
-  if (!(Ctor !== null && Ctor !== void 0 && Ctor.prototype)) return;
+  if (!(Ctor !== null && Ctor !== void 0 && Ctor.prototype)) {
+    return;
+  }
   const propertyDescriptors = Object.getOwnPropertyDescriptors(Ctor.prototype);
   return Object.values(propertyDescriptors).forEach(descriptor => {
     const stepConfig = getStepConfigFromMethod(descriptor);
-    if (!stepConfig) return;
+    if (!stepConfig) {
+      return;
+    }
     stepConfig.pomNode = pomNode;
     decoratedSteps.add(stepConfig);
   });
@@ -65,7 +69,9 @@ function appendDecoratorSteps(supportCodeLibrary) {
       pattern,
       code,
       line: 0,
+      // not used in playwright-bdd
       options: {},
+      // not used in playwright-bdd
       uri: '' // not used in playwright-bdd
     }, supportCodeLibrary);
     supportCodeLibrary.stepDefinitions.push(stepDefinition);
@@ -73,7 +79,6 @@ function appendDecoratorSteps(supportCodeLibrary) {
   decoratedSteps.clear();
   // todo: fill supportCodeLibrary.originalCoordinates as it is used in snippets?
 }
-
 function getFirstNonAutoInjectFixture(fixturesArg, stepConfig) {
   // there should be exatcly one suitable fixture in fixturesArg
   const fixtureNames = Object.keys(fixturesArg).filter(fixtureName => !(0, _bddFixtures.isBddAutoInjectFixture)(fixtureName));

package/build/bdd-framework/stepDefinitions/defineStep.js

@@ -34,7 +34,8 @@ function defineStep(stepConfig) {
 }
 function buildCucumberStepCode(stepConfig) {
   const code = function (...args) {
-    const fixturesArg = Object.assign({}, this.customFixtures, {
+    // build the first argument (fixtures) for step fn
+    const fixturesArg = Object.assign({}, this.stepFixtures, {
       $testInfo: this.testInfo,
       $test: this.test,
       $tags: this.tags

package/build/bdd-framework/utils/exit.js

@@ -5,17 +5,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.exit = exit;
 exports.withExitHandler = withExitHandler;
-var _logger = require("./logger");
 var _worker_threads = require("worker_threads");
 /**
  * Exit utils.
  *
- * When calling process.exit() in worker thread used for file generation,
+ * When calling process.exit() in worker thread used for test-file generation,
  * logs are not flushed (https://github.com/vitalets/playwright-bdd/issues/59).
  * That's why instead of process.exit we throw ExitError
  * that just sets process.exitCode = 1 and allow program to exit normally.
+ * This esnured by wrapping code with withExitHandler().
  *
- * On the other hand, when running in main thread, especially inside Playwright,
+ * On the other hand, when running in the main thread, especially inside Playwright,
  * thrown error is captured by Playwright and show with additional messages (e.g. no tests found).
  * That's why in main thread we to call process.exit() to show only needed error.
  *
@@ -35,6 +35,10 @@ async function withExitHandler(fn) {
     return await fn();
   } catch (e) {
     if (e instanceof ExitError) {
+      if (e.message) {
+        // eslint-disable-next-line no-console
+        console.error(e.message);
+      }
       process.exitCode = 1;
     } else {
       throw e;
@@ -45,7 +49,7 @@ function exit(...messages) {
   messages = messages.filter(Boolean);
   if (_worker_threads.isMainThread) {
     if (messages.length) {
-      _logger.logger.error('Error:', ...messages);
+      logger.error('Error:', ...messages);
     }
     process.exit(1);
   } else {