graphlient 0.7.0 → 0.9.0

data/spec/graphlient/adapters/http/faraday_adapter_spec.rb

@@ -1,112 +1,172 @@
-require 'spec_helper'
-
-describe Graphlient::Adapters::HTTP::FaradayAdapter do
-  let(:app) { Object.new }
-
-  context 'with a custom middleware' do
-    let(:client) do
-      Graphlient::Client.new('http://example.com/graphql') do |client|
-        client.http do |h|
-          h.connection do |c|
-            c.adapter Faraday::Adapter::Rack, app
-          end
-        end
-      end
-    end
-
-    it 'inserts a middleware into the connection' do
-      expect(client.http.connection.adapter).to eq Faraday::Adapter::Rack
-      expect(client.http.connection.builder.handlers).to eq(
-        [
-          Faraday::Response::RaiseError,
-          Faraday::Request::Json,
-          Faraday::Response::Json
-        ]
-      )
-    end
-  end
-
-  context 'with custom url, headers and http_options' do
-    let(:url) { 'http://example.com/graphql' }
-    let(:headers) { { 'Foo' => 'bar' } }
-    let(:http_options) { { timeout: timeout, write_timeout: write_timeout } }
-    let(:timeout) { 123 }
-    let(:write_timeout) { 234 }
-    let(:client) do
-      Graphlient::Client.new(url, headers: headers, http_options: http_options)
-    end
-
-    it 'sets url' do
-      expect(client.http.url).to eq url
-    end
-
-    it 'sets headers' do
-      expect(client.http.headers).to eq headers
-    end
-
-    it 'sets http_options' do
-      expect(client.http.connection.options.timeout).to eq(timeout)
-      expect(client.http.connection.options.write_timeout).to eq(write_timeout)
-    end
-
-    context 'when http_options contains invalid option' do
-      let(:http_options) { { an_invalid_option: 'an invalid option' } }
-
-      it 'raises Graphlient::Errors::HttpOptionsError' do
-        expect { client.http.connection }.to raise_error(Graphlient::Errors::HttpOptionsError)
-      end
-    end
-  end
-
-  context 'default' do
-    let(:url) { 'http://example.com/graphql' }
-    let(:client) { Graphlient::Client.new(url) }
-
-    before do
-      stub_request(:post, url).to_return(
-        status: 200,
-        body: DummySchema.execute(GraphQL::Introspection::INTROSPECTION_QUERY).to_json,
-        headers: { 'Content-Type' => 'application/json' }
-      )
-    end
-
-    it 'retrieves schema' do
-      expect(client.schema).to be_a Graphlient::Schema
-    end
-  end
-
-  context 'Failed to open TCP connection error' do
-    let(:url) { 'http://example.com/graphql' }
-    let(:client) { Graphlient::Client.new(url) }
-    let(:error_message) do
-      'Failed to open TCP connection to localhost:3000 (Connection refused - connect(2) for "localhost" port 3000)'
-    end
-
-    before do
-      wrapped_error = Errno::ECONNREFUSED.new(error_message)
-      error = Faraday::ConnectionFailed.new(wrapped_error)
-
-      stub_request(:post, url).to_raise(error)
-    end
-
-    specify do
-      expected_error_message = "Connection refused - #{error_message}"
-      expect { client.schema }.to raise_error(Graphlient::Errors::ConnectionFailedError, expected_error_message)
-    end
-  end
-
-  context 'Faraday Timeout Error' do
-    let(:url) { 'http://example.com/graphql' }
-    let(:client) { Graphlient::Client.new(url) }
-    let(:error_message) { 'Failed to Connect' }
-
-    before do
-      stub_request(:post, url).to_raise(Faraday::TimeoutError.new(Net::ReadTimeout.new(error_message)))
-    end
-    it 'raises a Graphlient Timeout' do
-      expect { client.schema }.to raise_error(Graphlient::Errors::TimeoutError) { |error|
-        expect(error.message).to include(error_message)
-      }
-    end
-  end
-end
+require 'spec_helper'
+
+describe Graphlient::Adapters::HTTP::FaradayAdapter do
+  let(:app) { Object.new }
+
+  context 'with a custom middleware' do
+    let(:client) do
+      Graphlient::Client.new('http://example.com/graphql') do |client|
+        client.http do |h|
+          h.connection do |c|
+            c.adapter Faraday::Adapter::Rack, app
+          end
+        end
+      end
+    end
+
+    it 'inserts a middleware into the connection' do
+      expect(client.http.connection.adapter).to eq Faraday::Adapter::Rack
+      expect(client.http.connection.builder.handlers).to eq(
+        [
+          Faraday::Response::RaiseError,
+          Faraday::Request::Json,
+          Faraday::Response::Json
+        ]
+      )
+    end
+  end
+
+  context 'with custom url, headers and http_options' do
+    let(:url) { 'http://example.com/graphql' }
+    let(:headers) { { 'Foo' => 'bar' } }
+    let(:http_options) { { timeout: timeout, write_timeout: write_timeout } }
+    let(:timeout) { 123 }
+    let(:write_timeout) { 234 }
+    let(:client) do
+      Graphlient::Client.new(url, headers: headers, http_options: http_options)
+    end
+
+    it 'sets url' do
+      expect(client.http.url).to eq url
+    end
+
+    it 'sets headers' do
+      expect(client.http.headers).to eq headers
+    end
+
+    it 'sets http_options' do
+      expect(client.http.connection.options.timeout).to eq(timeout)
+      expect(client.http.connection.options.write_timeout).to eq(write_timeout)
+    end
+
+    context 'when http_options contains invalid option' do
+      let(:http_options) { { an_invalid_option: 'an invalid option' } }
+
+      it 'raises Graphlient::Errors::HttpOptionsError' do
+        expect { client.http.connection }.to raise_error(Graphlient::Errors::HttpOptionsError)
+      end
+    end
+  end
+
+  context 'default' do
+    let(:url) { 'http://example.com/graphql' }
+    let(:client) { Graphlient::Client.new(url) }
+
+    before do
+      stub_request(:post, url).to_return(
+        status: 200,
+        body: DummySchema.execute(GraphQL::Introspection::INTROSPECTION_QUERY).to_json,
+        headers: { 'Content-Type' => 'application/json' }
+      )
+    end
+
+    it 'retrieves schema' do
+      expect(client.schema).to be_a Graphlient::Schema
+    end
+  end
+
+  context 'a non-error response without an appropriate JSON header' do
+    let(:url) { 'http://example.com/graphql' }
+    let(:headers) { { 'Content-Type' => 'application/notjson' } }
+    let(:client) { Graphlient::Client.new(url) }
+    let(:response_headers) { { 'Content-Type' => 'application/notjson' } }
+
+    context 'when the response body is valid JSON' do
+      before do
+        stub_request(:post, url).to_return(
+          status: 200,
+          headers: response_headers,
+          body: DummySchema.execute(GraphQL::Introspection::INTROSPECTION_QUERY).to_json
+        )
+      end
+
+      it 'retrieves schema' do
+        expect(client.schema).to be_a Graphlient::Schema
+      end
+    end
+
+    context 'when the response body is not valid JSON' do
+      before do
+        stub_request(:post, url).to_return(
+          status: 200,
+          headers: response_headers,
+          body: ''
+        )
+      end
+
+      it 'raises Graphlient::Errors::ServerError' do
+        expect { client.schema }.to raise_error(Graphlient::Errors::ServerError) { |error|
+          expect(error.message).to include('Failed to parse response body as JSON')
+        }
+      end
+    end
+
+    context 'when the Faraday response body object is not a type we expect from Faraday' do
+      before do
+        stub_request(:post, url).to_return(
+          status: 200,
+          headers: response_headers
+        )
+      end
+
+      it 'raises Graphlient::Errors::ClientError' do
+        mock_response = double('response', body: nil)
+        allow(client.http.connection).to receive(:post).and_return(mock_response)
+
+        expect { client.schema }.to raise_error(Graphlient::Errors::ClientError) { |error|
+          expect(error.message).to include "Unexpected response body type 'NilClass'"
+        }
+      end
+    end
+  end
+
+  context 'Failed to open TCP connection error' do
+    let(:url) { 'http://example.com/graphql' }
+    let(:client) { Graphlient::Client.new(url) }
+    let(:error_message) do
+      'Failed to open TCP connection to localhost:3000 (Connection refused - connect(2) for "localhost" port 3000)'
+    end
+
+    before do
+      wrapped_error = Errno::ECONNREFUSED.new(error_message)
+      error = Faraday::ConnectionFailed.new(wrapped_error)
+
+      stub_request(:post, url).to_raise(error)
+    end
+
+    specify do
+      # Use a regex so the test passes on both Linux ("Connection refused - ...")
+      # and Windows (where Errno::ECONNREFUSED prepends a different OS message).
+      # Both platforms include the core error_message string in the result.
+      expect { client.schema }.to raise_error(
+        Graphlient::Errors::ConnectionFailedError,
+        /#{Regexp.escape(error_message)}/
+      )
+    end
+  end
+
+  context 'Faraday Timeout Error' do
+    let(:url) { 'http://example.com/graphql' }
+    let(:client) { Graphlient::Client.new(url) }
+    let(:error_message) { 'Failed to Connect' }
+
+    before do
+      stub_request(:post, url).to_raise(Faraday::TimeoutError.new(Net::ReadTimeout.new(error_message)))
+    end
+    it 'raises a Graphlient Timeout' do
+      expect { client.schema }.to raise_error(Graphlient::Errors::TimeoutError) { |error|
+        expect(error.message).to include(error_message)
+      }
+    end
+  end
+end

data/spec/graphlient/adapters/http/http_adapter_spec.rb

@@ -1,60 +1,60 @@
-require 'spec_helper'
-
-describe Graphlient::Adapters::HTTP::HTTPAdapter do
-  let(:app) { Object.new }
-
-  context 'with custom url, headers and http_options' do
-    let(:url) { 'http://example.com/graphql' }
-    let(:headers) { { 'Foo' => 'bar' } }
-    let(:http_options) { { read_timeout: read_timeout } }
-    let(:read_timeout) { nil }
-    let(:client) do
-      Graphlient::Client.new(
-        url,
-        headers: headers,
-        http_options: http_options,
-        http: Graphlient::Adapters::HTTP::HTTPAdapter
-      )
-    end
-
-    it 'sets adapter' do
-      expect(client.http).to be_a Graphlient::Adapters::HTTP::HTTPAdapter
-    end
-
-    it 'sets url' do
-      expect(client.http.url).to eq url
-    end
-
-    it 'sets headers' do
-      expect(client.http.headers).to eq headers
-    end
-
-    it 'sets http_options' do
-      expect(client.http.connection.read_timeout).to eq(read_timeout)
-    end
-
-    context 'when http_options contains invalid option' do
-      let(:http_options) { { an_invalid_option: 'an invalid option' } }
-
-      it 'raises Graphlient::Errors::HttpOptionsError' do
-        expect { client.http.connection }.to raise_error(Graphlient::Errors::HttpOptionsError)
-      end
-    end
-  end
-
-  context 'default' do
-    let(:url) { 'http://example.com/graphql' }
-    let(:client) { Graphlient::Client.new(url, http: Graphlient::Adapters::HTTP::HTTPAdapter) }
-
-    before do
-      stub_request(:post, url).to_return(
-        status: 200,
-        body: DummySchema.execute(GraphQL::Introspection::INTROSPECTION_QUERY).to_json
-      )
-    end
-
-    it 'retrieves schema' do
-      expect(client.schema).to be_a Graphlient::Schema
-    end
-  end
-end
+require 'spec_helper'
+
+describe Graphlient::Adapters::HTTP::HTTPAdapter do
+  let(:app) { Object.new }
+
+  context 'with custom url, headers and http_options' do
+    let(:url) { 'http://example.com/graphql' }
+    let(:headers) { { 'Foo' => 'bar' } }
+    let(:http_options) { { read_timeout: read_timeout } }
+    let(:read_timeout) { nil }
+    let(:client) do
+      Graphlient::Client.new(
+        url,
+        headers: headers,
+        http_options: http_options,
+        http: Graphlient::Adapters::HTTP::HTTPAdapter
+      )
+    end
+
+    it 'sets adapter' do
+      expect(client.http).to be_a Graphlient::Adapters::HTTP::HTTPAdapter
+    end
+
+    it 'sets url' do
+      expect(client.http.url).to eq url
+    end
+
+    it 'sets headers' do
+      expect(client.http.headers).to eq headers
+    end
+
+    it 'sets http_options' do
+      expect(client.http.connection.read_timeout).to eq(read_timeout)
+    end
+
+    context 'when http_options contains invalid option' do
+      let(:http_options) { { an_invalid_option: 'an invalid option' } }
+
+      it 'raises Graphlient::Errors::HttpOptionsError' do
+        expect { client.http.connection }.to raise_error(Graphlient::Errors::HttpOptionsError)
+      end
+    end
+  end
+
+  context 'default' do
+    let(:url) { 'http://example.com/graphql' }
+    let(:client) { Graphlient::Client.new(url, http: Graphlient::Adapters::HTTP::HTTPAdapter) }
+
+    before do
+      stub_request(:post, url).to_return(
+        status: 200,
+        body: DummySchema.execute(GraphQL::Introspection::INTROSPECTION_QUERY).to_json
+      )
+    end
+
+    it 'retrieves schema' do
+      expect(client.schema).to be_a Graphlient::Schema
+    end
+  end
+end

data/spec/graphlient/client_dsl_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe Graphlient::Client do
+  let(:client) { described_class.new('http://example.com/graphql') }
+
+  describe '#to_query_string' do
+    it 'returns a String' do
+      result = client.to_query_string do
+        query do
+          invoice(id: 10) do
+            id
+            feeInCents
+          end
+        end
+      end
+      expect(result).to be_a String
+    end
+
+    it 'builds a simple query without HTTP or schema access' do
+      result = client.to_query_string do
+        query do
+          invoice(id: 10) do
+            id
+            feeInCents
+          end
+        end
+      end
+      expect(result).to include('query')
+      expect(result).to include('invoice')
+      expect(result).to include('feeInCents')
+    end
+
+    it 'builds a parameterized query with variable declarations' do
+      result = client.to_query_string do
+        query(id: :int) do
+          invoice(id: :id) do
+            id
+            feeInCents
+          end
+        end
+      end
+      expect(result).to include('$id: Int')
+      expect(result).to include('invoice(id: $id)')
+    end
+
+    it 'builds a mutation query string' do
+      result = client.to_query_string do
+        mutation(input: :CreateInvoiceInput!) do
+          createInvoice(input: :input) do
+            invoice do
+              id
+            end
+            errors
+          end
+        end
+      end
+      expect(result).to include('mutation')
+      expect(result).to include('createInvoice')
+      expect(result).to include('$input: CreateInvoiceInput!')
+    end
+
+    it 'does not interact with the HTTP adapter' do
+      expect_any_instance_of(Graphlient::Adapters::HTTP::FaradayAdapter).not_to receive(:execute)
+      client.to_query_string do
+        query do
+          invoice(id: 1) { id }
+        end
+      end
+    end
+
+    context 'with spread helper' do
+      it 'includes a named fragment spread in the query string' do
+        result = client.to_query_string do
+          query do
+            invoice(id: 10) do
+              spread :InvoiceFields
+            end
+          end
+        end
+        expect(result).to include('...InvoiceFields')
+      end
+
+      it 'supports multiple spreads at the same level' do
+        result = client.to_query_string do
+          query do
+            nodes do
+              spread :FragmentA
+              spread :FragmentB
+            end
+          end
+        end
+        expect(result).to include('...FragmentA')
+        expect(result).to include('...FragmentB')
+      end
+    end
+
+    it 'builds a query with a directive' do
+      result = client.to_query_string do
+        query(skip_fee: :boolean!) do
+          invoice(id: 10) do
+            id
+            feeInCents _skip(if: :skip_fee)
+          end
+        end
+      end
+      expect(result).to include('feeInCents @skip(if: $skip_fee)')
+      expect(result).to include('$skip_fee: Boolean!')
+    end
+
+    it 'builds a query with an inline fragment' do
+      result = client.to_query_string do
+        query do
+          invoice(id: 10) do
+            spread(on: :PaidInvoice) { amountPaid }
+          end
+        end
+      end
+      expect(result).to include('... on PaidInvoice')
+      expect(result).to include('amountPaid')
+    end
+
+    it 'builds a query with an inline fragment definition' do
+      result = client.to_query_string do
+        fragment(:InvoiceFields, on: :Invoice) do
+          id
+          feeInCents
+        end
+        query { invoice(id: 10) { spread :InvoiceFields } }
+      end
+      expect(result).to include('...InvoiceFields')
+      expect(result).to include('fragment InvoiceFields on Invoice')
+    end
+  end
+
+  describe '#scalar (custom scalar registration)' do
+    let(:client_with_scalars) do
+      described_class.new('http://example.com/graphql') do |c|
+        c.scalar :date, 'Date'
+        c.scalar :uuid, 'UUID'
+      end
+    end
+
+    it 'registers custom scalars via the client block' do
+      result = client_with_scalars.to_query_string do
+        query(created_after: :date, id: :uuid!) do
+          invoices(created_after: :created_after) { total }
+        end
+      end
+      expect(result).to include('$created_after: Date')
+      expect(result).to include('$id: UUID!')
+    end
+  end
+end