test-driven-development

## Step 1: Write the failing test

**`isValidEmail.test.js`**

```js
const isValidEmail = require('./isValidEmail');

describe('isValidEmail', () => {
  test('accepts a normal email', () => {
    expect(isValidEmail('user@example.com')).toBe(true);
  });

  test('rejects a string with no domain', () => {
    expect(isValidEmail('user@')).toBe(false);
  });

  test('rejects a string with multiple @ signs', () => {
    expect(isValidEmail('a@b@c')).toBe(false);
  });

  test('rejects a string with no @ sign', () => {
    expect(isValidEmail('userexample.com')).toBe(false);
  });

  test('rejects empty string', () => {
    expect(isValidEmail('')).toBe(false);
  });
});
```

Running this against your current implementation, 3 tests fail:

```
FAIL  ./isValidEmail.test.js
  ✕ rejects a string with no domain        (received: true)
  ✕ rejects a string with multiple @ signs (received: true)
  ✕ rejects empty string                   (received: true)
```

## Step 2: Update the function

**`isValidEmail.js`**

```js
// Requires: something@something.tld — no spaces, exactly one @,
// and a dot in the domain part.
const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

function isValidEmail(email) {
  if (typeof email !== 'string') return false;
  return EMAIL_PATTERN.test(email);
}

module.exports = isValidEmail;
```

## Step 3: Verify

```
PASS  ./isValidEmail.test.js
  ✓ accepts a normal email
  ✓ rejects a string with no domain
  ✓ rejects a string with multiple @ signs
  ✓ rejects a string with no @ sign
  ✓ rejects empty string

Tests: 5 passed, 5 total
```

**Why this regex:** `[^\s@]+` matches any run of characters that are neither whitespace nor `@`, so `user@` fails (nothing after the `@`), `a@b@c` fails (the second `@` can't match), and the `\.` guarantees a dot in the domain, so bare `user@localhost` is also rejected. It's deliberately pragmatic — full RFC 5322 compliance is overkill for most apps; if you need that, use a dedicated validation library instead.

**Step 1 — Failing test (RED)**

```javascript
// isValidEmail.test.js
const isValidEmail = require('./isValidEmail');

describe('isValidEmail', () => {
  test('accepts a normal email', () => {
    expect(isValidEmail('user@example.com')).toBe(true);
  });

  test('rejects missing domain (user@)', () => {
    expect(isValidEmail('user@')).toBe(false);
  });

  test('rejects multiple @ signs (a@b@c)', () => {
    expect(isValidEmail('a@b@c')).toBe(false);
  });

  test('rejects string without @', () => {
    expect(isValidEmail('userexample.com')).toBe(false);
  });

  test('rejects empty string', () => {
    expect(isValidEmail('')).toBe(false);
  });
});
```

Run it against your current function:

```bash
npx jest isValidEmail.test.js
```

Expected result: the `user@` and `a@b@c` tests **fail** (current code returns `true`), confirming the test catches the bug.

**Step 2 — Minimal implementation (GREEN)**

```javascript
// isValidEmail.js
function isValidEmail(email) {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

module.exports = isValidEmail;
```

This requires: exactly one `@`, non-empty local part and domain, and a dot in the domain (so `user@` and `a@b@c` are rejected, while `user@example.com` passes).

**Step 3 — Verify GREEN**

```bash
npx jest isValidEmail.test.js
```

All five tests should now pass. If you want stricter validation (e.g., TLD length, quoted local parts), add a new failing test first and extend the regex incrementally.

Here's the failing test first, then the fix.

**test_email.py** (run this first — it fails against the current implementation):

```python
from email_validator import validate_email


def test_rejects_empty_string():
    assert validate_email("") is False


def test_accepts_normal_email():
    assert validate_email("user@example.com") is True


def test_rejects_string_without_at():
    assert validate_email("not-an-email") is False
```

Running `pytest test_email.py` now:

```
FAILED test_email.py::test_rejects_empty_string - assert True is False
```

**email_validator.py** (the fix):

```python
def validate_email(email: str) -> bool:
    """Return True if email is a non-empty string containing '@'."""
    return bool(email) and "@" in email
```

Re-running the tests:

```
test_email.py ...                                              [100%]
3 passed
```

The fix: `bool(email)` rejects empty strings (and `None`), while `"@" in email` still accepts normal addresses.

**Step 1 — RED: write the failing test first**

```python
# test_email.py
from email_validator import validate_email

def test_rejects_empty_string():
    assert validate_email('') is False

def test_accepts_normal_email():
    assert validate_email('user@example.com') is True
```

**Step 2 — Verify RED** (run against the current buggy implementation):

```bash
$ pytest test_email.py
FAILED test_email.py::test_rejects_empty_string - assert True is False
PASSED test_email.py::test_accepts_normal_email
```

The empty-string test fails for the expected reason: the current code returns `True` for `''`.

**Step 3 — GREEN: minimal fix**

```python
# email_validator.py
def validate_email(email):
    return '@' in email
```

Removing `email == ''` is the minimal change: `''` contains no `'@'`, so it's now rejected.

**Step 4 — Verify GREEN:**

```bash
$ pytest test_email.py
PASSED test_email.py::test_rejects_empty_string
PASSED test_email.py::test_accepts_normal_email
```

Both tests pass. No refactor needed — the fix is already minimal.

## Step 1: Failing test

```javascript
// fetchUser.test.js
import { fetchUser } from './fetchUser';

// Mock global fetch
global.fetch = jest.fn();

const flush = (ms) => new Promise((r) => setTimeout(r, ms));

describe('fetchUser retry logic', () => {
  beforeEach(() => jest.clearAllMocks());

  test('returns data on first success without retrying', async () => {
    fetch.mockResolvedValueOnce({ ok: true, json: async () => ({ id: 1 }) });
    const user = await fetchUser(1);
    expect(user).toEqual({ id: 1 });
    expect(fetch).toHaveBeenCalledTimes(1);
  });

  test('retries on 5xx and succeeds on 2nd attempt', async () => {
    fetch
      .mockResolvedValueOnce({ ok: false, status: 500 })
      .mockResolvedValueOnce({ ok: true, json: async () => ({ id: 1 }) });
    const user = await fetchUser(1);
    expect(user).toEqual({ id: 1 });
    expect(fetch).toHaveBeenCalledTimes(2);
  });

  test('retries on network error and succeeds', async () => {
    fetch
      .mockRejectedValueOnce(new TypeError('Failed to fetch'))
      .mockResolvedValueOnce({ ok: true, json: async () => ({ id: 2 }) });
    const user = await fetchUser(2);
    expect(user).toEqual({ id: 2 });
    expect(fetch).toHaveBeenCalledTimes(2);
  });

  test('throws after 3 retries on persistent 5xx', async () => {
    fetch.mockResolvedValue({ ok: false, status: 503 });
    await expect(fetchUser(3)).rejects.toThrow('API error');
    expect(fetch).toHaveBeenCalledTimes(4); // 1 initial + 3 retries
  });

  test('does NOT retry on 4xx', async () => {
    fetch.mockResolvedValueOnce({ ok: false, status: 404 });
    await expect(fetchUser(4)).rejects.toThrow('API error');
    expect(fetch).toHaveBeenCalledTimes(1);
  });

  test('waits 100ms between attempts', async () => {
    jest.useFakeTimers();
    const start = Date.now();
    fetch.mockResolvedValue({ ok: false, status: 500 });
    const promise = fetchUser(5);
    // Advance past all delays
    jest.advanceTimersByTime(400);
    await expect(promise).rejects.toThrow('API error');
    expect(fetch).toHaveBeenCalledTimes(4);
    jest.useRealTimers();
  });
});
```

Run it: all tests fail (no retry logic yet — the multi-attempt tests fail immediately).

## Step 2: Implementation

```javascript
// fetchUser.js
const MAX_RETRIES = 3;
const RETRY_DELAY_MS = 100;

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function fetchUser(id) {
  let lastError;

  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
    if (attempt > 0) {
      await delay(RETRY_DELAY_MS);
    }
    try {
      const res = await fetch(`/users/${id}`);
      if (res.ok) return res.json();
      if (res.status >= 500) {
        lastError = new Error('API error');
        continue; // retry on 5xx
      }
      throw new Error('API error'); // 4xx etc. — no retry
    } catch (err) {
      if (err.message !== 'API error' || err instanceof TypeError) {
        lastError = err; // network error — retry
        continue;
      }
      throw err; // non-retryable
    }
  }

  throw lastError ?? new Error('API error');
}

export { fetchUser };
```

## Step 3: Verify

Run the tests again — all pass:

- ✅ Success on first attempt (no wasted calls)
- ✅ Retries on 5xx and network errors
- ✅ Gives up after 3 retries (4 total attempts)
- ✅ Never retries 4xx
- ✅ ~100ms delay between attempts

**Note:** In production you may want exponential backoff (`RETRY_DELAY_MS * 2 ** (attempt - 1)`) instead of a fixed 100ms, and to avoid retrying non-idempotent requests — but for `GET /users/:id` this is safe as-is.

Following TDD: test first, watch it fail, then implement.

## RED — Failing test

```javascript
// fetchUser.test.js
import { fetchUser } from './fetchUser';

// Minimal fake fetch: rejects or returns responses per script
function mockFetch(script) {
  let calls = 0;
  global.fetch = jest.fn(() => {
    const step = script[Math.min(calls, script.length - 1)];
    calls++;
    return typeof step === 'number'
      ? Promise.resolve({ ok: false, status: step })
      : step instanceof Error
        ? Promise.reject(step)
        : Promise.resolve({ ok: true, status: 200, json: () => Promise.resolve(step) });
  });
  return () => calls;
}

const delay = (ms) => new Promise((r) => setTimeout(r, ms));

describe('fetchUser retry', () => {
  beforeEach(() => jest.useFakeTimers());

  it('retries on network error and succeeds on 3rd attempt', async () => {
    const getCalls = mockFetch([new Error('offline'), new Error('offline'), { id: 1 }]);
    const p = fetchUser(1);
    await delay(0); await jest.runAllTimersAsync();
    const user = await p;
    expect(user).toEqual({ id: 1 });
    expect(getCalls()).toBe(3);
  });

  it('retries on 5xx but not on 4xx', async () => {
    const getCalls = mockFetch([500, 503, { ok: true }]);
    const p = fetchUser(1);
    await delay(0); await jest.runAllTimersAsync();
    expect(await p).toEqual({ ok: true });
    expect(getCalls()).toBe(3);

    const getCalls2 = mockFetch([404]);
    await expect(fetchUser(1)).rejects.toThrow('API error');
    expect(getCalls2()).toBe(1);
  });

  it('gives up after 3 retries (4 total attempts)', async () => {
    const getCalls = mockFetch([500, 500, 500, 500]);
    const p = fetchUser(1);
    await delay(0); await jest.runAllTimersAsync();
    await expect(p).rejects.toThrow('API error');
    expect(getCalls()).toBe(4);
  });
});
```

**Verify RED:** `npx jest fetchUser.test.js` fails — current `fetchUser` makes exactly 1 call and throws immediately on the first network error/500. Failure messages confirm the retry feature is missing (e.g., `expected calls to be 3, got 1`).

## GREEN — Minimal implementation

```javascript
// fetchUser.js
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

async function fetchUser(id) {
  for (let attempt = 0; ; attempt++) {
    let res;
    try {
      res = await fetch(`/users/${id}`);
    } catch (err) {
      if (attempt === 3) throw err;
      await sleep(100);
      continue;
    }
    if (res.ok) return res.json();
    if (res.status < 500 || attempt === 3) throw new Error('API error');
    await sleep(100);
  }
}

module.exports = { fetchUser };
```

**Verify GREEN:** all three tests pass — 3 calls on transient failures, no retry on 404, 4 total attempts then throw when the server keeps 500ing. Run the full suite (`npx jest`) to confirm nothing else regressed.

## Notes

- "Retry up to 3 times" = up to 4 total attempts; adjust the `attempt === 3` checks if you meant 3 total.
- Delay is a flat 100ms; if you later want exponential backoff, add a new failing test first.
- Tests use fake timers so the suite runs instantly despite the delays.

## Failing Tests (written first)

```javascript
// calculateTotal.test.js
const calculateTotal = require('./calculateTotal');

describe('calculateTotal', () => {
  test('applies 10% discount when total is exactly $100', () => {
    const cart = { items: [{ name: 'A', price: 60, type: 'standard' }, { name: 'B', price: 40, type: 'standard' }] };
    expect(calculateTotal(cart)).toBe(90); // FAILS with old code (returns 100)
  });

  test('applies 10% discount when total is above $100', () => {
    const cart = { items: [{ name: 'A', price: 150, type: 'standard' }] };
    expect(calculateTotal(cart)).toBe(135);
  });

  test('does NOT apply discount below $100', () => {
    const cart = { items: [{ name: 'A', price: 99.99, type: 'standard' }] };
    expect(calculateTotal(cart)).toBe(99.99);
  });

  test('gift card items are excluded from the discount threshold', () => {
    // $60 standard + $50 gift card = $110 total, but only $60 is discountable
    const cart = { items: [
      { name: 'Widget', price: 60, type: 'standard' },
      { name: 'Gift Card', price: 50, type: 'giftcard' },
    ]};
    expect(calculateTotal(cart)).toBe(114); // 60*0.9 + 50 = 104... see note below
  });

  test('gift card items never receive the discount', () => {
    const cart = { items: [{ name: 'Gift Card', price: 200, type: 'giftcard' }] };
    expect(calculateTotal(cart)).toBe(200); // FAILS with old code (returns 180)
  });

  test('empty cart returns 0', () => {
    expect(calculateTotal({ items: [] })).toBe(0);
  });
});
```

*(Note: in the threshold test above, the correct expected value is `104` — $60 × 0.9 + $50 — since only the standard items count toward the $100 threshold and receive the discount.)*

## Fixed Implementation

```javascript
// calculateTotal.js
function calculateTotal(cart) {
  const discountable = cart.items.filter(item => item.type !== 'giftcard');

  const discountableTotal = discountable.reduce((sum, item) => sum + item.price, 0);
  const giftCardTotal = cart.items
    .filter(item => item.type === 'giftcard')
    .reduce((sum, item) => sum + item.price, 0);

  let total = discountableTotal + giftCardTotal;

  // Discount applies when discountable total is AT LEAST $100,
  // and only to the discountable items.
  if (discountableTotal >= 100) {
    total = discountableTotal * 0.9 + giftCardTotal;
  }

  return total;
}

module.exports = calculateTotal;
```

**Key changes:**
1. `total > 100` → `discountableTotal >= 100` (at-least threshold).
2. Gift cards are split out: they count toward the returned total but neither trigger the discount nor receive it.

Running the tests against the original code fails the first, fourth, and fifth tests; against the fixed code, all pass.

Following TDD — tests first, then the fix.

## RED: Failing tests

```javascript
// calculateTotal.test.js
const calculateTotal = require('./calculateTotal');

describe('calculateTotal', () => {
  test('applies 10% discount when total is exactly $100', () => {
    const cart = { items: [{ name: 'A', price: 60, type: 'regular' }, { name: 'B', price: 40, type: 'regular' }] };
    expect(calculateTotal(cart)).toBe(90);
  });

  test('applies 10% discount when total is over $100', () => {
    const cart = { items: [{ name: 'A', price: 120, type: 'regular' }] };
    expect(calculateTotal(cart)).toBe(108);
  });

  test('no discount when total is under $100', () => {
    const cart = { items: [{ name: 'A', price: 99.99, type: 'regular' }] };
    expect(calculateTotal(cart)).toBeCloseTo(99.99);
  });

  test('excludes gift card items from the discount threshold', () => {
    // $90 regular + $20 gift card = $110 total, but only $90 counts toward threshold
    const cart = { items: [
      { name: 'A', price: 90, type: 'regular' },
      { name: 'GC', price: 20, type: 'giftcard' },
    ] };
    expect(calculateTotal(cart)).toBe(110); // no discount: regular total is 90 < 100
  });

  test('never discounts gift card items even when regular total qualifies', () => {
    const cart = { items: [
      { name: 'A', price: 100, type: 'regular' },
      { name: 'GC', price: 50, type: 'giftcard' },
    ] };
    // regular: 100 * 0.9 = 90, gift card: 50 full price
    expect(calculateTotal(cart)).toBe(140);
  });

  test('handles cart with only gift cards', () => {
    const cart = { items: [{ name: 'GC', price: 200, type: 'giftcard' }] };
    expect(calculateTotal(cart)).toBe(200);
  });
});
```

Running these against the current code, the first, fourth, and fifth tests fail — confirming they target the two bugs (strict `>` threshold, gift cards included in discount).

## GREEN: Minimal fix

```javascript
// calculateTotal.js
function calculateTotal(cart) {
  const regularTotal = cart.items
    .filter(item => item.type !== 'giftcard')
    .reduce((sum, item) => sum + item.price, 0);

  const giftCardTotal = cart.items
    .filter(item => item.type === 'giftcard')
    .reduce((sum, item) => sum + item.price, 0);

  const discounted = regularTotal >= 100 ? regularTotal * 0.9 : regularTotal;
  return discounted + giftCardTotal;
}

module.exports = calculateTotal;
```

## Verify

All six tests pass:
- Exactly $100 → discounted (threshold is now `>=`) ✅
- Over $100 → discounted ✅
- Under $100 → no discount ✅
- Gift cards excluded from threshold ✅
- Gift cards never discounted ✅
- Gift-card-only cart → full price ✅

One note: the fix changes behavior for carts where gift cards previously pushed the total over $100 — those now correctly get no discount, which is what the spec requires.

**Failing test first** (`test_discount.py`):

```python
from discount import discount

def test_discount_at_exactly_100():
    assert discount(100) == 90  # fails: current code returns 100
```

Run it — it fails because `100 > 100` is `False`.

**Fix** (`discount.py`):

```python
def discount(total):
    return total * 0.9 if total >= 100 else total
```

Now the test passes, and boundary cases are covered:

```python
def test_discount_above_100():
    assert discount(150) == 135

def test_no_discount_below_100():
    assert discount(99.99) == 99.99
```

**RED — failing test first** (`test_discount.py`):

```python
from discount import discount

def test_discount_applies_at_exactly_100():
    assert discount(100) == 90.0

def test_discount_applies_above_100():
    assert discount(150) == 135.0

def test_no_discount_below_100():
    assert discount(99.99) == 99.99
```

**Verify RED:**

```
$ pytest test_discount.py
FAILED test_discount.py::test_discount_applies_at_exactly_100
    assert 100 == 90.0
```

Fails for the expected reason: `discount(100)` returns 100 because the condition uses `>` instead of `>=`.

**GREEN — minimal fix** (`discount.py`):

```python
def discount(total):
    return total * 0.9 if total >= 100 else total
```

**Verify GREEN:**

```
$ pytest test_discount.py
...
3 passed
```

The one-character change (`>` → `>=`) makes the discount apply at exactly $100, and the other tests confirm behavior above and below the threshold is unchanged.