TDDが支えるリファクタリング - 自信を持ってコードを改善する技術

1
2
3
4
5
6
7

悪い例:
クラス全体を大幅に書き換え → テスト実行 → Red → どこが原因？

良い例:
メソッド名を変更 → テスト実行 → Green
メソッドを抽出 → テスト実行 → Green
変数名を変更 → テスト実行 → Green

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// orderCalculator.js - リファクタリング前
function calculateOrderTotal(items, customerType, couponCode) {
  let total = 0;
  for (let i = 0; i < items.length; i++) {
    total += items[i].price * items[i].quantity;
  }
  
  // 会員割引
  if (customerType === 'gold') {
    total = total * 0.8;
  } else if (customerType === 'silver') {
    total = total * 0.9;
  }
  
  // クーポン割引
  if (couponCode === 'SAVE10') {
    total = total - 1000;
  } else if (couponCode === 'SAVE20') {
    total = total - 2000;
  }
  
  if (total < 0) {
    total = 0;
  }
  
  return total;
}

module.exports = { calculateOrderTotal };

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// orderCalculator.test.js
const { calculateOrderTotal } = require('./orderCalculator');

describe('calculateOrderTotal', () => {
  const sampleItems = [
    { price: 1000, quantity: 2 },
    { price: 500, quantity: 3 }
  ];

  test('商品の合計金額を計算する', () => {
    expect(calculateOrderTotal(sampleItems, 'regular', null))
      .toBe(3500);
  });

  test('ゴールド会員は20%割引', () => {
    expect(calculateOrderTotal(sampleItems, 'gold', null))
      .toBe(2800);
  });

  test('シルバー会員は10%割引', () => {
    expect(calculateOrderTotal(sampleItems, 'silver', null))
      .toBe(3150);
  });

  test('SAVE10クーポンで1000円引き', () => {
    expect(calculateOrderTotal(sampleItems, 'regular', 'SAVE10'))
      .toBe(2500);
  });

  test('割引後の金額が0未満にならない', () => {
    const cheapItems = [{ price: 100, quantity: 1 }];
    expect(calculateOrderTotal(cheapItems, 'gold', 'SAVE10'))
      .toBe(0);
  });
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// ステップ1: 商品合計の計算を関数として抽出
function calculateSubtotal(items) {
  let subtotal = 0;
  for (let i = 0; i < items.length; i++) {
    subtotal += items[i].price * items[i].quantity;
  }
  return subtotal;
}

function calculateOrderTotal(items, customerType, couponCode) {
  let total = calculateSubtotal(items);
  
  // 会員割引
  if (customerType === 'gold') {
    total = total * 0.8;
  } else if (customerType === 'silver') {
    total = total * 0.9;
  }
  
  // クーポン割引
  if (couponCode === 'SAVE10') {
    total = total - 1000;
  } else if (couponCode === 'SAVE20') {
    total = total - 2000;
  }
  
  if (total < 0) {
    total = 0;
  }
  
  return total;
}

1
2
3
4
5
6
7

// ステップ2: reduceを使用した書き換え
function calculateSubtotal(items) {
  return items.reduce(
    (sum, item) => sum + item.price * item.quantity,
    0
  );
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// ステップ3: 会員割引率を取得する関数を抽出
function getMemberDiscountRate(customerType) {
  const discountRates = {
    gold: 0.8,
    silver: 0.9
  };
  return discountRates[customerType] || 1.0;
}

function calculateOrderTotal(items, customerType, couponCode) {
  let total = calculateSubtotal(items);
  total = total * getMemberDiscountRate(customerType);
  
  // クーポン割引
  if (couponCode === 'SAVE10') {
    total = total - 1000;
  } else if (couponCode === 'SAVE20') {
    total = total - 2000;
  }
  
  if (total < 0) {
    total = 0;
  }
  
  return total;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// ステップ4: クーポン割引額を取得する関数を抽出
function getCouponDiscountAmount(couponCode) {
  const couponDiscounts = {
    SAVE10: 1000,
    SAVE20: 2000
  };
  return couponDiscounts[couponCode] || 0;
}

function calculateOrderTotal(items, customerType, couponCode) {
  let total = calculateSubtotal(items);
  total = total * getMemberDiscountRate(customerType);
  total = total - getCouponDiscountAmount(couponCode);
  return Math.max(total, 0);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// orderCalculator.js - リファクタリング後
function calculateSubtotal(items) {
  return items.reduce(
    (sum, item) => sum + item.price * item.quantity,
    0
  );
}

function getMemberDiscountRate(customerType) {
  const discountRates = {
    gold: 0.8,
    silver: 0.9
  };
  return discountRates[customerType] || 1.0;
}

function getCouponDiscountAmount(couponCode) {
  const couponDiscounts = {
    SAVE10: 1000,
    SAVE20: 2000
  };
  return couponDiscounts[couponCode] || 0;
}

function calculateOrderTotal(items, customerType, couponCode) {
  const subtotal = calculateSubtotal(items);
  const afterMemberDiscount = subtotal * getMemberDiscountRate(customerType);
  const afterCouponDiscount = afterMemberDiscount - getCouponDiscountAmount(couponCode);
  return Math.max(afterCouponDiscount, 0);
}

module.exports = { calculateOrderTotal };

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

// Before: 長いメソッド
public void processOrder(Order order) {
    // 在庫確認
    for (OrderItem item : order.getItems()) {
        Product product = productRepository.findById(item.getProductId());
        if (product.getStock() < item.getQuantity()) {
            throw new InsufficientStockException(product.getName());
        }
    }
    
    // 合計計算
    double total = 0;
    for (OrderItem item : order.getItems()) {
        total += item.getPrice() * item.getQuantity();
    }
    
    // 割引適用
    if (order.getCouponCode() != null) {
        Coupon coupon = couponRepository.findByCode(order.getCouponCode());
        total = total - coupon.getDiscountAmount();
    }
    
    // 注文保存
    order.setTotal(total);
    orderRepository.save(order);
    
    // 通知送信
    emailService.sendOrderConfirmation(order);
}

// After: メソッドを抽出
public void processOrder(Order order) {
    validateStock(order);
    double total = calculateTotal(order);
    total = applyDiscount(order, total);
    saveOrder(order, total);
    sendConfirmation(order);
}

private void validateStock(Order order) {
    for (OrderItem item : order.getItems()) {
        Product product = productRepository.findById(item.getProductId());
        if (product.getStock() < item.getQuantity()) {
            throw new InsufficientStockException(product.getName());
        }
    }
}

private double calculateTotal(Order order) {
    return order.getItems().stream()
        .mapToDouble(item -> item.getPrice() * item.getQuantity())
        .sum();
}
// ... 他のメソッドも同様に抽出

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// Before: 重複したバリデーション
function validateEmail(email) {
  if (!email) return false;
  if (!email.includes('@')) return false;
  if (email.length > 255) return false;
  return true;
}

function validateUserEmail(user) {
  if (!user.email) return false;
  if (!user.email.includes('@')) return false;
  if (user.email.length > 255) return false;
  return true;
}

// After: 共通化
function isValidEmail(email) {
  if (!email) return false;
  if (!email.includes('@')) return false;
  if (email.length > 255) return false;
  return true;
}

function validateUserEmail(user) {
  return isValidEmail(user.email);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// Before: OrderServiceがOrderItemのデータを羨ましがっている
public class OrderService {
    public double calculateItemTotal(OrderItem item) {
        return item.getPrice() * item.getQuantity() * 
               (1 - item.getDiscountRate());
    }
}

// After: ロジックをOrderItemに移動
public class OrderItem {
    private double price;
    private int quantity;
    private double discountRate;
    
    public double calculateTotal() {
        return price * quantity * (1 - discountRate);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// Before: 基本型を使用
public class User {
    private String email;
    private String phoneNumber;
    private double accountBalance;
}

// After: 値オブジェクトを導入
public class User {
    private Email email;
    private PhoneNumber phoneNumber;
    private Money accountBalance;
}

public class Email {
    private final String value;
    
    public Email(String value) {
        if (!isValid(value)) {
            throw new IllegalArgumentException(
                "Invalid email format: " + value);
        }
        this.value = value;
    }
    
    private boolean isValid(String email) {
        return email != null && 
               email.matches("^[\\w.-]+@[\\w.-]+\\.[a-z]{2,}$");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// Before: switch文による分岐
public class ShippingCalculator {
    public double calculate(Order order) {
        switch (order.getShippingType()) {
            case "standard":
                return order.getWeight() * 100;
            case "express":
                return order.getWeight() * 200 + 500;
            case "overnight":
                return order.getWeight() * 300 + 1000;
            default:
                throw new IllegalArgumentException();
        }
    }
}

// After: ポリモーフィズムを使用
public interface ShippingStrategy {
    double calculate(Order order);
}

public class StandardShipping implements ShippingStrategy {
    public double calculate(Order order) {
        return order.getWeight() * 100;
    }
}

public class ExpressShipping implements ShippingStrategy {
    public double calculate(Order order) {
        return order.getWeight() * 200 + 500;
    }
}

public class OvernightShipping implements ShippingStrategy {
    public double calculate(Order order) {
        return order.getWeight() * 300 + 1000;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// Before
function printOwing(invoice) {
  let outstanding = 0;
  
  console.log('***********************');
  console.log('**** Customer Owes ****');
  console.log('***********************');
  
  for (const order of invoice.orders) {
    outstanding += order.amount;
  }
  
  console.log(`name: ${invoice.customer}`);
  console.log(`amount: ${outstanding}`);
}

// After
function printOwing(invoice) {
  printBanner();
  const outstanding = calculateOutstanding(invoice);
  printDetails(invoice, outstanding);
}

function printBanner() {
  console.log('***********************');
  console.log('**** Customer Owes ****');
  console.log('***********************');
}

function calculateOutstanding(invoice) {
  return invoice.orders.reduce((sum, order) => sum + order.amount, 0);
}

function printDetails(invoice, outstanding) {
  console.log(`name: ${invoice.customer}`);
  console.log(`amount: ${outstanding}`);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// Before: 過度に細分化されたメソッド
function getRating(driver) {
  return moreThanFiveLateDeliveries(driver) ? 2 : 1;
}

function moreThanFiveLateDeliveries(driver) {
  return driver.numberOfLateDeliveries > 5;
}

// After: インライン化
function getRating(driver) {
  return driver.numberOfLateDeliveries > 5 ? 2 : 1;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// Before
function calculateTotal(order) {
  const basePrice = order.quantity * order.itemPrice;
  const discountFactor = order.quantity > 100 ? 0.9 : 1;
  return basePrice * discountFactor;
}

// After
function calculateTotal(order) {
  return getBasePrice(order) * getDiscountFactor(order);
}

function getBasePrice(order) {
  return order.quantity * order.itemPrice;
}

function getDiscountFactor(order) {
  return order.quantity > 100 ? 0.9 : 1;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// Before
function calculateCharge(date, quantity) {
  let charge;
  if (date.isBefore(SUMMER_START) || date.isAfter(SUMMER_END)) {
    charge = quantity * winterRate + winterServiceCharge;
  } else {
    charge = quantity * summerRate;
  }
  return charge;
}

// After
function calculateCharge(date, quantity) {
  if (isWinter(date)) {
    return winterCharge(quantity);
  }
  return summerCharge(quantity);
}

function isWinter(date) {
  return date.isBefore(SUMMER_START) || date.isAfter(SUMMER_END);
}

function winterCharge(quantity) {
  return quantity * winterRate + winterServiceCharge;
}

function summerCharge(quantity) {
  return quantity * summerRate;
}