packages feed

kenshou-core-0.1.0.0: src/Kenshou/Core/Scenario.hs

module Kenshou.Core.Scenario
  ( Tier (..),
    Placement (..),
    KnownDefect (..),
    individualKnownDefects,
    CohortScope (..),
    PackageCondition (..),
    cohortScopeApplies,
    ScenarioReport (..),
    Scenario (..),
    renderTier,
    renderPlacement,
    passed,
    failedWith,
    inconclusiveBecause,
    infrastructureFailureBecause,
  )
where

import Data.List.NonEmpty (NonEmpty)
import Data.Text (Text)
import Data.Text qualified as Text
import Data.Version (parseVersion)
import Kenshou.Core.Cohort (CohortIdentity (..), PackageSource (..), ResolvedComponent (..), ResolvedPackage (..))
import Kenshou.Core.Context (RunContext)
import Kenshou.Core.Dimension (DimensionSupport)
import Kenshou.Core.Env (EnvRequirements)
import Kenshou.Core.Id (ScenarioId)
import Kenshou.Core.Knob (KnobSpec)
import Kenshou.Core.Outcome (Outcome (..))
import Kenshou.Core.Phase (PhasePlan)
import Text.ParserCombinators.ReadP (readP_to_S)

data Tier = TierSmoke | TierStandard | TierExtended | TierSoak deriving stock (Eq, Ord, Show)

data Placement = PlaceLocal | PlaceCell | PlaceEither deriving stock (Eq, Ord, Show)

data KnownDefect
  = KnownDefect
      { reference :: Text,
        summary :: Text,
        expectedFailures :: [Text],
        appliesTo :: CohortScope
      }
  | KnownDefectGroup (NonEmpty KnownDefect)
  deriving stock (Eq, Show)

individualKnownDefects :: KnownDefect -> [KnownDefect]
individualKnownDefects (KnownDefectGroup defects) = concatMap individualKnownDefects defects
individualKnownDefects defect = [defect]

data CohortScope = AllCohorts | OnlyWhen (NonEmpty PackageCondition) deriving stock (Eq, Show)

data PackageCondition
  = ResolvedFromHackage Text
  | ResolvedFromGit Text
  | VersionBelow Text Text
  | RevisionIs Text Text
  deriving stock (Eq, Show)

cohortScopeApplies :: CohortIdentity -> CohortScope -> Bool
cohortScopeApplies _ AllCohorts = True
cohortScopeApplies cohort (OnlyWhen conditions) = all (conditionApplies packages) conditions
  where
    packages = concatMap (.resolvedComponentPackages) cohort.identityComponents

conditionApplies :: [ResolvedPackage] -> PackageCondition -> Bool
conditionApplies packages condition = any matches packages
  where
    matches package = case condition of
      ResolvedFromHackage name -> package.resolvedPackageName == name && case package.resolvedPackageSource of FromHackage _ -> True; _ -> False
      ResolvedFromGit name -> package.resolvedPackageName == name && case package.resolvedPackageSource of FromGit _ _ _ -> True; _ -> False
      VersionBelow name boundary -> package.resolvedPackageName == name && maybe False (uncurry (<)) ((,) <$> parse package.resolvedPackageVersion <*> parse boundary)
      RevisionIs name revision -> package.resolvedPackageName == name && case package.resolvedPackageSource of FromGit _ actual _ -> actual == revision; _ -> False
    parse value = case [version | (version, "") <- readP_to_S parseVersion (Text.unpack value)] of [] -> Nothing; versions -> Just (last versions)

data ScenarioReport = ScenarioReport
  { outcome :: Outcome,
    reason :: Maybe Text,
    failures :: [Text]
  }
  deriving stock (Eq, Show)

data Scenario = Scenario
  { id :: ScenarioId,
    revision :: Int,
    summary :: Text,
    tier :: Tier,
    placement :: Placement,
    knobs :: [KnobSpec],
    dimensions :: DimensionSupport,
    phases :: PhasePlan,
    requires :: EnvRequirements,
    knownDefect :: Maybe KnownDefect,
    run :: RunContext -> IO ScenarioReport
  }

renderTier :: Tier -> Text
renderTier TierSmoke = "smoke"
renderTier TierStandard = "standard"
renderTier TierExtended = "extended"
renderTier TierSoak = "soak"

renderPlacement :: Placement -> Text
renderPlacement PlaceLocal = "local"
renderPlacement PlaceCell = "cell"
renderPlacement PlaceEither = "either"

passed :: ScenarioReport
passed = ScenarioReport Passed Nothing []

failedWith :: [Text] -> Text -> ScenarioReport
failedWith labels message = ScenarioReport Failed (Just message) labels

inconclusiveBecause :: Text -> ScenarioReport
inconclusiveBecause message = ScenarioReport Inconclusive (Just message) []

infrastructureFailureBecause :: Text -> ScenarioReport
infrastructureFailureBecause message = ScenarioReport InfrastructureFailure (Just message) []