@g_package/jest-cucumber-fusion 1.0.0

package/src/index.js

@@ -0,0 +1,404 @@
+const stepsDefinition = {
+  given: {},
+  when: {},
+  then: {},
+  and: {},
+  but: {},
+  before: null,
+  after: null,
+};
+
+const addDefinitionFunction = (
+  definitionType,
+  regexpSentence,
+  fnForDefinition
+) => {
+  if (stepsDefinition[definitionType]) {
+    if (regexpSentence.constructor === RegExp)
+      stepsDefinition[definitionType][regexpSentence.source] = {
+        stepRegExp: regexpSentence,
+        stepExpression: null,
+        stepFn: fnForDefinition,
+      };
+    else if (typeof regexpSentence === "string")
+      stepsDefinition[definitionType][regexpSentence] = {
+        stepRegExp: null,
+        stepExpression: regexpSentence,
+        stepFn: fnForDefinition,
+      };
+  }
+};
+
+const Given = (regexpSentenceOrChainedObject, fnForDefinition) => {
+  return defineAndChain(
+    "given",
+    regexpSentenceOrChainedObject,
+    fnForDefinition
+  );
+};
+const When = (regexpSentenceOrChainedObject, fnForDefinition) => {
+  return defineAndChain("when", regexpSentenceOrChainedObject, fnForDefinition);
+};
+const Then = (regexpSentenceOrChainedObject, fnForDefinition) => {
+  return defineAndChain("then", regexpSentenceOrChainedObject, fnForDefinition);
+};
+const And = (regexpSentenceOrChainedObject, fnForDefinition) => {
+  return defineAndChain("and", regexpSentenceOrChainedObject, fnForDefinition);
+};
+
+const But = (regexpSentenceOrChainedObject, fnForDefinition) => {
+  return defineAndChain("but", regexpSentenceOrChainedObject, fnForDefinition);
+};
+
+const defineAndChain = (stepType, stepObjectOrSentence, fnForStep) => {
+  if (
+    !fnForStep &&
+    stepObjectOrSentence instanceof Object &&
+    Object.prototype.toString.call(stepObjectOrSentence) !==
+      "[object RegExp]" &&
+    stepObjectOrSentence.stepSentence
+  ) {
+    addDefinitionFunction(
+      stepType,
+      stepObjectOrSentence.stepSentence,
+      stepObjectOrSentence.stepFnDefinition
+    );
+
+    return stepObjectOrSentence;
+  }
+
+  addDefinitionFunction(stepType, stepObjectOrSentence, fnForStep);
+
+  return { stepSentence: stepObjectOrSentence, stepFnDefinition: fnForStep };
+};
+
+const Before = (fnDefinition) => {
+  stepsDefinition.before = fnDefinition;
+};
+const After = (fnDefinition) => {
+  stepsDefinition.after = fnDefinition;
+};
+
+const Fusion = (featureFileToLoad, optionsToPassToJestCucumber) => {
+  const path = require("path");
+  const callerSites = require("callsites");
+  const callerSiteCaller = callerSites.default()[1].getFileName();
+  const dirOfCaller = path.dirname(callerSiteCaller || "");
+  const absoluteFeatureFilePath = path.resolve(dirOfCaller, featureFileToLoad);
+
+  const jestCucumber = require("jest-cucumber");
+  const feature = jestCucumber.loadFeature(
+    absoluteFeatureFilePath,
+    optionsToPassToJestCucumber
+  );
+
+  jestCucumber.defineFeature(feature, (testFn) => {
+    if (feature.scenarios.length > 0)
+      matchJestTestSuiteWithCucumberFeature(
+        feature.scenarios,
+        beforeEach,
+        afterEach,
+        testFn
+      );
+
+    if (feature.scenarioOutlines.length > 0)
+      matchJestTestSuiteWithCucumberFeature(
+        feature.scenarioOutlines,
+        beforeEach,
+        afterEach,
+        testFn,
+        true
+      );
+  });
+};
+
+const matchJestTestSuiteWithCucumberFeature = (
+  featureScenariosOrOutline,
+  beforeEachFn,
+  afterEachFn,
+  testFn,
+  isOutline
+) => {
+  featureScenariosOrOutline.forEach((currentScenarioOrOutline) => {
+    if (stepsDefinition.before) beforeEachFn(stepsDefinition.before);
+
+    matchJestTestWithCucumberScenario(
+      currentScenarioOrOutline.title,
+      currentScenarioOrOutline.steps,
+      testFn,
+      isOutline
+    );
+
+    if (stepsDefinition.after) afterEachFn(stepsDefinition.after);
+  });
+};
+
+const matchJestTestWithCucumberScenario = (
+  currentScenarioTitle,
+  currentScenarioSteps,
+  testFn,
+  isOutline
+) => {
+  testFn(currentScenarioTitle, ({ given, when, then, and, but }) => {
+    currentScenarioSteps.forEach((currentStep) => {
+      matchJestDefinitionWithCucumberStep(
+        { given, when, then, and, but },
+        currentStep,
+        isOutline
+      );
+    });
+  });
+};
+
+const matchJestDefinitionWithCucumberStep = (
+  verbFunction,
+  currentStep,
+  isOutline
+) => {
+  const foundMatchingStep = findMatchingStep(currentStep, isOutline);
+  if (!foundMatchingStep) return;
+
+  // this will be the "given", "when", "then"...functions
+  verbFunction[currentStep.keyword](
+    foundMatchingStep.stepExpression,
+    foundMatchingStep.stepFn
+  );
+};
+
+const findMatchingStep = (currentStep, isOutline) => {
+  const scenarioType = currentStep.keyword;
+  const scenarioSentence = currentStep.stepText;
+  const foundStep = Object.keys(stepsDefinition[scenarioType]).find(
+    (currentStepDefinitionFunction) => {
+      return isFunctionForScenario(
+        scenarioSentence,
+        stepsDefinition[scenarioType][currentStepDefinitionFunction],
+        isOutline
+      );
+    }
+  );
+  if (!foundStep) return null;
+
+  return injectVariable(
+    scenarioType,
+    scenarioSentence,
+    foundStep,
+    currentStep.stepArgument
+  );
+};
+
+const isFunctionForScenario = (
+  scenarioSentence,
+  stepDefinitionFunction,
+  isOutline
+) => {
+  if (stepDefinitionFunction.stepRegExp) {
+    if (isOutline && /<[\w]*>/.test(scenarioSentence)) {
+      return isPotentialStepFunctionForScenario(
+        scenarioSentence,
+        stepDefinitionFunction.stepRegExp
+      );
+    } else return scenarioSentence.match(stepDefinitionFunction.stepRegExp);
+  }
+
+  return scenarioSentence === stepDefinitionFunction.stepExpression;
+};
+
+const isPotentialStepFunctionForScenario = (
+  scenarioDefinition,
+  regStepFunc
+) => {
+  //so this one is tricky, to ensure we only find the
+  // step definition corresponding to actual steps function in the case of outlined gherkin
+  // we have to "disable" the outlining (since it can replace regular expression
+  // and then ensure that all "non-outlined" part do respect the regular expression of
+  // of the step function
+  // FIRST, we clean the string version of the step definition that has outline variable
+  const cleanedStepFunc = regStepFunc.source
+    .replace(/^\^/, "")
+    // .replace( /\\\(/g, '(' )
+    // .replace( /\\\)/g, ')')
+    // .replace( /\\\^/g, '^')
+    // .replace( /\\\$/g, '$')
+    .replace(/\$$/, "");
+  // .replace( /\([.\\]+[sSdDwWbB*][*?+]?\)|\(\[.*\](?:[+?*]{1}|\{\d\})\)/g, '' )
+
+  let currentScenarioPart;
+  let currentStepFuncLeft = cleanedStepFunc;
+  let currentScenarioDefLeft = scenarioDefinition;
+
+  //we step through each of the scenario outline variables
+  // from there, we will try to detect any regexp present in the
+  // step definition, so that we can ensure to find the right match
+  while (
+    (currentScenarioPart = /<[\w]*>/gi.exec(currentScenarioDefLeft)) != null
+  ) {
+    let fixedPart = currentScenarioPart.input.substring(
+      0,
+      currentScenarioPart.index
+    );
+    let idxCutScenarioPart =
+      currentScenarioPart.index + currentScenarioPart[0].length;
+
+    const regEscapedStepFunc = /\([a-zA-Z0!|,:?*+.^=${}><\\\-]+\)/g.exec(
+      currentStepFuncLeft
+        .replace(/\\\(/g, "(")
+        .replace(/\\\)/g, ")")
+        .replace(/\\\^/g, "^")
+        .replace(/\\\$/g, "$")
+    );
+    const regStepFuncLeft = /\([a-zA-Z0!|,:?*+.^=${}><\\\-]+\)/g.exec(
+      currentStepFuncLeft
+    );
+
+    if (
+      regStepFuncLeft &&
+      regEscapedStepFunc.index == currentScenarioPart.index
+    ) {
+      //if we have a regex inside our step function definition
+      // and that regex is at the same position than our Outlined variable
+      // we just need to check that the sentence match,
+      // so we can "evaluate" the step function and remove the regex in it
+      currentStepFuncLeft =
+        regEscapedStepFunc.input.substring(0, regEscapedStepFunc.index) +
+        currentStepFuncLeft.substring(
+          regStepFuncLeft.index + regStepFuncLeft[0].length
+        );
+    } else if (
+      regStepFuncLeft &&
+      regStepFuncLeft.index < currentScenarioPart.index
+    ) {
+      //if we have a regex inside our step function definition
+      // but that regex is not at the same position than our outlined variable
+      // we need to evaluate the regex against the scenario part
+      const strRegexToEvaluate = regStepFuncLeft.input.substring(
+        0,
+        regStepFuncLeft.index + regStepFuncLeft[0].length
+      );
+      const regexToEvaluate = new RegExp(strRegexToEvaluate);
+      const regIntermediatePart = regexToEvaluate.exec(
+        currentScenarioPart.input
+      );
+      if (regIntermediatePart) {
+        fixedPart = regStepFuncLeft.input.substring(
+          0,
+          regStepFuncLeft.index + regStepFuncLeft[0].length
+        );
+        idxCutScenarioPart = regIntermediatePart[0].length;
+      }
+    }
+
+    const partIndex = currentStepFuncLeft.indexOf(fixedPart);
+    if (partIndex !== -1) {
+      currentStepFuncLeft = currentStepFuncLeft.substring(
+        partIndex + fixedPart.length
+      );
+      currentScenarioDefLeft =
+        currentScenarioDefLeft.substring(idxCutScenarioPart);
+    } else {
+      return false;
+    }
+  }
+
+  return (
+    (currentScenarioDefLeft === "" && currentStepFuncLeft === "") ||
+    evaluateStepFuncEndVsScenarioEnd(
+      currentStepFuncLeft,
+      currentScenarioDefLeft
+    )
+  );
+};
+
+const evaluateStepFuncEndVsScenarioEnd = (
+  stepFunctionDef,
+  scenarioDefinition
+) => {
+  if (
+    /\(.*(\?\:)?[.\\]*[sSdDwWbB*][*?+]?.*\)|\(\[.*\](?:[+?*]{1}|\{\d\})\)/g.test(
+      stepFunctionDef
+    )
+  ) {
+    return new RegExp(stepFunctionDef).test(scenarioDefinition);
+  }
+
+  return stepFunctionDef.endsWith(scenarioDefinition);
+};
+
+const injectVariable = (
+  scenarioType,
+  scenarioSentence,
+  stepFunctionDefinition,
+  stepArgs
+) => {
+  const stepObject = stepsDefinition[scenarioType][stepFunctionDefinition];
+
+  if (!stepObject.stepRegExp)
+    return {
+      stepExpression: scenarioSentence,
+      // Forward through a rest-param wrapper so the reported arity is 0.
+      // jest-cucumber v4.4.0+ treats an arity mismatch (stepFn.length >
+      // matched args) as a request for a done() callback and then blocks
+      // on a Promise that never resolves. A rest param has length 0 while
+      // still passing along whatever args jest-cucumber provides.
+      stepFn: (...args) => stepObject.stepFn(...args),
+    };
+
+  const exprMatches = stepObject.stepRegExp.exec(scenarioSentence);
+
+  if (!exprMatches || /<.*>/.test(scenarioSentence))
+    return {
+      stepExpression: stepObject.stepRegExp,
+      // See note above: keep arity 0 to avoid jest-cucumber's done-callback
+      // heuristic hanging the step (matters for plain scenarios whose text
+      // contains "<...>" and for outline template steps).
+      stepFn: (...args) => stepObject.stepFn(...args),
+    };
+
+  const dynamicMatchThatAreVariables = [];
+
+  exprMatches.forEach((match, groupIndex) => {
+    if (groupIndex > 0) dynamicMatchThatAreVariables.push(match);
+  });
+
+  if (Array.isArray(stepArgs) && stepArgs.length > 0) {
+    dynamicMatchThatAreVariables.push(stepArgs);
+  }
+
+  return {
+    stepExpression: stepObject.stepRegExp,
+    stepFn: () => stepObject.stepFn(...dynamicMatchThatAreVariables),
+  };
+};
+
+// const path        = require( 'path' )
+//
+// function walkthroughDirectory( directoryName, bRecursive, fnDoForEachFile ) {
+//     const filesystem  = require( 'fs' )
+//     let filenamesOrDirectorynames = filesystem.readdirSync( directoryName )
+//
+//     filenamesOrDirectorynames.forEach( ( currentFilenameOrDirectoryname ) => {
+//         let currentFilepath = path.join( directoryName, currentFilenameOrDirectoryname )
+//         let currentFileStats = filesystem.statSync( currentFilepath )
+//         if( bRecursive && currentFileStats.isDirectory() )
+//             walkthroughDirectory( currentFilepath, activeLoadings, bRecursive, fnOnLoading )
+//
+//         else
+//             fnDoForEachFile( currentFilepath )
+//     } )
+// }
+
+// function FusionAll( dirFeatureFiles, bRecursive ) {
+//     const dirFinalDirectory = ( !dirFeatureFiles ? '<rootDir>/test/feature' : dirFeatureFiles )
+//
+//     walkthroughDirectory( dirFinalDirectory, bRecursive, Fusion )
+// }
+
+module.exports.Before = Before;
+module.exports.After = After;
+module.exports.Given = Given;
+module.exports.When = When;
+module.exports.Then = Then;
+module.exports.And = And;
+module.exports.But = But;
+module.exports.Fusion = Fusion;
+// module.exports.FusionAll    = FusionAll

package/test/specs/features/basic-scenarios.feature

@@ -0,0 +1,28 @@
+Feature: Rocket Launching
+
+  Scenario: Launching a SpaceX rocket
+    Given I am Elon Musk attempting to launch a rocket into space
+    When I launch the rocket
+    Then the rocket should end up in space
+    And the booster(s) should land back on the launch pad
+    But nobody should doubt me ever again
+
+  Scenario: Launching my ASCII rocket
+    Given I am Elon Musk attempting to launch a rocket into space
+    When I launch the '<rocket>'
+    Then the rocket should end up in space
+    And the booster(s) should land back on the launch pad
+    But nobody should doubt me ever again
+
+  Scenario: Launching my personal ASCII rocket
+    Given I am Elon Musk attempting to launch a rocket into space
+    When I launch my personal rocket named '<space poney==>'
+    Then the rocket should end up in space
+    And the booster(s) should land back on the launch pad
+    But nobody should doubt me ever again
+
+  Scenario: Folding ourselves in 2D
+    Given I am Elon Musk attempting to launch a rocket into space
+    And  my position in 2D space is [ 0, 2 ]
+    When I launch the rocket
+    Then the rocket should end up in space

package/test/specs/features/language.feature

@@ -0,0 +1,41 @@
+# language: nl
+
+Functionaliteit: Online verkopen
+
+    Scenario: t-shirt verkopen
+        Gegeven ik heb een t-shirt
+        Als ik een t-shirt wil verkopen
+        Dan ontvang ik €22
+        En ben ik blij
+        Maar heb ik geen t-shirts over
+
+    Abstract Scenario: <Object> verkopen
+        Gegeven ik heb een: <Object>
+        Als ik <Object> verkoop
+        Dan zou ik er €<Bedrag> voor moeten krijgen
+
+        Voorbeelden:
+
+            | Object                                         | Bedrag |
+            | Autographed Neil deGrasse Tyson book           | 100    |
+            | Rick Astley t-shirt                            | 22     |
+            | An idea to replace EVERYTHING with blockchains | 0      |
+
+    Scenario: Boek kopen
+        Gegeven 'Autographed Neil deGrasse Tyson book' is te koop
+        Als ik 'Autographed Neil deGrasse Tyson book' koop
+        Dan heb ik €100 uitgegeven
+
+    Scenario: voorraad bijvullen
+        Gegeven mijn voorraad bevat:
+            | Object                               |
+            | Autographed Neil deGrasse Tyson book |
+            | Rick Astley t-shirt                  |
+        Als ik de volgende producten toevoeg:
+            | Object            |
+            | Smurfen stripboek |
+        Dan zitten er 3 objecten in mijn voorraad, bestaant uit:
+            | Object                               |
+            | Autographed Neil deGrasse Tyson book |
+            | Rick Astley t-shirt                  |
+            | Smurfen stripboek                    |

package/test/specs/features/reuse-definition.feature

@@ -0,0 +1,13 @@
+Feature: Rocket reuse
+
+Scenario: Reusing a SpaceX rocket
+  Given I am Elon Musk and I launched a rocket in space already
+  When I relaunch the rocket
+  Then the rocket end up in space again
+  And I drop my mic
+
+  Scenario: Reading the critics
+    Given I am Elon Musk and I launched a rocket in space already
+    When I relaunch the rocket
+    Then the mission was said to be 'a success'
+    And the mission was said to be 'a wonder'

package/test/specs/features/scenario-outline2.feature

@@ -0,0 +1,71 @@
+Feature: Scenario Outline verification
+
+    Scenario Outline: Simple Scenario Outline. Buy item: <Item>
+        This scenario use Before fusion hook (see scenario-outline2.steps.js)
+        This hook is remove all items from list of onlineSales if number of items >=2.
+        This scenario also demonstrate case dependancy in scenario outline:
+        if you are using some global variable it is not clear between scenarious.
+
+        Given I have <nItems> items for sale
+        When I bought "<Item>"
+        Then I have <aItems> items for sale
+
+        Examples:
+            | nItems | Item                         | aItems |
+            | 0      | Mist written by Stephen King | 1      |
+            | 1      | Metallica. ReLoad.           | 2      |
+
+    Scenario Outline: Complex Scenario Outline. <nItems>
+        Given I have <nItems> items for sale
+        When I bought the following items:
+            | Item                         |
+            | Mist written by Stephen King |
+            | Metallica. ReLoad.           |
+
+        Then I have <aItems> items for sale
+
+        Examples:
+            | nItems | aItems |
+            | 0      | 2      |
+
+    Scenario: Complex Scenario
+        This scenario is necessary to make sure that related steps are working without examples.
+
+        Given I have 0 items for sale
+
+        When I bought the following items:
+            | Item                         |
+            | Mist written by Stephen King |
+            | Metallica. ReLoad.           |
+            | Sabaton. Great War           |
+
+        Then I have 3 items for sale
+
+        Then I want to sell 2 items if they in list
+            | Item                 |
+            | Sabaton. Great War   |
+            | Cucumber for dummies |
+
+    Scenario Outline: Using examples in sentance and in table
+
+        Given I have 0 items for sale
+
+        When I bought the following items:
+            | Item                         |
+            | Mist written by Stephen King |
+            | Metallica. ReLoad.           |
+            | Sabaton. Great War           |
+
+        Then I have 3 items for sale
+
+        Then I want to sell <nSale> items if they in list
+            | Item               |
+            | Sabaton. Great War |
+            | <SaleItemName>     |
+
+        Then I have <NItems> items for sale
+
+        Examples:
+            | nSale | SaleItemName                 | NItems |
+            | 2     | Cucumber for dummies         | 2      |
+            | 3     | Mist written by Stephen King | 1      |

package/test/specs/features/scenario-outlines.feature

@@ -0,0 +1,88 @@
+Feature: Online sales
+
+    Scenario Outline: Selling an <Item>
+        Given I have a(n) <Item>
+        When I sell the <Item>
+        Then I should get $<Amount>
+
+        Examples:
+
+        | Item                                           | Amount |
+        | Autographed Neil deGrasse Tyson book           | 100    |
+        | Rick Astley t-shirt                            | 22     |
+        | An idea to replace EVERYTHING with blockchains | 0      |
+
+
+    Scenario Outline: Selling all of one
+        Given I want to sell all my <Item>
+        When I sell all my <Item> at the price of $<Amount> CAD
+        Then I should still get $<Amount>
+
+        Examples:
+
+            | Item                                           | Amount |
+            | Autographed Neil deGrasse Tyson book           | 100    |
+            | Rick Astley t-shirt                            | 22     |
+            | An idea to replace EVERYTHING with blockchains | 0      |
+
+
+    Scenario: Selling a thing
+        Given I have an Item named '<ThatCouldLookLikeAnOutlineVariable>'
+        When I sell <ThatCouldLookLikeAnOutlineVariable With Spaces in it>
+        Then I get $<Amount>
+
+
+    Scenario Outline: Additional regexp in outline line
+        Given I want to sell all my <Item>
+        When I sell all my <Item> at the price of $100 CAD
+        Then I should still get $<Amount>
+
+        Examples:
+            | Item                                           | Amount |
+            | Autographed Neil deGrasse Tyson book           | 100    |
+            | Rick Astley t-shirt                            | 100    |
+
+
+    Scenario Outline: Additional regexp in outline line with non-string variables for <Item>
+        Given I want to sell all my <Item>
+        When I sell all my <Item> with a starting price of $<StartingPrice> at the rebate price of $100
+        Then I should still get $<Amount>
+
+        Examples:
+            | Item                                           | StartingPrice    | Amount    |
+            | Autographed Neil deGrasse Tyson book           | 100              | 100       |
+            | Rick Astley t-shirt                            | 22               | 100       |
+#
+#
+    Scenario Outline: Additional regexp in outline line with non-string variables and static one in the middle for <Item>
+        Given I want to sell all my <Item>
+        When I sell all my <Item> with a starting price of $100 at the rebate price of $<RebatePrice>
+        Then I should still get $<Amount>
+
+        Examples:
+            | Item                                           | RebatePrice      | Amount    |
+            | Autographed Neil deGrasse Tyson book           | 20               | 20        |
+            | Rick Astley t-shirt                            | 50               | 50        |
+
+
+    Scenario Outline: Additional regepx in outline line with non-string variable at the end for <Item>
+        Given I want to sell all my <Item>
+        When I sell all my <Item> with a starting price of $100 at the rebate price of $<RebatePrice>
+        Then the 1st item 1st price has a price amount of <Amount> which is a 'Number'
+
+        Examples:
+            | Item                                           | RebatePrice      | Amount    |
+            | Autographed Neil deGrasse Tyson book           | 20               | 20        |
+            | Rick Astley t-shirt                            | 50               | 50        |
+# Ability: this ones are not currently possible
+##
+#    Scenario Outline: Additional mix regexp and non-regexp in outline line with non-string variables and static one in the middle for <Item>
+#        Given I want to sell all my <Item>
+#        When I sell all my <Item> with a starting price <Description> price of <RebatePrice>$ <Currency> which is nice
+#        Then I should still get $<Amount>
+#
+#        Examples:
+#            | Item                                           | Description                  | RebatePrice   | Amount | Currency         |
+#            | Autographed Neil deGrasse Tyson book           | of $100 at the fantastic     | 20            | 20     | USD              |
+#            | Rick Astley t-shirt                            | of $100 at the fantastic     | 50            | 50     | CAD              |
+#            | Rick Astley t-shirt                            | of $100 at the rebate        | 50            | 50     | CAD              |

package/test/specs/features/step-definitions/basic-scenarios.steps.js

@@ -0,0 +1,45 @@
+const { Given, When, Then, And, But, Fusion } = require("../../../../src");
+
+const { Rocket } = require("../../../src/rocket");
+
+let rocket;
+
+Given("I am Elon Musk attempting to launch a rocket into space", () => {
+  rocket = new Rocket();
+});
+
+When("I launch the rocket", () => {
+  rocket.launch();
+});
+
+When("I launch the '<rocket>'", () => {
+  rocket.launch();
+});
+
+When(/^I launch my personal rocket named '(.*)'$/, (nameRocket) => {
+  expect(nameRocket).toBeDefined();
+  rocket.launch();
+});
+
+Then("the rocket should end up in space", () => {
+  expect(rocket.isInSpace).toBe(true);
+});
+
+/// Complex Regex :  at position (\[(?: *\d+(?: |, |,)*)+\]) with no value
+And(
+  /^my position in 2D space is (\[(?: *\d+(?: |, |,)*)+\])$/,
+  (arrayPosition) => {
+    const isAnArray = JSON.parse(arrayPosition);
+    expect(isAnArray).toBeInstanceOf(Array);
+  }
+);
+
+And(/^the booster\(s\) should land back on the launch pad$/, () => {
+  expect(rocket.boostersLanded).toBe(true);
+});
+
+But("nobody should doubt me ever again", () => {
+  expect("people").not.toBe("haters");
+});
+
+Fusion("../basic-scenarios.feature");