graphql 0.16.0 → 2.0.15

data/spec/graphql/query_spec.rb

@@ -1,363 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Query do
-  let(:query_string) { %|
-    query getFlavor($cheeseId: Int!) {
-      brie: cheese(id: 1)   { ...cheeseFields, taste: flavor },
-      cheese(id: $cheeseId)  {
-        __typename,
-        id,
-        ...cheeseFields,
-        ... edibleFields,
-        ... on Cheese { cheeseKind: flavor },
-      }
-      fromSource(source: COW) { id }
-      fromSheep: fromSource(source: SHEEP) { id }
-      firstSheep: searchDairy(product: [{source: SHEEP}]) {
-        __typename,
-        ... dairyFields,
-        ... milkFields
-      }
-      favoriteEdible { __typename, fatContent }
-    }
-    fragment cheeseFields on Cheese { flavor }
-    fragment edibleFields on Edible { fatContent }
-    fragment milkFields on Milk { source }
-    fragment dairyFields on AnimalProduct {
-       ... on Cheese { flavor }
-       ... on Milk   { source }
-    }
-  |}
-  let(:operation_name) { nil }
-  let(:max_depth) { nil }
-  let(:query_variables) { {"cheeseId" => 2} }
-  let(:schema) { DummySchema }
-  let(:document) { GraphQL.parse(query_string) }
-
-  let(:query) { GraphQL::Query.new(
-    schema,
-    query_string,
-    variables: query_variables,
-    operation_name: operation_name,
-    max_depth: max_depth,
-  )}
-  let(:result) { query.result }
-
-  describe "when passed no query string or document" do
-    it 'fails with an ArgumentError' do
-      assert_raises(ArgumentError) {
-        GraphQL::Query.new(
-          schema,
-          variables: query_variables,
-          operation_name: operation_name,
-          max_depth: max_depth,
-        )
-      }
-    end
-  end
-
-  describe "when passed a document instance" do
-    let(:query) { GraphQL::Query.new(
-      schema,
-      document: document,
-      variables: query_variables,
-      operation_name: operation_name,
-      max_depth: max_depth,
-    )}
-
-    it "runs the query using the already parsed document" do
-      expected = {"data"=> {
-        "brie" =>   { "flavor" => "Brie", "taste" => "Brie" },
-        "cheese" => {
-          "__typename" => "Cheese",
-          "id" => 2,
-          "flavor" => "Gouda",
-          "fatContent" => 0.3,
-          "cheeseKind" => "Gouda",
-        },
-        "fromSource" => [{ "id" => 1 }, {"id" => 2}],
-        "fromSheep"=>[{"id"=>3}],
-        "firstSheep" => { "__typename" => "Cheese", "flavor" => "Manchego" },
-        "favoriteEdible"=>{"__typename"=>"Milk", "fatContent"=>0.04},
-    }}
-    assert_equal(expected, result)
-    end
-  end
-
-  describe '#result' do
-    it "returns fields on objects" do
-      expected = {"data"=> {
-          "brie" =>   { "flavor" => "Brie", "taste" => "Brie" },
-          "cheese" => {
-            "__typename" => "Cheese",
-            "id" => 2,
-            "flavor" => "Gouda",
-            "fatContent" => 0.3,
-            "cheeseKind" => "Gouda",
-          },
-          "fromSource" => [{ "id" => 1 }, {"id" => 2}],
-          "fromSheep"=>[{"id"=>3}],
-          "firstSheep" => { "__typename" => "Cheese", "flavor" => "Manchego" },
-          "favoriteEdible"=>{"__typename"=>"Milk", "fatContent"=>0.04},
-      }}
-      assert_equal(expected, result)
-    end
-
-    describe "when it hits null objects" do
-      let(:query_string) {%|
-        {
-          maybeNull {
-            cheese {
-              flavor,
-              similarCheese(source: [SHEEP]) { flavor }
-            }
-          }
-        }
-      |}
-
-      it "skips null objects" do
-        expected = {"data"=> {
-          "maybeNull" => { "cheese" => nil }
-        }}
-        assert_equal(expected, result)
-      end
-    end
-  end
-
-  it "uses root_value as the object for the root type" do
-    result = GraphQL::Query.new(schema, '{ root }', root_value: "I am root").result
-    assert_equal 'I am root', result.fetch('data').fetch('root')
-  end
-
-  it "exposes fragments" do
-    assert_equal(GraphQL::Language::Nodes::FragmentDefinition, query.fragments["cheeseFields"].class)
-  end
-
-  it "exposes the original string" do
-    assert_equal(query_string, query.query_string)
-  end
-
-  describe "merging fragments with different keys" do
-    let(:query_string) { %|
-      query getCheeseFieldsThroughDairy {
-        ... cheeseFrag3
-        dairy {
-          ...flavorFragment
-          ...fatContentFragment
-        }
-      }
-      fragment flavorFragment on Dairy {
-        cheese {
-          flavor
-        }
-        milks {
-          id
-        }
-      }
-      fragment fatContentFragment on Dairy {
-        cheese {
-          fatContent
-        }
-        milks {
-          fatContent
-        }
-      }
-
-      fragment cheeseFrag1 on Query {
-        cheese(id: 1) {
-          id
-        }
-      }
-      fragment cheeseFrag2 on Query {
-        cheese(id: 1) {
-          flavor
-        }
-      }
-      fragment cheeseFrag3 on Query {
-        ... cheeseFrag2
-        ... cheeseFrag1
-      }
-    |}
-
-    it "should include keys from each fragment" do
-      expected = {"data" => {
-        "dairy" => {
-          "cheese" => {
-            "flavor" => "Brie",
-            "fatContent" => 0.19
-          },
-          "milks" => [
-            {
-              "id" => "1",
-              "fatContent" => 0.04,
-            }
-          ],
-        },
-        "cheese" => {
-          "id" => 1,
-          "flavor" => "Brie"
-        },
-      }}
-      assert_equal(expected, result)
-    end
-  end
-
-  describe "field argument default values" do
-    let(:query_string) {%|
-      query getCheeses(
-        $search: [DairyProductInput]
-        $searchWithDefault: [DairyProductInput] = [{source: COW}]
-      ){
-        noVariable: searchDairy(product: $search) {
-          ... cheeseFields
-        }
-        noArgument: searchDairy {
-          ... cheeseFields
-        }
-        variableDefault: searchDairy(product: $searchWithDefault) {
-          ... cheeseFields
-        }
-        convertedDefault: fromSource {
-          ... cheeseFields
-        }
-      }
-      fragment cheeseFields on Cheese { flavor }
-    |}
-
-    it "has a default value" do
-      default_source = schema.query.fields["searchDairy"].arguments["product"].default_value[0]["source"]
-      assert_equal("SHEEP", default_source)
-    end
-
-    describe "when a variable is used, but not provided" do
-      it "uses the default_value" do
-        assert_equal("Manchego", result["data"]["noVariable"]["flavor"])
-      end
-    end
-
-    describe "when the argument isn't passed at all" do
-      it "uses the default value" do
-        assert_equal("Manchego", result["data"]["noArgument"]["flavor"])
-      end
-    end
-
-    describe "when the variable has a default" do
-      it "uses the variable default" do
-        assert_equal("Brie", result["data"]["variableDefault"]["flavor"])
-      end
-    end
-
-    describe "when the variable has a default needing conversion" do
-      it "uses the converted variable default" do
-        assert_equal([{"flavor" => "Brie"}, {"flavor" => "Gouda"}], result["data"]["convertedDefault"])
-      end
-    end
-  end
-
-  describe "query variables" do
-    let(:query_string) {%|
-      query getCheese($cheeseId: Int!){
-        cheese(id: $cheeseId) { flavor }
-      }
-    |}
-
-    describe "when they can be coerced" do
-      let(:query_variables) { {"cheeseId" => 2.0} }
-
-      it "coerces them on the way in" do
-        assert("Gouda", result["data"]["cheese"]["flavor"])
-      end
-    end
-
-    describe "when they can't be coerced" do
-      let(:query_variables) { {"cheeseId" => "2"} }
-
-      it "raises an error" do
-        expected = {
-          "errors" => [
-            {
-              "message" => "Variable cheeseId of type Int! was provided invalid value",
-              "locations"=>[{ "line" => 2, "column" => 23 }],
-              "value" => "2",
-              "problems" => [{ "path" => [], "explanation" => 'Could not coerce value "2" to Int' }]
-            }
-          ]
-        }
-        assert_equal(expected, result)
-      end
-    end
-
-    describe "when they aren't provided" do
-      let(:query_variables) { {} }
-
-      it "raises an error" do
-        expected = {
-          "errors" => [
-            {
-              "message" => "Variable cheeseId of type Int! was provided invalid value",
-              "locations" => [{"line" => 2, "column" => 23}],
-              "value" => nil,
-              "problems" => [{ "path" => [], "explanation" => "Expected value to not be null" }]
-            }
-          ]
-        }
-        assert_equal(expected, result)
-      end
-    end
-
-    describe "default values" do
-      let(:query_string) {%|
-        query getCheese($cheeseId: Int = 3){
-          cheese(id: $cheeseId) { id, flavor }
-        }
-      |}
-
-      describe "when no value is provided" do
-        let(:query_variables) { {} }
-
-        it "uses the default" do
-          assert(3, result["data"]["cheese"]["id"])
-          assert("Manchego", result["data"]["cheese"]["flavor"])
-        end
-      end
-
-      describe "when a value is provided" do
-        it "uses the provided variable" do
-          assert(2, result["data"]["cheese"]["id"])
-          assert("Gouda", result["data"]["cheese"]["flavor"])
-        end
-      end
-
-      describe "when complex values" do
-        let(:query_variables) { {"search" => [{"source" => "COW"}]} }
-        let(:query_string) {%|
-          query getCheeses($search: [DairyProductInput]!){
-            cow: searchDairy(product: $search) {
-              ... on Cheese {
-                flavor
-              }
-            }
-          }
-        |}
-
-        it "coerces recursively" do
-          assert_equal("Brie", result["data"]["cow"]["flavor"])
-        end
-      end
-    end
-  end
-
-  describe "#max_depth" do
-    it "defaults to the schema's max_depth" do
-      assert_equal 5, query.max_depth
-    end
-
-    describe "overriding max_depth" do
-      let(:max_depth) { 12 }
-
-      it "overrides the schema's max_depth" do
-        assert_equal 12, query.max_depth
-      end
-    end
-  end
-end

data/spec/graphql/scalar_type_spec.rb

@@ -1,61 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::ScalarType do
-  let(:custom_scalar) {
-    GraphQL::ScalarType.define do
-      name "BigInt"
-      coerce_input ->(value) { value =~ /\d+/ ? Integer(value) : nil }
-      coerce_result ->(value) { value.to_s }
-    end
-  }
-  let(:bignum) { 2 ** 128 }
-
-  it "coerces nil into nil" do
-    assert_equal(nil, custom_scalar.coerce_input(nil))
-  end
-
-  it "coerces input into objects" do
-    assert_equal(bignum, custom_scalar.coerce_input(bignum.to_s))
-  end
-
-  it "coerces result value for serialization" do
-    assert_equal(bignum.to_s, custom_scalar.coerce_result(bignum))
-  end
-
-  describe "custom scalar errors" do
-    let(:result) { custom_scalar.validate_input("xyz") }
-
-    it "returns an invalid result" do
-      assert !result.valid?
-      assert_equal 'Could not coerce value "xyz" to BigInt', result.problems[0]["explanation"]
-    end
-  end
-
-  describe "validate_input with good input" do
-    let(:result) { GraphQL::INT_TYPE.validate_input(150) }
-
-    it "returns a valid result" do
-      assert(result.valid?)
-    end
-  end
-
-  describe "validate_input with bad input" do
-    let(:result) { GraphQL::INT_TYPE.validate_input("bad num") }
-
-    it "returns an invalid result for bad input" do
-      assert(!result.valid?)
-    end
-
-    it "has one problem" do
-      assert_equal(result.problems.length, 1)
-    end
-
-    it "has the correct explanation" do
-      assert(result.problems[0]["explanation"].include?("Could not coerce value"))
-    end
-
-    it "has an empty path" do
-      assert(result.problems[0]["path"].empty?)
-    end
-  end
-end

data/spec/graphql/schema/catchall_middleware_spec.rb

@@ -1,32 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Schema::CatchallMiddleware do
-  let(:result) { DummySchema.execute(query_string) }
-  let(:query_string) {%| query noMilk { error }|}
-
-  before do
-    DummySchema.middleware << GraphQL::Schema::CatchallMiddleware
-  end
-
-  after do
-    DummySchema.middleware.delete(GraphQL::Schema::CatchallMiddleware)
-  end
-
-  describe "rescuing errors" do
-    let(:errors) { query.context.errors }
-
-    it "turns into error messages" do
-      expected = {
-        "data" => { "error" => nil },
-        "errors"=> [
-          {
-            "message"=>"Internal error",
-            "locations"=>[{"line"=>1, "column"=>17}],
-          },
-        ]
-      }
-      assert_equal(expected, result)
-    end
-  end
-
-end

data/spec/graphql/schema/middleware_chain_spec.rb

@@ -1,42 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Schema::MiddlewareChain do
-  let(:step_1) { -> (step_values, next_step) { step_values << 1; next_step.call } }
-  let(:step_2) { -> (step_values, next_step) { step_values << 2; next_step.call } }
-  let(:step_3) { -> (step_values, next_step) { step_values << 3; :return_value } }
-  let(:steps) { [step_1, step_2, step_3] }
-  let(:step_values) { [] }
-  let(:arguments) { [step_values] }
-  let(:middleware_chain) { GraphQL::Schema::MiddlewareChain.new(steps: steps, arguments: arguments)}
-
-  describe "#call" do
-    it "runs steps in order" do
-      middleware_chain.call
-      assert_equal([1,2,3], step_values)
-    end
-
-    it "returns the value of the last middleware" do
-      assert_equal(:return_value, middleware_chain.call)
-    end
-
-    describe "when a step returns early" do
-      let(:early_return_step) { -> (step_values, next_step) { :early_return } }
-      it "doesn't continue the chain" do
-        steps.insert(2, early_return_step)
-        assert_equal(:early_return, middleware_chain.call)
-        assert_equal([1,2], step_values)
-      end
-    end
-
-    describe "when a step provides alternate arguments" do
-      it "passes the new arguments to the next step" do
-        step_1 = -> (test_arg, next_step) { assert_equal(test_arg, 'HELLO'); next_step.call(['WORLD']) }
-        step_2 = -> (test_arg, next_step) { assert_equal(test_arg, 'WORLD'); test_arg }
-
-        chain = GraphQL::Schema::MiddlewareChain.new(steps: [step_1, step_2], arguments: ['HELLO'])
-        result = chain.call
-        assert_equal(result, 'WORLD')
-      end
-    end
-  end
-end

data/spec/graphql/schema/printer_spec.rb

@@ -1,190 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Schema::Printer do
-  let(:schema) {
-    node_type = GraphQL::InterfaceType.define do
-      name "Node"
-
-      field :id, !types.ID
-    end
-
-    choice_type = GraphQL::EnumType.define do
-      name "Choice"
-
-      value "FOO"
-      value "BAR"
-    end
-
-    sub_input_type = GraphQL::InputObjectType.define do
-      name "Sub"
-      input_field :string, types.String
-    end
-
-    variant_input_type = GraphQL::InputObjectType.define do
-      name "Varied"
-      input_field :id, types.ID
-      input_field :int, types.Int
-      input_field :float, types.Float
-      input_field :bool, types.Boolean
-      input_field :enum, choice_type
-      input_field :sub, types[sub_input_type]
-    end
-
-    comment_type = GraphQL::ObjectType.define do
-      name "Comment"
-      description "A blog comment"
-      interfaces [node_type]
-
-      field :id, !types.ID
-    end
-
-    post_type = GraphQL::ObjectType.define do
-      name "Post"
-      description "A blog post"
-
-      field :id, !types.ID
-      field :title, !types.String
-      field :body, !types.String
-      field :comments, types[!comment_type]
-    end
-
-    query_root = GraphQL::ObjectType.define do
-      name "Query"
-      description "The query root of this schema"
-
-      field :post do
-        type post_type
-        argument :id, !types.ID
-        argument :varied, variant_input_type, default_value: { id: "123", int: 234, float: 2.3, enum: "FOO", sub: [{ string: "str" }] }
-        resolve -> (obj, args, ctx) { Post.find(args["id"]) }
-      end
-    end
-
-    GraphQL::Schema.new(query: query_root)
-  }
-
-  describe ".print_introspection_schema" do
-    it "returns the schema as a string for the introspection types" do
-      expected = <<SCHEMA
-type __Directive {
-  name: String!
-  description: String
-  args: [__InputValue!]!
-  locations: [__DirectiveLocation!]!
-  onOperation: Boolean!
-  onFragment: Boolean!
-  onField: Boolean!
-}
-
-enum __DirectiveLocation {
-  QUERY
-  MUTATION
-  SUBSCRIPTION
-  FIELD
-  FRAGMENT_DEFINITION
-  FRAGMENT_SPREAD
-  INLINE_FRAGMENT
-}
-
-type __EnumValue {
-  name: String!
-  description: String
-  deprecationReason: String
-  isDeprecated: Boolean!
-}
-
-type __Field {
-  name: String!
-  description: String
-  type: __Type!
-  isDeprecated: Boolean!
-  args: [__InputValue!]!
-  deprecationReason: String
-}
-
-type __InputValue {
-  name: String!
-  description: String
-  type: __Type!
-  defaultValue: String
-}
-
-type __Schema {
-  types: [__Type!]!
-  directives: [__Directive!]!
-  queryType: __Type!
-  mutationType: __Type
-  subscriptionType: __Type
-}
-
-type __Type {
-  name: String
-  description: String
-  kind: __TypeKind!
-  fields(includeDeprecated: Boolean = false): [__Field!]
-  ofType: __Type
-  inputFields: [__InputValue!]
-  possibleTypes: [__Type!]
-  enumValues(includeDeprecated: Boolean = false): [__EnumValue!]
-  interfaces: [__Type!]
-}
-
-enum __TypeKind {
-  SCALAR
-  OBJECT
-  INTERFACE
-  UNION
-  ENUM
-  INPUT_OBJECT
-  LIST
-  NON_NULL
-}
-SCHEMA
-      assert_equal expected.chomp, GraphQL::Schema::Printer.print_introspection_schema
-    end
-  end
-
-  describe ".print_schema" do
-    it "returns the schema as a string for the defined types" do
-      expected = <<SCHEMA
-enum Choice {
-  FOO
-  BAR
-}
-
-type Comment implements Node {
-  id: ID!
-}
-
-interface Node {
-  id: ID!
-}
-
-type Post {
-  id: ID!
-  title: String!
-  body: String!
-  comments: [Comment!]
-}
-
-type Query {
-  post(id: ID!, varied: Varied = { id: \"123\", int: 234, float: 2.3, enum: FOO, sub: [{ string: \"str\" }] }): Post
-}
-
-input Sub {
-  string: String
-}
-
-input Varied {
-  id: ID
-  int: Int
-  float: Float
-  bool: Boolean
-  enum: Choice
-  sub: [Sub]
-}
-SCHEMA
-      assert_equal expected.chomp, GraphQL::Schema::Printer.print_schema(schema)
-    end
-  end
-end