Test Coverage Boost - From Zero to Hero Testing

🎯 When to Use This Skill

Use when you need to:

• Add tests to untested code

• Increase coverage for CI/CD requirements

• Prepare for major refactoring

• Meet team coverage goals (usually 70-80%)

• Fix flaky or broken tests

• Implement TDD practices

⚡ Quick Coverage Check

Check Current Coverage:

JavaScript (Jest/Vitest)

npm test -- --coverage

Python

pytest --cov=. --cov-report=html

Go

go test -cover ./...

Java

mvn clean test jacoco:report

Ruby

bundle exec rspec --coverage

.NET

dotnet test /p:CollectCoverage=true

📊 The Coverage Ladder (0% → 80%)

Level 0: No Tests (0% coverage)

Level 1: Critical Path (20% coverage)

Level 2: Happy Path (40% coverage)

Level 3: Edge Cases (60% coverage)

Level 4: Error Handling (80% coverage)

Level 5: Full Coverage (95%+)

🎯 Strategic Test Writing (80/20 Rule)

WITH MCP (Test Generator):

"Generate tests for the most critical untested functions" "Create tests to reach 80% coverage for [module]"

WITHOUT MCP - Priority Order:

1. Test Business Critical Code First (20% effort → 80% value)

// Priority 1: Money/Payment handling test('calculateTotal should handle discounts correctly', () => { expect(calculateTotal(100, 0.2)).toBe(80); // 20% discount expect(calculateTotal(100, 0)).toBe(100); // No discount expect(calculateTotal(100, 1)).toBe(0); // 100% discount });

// Priority 2: Authentication/Authorization test('user should not access admin functions', () => { const user = { role: 'user' }; expect(() => adminFunction(user)).toThrow('Unauthorized'); });

// Priority 3: Data validation test('email validator should reject invalid emails', () => { expect(validateEmail('notanemail')).toBe(false); expect(validateEmail('test@example.com')).toBe(true); });

2. The Test Writing Formula

// Universal Test Structure (AAA Pattern) test('should [expected behavior] when [condition]', () => { // Arrange - Set up test data const input = { /* test data / }; const expected = { / expected result */ };

// Act - Execute the function const result = functionUnderTest(input);

// Assert - Verify the result expect(result).toEqual(expected); });

📝 Test Patterns by Code Type

1. Pure Functions (Easiest to Test)

// Function to test function addTax(price, taxRate) { return price * (1 + taxRate); }

// Tests describe('addTax', () => { test('should add tax correctly', () => { expect(addTax(100, 0.1)).toBe(110); });

test('should handle zero tax', () => { expect(addTax(100, 0)).toBe(100); });

test('should handle negative price', () => { expect(addTax(-100, 0.1)).toBe(-110); }); });

2. Async Functions

// Function to test async function fetchUser(id) { const response = await api.get(/users/${id}); return response.data; }

// Tests describe('fetchUser', () => { test('should fetch user successfully', async () => { // Mock the API api.get = jest.fn().mockResolvedValue({ data: { id: 1, name: 'John' }, });

const user = await fetchUser(1);
expect(user.name).toBe('John');

});

test('should handle API errors', async () => { api.get = jest.fn().mockRejectedValue(new Error('Network error'));

await expect(fetchUser(1)).rejects.toThrow('Network error');

}); });

3. Classes/Objects

// Class to test class ShoppingCart { constructor() { this.items = []; }

addItem(item) { this.items.push(item); }

getTotal() { return this.items.reduce((sum, item) => sum + item.price, 0); } }

// Tests describe('ShoppingCart', () => { let cart;

beforeEach(() => { cart = new ShoppingCart(); });

test('should start empty', () => { expect(cart.items).toHaveLength(0); });

test('should add items', () => { cart.addItem({ name: 'Book', price: 10 }); expect(cart.items).toHaveLength(1); });

test('should calculate total', () => { cart.addItem({ name: 'Book', price: 10 }); cart.addItem({ name: 'Pen', price: 2 }); expect(cart.getTotal()).toBe(12); }); });

4. API Endpoints

// Express endpoint app.get('/api/users/:id', async (req, res) => { const user = await User.findById(req.params.id); if (!user) return res.status(404).json({ error: 'Not found' }); res.json(user); });

// Tests describe('GET /api/users/:id', () => { test('should return user when exists', async () => { const response = await request(app).get('/api/users/1').expect(200);

expect(response.body).toHaveProperty('id', 1);

});

test('should return 404 when user not found', async () => { const response = await request(app).get('/api/users/999').expect(404);

expect(response.body.error).toBe('Not found');

}); });

🚀 Rapid Coverage Improvement Strategy

Day 1: Foundation (0% → 20%)

1. Setup test infrastructure

npm install --save-dev jest @types/jest

2. Create test script

package.json

"scripts": { "test": "jest", "test:coverage": "jest --coverage", "test:watch": "jest --watch" }

3. Write first test for main function

echo "describe('app', () => { test('should start', () => { expect(true).toBe(true); }); });" > app.test.js

Day 2: Critical Paths (20% → 40%)

// Test the money flow test('payment processing flow', async () => { // Test the entire payment pipeline });

// Test user authentication test('login flow', async () => { // Test login process end-to-end });

Day 3: Happy Paths (40% → 60%)

// Test successful scenarios test('user can create account', () => {}); test('user can update profile', () => {}); test('user can delete account', () => {});

Day 4: Edge Cases (60% → 70%)

// Test boundaries and limits test('handles maximum input size', () => {}); test('handles empty input', () => {}); test('handles special characters', () => {});

Day 5: Error Cases (70% → 80%)

// Test error handling test('handles network timeout', () => {}); test('handles invalid data', () => {}); test('handles concurrent access', () => {});

🎯 Coverage Improvement Techniques

1. Find Untested Code

Generate coverage report

npm test -- --coverage

Open HTML report

open coverage/index.html # Mac xdg-open coverage/index.html # Linux start coverage/index.html # Windows

Red lines = untested code

2. Test the Untestable

Mocking External Dependencies:

// Mock database jest.mock('./database', () => ({ query: jest.fn(), connect: jest.fn(), }));

// Mock file system jest.mock('fs', () => ({ readFile: jest.fn((path, callback) => { callback(null, 'mock file content'); }), }));

// Mock HTTP requests jest.mock('axios'); axios.get.mockResolvedValue({ data: 'test' });

Testing Private Methods:

// Option 1: Test through public interface class Calculator { #privateMethod() { return 42; } publicMethod() { return this.#privateMethod(); } }

test('private method via public', () => { const calc = new Calculator(); expect(calc.publicMethod()).toBe(42); });

// Option 2: Extract to separate testable function function complexLogic(input) { /* ... */ } export { complexLogic }; // Test directly

3. Parameterized Tests (Test Multiple Cases)

// Jest test.each([ [1, 1, 2], [1, 2, 3], [2, 2, 4], ])('add(%i, %i) = %i', (a, b, expected) => { expect(add(a, b)).toBe(expected); });

// Python pytest @pytest.mark.parametrize("input,expected", [ (1, 2), (2, 4), (3, 6), ]) def test_double(input, expected): assert double(input) == expected

📊 Coverage Goals by Project Type

Web Application

• Controllers/Routes: 90%+ (critical paths)

• Business Logic: 85%+ (core features)

• Utilities: 95%+ (pure functions)

• UI Components: 70%+ (focus on logic)

• Database Models: 80%+ (validations)

API Service

• Endpoints: 95%+ (all routes)

• Middleware: 90%+ (auth, validation)

• Services: 85%+ (business logic)

• Error Handlers: 100% (critical)

Library/Package

• Public API: 100% (all exports)

• Core Logic: 95%+ (main features)

• Edge Cases: 90%+ (robustness)

• Examples: 100% (documentation)

💡 Pro Tips

Speed Up Test Writing:

Generate test boilerplate

VS Code: Install "Jest Snippets" extension

Type: "desc" → describe block

Type: "test" → test block

Type: "exp" → expect statement

Test Data Builders:

// Create reusable test data class UserBuilder { constructor() { this.user = { id: 1, name: 'Test User', email: 'test@example.com', }; }

withName(name) { this.user.name = name; return this; }

withEmail(email) { this.user.email = email; return this; }

build() { return this.user; } }

// Usage const user = new UserBuilder().withName('John').withEmail('john@example.com').build();

Coverage Exclusions:

// Istanbul ignore comments /* istanbul ignore next / // Ignore next line / istanbul ignore if / // Ignore if block / istanbul ignore else */ // Ignore else block

// Jest coverage config // package.json "jest": { "coveragePathIgnorePatterns": [ "node_modules", "test-fixtures", ".mock.js" ], "coverageThreshold": { "global": { "branches": 80, "functions": 80, "lines": 80, "statements": 80 } } }

🎯 Success Checklist

Your tests are good when:

• ✅ Coverage > 80%

• ✅ Tests run fast (< 1 minute)

• ✅ Tests are deterministic (no flakiness)

• ✅ Tests are readable (clear descriptions)

• ✅ Tests catch real bugs

• ✅ CI/CD pipeline includes tests

• ✅ Team writes tests for new features

Remember: 80% coverage with good tests > 100% coverage with bad tests! 🎯