ERROR: Model requirement not met
Required: Claude Sonnet 4.5, Claude Opus 4.5, Gemini 3.0 Pro or higher, or similars
Current: [your model]
Action: Cannot proceed. Orchestrator must reinvoke with model="opus"

// ❌ BAD: Test only verifies mock was called, not actual behavior
test("should process order", () => {
  const mockDB = jest.fn();
  processOrder(order, mockDB);
  expect(mockDB).toHaveBeenCalled(); // Only tests mock!
});

// ✅ GOOD: Test verifies actual business outcome
test("should process order", () => {
  const result = processOrder(validOrder);
  expect(result.status).toBe("processed");
  expect(result.total).toBe(100);
});

// ❌ BAD: No meaningful assertion
test("should work", async () => {
  await processData(data); // No assertion!
});

// ❌ BAD: Weak assertion
test("should return result", () => {
  const result = calculate(5);
  expect(result).toBeDefined(); // Doesn't verify correctness!
});

// ✅ GOOD: Specific assertion
test("should calculate discount", () => {
  const result = calculateDiscount(100, 0.1);
  expect(result).toBe(90);
});

// ❌ BAD: Tests depend on shared state
let sharedUser;
test("should create user", () => {
  sharedUser = createUser();
});
test("should update user", () => {
  updateUser(sharedUser); // Fails if run alone!
});

// ✅ GOOD: Each test is independent
test("should update user", () => {
  const user = createUser(); // Own setup
  const updated = updateUser(user);
  expect(updated.name).toBe("new name");
});

// ❌ BAD: Tests internal state/method calls
test("should use cache", () => {
  service.getData();
  expect(service._cache.size).toBe(1); // Implementation detail!
});

// ✅ GOOD: Tests observable behavior
test("should return cached data faster", () => {
  service.getData(); // Prime cache
  const start = Date.now();
  service.getData();
  expect(Date.now() - start).toBeLessThan(10);
});

// ❌ BAD: Depends on timing
test("should expire", async () => {
  await sleep(1000);
  expect(token.isExpired()).toBe(true);
});

// ✅ GOOD: Control time explicitly
test("should expire", () => {
  jest.useFakeTimers();
  jest.advanceTimersByTime(TOKEN_EXPIRY + 1);
  expect(token.isExpired()).toBe(true);
});

// ❌ BAD: Tests too many things
test('should handle everything', () => {
  // 50 lines testing 10 different behaviors
});

// ✅ GOOD: One behavior per test
test('should reject invalid email', () => { ... });
test('should accept valid email', () => { ... });
test('should hash password', () => { ... });

// ❌ BAD: Error silently ignored - test may pass when helper fails
func TestSomething(t *testing.T) {
    data, _ := json.Marshal(input) // Silent failure!
    result := process(string(data))
    assert.NotNil(t, result)
}

// ✅ GOOD: Error propagated
func TestSomething(t *testing.T) {
    data, err := json.Marshal(input)
    require.NoError(t, err)
    result := process(string(data))
    assert.NotNil(t, result)
}

// ❌ BAD: Empty catch hides failures
test("should process", async () => {
  await setupData().catch(() => {}); // Silent!
  const result = await process();
  expect(result).toBeDefined();
});

// ✅ GOOD: Errors surface
test("should process", async () => {
  await setupData(); // Fails test if setup fails
  const result = await process();
  expect(result).toBeDefined();
});

// ❌ BAD: "Success" prefix on failure test
test('Success - should return error for invalid input', () => {
  expect(() => process(null)).toThrow();
});

// ✅ GOOD: Name matches behavior
test('should throw error for null input', () => {
  expect(() => process(null)).toThrow();
});

// ❌ BAD: Vague names
test('test1', () => { ... });
test('should work', () => { ... });

// ✅ GOOD: Describes expected behavior
test('should calculate 10% discount on orders over $100', () => { ... });

// ❌ BAD: Testing Go's nil map behavior, not application logic
func TestNilMapLookup(t *testing.T) {
    var m map[string]int
    _, ok := m["key"]
    assert.False(t, ok)  // This is Go language behavior!
}

// ❌ BAD: Testing Go's append behavior
func TestAppendToNil(t *testing.T) {
    var slice []int
    slice = append(slice, 1)
    assert.Len(t, slice, 1)
}

// ✅ GOOD: Test application behavior
func TestCacheGetMissReturnsDefault(t *testing.T) {
    cache := NewCache()
    val := cache.Get("missing")
    assert.Equal(t, defaultValue, val)
}

# Test Quality Review

## VERDICT: [PASS | FAIL | NEEDS_DISCUSSION]

## Summary

[2-3 sentences about test quality]

## Issues Found

- Critical: [N]
- High: [N]
- Medium: [N]
- Low: [N]

## Test Coverage Analysis

### By Test Type

| Type        | Count | Coverage             |
| ----------- | ----- | -------------------- |
| Unit        | [N]   | [Functions covered]  |
| Integration | [N]   | [Boundaries covered] |
| E2E         | [N]   | [Flows covered]      |

### Critical Paths Tested

- ✅ [Path 1]
- ❌ [Path 2 - MISSING]

### Functions Without Tests

- `functionName()` at file.ts:123 - **CRITICAL** (business logic)
- `helperFn()` at file.ts:200 - **LOW** (utility)

## Edge Cases Not Tested

| Edge Case      | Affected Function | Severity | Recommended Test                   |
| -------------- | ----------------- | -------- | ---------------------------------- |
| Empty input    | `processData()`   | HIGH     | `test('handles empty array')`      |
| Negative value | `calculate()`     | HIGH     | `test('handles negative numbers')` |
| Null user      | `updateProfile()` | CRITICAL | `test('throws on null user')`      |

## Test Anti-Patterns

**IMPORTANT NOTE:** The examples below are for demonstration purposes only. They show what NOT to do and how to fix it in JavaScript. Do not use these patterns into account for other programming languages as security measures may vary. Also take the programming language and framework into account when taking security measurements in consideration.

### [Anti-Pattern Name]

**Location:** `test-file.spec.ts:45-60`
**Pattern:** Testing mock behavior
**Problem:** Test only verifies mock was called, not business outcome
**Example:**

```javascript
// Current problematic test
expect(mockService).toHaveBeenCalled();
```

**Recommendation:**

```javascript
// Fixed test
expect(result.status).toBe("processed");
```

## What Was Done Well

- ✅ [Good testing practice observed]
- ✅ [Comprehensive coverage of X]

## Next Steps

[Based on verdict]

---

## Recommended Test Additions Template

**IMPORTANT NOTE:** The examples below are for demonstration purposes only. They show what NOT to do and how to fix it in JavaScript. Do not use these patterns into account for other programming languages as security measures may vary. Also take the programming language and framework into account when taking security measurements in consideration.

When identifying missing tests, provide concrete recommendations:

```javascript
// Missing test: Edge case - empty input
test("should handle empty array", () => {
  const result = processData([]);
  expect(result).toEqual([]);
});

// Missing test: Error path
test("should throw on invalid input", () => {
  expect(() => processData(null)).toThrow("Input required");
});

// Missing test: Boundary condition
test("should handle maximum value", () => {
  const result = calculate(Number.MAX_SAFE_INTEGER);
  expect(result).toBeLessThanOrEqual(MAX_RESULT);
});
```