module Database.Redis.Set.Tests
    ( tests ) where


------------------------------------------------------------------------------
import           Test.Framework (Test)
import           Test.Framework.Providers.HUnit
-- import           Test.Framework.Providers.QuickCheck2
import qualified Test.HUnit as H
-- import           Test.QuickCheck
-- import           Test.QuickCheck.Monadic

import           Database.Redis


------------------------------------------------------------------------------
-- N.B. These aren't proper tests yet, just checks


------------------------------------------------------------------------------
tests :: [Test]
tests = [ testCase "redis setAdd"         setAddTest
        , testCase "redis setAddB"        setAddBTest
        , testCase "redis setContains"    setContainsTest
        , testCase "redis setContainsB"   setContainsBTest
        , testCase "redis setMembers"     setMembersTest
        , testCase "redis setMembersB"    setMembersBTest
        , testCase "redis setRemove"      setRemoveTest
        , testCase "redis setRemoveB"     setRemoveBTest
        , testCase "redis setRandMember"  setRandMemberTest
        , testCase "redis setRandMemberB" setRandMemberBTest
        ]


------------------------------------------------------------------------------
setAddTest :: H.Assertion
setAddTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    returning <- setAdd con "theset" "bob"
    _ <- keyDelete con ["theset"]
    disconnect con
    H.assertEqual "setAdd" (Just $ RedisInteger 1) returning


------------------------------------------------------------------------------
setAddBTest :: H.Assertion
setAddBTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    returning <- setAddB con (toUTF8 "thebset") (toUTF8 "bob")
    _ <- keyDelete con ["thebset"]
    disconnect con
    H.assertEqual "setAddB" (Just $ RedisInteger 1) returning


------------------------------------------------------------------------------
setContainsTest :: H.Assertion
setContainsTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    _ <- setAdd con "setkey" "bob"
    returning <- setContains con "setkey" "bob"
    _ <- keyDelete con ["setkey"]
    disconnect con
    H.assertEqual "setContains" (Just $ RedisInteger 1) returning


------------------------------------------------------------------------------
setContainsBTest :: H.Assertion
setContainsBTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    _ <- setAdd con "setbkey" "bob"
    returning <- setContainsB con (toUTF8 "setbkey") (toUTF8 "bob")
    _ <- keyDelete con ["setbkey"]
    disconnect con
    H.assertEqual "setContainsB" (Just $ RedisInteger 1) returning


------------------------------------------------------------------------------
setMembersTest :: H.Assertion
setMembersTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    _ <- setAdd con "nameset" "Bob"
    _ <- setAdd con "nameset" "Jane"
    returning <- setMembers con "nameset"
    _ <- keyDelete con ["nameset"]
    disconnect con
    H.assertEqual "setContains"
      (Just (RedisBulk [Just (RedisBulk [Just (RedisSingle $ toUTF8 "Bob")])
      ,Just (RedisBulk [Just (RedisSingle $ toUTF8 "Jane")])
      ,Nothing]))
      returning


------------------------------------------------------------------------------
setMembersBTest :: H.Assertion
setMembersBTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    _ <- setAdd con "namesetb" "Bob"
    _ <- setAdd con "namesetb" "Jane"
    returning <- setMembersB con (toUTF8 "namesetb")
    _ <- keyDelete con ["namesetb"]
    disconnect con
    H.assertEqual "setContains"
      (Just (RedisBulk [Just (RedisBulk [Just (RedisSingle $ toUTF8 "Bob")])
      ,Just (RedisBulk [Just (RedisSingle $ toUTF8 "Jane")])
      ,Nothing]))
      returning


------------------------------------------------------------------------------
setRemoveTest :: H.Assertion
setRemoveTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    _ <- setAdd con "setit" "Bob"
    _ <- setAdd con "setit" "Frank"
    _ <- setAdd con "setit" "Jane"
    _ <- setRemove con "setit" "Frank"
    returning <- setMembers con "setit"
    _ <- keyDelete con ["setit"]
    disconnect con
    H.assertEqual "setRemove"
      (Just (RedisBulk [Just (RedisBulk [Just (RedisSingle $ toUTF8 "Bob")])
      ,Just (RedisBulk [Just (RedisSingle $ toUTF8 "Jane")])
      ,Nothing]))
      returning


------------------------------------------------------------------------------
setRemoveBTest :: H.Assertion
setRemoveBTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    _ <- setAdd con "setitb" "Bob"
    _ <- setAdd con "setitb" "Frank"
    _ <- setAdd con "setitb" "Jane"
    _ <- setRemoveB con (toUTF8 "setitb") (toUTF8 "Frank")
    returning <- setMembers con "setitb"
    _ <- keyDelete con ["setitb"]
    disconnect con
    H.assertEqual "setRemoveB"
      (Just (RedisBulk [Just (RedisBulk [Just (RedisSingle $ toUTF8 "Bob")])
      ,Just (RedisBulk [Just (RedisSingle $ toUTF8 "Jane")])
      ,Nothing]))
      returning


------------------------------------------------------------------------------
setRandMemberTest :: H.Assertion
setRandMemberTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    _ <- setAdd con "randset" "Bob"
    _ <- setAdd con "randset" "Jane"
    _ <- setRandMember con "nameset"
    _ <- keyDelete con ["randset"]
    disconnect con
    H.assertEqual "setContains" "blah" "blah"


------------------------------------------------------------------------------
setRandMemberBTest :: H.Assertion
setRandMemberBTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    _ <- setAdd con "randbset" "Bob"
    _ <- setAdd con "randbset" "Jane"
    _ <- setRandMemberB con (toUTF8 "nameset")
    _ <- keyDelete con ["randbset"]
    disconnect con
    H.assertEqual "setContains" "blah" "blah"