packages feed

keiro-dsl-0.26.0.0: test/conformance-topology-machine/Generated/TopologyMachine/Order/Harness.hs

-- @generated by keiro-dsl 0.26.0.0 (language keiro-dsl 6) from aggregate Order; do not edit.
module Generated.TopologyMachine.Order.Harness (harnessAssertions) where

import Generated.TopologyMachine.Order.Domain
import Generated.TopologyMachine.Order.Codec (encodeOrderEvent, parseOrderEvent, orderCodec)
import Generated.TopologyMachine.Order.Transducer (orderTransducer)
import Keiki.Core (applyEventsEither, defaultValidationOptions, step, validateTransducer)
import Keiro.Codec (eventType)
import Generated.TopologyMachine.Nominals (OrderId, parseOrderId)
import TopologyMachine.Order.BehaviorHoles (behaviorWitnesses)
import Generated.TopologyMachine.Order.BehaviorContract (BehaviorConformanceReport (..), BehaviorKey (..), behaviorObligationReport)

-- | (label, passed). A driver runs these and exits non-zero on any False,
-- naming the failing assertion. Filling a hole wrongly turns a specific
-- entry False; pending Hole witnesses fail until filled and verified.
harnessAssertions :: [(String, Bool)]
harnessAssertions =
  [ ("validateTransducer is empty", null (validateTransducer defaultValidationOptions orderTransducer))
  -- clock-free: spec samples no wall clock (verified at scaffold time)
  , ("golden round-trip: OrderPlaced", roundTrips sampleEventOrderPlaced)
  , ("golden round-trip: OrderAmended", roundTrips sampleEventOrderAmended)
  , ("golden round-trip: OrderNoted", roundTrips sampleEventOrderNoted)
  , ("golden round-trip: OrderShipped", roundTrips sampleEventOrderShipped)
  , ("golden round-trip: ShipmentLabelled", roundTrips sampleEventShipmentLabelled)
  , ("golden round-trip: OrderClosed", roundTrips sampleEventOrderClosed)
  , ("accepts PlaceOrder from OrderDraft", acceptPlaceOrder)
  , ("accepts NoteOrder from OrderDraft", acceptNoteOrder)
  ]
  ++ forwardReplayPlaceOrder
  ++ forwardReplayNoteOrder

roundTrips :: OrderEvent -> Bool
roundTrips e = parseOrderEvent (eventType orderCodec e) (encodeOrderEvent e) == Right e

-- | One required obligation carrying exactly one non-pending witness.
holeWitnessFilled :: BehaviorKey -> BehaviorConformanceReport -> Bool
holeWitnessFilled key report = report.required == [key] && report.filled == [key]

sampleOrderId :: OrderId
sampleOrderId =
  case parseOrderId "ord_01h455vb4pex5vsknk084sn02q" of
    Right parsed -> parsed
    Left problem -> error (show problem)

sampleEventOrderPlaced :: OrderEvent
sampleEventOrderPlaced = OrderPlaced (OrderPlacedData sampleOrderId)

sampleEventOrderAmended :: OrderEvent
sampleEventOrderAmended = OrderAmended (OrderAmendedData sampleOrderId)

sampleEventOrderNoted :: OrderEvent
sampleEventOrderNoted = OrderNoted (OrderNotedData sampleOrderId "sample-note")

sampleEventOrderShipped :: OrderEvent
sampleEventOrderShipped = OrderShipped (OrderShippedData sampleOrderId)

sampleEventShipmentLabelled :: OrderEvent
sampleEventShipmentLabelled = ShipmentLabelled (ShipmentLabelledData sampleOrderId)

sampleEventOrderClosed :: OrderEvent
sampleEventOrderClosed = OrderClosed (OrderClosedData sampleOrderId)

acceptPlaceOrder :: Bool
acceptPlaceOrder =
  case step orderTransducer (OrderDraft, initialOrderRegs) (PlaceOrder (PlaceOrderData sampleOrderId)) of
    Just (v, _, _) -> v == OrderOpen
    Nothing -> False

-- Hole-owned initial edge: the consumer's history-backed live witness
-- proves acceptance through the generated behavior contract.
holeWitnessNoteOrder :: BehaviorConformanceReport
holeWitnessNoteOrder = behaviorObligationReport (BehaviorKey "behavior-v1-e07448f38133b7e0") behaviorWitnesses

acceptNoteOrder :: Bool
acceptNoteOrder = holeWitnessFilled (BehaviorKey "behavior-v1-e07448f38133b7e0") holeWitnessNoteOrder && null holeWitnessNoteOrder.failed

-- forward/replay equality (plan 147): cross the persisted codec boundary,
-- replay the emitted chain, and compare the final vertex and every register.
forwardReplayPlaceOrder :: [(String, Bool)]
forwardReplayPlaceOrder =
  case step orderTransducer (OrderDraft, initialOrderRegs) (PlaceOrder (PlaceOrderData sampleOrderId)) of
    Nothing -> [(prefix <> "forward step accepted", False)]
    Just (forwardVertex, _forwardRegs, emitted) ->
      case mapM (\event -> parseOrderEvent (eventType orderCodec event) (encodeOrderEvent event)) emitted of
        Left _ -> [(prefix <> "emitted chain decodes", False)]
        Right decodedEvents ->
          case applyEventsEither orderTransducer (OrderDraft, initialOrderRegs) decodedEvents of
            Left _ -> [(prefix <> "replay succeeds", False)]
            Right (replayVertex, _replayRegs) ->
              [ (prefix <> "final vertex", replayVertex == forwardVertex)
              ]
  where
    prefix = "forward/replay equality: PlaceOrder from OrderDraft -- "

-- The behavior contract decodes emissions through the persisted codec,
-- replays them, and compares the final vertex and every register.
forwardReplayNoteOrder :: [(String, Bool)]
forwardReplayNoteOrder =
  [ (prefix <> "hole witness filled", holeWitnessFilled key holeWitnessNoteOrder)
  , (prefix <> "hole witness verified", holeWitnessFilled key holeWitnessNoteOrder && null holeWitnessNoteOrder.failed)
  ]
  where
    key = BehaviorKey "behavior-v1-e07448f38133b7e0"
    prefix = "forward/replay equality: NoteOrder from OrderDraft -- "