Replace gql with literals in the validation tests

1 files changed, 318 insertions, 412 deletions

diff --git a/tests/Language/GraphQL/Validate/RulesSpec.hs b/tests/Language/GraphQL/Validate/RulesSpec.hs
index 07ab2f6..c48b329 100644
--- a/tests/Language/GraphQL/Validate/RulesSpec.hs
+++ b/tests/Language/GraphQL/Validate/RulesSpec.hs
@@ -3,7 +3,6 @@
    obtain one at https://mozilla.org/MPL/2.0/. -}
 
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes #-}
 
 module Language.GraphQL.Validate.RulesSpec
     ( spec
@@ -13,7 +12,6 @@ import Data.Foldable (toList)
 import qualified Data.HashMap.Strict as HashMap
 import Data.Text (Text)
 import qualified Language.GraphQL.AST as AST
-import Language.GraphQL.TH
 import Language.GraphQL.Type
 import qualified Language.GraphQL.Type.Schema as Schema
 import qualified Language.GraphQL.AST.DirectiveLocation as DirectiveLocation
@@ -173,18 +171,16 @@ spec =
     describe "document" $ do
         context "executableDefinitionsRule" $
             it "rejects type definitions" $
-                let queryString = [gql|
-                  query getDogName {
-                    dog {
-                      name
-                      color
-                    }
-                  }
-
-                  extend type Dog {
-                    color: String
-                  }
-                |]
+                let queryString = "query getDogName {\n\
+                        \  dog {\n\
+                        \    name\n\
+                        \    color\n\
+                        \  }\n\
+                        \}\n\
+                        \\n\
+                        \extend type Dog {\n\
+                        \  color: String\n\
+                        \}"
                     expected = Error
                         { message =
                             "Definition must be OperationDefinition or \
@@ -195,15 +191,13 @@ spec =
 
         context "singleFieldSubscriptionsRule" $ do
             it "rejects multiple subscription root fields" $
-                let queryString = [gql|
-                  subscription sub {
-                    newMessage {
-                      body
-                      sender
-                    }
-                    disallowedSecondRootField
-                  }
-                |]
+                let queryString = "subscription sub {\n\
+                        \  newMessage {\n\
+                        \    body\n\
+                        \    sender\n\
+                        \  }\n\
+                        \  disallowedSecondRootField\n\
+                        \}"
                     expected = Error
                         { message =
                             "Subscription \"sub\" must select only one top \
@@ -213,19 +207,17 @@ spec =
                  in validate queryString `shouldContain` [expected]
 
             it "rejects multiple subscription root fields coming from a fragment" $
-                let queryString = [gql|
-                  subscription sub {
-                    ...multipleSubscriptions
-                  }
-
-                  fragment multipleSubscriptions on Subscription {
-                    newMessage {
-                      body
-                      sender
-                    }
-                    disallowedSecondRootField
-                  }
-                |]
+                let queryString = "subscription sub {\n\
+                        \  ...multipleSubscriptions\n\
+                        \}\n\
+                        \\n\
+                        \fragment multipleSubscriptions on Subscription {\n\
+                        \  newMessage {\n\
+                        \    body\n\
+                        \    sender\n\
+                        \  }\n\
+                        \  disallowedSecondRootField\n\
+                        \}"
                     expected = Error
                         { message =
                             "Subscription \"sub\" must select only one top \
@@ -235,26 +227,24 @@ spec =
                  in validate queryString `shouldContain` [expected]
 
             it "finds corresponding subscription fragment" $
-                let queryString = [gql|
-                  subscription sub {
-                    ...anotherSubscription
-                    ...multipleSubscriptions
-                  }
-                  fragment multipleSubscriptions on Subscription {
-                    newMessage {
-                      body
-                    }
-                    disallowedSecondRootField {
-                      sender
-                    }
-                  }
-                  fragment anotherSubscription on Subscription {
-                    newMessage {
-                      body
-                      sender
-                    }
-                  }
-                |]
+                let queryString = "subscription sub {\n\
+                        \  ...anotherSubscription\n\
+                        \  ...multipleSubscriptions\n\
+                        \}\n\
+                        \fragment multipleSubscriptions on Subscription {\n\
+                        \  newMessage {\n\
+                        \    body\n\
+                        \  }\n\
+                        \  disallowedSecondRootField {\n\
+                        \    sender\n\
+                        \  }\n\
+                        \}\n\
+                        \fragment anotherSubscription on Subscription {\n\
+                        \  newMessage {\n\
+                        \    body\n\
+                        \    sender\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Subscription \"sub\" must select only one top \
@@ -265,21 +255,19 @@ spec =
 
         context "loneAnonymousOperationRule" $
             it "rejects multiple anonymous operations" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      name
-                    }
-                  }
-
-                  query getName {
-                    dog {
-                      owner {
-                        name
-                      }
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    name\n\
+                        \  }\n\
+                        \}\n\
+                        \\n\
+                        \query getName {\n\
+                        \  dog {\n\
+                        \    owner {\n\
+                        \      name\n\
+                        \    }\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "This anonymous operation must be the only defined \
@@ -290,19 +278,17 @@ spec =
 
         context "uniqueOperationNamesRule" $
             it "rejects operations with the same name" $
-                let queryString = [gql|
-                  query dogOperation {
-                    dog {
-                      name
-                    }
-                  }
-
-                  mutation dogOperation {
-                    mutateDog {
-                      id
-                    }
-                }
-                |]
+                let queryString = "query dogOperation {\n\
+                        \  dog {\n\
+                        \    name\n\
+                        \  }\n\
+                        \}\n\
+                        \\n\
+                        \mutation dogOperation {\n\
+                        \  mutateDog {\n\
+                        \    id\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "There can be only one operation named \
@@ -313,23 +299,21 @@ spec =
 
         context "uniqueFragmentNamesRule" $
             it "rejects fragments with the same name" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      ...fragmentOne
-                    }
-                  }
-
-                  fragment fragmentOne on Dog {
-                    name
-                  }
-
-                  fragment fragmentOne on Dog {
-                    owner {
-                      name
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    ...fragmentOne\n\
+                        \  }\n\
+                        \}\n\
+                        \\n\
+                        \fragment fragmentOne on Dog {\n\
+                        \  name\n\
+                        \}\n\
+                        \\n\
+                        \fragment fragmentOne on Dog {\n\
+                        \  owner {\n\
+                        \    name\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "There can be only one fragment named \
@@ -340,13 +324,11 @@ spec =
 
         context "fragmentSpreadTargetDefinedRule" $
             it "rejects the fragment spread without a target" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      ...undefinedFragment
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    ...undefinedFragment\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Fragment target \"undefinedFragment\" is \
@@ -357,16 +339,14 @@ spec =
 
         context "fragmentSpreadTypeExistenceRule" $ do
             it "rejects fragment spreads without an unknown target type" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      ...notOnExistingType
-                    }
-                  }
-                  fragment notOnExistingType on NotInSchema {
-                    name
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    ...notOnExistingType\n\
+                        \  }\n\
+                        \}\n\
+                        \fragment notOnExistingType on NotInSchema {\n\
+                        \  name\n\
+                        \}"
                     expected = Error
                         { message =
                             "Fragment \"notOnExistingType\" is specified on \
@@ -377,13 +357,11 @@ spec =
                  in validate queryString `shouldBe` [expected]
 
             it "rejects inline fragments without a target" $
-                let queryString = [gql|
-                  {
-                    ... on NotInSchema {
-                      name
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  ... on NotInSchema {\n\
+                        \    name\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Inline fragment is specified on type \
@@ -394,16 +372,14 @@ spec =
 
         context "fragmentsOnCompositeTypesRule" $ do
             it "rejects fragments on scalar types" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      ...fragOnScalar
-                    }
-                  }
-                  fragment fragOnScalar on Int {
-                    name
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    ...fragOnScalar\n\
+                        \  }\n\
+                        \}\n\
+                        \fragment fragOnScalar on Int {\n\
+                        \  name\n\
+                        \}"
                     expected = Error
                         { message =
                             "Fragment cannot condition on non composite type \
@@ -413,13 +389,11 @@ spec =
                  in validate queryString `shouldContain` [expected]
 
             it "rejects inline fragments on scalar types" $
-                let queryString = [gql|
-                  {
-                    ... on Boolean {
-                      name
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  ... on Boolean {\n\
+                        \    name\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Fragment cannot condition on non composite type \
@@ -430,17 +404,15 @@ spec =
 
         context "noUnusedFragmentsRule" $
             it "rejects unused fragments" $
-                let queryString = [gql|
-                  fragment nameFragment on Dog { # unused
-                    name
-                  }
-
-                  {
-                    dog {
-                      name
-                    }
-                  }
-                |]
+                let queryString = "fragment nameFragment on Dog { # unused\n\
+                        \  name\n\
+                        \}\n\
+                        \\n\
+                        \{\n\
+                        \  dog {\n\
+                        \    name\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Fragment \"nameFragment\" is never used."
@@ -450,21 +422,19 @@ spec =
 
         context "noFragmentCyclesRule" $
             it "rejects spreads that form cycles" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      ...nameFragment
-                    }
-                  }
-                  fragment nameFragment on Dog {
-                    name
-                    ...barkVolumeFragment
-                  }
-                  fragment barkVolumeFragment on Dog {
-                    barkVolume
-                    ...nameFragment
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    ...nameFragment\n\
+                        \  }\n\
+                        \}\n\
+                        \fragment nameFragment on Dog {\n\
+                        \  name\n\
+                        \  ...barkVolumeFragment\n\
+                        \}\n\
+                        \fragment barkVolumeFragment on Dog {\n\
+                        \  barkVolume\n\
+                        \  ...nameFragment\n\
+                        \}"
                     error1 = Error
                         { message =
                             "Cannot spread fragment \"barkVolumeFragment\" \
@@ -483,13 +453,11 @@ spec =
 
         context "uniqueArgumentNamesRule" $
             it "rejects duplicate field arguments" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      isHousetrained(atOtherHomes: true, atOtherHomes: true)
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    isHousetrained(atOtherHomes: true, atOtherHomes: true)\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "There can be only one argument named \
@@ -500,13 +468,11 @@ spec =
 
         context "uniqueDirectiveNamesRule" $ do
             it "rejects more than one directive per location" $
-                let queryString = [gql|
-                  query ($foo: Boolean = true, $bar: Boolean = false) {
-                    dog @skip(if: $foo) @skip(if: $bar) {
-                      name
-                    }
-                  }
-                |]
+                let queryString = "query ($foo: Boolean = true, $bar: Boolean = false) {\n\
+                        \  dog @skip(if: $foo) @skip(if: $bar) {\n\
+                        \    name\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "There can be only one directive named \"skip\"."
@@ -515,24 +481,20 @@ spec =
                  in validate queryString `shouldBe` [expected]
 
             it "allows repeating repeatable directives" $
-                let queryString = [gql|
-                  query {
-                    dog @repeat @repeat {
-                      name
-                    }
-                  }
-                |]
+                let queryString = "query {\n\
+                        \  dog @repeat @repeat {\n\
+                        \    name\n\
+                        \  }\n\
+                        \}"
                  in validate queryString `shouldBe` []
 
         context "uniqueVariableNamesRule" $
             it "rejects duplicate variables" $
-                let queryString = [gql|
-                  query houseTrainedQuery($atOtherHomes: Boolean, $atOtherHomes: Boolean) {
-                    dog {
-                      isHousetrained(atOtherHomes: $atOtherHomes)
-                    }
-                  }
-                |]
+                let queryString = "query houseTrainedQuery($atOtherHomes: Boolean, $atOtherHomes: Boolean) {\n\
+                        \  dog {\n\
+                        \    isHousetrained(atOtherHomes: $atOtherHomes)\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "There can be only one variable named \
@@ -543,13 +505,11 @@ spec =
 
         context "variablesAreInputTypesRule" $
             it "rejects non-input types as variables" $
-                let queryString = [gql|
-                  query takesDogBang($dog: Dog!) {
-                    dog {
-                      isHousetrained(atOtherHomes: $dog)
-                    }
-                  }
-                |]
+                let queryString = "query takesDogBang($dog: Dog!) {\n\
+                        \  dog {\n\
+                        \    isHousetrained(atOtherHomes: $dog)\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Variable \"$dog\" cannot be non-input type \
@@ -560,17 +520,15 @@ spec =
 
         context "noUndefinedVariablesRule" $ do
             it "rejects undefined variables" $
-                let queryString = [gql|
-                  query variableIsNotDefinedUsedInSingleFragment {
-                    dog {
-                      ...isHousetrainedFragment
-                    }
-                  }
-
-                  fragment isHousetrainedFragment on Dog {
-                    isHousetrained(atOtherHomes: $atOtherHomes)
-                  }
-                |]
+                let queryString = "query variableIsNotDefinedUsedInSingleFragment {\n\
+                        \  dog {\n\
+                        \    ...isHousetrainedFragment\n\
+                        \  }\n\
+                        \}\n\
+                        \\n\
+                        \fragment isHousetrainedFragment on Dog {\n\
+                        \  isHousetrained(atOtherHomes: $atOtherHomes)\n\
+                        \}"
                     expected = Error
                         { message =
                             "Variable \"$atOtherHomes\" is not defined by \
@@ -581,13 +539,11 @@ spec =
                  in validate queryString `shouldBe` [expected]
 
             it "gets variable location inside an input object" $
-                let queryString = [gql|
-                  query {
-                    findDog (complex: { name: $name }) {
-                      name
-                    }
-                  }
-                |]
+                let queryString = "query {\n\
+                        \  findDog (complex: { name: $name }) {\n\
+                        \    name\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message = "Variable \"$name\" is not defined."
                         , locations = [AST.Location 2 29]
@@ -595,13 +551,11 @@ spec =
                  in validate queryString `shouldBe` [expected]
 
             it "gets variable location inside an array" $
-                let queryString = [gql|
-                  query {
-                    findCats (commands: [JUMP, $command]) {
-                      name
-                    }
-                  }
-                |]
+                let queryString = "query {\n\
+                        \  findCats (commands: [JUMP, $command]) {\n\
+                        \    name\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message = "Variable \"$command\" is not defined."
                         , locations = [AST.Location 2 30]
@@ -610,13 +564,11 @@ spec =
 
         context "noUnusedVariablesRule" $ do
             it "rejects unused variables" $
-                let queryString = [gql|
-                  query variableUnused($atOtherHomes: Boolean) {
-                    dog {
-                      isHousetrained
-                    }
-                  }
-                |]
+                let queryString = "query variableUnused($atOtherHomes: Boolean) {\n\
+                        \  dog {\n\
+                        \    isHousetrained\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Variable \"$atOtherHomes\" is never used in \
@@ -626,24 +578,20 @@ spec =
                  in validate queryString `shouldBe` [expected]
 
             it "detects variables in properties of input objects" $
-                let queryString = [gql|
-                  query withVar ($name: String!) {
-                    findDog (complex: { name: $name }) {
-                      name
-                    }
-                  }
-                |]
+                let queryString = "query withVar ($name: String!) {\n\
+                        \  findDog (complex: { name: $name }) {\n\
+                        \    name\n\
+                        \  }\n\
+                        \}"
                  in validate queryString `shouldBe` []
 
         context "uniqueInputFieldNamesRule" $
             it "rejects duplicate fields in input objects" $
-                let queryString = [gql|
-                  {
-                    findDog(complex: { name: "Fido", name: "Jack" }) {
-                      name
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  findDog(complex: { name: \"Fido\", name: \"Jack\" }) {\n\
+                        \    name\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "There can be only one input field named \"name\"."
@@ -653,13 +601,11 @@ spec =
 
         context "fieldsOnCorrectTypeRule" $
             it "rejects undefined fields" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      meowVolume
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    meowVolume\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Cannot query field \"meowVolume\" on type \"Dog\"."
@@ -669,15 +615,13 @@ spec =
 
         context "scalarLeafsRule" $
             it "rejects scalar fields with not empty selection set" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      barkVolume {
-                        sinceWhen
-                      }
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    barkVolume {\n\
+                        \      sinceWhen\n\
+                        \    }\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Field \"barkVolume\" must not have a selection \
@@ -688,13 +632,11 @@ spec =
 
         context "knownArgumentNamesRule" $ do
             it "rejects field arguments missing in the type" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      doesKnowCommand(command: CLEAN_UP_HOUSE, dogCommand: SIT)
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    doesKnowCommand(command: CLEAN_UP_HOUSE, dogCommand: SIT)\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Unknown argument \"command\" on field \
@@ -704,13 +646,11 @@ spec =
                  in validate queryString `shouldBe` [expected]
 
             it "rejects directive arguments missing in the definition" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      isHousetrained(atOtherHomes: true) @include(unless: false, if: true)
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    isHousetrained(atOtherHomes: true) @include(unless: false, if: true)\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Unknown argument \"unless\" on directive \
@@ -721,13 +661,11 @@ spec =
 
         context "knownDirectiveNamesRule" $
             it "rejects undefined directives" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      isHousetrained(atOtherHomes: true) @ignore(if: true)
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    isHousetrained(atOtherHomes: true) @ignore(if: true)\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message = "Unknown directive \"@ignore\"."
                         , locations = [AST.Location 3 40]
@@ -736,13 +674,11 @@ spec =
 
         context "knownInputFieldNamesRule" $
             it "rejects undefined input object fields" $
-                let queryString = [gql|
-                  {
-                    findDog(complex: { favoriteCookieFlavor: "Bacon", name: "Jack" }) {
-                      name
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  findDog(complex: { favoriteCookieFlavor: \"Bacon\", name: \"Jack\" }) {\n\
+                        \    name\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Field \"favoriteCookieFlavor\" is not defined \
@@ -753,13 +689,11 @@ spec =
 
         context "directivesInValidLocationsRule" $
             it "rejects directives in invalid locations" $
-                let queryString = [gql|
-                  query @skip(if: $foo) {
-                    dog {
-                      name
-                    }
-                  }
-                |]
+                let queryString = "query @skip(if: $foo) {\n\
+                        \  dog {\n\
+                        \    name\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Directive \"@skip\" may not be used on QUERY."
@@ -769,14 +703,12 @@ spec =
 
         context "overlappingFieldsCanBeMergedRule" $ do
             it "fails to merge fields of mismatching types" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      name: nickname
-                      name
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    name: nickname\n\
+                        \    name\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Fields \"name\" conflict because \"nickname\" and \
@@ -788,14 +720,12 @@ spec =
                  in validate queryString `shouldBe` [expected]
 
             it "fails if the arguments of the same field don't match" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      doesKnowCommand(dogCommand: SIT)
-                      doesKnowCommand(dogCommand: HEEL)
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    doesKnowCommand(dogCommand: SIT)\n\
+                        \    doesKnowCommand(dogCommand: HEEL)\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Fields \"doesKnowCommand\" conflict because they \
@@ -807,14 +737,12 @@ spec =
                  in validate queryString `shouldBe` [expected]
 
             it "fails to merge same-named field and alias" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      doesKnowCommand(dogCommand: SIT)
-                      doesKnowCommand: isHousetrained(atOtherHomes: true)
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    doesKnowCommand(dogCommand: SIT)\n\
+                        \    doesKnowCommand: isHousetrained(atOtherHomes: true)\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Fields \"doesKnowCommand\" conflict because \
@@ -826,18 +754,16 @@ spec =
                  in validate queryString `shouldBe` [expected]
 
             it "looks for fields after a successfully merged field pair" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      name
-                      doesKnowCommand(dogCommand: SIT)
-                    }
-                    dog {
-                      name
-                      doesKnowCommand: isHousetrained(atOtherHomes: true)
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    name\n\
+                        \    doesKnowCommand(dogCommand: SIT)\n\
+                        \  }\n\
+                        \  dog {\n\
+                        \    name\n\
+                        \    doesKnowCommand: isHousetrained(atOtherHomes: true)\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Fields \"doesKnowCommand\" conflict because \
@@ -850,15 +776,13 @@ spec =
 
         context "possibleFragmentSpreadsRule" $ do
             it "rejects object inline spreads outside object scope" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      ... on Cat {
-                        meowVolume
-                      }
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    ... on Cat {\n\
+                        \      meowVolume\n\
+                        \    }\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Fragment cannot be spread here as objects of type \
@@ -868,17 +792,15 @@ spec =
                  in validate queryString `shouldBe` [expected]
 
             it "rejects object named spreads outside object scope" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      ... catInDogFragmentInvalid
-                    }
-                  }
-
-                  fragment catInDogFragmentInvalid on Cat {
-                    meowVolume
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    ... catInDogFragmentInvalid\n\
+                        \  }\n\
+                        \}\n\
+                        \\n\
+                        \fragment catInDogFragmentInvalid on Cat {\n\
+                        \  meowVolume\n\
+                        \}"
                     expected = Error
                         { message =
                             "Fragment \"catInDogFragmentInvalid\" cannot be \
@@ -890,13 +812,11 @@ spec =
 
         context "providedRequiredInputFieldsRule" $
             it "rejects missing required input fields" $
-                let queryString = [gql|
-                  {
-                    findDog(complex: { name: null }) {
-                      name
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  findDog(complex: { name: null }) {\n\
+                        \    name\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Input field \"name\" of type \"DogData\" is \
@@ -907,13 +827,11 @@ spec =
 
         context "providedRequiredArgumentsRule" $ do
             it "checks for (non-)nullable arguments" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      doesKnowCommand(dogCommand: null)
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    doesKnowCommand(dogCommand: null)\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Field \"doesKnowCommand\" argument \"dogCommand\" \
@@ -925,13 +843,11 @@ spec =
 
         context "variablesInAllowedPositionRule" $ do
             it "rejects wrongly typed variable arguments" $
-                let queryString = [gql|
-                  query dogCommandArgQuery($dogCommandArg: DogCommand) {
-                    dog {
-                      doesKnowCommand(dogCommand: $dogCommandArg)
-                    }
-                  }
-                |]
+                let queryString = "query dogCommandArgQuery($dogCommandArg: DogCommand) {\n\
+                        \  dog {\n\
+                        \    doesKnowCommand(dogCommand: $dogCommandArg)\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Variable \"$dogCommandArg\" of type \
@@ -942,13 +858,11 @@ spec =
                  in validate queryString `shouldBe` [expected]
 
             it "rejects wrongly typed variable arguments" $
-                let queryString = [gql|
-                  query intCannotGoIntoBoolean($intArg: Int) {
-                    dog {
-                      isHousetrained(atOtherHomes: $intArg)
-                    }
-                  }
-                |]
+                let queryString = "query intCannotGoIntoBoolean($intArg: Int) {\n\
+                        \  dog {\n\
+                        \    isHousetrained(atOtherHomes: $intArg)\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Variable \"$intArg\" of type \"Int\" used in \
@@ -959,13 +873,11 @@ spec =
 
         context "valuesOfCorrectTypeRule" $ do
             it "rejects values of incorrect types" $
-                let queryString = [gql|
-                  {
-                    dog {
-                      isHousetrained(atOtherHomes: 3)
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  dog {\n\
+                        \    isHousetrained(atOtherHomes: 3)\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Value 3 cannot be coerced to type \"Boolean\"."
@@ -974,13 +886,11 @@ spec =
                  in validate queryString `shouldBe` [expected]
 
             it "uses the location of a single list value" $
-                let queryString = [gql|
-                  {
-                    cat {
-                      doesKnowCommands(catCommands: [3])
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  cat {\n\
+                        \    doesKnowCommands(catCommands: [3])\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Value 3 cannot be coerced to type \"CatCommand!\"."
@@ -989,13 +899,11 @@ spec =
                  in validate queryString `shouldBe` [expected]
 
             it "validates input object properties once" $
-                let queryString = [gql|
-                  {
-                    findDog(complex: { name: 3 }) {
-                      name
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  findDog(complex: { name: 3 }) {\n\
+                        \    name\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "Value 3 cannot be coerced to type \"String!\"."
@@ -1004,13 +912,11 @@ spec =
                  in validate queryString `shouldBe` [expected]
 
             it "checks for required list members" $
-                let queryString = [gql|
-                  {
-                    cat {
-                      doesKnowCommands(catCommands: [null])
-                    }
-                  }
-                |]
+                let queryString = "{\n\
+                        \  cat {\n\
+                        \    doesKnowCommands(catCommands: [null])\n\
+                        \  }\n\
+                        \}"
                     expected = Error
                         { message =
                             "List of non-null values of type \"CatCommand\" \