Files
home-assistant-controller/test/HallwaySpec.hs
T
2026-11-03 14:47:01 +02:00

212 lines
8.7 KiB
Haskell

{-# LANGUAGE OverloadedStrings #-}
module HallwaySpec (spec) where
import AFRP (Event (..))
import qualified Data.Text as T
import Data.Aeson (Value)
import Data.Bool (bool)
import Data.Default (def)
import Data.List (scanl')
import Data.Time (UTCTime, addUTCTime)
import HomeAssistant.Controller
import HomeAssistant.Controller.Hallway
import Support
import Test.Hspec
import Test.Hspec.Hedgehog
import qualified Hedgehog.Gen as Gen
import qualified Hedgehog.Range as Range
day, night :: UTCTime
day = clock 10 0 -- 10:00, outside sleep hours
night = clock 21 0 -- 21:00, inside sleep hours (20:30 - 07:30)
motionSensor :: T.Text -> Event Value
motionSensor = Event . stateEvent "binary_sensor.hallway_movement_occupancy"
masterDoor :: T.Text -> Event Value
masterDoor = Event . stateEvent "binary_sensor.makuuhuone_ovi_contact"
childrenDoor :: T.Text -> Event Value
childrenDoor = Event . stateEvent "binary_sensor.lasten_makuuhuone_ovi_contact"
-- Same shape as the generator in PresenceSpec: mostly short gaps (< 500s
-- timeout), occasionally a 600s gap so presence can expire and the room can
-- become unoccupied again.
data TestEvent = TestEvent Int (Event Bool)
deriving Show
genTestEvent :: Gen TestEvent
genTestEvent = TestEvent
<$> Gen.frequency [(8, Gen.integral (Range.linear 0 20)), (2, pure 600)]
<*> Gen.frequency [(3, pure Tick), (1, Event <$> Gen.bool)]
-- | Presence and both of its presence-derived triggers, observed in lock-step
-- over the same motion stream, so the triggers can be judged against the
-- intermediate presence value at each step.
presenceProbe :: HASS (Event Value) (Presence, Event (), Event ())
presenceProbe = (,,) <$> hallwayPresence <*> lightsOnTrigger <*> lightsOffTrigger
-- | Expected firing steps: every step that *enters* `target`. The implicit
-- state before the first step is Unoccupied — the room starts unoccupied —
-- so an Unoccupied-trigger never fires at the first step.
edgeSteps :: Presence -> [Presence] -> [Int]
edgeSteps target ps =
[ i
| (i, (prev, p)) <- zip [0 ..] (zip (Unoccupied : ps) ps)
, prev /= target
, p == target
]
spec :: Spec
spec = describe "Hallway" $ do
lightsSpec
presenceTransitionSpec
modeTriggerSpec
presenceTransitionSpec :: Spec
presenceTransitionSpec = describe "presenceTriggers" $
it "fires exactly on the corresponding presence transitions" $ hedgehog $ do
events <- forAll $ Gen.list (Range.linear 0 100) genTestEvent
let steps = drop 1 $ scanl' (flip addUTCTime) day [fromIntegral t | TestEvent t _ <- events]
timed = values (runHASSTimed presenceProbe
(zipWith (\t (TestEvent _ e) ->
(t, stateEvent "binary_sensor.hallway_movement_occupancy" . bool "off" "on" <$> e))
steps events))
presences = [p | (p, _, _) <- timed]
onSteps = [i | (i, (_, Event (), _)) <- zip [0 ..] timed]
offSteps = [i | (i, (_, _, Event ())) <- zip [0 ..] timed]
onSteps === edgeSteps Occupied presences
offSteps === edgeSteps Unoccupied presences
cover 30 "at least one unoccupied -> occupied transition" (not (null onSteps))
cover 30 "at least one occupied -> unoccupied transition" (not (null offSteps))
-- | Presence, the chosen mode and the mode-adjustment trigger observed in
-- lock-step over the same event stream.
modeProbe :: HASS (Event Value) (Presence, Mode, Event Mode)
modeProbe = (,,) <$> hallwayPresence <*> mode <*> modeTrigger
data ModeAction
= Motion Bool -- ^ @True@ is motion detected
| MasterDoor Bool -- ^ @True@ is closed
| ChildrenDoor Bool -- ^ @True@ is closed
| Idle
deriving Show
data ModeEvent = ModeEvent Int ModeAction
deriving Show
genModeEvent :: Gen ModeEvent
genModeEvent = ModeEvent
<$> Gen.frequency [(6, Gen.integral (Range.linear 0 15)), (1, pure 900)]
<*> Gen.frequency [(4, Motion <$> Gen.bool)
,(2, MasterDoor <$> Gen.bool)
,(2, ChildrenDoor <$> Gen.bool)
,(2, pure Idle)
]
modeEventValue :: ModeAction -> Event Value
modeEventValue (Motion b) = Event $ stateEvent "binary_sensor.hallway_movement_occupancy" (bool "off" "on" b)
modeEventValue (MasterDoor b) = Event $ stateEvent "binary_sensor.makuuhuone_ovi_contact" (bool "off" "on" b)
modeEventValue (ChildrenDoor b) = Event $ stateEvent "binary_sensor.lasten_makuuhuone_ovi_contact" (bool "off" "on" b)
modeEventValue Idle = Tick
-- | The mode-adjustment trigger: the presence-based lights are already on
-- (room occupied), the world changed which lights should be on, so adjust.
-- The first observed mode is the baseline the lights-on trigger already
-- acted on, so it is not an adjustment.
modeTriggerSpec :: Spec
modeTriggerSpec = describe "modeTrigger" $
it "fires exactly on occupied steps that change the mode, tagged with the new mode" $ hedgehog $ do
events <- forAll $ Gen.list (Range.linear 0 100) genModeEvent
let steps = drop 1 $ scanl' (flip addUTCTime) (clock 20 0) [fromIntegral t | ModeEvent t _ <- events]
timed = values (runHASSTimed modeProbe
(zipWith (\t (ModeEvent _ a) -> (t, modeEventValue a)) steps events))
modes = [m | (_, m, _) <- timed]
-- The previous mode; at the first step it is the mode itself, since
-- the first observed mode is the baseline the lights-on trigger
-- already acted on, not an adjustment.
prior = case modes of [] -> []; m0 : _ -> m0 : init modes
expected =
[ i
| (i, (prevM, (p, m, _))) <- zip [0 ..] (zip prior timed)
, prevM /= m
, p == Occupied
]
suppressed =
[ () | (prevM, (p, m, _)) <- zip prior timed
, p == Unoccupied
, prevM /= m
]
fired = [i | (i, (_, _, Event _)) <- zip [0 ..] timed]
tags = [(i, tag) | (i, (_, _, Event tag)) <- zip [0 ..] timed]
fired === expected
tags === [(i, m) | i <- expected, let m = modes !! i]
cover 25 "fires at least once" (not (null fired))
cover 25 "suppressed a mode change while unoccupied" (not (null suppressed))
cover 25 "reaches quiet mode" (Quiet `elem` modes)
lightsSpec :: Spec
lightsSpec = do
describe "hallwayLightsController" $ do
it "turns the full lights on when someone enters during daytime" $
services (runHASSTimed hallwayLightsController [(day, motionSensor "on")])
`shouldBe` [[light [EntityId "light.hallway_lights"] (On def)]]
it "turns the full lights on when someone enters during daytime preceding tick" $
services (runHASSTimed hallwayLightsController [(day, Tick), (day, motionSensor "on")])
`shouldBe` [[], [light [EntityId "light.hallway_lights"] (On def)]]
it "turns the lights off when everyone leaves, without sleep mode" $
let later = 505 `addUTCTime` day
in services (runHASSTimed hallwayLightsController
[ (day, Tick)
, (day, motionSensor "on")
, (day, motionSensor "off")
, (later, Tick)
])
`shouldBe` [ []
, [light [EntityId "light.hallway_lights"] (On def)]
, []
, [light [EntityId "light.hallway_lights"] Off]
]
it "turns on only the ceiling light when entering during sleep hours with a door open" $
services (runHASSTimed hallwayLightsController
[ (night, Tick)
, (night, masterDoor "on")
, (night, motionSensor "on")
])
`shouldBe` [ []
, []
, [light [EntityId "light.hallway_ceiling_2"] (On def)]
]
it "sets the lower hallway light off when a door is opened during sleep hours" $
services (runHASSTimed hallwayLightsController
[ (night, masterDoor "off")
, (night, childrenDoor "off")
, (night, motionSensor "on")
, (night, masterDoor "on")
])
`shouldBe` [ []
, []
, [light [EntityId "light.hallway_lights"] (On def)]
, [light [EntityId "light.hallway_ceiling"] Off]
]
it "turns the lower hallway light on when the doors close while presence is active" $
services (runHASSTimed hallwayLightsController
[ (night, masterDoor "on")
, (night, motionSensor "on")
, (night, masterDoor "off")
, (night, childrenDoor "off")
])
`shouldBe` [ []
, [light [EntityId "light.hallway_ceiling_2"] (On def)]
, []
, [light [EntityId "light.hallway_ceiling"] (On def)]
]