graphql 0.0.1 → 0.0.2

data/spec/graphql/field_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe GraphQL::Field do
+  let(:owner) { OpenStruct.new(name: "TestOwner")}
+  let(:field) { GraphQL::Field.create_class(name: "high_fives", type: :number, owner_class: owner).new(query: {}) }
+
+  describe '#name' do
+    it 'is present' do
+      assert_equal field.name, "high_fives"
+    end
+  end
+
+  describe '#method' do
+    it 'defaults to name' do
+      assert_equal "high_fives", field.method
+    end
+  end
+
+  describe '.call' do
+    let(:content_field) { Nodes::PostNode.all_fields["content"] }
+    it 'doesnt register a call twice' do
+      assert_equal 3, content_field.calls.size
+      call = content_field.calls.first[1]
+      content_field.call(call.name, call.lambda)
+      content_field.call(call.name, call.lambda)
+      assert_equal 3, content_field.calls.size
+    end
+  end
+
+  describe '.to_s' do
+    it 'includes name' do
+      assert_match(/high_fives/, field.class.to_s)
+    end
+    it 'includes owner name' do
+      assert_match(/TestOwner/, field.class.to_s)
+    end
+  end
+
+  describe '__type__' do
+    let(:query_string) { "type(post) { fields { edges { node { name, type, calls { edges { node { name } }} } } } } "}
+    let(:query) { GraphQL::Query.new(query_string, context: {}) }
+    let(:result) { query.as_result }
+    let(:id_field)        { result["post"]["fields"]["edges"][1]["node"] }
+    let(:title_field)     { result["post"]["fields"]["edges"][2]["node"] }
+    let(:comments_field)  { result["post"]["fields"]["edges"][5]["node"] }
+    let(:content_field)   { result["post"]["fields"]["edges"][3]["node"] }
+
+    it 'has name' do
+      assert_equal "id", id_field["name"]
+      assert_equal "title", title_field["name"]
+      assert_equal "comments", comments_field["name"]
+    end
+
+    it 'has type' do
+      assert_equal "number", id_field["type"]
+      assert_equal "string", title_field["type"]
+      assert_equal "connection", comments_field["type"]
+    end
+
+    it 'has calls' do
+      assert_equal 3, content_field["calls"]["edges"].length
+      assert_equal ["from", "for", "select"], content_field["calls"]["edges"].map {|c| c["node"]["name"] }
+    end
+  end
+end

data/spec/graphql/node_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe GraphQL::Node do
+  let(:query_string) { "type(post) { name, description, fields { count, edges { node { name, description }}} }"}
+  let(:result) { GraphQL::Query.new(query_string).as_result}
+
+  describe '__type__' do
+    let(:title_field) { result["post"]["fields"]["edges"].find {|e| e["node"]["name"] == "title"}["node"] }
+    it 'has name' do
+      assert_equal "post", result["post"]["name"]
+    end
+
+    it 'has description' do
+      assert_equal "A blog post entry", result["post"]["description"]
+    end
+
+    it 'has fields' do
+      assert_equal 8, result["post"]["fields"]["count"]
+      assert_equal({ "name" => "title", "description" => nil}, title_field)
+    end
+
+    describe 'getting the __type__ field' do
+      before do
+        @post = Post.create(id: 155, content: "Hello world")
+      end
+
+      after do
+        @post.destroy
+      end
+
+      let(:query_string) { "post(155) { __type__ { name, fields { count } } }"}
+
+      it 'exposes the type' do
+        assert_equal "post", result["155"]["__type__"]["name"]
+        assert_equal 8, result["155"]["__type__"]["fields"]["count"]
+      end
+    end
+  end
+
+  describe '.node_name' do
+    let(:query_string) { "type(upvote) { name }"}
+
+    it 'overrides __type__.name' do
+      assert_equal "upvote", result["upvote"]["name"]
+    end
+  end
+
+  describe '.field' do
+    it 'doesnt add the field twice if you call it twice' do
+      assert_equal 5, Nodes::CommentNode.all_fields.size
+      Nodes::CommentNode.field.number(:id)
+      Nodes::CommentNode.field.number(:id)
+      assert_equal 5, Nodes::CommentNode.all_fields.size
+      Nodes::CommentNode.remove_field(:id)
+    end
+
+    describe 'type:' do
+      it 'uses symbols to find built-ins' do
+        id_field = Nodes::CommentNode.all_fields["id"]
+        assert id_field.superclass == GraphQL::Types::NumberField
+      end
+      it 'uses the provided class as a superclass' do
+        letters_field = Nodes::CommentNode.all_fields["letters"]
+        assert letters_field.superclass == Nodes::LetterSelectionField
+      end
+    end
+  end
+end

data/spec/graphql/parser_spec.rb

@@ -1,33 +1,59 @@
 require 'spec_helper'
 
 describe GraphQL::Parser do
-  let(:node_name) { "" }
-  let(:fields) { "id, name"}
-  let(:query) { "#{node_name} { #{fields} }"}
   let(:parser) { GraphQL::PARSER }
 
+  describe 'query' do
+    let(:query) { parser.query }
+    it 'parses node-only' do
+      assert query.parse_with_debug("node(4) { id, name } ")
+    end
+    it 'parses node and variables' do
+      assert query.parse_with_debug(%{
+        like_page(<page>) {
+          page { id }
+        }
+        <page>: {
+          "page": {"id": 1},
+          "person" : { "id", 4}
+        }
+        <other>: {
+          "page": {"id": 1},
+          "person" : { "id", 4}
+        }
+      })
+    end
+  end
   describe 'field' do
     let(:field) { parser.field }
     it 'finds words' do
-      assert field.parse_with_debug("name")
       assert field.parse_with_debug("date_of_birth")
     end
-  end
 
-  describe 'edge' do
-    let(:edge) { parser.edge }
+    it 'finds aliases' do
+      assert field.parse_with_debug("name as moniker")
+    end
 
     it 'finds calls on fields' do
-      assert edge.parse_with_debug("friends.first(1) {
-              count,
-              edges {
-                cursor,
-                node {
-                  name
-                }
-              }
-            }
-        ")
+      assert field.parse_with_debug("url.site(www).upcase()")
+    end
+
+    describe 'fields that return objects' do
+      it 'finds them' do
+        assert field.parse_with_debug("birthdate { month, year }")
+      end
+
+      it 'finds them with aliases' do
+        assert field.parse_with_debug("birthdate as d_o_b { month, year }")
+      end
+
+      it 'finds them with calls' do
+        assert field.parse_with_debug("friends.after(123) { count { edges { node { id } } } }")
+      end
+
+      it 'finds them with calls and aliases' do
+        assert field.parse_with_debug("friends.after(123) as pals { count { edges { node { id } } } }")
+      end
     end
   end
 
@@ -37,15 +63,13 @@ describe GraphQL::Parser do
       assert call.parse_with_debug("node(123)")
       assert call.parse_with_debug("viewer()")
     end
-  end
 
-  describe 'call_chain' do
-    let(:call_chain) { parser.call_chain }
-    it 'finds deep calls' do
-      assert call_chain.parse_with_debug("friends.after(123).first(2)")
+    it 'finds calls with multiple arguments' do
+      assert call.parse_with_debug("node(4, 6)")
     end
-    it 'finds chain with no calls' do
-      assert call_chain.parse_with_debug("friends")
+
+    it 'finds calls with variables' do
+      assert call.parse_with_debug("like_page(<page>)")
     end
   end
 
@@ -71,7 +95,8 @@ describe GraphQL::Parser do
     end
 
     it 'parses nested nodes' do
-      assert node.parse_with_debug("node(someone)
+      assert node.parse_with_debug("
+        node(someone)
             {
               id,
               name,
@@ -86,4 +111,29 @@ describe GraphQL::Parser do
           ")
     end
   end
+
+  describe 'variable' do
+    let(:variable) { parser.variable }
+
+    it 'gets scalar variables' do
+      assert variable.parse_with_debug(%{<some_number>: 888})
+      assert variable.parse_with_debug(%{<some_string>: my_string})
+    end
+    it 'gets json variables' do
+      assert variable.parse_with_debug(%{<my_input>: {"key": "value"}})
+    end
+
+    it 'gets variables with nesting' do
+      assert variable.parse_with_debug(%{
+      <my_input>: {
+        "key": "value",
+        "1": 2,
+        "true": false,
+        "nested": {
+          "key" : "value"
+          }
+        }
+      })
+    end
+  end
 end

data/spec/graphql/query_spec.rb

@@ -2,153 +2,255 @@ require 'spec_helper'
 
 describe GraphQL::Query do
   let(:query_string) { "post(123) { title, content } "}
-  let(:namespace) { Nodes }
-  let(:query) { GraphQL::Query.new(query_string, namespace: namespace) }
+  let(:context) { Context.new(person_name: "Han Solo") }
+  let(:query) { GraphQL::Query.new(query_string, context: context) }
+  let(:result) { query.as_result }
 
-  describe '#root' do
-    it 'contains the first node of the graph' do
-      assert query.root.is_a?(GraphQL::Syntax::Node)
-    end
+  before do
+    @post = Post.create(id: 123, content: "So many great things", title: "My great post", published_at: Date.new(2010,1,4))
+    @comment1 = Comment.create(id: 444, post_id: 123, content: "I agree", rating: 5)
+    @comment2 = Comment.create(id: 445, post_id: 123, content: "I disagree", rating: 1)
+    @like1 = Like.create(id: 991, post_id: 123)
+    @like2 = Like.create(id: 992, post_id: 123)
+  end
+
+  after do
+    @post.destroy
+    @comment1.destroy
+    @comment2.destroy
+    @like1.destroy
+    @like2.destroy
   end
 
-  describe '#to_json' do
-    before do
-      @post = Post.create(id: 123, content: "So many great things", title: "My great post")
-      @comment1 = Comment.create(id: 444, post_id: 123, content: "I agree")
-      @comment2 = Comment.create(id: 445, post_id: 123, content: "I disagree")
+  describe '#as_result' do
+    it 'finds fields that delegate to a target' do
+      assert_equal result, {"123" => {"title" => "My great post", "content" => "So many great things"}}
     end
 
-    after do
-      @post.destroy
-      @comment1.destroy
-      @comment2.destroy
+    describe 'with multiple roots' do
+      let(:query_string) { "comment(444, 445) { content } "}
+      it 'adds each as a key-value of the response' do
+        assert_equal ["444", "445"], result.keys
+      end
     end
 
-    it 'performs the root node call' do
-      assert_send([Nodes::PostNode, :call, "123"])
-      query.to_json
+    describe 'when accessing fields that return objects' do
+      describe 'when making calls on the field' do
+        let(:query_string) { "post(123) { published_at.minus_days(200) { year } }"}
+        it 'returns the modified value' do
+          assert_equal 2009, result["123"]["published_at"]["year"]
+        end
+      end
+      describe 'when requesting more fields' do
+        let(:query_string) { "post(123) { published_at { month, year } }"}
+        it 'returns those fields' do
+          assert_equal({"month" => 1, "year" => 2010}, result["123"]["published_at"])
+        end
+      end
     end
+    describe 'when aliasing things' do
+      let(:query_string) { "post(123) { title as headline, content as what_it_says }"}
 
-    it 'finds fields that delegate to a target' do
-      assert_equal query.to_json, {
-        "123" => {
-          "title" => "My great post",
-          "content" => "So many great things"
-        }
-      }
+      it 'applies aliases to fields' do
+        assert_equal @post.title, result["123"]["headline"]
+        assert_equal @post.content, result["123"]["what_it_says"]
+      end
+
+      it 'applies aliases to edges' # dunno the syntax yet
     end
 
     describe 'when requesting fields defined on the node' do
-      let(:query_string) { "post(123) { teaser } "}
+      let(:query_string) { "post(123) { length } "}
       it 'finds fields defined on the node' do
-        assert_equal query.to_json, { "123" => { "teaser" => @post.content[0,10] + "..."}}
+        assert_equal 20, result["123"]["length"]
       end
     end
 
+    describe 'when accessing custom fields' do
+      let(:query_string) { "comment(444) { letters }"}
+      it 'uses the custom field' do
+        assert_equal "I agree", result["444"]["letters"]
+      end
+
+      describe 'when making calls on fields' do
+        let(:query_string) { "comment(444) {
+            letters.select(4, 3),
+            letters.from(3).for(2) as snippet
+          }"}
+
+        it 'works with aliases' do
+          assert result["444"]["snippet"].present?
+        end
+
+        it 'applies calls' do
+          assert_equal "gr", result["444"]["snippet"]
+        end
+
+        it 'applies calls with multiple arguments' do
+          assert_equal "ree", result["444"]["letters"]
+        end
+      end
+
+      describe 'when requesting fields overriden on a child class' do
+        let(:query_string) { 'thumb_up(991) { id }'}
+        it 'uses the child implementation' do
+          assert_equal '991991', result["991991"]["id"]
+        end
+      end
+    end
 
     describe 'when requesting an undefined field' do
       let(:query_string) { "post(123) { destroy } "}
       it 'raises a FieldNotDefined error' do
-        assert_raises(GraphQL::FieldNotDefinedError) { query.to_json }
+        assert_raises(GraphQL::FieldNotDefinedError) { query.as_result }
         assert(Post.find(123).present?)
       end
     end
 
     describe 'when the root call doesnt have an argument' do
-      let(:query_string) { "viewer() { name }"}
-      it 'calls the node with nil' do
-        assert_send([Nodes::ViewerNode, :call, nil])
-        query.to_json
+      let(:query_string) { "context() { person_name }"}
+      it 'calls the node with no arguments' do
+        assert_equal "Han Solo", result["context"]["person_name"]
       end
     end
 
     describe  'when requesting a collection' do
       let(:query_string) { "post(123) {
           title,
-          comments {
-            count,
-            edges {
-              cursor,
-              node {
-                content
-              }
-            }
-          }
+          comments { count, edges { cursor, node { content } } }
         }"}
+
       it 'returns collection data' do
-        assert_equal query.to_json, {
+        assert_equal result, {
             "123" => {
               "title" => "My great post",
               "comments" => {
                 "count" => 2,
                 "edges" => [
-                  {
-                    "cursor" => "444",
-                    "node" => {
-                      "content" => "I agree"
-                    }
-                  },
-                  {
-                    "cursor" => "445",
-                    "node" => {
-                      "content" => "I disagree"
-                    }
-                  }
+                  { "cursor" => "444", "node" => {"content" => "I agree"} },
+                  { "cursor" => "445", "node" => {"content" => "I disagree"}}
                 ]
-              }
-            }
-          }
+            }}}
       end
     end
 
     describe  'when making calls on a collection' do
-      let(:query_string) { "post(123) {
-          comments.first(1) {
-            edges { cursor, node { content } }
-          }
-        }"}
+      let(:query_string) { "post(123) { comments.first(1) { edges { cursor, node { content } } } }"}
 
       it 'executes those calls' do
-        assert_equal query.to_json, {
+        assert_equal result, {
             "123" => {
               "comments" => {
                 "edges" => [
-                  {
-                    "cursor" => "444",
-                    "node" => {
-                      "content" => "I agree"
-                    }
-                  }
+                  { "cursor" => "444", "node" => { "content" => "I agree"} }
                 ]
-              }
-            }
-          }
+            }}}
       end
     end
 
     describe  'when making DEEP calls on a collection' do
-      let(:query_string) { "post(123) {
-          comments.after(444).first(1) {
+      let(:query_string) { "post(123) { comments.after(444).first(1) {
             edges { cursor, node { content } }
-          }
-        }"}
+          }}"}
 
       it 'executes those calls' do
-        assert_equal query.to_json, {
+        assert_equal result, {
             "123" => {
               "comments" => {
                 "edges" => [
                   {
                     "cursor" => "445",
-                    "node" => {
-                      "content" => "I disagree"
-                    }
+                    "node" => { "content" => "I disagree"}
                   }
                 ]
-              }
-            }
-          }
+            }}}
       end
     end
+
+    describe  'when requesting fields at collection-level' do
+      let(:query_string) { "post(123) { comments { average_rating } }"}
+
+      it 'executes those calls' do
+        assert_equal result, { "123" => { "comments" => { "average_rating" => 3 } } }
+      end
+    end
+
+    describe  'when making calls on node fields' do
+      let(:query_string) { "post(123) { comments { edges { node { letters.from(3).for(3) }} } }"}
+
+      it 'makes calls on the fields' do
+        assert_equal ["gre", "isa"], result["123"]["comments"]["edges"].map {|e| e["node"]["letters"] }
+      end
+    end
+
+    describe  'when requesting collection-level fields that dont exist' do
+      let(:query_string) { "post(123) { comments { bogus_field } }"}
+
+      it 'raises FieldNotDefined' do
+        assert_raises(GraphQL::FieldNotDefinedError) { query.as_result }
+      end
+    end
+  end
+
+  describe 'when requesting fields on a related object' do
+    let(:query_string) { "comment(444) { post { title } }"}
+    it 'finds fields on that object' do
+      assert_equal "My great post", result["444"]["post"]["title"]
+    end
+
+    describe 'when the object doesnt exist' do
+      before do
+        Post.all.map(&:destroy)
+      end
+
+      it 'blows_up' do # what _should_ this do?
+        assert_raises(RuntimeError) { result }
+      end
+    end
+  end
+
+  describe 'when edge classes were named explicitly' do
+    let(:query_string) { "post(123) { likes { any, edges { node { id } } } }"}
+
+    it 'gets node values' do
+      assert_equal ["991991","992992"], result["123"]["likes"]["edges"].map {|e|  e["node"]["id"] }
+    end
+
+    it 'gets edge values' do
+      assert_equal true, result["123"]["likes"]["any"]
+    end
+  end
+
+  describe '#context' do
+    let(:query_string) { "context() { person_name }"}
+
+    it 'is accessible inside nodes' do
+      assert_equal({"context" => {"person_name" => "Han Solo"}}, result)
+    end
+
+    describe 'inside edges' do
+      let(:query_string) { "post(123) { comments { viewer_name_length } }"}
+      it 'is accessible' do
+        assert_equal 8, result["123"]["comments"]["viewer_name_length"]
+      end
+    end
+  end
+
+  describe 'parsing error' do
+    let(:query_string) { "\n\n<< bogus >>"}
+
+    it 'raises SyntaxError' do
+      assert_raises(GraphQL::SyntaxError) { result }
+    end
+
+    it 'contains line an character number' do
+      err = assert_raises(GraphQL::SyntaxError) { result }
+      assert_match(/1, 1/, err.to_s)
+    end
+
+    it 'contains sample of text' do
+      err = assert_raises(GraphQL::SyntaxError) { result }
+      assert_includes(err.to_s, "<< bogus >>")
+    end
   end
 end