Clean Code Principles

Writing clean, testable code is essential for maintainable systems.

Meaningful Names

// Bad
const d = new Date();
const x = users.filter(u => u.a > 18);

// Good
const currentDate = new Date();
const adultUsers = users.filter(user => user.age > 18);

// Bad function name
function process(data: any): any { ... }

// Good function name
function calculateOrderTotal(orderItems: OrderItem[]): number { ... }

Small, Focused Functions

// Bad: Function does too much
function processOrder(order: Order): void {
  // Validate order
  if (!order.items.length) throw new Error('Empty order');
  if (!order.customerId) throw new Error('No customer');

  // Calculate total
  let total = 0;
  for (const item of order.items) {
    total += item.price * item.quantity;
  }

  // Apply discount
  if (order.couponCode) {
    const discount = getCouponDiscount(order.couponCode);
    total = total * (1 - discount);
  }

  // Process payment
  chargeCustomer(order.customerId, total);

  // Send email
  sendOrderConfirmation(order.customerId, order.id);

  // Update inventory
  for (const item of order.items) {
    decrementInventory(item.productId, item.quantity);
  }
}

// Good: Single responsibility per function
class OrderService {
  constructor(
    private validator: OrderValidator,
    private calculator: PriceCalculator,
    private paymentService: PaymentService,
    private notificationService: NotificationService,
    private inventoryService: InventoryService
  ) {}

  async processOrder(order: Order): Promise {
    this.validator.validate(order);
    const total = this.calculator.calculateTotal(order);
    await this.paymentService.charge(order.customerId, total);
    await this.notificationService.sendConfirmation(order);
    await this.inventoryService.decrementStock(order.items);

    return { ...order, total, status: 'processed' };
  }
}

Unit Testing with Mocks

// Interface for dependency
interface UserRepository {
  findById(id: string): Promise;
  save(user: User): Promise;
}

// Service to test
class UserService {
  constructor(private userRepo: UserRepository) {}

  async updateEmail(userId: string, newEmail: string): Promise {
    const user = await this.userRepo.findById(userId);
    if (!user) throw new Error('User not found');

    user.email = newEmail;
    return this.userRepo.save(user);
  }
}

// Test with mock
describe('UserService', () => {
  let userService: UserService;
  let mockUserRepo: jest.Mocked;

  beforeEach(() => {
    mockUserRepo = {
      findById: jest.fn(),
      save: jest.fn()
    };
    userService = new UserService(mockUserRepo);
  });

  describe('updateEmail', () => {
    it('should update user email successfully', async () => {
      const existingUser = { id: '1', email: 'old@test.com', name: 'Test' };
      const updatedUser = { ...existingUser, email: 'new@test.com' };

      mockUserRepo.findById.mockResolvedValue(existingUser);
      mockUserRepo.save.mockResolvedValue(updatedUser);

      const result = await userService.updateEmail('1', 'new@test.com');

      expect(mockUserRepo.findById).toHaveBeenCalledWith('1');
      expect(mockUserRepo.save).toHaveBeenCalledWith(
        expect.objectContaining({ email: 'new@test.com' })
      );
      expect(result.email).toBe('new@test.com');
    });

    it('should throw error if user not found', async () => {
      mockUserRepo.findById.mockResolvedValue(null);

      await expect(
        userService.updateEmail('999', 'new@test.com')
      ).rejects.toThrow('User not found');
    });
  });
});

Integration Testing

describe('OrderService Integration', () => {
  let orderService: OrderService;
  let testDb: TestDatabase;

  beforeAll(async () => {
    testDb = await TestDatabase.create();
    orderService = new OrderService(
      new OrderRepository(testDb),
      new PaymentService(new MockPaymentGateway()),
      new InventoryService(testDb)
    );
  });

  afterAll(async () => {
    await testDb.cleanup();
  });

  beforeEach(async () => {
    await testDb.seed({
      products: [
        { id: 'P1', name: 'Widget', price: 10, stock: 100 }
      ],
      customers: [
        { id: 'C1', name: 'Test Customer', balance: 1000 }
      ]
    });
  });

  it('should process complete order flow', async () => {
    const order = {
      customerId: 'C1',
      items: [{ productId: 'P1', quantity: 5 }]
    };

    const result = await orderService.processOrder(order);

    expect(result.status).toBe('processed');
    expect(result.total).toBe(50);

    // Verify side effects
    const product = await testDb.findProduct('P1');
    expect(product.stock).toBe(95);
  });
});

Clean Code & Testing

Clean Code & Testing

Clean Code Principles

Meaningful Names

Small, Focused Functions

Unit Testing with Mocks

Integration Testing