WVar.hs

module Test.WVar where

import qualified Test.Hspec      as HS
import qualified Test.QuickCheck as Q

import qualified Control.Concurrent.WVar as WV

import qualified Control.Monad as M

withLatestCache ::
    (IO (v, v, WV.WVar v, WV.WCached v) -> r) -> IO (v, WV.WVar v) -> r
withLatestCache f prepare = f prepare'
    where
        prepare' = do
            (val, wv) <- prepare
            wc        <- WV.cacheWVar wv
            return (val, val, wv, wc)

whenWVarIsFresh ::
    (IO (Int, WV.WVar Int) -> HS.Spec) -> HS.Spec
whenWVarIsFresh f = HS.describe "when WVar is fresh" $ f prepare
    where
        prepare = do
            val <- Q.generate Q.arbitrary
            wv  <- WV.newWVar val
            return (val, wv)

whenWVarIsUpdating :: Q.Arbitrary v =>
    (IO (v, WV.WVar v) -> HS.Spec) -> HS.Spec
whenWVarIsUpdating f = HS.describe "when WVar is updating" $ f prepare
    where
        prepare = do
            val <- Q.generate Q.arbitrary
            wv  <- WV.newWVar val
            M.void $ WV.takeWVar wv
            return (val, wv)

whenWVarIsFreshButCacheStaled :: (Eq v, Q.Arbitrary v) =>
    (IO (v, v, WV.WVar v, WV.WCached v) -> HS.Spec) -> HS.Spec
whenWVarIsFreshButCacheStaled f =
    HS.describe "when WVar is fresh but cache staled" $ f prepare
    where
        prepare = do
            val1 <- Q.generate Q.arbitrary
            val2 <- Q.generate $ Q.arbitrary `Q.suchThat` (/= val1)
            wv   <- WV.newWVar val1
            wc   <- WV.cacheWVar wv
            WV.putWVar wv val2
            return (val1, val2, wv, wc)

whenWVarIsUpdatingAndCacheStaled :: (Eq v, Q.Arbitrary v) =>
    (IO (v, v, WV.WVar v, WV.WCached v) -> HS.Spec) -> HS.Spec
whenWVarIsUpdatingAndCacheStaled f =
    HS.describe "when WVar is updating and cache staled" $ f prepare
    where
        prepare = do
            val <- Q.generate Q.arbitrary
            wv  <- WV.newWVar val
            wc  <- WV.cacheWVar wv
            M.void $ WV.takeWVar wv
            return (val, val, wv, wc)