graphql 1.9.0 → 2.1.1

data/spec/graphql/query/context_spec.rb

@@ -1,292 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Query::Context do
-  CTX = []
-  before { CTX.clear }
-
-  let(:parent_info_type) {
-    GraphQL::ObjectType.define {
-      name "ParentInfo"
-      field :object, types.String do
-        resolve ->(o, a, c) { c.parent.parent.object }
-      end
-      field :objectClassName, types.String do
-        resolve ->(o, a, c) { c.parent.parent.object.class.name }
-      end
-      field :valueClassName, types.String do
-        resolve ->(o, a, c) { c.parent.parent.value.class.name }
-      end
-      field :value, types.String do
-        resolve ->(o, a, c) { c.parent.parent.value.to_s }
-      end
-    }
-  }
-  let(:backtrace_type) {
-    GraphQL::ObjectType.define do
-      name "Backtrace"
-      field :backtraceEntry, types.String do
-        argument :idx, !types.Int
-        resolve ->(o, a, c) { c.backtrace[a[:idx]] }
-      end
-      field :backtraceArray, types[types.String] do
-        resolve ->(o, a, c) { c.backtrace.to_a }
-      end
-      field :backtraceTable, types.String do
-        resolve ->(o, a, c) { c.backtrace.inspect }
-      end
-    end
-  }
-  let(:query_type) {
-    parent_info = parent_info_type
-    backtrace = backtrace_type
-    GraphQL::ObjectType.define {
-      name "Query"
-      field :context, types.String do
-        argument :key, !types.String
-        resolve ->(target, args, ctx) { ctx[args[:key]] }
-      end
-      field :contextAstNodeName, types.String do
-        resolve ->(target, args, ctx) { ctx.ast_node.class.name }
-      end
-      field :contextIrepNodeName, types.String do
-        resolve ->(target, args, ctx) { ctx.irep_node.class.name }
-      end
-      field :queryName, types.String do
-        resolve ->(target, args, ctx) { ctx.query.class.name }
-      end
-
-      field :pushContext, types.Int do
-        resolve ->(t,a,c) { CTX << c; 1 }
-      end
-
-      field :pushQueryError, types.Int do
-        resolve ->(t,a,c) {
-          c.query.context.add_error(GraphQL::ExecutionError.new("Query-level error"))
-          1
-        }
-      end
-
-      field :parentInfo, parent_info, resolve: ->(o,a,c) { :noop }
-      field :backtrace, backtrace, resolve: Proc.new { :noop }
-    }
-  }
-
-  let(:schema) { GraphQL::Schema.define(query: query_type, mutation: nil)}
-  let(:result) { schema.execute(query_string, root_value: "rootval", context: {"some_key" => "some value"})}
-
-  describe "access to parent context" do
-    let(:query_string) { %|
-      {
-        parentInfo {
-          value
-          valueClassName
-          object
-          objectClassName
-        }
-      }
-    |}
-
-    it "exposes the parent object" do
-      expected = {
-        "data" => {
-          "parentInfo" => {
-            "objectClassName" => "String",
-            "object" => "rootval",
-            "value" => "{}",
-            "valueClassName" => "Hash",
-          }
-        }
-      }
-      assert_equal(expected, result)
-    end
-  end
-
-  describe "access to passed-in values" do
-    let(:query_string) { %|
-      query getCtx { context(key: "some_key") }
-    |}
-
-    it "passes context to fields" do
-      expected = {"data" => {"context" => "some value"}}
-      assert_equal(expected, result)
-    end
-  end
-
-  describe "access to the AST node" do
-    let(:query_string) { %|
-      query getCtx { contextAstNodeName }
-    |}
-
-    it "provides access to the AST node" do
-      expected = {"data" => {"contextAstNodeName" => "GraphQL::Language::Nodes::Field"}}
-      assert_equal(expected, result)
-    end
-  end
-
-  describe "#backtrace" do
-    let(:query_string) { %|
-      query {
-        backtrace {
-          b1: backtraceEntry(idx: 0)
-          b2: backtraceEntry(idx: 1)
-          b3: backtraceEntry(idx: 2)
-          backtraceArray
-          backtraceTable
-        }
-        pushContext
-      }
-    |}
-
-    it "exposes the GraphQL backtrace" do
-      backtrace_result = result.fetch("data").fetch("backtrace")
-      assert_equal "4:11: Backtrace.backtraceEntry as b1", backtrace_result.fetch("b1")
-      assert_equal "3:9: Query.backtrace", backtrace_result.fetch("b2")
-      assert_equal "2:7: query", backtrace_result.fetch("b3")
-      assert_equal ["7:11: Backtrace.backtraceArray", "3:9: Query.backtrace", "2:7: query"], backtrace_result.fetch("backtraceArray")
-      expected_table = [
-        'Loc  | Field                    | Object    | Arguments | Result',
-        '8:11 | Backtrace.backtraceTable | :noop     | {}        | nil',
-        '3:9  | Query.backtrace          | "rootval" | {}        | {b1: "4:11: Backtrace.backtraceEntry as b1", b2: "3:9: Query.backtrace", b3: "2:7: query", backtr...',
-        '2:7  | query                    | "rootval" | {}        | {}',
-        '',
-      ].join("\n")
-      assert_equal expected_table, backtrace_result.fetch("backtraceTable")
-
-      expected_table_2 = <<-TABLE
-Loc  | Field             | Object    | Arguments | Result
-10:9 | Query.pushContext | "rootval" | {}        | 1
-2:7  | query             | "rootval" | {}        | {backtrace: {...}, pushContext: 1}
-TABLE
-
-      ctx = CTX.last
-      assert_equal expected_table_2, ctx.backtrace.to_s
-    end
-  end
-
-  describe "access to the InternalRepresentation node" do
-    let(:query_string) { %|
-      query getCtx { contextIrepNodeName }
-    |}
-
-    it "provides access to the AST node" do
-      expected = {"data" => {"contextIrepNodeName" => "GraphQL::InternalRepresentation::Node"}}
-      assert_equal(expected, result)
-    end
-  end
-
-  describe "access to the query" do
-    let(:query_string) { %|
-      query getCtx { queryName }
-    |}
-
-    it "provides access to the AST node" do
-      expected = {"data" => {"queryName" => "GraphQL::Query"}}
-      assert_equal(expected, result)
-    end
-  end
-
-  describe "empty values" do
-    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil, object: nil) }
-
-    it "returns returns nil and reports key? => false" do
-      assert_equal(nil, context[:some_key])
-      assert_equal(false, context.key?(:some_key))
-      assert_raises(KeyError) { context.fetch(:some_key) }
-    end
-  end
-
-  describe "assigning values" do
-    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil, object: nil) }
-
-    it "allows you to assign new contexts" do
-      assert_equal(nil, context[:some_key])
-      context[:some_key] = "wow!"
-      assert_equal("wow!", context[:some_key])
-    end
-
-    describe "namespaces" do
-      let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: {a: 1}, object: nil) }
-
-      it "doesn't conflict with base values" do
-        ns = context.namespace(:stuff)
-        ns[:b] = 2
-        assert_equal({a: 1}, context.to_h)
-        assert_equal({b: 2}, context.namespace(:stuff))
-      end
-    end
-  end
-
-  describe "read values" do
-    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: {a: {b: 1}}, object: nil) }
-
-    it "allows you to read values of contexts using []" do
-      assert_equal({b: 1}, context[:a])
-    end
-
-    it "allows you to read values of contexts using dig" do
-      if RUBY_VERSION >= '2.3.0'
-        assert_equal(1, context.dig(:a, :b))
-      else
-        assert_raises NoMethodError do
-          context.dig(:a, :b)
-        end
-      end
-    end
-  end
-
-  describe "splatting" do
-    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: {a: {b: 1}}, object: nil) }
-
-    let(:splat) { ->(**context) { context } }
-
-    it "runs successfully" do
-      assert_equal({a: { b: 1 }}, splat.call(context))
-    end
-  end
-
-  describe "accessing context after the fact" do
-    let(:query_string) { %|
-      { pushContext }
-    |}
-
-    it "preserves path information" do
-      assert_equal 1, result["data"]["pushContext"]
-      last_ctx = CTX.pop
-      assert_equal ["pushContext"], last_ctx.path
-      err = GraphQL::ExecutionError.new("Test position info")
-      last_ctx.add_error(err)
-      assert_equal ["pushContext"], err.path
-      assert_equal [2, 9], [err.ast_node.line, err.ast_node.col]
-    end
-  end
-
-  describe "query-level errors" do
-    let(:query_string) { %|
-      { pushQueryError }
-    |}
-
-    it "allows query-level errors" do
-      expected_err = { "message" => "Query-level error" }
-      assert_equal [expected_err], result["errors"]
-    end
-  end
-
-  describe "custom context class" do
-    it "can be specified" do
-      query_str = '{
-        inspectContext
-        find(id: "Musician/Herbie Hancock") {
-          ... on Musician {
-            inspectContext
-          }
-        }
-      }'
-      res = Jazz::Schema.execute(query_str, context: { magic_key: :ignored, normal_key: "normal_value" })
-      expected_values = ["custom_method", "magic_value", "normal_value"]
-      expected_values_with_nil = expected_values + [nil]
-      assert_equal expected_values, res["data"]["inspectContext"]
-      assert_equal expected_values_with_nil, res["data"]["find"]["inspectContext"]
-    end
-  end
-end

data/spec/graphql/query/executor_spec.rb

@@ -1,314 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Query::Executor do
-  let(:operation_name) { nil }
-  let(:schema) { Dummy::Schema }
-  let(:variables) { {"cheeseId" => 2} }
-  let(:query) { GraphQL::Query.new(
-    schema,
-    query_string,
-    variables: variables,
-    operation_name: operation_name,
-  )}
-  let(:result) { query.result }
-
-  describe "multiple operations" do
-    let(:query_string) { %|
-      query getCheese1 { cheese(id: 1) { flavor } }
-      query getCheese2 { cheese(id: 2) { flavor } }
-    |}
-
-    describe "when an operation is named" do
-      let(:operation_name) { "getCheese2" }
-
-      it "runs the named one" do
-        expected = {
-          "data" => {
-            "cheese" => {
-              "flavor" => "Gouda"
-            }
-          }
-        }
-        assert_equal(expected, result)
-      end
-    end
-
-    describe "when one is NOT named" do
-      it "returns an error" do
-        expected = {
-          "errors" => [
-            {"message" => "An operation name is required"}
-          ]
-        }
-        assert_equal(expected, result)
-      end
-    end
-
-    describe "when the named operation is not present" do
-      let(:operation_name) { "nonsenseOperation" }
-      it "returns an error" do
-        expected = {
-          "errors" => [
-            {"message" => 'No operation named "nonsenseOperation"'}
-          ]
-        }
-        assert_equal(expected, result)
-      end
-    end
-  end
-
-  describe "operation and fragment defintions of the same name" do
-    let(:query_string) { %|
-      query Cheese { cheese(id: 1) { ...Cheese } }
-      query MoreCheese { cheese(id: 2) { ...Cheese } }
-      fragment Cheese on Cheese { flavor }
-    |}
-
-    let(:operation_name) { "Cheese" }
-
-    it "runs the named operation" do
-      expected = {
-        "data" => {
-          "cheese" => {
-            "flavor" => "Brie"
-          }
-        }
-      }
-      assert_equal(expected, result)
-    end
-  end
-
-
-  describe "execution order" do
-    let(:query_string) {%|
-      mutation setInOrder {
-        first:  pushValue(value: 1)
-        second: pushValue(value: 5)
-        third:  pushValue(value: 2)
-        fourth: replaceValues(input: {values: [6,5,4]})
-      }
-    |}
-
-    it "executes mutations in order" do
-      expected = {"data"=>{
-          "first"=> [1],
-          "second"=>[1, 5],
-          "third"=> [1, 5, 2],
-          "fourth"=> [6, 5 ,4],
-      }}
-      assert_equal(expected, result)
-    end
-  end
-
-
-  describe "fragment resolution" do
-    let(:schema) {
-      # we will raise if the dairy field is resolved more than one time
-      resolved = false
-
-      DummyQueryType = GraphQL::ObjectType.define do
-        name "Query"
-        field :dairy do
-          type Dummy::Dairy.graphql_definition
-          resolve ->(t, a, c) {
-            raise if resolved
-            resolved = true
-            Dummy::DAIRY
-          }
-        end
-      end
-
-      GraphQL::Schema.define(query: DummyQueryType, mutation: Dummy::DairyAppMutation.graphql_definition, resolve_type: ->(a,b,c) { :pass }, id_from_object: :pass)
-    }
-    let(:variables) { nil }
-    let(:query_string) { %|
-      query getDairy {
-        dairy {
-          id
-          ... on Dairy {
-            id
-          }
-          ...repetitiveFragment
-        }
-      }
-      fragment repetitiveFragment on Dairy {
-        id
-      }
-    |}
-
-    it "resolves each field only one time, even when present in multiple fragments" do
-      expected = {"data" => {
-        "dairy" => { "id" => "1" }
-      }}
-      assert_equal(expected, result)
-    end
-
-  end
-
-
-  describe "runtime errors" do
-    let(:query_string) {%| query noMilk { error }|}
-
-    it "raises error" do
-      assert_raises(RuntimeError) { result }
-    end
-
-    describe "if nil is given for a non-null field" do
-      let(:query_string) {%| query noMilk { cow { name cantBeNullButIs } }|}
-      it "turns into error message and nulls the entire selection" do
-        expected = {
-          "data" => { "cow" => nil },
-          "errors" => [
-            {
-              "message" => "Cannot return null for non-nullable field Cow.cantBeNullButIs"
-            }
-          ]
-        }
-        assert_equal(expected, result)
-      end
-    end
-
-    describe "if an execution error is raised for a non-null field" do
-      let(:query_string) {%| query noMilk { cow { name cantBeNullButRaisesExecutionError } }|}
-      it "uses provided error message and nulls the entire selection" do
-        expected = {
-          "data" => { "cow" => nil },
-          "errors" => [
-            {
-              "message" => "BOOM",
-              "locations" => [ { "line" => 1, "column" => 28 } ],
-              "path" => ["cow", "cantBeNullButRaisesExecutionError"]
-            }
-          ]
-        }
-        assert_equal(expected, result)
-      end
-    end
-
-    if TESTING_RESCUE_FROM
-      describe "if the schema has a rescue handler" do
-        before do
-          # HACK: reach to the underlying instance to perform a side-effect
-          schema.graphql_definition.rescue_from(RuntimeError) { "Error was handled!" }
-        end
-
-        after do
-          # remove the handler from the middleware:
-          schema.remove_handler(RuntimeError)
-        end
-
-        it "adds to the errors key" do
-          expected = {
-            "data" => {"error" => nil},
-            "errors"=>[
-              {
-                "message"=>"Error was handled!",
-                "locations" => [{"line"=>1, "column"=>17}],
-                "path"=>["error"]
-              }
-            ]
-          }
-          assert_equal(expected, result)
-        end
-      end
-    end
-  end
-
-  describe "variable coercion" do
-    describe "for unspecified with default" do
-      let(:query_string) {%| query Q($limit: Int = 2) { milk(id: 1) { flavors(limit: $limit) } } |}
-
-      it "uses the default value" do
-        expected = {
-          "data" => {
-            "milk" => {
-              "flavors" => ["Natural", "Chocolate"],
-            }
-          }
-        }
-        assert_equal(expected, result)
-      end
-    end
-
-    describe "for input object type" do
-      let(:variables) { {"input" => [{ "source" => "SHEEP" }]} }
-      let(:query_string) {%| query Q($input: [DairyProductInput]) { searchDairy(product: $input) { __typename, ... on Cheese { id, source } } } |}
-      it "uses the default value" do
-        expected = {
-          "data" => {
-            "searchDairy" => {
-              "__typename" => "Cheese",
-              "id" => 3,
-              "source" => "SHEEP"
-            }
-          }
-        }
-        assert_equal(expected, result)
-      end
-    end
-
-    describe "for required input objects" do
-      let(:variables) { { } }
-      let(:query_string) {%| mutation M($input: ReplaceValuesInput!) { replaceValues(input: $input) } |}
-      it "returns a variable validation error" do
-        expected = {
-          "errors"=>[
-            {
-              "message" => "Variable input of type ReplaceValuesInput! was provided invalid value",
-              "locations" => [{ "line" => 1, "column" => 13 }],
-              "extensions" => {
-                "value" => nil,
-                "problems" => [{ "path" => [], "explanation" => "Expected value to not be null" }]
-              }
-            }
-          ]
-        }
-        assert_equal(expected, result)
-      end
-    end
-
-    describe "for required input object fields" do
-      let(:variables) { {"input" => {} } }
-      let(:query_string) {%| mutation M($input: ReplaceValuesInput!) { replaceValues(input: $input) } |}
-      it "returns a variable validation error" do
-        expected = {
-          "errors"=>[
-            {
-              "message" => "Variable input of type ReplaceValuesInput! was provided invalid value",
-              "locations" => [{ "line" => 1, "column" => 13 }],
-              "extensions" => {
-                "value" => {},
-                "problems" => [{ "path" => ["values"], "explanation" => "Expected value to not be null" }]
-              }
-            }
-          ]
-        }
-        assert_equal(expected, result)
-      end
-    end
-
-    describe "for input objects with unknown keys in value" do
-      let(:variables) { {"input" => [{ "foo" => "bar" }]} }
-      let(:query_string) {%| query Q($input: [DairyProductInput]) { searchDairy(product: $input) { __typename, ... on Cheese { id, source } } } |}
-      it "returns a variable validation error" do
-        expected = {
-          "errors"=>[
-            {
-              "message" => "Variable input of type [DairyProductInput] was provided invalid value",
-              "locations" => [{ "line" => 1, "column" => 10 }],
-              "extensions" => {
-                "value" => [{ "foo" => "bar" }],
-                "problems" => [
-                  { "path" => [0, "foo"], "explanation" => "Field is not defined on DairyProductInput" },
-                  { "path" => [0, "source"], "explanation" => "Expected value to not be null" }
-                ]
-              }
-            }
-          ]
-        }
-        assert_equal(expected, result)
-      end
-    end
-  end
-end

data/spec/graphql/query/literal_input_spec.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Query::LiteralInput do
-  describe ".from_arguments" do
-    describe "arguments are prepared" do
-      let(:schema) {
-        type = GraphQL::ObjectType.define do
-          name "SomeType"
-
-          field :addToArgumentValue do
-            type !types.Int
-            argument :value do
-              type types.Int
-              default_value 3
-              prepare ->(arg, ctx) do
-                return GraphQL::ExecutionError.new("Can't return more than 3 digits") if arg > 998
-                arg + ctx[:val]
-              end
-            end
-            resolve ->(t, a, c) { a[:value] }
-          end
-
-          field :fieldWithArgumentThatIsBadByDefault do
-            type types.Int
-            argument :value do
-              type types.Int
-              default_value 7
-              prepare ->(arg, ctx) do
-                GraphQL::ExecutionError.new("Always bad")
-              end
-            end
-
-            resolve ->(*args) { 42 }
-          end
-        end
-
-        query = GraphQL::ObjectType.define do
-          name "Query"
-
-          field :top, type, resolve: ->(_, _, _) { true }
-        end
-
-        GraphQL::Schema.define(query: query)
-      }
-
-      it "prepares values from query literals" do
-        result = schema.execute("{ top { addToArgumentValue(value: 1) } }", context: { val: 1 })
-        assert_equal(result["data"]["top"]["addToArgumentValue"], 2)
-      end
-
-      it "prepares default values" do
-        result = schema.execute("{ top { addToArgumentValue } }", context: { val: 4 })
-        assert_equal(7, result["data"]["top"]["addToArgumentValue"])
-      end
-
-      it "raises an execution error if the default value is bad" do
-        result = schema.execute("{ top { fieldWithArgumentThatIsBadByDefault } }", context: { })
-        assert_equal(result["data"], {
-          "top"=>{
-            "fieldWithArgumentThatIsBadByDefault"=>nil}
-        })
-        assert_equal(result["errors"], [
-          {"message"=>"Always bad",
-           "locations"=>[{"line"=>1, "column"=>9}],
-           "path"=>["top", "fieldWithArgumentThatIsBadByDefault"]}
-        ])
-      end
-
-      it "prepares values from variables" do
-        result = schema.execute("query ($value: Int!) { top { addToArgumentValue(value: $value) } }", variables: { "value" => 1}, context: { val: 2 } )
-        assert_equal(result["data"]["top"]["addToArgumentValue"], 3)
-      end
-
-      it "prepares values correctly if called multiple times with different arguments" do
-        result = schema.execute("{ top { first: addToArgumentValue(value: 1) second: addToArgumentValue(value: 2) } }", context: { val: 3 })
-        assert_equal(result["data"]["top"]["first"], 4)
-        assert_equal(result["data"]["top"]["second"], 5)
-      end
-
-      it "adds message to errors key if an ExecutionError is returned from the prepare function" do
-        result = schema.execute("{ top { addToArgumentValue(value: 999) } }")
-        assert_equal(result["data"]["top"], nil)
-        assert_equal(result["errors"][0]["message"], "Can't return more than 3 digits")
-        assert_equal(result["errors"][0]["locations"][0]["line"], 1)
-        assert_equal(result["errors"][0]["locations"][0]["column"], 28)
-        assert_equal(result["errors"][0]["path"], ["top", "addToArgumentValue"])
-      end
-    end
-  end
-end