graphql 0.16.0 → 2.0.15

data/spec/graphql/float_type_spec.rb

@@ -1,15 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::FLOAT_TYPE do
-  describe "coerce_input" do
-    it "accepts ints and floats" do
-      assert_equal 1.0, GraphQL::FLOAT_TYPE.coerce_input(1)
-      assert_equal 6.1, GraphQL::FLOAT_TYPE.coerce_input(6.1)
-    end
-
-    it "rejects other types" do
-      assert_equal nil, GraphQL::FLOAT_TYPE.coerce_input("55")
-      assert_equal nil, GraphQL::FLOAT_TYPE.coerce_input(true)
-    end
-  end
-end

data/spec/graphql/id_type_spec.rb

@@ -1,32 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::ID_TYPE do
-  let(:result) { DummySchema.execute(query_string)}
-
-  describe "coercion for int inputs" do
-    let(:query_string) { %|query getMilk { cow: milk(id: 1) { id } }| }
-
-    it "coerces IDs from ints and serializes as strings" do
-      expected = {"data" => {"cow" => {"id" => "1"}}}
-      assert_equal(expected, result)
-    end
-  end
-
-  describe "coercion for string inputs" do
-    let(:query_string) { %|query getMilk { cow: milk(id: "1") { id } }| }
-
-    it "coerces IDs from strings and serializes as strings" do
-      expected = {"data" => {"cow" => {"id" => "1"}}}
-      assert_equal(expected, result)
-    end
-  end
-
-  describe "coercion for other types" do
-    let(:query_string) { %|query getMilk { cow: milk(id: 1.0) { id } }| }
-
-    it "doesn't allow other types" do
-      assert_equal nil, result["data"]
-      assert_equal 1, result["errors"].length
-    end
-  end
-end

data/spec/graphql/input_object_type_spec.rb

@@ -1,162 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::InputObjectType do
-  let(:input_object) { DairyProductInputType }
-  it "has a description" do
-    assert(input_object.description)
-  end
-
-  it "has input fields" do
-    assert(DairyProductInputType.input_fields["fatContent"])
-  end
-
-  describe "input validation" do
-    it "Accepts anything that yields key-value pairs to #all?" do
-      values_obj = MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4})
-      assert DairyProductInputType.valid_input?(values_obj)
-    end
-
-    describe "validate_input with non-enumerable input" do
-      it "returns a valid result for MinimumInputObject" do
-        result = DairyProductInputType.validate_input(MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4}))
-        assert(result.valid?)
-      end
-
-      it "returns an invalid result for MinimumInvalidInputObject" do
-        invalid_input = MinimumInputObject.new({"source" => "KOALA", "fatContent" => 0.4})
-        result = DairyProductInputType.validate_input(invalid_input)
-        assert(!result.valid?)
-      end
-    end
-
-    describe "validate_input with enumerable input" do
-      describe "with good input" do
-        let(:input) do
-          {
-            "source" => "COW",
-            "fatContent" => 0.4
-          }
-        end
-        let(:result) { DairyProductInputType.validate_input(input) }
-
-        it "returns a valid result" do
-          assert(result.valid?)
-        end
-      end
-
-      describe "with bad enum and float" do
-        let(:result) { DairyProductInputType.validate_input("source" => "KOALA", "fatContent" => "bad_num") }
-
-        it "returns an invalid result" do
-          assert(!result.valid?)
-        end
-
-        it "has problems with correct paths" do
-          paths = result.problems.map { |p| p["path"] }
-          assert(paths.include?(["source"]))
-          assert(paths.include?(["fatContent"]))
-        end
-
-        it "has correct problem explanation" do
-          expected = DairyAnimalEnum.validate_input("KOALA").problems[0]["explanation"]
-
-          source_problem = result.problems.detect { |p| p["path"] == ["source"] }
-          actual = source_problem["explanation"]
-
-          assert_equal(expected, actual)
-        end
-      end
-
-      describe "with extra argument" do
-        let(:result) { DairyProductInputType.validate_input("source" => "COW", "fatContent" => 0.4, "isDelicious" => false) }
-
-        it "returns an invalid result" do
-          assert(!result.valid?)
-        end
-
-        it "has problem with correct path" do
-          paths = result.problems.map { |p| p["path"] }
-          assert_equal(paths, [["isDelicious"]])
-        end
-
-        it "has correct problem explanation" do
-          assert(result.problems[0]["explanation"].include?("Field is not defined"))
-        end
-      end
-
-      describe "list with one invalid element" do
-        let(:list_type) { GraphQL::ListType.new(of_type: DairyProductInputType) }
-        let(:result) do
-          list_type.validate_input([
-            { "source" => "COW", "fatContent" => 0.4 },
-            { "source" => "KOALA", "fatContent" => 0.4 }
-          ])
-        end
-
-        it "returns an invalid result" do
-          assert(!result.valid?)
-        end
-
-        it "has one problem" do
-          assert_equal(result.problems.length, 1)
-        end
-
-        it "has problem with correct path" do
-          path = result.problems[0]["path"]
-          assert_equal(path, [1, "source"])
-        end
-
-        it "has problem with correct explanation" do
-          expected = DairyAnimalEnum.validate_input("KOALA").problems[0]["explanation"]
-          actual = result.problems[0]["explanation"]
-          assert_equal(expected, actual)
-        end
-      end
-    end
-  end
-
-  describe "when sent into a query" do
-    let(:variables) { {} }
-    let(:result) { DummySchema.execute(query_string, variables: variables) }
-
-    describe "list inputs" do
-      let(:variables) { {"search" => [MinimumInputObject.new({"source" => "COW", "fatContent" => 0.4})]} }
-      let(:query_string) {%|
-        query getCheeses($search: [DairyProductInput]!){
-            sheep: searchDairy(product: [{source: SHEEP, fatContent: 0.1}]) {
-              ... cheeseFields
-            }
-            cow: searchDairy(product: $search) {
-              ... cheeseFields
-            }
-        }
-
-        fragment cheeseFields on Cheese {
-          flavor
-        }
-      |}
-
-      it "converts items to plain values" do
-        sheep_value = result["data"]["sheep"]["flavor"]
-        cow_value = result["data"]["cow"]["flavor"]
-        assert_equal("Manchego", sheep_value)
-        assert_equal("Brie", cow_value)
-      end
-    end
-
-    describe "scalar inputs" do
-      let(:query_string) {%|
-        {
-          cheese(id: 1.4) {
-            flavor
-          }
-        }
-      |}
-
-      it "converts them to the correct type" do
-        cheese_name = result["data"]["cheese"]["flavor"]
-        assert_equal("Brie", cheese_name)
-      end
-    end
-  end
-end

data/spec/graphql/int_type_spec.rb

@@ -1,15 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::INT_TYPE do
-  describe "coerce_input" do
-    it "accepts ints and floats" do
-      assert_equal 1, GraphQL::INT_TYPE.coerce_input(1)
-      assert_equal 6, GraphQL::INT_TYPE.coerce_input(6.1)
-    end
-
-    it "rejects other types" do
-      assert_equal nil, GraphQL::INT_TYPE.coerce_input("55")
-      assert_equal nil, GraphQL::INT_TYPE.coerce_input(true)
-    end
-  end
-end

data/spec/graphql/interface_type_spec.rb

@@ -1,56 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::InterfaceType do
-  let(:interface) { EdibleInterface }
-  let(:dummy_query_context) { OpenStruct.new(schema: DummySchema) }
-
-  it "has possible types" do
-    assert_equal([CheeseType, HoneyType, MilkType], DummySchema.possible_types(interface))
-  end
-
-  it "resolves types for objects" do
-    assert_equal(CheeseType, interface.resolve_type(CHEESES.values.first, dummy_query_context))
-    assert_equal(MilkType, interface.resolve_type(MILKS.values.first, dummy_query_context))
-  end
-
-  describe "query evaluation" do
-    let(:result) { DummySchema.execute(query_string, variables: {"cheeseId" => 2})}
-    let(:query_string) {%|
-      query fav {
-        favoriteEdible { fatContent }
-      }
-    |}
-    it "gets fields from the type for the given object" do
-      expected = {"data"=>{"favoriteEdible"=>{"fatContent"=>0.04}}}
-      assert_equal(expected, result)
-    end
-  end
-
-  describe "mergable query evaluation" do
-    let(:result) { DummySchema.execute(query_string, variables: {"cheeseId" => 2})}
-    let(:query_string) {%|
-      query fav {
-        favoriteEdible { fatContent }
-        favoriteEdible { origin }
-      }
-    |}
-    it "gets fields from the type for the given object" do
-      expected = {"data"=>{"favoriteEdible"=>{"fatContent"=>0.04, "origin"=>"Antiquity"}}}
-      assert_equal(expected, result)
-    end
-  end
-
-  describe '#resolve_type' do
-    let(:interface) {
-      GraphQL::InterfaceType.define do
-        resolve_type -> (object, ctx) {
-          :custom_resolve
-        }
-      end
-    }
-
-    it "can be overriden in the definition" do
-      assert_equal(interface.resolve_type(123, nil), :custom_resolve)
-    end
-  end
-end

data/spec/graphql/internal_representation/rewrite_spec.rb

@@ -1,120 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::InternalRepresentation::Rewrite do
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:rewrite_result) {
-    validator.validate(query)[:irep]
-  }
-  describe "plain queries" do
-    let(:query_string) {%|
-    query getCheeses {
-      cheese1: cheese(id: 1) {
-        id1: id
-        id2: id
-        id3: id
-      }
-      cheese2: cheese(id: 2) {
-        id
-      }
-    }
-    |}
-    it "produces a tree of nodes" do
-      op_node = rewrite_result["getCheeses"]
-
-      assert_equal 2, op_node.children.length
-      assert_equal QueryType, op_node.return_type
-      first_field = op_node.children.values.first
-      assert_equal 3, first_field.children.length
-      assert_equal [QueryType], first_field.on_types.to_a
-      assert_equal CheeseType, first_field.return_type
-
-      second_field = op_node.children.values.last
-      assert_equal 1, second_field.children.length
-      assert_equal [QueryType], second_field.on_types.to_a
-      assert_equal CheeseType, second_field.return_type
-    end
-  end
-
-  describe "dynamic fields" do
-    let(:query_string) {%|
-      {
-        cheese(id: 1) {
-          typename: __typename
-        }
-      }
-    |}
-
-    it "gets dynamic field definitions" do
-      cheese_field = rewrite_result[nil].children["cheese"]
-      typename_field = cheese_field.children["typename"]
-      assert_equal "__typename", typename_field.definition.name
-    end
-  end
-
-  describe "merging fragments" do
-    let(:query_string) {%|
-    {
-      cheese(id: 1) {
-        id1: id
-        ... {
-          id2: id
-        }
-
-        fatContent
-        ... on Edible {
-          fatContent
-          origin
-        }
-        ... cheeseFields
-
-        ... similarCheeseField
-      }
-    }
-
-    fragment cheeseFields on Cheese {
-      fatContent
-      flavor
-      similarCow: similarCheese(source: COW) {
-        similarCowSource: source,
-        id
-        ... similarCowFields
-      }
-    }
-
-    fragment similarCowFields on Cheese {
-      similarCheese(source: SHEEP) {
-        source
-      }
-    }
-
-    fragment similarCheeseField on Cheese {
-      # deep fragment merge
-      similarCow: similarCheese(source: COW) {
-        similarCowSource: source,
-        fatContent
-        similarCheese(source: SHEEP) {
-          flavor
-        }
-      }
-    }
-    |}
-
-    it "puts all fragment members as children" do
-      op_node = rewrite_result[nil]
-
-      cheese_field = op_node.children["cheese"]
-      assert_equal ["id1", "id2", "fatContent", "origin", "similarCow", "flavor"], cheese_field.children.keys
-      # Merge:
-      similar_cow_field = cheese_field.children["similarCow"]
-      assert_equal ["similarCowSource", "fatContent", "similarCheese", "id"], similar_cow_field.children.keys
-      # Deep merge:
-      similar_sheep_field = similar_cow_field.children["similarCheese"]
-      assert_equal ["flavor", "source"], similar_sheep_field.children.keys
-
-      assert_equal Set.new([EdibleInterface]), cheese_field.children["origin"].on_types
-      assert_equal Set.new([CheeseType, EdibleInterface]), cheese_field.children["fatContent"].on_types
-      assert_equal Set.new([CheeseType]), cheese_field.children["flavor"].on_types
-    end
-  end
-end

data/spec/graphql/introspection/directive_type_spec.rb

@@ -1,50 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Introspection::DirectiveType do
-  let(:query_string) {%|
-    query getDirectives {
-      __schema {
-        directives {
-          name,
-          args { name, type { name, ofType { name } } },
-          locations
-          # Deprecated fields:
-          onField
-          onFragment
-          onOperation
-        }
-      }
-    }
-  |}
-  let(:result) { DummySchema.execute(query_string) }
-
-  it "shows directive info " do
-    expected = { "data" => {
-      "__schema" => {
-        "directives" => [
-          {
-            "name" => "skip",
-            "args" => [
-              {"name"=>"if", "type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"Boolean"}}}
-            ],
-            "locations"=>["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"],
-            "onField" => true,
-            "onFragment" => true,
-            "onOperation" => false,
-          },
-          {
-            "name" => "include",
-            "args" => [
-              {"name"=>"if", "type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"Boolean"}}}
-            ],
-            "locations"=>["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"],
-            "onField" => true,
-            "onFragment" => true,
-            "onOperation" => false,
-          },
-        ]
-      }
-    }}
-    assert_equal(expected, result)
-  end
-end

data/spec/graphql/introspection/input_value_type_spec.rb

@@ -1,42 +0,0 @@
-require "spec_helper"
-
-
-describe GraphQL::Introspection::InputValueType do
-  let(:query_string) {%|
-     {
-       __type(name: "DairyProductInput") {
-         name,
-         description,
-         kind,
-         inputFields {
-           name,
-           type { name },
-           defaultValue
-           description
-         }
-       }
-     }
-  |}
-  let(:result) { DummySchema.execute(query_string)}
-
-  it "exposes metadata about input objects, giving extra quotes for strings" do
-    expected = { "data" => {
-        "__type" => {
-          "name"=>"DairyProductInput",
-          "description"=>"Properties for finding a dairy product",
-          "kind"=>"INPUT_OBJECT",
-          "inputFields"=>[
-            {"name"=>"source", "type"=>{ "name" => "Non-Null"}, "defaultValue"=>nil,
-             "description" => "Where it came from"},
-            {"name"=>"originDairy", "type"=>{ "name" => "String"}, "defaultValue"=>"\"Sugar Hollow Dairy\"",
-             "description" => "Dairy which produced it"},
-            {"name"=>"fatContent", "type"=>{ "name" => "Float"}, "defaultValue"=>"0.3",
-             "description" => "How much fat it has"},
-            {"name"=>"organic", "type"=>{ "name" => "Boolean"}, "defaultValue"=>"false",
-             "description" => nil}
-          ]
-        }
-      }}
-    assert_equal(expected, result)
-  end
-end

data/spec/graphql/introspection/introspection_query_spec.rb

@@ -1,10 +0,0 @@
-require "spec_helper"
-
-describe "GraphQL::Introspection::INTROSPECTION_QUERY" do
-  let(:query_string) { GraphQL::Introspection::INTROSPECTION_QUERY }
-  let(:result) { DummySchema.execute(query_string) }
-
-  it "runs" do
-    assert(result["data"])
-  end
-end

data/spec/graphql/introspection/schema_type_spec.rb

@@ -1,45 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Introspection::SchemaType do
-  let(:query_string) {%|
-    query getSchema {
-      __schema {
-        types { name }
-        queryType { fields { name }}
-        mutationType { fields { name }}
-      }
-    }
-  |}
-  let(:result) { DummySchema.execute(query_string) }
-
-  it "exposes the schema" do
-    expected = { "data" => {
-      "__schema" => {
-        "types" => DummySchema.types.values.map { |t| t.name.nil? ? (p t; raise("no name for #{t}")) : {"name" => t.name} },
-        "queryType"=>{
-          "fields"=>[
-            {"name"=>"cheese"},
-            {"name"=>"cow"},
-            {"name"=>"dairy"},
-            {"name"=>"deepNonNull"},
-            {"name"=>"error"},
-            {"name"=>"executionError"},
-            {"name"=>"favoriteEdible"},
-            {"name"=>"fromSource"},
-            {"name"=>"maybeNull"},
-            {"name"=>"milk"},
-            {"name"=>"root"},
-            {"name"=>"searchDairy"},
-          ]
-        },
-        "mutationType"=> {
-          "fields"=>[
-            {"name"=>"pushValue"},
-            {"name"=>"replaceValues"},
-          ]
-        },
-      }
-    }}
-    assert_equal(expected, result)
-  end
-end

data/spec/graphql/introspection/type_type_spec.rb

@@ -1,122 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Introspection::TypeType do
-  let(:query_string) {%|
-     query introspectionQuery {
-       cheeseType:    __type(name: "Cheese") { name, kind, fields { name, isDeprecated, type { name, ofType { name } } } }
-       milkType:      __type(name: "Milk") { interfaces { name }, fields { type { name, ofType { name } } } }
-       dairyAnimal:   __type(name: "DairyAnimal") { name, kind, enumValues(includeDeprecated: false) { name, isDeprecated } }
-       dairyProduct:  __type(name: "DairyProduct") { name, kind, possibleTypes { name } }
-       animalProduct: __type(name: "AnimalProduct") { name, kind, possibleTypes { name }, fields { name } }
-     }
-  |}
-  let(:result) { DummySchema.execute(query_string, context: {}, variables: {"cheeseId" => 2}) }
-  let(:cheese_fields) {[
-    {"name"=>"deeplyNullableCheese", "isDeprecated"=>false, "type"=>{"name"=>"Cheese", "ofType"=>nil}},
-    {"name"=>"flavor",      "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "String"}}},
-    {"name"=>"id",          "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "Int"}}},
-    {"name"=>"nullableCheese", "isDeprecated"=>false, "type"=>{"name"=>"Cheese", "ofType"=>nil}},
-    {"name"=>"origin",      "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "String"}}},
-    {"name"=>"similarCheese", "isDeprecated"=>false, "type"=>{"name"=>"Cheese", "ofType"=>nil}},
-    {"name"=>"source",      "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "DairyAnimal"}}},
-  ]}
-
-  let(:dairy_animals) {[
-    {"name"=>"COW",   "isDeprecated"=> false },
-    {"name"=>"GOAT",  "isDeprecated"=> false },
-    {"name"=>"SHEEP", "isDeprecated"=> false },
-  ]}
-  it "exposes metadata about types" do
-    expected = {"data"=> {
-      "cheeseType" => {
-        "name"=> "Cheese",
-        "kind" => "OBJECT",
-        "fields"=> cheese_fields
-      },
-      "milkType"=>{
-        "interfaces"=>[
-          {"name"=>"Edible"},
-          {"name"=>"AnimalProduct"}
-        ],
-        "fields"=>[
-          {"type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"Float"}}},
-          {"type"=>{"name"=>"List", "ofType"=>{"name"=>"String"}}},
-          {"type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"ID"}}},
-          {"type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"String"}}},
-          {"type"=>{"name"=>"DairyAnimal", "ofType"=>nil}},
-        ]
-      },
-      "dairyAnimal"=>{
-        "name"=>"DairyAnimal",
-        "kind"=>"ENUM",
-        "enumValues"=> dairy_animals,
-      },
-      "dairyProduct"=>{
-        "name"=>"DairyProduct",
-        "kind"=>"UNION",
-        "possibleTypes"=>[{"name"=>"Milk"}, {"name"=>"Cheese"}],
-      },
-      "animalProduct" => {
-        "name"=>"AnimalProduct",
-        "kind"=>"INTERFACE",
-        "possibleTypes"=>[{"name"=>"Cheese"}, {"name"=>"Honey"}, {"name"=>"Milk"}],
-        "fields"=>[
-          {"name"=>"source"},
-        ]
-      }
-    }}
-    assert_equal(expected, result)
-  end
-
-  describe "deprecated fields" do
-    let(:query_string) {%|
-       query introspectionQuery {
-         cheeseType:    __type(name: "Cheese") { name, kind, fields(includeDeprecated: true) { name, isDeprecated, type { name, ofType { name } } } }
-         dairyAnimal:   __type(name: "DairyAnimal") { name, kind, enumValues(includeDeprecated: true) { name, isDeprecated } }
-       }
-    |}
-    let(:deprecated_fields) { {"name"=>"fatContent", "isDeprecated"=>true, "type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"Float"}}} }
-
-    it "can expose deprecated fields" do
-      new_cheese_fields = ([deprecated_fields] + cheese_fields).sort_by { |f| f["name"] }
-      expected = { "data" => {
-        "cheeseType" => {
-          "name"=> "Cheese",
-          "kind" => "OBJECT",
-          "fields"=> new_cheese_fields
-        },
-        "dairyAnimal"=>{
-          "name"=>"DairyAnimal",
-          "kind"=>"ENUM",
-          "enumValues"=> dairy_animals + [{"name" => "YAK", "isDeprecated" => true}],
-        },
-      }}
-      assert_equal(expected, result)
-    end
-
-    describe "input objects" do
-      let(:query_string) {%|
-         query introspectionQuery {
-           __type(name: "DairyProductInput") { name, description, kind, inputFields { name, type { name }, defaultValue } }
-         }
-      |}
-
-      it "exposes metadata about input objects" do
-        expected = { "data" => {
-            "__type" => {
-              "name"=>"DairyProductInput",
-              "description"=>"Properties for finding a dairy product",
-              "kind"=>"INPUT_OBJECT",
-              "inputFields"=>[
-                {"name"=>"source", "type"=>{ "name" => "Non-Null"}, "defaultValue"=>nil},
-                {"name"=>"originDairy", "type"=>{"name"=>"String"}, "defaultValue"=>"\"Sugar Hollow Dairy\""},
-                {"name"=>"fatContent", "type"=>{ "name" => "Float"}, "defaultValue"=>"0.3"},
-                {"name"=>"organic", "type"=>{ "name" => "Boolean"}, "defaultValue"=>"false"},
-              ]
-            }
-          }}
-        assert_equal(expected, result)
-      end
-    end
-  end
-end