graphql 0.0.4 → 0.1.0

data/spec/graphql/schema/schema_spec.rb

@@ -1,93 +0,0 @@
-require 'spec_helper'
-
-describe GraphQL::Schema::Schema do
-  let(:schema) { GraphQL::SCHEMA }
-  describe 'global instance' do
-    it 'exists as GraphQL::SCHEMA' do
-      assert GraphQL::SCHEMA.is_a?(GraphQL::Schema::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) { }
-    let(:query) { GraphQL::Query.new(query_string) }
-    let(:result) { GraphQL::SCHEMA.all }
-
-    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"]}
-      let(:type_names) { result["schema"]["types"]["edges"].map {|t| t["node"]["name"] }}
-
-      it 'returns all types' do
-        types_count = 19
-        assert_equal types_count, result["schema"]["types"]["count"]
-        assert_equal types_count, type_names.length
-      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 'has custom types' do
-        assert type_names.include?("letter_selection")
-        assert_equal "letter_selection", content_field["type"]
-      end
-
-      it 'shows field type & calls' do
-        assert_equal "letter_selection", 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/schema/schema_validation_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe GraphQL::Schema::SchemaValidation do
-  let(:schema) { GraphQL::SCHEMA }
-
-  it 'runs' do
-    schema.validate
-  end
-
-  describe "when the exposes_class doesnt exist" do
-    before do
-      Nodes::PostNode.exposes("BogusPost")
-    end
-    after do
-      Nodes::PostNode.exposes("Post")
-    end
-
-    it 'raises an error' do
-      assert_raises(GraphQL::ExposesClassMissingError) { schema.validate }
-    end
-  end
-
-  describe "when there's a bad field type" do
-    before do
-      Nodes::PostNode.field.bogus_kind(:bogus_title)
-    end
-    after do
-      Nodes::PostNode.remove_field(:bogus_title)
-    end
-
-    it 'raises an error' do
-      assert_raises(GraphQL::NodeNotDefinedError) { schema.validate }
-    end
-  end
-
-  describe "when a field cant find a corresponding method" do
-    before do
-      Nodes::PostNode.field.string(:bogus_title)
-    end
-    after do
-      Nodes::PostNode.remove_field(:bogus_title)
-    end
-
-    it 'raises an error' do
-      assert_raises(GraphQL::FieldNotDefinedError) { schema.validate }
-    end
-  end
-end

data/spec/support/nodes.rb

@@ -1,175 +0,0 @@
-require 'graphql'
-require 'support/dummy_app.rb'
-
-module Nodes
-  class ApplicationNode < GraphQL::Node
-    field.number(:id)
-    cursor :id
-
-    class << self
-      attr_accessor :model_class
-      def node_for(m_class)
-        @model_class = m_class
-      end
-    end
-  end
-
-
-  class ApplicationConnection < GraphQL::Connection
-    type :connection
-    call :first, -> (prev_items, first) { prev_items.first(first.to_i) }
-    call :after, -> (prev_items, after) { prev_items.select {|i| i.id > after.to_i } }
-
-    field.number(:count)
-    field.boolean(:any)
-
-    def count
-      target.count
-    end
-
-    def any
-      target.any?
-    end
-  end
-
-  class CommentsConnection < ApplicationConnection
-    type :comments
-    field.number :viewer_name_length
-    field.number :average_rating
-
-    # just to test context:
-    def viewer_name_length
-      context.person_name.length
-    end
-
-    def average_rating
-      total_rating = target.map(&:rating).inject(&:+).to_f
-      total_rating / target.size
-    end
-  end
-
-  class DateType < GraphQL::Node
-    exposes "Date"
-    type :date
-    call :minus_days, -> (prev_value, minus_days) { prev_value - minus_days.to_i }
-    field.number(:year)
-    field.number(:month)
-  end
-
-  class PostNode < ApplicationNode
-    node_for Post
-    exposes "Post"
-    desc "A blog post entry"
-
-    field.string(:title)
-    field.letter_selection(:content)
-    field.number(:length)
-    field.comments(:comments)
-    field.date(:published_at)
-    field.connection(:likes)
-
-    def length
-      target.content.length
-    end
-  end
-
-  class CommentNode < ApplicationNode
-    node_for Comment
-    exposes "Comment"
-    field.string(:content)
-    field.letter_selection(:letters)
-    field.post(:post)
-
-    def letters; content; end
-  end
-
-  # wraps a Like, for testing explicit name
-  class ThumbUpNode < ApplicationNode
-    node_for(Like)
-    exposes "Like"
-    type "upvote"
-    field.number :post_id
-    def id
-      target.id.to_s + target.id.to_s
-    end
-  end
-
-  class ContextNode < GraphQL::Node
-    exposes "Context"
-    field.string(:person_name)
-    field.boolean(:present)
-
-    def cursor
-      "context"
-    end
-
-    def present
-      true
-    end
-  end
-
-  class LetterSelectionType < GraphQL::Node
-    type :letter_selection
-    call :from, ->    (prev_value, chars) { prev_value[(chars.to_i)..-1] }
-    call :for, ->     (prev_value, chars) { prev_value[0, (chars.to_i)] }
-    call :select, ->  (prev_value, from_chars, for_chars) { prev_value[from_chars.to_i, for_chars.to_i] }
-    def as_result
-      apply_calls(target)
-    end
-  end
-
-  class FindCall < GraphQL::RootCall
-    abstract!
-    argument.number("ids", any_number: true)
-    def execute!(*ids)
-      model_class = model_type
-      items = ids.map { |id| model_class.find(id.to_i) }
-    end
-  end
-
-  class PostCall < FindCall
-    returns :post
-    def model_type
-      Post
-    end
-  end
-
-  class CommentCall < FindCall
-    returns :comment
-    def model_type
-      Comment
-    end
-  end
-
-  class ThumbUpCall < FindCall
-    returns :thumb_up
-    def model_type
-      Like
-    end
-  end
-
-  class ContextCall < GraphQL::RootCall
-    returns :context
-    def execute!
-      context
-    end
-  end
-
-  class LikePostCall < GraphQL::RootCall
-    indentifier "upvote_post"
-    returns :post, :upvote
-
-    argument.object("post_data")
-    argument.number("person_id")
-
-
-    def execute!(post_data, person_id)
-      post_id = post_data["id"]
-      like = Like.create(post_id: post_id)
-      {
-        post: Post.find(post_id),
-        upvote: like
-      }
-    end
-  end
-end