graphql 0.0.4 → 0.1.0

data/spec/graph_ql/directive_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe GraphQL::Directive do
+  let(:result) { GraphQL::Query.new(DummySchema, query_string, params: {"t" => true, "f" => false}).result }
+  describe 'on fields' do
+    let(:query_string) { %|query directives($t: Boolean!, $f: Boolean!) {
+      cheese(id: 1) {
+        # plain fields:
+        skipFlavor: flavor @skip(if: true)
+        dontSkipFlavor: flavor @skip(if: false)
+        includeFlavor: flavor @include(if: $t)
+        dontIncludeFlavor: flavor @include(if: $f)
+        # fields in fragments
+        ... includeIdField
+        ... dontIncludeIdField
+        ... skipIdField
+        ... dontSkipIdField
+        }
+      }
+      fragment includeIdField on Cheese { includeId: id @include(if: true) }
+      fragment dontIncludeIdField on Cheese { dontIncludeId: id @include(if: false) }
+      fragment skipIdField on Cheese { skipId: id @skip(if: true) }
+      fragment dontSkipIdField on Cheese { dontSkipId: id @skip(if: false) }
+    |}
+    it 'intercepts fields' do
+      expected = { "data" => {"directives" => {
+        "cheese" => {
+          "dontSkipFlavor" => "Brie",
+          "includeFlavor" => "Brie",
+          "includeId" => 1,
+          "dontSkipId" => 1,
+        },
+      }}}
+      assert_equal(expected, result)
+    end
+  end
+  describe 'on fragments' do
+    let(:query_string) { %|query directives {
+      cheese(id: 1) {
+        ... skipFlavorField @skip(if: true)
+        ... dontSkipFlavorField @skip(if: false)
+        ... includeFlavorField @include(if: true)
+        ... dontIncludeFlavorField @include(if: false)
+
+        ... includeIdField
+        ... dontIncludeIdField
+        ... skipIdField
+        ... dontSkipIdField
+
+        ... on Cheese @skip(if: true) { skipInlineId: id }
+        ... on Cheese @skip(if: false) { dontSkipInlineId: id }
+        ... on Cheese @include(if: true) { includeInlineId: id }
+        ... on Cheese @include(if: false) { dontIncludeInlineId: id }
+        }
+      }
+      fragment includeFlavorField on Cheese { includeFlavor: flavor  }
+      fragment dontIncludeFlavorField on Cheese { dontIncludeFlavor: flavor  }
+      fragment skipFlavorField on Cheese { skipFlavor: flavor  }
+      fragment dontSkipFlavorField on Cheese { dontSkipFlavor: flavor }
+
+      fragment includeIdField on Cheese @include(if: true) { includeId: id  }
+      fragment dontIncludeIdField on Cheese @include(if: false) { dontIncludeId: id  }
+      fragment skipIdField on Cheese @skip(if: true) { skipId: id  }
+      fragment dontSkipIdField on Cheese @skip(if: false) { dontSkipId: id }
+    |}
+
+    it 'intercepts fragment spreads' do
+      expected = { "data" => {"directives" => {
+        "cheese" => {
+          "dontSkipFlavor" => "Brie",
+          "includeFlavor" => "Brie",
+          "includeId" => 1,
+          "dontSkipId" => 1,
+          "dontSkipInlineId" => 1,
+          "includeInlineId" => 1,
+        },
+      }}}
+      assert_equal(expected, result)
+    end
+  end
+end

data/spec/graph_ql/enum_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe GraphQL::Enum do
+  let(:enum) { DairyAnimalEnum }
+end

data/spec/graph_ql/fields/field_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe GraphQL::Field do
+  it 'accepts a proc as type' do
+    field = GraphQL::Field.new { |f|
+      f.type(-> { DairyProductUnion })
+    }
+    assert_equal(DairyProductUnion, field.type)
+  end
+end

data/spec/graph_ql/interface_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe GraphQL::Interface do
+  let(:interface) { Edible }
+  it 'has possible types' do
+    assert_equal([CheeseType, MilkType], interface.possible_types)
+  end
+
+  it 'resolves types for objects' do
+    assert_equal(CheeseType, interface.resolve_type(CHEESES.values.first))
+    assert_equal(MilkType, interface.resolve_type(MILKS.values.first))
+  end
+end

data/spec/graph_ql/introspection/directive_type_spec.rb

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

data/spec/graph_ql/introspection/schema_type_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe GraphQL::SchemaType do
+  let(:query_string) {%|
+    query getSchema {
+      __schema {
+        types { name }
+        queryType { fields { name }}
+        mutationType { fields { name }}
+      }
+    }
+  |}
+  let(:result) { GraphQL::Query.new(DummySchema, query_string).result }
+  it 'exposes the schema' do
+    expected = { "data" => { "getSchema" => {
+      "__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"=>"fromSource"},
+            {"name"=>"favoriteEdible"},
+            {"name"=>"searchDairy"},
+            {"name"=>"__typename"},
+            {"name"=>"__type"},
+            {"name"=>"__schema"},
+          ]
+        },
+        "mutationType"=> {
+          "fields"=>[
+            {"name"=>"pushValue"},
+            {"name"=>"__typename"}
+          ]
+        },
+      }
+    }}}
+    assert_equal(expected, result)
+  end
+end

data/spec/graph_ql/introspection/type_type_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe GraphQL::TypeType do
+  let(:query_string) {%|
+     query introspectionQuery {
+       cheeseType:    __type(name: "Cheese") { name, kind, fields { name, isDeprecated, 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(:query) { GraphQL::Query.new(DummySchema, query_string, context: {}, params: {"cheeseId" => 2})}
+  let(:cheese_fields) {[
+    {"name"=>"id",          "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "Int"}}},
+    {"name"=>"flavor",      "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "String"}}},
+    {"name"=>"source",      "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "DairyAnimal"}}},
+    {"name"=>"__typename",  "isDeprecated"=>false,    "type"=> { "name" => "Non-Null", "ofType" => { "name" => "String"}}},
+  ]}
+
+  let(:dairy_animals) {[
+    {"name"=>"COW",   "isDeprecated"=> false },
+    {"name"=>"GOAT",  "isDeprecated"=> false },
+    {"name"=>"SHEEP", "isDeprecated"=> false },
+  ]}
+  it 'exposes metadata about types' do
+    expected = {"data"=> { "introspectionQuery" => {
+      "cheeseType" => {
+        "name"=> "Cheese",
+        "kind" => "OBJECT",
+        "fields"=> cheese_fields
+      },
+      "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"=>"Milk"}],
+        "fields"=>[
+          {"name"=>"source"},
+          {"name"=>"__typename"},
+        ]
+      }
+    }}}
+    assert_equal(expected, query.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
+      typename = cheese_fields.pop
+      new_cheese_fields = cheese_fields + [deprecated_fields, typename]
+      expected = { "data" => { "introspectionQuery" => {
+        "cheeseType" => {
+          "name"=> "Cheese",
+          "kind" => "OBJECT",
+          "fields"=> new_cheese_fields
+        },
+        "dairyAnimal"=>{
+          "name"=>"DairyAnimal",
+          "kind"=>"ENUM",
+          "enumValues"=> dairy_animals + [{"name" => "YAK", "isDeprecated" => true}],
+        },
+      }}}
+      assert_equal(expected, query.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" => { "introspectionQuery" => {
+            "__type" => {
+              "name"=>"DairyProductInput",
+              "description"=>"Properties for finding a dairy product",
+              "kind"=>"INPUT_OBJECT",
+              "inputFields"=>[
+                {"name"=>"source", "type"=>{ "name" => "DairyAnimal"}, "defaultValue"=>nil},
+                {"name"=>"fatContent", "type"=>{ "name" => "Float"}, "defaultValue"=>nil}
+              ]
+            }
+          }}}
+        assert_equal(expected, query.result)
+      end
+    end
+  end
+end

data/spec/graph_ql/parser/parser_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe GraphQL::Parser do
+  let(:parser) { GraphQL::PARSER }
+
+  it 'parses documents' do
+    assert(parser.parse_with_debug(%|
+    # let's make a big query:
+    # a read-only:
+    query getStuff {id, name @skip(if: true)}
+    # a mutation:
+    mutation changeStuff($override: Boolean!, $cucumbers: [Vegetable]!) @veggie, @healthy(vitamins: true) {
+      # change the cucumber
+      changeStuff(thing: $cucumbers) {
+        id,
+        name,
+        ... on Species { color },
+        ... family # background info, of course
+      }
+    }
+
+    # a fragment:
+    fragment family on Species {
+      family {
+        name,                                       # name of the family
+        members(first: 3, query: {isPlant: true}) # some of the other examples
+      }
+    }
+
+    fragment nonsense on NonsenseType @skip(if: true) { bogus }
+    |), 'gets a document with lots of comments')
+
+    assert(parser.parse_with_debug("{fields, only, inThisOne}"), 'fetch-only query')
+  end
+
+
+  it 'parses operation definitions' do
+    assert(parser.operation_definition.parse_with_debug(%|{id, name, ...people}|), "just a selection")
+    assert(parser.operation_definition.parse_with_debug(%|query personStuff {id, name, ...people, ... stuff}|), "named fetch")
+    assert(parser.operation_definition.parse_with_debug(%|query personStuff @flagDirective {id, name, ...people}|), "with a directive")
+    assert(parser.operation_definition.parse_with_debug(%|mutation changeStuff($stuff: Int = 1, $things: [Boolean]!) {id, name, ...people}|), "mutation with arguments")
+  end
+
+  it 'parses fragment definitions' do
+    assert(parser.fragment_definition.parse_with_debug(%|fragment nutritionFacts on Food { fat, sodium, carbohydrates, vitamins { a, b } }|))
+    assert(parser.fragment_definition.parse_with_debug(%|fragment nutritionFacts on Food @directive(key: 1) { fat, sodium, carbohydrates, vitamins { a, b } }|), 'gets directives')
+  end
+
+  it 'parses selections' do
+    assert(parser.selections.parse_with_debug(%|{id, name, people { count }}|), 'gets nested fields')
+    assert(parser.selections.parse_with_debug(%|{id, ... myFragment }|), 'gets fragment spreads')
+    assert(parser.selections.parse_with_debug(%|{id, ... on User @myFlag { name, photo } }|), 'gets inline fragments')
+    assert(parser.selections.parse_with_debug(%|{id @skip(if: true), ... myFragment @include(if: $something)}|), 'gets directives')
+  end
+
+  it 'parses directives' do
+    assert(parser.directives.parse_with_debug("@doSomething"), 'gets without argument')
+    assert(parser.directives.parse_with_debug('@doSomething(why: "forSomeReason")'), 'gets with argument')
+    assert(parser.directives.parse_with_debug('@myFlag, @doSomething(why: "forSomeReason")'), 'gets multiple')
+  end
+
+  it 'parses fields' do
+    assert(parser.field.parse_with_debug(%|myField { name, id }|), 'gets subselections')
+    assert(parser.field.parse_with_debug(%{myAlias: myField}), 'gets an alias')
+    assert(parser.field.parse_with_debug(%{myField(intKey: 1, floatKey: 1.1e5)}), 'gets arguments')
+    assert(parser.field.parse_with_debug(%{myAlias: myField(stringKey: "my_string", boolKey: false, objKey: {key : true})}), 'gets alias and arguments')
+    assert(parser.field.parse_with_debug(%|myField @withFlag, @skip(if: true) { name, id }|), 'gets with directive')
+  end
+
+  it 'parses variable definitions' do
+    assert(parser.operation_variable_definition.parse_with_debug("$myVar: Boolean = true"), "it gets variables with defaults")
+    assert(parser.operation_variable_definition.parse_with_debug("$myVar: [Int]"), "it gets list variables")
+    assert(parser.operation_variable_definition.parse_with_debug("$myVar: Elephant!"), "it gets non-null variables")
+    assert(parser.operation_variable_definition.parse_with_debug("$myVar: [Food]!"), "it gets non-null list variables")
+    assert(parser.operation_variable_definitions.parse_with_debug(%|($myVar: Elephant!, $myList: [Float], $myString: String="Cheese")|), "it gets a list of defns")
+  end
+
+  describe 'value' do
+    it 'gets ints' do
+      assert(parser.value.parse_with_debug("100"), 'positive')
+      assert(parser.value.parse_with_debug("-9"), 'negative')
+      assert(parser.value.parse_with_debug("0"), 'zero')
+    end
+
+    it 'gets floats' do
+      assert(parser.value.parse_with_debug("1.14"), 'no exponent')
+      assert(parser.value.parse_with_debug("6.7e-9"), 'negative exponent')
+      assert(parser.value.parse_with_debug("0.4e12"), 'exponent')
+    end
+
+    it 'gets booleans' do
+      assert(parser.value.parse_with_debug("true"))
+      assert(parser.value.parse_with_debug("false"))
+    end
+
+    it 'gets strings' do
+      assert(parser.value.parse_with_debug('"my string"'))
+    end
+
+    it 'gets arrays' do
+      assert(parser.value.parse_with_debug('[true, 1, "my string", -5.123e56]'), 'array of values')
+      assert(parser.value.parse_with_debug('[]'), 'empty array')
+      assert(parser.value.parse_with_debug('[[true, 1], ["my string", -5.123e56]]'), 'array of arrays')
+    end
+
+    it 'gets variables' do
+      assert(parser.value.parse_with_debug('$myVariable'), 'gets named variables')
+    end
+
+    it 'gets objects' do
+      assert(parser.value.parse_with_debug('{name: "tomato", calories: 50}'), 'gets scalar values')
+      assert(parser.value.parse_with_debug('{listOfValues: [1, 2, [3]], nestedObject: {nestedKey: "nested{Value}"}}'), 'gets complex values')
+      assert(parser.value.parse_with_debug('{variableKey: $variableValue}'), 'gets variables')
+    end
+
+    it 'gets enums' do
+      assert(parser.value.parse_with_debug("MY_ENUM"), 'gets enums')
+    end
+  end
+end

data/spec/graph_ql/parser/transform_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe GraphQL::Transform do
+  def get_result(query_string, parse: nil, debug: false)
+    # send parse: :value to do something less than a document
+    parser = parse ? GraphQL::PARSER.send(parse) : GraphQL::PARSER
+    raw_tree = parser.parse_with_debug(query_string)
+    transformed_result = GraphQL::TRANSFORM.apply(raw_tree)
+    # send debug: true to see parsing & transforming output
+    if debug
+      p raw_tree.inspect
+      p transformed_result.inspect
+    end
+    transformed_result
+  end
+
+  it 'transforms documents' do
+    query = %|
+      # you can retrieve data:
+      query someInfo {
+        me {
+          name, favorite_food,
+          ...personInfo
+        }
+      }
+
+      # assign fragments:
+      fragment personInfo on Person {
+        birthdate, name # with fields
+      }
+
+      fragment petInfo on Pet { isHousebroken, species } # all on one line
+
+      # and also mutations
+      mutation changePetInfo($id: Int = 5, $info: [Dog]) {
+        changePetName(id: $id, info: $info) {
+          name,
+          ... petInfo,
+        }
+      }
+    |
+    res = get_result(query, debug: false)
+    assert_equal(4, res.parts.length)
+
+    res = get_result("{ me {id, birthdate} } # query shorthand")
+    assert_equal(1, res.parts.length)
+    assert_equal("me", res.parts.first.selections.first.name)
+  end
+
+  it 'transforms operation definitions' do
+    res = get_result("query someInfo { a, b, c }", parse: :operation_definition)
+    assert_equal("query", res.operation_type)
+    assert_equal("someInfo", res.name)
+    assert_equal(3, res.selections.length)
+
+    res = get_result("mutation changeThings($var: Float = 4.5, $arr: [Int]!) @flag, @skip(if: 1) { changeThings(var: $var) { a,b,c }}", parse: :operation_definition)
+    assert_equal("mutation", res.operation_type)
+    assert_equal("var", res.variables.first.name)
+    assert_equal("Float", res.variables.first.type.name)
+    assert_equal(4.5, res.variables.first.default_value)
+    assert_equal("arr", res.variables.last.name)
+    assert_equal("Int", res.variables.last.type.of_type.of_type.name)
+    assert_equal(2, res.directives.length)
+  end
+
+  it 'transforms fragment definitions' do
+    res = get_result("fragment someFields on SomeType @flag1, @flag2 { id, name }", parse: :fragment_definition)
+    assert_equal("someFields", res.name)
+    assert_equal("SomeType", res.type)
+    assert_equal(2, res.directives.length)
+    assert_equal(2, res.selections.length)
+  end
+
+  it 'transforms selections' do
+    res = get_result("{ id, ...petStuff @flag, ... on Pet { isHousebroken }, name }", parse: :selections)
+    expected_classes = [GraphQL::Nodes::Field, GraphQL::Nodes::FragmentSpread, GraphQL::Nodes::InlineFragment, GraphQL::Nodes::Field]
+    assert_equal(expected_classes, res.map(&:class))
+  end
+
+  it 'transforms fields' do
+    res = get_result(%|best_pals: friends(first: 3, coolnessLevel: SO_COOL, query: {nice: {very: true}})|, parse: :field)
+    assert_equal(GraphQL::Nodes::Field, res.class)
+    assert_equal("friends", res.name)
+    assert_equal("best_pals", res.alias)
+    assert_equal("first", res.arguments[0].name)
+    assert_equal(3, res.arguments[0].value)
+    assert_equal("SO_COOL", res.arguments[1].value.name)
+    assert_equal({"nice" => {"very" => true}}, res.arguments[2].value.to_h)
+
+    res = get_result(%|me @flag, @include(if: "something") {name, id}|, parse: :field)
+    assert_equal("me", res.name)
+    assert_equal(nil, res.alias)
+    assert_equal(2, res.directives.length)
+    assert_equal("flag", res.directives.first.name)
+    assert_equal("something", res.directives.last.arguments.first.value)
+    assert_equal(2, res.selections.length)
+  end
+
+  it 'transforms directives' do
+    res = get_result("@doSomething(vigorously: true)", parse: :directive)
+    assert_equal("doSomething", res.name, 'gets the name without @')
+    assert_equal("vigorously", res.arguments.first.name)
+    assert_equal(true, res.arguments.first.value)
+
+    res = get_result("@someFlag", parse: :directive)
+    assert_equal("someFlag", res.name)
+    assert_equal([], res.arguments, 'gets [] if no args')
+  end
+end