frenetic 0.0.20.alpha.6 → 1.0.0.alpha.1

data/spec/connection_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe Frenetic::Connection do
+  let(:url) { 'http://example.com' }
+  let(:cfg) do
+    {
+      adapter: :net_http,
+      url: url
+    }
+  end
+
+  subject(:instance) { described_class.new(cfg) }
+
+  describe '#initialize?' do
+    subject { super().valid? }
+
+    context 'with an invalid configuration' do
+      let(:url) { nil }
+
+      it 'raises an error' do
+        expect{subject}.to raise_error Frenetic::ConfigError, %r{Url must be present}
+      end
+    end
+
+    context 'with a valid configuration' do
+      let(:url) { 'http://example.com' }
+
+      it 'does not raise an error' do
+        expect{subject}.to_not raise_error
+      end
+    end
+  end
+
+  describe '#process_config' do
+    subject { super().process_config(url:url) }
+
+    it 'returns a Faraday builder-compatible config' do
+      expect(subject[0]).to be_a Hash
+    end
+
+    it 'returns a Faraday::Connection-compatible config' do
+      expect(subject[1]).to include :url
+    end
+
+    it 'converts URLs to URIs' do
+      expect(subject[1]).to include url:kind_of(Addressable::URI)
+    end
+  end
+
+  describe '#configure_authentication' do
+    let(:builder) { double('FaradayBuilder', request:true) }
+
+    subject { super().configure_authentication(builder) }
+
+    context 'with no authentication credentials' do
+      it 'does not use any authentication middleware' do
+        subject
+        expect(builder).to_not have_received(:request)
+      end
+    end
+
+    context 'with Basic Auth credentials' do
+      let(:cfg) { super().merge(username:'un', password:'pw') }
+
+      it 'uses the Basic Auth middleware' do
+        subject
+        expect(builder).to have_received(:request).with(:basic_auth, 'un', 'pw')
+      end
+    end
+
+    context 'with Basic Auth credentials' do
+      let(:cfg) { super().merge(api_token:'abc123') }
+
+      it 'uses the Basic Auth middleware' do
+        subject
+        expect(builder).to have_received(:request).with(:token_auth, 'abc123')
+      end
+    end
+  end
+
+  describe '#configure_cache' do
+    let(:builder) { double('FaradayBuilder', use:true) }
+
+    subject { super().configure_cache(builder) }
+
+    context 'with no cache settings' do
+      it 'does not use any caching middleware' do
+        subject
+        expect(builder).to_not have_received(:use)
+      end
+    end
+
+    context 'with :rack' do
+      let(:cfg) { super().merge(cache: :rack) }
+
+      it 'uses the Rack::Compatible caching middleware' do
+        subject
+        expect(builder).to have_received(:use).with(
+          FaradayMiddleware::RackCompatible,
+          Rack::Cache::Context,
+          hash_including(
+            :metastore,
+            :entitystore,
+            :ignore_headers
+          )
+        )
+      end
+    end
+
+    context 'with :rails' do
+      let(:cfg) { super().merge(cache: :rails) }
+      let(:rails) { double('Rails').as_null_object }
+
+      before { stub_const 'Rails', rails }
+
+      it 'uses the HttpCache caching middleware' do
+        subject
+        expect(builder).to have_received(:use).with(
+          Faraday::HttpCache,
+          hash_including(:store)
+        )
+      end
+    end
+  end
+
+  describe '#configure_adapter' do
+    let(:builder) { double('FaradayBuilder', adapter:true) }
+    let(:cfg) { super().merge(adapter: :patron) }
+
+    subject { super().configure_adapter(builder) }
+
+    it 'uses the specified adapter' do
+      subject
+      expect(builder).to have_received(:adapter).with(:patron)
+    end
+  end
+end

data/spec/fixtures/test_api_requests.rb

@@ -1,7 +1,6 @@
 require 'json'
 
 class HttpStubs
-
   def initialize( rspec )
     @rspec = rspec
   end
@@ -81,8 +80,16 @@ class HttpStubs
           my_temp_resource: {
             description: 'Humanized resource description',
             properties: {
+              id:   'number',
               name: 'string'
             }
+          },
+          abstract_resource: {
+            description: 'A random thing',
+            properties: {
+              id:    'number',
+              genus: 'string'
+            }
           }
         }
       },
@@ -103,7 +110,6 @@ class HttpStubs
       }
     }
   end
-
 end
 
 RSpec.configure do |c|

data/spec/frenetic_spec.rb

@@ -1,155 +1,243 @@
 require 'spec_helper'
 
 describe Frenetic do
-  let(:test_cfg) do
-    {
-      url:'http://example.com/api'
-    }
-  end
-
-  subject(:instance) { described_class.new( test_cfg ) }
-
-  describe '#connection' do
-    subject { instance.connection }
-
-    it { should be_a Faraday::Connection }
-
-    context 'configured with a :username' do
-      let(:test_cfg) { super().merge username:'foo' }
-
-      subject { super().builder.handlers }
-
-      it { should include Faraday::Request::BasicAuthentication }
-    end
-
-    context 'configured with a :api_token' do
-      let(:test_cfg) { super().merge api_token:'API_TOKEN' }
-
-      subject { super().builder.handlers }
-
-      it { should include Faraday::Request::TokenAuthentication }
-    end
-
-    context 'configured to use Rack::Cache' do
-      let(:test_cfg) { super().merge cache: :rack }
-
-      subject { super().builder.handlers }
-
-      it { should include FaradayMiddleware::RackCompatible }
-    end
-
-    context 'when Frenetic is initialized with a block' do
-      it 'should yield the Faraday builder to the block argument' do
-        builder = nil
-
-        described_class.new(test_cfg) do |b|
-          builder = b
-        end.connection
-
-        builder.should be_a Faraday::Connection
-      end
+  let(:url) { 'http://example.com/api' }
+  let(:test_cfg) { { url:url } }
+
+  subject(:instance) { described_class.new(test_cfg) }
+
+  describe '.config' do
+    subject { described_class.config }
+
+    it 'includes expected options' do
+      expect(subject).to include adapter: Faraday.default_adapter
+      expect(subject).to include :api_token
+      expect(subject).to include cache:false
+      expect(subject).to include :default_root_cache_age
+      expect(subject).to include headers:kind_of(Hash)
+      expect(subject).to include middleware:[]
+      expect(subject).to include :password
+      expect(subject).to include ssl:{verify:true}
+      expect(subject).to include test_mode:false
+      expect(subject).to include :url
+      expect(subject).to include :username
     end
   end
 
-  describe '#description' do
-    subject { instance.description }
-
-    context 'with a URL that returns a' do
-      context 'valid response' do
-        before { @stubs.api_description }
-
-        it { should include '_embedded', '_links' }
-      end
-
-      context 'server error' do
-        before { @stubs.api_server_error }
-
-        it 'should raise an error' do
-          expect{ subject }.to raise_error Frenetic::ServerError
-        end
-      end
+  describe '#config' do
+    subject { super().config }
 
-      context 'client error' do
-        before { @stubs.api_client_error :json }
-
-        it 'should raise an error' do
-          expect{ subject }.to raise_error Frenetic::ClientError
-        end
-      end
-
-      context 'JSON parsing error' do
-        context 'for an otherwise successful response' do
-          before { @stubs.api_html_response }
-
-          it 'should raise an error' do
-            expect{ subject }.to raise_error Frenetic::ParsingError
-          end
-        end
-
-        context 'for a server error' do
-          before { @stubs.api_server_error :text }
-
-          it 'should raise an error' do
-            expect{ subject }.to raise_error Frenetic::ServerError, '500 Error encountered'
-          end
-        end
-
-        context 'for a client error' do
-          before { @stubs.api_client_error :text }
-
-          it 'should raise an error' do
-            expect{ subject }.to raise_error Frenetic::ClientError, '404 Error encountered'
-          end
-        end
-      end
+    it 'includes non-default instance values' do
+      expect(subject.url).to eq url
     end
-  end
-
-  describe '.schema' do
-    subject { instance.schema }
-
-    before { @stubs.api_description }
-
-    it { should include 'my_temp_resource' }
-  end
 
-  describe '#get' do
-    subject { instance.get '/foo' }
-
-    it 'should delegate to Faraday' do
-      instance.connection.should_receive :get
-
-      subject
+    it 'does not override the default class values' do
+      expect(subject.url).to_not eq described_class.config.url
     end
   end
 
-  describe '#put' do
-    subject { instance.put '/foo' }
-
-    it 'should delegate to Faraday' do
-      instance.connection.should_receive :put
+  describe '#configure' do
+    subject { instance.configure {|c| } }
 
+    it 'resets the Connection' do
+      prev_connection = instance.connection
       subject
+      expect(instance.connection).to_not eq prev_connection
     end
   end
 
-  describe '#post' do
-    subject { instance.post '/foo' }
-
-    it 'should delegate to Faraday' do
-      instance.connection.should_receive :post
+  describe '#connection' do
+    subject { super().connection }
 
-      subject
+    it 'returns a Connection' do
+      expect(subject).to be_a Frenetic::Connection
     end
   end
 
-  describe '#delete' do
-    subject { instance.delete '/foo' }
-
-    it 'should delegate to Faraday' do
-      instance.connection.should_receive :delete
-
-      subject
-    end
-  end
+  # describe '#connection' do
+  #   subject { super().connection }
+
+  #   it 'returns a Faraday Connection' do
+  #     expect(subject).to be_a Faraday::Connection
+  #   end
+
+  #   context 'when Frenetic is initialized with a block' do
+  #     subject do
+  #       builder = nil
+  #       described_class.new(test_cfg) do |b|
+  #         builder = b
+  #       end.connection
+  #       builder
+  #     end
+
+  #     it 'yields the Faraday builder to the block argument' do
+  #       expect(subject).to be_a Faraday::Connection
+  #     end
+  #   end
+
+  #   describe 'middleware' do
+  #     subject { super().builder.handlers }
+
+  #     context 'configured with a :username' do
+  #       let(:test_cfg) { super().merge username:'foo' }
+
+  #       it 'includes Basic Auth middleware' do
+  #         expect(subject).to include Faraday::Request::BasicAuthentication
+  #       end
+  #     end
+
+  #     context 'configured with a :api_token' do
+  #       let(:test_cfg) { super().merge api_token:'API_TOKEN' }
+
+  #       it 'includes Token Authentication middleware' do
+  #         expect(subject).to include Faraday::Request::TokenAuthentication
+  #       end
+  #     end
+
+  #     context 'configured to use Rack::Cache' do
+  #       let(:test_cfg) { super().merge cache: :rack }
+
+  #       it 'includes Rack middleware' do
+  #         expect(subject).to include FaradayMiddleware::RackCompatible
+  #       end
+  #     end
+  #   end
+  # end
+
+  # describe '#description' do
+  #   subject { super().description }
+
+  #   context 'with a URL that returns a' do
+  #     context 'valid response' do
+  #       before { @stubs.api_description }
+
+  #       it 'includes meta Hypermedia properties' do
+  #         expect(subject).to include '_embedded'
+  #         expect(subject).to include '_links'
+  #       end
+  #     end
+
+  #     context 'server error' do
+  #       before { @stubs.api_server_error }
+
+  #       it 'raises an error' do
+  #         expect{subject}.to raise_error Frenetic::ServerParsingError
+  #       end
+  #     end
+
+  #     context 'client error' do
+  #       before { @stubs.api_client_error :json }
+
+  #       it 'raises an error' do
+  #         expect{subject}.to raise_error Frenetic::ClientError
+  #       end
+  #     end
+
+  #     context 'JSON parsing error' do
+  #       context 'for an otherwise successful response' do
+  #         before { @stubs.api_html_response }
+
+  #         it 'raises an error' do
+  #           expect{subject}.to raise_error Frenetic::UnknownParsingError
+  #         end
+  #       end
+
+  #       context 'for a server error' do
+  #         before { @stubs.api_server_error :text }
+
+  #         it 'raises an error' do
+  #           expect{subject}.to raise_error Frenetic::ServerParsingError
+  #         end
+  #       end
+
+  #       context 'for a client error' do
+  #         before { @stubs.api_client_error :text }
+
+  #         it 'raises an error' do
+  #           expect{subject}.to raise_error Frenetic::ClientParsingError
+  #         end
+  #       end
+  #     end
+  #   end
+  # end
+
+  # describe '.schema' do
+  #   before { @stubs.api_description }
+
+  #   subject { super().schema }
+
+  #   it 'includes a list of defined resources' do
+  #     expect(subject).to include 'my_temp_resource'
+  #   end
+  # end
+
+  # describe '#get' do
+  #   subject { super().get '/foo' }
+
+  #   it 'delegates to Faraday' do
+  #     allow(instance.connection).to receive(:get)
+  #     subject
+  #     expect(instance.connection).to have_received(:get)
+  #   end
+  # end
+
+  # describe '#put' do
+  #   subject { super().put '/foo' }
+
+  #   it 'delegates to Faraday' do
+  #     allow(instance.connection).to receive(:put)
+  #     subject
+  #     expect(instance.connection).to have_received(:put)
+  #   end
+  # end
+
+  # describe '#patch' do
+  #   subject { super().patch '/foo' }
+
+  #   it 'delegates to Faraday' do
+  #     allow(instance.connection).to receive(:patch)
+  #     subject
+  #     expect(instance.connection).to have_received(:patch)
+  #   end
+  # end
+
+  # describe '#head' do
+  #   subject { instance.head '/foo' }
+
+  #   it 'delegates to Faraday' do
+  #     allow(instance.connection).to receive(:head)
+  #     subject
+  #     expect(instance.connection).to have_received(:head)
+  #   end
+  # end
+
+  # describe '#options' do
+  #   subject { instance.options '/foo' }
+
+  #   it 'delegates to Faraday' do
+  #     allow(instance.connection).to receive(:options)
+  #     subject
+  #     expect(instance.connection).to have_received(:options)
+  #   end
+  # end
+
+  # describe '#post' do
+  #   subject { super().post '/foo' }
+
+  #   it 'delegates to Faraday' do
+  #     allow(instance.connection).to receive(:post)
+  #     subject
+  #     expect(instance.connection).to have_received(:post)
+  #   end
+  # end
+
+  # describe '#delete' do
+  #   subject { super().delete '/foo' }
+
+  #   it 'delegates to Faraday' do
+  #     allow(instance.connection).to receive(:delete)
+  #     subject
+  #     expect(instance.connection).to have_received(:delete)
+  #   end
+  # end
 end