@zohodesk/testinglibrary 0.1.8-stb-bdd-v26 → 0.1.9

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

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BddData = void 0;
+exports.getBddDataFromTestResult = getBddDataFromTestResult;
+exports.isBddDataAttachment = isBddDataAttachment;
+var _createTestStep = require("../cucumber/createTestStep");
+var _utils = require("../utils");
+const BDD_DATA_ATTACHMENT_NAME = '__bddData';
+class BddData {
+  world;
+  steps = [];
+  constructor(world) {
+    this.world = world;
+  }
+  registerStep(stepDefinition, stepText, pwStepLocation) {
+    const step = (0, _createTestStep.createTestStep)(stepDefinition, stepText);
+    this.steps.push({
+      pwStepLocation: (0, _utils.stringifyLocation)(pwStepLocation),
+      stepMatchArgumentsLists: step.stepMatchArgumentsLists || []
+    });
+  }
+  async attach(testMeta, uri) {
+    const attachment = {
+      uri,
+      pickleLocation: testMeta.pickleLocation,
+      steps: this.steps
+    };
+    await this.world.testInfo.attach(BDD_DATA_ATTACHMENT_NAME, {
+      contentType: 'application/json',
+      body: JSON.stringify(attachment)
+    });
+  }
+}
+exports.BddData = BddData;
+function getBddDataFromTestResult(result) {
+  var _attachment$body;
+  const attachment = result.attachments.find(isBddDataAttachment);
+  const attachmentBody = attachment === null || attachment === void 0 || (_attachment$body = attachment.body) === null || _attachment$body === void 0 ? void 0 : _attachment$body.toString();
+  return attachmentBody ? JSON.parse(attachmentBody) : undefined;
+}
+function isBddDataAttachment(attachment) {
+  return attachment.name === BDD_DATA_ATTACHMENT_NAME;
+}

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

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isBddAutoInjectFixture = isBddAutoInjectFixture;
+exports.test = void 0;
+var _test = require("@playwright/test");
+var _loadConfig = require("../cucumber/loadConfig");
+var _loadSteps = require("../cucumber/loadSteps");
+var _bddWorld = require("./bddWorld");
+var _config = require("../config");
+var _env = require("../config/env");
+var _steps = require("../stepDefinitions/decorators/steps");
+var _configDir = require("../config/configDir");
+var _scenario = require("../hooks/scenario");
+var _worker = require("../hooks/worker");
+var _StepInvoker = require("./StepInvoker");
+var _testMeta = require("../gen/testMeta");
+var _logger = require("../utils/logger");
+var _enrichReporterData = require("../config/enrichReporterData");
+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, _configDir.getPlaywrightConfigDir)()
+    };
+    const {
+      runConfiguration
+    } = await (0, _loadConfig.loadConfig)({
+      provided: (0, _config.extractCucumberConfig)(config)
+    }, environment);
+    const supportCodeLibrary = await (0, _loadSteps.loadSteps)(runConfiguration, environment);
+    (0, _steps.appendDecoratorSteps)(supportCodeLibrary);
+    const World = (0, _bddWorld.getWorldConstructor)(supportCodeLibrary);
+    await use({
+      runConfiguration,
+      supportCodeLibrary,
+      World,
+      config
+    });
+  }, {
+    auto: true,
+    scope: 'worker'
+  }],
+  // $lang fixture can be overwritten in test file
+  $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,
+    $testMeta,
+    $uri
+  }, use, testInfo) => {
+    const {
+      runConfiguration,
+      supportCodeLibrary,
+      World,
+      config
+    } = $cucumber;
+    const world = new World({
+      testInfo,
+      supportCodeLibrary,
+      $tags,
+      $test,
+      $bddWorldFixtures,
+      lang: $lang,
+      parameters: runConfiguration.runtime.worldParameters || {},
+      log: () => _logger.logger.warn(`world.log() is noop, please use world.testInfo.attach()`),
+      attach: async () => _logger.logger.warn(`world.attach() is noop, please use world.testInfo.attach()`)
+    });
+    await world.init();
+    await use(world);
+    await world.destroy();
+    if ((0, _enrichReporterData.getEnrichReporterData)(config)) {
+      await world.$internal.bddData.attach($testMeta, $uri);
+    }
+  },
+  Given: ({
+    $bddWorld
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'Given').invoke),
+  When: ({
+    $bddWorld
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'When').invoke),
+  Then: ({
+    $bddWorld
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'Then').invoke),
+  And: ({
+    $bddWorld
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'And').invoke),
+  But: ({
+    $bddWorld
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'But').invoke),
+  // init $testMetaMap with empty object, will be overwritten in each test file
+  $testMetaMap: ({}, use) => use({}),
+  // concrete test meta
+  $testMeta: ({
+    $testMetaMap
+  }, use, testInfo) => use((0, _testMeta.getTestMeta)($testMetaMap, testInfo)),
+  // concrete test tags
+  $tags: ({
+    $testMeta
+  }, use) => use($testMeta.tags || []),
+  // init $test with base test, but it will be overwritten in test file
+  $test: ({}, use) => use(_test.test),
+  // feature file uri, relative to configDir, will be overwritten in test file
+  $uri: ({}, use) => use(''),
+  // 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'
+  }]
+});
+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

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BddWorld = void 0;
+exports.getWorldConstructor = getWorldConstructor;
+var _cucumber = require("@cucumber/cucumber");
+var _bddWorldInternal = require("./bddWorldInternal");
+class BddWorld extends _cucumber.World {
+  options;
+  // special property to hold internal bdd related methods, must be public.
+  $internal;
+  constructor(options) {
+    super(options);
+    this.options = options;
+    this.$internal = new _bddWorldInternal.BddWorldInternal(this);
+  }
+  /**
+     * 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.$internal.currentStepFixtures[fixtureName];
+  }
+  get page() {
+    return this.options.$bddWorldFixtures.page;
+  }
+  get context() {
+    return this.options.$bddWorldFixtures.context;
+  }
+  get browser() {
+    return this.options.$bddWorldFixtures.browser;
+  }
+  get browserName() {
+    return this.options.$bddWorldFixtures.browserName;
+  }
+  get request() {
+    return this.options.$bddWorldFixtures.request;
+  }
+  get testInfo() {
+    return this.options.testInfo;
+  }
+  get tags() {
+    return this.options.$tags;
+  }
+  get test() {
+    return this.options.$test;
+  }
+  async init() {
+    // async setup before each test
+  }
+  async destroy() {
+    // async teardown after each test
+  }
+}
+exports.BddWorld = BddWorld;
+function getWorldConstructor(supportCodeLibrary) {
+  // setWorldConstructor was not called
+  if (supportCodeLibrary.World === _cucumber.World) {
+    return BddWorld;
+  }
+  if (!Object.prototype.isPrototypeOf.call(BddWorld, supportCodeLibrary.World)) {
+    throw new Error(`CustomWorld should inherit from playwright-bdd World`);
+  }
+  return supportCodeLibrary.World;
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BddWorldInternal = void 0;
+var _bddDataAttachment = require("./bddDataAttachment");
+class BddWorldInternal {
+  currentStepFixtures = {};
+  bddData;
+  constructor(world) {
+    this.bddData = new _bddDataAttachment.BddData(world);
+  }
+}
+exports.BddWorldInternal = BddWorldInternal;

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

@@ -0,0 +1,132 @@
+"use strict";
+
+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");
+/**
+ * Generate and show snippets for undefined steps
+ */
+
+class Snippets {
+  files;
+  runConfiguration;
+  supportCodeLibrary;
+  snippetBuilder;
+  bddBuiltInSyntax = false;
+  constructor(files, runConfiguration, supportCodeLibrary) {
+    this.files = files;
+    this.runConfiguration = runConfiguration;
+    this.supportCodeLibrary = supportCodeLibrary;
+  }
+  async print() {
+    this.snippetBuilder = await this.createSnippetBuilder();
+    const snippets = this.getSnippets();
+    this.printHeader();
+    this.printSnippets(snippets);
+    this.printFooter(snippets);
+    // exit();
+  }
+  async createSnippetBuilder() {
+    const snippetInterface = this.runConfiguration.formats.options.snippetInterface;
+    const snippetSyntax = this.getSnippetSyntax();
+    return (0, _loadSnippetBuilder.loadSnippetBuilder)(this.supportCodeLibrary, snippetInterface, snippetSyntax);
+  }
+  getSnippetSyntax() {
+    const snippetSyntax = this.runConfiguration.formats.options.snippetSyntax;
+    if (!snippetSyntax && this.isPlaywrightStyle()) {
+      this.bddBuiltInSyntax = true;
+      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;
+    }
+  }
+  getSnippets() {
+    const snippetsSet = new Set();
+    const snippets = [];
+    this.files.forEach(file => {
+      file.undefinedSteps.forEach(undefinedStep => {
+        const {
+          snippet,
+          snippetWithLocation
+        } = this.getSnippet(file, snippets.length + 1, undefinedStep);
+        if (!snippetsSet.has(snippet)) {
+          snippetsSet.add(snippet);
+          snippets.push(snippetWithLocation);
+        }
+      });
+    });
+    return snippets;
+  }
+  getSnippet(file, index, undefinedStep) {
+    const snippet = this.snippetBuilder.build({
+      keywordType: undefinedStep.keywordType,
+      pickleStep: undefinedStep.pickleStep
+    });
+    const {
+      line,
+      column
+    } = undefinedStep.step.location;
+    const snippetWithLocation = [`// ${index}. Missing step definition for "${file.featureUri}:${line}:${column}"`, snippet].join('\n');
+    return {
+      snippet,
+      snippetWithLocation
+    };
+  }
+  isTypeScript() {
+    const {
+      requirePaths,
+      importPaths
+    } = this.supportCodeLibrary.originalCoordinates;
+    return requirePaths.some(p => p.endsWith('.ts')) || importPaths.some(p => p.endsWith('.ts'));
+  }
+  isPlaywrightStyle() {
+    const {
+      stepDefinitions
+    } = this.supportCodeLibrary;
+    return stepDefinitions.length > 0 ? stepDefinitions.some(step => (0, _stepConfig.isPlaywrightStyle)((0, _stepConfig.getStepConfig)(step))) : true;
+  }
+  isDecorators() {
+    const {
+      stepDefinitions
+    } = this.supportCodeLibrary;
+    const decoratorSteps = stepDefinitions.filter(step => (0, _stepConfig.isDecorator)((0, _stepConfig.getStepConfig)(step)));
+    return decoratorSteps.length > stepDefinitions.length / 2;
+  }
+  printHeader() {
+    const lines = [`Missing steps found. Use snippets below:`];
+    if (this.bddBuiltInSyntax) {
+      if (this.isDecorators()) {
+        lines.push(`import { Fixture, Given, When, Then } from 'playwright-bdd/decorators';\n`);
+      } else {
+        lines.push(`import { createBdd } from '@zohodesk/testinglibrary';`, `const { Given, When, Then } = createBdd();\n`);
+      }
+    } else {
+      lines.push(`import { Given, When, Then } from '@cucumber/cucumber';\n`);
+    }
+    _logger.logger.error(lines.join('\n\n'));
+  }
+  printSnippets(snippets) {
+    _logger.logger.error(snippets.concat(['']).join('\n\n'));
+  }
+  printFooter(snippets) {
+    _logger.logger.error(`Missing step definitions (${snippets.length}).`, `Use snippets above to create them.`);
+    this.printWarningOnZeroScannedFiles();
+  }
+  printWarningOnZeroScannedFiles() {
+    const {
+      requirePaths,
+      importPaths
+    } = this.supportCodeLibrary.originalCoordinates;
+    const scannedFilesCount = requirePaths.length + importPaths.length;
+    if (scannedFilesCount === 0 && !this.isDecorators()) {
+      _logger.logger.error(`Note that 0 step definition files found, check the config.`);
+    }
+  }
+}
+exports.Snippets = Snippets;

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

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// todo: custom cucumber parameters
+// See: https://github.com/cucumber/cucumber-expressions#custom-parameter-types
+class _default {
+  isTypescript = false;
+  build({
+    generatedExpressions,
+    functionName,
+    stepParameterNames
+  }) {
+    // Always take only first generatedExpression
+    // Other expressions are for int/float combinations
+    const generatedExpression = generatedExpressions[0];
+    const expressionParameters = generatedExpression.parameterNames.map((name, i) => {
+      const argName = `arg${i === 0 ? '' : i}`;
+      const type = name.startsWith('string') ? 'string' : 'number';
+      return this.isTypescript ? `${argName}: ${type}` : argName;
+    });
+    const stepParameters = stepParameterNames.map(argName => {
+      const type = argName === 'dataTable' ? 'DataTable' : 'string';
+      return this.isTypescript ? `${argName}: ${type}` : argName;
+    });
+    const allParameterNames = ['{}', ...expressionParameters, ...stepParameters];
+    const functionSignature = `${functionName}('${this.escapeSpecialCharacters(generatedExpression)}', async (${allParameterNames.join(', ')}) => {`;
+    return [functionSignature,
+    // prettier-ignore
+    `  // ...`, '});'].join('\n');
+  }
+  escapeSpecialCharacters(generatedExpression) {
+    let source = generatedExpression.source;
+    // double up any backslashes because we're in a javascript string
+    source = source.replace(/\\/g, '\\\\');
+    // escape any single quotes because that's our quote delimiter
+    source = source.replace(/'/g, "\\'");
+    return source;
+  }
+}
+exports.default = _default;

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

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class _default {
+  build({
+    generatedExpressions,
+    functionName
+  }) {
+    // Always take only first generatedExpression
+    // Other expressions are for int/float combinations
+    const generatedExpression = generatedExpressions[0];
+    return `@${functionName}('${this.escapeSpecialCharacters(generatedExpression)}')`;
+  }
+  escapeSpecialCharacters(generatedExpression) {
+    let source = generatedExpression.source;
+    // double up any backslashes because we're in a javascript string
+    source = source.replace(/\\/g, '\\\\');
+    // escape any single quotes because that's our quote delimiter
+    source = source.replace(/'/g, "\\'");
+    return source;
+  }
+}
+exports.default = _default;

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

@@ -0,0 +1,18 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _snippetSyntax = _interopRequireDefault(require("./snippetSyntax"));
+/**
+ * Playwright-style snippet syntax for typescript.
+ * Important to use separate file as it's simplest way to distinguish between js/ts
+ * without hooking into cucumber machinery.
+ */
+
+class _default extends _snippetSyntax.default {
+  isTypescript = true;
+}
+exports.default = _default;

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

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBdd = createBdd;
+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) {
+  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,
+    Before,
+    After,
+    BeforeAll,
+    AfterAll
+  };
+}
+function defineStepCtor(keyword, hasCustomTest) {
+  return (pattern, fn) => {
+    (0, _defineStep.defineStep)({
+      keyword,
+      pattern,
+      fn,
+      hasCustomTest
+    });
+  };
+}
+function isCustomTest(customTest) {
+  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"`);
+  }
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Fixture = Fixture;
+exports.getPomNodeByFixtureName = getPomNodeByFixtureName;
+var _steps = require("./steps");
+var _exit = require("../../utils/exit");
+/**
+ * Class level @Fixture decorator.
+ */
+
+/**
+ * Graph of POM class inheritance.
+ * Allows to guess correct fixture by step text.
+ */
+const pomGraph = new Map();
+/**
+ * @Fixture decorator.
+ */
+function Fixture(fixtureName) {
+  // context parameter is required for decorator by TS even though it's not used
+  return Ctor => {
+    createPomNode(Ctor, fixtureName);
+  };
+}
+function createPomNode(Ctor, fixtureName) {
+  const pomNode = {
+    fixtureName,
+    className: Ctor.name,
+    children: new Set()
+  };
+  ensureUniqueFixtureName(pomNode);
+  pomGraph.set(Ctor, pomNode);
+  (0, _steps.linkStepsWithPomNode)(Ctor, pomNode);
+  linkParentWithPomNode(Ctor, pomNode);
+  return pomNode;
+}
+function ensureUniqueFixtureName({
+  fixtureName,
+  className
+}) {
+  if (!fixtureName) {
+    return;
+  }
+  const existingPom = getPomNodeByFixtureName(fixtureName);
+  if (existingPom) {
+    (0, _exit.exit)(`Duplicate fixture name "${fixtureName}"`, `defined for classes: ${existingPom.className}, ${className}`);
+  }
+}
+function linkParentWithPomNode(Ctor, pomNode) {
+  const parentCtor = Object.getPrototypeOf(Ctor);
+  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, '');
+  parentPomNode.children.add(pomNode);
+}
+function getPomNodeByFixtureName(fixtureName) {
+  for (const pomNode of pomGraph.values()) {
+    if (pomNode.fixtureName === fixtureName) {
+      return pomNode;
+    }
+  }
+}