@g_package/jest-cucumber-fusion 1.0.0

package/docs/Language.md

@@ -0,0 +1,76 @@
+# Language
+
+You can use different languages in jest-cucumber-fusion by adding a `# language:` header, 
+for example `# language: nl` for dutch. 
+If you don't set any header the default language will be English (`en`).
+
+Ghenkin has translated over 70 [languages](https://cucumber.io/docs/gherkin/languages/).
+
+An example of a feature file in the dutch (nl) language:
+
+```gherkin
+# 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
+```
+Most modern IDE's (or plugin) will support this feature and autocomplete keywords when using with a language.
+
+The step-file can be defined as normal like:
+
+```javascript
+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')
+})
+...
+```
+
+Optionally you can also translate the keywords in your step-files like so:
+
+```javascript
+import {
+    Before, 
+    Given as Gegeven, 
+    When as Wanneer, 
+    Then as Dan, 
+    Fusion, 
+    And as En, 
+    But as Maar
+} from '../../../../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')
+})
+...
+```
+This example used `import` which requires ES6.

package/docs/ReusingStepDefinitions.md

@@ -0,0 +1,110 @@
+# Re-using step definitions
+
+One of the advantage of using jest-cucumber-fusion is that it will manage your test suite scope inside its execution
+Your automation code easy to read: it reads pretty much like your feature file. 
+You can then reuse the same steps repeatedly in multiple scenarios.
+
+It is normally recommended that your test code contain as little logic as possible, with common setup logic abstracted into other modules (e.g., test data creation), so there really shouldn't be much duplicated code in the first place. To further reduce duplicated code, you could do something like this:
+```gherkin
+# reuse-rocket.feature
+Feature: Rocket reuse
+
+Scenario: Reusing a SpaceX rocket
+  Given I am Elon Musk and I launched a rocket in space already
+  Then I'm happy
+```
+
+Write you step definitions as usual but require (or import) your shared step definition file
+```javascript
+// reuse-rocket.steps.js
+const { Given, Fusion } = require( 'jest-cucumber-fusion' )
+
+
+
+Given( 'I am Elon Musk and I launched a rocket in space already', () => {
+    const hasLaunchedARocket = true
+    expect( hasLaunchedARocket ).toBe( true )
+} )
+
+///
+///This is our shared test code
+///
+require( './reuse-code' )
+
+
+Fusion( '../reuse-rocket.feature' )
+```
+
+Place you shared step definitions in a shared step definition file, jest-cucumber-fusion takes care of the rest
+```javascript
+// reuse-code.js
+const { Then } = require( 'jest-cucumber-fusion' )
+
+Then( 'I\'m happy', () => {
+    const localHappy = true
+    expect( localHappy ).toBe( true )
+} )
+```
+
+
+### Managing dependencies
+Though it is not best practice, you sometime need to pass value to the shared step definitions file, like in this example:
+
+```gherkin
+# reuse-rocket.feature
+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
+```
+
+
+You will now need to encapsulate the variables in an accessor function and pass the accessor to the constructor/init of your file
+```javascript
+// reuse-rocket.steps.js
+const { Given, Fusion } = require( 'jest-cucumber-fusion' )
+
+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 )
+
+
+Fusion( '../reuse-definition.feature' )
+```
+
+
+Inside you shared step file, be careful to call the accessor inside your test step function not outside
+```javascript
+// reuse-code.js
+const { When, Then, And } = require( 'jest-cucumber-fusion' )
+
+And( 'I drop my mic', () => {  
+    const micDropped = true
+    expect( micDropped ).toBe( true )
+} )
+
+module.exports = exports = function( 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/docs/RunningTheExamples.md

@@ -0,0 +1,16 @@
+# Running the examples
+
+Note that examples are provided in both ECMAScript and TypeScript.
+
+First, build jest-cucumber-fusion: 
+
+```
+$ npm install
+```
+
+## Running examples from the CMD line
+
+
+```
+$ npm test
+```

package/docs/ScenarioOutlines.md

@@ -0,0 +1,43 @@
+# Scenario outlines
+
+```gherkin
+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     |
+```
+
+```javascript
+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)
+} )
+
+When( /^I sell the (.*)$/, item => {
+    salesPrice = onlineSales.sellItem(item)
+} )
+
+Then( /^I should get \$(\d+)$/, expectedSalesPrice => {
+    expect(salesPrice).toBe(parseInt(expectedSalesPrice))
+} )
+
+
+Fusion( '../scenario-outlines.feature' )
+```

package/docs/StepDefinitionArguments.md

@@ -0,0 +1,37 @@
+## Step definition arguments
+
+```gherkin
+Feature: Getting rich writing software
+
+Scenario: Depositing a paycheck
+  Given my account balance is $10
+  When I get paid $1000000 for writing some awesome code
+  Then my account balance should be $1000010
+```
+
+```javascript
+const { Before, Given, When, Then, Fusion } = require( '../../../../src' )
+
+const { BankAccount } = require( '../../../src/bank-account' )
+let myAccount
+
+
+Before( () => { myAccount = new BankAccount() } )
+
+
+Given(/^my account balance is \$(\d+)$/, balance => {
+    myAccount.deposit(parseInt(balance))
+} )
+
+When(/^I get paid \$(\d+) for writing some awesome code$/, paycheck => {
+    myAccount.deposit(parseInt(paycheck))
+} )
+
+Then(/^my account balance should be \$(\d+)$/, expectedBalance => {
+    expect(myAccount.balance).toBe(parseInt(expectedBalance))
+} )
+
+
+Fusion( '../using-dynamic-values.feature' )
+
+```

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@g_package/jest-cucumber-fusion",
+  "version": "1.0.0",
+  "description": "Write cucumber test as part of a jest run (including coverage)",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "scripts": {
+    "test": "jest --color",
+    "coverage": "jest --coverage",
+    "commit": "git-cz",
+    "semantic-release": "semantic-release",
+    "fmt": "npx prettier --write ."
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gotreasa/jest-cucumber-fusion.git"
+  },
+  "keywords": [
+    "jest",
+    "cucumber",
+    "BDD",
+    "gherkin"
+  ],
+  "dependencies": {
+    "callsites": "~3.1.0",
+    "jest": "^30.4.2",
+    "jest-cucumber": "^4.5.0"
+  },
+  "devDependencies": {
+    "cz-conventional-changelog": "^3.3.0",
+    "prettier": "2.3.2",
+    "semantic-release": "^25.0.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
+  },
+  "release": {
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      [
+        "@semantic-release/github",
+        {
+          "assets": [
+            "dist/**"
+          ]
+        }
+      ],
+      [
+        "@semantic-release/npm",
+        {
+          "npmPublish": true
+        }
+      ]
+    ],
+    "parserOpts": {
+      "mergePattern": "Merged PR .*:"
+    }
+  },
+  "author": "B-Yond",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/gotreasa/jest-cucumber-fusion/issues"
+  },
+  "homepage": "https://github.com/gotreasa/jest-cucumber-fusion#readme",
+  "jest": {
+    "testMatch": [
+      "**/*.steps.js"
+    ],
+    "coveragePathIgnorePatterns": [
+      "/node_modules/",
+      "/test/"
+    ],
+    "coverageDirectory": "./coverage/",
+    "collectCoverage": true
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,25 @@
+// Type definitions for jest-cucumber-fusion 0.6
+// Project: https://github.com/b-yond-infinite-network/jest-cucumber-fusion#readme
+// Definitions by: Pelle Johnsen <https://github.com/pjoe>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 3.4
+
+import { loadFeature } from "jest-cucumber";
+
+export type CallBack = (
+  ...args: ReadonlyArray<string | Array<Record<string, string>>>
+) => void | Promise<void>;
+
+export function Given(name: string | RegExp, callback: CallBack): void;
+export function When(name: string | RegExp, callback: CallBack): void;
+export function Then(name: string | RegExp, callback: CallBack): void;
+export function And(name: string | RegExp, callback: CallBack): void;
+export function But(name: string | RegExp, callback: CallBack): void;
+
+export function Before(callback: () => void | Promise<void>): void;
+export function After(callback: () => void | Promise<void>): void;
+
+export function Fusion(
+  feature: string,
+  options?: Parameters<typeof loadFeature>[1]
+): void;