graphql 0.0.1 → 0.0.2

data/spec/graphql/root_call_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe GraphQL::RootCall do
+  let(:query_string) { %{
+    upvote_post(<post_data>, <person_id>) {
+      post {
+        likes { count, any }
+      }
+      upvote {
+        post_id
+      }
+    }
+    <post_data>: { "id" : #{@post_id} }
+    <person_id>: 888
+  }}
+  let(:result) { GraphQL::Query.new(query_string).as_result }
+
+  before do
+    # make sure tests don't conflict :(
+    @post_id = "#{Time.now.to_i}#{[1,2,3].sample}".to_i
+    @post = Post.create(id: @post_id, content: "My great post")
+    @like = Like.create(post_id: @post_id)
+  end
+
+  after do
+    @post.likes.map(&:destroy)
+    @post.destroy
+  end
+
+  describe '#as_result' do
+    it 'operates on the application' do
+      assert_equal 1, @post.likes.count
+      result
+      assert_equal 2, @post.likes.count
+    end
+
+    it 'returns fields for the node' do
+      assert_equal @post_id, result["upvote"]["post_id"]
+      assert_equal 2, result["post"]["likes"]["count"]
+      assert_equal true, result["post"]["likes"]["any"]
+    end
+
+    describe 'when the input is the wrong type' do
+      let(:query_string) { %{upvote_post(bogus_arg, 888) { post { id } } } }
+      it 'validates the input' do
+        assert_raises(GraphQL::RootCallArgumentError) { result }
+      end
+    end
+  end
+
+  describe '#__type__' do
+    it 'describes the input'
+    it 'describes the response'
+  end
+end

data/spec/graphql/schema_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe GraphQL::Schema do
+  let(:schema) { GraphQL::SCHEMA }
+  describe 'global instance' do
+    it 'exists as GraphQL::SCHEMA' do
+      assert GraphQL::SCHEMA.is_a?(GraphQL::Schema)
+    end
+  end
+
+  describe '#get_call' do
+    it 'finds calls from their class name' do
+      assert_equal Nodes::ContextCall, schema.get_call("context")
+    end
+
+    it 'finds calls from declared names' do
+      assert_equal Nodes::LikePostCall, schema.get_call("upvote_post")
+    end
+  end
+
+  describe '#get_type' do
+    it 'finds nodes from their class name' do
+      assert_equal Nodes::PostNode, schema.get_type("post")
+    end
+
+    it 'finds nodes from declared names' do
+      assert_equal Nodes::ThumbUpNode, schema.get_type("upvote")
+    end
+  end
+
+  describe 'querying schema' do
+  let(:query_string) { "schema() {
+    calls {
+      count,
+      edges {
+        node {
+          name,
+          returns,
+          arguments {
+            edges {
+              node {
+                name, type
+              }
+            }
+          }
+        }
+      }
+    },
+    types {
+      count,
+      edges {
+        node {
+          name,
+          fields {
+            count,
+            edges {
+              node {
+                name,
+                type,
+                calls {
+                  count,
+                  edges {
+                    node {
+                      name,
+                      arguments
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }"}
+  let(:query) { GraphQL::Query.new(query_string) }
+  let(:result) { query.as_result }
+
+    describe 'querying calls' do
+      let(:upvote_post_call) { result["schema"]["calls"]["edges"].find {|e| e["node"]["name"] == "upvote_post"} }
+
+      it 'returns all calls' do
+        assert_equal 7, result["schema"]["calls"]["count"]
+      end
+
+      it 'doesnt show abstract call classes' do
+        call_names = result["schema"]["calls"]["edges"].map {|e| e["node"]["name"] }
+        assert(!call_names.include?("find"))
+      end
+
+      it 'shows return types' do
+        assert_equal ["post", "upvote"], upvote_post_call["node"]["returns"]
+      end
+
+      it 'shows argument types' do
+        expected_arguments = [{"node"=>{"name"=>"post_data", "type"=>"object"}}, {"node"=>{"name"=>"person_id", "type"=>"number"}}]
+        assert_equal expected_arguments, upvote_post_call["node"]["arguments"]["edges"]
+      end
+    end
+
+    describe 'querying types' do
+      let(:post_type) { result["schema"]["types"]["edges"].find { |e| e["node"]["name"] == "post" }["node"]}
+      let(:content_field) { post_type["fields"]["edges"].find { |e| e["node"]["name"] == "content" }["node"]}
+      let(:select_call) { content_field["calls"]["edges"].find { |e| e["node"]["name"] == "select"}["node"]}
+
+      it 'returns all types' do
+        assert_equal 13, result["schema"]["types"]["count"]
+      end
+
+      it 'doesnt return types that dont expose anything' do
+        type_names = result["schema"]["types"]["edges"].map {|e| e["node"]["name"] }
+        assert(!type_names.include?("application"))
+      end
+
+      it 'show type name & fields' do
+        assert_equal "post", post_type["name"]
+        assert_equal 8, post_type["fields"]["count"]
+      end
+
+      it 'shows field type & calls' do
+        assert_equal "string", content_field["type"]
+        assert_equal 3, content_field["calls"]["count"]
+        assert_equal "select", select_call["name"]
+        assert_equal "from_chars (req), for_chars (req)", select_call["arguments"]
+      end
+    end
+  end
+end

data/spec/graphql/transform_spec.rb

@@ -5,54 +5,139 @@ describe GraphQL::Transform do
   let(:parser) { GraphQL::PARSER }
 
   describe '#apply' do
-    it 'turns a simple node into a Node' do
-      tree = parser.parse("post(123) { name }")
-      res = transform.apply(tree)
-      assert(res.is_a?(GraphQL::Syntax::Node), 'it gets a node')
-    end
+    describe 'query' do
+      it 'parses node and variables' do
+        tree = parser.query.parse(%{
+          like_page(<page_info>) { page { id, likes } }
 
-    it 'turns a node into a Node' do
-      tree = parser.parse("viewer() { name, friends.first(10) { birthdate } }")
-      res = transform.apply(tree)
-      assert(res.is_a?(GraphQL::Syntax::Node), 'it gets a node')
-      assert(res.identifier == "viewer")
-      assert(res.fields.length == 2)
-      assert(res.fields[0].is_a?(GraphQL::Syntax::Field), 'it gets a field')
-      assert(res.fields[1].is_a?(GraphQL::Syntax::Edge), 'it gets an edge')
+          <page_info>: {
+            "page" : { "id": 4},
+            "person" : {"id": 4}
+          }
+          <other>: {
+            "page" : { "id": 4},
+            "person" : {"id": 4}
+          }
+          })
+        res = transform.apply(tree)
+        assert_equal 1, res.nodes.length
+        assert_equal "like_page", res.nodes[0].identifier
+        assert_equal ["<page_info>"], res.nodes[0].arguments
+        assert_equal ["<page_info>", "<other>"], res.variables.map(&:identifier)
+      end
     end
 
-    it 'turns a field into a Field' do
-      tree = parser.field.parse("friends")
-      res = transform.apply(tree)
-      assert(res.is_a?(GraphQL::Syntax::Field))
-      assert(res.identifier == "friends")
+    describe 'nodes' do
+      it 'turns a simple node into a Node' do
+        tree = parser.node.parse("post(123) { name }")
+        res = transform.apply(tree)
+        assert(res.is_a?(GraphQL::Syntax::Node), 'it gets a node')
+      end
+
+      it 'turns a node into a Node' do
+        tree = parser.node.parse("person(1) { name, check_ins.last(4) { count, edges { node { id } }  } }")
+        res = transform.apply(tree)
+        assert(res.is_a?(GraphQL::Syntax::Node), 'it gets a node')
+        assert(res.identifier == "person")
+        assert(res.fields.length == 2)
+        assert(res.fields[0].is_a?(GraphQL::Syntax::Field), 'it gets a field')
+        assert(res.fields[1].is_a?(GraphQL::Syntax::Field), 'it gets an field with fields')
+        assert(res.fields[1].calls.first.is_a?(GraphQL::Syntax::Call), 'it gets a call')
+      end
     end
 
-    it 'turns edge into an Edge' do
-      tree = parser.edge.parse("friends.after(123).first(2) { count, edges { node { name } } }")
-      res = transform.apply(tree)
-      assert(res.is_a?(GraphQL::Syntax::Edge), 'it gets the Edge')
-      assert(res.identifier == "friends")
-      assert(res.calls.length == 2, 'it tracks calls')
-      assert(res.calls[0].identifier == "after")
-      assert(res.calls[1].identifier == "first")
-      assert_equal(res.call_hash, {"after" => "123", "first" => "2"})
+    describe 'fields' do
+      it 'turns a field into a Field' do
+        tree = parser.field.parse("friends")
+        res = transform.apply(tree)
+        assert(res.is_a?(GraphQL::Syntax::Field))
+        assert(res.identifier == "friends")
+      end
+
+      it 'gets aliases' do
+        tree = parser.field.parse("friends as pals")
+        res = transform.apply(tree)
+        assert(res.is_a?(GraphQL::Syntax::Field))
+        assert(res.identifier == "friends")
+        assert(res.alias_name == "pals")
+      end
+
+      it 'gets calls' do
+        tree = parser.field.parse("friends.orderby(name, birthdate).first(3)")
+        res = transform.apply(tree)
+        assert_equal "orderby", res.calls[0].identifier
+        assert_equal ["name", "birthdate"], res.calls[0].arguments
+        assert_equal "first", res.calls[1].identifier
+        assert_equal ["3"], res.calls[1].arguments
+      end
+
+      describe 'fields that return objects' do
+        it 'gets them' do
+          tree = parser.field.parse("friends { count }")
+          res = transform.apply(tree)
+          assert_equal "friends", res.identifier
+          assert_equal 1, res.fields.length
+        end
+        it 'gets them with aliases' do
+          tree = parser.field.parse("friends as pals { count }")
+          res = transform.apply(tree)
+          assert_equal "friends", res.identifier
+          assert_equal "pals", res.alias_name
+          assert_equal 1, res.fields.length
+        end
+        it 'gets them with calls' do
+          tree = parser.field.parse("friends.orderby(name, birthdate).last(1) { count }")
+          res = transform.apply(tree)
+          assert_equal "friends", res.identifier
+          assert_equal 1, res.fields.length
+          assert_equal 2, res.calls.length
+        end
+        it 'gets them with calls and aliases' do
+          tree = parser.field.parse("friends.orderby(name, birthdate).last(1) as pals { count }")
+          res = transform.apply(tree)
+          assert_equal "friends", res.identifier
+          assert_equal "pals", res.alias_name
+          assert_equal 1, res.fields.length
+          assert_equal 2, res.calls.length
+        end
+      end
     end
 
-    it 'turns call into a Call' do
-      tree = parser.call.parse("node(123)")
-      res = transform.apply(tree)
-      assert(res.is_a?(GraphQL::Syntax::Call))
-      assert(res.identifier == "node")
-      assert(res.argument == "123")
+    describe 'calls' do
+      it 'turns call into a Call' do
+        tree = parser.call.parse("node(4, 6, tree)")
+        res = transform.apply(tree)
+        assert(res.is_a?(GraphQL::Syntax::Call))
+        assert(res.identifier == "node")
+        assert(res.arguments == ["4", "6", "tree"])
+      end
+
+      it 'turns a call without an argument into a Call' do
+        tree = parser.call.parse("viewer()")
+        res = transform.apply(tree)
+        assert(res.is_a?(GraphQL::Syntax::Call))
+        assert(res.identifier == "viewer")
+        assert(res.arguments.length == 0)
+      end
+
+      it 'gets calls with variable identifiers' do
+        tree = parser.call.parse("like_page(<page_info>)")
+        res = transform.apply(tree)
+        assert_equal "<page_info>", res.arguments[0]
+      end
     end
 
-    it 'turns a call without an argument into a Call' do
-      tree = parser.call.parse("viewer()")
-      res = transform.apply(tree)
-      assert(res.is_a?(GraphQL::Syntax::Call))
-      assert(res.identifier == "viewer")
-      assert(res.argument == nil)
+    describe 'variables' do
+      it 'gets variables' do
+        tree = parser.variable.parse(%{
+          <page_info>: {
+            "page" : { "id": 4},
+            "person" : {"id": 4}
+          }
+          })
+        res = transform.apply(tree)
+        assert_equal "<page_info>", res.identifier
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,7 +1,8 @@
+require 'date'
 require "minitest/autorun"
 require "minitest/focus"
 require "minitest/reporters"
-
+require 'pry'
 Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
 
 # Filter out Minitest backtrace while allowing backtrace from other libraries

data/spec/support/dummy_app.rb

@@ -6,56 +6,76 @@ class InadequateRecordBase
   end
 
   def destroy
-    self.class.objects.delete(self)
+    self.class.all.delete(self)
   end
 
   class << self
     attr_accessor :_objects
-    def objects
+    def all
       @_objects ||= []
     end
-  end
 
-  def self.find(id)
-    objects.find { |object| object.id.to_s == id.to_s}
-  end
+    def find(id)
+      all.find { |object| object.id.to_s == id.to_s }
+    end
 
-  def self.where(query={})
-    result = []
-    objects.each do |object|
-      match = true
+    def where(query={})
+      result = []
+      all.each do |object|
+        match = true
 
-      query.each do |key, value|
-        if object.send(key) != value
-          match = false
+        query.each do |key, value|
+          if object.send(key) != value
+            match = false
+          end
         end
-      end
 
-      result << object if match
+        result << object if match
+      end
+      result
     end
-    result
-  end
 
-  def self.create(attributes)
-    instance = self.new(attributes)
-    objects << instance
-    instance
+    def create(attributes)
+      @next_id ||= 0
+      attributes[:id] ||= @next_id += 1
+      instance = self.new(attributes)
+      all << instance
+      instance
+    end
   end
 end
 
 class Post < InadequateRecordBase
-  attr_accessor :id, :title, :content
+  attr_accessor :id, :title, :content, :published_at
 
   def comments
     Comment.where(post_id: id)
   end
+
+  def likes
+    Like.where(post_id: id)
+  end
 end
 
 class Comment < InadequateRecordBase
-  attr_accessor :id, :post_id, :content
+  attr_accessor :id, :post_id, :content, :rating
+
   def post
     Post.find(post_id)
   end
 end
 
+class Like < InadequateRecordBase
+  attr_accessor :id, :post_id
+
+  def post
+    Post.find(post_id)
+  end
+end
 
+class Context
+  attr_reader :person_name
+  def initialize(person_name:)
+    @person_name = person_name
+  end
+end