graphql 0.17.2 → 0.18.0

data/spec/graphql/relay/relation_connection_spec.rb

@@ -0,0 +1,348 @@
+require 'spec_helper'
+
+describe GraphQL::Relay::RelationConnection do
+  def get_names(result)
+    ships = result["data"]["empire"]["bases"]["edges"]
+    names = ships.map { |e| e["node"]["name"] }
+  end
+
+  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
+
+  describe "results" do
+    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) {
+            ... basesConnection
+          }
+        }
+      }
+
+      fragment basesConnection on BasesConnectionWithTotalCount {
+        totalCount,
+        edges {
+          cursor
+          node {
+            name
+          }
+        },
+        pageInfo {
+          hasNextPage
+          hasPreviousPage
+          startCursor
+          endCursor
+        }
+      }
+    |}
+
+    it 'limits the result' do
+      result = query(query_string, "first" => 2)
+      assert_equal(2, get_names(result).length)
+      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" => 3)
+      assert_equal(3, get_names(result).length)
+      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("Mw==", get_page_info(result)["endCursor"])
+      assert_equal("MQ==", get_first_cursor(result))
+      assert_equal("Mw==", get_last_cursor(result))
+    end
+
+    it 'provides custom fields on the connection type' do
+      result = query(query_string, "first" => 2)
+      assert_equal(
+        Base.where(faction_id: 2).count,
+        result["data"]["empire"]["bases"]["totalCount"]
+      )
+    end
+
+    it 'slices the result' do
+      result = query(query_string, "first" => 2)
+      assert_equal(["Death Star", "Shield Generator"], 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(["Headquarters"], get_names(result))
+
+      last_cursor = get_last_cursor(result)
+
+      result = query(query_string, "before" => last_cursor, "last" => 1)
+      assert_equal(["Shield Generator"], get_names(result))
+
+      result = query(query_string, "before" => last_cursor, "last" => 2)
+      assert_equal(["Death Star", "Shield Generator"], get_names(result))
+
+      result = query(query_string, "before" => last_cursor, "last" => 10)
+      assert_equal(["Death Star", "Shield Generator"], get_names(result))
+
+    end
+
+    it "applies custom arguments" do
+      result = query(query_string, "first" => 1, "nameIncludes" => "ea")
+      assert_equal(["Death Star"], get_names(result))
+
+      after = get_last_cursor(result)
+
+      result = query(query_string, "first" => 2, "nameIncludes" => "ea", "after" => after )
+      assert_equal(["Headquarters"], get_names(result))
+      before = get_last_cursor(result)
+
+      result = query(query_string, "last" => 1, "nameIncludes" => "ea", "before" => before)
+      assert_equal(["Death Star"], get_names(result))
+    end
+
+    it 'works without first/last/after/before' do
+      result = query(query_string)
+
+      assert_equal(3, result["data"]["empire"]["bases"]["edges"].length)
+    end
+
+    describe "applying max_page_size" do
+      let(:query_string) {%|
+        query getBases($first: Int, $after: String, $last: Int, $before: String){
+          empire {
+            bases: basesWithMaxLimitRelation(first: $first, after: $after, last: $last, before: $before) {
+              ... basesConnection
+            }
+          }
+        }
+
+        fragment basesConnection on BaseConnection {
+          edges {
+            cursor
+            node {
+              name
+            }
+          },
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+        }
+      |}
+
+      it "applies to queries by `first`" do
+        result = query(query_string, "first" => 100)
+        assert_equal(2, result["data"]["empire"]["bases"]["edges"].size)
+        assert_equal(true, result["data"]["empire"]["bases"]["pageInfo"]["hasNextPage"])
+
+        # Max page size is applied _without_ `first`, also
+        result = query(query_string)
+        assert_equal(2, result["data"]["empire"]["bases"]["edges"].size)
+        assert_equal(false, result["data"]["empire"]["bases"]["pageInfo"]["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, result["data"]["empire"]["bases"]["pageInfo"]["hasPreviousPage"])
+
+        result = query(query_string, "before" => last_cursor)
+        assert_equal(second_to_last_two_names, get_names(result))
+        assert_equal(false, result["data"]["empire"]["bases"]["pageInfo"]["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
+
+  describe "without a block" do
+    let(:query_string) {%|
+      {
+        empire {
+          basesClone(first: 10) {
+            edges {
+              node {
+                name
+              }
+            }
+          }
+        }
+    }|}
+    it "uses default resolve" do
+      result = query(query_string)
+      bases = result["data"]["empire"]["basesClone"]["edges"]
+      assert_equal(3, bases.length)
+    end
+  end
+
+  describe "custom ordering" do
+    let(:query_string) {%|
+      query getBases {
+        empire {
+          basesByName(first: 30) { ... basesFields }
+          bases(first: 30) { ... basesFields2 }
+        }
+      }
+      fragment basesFields on BaseConnection {
+        edges {
+          node {
+            name
+          }
+        }
+      }
+      fragment basesFields2 on BasesConnectionWithTotalCount {
+        edges {
+          node {
+            name
+          }
+        }
+      }
+    |}
+
+    def get_names(result, field_name)
+      bases = result["data"]["empire"][field_name]["edges"]
+      base_names = bases.map { |b| b["node"]["name"] }
+    end
+
+    it "applies the default value" do
+      result = query(query_string)
+      bases_by_id   = ["Death Star", "Shield Generator", "Headquarters"]
+      bases_by_name = ["Death Star", "Headquarters", "Shield Generator"]
+
+      assert_equal(bases_by_id, get_names(result, "bases"))
+      assert_equal(bases_by_name, get_names(result, "basesByName"))
+    end
+  end
+
+  describe "with a Sequel::Dataset" do
+    def get_names(result)
+      ships = result["data"]["empire"]["basesAsSequelDataset"]["edges"]
+      names = ships.map { |e| e["node"]["name"] }
+    end
+
+    def get_page_info(result)
+      result["data"]["empire"]["basesAsSequelDataset"]["pageInfo"]
+    end
+
+    def get_first_cursor(result)
+      result["data"]["empire"]["basesAsSequelDataset"]["edges"].first["cursor"]
+    end
+
+    def get_last_cursor(result)
+      result["data"]["empire"]["basesAsSequelDataset"]["edges"].last["cursor"]
+    end
+
+    describe "results" do
+      let(:query_string) {%|
+        query getShips($first: Int, $after: String, $last: Int, $before: String,  $nameIncludes: String){
+          empire {
+            basesAsSequelDataset(first: $first, after: $after, last: $last, before: $before, nameIncludes: $nameIncludes) {
+              ... basesConnection
+            }
+          }
+        }
+
+        fragment basesConnection on BasesConnectionWithTotalCount {
+          totalCount,
+          edges {
+            cursor
+            node {
+              name
+            }
+          },
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
+        }
+      |}
+
+      it 'limits the result' do
+        result = query(query_string, "first" => 2)
+        assert_equal(2, get_names(result).length)
+        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" => 3)
+        assert_equal(3, get_names(result).length)
+        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("Mw==", get_page_info(result)["endCursor"])
+        assert_equal("MQ==", get_first_cursor(result))
+        assert_equal("Mw==", get_last_cursor(result))
+      end
+
+      it 'provides custom fields on the connection type' do
+        result = query(query_string, "first" => 2)
+        assert_equal(
+          Base.where(faction_id: 2).count,
+          result["data"]["empire"]["basesAsSequelDataset"]["totalCount"]
+        )
+      end
+
+      it 'slices the result' do
+        result = query(query_string, "first" => 2)
+        assert_equal(["Death Star", "Shield Generator"], 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(["Headquarters"], get_names(result))
+
+        last_cursor = get_last_cursor(result)
+
+        result = query(query_string, "before" => last_cursor, "last" => 1)
+        assert_equal(["Shield Generator"], get_names(result))
+
+        result = query(query_string, "before" => last_cursor, "last" => 2)
+        assert_equal(["Death Star", "Shield Generator"], get_names(result))
+
+        result = query(query_string, "before" => last_cursor, "last" => 10)
+        assert_equal(["Death Star", "Shield Generator"], get_names(result))
+
+      end
+
+      it "applies custom arguments" do
+        result = query(query_string, "first" => 1, "nameIncludes" => "ea")
+        assert_equal(["Death Star"], get_names(result))
+
+        after = get_last_cursor(result)
+
+        result = query(query_string, "first" => 2, "nameIncludes" => "ea", "after" => after )
+        assert_equal(["Headquarters"], get_names(result))
+        before = get_last_cursor(result)
+
+        result = query(query_string, "last" => 1, "nameIncludes" => "ea", "before" => before)
+        assert_equal(["Death Star"], get_names(result))
+      end
+    end
+  end
+end

data/spec/graphql/schema/printer_spec.rb

@@ -66,6 +66,10 @@ describe GraphQL::Schema::Printer do
   describe ".print_introspection_schema" do
     it "returns the schema as a string for the introspection types" do
       expected = <<SCHEMA
+schema {
+  query: Query
+}
+
 type __Directive {
   name: String!
   description: String
@@ -147,6 +151,10 @@ SCHEMA
   describe ".print_schema" do
     it "returns the schema as a string for the defined types" do
       expected = <<SCHEMA
+schema {
+  query: Query
+}
+
 enum Choice {
   FOO
   BAR

data/spec/graphql/schema/reduce_types_spec.rb

@@ -21,7 +21,7 @@ describe GraphQL::Schema::ReduceTypes do
   end
 
   it "finds type from arguments" do
-    result = reduce_types([QueryType])
+    result = reduce_types([DairyAppQueryType])
     assert_equal(DairyProductInputType, result["DairyProductInput"])
   end
 

data/spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb

@@ -26,37 +26,43 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
 
     query_root_error = {
       "message"=>"Argument 'id' on Field 'cheese' has an invalid value",
-      "locations"=>[{"line"=>3, "column"=>7}]
+      "locations"=>[{"line"=>3, "column"=>7}],
+      "path"=>["query getCheese", "cheese", "id"],
     }
     assert_includes(errors, query_root_error)
 
     directive_error = {
       "message"=>"Argument 'if' on Directive 'skip' has an invalid value",
-      "locations"=>[{"line"=>4, "column"=>30}]
+      "locations"=>[{"line"=>4, "column"=>30}],
+      "path"=>["query getCheese", "cheese", "source", "if"],
     }
     assert_includes(errors, directive_error)
 
     input_object_error = {
       "message"=>"Argument 'product' on Field 'badSource' has an invalid value",
-      "locations"=>[{"line"=>6, "column"=>7}]
+      "locations"=>[{"line"=>6, "column"=>7}],
+      "path"=>["query getCheese", "badSource", "product"],
     }
     assert_includes(errors, input_object_error)
 
     input_object_field_error = {
       "message"=>"Argument 'source' on InputObject 'DairyProductInput' has an invalid value",
-      "locations"=>[{"line"=>6, "column"=>40}]
+      "locations"=>[{"line"=>6, "column"=>40}],
+      "path"=>["query getCheese", "badSource", "product", "source"],
     }
     assert_includes(errors, input_object_field_error)
 
     missing_required_field_error = {
       "message"=>"Argument 'product' on Field 'missingSource' has an invalid value",
-      "locations"=>[{"line"=>7, "column"=>7}]
+      "locations"=>[{"line"=>7, "column"=>7}],
+      "path"=>["query getCheese", "missingSource", "product"],
     }
     assert_includes(errors, missing_required_field_error)
 
     fragment_error = {
       "message"=>"Argument 'source' on Field 'similarCheese' has an invalid value",
-      "locations"=>[{"line"=>13, "column"=>7}]
+      "locations"=>[{"line"=>13, "column"=>7}],
+      "path"=>["fragment cheeseFields", "similarCheese", "source"],
     }
     assert_includes(errors, fragment_error)
   end

data/spec/graphql/static_validation/rules/arguments_are_defined_spec.rb

@@ -23,25 +23,29 @@ describe GraphQL::StaticValidation::ArgumentsAreDefined do
 
     query_root_error = {
       "message"=>"Field 'cheese' doesn't accept argument 'silly'",
-      "locations"=>[{"line"=>4, "column"=>7}]
+      "locations"=>[{"line"=>4, "column"=>7}],
+      "path"=>["query getCheese", "cheese", "silly"],
     }
     assert_includes(errors, query_root_error)
 
     input_obj_record = {
       "message"=>"InputObject 'DairyProductInput' doesn't accept argument 'wacky'",
-      "locations"=>[{"line"=>5, "column"=>29}]
+      "locations"=>[{"line"=>5, "column"=>29}],
+      "path"=>["query getCheese", "searchDairy", "product", "wacky"],
     }
     assert_includes(errors, input_obj_record)
 
     fragment_error = {
       "message"=>"Field 'similarCheese' doesn't accept argument 'nonsense'",
-      "locations"=>[{"line"=>9, "column"=>7}]
+      "locations"=>[{"line"=>9, "column"=>7}],
+      "path"=>["fragment cheeseFields", "similarCheese", "nonsense"],
     }
     assert_includes(errors, fragment_error)
 
     directive_error = {
       "message"=>"Directive 'skip' doesn't accept argument 'something'",
-      "locations"=>[{"line"=>10, "column"=>10}]
+      "locations"=>[{"line"=>10, "column"=>10}],
+      "path"=>["fragment cheeseFields", "id", "something"],
     }
     assert_includes(errors, directive_error)
   end