The Journal: one run

#!ek9
<?-
  debug-journal / orders: a defect that shows itself late.

  An order's total goes negative only when a refund FOLLOWS a discount: the refund is taken from what is left to pay
  (the discounted total) rather than from what was paid. Nothing fails at the refund; the invoice, later, refuses a
  negative total with a Panic. Scenario: 1 add, 2 +discount, 3 +discount +refund (fails), 4 +refund (passes).
-?>
defines module live.orders

  defines constant
    NOTHING <- 0
    PERCENT <- 100
    PRICE <- 100
    HALF <- 50
    REFUNDED <- 80
    DISCOUNTS <- 2
    REFUNDS <- 3

  defines class

    Order
      total as Integer: 0

      add()
        -> amount as Integer
        total += amount

      discount()
        -> percent as Integer
        saving <- total * percent / PERCENT
        total -= saving

      invoice()
        <- rtn as String?
        require total >= NOTHING
        rtn: `invoice for ${total}`

      refund()
        -> amount as Integer
        total -= amount

      default operator ?

  defines program

    Orders()
      -> scenario as Integer
      stdout <- Stdout()
      order <- Order()
      order.add(PRICE)
      if scenario == DISCOUNTS or scenario == REFUNDS
        order.discount(HALF)
      if scenario >= REFUNDS
        order.refund(REFUNDED)
      stdout.println(order.invoice())

//EOF

#!ek9
<?-
  debug-journal / orders: the tests, for trying coverage in the IDE (-t, the coverage toggle Alt+Cmd+F6).

  They cover adding, a discount alone and a refund alone - each passes. The defect path (a refund AFTER a discount,
  which the invoice refuses with a Panic) and the Orders program itself are deliberately left untested, so coverage
  shows what the tests do not reach.
-?>
defines module live.orders.tests

  references
    live.orders::HALF
    live.orders::Order
    live.orders::PRICE
    live.orders::REFUNDED

  defines constant
    FULL_PRICE <- "invoice for 100"
    HALF_PRICE <- "invoice for 50"
    PRICE_LESS_REFUND <- "invoice for 20"

  defines program

    @Test
    AddOnly()
      order <- Order()
      order.add(PRICE)
      assert order.invoice() == FULL_PRICE

    @Test
    HalfDiscount()
      order <- Order()
      order.add(PRICE)
      order.discount(HALF)
      assert order.invoice() == HALF_PRICE

    @Test
    RefundWithoutDiscount()
      order <- Order()
      order.add(PRICE)
      order.refund(REFUNDED)
      assert order.invoice() == PRICE_LESS_REFUND

//EOF