graphql 1.9.11 → 1.9.12

data/spec/integration/rails/graphql/relay/base_connection_spec.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-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
-      class SpecialArrayConnection < GraphQL::Relay::BaseConnection; end
-      GraphQL::Relay::BaseConnection.register_connection_implementation(SpecialArray, SpecialArrayConnection)
-
-      nodes = SpecialArray.new
-
-      conn_class = GraphQL::Relay::BaseConnection.connection_for_nodes(nodes)
-      assert_equal conn_class, SpecialArrayConnection
-    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
-
-      args = {
-        first: nil,
-      }
-      conn = GraphQL::Relay::BaseConnection.new([], args, context: context)
-      assert_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
-    end
-  end
-
-  describe "#inspect" do
-    it "inspects nicely" do
-      args = {
-        first: 1,
-        last: -1,
-      }
-      conn = GraphQL::Relay::BaseConnection.new([], args, context: context)
-      assert_equal "#<GraphQL::Relay::Connection @parent=nil @arguments={:first=>1, :last=>-1}>", conn.inspect
-    end
-  end
-
-  describe "#encode / #decode" do
-    module ReverseEncoder
-      module_function
-      def encode(str, nonce: false); str.reverse; end
-      def decode(str, nonce: false); str.reverse; end
-    end
-
-    let(:schema) { OpenStruct.new(cursor_encoder: ReverseEncoder) }
-    let(:context) { OpenStruct.new(schema: schema) }
-
-    it "Uses the schema's encoder" do
-      conn = GraphQL::Relay::BaseConnection.new([], {}, context: context)
-
-      assert_equal "1/nosreP", conn.encode("Person/1")
-      assert_equal "Person/1", conn.decode("1/nosreP")
-    end
-
-    it "defaults to base64 (urlsafe_base64 without padding)" do
-      conn = GraphQL::Relay::BaseConnection.new([], {}, context: nil)
-
-      assert_equal "UGVyc29uLzE", conn.encode("Person/1")
-      assert_equal "Person/1", conn.decode("UGVyc29uLzE=") # can decode with padding
-    end
-
-    it "handles trimmed base64" do
-      conn = GraphQL::Relay::BaseConnection.new([], {}, context: nil)
-
-      assert_equal "Person/1", conn.decode("UGVyc29uLzE")
-    end
-
-    it "raises an execution error when an invalid cursor is given" do
-      conn = GraphQL::Relay::BaseConnection.new([], {}, context: nil)
-
-      assert_raises(GraphQL::ExecutionError) do
-        conn.decode("0")
-      end
-    end
-  end
-end

data/spec/integration/rails/graphql/relay/connection_instrumentation_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Relay::ConnectionInstrumentation do
-  it "replaces the previous field definition" do
-    test_type = GraphQL::ObjectType.define do
-      name "Test"
-      connection :tests, test_type.connection_type
-    end
-
-    assert_equal ["tests"], test_type.fields.keys
-  end
-
-  let(:build_schema) {
-    test_type = nil
-
-    test_field = GraphQL::Field.define do
-      type(test_type.connection_type)
-      property(:something)
-    end
-
-    test_type = GraphQL::ObjectType.define do
-      name "Test"
-      connection :tests, test_field
-    end
-
-    [
-      test_field,
-      GraphQL::Schema.define(query: test_type, raise_definition_error: true)
-    ]
-  }
-
-  it "leaves the original field untouched" do
-    test_field, test_schema = build_schema
-    conn_field = test_schema.get_field(test_schema.query, "tests")
-
-    assert_equal 0, test_field.arguments.length
-    assert_equal 4, conn_field.arguments.length
-
-    assert_instance_of GraphQL::Field::Resolve::MethodResolve, test_field.resolve_proc
-    assert_instance_of GraphQL::Relay::ConnectionResolve, conn_field.resolve_proc
-  end
-
-  it "passes connection behaviors to redefinitions" do
-    _test_field, test_schema = build_schema
-    connection_field = test_schema.get_field(test_schema.query, "tests")
-    redefined_connection_field = connection_field.redefine { argument "name", types.String }
-
-    assert_equal 4, connection_field.arguments.size
-    assert_equal 5, redefined_connection_field.arguments.size
-
-    assert_instance_of GraphQL::Relay::ConnectionResolve, connection_field.resolve_proc
-    assert_instance_of GraphQL::Relay::ConnectionResolve, redefined_connection_field.resolve_proc
-  end
-
-  # field instrumentation doesn't exist here
-  if !TESTING_INTERPRETER
-    describe "after_built_ins instrumentation" do
-      it "has access to connection objects" do
-        query_str = <<-GRAPHQL
-        {
-          rebels {
-            ships {
-              pageInfo {
-                __typename
-              }
-            }
-          }
-        }
-        GRAPHQL
-        ctx = { before_built_ins: [], after_built_ins: [] }
-        star_wars_query(query_str, {}, context: ctx)
-        # These are data classes, later they're wrapped with type proxies
-        assert_equal ["StarWars::FactionRecord", "GraphQL::Relay::ArrayConnection", "GraphQL::Relay::ArrayConnection"], ctx[:before_built_ins]
-        # After the object is wrapped in a connection, it sees the connection object
-        assert_equal ["StarWars::Faction", "StarWars::ShipConnectionWithParentType", "GraphQL::Types::Relay::PageInfo"], ctx[:after_built_ins]
-      end
-    end
-  end
-end

data/spec/integration/rails/graphql/relay/connection_resolve_spec.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Relay::ConnectionResolve do
-  let(:query_string) { <<-GRAPHQL
-    query getShips($name: String!){
-      rebels {
-        ships(nameIncludes: $name) {
-          edges {
-            node {
-              name
-            }
-          }
-          parentClassName
-        }
-      }
-    }
-    GRAPHQL
-  }
-
-  describe "when an execution error is returned" do
-    it "adds an error" do
-      result = star_wars_query(query_string, { "name" => "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, { "name" => "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, { "name" => "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, { "name" => "raisedError"})
-      assert_equal 1, result["errors"].length
-      assert_equal "error raised from within connection", result["errors"][0]["message"]
-    end
-  end
-
-
-  describe "when a lazy object is returned" do
-    it "returns the items with the correct parent" do
-      result = star_wars_query(query_string, { "name" => "lazyObject"})
-      assert_equal 5, result["data"]["rebels"]["ships"]["edges"].length
-      assert_equal "StarWars::FactionRecord", result["data"]["rebels"]["ships"]["parentClassName"]
-    end
-  end
-
-  describe "when a resolver is used" do
-    it "returns the items with the correct parent" do
-      resolver_query_str = <<-GRAPHQL
-        {
-          rebels {
-            shipsByResolver {
-              parentClassName
-            }
-          }
-        }
-        GRAPHQL
-      result = star_wars_query(resolver_query_str)
-      assert_equal "StarWars::FactionRecord", result["data"]["rebels"]["shipsByResolver"]["parentClassName"]
-    end
-  end
-
-  describe "when nil is returned" do
-    it "becomes null" do
-      result = star_wars_query(query_string, { "name" => "null" })
-      conn = result["data"]["rebels"]["ships"]
-      assert_nil conn
-    end
-  end
-end

data/spec/integration/rails/graphql/relay/connection_type_spec.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Relay::ConnectionType do
-  describe ".create_type" do
-    describe "connections with custom Edge classes / EdgeTypes" do
-      let(:query_string) {%|
-        {
-          rebels {
-            basesWithCustomEdge {
-              totalCountTimes100
-              fieldName
-              edges {
-                upcasedName
-                upcasedParentName
-                edgeClassName
-                node {
-                  name
-                }
-                cursor
-              }
-            }
-          }
-        }
-      |}
-
-      it "uses the custom edge and custom connection" do
-        result = star_wars_query(query_string)
-        bases = result["data"]["rebels"]["basesWithCustomEdge"]
-        assert_equal 300, bases["totalCountTimes100"]
-        assert_equal 'basesWithCustomEdge', bases["fieldName"]
-        assert_equal ["YAVIN", "ECHO BASE", "SECRET HIDEOUT"] , bases["edges"].map { |e| e["upcasedName"] }
-        assert_equal ["Yavin", "Echo Base", "Secret Hideout"] , bases["edges"].map { |e| e["node"]["name"] }
-        assert_equal ["StarWars::CustomBaseEdge"] , bases["edges"].map { |e| e["edgeClassName"] }.uniq
-        upcased_rebels_name = "ALLIANCE TO RESTORE THE REPUBLIC"
-        assert_equal [upcased_rebels_name] , bases["edges"].map { |e| e["upcasedParentName"] }.uniq
-      end
-    end
-
-    describe "connections with nodes field" do
-      let(:query_string) {%|
-        {
-          rebels {
-            bases {
-              nodes {
-                name
-              }
-            }
-            basesWithCustomEdge {
-              nodes {
-                name
-              }
-            }
-          }
-        }
-      |}
-
-      it "uses the custom edge and custom connection" do
-        result = star_wars_query(query_string)
-        bases = result["data"]["rebels"]["bases"]
-        assert_equal ["Yavin", "Echo Base", "Secret Hideout"] , bases["nodes"].map { |e| e["name"] }
-        bases_with_custom_edge = result["data"]["rebels"]["basesWithCustomEdge"]
-        assert_equal ["Yavin", "Echo Base", "Secret Hideout"] , bases_with_custom_edge["nodes"].map { |e| e["name"] }
-      end
-    end
-
-    describe "connections without nodes field" do
-      let(:query_string) {%|
-        {
-          rebels {
-            basesWithoutNodes {
-              nodes {
-                name
-              }
-            }
-          }
-        }
-      |}
-
-      it "raises error" do
-        result = star_wars_query(query_string)
-        assert_includes result["errors"][0]["message"], "Field 'nodes' doesn't exist"
-      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_nil result["data"]["basesWithNullName"]["edges"][0]["node"]
-        assert_equal "Boom!", result["errors"][0]["message"]
-      end
-    end
-  end
-end

data/spec/integration/rails/graphql/relay/edge_spec.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Relay::Edge do
-  it "inspects nicely" do
-    connection = OpenStruct.new(parent: "Parent")
-    edge = GraphQL::Relay::Edge.new("Node", connection)
-    assert_equal '#<GraphQL::Relay::Edge ("Parent" => "Node")>', edge.inspect
-  end
-end

data/spec/integration/rails/graphql/relay/mutation_spec.rb

@@ -1,387 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe GraphQL::Relay::Mutation do
-  let(:query_string) {%|
-    mutation addBagel($clientMutationId: String, $shipName: String = "Bagel") {
-      introduceShip(input: {shipName: $shipName, factionId: "1", clientMutationId: $clientMutationId}) {
-        clientMutationId
-        shipEdge {
-          node { name, id }
-        }
-        faction { name }
-      }
-    }
-  |}
-  let(:introspect) {%|
-    {
-      __schema {
-        types { name, fields { name } }
-      }
-    }
-  |}
-
-  after do
-    StarWars::DATA["Ship"].delete("9")
-    StarWars::DATA["Faction"]["1"].ships.delete("9")
-  end
-
-  it "supports null values" do
-    result = star_wars_query(query_string, "clientMutationId" => "1234", "shipName" => nil)
-
-    expected = {"data" => {
-      "introduceShip" => {
-        "clientMutationId" => "1234",
-        "shipEdge" => {
-          "node" => {
-            "name" => nil,
-            "id" => GraphQL::Schema::UniqueWithinType.encode("Ship", "9"),
-          },
-        },
-        "faction" => {"name" => StarWars::DATA["Faction"]["1"].name }
-      }
-    }}
-    assert_equal(expected, result)
-  end
-
-  it "supports lazy resolution" do
-    result = star_wars_query(query_string, "clientMutationId" => "1234", "shipName" => "Slave II")
-    assert_equal "Slave II", result["data"]["introduceShip"]["shipEdge"]["node"]["name"]
-  end
-
-  it "raises when using a generated return type and resolve doesnt return a Hash" do
-    bad_mutation = GraphQL::Relay::Mutation.define do
-      name 'BadMutation'
-      description 'A mutation type that doesnt return a hash'
-
-      input_field :input, types.String
-      return_field :return, types.String
-
-      resolve ->(_, _, _) {
-        # Should have been { return: 'my_bad_return_value' }
-        'my_bad_return_value'
-      }
-    end
-
-    root = GraphQL::ObjectType.define do
-      name "MutationRoot"
-      field :bad, bad_mutation.field
-    end
-
-    schema = GraphQL::Schema.define { mutation(root) }
-
-    exception = assert_raises(StandardError) do
-      schema.execute('mutation { bad(input: { input: "graphql" }) { return } }')
-    end
-
-    expected_message = "Expected `my_bad_return_value` to be a Hash."\
-      " Return a hash when using `return_field` or specify a custom `return_type`."
-    assert_equal expected_message, exception.message
-  end
-
-  it "returns the result & clientMutationId" do
-    result = star_wars_query(query_string, "clientMutationId" => "1234")
-    expected = {"data" => {
-      "introduceShip" => {
-        "clientMutationId" => "1234",
-        "shipEdge" => {
-          "node" => {
-            "name" => "Bagel",
-            "id" => GraphQL::Schema::UniqueWithinType.encode("Ship", "9"),
-          },
-        },
-        "faction" => {"name" => StarWars::DATA["Faction"]["1"].name }
-      }
-    }}
-    assert_equal(expected, result)
-  end
-
-  it "doesn't require a clientMutationId to perform mutations" do
-    result = star_wars_query(query_string)
-    new_ship_name = result["data"]["introduceShip"]["shipEdge"]["node"]["name"]
-    assert_equal("Bagel", new_ship_name)
-  end
-
-  it "applies the description to the derived field" do
-    field = GraphQL::Schema::Field.from_options(name: "x", **StarWars::IntroduceShipMutation.field_options)
-    assert_equal "Add a ship to this faction", field.description
-  end
-
-  it "inserts itself into the derived objects' metadata" do
-    field = GraphQL::Schema::Field.from_options(name: "x", **StarWars::IntroduceShipMutation.field_options)
-    assert_equal StarWars::IntroduceShipMutation, field.mutation
-    assert_equal StarWars::IntroduceShipMutation, field.to_graphql.mutation
-    assert_equal StarWars::IntroduceShipMutation, StarWars::IntroduceShipMutation.payload_type.mutation
-    assert_equal StarWars::IntroduceShipMutation, StarWars::IntroduceShipMutation.input_type.mutation
-  end
-
-  describe "return_field ... property:" do
-    it "resolves correctly" do
-      query_str = <<-GRAPHQL
-        mutation {
-          introduceShip(input: {shipName: "Bagel", factionId: "1"}) {
-            aliasedFaction { name }
-          }
-        }
-      GRAPHQL
-      result = star_wars_query(query_str)
-      faction_name = result["data"]["introduceShip"]["aliasedFaction"]["name"]
-      assert_equal("Alliance to Restore the Republic", faction_name)
-    end
-  end
-
-  describe "aliased methods" do
-    describe "on an unreached mutation" do
-      it 'still ensures definitions' do
-        UnreachedMutation = GraphQL::Relay::Mutation.define do
-          name 'UnreachedMutation'
-          description 'A mutation type not directly used in the schema.'
-
-          input_field :input, types.String
-          return_field :return, types.String
-        end
-
-        assert UnreachedMutation.input_fields['input']
-        assert UnreachedMutation.return_fields['return']
-      end
-    end
-  end
-
-  describe "providing a return type" do
-    let(:custom_return_type) {
-      GraphQL::ObjectType.define do
-        name "CustomReturnType"
-        field :name, types.String
-      end
-    }
-
-    let(:mutation) {
-      custom_type = custom_return_type
-      GraphQL::Relay::Mutation.define do
-        name "CustomReturnTypeTest"
-
-        input_field :nullDefault, types.String, default_value: nil
-        input_field :noDefault, types.String
-        input_field :stringDefault, types.String, default_value: 'String'
-
-        return_type custom_type
-        resolve ->(obj, input, ctx) {
-          OpenStruct.new(name: "Custom Return Type Test")
-        }
-      end
-    }
-
-    let(:input) { mutation.field.arguments['input'].type.unwrap }
-
-    let(:schema) {
-      mutation_field = mutation.field
-
-      mutation_root = GraphQL::ObjectType.define do
-        name "Mutation"
-        field :custom, mutation_field
-      end
-
-      GraphQL::Schema.define do
-        mutation(mutation_root)
-      end
-    }
-
-    it "uses the provided type" do
-      assert_equal custom_return_type, mutation.return_type
-      assert_equal custom_return_type, mutation.field.type
-
-      result = schema.execute("mutation { custom(input: {}) { name } }")
-      assert_equal "Custom Return Type Test", result["data"]["custom"]["name"]
-    end
-
-    it "doesn't get a mutation in the metadata" do
-      assert_nil custom_return_type.mutation
-    end
-
-    it "supports input fields with nil default value" do
-      assert input.arguments['nullDefault'].default_value?
-      assert_nil input.arguments['nullDefault'].default_value
-    end
-
-    it "supports input fields with no default value" do
-      assert !input.arguments['noDefault'].default_value?
-      assert_nil input.arguments['noDefault'].default_value
-    end
-
-    it "supports input fields with non-nil default value" do
-      assert input.arguments['stringDefault'].default_value?
-      assert_equal "String", input.arguments['stringDefault'].default_value
-    end
-  end
-
-  describe "specifying return interfaces" do
-    let(:result_interface) {
-      GraphQL::InterfaceType.define do
-        name "ResultInterface"
-        field :success, !types.Boolean
-        field :notice, types.String
-      end
-    }
-
-    let(:error_interface) {
-      GraphQL::InterfaceType.define do
-        name "ErrorInterface"
-        field :error, types.String
-      end
-    }
-
-    let(:mutation) {
-      interfaces = [result_interface, error_interface]
-      GraphQL::Relay::Mutation.define do
-        name "ReturnTypeWithInterfaceTest"
-
-        return_field :name, types.String
-
-        return_interfaces interfaces
-
-        resolve ->(obj, input, ctx) {
-          {
-            name: "Type Specific Field",
-            success: true,
-            notice: "Success Interface Field",
-            error: "Error Interface Field"
-          }
-        }
-      end
-    }
-
-    let(:schema) {
-      mutation_field = mutation.field
-
-      mutation_root = GraphQL::ObjectType.define do
-        name "Mutation"
-        field :custom, mutation_field
-      end
-
-      GraphQL::Schema.define do
-        mutation(mutation_root)
-        resolve_type NO_OP_RESOLVE_TYPE
-      end
-    }
-
-    it 'makes the mutation type implement the interfaces' do
-      assert_equal [result_interface, error_interface], mutation.return_type.interfaces
-    end
-
-    it "returns interface values and specific ones" do
-      result = schema.execute('mutation { custom(input: {clientMutationId: "123"}) { name, success, notice, error, clientMutationId } }')
-      assert_equal "Type Specific Field", result["data"]["custom"]["name"]
-      assert_equal "Success Interface Field", result["data"]["custom"]["notice"]
-      assert_equal true, result["data"]["custom"]["success"]
-      assert_equal "Error Interface Field", result["data"]["custom"]["error"]
-      assert_equal "123", result["data"]["custom"]["clientMutationId"]
-    end
-  end
-
-  describe "handling errors" do
-    it "supports returning an error in resolve" do
-      result = star_wars_query(query_string, "clientMutationId" => "5678", "shipName" => "Millennium Falcon")
-
-      expected = {
-        "data" => {
-          "introduceShip" => nil,
-        },
-        "errors" => [
-          {
-            "message" => "Sorry, Millennium Falcon ship is reserved",
-            "locations" => [ { "line" => 3 , "column" => 7}],
-            "path" => ["introduceShip"]
-          }
-        ]
-      }
-
-      assert_equal(expected, result)
-    end
-
-    it "supports raising an error in a lazy callback" do
-      result = star_wars_query(query_string, "clientMutationId" => "5678", "shipName" => "Ebon Hawk")
-
-      expected = {
-        "data" => {
-          "introduceShip" => nil,
-        },
-        "errors" => [
-          {
-            "message" => "💥",
-            "locations" => [ { "line" => 3 , "column" => 7}],
-            "path" => ["introduceShip"]
-          }
-        ]
-      }
-
-      assert_equal(expected, result)
-    end
-
-    it "supports raising an error in the resolve function" do
-      result = star_wars_query(query_string, "clientMutationId" => "5678", "shipName" => "Leviathan")
-
-      expected = {
-        "data" => {
-          "introduceShip" => nil,
-        },
-        "errors" => [
-          {
-            "message" => "🔥",
-            "locations" => [ { "line" => 3 , "column" => 7}],
-            "path" => ["introduceShip"]
-          }
-        ]
-      }
-
-      assert_equal(expected, result)
-    end
-  end
-
-  describe 'supports new input object definition with old mutation definition' do
-    let(:some_attribute_type) do
-      Class.new(GraphQL::Schema::InputObject) do
-        graphql_name 'SomeAttribute'
-        argument :something, String, required: false
-      end
-    end
-
-    let(:do_something_mutation) do
-      some_attribute = some_attribute_type
-
-      GraphQL::Relay::Mutation.define do
-        name 'DoSomethingMutation'
-        input_field :someAttributes, types[some_attribute.graphql_definition]
-
-        return_field :anything, types.String
-
-        resolve ->(_obj, inputs, _ctx) {
-          {
-            anything: inputs.to_h['someAttributes'][0].class.to_s
-          }
-        }
-      end
-    end
-
-    let(:mutation_type) do
-      do_something = do_something_mutation
-
-      Class.new(GraphQL::Schema::Object) do
-        graphql_name 'Mutation'
-        field :doSomething, field: do_something.field
-      end
-    end
-
-    let(:schema) do
-      mutation = mutation_type
-
-      Class.new(GraphQL::Schema) do
-        mutation mutation
-      end
-    end
-
-    it 'converts to hash the whole input' do
-      result = schema.execute('mutation { doSomething(input: {someAttributes: [{something: "string"}]}) { anything } }')
-      assert_equal 'Hash', result['data']['doSomething']['anything']
-    end
-  end
-end