エピローグ — パターンの組み合わせと過剰適用の罠

# ユウキのコード
class OrderCompletionFacade
  include Singleton
 
  def initialize
    @observer = OrderEventObserver.new
    @strategy_factory = StrategyFactory.new
    @command_chain = CommandChain.new([
      RefundCalculationCommand,
      StockReductionCommand,
      PointGrantCommand,
      NotificationCommand
    ])
    @builder = OrderCompletionReportBuilder.new
    @proxy = CachedCompletionService.new(OrderCompletionService.new)
  end
 
  def complete(order)
    strategy = @strategy_factory.create_for(order.order_type)
    report = @builder.build_for(order)
    result = @proxy.complete(strategy.execute(@observer.notify(@command_chain.execute(order))))
    report.finalize(result)
  end
end

# 過剰設計の典型例
# 「将来的に複数の割引戦略が必要かもしれない」という理由で作られたクラス群
 
class PriceCalculationStrategyFactory
  def self.create(strategy_type)
    case strategy_type
    when :simple then SimplePriceCalculationStrategy.new
    when :complex then ComplexPriceCalculationStrategy.new
    end
  end
end
 
class PriceCalculationStrategyInterface
  def calculate(price, options = {})
    raise NotImplementedError
  end
end
 
class SimplePriceCalculationStrategy < PriceCalculationStrategyInterface
  def calculate(price, options = {})
    price  # ただprice を返すだけ！
  end
end
 
class ComplexPriceCalculationStrategy < PriceCalculationStrategyInterface
  def calculate(price, options = {})
    price * 1.0  # これだけのために抽象化する必要はない
  end
end
 
# 実際に必要だったのはこれだけ
def calculate_price(amount)
  amount
end

# 元のコード（問題のある状態）
class OrdersController < ApplicationController
  def complete
    order = Order.find(params[:id])
 
    # 在庫を減らす
    order.order_items.each do |item|
      item.product.decrement!(:stock, item.quantity)
    end
 
    # ポイント付与
    order.user.increment!(:points, (order.total_price / 100).floor)
 
    # メール送信
    OrderMailer.completion(order).deliver_later
    AdminMailer.new_order_notification(order).deliver_later
 
    # 注文のステータス更新
    order.update!(status: :completed, completed_at: Time.current)
 
    render json: { message: "注文が完了しました" }
  end
end

# app/services/order_completion_service.rb（Facade）
class OrderCompletionService
  def initialize(order:)
    @order = order
  end
 
  def call
    ActiveRecord::Base.transaction do
      reduce_stock
      grant_points
      complete_order
    end
 
    send_notifications  # トランザクション外（失敗してもロールバックしない）
 
    @order
  end
 
  private
 
  def reduce_stock
    @order.order_items.each do |item|
      # lock!でデッドロック防止
      product = item.product.lock!
      raise InsufficientStockError, "#{product.name}の在庫が不足しています" if product.stock < item.quantity
 
      product.decrement!(:stock, item.quantity)
    end
  end
 
  def grant_points
    point_amount = (@order.total_price / 100).floor
    @order.user.increment!(:points, point_amount)
  end
 
  def complete_order
    @order.complete!  # AASMの状態遷移
  end
 
  def send_notifications
    OrderMailer.completion(@order).deliver_later
    AdminMailer.new_order_notification(@order).deliver_later
  end
end

# コントローラはシンプルに
class OrdersController < ApplicationController
  def complete
    order = current_user.orders.find(params[:id])
 
    result = OrderCompletionService.new(order: order).call
 
    render json: { message: "注文が完了しました", order_id: result.id }
  rescue InsufficientStockError => e
    render json: { error: e.message }, status: :unprocessable_entity
  end
end

# すべてを知っているクラス（アンチパターン）
class OrderManager
  def create_order(params); end
  def calculate_shipping(order); end
  def process_payment(order, payment); end
  def send_confirmation_email(order); end
  def update_inventory(order); end
  def generate_invoice(order); end
  def apply_discount(order, coupon); end
  def check_fraud(order); end
  def notify_warehouse(order); end
  def update_crm(order); end
  def log_analytics(order); end
  # ...800行のクラス
end

class OrderCreationService  # Facade
  def call
    validate      # → OrderValidationChain に委ねる
    charge        # → PaymentGateway に委ねる
    create        # → Order.create! に委ねる
    notify        # → Notifications に委ねる
  end
end

# 必要のないStrategyインターフェース（アンチパターン）
class UserGreetingStrategyBase
  def greet(user)
    raise NotImplementedError
  end
end
 
class DefaultUserGreetingStrategy < UserGreetingStrategyBase
  def greet(user)
    "こんにちは、#{user.name}さん"  # ← これだけのために抽象化する必要はない
  end
end
 
# 素直に書けばいい
def greeting_for(user)
  "こんにちは、#{user.name}さん"
end

# Decoratorを重ねすぎて何が何だかわからない（アンチパターン）
user = User.find(1)
  .then { |u| AdminRoleDecorator.new(u) }
  .then { |u| PremiumMemberDecorator.new(u) }
  .then { |u| LocaleDecorator.new(u) }
  .then { |u| TimezoneDecorator.new(u) }
  .then { |u| CurrencyDecorator.new(u) }
  .then { |u| NotificationPreferenceDecorator.new(u) }

# グローバル状態を持つSingleton（テストが難しい）
class AppConfig
  include Singleton
 
  def initialize
    @config = YAML.load_file(Rails.root.join("config/app.yml"))
  end
 
  def late_fee
    @config["late_fee"]
  end
end
 
# テストが難しい — Singletonは状態が漏れる
class OrderService
  def calculate_late_fee(order)
    AppConfig.instance.late_fee * order.days_late
  end
end

# 改善: 設定を依存性注入で渡す
class OrderService
  def initialize(config: Rails.application.config_for(:app))
    @config = config
  end
 
  def calculate_late_fee(order)
    @config[:late_fee] * order.days_late
  end
end
 
# テストで差し替えられる
service = OrderService.new(config: { late_fee: 100 })

# テストしにくいコード（問題のある設計）
class OrderService
  def complete(order)
    # グローバル状態に依存
    fee = AppConfig.instance.late_fee
    # 外部APIに直接依存
    charge_id = Stripe::Charge.create(amount: order.total_price * 100, currency: "jpy")[:id]
    # メールを直接送信
    OrderMailer.confirmation(order).deliver_now
    order.update!(status: :completed, stripe_charge_id: charge_id)
  end
end
 
# テストするためには本物のStripeキーが必要……
# メールを実際に送ってしまう……

# テストしやすいコード（依存性注入を使う）
class OrderService
  def initialize(
    config: Rails.application.config_for(:app),
    payment_gateway: StripeGateway.new,
    mailer: OrderMailer
  )
    @config = config
    @payment_gateway = payment_gateway
    @mailer = mailer
  end
 
  def complete(order)
    charge = @payment_gateway.charge(
      amount: order.total_price,
      currency: "jpy"
    )
    order.update!(status: :completed, charge_id: charge[:id])
    @mailer.confirmation(order).deliver_later
  end
end

# テストでモックを差し込める
RSpec.describe OrderService do
  let(:mock_gateway) do
    instance_double(StripeGateway, charge: { id: "ch_test_123", success: true })
  end
  let(:mock_mailer) { class_double(OrderMailer, confirmation: double(deliver_later: true)) }
 
  subject(:service) do
    described_class.new(
      config: { late_fee: 100 },
      payment_gateway: mock_gateway,
      mailer: mock_mailer
    )
  end
 
  it "注文を完了させる" do
    order = create(:order, :paid)
    service.complete(order)
    expect(order.reload.status).to eq("completed")
  end
 
  it "支払いを処理する" do
    order = create(:order, :paid, total_price: 5000)
    service.complete(order)
    expect(mock_gateway).to have_received(:charge).with(amount: 5000, currency: "jpy")
  end
end