Draft example, Ruby-shaped (superseded)
Superseded by base-example; kept because several picks were made by reacting to it.
module Payments::Refund
intent "Refund a captured charge, at most once, within 90 days of capture."
never refund.amount > charge.captured_amount
never a charge is refunded twice
never card.number reaches log
type Money = UInt64 where value <= 10_000_000_00
struct Charge
id : ChargeId
captured_amount : Money
captured_at : Time
refunded : Bool
end
enum RefundError
ChargeNotFound(id : ChargeId)
AlreadyRefunded(id : ChargeId)
WindowExpired(captured_at : Time, now : Time)
Timeout
end
def within_window?(charge : Charge, now : Time) : Bool
requires now >= charge.captured_at
now - charge.captured_at <= 90.days
end
def apply_refund(charge : Charge, amount : Money) : Result(Charge, RefundError)
requires amount <= charge.captured_amount
ensures ok(c) implies c.refunded?
return error AlreadyRefunded(charge.id) if charge.refunded?
ok charge.with(refunded: true)
end
def refund(db : Ledger, clock : Clock, id : ChargeId, amount : Money) : Result(Refund, RefundError)
requires amount > 0
ensures ok(r) implies r.amount == amount
now = clock.now
charge = try db.find_charge(id, within: 200.ms)
unless within_window?(charge, now)
return error WindowExpired(captured_at: charge.captured_at, now: now)
end
updated = try apply_refund(charge, amount)
try db.save_charge(updated, within: 200.ms)
ok Refund.new(charge: id, amount: amount, at: now)
end
process RefundQueue
state
pending : List(RefundRequest) where size <= 1_000
done : UInt32
end
invariant done >= 0
message Enqueue(request : RefundRequest)
message Drain
def update(state, message, db : Ledger, clock : Clock)
case message
when Enqueue(request)
state.with(pending: state.pending.push(request))
when Drain
var done = state.done
state.pending.each do |request|
case refund(db, clock, request.id, request.amount)
when Ok(_) then done += 1
when Error(e) then log.warn(e)
end
end
state.with(pending: [], done: done)
end
end
end
test "refund within window succeeds"
charge = Charge.fixture(captured_at: t0, captured_amount: 5_00)
assert apply_refund(charge, 5_00) == ok(charge.with(refunded: true))
end
test "second refund is rejected"
charge = Charge.fixture(refunded: true)
assert apply_refund(charge, 1_00) == error(AlreadyRefunded(charge.id))
end
test rejects "amount above captured violates requires"
charge = Charge.fixture(captured_amount: 5_00)
apply_refund(charge, 9_99)
end
verified by contracts, tests, simulation(runs: 1_000)
end