graphql 0.13.0 → 0.14.0

data/lib/graphql/schema/type_validator.rb

@@ -1,58 +0,0 @@
-module GraphQL
-  class Schema
-    class TypeValidator
-      def validate(type, errors)
-        own_errors = []
-        implementation = GraphQL::Schema::ImplementationValidator.new(type, as: "Type", errors: own_errors)
-        implementation.must_respond_to(:name)
-        implementation.must_respond_to(:kind)
-        if own_errors.any? # if no name or kind, abort!
-          errors.push(*own_errors)
-          return
-        end
-
-        type_name = type.name
-        kind_name = type.kind.name
-
-        implementation.must_respond_to(:description, as: kind_name)
-        each_item_validator = GraphQL::Schema::EachItemValidator.new(own_errors)
-
-        if type.kind.fields?
-          field_validator = GraphQL::Schema::FieldValidator.new
-          implementation.must_respond_to(:fields, as: kind_name) do |fields|
-            each_item_validator.validate(fields.keys, as: "#{type.name}.fields keys", must_be: "Strings") { |k| k.is_a?(String) }
-
-            fields.values.each do |field|
-              field_validator.validate(field, own_errors)
-            end
-          end
-        end
-
-        if type.kind.union?
-          implementation.must_respond_to(:resolve_type)
-          implementation.must_respond_to(:possible_types, as: kind_name) do |possible_types|
-            each_item_validator.validate(possible_types, as: "#{type_name}.possible_types", must_be: "objects") { |t| t.kind.object? }
-          end
-        end
-
-        if type.kind.object?
-          implementation.must_respond_to(:interfaces, as: kind_name) do |interfaces|
-            each_item_validator.validate(interfaces, as: "#{type_name}.interfaces", must_be: "interfaces") { |t| t.kind.interface? }
-          end
-        end
-
-        if type.kind.input_object?
-          implementation.must_respond_to(:input_fields, as: kind_name)
-        end
-
-        if type.kind.union?
-          union_types = type.possible_types
-          if union_types.none?
-            own_errors << "Union #{type_name} must be defined with 1 or more types, not 0!"
-          end
-        end
-        errors.push(*own_errors)
-      end
-    end
-  end
-end

data/spec/graphql/schema/field_validator_spec.rb

@@ -1,21 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Schema::FieldValidator do
-  let(:field_defn) {{
-    name: "Field",
-    description: "Invalid field",
-    deprecation_reason: nil,
-    arguments: {symbol_arg: nil},
-    type: DairyAnimalEnum,
-  }}
-  let(:field) {
-    f = OpenStruct.new(field_defn)
-    def f.to_s; f.name; end
-    f
-  }
-  let(:errors) { e = []; GraphQL::Schema::FieldValidator.new.validate(field, e); e }
-  it "requires argument names to be strings" do
-    expected = ["Field.arguments keys must be Strings, but some aren't: symbol_arg"]
-    assert_equal(expected, errors)
-  end
-end

data/spec/graphql/schema/type_validator_spec.rb

@@ -1,81 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Schema::TypeValidator do
-  let(:base_type_defn) {
-    {
-      name: "InvalidType",
-      description: "...",
-      deprecation_reason: nil,
-      kind: GraphQL::TypeKinds::OBJECT,
-      interfaces: [],
-      fields: {},
-    }
-  }
-  let(:object) {
-    o = OpenStruct.new(type_defn)
-    def o.to_s; "InvalidType"; end
-    o
-  }
-  let(:validator) { GraphQL::Schema::TypeValidator.new }
-  let(:errors) { e = []; validator.validate(object, e); e;}
-  describe "when name isnt defined" do
-    let(:type_defn) { base_type_defn.delete_if {|k,v| k == :name }}
-    it "requires name" do
-      assert_equal(
-        ["InvalidType must respond to #name() to be a Type"],
-        errors
-      )
-    end
-  end
-
-  describe "when a method returns nil" do
-    let(:type_defn) { base_type_defn.merge(interfaces: nil)}
-    it "requires name" do
-      assert_equal(
-        ["InvalidType must return a value for #interfaces() to be a OBJECT"],
-        errors
-      )
-    end
-  end
-
-  describe "when a field name isnt a string" do
-    let(:type_defn) { base_type_defn.merge(fields: {symbol_field: (GraphQL::Field.new {|f|}) }) }
-    it "requires string names" do
-      assert_equal(
-        ["InvalidType.fields keys must be Strings, but some aren't: symbol_field"],
-        errors
-      )
-    end
-  end
-
-  describe "when a Union isnt valid" do
-    let(:object) {
-      union_types = types
-      GraphQL::UnionType.define do
-        name "Something"
-        description "some union"
-        possible_types union_types
-      end
-    }
-    let(:errors) { e = []; GraphQL::Schema::TypeValidator.new.validate(object, e); e;}
-
-    describe "when non-object types" do
-      let(:types) { [DairyProductInputType] }
-      it "must be must be only object types" do
-        expected = [
-          "Something.possible_types must be objects, but some aren't: DairyProductInput"
-        ]
-        assert_equal(expected, errors)
-      end
-    end
-    describe "when no types" do
-      let(:types) { [] }
-      it "must have a type" do
-        expected = [
-          "Union Something must be defined with 1 or more types, not 0!"
-        ]
-        assert_equal(expected, errors)
-      end
-    end
-  end
-end