summaryrefslogtreecommitdiff
path: root/tests/Language/GraphQL/Execute/OrderedMapSpec.hs
blob: fd33316ae61db9943a61330199619fe6f8b74e02 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
{- This Source Code Form is subject to the terms of the Mozilla Public License,
   v. 2.0. If a copy of the MPL was not distributed with this file, You can
   obtain one at https://mozilla.org/MPL/2.0/. -}

{-# LANGUAGE OverloadedStrings #-}

module Language.GraphQL.Execute.OrderedMapSpec
    ( spec
    ) where

import Language.GraphQL.Execute.OrderedMap (OrderedMap)
import qualified Language.GraphQL.Execute.OrderedMap as OrderedMap
import Test.Hspec (Spec, describe, it, shouldBe, shouldSatisfy)

spec :: Spec
spec =
    describe "OrderedMap" $ do
        it "creates an empty map" $
            (mempty :: OrderedMap String) `shouldSatisfy` null

        it "creates a singleton" $
            let value :: String
                value = "value"
             in OrderedMap.size (OrderedMap.singleton "key" value) `shouldBe` 1

        it "combines inserted vales" $
            let key = "key"
                map1 = OrderedMap.singleton key ("1" :: String)
                map2 = OrderedMap.singleton key ("2" :: String)
             in OrderedMap.lookup key (map1 <> map2) `shouldBe` Just "12"

        it "shows the map" $
            let actual = show
                    $ OrderedMap.insert "key1" "1"
                    $ OrderedMap.singleton "key2" ("2" :: String)
                expected = "fromList [(\"key2\",\"2\"),(\"key1\",\"1\")]"
             in actual `shouldBe` expected

        it "traverses a map of just values" $
            let actual = sequence
                    $ OrderedMap.insert "key1" (Just "2")
                    $ OrderedMap.singleton "key2" $ Just ("1" :: String)
                expected = Just
                    $ OrderedMap.insert "key1" "2"
                    $ OrderedMap.singleton "key2" ("1" :: String)
             in actual `shouldBe` expected

        it "traverses a map with a Nothing" $
            let actual = sequence
                    $ OrderedMap.insert "key1" Nothing
                    $ OrderedMap.singleton "key2" $ Just ("1" :: String)
                expected = Nothing
             in actual `shouldBe` expected

        it "combines two maps preserving the order of the second one" $
            let map1 :: OrderedMap String
                map1 = OrderedMap.insert "key2" "2"
                    $ OrderedMap.singleton "key1" "1"
                map2 :: OrderedMap String
                map2 = OrderedMap.insert "key4" "4"
                    $ OrderedMap.singleton "key3" "3"
                expected = OrderedMap.insert "key4" "4"
                    $ OrderedMap.insert "key3" "3"
                    $ OrderedMap.insert "key2" "2"
                    $ OrderedMap.singleton "key1" "1"
             in (map1 <> map2) `shouldBe` expected