graphql 1.4.5 → 1.5.3

data/spec/graphql/query/arguments_spec.rb

@@ -138,6 +138,26 @@ describe GraphQL::Query::Arguments do
             1
           }
         end
+
+        field :noArgTest, types.Int do
+          resolve ->(obj, args, ctx) {
+            arg_values_array << args
+            1
+          }
+        end
+
+        field :noDefaultsTest, types.Int do
+          argument :a, types.Int
+          argument :b, types.Int
+          resolve ->(obj, args, ctx) {
+            arg_values_array << args
+            1
+          }
+          resolve ->(obj, args, ctx) {
+            arg_values_array << args
+            1
+          }
+        end
       end
 
       GraphQL::Schema.define(query: query)
@@ -170,6 +190,14 @@ describe GraphQL::Query::Arguments do
       assert_equal({"a" => 1, "b" => 2}, last_args.to_h)
     end
 
+    it "uses Field#default_arguments when no args are provided" do
+      schema.execute("{ argTest noArgTest noDefaultsTest }")
+
+      assert schema.query.get_field("argTest").default_arguments.eql?(arg_values[0])
+      assert GraphQL::Query::Arguments::NO_ARGS.eql?(arg_values[1])
+      assert GraphQL::Query::Arguments::NO_ARGS.eql?(arg_values[2])
+    end
+
     it "works from variables" do
       variables = { "arg" => { "a" => 1, "d" => nil } }
       schema.execute("query ArgTest($arg: TestInput){ argTest(d: $arg) }", variables: variables)

data/spec/graphql/query/variables_spec.rb

@@ -33,6 +33,12 @@ describe GraphQL::Query::Variables do
     end
 
     describe "nullable variables" do
+      module ObjectWithThingsCount
+        def self.thingsCount(args, ctx) # rubocop:disable Style/MethodName
+          1
+        end
+      end
+
       let(:schema) { GraphQL::Schema.from_definition(%|
         type Query {
           thingsCount(ids: [ID!]): Int!
@@ -45,7 +51,7 @@ describe GraphQL::Query::Variables do
         }
       |}
       let(:result) {
-        schema.execute(query_string, variables: provided_variables, root_value: OpenStruct.new(thingsCount: 1))
+        schema.execute(query_string, variables: provided_variables, root_value: ObjectWithThingsCount)
       }
 
       describe "when they are present, but null" do

data/spec/graphql/query_spec.rb

@@ -420,4 +420,34 @@ describe GraphQL::Query do
       assert_equal({"cheeseId" => 2}, query.provided_variables)
     end
   end
+
+  describe "parse errors" do
+    let(:invalid_query_string) {
+      <<-GRAPHQL
+        {
+          getStuff
+          nonsense
+          This is broken 1
+        }
+      GRAPHQL
+    }
+    it "adds an entry to the errors key" do
+      res = schema.execute(" { ")
+      assert_equal 1, res["errors"].length
+      assert_equal "Unexpected end of document", res["errors"][0]["message"]
+      assert_equal [], res["errors"][0]["locations"]
+
+      res = schema.execute(invalid_query_string)
+      assert_equal 1, res["errors"].length
+      assert_equal %|Parse error on "1" (INT) at [4, 26]|, res["errors"][0]["message"]
+      assert_equal({"line" => 4, "column" => 26}, res["errors"][0]["locations"][0])
+    end
+
+    it "can be configured to raise" do
+      raise_schema = schema.redefine(parse_error: ->(err, ctx) { raise err })
+      assert_raises(GraphQL::ParseError) {
+        raise_schema.execute(invalid_query_string)
+      }
+    end
+  end
 end

data/spec/graphql/relay/base_connection_spec.rb

@@ -2,6 +2,15 @@
 require 'spec_helper'
 
 describe GraphQL::Relay::BaseConnection do
+  module Encoder
+    module_function
+    def encode(str, nonce: false); str; end
+    def decode(str, nonce: false); str; end
+  end
+
+  let(:schema) { OpenStruct.new(cursor_encoder: Encoder) }
+  let(:context) { OpenStruct.new(schema: schema) }
+
   describe ".connection_for_nodes" do
     it "resolves most specific connection type" do
       class SpecialArray < Array; end
@@ -15,16 +24,25 @@ describe GraphQL::Relay::BaseConnection do
     end
   end
 
-  describe "#context" do
-    module Encoder
-      module_function
-      def encode(str, nonce: false); str; end
-      def decode(str, nonce: false); str; end
-    end
+  describe "arguments" do
+    it "limits pagination args to positive numbers" do
+      args = {
+        first: 1,
+        last: -1,
+      }
+      conn = GraphQL::Relay::BaseConnection.new([], args, context: context)
+      assert_equal 1, conn.first
+      assert_equal 0, conn.last
 
-    let(:schema) { OpenStruct.new(cursor_encoder: Encoder) }
-    let(:context) { OpenStruct.new(schema: schema) }
+      args = {
+        first: nil,
+      }
+      conn = GraphQL::Relay::BaseConnection.new([], args, context: context)
+      assert_equal nil, conn.first
+    end
+  end
 
+  describe "#context" do
     it "Has public access to the field context" do
       conn = GraphQL::Relay::BaseConnection.new([], {}, context: context)
       assert_equal context, conn.context

data/spec/graphql/relay/connection_resolve_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Relay::ConnectionResolve do
+  describe "when an execution error is returned" do
+    let(:query_string) { <<-GRAPHQL
+      query getError($error: String!){
+        rebels {
+          ships(nameIncludes: $error) {
+            edges {
+              node {
+                name
+              }
+            }
+          }
+        }
+      }
+    GRAPHQL
+    }
+
+    it "adds an error" do
+      result = star_wars_query(query_string, { "error" => "error"})
+      assert_equal 1, result["errors"].length
+      assert_equal "error from within connection", result["errors"][0]["message"]
+    end
+
+    it "adds an error for a lazy error" do
+      result = star_wars_query(query_string, { "error" => "lazyError"})
+      assert_equal 1, result["errors"].length
+      assert_equal "lazy error from within connection", result["errors"][0]["message"]
+    end
+
+    it "adds an error for a lazy raised error" do
+      result = star_wars_query(query_string, { "error" => "lazyRaisedError"})
+      assert_equal 1, result["errors"].length
+      assert_equal "lazy raised error from within connection", result["errors"][0]["message"]
+    end
+
+    it "adds an error for a raised error" do
+      result = star_wars_query(query_string, { "error" => "raisedError"})
+      assert_equal 1, result["errors"].length
+      assert_equal "error raised from within connection", result["errors"][0]["message"]
+    end
+  end
+end

data/spec/graphql/relay/connection_type_spec.rb

@@ -56,5 +56,26 @@ describe GraphQL::Relay::ConnectionType do
         assert_equal ["Yavin", "Echo Base", "Secret Hideout"] , bases["nodes"].map { |e| e["name"] }
       end
     end
+
+
+    describe "when an execution error is raised" do
+      let(:query_string) {%|
+        {
+          basesWithNullName {
+            edges {
+              node {
+                name
+              }
+            }
+          }
+        }
+      |}
+
+      it "nullifies the parent and adds an error" do
+        result = star_wars_query(query_string)
+        assert_equal nil, result["data"]["basesWithNullName"]["edges"][0]["node"]
+        assert_equal "Boom!", result["errors"][0]["message"]
+      end
+    end
   end
 end

data/spec/graphql/relay/node_spec.rb

@@ -9,7 +9,21 @@ describe GraphQL::Relay::Node do
   end
 
   describe ".field" do
-    describe "with custom resolver" do
+    describe "with custom definition" do
+      it 'creates a field with the custom definition' do
+        faction = StarWars::DATA['Faction'][0]
+
+        node_field = GraphQL::Relay::Node.field do
+          name "nod3"
+          description "The Relay Node Field"
+          resolve ->(_, _ , _) { faction }
+        end
+
+        assert_equal "nod3", node_field.name
+        assert_equal "The Relay Node Field", node_field.description
+        assert_equal faction, node_field.resolve(nil, { 'id' => '1' }, nil)
+      end
+
       it "executes the custom resolve instead of relay default" do
         id = "resolver_is_hardcoded_so_this_does_not_matter"
 
@@ -131,7 +145,21 @@ describe GraphQL::Relay::Node do
   end
 
   describe ".plural_identifying_field" do
-    describe "with custom resolver" do
+    describe "with custom definition" do
+      it 'creates a field with the custom definition' do
+        factions = StarWars::DATA['Faction']
+
+        node_field = GraphQL::Relay::Node.plural_field do
+          name "nodez"
+          description "The Relay Nodes Field"
+          resolve ->(_, _ , _) { factions }
+        end
+
+        assert_equal "nodez", node_field.name
+        assert_equal "The Relay Nodes Field", node_field.description
+        assert_equal factions, node_field.resolve_proc.call(nil, { 'ids' => ['1', '2'] }, nil)
+      end
+
       it "executes the custom resolve instead of relay default" do
         id = ["resolver_is_hardcoded_so_this_does_not_matter", "another_id"]
 

data/spec/graphql/relay/range_add_spec.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Relay::RangeAdd do
+  # Make sure that the encoder is found through `ctx.schema`:
+  module PassThroughEncoder
+    def self.encode(plaintext, nonce: false)
+      "__#{plaintext}"
+    end
+
+    def self.decode(ciphertext, nonce: false)
+      ciphertext[2..-1]
+    end
+  end
+
+  let(:schema) {
+    menus = [
+      OpenStruct.new(
+        name: "Los Primos",
+        items: [
+          OpenStruct.new(name: "California Burrito", price: 699),
+          OpenStruct.new(name: "Fish Taco", price: 399),
+        ]
+      )
+    ]
+
+    item = GraphQL::ObjectType.define do
+      name "Item"
+      field :price, !types.Int
+      field :name, !types.String
+    end
+    menu = GraphQL::ObjectType.define do
+      name "Menu"
+      field :name, !types.String
+      field :items, !item.connection_type
+    end
+    query = GraphQL::ObjectType.define do
+      name "Query"
+      field :menus, types[menu], resolve: Proc.new { menus }
+    end
+    add_item = GraphQL::Relay::Mutation.define do
+      name "AddItem"
+      input_field :name, !types.String
+      input_field :price, !types.Int
+      input_field :menu_idx, !types.Int
+
+      return_field :item_edge, item.edge_type
+      return_field :items, item.connection_type
+      return_field :menu, menu
+      resolve ->(obj, input, ctx) {
+        this_menu = menus[input[:menu_idx]]
+        new_item = OpenStruct.new(name: input[:name], price: input[:price])
+        this_menu.items << new_item
+        range_add = GraphQL::Relay::RangeAdd.new(
+          parent: this_menu,
+          item: new_item,
+          collection: this_menu.items,
+          context: ctx,
+        )
+
+        {
+          menu: range_add.parent,
+          items: range_add.connection,
+          item_edge: range_add.edge,
+        }
+      }
+    end
+    mutation = GraphQL::ObjectType.define do
+      name "Mutation"
+      field :add_item, add_item.field
+    end
+
+    GraphQL::Schema.define(query: query, mutation: mutation, cursor_encoder: PassThroughEncoder)
+  }
+
+
+  describe "returning Relay objects" do
+    let(:query_str) { <<-GRAPHQL
+    mutation {
+      add_item(input: {name: "Chilaquiles", price: 699, menu_idx: 0}) {
+        menu {
+          name
+        }
+        item_edge {
+          node {
+            name
+            price
+          }
+        }
+        items {
+          edges {
+            node {
+              name
+            }
+            cursor
+          }
+        }
+      }
+    }
+    GRAPHQL
+    }
+
+    it "returns a connection and an edge" do
+      res = schema.execute(query_str)
+
+      mutation_res = res["data"]["add_item"]
+      assert_equal("Los Primos", mutation_res["menu"]["name"])
+      assert_equal({"name"=>"Chilaquiles", "price"=>699}, mutation_res["item_edge"]["node"])
+      assert_equal(["California Burrito", "Fish Taco", "Chilaquiles"], mutation_res["items"]["edges"].map { |e| e["node"]["name"] })
+      assert_equal(["__1", "__2", "__3"], mutation_res["items"]["edges"].map { |e| e["cursor"] })
+    end
+  end
+end

data/spec/graphql/schema/build_from_definition_spec.rb

@@ -700,4 +700,118 @@ SCHEMA
       assert_equal 'Specified query type "Foo" not found in document.', err.message
     end
   end
+
+  describe "executable schemas from string" do
+    let(:schema_defn) {
+      <<-GRAPHQL
+        type Todo {text: String, from_context: String}
+        type Query { all_todos: [Todo]}
+        type Mutation { todo_add(text: String!): Todo}
+      GRAPHQL
+    }
+
+    Todo = Struct.new(:text, :from_context)
+
+    class RootResolver
+      attr_accessor :todos
+
+      def initialize
+        @todos = [Todo.new("Pay the bills.")]
+      end
+
+      def all_todos
+        @todos
+      end
+
+      def todo_add(args, ctx) # this is a method and accepting arguments
+        todo = Todo.new(args[:text], ctx[:context_value])
+        @todos << todo
+        todo
+      end
+    end
+
+    it "calls methods with args if args are defined" do
+      schema = GraphQL::Schema.from_definition(schema_defn)
+      root_values = RootResolver.new
+      schema.execute("mutation { todoAdd: todo_add(text: \"Buy Milk\") { text } }", root_value: root_values, context: {context_value: "bar"})
+      result = schema.execute("query { allTodos: all_todos { text, from_context } }", root_value: root_values)
+      assert_equal(result.to_json, '{"data":{"allTodos":[{"text":"Pay the bills.","from_context":null},{"text":"Buy Milk","from_context":"bar"}]}}')
+    end
+
+    describe "hash of resolvers" do
+      let(:todos) { [Todo.new("Pay the bills.")] }
+      let(:schema) { GraphQL::Schema.from_definition(schema_defn, default_resolve: resolve_hash) }
+      let(:resolve_hash) {
+        h = base_hash
+        h["Query"] ||= {}
+        h["Query"]["all_todos"] = ->(obj, args, ctx) { obj }
+        h["Mutation"] ||= {}
+        h["Mutation"]["todo_add"] = ->(obj, args, ctx) {
+          todo = Todo.new(args[:text], ctx[:context_value])
+          obj << todo
+          todo
+        }
+        h
+      }
+      describe "with defaults" do
+        let(:base_hash) {
+          # Fallback is to resolve by sending the field name
+          Hash.new { |h, k| h[k] = Hash.new { |h2, k2| ->(obj, args, ctx) { obj.public_send(k2) } } }
+        }
+
+        it "accepts a hash of resolve functions" do
+          schema.execute("mutation { todoAdd: todo_add(text: \"Buy Milk\") { text } }", context: {context_value: "bar"}, root_value: todos)
+          result = schema.execute("query { allTodos: all_todos { text, from_context } }", root_value: todos)
+          assert_equal(result.to_json, '{"data":{"allTodos":[{"text":"Pay the bills.","from_context":null},{"text":"Buy Milk","from_context":"bar"}]}}')
+        end
+      end
+
+      describe "wihtout defaults" do
+        let(:base_hash) { {} }
+        it "raises a KeyError" do
+          assert_raises(KeyError) do
+            schema.execute("mutation { todoAdd: todo_add(text: \"Buy Milk\") { text } }", context: {context_value: "bar"}, root_value: todos)
+          end
+        end
+      end
+    end
+
+    describe "custom resolve behavior" do
+      class AppResolver
+        def initialize
+          @todos = [Todo.new("Pay the bills.")]
+          @resolves = {
+            "Query" => {
+              "all_todos" => ->(obj, args, ctx) { @todos },
+            },
+            "Mutation" => {
+              "todo_add" => ->(obj, args, ctx) {
+                todo = Todo.new(args[:text], ctx[:context_value])
+                @todos << todo
+                todo
+              },
+            },
+            "Todo" => {
+              "text" => ->(obj, args, ctx) { obj.text },
+              "from_context" => ->(obj, args, ctx) { obj.from_context },
+            }
+          }
+        end
+
+        def call(type, field, obj, args, ctx)
+          @resolves
+            .fetch(type.name)
+            .fetch(field.name)
+            .call(obj, args, ctx)
+        end
+      end
+
+      it "accepts a default_resolve callable" do
+        schema = GraphQL::Schema.from_definition(schema_defn, default_resolve: AppResolver.new)
+        schema.execute("mutation { todoAdd: todo_add(text: \"Buy Milk\") { text } }", context: {context_value: "bar"})
+        result = schema.execute("query { allTodos: all_todos { text, from_context } }")
+        assert_equal(result.to_json, '{"data":{"allTodos":[{"text":"Pay the bills.","from_context":null},{"text":"Buy Milk","from_context":"bar"}]}}')
+      end
+    end
+  end
 end