OSS/graphql
1
1
Fork 1
Code Issues 6 Pull Requests Actions Releases 22 Wiki Activity
09135c581a
graphql/tests/Test/StarWars/QuerySpec.hs

367 lines
11 KiB
Haskell
Raw Normal View History

Split StarWars tests in different modules
2016-02-12 13:27:46 +01:00
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
module Test.StarWars.QuerySpec
( spec
) where
Split StarWars tests in different modules
2016-02-12 13:27:46 +01:00
Introduce monad transformer for resolvers Now the errors in the resolvers can be handled and 3 tests throwing errors pass now. Another test fail but it requires distinguisching nullable and non-nullable values.
2019-07-02 20:07:26 +02:00
import qualified Data.Aeson as Aeson
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
import Data.Aeson ((.=))
import qualified Data.HashMap.Strict as HashMap
Split StarWars tests in different modules
2016-02-12 13:27:46 +01:00
import Data.Text (Text)
Change the main namespace to Language.GraphQL
2019-07-07 06:31:53 +02:00
import Language.GraphQL
Split StarWars tests in different modules
2016-02-12 13:27:46 +01:00
import Text.RawString.QQ (r)
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
import Test.Hspec.Expectations (Expectation, shouldBe)
import Test.Hspec (Spec, describe, it)
Split StarWars tests in different modules
2016-02-12 13:27:46 +01:00
import Test.StarWars.Schema
-- * Test
-- See https://github.com/graphql/graphql-js/blob/master/src/__tests__/starWarsQueryTests.js
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
spec :: Spec
spec = describe "Star Wars Query Tests" $ do
describe "Basic Queries" $ do
it "R2-D2 hero" $ testQuery
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
[r| query HeroNameQuery {
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
hero {
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
id
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
}
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
}
|]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
$ Aeson.object
[ "data" .= Aeson.object
[ "hero" .= Aeson.object ["id" .= ("2001" :: Text)]
]
]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
it "R2-D2 ID and friends" $ testQuery
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
[r| query HeroNameAndFriendsQuery {
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
hero {
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
id
name
friends {
Don't fail on invalid fragments and variables
2020-05-23 06:46:21 +02:00
name
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
}
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
}
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
}
|]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
$ Aeson.object [ "data" .= Aeson.object [
"hero" .= Aeson.object
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
[ "id" .= ("2001" :: Text)
, r2d2Name
, "friends" .=
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
[ Aeson.object [lukeName]
, Aeson.object [hanName]
, Aeson.object [leiaName]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
]
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
]
Added exception handling with Alternative constraint according to spec.
2016-03-12 00:59:51 +01:00
]]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
describe "Nested Queries" $ do
it "R2-D2 friends" $ testQuery
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
[r| query NestedQuery {
hero {
name
friends {
name
appearsIn
Coerce result Fixes #45.
2020-06-13 07:20:19 +02:00
friends {
name
}
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
}
}
}
|]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
$ Aeson.object [ "data" .= Aeson.object [
"hero" .= Aeson.object [
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
"name" .= ("R2-D2" :: Text)
, "friends" .= [
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
Aeson.object [
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
"name" .= ("Luke Skywalker" :: Text)
Coerce result Fixes #45.
2020-06-13 07:20:19 +02:00
, "appearsIn" .= ["NEW_HOPE", "EMPIRE", "JEDI" :: Text]
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
, "friends" .= [
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
Aeson.object [hanName]
, Aeson.object [leiaName]
, Aeson.object [c3poName]
, Aeson.object [r2d2Name]
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
]
]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
, Aeson.object [
adds the starwars tests for fragments Also refactors some deplicate objects into a where clause
2016-07-08 22:10:58 +02:00
hanName
Coerce result Fixes #45.
2020-06-13 07:20:19 +02:00
, "appearsIn" .= ["NEW_HOPE", "EMPIRE", "JEDI" :: Text]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
, "friends" .=
[ Aeson.object [lukeName]
, Aeson.object [leiaName]
, Aeson.object [r2d2Name]
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
]
]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
, Aeson.object [
adds the starwars tests for fragments Also refactors some deplicate objects into a where clause
2016-07-08 22:10:58 +02:00
leiaName
Coerce result Fixes #45.
2020-06-13 07:20:19 +02:00
, "appearsIn" .= ["NEW_HOPE", "EMPIRE", "JEDI" :: Text]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
, "friends" .=
[ Aeson.object [lukeName]
, Aeson.object [hanName]
, Aeson.object [c3poName]
, Aeson.object [r2d2Name]
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
]
]
]
]
Added exception handling with Alternative constraint according to spec.
2016-03-12 00:59:51 +01:00
]]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
it "Luke ID" $ testQuery
Clean up StarWars test queries
2016-02-15 11:19:05 +01:00
[r| query FetchLukeQuery {
human(id: "1000") {
name
}
}
|]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
$ Aeson.object [ "data" .= Aeson.object
[ "human" .= Aeson.object [lukeName]
]]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
it "Luke ID with variable" $ testQueryParams
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
(HashMap.singleton "someId" "1000")
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
[r| query FetchSomeIDQuery($someId: String!) {
human(id: $someId) {
name
Add remaining tests with variables in arguments The test with invalid ID is commented out until proper exception handling is implemented.
2016-02-17 12:35:54 +01:00
}
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
}
|]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
$ Aeson.object [ "data" .= Aeson.object [
"human" .= Aeson.object [lukeName]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
]]
it "Han ID with variable" $ testQueryParams
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
(HashMap.singleton "someId" "1002")
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
[r| query FetchSomeIDQuery($someId: String!) {
human(id: $someId) {
name
When argument is not found return null The relevant test was restored too.
2017-03-04 00:39:03 +01:00
}
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
}
|]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
$ Aeson.object [ "data" .= Aeson.object [
"human" .= Aeson.object [hanName]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
]]
it "Invalid ID" $ testQueryParams
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
(HashMap.singleton "id" "Not a valid ID")
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
[r| query humanQuery($id: String!) {
human(id: $id) {
name
Initial support for aliases in `execute`
2016-02-17 12:59:35 +01:00
}
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
}
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
|] $ Aeson.object ["data" .= Aeson.object ["human" .= Aeson.Null]]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
it "Luke aliased" $ testQuery
[r| query FetchLukeAliased {
luke: human(id: "1000") {
name
}
}
|]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
$ Aeson.object [ "data" .= Aeson.object [
"luke" .= Aeson.object [lukeName]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
]]
it "R2-D2 ID and friends aliased" $ testQuery
[r| query HeroNameAndFriendsQuery {
hero {
id
name
friends {
friendName: name
Overhaul Schema DSL Aside of making the definition of Schemas easier, it takes care of issues like nested aliases which previously wasn't possible. The naming of the DSL functions is still provisional.
2016-02-17 18:13:10 +01:00
}
}
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
}
|]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
$ Aeson.object [ "data" .= Aeson.object [
"hero" .= Aeson.object [
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
"id" .= ("2001" :: Text)
, r2d2Name
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
, "friends" .=
[ Aeson.object ["friendName" .= ("Luke Skywalker" :: Text)]
, Aeson.object ["friendName" .= ("Han Solo" :: Text)]
, Aeson.object ["friendName" .= ("Leia Organa" :: Text)]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
]
]
]]
it "Luke and Leia aliased" $ testQuery
[r| query FetchLukeAndLeiaAliased {
luke: human(id: "1000") {
name
Initial support for aliases in `execute`
2016-02-17 12:59:35 +01:00
}
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
leia: human(id: "1003") {
name
}
}
|]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
$ Aeson.object [ "data" .= Aeson.object
[ "luke" .= Aeson.object [lukeName]
, "leia" .= Aeson.object [leiaName]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
]]
describe "Fragments for complex queries" $ do
it "Aliases to query for duplicate content" $ testQuery
adds the starwars tests for fragments Also refactors some deplicate objects into a where clause
2016-07-08 22:10:58 +02:00
[r| query DuplicateFields {
luke: human(id: "1000") {
name
homePlanet
}
leia: human(id: "1003") {
name
homePlanet
}
}
|]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
$ Aeson.object [ "data" .= Aeson.object [
"luke" .= Aeson.object [lukeName, tatooine]
, "leia" .= Aeson.object [leiaName, alderaan]
Added exception handling with Alternative constraint according to spec.
2016-03-12 00:59:51 +01:00
]]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
it "Fragment for duplicate content" $ testQuery
adds the starwars tests for fragments Also refactors some deplicate objects into a where clause
2016-07-08 22:10:58 +02:00
[r| query UseFragment {
luke: human(id: "1000") {
...HumanFragment
}
leia: human(id: "1003") {
...HumanFragment
}
}
fragment HumanFragment on Human {
name
homePlanet
}
|]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
$ Aeson.object [ "data" .= Aeson.object [
"luke" .= Aeson.object [lukeName, tatooine]
, "leia" .= Aeson.object [leiaName, alderaan]
adds the starwars tests for fragments Also refactors some deplicate objects into a where clause
2016-07-08 22:10:58 +02:00
]]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
describe "__typename" $ do
it "R2D2 is a Droid" $ testQuery
adds __typename tests to starwars testfile
2016-07-08 22:36:45 +02:00
[r| query CheckTypeOfR2 {
hero {
__typename
name
}
}
|]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
$ Aeson.object ["data" .= Aeson.object [
"hero" .= Aeson.object
[ "__typename" .= ("Droid" :: Text)
, r2d2Name
]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
]]
it "Luke is a human" $ testQuery
adds __typename tests to starwars testfile
2016-07-08 22:36:45 +02:00
[r| query CheckTypeOfLuke {
hero(episode: EMPIRE) {
__typename
name
}
}
|]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
$ Aeson.object ["data" .= Aeson.object [
"hero" .= Aeson.object
[ "__typename" .= ("Human" :: Text)
, lukeName
]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
]]
describe "Errors in resolvers" $ do
it "error on secretBackstory" $ testQuery
Introduce monad transformer for resolvers Now the errors in the resolvers can be handled and 3 tests throwing errors pass now. Another test fail but it requires distinguisching nullable and non-nullable values.
2019-07-02 20:07:26 +02:00
[r|
query HeroNameQuery {
hero {
name
add tests for errors in queries for queries in starwars tests
2016-07-08 23:50:31 +02:00
secretBackstory
}
Introduce monad transformer for resolvers Now the errors in the resolvers can be handled and 3 tests throwing errors pass now. Another test fail but it requires distinguisching nullable and non-nullable values.
2019-07-02 20:07:26 +02:00
}
|]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
$ Aeson.object
[ "data" .= Aeson.object
[ "hero" .= Aeson.object
Introduce monad transformer for resolvers Now the errors in the resolvers can be handled and 3 tests throwing errors pass now. Another test fail but it requires distinguisching nullable and non-nullable values.
2019-07-02 20:07:26 +02:00
[ "name" .= ("R2-D2" :: Text)
, "secretBackstory" .= Aeson.Null
]
]
, "errors" .=
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
[ Aeson.object
Introduce monad transformer for resolvers Now the errors in the resolvers can be handled and 3 tests throwing errors pass now. Another test fail but it requires distinguisching nullable and non-nullable values.
2019-07-02 20:07:26 +02:00
["message" .= ("secretBackstory is secret." :: Text)]
]
]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
it "Error in a list" $ testQuery
add tests for errors in queries for queries in starwars tests
2016-07-08 23:50:31 +02:00
[r| query HeroNameQuery {
hero {
name
friends {
name
secretBackstory
}
}
}
|]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
$ Aeson.object ["data" .= Aeson.object
[ "hero" .= Aeson.object
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
[ "name" .= ("R2-D2" :: Text)
, "friends" .=
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
[ Aeson.object
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
[ "name" .= ("Luke Skywalker" :: Text)
, "secretBackstory" .= Aeson.Null
]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
, Aeson.object
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
[ "name" .= ("Han Solo" :: Text)
, "secretBackstory" .= Aeson.Null
]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
, Aeson.object
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
[ "name" .= ("Leia Organa" :: Text)
, "secretBackstory" .= Aeson.Null
]
]
]
Introduce monad transformer for resolvers Now the errors in the resolvers can be handled and 3 tests throwing errors pass now. Another test fail but it requires distinguisching nullable and non-nullable values.
2019-07-02 20:07:26 +02:00
]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
, "errors" .=
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
[ Aeson.object
[ "message" .= ("secretBackstory is secret." :: Text)
]
, Aeson.object
[ "message" .= ("secretBackstory is secret." :: Text)
]
, Aeson.object
[ "message" .= ("secretBackstory is secret." :: Text)
]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
]
]
it "error on secretBackstory with alias" $ testQuery
add tests for errors in queries for queries in starwars tests
2016-07-08 23:50:31 +02:00
[r| query HeroNameQuery {
mainHero: hero {
name
story: secretBackstory
}
}
|]
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
$ Aeson.object
[ "data" .= Aeson.object
[ "mainHero" .= Aeson.object
Introduce monad transformer for resolvers Now the errors in the resolvers can be handled and 3 tests throwing errors pass now. Another test fail but it requires distinguisching nullable and non-nullable values.
2019-07-02 20:07:26 +02:00
[ "name" .= ("R2-D2" :: Text)
, "story" .= Aeson.Null
]
]
, "errors" .=
Replace substitution function with a map It makes using variables with queries more approachable, but some work still has to be done. - The type `Subs` should be renamed and moved out of `Schema`, together with `AST.Core.Value` probably. - Some kind of conversion should be possible from a user-defined input type T to the Value. So the final HashMap should have a type like `HashMap name a`, where a is an instance of a potential typeclass InputType.
2019-12-30 18:26:24 +01:00
[ Aeson.object
[ "message" .= ("secretBackstory is secret." :: Text)
]
Introduce monad transformer for resolvers Now the errors in the resolvers can be handled and 3 tests throwing errors pass now. Another test fail but it requires distinguisching nullable and non-nullable values.
2019-07-02 20:07:26 +02:00
]
]
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
adds the starwars tests for fragments Also refactors some deplicate objects into a where clause
2016-07-08 22:10:58 +02:00
where
lukeName = "name" .= ("Luke Skywalker" :: Text)
leiaName = "name" .= ("Leia Organa" :: Text)
hanName = "name" .= ("Han Solo" :: Text)
adds __typename tests to starwars testfile
2016-07-08 22:36:45 +02:00
r2d2Name = "name" .= ("R2-D2" :: Text)
c3poName = "name" .= ("C-3PO" :: Text)
adds the starwars tests for fragments Also refactors some deplicate objects into a where clause
2016-07-08 22:10:58 +02:00
tatooine = "homePlanet" .= ("Tatooine" :: Text)
alderaan = "homePlanet" .= ("Alderaan" :: Text)
Overhaul Schema DSL Aside of making the definition of Schemas easier, it takes care of issues like nested aliases which previously wasn't possible. The naming of the DSL functions is still provisional.
2016-02-17 18:13:10 +01:00
Replace tasty and HUnit with Hspec
2019-07-10 05:57:35 +02:00
testQuery :: Text -> Aeson.Value -> Expectation
Constrain base monad to MonadCatch Let's try MonadThrow/MonadCatch. It looks nice at a first glance. The monad transformer stack contains only the ReaderT, less lifts are required. Exception subtyping is easier, the user can (and should) define custom error types and throw them. And it is still possible to use pure error handling, if someone doesn't like runtime exceptions or need to run a query in a pure environment. Fixes #42.
2020-07-17 07:05:03 +02:00
testQuery q expected =
let Right actual = graphql schema q
in actual `shouldBe` expected
Overhaul Schema DSL Aside of making the definition of Schemas easier, it takes care of issues like nested aliases which previously wasn't possible. The naming of the DSL functions is still provisional.
2016-02-17 18:13:10 +01:00
Coerce variable values
2020-05-21 10:20:59 +02:00
testQueryParams :: Aeson.Object -> Text -> Aeson.Value -> Expectation
Replace MonadIO constraint with just Monad And make the tests use Identity instead of IO.
2020-02-01 20:46:35 +01:00
testQueryParams f q expected =
Constrain base monad to MonadCatch Let's try MonadThrow/MonadCatch. It looks nice at a first glance. The monad transformer stack contains only the ReaderT, less lifts are required. Exception subtyping is easier, the user can (and should) define custom error types and throw them. And it is still possible to use pure error handling, if someone doesn't like runtime exceptions or need to run a query in a pure environment. Fixes #42.
2020-07-17 07:05:03 +02:00
let Right actual = graphqlSubs schema Nothing f q
in actual `shouldBe` expected
Reference in New Issue Copy Permalink