@zohodesk/testinglibrary 0.0.4 → 0.0.5-exp.10

package/build/bdd-framework/gen/testFile.js

@@ -0,0 +1,356 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestFile = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _formatter = require("./formatter");
+var _i18n = require("./i18n");
+var _loadSteps = require("../cucumber/loadSteps");
+var _createBdd = require("../stepDefinitions/createBdd");
+var _index = require("@cucumber/cucumber/lib/formatter/helpers/index");
+var _utils = require("../utils");
+var _defineStep = require("../stepDefinitions/defineStep");
+var _poms = require("./poms");
+var _testNode = require("./testNode");
+/**
+ * Generate test code.
+ */
+
+/* eslint-disable max-lines, max-params */
+
+class TestFile {
+  lines = [];
+  i18nKeywordsMap;
+  formatter;
+  testNodes = [];
+  hasCustomTest = false;
+  undefinedSteps = [];
+  constructor(options) {
+    this.options = options;
+    this.formatter = new _formatter.Formatter(options.config);
+  }
+  get sourceFile() {
+    const {
+      uri
+    } = this.options.doc;
+    if (!uri) throw new Error(`Document without uri`);
+    return uri;
+  }
+  get content() {
+    return this.lines.join('\n');
+  }
+  get language() {
+    var _this$options$doc$fea;
+    return ((_this$options$doc$fea = this.options.doc.feature) === null || _this$options$doc$fea === void 0 ? void 0 : _this$options$doc$fea.language) || 'en';
+  }
+  get config() {
+    return this.options.config;
+  }
+  get outputPath() {
+    return this.options.outputPath;
+  }
+  build() {
+    this.loadI18nKeywords();
+    this.lines = [...this.getFileHeader(),
+    // prettier-ignore
+    ...this.getRootSuite(), ...this.getFileFixtures()];
+    return this;
+  }
+  save() {
+    const dir = _path.default.dirname(this.outputPath);
+    if (!_fs.default.existsSync(dir)) _fs.default.mkdirSync(dir, {
+      recursive: true
+    });
+    _fs.default.writeFileSync(this.outputPath, this.content);
+  }
+  getFileHeader() {
+    const importTestFrom = this.getRelativeImportTestFrom();
+    return this.formatter.fileHeader(this.sourceFile, importTestFrom);
+  }
+  loadI18nKeywords() {
+    if (this.language !== 'en') {
+      this.i18nKeywordsMap = (0, _i18n.getKeywordsMap)(this.language);
+    }
+  }
+  getRelativeImportTestFrom() {
+    const {
+      importTestFrom
+    } = this.config;
+    if (!importTestFrom) return;
+    const {
+      file,
+      varName
+    } = importTestFrom;
+    const dir = _path.default.dirname(this.outputPath);
+    return {
+      file: _path.default.relative(dir, file),
+      varName
+    };
+  }
+  getFileFixtures() {
+    return this.formatter.useFixtures([...this.formatter.testFixture(), ...this.formatter.tagsFixture(this.testNodes)]);
+  }
+  getRootSuite() {
+    const {
+      feature
+    } = this.options.doc;
+    if (!feature) throw new Error(`Document without feature.`);
+    return this.getSuite(feature);
+  }
+
+  /**
+   * Generate test.describe suite for root Feature or Rule
+   */
+  getSuite(feature, parent) {
+    const node = new _testNode.TestNode(feature, parent);
+    const lines = [];
+    feature.children.forEach(child => lines.push(...this.getSuiteChild(child, node)));
+    return this.formatter.suite(node, lines);
+  }
+  getSuiteChild(child, parent) {
+    if ('rule' in child && child.rule) return this.getSuite(child.rule, parent);
+    if (child.background) return this.getBeforeEach(child.background);
+    if (child.scenario) return this.getScenarioLines(child.scenario, parent);
+    throw new Error(`Empty child: ${JSON.stringify(child)}`);
+  }
+  getScenarioLines(scenario, parent) {
+    return isOutline(scenario) ? this.getOutlineSuite(scenario, parent) : this.getTest(scenario, parent);
+  }
+
+  /**
+   * Generate test.beforeEach for Background
+   */
+  getBeforeEach(bg) {
+    const {
+      fixtures,
+      lines
+    } = this.getSteps(bg);
+    return this.formatter.beforeEach(fixtures, lines);
+  }
+
+  /**
+   * Generate test.describe suite for Scenario Outline
+   */
+  getOutlineSuite(scenario, parent) {
+    const node = new _testNode.TestNode(scenario, parent);
+    const lines = [];
+    let exampleIndex = 0;
+    scenario.examples.forEach(examples => {
+      const titleFormat = this.getExamplesTitleFormat(examples);
+      examples.tableBody.forEach(exampleRow => {
+        const testTitle = this.getOutlineTestTitle(titleFormat, examples, exampleRow, ++exampleIndex);
+        const testLines = this.getOutlineTest(scenario, examples, exampleRow, testTitle, node);
+        lines.push(...testLines);
+      });
+    });
+    return this.formatter.suite(node, lines);
+  }
+
+  /**
+   * Generate test from Examples row of Scenario Outline
+   */
+  // eslint-disable-next-line max-params
+  getOutlineTest(scenario, examples, exampleRow, title, parent) {
+    const node = new _testNode.TestNode({
+      name: title,
+      tags: examples.tags
+    }, parent);
+    if (this.skipByTagsExpression(node)) return [];
+    this.testNodes.push(node);
+    const {
+      fixtures,
+      lines
+    } = this.getSteps(scenario, node.ownTags, exampleRow.id);
+    return this.formatter.test(node, fixtures, lines);
+  }
+
+  /**
+   * Generate test from Scenario
+   */
+  getTest(scenario, parent) {
+    const node = new _testNode.TestNode(scenario, parent);
+    if (this.skipByTagsExpression(node)) return [];
+    this.testNodes.push(node);
+    const {
+      fixtures,
+      lines
+    } = this.getSteps(scenario, node.ownTags);
+    return this.formatter.test(node, fixtures, lines);
+  }
+
+  /**
+   * Generate test steps
+   */
+  getSteps(scenario, ownTestTags, outlineExampleRowId) {
+    const testFixtureNames = new Set();
+    const usedPoms = new _poms.POMS();
+    const decoratorSteps = [];
+    let previousKeywordType = undefined;
+    const lines = scenario.steps.map((step, index) => {
+      const {
+        keyword,
+        keywordType,
+        fixtureNames: stepFixtureNames,
+        line,
+        pickleStep,
+        stepConfig
+      } = this.getStep(step, previousKeywordType, outlineExampleRowId);
+      previousKeywordType = keywordType;
+      testFixtureNames.add(keyword);
+      stepFixtureNames.forEach(fixtureName => testFixtureNames.add(fixtureName));
+      if (!line && stepConfig !== null && stepConfig !== void 0 && stepConfig.pomNode) {
+        usedPoms.add(stepConfig.pomNode);
+        decoratorSteps.push({
+          index,
+          keyword,
+          pickleStep,
+          pomNode: stepConfig.pomNode
+        });
+      }
+      return line;
+    });
+    if (decoratorSteps.length) {
+      testFixtureNames.forEach(fixtureName => usedPoms.addByFixtureName(fixtureName));
+      ownTestTags === null || ownTestTags === void 0 || ownTestTags.forEach(tag => usedPoms.addByTag(tag));
+      decoratorSteps.forEach(step => {
+        const {
+          line,
+          fixtureNames
+        } = this.getDecoratorStep(step, usedPoms);
+        lines[step.index] = line;
+        fixtureNames.forEach(fixtureName => testFixtureNames.add(fixtureName));
+      });
+    }
+    return {
+      fixtures: testFixtureNames,
+      lines
+    };
+  }
+
+  /**
+   * Generate step for Given, When, Then
+   */
+  // eslint-disable-next-line max-statements, complexity
+  getStep(step, previousKeywordType, outlineExampleRowId) {
+    const pickleStep = this.getPickleStep(step, outlineExampleRowId);
+    const stepDefinition = (0, _loadSteps.findStepDefinition)(this.options.supportCodeLibrary, pickleStep.text, this.sourceFile);
+    const keywordType = (0, _index.getStepKeywordType)({
+      keyword: step.keyword,
+      language: this.language,
+      previousKeywordType
+    });
+    let keyword = this.getStepKeyword(step);
+    if (!stepDefinition) {
+      this.undefinedSteps.push({
+        keywordType,
+        step,
+        pickleStep
+      });
+      return this.getMissingStep(keyword, keywordType, pickleStep);
+    }
+    // for cucumber-style stepConfig is undefined
+    const stepConfig = (0, _defineStep.getStepConfig)(stepDefinition);
+    if (stepConfig !== null && stepConfig !== void 0 && stepConfig.hasCustomTest) this.hasCustomTest = true;
+    // for cucumber-style transform Given/When/Then -> Given_/When_/Then_
+    // to use fixtures with own bddWorld (containing fixtures)
+    if (!(0, _defineStep.isPlaywrightStyle)(stepDefinition)) keyword = `${keyword}_`;
+    // for decorator steps fixtures defined later in second pass
+    const fixtureNames = stepConfig !== null && stepConfig !== void 0 && stepConfig.isDecorator ? [] : (0, _createBdd.extractFixtureNames)(stepConfig === null || stepConfig === void 0 ? void 0 : stepConfig.fn);
+    const line = stepConfig !== null && stepConfig !== void 0 && stepConfig.isDecorator ? '' : this.formatter.step(keyword, pickleStep.text, pickleStep.argument, fixtureNames);
+    return {
+      keyword,
+      keywordType,
+      fixtureNames,
+      line,
+      pickleStep,
+      stepConfig
+    };
+  }
+  getMissingStep(keyword, keywordType, pickleStep) {
+    return {
+      keyword,
+      keywordType,
+      fixtureNames: [],
+      line: this.formatter.missingStep(keyword, pickleStep.text),
+      pickleStep,
+      stepConfig: undefined
+    };
+  }
+  getPickleStep(step, outlineExampleRowId) {
+    for (const pickle of this.options.pickles) {
+      const pickleStep = pickle.steps.find(({
+        astNodeIds
+      }) => {
+        const hasStepId = astNodeIds.includes(step.id);
+        const hasRowId = !outlineExampleRowId || astNodeIds.includes(outlineExampleRowId);
+        return hasStepId && hasRowId;
+      });
+      if (pickleStep) return pickleStep;
+    }
+    throw new Error(`Pickle step not found for step: ${step.text}`);
+  }
+  getStepKeyword(step) {
+    const origKeyword = step.keyword.trim();
+    let enKeyword;
+    if (origKeyword === '*') {
+      enKeyword = 'And';
+    } else {
+      enKeyword = this.i18nKeywordsMap ? this.i18nKeywordsMap.get(origKeyword) : origKeyword;
+    }
+    if (!enKeyword) throw new Error(`Keyword not found: ${origKeyword}`);
+    return enKeyword;
+  }
+  getDecoratorStep(step, usedPoms) {
+    const {
+      keyword,
+      pickleStep,
+      pomNode
+    } = step;
+    const fixtureNames = usedPoms.resolveFixtureNames(pomNode);
+    if (fixtureNames.length !== 1) {
+      const suggestedTags = fixtureNames.map(name => (0, _poms.buildFixtureTag)(name)).join(', ');
+      (0, _utils.exitWithMessage)(`Can't guess fixture for decorator step "${pickleStep.text}" in file: ${this.sourceFile}.`, `Please set one of the following tags (${suggestedTags}) or refactor your Page Object classes.`);
+    }
+    return {
+      fixtureNames,
+      line: this.formatter.step(keyword, pickleStep.text, pickleStep.argument, [fixtureNames[0]])
+    };
+  }
+  getOutlineTestTitle(titleFormat, examples, exampleRow, exampleIndex) {
+    const params = {
+      _index_: exampleIndex
+    };
+    exampleRow.cells.forEach((cell, index) => {
+      var _examples$tableHeader;
+      const colName = (_examples$tableHeader = examples.tableHeader) === null || _examples$tableHeader === void 0 || (_examples$tableHeader = _examples$tableHeader.cells[index]) === null || _examples$tableHeader === void 0 ? void 0 : _examples$tableHeader.value;
+      if (colName) params[colName] = cell.value;
+    });
+    return (0, _utils.template)(titleFormat, params);
+  }
+  getExamplesTitleFormat(examples) {
+    var _comment$text;
+    const {
+      line
+    } = examples.location;
+    const titleFormatCommentLine = line - 1;
+    const comment = this.options.doc.comments.find(c => {
+      return c.location.line === titleFormatCommentLine;
+    });
+    const commentText = comment === null || comment === void 0 || (_comment$text = comment.text) === null || _comment$text === void 0 ? void 0 : _comment$text.trim();
+    const prefix = '# title-format:';
+    return commentText !== null && commentText !== void 0 && commentText.startsWith(prefix) ? commentText.replace(prefix, '').trim() : this.config.examplesTitleFormat;
+  }
+  skipByTagsExpression(node) {
+    var _this$options$tagsExp;
+    // see: https://github.com/cucumber/tag-expressions/tree/main/javascript
+    return ((_this$options$tagsExp = this.options.tagsExpression) === null || _this$options$tagsExp === void 0 ? void 0 : _this$options$tagsExp.evaluate(node.tags)) === false;
+  }
+}
+exports.TestFile = TestFile;
+function isOutline(scenario) {
+  return scenario.keyword === 'Scenario Outline' || scenario.keyword === 'Scenario Template';
+}

package/build/bdd-framework/gen/testNode.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestNode = void 0;
+var _utils = require("../utils");
+/**
+ * Universal TestNode class with accumulated data (tags, titiles)
+ * of parent-child relations in test file structure.
+ */
+
+const SPECIAL_TAGS = ['@only', '@skip', '@fixme'];
+class TestNode {
+  title;
+  titlePath;
+  ownTags = [];
+  tags = [];
+  flags = {};
+  constructor(origItem, parent) {
+    this.origItem = origItem;
+    this.parent = parent;
+    this.initOwnTags(origItem);
+    this.tags = (0, _utils.removeDuplicates)(((parent === null || parent === void 0 ? void 0 : parent.tags) || []).concat(this.ownTags));
+    this.title = origItem.name;
+    this.titlePath = ((parent === null || parent === void 0 ? void 0 : parent.titlePath) || []).concat([this.title]);
+  }
+  initOwnTags(origItem) {
+    const tagNames = (0, _utils.removeDuplicates)(getTagNames(origItem.tags));
+    tagNames.forEach(tag => {
+      if (isSpecialTag(tag)) {
+        this.setFlag(tag);
+      } else {
+        this.ownTags.push(tag);
+      }
+    });
+  }
+  setFlag(tag) {
+    if (tag === '@only') this.flags.only = true;
+    if (tag === '@skip') this.flags.skip = true;
+    if (tag === '@fixme') this.flags.fixme = true;
+  }
+}
+exports.TestNode = TestNode;
+function getTagNames(tags) {
+  return tags.map(tag => tag.name);
+}
+function isSpecialTag(tag) {
+  return SPECIAL_TAGS.includes(tag);
+}

package/build/bdd-framework/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BddWorld", {
+  enumerable: true,
+  get: function () {
+    return _bddWorld.BddWorld;
+  }
+});
+Object.defineProperty(exports, "createBdd", {
+  enumerable: true,
+  get: function () {
+    return _createBdd.createBdd;
+  }
+});
+Object.defineProperty(exports, "defineBddConfig", {
+  enumerable: true,
+  get: function () {
+    return _config.defineBddConfig;
+  }
+});
+Object.defineProperty(exports, "test", {
+  enumerable: true,
+  get: function () {
+    return _bddFixtures.test;
+  }
+});
+var _config = require("./config");
+var _createBdd = require("./stepDefinitions/createBdd");
+var _bddFixtures = require("./run/bddFixtures");
+var _bddWorld = require("./run/bddWorld");

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

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fixtureParameterNames = fixtureParameterNames;
+/**
+ * Extracted from playwright.
+ * https://github.com/microsoft/playwright/blob/main/packages/playwright-test/src/common/fixtures.ts#L226
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/ban-types */
+/* eslint-disable max-statements, complexity, max-len, max-depth */
+
+const signatureSymbol = Symbol('signature');
+function fixtureParameterNames(fn) {
+  if (typeof fn !== 'function') {
+    return [];
+  }
+  ;
+  if (!fn[signatureSymbol]) {
+    fn[signatureSymbol] = innerFixtureParameterNames(fn);
+  }
+  return fn[signatureSymbol];
+}
+function innerFixtureParameterNames(fn) {
+  const text = filterOutComments(fn.toString());
+  const match = text.match(/(?:async)?(?:\s+function)?[^(]*\(([^)]*)/);
+  if (!match) {
+    return [];
+  }
+  ;
+  const trimmedParams = match[1].trim();
+  if (!trimmedParams) {
+    return [];
+  }
+  ;
+  const [firstParam] = splitByComma(trimmedParams);
+  if (firstParam[0] !== '{' || firstParam[firstParam.length - 1] !== '}') {
+    throw new Error('First argument must use the object destructuring pattern: ' + firstParam + ' ' + fn.toString());
+  }
+  const props = splitByComma(firstParam.substring(1, firstParam.length - 1)).map(prop => {
+    const colon = prop.indexOf(':');
+    return colon === -1 ? prop.trim() : prop.substring(0, colon).trim();
+  });
+  const restProperty = props.find(prop => prop.startsWith('...'));
+  if (restProperty) {
+    throw new Error(`Rest property "${restProperty}" is not supported. List all used fixtures explicitly, separated by comma. ${fn.toString()}`);
+  }
+  return props;
+}
+function filterOutComments(s) {
+  const result = [];
+  let commentState = 'none';
+  for (let i = 0; i < s.length; ++i) {
+    if (commentState === 'singleline') {
+      if (s[i] === '\n') {
+        commentState = 'none';
+      }
+      ;
+    } else if (commentState === 'multiline') {
+      if (s[i - 1] === '*' && s[i] === '/') {
+        commentState = 'none';
+      }
+      ;
+    } else if (commentState === 'none') {
+      if (s[i] === '/' && s[i + 1] === '/') {
+        commentState = 'singleline';
+      } else if (s[i] === '/' && s[i + 1] === '*') {
+        commentState = 'multiline';
+        i += 2;
+      } else {
+        result.push(s[i]);
+      }
+    }
+  }
+  return result.join('');
+}
+function splitByComma(s) {
+  const result = [];
+  const stack = [];
+  let start = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === '{' || s[i] === '[') {
+      stack.push(s[i] === '{' ? '}' : ']');
+    } else if (s[i] === stack[stack.length - 1]) {
+      stack.pop();
+    } else if (!stack.length && s[i] === ',') {
+      const token = s.substring(start, i).trim();
+      if (token) {
+        result.push(token);
+      }
+      ;
+      start = i + 1;
+    }
+  }
+  const lastToken = s.substring(start).trim();
+  if (lastToken) {
+    result.push(lastToken);
+  }
+  ;
+  return result;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLocationInFile = getLocationInFile;
+var _url = _interopRequireDefault(require("url"));
+var _utils = require("./utils");
+/**
+ * Inspects stacktrace and finds call location in provided file.
+ * This function is based on Playwright's getLocationByStacktrace().
+ * See: https://github.com/microsoft/playwright/blob/main/packages/playwright-test/src/common/transform.ts#L229
+ */
+function getLocationInFile(filePath) {
+  const {
+    sourceMapSupport
+  } = (0, _utils.requirePlaywrightModule)('lib/utilsBundle.js');
+  const oldPrepareStackTrace = Error.prepareStackTrace;
+  Error.prepareStackTrace = (error, stackFrames) => {
+    const frameInFile = stackFrames.find(frame => frame.getFileName() === filePath);
+    if (!frameInFile) {
+      return {
+        file: '',
+        line: 0,
+        column: 0
+      };
+    }
+    ;
+    const frame = sourceMapSupport.wrapCallSite(frameInFile);
+    const fileName = frame.getFileName();
+    // Node error stacks for modules use file:// urls instead of paths.
+    const file = fileName && fileName.startsWith('file://') ? _url.default.fileURLToPath(fileName) : fileName;
+    return {
+      file,
+      line: frame.getLineNumber(),
+      column: frame.getColumnNumber()
+    };
+  };
+  // commented stackTraceLImit modification, todo: check if it has perf impact
+  // const oldStackTraceLimit = Error.stackTraceLimit;
+  // Error.stackTraceLimit = level + 1;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const obj = {};
+  Error.captureStackTrace(obj);
+  const location = obj.stack;
+  // Error.stackTraceLimit = oldStackTraceLimit;
+  Error.prepareStackTrace = oldPrepareStackTrace;
+  return location;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadConfig = loadConfig;
+exports.resolveConfigFile = resolveConfigFile;
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+var _utils = require("./utils");
+var _transform = require("./transform");
+var _utils2 = require("../utils");
+/**
+ * Loading Playwright config.
+ * See: https://github.com/microsoft/playwright/blob/main/packages/playwright-test/src/common/configLoader.ts
+ */
+
+async function loadConfig(cliConfigPath) {
+  const resolvedConfigFile = resolveConfigFile(cliConfigPath);
+  assertConfigFileExists(resolvedConfigFile, cliConfigPath);
+  await (0, _transform.requireTransform)().requireOrImport(resolvedConfigFile);
+  return {
+    resolvedConfigFile
+  };
+}
+function resolveConfigFile(cliConfigPath) {
+  const {
+    resolveConfigFile
+  } = (0, _utils.requirePlaywrightModule)('lib/common/configLoader.js');
+  const configFileOrDirectory = getConfigFilePath(cliConfigPath);
+  return resolveConfigFile(configFileOrDirectory) || '';
+}
+function getConfigFilePath(cliConfigPath) {
+  return cliConfigPath ? _path.default.resolve(process.cwd(), cliConfigPath) : process.cwd();
+}
+function assertConfigFileExists(resolvedConfigFile, cliConfigPath) {
+  if (!resolvedConfigFile || !_fs.default.existsSync(resolvedConfigFile)) {
+    const configFilePath = getConfigFilePath(cliConfigPath);
+    (0, _utils2.exitWithMessage)(`Can't find Playwright config file in: ${configFilePath}`);
+  }
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTestImpl = getTestImpl;
+exports.isParentChildTest = isParentChildTest;
+var _test = require("@playwright/test");
+var _utils = require("../utils");
+/**
+ * Helpers to deal with Playwright test internal stuff.
+ * See: https://github.com/microsoft/playwright/blob/main/packages/playwright-test/src/common/testType.ts
+ */
+
+const testTypeSymbol = (0, _utils.getSymbolByName)(_test.test, 'testType');
+
+/**
+ * Returns test fixtures using Symbol.
+ */
+function getTestFixtures(test) {
+  return getTestImpl(test).fixtures;
+}
+function getTestImpl(test) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return test[testTypeSymbol];
+}
+
+/**
+ * Returns true if all fixtures of parent test found in child test.
+ */
+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 locationToString({
+  file,
+  line,
+  column
+}) {
+  return `${file}:${line}:${column}`;
+}