Refactoring

examples/typescript/specs/features/extended-rules-auto-step-binding.feature

@@ -0,0 +1,34 @@
+Feature: Vending machine
+
+  Rule: Dispenses items if correct amount of money is inserted
+
+      Scenario: Selecting a snack
+          Given the vending machine has "Maltesers" in stock
+          And I have inserted the correct amount of money
+          When I select "Maltesers"
+          Then my "Maltesers" should be dispensed
+
+      Scenario Outline: Selecting a beverage
+          Given the vending machine has "<beverage>" in stock
+          And I have inserted the correct amount of money
+          When I select "<beverage>"
+          Then my "<beverage>" should be dispensed
+
+          Examples:
+          | beverage   |
+          | Cola       |
+          | Ginger ale |
+
+  Rule: Returns my money if item is out of stock
+
+      Scenario: Selecting a snack
+          Given the vending machine has no "Maltesers" in stock
+          And I have inserted the correct amount of money
+          When I select "Maltesers"
+          Then my money should be returned
+
+      Scenario: Selecting a beverage
+          Given the vending machine has no "Cola" in stock
+          And I have inserted the correct amount of money
+          When I select "Cola"
+          Then my money should be returned

examples/typescript/specs/features/extended-rules-definition.feature

@@ -0,0 +1,34 @@
+Feature: Vending machine
+
+  Rule: Dispenses items if correct amount of money is inserted
+
+      Scenario: Selecting a snack
+          Given the vending machine has "Maltesers" in stock
+          And I have inserted the correct amount of money
+          When I select "Maltesers"
+          Then my "Maltesers" should be dispensed
+
+      Scenario Outline: Selecting a beverage
+          Given the vending machine has "<beverage>" in stock
+          And I have inserted the correct amount of money
+          When I select "<beverage>"
+          Then my "<beverage>" should be dispensed
+
+          Examples:
+          | beverage   |
+          | Cola       |
+          | Ginger ale |
+
+  Rule: Returns my money if item is out of stock
+
+      Scenario: Selecting a snack
+          Given the vending machine has no "Maltesers" in stock
+          And I have inserted the correct amount of money
+          When I select "Maltesers"
+          Then my money should be returned
+
+      Scenario: Selecting a beverage
+          Given the vending machine has no "Cola" in stock
+          And I have inserted the correct amount of money
+          When I select "Cola"
+          Then my money should be returned

examples/typescript/specs/features/tag-filtering.feature

@@ -0,0 +1,37 @@
+@included
+Feature: Vending machine
+
+  Rule: Dispenses items if correct amount of money is inserted
+
+      Scenario: Selecting a snack
+          Given the vending machine has "Maltesers" in stock
+          And I have inserted the correct amount of money
+          When I select "Maltesers"
+          Then my "Maltesers" should be dispensed
+
+      @excluded
+      Scenario Outline: Selecting a beverage
+          Given the vending machine has "<beverage>" in stock
+          And I have inserted the correct amount of money
+          When I select "<beverage>"
+          Then my "<beverage>" should be dispensed
+
+          Examples:
+          | beverage   |
+          | Cola       |
+          | Ginger ale |
+
+  Rule: Returns my money if item is out of stock
+
+      @excluded
+      Scenario: Selecting a snack
+          Given the vending machine has no "Maltesers" in stock
+          And I have inserted the correct amount of money
+          When I select "Maltesers"
+          Then my money should be returned
+
+      Scenario: Selecting a beverage
+          Given the vending machine has no "Cola" in stock
+          And I have inserted the correct amount of money
+          When I select "Cola"
+          Then my money should be returned

examples/typescript/specs/step-definitions/extended-rules-auto-step-binding.steps.ts

@@ -0,0 +1,43 @@
+import { StepDefinitions, loadFeature, autoBindSteps} from '../../../../src';
+import { VendingMachine } from '../../src/vending-machine';
+
+export const vendingMachineSteps: StepDefinitions = ({ given, and, when, then }) => {
+    let vendingMachine: VendingMachine;
+
+    const myMoney = 0.50;
+
+    given(/^the vending machine has "([^"]*)" in stock$/, (itemName: string) => {
+        vendingMachine = new VendingMachine();
+        vendingMachine.stockItem(itemName, 1);
+    });
+
+    given(/^the vending machine has no "([^"]*)" in stock$/, (itemName: string) => {
+        vendingMachine = new VendingMachine();
+        vendingMachine.stockItem(itemName, 0);
+    });
+
+    and('I have inserted the correct amount of money', () => {
+        vendingMachine.insertMoney(myMoney);
+    });
+
+    when(/^I select "(.*)"$/, (itemName: string) => {
+        vendingMachine.dispenseItem(itemName);
+    });
+
+    then(/^my money should be returned$/, () => {
+        const returnedMoney = vendingMachine.moneyReturnSlot;
+        expect(returnedMoney).toBe(myMoney);
+    });
+
+    then(/^my "(.*)" should be dispensed$/, (itemName: string) => {
+        const inventoryAmount = vendingMachine.items[itemName];
+        expect(inventoryAmount).toBe(0);
+    });
+};
+
+const feature = loadFeature(
+    './examples/typescript/specs/features/extended-rules-auto-step-binding.feature', {
+        collapseRules: false,
+    });
+
+autoBindSteps([feature], [ vendingMachineSteps ]);

examples/typescript/specs/step-definitions/extended-rules-definition.steps.ts

@@ -0,0 +1,88 @@
+import { loadFeature, defineFeature} from '../../../../src';
+import { DefineStepFunction } from '../../../../src/feature-definition-creation';
+import { VendingMachine } from '../../src/vending-machine';
+
+const feature = loadFeature(
+  './examples/typescript/specs/features/extended-rules-definition.feature', {
+    collapseRules: false,
+});
+
+defineFeature(feature, ({rule}) => {
+    let vendingMachine: VendingMachine;
+
+    const myMoney = 0.50;
+
+    const givenTheVendingMachineHasXInStock = (given: DefineStepFunction) => {
+        given(/^the vending machine has "([^"]*)" in stock$/, (itemName: string) => {
+            vendingMachine = new VendingMachine();
+            vendingMachine.stockItem(itemName, 1);
+        });
+    };
+
+    const givenTheVendingMachineHasNoXInStock = (given: DefineStepFunction) => {
+        given(/^the vending machine has no "([^"]*)" in stock$/, (itemName: string) => {
+            vendingMachine = new VendingMachine();
+            vendingMachine.stockItem(itemName, 0);
+        });
+    };
+
+    const givenIHaveInsertedTheCorrectAmountOfMoney = (given: DefineStepFunction) => {
+        given('I have inserted the correct amount of money', () => {
+            vendingMachine.insertMoney(myMoney);
+        });
+    };
+
+    const whenISelectX = (when: DefineStepFunction) => {
+        when(/^I select "(.*)"$/, (itemName: string) => {
+            vendingMachine.dispenseItem(itemName);
+        });
+    };
+
+    const thenXShouldBeDespensed = (then: DefineStepFunction) => {
+        then(/^my "(.*)" should be dispensed$/, (itemName: string) => {
+            const inventoryAmount = vendingMachine.items[itemName];
+            expect(inventoryAmount).toBe(0);
+        });
+    };
+
+    const thenMyMoneyShouldBeReturned = (then: DefineStepFunction) => {
+        then(/^my money should be returned$/, () => {
+            const returnedMoney = vendingMachine.moneyReturnSlot;
+            expect(returnedMoney).toBe(myMoney);
+        });
+    };
+
+    rule('Dispenses items if correct amount of money is inserted', (test) => {
+
+        test('Selecting a snack', ({ given, when, then }) => {
+            givenTheVendingMachineHasXInStock(given);
+            givenIHaveInsertedTheCorrectAmountOfMoney(given);
+            whenISelectX(when);
+            thenXShouldBeDespensed(then);
+        });
+
+        test('Selecting a beverage', ({ given, when, then }) => {
+            givenTheVendingMachineHasXInStock(given);
+            givenIHaveInsertedTheCorrectAmountOfMoney(given);
+            whenISelectX(when);
+            thenXShouldBeDespensed(then);
+        });
+    });
+
+    rule('Returns my money if item is out of stock', (test) => {
+
+        test('Selecting a snack', ({ given, when, then }) => {
+            givenTheVendingMachineHasNoXInStock(given);
+            givenIHaveInsertedTheCorrectAmountOfMoney(given);
+            whenISelectX(when);
+            thenMyMoneyShouldBeReturned(then);
+        });
+
+        test('Selecting a beverage', ({ given, when, then }) => {
+            givenTheVendingMachineHasNoXInStock(given);
+            givenIHaveInsertedTheCorrectAmountOfMoney(given);
+            whenISelectX(when);
+            thenMyMoneyShouldBeReturned(then);
+        });
+    });
+});

examples/typescript/specs/step-definitions/tag-filtering.steps.ts

@@ -0,0 +1,74 @@
+import { loadFeature, defineFeature} from '../../../../src';
+import { DefineStepFunction } from '../../../../src/feature-definition-creation';
+import { VendingMachine } from '../../src/vending-machine';
+
+const feature = loadFeature('./examples/typescript/specs/features/tag-filtering.feature', {
+  collapseRules: false,
+  tagFilter: '@included and not @excluded',
+});
+
+defineFeature(feature, ({rule}) => {
+    let vendingMachine: VendingMachine;
+
+    const myMoney = 0.50;
+
+    const givenTheVendingMachineHasXInStock = (given: DefineStepFunction) => {
+        given(/^the vending machine has "([^"]*)" in stock$/, (itemName: string) => {
+            vendingMachine = new VendingMachine();
+            vendingMachine.stockItem(itemName, 1);
+        });
+    };
+
+    const givenTheVendingMachineHasNoXInStock = (given: DefineStepFunction) => {
+        given(/^the vending machine has no "([^"]*)" in stock$/, (itemName: string) => {
+            vendingMachine = new VendingMachine();
+            vendingMachine.stockItem(itemName, 0);
+        });
+    };
+
+    const givenIHaveInsertedTheCorrectAmountOfMoney = (given: DefineStepFunction) => {
+        given('I have inserted the correct amount of money', () => {
+            vendingMachine.insertMoney(myMoney);
+        });
+    };
+
+    const whenISelectX = (when: DefineStepFunction) => {
+        when(/^I select "(.*)"$/, (itemName: string) => {
+            vendingMachine.dispenseItem(itemName);
+        });
+    };
+
+    const thenXShouldBeDespensed = (then: DefineStepFunction) => {
+        then(/^my "(.*)" should be dispensed$/, (itemName: string) => {
+            const inventoryAmount = vendingMachine.items[itemName];
+            expect(inventoryAmount).toBe(0);
+        });
+    };
+
+    const thenMyMoneyShouldBeReturned = (then: DefineStepFunction) => {
+        then(/^my money should be returned$/, () => {
+            const returnedMoney = vendingMachine.moneyReturnSlot;
+            expect(returnedMoney).toBe(myMoney);
+        });
+    };
+
+    rule('Dispenses items if correct amount of money is inserted', (test) => {
+
+        test('Selecting a snack', ({ given, when, then }) => {
+            givenTheVendingMachineHasXInStock(given);
+            givenIHaveInsertedTheCorrectAmountOfMoney(given);
+            whenISelectX(when);
+            thenXShouldBeDespensed(then);
+        });
+    });
+
+    rule('Returns my money if item is out of stock', (test) => {
+
+        test('Selecting a beverage', ({ given, when, then }) => {
+            givenTheVendingMachineHasNoXInStock(given);
+            givenIHaveInsertedTheCorrectAmountOfMoney(given);
+            whenISelectX(when);
+            thenMyMoneyShouldBeReturned(then);
+        });
+    });
+});

examples/typescript/specs/step-definitions/using-latest-gherkin-keywords.steps.ts

@@ -37,11 +37,11 @@ defineFeature(feature, (test) => {
     };
 
     const thenTheOutputOfXShouldBeDisplayed = (then: DefineStepFunction) => {
-        then(/^the output of "(\d+)" should be displayed$/, (expectedOutput: string) => {
+        then(/^the output of "(\d+|undefined)" should be displayed$/, (expectedOutput: string) => {
             if (!expectedOutput) {
                 expect(output).toBeFalsy();
             } else {
-                expect(output).toBe(parseFloat(expectedOutput));
+                expect(output).toBe(expectedOutput === 'undefined' ? undefined : parseFloat(expectedOutput));
             }
         });
     };

examples/typescript/src/vending-machine.ts

@@ -3,6 +3,7 @@ const ITEM_COST = 0.50;
 export class VendingMachine {
     public balance: number = 0;
     public items: { [itemName: string]: number } = {};
+    public moneyReturnSlot: number = 0;
 
     public stockItem(itemName: string, count: number) {
         this.items[itemName] = this.items[itemName] || 0;
@@ -14,10 +15,14 @@ export class VendingMachine {
     }
 
     public dispenseItem(itemName: string) {
+        if (this.items[itemName] === 0) {
+            this.moneyReturnSlot = this.balance;
+            this.balance = 0;
+        }
+
         if (this.balance >= ITEM_COST && this.items[itemName] > 0) {
             this.balance -= ITEM_COST;
+            this.items[itemName]--;
         }
-
-        this.items[itemName]--;
     }
 }