graphlient 0.7.0 → 0.9.0

data/spec/graphlient/client_schema_spec.rb

@@ -1,55 +1,75 @@
-require 'spec_helper'
-require 'tempfile'
-
-describe Graphlient::Client do
-  let(:client) { described_class.new(url) }
-  let(:url) { 'http://graph.biz/graphql' }
-
-  describe '#schema' do
-    before do
-      stub_request(:post, url).to_return(
-        body: DummySchema.execute(GraphQL::Introspection::INTROSPECTION_QUERY).to_json,
-        headers: { 'Content-Type' => 'application/json' }
-      )
-    end
-
-    context 'when server returns error' do
-      before do
-        stub_request(:post, url).to_return(
-          status: 500,
-          body: {
-            errors: [
-              { message: 'test message', extensions: { code: 'SOMETHING', timestamp: Time.now } }
-            ]
-          }.to_json,
-          headers: { 'Content-Type' => 'application/json' }
-        )
-      end
-
-      it 'fails with an exception' do
-        expect do
-          client.schema
-        end.to raise_error Graphlient::Errors::FaradayServerError do |e|
-          expect(e.to_s).to eq 'the server responded with status 500'
-          expect(e.status_code).to eq 500
-          expect(e.response['errors'].size).to eq 1
-          expect(e.response['errors'].first['message']).to eq 'test message'
-        end
-      end
-    end
-
-    context 'when introspection request is sucessfull' do
-      it 'returns Graphlient::Schema instance' do
-        expect(client.schema).to be_a(Graphlient::Schema)
-      end
-    end
-
-    context 'when schema path option is not String' do
-      let(:client) { described_class.new(url, schema_path: Pathname.new('config/schema.json')) }
-
-      it 'converts path to string' do
-        expect(client.schema.path).to eq 'config/schema.json'
-      end
-    end
-  end
-end
+require 'spec_helper'
+require 'tempfile'
+
+describe Graphlient::Client do
+  let(:client) { described_class.new(url) }
+  let(:url) { 'http://graph.biz/graphql' }
+
+  describe '#schema' do
+    before do
+      stub_request(:post, url).to_return(
+        body: DummySchema.execute(GraphQL::Introspection::INTROSPECTION_QUERY).to_json,
+        headers: { 'Content-Type' => 'application/json' }
+      )
+    end
+
+    context 'when server returns error' do
+      before do
+        stub_request(:post, url).to_return(
+          status: 500,
+          body: {
+            errors: [
+              { message: 'test message', extensions: { code: 'SOMETHING', timestamp: Time.now } }
+            ]
+          }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        )
+      end
+
+      it 'fails with an exception' do
+        expect do
+          client.schema
+        end.to raise_error Graphlient::Errors::FaradayServerError do |e|
+          expect(e.to_s).to include('the server responded with status 500')
+          expect(e.status_code).to eq 500
+          expect(e.response['errors'].size).to eq 1
+          expect(e.response['errors'].first['message']).to eq 'test message'
+        end
+      end
+    end
+
+    context 'when introspection request is sucessfull' do
+      it 'returns Graphlient::Schema instance' do
+        expect(client.schema).to be_a(Graphlient::Schema)
+      end
+    end
+
+    context 'when schema path option is not String' do
+      let(:client) { described_class.new(url, schema_path: Pathname.new('config/schema.json')) }
+
+      it 'converts path to string' do
+        expect(client.schema.path).to eq 'config/schema.json'
+      end
+    end
+
+    context 'when preloaded schema is provided' do
+      let(:schema) { Graphlient::Schema.new(url, 'spec/support/fixtures/invoice_api.json') }
+      let(:client) { described_class.new(url, schema: schema) }
+
+      it 'returns the passed in schema' do
+        expect(client.schema).not_to be_nil
+        expect(client.schema).to eq(schema)
+      end
+    end
+
+    context 'when and a schema and a schema path are provided' do
+      let(:schema) { Graphlient::Schema.new(url, 'spec/support/fixtures/invoice_api.json') }
+      let(:client) { described_class.new(url, schema: schema, schema_path: 'spec/support/fixtures/invoice_api.json') }
+
+      it 'raises an invalid configuration error' do
+        expect { client }.to raise_error(Graphlient::Client::InvalidConfigurationError,
+                                         /schema_path and schema cannot both be provided/)
+      end
+    end
+  end
+end

data/spec/graphlient/extensions/query_spec.rb

@@ -1,16 +1,16 @@
-require 'spec_helper'
-
-describe Graphlient::Extensions::Query do
-  describe 'Query' do
-    include Graphlient::Extensions::Query
-
-    it 'returns correct query' do
-      query = query do
-        invoice(id: 10) do
-          line_items
-        end
-      end
-      expect(query.to_s).to eq("query{\n  invoice(id: 10){\n    line_items\n    }\n  }")
-    end
-  end
-end
+require 'spec_helper'
+
+describe Graphlient::Extensions::Query do
+  describe 'Query' do
+    include Graphlient::Extensions::Query
+
+    it 'returns correct query' do
+      query = query do
+        invoice(id: 10) do
+          line_items
+        end
+      end
+      expect(query.to_s).to eq("query{\n  invoice(id: 10){\n    line_items\n    }\n  }")
+    end
+  end
+end

data/spec/graphlient/github_query_spec.rb

@@ -1,32 +1,32 @@
-require 'spec_helper'
-
-describe Graphlient::Client do
-  include_context 'Github Client'
-
-  it 'has a schema', vcr: { cassette_name: 'github/schema' } do
-    expect(client.schema).to be_a Graphlient::Schema
-  end
-
-  it 'queries current user', vcr: { cassette_name: 'github/viewer' } do
-    rc = client.query <<-GRAPHQL
-      query {
-        viewer {
-          name
-        }
-      }
-    GRAPHQL
-    expect(rc.data.viewer.name).to eq 'Daniel Doubrovkine (dB.) @dblockdotorg'
-  end
-
-  it 'queries with a parameter', vcr: { cassette_name: 'github/user' } do
-    query = <<-GRAPHQL
-      query($login: String!) {
-        user(login: $login) {
-          name
-        }
-      }
-    GRAPHQL
-    rc = client.query query, login: 'orta'
-    expect(rc.data.user.name).to eq 'Orta'
-  end
-end
+require 'spec_helper'
+
+describe Graphlient::Client do
+  include_context 'Github Client'
+
+  it 'has a schema', vcr: { cassette_name: 'github/schema' } do
+    expect(client.schema).to be_a Graphlient::Schema
+  end
+
+  it 'queries current user', vcr: { cassette_name: 'github/viewer' } do
+    rc = client.query <<-GRAPHQL
+      query {
+        viewer {
+          name
+        }
+      }
+    GRAPHQL
+    expect(rc.data.viewer.name).to eq 'Daniel Doubrovkine (dB.) @dblockdotorg'
+  end
+
+  it 'queries with a parameter', vcr: { cassette_name: 'github/user' } do
+    query = <<-GRAPHQL
+      query($login: String!) {
+        user(login: $login) {
+          name
+        }
+      }
+    GRAPHQL
+    rc = client.query query, login: 'orta'
+    expect(rc.data.user.name).to eq 'Orta'
+  end
+end

data/spec/graphlient/query_dsl_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+# Specs for DSL extensions: directives, inline fragments, fragment definitions,
+# spread + directive, and custom scalar registration.
+# These operate on the Query string builder only -- no HTTP or schema access.
+
+RSpec.describe Graphlient::Query do
+  def build(&block)
+    described_class.new(&block).to_s
+  end
+
+  # --- Directives -----------------------------------------------------------
+
+  describe 'directives (_name convention → @name)' do
+    it 'applies @skip to a field' do
+      result = build do
+        query(skip_fee: :boolean!) do
+          invoice(id: 10) do
+            id
+            feeInCents _skip(if: :skip_fee)
+          end
+        end
+      end
+      expect(result).to include('@skip(if: $skip_fee)')
+      expect(result).to include('feeInCents @skip(if: $skip_fee)')
+    end
+
+    it 'applies @include to a field' do
+      result = build do
+        query(show_fee: :boolean!) do
+          invoice(id: 10) do
+            feeInCents _include(if: :show_fee)
+          end
+        end
+      end
+      expect(result).to include('feeInCents @include(if: $show_fee)')
+    end
+
+    it 'applies multiple directives to one field' do
+      result = build do
+        query(skip_fee: :boolean!, show_desc: :boolean!) do
+          invoice(id: 10) do
+            feeInCents _skip(if: :skip_fee), _include(if: :show_desc)
+          end
+        end
+      end
+      expect(result).to include('@skip(if: $skip_fee)')
+      expect(result).to include('@include(if: $show_desc)')
+    end
+
+    it 'applies a directive with no arguments' do
+      result = build do
+        query do
+          invoice(id: 10) do
+            id _deprecated
+          end
+        end
+      end
+      expect(result).to include('id @deprecated')
+    end
+
+    it 'does not confuse ___ fragment constant with a directive' do
+      result = build do
+        query do
+          invoice(id: 10) { id }
+        end
+      end
+      expect(result).not_to include('@__')
+    end
+  end
+
+  # --- Fragment spreads with directives ------------------------------------
+
+  describe 'spread with directive' do
+    it 'appends directive after the spread name' do
+      result = build do
+        query(skip_invoice: :boolean!) do
+          spread :InvoiceFields, _skip(if: :skip_invoice)
+        end
+      end
+      expect(result).to include('...InvoiceFields @skip(if: $skip_invoice)')
+    end
+
+    it 'spread without directive is unchanged' do
+      result = build do
+        query { spread :InvoiceFields }
+      end
+      expect(result).to include('...InvoiceFields')
+      expect(result).not_to include('@')
+    end
+  end
+
+  # --- Inline fragments ----------------------------------------------------
+
+  # Inline fragments use the same `spread` verb as named fragment spreads, with the
+  # `on:` keyword (the same keyword as `fragment(name, on:)`) — one consistent entry point.
+  describe 'spread(on: :Type) — inline fragment' do
+    it 'generates ... on Type { }' do
+      result = build do
+        query do
+          invoice(id: 10) do
+            spread(on: :PaidInvoice) do
+              amountPaid
+            end
+            spread(on: :UnpaidInvoice) do
+              amountDue
+            end
+          end
+        end
+      end
+      expect(result).to include('... on PaidInvoice')
+      expect(result).to include('amountPaid')
+      expect(result).to include('... on UnpaidInvoice')
+      expect(result).to include('amountDue')
+    end
+
+    it 'applies a directive on the inline fragment' do
+      result = build do
+        query(skip_draft: :boolean!) do
+          invoice(id: 10) do
+            spread(_skip(if: :skip_draft), on: :DraftInvoice) do
+              draftId
+            end
+          end
+        end
+      end
+      expect(result).to include('... on DraftInvoice @skip(if: $skip_draft)')
+      expect(result).to include('draftId')
+    end
+
+    it 'inline fragment without block (bare type condition)' do
+      result = build do
+        query { spread(on: :Invoice) }
+      end
+      expect(result).to include('... on Invoice')
+    end
+  end
+
+  # --- spread argument validation -----------------------------------------
+
+  describe 'spread requires a name or an inline type condition' do
+    it 'raises when given neither a fragment name nor on:' do
+      expect { build { query { spread } } }
+        .to raise_error(Graphlient::Errors::Error, /requires a fragment name/)
+    end
+
+    it 'raises when a named spread is given a block' do
+      expect { build { query { spread(:InvoiceFields) { id } } } }
+        .to raise_error(Graphlient::Errors::Error, /takes no block/)
+    end
+  end
+
+  # --- Fragment definitions ------------------------------------------------
+
+  describe 'fragment(:Name, on: :Type)' do
+    it 'appends the fragment definition after the main query' do
+      result = build do
+        fragment(:InvoiceFields, on: :Invoice) do
+          id
+          feeInCents
+        end
+        query do
+          invoice(id: 10) do
+            spread :InvoiceFields
+          end
+        end
+      end
+      expect(result).to include('...InvoiceFields')
+      expect(result).to include('fragment InvoiceFields on Invoice')
+      expect(result).to include('feeInCents')
+    end
+
+    it 'separates query and fragment with a blank line' do
+      result = build do
+        fragment(:F, on: :T) { id }
+        query { spread :F }
+      end
+      parts = result.split("\n\n")
+      expect(parts.length).to eq 2
+      expect(parts.last).to start_with('fragment F on T')
+    end
+
+    it 'supports multiple fragment definitions' do
+      result = build do
+        fragment(:FragA, on: :TypeA) { field_a }
+        fragment(:FragB, on: :TypeB) { field_b }
+        query do
+          spread :FragA
+          spread :FragB
+        end
+      end
+      expect(result).to include('fragment FragA on TypeA')
+      expect(result).to include('fragment FragB on TypeB')
+    end
+  end
+
+  # --- Custom scalar registration ------------------------------------------
+
+  describe 'custom scalar registration' do
+    before { described_class::Serializer.scalar(:date, 'Date') }
+
+    it 'uses the registered type in variable declarations' do
+      result = build do
+        query(created_after: :date) do
+          invoices(created_after: :created_after) { id }
+        end
+      end
+      # Variable names are not camelized -- snake_case keys output as-is
+      expect(result).to include('$created_after: Date')
+    end
+
+    it 'supports non-null custom scalars with !' do
+      result = build do
+        query(started_at: :date!) do
+          invoices(started_at: :started_at) { id }
+        end
+      end
+      expect(result).to include('$started_at: Date!')
+    end
+
+    it 'built-in scalars still work alongside custom ones' do
+      result = build do
+        query(id: :int, created_after: :date) do
+          invoice(id: :id) { id }
+        end
+      end
+      expect(result).to include('$id: Int')
+      expect(result).to include('$created_after: Date')
+    end
+  end
+end

data/spec/graphlient/query_spec.rb

@@ -1,105 +1,105 @@
-require 'spec_helper'
-
-describe Graphlient::Query do
-  describe '#initialize' do
-    context 'query' do
-      it 'returns expected query with block' do
-        query = Graphlient::Query.new do
-          query do
-            invoice do
-              line_items
-            end
-          end
-        end
-        expect(query.to_s).to eq "query{\n  invoice{\n    line_items\n    }\n  }"
-      end
-
-      it 'returns expected query with block and attributes' do
-        query = Graphlient::Query.new do
-          query do
-            invoice(id: 10) do
-              line_items
-            end
-          end
-        end
-        expect(query.to_s).to eq "query{\n  invoice(id: 10){\n    line_items\n    }\n  }"
-      end
-
-      it 'returns expected query with block and attributes' do
-        query = Graphlient::Query.new do
-          query do
-            invoice(id: 10) do
-              line_items(name: 'test')
-            end
-          end
-        end
-        expect(query.to_s).to eq "query{\n  invoice(id: 10){\n    line_items(name: \"test\")\n    }\n  }"
-      end
-
-      it 'returns expected query with block and local variables with proper type' do
-        int_arg = 10
-        float_arg = 10.3
-        str_arg = 'new name'
-        array_arg = ['str_item', 2]
-        query = Graphlient::Query.new do
-          query do
-            invoice(id: int_arg, threshold: float_arg, item_list: array_arg) do
-              line_items(name: str_arg)
-            end
-          end
-        end
-        expect(query.to_s).to eq "query{\n  invoice(id: 10, threshold: 10.3, item_list: [\"str_item\", 2]){\n    line_items(name: \"new name\")\n    }\n  }"
-      end
-
-      it 'returns proper query' do
-        query = Graphlient::Query.new do
-          query do
-            invoice(id: 10) do
-              line_items do
-                line_item_type
-              end
-            end
-          end
-        end
-        expect(query.to_s).to eq "query{\n  invoice(id: 10){\n    line_items{\n      line_item_type\n      }\n    }\n  }"
-      end
-
-      it 'returns proper query with query variables' do
-        query = Graphlient::Query.new do
-          query(invoice_id: :int, names: [:string!]) do
-            invoice(id: :invoice_id, name: :names) do
-              line_items do
-                line_item_type
-              end
-            end
-          end
-        end
-        expect(query.to_s).to eq "query($invoice_id: Int, $names: [String!]){\n  invoice(id: $invoice_id, name: $names){\n    line_items{\n      line_item_type\n      }\n    }\n  }"
-      end
-    end
-
-    context 'mutation' do
-      it 'returns proper mutation with arguments' do
-        mutation = Graphlient::Query.new do
-          mutation do
-            invoice(type: 'test', fee_in_cents: 20_000, total_cents: 50_000, line_items: %w[li1 li2]) do
-              id
-            end
-          end
-        end
-        expect(mutation.to_s).to eq "mutation{\n  invoice(type: \"test\", fee_in_cents: 20000, total_cents: 50000, line_items: [\"li1\", \"li2\"]){\n    id\n    }\n  }"
-      end
-    end
-
-    it 'returns proper mutation for relay style mutation' do
-      mutation = Graphlient::Query.new do
-        mutation do
-          invoice(input: { type: 'test', fee_in_cents: 20_000, total_cents: 50_000, line_items: %w[li1 li2] }) do
-            id
-          end
-        end
-      end
-      expect(mutation.to_s).to eq "mutation{\n  invoice(input: { type: \"test\", fee_in_cents: 20000, total_cents: 50000, line_items: [\"li1\", \"li2\"] }){\n    id\n    }\n  }"
-    end
-  end
-end
+require 'spec_helper'
+
+describe Graphlient::Query do
+  describe '#initialize' do
+    context 'query' do
+      it 'returns expected query with block' do
+        query = Graphlient::Query.new do
+          query do
+            invoice do
+              line_items
+            end
+          end
+        end
+        expect(query.to_s).to eq "query{\n  invoice{\n    line_items\n    }\n  }"
+      end
+
+      it 'returns expected query with block and attributes' do
+        query = Graphlient::Query.new do
+          query do
+            invoice(id: 10) do
+              line_items
+            end
+          end
+        end
+        expect(query.to_s).to eq "query{\n  invoice(id: 10){\n    line_items\n    }\n  }"
+      end
+
+      it 'returns expected query with block and attributes' do
+        query = Graphlient::Query.new do
+          query do
+            invoice(id: 10) do
+              line_items(name: 'test')
+            end
+          end
+        end
+        expect(query.to_s).to eq "query{\n  invoice(id: 10){\n    line_items(name: \"test\")\n    }\n  }"
+      end
+
+      it 'returns expected query with block and local variables with proper type' do
+        int_arg = 10
+        float_arg = 10.3
+        str_arg = 'new name'
+        array_arg = ['str_item', 2]
+        query = Graphlient::Query.new do
+          query do
+            invoice(id: int_arg, threshold: float_arg, item_list: array_arg) do
+              line_items(name: str_arg)
+            end
+          end
+        end
+        expect(query.to_s).to eq "query{\n  invoice(id: 10, threshold: 10.3, item_list: [\"str_item\", 2]){\n    line_items(name: \"new name\")\n    }\n  }"
+      end
+
+      it 'returns proper query' do
+        query = Graphlient::Query.new do
+          query do
+            invoice(id: 10) do
+              line_items do
+                line_item_type
+              end
+            end
+          end
+        end
+        expect(query.to_s).to eq "query{\n  invoice(id: 10){\n    line_items{\n      line_item_type\n      }\n    }\n  }"
+      end
+
+      it 'returns proper query with query variables' do
+        query = Graphlient::Query.new do
+          query(invoice_id: :int, names: [:string!]) do
+            invoice(id: :invoice_id, name: :names) do
+              line_items do
+                line_item_type
+              end
+            end
+          end
+        end
+        expect(query.to_s).to eq "query($invoice_id: Int, $names: [String!]){\n  invoice(id: $invoice_id, name: $names){\n    line_items{\n      line_item_type\n      }\n    }\n  }"
+      end
+    end
+
+    context 'mutation' do
+      it 'returns proper mutation with arguments' do
+        mutation = Graphlient::Query.new do
+          mutation do
+            invoice(type: 'test', fee_in_cents: 20_000, total_cents: 50_000, line_items: %w[li1 li2]) do
+              id
+            end
+          end
+        end
+        expect(mutation.to_s).to eq "mutation{\n  invoice(type: \"test\", fee_in_cents: 20000, total_cents: 50000, line_items: [\"li1\", \"li2\"]){\n    id\n    }\n  }"
+      end
+    end
+
+    it 'returns proper mutation for relay style mutation' do
+      mutation = Graphlient::Query.new do
+        mutation do
+          invoice(input: { type: 'test', fee_in_cents: 20_000, total_cents: 50_000, line_items: %w[li1 li2] }) do
+            id
+          end
+        end
+      end
+      expect(mutation.to_s).to eq "mutation{\n  invoice(input: { type: \"test\", fee_in_cents: 20000, total_cents: 50000, line_items: [\"li1\", \"li2\"] }){\n    id\n    }\n  }"
+    end
+  end
+end