Behavior-Driven Development: Bridging the Communication Gap

// Traditional test (technical, written by engineers)
test('order calculation includes tax', () => {
  const order = new Order();
  order.addLineItem(product, 2);
  const total = order.calculateTotal(0.10);
  expect(total).toBe(42);
});

// BDD specification (natural language, can be read by anyone)
Feature: Order Calculation
  Scenario: Calculate order total with tax
    Given an order with a product costing 20 dollars
    And a quantity of 2
    When the customer calculates the total with 10 percent tax
    Then the order total should be 42 dollars

Scenario: Cannot add out of stock items
  Given a product that is out of stock
  And a customer on the product page
  When the customer clicks "Add to Cart"
  Then they should see "Product is out of stock" error
  And the item is not added to cart

Scenario: Customer uses valid promo code
  Given a customer has items in their cart totaling 100 dollars
  And they have a valid promo code for 10 percent off
  When the customer applies the promo code
  Then the order total should be 90 dollars
  And the promo code should be marked as used

Scenario: Customer uses expired promo code
  Given a customer has items in their cart
  And they have a promo code that expired yesterday
  When the customer applies the promo code
  Then they should see an error "Promo code is expired"
  And the order total should remain unchanged

// Gherkin syntax (plain language)
Feature: Order management
  Scenario: Place order with valid items
    Given I am a logged-in customer
    And I have selected 2 products
    When I place the order
    Then my order should be created
    And I should receive a confirmation email

// Step definitions (connects Gherkin to code)
import { Given, When, Then } from '@cucumber/cucumber';

Given('I am a logged-in customer', function() {
  this.customer = new Customer('alice@example.com');
  this.customer.login('password');
});

Given('I have selected {int} products', function(count) {
  this.cart = new ShoppingCart();
  for (let i = 0; i < count; i++) {
    this.cart.addItem(testProduct);
  }
});

When('I place the order', function() {
  this.order = this.customer.placeOrder(this.cart);
});

Then('my order should be created', function() {
  expect(this.order).toBeDefined();
  expect(this.order.status).toBe('created');
});

Then('I should receive a confirmation email', function() {
  const email = emailService.getLastEmail();
  expect(email.to).toBe(this.customer.email);
  expect(email.subject).toContain('Order Confirmation');
});

test('Money constructor validates amount', () => {
  expect(() => new Money(-10)).toThrow();
  expect(() => new Money(0)).not.toThrow();
});

test('Money.plus adds correctly', () => {
  const m1 = new Money(10);
  const m2 = new Money(20);
  expect(m1.plus(m2).amount).toBe(30);
});

test('customer can place order with items', () => {
  const customer = new Customer('Alice');
  const order = customer.placeOrder(items);
  expect(order.total).toBe(expectedTotal);
});

Scenario: Place order
  Given a customer with items in their cart
  When they place the order
  Then the order should be created
  And they should be sent a confirmation email

// Bad: Too vague
Scenario: User does something
  Given the user is logged in
  When they do something
  Then something happens

// Good: Specific behavior
Scenario: Customer receives discount for loyalty
  Given a customer with 5 previous purchases
  And a new order totaling 100 dollars
  When they complete checkout
  Then a 10 percent loyalty discount is applied
  And the total becomes 90 dollars

// Bad: Testing implementation
Scenario: Order total calculation
  Given an order object is created
  And the addLineItem method is called with product and quantity
  When the calculateTotal method is invoked
  Then the total property contains the correct value

// Good: Testing behavior
Scenario: Order total reflects all items
  Given a customer has 2 items in their order
  Where each item costs 50 dollars
  When they view the order total
  Then the total is 100 dollars

// Bad: Abstract
Scenario: Apply discount code
  Given a customer with a discount code
  When they apply it
  Then the total is reduced

// Good: Concrete example
Scenario: Apply Black Friday discount code
  Given a customer with order total of 200 dollars
  And a "BLACKFRIDAY" discount code for 25 percent off
  When they apply the code at checkout
  Then the order total becomes 150 dollars

Feature: Payment Processing
  Scenario: Successful charge completes order
    Given a customer with a valid payment method
    And an order totaling 100 dollars
    When the payment processor attempts to charge the card
    Then the order status becomes "paid"
    And the fulfillment system receives the order
    And the customer receives a confirmation email

// Simple internal tool, no ambiguity
Feature: Database backup
  Scenario: Create daily backup
    When the backup job runs
    Then a backup file is created
    And the file size is greater than zero

// This could just be:
test('backup job creates non-empty backup file', () => {
  // ...
});