graphql 0.0.4 → 0.1.0

data/spec/graph_ql/parser/visitor_spec.rb

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

data/spec/graph_ql/query/operation_resolver_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe GraphQL::Query::OperationResolver do
+  let(:operation) { GraphQL.parse("query getCheese($cheeseId: Int!) { cheese(id: $cheeseId) { name }}", as: :operation_definition) }
+  let(:params) { {"cheeseId" => 1}}
+  let(:query) { q = Minitest::Mock.new; q.expect(:params, params); q}
+  let(:resolver) { GraphQL::Query::OperationResolver.new(operation, query)}
+
+  describe "variables" do
+    it 'returns variables by name' do
+      assert_equal(1, resolver.variables["cheeseId"])
+    end
+  end
+end

data/spec/graph_ql/query_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe GraphQL::Query do
+  describe '#execute' do
+    let(:query_string) { %|
+      query getFlavor($cheeseId: Int!) {
+        brie: cheese(id: 1)   { ...cheeseFields, ... meatFields, taste: flavor },
+        cheese(id: $cheeseId)  {
+          __typename,
+          id,
+          ...cheeseFields,
+          ... edibleFields,
+          ... on Cheese { cheeseKind: flavor },
+          ... on Meat { cut }
+        }
+        fromSource(source: COW) { id }
+        firstSheep: searchDairy(product: {source: SHEEP}) { ... dairyFields }
+        favoriteEdible { __typename, fatContent }
+      }
+      fragment cheeseFields on Cheese { flavor }
+      fragment edibleFields on Edible { fatContent }
+      fragment meatFields on Meat { cut }
+      fragment dairyFields on DairyProduct {
+         ... on Cheese { flavor }
+         ... on Milk   { source }
+      }
+    |}
+    let(:query) { GraphQL::Query.new(DummySchema, query_string, context: {}, params: {"cheeseId" => 2})}
+    let(:result) { query.result }
+    it 'returns fields on objects' do
+      expected = {"data"=> { "getFlavor" => {
+          "brie" =>   { "flavor" => "Brie", "taste" => "Brie" },
+          "cheese" => {
+            "__typename" => "Cheese",
+            "id" => 2,
+            "fatContent" => 0.3,
+            "flavor" => "Gouda",
+            "cheeseKind" => "Gouda",
+          },
+          "fromSource" => [{ "id" => 1 }, {"id" => 2}],
+          "firstSheep" => { "flavor" => "Manchego" },
+          "favoriteEdible"=>{"__typename"=>"Edible", "fatContent"=>0.04},
+      }}}
+      assert_equal(expected, result)
+    end
+
+    it 'exposes fragments' do
+      assert_equal(GraphQL::Nodes::FragmentDefinition, query.fragments['cheeseFields'].class)
+    end
+
+    describe 'runtime errors' do
+      let(:query_string) {%| query noMilk { milk(id: 1000) { name } }|}
+      it 'turns into error messages' do
+        expected = {"errors"=>[
+          {"message"=>"Something went wrong during query execution: No field found on Query 'Query' for 'milk'"}
+        ]}
+        assert_equal(expected, result)
+      end
+    end
+
+
+    describe 'execution order' do
+      let(:query_string) {%|
+        mutation setInOrder {
+          first:  pushValue(value: 1)
+          second: pushValue(value: 5)
+          third:  pushValue(value: 2)
+        }
+      |}
+      it 'executes mutations in order' do
+        expected = {"data"=>{
+          "setInOrder"=>{
+            "first"=> [1],
+            "second"=>[1, 5],
+            "third"=> [1, 5, 2],
+          }
+        }}
+        assert_equal(expected, result)
+      end
+    end
+  end
+end

data/spec/graph_ql/schema/type_reducer_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe GraphQL::Schema::TypeReducer do
+  it 'finds types from a single type and its fields' do
+    reducer = GraphQL::Schema::TypeReducer.new(CheeseType, {})
+    expected = {
+      "Cheese" => CheeseType,
+      "Int" => GraphQL::INT_TYPE,
+      "String" => GraphQL::STRING_TYPE,
+      "DairyAnimal" => DairyAnimalEnum,
+      "Float" => GraphQL::FLOAT_TYPE,
+      "Edible" => Edible,
+      "Milk" => MilkType,
+      "AnimalProduct" => AnimalProduct,
+    }
+    assert_equal(expected.keys, reducer.result.keys)
+    assert_equal(expected, reducer.result)
+  end
+
+  it 'finds type from arguments' do
+    reducer = GraphQL::Schema::TypeReducer.new(QueryType, {})
+    assert_equal(DairyProductInputType, reducer.result["DairyProductInput"])
+  end
+end

data/spec/graph_ql/types/input_object_type_spec.rb

@@ -0,0 +1,12 @@
+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
+end

data/spec/graph_ql/types/object_type_spec.rb

@@ -0,0 +1,35 @@
+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([Edible, AnimalProduct], type.interfaces)
+  end
+
+  it 'becomes non-null with !' do
+    non_null_type = !type
+    assert_equal(GraphQL::TypeKinds::NON_NULL, non_null_type.kind)
+    assert_equal(type, non_null_type.of_type)
+    assert_equal(GraphQL::TypeKinds::NON_NULL, (!GraphQL::STRING_TYPE).kind)
+  end
+
+  describe '.fields ' do
+    it 'exposes fields' do
+      field = type.fields["id"]
+      assert_equal(GraphQL::TypeKinds::NON_NULL, field.type.kind)
+      assert_equal(GraphQL::TypeKinds::SCALAR, field.type.of_type.kind)
+    end
+  end
+end

data/spec/graph_ql/union_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe GraphQL::Union do
+  let(:type_1) { OpenStruct.new(kind: GraphQL::TypeKinds::OBJECT)}
+  let(:type_2) { OpenStruct.new(kind: GraphQL::TypeKinds::OBJECT)}
+  let(:union) { GraphQL::Union.new("MyUnion", [type_1, type_2]) }
+  it 'has a name' do
+    assert_equal("MyUnion", union.name)
+  end
+
+  it 'identifies members' do
+    assert(union.include?(type_1))
+    assert(!union.include?(:type_3))
+  end
+
+  it 'must be 2+ types' do
+    assert_raises(ArgumentError) { GraphQL::Union.new("Something", [type_1])}
+  end
+
+  it 'must be all object types' do
+    assert_raises(ArgumentError) { GraphQL::Union.new("Something", [type_1, type_2, union])}
+  end
+
+  it 'infers type from an object' do
+    assert_equal(CheeseType, DairyProductUnion.resolve_type(CHEESES[1]))
+  end
+end

data/spec/graph_ql/validations/fields_are_defined_on_type_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe GraphQL::Validations::FieldsAreDefinedOnType do
+  let(:document) { GraphQL.parse("
+    query getCheese($sourceVar: DairyAnimal!) {
+      notDefinedField { name }
+      cheese(id: 1) { nonsenseField, flavor }
+      fromSource(source: COW) { bogusField }
+    }
+
+    fragment cheeseFields on Cheese { fatContent, hogwashField }
+  ")}
+
+  let(:validator) { GraphQL::Validator.new(schema: DummySchema, validators: [GraphQL::Validations::FieldsAreDefinedOnType]) }
+  let(:errors) { validator.validate(document) }
+  it "finds fields that are requested on types that don't have that field" do
+    expected_errors = [
+      "Field 'notDefinedField' doesn't exist on type 'Query'",  # from query root
+      "Field 'nonsenseField' doesn't exist on type 'Cheese'",   # from another field
+      "Field 'bogusField' doesn't exist on type 'Cheese'",      # from a list
+      "Field 'hogwashField' doesn't exist on type 'Cheese'",    # from a fragment
+    ]
+    assert_equal(expected_errors, errors)
+  end
+
+  it 'finds invalid fields on interfaces'
+  it 'finds invalid fields on unions'
+end

data/spec/graph_ql/validations/fields_will_merge_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe GraphQL::Validations::FieldsWillMerge do
+  let(:document) { GraphQL.parse("
+    query getCheese($sourceVar: DairyAnimal!) {
+      id
+      nickname: name,
+      nickname: fatContent,
+      fatContent
+
+      similarCheeses(source: $sourceVar)
+
+      origin { originName: id },
+      ...cheeseFields
+      ... on Cheese {
+        fatContent: name
+        similarCheeses(source: SHEEP)
+      }
+    }
+    fragment cheeseFields on Cheese {
+      fatContent,
+      origin { originName: name }
+      id @someFlag
+    }
+  ")}
+
+  let(:validator) { GraphQL::Validator.new(schema: nil, validators: [GraphQL::Validations::FieldsWillMerge]) }
+  let(:errors) { validator.validate(document) }
+  it 'finds field naming conflicts' do
+    expected_errors = [
+      "Field 'nickname' has a field conflict: name or fatContent?",             # alias conflict in query
+      "Field 'originName' has a field conflict: id or name?",                   # nested conflict
+      "Field 'id' has a directive conflict: [] or [someFlag]?",                 # different directives
+      "Field 'id' has a directive argument conflict: [] or [{}]?",              # not sure this is a great way to handle it but here we are!
+      "Field 'fatContent' has a field conflict: fatContent or name?",           # alias/name conflict in query and fragment
+      "Field 'similarCheeses' has an argument conflict: {\"source\":\"sourceVar\"} or {\"source\":\"SHEEP\"}?", # different arguments
+    ]
+    assert_equal(expected_errors, errors)
+  end
+end

data/spec/graph_ql/validations/fragments_are_used_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe GraphQL::Validations::FragmentsAreUsed do
+  let(:document) { GraphQL.parse("
+    query getCheese {
+      name,
+      ...cheeseFields,
+      origin {
+        ...originFields
+        ...undefinedFields
+      }
+    }
+    fragment cheeseFields on Cheese { fatContent }
+    fragment originFields on Country { name, continent { ...continentFields }}
+    fragment continentFields on Continent { name }
+    fragment unusedFields on Cheese { is, not, used }
+  ")}
+
+  let(:validator) { GraphQL::Validator.new(schema: nil, validators: [GraphQL::Validations::FragmentsAreUsed]) }
+  let(:errors) { validator.validate(document) }
+
+  it 'adds errors for unused fragment definitions' do
+    assert_includes(errors, 'Some fragments were defined but not used: unusedFields')
+  end
+  it 'adds errors for undefined fragment spreads' do
+    assert_includes(errors, 'Some fragments were used but not defined: undefinedFields')
+  end
+end

data/spec/graph_ql/validator_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+class SchemaErrorValidator
+  def validate(context)
+    context.errors << "Something is wrong: #{context.schema}"
+  end
+end
+
+class DocumentErrorValidator
+  def validate(context)
+    context.errors << "Something is wrong: #{context.document.name}"
+  end
+end
+
+describe GraphQL::Validator do
+  let(:document)  { OpenStruct.new(name: "This is not a document", children: []) }
+  let(:validator) { GraphQL::Validator.new(schema: "This is not a schema", validators: [SchemaErrorValidator, DocumentErrorValidator]) }
+
+  it 'uses validators' do
+    errors = validator.validate(document)
+    expected_errors = ["Something is wrong: This is not a schema", "Something is wrong: This is not a document"]
+    assert_equal(expected_errors, errors)
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 require "codeclimate-test-reporter"
 CodeClimate::TestReporter.start
-
+require 'graphql'
 require 'date'
 require "minitest/autorun"
 require "minitest/focus"
@@ -16,4 +16,4 @@ Minitest.backtrace_filter = Minitest::BacktraceFilter.new
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 require 'parslet'
-require 'parslet/convenience'
+require 'parslet/convenience'

data/spec/support/dummy_app.rb

@@ -1,81 +1,141 @@
-class InadequateRecordBase
-  def initialize(attributes={})
-    attributes.each do |key, value|
-      self.send("#{key}=", value)
-    end
-  end
+require_relative './dummy_data'
 
-  def destroy
-    self.class.all.delete(self)
-  end
+Edible = GraphQL::Interface.new do
+  name "Edible"
+  description "Something you can eat, yum"
+  fields({
+    fatContent: field(type: !type.Float, desc: "Percentage which is fat"),
+  })
+end
 
-  class << self
-    attr_accessor :_objects
-    def all
-      @_objects ||= []
-    end
-
-    def find(id)
-      all.find { |object| object.id.to_s == id.to_s }
-    end
-
-    def where(query={})
-      result = []
-      all.each do |object|
-        match = true
-
-        query.each do |key, value|
-          if object.send(key) != value
-            match = false
-          end
-        end
+AnimalProduct = GraphQL::Interface.new do
+  name "AnimalProduct"
+  description "Comes from an animal, no joke"
+  fields({
+    source: field(type: !type.String, desc: "Animal which produced this product"),
+  })
+end
 
-        result << object if match
-      end
-      result
-    end
-
-    def create(attributes)
-      @next_id ||= 0
-      attributes[:id] ||= @next_id += 1
-      instance = self.new(attributes)
-      all << instance
-      instance
-    end
-  end
+DairyAnimalEnum = GraphQL::Enum.new do |e|
+  e.name "DairyAnimal"
+  e.description "An animal which can yield milk"
+  e.value("COW",    "Animal with black and white spots")
+  e.value("GOAT",   "Animal with horns")
+  e.value("SHEEP",  "Animal with wool")
+  e.value("YAK",    "Animal with long hair", deprecation_reason: "Out of fashion")
+end
+
+CheeseType = GraphQL::ObjectType.new do
+  name "Cheese"
+  description "Cultured dairy product"
+  interfaces [Edible, AnimalProduct]
+  self.fields = {
+    id:           field(type: !type.Int, desc: "Unique identifier"),
+    flavor:       field(type: !type.String, desc: "Kind of cheese"),
+    source:       field(type: !DairyAnimalEnum, desc: "Animal which produced the milk for this cheese"),
+    fatContent:   field(type: !type.Float, desc: "Percentage which is milkfat", deprecation_reason: "Diet fashion has changed"),
+  }
+end
+
+MilkType = GraphQL::ObjectType.new do
+  name 'Milk'
+  description "Dairy beverage"
+  interfaces [Edible, AnimalProduct]
+  self.fields = {
+    id:           field(type: !type.Int, desc: "Unique identifier"),
+    source:       field(type: DairyAnimalEnum, desc: "Animal which produced this milk"),
+    fatContent:   field(type: !type.Float, desc: "Percentage which is milkfat"),
+    flavors:      field(
+          type: type[type.String],
+          desc: "Chocolate, Strawberry, etc",
+          args: {limit: {type: type.Int}}
+        ),
+  }
 end
 
-class Post < InadequateRecordBase
-  attr_accessor :id, :title, :content, :published_at
+DairyProductUnion = GraphQL::Union.new("DairyProduct", [MilkType, CheeseType])
 
-  def comments
-    Comment.where(post_id: id)
+DairyProductInputType = GraphQL::InputObjectType.new {
+  name "DairyProductInput"
+  description "Properties for finding a dairy product"
+  input_fields({
+    source:     arg({type: DairyAnimalEnum}),
+    fatContent: arg({type: type.Float}),
+  })
+}
+
+
+class FetchField < GraphQL::AbstractField
+  attr_reader :type
+  attr_accessor :name
+  def initialize(type:, data:)
+    @type = type
+    @data = data
   end
 
-  def likes
-    Like.where(post_id: id)
+  def description
+    "Find a #{@type.name} by id"
+  end
+
+  def resolve(target, arguments, context)
+    @data[arguments["id"]]
   end
 end
 
-class Comment < InadequateRecordBase
-  attr_accessor :id, :post_id, :content, :rating
+SourceField = GraphQL::Field.new do |f|
+  f.type GraphQL::ListType.new(of_type: CheeseType)
+  f.description "Cheese from source"
+  f.resolve -> (target, arguments, context) {
+    CHEESES.values.select{ |c| c.source == arguments["source"] }
+  }
+end
 
-  def post
-    Post.find(post_id)
-  end
+FavoriteField = GraphQL::Field.new do |f|
+  f.description "My favorite food"
+  f.type Edible
+  f.resolve -> (t, a, c) { MILKS[1] }
 end
 
-class Like < InadequateRecordBase
-  attr_accessor :id, :post_id
 
-  def post
-    Post.find(post_id)
-  end
+QueryType = GraphQL::ObjectType.new do
+  name "Query"
+  description "Query root of the system"
+  fields({
+    cheese: FetchField.new(type: CheeseType, data: CHEESES),
+    fromSource: SourceField,
+    favoriteEdible: FavoriteField,
+    searchDairy: GraphQL::Field.new { |f|
+      f.name "searchDairy"
+      f.description "Find dairy products matching a description"
+      f.type DairyProductUnion
+      f.arguments({product: {type: DairyProductInputType}})
+      f.resolve -> (t, a, c) {
+        products = CHEESES.values + MILKS.values
+        source =  a["product"]["source"]
+        if !source.nil?
+          products = products.select { |p| p.source == source }
+        end
+        products.first
+      }
+    }
+  })
 end
 
-class Context
-  attr_reader :person_name
-  def initialize(person_name:)
-    @person_name = person_name
-  end
+GLOBAL_VALUES = []
+
+MutationType = GraphQL::ObjectType.new do
+  name "Mutation"
+  description "The root for mutations in this schema"
+  fields({
+    pushValue: GraphQL::Field.new { |f|
+      f.description("Push a value onto a global array :D")
+      f.type(!type[!type.Int])
+      f.arguments(value: arg(type: !type.Int))
+      f.resolve -> (o, args, ctx) {
+        GLOBAL_VALUES << args["value"]
+        GLOBAL_VALUES
+      }
+    }
+  })
 end
+DummySchema = GraphQL::Schema.new(query: QueryType, mutation: MutationType)