graphql 1.9.11 → 1.9.12

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

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

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Relay::PageInfo do
-  def get_page_info(result)
-    result["data"]["empire"]["bases"]["pageInfo"]
-  end
-
-  def get_first_cursor(result)
-    result["data"]["empire"]["bases"]["edges"].first["cursor"]
-  end
-
-  def get_last_cursor(result)
-    result["data"]["empire"]["bases"]["edges"].last["cursor"]
-  end
-
-  let(:cursor_of_last_base) {
-    result = star_wars_query(query_string, "first" => 100)
-    get_last_cursor(result)
-  }
-
-  let(:query_string) {%|
-    query getShips($first: Int, $after: String, $last: Int, $before: String, $nameIncludes: String){
-      empire {
-        bases(first: $first, after: $after, last: $last, before: $before, nameIncludes: $nameIncludes) {
-          edges {
-            cursor
-          }
-          pageInfo {
-            hasNextPage
-            hasPreviousPage
-            startCursor
-            endCursor
-          }
-        }
-      }
-    }
-  |}
-
-  it "is a default relay type" do
-    assert_equal true, GraphQL::Relay::PageInfo.default_relay?
-  end
-
-  describe 'hasNextPage / hasPreviousPage' do
-    it "hasNextPage is true if there are more items" do
-      result = star_wars_query(query_string, "first" => 2)
-      assert_equal(true, get_page_info(result)["hasNextPage"])
-      assert_equal(false, get_page_info(result)["hasPreviousPage"], "hasPreviousPage is false if 'last' is missing")
-      assert_equal("MQ", get_page_info(result)["startCursor"])
-      assert_equal("Mg", get_page_info(result)["endCursor"])
-
-      last_cursor = get_last_cursor(result)
-      result = star_wars_query(query_string, "first" => 100, "after" => last_cursor)
-      assert_equal(false, get_page_info(result)["hasNextPage"])
-      assert_equal(false, get_page_info(result)["hasPreviousPage"])
-      assert_equal("Mw", get_page_info(result)["startCursor"])
-      assert_equal("Mw", get_page_info(result)["endCursor"])
-    end
-
-    it "hasPreviousPage if there are more items" do
-      result = star_wars_query(query_string, "last" => 100, "before" => cursor_of_last_base)
-      assert_equal(false, get_page_info(result)["hasNextPage"])
-      assert_equal(false, get_page_info(result)["hasPreviousPage"])
-      assert_equal("MQ", get_page_info(result)["startCursor"])
-      assert_equal("Mg", get_page_info(result)["endCursor"])
-
-      result = star_wars_query(query_string, "last" => 1, "before" => cursor_of_last_base)
-      assert_equal(false, get_page_info(result)["hasNextPage"])
-      assert_equal(true, get_page_info(result)["hasPreviousPage"])
-      assert_equal("Mg", get_page_info(result)["startCursor"])
-      assert_equal("Mg", get_page_info(result)["endCursor"])
-    end
-
-    it "has both if first and last are present" do
-      result = star_wars_query(query_string, "last" => 1, "first" => 1, "before" => cursor_of_last_base)
-      assert_equal(true, get_page_info(result)["hasNextPage"])
-      assert_equal(true, get_page_info(result)["hasPreviousPage"])
-      assert_equal("MQ", get_page_info(result)["startCursor"])
-      assert_equal("MQ", get_page_info(result)["endCursor"])
-    end
-
-    it "startCursor and endCursor are the cursors of the first and last edge" do
-      result = star_wars_query(query_string, "first" => 2)
-      assert_equal(true, get_page_info(result)["hasNextPage"])
-      assert_equal(false, get_page_info(result)["hasPreviousPage"])
-      assert_equal("MQ", get_page_info(result)["startCursor"])
-      assert_equal("Mg", get_page_info(result)["endCursor"])
-      assert_equal("MQ", get_first_cursor(result))
-      assert_equal("Mg", get_last_cursor(result))
-
-      result = star_wars_query(query_string, "first" => 1, "after" => get_page_info(result)["endCursor"])
-      assert_equal(false, get_page_info(result)["hasNextPage"])
-      assert_equal(false, get_page_info(result)["hasPreviousPage"])
-      assert_equal("Mw", get_page_info(result)["startCursor"])
-      assert_equal("Mw", get_page_info(result)["endCursor"])
-      assert_equal("Mw", get_first_cursor(result))
-      assert_equal("Mw", get_last_cursor(result))
-
-      result = star_wars_query(query_string, "last" => 1, "before" => get_page_info(result)["endCursor"])
-      assert_equal(false, get_page_info(result)["hasNextPage"])
-      assert_equal(true, get_page_info(result)["hasPreviousPage"])
-      assert_equal("Mg", get_page_info(result)["startCursor"])
-      assert_equal("Mg", get_page_info(result)["endCursor"])
-      assert_equal("Mg", get_first_cursor(result))
-      assert_equal("Mg", get_last_cursor(result))
-    end
-  end
-
-
-
-end

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

@@ -1,117 +0,0 @@
-# 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(unencoded_text, nonce: false)
-      "__#{unencoded_text}"
-    end
-
-    def self.decode(encoded_text, nonce: false)
-      encoded_text[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
-
-    Class.new(GraphQL::Schema) do
-      self.query(query)
-      self.mutation(mutation)
-      self.cursor_encoder(PassThroughEncoder)
-    end
-  }
-
-
-  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