graphql_client 0.3.3

data/test/graphql_client/query/field_test.rb

@@ -0,0 +1,163 @@
+require 'test_helper'
+
+module GraphQL
+  module Client
+    module Query
+      class FieldTest < Minitest::Test
+        def setup
+          @schema = GraphQLSchema.new(schema_fixture('schema.json'))
+          @document = Document.new(@schema)
+        end
+
+        def test_validates_arguments
+          field_defn = @schema.query_root.field('shop')
+
+          assert_raises Field::INVALID_ARGUMENTS do
+            Field.new(field_defn, document: @document, arguments: { id: 2 })
+          end
+        end
+
+        def test_add_arguments_merges_new_arguments_with_existing_ones
+          shop = @schema.query_root.field('shop')
+          products_defn = schema_type(shop.type).field('products')
+          field = Field.new(products_defn, document: @document, arguments: { first: 5 })
+
+          field.add_arguments(first: 10, after: 'cursor')
+
+          first_arg = Argument.new(10)
+          after_arg = Argument.new('cursor')
+
+          assert_equal({ first: first_arg, after: after_arg }, field.arguments)
+        end
+
+        def test_add_field_creates_field_and_adds_to_selection_set
+          field_defn = @schema.query_root.field('shop')
+          field = Field.new(field_defn, document: @document, arguments: {})
+
+          name = field.add_field('name')
+
+          assert_equal({ 'name' => name }, field.selection_set.fields)
+        end
+
+        def test_add_field_does_not_add_duplicate_fields
+          field_defn = @schema.query_root.field('shop')
+          field = Field.new(field_defn, document: @document, arguments: {})
+
+          field.add_field('name')
+          new_name = field.add_field('name')
+
+          assert_equal({ 'name' => new_name }, field.selection_set.fields)
+        end
+
+        def test_add_field_allows_multiple_fields_of_same_type_with_aliases
+          field_defn = @schema.query_root.field('shop')
+          field = Field.new(field_defn, document: @document, arguments: {})
+
+          name = field.add_field('name')
+          myname = field.add_field('name', as: 'myname')
+
+          assert_equal({ 'name' => name, 'myname' => myname }, field.selection_set.fields)
+        end
+
+        def test_add_fields_creates_multiple_fields
+          field_defn = @schema.query_root.field('shop')
+          field = Field.new(field_defn, document: @document, arguments: {})
+
+          field.add_fields('name', 'termsOfService')
+
+          assert_equal %w(name termsOfService), field.selection_set.fields.keys
+        end
+
+        def test_add_field_uses_as_alias_name
+          field_defn = @schema.query_root.field('shop')
+          field = Field.new(field_defn, document: @document, arguments: {}, as: 'myshop')
+
+          field.add_field('name')
+
+          query_string = <<~QUERY
+            myshop: shop {
+              name
+            }
+          QUERY
+
+          assert_equal query_string.chomp, field.to_query
+        end
+
+        def test_name_returns_alias_if_set
+          field_defn = @schema.query_root.field('shop')
+          field = Field.new(field_defn, document: @document, as: 'myshop')
+
+          assert_equal 'myshop', field.name
+        end
+
+        def test_name_defaults_to_field_name
+          field_defn = @schema.query_root.field('shop')
+          field = Field.new(field_defn, document: @document)
+
+          assert_equal 'shop', field.name
+        end
+
+        def test_resolver_type_is_the_fields_base_type
+          field_defn = @schema.query_root.field('shop')
+          field = Field.new(field_defn, document: @document, arguments: {})
+
+          assert_equal schema_type(field_defn.type), field.resolver_type
+        end
+
+        def test_to_query_is_the_graphql_query_string
+          field_defn = @schema.query_root.field('shop')
+          field = Field.new(field_defn, document: @document, arguments: {})
+
+          assert_equal 'shop', field.to_query
+        end
+
+        def test_to_query_includes_the_selection_set_selection_set
+          field_defn = @schema.query_root.field('shop')
+          field = Field.new(field_defn, document: @document, arguments: {})
+
+          field.add_field('name')
+
+          query_string = <<~QUERY
+            shop {
+              name
+            }
+          QUERY
+
+          assert_equal query_string.chomp, field.to_query
+        end
+
+        def test_to_query_includes_arguments
+          field_defn = @schema.query_root.field('shop')
+
+          shop = Field.new(field_defn, document: @document)
+          shop.add_field('name')
+
+          shop.add_connection('products', first: 5, after: 'cursor') do |products|
+            products.add_field('title')
+          end
+
+          query_string = <<~QUERY
+            shop {
+              name
+              products(first: 5, after: "cursor") {
+                edges {
+                  cursor
+                  node {
+                    id
+                    title
+                  }
+                }
+                pageInfo {
+                  hasPreviousPage
+                  hasNextPage
+                }
+              }
+            }
+          QUERY
+
+          assert_equal query_string.chomp, shop.to_query
+        end
+      end
+    end
+  end
+end

data/test/graphql_client/query/fragment_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+module GraphQL
+  module Client
+    module Query
+      class FragmentTest < Minitest::Test
+        def setup
+          @schema = GraphQLSchema.new(schema_fixture('schema.json'))
+          @document = Document.new(@schema)
+        end
+
+        def test_resolver_type_is_the_type
+          shop = @schema.type('Shop')
+          fragment = Fragment.new('shopFields', shop, document: @document)
+
+          assert_equal shop, fragment.resolver_type
+        end
+
+        def test_to_definition
+          shop = @schema.type('Shop')
+          fragment = Fragment.new('shopFields', shop, document: @document)
+          fragment.add_field('name')
+
+          definition_string = <<~QUERY
+            fragment shopFields on Shop {
+              name
+            }
+          QUERY
+
+          assert_equal definition_string, fragment.to_definition
+        end
+
+        def test_to_query_is_the_fragment_spread
+          shop = @schema.type('Shop')
+
+          fragment = Fragment.new('shopFields', shop, document: @document) do |f|
+            f.add_field('name')
+          end
+
+          assert_equal '...shopFields', fragment.to_query
+        end
+      end
+    end
+  end
+end

data/test/graphql_client/query/inline_fragment_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+module GraphQL
+  module Client
+    module Query
+      class InlineFragmentTest < Minitest::Test
+        def setup
+          @schema = GraphQLSchema.new(schema_fixture('schema.json'))
+          @document = Document.new(@schema)
+        end
+
+        def test_resolver_type_is_the_type
+          shop = @schema.type('Shop')
+          inline_fragment = InlineFragment.new(shop, document: @document)
+
+          assert_equal shop, inline_fragment.resolver_type
+        end
+
+        def test_to_query
+          shop = @schema.type('Shop')
+
+          inline_fragment = InlineFragment.new(shop, document: @document) do |f|
+            f.add_field('name')
+          end
+
+          query_string = <<~QUERY
+            ... on Shop {
+              name
+            }
+          QUERY
+
+          assert_equal query_string.chomp, inline_fragment.to_query
+        end
+      end
+    end
+  end
+end

data/test/graphql_client/query/mutation_document_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+module GraphQL
+  module Client
+    module Query
+      class QueryDocumentTest < Minitest::Test
+        def setup
+          @schema = GraphQLSchema.new(schema_fixture('schema.json'))
+        end
+
+        def test_new_creates_a_document_with_a_mutation_operation
+          mutation_operation = MutationDocument.new(@schema)
+
+          assert_equal mutation_operation, mutation_operation.document.operations['default']
+          assert_instance_of MutationOperation, mutation_operation
+        end
+
+        def test_new_yields_mutation_operation
+          mutation_operation_object = nil
+
+          mutation_operation = MutationDocument.new(@schema) do |q|
+            mutation_operation_object = q
+          end
+
+          assert_equal mutation_operation_object, mutation_operation
+        end
+      end
+    end
+  end
+end

data/test/graphql_client/query/mutation_operation_test.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+module GraphQL
+  module Client
+    module Query
+      class MutationOperationTest < 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 = Document.new(@schema)
+          query_object = nil
+
+          query = MutationOperation.new(document) do |q|
+            query_object = q
+          end
+
+          assert_equal query_object, query
+        end
+
+        def test_resolver_type_is_the_schemas_mutation_root
+          mock_schema = Minitest::Mock.new
+          document = Document.new(mock_schema)
+
+          query = MutationOperation.new(document)
+
+          mock_schema.expect(:mutation_root_name, 'mutationRoot')
+          mock_schema.expect(:type, nil, ['mutationRoot'])
+
+          query.resolver_type
+
+          assert mock_schema.verify
+        end
+
+        def test_to_query_handles_multiple_nested_selection_set
+          document = Document.new(@schema)
+
+          query = MutationOperation.new(document) do |q|
+            q.add_field('customerCreate', input: { email: 'email', password: 'password' }) do |mutation|
+              mutation.add_field('customer') do |customer|
+                customer.add_field('email')
+              end
+            end
+          end
+
+          query_string = <<~QUERY
+            mutation {
+              customerCreate(input: { email: "email", password: "password" }) {
+                customer {
+                  email
+                }
+              }
+            }
+          QUERY
+
+          assert_equal query_string, query.to_query
+          assert_valid_query query_string, @graphql_schema
+        end
+
+        def test_to_query_handles_variables
+          document = Document.new(@schema)
+
+          query = MutationOperation.new(document, variables: { email: 'String!' }) do |q|
+            q.add_field('customerCreate', input: { email: '$email', password: 'password' }) do |mutation|
+              mutation.add_field('customer') do |customer|
+                customer.add_field('email')
+              end
+            end
+          end
+
+          query_string = <<~QUERY
+            mutation($email: String!) {
+              customerCreate(input: { email: $email, password: \"password\" }) {
+                customer {
+                  email
+                }
+              }
+            }
+          QUERY
+
+          assert_equal query_string, query.to_query
+          assert_valid_query query_string, @graphql_schema, variables: { 'email' => 'email' }
+        end
+      end
+    end
+  end
+end

data/test/graphql_client/query/query_document_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+module GraphQL
+  module Client
+    module Query
+      class QueryDocumentTest < Minitest::Test
+        def setup
+          @schema = GraphQLSchema.new(schema_fixture('schema.json'))
+        end
+
+        def test_new_creates_a_document_with_a_query_operation
+          query_operation = QueryDocument.new(@schema)
+
+          assert_equal query_operation, query_operation.document.operations['default']
+          assert_instance_of QueryOperation, query_operation
+        end
+
+        def test_new_yields_query_operation
+          query_operation_object = nil
+
+          query_operation = QueryDocument.new(@schema) do |q|
+            query_operation_object = q
+          end
+
+          assert_equal query_operation_object, query_operation
+        end
+      end
+    end
+  end
+end

data/test/graphql_client/query/query_operation_test.rb

@@ -0,0 +1,262 @@
+require 'test_helper'
+
+module GraphQL
+  module Client
+    module Query
+      class QueryOperationTest < 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
+          query_object = nil
+          document = Document.new(@schema)
+
+          query = QueryOperation.new(document) do |q|
+            query_object = q
+          end
+
+          assert_equal query_object, query
+        end
+
+        def test_resolver_type_is_the_schemas_query_root
+          mock_schema = Minitest::Mock.new
+          document = Document.new(mock_schema)
+          query = QueryOperation.new(document)
+
+          mock_schema.expect(:query_root_name, 'queryRoot')
+          mock_schema.expect(:type, nil, ['queryRoot'])
+
+          query.resolver_type
+
+          assert mock_schema.verify
+        end
+
+        def test_to_query_with_a_single_query_field
+          document = Document.new(@schema)
+
+          query = QueryOperation.new(document) do |q|
+            q.add_field('shop') do |s|
+              s.add_field('productByHandle', handle: "test") do |product|
+                product.add_field('title')
+              end
+            end
+          end
+
+          query_string = <<~QUERY
+            query {
+              shop {
+                productByHandle(handle: "test") {
+                  id
+                  title
+                }
+              }
+            }
+          QUERY
+
+          assert_equal query_string, query.to_query
+          assert_valid_query query_string, @graphql_schema
+        end
+
+        def test_to_query_with_a_field_alias
+          document = Document.new(@schema)
+
+          query = QueryOperation.new(document) do |q|
+            q.add_field('shop') do |s|
+              s.add_field('productByHandle', handle: 'test', as: 'userProduct') do |product|
+                product.add_field('title')
+              end
+            end
+          end
+
+          query_string = <<~QUERY
+            query {
+              shop {
+                userProduct: productByHandle(handle: \"test\") {
+                  id
+                  title
+                }
+              }
+            }
+          QUERY
+
+          assert_equal query_string, query.to_query
+          assert_valid_query query_string, @graphql_schema
+        end
+
+        def test_to_query_handles_multiple_nested_query_fields
+          document = Document.new(@schema)
+
+          query = QueryOperation.new(document) do |q|
+
+            q.add_field('shop') do |shop|
+              shop.add_field('name')
+
+              shop.add_field('privacyPolicy') do |policy|
+                policy.add_field('body')
+              end
+
+              shop.add_field('productByHandle', handle: 'test') do |product|
+                product.add_field('title')
+              end
+            end
+          end
+
+          query_string = <<~QUERY
+            query {
+              shop {
+                name
+                privacyPolicy {
+                  id
+                  body
+                }
+                productByHandle(handle: "test") {
+                  id
+                  title
+                }
+              }
+            }
+          QUERY
+
+          assert_equal query_string, query.to_query
+          assert_valid_query query_string, @graphql_schema
+        end
+
+        def test_to_query_handles_add_fields
+          document = Document.new(@schema)
+
+          query = QueryOperation.new(document) do |q|
+            q.add_field('shop') do |shop|
+              shop.add_field('name')
+
+              shop.add_field('productByHandle', handle: 'test') do |product|
+                product.add_field('title')
+              end
+            end
+          end
+
+          query_string = <<~QUERY
+            query {
+              shop {
+                name
+                productByHandle(handle: "test") {
+                  id
+                  title
+                }
+              }
+            }
+          QUERY
+
+          assert_equal query_string, query.to_query
+          assert_valid_query query_string, @graphql_schema
+        end
+
+        def test_to_query_handles_connections
+          document = Document.new(@schema)
+
+          query = QueryOperation.new(document) do |q|
+            q.add_field('shop') do |s|
+              s.add_field('productByHandle', handle: 'test') do |product|
+                product.add_connection('images', first: 10) do |connection|
+                  connection.add_field('src')
+                end
+              end
+            end
+          end
+
+          query_string = <<~QUERY
+            query {
+              shop {
+                productByHandle(handle: \"test\") {
+                  id
+                  images(first: 10) {
+                    edges {
+                      cursor
+                      node {
+                        src
+                      }
+                    }
+                    pageInfo {
+                      hasPreviousPage
+                      hasNextPage
+                    }
+                  }
+                }
+              }
+            }
+          QUERY
+
+          assert_equal query_string, query.to_query
+          assert_valid_query query_string, @graphql_schema
+        end
+
+        def test_to_query_adds_node_id_if_type_implements_node
+          document = Document.new(@schema)
+
+          query = QueryOperation.new(document) do |q|
+            q.add_field('shop') do |s|
+              s.add_field('productByHandle', handle: 'test') do |product|
+                product.add_connection('variants', first: 10) do |connection|
+                  connection.add_field('title')
+                end
+              end
+            end
+          end
+
+          query_string = <<~QUERY
+            query {
+              shop {
+                productByHandle(handle: \"test\") {
+                  id
+                  variants(first: 10) {
+                    edges {
+                      cursor
+                      node {
+                        id
+                        title
+                      }
+                    }
+                    pageInfo {
+                      hasPreviousPage
+                      hasNextPage
+                    }
+                  }
+                }
+              }
+            }
+          QUERY
+
+          assert_equal query_string, query.to_query
+          assert_valid_query query_string, @graphql_schema
+        end
+
+        def test_to_query_handles_variables
+          document = Document.new(@schema)
+
+          query = QueryOperation.new(document, variables: { productHandle: 'String!' }) do |q|
+            q.add_field('shop') do |shop|
+              shop.add_field('productByHandle', handle: '$productHandle') do |product|
+                product.add_field('title')
+              end
+            end
+          end
+
+          query_string = <<~QUERY
+            query($productHandle: String!) {
+              shop {
+                productByHandle(handle: $productHandle) {
+                  id
+                  title
+                }
+              }
+            }
+          QUERY
+
+          assert_equal query_string, query.to_query
+          assert_valid_query query_string, @graphql_schema, variables: { 'productHandle' => 'test' }
+        end
+      end
+    end
+  end
+end