packages feed

kenshou-check-0.1.0.0: src/Kenshou/Check/Scenario.hs

module Kenshou.Check.Scenario
  ( CheckEnv (..),
    withCheck,
    finishWithVerdicts,
    deriveSeed,
  )
where

import Data.Aeson (object, toJSON, (.=))
import Data.Foldable (traverse_)
import Data.Int (Int64)
import Data.Map.Strict qualified as Map
import Data.Text (Text)
import Data.Text qualified as Text
import Data.Word (Word64)
import Kenshou.Check.Fact (ProcId (..))
import Kenshou.Check.Ledger
import Kenshou.Check.Verdict
import Kenshou.Core.Context
import Kenshou.Core.Id (deriveGen, mkSeed, renderRunId)
import Kenshou.Core.Outcome (Outcome (..))
import Kenshou.Core.Scenario (ScenarioReport (..))
import System.Environment (lookupEnv)
import System.FilePath (makeRelative)
import System.Random.SplitMix (nextWord64)
import Text.Read (readMaybe)

data CheckEnv = CheckEnv
  { context :: !RunContext,
    ledger :: !LedgerWriter,
    ledgerDirectory :: !FilePath,
    skewBoundMicros :: !Int64
  }

withCheck :: RunContext -> (CheckEnv -> IO value) -> IO value
withCheck context action = do
  directory <- artifactPath context VerdictsDir "ledger"
  measured <- lookupEnv "KENSHOU_CLOCK_SKEW_BOUND_MICROS"
  let (source, skew) = case measured >>= readMaybe of
        Just value -> (Measured, value)
        Nothing -> (SameHost, 1000)
      config = LedgerConfig directory (ProcId "harness" 0 0) (renderRunId context.runId) (64 * 1024 * 1024) (ClockInfo source skew)
  withLedger config \writer -> action (CheckEnv context writer directory skew)

finishWithVerdicts :: CheckEnv -> [Verdict] -> IO ScenarioReport
finishWithVerdicts environment verdicts = do
  verdictDirectory <- artifactPath environment.context VerdictsDir ""
  let runInfo = RunInfo environment.context.runId environment.context.scenario
  paths <- traverse (writeVerdict verdictDirectory runInfo) verdicts
  traverse_ (\path -> declareMediaType environment.context (makeRelative environment.context.outDir path) "application/json") paths
  putSummary environment.context Verdicts "checks" (toJSON (fmap summaryValue verdicts))
  let outcome = outcomeFromVerdicts verdicts
      failures = [verdict.checker | verdict <- verdicts, verdict.cls == Contract, verdict.status == Violated]
      reason = case outcome of
        Passed -> Nothing
        Failed -> Just "one or more contract invariants were violated"
        Inconclusive -> Just "one or more contract invariants could not be decided"
        Errored -> Just "one or more contract invariants were not evaluated"
        InfrastructureFailure -> Just "correctness evidence could not be collected"
  pure (ScenarioReport outcome reason failures)
  where
    summaryValue verdict =
      object
        [ "checker" .= verdict.checker,
          "invariant" .= verdict.invariant,
          "class" .= showClass verdict.cls,
          "status" .= showStatus verdict.status,
          "violations" .= Map.findWithDefault 0 "violations" verdict.counts
        ]
    showClass Contract = ("contract" :: Text)
    showClass Implementation = "implementation"
    showStatus Held = ("held" :: Text)
    showStatus Violated = "violated"
    showStatus NotEvaluated = "not-evaluated"

deriveSeed :: Word64 -> Text -> Word64
deriveSeed seed label = fst (nextWord64 (deriveGen (either (error . Text.unpack) id (mkSeed seed)) label))