graphql 1.9.5 → 1.13.19

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

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

@@ -1,263 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Relay::Node do
-  describe ".interface" do
-    it "is a default relay type" do
-      assert_equal true, GraphQL::Relay::Node.interface.default_relay?
-    end
-  end
-
-  describe ".field" 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"
-
-        result = star_wars_query(%|{
-          nodeWithCustomResolver(id: "#{id}") {
-            id,
-            ... on Faction {
-              name
-              ships(first: 1) {
-                edges {
-                 node {
-                   name
-                   }
-                }
-              }
-            }
-          }
-        }|)
-
-        expected = {"data" => {
-          "nodeWithCustomResolver"=>{
-            "id"=>"RmFjdGlvbi0x",
-            "name"=>"Alliance to Restore the Republic",
-            "ships"=>{
-              "edges"=>[
-                {"node"=>{
-                    "name" => "X-Wing"
-                  }
-                }
-              ]
-            }
-          }
-        }}
-
-        assert_equal(expected, result)
-      end
-    end
-
-    describe "Custom global IDs" do
-      before do
-        # TODO: make the schema eager-load so we can remove this
-        # Ensure the schema is defined:
-        StarWars::Schema.types
-
-        @previous_id_from_object_proc = StarWars::Schema.id_from_object_proc
-        @previous_object_from_id_proc = StarWars::Schema.object_from_id_proc
-
-        StarWars::Schema.id_from_object = ->(obj, type_name, ctx) {
-          "#{type_name}/#{obj.id}"
-        }
-
-        StarWars::Schema.object_from_id = ->(global_id, ctx) {
-          type_name, id = global_id.split("/")
-          StarWars::DATA[type_name][id]
-        }
-      end
-
-      after do
-        StarWars::Schema.id_from_object = @previous_id_from_object_proc
-        StarWars::Schema.object_from_id = @previous_object_from_id_proc
-      end
-
-      it "Deconstructs the ID by the custom proc" do
-        result = star_wars_query(%| { node(id: "Base/1") { ... on Base { name } } }|)
-        base_name = result["data"]["node"]["name"]
-        assert_equal "Yavin", base_name
-      end
-
-      describe "generating IDs" do
-        it "Applies custom-defined ID generation" do
-          result = star_wars_query(%| { largestBase { id } }|)
-          generated_id = result["data"]["largestBase"]["id"]
-          assert_equal "Base/3", generated_id
-        end
-      end
-    end
-
-    describe "setting a description" do
-      it "allows you to set a description" do
-        node_field = GraphQL::Relay::Node.field
-        node_field.description = "Hello, World!"
-        assert_equal "Hello, World!", node_field.description
-      end
-    end
-
-    it 'finds objects by id' do
-      id = GraphQL::Schema::UniqueWithinType.encode("Faction", "1")
-      result = star_wars_query(%|{
-        node(id: "#{id}") {
-          id,
-          ... on Faction {
-            name
-            ships(first: 1) {
-              edges {
-               node {
-                 name
-                 }
-              }
-            }
-          }
-        }
-      }|)
-      expected = {"data" => {
-        "node"=>{
-          "id"=>"RmFjdGlvbi0x",
-          "name"=>"Alliance to Restore the Republic",
-          "ships"=>{
-            "edges"=>[
-              {"node"=>{
-                  "name" => "X-Wing"
-                }
-              }
-            ]
-          }
-        }
-      }}
-      assert_equal(expected, result)
-    end
-  end
-
-  describe ".plural_identifying_field" 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"]
-
-        result = star_wars_query(%|{
-          nodesWithCustomResolver(ids: ["#{id[0]}", "#{id[1]}"]) {
-            id,
-            ... on Faction {
-              name
-              ships(first: 1) {
-                edges {
-                 node {
-                   name
-                   }
-                }
-              }
-            }
-          }
-        }|)
-
-        expected = {
-          "data" => {
-            "nodesWithCustomResolver" => [
-              {
-                "id" => "RmFjdGlvbi0x",
-                "name" => "Alliance to Restore the Republic",
-                "ships" => {
-                  "edges"=>[
-                    { "node" => { "name" => "X-Wing" } }
-                  ]
-                }
-              },
-              {
-                "id" => "RmFjdGlvbi0y",
-                "name" => "Galactic Empire",
-                "ships" => {
-                  "edges"=>[
-                    { "node" => { "name" => "TIE Fighter" } }
-                  ]
-                }
-              },
-            ]
-          }
-        }
-
-        assert_equal(expected, result)
-      end
-    end
-
-    it 'finds objects by ids' do
-      id = GraphQL::Schema::UniqueWithinType.encode("Faction", "1")
-      id2 = GraphQL::Schema::UniqueWithinType.encode("Faction", "2")
-
-      result = star_wars_query(%|{
-        nodes(ids: ["#{id}", "#{id2}"]) {
-          id,
-          ... on Faction {
-            name
-            ships(first: 1) {
-              edges {
-               node {
-                 name
-                 }
-              }
-            }
-          }
-        }
-      }|)
-
-      expected = {
-        "data" => {
-          "nodes" => [{
-            "id"=>"RmFjdGlvbi0x",
-            "name"=>"Alliance to Restore the Republic",
-            "ships"=>{
-              "edges"=>[
-                {"node"=>{
-                    "name" => "X-Wing"
-                  }
-                }
-              ]
-            }
-          }, {
-            "id" => "RmFjdGlvbi0y",
-            "name" => "Galactic Empire",
-            "ships" => {
-              "edges" => [
-                { "node" => { "name" => "TIE Fighter" } }
-              ]
-            }
-          }]
-        }
-      }
-
-      assert_equal(expected, result)
-    end
-
-    it 'is marked as relay_nodes_field' do
-      assert GraphQL::Relay::Node.plural_field.relay_nodes_field
-    end
-  end
-end