redis-0.10: Test/SetCommands.hs

module Test.SetCommands where

import Test.HUnit
import Control.Monad.Reader
import Data.Maybe
import Data.Set
import Database.Redis.Redis
import Test.Setup
import Test.Utils

tests = TestList [TestLabel "smembers" test_smembers,
                  TestLabel "sismember" test_sismember,
                  TestLabel "sadd" test_sadd,
                  TestLabel "srem" test_srem,
                  TestLabel "spop" test_spop,
                  TestLabel "smove" test_smove,
                  TestLabel "scard" test_scard,
                  TestLabel "srandmember" test_srandmember,
                  TestLabel "sinter and sinterStore" test_sinter_sinterstore,
                  TestLabel "sunion and sunionStore" test_sunion_sunionstore,
                  TestLabel "sdiff and sdiffStore" test_sdiff_sdiffstore]

asSet :: Reply String -> IO (Set (Maybe String))
asSet r = fromRMultiBulk r >>= return . fromList . fromJust
        
test_smembers = TestCase $ testRedis $
    do r <- ask
       addSet
       liftIO $ do s <- smembers r "set" >>= asSet
                   assertEqual "" (fromList [Just "1", Just "2", Just "3"]) s

test_sismember = TestCase $ testRedis $
    do r <- ask
       addSet
       liftIO $ do sismember r "set" "1" >>= fromRInt >>= assertEqual "" 1
                   sismember r "set" "0" >>= fromRInt >>= assertEqual "" 0
                   sismember r "no-such-key" "1" >>= fromRInt >>= assertEqual "" 0

test_sadd = TestCase $ testRedis $
    do r <- ask
       addSet
       liftIO $ do s <- smembers r "set" >>= asSet
                   sadd r "set" "3" >>= fromRInt >>= assertEqual "element allready exists" 0
                   sadd r "set" "4" >>= fromRInt >>= assertEqual "" 1
                   s' <- smembers r "set" >>= asSet
                   assertEqual "" (insert (Just "4") s) s'

test_srem = TestCase $ testRedis $
    do r <- ask
       addSet
       liftIO $ do s <- smembers r "set" >>= asSet
                   srem r "set" "4" >>= fromRInt >>= assertEqual "element is not a member" 0
                   srem r "set" "3" >>= fromRInt >>= assertEqual "" 1
                   s' <- smembers r "set" >>= asSet
                   assertEqual "" (delete (Just "3") s) s'

test_spop = TestCase $ testRedis $
    do r <- ask
       addSet
       liftIO $ do s <- smembers r "set" >>= asSet
                   el <- spop r "set" >>= fromRBulk :: IO (Maybe String)
                   assertBool "" $ member el s
                   s' <- smembers r "set" >>= asSet
                   assertEqual "" (delete el s) s'

test_smove = TestCase $ testRedis $
    do r <- ask
       addSet
       liftIO $ do s <- smembers r "set" >>= asSet
                   smove r "set" "set2" "3" >>= fromRInt >>= assertEqual "" 1
                   s' <- smembers r "set" >>= asSet
                   assertEqual "" (delete (Just "3") s) s'
                   s' <- smembers r "set2" >>= asSet
                   assertEqual "" (fromList [Just "3"]) s'

test_scard = TestCase $ testRedis $
    do r <- ask
       addSet
       liftIO $ do s <- smembers r "set" >>= asSet
                   scard r "set" >>= fromRInt >>= assertEqual "" (size s)

test_srandmember = TestCase $ testRedis $
    do r <- ask
       addSet
       liftIO $ do s <- smembers r "set" >>= asSet
                   el <- srandmember r "set" >>= fromRBulk
                   assertBool "" $ member el s

test_sinter_sinterstore = TestCase $ testRedis $
    do r <- ask
       addSet
       liftIO $ do mapM_ (sadd r "set2") ["2", "3", "4"]
                   s <- smembers r "set" >>= asSet
                   s2 <- smembers r "set2" >>= asSet
                   s3 <- sinter r ["set", "set2"] >>= asSet
                   assertEqual "" (intersection s s2) s3
                   sinterStore r "set3" ["set", "set2"] >>= fromRInt >>= assertEqual "" (size s3)
                   smembers r "set3" >>= asSet >>= assertEqual "" s3
                   sinterStore r "set3" ["set", "set4"] >>= fromRInt >>= assertEqual "" 0

test_sunion_sunionstore = TestCase $ testRedis $
    do r <- ask
       addSet
       liftIO $ do mapM_ (sadd r "set2") ["3", "4", "5"]
                   s <- smembers r "set" >>= asSet
                   s2 <- smembers r "set2" >>= asSet
                   s3 <- sunion r ["set", "set2"] >>= asSet
                   assertEqual "" (union s s2) s3
                   sunionStore r "set3" ["set", "set2"] >>= fromRInt >>= assertEqual "" (size s3)
                   smembers r "set3" >>= asSet >>= assertEqual "" s3
                   sunionStore r "set3" ["set", "set4"] >>= fromRInt >>= assertEqual "" (size s)

test_sdiff_sdiffstore = TestCase $ testRedis $
    do r <- ask
       addSet
       liftIO $ do mapM_ (sadd r "set2") ["3", "4", "5"]
                   s <- smembers r "set" >>= asSet
                   s2 <- smembers r "set2" >>= asSet
                   s3 <- sdiff r ["set", "set2"] >>= asSet
                   assertEqual "" (difference s s2) s3
                   sdiffStore r "set3" ["set", "set2"] >>= fromRInt >>= assertEqual "" (size s3)
                   smembers r "set3" >>= asSet >>= assertEqual "" s3
                   sdiffStore r "set3" ["set", "set4"] >>= fromRInt >>= assertEqual "" (size s)