Adding Tests

// Function to test
function add(a, b) {
    return a + b;
}
 
// Unit test
describe('add', () => {
    it('should add two positive numbers', () => {
        expect(add(2, 3)).toBe(5);
    });
    
    it('should handle negative numbers', () => {
        expect(add(-1, 1)).toBe(0);
    });
    
    it('should handle zero', () => {
        expect(add(0, 5)).toBe(5);
    });
});

// Integration test
describe('UserService', () => {
    it('should create user and send welcome email', async () => {
        const user = await UserService.create({
            email: 'test@example.com',
            name: 'Test User'
        });
        
        expect(user.id).toBeDefined();
        expect(EmailService.sent).toContain('test@example.com');
    });
});

// E2E test
describe('Login Flow', () => {
    it('should allow user to log in', async () => {
        await page.goto('/login');
        await page.fill('#email', 'user@example.com');
        await page.fill('#password', 'password123');
        await page.click('#submit');
        
        await expect(page).toHaveURL('/dashboard');
        await expect(page.locator('.welcome')).toContainText('Welcome');
    });
});

# Check package.json for test script
cat package.json | grep -A5 '"scripts"'
 
# Common test commands
npm test
npm run test
yarn test
pytest
go test ./...
cargo test

it('should calculate discount for premium users', () => {
    // Arrange: Set up test data
    const user = { isPremium: true, yearsActive: 3 };
    
    // Act: Call the function
    const discount = calculateDiscount(user);
    
    // Assert: Check the result
    expect(discount).toBe(0.2);
});

// ❌ Bad names
it('test1', () => {});
it('works', () => {});
it('discount', () => {});
 
// ✅ Good names
it('should return 0 discount for non-premium users', () => {});
it('should throw error when user is null', () => {});
it('should apply 20% discount for premium users with 2+ years', () => {});

describe('formatPrice', () => {
    // Happy path
    it('should format positive price with currency', () => {
        expect(formatPrice(9.99, 'USD')).toBe('$9.99');
    });
    
    // Edge cases
    it('should handle zero price', () => {
        expect(formatPrice(0, 'USD')).toBe('$0.00');
    });
    
    it('should round to 2 decimal places', () => {
        expect(formatPrice(9.999, 'USD')).toBe('$10.00');
    });
    
    // Error cases
    it('should throw for negative price', () => {
        expect(() => formatPrice(-5, 'USD')).toThrow('Price cannot be negative');
    });
    
    it('should throw for invalid currency', () => {
        expect(() => formatPrice(10, 'INVALID')).toThrow('Unknown currency');
    });
    
    // Boundary cases
    it('should handle very large numbers', () => {
        expect(formatPrice(999999999.99, 'USD')).toBe('$999,999,999.99');
    });
});

// 1. First, write test that exposes the bug
it('should handle special characters in password', () => {
    const result = login('user@example.com', 'Pass#123!');
    expect(result.success).toBe(true);
});
 
// 2. Run test - it fails (proving bug exists)
// 3. Fix the code
// 4. Run test - it passes (proving bug is fixed)
// 5. The test prevents regression forever

# Mirror source structure
src/
  utils/
    format.js
  services/
    userService.js
tests/
  utils/
    format.test.js
  services/
    userService.test.js

# Or co-located
src/
  utils/
    format.js
    format.test.js

# Run all tests
npm test
 
# Run specific test file
npm test -- format.test.js
 
# Run tests matching pattern
npm test -- --grep "discount"
 
# Run with coverage
npm test -- --coverage

# Generate coverage report
npm test -- --coverage
 
# Output example
----------|---------|----------|---------|---------|
File      | % Stmts | % Branch | % Funcs | % Lines |
----------|---------|----------|---------|---------|
All files |   85.5  |    72.3  |   90.0  |   85.5  |
 utils.js |   100   |    100   |   100   |   100   |
 auth.js  |    75   |     50   |    80   |    75   |
----------|---------|----------|---------|---------|

// Mock external service
jest.mock('../services/emailService', () => ({
    sendEmail: jest.fn().mockResolvedValue(true)
}));
 
it('should send welcome email on signup', async () => {
    await userService.signup({ email: 'test@example.com' });
    
    expect(emailService.sendEmail).toHaveBeenCalledWith(
        'test@example.com',
        'Welcome!',
        expect.any(String)
    );
});

// Async/await
it('should fetch user data', async () => {
    const user = await userService.getUser(123);
    expect(user.name).toBe('John');
});
 
// Promises
it('should reject for invalid user', () => {
    return expect(userService.getUser(-1)).rejects.toThrow('Invalid ID');
});

it('should throw for null input', () => {
    expect(() => processData(null)).toThrow('Data cannot be null');
});
 
it('should return error result for invalid data', async () => {
    const result = await processData({ invalid: true });
    expect(result.success).toBe(false);
    expect(result.error).toContain('validation failed');
});

// Start with critical paths
describe('AuthService', () => {
    it('should allow login with valid credentials', async () => {
        // Test core functionality
    });
    
    it('should reject invalid password', async () => {
        // Test security case
    });
});

## Proposal: Add Testing Infrastructure
 
I noticed the project doesn't have tests yet. I'd like to help add them.
 
**Proposed approach:**
1. Add Jest/pytest/etc. with basic configuration
2. Start with tests for core functionality
3. Add tests incrementally with new PRs
 
**Benefits:**
- Catch regressions early
- Easier onboarding for contributors
- More confident refactoring
 
Would maintainers be open to this? Happy to start small.

describe('[Component/Function Name]', () => {
    // Setup (if needed)
    beforeEach(() => {
        // Reset state
    });
    
    describe('[method or scenario]', () => {
        it('should [expected behavior] when [condition]', () => {
            // Arrange
            // Act
            // Assert
        });
    });
});