73 lines
2.9 KiB
Haskell
73 lines
2.9 KiB
Haskell
{- 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.GraphQLSpec
|
|
( spec
|
|
) where
|
|
|
|
import Data.HashMap.Strict (HashMap)
|
|
import qualified Data.HashMap.Strict as HashMap
|
|
import Language.GraphQL.AST (Name)
|
|
import Language.GraphQL.Error
|
|
import qualified Language.GraphQL.Type as Type
|
|
import Language.GraphQL.Type
|
|
import qualified Language.GraphQL.Type.In as In
|
|
import qualified Language.GraphQL.Type.Out as Out
|
|
import Prelude hiding (id)
|
|
import Test.Hspec (Spec, describe, it, shouldBe)
|
|
import qualified Data.Text as Text
|
|
import Test.Hspec.Expectations
|
|
( Expectation
|
|
, expectationFailure
|
|
)
|
|
import Language.GraphQL (graphql)
|
|
|
|
queryType :: Out.ObjectType IO
|
|
queryType = Out.ObjectType "Query" Nothing []
|
|
$ HashMap.fromList
|
|
[ ("sequence", ValueResolver sequenceField sequenceResolver)
|
|
]
|
|
where
|
|
sequenceField =
|
|
let fieldType = Out.ListType $ Out.NonNullScalarType int
|
|
in Out.Field Nothing fieldType $ HashMap.fromList
|
|
[("values", In.Argument Nothing (In.NonNullListType $ In.NonNullScalarType int) Nothing)]
|
|
sequenceResolver = argument "values"
|
|
|
|
testSchema :: Schema IO
|
|
testSchema =
|
|
schemaWithTypes Nothing queryType Nothing Nothing mempty mempty
|
|
|
|
shouldResolveTo :: Text.Text -> HashMap Name Type.Value -> Response Type.Value -> Expectation
|
|
shouldResolveTo querySource variables expected = do
|
|
response <- graphql testSchema Nothing variables querySource
|
|
case response of
|
|
(Right result) -> result `shouldBe` expected
|
|
Left _ -> expectationFailure
|
|
"the query is expected to resolve to a value, but it resolved to an event stream"
|
|
|
|
spec :: Spec
|
|
spec =
|
|
describe "value to singleton list coercion" $ do
|
|
it "coerces a value to a singleton list" $
|
|
let data'' = Object $ HashMap.singleton "sequence" $ Type.List [Type.Int 5]
|
|
expected = Response data'' mempty
|
|
sourceQuery = "{ sequence(values: 5) }"
|
|
in shouldResolveTo sourceQuery HashMap.empty expected
|
|
|
|
it "coerces a variable to a singleton list" $
|
|
let variables = HashMap.singleton "values" $ Type.Int 5
|
|
data'' = Object $ HashMap.singleton "sequence" $ Type.List [Type.Int 5]
|
|
expected = Response data'' mempty
|
|
sourceQuery = "query($values: [Int!]!) { sequence(values: $values) }"
|
|
in shouldResolveTo sourceQuery variables expected
|
|
|
|
it "accepts a singleton list" $
|
|
let data'' = Object $ HashMap.singleton "sequence" $ Type.List [Type.Int 5]
|
|
expected = Response data'' mempty
|
|
sourceQuery = "{ sequence(values: [5]) }"
|
|
in shouldResolveTo sourceQuery HashMap.empty expected
|