プロローグ — コードがビジネスを語れない

# これは何をするコードか、説明できるか？
def process(id, type, flag = false)
  obj = Obj.find(id)
  if type == 1
    obj.update(status: flag ? 2 : 1)
    Mailer.send_mail(obj.user_id, type)
    Stock.where(item_id: obj.item_id).first.decrement!(:count)
  elsif type == 2
    obj.update(status: 3)
    Stock.where(item_id: obj.item_id).first.increment!(:count)
  end
end

# app/models/order.rb より抜粋 — 全体は500行を超える
class Order < ApplicationRecord
  STATUS_PENDING    = 0
  STATUS_CONFIRMED  = 1
  STATUS_PROCESSING = 2
  STATUS_SHIPPED    = 3
  STATUS_DELIVERED  = 4
  STATUS_CANCELLED  = 5
 
  def process_order(type, opts = {})
    if type == 'confirm'
      # 確認済みにする
      self.status = STATUS_CONFIRMED
      # 在庫を減らす
      items.each do |i|
        s = Stock.where(item_id: i.item_id).first
        s.qty -= i.qty
        s.save
      end
      # メール
      OrderMailer.delay.send_confirm(id)
      # ポイント
      user.point += (total_price * 0.01).to_i
      user.save
    elsif type == 'cancel'
      # ...
    end
  end
end

# 検索で見つかった3つの"在庫引き当て"処理
 
# 場所1: app/models/order.rb
Stock.find_by(item_id: item.item_id).decrement!(:qty, item.qty)
 
# 場所2: app/services/cart_service.rb
stock = Stock.where("item_id = ? AND qty > 0", item_id).first
stock.update_column(:qty, stock.qty - quantity) if stock
 
# 場所3: app/workers/order_processing_worker.rb
StockManager.hold(product_id: product_id, amount: quantity)

class Order < ApplicationRecord
  belongs_to :user
  belongs_to :product
  has_many :order_items
  has_one :shipment
  has_one :payment
 
  # 注文確定 — 何でもここで処理する
  def confirm
    update!(status: 'confirmed')
 
    # 在庫管理の責務
    items.each do |item|
      Stock.find_by(product_id: item.product_id)
           .decrement!(:quantity, item.quantity)
    end
 
    # 決済の責務
    PaymentService.charge(self)
 
    # 配送の責務
    ShipmentService.prepare(self)
 
    # 通知の責務
    UserMailer.order_confirmed(self).deliver_later
 
    # ポイントの責務
    LoyaltyService.add_points(user, total_amount)
 
    # 在庫アラートの責務（別の在庫管理ロジック）
    InventoryAlertService.check_low_stock(items)
 
    # 分析データ送信の責務
    Analytics.track('order_confirmed', order_id: id, amount: total_amount)
 
    # キャッシュの責務
    Rails.cache.delete("user_orders_#{user_id}")
  end
 
  # キャンセル — confirm の鏡像だが少し違う
  def cancel
    update!(status: 'cancelled')
    items.each do |item|
      Stock.find_by(product_id: item.product_id)
           .increment!(:quantity, item.quantity)
    end
    PaymentService.refund(self)
    UserMailer.order_cancelled(self).deliver_later
    LoyaltyService.remove_points(user, total_amount)
    Analytics.track('order_cancelled', order_id: id)
    Rails.cache.delete("user_orders_#{user_id}")
  end
 
  # 200行続く...
  # calculate_discount, apply_coupon, check_inventory, ...
end

# 意味のないテスト
it 'confirms an order' do
  order = create(:order)
  order.confirm
  expect(order.status).to eq('confirmed')
  # LoyaltyService, PaymentService, ShipmentService の副作用は検証していない
  # これらが失敗してもテストは通る
end

# 現状のコード: べき等性がない
def confirm!
  # pending? チェックがない
  self.status = 'confirmed'
  Stock.decrement!(...)  # 二重に実行される
end
 
# 修正後: べき等性を保証
def confirm!
  raise AlreadyConfirmed, "注文は既に確定されています" unless pending?
  # ...
end

# レースコンディションの例
# リクエストA:               リクエストB:
order = Order.find(12345)  # order = Order.find(12345)
order.pending?             # → true
                           # order.pending?  → true（Aがまだ保存していない）
order.confirm!             #
                           # order.confirm!  ← 両方が同時に実行される

# 楽観的ロックを使う（DDDと相性が良い）
# migration: add_column :orders, :lock_version, :integer, default: 0
 
def confirm!
  raise AlreadyConfirmed unless pending?
  @status = OrderStatus::CONFIRMED
  # → Repositoryがlock_versionで競合を検知する
end
 
# repository
def save(domain_order)
  record = OrderRecord.find(domain_order.id)
  record.lock!  # SELECTとUPDATEの間をロック
  record.update!(
    status: domain_order.status.to_s,
    lock_version: record.lock_version + 1
  )
rescue ActiveRecord::StaleObjectError
  raise OrderConcurrentModification, "注文が同時に変更されました。もう一度試してください"
end

# grep結果: 意味不明な名前の宝庫
def proc(t, f = false)  # process? procure? t は type か term か?
  ...
end
 
def upd_st(s)            # update_status? update_stock?
  ...
end
 
def chk(id)              # check? checkout?
  ...
end

def confirm!
  # ステータスを2に更新（2 = confirmed）
  update_column(:status, 2)
 
  # 在庫を減らす
  items.each do |item|
    # product_idで在庫を検索して数量を引く
    Stock.where(product_id: item.product_id).first.decrement!(:qty, item.qty)
  end
 
  # 確認メール送信
  OrderMailer.delay.confirmation(id)
end

$ grep -r "stock.decrement\|Stock.decrement\|stock.qty -=" app/ --include="*.rb" | wc -l
17

# テストが実装の詳細を知りすぎている
it '注文確定でメールが送られる' do
  order = create(:order)
  expect(OrderMailer).to receive(:confirmation).with(order.id)
  expect(Stock).to receive(:decrement!).twice
  expect(User).to receive(:update!)
 
  order.confirm!
end

# DDDスタイルのテスト: 振る舞いを検証
it '注文確定後、状態がCONFIRMEDになる' do
  order = build_pending_order_with_items
  order.confirm!
  expect(order.status).to eq(OrderContext::OrderStatus::CONFIRMED)
end
 
it '注文確定でOrderConfirmedイベントが発生する' do
  order = build_pending_order_with_items
  order.confirm!
  expect(order.domain_events).to include(an_instance_of(OrderContext::OrderConfirmed))
end