graphql_client 0.3.3

data/test/graphql_client/graph_object_test.rb

@@ -0,0 +1,142 @@
+require 'test_helper'
+
+module GraphQL
+  module Client
+    class GraphObjectTest < Minitest::Test
+      def setup
+        @schema = GraphQLSchema.new(schema_fixture('schema.json'))
+      end
+
+      def test_builds_graph_objects_from_hashes
+        query = Query::QueryDocument.new(@schema)
+        shop = query.add_field('shop', as: 'myshop')
+        shop.add_field('name')
+
+        data = {
+          'myshop' => {
+            'name' => 'My Shop',
+          }
+        }
+
+        result = GraphObject.new(data: data, query: query)
+        myshop = result.myshop
+
+        assert_equal data.fetch('myshop'), myshop.data
+        assert_equal shop, myshop.query
+        assert_equal result, myshop.parent
+      end
+
+      def test_builds_graph_objects_from_arrays
+        query = Query::QueryDocument.new(@schema)
+        shop = query.add_field('shop')
+        product = shop.add_field('productByHandle', handle: 'handle')
+        product.add_field('tags')
+
+        data = {
+          'shop' => {
+            'productByHandle' => {
+              'tags' => [
+                'tag1',
+                'tag2',
+              ]
+            }
+          }
+        }
+
+        result = GraphObject.new(data: data, query: query)
+
+        assert_equal ['tag1', 'tag2'], result.shop.product_by_handle.tags
+      end
+
+      def test_instantiates_a_graph_connection_for_connection_fields
+        query = Query::QueryDocument.new(@schema)
+        shop = query.add_field('shop')
+
+        data = {
+          'shop' => {}
+        }
+
+        shop.stub(:connection?, true) do
+          result = GraphObject.new(data: data, query: query)
+          assert_instance_of GraphConnection, result.shop
+        end
+      end
+
+      def test_instantiates_a_graph_node_for_node_types
+        query = Query::QueryDocument.new(@schema)
+        shop = query.add_field('shop')
+
+        data = {
+          'shop' => {}
+        }
+
+        shop.stub(:node?, true) do
+          result = GraphObject.new(data: data, query: query)
+          assert_instance_of GraphNode, result.shop
+        end
+      end
+
+      def test_defines_methods_from_data
+        query = Query::QueryDocument.new(@schema)
+        shop = query.add_field('shop', as: 'myshop')
+        shop.add_fields('name', 'termsOfService')
+
+        data = {
+          'myshop' => {
+            'name' => 'My Shop',
+            'termsOfService' => false,
+          }
+        }
+
+        result = GraphObject.new(data: data, query: query)
+        myshop = result.myshop
+
+        assert_equal 'My Shop', myshop.name
+        assert_equal false, myshop.terms_of_service
+        assert_equal false, myshop.termsOfService
+      end
+
+      def test_defines_instance_variable_during_method_access
+        query = Query::QueryDocument.new(@schema)
+        shop = query.add_field('shop')
+        shop.add_field('name')
+
+        data = {
+          'shop' => {
+            'name' => 'My Shop',
+          }
+        }
+
+        result = GraphObject.new(data: data, query: query)
+        refute result.instance_variable_defined?("@shop")
+
+        result.shop
+        assert result.instance_variable_defined?("@shop")
+        assert_equal result.shop, result.instance_variable_get("@shop")
+      end
+
+      def test_build_minimal_query_creates_a_new_query_operation_for_the_root_object
+        query = Query::QueryDocument.new(@schema) do |root|
+          root.add_field('shop') do |non_node|
+            non_node.add_field('name')
+          end
+        end
+
+        data = {
+          'shop' => {
+            'name' => 'Foo'
+          }
+        }
+
+        graph = GraphObject.new(data: data, query: query)
+        root = nil
+
+        graph.build_minimal_query do |context|
+          root = context
+        end
+
+        assert_instance_of Query::QueryOperation, root
+      end
+    end
+  end
+end

data/test/graphql_client/graphql_client_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+module GraphQL
+  module Client
+    class ClientTest < Minitest::Test
+      TestAdapter = Struct.new(:config) do
+        def request(_query_string)
+          Response.new('{ "data": { } }')
+        end
+      end
+
+      def test_dump_schema_writes_a_schema_file_from_introspection_query
+        adapter = TestAdapter.new(Config.new)
+
+        Tempfile.create('temp_schema.json') do |f|
+          Client.dump_schema(f, adapter: adapter)
+
+          assert_equal(JSON.pretty_generate(data: {}), File.read(f))
+        end
+      end
+
+      def test_new_instantiates_base
+        client = Client.new(schema_fixture('schema.json'))
+
+        assert_instance_of Base, client
+      end
+
+      def test_new_accepts_a_block_for_httpclient
+        url = URI('http://example.com')
+
+        client = Client.new(schema_fixture('schema.json')) do
+          configure do |c|
+            c.url = url
+          end
+        end
+
+        assert_equal url, client.config.url
+      end
+    end
+  end
+end

data/test/graphql_client/http_client_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+module GraphQL
+  module Client
+    class BaseTest < Minitest::Test
+      def test_configure_yields_the_config
+        client = Base.new(schema_fixture('schema.json'))
+
+        client.configure do |c|
+          assert_equal c, client.config
+        end
+      end
+
+      def test_query_calls_adapter_request_with_query_builder_instance_and_creates_a_graph_object
+        config = Config.new(url: 'http://example.com')
+
+        query = Minitest::Mock.new
+        query.expect(:to_query, 'query shopQuery { shop }')
+
+        adapter = Minitest::Mock.new
+        adapter.expect(:request, Response.new('{}'), [
+          'query shopQuery { shop }',
+          operation_name: 'shopQuery',
+          variables: {}
+        ])
+
+        mock = Minitest::Mock.new
+        mock.expect(:call, nil, [data: nil, query: query])
+
+        GraphObject.stub(:new, mock) do
+          client = Base.new(schema_fixture('schema.json'), config: config, adapter: adapter)
+          client.query(query, operation_name: 'shopQuery')
+
+          mock.verify
+          query.verify
+        end
+      end
+
+      def test_raw_query_calls_adapter_request_with_query_string
+        config = Config.new(url: 'http://example.com')
+
+        adapter = Minitest::Mock.new
+        adapter.expect(:request, Response.new('{}'), ['query { shop }', operation_name: nil, variables: {}])
+
+        client = Base.new(schema_fixture('schema.json'), config: config, adapter: adapter)
+        client.raw_query('query { shop }')
+
+        adapter.verify
+      end
+    end
+  end
+end

data/test/graphql_client/query/add_inline_fragment_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+module GraphQL
+  module Client
+    module Query
+      class AddInlineFragmentTest < Minitest::Test
+        def setup
+          @schema = GraphQLSchema.new(schema_fixture('schema.json'))
+          @document = Document.new(@schema)
+
+          shop = @schema.query_root.field('shop')
+          field_defn = schema_type(shop.type).field('productByHandle')
+          @field = Field.new(field_defn, document: @document, arguments: { handle: 'test' })
+        end
+
+        def test_add_inline_fragment_yields_inline_fragment
+          inline_fragment_object = nil
+
+          inline_fragment = @field.add_inline_fragment('Product') do |f|
+            inline_fragment_object = f
+          end
+
+          assert_equal inline_fragment_object, inline_fragment
+        end
+
+        def test_add_inline_fragment_creates_inline_fragment_with_explicit_type
+          inline_fragment = @field.add_inline_fragment('Product')
+
+          assert_equal @schema.type('Product'), inline_fragment.type
+          assert_equal [inline_fragment], @field.selection_set.inline_fragments
+        end
+
+        def test_add_inline_fragment_creates_inline_fragment_with_explicit_interface_type
+          inline_fragment = @field.add_inline_fragment('Node')
+
+          assert_equal @schema.type('Node'), inline_fragment.type
+          assert_equal [inline_fragment], @field.selection_set.inline_fragments
+        end
+
+        def test_add_inline_fragment_creates_inline_fragment_with_implicit_type
+          inline_fragment = @field.add_inline_fragment
+
+          assert_equal @schema.type('Product'), inline_fragment.type
+          assert_equal [inline_fragment], @field.selection_set.inline_fragments
+        end
+
+        def test_add_inline_fragment_raises_exception_for_invalid_target_type
+          assert_raises AddInlineFragment::INVALID_FRAGMENT_TARGET do |e|
+            @field.add_inline_fragment('Image')
+
+            assert_equal "invalid target type 'Image' for fragment of type 'Product'", e.message
+          end
+        end
+      end
+    end
+  end
+end

data/test/graphql_client/query/arguments_test.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+module GraphQL
+  module Client
+    module Query
+      class ArgumentTest < Minitest::Test
+        def test_to_query_formats_arguments
+          arguments = Argument.new(2)
+
+          assert_equal '2', arguments.to_query
+        end
+
+        def test_to_query_quotes_string_values
+          arguments = Argument.new('2')
+
+          assert_equal '"2"', arguments.to_query
+        end
+
+        def test_to_query_boolean
+          arguments = Argument.new(true)
+
+          assert_equal 'true', arguments.to_query
+        end
+
+        def test_to_query_array
+          arguments = Argument.new([1, 'two'])
+
+          assert_equal '[1, "two"]', arguments.to_query
+        end
+
+        def test_to_query_hash
+          arguments = Argument.new(name: 'Foo', ids: [1, 2], variable: '$variableName')
+
+          assert_equal '{ name: "Foo", ids: [1,2], variable: $variableName }', arguments.to_query
+        end
+
+        def test_to_query_float
+          arguments = Argument.new(4.7e-24)
+
+          assert_equal '4.7e-24', arguments.to_query
+        end
+
+        def test_to_query_escapes_control_characters
+          arguments = Argument.new("control\ncharacter")
+
+          assert_equal '"control\\ncharacter"', arguments.to_query
+        end
+
+        def test_to_query_unicode
+          arguments = Argument.new('☀︎🏆 ¶')
+
+          assert_equal '"☀︎🏆 ¶"', arguments.to_query
+        end
+
+        def test_to_query_escaped_unicode
+          arguments = Argument.new("\u0012")
+
+          assert_equal '"\\u0012"', arguments.to_query
+        end
+
+        def test_to_query_escapes_characters
+          arguments = Argument.new("foo\"bar")
+
+          assert_equal '"foo\"bar"', arguments.to_query
+        end
+
+        def test_to_query_passes_through_variables
+          arguments = Argument.new('$variableName')
+
+          assert_equal '$variableName', arguments.to_query
+        end
+
+        def test_argument_instances_are_equal_for_same_value
+          argument = Argument.new('foo')
+          other_argument = Argument.new('foo')
+
+          assert_equal argument, other_argument
+        end
+
+        def test_argument_instances_are_not_equal_for_different_values
+          argument = Argument.new('foo')
+          other_argument = Argument.new('var')
+
+          refute_equal argument, other_argument
+        end
+      end
+    end
+  end
+end

data/test/graphql_client/query/document_test.rb

@@ -0,0 +1,246 @@
+require 'test_helper'
+
+module GraphQL
+  module Client
+    module Query
+      class DocumentTest < Minitest::Test
+        def setup
+          @schema = GraphQLSchema.new(schema_fixture('schema.json'))
+          @graphql_schema = GraphQL::Schema::Loader.load(schema_fixture('schema.json'))
+        end
+
+        def test_initialize_yields_self
+          document_object = nil
+
+          document = Document.new(@schema) do |d|
+            document_object = d
+          end
+
+          assert_equal document_object, document
+        end
+
+        def test_add_mutation_creates_a_mutation_operation
+          document = Document.new(@schema)
+          mutation = document.add_mutation('createUser')
+
+          assert_instance_of MutationOperation, mutation
+          assert_equal({ 'createUser' => mutation }, document.operations)
+        end
+
+        def test_add_query_creates_a_query_operation
+          document = Document.new(@schema)
+          query = document.add_query('getUser')
+
+          assert_instance_of QueryOperation, query
+          assert_equal({ 'getUser' => query }, document.operations)
+          assert_equal 1, document.operations.size
+        end
+
+        def test_add_operation_sets_default_name
+          document = Document.new(@schema)
+          query = document.add_query
+
+          assert_instance_of QueryOperation, query
+          assert_equal({ 'default' => query }, document.operations)
+          assert_equal 1, document.operations.size
+        end
+
+        def test_add_operation_yields_block
+          document = Document.new(@schema)
+          query_object = nil
+
+          query = document.add_query do |q|
+            query_object = q
+          end
+
+          assert_equal query_object, query
+        end
+
+        def test_add_operation_supports_multiple_unique_operations
+          document = Document.new(@schema)
+          document.add_query('getUser')
+          document.add_query('getPosts')
+
+          assert_equal 2, document.operations.size
+          assert_equal %w(getUser getPosts), document.operations.keys
+        end
+
+        def test_add_operation_enforces_unique_names
+          document = Document.new(@schema)
+          document.add_query('getUser')
+
+          assert_raises Document::DUPLICATE_OPERATION_NAME do
+            document.add_query('getUser')
+          end
+        end
+
+        def test_add_operation_requires_a_document_with_multiple_operations_to_all_be_named
+          document = Document.new(@schema)
+          document.add_query
+
+          assert_raises Document::INVALID_DOCUMENT do
+            document.add_query('getUser')
+          end
+        end
+
+        def test_define_fragment_creates_a_fragment
+          document = Document.new(@schema)
+
+          fragment = document.define_fragment('imageFields', on: 'Image')
+
+          assert_equal 'imageFields', fragment.name
+          assert_equal @schema.type('Image'), fragment.type
+          assert_equal document, fragment.document
+          assert_equal({ 'imageFields' => fragment }, document.fragments)
+        end
+
+        def test_define_fragment_yields_fragment
+          document = Document.new(@schema)
+          fragment_object = nil
+
+          fragment = document.define_fragment('imageFields', on: 'Image') do |f|
+            fragment_object = f
+          end
+
+          assert_equal fragment_object, fragment
+        end
+
+        def test_define_fragment_raises_exception_for_invalid_targets
+          document = Document.new(@schema)
+
+          assert_raises Document::INVALID_FRAGMENT_TARGET do
+            document.define_fragment('imageFields', on: 'String')
+          end
+        end
+
+        def test_fragment_definitions_is_the_fragments_definition_string
+          document = Document.new(@schema)
+
+          document.define_fragment('imageFields', on: 'Image') do |f|
+            f.add_field('src')
+          end
+
+          document.define_fragment('shopName', on: 'Shop') do |f|
+            f.add_field('name')
+          end
+
+          fragment_string = <<~QUERY
+            fragment imageFields on Image {
+              src
+            }
+
+            fragment shopName on Shop {
+              name
+            }
+          QUERY
+
+          assert_equal fragment_string, document.fragment_definitions
+        end
+
+        def test_to_query_joins_all_operations
+          document = Document.new(@schema) do |d|
+            d.add_query('shopQuery') do |q|
+              q.add_field('shop') do |shop|
+                shop.add_field('name')
+              end
+            end
+
+            d.add_mutation('customers') do |c|
+              c.add_field('customerCreate', input: { email: 'email', password: 'password' }) do |create|
+                create.add_field('customer') do |customer|
+                  customer.add_field('email')
+                end
+              end
+            end
+          end
+
+          query_string = <<~QUERY
+            query shopQuery {
+              shop {
+                name
+              }
+            }
+
+            mutation customers {
+              customerCreate(input: { email: \"email\", password: \"password\" }) {
+                customer {
+                  email
+                }
+              }
+            }
+          QUERY
+
+          assert_equal query_string, document.to_query
+          assert_valid_query query_string, @graphql_schema, operation_name: 'shopQuery'
+          assert_valid_query query_string, @graphql_schema, operation_name: 'customers'
+        end
+
+        def test_to_query_includes_fragment_definitions
+          document = Document.new(@schema) do |d|
+            d.define_fragment('imageFields', on: 'Image') do |f|
+              f.add_field('src')
+            end
+
+            d.add_query('getShop') do |q|
+              q.add_field('shop') do |shop|
+                shop.add_field('name')
+              end
+            end
+
+            d.add_query('getProductImages') do |q|
+              q.add_field('shop') do |shop|
+                shop.add_field('productByHandle', handle: 'test') do |product|
+                  product.add_connection('images', first: 10) do |connection|
+                    connection.add_fragment('imageFields')
+
+                    connection.add_inline_fragment do |f|
+                      f.add_field('altText')
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          query_string = <<~QUERY
+            fragment imageFields on Image {
+              src
+            }
+
+            query getShop {
+              shop {
+                name
+              }
+            }
+
+            query getProductImages {
+              shop {
+                productByHandle(handle: \"test\") {
+                  id
+                  images(first: 10) {
+                    edges {
+                      cursor
+                      node {
+                        ...imageFields
+                        ... on Image {
+                          altText
+                        }
+                      }
+                    }
+                    pageInfo {
+                      hasPreviousPage
+                      hasNextPage
+                    }
+                  }
+                }
+              }
+            }
+          QUERY
+
+          assert_equal query_string, document.to_query
+          assert_valid_query query_string, @graphql_schema, operation_name: 'getShop'
+        end
+      end
+    end
+  end
+end