tdd

TDD loop

Opt-in only. When invoked, you do not write implementation code until a test fails for the right reason.

The loop

1. Name the behaviour. One sentence, declarative, third person, no "should":

returns enabled when no state has been persisted

If you can't phrase it that way, the behaviour isn't defined yet. Go ask.

2. Write the failing test. Colocated <name>.test.ts(x) beside the source. Match the house style:

describe('SignificantEventsMaintenanceService', () => {
  describe('getState', () => {
    it('returns enabled when no state has been persisted', async () => {
      const service = makeService();
      await expect(service.getState()).resolves.toBe('enabled');
    });
  });
});

3. Run it and read the failure. This is the step people skip.

# use your project's test runner, e.g.:
npx jest <path/to/file.test.ts>

The test must fail because the behaviour is missing, not because of a typo, a bad import, or a mock that throws. A test that fails for the wrong reason proves nothing. If the error isn't the one you predicted, fix the test before touching the implementation.

4. Implement the minimum that makes it pass. No speculative extras.

5. Run again. Green, and no other test broke.

6. Refactor. Now, with the test as the safety net. Prefer deleting over abstracting.

Repeat per behaviour. Do not batch five tests then implement; the loop's value is in the failure you read at step 3.

Testing style

Follow marco-code-style for the full picture. The parts that matter most here:

• Hand-rolled stateful mock factories for services. Build a fake that round-trips: a Map-backed saved-objects client that throws NotFound until create, a management API that tracks enabled so pause→resume actually works. JSDoc each option. jest.mock is for module-mocking your own hooks in component tests, and nothing else.
• renderHook/act for hooks, render/screen for components.
• Full variable names here too: rulesClient, not rc.
• Assert concrete values, not snapshots. expect.objectContaining where partial matching is honest.
• Async via .rejects/.resolves: await expect(fn()).rejects.toMatchObject({ statusCode: 409 }).
• Negative assertions pin the contract: expect(service.getStatus).not.toHaveBeenCalled() proves the guard took the cheap path.
• Shared fixtures as SCREAMING_SNAKE consts: const REQUEST = {} as Request.
• Fakes cast at the seam with as unknown as T.