apollo-compiler 1.31.1

type ComplicatedArgs {
  # TODO List
  # TODO Coercion
  # TODO NotNulls
  intArgField(intArg: Int): String
  nonNullIntArgField(nonNullIntArg: Int!): String
  stringArgField(stringArg: String): String
  booleanArgField(booleanArg: Boolean): String
  enumArgField(enumArg: FurColor): String
  floatArgField(floatArg: Float): String
  idArgField(idArg: ID): String
  stringListArgField(stringListArg: [String]): String
  stringListNonNullArgField(stringListNonNullArg: [String!]): String
  complexArgField(complexArg: ComplexInput): String
  multipleReqs(req1: Int!, req2: Int!): String
  nonNullFieldWithDefault(arg: Int! = 0): String
  multipleOpts(opt1: Int = 0, opt2: Int = 0): String
  multipleOptAndReq(req1: Int!, req2: Int!, opt1: Int = 0, opt2: Int = 0): String
}

enum FurColor {
  BROWN
  BLACK
  TAN
  SPOTTED
  NO_FUR
  UNKNOWN
}

input ComplexInput {
  requiredField: Boolean!
  nonNullField: Boolean! = false
  intField: Int
  stringField: String
  booleanField: Boolean
  stringListField: [String]
}

enum DogCommand {
  SIT
  HEEL
  DOWN
}

type Dog {
  doesKnowCommand(dogCommand: DogCommand): Boolean
  name(surname: Boolean): String
  isHouseTrained(atOtherHomes: Boolean = true): Boolean
}

interface Pet {
  name(surname: Boolean): String
}

type Query {
  complicatedArgs: ComplicatedArgs
  dog: Dog
  human(id: ID): Human
}

type Human {
  name(surname: Boolean): String
  pets: [Pet]
  relatives: [Human]!
}


query intIntoString {
  complicatedArgs {
    stringArgField(stringArg: 1)
  }
}

query floatIntoString {
  complicatedArgs {
    stringArgField(stringArg: 1.0)
  }
}

query booleanIntoString {
  complicatedArgs {
    stringArgField(stringArg: true)
  }
}

query unquotedStringIntoString {
  complicatedArgs {
    stringArgField(stringArg: BAR)
  }
}

query stringIntoInt {
  complicatedArgs {
    intArgField(intArg: "3")
  }
}

query bigIntIntoInt {
  complicatedArgs {
    intArgField(intArg: 829384293849283498239482938)
  }
}

query unquotedStringIntoInt {
  complicatedArgs {
    intArgField(intArg: FOO)
  }
}

query simpleFloatIntoInt {
  complicatedArgs {
    intArgField(intArg: 3.0)
  }
}

query floatIntoInt {
  complicatedArgs {
    intArgField(intArg: 3.333)
  }
}

query stringIntoFloat {
  complicatedArgs {
    floatArgField(floatArg: "3.333")
  }
}

query booleanIntoFloat {
  complicatedArgs {
    floatArgField(floatArg: true)
  }
}

query unquotedIntoFloat {
  complicatedArgs {
    floatArgField(floatArg: FOO)
  }
}

query intIntoBoolean {
  complicatedArgs {
    booleanArgField(booleanArg: 2)
  }
}

query floatIntoBoolean {
  complicatedArgs {
    booleanArgField(booleanArg: 1.0)
  }
}

query stringIntoBoolean {
  complicatedArgs {
    booleanArgField(booleanArg: "true")
  }
}

query unquotedIntoBoolean {
  complicatedArgs {
    booleanArgField(booleanArg: TRUE)
  }
}

query floatIntoId {
  complicatedArgs {
    idArgField(idArg: 1.0)
  }
}

query booleanIntoID {
  complicatedArgs {
    idArgField(idArg: true)
  }
}

query unquotedIntoID {
  complicatedArgs {
    idArgField(idArg: SOMETHING)
  }
}

# Invalid Enum Value
query intIntoEnum {
  dog {
    doesKnowCommand(dogCommand: 2)
  }
}

query floatIntoEnum {
  dog {
    doesKnowCommand(dogCommand: 1.0)
  }
}

query stringIntoEnum {
  dog {
    doesKnowCommand(dogCommand: "SIT")
  }
}

query booleanIntoEnum {
  dog {
    doesKnowCommand(dogCommand: true)
  }
}

query unknownEnumValueIntoEnum {
  dog {
    doesKnowCommand(dogCommand: JUGGLE)
  }
}

query differentCaseEnumValueIntoEnum {
  dog {
    doesKnowCommand(dogCommand: sit)
  }
}

query incorrectListItemType {
  complicatedArgs {
    stringListArgField(stringListArg: ["one", 2])
  }
}

query singleValueOfIncorrectType {
  complicatedArgs {
    stringListArgField(stringListArg: 1)
  }
}

# Invalid non-nullable value
query incorrectValueType {
  complicatedArgs {
    multipleReqs(req2: "two", req1: "one")
  }
}

query incorrectValueAndMissingArgument {
  complicatedArgs {
    multipleReqs(req1: "one")
  }
}

query nullValue {
  complicatedArgs {
    multipleReqs(req1: null)
  }
}

# InvalidInputObjectValue
query partialObjectMissingField {
  complicatedArgs {
    complexArgField(complexArg: { intField: 4 })
  }
}

query partialObjectInvalidFieldType {
  complicatedArgs {
    complexArgField(complexArg: {
      stringListField: ["one", 2],
      requiredField: true,
    })
  }
}

query partialObjectNullToNonNullField {
  complicatedArgs {
    complexArgField(complexArg: {
      requiredField: true,
      nonNullField: null,
    })
  }
}

query partialObjectUnknownFieldArg {
  complicatedArgs {
    complexArgField(complexArg: {
      requiredField: true,
      invalidField: "value"
    })
  }
}

# Directive arguments
query withDirectiveWithIncorrectTypes {
  dog @include(if: "yes") {
    name @skip(if: ENUM)
  }
}

# Variable default values
query variablesWithInvalidDefaultNullValues(
  $a: Int! = null,
  $b: String! = null,
  $c: ComplexInput = { requiredField: null, intField: null }
) {
  complicatedArgs {
    complexArgField(complexArg: $c)
    intArgField(intArg: $a)
    stringArgField(stringArg: $b)
  }
}

query variablesWithInvalidDefaultValues(
  $a: Int = "one",
  $b: String = 4,
  $c: ComplexInput = "NotVeryComplex"
) {
  complicatedArgs {
    complexArgField(complexArg: $c)
    intArgField(intArg: $a)
    stringArgField(stringArg: $b)
    again: stringArgField(stringArg: $b)
  }
}

query variablesWithComplexInvalidDefaultValues(
  $a: ComplexInput = { requiredField: 123, intField: "abc" }
) {
  complicatedArgs {
    complexArgField(complexArg: $a)
  }
}

query complexVariablesMissingRequiredField(
  $a: ComplexInput = {intField: 3}
) {
  complicatedArgs {
    complexArgField(complexArg: $a)
  }

}

query listVariablesWithInvalidItem(
  $a: [String] = ["one", 2]
) {
  complicatedArgs {
    stringListArgField(stringListArg: $a)
  }
}