graphql 0.16.0 → 2.0.15

data/spec/graphql/query/context_spec.rb

@@ -1,83 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Query::Context do
-  let(:query_type) { GraphQL::ObjectType.define {
-    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
-  }}
-  let(:schema) { GraphQL::Schema.new(query: query_type, mutation: nil)}
-  let(:result) { schema.execute(query_string, context: {"some_key" => "some value"})}
-
-  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 "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) }
-
-    it "returns nil for any key" do
-      assert_equal(nil, context[:some_key])
-    end
-  end
-
-  describe "assigning values" do
-    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: 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
-  end
-end

data/spec/graphql/query/executor_spec.rb

@@ -1,273 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Query::Executor do
-  let(:operation_name) { nil }
-  let(:schema) { DummySchema }
-  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" => "You must provide an operation name from: getCheese1, getCheese2"}
-          ]
-        }
-        assert_equal(expected, result)
-      end
-    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 DairyType
-          resolve -> (t, a, c) {
-            raise if resolved
-            resolved = true
-            DAIRY
-          }
-        end
-      end
-
-      GraphQL::Schema.new(query: DummyQueryType, mutation: MutationType)
-    }
-    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 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 } ]
-            }
-          ]
-        }
-        assert_equal(expected, result)
-      end
-    end
-
-    describe "if the schema has a rescue handler" do
-      before do
-        schema.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}]
-            }
-          ]
-        }
-        assert_equal(expected, result)
-      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 }],
-              "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 }],
-              "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 }],
-              "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/serial_execution/execution_context_spec.rb

@@ -1,53 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Query::SerialExecution::ExecutionContext do
-  let(:query_string) { %|
-    query getFlavor($cheeseId: Int!) {
-      brie: cheese(id: 1)   { ...cheeseFields, taste: flavor }
-    }
-    fragment cheeseFields on Cheese { flavor }
-  |}
-  let(:operation_name) { nil }
-  let(:query_variables) { {"cheeseId" => 2} }
-  let(:schema) { DummySchema }
-  let(:query) { GraphQL::Query.new(
-    schema,
-    query_string,
-    variables: query_variables,
-    operation_name: operation_name,
-  )}
-  let(:execution_context) {
-    GraphQL::Query::SerialExecution::ExecutionContext.new(query, nil)
-  }
-
-  describe "add_error" do
-    let(:err) { StandardError.new("test") }
-    let(:expected) { [err] }
-
-    it "adds an error on the query context" do
-      execution_context.add_error(err)
-      assert_equal(expected, query.context.errors)
-    end
-  end
-
-  describe "get_type" do
-    it "returns the respective type from the schema" do
-      type = execution_context.get_type("Dairy")
-      assert_equal(DairyType, type)
-    end
-  end
-
-  describe "get_field" do
-    it "returns the respective field from the schema" do
-      field = execution_context.get_field(DairyType, "cheese")
-      assert_equal("cheese", field.name)
-    end
-  end
-
-  describe "get_fragment" do
-    it "returns a fragment on the query by name" do
-      fragment = execution_context.get_fragment("cheeseFields")
-      assert_equal("cheeseFields", fragment.name)
-    end
-  end
-end

data/spec/graphql/query/serial_execution/value_resolution_spec.rb

@@ -1,66 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Query::SerialExecution::ValueResolution do
-  let(:query_root) {
-    day_of_week_enum = GraphQL::EnumType.define do
-      name "DayOfWeek"
-      value("MONDAY", value: 0)
-      value("TUESDAY", value: 1)
-      value("WEDNESDAY", value: 2)
-      value("THURSDAY", value: 3)
-      value("FRIDAY", value: 4)
-      value("SATURDAY", value: 5)
-      value("SUNDAY", value: 6)
-    end
-
-    interface = GraphQL::InterfaceType.define do
-      name "SomeInterface"
-      field :someField, !types.Int
-      resolve_type ->(obj, ctx) { nil }
-    end
-
-    GraphQL::ObjectType.define do
-      name "Query"
-      field :tomorrow, day_of_week_enum do
-        argument :today, day_of_week_enum
-        resolve ->(obj, args, ctx) { (args["today"] + 1) % 7 }
-      end
-      field :misbehavedInterface, interface do
-        resolve ->(obj, args, ctx) { Object.new }
-      end
-    end
-  }
-  let(:schema) { GraphQL::Schema.new(query: query_root) }
-  let(:result) { schema.execute(
-    query_string,
-  )}
-
-  describe "enum resolution" do
-    let(:query_string) { %|
-      {
-        tomorrow(today: FRIDAY)
-      }
-    |}
-
-    it "coerces enum input to the value and result to the name" do
-      expected = {
-        "data" => {
-          "tomorrow" => "SATURDAY"
-        }
-      }
-      assert_equal(expected, result)
-    end
-  end
-
-  describe "interface type resolution" do
-    let(:query_string) { %|
-      {
-        misbehavedInterface { someField }
-      }
-    |}
-
-    it "raises an error if it cannot resolve the type of an interface" do
-      assert_raises(GraphQL::ObjectType::UnresolvedTypeError) { result }
-    end
-  end
-end

data/spec/graphql/query/type_resolver_spec.rb

@@ -1,8 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Query::TypeResolver do
-  it "resolves correcty when child_type is UnionType" do
-    type = GraphQL::Query::TypeResolver.new(MILKS[1], DairyProductUnion, MilkType, nil).type
-    assert_equal(MilkType, type)
-  end
-end

data/spec/graphql/query/variables_spec.rb

@@ -1,28 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Query::Variables do
-  let(:query_string) {%|
-  query getCheese($animals: [DairyAnimal]) {
-    cheese(id: 1) {
-      similarCheese(source: $animals)
-    }
-  }
-  |}
-  let(:ast_variables) { GraphQL.parse(query_string).definitions.first.variables }
-  let(:variables) { GraphQL::Query::Variables.new(
-    DummySchema,
-    ast_variables,
-    provided_variables)
-  }
-
-  describe "#initialize" do
-    describe "coercing inputs" do
-      let(:provided_variables) {
-        {"animals" => "YAK"}
-      }
-      it "coerces single items into one-element lists" do
-        assert_equal ["YAK"], variables["animals"]
-      end
-    end
-  end
-end