module Main (main) where
import Control.Monad (forM_)
import Data.Aeson (Object, Value (Number), decode, encode, object)
import Data.Aeson.Key qualified as Key
import Data.Aeson.KeyMap qualified as KeyMap
import Data.IORef
import Data.Int (Int64)
import Data.List (sortOn)
import Data.Map.Strict qualified as Map
import Data.Maybe (isNothing)
import Data.Text qualified as Text
import Kenshou.Check.Fact
import Kenshou.Check.Invariant
import Kenshou.Check.Ledger
import Kenshou.Check.Ledger.Read
import Kenshou.Check.Ledger.Sort
import Kenshou.Check.Model.Linearizability
import Kenshou.Check.Oracle (OracleQuery (..), OracleSpec (..), fromSpec, registeredOracle)
import Kenshou.Check.Process
import Kenshou.Check.Scenario
import Kenshou.Check.Verdict
import Kenshou.Check.Verdict qualified as Verdict
import Kenshou.Core.Bundle (LayerBundle (..), mkBundle, mkRegistry)
import Kenshou.Core.Context
import Kenshou.Core.Dimension (emptyDimensions)
import Kenshou.Core.Id (mkSeed, newRunId, parseScenarioId, selftestLayer)
import Kenshou.Core.Knob (resolveKnobs)
import Kenshou.Core.Log (nullLogger)
import Kenshou.Core.Phase (zeroPhases)
import Kenshou.Core.RunSpec (RunSpec (..), minimalRunSpec)
import System.Directory (listDirectory)
import System.FilePath ((</>))
import System.IO.Temp (withSystemTempDirectory)
import System.Mem (performMajorGC)
import System.Mem.Weak (Weak, deRefWeak, mkWeakPtr)
import Test.Hspec
main :: IO ()
main = hspec do
describe "registered oracles" do
let spec = OracleSpec "queued-rows" "select count(*) from kenshou_selftest.roundtrip"
bundle = (mkBundle selftestLayer [] []) {oracles = [spec]}
it "finds an oracle a bundle registers and builds its query" do
registry <- either (fail . show) pure (mkRegistry [bundle])
registeredOracle registry selftestLayer "queued-rows" `shouldBe` Just spec
registeredOracle registry selftestLayer "missing" `shouldBe` Nothing
let query = fromSpec spec Right
(query.name, query.sql) `shouldBe` (spec.name, spec.sql)
it "rejects two oracles with one name in a bundle" do
either (const True) (const False) (mkRegistry [bundle {oracles = [spec, spec]}]) `shouldBe` True
describe "verdict protocol" do
it "rejects missing assertion counters before writing a document" $ withSystemTempDirectory "kenshou-verdict-protocol" \directory -> do
runId <- newRunId
let scenario = either (error . show) id (parseScenarioId "selftest/check/correctness/verdict-protocol")
runInfo = RunInfo runId scenario
valid = Verdict "protocol" "required-counters" Contract Held Nothing "protocol fixture" (Map.fromList [("examined", 1), ("violations", 0)]) (object []) [] False [] Nothing (read "2026-01-01 00:00:00 UTC") 0
forM_ ["examined", "violations"] \key ->
writeVerdict directory runInfo valid {Verdict.counts = Map.delete key valid.counts} `shouldThrow` anyIOException
listDirectory directory `shouldReturn` []
_ <- writeVerdict directory runInfo valid
listDirectory directory `shouldReturn` ["protocol.json"]
describe "Fact" do
it "round-trips through JSON" do
let fact = Fact Produced "stream" 3 "event" "writer/0" (ProcId "writer" 0 0) 1 2 3 KeyMap.empty
decode (encode fact) `shouldBe` Just fact
describe "Ledger" do
it "rotates immutable segments and reads every fact" $ withSystemTempDirectory "kenshou-ledger" \directory -> do
let config = LedgerConfig directory (ProcId "writer" 0 0) "run" 1024 (ClockInfo SameHost 1000)
withLedger config \writer -> forM_ [1 .. 200 :: Int64] \number -> record writer Produced "key" number (Text.pack (show number)) KeyMap.empty
files <- listDirectory directory
length files `shouldSatisfy` (> 1)
ledger <- discoverLedgers directory
count <- foldFacts ledger (0 :: Int) (\value _ -> pure (value + 1))
count `shouldBe` 200
it "drops a torn final fact line" $ withSystemTempDirectory "kenshou-torn" \directory -> do
let config = LedgerConfig directory (ProcId "writer" 0 0) "run" 1000000 (ClockInfo SameHost 1000)
withLedger config \writer -> record writer Produced "key" 1 "one" KeyMap.empty
[path] <- fmap (directory </>) <$> listDirectory directory
appendFile path "{\"schema\":\"kenshou.ledger-fact/v1\""
ledger <- discoverLedgers directory
count <- foldFacts ledger (0 :: Int) (\value _ -> pure (value + 1))
count `shouldBe` 1
describe "external sort" do
it "matches an in-memory sort across many runs" $ withSystemTempDirectory "kenshou-sort" \directory -> do
let ledgerDir = directory </> "ledger"
config = LedgerConfig ledgerDir (ProcId "writer" 0 0) "run" 10000000 (ClockInfo SameHost 1000)
facts = [1000, 999 .. 1 :: Int64]
withLedger config \writer -> forM_ facts \number -> record writer Produced (Text.pack (show (number `mod` 13))) number (Text.pack (show number)) KeyMap.empty
ledger <- discoverLedgers ledgerDir
collected <- newIORef []
sortedFacts (SortConfig (ledgerDir </> ".sort") 17 8) ByKeySeq (const True) ledger \source -> drain source collected
actual <- readIORef collected
fmap (\fact -> (fact.key, fact.seq)) actual `shouldBe` sortOn id [(Text.pack (show (number `mod` 13)), number) | number <- facts]
describe "invariant checkers" do
let cases =
[ ("no-loss", noLoss "no-loss" Contract "consumer", cleanDelivery, [fact Produced "producer" 1 1 mempty]),
("duplicates", duplicatesWithin "duplicates" Contract "consumer" (DuplicateBudget (Just 0) Nothing) [], [fact Observed "consumer" 1 1 mempty], [fact Observed "consumer" 1 1 mempty, fact Observed "consumer" 2 1 mempty]),
("per-key-order", perKeyOrder "per-key-order" Contract "consumer", [fact Observed "consumer" 1 1 mempty, fact Observed "consumer" 2 2 mempty], [fact Observed "consumer" 1 2 mempty, fact Observed "consumer" 2 1 mempty]),
("global-order", globalOrder "global-order" Contract "consumer" "gp", [fact Observed "consumer" 1 1 (gp 1), fact Observed "consumer" 2 2 (gp 2)], [fact Observed "consumer" 1 1 (gp 2), fact Observed "consumer" 2 2 (gp 1)]),
("gapless", gaplessPositions "gapless" Implementation, [fact Produced "producer" 1 1 mempty, fact Produced "producer" 2 2 mempty], [fact Produced "producer" 1 1 mempty, fact Produced "producer" 2 3 mempty]),
("effects", exactlyNEffects "effects" Contract 1, [fact Effect "consumer" 1 1 mempty], [fact Effect "consumer" 1 1 mempty, fact Effect "consumer" 2 1 mempty]),
("quiescence", eventualQuiescence "quiescence" Contract (Deadline 1000), [fact Produced "producer" 1 1 mempty, fact Terminal "consumer" 2 1 mempty], [fact Produced "producer" 1 1 mempty]),
("checkpoint", monotonicCheckpoints "checkpoint" Contract, [fact Checkpoint "consumer" 1 1 mempty, fact Checkpoint "consumer" 2 2 mempty], [fact Checkpoint "consumer" 1 2 mempty, fact Checkpoint "consumer" 2 1 mempty]),
("ownership", disjointOwnership "ownership" Contract, [fact Acquired "owner-a" 1 1 mempty, fact Acted "owner-a" 2 1 mempty, fact Released "owner-a" 3 1 mempty], [fact Acquired "owner-a" 1 1 mempty, fact Acquired "owner-b" 2 1 mempty, fact Acted "owner-a" 3 1 mempty])
]
forM_ cases \(label, checker, heldFacts, violatedFacts) -> do
it (label <> " holds for valid facts") $ (evaluateChecker checker heldFacts).status `shouldBe` Held
it (label <> " rejects a targeted mutation") $ (evaluateChecker checker violatedFacts).status `shouldBe` Violated
it (label <> " refuses a vacuous pass") $ (evaluateChecker checker []).status `shouldBe` NotEvaluated
describe "process supervisor" do
it "releases retired children before supervisor cleanup" $ withSystemTempDirectory "kenshou-retirement" \directory -> do
runId <- newRunId
state <- newRunState
let scenario = either (error . show) id (parseScenarioId "selftest/check/process/retirement")
knobs = either (error . show) id (resolveKnobs [] [])
seed = either (error . show) id (mkSeed 0)
runContext = RunContext runId scenario knobs emptyDimensions seed zeroPhases (Environment Nothing mempty mempty) (minimalRunSpec scenario).environment Nothing directory nullLogger state
withCheck runContext \environment -> withSupervisor environment \supervisor -> do
weak <- retireFixture supervisor
performMajorGC
(isNothing <$> deRefWeak weak) `shouldReturn` True
windows <- crashWindows supervisor
length windows `shouldBe` 1
describe "linearizability" do
it "accepts and rejects register histories" do
let valid = [Operation "p1" "register" (WriteRegister 1) 0 (Just 1) (Returned Written), Operation "p2" "register" ReadRegister 2 (Just 3) (Returned (ReadValue (Just 1)))]
invalid = [Operation "p1" "register" (WriteRegister 1) 0 (Just 1) (Returned Written), Operation "p2" "register" ReadRegister 2 (Just 3) (Returned (ReadValue Nothing))]
checkLinearizable defaultLinConfig registerModel valid `shouldBe` Linearizable
checkLinearizable defaultLinConfig registerModel invalid `shouldSatisfy` isRejected
it "accepts and rejects append-log histories" do
let valid = [Operation "p1" "log" (Append "a") 0 (Just 1) (Returned (Appended 0)), Operation "p2" "log" ReadLog 2 (Just 3) (Returned (LogContents ["a"]))]
invalid = [Operation "p1" "log" (Append "a") 0 (Just 1) (Returned (Appended 0)), Operation "p2" "log" ReadLog 2 (Just 3) (Returned (LogContents []))]
checkLinearizable defaultLinConfig appendLogModel valid `shouldBe` Linearizable
checkLinearizable defaultLinConfig appendLogModel invalid `shouldSatisfy` isRejected
drain :: FactSource -> IORef [Fact] -> IO ()
drain source output =
source.next >>= \case
Nothing -> pure ()
Just fact -> modifyIORef' output (<> [fact]) >> drain source output
fact :: FactKind -> Text.Text -> Word -> Int64 -> Object -> Fact
fact kind scope n sequenceNumber attrs = Fact kind "key" sequenceNumber "item" scope (ProcId scope 0 0) (fromIntegral n) (fromIntegral n) (fromIntegral n * 100) attrs
gp :: Int64 -> Object
gp value = KeyMap.singleton (Key.fromText "gp") (Number (fromIntegral value))
cleanDelivery :: [Fact]
cleanDelivery = [fact Intent "producer" 1 1 mempty, fact Produced "producer" 2 1 mempty, fact Observed "consumer" 3 1 mempty]
isRejected :: LinResult -> Bool
isRejected (NotLinearizable _) = True
isRejected _ = False
-- Keep the caller from retaining the fixture across the major collection.
{-# NOINLINE retireFixture #-}
retireFixture :: Supervisor -> IO (Weak Child)
retireFixture supervisor = do
child <- spawn supervisor (ProcessSpec (ProcId "retirement" 0 0) "kenshou-check-fixture-worker" [] [] Nothing)
weak <- mkWeakPtr child Nothing
killChild supervisor child
pure weak