graphql 0.16.0 → 2.0.15

data/spec/graphql/language/generation_spec.rb

@@ -1,42 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Language::Generation do
-  let(:document) { GraphQL::Language::Parser.parse(query_string) }
-  let(:query_string) {%|
-    query getStuff($someVar: Int = 1, $anotherVar: [String!]) @skip(if: false) {
-      myField: someField(someArg: $someVar, ok: 1.4) @skip(if: $anotherVar) @thing(or: "Whatever")
-      anotherField(someArg: [1, 2, 3]) {
-        nestedField
-        ... moreNestedFields @skip(if: true)
-      }
-      ... on OtherType @include(unless: false) {
-        field(arg: [{key: "value", anotherKey: 0.9, anotherAnotherKey: WHATEVER}])
-        anotherField
-      }
-      ... {
-        id
-      }
-    }
-    fragment moreNestedFields on NestedType @or(something: "ok") {
-      anotherNestedField
-    }
-  |}
-
-  describe ".generate" do
-    it "generates query string" do
-      assert_equal query_string.gsub(/^    /, "").strip, document.to_query_string
-    end
-
-    describe "inputs" do
-      let(:query_string) {%|
-        query {
-          field(int: 3, float: 4.7e-24, bool: false, string: "☀︎🏆\\n escaped \\" unicode ¶ /", enum: ENUM_NAME, array: [7, 8, 9], object: {a: [1, 2, 3], b: {c: "4"}}, unicode_bom: "\xef\xbb\xbfquery")
-        }
-      |}
-
-      it "generate" do
-        assert_equal query_string.gsub(/^        /, "").strip, document.to_query_string
-      end
-    end
-  end
-end

data/spec/graphql/language/parser_spec.rb

@@ -1,442 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Language::Parser do
-  let(:document) { GraphQL::Language::Parser.parse(query_string) }
-  let(:query_string) {%|
-    query getStuff($someVar: Int = 1, $anotherVar: [String!] ) @skip(if: false) {
-      myField: someField(someArg: $someVar, ok: 1.4) @skip(if: $anotherVar) @thing(or: "Whatever")
-
-      anotherField(someArg: [1,2,3]) {
-        nestedField
-        ... moreNestedFields @skip(if: true)
-      }
-
-      ... on OtherType @include(unless: false){
-        field(arg: [{key: "value", anotherKey: 0.9, anotherAnotherKey: WHATEVER}])
-        anotherField
-      }
-
-      ... {
-        id
-      }
-    }
-
-    fragment moreNestedFields on NestedType @or(something: "ok") {
-      anotherNestedField
-    }
-  |}
-
-  describe ".parse" do
-    it "parses queries" do
-      assert document
-    end
-
-    describe "visited nodes" do
-      let(:query) { document.definitions.first }
-      let(:fragment_def) { document.definitions.last }
-
-      it "creates a valid document" do
-        assert document.is_a?(GraphQL::Language::Nodes::Document)
-        assert_equal 2, document.definitions.length
-      end
-
-      it "creates a valid operation" do
-        assert query.is_a?(GraphQL::Language::Nodes::OperationDefinition)
-        assert_equal "getStuff", query.name
-        assert_equal "query", query.operation_type
-        assert_equal 2, query.variables.length
-        assert_equal 4, query.selections.length
-        assert_equal 1, query.directives.length
-        assert_equal [2, 5], [query.line, query.col]
-      end
-
-      it "creates a valid fragment definition" do
-        assert fragment_def.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-        assert_equal "moreNestedFields", fragment_def.name
-        assert_equal 1, fragment_def.selections.length
-        assert_equal "NestedType", fragment_def.type
-        assert_equal 1, fragment_def.directives.length
-        assert_equal [20, 5], fragment_def.position
-      end
-
-      describe "variable definitions" do
-        let(:optional_var) { query.variables.first }
-        it "gets name and type" do
-          assert_equal "someVar", optional_var.name
-          assert_equal "Int", optional_var.type.name
-        end
-
-        it "gets default value" do
-          assert_equal 1, optional_var.default_value
-        end
-
-        it "gets position info" do
-          assert_equal [2, 20], optional_var.position
-        end
-      end
-
-      describe "fields" do
-        let(:leaf_field) { query.selections.first }
-        let(:parent_field) { query.selections[1] }
-
-        it "gets name, alias, arguments and directives" do
-          assert_equal "someField", leaf_field.name
-          assert_equal "myField", leaf_field.alias
-          assert_equal 2, leaf_field.directives.length
-          assert_equal 2, leaf_field.arguments.length
-        end
-
-        it "gets nested fields" do
-          assert_equal 2, parent_field.selections.length
-        end
-
-        it "gets location info" do
-          assert_equal [3 ,7], leaf_field.position
-        end
-
-        describe "when the arguments list is empty" do
-          let(:query_string) { "{ field() }"}
-          let(:field) { query.selections.first }
-          it "has zero arguments" do
-            assert_equal 0, field.arguments.length
-          end
-        end
-
-        describe "when selections are empty" do
-          let(:query_string) { "{ field { } }"}
-          let(:field) { query.selections.first }
-          it "has zero selections" do
-            assert_equal 0, field.selections.length
-          end
-        end
-      end
-
-      describe "arguments" do
-        let(:literal_argument) { query.selections.first.arguments.last }
-        let(:variable_argument) { query.selections.first.arguments.first }
-
-        it "gets name and literal value" do
-          assert_equal "ok", literal_argument.name
-          assert_equal 1.4, literal_argument.value
-        end
-
-        it "gets name and variable value" do
-          assert_equal "someArg", variable_argument.name
-          assert_equal "someVar", variable_argument.value.name
-        end
-
-
-        it "gets position info" do
-          assert_equal [3, 26], variable_argument.position
-        end
-      end
-
-      describe "fragment spreads" do
-        let(:fragment_spread) { query.selections[1].selections.last }
-        it "gets the name and directives" do
-          assert_equal "moreNestedFields", fragment_spread.name
-          assert_equal 1, fragment_spread.directives.length
-        end
-
-        it "gets position info" do
-          assert_equal [7, 9], fragment_spread.position
-        end
-      end
-
-      describe "directives" do
-        let(:variable_directive) { query.selections.first.directives.first }
-
-        it "gets the name and arguments" do
-          assert_equal "skip", variable_directive.name
-          assert_equal "if", variable_directive.arguments.first.name
-          assert_equal 1, variable_directive.arguments.length
-        end
-
-        it "gets position info" do
-          assert_equal [3, 54], variable_directive.position
-        end
-      end
-
-      describe "inline fragments" do
-        let(:inline_fragment) { query.selections[2] }
-        let(:typeless_inline_fragment) { query.selections[3] }
-
-        it "gets the type and directives" do
-          assert_equal "OtherType", inline_fragment.type
-          assert_equal 2, inline_fragment.selections.length
-          assert_equal 1, inline_fragment.directives.length
-        end
-
-        it "gets inline fragments without type conditions" do
-          assert_equal nil, typeless_inline_fragment.type
-          assert_equal 1, typeless_inline_fragment.selections.length
-          assert_equal 0, typeless_inline_fragment.directives.length
-        end
-
-        it "gets position info" do
-          assert_equal [10, 7], inline_fragment.position
-        end
-      end
-
-      describe "inputs" do
-        let(:query_string) {%|
-          {
-            field(
-              int: 3,
-              float: 4.7e-24,
-              bool: false,
-              string: "☀︎🏆\\n escaped \\" unicode \\u00b6 /",
-              enum: ENUM_NAME,
-              array: [7, 8, 9]
-              object: {a: [1,2,3], b: {c: "4"}}
-              unicode_bom: "\xef\xbb\xbfquery"
-            )
-          }
-        |}
-
-        let(:inputs) { document.definitions.first.selections.first.arguments }
-
-        it "parses ints" do
-          assert_equal 3, inputs[0].value
-        end
-
-        it "parses floats" do
-          assert_equal 0.47e-23, inputs[1].value
-        end
-
-        it "parses booleans" do
-          assert_equal false, inputs[2].value
-        end
-
-        it "parses UTF-8 strings" do
-          assert_equal %|☀︎🏆\n escaped " unicode ¶ /|, inputs[3].value
-        end
-
-        it "parses enums" do
-          assert_instance_of GraphQL::Language::Nodes::Enum, inputs[4].value
-          assert_equal "ENUM_NAME", inputs[4].value.name
-        end
-
-        it "parses arrays" do
-          assert_equal [7,8,9], inputs[5].value
-        end
-
-        it "parses objects" do
-          obj = inputs[6].value
-          assert_equal "a", obj.arguments[0].name
-          assert_equal [1,2,3], obj.arguments[0].value
-          assert_equal "b", obj.arguments[1].name
-          assert_equal "c", obj.arguments[1].value.arguments[0].name
-          assert_equal "4", obj.arguments[1].value.arguments[0].value
-        end
-
-        it "parses unicode bom" do
-          obj = inputs[7].value
-          assert_equal %|\xef\xbb\xbfquery|, inputs[7].value
-        end
-      end
-    end
-
-    describe "unnamed queries" do
-      let(:query_string) {%|
-        { name, age, height }
-      |}
-      let(:operation) { document.definitions.first }
-
-      it "parses unnamed queries" do
-        assert_equal 1, document.definitions.length
-        assert_equal "query", operation.operation_type
-        assert_equal nil, operation.name
-        assert_equal 3, operation.selections.length
-      end
-    end
-
-    describe "introspection query" do
-      let(:query_string) { GraphQL::Introspection::INTROSPECTION_QUERY }
-
-      it "parses a big ol' query" do
-        assert(document)
-      end
-    end
-  end
-
-  describe "errors" do
-    let(:query_string) {%| query doSomething { bogus { } |}
-    it "raises a parse error" do
-      err = assert_raises(GraphQL::ParseError) { document }
-    end
-
-    it "correctly identifies parse error location and content" do
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("
-          query getCoupons {
-            allCoupons: {data{id}}
-          }
-        ")
-      end
-      assert_includes(e.message, '"{"')
-      assert_includes(e.message, "RCURLY")
-      assert_equal(3, e.line)
-      assert_equal(25, e.col)
-    end
-
-    it "handles unexpected ends" do
-      err = assert_raises { GraphQL.parse("{ ") }
-      assert_equal "Unexpected end of document", err.message
-    end
-
-    it "rejects unsupported characters" do
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("{ field; }")
-      end
-
-      assert_includes(e.message, "Parse error on \";\"")
-    end
-
-    it "rejects control characters" do
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("{ \afield }")
-      end
-
-      assert_includes(e.message, "Parse error on \"\\a\"")
-    end
-
-    it "rejects partial BOM" do
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("{ \xeffield }")
-      end
-
-      assert_includes(e.message, "Parse error on \"\\xEF\"")
-    end
-
-    it "rejects vertical tabs" do
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("{ \vfield }")
-      end
-
-      assert_includes(e.message, "Parse error on \"\\v\"")
-    end
-
-    it "rejects form feed" do
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("{ \ffield }")
-      end
-
-      assert_includes(e.message, "Parse error on \"\\f\"")
-    end
-
-    it "rejects no break space" do
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("{ \xa0field }")
-      end
-
-      assert_includes(e.message, "Parse error on \"\\xA0\"")
-    end
-
-    it "rejects unterminated strings" do
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("\"")
-      end
-
-      assert_includes(e.message, "Parse error on \"\\\"\"")
-
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("\"\n\"")
-      end
-
-      assert_includes(e.message, "Parse error on \"\\n\"")
-    end
-
-    it "rejects bad escape sequence in strings" do
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("{ field(arg:\"\\x\") }")
-      end
-
-      assert_includes(e.message, "Parse error on bad Unicode escape sequence")
-    end
-
-    it "rejects incomplete escape sequence in strings" do
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("{ field(arg:\"\\u1\") }")
-      end
-
-      assert_includes(e.message, "bad Unicode escape sequence")
-    end
-
-    it "rejects unicode escape with bad chars" do
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("{ field(arg:\"\\u0XX1\") }")
-      end
-
-      assert_includes(e.message, "bad Unicode escape sequence")
-
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("{ field(arg:\"\\uXXXX\") }")
-      end
-
-      assert_includes(e.message, "bad Unicode escape sequence")
-
-
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("{ field(arg:\"\\uFXXX\") }")
-      end
-
-      assert_includes(e.message, "bad Unicode escape sequence")
-
-
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("{ field(arg:\"\\uXXXF\") }")
-      end
-
-      assert_includes(e.message, "bad Unicode escape sequence")
-    end
-
-    it "rejects fragments named 'on'" do
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("fragment on on on { on }")
-      end
-
-      assert_includes(e.message, "Parse error on \"on\"")
-    end
-
-    it "rejects fragment spread of 'on'" do
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("{ ...on }")
-      end
-
-      assert_includes(e.message, "Parse error on \"}\"")
-    end
-
-    it "rejects null value" do
-      e = assert_raises(GraphQL::ParseError) do
-        GraphQL.parse("{ fieldWithNullableStringInput(input: null) }")
-      end
-
-      assert_includes(e.message, "Parse error on \"null\"")
-    end
-  end
-
-
-  describe "whitespace" do
-    describe "whitespace-only queries" do
-      let(:query_string) { " " }
-      it "doesn't blow up" do
-        assert_equal [], document.definitions
-      end
-    end
-
-    describe "empty string queries" do
-      let(:query_string) { "" }
-      it "doesn't blow up" do
-        assert_equal [], document.definitions
-      end
-    end
-
-    describe "using tabs as whitespace" do
-      let(:query_string) { "\t{\t\tid, \tname}"}
-      it "parses the query" do
-        assert_equal 1, document.definitions.length
-      end
-    end
-  end
-end

data/spec/graphql/language/visitor_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Language::Visitor do
-  let(:document) { GraphQL.parse("
-    query cheese {
-      cheese(id: 1) {
-        flavor,
-        source,
-        producers(first: 3) {
-          name
-        }
-        ... cheeseFields
-      }
-    }
-
-    fragment cheeseFields on Cheese { flavor }
-    ")}
-  let(:counts) { {fields_entered: 0, arguments_entered: 0, arguments_left: 0, argument_names: []} }
-
-  let(:visitor) do
-    v = GraphQL::Language::Visitor.new(document)
-    v[GraphQL::Language::Nodes::Field] << -> (node, parent) { counts[:fields_entered] += 1 }
-    # two ways to set up enter hooks:
-    v[GraphQL::Language::Nodes::Argument] <<       -> (node, parent) { counts[:argument_names] << node.name }
-    v[GraphQL::Language::Nodes::Argument].enter << -> (node, parent) { counts[:arguments_entered] += 1}
-    v[GraphQL::Language::Nodes::Argument].leave << -> (node, parent) { counts[:arguments_left] += 1 }
-
-    v[GraphQL::Language::Nodes::Document].leave << -> (node, parent) { counts[:finished] = true }
-    v
-  end
-
-  it "calls hooks during a depth-first tree traversal" do
-    assert_equal(2, visitor[GraphQL::Language::Nodes::Argument].enter.length)
-    visitor.visit
-    assert_equal(6, counts[:fields_entered])
-    assert_equal(2, counts[:arguments_entered])
-    assert_equal(2, counts[:arguments_left])
-    assert_equal(["id", "first"], counts[:argument_names])
-    assert(counts[:finished])
-  end
-
-  describe "Visitor::SKIP" do
-    it "skips the rest of the node" do
-      visitor[GraphQL::Language::Nodes::Document] << -> (node, parent) { GraphQL::Language::Visitor::SKIP }
-      visitor.visit
-      assert_equal(0, counts[:fields_entered])
-    end
-  end
-end

data/spec/graphql/list_type_spec.rb

@@ -1,32 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::ListType do
-  let(:float_list) { GraphQL::ListType.new(of_type: GraphQL::FLOAT_TYPE) }
-
-  it "coerces elements in the list" do
-    assert_equal([1.0, 2.0, 3.0].inspect, float_list.coerce_input([1, 2, 3]).inspect)
-  end
-
-  describe "validate_input with bad input" do
-    let(:bad_num) { "bad_num" }
-    let(:result) { float_list.validate_input([bad_num, 2.0, 3.0]) }
-
-    it "returns an invalid result" do
-      assert(!result.valid?)
-    end
-
-    it "has one problem" do
-      assert_equal(result.problems.length, 1)
-    end
-
-    it "has path [0]" do
-      assert_equal(result.problems[0]["path"], [0])
-    end
-
-    it "has the correct explanation" do
-      expected = GraphQL::FLOAT_TYPE.validate_input(bad_num).problems[0]["explanation"]
-      actual = result.problems[0]["explanation"]
-      assert_equal(actual, expected)
-    end
-  end
-end

data/spec/graphql/non_null_type_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::NonNullType do
-  describe "when a non-null field returns null" do
-    it "nulls out the parent selection" do
-      query_string = %|{ cow { name cantBeNullButIs } }|
-      result = DummySchema.execute(query_string)
-      assert_equal({"cow" => nil }, result["data"])
-      assert_equal([{"message"=>"Cannot return null for non-nullable field cantBeNullButIs"}], result["errors"])
-    end
-
-    it "propagates the null up to the next nullable field" do
-      query_string = %|
-      {
-        nn1: deepNonNull {
-          nni1: nonNullInt(returning: 1)
-          nn2: deepNonNull {
-            nni2: nonNullInt(returning: 2)
-            nn3: deepNonNull {
-              nni3: nonNullInt
-            }
-          }
-        }
-      }
-      |
-      result = DummySchema.execute(query_string)
-      assert_equal(nil, result["data"])
-      assert_equal([{"message"=>"Cannot return null for non-nullable field nonNullInt"}], result["errors"])
-    end
-  end
-end

data/spec/graphql/object_type_spec.rb

@@ -1,42 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::ObjectType do
-  let(:type) { CheeseType }
-
-  it "has a name" do
-    assert_equal("Cheese", type.name)
-    type.name = "Fromage"
-    assert_equal("Fromage", type.name)
-    type.name = "Cheese"
-  end
-
-  it "has a description" do
-    assert_equal(22, type.description.length)
-  end
-
-  it "may have interfaces" do
-    assert_equal([EdibleInterface, AnimalProductInterface], type.interfaces)
-  end
-
-  describe '#get_field ' do
-    it "exposes fields" do
-      field = type.get_field("id")
-      assert_equal(GraphQL::TypeKinds::NON_NULL, field.type.kind)
-      assert_equal(GraphQL::TypeKinds::SCALAR, field.type.of_type.kind)
-    end
-
-    it "exposes defined field property" do
-      field_without_prop = CheeseType.get_field("flavor")
-      field_with_prop = CheeseType.get_field("fatContent")
-      assert_equal(field_without_prop.property, nil)
-      assert_equal(field_with_prop.property, :fat_content)
-    end
-
-    it "looks up from interfaces" do
-      field_from_self = CheeseType.get_field("fatContent")
-      field_from_iface = MilkType.get_field("fatContent")
-      assert_equal(field_from_self.property, :fat_content)
-      assert_equal(field_from_iface.property, nil)
-    end
-  end
-end

data/spec/graphql/query/arguments_spec.rb

@@ -1,25 +0,0 @@
-require "spec_helper"
-
-describe GraphQL::Query::Arguments do
-  let(:arguments) { GraphQL::Query::Arguments.new({ a: 1, b: 2, c: GraphQL::Query::Arguments.new({ d: 3, e: 4}) }) }
-
-  it "returns keys as strings" do
-    assert_equal(["a", "b", "c"], arguments.keys)
-  end
-
-  it "delegates values to values hash" do
-    assert_equal([1, 2, {"d" => 3, "e" => 4}], arguments.values)
-  end
-
-  it "delegates each to values hash" do
-    pairs = []
-    arguments.each do |key, value|
-      pairs << [key, value]
-    end
-    assert_equal([["a", 1], ["b", 2], ["c", {"d" => 3, "e" => 4}]], pairs)
-  end
-
-  it "returns original Ruby hash values with to_h" do
-    assert_equal({ a: 1, b: 2, c: { d: 3, e: 4 } }, arguments.to_h)
-  end
-end