MaitreDTests.hs

module MaitreDTests
    ( tryAcceptBehavesCorrectlyWhenItCanAccept
    , tryAcceptBehavesCorrectlyWhenItCanNotAccept
    ) where

import           Control.Monad      (liftM2)
import           Data.Maybe         (isNothing)
import           Data.Time          (LocalTime (..), ZonedTime (..), midnight,
                                     utc)
import           Data.Time.Calendar (fromGregorian, gregorianMonthLength)
import           MaitreD

import           Hedgehog
import qualified Hedgehog.Gen       as Gen
import qualified Hedgehog.Range     as Range

genZonedTime :: Monad m => Gen m ZonedTime
genZonedTime = do
    y <- Gen.int (Range.linear 1 9999)
    m <- Gen.int (Range.linear 1 12)
    d <- Gen.int (Range.linear 1 (gregorianMonthLength (toInteger y) m))
    return $ ZonedTime (LocalTime (fromGregorian (toInteger y) m d) midnight) utc

genReservation :: Monad m => Gen m Reservation
genReservation = do
  bookingDate <- genZonedTime
  positiveQty <- Gen.int (Range.linear 1 99)
  trueOrFalse <- Gen.bool
  return Reservation
    { date       = bookingDate
    , quantity   = positiveQty
    , isAccepted = trueOrFalse }

sumBy :: Num a => (b -> a) -> [b] -> a
sumBy x xs = sum $ map x xs

tryAcceptBehavesCorrectlyWhenItCanAccept :: Property
tryAcceptBehavesCorrectlyWhenItCanAccept =
  property $ do
    reservation    <- forAll genReservation
    reservations   <- forAll $ Gen.list (Range.linear 0 100) genReservation
    excessCapacity <- forAll $ Gen.filter (>= 0) $ Gen.int (Range.linear 1 99)
    let capacity = excessCapacity
                   + sumBy quantity reservations
                   + quantity reservation

        actual = tryAccept capacity reservations reservation

    Just (reservation { isAccepted = True }) === actual

tryAcceptBehavesCorrectlyWhenItCanNotAccept :: Property
tryAcceptBehavesCorrectlyWhenItCanNotAccept =
  property $ do
    reservation     <- forAll genReservation
    reservations    <- forAll $ Gen.list (Range.linear 0 100) genReservation
    lackingCapacity <- forAll $ Gen.filter (> 0) $ Gen.int (Range.linear 1 99)
    let capacity = sumBy quantity reservations - lackingCapacity

        actual = tryAccept capacity reservations reservation

    Nothing === actual