module Database.Redis.Tests
    ( tests ) where


------------------------------------------------------------------------------
-- import           Data.ByteString.Char8 (ByteString)
-- import qualified Data.ByteString.Char8 as B
-- import qualified Data.ByteString.Lazy.Char8 as L
-- import           Data.Maybe
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-link ping"          pingTest
        , testCase "redis-link itemSet"       itemSetTest
        , testCase "redis-link itemGet"       itemGetTest
        , testCase "redis-link keyExists"     keyExistsTest
        , testCase "redis-link keyType"       keyTypeTest
        , testCase "redis-link listRightPush" listRightPushTest
        , testCase "redis-link listLeftPush"  listLeftPushTest
        , testCase "redis-link listIndex"     listIndexTest
        , testCase "redis-link listLength"    listLengthTest
        , testCase "redis-link listRange"     listRangeTest
        , testCase "redis-link setAdd"        setAddTest
        , testCase "redis-link setContains"   setContainsTest
        , testCase "redis-link setMembers"    setMembersTest
        , testCase "redis-link setRemove"     setRemoveTest
        ]


------------------------------------------------------------------------------
pingTest :: H.Assertion
pingTest = do
    con <- connect localhost defaultPort
    returning <- ping con
    disconnect con
    H.assertEqual "ping" (Just $ RedisSingle $ toUTF8 "PONG") returning


------------------------------------------------------------------------------
itemSetTest :: H.Assertion
itemSetTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    returning <- itemSet con "akey" "ἐστίν"
    _ <- keyDelete con "akey"
    disconnect con
    H.assertEqual "itemSet" (Just $ RedisSingle $ toUTF8 "OK") returning


------------------------------------------------------------------------------
itemGetTest :: H.Assertion
itemGetTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    _ <- itemSet con "differentKey" "ἐστίν"
    returning <- itemGet con "differentKey"
    _ <- keyDelete con "differentKey"
    disconnect con
    H.assertEqual "itemGet" (Just $ RedisBulk [Just (RedisSingle $ toUTF8 "ἐστίν")]) returning


------------------------------------------------------------------------------
keyExistsTest :: H.Assertion
keyExistsTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    _ <- itemSet con "thekey" "thevalue"
    returning <- keyExists con "thekey"
    _ <- keyDelete con "thekey"
    disconnect con
    H.assertEqual "keyExistsTest" (Just $ RedisInteger 1) returning


------------------------------------------------------------------------------
keyTypeTest :: H.Assertion
keyTypeTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    _ <- itemSet con "typekey" "typevalue"
    returning <- keyType con "typekey"
    _ <- keyDelete con "typekey"
    disconnect con
    H.assertEqual "keyTypeTest" (Just $ RedisSingle $ toUTF8 "string") returning


------------------------------------------------------------------------------
listRightPushTest :: H.Assertion
listRightPushTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    returning <- listRightPush con "thelist" "theitem"
    _ <- keyDelete con "thelist"
    disconnect con
    H.assertBool "listRightPush" $ case returning of
                                     Just (RedisInteger _) -> True
                                     _                     -> False


------------------------------------------------------------------------------
listLeftPushTest :: H.Assertion
listLeftPushTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    returning <- listLeftPush con "leftlist" "anitem"
    _ <- keyDelete con "leftlist"
    disconnect con
    H.assertBool "listLeftPush" $ case returning of
                                     Just (RedisInteger _) -> True
                                     _                     -> False


------------------------------------------------------------------------------
listLengthTest :: H.Assertion
listLengthTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    _ <- listRightPush con "lengthlist" "anitem"
    _ <- listRightPush con "lengthlist" "anitem"
    returning <- listLength con "lengthlist"
    _ <- keyDelete con "lengthlist"
    disconnect con
    H.assertEqual "listLeftPush" (Just $ RedisInteger 2) returning


------------------------------------------------------------------------------
listIndexTest :: H.Assertion
listIndexTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    _ <- listRightPush con "indexlist" "theitem"
    returning <- listIndex con "indexlist" 0
    _ <- keyDelete con "indexlist"
    disconnect con
    H.assertEqual "listIndex"
      (Just $ RedisBulk [Just (RedisSingle $ toUTF8 "theitem")])
      returning


------------------------------------------------------------------------------
listRangeTest :: H.Assertion
listRangeTest = do
    con <- connect localhost defaultPort
    _ <- select con 0
    _ <- listRightPush con "alist" "value0"
    _ <- listRightPush con "alist" "value1"
    returning <- listRange con "alist" 0 1
    _ <- keyDelete con "alist"
    disconnect con
    H.assertEqual "listRange"
      (Just (RedisBulk [Just (RedisBulk [Just (RedisSingle $ toUTF8 "value0")])
      ,Just (RedisBulk [Just (RedisSingle $ toUTF8 "value1")])
      ,Nothing]))
      returning


------------------------------------------------------------------------------
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


------------------------------------------------------------------------------
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


------------------------------------------------------------------------------
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 "setkey"
    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