kenshou-core-0.1.0.0: src/Kenshou/Plan/Summary.hs
{-# LANGUAGE FieldSelectors #-}
module Kenshou.Plan.Summary
( EntryStatus (..),
Attempt (..),
SummaryEntry (..),
PlanSummary (..),
emptySummary,
worstOutcome,
summaryExitCode,
finalizeSummary,
writeSummary,
)
where
import Data.Aeson
import Data.Aeson.Types (Parser)
import Data.ByteString.Lazy qualified as LazyByteString
import Data.Map.Strict (Map)
import Data.Map.Strict qualified as Map
import Data.Text (Text)
import Data.Time (UTCTime)
import Kenshou.Core.Id (RunId, ScenarioId)
import Kenshou.Core.Outcome (Outcome (..), outcomeExitCode, renderOutcome)
import System.Directory (renameFile)
import System.Exit (ExitCode (..))
data EntryStatus = Pending | Running | Completed deriving stock (Eq, Show)
data Attempt = Attempt
{ runId :: RunId,
startedAt :: UTCTime,
finishedAt :: Maybe UTCTime,
outcome :: Maybe Outcome,
knownDefect :: Bool,
childExitCode :: Maybe Int
}
deriving stock (Eq, Show)
data SummaryEntry = SummaryEntry
{ ordinal :: Int,
scenario :: ScenarioId,
status :: EntryStatus,
attempts :: [Attempt]
}
deriving stock (Eq, Show)
data PlanSummary = PlanSummary
{ planId :: RunId,
entries :: [SummaryEntry],
counts :: Map Text Int,
worst :: Outcome,
exitCode :: Int
}
deriving stock (Eq, Show)
emptySummary :: RunId -> [(Int, ScenarioId)] -> PlanSummary
emptySummary planId entries = finalizeSummary (PlanSummary planId [SummaryEntry ordinal scenario Pending [] | (ordinal, scenario) <- entries] Map.empty Passed 0)
worstOutcome :: PlanSummary -> Outcome
worstOutcome summary = case blocking of
[] -> Passed
values -> foldl1 worse values
where
blocking = concatMap entryOutcome summary.entries
entryOutcome entry
| entry.status /= Completed = [Errored]
| otherwise = case reverse entry.attempts of
attempt : _ | attempt.knownDefect -> []
attempt : _ -> maybe [Errored] pure attempt.outcome
[] -> [Errored]
worse left right = if rank left >= rank right then left else right
rank Passed = (0 :: Int)
rank Inconclusive = 1
rank InfrastructureFailure = 2
rank Errored = 3
rank Failed = 4
summaryExitCode :: PlanSummary -> ExitCode
summaryExitCode summary = case outcomeExitCode (worstOutcome summary) of 0 -> ExitSuccess; value -> ExitFailure value
finalizeSummary :: PlanSummary -> PlanSummary
finalizeSummary summary = summary {counts = outcomeCounts, worst, exitCode = outcomeExitCode worst}
where
worst = worstOutcome summary
latest = [attempt | entry <- summary.entries, attempt <- take 1 (reverse entry.attempts)]
outcomes = [outcome | attempt <- latest, not attempt.knownDefect, Just outcome <- [attempt.outcome]]
defectCount = length (filter (.knownDefect) latest)
outcomeCounts = Map.fromListWith (+) ([(renderOutcome outcome, 1) | outcome <- outcomes] <> [("known-defect", defectCount) | defectCount > 0])
writeSummary :: FilePath -> PlanSummary -> IO ()
writeSummary path summary = do
let temporary = path <> ".tmp"
LazyByteString.writeFile temporary (encode (finalizeSummary summary))
renameFile temporary path
instance ToJSON PlanSummary where
toJSON summary = object ["schema" .= ("kenshou.plan-summary/v1" :: Text), "planId" .= summary.planId, "entries" .= summary.entries, "counts" .= summary.counts, "worstOutcome" .= summary.worst, "exitCode" .= summary.exitCode]
instance FromJSON PlanSummary where
parseJSON = withObject "PlanSummary" \value -> do
schema <- value .: "schema"
if schema /= ("kenshou.plan-summary/v1" :: Text) then fail "unsupported plan summary schema" else pure ()
PlanSummary <$> value .: "planId" <*> value .: "entries" <*> value .:? "counts" .!= Map.empty <*> value .:? "worstOutcome" .!= Passed <*> value .:? "exitCode" .!= 0
instance ToJSON SummaryEntry where
toJSON entry = object ["ordinal" .= entry.ordinal, "scenario" .= entry.scenario, "status" .= renderStatus entry.status, "attempts" .= entry.attempts]
instance FromJSON SummaryEntry where
parseJSON = withObject "SummaryEntry" \value -> SummaryEntry <$> value .: "ordinal" <*> value .: "scenario" <*> (value .: "status" >>= parseStatus) <*> value .:? "attempts" .!= []
instance ToJSON Attempt where
toJSON attempt = object ["runId" .= attempt.runId, "startedAt" .= attempt.startedAt, "finishedAt" .= attempt.finishedAt, "outcome" .= attempt.outcome, "knownDefect" .= attempt.knownDefect, "childExitCode" .= attempt.childExitCode]
instance FromJSON Attempt where
parseJSON = withObject "Attempt" \value -> Attempt <$> value .: "runId" <*> value .: "startedAt" <*> value .:? "finishedAt" <*> value .:? "outcome" <*> value .:? "knownDefect" .!= False <*> value .:? "childExitCode"
renderStatus :: EntryStatus -> Text
renderStatus Pending = "pending"
renderStatus Running = "running"
renderStatus Completed = "completed"
parseStatus :: Text -> Parser EntryStatus
parseStatus "pending" = pure Pending
parseStatus "running" = pure Running
parseStatus "completed" = pure Completed
parseStatus other = fail ("unknown entry status " <> show other)