graphql 0.17.2 → 0.18.0

data/spec/graphql/query_spec.rb

@@ -124,6 +124,16 @@ describe GraphQL::Query do
     end
   end
 
+  it "fails to execute a query containing a type definition" do
+    query_string = '
+      { root }
+
+      type Query { foo: String }
+    '
+    exc = assert_raises(GraphQL::ExecutionError) { GraphQL::Query.new(schema, query_string) }
+    assert_equal "GraphQL query cannot contain a schema definition", exc.message
+  end
+
   it "uses root_value as the object for the root type" do
     result = GraphQL::Query.new(schema, '{ root }', root_value: "I am root").result
     assert_equal 'I am root', result.fetch('data').fetch('root')

data/spec/graphql/relay/array_connection_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+describe GraphQL::Relay::ArrayConnection do
+  def get_names(result)
+    ships = result["data"]["rebels"]["ships"]["edges"]
+    names = ships.map { |e| e["node"]["name"] }
+  end
+
+  def get_last_cursor(result)
+    result["data"]["rebels"]["ships"]["edges"].last["cursor"]
+  end
+
+  describe "results" do
+    let(:query_string) {%|
+      query getShips($first: Int, $after: String, $last: Int, $before: String, $nameIncludes: String){
+        rebels {
+          ships(first: $first, after: $after, last: $last, before: $before, nameIncludes: $nameIncludes) {
+            edges {
+              cursor
+              node {
+                name
+              }
+            }
+            pageInfo {
+              hasNextPage
+              hasPreviousPage
+              startCursor
+              endCursor
+            }
+          }
+        }
+      }
+    |}
+
+    it 'limits the result' do
+      result = query(query_string, "first" => 2)
+      number_of_ships = get_names(result).length
+      assert_equal(2, number_of_ships)
+      assert_equal(true, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
+      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
+      assert_equal("MQ==", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
+      assert_equal("Mg==", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
+
+      result = query(query_string, "first" => 3)
+      number_of_ships = get_names(result).length
+      assert_equal(3, number_of_ships)
+    end
+
+    it 'provides pageInfo' do
+      result = query(query_string, "first" => 2)
+      assert_equal(true, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
+      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
+      assert_equal("MQ==", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
+      assert_equal("Mg==", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
+
+      result = query(query_string, "first" => 100)
+      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
+      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
+      assert_equal("MQ==", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
+      assert_equal("NQ==", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
+    end
+
+    it 'slices the result' do
+      result = query(query_string, "first" => 1)
+      assert_equal(["X-Wing"], get_names(result))
+
+      # After the last result, find the next 2:
+      last_cursor = get_last_cursor(result)
+
+      result = query(query_string, "after" => last_cursor, "first" => 2)
+      assert_equal(["Y-Wing", "A-Wing"], get_names(result))
+
+      # After the last result, find the next 2:
+      last_cursor = get_last_cursor(result)
+
+      result = query(query_string, "after" => last_cursor, "first" => 2)
+      assert_equal(["Millenium Falcon", "Home One"], get_names(result))
+
+      result = query(query_string, "before" => last_cursor, "last" => 2)
+      assert_equal(["X-Wing", "Y-Wing"], get_names(result))
+    end
+
+    it 'applies custom arguments' do
+      result = query(query_string, "nameIncludes" => "Wing", "first" => 2)
+      names = get_names(result)
+      assert_equal(2, names.length)
+
+      after = get_last_cursor(result)
+      result = query(query_string, "nameIncludes" => "Wing", "after" => after, "first" => 3)
+      names = get_names(result)
+      assert_equal(1, names.length)
+    end
+
+    it 'works without first/last/after/before' do
+      result = query(query_string)
+
+      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasNextPage"])
+      assert_equal(false, result["data"]["rebels"]["ships"]["pageInfo"]["hasPreviousPage"])
+      assert_equal("MQ==", result["data"]["rebels"]["ships"]["pageInfo"]["startCursor"])
+      assert_equal("NQ==", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
+      assert_equal(5, result["data"]["rebels"]["ships"]["edges"].length)
+    end
+
+    describe "applying max_page_size" do
+      def get_names(result)
+        result["data"]["rebels"]["bases"]["edges"].map { |e| e["node"]["name"] }
+      end
+
+      def get_page_info(result)
+        result["data"]["rebels"]["bases"]["pageInfo"]
+      end
+
+      let(:query_string) {%|
+        query getShips($first: Int, $after: String, $last: Int, $before: String){
+          rebels {
+            bases: basesWithMaxLimitArray(first: $first, after: $after, last: $last, before: $before) {
+              edges {
+                cursor
+                node {
+                  name
+                }
+              }
+              pageInfo {
+                hasNextPage
+                hasPreviousPage
+              }
+            }
+          }
+        }
+      |}
+
+      it "applies to queries by `first`" do
+        result = query(query_string, "first" => 100)
+        assert_equal(["Yavin", "Echo Base"], get_names(result))
+        assert_equal(true, get_page_info(result)["hasNextPage"])
+
+        # Max page size is applied _without_ `first`, also
+        result = query(query_string)
+        assert_equal(["Yavin", "Echo Base"], get_names(result))
+        assert_equal(false, get_page_info(result)["hasNextPage"], "hasNextPage is false when first is not specified")
+      end
+
+      it "applies to queries by `last`" do
+        last_cursor = "Ng=="
+        second_to_last_two_names = ["Death Star", "Shield Generator"]
+        result = query(query_string, "last" => 100, "before" => last_cursor)
+        assert_equal(second_to_last_two_names, get_names(result))
+        assert_equal(true, get_page_info(result)["hasPreviousPage"])
+
+        result = query(query_string, "before" => last_cursor)
+        assert_equal(second_to_last_two_names, get_names(result))
+        assert_equal(false, get_page_info(result)["hasPreviousPage"], "hasPreviousPage is false when last is not specified")
+
+        third_cursor = "Mw=="
+        first_and_second_names = ["Yavin", "Echo Base"]
+        result = query(query_string, "last" => 100, "before" => third_cursor)
+        assert_equal(first_and_second_names, get_names(result))
+
+        result = query(query_string, "before" => third_cursor)
+        assert_equal(first_and_second_names, get_names(result))
+      end
+    end
+  end
+end

data/spec/graphql/relay/connection_type_spec.rb

@@ -0,0 +1,37 @@
+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
+              edges {
+                upcasedName
+                upcasedParentName
+                edgeClassName
+                node {
+                  name
+                }
+                cursor
+              }
+            }
+          }
+        }
+      |}
+
+      it "uses the custom edge and custom connection" do
+        result = query(query_string)
+        bases = result["data"]["rebels"]["basesWithCustomEdge"]
+        assert_equal 300, bases["totalCountTimes100"]
+        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 ["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
+  end
+end

data/spec/graphql/relay/global_node_identification_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe GraphQL::Relay::GlobalNodeIdentification do
+  let(:node_identification) { StarWarsSchema.node_identification }
+  describe 'NodeField' do
+    it 'finds objects by id' do
+      global_id = node_identification.to_global_id("Faction", "1")
+      result = query(%|{
+        node(id: "#{global_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
+
+  after do
+    # Set the id_separator back to it's default after each spec, since some of
+    # them change it at runtime
+    GraphQL::Relay::GlobalNodeIdentification.id_separator = "-"
+  end
+
+  describe 'id_separator' do
+    it "allows you to change it at runtime" do
+      GraphQL::Relay::GlobalNodeIdentification.id_separator = "-zomg-"
+
+      assert_equal("-zomg-", GraphQL::Relay::GlobalNodeIdentification.id_separator)
+    end
+  end
+
+  describe 'to_global_id / from_global_id ' do
+    it 'Converts typename and ID to and from ID' do
+      global_id = node_identification.to_global_id("SomeType", 123)
+      type_name, id = node_identification.from_global_id(global_id)
+      assert_equal("SomeType", type_name)
+      assert_equal("123", id)
+    end
+
+    it "allows you to change the id_separator" do
+      GraphQL::Relay::GlobalNodeIdentification.id_separator = "---"
+
+      global_id = node_identification.to_global_id("Type-With-UUID", "250cda0e-a89d-41cf-99e1-2872d89f1100")
+      type_name, id = node_identification.from_global_id(global_id)
+      assert_equal("Type-With-UUID", type_name)
+      assert_equal("250cda0e-a89d-41cf-99e1-2872d89f1100", id)
+    end
+
+    it "raises an error if you try and use a reserved character in the ID" do
+      err = assert_raises(RuntimeError) {
+        node_identification.to_global_id("Best-Thing", "234")
+      }
+      assert_includes err.message, "to_global_id(Best-Thing, 234) contains reserved characters `-`"
+    end
+
+    describe "custom definitions" do
+      let(:custom_node_identification) {
+        ident = GraphQL::Relay::GlobalNodeIdentification.define do
+          to_global_id -> (type_name, id) {
+            "#{type_name}/#{id}"
+          }
+
+          from_global_id -> (global_id) {
+            global_id.split("/")
+          }
+
+          object_from_id -> (node_id, ctx) do
+            type_name, id = ident.from_global_id(node_id)
+            STAR_WARS_DATA[type_name][id]
+          end
+
+          description "Hello, World!"
+        end
+      }
+
+      before do
+        @prev_node_identification = StarWarsSchema.node_identification
+        StarWarsSchema.node_identification = custom_node_identification
+      end
+
+      after do
+        StarWarsSchema.node_identification = @prev_node_identification
+      end
+
+      describe "generating IDs" do
+        it "Applies custom-defined ID generation" do
+          result = query(%| { largestBase { id } }|)
+          generated_id = result["data"]["largestBase"]["id"]
+          assert_equal "Base/3", generated_id
+        end
+      end
+
+      describe "fetching by ID" do
+        it "Deconstructs the ID by the custom proc" do
+          result = query(%| { node(id: "Base/1") { ... on Base { name } } }|)
+          base_name = result["data"]["node"]["name"]
+          assert_equal "Yavin", base_name
+        end
+      end
+
+      describe "setting a description" do
+        it "allows you to set a description" do
+          assert_equal "Hello, World!", custom_node_identification.field.description
+        end
+      end
+    end
+  end
+
+  describe "type_from_object" do
+    describe "when the return value is nil" do
+      it "returns nil" do
+        result = node_identification.type_from_object(123)
+        assert_equal(nil, result)
+      end
+    end
+
+    describe "when the return value is not a BaseType" do
+      it "raises an error " do
+        err = assert_raises(RuntimeError) {
+          node_identification.type_from_object(:test_error)
+        }
+        assert_includes err.message, "not_a_type (Symbol)"
+      end
+    end
+  end
+end

data/spec/graphql/relay/mutation_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe GraphQL::Relay::Mutation do
+  let(:query_string) {%|
+    mutation addBagel($clientMutationId: String) {
+      introduceShip(input: {shipName: "Bagel", factionId: "1", clientMutationId: $clientMutationId}) {
+        clientMutationId
+        ship { name, id }
+        faction { name }
+      }
+    }
+  |}
+  let(:introspect) {%|
+    {
+      __schema {
+        types { name, fields { name } }
+      }
+    }
+  |}
+
+  after do
+    STAR_WARS_DATA["Ship"].delete("9")
+    STAR_WARS_DATA["Faction"]["1"]["ships"].delete("9")
+  end
+
+  it "returns the result & clientMutationId" do
+    result = query(query_string, "clientMutationId" => "1234")
+    expected = {"data" => {
+      "introduceShip" => {
+        "clientMutationId" => "1234",
+        "ship" => {
+          "name" => "Bagel",
+          "id" => NodeIdentification.to_global_id("Ship", "9"),
+        },
+        "faction" => {"name" => STAR_WARS_DATA["Faction"]["1"].name }
+      }
+    }}
+    assert_equal(expected, result)
+  end
+
+  it "doesn't require a clientMutationId to perform mutations" do
+    result = query(query_string)
+    expected = {"data" => {
+      "introduceShip" => {
+        "clientMutationId" => nil,
+        "ship" => {
+          "name" => "Bagel",
+          "id" => NodeIdentification.to_global_id("Ship", "9"),
+        },
+        "faction" => {"name" => STAR_WARS_DATA["Faction"]["1"].name }
+      }
+    }}
+    assert_equal(expected, result)
+  end
+end

data/spec/graphql/relay/page_info_spec.rb

@@ -0,0 +1,106 @@
+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 = query(query_string, "first" => 100)
+    last_cursor = 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
+          }
+        }
+      }
+    }
+  |}
+
+  describe 'hasNextPage / hasPreviousPage' do
+    it "hasNextPage is true if there are more items" do
+      result = 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 = 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 = 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 = 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 = 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("Mg==", get_page_info(result)["startCursor"])
+      assert_equal("Mg==", get_page_info(result)["endCursor"])
+    end
+
+    it "startCursor and endCursor are the cursors of the first and last edge" do
+      result = 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 = 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 = 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