Part 4: Testing During Refactoring

Series Navigation: ← Part 3: Refactoring Techniques | Part 5: Automated Tools and CI/CD Integration →

Introduction

In Part 3, we covered refactoring techniques. But here's the truth I learned the hard way: refactoring without tests is just changing code and hoping for the best. Early in my career, I "improved" a critical payment service without proper tests. It looked better, passed my manual testing, and broke production in subtle ways that took days to diagnose.

Now, whenever I refactor code in my TypeScript microservices, I follow a strict test-first approach. Tests aren't just nice to have—they're the safety net that makes confident refactoring possible. In this part, I'll share the testing strategies that have saved me countless times.

The Testing Pyramid

In my microservices, I follow this distribution:

• 70% Unit Tests: Fast, isolated, test individual functions/classes

• 20% Integration Tests: Test component interactions

• 10% E2E Tests: Test complete user flows

This ratio keeps our test suite fast (under 2 minutes for 1,500+ tests) while maintaining confidence in the system.

Step 1: Add Characterization Tests

What Are Characterization Tests?

When refactoring legacy code without tests, start by documenting current behavior—even if it's wrong. These tests capture "what the code does" not "what it should do."

Real Example: Legacy Order Calculator

I inherited this code in our checkout service:

// Legacy code - no tests
function calculateOrderTotal(items: any[], discount: any) {
  let total = 0;
  
  for (let i = 0; i < items.length; i++) {
    total += items[i].price * items[i].qty;
  }
  
  if (discount) {
    if (discount.type === 'percent') {
      total = total - (total * discount.value / 100);
    } else {
      total = total - discount.value;
    }
  }
  
  return Math.round(total * 100) / 100;
}

Before refactoring, write characterization tests:

describe('calculateOrderTotal - Current Behavior', () => {
  describe('basic calculations', () => {
    it('calculates total for single item', () => {
      const items = [{ price: 10.00, qty: 2 }];
      expect(calculateOrderTotal(items, null)).toBe(20.00);
    });

    it('calculates total for multiple items', () => {
      const items = [
        { price: 10.00, qty: 2 },
        { price: 5.00, qty: 3 }
      ];
      expect(calculateOrderTotal(items, null)).toBe(35.00);
    });
  });

  describe('discounts', () => {
    it('applies percentage discount', () => {
      const items = [{ price: 100, qty: 1 }];
      const discount = { type: 'percent', value: 10 };
      expect(calculateOrderTotal(items, discount)).toBe(90.00);
    });

    it('applies fixed amount discount', () => {
      const items = [{ price: 100, qty: 1 }];
      const discount = { type: 'fixed', value: 15 };
      expect(calculateOrderTotal(items, discount)).toBe(85.00);
    });
  });

  describe('edge cases discovered', () => {
    it('handles undefined discount', () => {
      const items = [{ price: 10, qty: 1 }];
      expect(calculateOrderTotal(items, undefined)).toBe(10.00);
    });

    it('rounds to 2 decimal places', () => {
      const items = [{ price: 10.555, qty: 1 }];
      expect(calculateOrderTotal(items, null)).toBe(10.56);
    });

    // Document buggy behavior to track during refactoring
    it('CURRENT BUG: allows discount greater than total', () => {
      const items = [{ price: 10, qty: 1 }];
      const discount = { type: 'fixed', value: 20 };
      // Currently returns negative, should be 0
      expect(calculateOrderTotal(items, discount)).toBe(-10.00);
    });
  });
});

Benefits:

• Documents current behavior (good and bad)

• Provides regression safety during refactoring

• Identifies bugs to fix after refactoring

• Builds confidence in the refactoring process

Step 2: Refactor with Tests Passing

Now refactor while keeping tests green:

// Refactored version
interface OrderItem {
  price: number;
  quantity: number;
}

interface Discount {
  type: 'percentage' | 'fixed';
  value: number;
}

class OrderCalculator {
  calculateTotal(
    items: OrderItem[],
    discount?: Discount
  ): number {
    const subtotal = this.calculateSubtotal(items);
    const discountAmount = this.calculateDiscount(subtotal, discount);
    const total = Math.max(0, subtotal - discountAmount);
    
    return this.roundToTwoDecimals(total);
  }

  private calculateSubtotal(items: OrderItem[]): number {
    return items.reduce(
      (sum, item) => sum + (item.price * item.quantity),
      0
    );
  }

  private calculateDiscount(
    subtotal: number,
    discount?: Discount
  ): number {
    if (!discount) {
      return 0;
    }

    if (discount.type === 'percentage') {
      return subtotal * (discount.value / 100);
    }

    return discount.value;
  }

  private roundToTwoDecimals(value: number): number {
    return Math.round(value * 100) / 100;
  }
}

Update tests to use refactored code:

describe('OrderCalculator', () => {
  let calculator: OrderCalculator;

  beforeEach(() => {
    calculator = new OrderCalculator();
  });

  describe('calculateTotal', () => {
    it('calculates total for single item', () => {
      const items = [{ price: 10.00, quantity: 2 }];
      expect(calculator.calculateTotal(items)).toBe(20.00);
    });

    it('calculates total for multiple items', () => {
      const items = [
        { price: 10.00, quantity: 2 },
        { price: 5.00, quantity: 3 }
      ];
      expect(calculator.calculateTotal(items)).toBe(35.00);
    });

    it('applies percentage discount', () => {
      const items = [{ price: 100, quantity: 1 }];
      const discount = { type: 'percentage' as const, value: 10 };
      expect(calculator.calculateTotal(items, discount)).toBe(90.00);
    });

    it('applies fixed amount discount', () => {
      const items = [{ price: 100, quantity: 1 }];
      const discount = { type: 'fixed' as const, value: 15 };
      expect(calculator.calculateTotal(items, discount)).toBe(85.00);
    });

    // Bug fixed!
    it('prevents negative total from excessive discount', () => {
      const items = [{ price: 10, quantity: 1 }];
      const discount = { type: 'fixed' as const, value: 20 };
      expect(calculator.calculateTotal(items, discount)).toBe(0.00);
    });
  });
});

Unit Testing Strategies

Test Structure: Arrange-Act-Assert

describe('UserService', () => {
  describe('createUser', () => {
    it('should create user with hashed password', async () => {
      // Arrange
      const userRepository = createMockUserRepository();
      const passwordService = createMockPasswordService();
      const emailService = createMockEmailService();
      
      const service = new UserService(
        userRepository,
        passwordService,
        emailService
      );

      const userData = {
        email: '[email protected]',
        password: 'plaintext123'
      };

      const hashedPassword = 'hashed_password_123';
      passwordService.hash.mockResolvedValue(hashedPassword);

      // Act
      const user = await service.createUser(userData);

      // Assert
      expect(passwordService.hash).toHaveBeenCalledWith('plaintext123');
      expect(userRepository.create).toHaveBeenCalledWith({
        email: '[email protected]',
        passwordHash: hashedPassword
      });
      expect(emailService.sendWelcomeEmail).toHaveBeenCalledWith(
        '[email protected]'
      );
    });
  });
});

Testing Error Paths

Don't just test the happy path:

describe('PaymentService', () => {
  describe('processPayment', () => {
    it('throws error when order not found', async () => {
      const orderRepository = createMockOrderRepository();
      orderRepository.findById.mockResolvedValue(null);
      
      const service = new PaymentService(orderRepository, null, null);

      await expect(
        service.processPayment('invalid-order-id', {})
      ).rejects.toThrow(OrderNotFoundError);
    });

    it('throws error when payment gateway fails', async () => {
      const orderRepository = createMockOrderRepository();
      const paymentGateway = createMockPaymentGateway();
      
      const order = createTestOrder({ total: 100 });
      orderRepository.findById.mockResolvedValue(order);
      
      const gatewayError = new Error('Gateway timeout');
      paymentGateway.charge.mockRejectedValue(gatewayError);

      const service = new PaymentService(
        orderRepository,
        paymentGateway,
        null
      );

      await expect(
        service.processPayment(order.id, {})
      ).rejects.toThrow(PaymentProcessingError);
    });

    it('retries on transient failures', async () => {
      const orderRepository = createMockOrderRepository();
      const paymentGateway = createMockPaymentGateway();
      
      const order = createTestOrder({ total: 100 });
      orderRepository.findById.mockResolvedValue(order);
      
      // Fail twice, succeed on third attempt
      paymentGateway.charge
        .mockRejectedValueOnce(new Error('Timeout'))
        .mockRejectedValueOnce(new Error('Timeout'))
        .mockResolvedValueOnce({ success: true, transactionId: '123' });

      const service = new PaymentService(
        orderRepository,
        paymentGateway,
        null
      );

      const result = await service.processPayment(order.id, {});

      expect(paymentGateway.charge).toHaveBeenCalledTimes(3);
      expect(result.success).toBe(true);
    });
  });
});

Test Helpers and Factories

Create reusable test data builders:

// test/helpers/order.factory.ts
export function createTestOrder(overrides?: Partial<Order>): Order {
  return {
    id: crypto.randomUUID(),
    customerId: crypto.randomUUID(),
    items: [
      {
        productId: 'prod-1',
        name: 'Test Product',
        price: 10.00,
        quantity: 1
      }
    ],
    subtotal: 10.00,
    tax: 0.85,
    shipping: 5.00,
    total: 15.85,
    status: OrderStatus.Pending,
    createdAt: new Date(),
    ...overrides
  };
}

export function createMockOrderRepository(): jest.Mocked<OrderRepository> {
  return {
    findById: jest.fn(),
    create: jest.fn(),
    update: jest.fn(),
    delete: jest.fn()
  };
}

// Usage
const order = createTestOrder({ 
  total: 100,
  status: OrderStatus.Paid 
});

Integration Testing

Testing Repository Layer

describe('OrderRepository (Integration)', () => {
  let repository: OrderRepository;
  let db: Database;

  beforeAll(async () => {
    // Use test database
    db = await createTestDatabase();
    repository = new OrderRepository(db);
  });

  afterAll(async () => {
    await db.close();
  });

  beforeEach(async () => {
    // Clean database before each test
    await db.query('DELETE FROM orders');
  });

  describe('create', () => {
    it('inserts order into database', async () => {
      const orderData = {
        customerId: 'cust-123',
        items: [
          { productId: 'prod-1', price: 10, quantity: 2 }
        ],
        total: 20.00
      };

      const order = await repository.create(orderData);

      expect(order.id).toBeDefined();
      expect(order.customerId).toBe('cust-123');
      expect(order.total).toBe(20.00);

      // Verify in database
      const rows = await db.query(
        'SELECT * FROM orders WHERE id = ?',
        [order.id]
      );
      expect(rows).toHaveLength(1);
      expect(rows[0].customer_id).toBe('cust-123');
    });
  });

  describe('findById', () => {
    it('returns order with items', async () => {
      // Insert test data
      const orderId = await insertTestOrder(db, {
        customerId: 'cust-123',
        items: [
          { productId: 'prod-1', price: 10, quantity: 2 },
          { productId: 'prod-2', price: 5, quantity: 1 }
        ]
      });

      const order = await repository.findById(orderId);

      expect(order).toBeDefined();
      expect(order!.id).toBe(orderId);
      expect(order!.items).toHaveLength(2);
      expect(order!.items[0].productId).toBe('prod-1');
    });

    it('returns null for non-existent order', async () => {
      const order = await repository.findById('non-existent');
      expect(order).toBeNull();
    });
  });
});

Testing Service Integration

describe('OrderService (Integration)', () => {
  let service: OrderService;
  let orderRepository: OrderRepository;
  let inventoryService: InventoryService;
  let paymentService: PaymentService;
  let db: Database;

  beforeAll(async () => {
    db = await createTestDatabase();
    orderRepository = new OrderRepository(db);
    inventoryService = new InventoryService(db);
    paymentService = new PaymentService(db);
    
    service = new OrderService(
      orderRepository,
      inventoryService,
      paymentService
    );
  });

  beforeEach(async () => {
    await cleanDatabase(db);
    await seedTestData(db);
  });

  describe('createOrder', () => {
    it('creates order, reserves inventory, and processes payment', async () => {
      const customerId = 'cust-123';
      const items = [
        { productId: 'prod-1', quantity: 2 }
      ];

      const order = await service.createOrder(customerId, items);

      // Verify order created
      expect(order.id).toBeDefined();
      expect(order.status).toBe(OrderStatus.Paid);

      // Verify inventory reserved
      const inventory = await inventoryService.getAvailability('prod-1');
      expect(inventory.available).toBe(8); // Was 10, reserved 2

      // Verify payment recorded
      const payment = await paymentService.findByOrderId(order.id);
      expect(payment).toBeDefined();
      expect(payment!.status).toBe('completed');
    });

    it('rolls back on payment failure', async () => {
      // Mock payment service to fail
      jest.spyOn(paymentService, 'charge').mockRejectedValue(
        new Error('Payment declined')
      );

      const customerId = 'cust-123';
      const items = [{ productId: 'prod-1', quantity: 2 }];

      await expect(
        service.createOrder(customerId, items)
      ).rejects.toThrow('Payment declined');

      // Verify inventory not reserved
      const inventory = await inventoryService.getAvailability('prod-1');
      expect(inventory.available).toBe(10); // Unchanged

      // Verify no order created
      const orders = await orderRepository.findByCustomerId(customerId);
      expect(orders).toHaveLength(0);
    });
  });
});

Test-Driven Refactoring

Example: Refactoring to Repository Pattern

Current code (direct database access):

class OrderService {
  async getOrder(orderId: string) {
    const rows = await db.query(
      'SELECT * FROM orders WHERE id = ?',
      [orderId]
    );
    return rows[0];
  }
}

Step 1: Write tests for new repository:

describe('OrderRepository', () => {
  it('should find order by id', async () => {
    const repository = new OrderRepository(db);
    
    // Assuming we have test data
    const order = await repository.findById('order-123');
    
    expect(order).toBeDefined();
    expect(order!.id).toBe('order-123');
  });
});

Step 2: Implement repository:

class OrderRepository {
  constructor(private db: Database) {}

  async findById(id: string): Promise<Order | null> {
    const rows = await this.db.query(
      'SELECT * FROM orders WHERE id = ?',
      [id]
    );
    
    if (rows.length === 0) {
      return null;
    }
    
    return this.mapToOrder(rows[0]);
  }

  private mapToOrder(row: any): Order {
    return {
      id: row.id,
      customerId: row.customer_id,
      total: row.total,
      status: row.status,
      createdAt: new Date(row.created_at)
    };
  }
}

Step 3: Update service to use repository:

class OrderService {
  constructor(private orderRepository: OrderRepository) {}

  async getOrder(orderId: string): Promise<Order | null> {
    return await this.orderRepository.findById(orderId);
  }
}

Step 4: Update service tests:

describe('OrderService', () => {
  it('should return order from repository', async () => {
    const mockRepository = createMockOrderRepository();
    const testOrder = createTestOrder({ id: 'order-123' });
    mockRepository.findById.mockResolvedValue(testOrder);

    const service = new OrderService(mockRepository);
    const order = await service.getOrder('order-123');

    expect(order).toBe(testOrder);
    expect(mockRepository.findById).toHaveBeenCalledWith('order-123');
  });
});

Testing Refactored Code

Before: Tightly Coupled Code

class NotificationService {
  async sendOrderConfirmation(orderId: string) {
    const order = await db.query('SELECT * FROM orders WHERE id = ?', [orderId]);
    const user = await db.query('SELECT * FROM users WHERE id = ?', [order.user_id]);
    
    await fetch('https://email-service.com/send', {
      method: 'POST',
      body: JSON.stringify({
        to: user.email,
        subject: 'Order Confirmation',
        body: `Your order ${order.id} has been confirmed`
      })
    });
  }
}

// Hard to test!

After: Dependency Injection

interface OrderRepository {
  findById(id: string): Promise<Order | null>;
}

interface UserRepository {
  findById(id: string): Promise<User | null>;
}

interface EmailService {
  send(to: string, subject: string, body: string): Promise<void>;
}

class NotificationService {
  constructor(
    private orderRepository: OrderRepository,
    private userRepository: UserRepository,
    private emailService: EmailService
  ) {}

  async sendOrderConfirmation(orderId: string): Promise<void> {
    const order = await this.orderRepository.findById(orderId);
    if (!order) {
      throw new OrderNotFoundError(orderId);
    }

    const user = await this.userRepository.findById(order.customerId);
    if (!user) {
      throw new UserNotFoundError(order.customerId);
    }

    await this.emailService.send(
      user.email,
      'Order Confirmation',
      `Your order ${order.id} has been confirmed`
    );
  }
}

// Easy to test!
describe('NotificationService', () => {
  it('sends email to order customer', async () => {
    const orderRepository = createMockOrderRepository();
    const userRepository = createMockUserRepository();
    const emailService = createMockEmailService();

    const order = createTestOrder({ 
      id: 'order-123',
      customerId: 'user-456'
    });
    const user = createTestUser({ 
      id: 'user-456',
      email: '[email protected]'
    });

    orderRepository.findById.mockResolvedValue(order);
    userRepository.findById.mockResolvedValue(user);
    emailService.send.mockResolvedValue(undefined);

    const service = new NotificationService(
      orderRepository,
      userRepository,
      emailService
    );

    await service.sendOrderConfirmation('order-123');

    expect(emailService.send).toHaveBeenCalledWith(
      '[email protected]',
      'Order Confirmation',
      'Your order order-123 has been confirmed'
    );
  });
});

Coverage and Quality Metrics

What I Track

In my microservices, I monitor:

{
  "jest": {
    "coverageThreshold": {
      "global": {
        "branches": 80,
        "functions": 80,
        "lines": 80,
        "statements": 80
      },
      "src/services/payment/**": {
        "branches": 90,
        "functions": 90,
        "lines": 90,
        "statements": 90
      }
    }
  }
}

Critical paths (payment, auth) require 90%+ coverage

Coverage Reports

npm test -- --coverage

----------------------|---------|----------|---------|---------|
File                  | % Stmts | % Branch | % Funcs | % Lines |
----------------------|---------|----------|---------|---------|
All files             |   85.32 |    82.14 |   87.93 |   85.45 |
 services/            |   92.15 |    88.42 |   94.28 |   92.31 |
  order.service.ts    |   94.23 |    90.00 |   95.00 |   94.44 |
  payment.service.ts  |   96.55 |    92.85 |   100   |   96.77 |
 repositories/        |   88.46 |    85.71 |   90.00 |   88.88 |
  order.repository.ts |   91.30 |    87.50 |   92.30 |   91.66 |
----------------------|---------|----------|---------|---------|

Continuous Testing During Development

Watch Mode

npm test -- --watch

This runs tests automatically when files change. I keep this running in a terminal while refactoring.

Pre-commit Hooks

{
  "husky": {
    "hooks": {
      "pre-commit": "npm test && npm run lint"
    }
  }
}

Prevents committing code that breaks tests.

Conclusion

Testing and refactoring go hand-in-hand:

1. Add characterization tests before refactoring legacy code

2. Keep tests passing during refactoring

3. Use dependency injection to make code testable

4. Test error paths not just happy paths

5. Use test helpers to reduce duplication

6. Monitor coverage especially for critical paths

7. Run tests continuously during development

In Part 5, we'll explore automated tools and CI/CD integration to enforce code quality and testing standards across your team.

Series Navigation: ← Part 3: Refactoring Techniques | Part 5: Automated Tools and CI/CD Integration →