graphql 1.9.0 → 2.1.1

data/spec/graphql/execution/multiplex_spec.rb

@@ -1,211 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Execution::Multiplex do
-  def multiplex(*a)
-    LazyHelpers::LazySchema.multiplex(*a)
-  end
-
-  let(:q1) { <<-GRAPHQL
-    query Q1 {
-      nestedSum(value: 3) {
-        value
-        nestedSum(value: 7) {
-          value
-        }
-      }
-    }
-    GRAPHQL
-  }
-  let(:q2) { <<-GRAPHQL
-    query Q2 {
-      nestedSum(value: 2) {
-        value
-        nestedSum(value: 11) {
-          value
-        }
-      }
-    }
-    GRAPHQL
-  }
-  let(:q3) { <<-GRAPHQL
-    query Q3 {
-      listSum(values: [1,2]) {
-        nestedSum(value: 3) {
-          value
-        }
-      }
-    }
-    GRAPHQL
-  }
-
-  let(:queries) { [{query: q1}, {query: q2}, {query: q3}] }
-
-  describe "multiple queries in the same lazy context" do
-    it "runs multiple queries in the same lazy context" do
-      expected_data = [
-        {"data"=>{"nestedSum"=>{"value"=>14, "nestedSum"=>{"value"=>46}}}},
-        {"data"=>{"nestedSum"=>{"value"=>14, "nestedSum"=>{"value"=>46}}}},
-        {"data"=>{"listSum"=>[{"nestedSum"=>{"value"=>14}}, {"nestedSum"=>{"value"=>14}}]}},
-      ]
-
-      res = multiplex(queries)
-      assert_equal expected_data, res
-    end
-  end
-
-  describe "when some have validation errors or runtime errors" do
-    let(:q1) { " { success: nullableNestedSum(value: 1) { value } }" }
-    let(:q2) { " { runtimeError: nullableNestedSum(value: 13) { value } }" }
-    let(:q3) { "{
-      invalidNestedNull: nullableNestedSum(value: 1) {
-        value
-        nullableNestedSum(value: 2) {
-          nestedSum(value: 13) {
-            value
-          }
-          # This field will never get executed
-          ns2: nestedSum(value: 13) {
-            value
-          }
-        }
-      }
-    }" }
-    let(:q4) { " { validationError: nullableNestedSum(value: true) }"}
-
-    it "returns a mix of errors and values" do
-      expected_res = [
-        {
-          "data"=>{"success"=>{"value"=>2}}
-        },
-        {
-          "data"=>{"runtimeError"=>nil},
-          "errors"=>[{
-            "message"=>"13 is unlucky",
-            "locations"=>[{"line"=>1, "column"=>4}],
-            "path"=>["runtimeError"]
-          }]
-        },
-        {
-          "data"=>{"invalidNestedNull"=>{"value" => 2,"nullableNestedSum" => nil}},
-          "errors"=>[{"message"=>"Cannot return null for non-nullable field LazySum.nestedSum"}],
-        },
-        {
-          "errors" => [{
-            "message"=>"Field must have selections (field 'nullableNestedSum' returns LazySum but has no selections. Did you mean 'nullableNestedSum { ... }'?)",
-            "locations"=>[{"line"=>1, "column"=>4}],
-            "path"=>["query", "validationError"],
-            "extensions"=>{"code"=>"selectionMismatch", "nodeName"=>"field 'nullableNestedSum'", "typeName"=>"LazySum"}
-          }]
-        },
-      ]
-
-      res = multiplex([
-        {query: q1},
-        {query: q2},
-        {query: q3},
-        {query: q4},
-      ])
-      assert_equal expected_res, res.map(&:to_h)
-    end
-  end
-
-  describe "context shared by a multiplex run" do
-    it "is provided as context:" do
-      checks = []
-      multiplex(queries, context: { instrumentation_checks: checks })
-      assert_equal ["before multiplex 1", "before multiplex 2", "after multiplex 2", "after multiplex 1"], checks
-    end
-  end
-
-  describe "instrumenting a multiplex run" do
-    it "runs query instrumentation for each query and multiplex-level instrumentation" do
-      checks = []
-      queries_with_context = queries.map { |q| q.merge(context: { instrumentation_checks: checks }) }
-      multiplex(queries_with_context, context: { instrumentation_checks: checks })
-      assert_equal [
-        "before multiplex 1",
-        "before multiplex 2",
-        "before Q1", "before Q2", "before Q3",
-        "after Q3", "after Q2", "after Q1",
-        "after multiplex 2",
-        "after multiplex 1",
-      ], checks
-    end
-  end
-
-  describe "after_query when errors are raised" do
-    class InspectQueryInstrumentation
-      class << self
-        attr_reader :last_json
-        def before_query(query)
-        end
-
-        def after_query(query)
-          @last_json = query.result.to_json
-        end
-      end
-    end
-
-    InspectQueryType = GraphQL::ObjectType.define do
-      name "Query"
-
-      field :raiseExecutionError, types.String do
-        resolve ->(object, args, ctx) {
-          raise GraphQL::ExecutionError, "Whoops"
-        }
-      end
-
-      field :raiseError, types.String do
-        resolve ->(object, args, ctx) {
-          raise GraphQL::Error, "Crash"
-        }
-      end
-
-      field :raiseSyntaxError, types.String do
-        resolve ->(object, args, ctx) {
-          raise SyntaxError
-        }
-      end
-
-      field :raiseException, types.String do
-        resolve ->(object, args, ctx) {
-          raise Exception
-        }
-      end
-
-    end
-
-    InspectSchema = GraphQL::Schema.define do
-      query InspectQueryType
-      instrument(:query, InspectQueryInstrumentation)
-    end
-
-    unhandled_err_json = '{}'
-
-    it "can access the query results" do
-      InspectSchema.execute("{ raiseExecutionError }")
-      handled_err_json = '{"data":{"raiseExecutionError":null},"errors":[{"message":"Whoops","locations":[{"line":1,"column":3}],"path":["raiseExecutionError"]}]}'
-      assert_equal handled_err_json, InspectQueryInstrumentation.last_json
-
-
-      assert_raises(GraphQL::Error) do
-        InspectSchema.execute("{ raiseError }")
-      end
-
-      assert_equal unhandled_err_json, InspectQueryInstrumentation.last_json
-    end
-
-    it "can access the query results when the error is not a StandardError" do
-      assert_raises(SyntaxError) do
-        InspectSchema.execute("{ raiseSyntaxError }")
-      end
-      assert_equal unhandled_err_json, InspectQueryInstrumentation.last_json
-
-      assert_raises(Exception) do
-        InspectSchema.execute("{ raiseException }")
-      end
-      assert_equal unhandled_err_json, InspectQueryInstrumentation.last_json
-    end
-  end
-end

data/spec/graphql/execution/typecast_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Execution::Typecast do
-  describe ".subtype?" do
-    def subtype?(*args)
-      GraphQL::Execution::Typecast.subtype?(*args)
-    end
-
-    it "counts the same type as a subtype" do
-      assert subtype?(Dummy::Milk.graphql_definition, Dummy::Milk.graphql_definition)
-      assert !subtype?(Dummy::Milk.graphql_definition, Dummy::Cheese.graphql_definition)
-      assert subtype?(Dummy::Milk.graphql_definition.to_list_type.to_non_null_type, Dummy::Milk.graphql_definition.to_list_type.to_non_null_type)
-    end
-
-    it "counts member types as subtypes" do
-      assert subtype?(Dummy::Edible.graphql_definition, Dummy::Cheese.graphql_definition)
-      assert subtype?(Dummy::Edible.graphql_definition, Dummy::Milk.graphql_definition)
-      assert subtype?(Dummy::DairyProduct.graphql_definition, Dummy::Milk.graphql_definition)
-      assert subtype?(Dummy::DairyProduct.graphql_definition, Dummy::Cheese.graphql_definition)
-
-      assert !subtype?(Dummy::DairyAppQuery.graphql_definition, Dummy::DairyProduct.graphql_definition)
-      assert !subtype?(Dummy::Cheese.graphql_definition, Dummy::DairyProduct.graphql_definition)
-      assert !subtype?(Dummy::Edible.graphql_definition, Dummy::DairyProduct.graphql_definition)
-      assert !subtype?(Dummy::Edible.graphql_definition, GraphQL::STRING_TYPE)
-      assert !subtype?(Dummy::Edible.graphql_definition, Dummy::DairyProductInput.graphql_definition)
-    end
-
-    it "counts lists as subtypes if their inner types are subtypes" do
-      assert subtype?(Dummy::Edible.graphql_definition.to_list_type, Dummy::Milk.graphql_definition.to_list_type)
-      assert subtype?(Dummy::DairyProduct.graphql_definition.to_list_type, Dummy::Milk.graphql_definition.to_list_type)
-      assert !subtype?(Dummy::Cheese.graphql_definition.to_list_type, Dummy::DairyProduct.graphql_definition.to_list_type)
-      assert !subtype?(Dummy::Edible.graphql_definition.to_list_type, Dummy::DairyProduct.graphql_definition.to_list_type)
-      assert !subtype?(Dummy::Edible.graphql_definition.to_list_type, GraphQL::STRING_TYPE.to_list_type)
-    end
-
-    it "counts non-null types as subtypes of nullable parent types" do
-      assert subtype?(Dummy::Milk.graphql_definition, Dummy::Milk.graphql_definition.to_non_null_type)
-      assert subtype?(Dummy::Edible.graphql_definition, Dummy::Milk.graphql_definition.to_non_null_type)
-      assert subtype?(Dummy::Edible.graphql_definition.to_non_null_type, Dummy::Milk.graphql_definition.to_non_null_type)
-      assert subtype?(
-        GraphQL::STRING_TYPE.to_non_null_type.to_list_type,
-        GraphQL::STRING_TYPE.to_non_null_type.to_list_type.to_non_null_type,
-      )
-    end
-  end
-end

data/spec/graphql/execution_error_spec.rb

@@ -1,325 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::ExecutionError do
-  let(:result) { Dummy::Schema.execute(query_string) }
-  if TESTING_RESCUE_FROM
-    describe "when returned from a field" do
-      let(:query_string) {%|
-    {
-      cheese(id: 1) {
-        id
-        error1: similarCheese(source: [YAK]) {
-          ... similarCheeseFields
-        }
-        error2: similarCheese(source: [YAK]) {
-          ... similarCheeseFields
-        }
-        nonError: similarCheese(source: [SHEEP]) {
-          ... similarCheeseFields
-        }
-        flavor
-      }
-      allDairy {
-        ... on Cheese {
-          flavor
-        }
-        ... on Milk {
-          source
-          executionError
-        }
-      }
-      dairyErrors: allDairy(executionErrorAtIndex: 1) {
-        __typename
-      }
-      dairy {
-        milks {
-          source
-          executionError
-          allDairy {
-            __typename
-            ... on Milk {
-              origin
-              executionError
-            }
-          }
-        }
-      }
-      executionError
-      valueWithExecutionError
-    }
-
-    fragment similarCheeseFields on Cheese {
-      id, flavor
-    }
-      |}
-      it "the error is inserted into the errors key and the rest of the query is fulfilled" do
-        expected_result = {
-          "data"=>{
-            "cheese"=>{
-              "id" => 1,
-              "error1"=> nil,
-              "error2"=> nil,
-              "nonError"=> {
-                "id" => 3,
-                "flavor" => "Manchego",
-              },
-              "flavor" => "Brie",
-              },
-              "allDairy" => [
-                { "flavor" => "Brie" },
-                { "flavor" => "Gouda" },
-                { "flavor" => "Manchego" },
-                { "source" => "COW", "executionError" => nil }
-              ],
-              "dairyErrors" => [
-                { "__typename" => "Cheese" },
-                nil,
-                { "__typename" => "Cheese" },
-                { "__typename" => "Milk" }
-              ],
-              "dairy" => {
-                "milks" => [
-                  {
-                    "source" => "COW",
-                    "executionError" => nil,
-                    "allDairy" => [
-                      { "__typename" => "Cheese" },
-                      { "__typename" => "Cheese" },
-                      { "__typename" => "Cheese" },
-                      { "__typename" => "Milk", "origin" => "Antiquity", "executionError" => nil }
-                    ]
-                  }
-                ]
-              },
-              "executionError" => nil,
-              "valueWithExecutionError" => 0
-            },
-            "errors"=>[
-              {
-                "message"=>"No cheeses are made from Yak milk!",
-                "locations"=>[{"line"=>5, "column"=>9}],
-                "path"=>["cheese", "error1"]
-              },
-              {
-                "message"=>"No cheeses are made from Yak milk!",
-                "locations"=>[{"line"=>8, "column"=>9}],
-                "path"=>["cheese", "error2"]
-              },
-              {
-                "message"=>"There was an execution error",
-                "locations"=>[{"line"=>22, "column"=>11}],
-                "path"=>["allDairy", 3, "executionError"]
-              },
-              {
-                "message"=>"missing dairy",
-                "locations"=>[{"line"=>25, "column"=>7}],
-                "path"=>["dairyErrors", 1]
-              },
-              {
-                "message"=>"There was an execution error",
-                "locations"=>[{"line"=>31, "column"=>11}],
-                "path"=>["dairy", "milks", 0, "executionError"]
-              },
-              {
-                "message"=>"There was an execution error",
-                "locations"=>[{"line"=>36, "column"=>15}],
-                "path"=>["dairy", "milks", 0, "allDairy", 3, "executionError"]
-              },
-              {
-                "message"=>"There was an execution error",
-                "locations"=>[{"line"=>41, "column"=>7}],
-                "path"=>["executionError"]
-              },
-              {
-                "message"=>"Could not fetch latest value",
-                "locations"=>[{"line"=>42, "column"=>7}],
-                "path"=>["valueWithExecutionError"]
-              },
-            ]
-          }
-        assert_equal(expected_result, result.to_h)
-      end
-    end
-  end
-
-  describe "named query when returned from a field" do
-    let(:query_string) {%|
-    query MilkQuery {
-      dairy {
-        milks {
-          source
-          executionError
-          allDairy {
-            __typename
-            ... on Milk {
-              origin
-              executionError
-            }
-          }
-        }
-      }
-    }
-    |}
-    it "the error is inserted into the errors key and the rest of the query is fulfilled" do
-      expected_result = {
-        "data"=>{
-            "dairy" => {
-              "milks" => [
-                {
-                  "source" => "COW",
-                  "executionError" => nil,
-                  "allDairy" => [
-                    { "__typename" => "Cheese" },
-                    { "__typename" => "Cheese" },
-                    { "__typename" => "Cheese" },
-                    { "__typename" => "Milk", "origin" => "Antiquity", "executionError" => nil }
-                  ]
-                }
-              ]
-            }
-          },
-          "errors"=>[
-            {
-              "message"=>"There was an execution error",
-              "locations"=>[{"line"=>6, "column"=>11}],
-              "path"=>["dairy", "milks", 0, "executionError"]
-            },
-            {
-              "message"=>"There was an execution error",
-              "locations"=>[{"line"=>11, "column"=>15}],
-              "path"=>["dairy", "milks", 0, "allDairy", 3, "executionError"]
-            }
-          ]
-        }
-      assert_equal(expected_result, result)
-    end
-  end
-
-  describe "fragment query when returned from a field" do
-    let(:query_string) {%|
-    query MilkQuery {
-      dairy {
-        ...Dairy
-      }
-    }
-
-    fragment Dairy on Dairy {
-      milks {
-        source
-        executionError
-        allDairy {
-          __typename
-          ...Milk
-        }
-      }
-    }
-
-    fragment Milk on Milk {
-      origin
-      executionError
-    }
-    |}
-    it "the error is inserted into the errors key and the rest of the query is fulfilled" do
-      expected_result = {
-        "data"=>{
-            "dairy" => {
-              "milks" => [
-                {
-                  "source" => "COW",
-                  "executionError" => nil,
-                  "allDairy" => [
-                    { "__typename" => "Cheese" },
-                    { "__typename" => "Cheese" },
-                    { "__typename" => "Cheese" },
-                    { "__typename" => "Milk", "origin" => "Antiquity", "executionError" => nil }
-                  ]
-                }
-              ]
-            }
-          },
-          "errors"=>[
-            {
-              "message"=>"There was an execution error",
-              "locations"=>[{"line"=>11, "column"=>9}],
-              "path"=>["dairy", "milks", 0, "executionError"]
-            },
-            {
-              "message"=>"There was an execution error",
-              "locations"=>[{"line"=>21, "column"=>7}],
-              "path"=>["dairy", "milks", 0, "allDairy", 3, "executionError"]
-            }
-          ]
-        }
-      assert_equal(expected_result, result)
-    end
-  end
-
-  describe "options in ExecutionError" do
-    let(:query_string) {%|
-    {
-      executionErrorWithOptions
-    }
-    |}
-    it "the error is inserted into the errors key and the rest of the query is fulfilled" do
-      expected_result = {
-        "data"=>{"executionErrorWithOptions"=>nil},
-        "errors"=>
-            [{"message"=>"Permission Denied!",
-              "locations"=>[{"line"=>3, "column"=>7}],
-              "path"=>["executionErrorWithOptions"],
-              "code"=>"permission_denied"}]
-      }
-      assert_equal(expected_result, result)
-    end
-  end
-
-  describe "extensions in ExecutionError" do
-    let(:query_string) {%|
-    {
-      executionErrorWithExtensions
-    }
-    |}
-    it "the error is inserted into the errors key with custom data set in `extensions`" do
-      expected_result = {
-        "data"=>{"executionErrorWithExtensions"=>nil},
-        "errors"=>
-            [{"message"=>"Permission Denied!",
-              "locations"=>[{"line"=>3, "column"=>7}],
-              "path"=>["executionErrorWithExtensions"],
-              "extensions"=>{"code"=>"permission_denied"}}]
-      }
-      assert_equal(expected_result, result)
-    end
-  end
-
-  describe "more than one ExecutionError" do
-    let(:query_string) { %|{ multipleErrorsOnNonNullableField} |}
-    it "the errors are inserted into the errors key and the data is nil even for a NonNullable field " do
-
-      # I Think the path here is _wrong_, since this is not an array field:
-      # expected_result = {
-      #     "data"=>nil,
-      #     "errors"=>
-      #         [{"message"=>"This is an error message for some error.",
-      #           "locations"=>[{"line"=>1, "column"=>3}],
-      #           "path"=>["multipleErrorsOnNonNullableField", 0]},
-      #          {"message"=>"This is another error message for a different error.",
-      #           "locations"=>[{"line"=>1, "column"=>3}],
-      #           "path"=>["multipleErrorsOnNonNullableField", 1]}]
-      # }
-      expected_result = {
-        "data"=>nil,
-        "errors"=>
-          [{"message"=>"This is an error message for some error.",
-            "locations"=>[{"line"=>1, "column"=>3}],
-            "path"=>["multipleErrorsOnNonNullableField"]},
-           {"message"=>"This is another error message for a different error.",
-            "locations"=>[{"line"=>1, "column"=>3}],
-            "path"=>["multipleErrorsOnNonNullableField"]}],
-      }
-      assert_equal(expected_result, result)
-    end
-  end
-
-end