@g_package/jest-cucumber-fusion 1.0.0

package/test/specs/features/step-definitions/language.steps.js

@@ -0,0 +1,86 @@
+const {
+  Before,
+  Given,
+  When,
+  Then,
+  Fusion,
+  And,
+  But,
+} = require("../../../../src");
+
+const { OnlineSales } = require("../../../src/online-sales");
+
+let onlineSales;
+let salesPrice;
+
+Before(() => {
+  onlineSales = new OnlineSales();
+});
+
+Given(/^ik heb een t-shirt$/, (item) => {
+  onlineSales.listItem("Rick Astley t-shirt");
+});
+
+When(/^ik een t-shirt wil verkopen$/, (item) => {
+  salesPrice = onlineSales.sellItem("Rick Astley t-shirt");
+});
+
+Then(/^ontvang ik €22$/, (item) => {
+  expect(salesPrice).toEqual(22);
+});
+
+And(/^ben ik blij$/, (item) => {
+  expect("ik").not.toEqual("boos");
+});
+
+But(/^heb ik geen t-shirts over$/, (item) => {
+  expect(onlineSales.listedItems).not.toContain("Rick Astley t-shirt");
+});
+
+Given(/^ik heb een: (.*)$/, (item) => {
+  onlineSales.listItem(item);
+});
+
+When(/^ik (.*) verkoop$/, (item) => {
+  salesPrice = onlineSales.sellItem(item);
+});
+
+Then(/^zou ik er €(\d+) voor moeten krijgen$/, (expectedSalesPrice) => {
+  expect(salesPrice).toBe(parseInt(expectedSalesPrice));
+});
+
+Given(/^'(.*)' is te koop$/, (object) => {
+  onlineSales.listItem(object);
+});
+
+When(/^ik '(.*)' koop$/, (object) => {
+  salesPrice = onlineSales.sellItem(object);
+});
+
+Then(/^heb ik €(\d+) uitgegeven$/, (amount) => {
+  expect(salesPrice).toEqual(100);
+});
+
+Given("mijn voorraad bevat:", (table) => {
+  table.forEach((row) => {
+    onlineSales.listItem(row.Object);
+  });
+});
+
+When("ik de volgende producten toevoeg:", (table) => {
+  onlineSales.listItem(table[0].Object);
+});
+
+Then(
+  /^zitten er (\d) objecten in mijn voorraad, bestaant uit:$/,
+  (nbre, table) => {
+    expect(onlineSales.listedItems.length).toBe(parseInt(nbre));
+    expect(onlineSales.listedItems.length).toBe(table.length);
+
+    table.forEach((row, index) => {
+      expect(onlineSales.listedItems).toContain(table[index].Object);
+    });
+  }
+);
+
+Fusion("../language.feature");

package/test/specs/features/step-definitions/reuse-code.js

@@ -0,0 +1,17 @@
+const { When, Then, And } = require("../../../../src");
+
+And("I drop my mic", () => {
+  const micDropped = true;
+});
+
+module.exports = exports = (fnRocket) => {
+  When("I relaunch the rocket", () => {
+    const rocketUsed = fnRocket();
+    rocketUsed.launch();
+  });
+
+  Then("the rocket end up in space again", () => {
+    const rocketUsed = fnRocket();
+    expect(rocketUsed.isInSpace).toBe(true);
+  });
+};

package/test/specs/features/step-definitions/reuse-definition.steps.js

@@ -0,0 +1,22 @@
+const { Given, Then, And, Fusion } = require("../../../../src");
+
+const { Rocket } = require("../../../src/rocket");
+
+let rocket;
+function getCurrentRocket() {
+  return rocket;
+}
+
+Given(/^I am Elon Musk and I launched a rocket in space already$/, () => {
+  rocket = new Rocket();
+});
+
+require("./reuse-code")(getCurrentRocket);
+
+Then(
+  And(/^the mission was said to be '(.*)'$/, (sayingForTheMission) => {
+    expect(sayingForTheMission).toBeDefined();
+  })
+);
+
+Fusion("../reuse-definition.feature");

package/test/specs/features/step-definitions/scenario-outline2.steps.js

@@ -0,0 +1,46 @@
+const { Given, When, Then, Fusion, Before } = require("../../../../src");
+
+const { OnlineSales } = require("../../../src/online-sales");
+
+const onlineSales = new OnlineSales();
+
+Before(()=>{
+  if (onlineSales.nItems() >= 2) {
+    onlineSales.listedItems = [];
+  }
+})
+
+Given(/^I have (\d+) items for sale$/, (nItems) => {
+  expect(Number(nItems)).toBe(onlineSales.nItems());
+});
+
+When(/^I bought "(.+)"/, (item) => {
+  onlineSales.buyItem(item);
+});
+
+When(/^I bought the following items:$/, (table) => {
+    if (typeof table === "string") return;
+
+    table.forEach((row) => {
+      onlineSales.buyItem(row.Item)
+    });
+});
+
+Then(/^I have (\d+) items for sale$/, (nItems) => {
+  expect(Number(nItems)).toBe(onlineSales.nItems());
+});
+
+Then(/^I want to sell (\d+) items if they in list$/, (nItems, table) => {
+  if (typeof nItems !== "string") return;
+  if (typeof table === "string") return;
+  let iNumber = Number(nItems);
+
+  table.forEach((row) => {
+    if (iNumber > 0 && onlineSales.listedItems.includes(row.Item)) {
+      onlineSales.sellItem(row.Item);
+      iNumber--;
+    }
+  });
+});
+
+Fusion("../scenario-outline2.feature");

package/test/specs/features/step-definitions/scenario-outlines.steps.js

@@ -0,0 +1,110 @@
+const { Before, Given, When, Then, Fusion } = require("../../../../src");
+
+const { OnlineSales } = require("../../../src/online-sales");
+
+let onlineSales;
+let salesPrice;
+
+Before(() => {
+  onlineSales = new OnlineSales();
+});
+
+Given(/^I have a\(n\) (.*)$/, (item) => {
+  onlineSales.listItem(item);
+});
+
+Given(
+  /^I have an Item named '<ThatCouldLookLikeAnOutlineVariable>'$/,
+  (item) => {
+    onlineSales.listItem("Autographed Neil deGrasse Tyson book");
+  }
+);
+
+When(/^I sell the (.*)$/, (item) => {
+  salesPrice = onlineSales.sellItem(item);
+});
+
+When(/^I sell <ThatCouldLookLikeAnOutlineVariable With Spaces in it>$/, () => {
+  salesPrice = onlineSales.sellItem("Autographed Neil deGrasse Tyson book");
+});
+
+Then(/^I should get \$(\d+)$/, (expectedSalesPrice) => {
+  expect(salesPrice).toBe(parseInt(expectedSalesPrice));
+});
+
+Then(/^I get \$<Amount>$/, (expectedSalesPrice) => {
+  expect(salesPrice).toBe(parseInt(100));
+});
+
+Given(/^I want to sell all my (.*)$/, (item) => {
+  onlineSales.listItem(item);
+});
+
+When(
+  /^I sell all my (.*) at the price of \$(\d+) CAD$/,
+  (item, expectedSalesPrice) => {
+    salesPrice = onlineSales.sellItem(item);
+    if (salesPrice) salesPrice = parseInt(expectedSalesPrice);
+  }
+);
+
+When(
+  /^I sell all my (.*) with a starting price of \$(\d+) at the rebate price of \$(\d+)$/,
+  (item, startingPrice, expectedSalesPrice) => {
+    salesPrice = onlineSales.sellItem(item);
+    if (salesPrice) {
+      salesPrice = parseInt(expectedSalesPrice);
+    } else {
+      salesPrice = null;
+    }
+  }
+);
+
+When(
+  /^I sell all my (.*) with a starting price of \$(\d+) at the fantastic price of (\d+)\$ USD which is nice$/,
+  (item, startingPrice, expectedSalesPrice) => {
+    salesPrice = onlineSales.sellItem(item);
+    if (salesPrice) {
+      salesPrice = parseInt(expectedSalesPrice);
+    } else {
+      salesPrice = null;
+    }
+  }
+);
+
+When(
+  /^I sell all my (.*) with a starting price of \$(\d+) at the fantastic price of (\d+)\$ CAD which is nice$/,
+  (item, startingPrice, expectedSalesPrice) => {
+    salesPrice = onlineSales.sellItem(item);
+    if (salesPrice) {
+      salesPrice = parseInt(expectedSalesPrice);
+    } else {
+      salesPrice = null;
+    }
+  }
+);
+
+When(
+  /^I sell all my (.*) with a starting price of \$(\d+) at the rebate price of (\d+)\$ CAD which is nice$/,
+  (item, startingPrice, expectedSalesPrice) => {
+    salesPrice = onlineSales.sellItem(item);
+    if (salesPrice) {
+      salesPrice = parseInt(expectedSalesPrice);
+    } else {
+      salesPrice = null;
+    }
+  }
+);
+
+Then(/^I should still get \$(\d+)$/, (expectedSalesPrice) => {
+  expect(salesPrice).toBe(parseInt(expectedSalesPrice));
+});
+
+Then(
+  /^the (\d+)(?:th|d|nd|rd|st) item (\d+)(?:th|d|nd|rd|st) price has a price amount of (\d+) which is a '(\w*)'$/,
+  (indexItem, indexPrice, amountPrice, typePrice) => {
+    expect(salesPrice).toBe(parseInt(amountPrice));
+  }
+);
+
+Fusion("../scenario-outlines.feature");

package/test/specs/features/step-definitions/using-dynamic-values.steps.js

@@ -0,0 +1,70 @@
+const { Before, Given, When, Then, Fusion } = require("../../../../src");
+
+const { BankAccount } = require("../../../src/bank-account");
+
+let myAccounts;
+
+Before(() => {
+  myAccounts = [];
+});
+
+Given(/^I open new account with '(.+)' name$/, (newAccountName) => {
+  myAccounts.push(new BankAccount());
+  myAccounts[myAccounts.length - 1].name = newAccountName;
+});
+
+Given(/^my account#(\d+) balance is \$(\d+)$/, (nAcc, balance) => {
+  myAccounts[nAcc - 1].deposit(parseInt(balance));
+});
+
+When(
+  /^I get paid \$(\d+) for writing some awesome code from my account#(\d+)$/,
+  (paycheck, nAcc) => {
+    myAccounts[nAcc - 1].deposit(parseInt(paycheck));
+  }
+);
+
+Then(
+  /^my account#(\d+) balance should be \$(\d+)$/,
+  (nAcc, expectedBalance) => {
+    expect(myAccounts[nAcc - 1].balance).toBe(parseInt(expectedBalance));
+  }
+);
+
+Then(/^I have (\d+) accounts$/, (nAccounts) => {
+  expect(myAccounts.length).toBe(parseInt(nAccounts));
+});
+
+Given(/^my account#(\d+) name is '(.*)'$/, (nAcc, nameAccount) => {
+  myAccounts[nAcc - 1].name = nameAccount;
+});
+
+When(
+  /^I get an new account#(\d+) name '(.*)' with a type (.*) from my old account named '(.*)'$/,
+  (nAcc, nameNewAccount, typeAccount, nameOldAccount) => {
+    myAccounts[nAcc - 1].name = nameNewAccount;
+    myAccounts[nAcc - 1].type = typeAccount;
+  }
+);
+
+Then(
+  /^my account#(\d+) name should be "(.*)" and have a type (.*)$/,
+  (nAcc, nameAccount, typeAccount) => {
+    expect(myAccounts[nAcc - 1].name).toBe(nameAccount);
+    expect(myAccounts[nAcc - 1].type).toBe(typeAccount);
+  }
+);
+
+Then(/^my account#(\d+) should be:$/, (nAcc, table) => {
+  if (typeof table === "string") return;
+
+  for (const [key, value] of Object.entries(myAccounts[nAcc - 1])) {
+    table.forEach((row) => {
+      if (row.field === key) {
+        expect(value.toString()).toBe(row.value);
+      }
+    });
+  }
+});
+
+Fusion("../using-dynamic-values.feature");

package/test/specs/features/step-definitions/using-gherkin-tables.steps.js

@@ -0,0 +1,42 @@
+const { Before, After, Given, When, Then, Fusion } = require("../../../../src");
+
+const { TodoList } = require("../../../src/todo-list");
+
+let todoList;
+
+Before(() => {
+  todoList = new TodoList();
+});
+
+Given("my todo list currently looks as follows:", (table) => {
+  table.forEach((row) => {
+    todoList.add({
+      name: row.TaskName,
+      priority: row.Priority,
+    });
+  });
+});
+
+When("I add the following task:", (table) => {
+  todoList.add({
+    name: table[0].TaskName,
+    priority: table[0].Priority,
+  });
+});
+
+Then(/^I should see the following (\d) todos in my list:$/, (nbre, table) => {
+  expect(todoList.items.length).toBe(parseInt(nbre));
+  expect(todoList.items.length).toBe(table.length);
+
+  table.forEach((row, index) => {
+    expect(todoList.items[index].name).toBe(table[index].TaskName);
+    expect(todoList.items[index].priority).toBe(table[index].Priority);
+  });
+});
+
+After(() => {
+  const emptyTodo = new TodoList();
+  emptyTodo.add({ name: "Empty on purpose", priority: "so low" });
+});
+
+Fusion("../using-gherkin-tables.feature");

package/test/specs/features/using-dynamic-values.feature

@@ -0,0 +1,34 @@
+Feature: Getting rich writing software
+
+  Scenario: Depositing a paycheck
+    Given I open new account with 'Cash' name
+    Given my account#1 balance is $10
+    When I get paid $1000000 for writing some awesome code from my account#1
+    Then my account#1 balance should be $1000010
+
+  Scenario: Testing simple inception
+    Given I open new account with 'Cash' name
+    Given my account#1 name is 'a'
+    When I get an new account#1 name 'name' with a type Test from my old account named 'a'
+    Then my account#1 name should be "name" and have a type Test
+
+  Scenario Outline: Using examples in step RegExp and step Table at the same time. <Description>
+    Given I open new account with 'Cash' name
+    Given I open new account with 'Deposit' name
+
+    Given my account#1 balance is $10000
+    Given my account#2 balance is $1234
+
+    Then I have <NAccounts> accounts
+
+    # Use test step with parameter in step RegExp and paramter in step Table
+    Then my account#<accN> should be:
+      | field   | value     |
+      | name    | <Type>    |
+      | balance | <balance> |
+      | type    | Account   |
+
+    Examples:
+      | NAccounts | accN | Type    | balance | Description     |
+      | 2         | 1    | Cash    | 10000   | First Scenario  |
+      | 2         | 2    | Deposit | 1234    | Second Scenario |

package/test/specs/features/using-gherkin-tables.feature

@@ -0,0 +1,16 @@
+Feature: Todo List
+
+  Scenario: Adding an item to my todo list
+    Given my todo list currently looks as follows:
+      | TaskName            | Priority |
+      | Fix bugs in my code | medium   |
+      | Document my hours   | medium   |
+    When I add the following task:
+      | TaskName                            | Priority |
+      | Watch cat videos on YouTube all day | high     |
+      | Document my hours                   | medium   |
+    Then I should see the following 2 todos in my list:
+      | TaskName                            | Priority |
+      | Watch cat videos on YouTube all day | high     |
+      | Sign up for unemployment            | high     |
+

package/test/src/bank-account.js

@@ -0,0 +1,17 @@
+class BankAccount {
+  constructor() {
+    this.balance = 0;
+    this.name = "";
+    this.type = "Account";
+  }
+
+  deposit(amount) {
+    this.balance += amount;
+  }
+
+  withdraw(amount) {
+    this.balance -= amount;
+  }
+}
+
+module.exports.BankAccount = BankAccount;

package/test/src/online-sales.js

@@ -0,0 +1,33 @@
+const itemPrices = {
+  "Autographed Neil deGrasse Tyson book": 100,
+  "Rick Astley t-shirt": 22,
+  "An idea to replace EVERYTHING with blockchains": 0,
+};
+
+class OnlineSales {
+  constructor() {
+    this.listedItems = [];
+  }
+
+  nItems = () => this.listedItems.length;
+
+  listItem(name) {
+    this.listedItems.push(name);
+  }
+
+  buyItem = (name) => this.listedItems.push(name);
+
+  sellItem(name) {
+    const itemIndex = this.listedItems.indexOf(name);
+
+    if (itemIndex !== -1) {
+      this.listedItems.splice(itemIndex, 1);
+
+      return itemPrices[name];
+    } else {
+      return null;
+    }
+  }
+}
+
+module.exports.OnlineSales = OnlineSales;

package/test/src/rocket.js

@@ -0,0 +1,13 @@
+class Rocket {
+  constructor() {
+    this.isInSpace = false;
+    this.boostersLanded = true;
+  }
+
+  launch() {
+    this.isInSpace = true;
+    this.boostersLanded = true;
+  }
+}
+
+module.exports.Rocket = Rocket;

package/test/src/todo-list.js

@@ -0,0 +1,20 @@
+class TodoList {
+  constructor() {
+    this.items = [];
+  }
+
+  add(todo) {
+    if (todo.name.toLocaleLowerCase().indexOf("youtube")) {
+      this.items = [];
+      this.items.push(todo);
+      this.items.push({
+        name: "Sign up for unemployment",
+        priority: "high",
+      });
+    } else {
+      this.items.push(todo);
+    }
+  }
+}
+
+module.exports.TodoList = TodoList;