forked from OSS/graphql
120 lines
5.2 KiB
Haskell
120 lines
5.2 KiB
Haskell
{-# LANGUAGE OverloadedStrings #-}
|
|
module Language.GraphQL.Execute.CoerceSpec
|
|
( spec
|
|
) where
|
|
|
|
import Data.Aeson as Aeson ((.=))
|
|
import qualified Data.Aeson as Aeson
|
|
import qualified Data.Aeson.Types as Aeson
|
|
import Data.HashMap.Strict (HashMap)
|
|
import qualified Data.HashMap.Strict as HashMap
|
|
import Data.Maybe (isNothing)
|
|
import Data.Scientific (scientific)
|
|
import qualified Data.Set as Set
|
|
import Language.GraphQL.AST.Core
|
|
import Language.GraphQL.Execute.Coerce
|
|
import Language.GraphQL.Schema
|
|
import Language.GraphQL.Type.Definition
|
|
import qualified Language.GraphQL.Type.In as In
|
|
import Prelude hiding (id)
|
|
import Test.Hspec (Spec, describe, it, shouldBe, shouldSatisfy)
|
|
|
|
direction :: EnumType
|
|
direction = EnumType "Direction" Nothing
|
|
$ Set.fromList ["NORTH", "EAST", "SOUTH", "WEST"]
|
|
|
|
coerceInputLiteral :: InputType -> In.Value -> Maybe Subs
|
|
coerceInputLiteral input value = coerceInputLiterals
|
|
(HashMap.singleton "variableName" input)
|
|
(HashMap.singleton "variableName" value)
|
|
|
|
lookupActual :: Maybe (HashMap Name In.Value) -> Maybe In.Value
|
|
lookupActual = (HashMap.lookup "variableName" =<<)
|
|
|
|
singletonInputObject :: InputType
|
|
singletonInputObject = ObjectInputType type'
|
|
where
|
|
type' = InputObjectType "ObjectName" Nothing inputFields
|
|
inputFields = HashMap.singleton "field" field
|
|
field = InputField Nothing (ScalarInputType string) Nothing
|
|
|
|
spec :: Spec
|
|
spec = do
|
|
describe "ToGraphQL Aeson" $ do
|
|
it "coerces strings" $
|
|
let expected = Just (In.String "asdf")
|
|
actual = coerceVariableValue
|
|
(ScalarInputType string) (Aeson.String "asdf")
|
|
in actual `shouldBe` expected
|
|
it "coerces non-null strings" $
|
|
let expected = Just (In.String "asdf")
|
|
actual = coerceVariableValue
|
|
(NonNullScalarInputType string) (Aeson.String "asdf")
|
|
in actual `shouldBe` expected
|
|
it "coerces booleans" $
|
|
let expected = Just (In.Boolean True)
|
|
actual = coerceVariableValue
|
|
(ScalarInputType boolean) (Aeson.Bool True)
|
|
in actual `shouldBe` expected
|
|
it "coerces zero to an integer" $
|
|
let expected = Just (In.Int 0)
|
|
actual = coerceVariableValue
|
|
(ScalarInputType int) (Aeson.Number 0)
|
|
in actual `shouldBe` expected
|
|
it "rejects fractional if an integer is expected" $
|
|
let actual = coerceVariableValue
|
|
(ScalarInputType int) (Aeson.Number $ scientific 14 (-1))
|
|
in actual `shouldSatisfy` isNothing
|
|
it "coerces float numbers" $
|
|
let expected = Just (In.Float 1.4)
|
|
actual = coerceVariableValue
|
|
(ScalarInputType float) (Aeson.Number $ scientific 14 (-1))
|
|
in actual `shouldBe` expected
|
|
it "coerces IDs" $
|
|
let expected = Just (In.String "1234")
|
|
actual = coerceVariableValue
|
|
(ScalarInputType id) (Aeson.String "1234")
|
|
in actual `shouldBe` expected
|
|
it "coerces input objects" $
|
|
let actual = coerceVariableValue singletonInputObject
|
|
$ Aeson.object ["field" .= ("asdf" :: Aeson.Value)]
|
|
expected = Just $ In.Object $ HashMap.singleton "field" "asdf"
|
|
in actual `shouldBe` expected
|
|
it "skips the field if it is missing in the variables" $
|
|
let actual = coerceVariableValue
|
|
singletonInputObject Aeson.emptyObject
|
|
expected = Just $ In.Object HashMap.empty
|
|
in actual `shouldBe` expected
|
|
it "fails if input object value contains extra fields" $
|
|
let actual = coerceVariableValue singletonInputObject
|
|
$ Aeson.object variableFields
|
|
variableFields =
|
|
[ "field" .= ("asdf" :: Aeson.Value)
|
|
, "extra" .= ("qwer" :: Aeson.Value)
|
|
]
|
|
in actual `shouldSatisfy` isNothing
|
|
it "preserves null" $
|
|
let actual = coerceVariableValue (ScalarInputType id) Aeson.Null
|
|
in actual `shouldBe` Just In.Null
|
|
it "preserves list order" $
|
|
let list = Aeson.toJSONList ["asdf" :: Aeson.Value, "qwer"]
|
|
listType = (ListInputType $ ScalarInputType string)
|
|
actual = coerceVariableValue listType list
|
|
expected = Just $ In.List [In.String "asdf", In.String "qwer"]
|
|
in actual `shouldBe` expected
|
|
|
|
describe "coerceInputLiterals" $ do
|
|
it "coerces enums" $
|
|
let expected = Just (In.Enum "NORTH")
|
|
actual = coerceInputLiteral
|
|
(EnumInputType direction) (In.Enum "NORTH")
|
|
in lookupActual actual `shouldBe` expected
|
|
it "fails with non-existing enum value" $
|
|
let actual = coerceInputLiteral
|
|
(EnumInputType direction) (In.Enum "NORTH_EAST")
|
|
in actual `shouldSatisfy` isNothing
|
|
it "coerces integers to IDs" $
|
|
let expected = Just (In.String "1234")
|
|
actual = coerceInputLiteral (ScalarInputType id) (In.Int 1234)
|
|
in lookupActual actual `shouldBe` expected
|