cardiac 0.2.0.pre2

data/spec/shared/cardiac/operation_builder_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Cardiac::OperationBuilder do
+
+  let(:base_url) { 'http://localhost/prefix/segment?q=foobar' }
+  let(:base_uri) { URI(base_url) }
+  let(:resource) { Cardiac::Resource.new(base_uri) }
+  let(:builder)  { Cardiac::OperationBuilder.new(resource.dup) }
+
+  subject { builder }
+
+  shared_examples 'a URI builder' do |args,url|
+    calldesc = "##{args[0]}(#{args[1..-1].map(&:inspect).join(',')})"
+
+    subject { builder.send(*args) }
+
+    it "#{calldesc} should modify the new builder" do
+      expect(subject.to_resource.to_url).to eq(url)
+      unless url == base_url
+        expect(subject.to_resource.to_uri).not_to eq(base_uri)
+        expect(subject.to_resource.to_url).not_to eq(base_url)
+      end
+    end
+
+    it "#{calldesc} should not modify the original builder" do
+      unless url == base_url
+        expect(builder.to_resource.to_uri).to eq(base_uri)
+        expect(builder.to_resource.to_url).to eq(base_url)
+      end
+    end
+  end
+
+  shared_examples 'a call builder' do |verb|
+    it { is_expected.to respond_to(verb) }
+
+    describe "##{verb}" do
+      subject { builder.send(verb, *args).to_resource }
+      let!(:args) { [] }
+
+      if verb==:call
+        describe '#method_value' do
+          subject { super().method_value }
+          it { is_expected.to be_nil }
+        end
+      else
+        describe '#method_value' do
+          subject { super().method_value }
+          it { is_expected.to eq(verb) }
+        end
+      end
+    end
+  end
+
+  shared_examples 'a call proxy' do |verb, mock|
+    it { is_expected.to respond_to(verb) }
+  
+    include_context 'Client responses'
+
+    describe "##{verb}" do
+      include_context 'Client execution', verb, mock
+      
+      subject { builder.send(verb, *args) }
+      let!(:args) { [] }
+        
+      it 'should not raise an error' do
+        expect { subject.to_s }.not_to raise_error
+      end
+    end
+  end
+
+  shared_examples 'URI building' do
+    it_behaves_like 'a URI builder', [:scheme, 'https'],     'https://localhost/prefix/segment?q=foobar'
+    it_behaves_like 'a URI builder', [:https],               'https://localhost/prefix/segment?q=foobar'
+    it_behaves_like 'a URI builder', [:host, 'google.com'],  'http://google.com/prefix/segment?q=foobar'
+    it_behaves_like 'a URI builder', [:port, 8080],          'http://localhost:8080/prefix/segment?q=foobar'
+    it_behaves_like 'a URI builder', [:path, '1'],           'http://localhost/prefix/segment/1?q=foobar'
+    it_behaves_like 'a URI builder', [:query, 'q=barfoo'],   'http://localhost/prefix/segment?q=barfoo'
+    it_behaves_like 'a URI builder', [:query, {q: 1, r: 2}], 'http://localhost/prefix/segment?q=1&r=2'
+  end
+  
+  include_examples 'URI building'
+
+  it_behaves_like 'a call builder', :get
+  it_behaves_like 'a call builder', :post
+  it_behaves_like 'a call builder', :put
+  it_behaves_like 'a call builder', :delete
+
+  describe Cardiac::OperationProxy do
+    let(:builder)  { Cardiac::OperationProxy.new(resource.dup) }
+     
+    include_examples 'URI building'
+    
+    it_behaves_like 'a call proxy', :get, :success
+  end
+
+end

data/spec/shared/cardiac/operation_handler_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Cardiac::OperationHandler do
+  
+  let(:resource)       { Cardiac::Resource.new('http://google.com') }
+  let(:client_options) { resource.send(:build_client_options) }
+  let(:client_handler) { }
+  
+  subject do
+    described_class.new(client_options, nil, &client_handler)
+  end
+    
+  include_context 'Client responses'
+    
+  shared_examples 'successful responses' do |verb|
+    include_context 'Client execution', verb, :success
+    
+    before :example do
+      resource.http_method(verb)
+      expect{ subject.transmit! }.not_to raise_error
+    end
+    
+    it { is_expected.to be_completed }
+    it { is_expected.to be_transmitted }
+    it { is_expected.not_to be_aborted }
+  end
+  
+  shared_examples 'unsuccessful responses' do |verb|
+    include_context 'Client execution', verb, :failure
+    
+    before :example do
+      resource.http_method(verb)
+      expect{ subject.transmit! }.to raise_error(/Not Found/)
+    end
+    
+    it { is_expected.not_to be_completed }
+    it { is_expected.to be_transmitted }
+    it { is_expected.to be_aborted }
+  end
+  
+  shared_examples 'aborted requests' do |verb|
+    before :example do
+      allow_any_instance_of(Cardiac::OperationHandler).to receive(:perform_request){|_| raise Errno::ECONNREFUSED }
+      resource.http_method(verb)
+      expect{ subject.transmit! }.to raise_error
+    end
+    
+    it { is_expected.not_to be_completed }
+    it { is_expected.not_to be_transmitted }
+    it { is_expected.to be_aborted }
+  end
+  
+  describe 'GET' do
+    it_behaves_like 'successful responses', :get
+    it_behaves_like 'unsuccessful responses', :get
+    it_behaves_like 'aborted requests', :get
+  end
+  
+  describe 'POST' do
+    it_behaves_like 'successful responses', :post
+    it_behaves_like 'unsuccessful responses', :post
+    it_behaves_like 'aborted requests', :post
+  end
+  
+  describe 'PUT' do
+    it_behaves_like 'successful responses', :put
+    it_behaves_like 'unsuccessful responses', :put
+    it_behaves_like 'aborted requests', :put
+  end
+  
+  describe 'DELETE' do
+    it_behaves_like 'successful responses', :delete
+    it_behaves_like 'unsuccessful responses', :delete
+    it_behaves_like 'aborted requests', :delete
+  end
+  
+  it 'will not transmit without an HTTP verb' do
+    resource.http_method(nil)
+    expect { subject.transmit! }.to raise_error(Cardiac::InvalidOperationError)
+  end
+  
+end

data/spec/shared/cardiac/representation/reflection_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Cardiac::Representation::Reflection do
+  
+  shared_context 'by extension' do |_extension,*rest|
+    let(:extension) { _extension }
+    subject { described_class.new(extension, *rest) }
+  end
+  
+  shared_examples 'default type' do |*rest|
+    describe '#extension' do
+      subject { super().extension }
+      it { is_expected.to eq(extension) }
+    end
+
+    describe '#default_type' do
+      subject { super().default_type }
+      it { is_expected.to be_present }
+    end
+
+    describe '#types' do
+      it 'includes the default type' do
+        expect(subject.types).to be_include(subject.default_type)
+      end
+      it 'includes the application/:extension type' do
+        expect(subject.types).to be_include("application/#{extension}")
+      end
+    end
+  end
+  
+  shared_examples 'default coder' do
+    describe '#coder' do
+      subject { super().coder }
+      it { is_expected.to eq(::Cardiac::Representation::Codecs.const_get(extension.to_s.classify)) }
+    end
+
+    describe '#coder' do
+      subject { super().coder }
+      it { is_expected.to be_respond_to(:decode) }
+    end
+
+    describe '#coder' do
+      subject { super().coder }
+      it { is_expected.to be_respond_to(:encode) }
+    end
+  end
+  
+  describe 'JSON' do
+    include_context  'by extension', :json
+    include_examples 'default type'
+    include_examples 'default coder'
+  end
+  
+  describe 'XML' do
+    include_context  'by extension', :xml
+    include_examples 'default type'
+    include_examples 'default coder'
+    
+    describe '#types' do
+      subject { super().types }
+      it { is_expected.to be_include("text/xml") }
+    end
+  end
+  
+  describe 'unknown' do
+    include_context  'by extension', :unknown
+    
+    it 'cannot be created' do
+      expect { subject }.to raise_error
+    end
+  end
+  
+end

data/spec/shared/cardiac/resource/adapter_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Cardiac::ResourceAdapter do
+  
+  let(:base_url) { 'http://localhost/prefix/segment?q=foobar' }
+  let(:base_uri) { URI(base_url) }
+  let(:resource) { Cardiac::Resource.new(base_uri) }
+  let(:adapter)  { Cardiac::ResourceAdapter.new(nil, resource) }
+    
+  include_context 'Client responses'
+    
+  subject { adapter }
+    
+  describe '#http_verb' do
+    subject { super().http_verb }
+    it { is_expected.to be_nil }
+  end
+
+  describe '#payload' do
+    subject { super().payload }
+    it { is_expected.to be_nil }
+  end
+
+  describe '#response' do
+    subject { super().response }
+    it { is_expected.to be_nil }
+  end
+
+  describe '#result' do
+    subject { super().result }
+    it { is_expected.to be_nil }
+  end
+
+  describe '#resource' do
+    subject { super().resource }
+    it { is_expected.to eq(resource) }
+  end
+    
+  it { is_expected.to be_resolved }
+    
+  describe '#call!()' do
+    
+    describe 'successful responses' do
+      include_context 'Client execution', :get, :success
+      
+      before :example do
+        resource.http_method(:get)
+        expect { @retval = adapter.call! }.not_to raise_error
+      end
+      
+      describe '#response' do
+        subject { adapter.response }
+        it { is_expected.to be_present }
+      end
+
+      describe '#result' do
+        subject { adapter.result }
+        it { is_expected.to be_present }
+      end
+        
+      it('returns true')   { expect(@retval).to be_a(TrueClass) }
+    end
+    
+    describe 'failed responses' do
+      include_context 'Client execution', :get, :failure
+      
+      before :example do
+        resource.http_method(:get)
+        expect { @retval = adapter.call! }.to raise_error
+      end
+      
+      describe '#response' do
+        subject { adapter.response }
+        it { is_expected.not_to be_present }
+      end
+
+      describe '#result' do
+        subject { adapter.result }
+        it { is_expected.not_to be_present }
+      end
+    end
+  end
+end

data/spec/shared/cardiac/resource/builder_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Cardiac::ResourceBuilder do
+  
+  let(:base_url) { 'http://localhost/prefix/segment?q=foobar' }
+  let(:base_uri) { URI(base_url) }
+  let(:resource) { Cardiac::Resource.new(base_uri) }
+  let(:builder)  { Cardiac::ResourceBuilder.new(resource.dup) }
+    
+  subject { builder }
+
+  shared_examples 'a non-operational resource' do |sym|
+    it { is_expected.not_to respond_to(sym) }
+    it("##{sym} should raise an error") { expect { builder.send(sym) }.to raise_error }
+  end
+  
+  shared_examples 'a URI builder' do |args,url|
+    calldesc = "##{args[0]}(#{args[1..-1].map(&:inspect).join(',')})"
+    
+    subject { builder.send(*args) }
+    
+    it "#{calldesc} should modify the new builder" do
+      expect(subject.to_resource.to_url).to eq(url)
+      unless url == base_url
+        expect(subject.to_resource.to_uri).not_to eq(base_uri)
+        expect(subject.to_resource.to_url).not_to eq(base_url)
+      end
+    end
+    
+    it "#{calldesc} should not modify the original builder" do
+      unless url == base_url
+        expect(builder.to_resource.to_uri).to eq(base_uri)
+        expect(builder.to_resource.to_url).to eq(base_url)
+      end
+    end
+  end
+  
+  it_behaves_like 'a URI builder', [:scheme, 'https'],     'https://localhost/prefix/segment?q=foobar'
+  it_behaves_like 'a URI builder', [:https],               'https://localhost/prefix/segment?q=foobar'
+  it_behaves_like 'a URI builder', [:host, 'google.com'],  'http://google.com/prefix/segment?q=foobar'
+  it_behaves_like 'a URI builder', [:port, 8080],          'http://localhost:8080/prefix/segment?q=foobar'
+  it_behaves_like 'a URI builder', [:path, '1'],           'http://localhost/prefix/segment/1?q=foobar'
+  it_behaves_like 'a URI builder', [:query, 'q=barfoo'],   'http://localhost/prefix/segment?q=barfoo'
+  it_behaves_like 'a URI builder', [:query, {q: 1, r: 2}], 'http://localhost/prefix/segment?q=1&r=2'
+  
+  it_behaves_like 'a non-operational resource', :get
+  it_behaves_like 'a non-operational resource', :post
+  it_behaves_like 'a non-operational resource', :put
+  it_behaves_like 'a non-operational resource', :delete
+  it_behaves_like 'a non-operational resource', :call
+  
+end

data/spec/shared/cardiac/resource/codec_methods_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Cardiac::CodecMethods do
+  
+  let(:base_url) { 'http://localhost/prefix/segment?q=foobar' }
+  let(:base_uri) { URI(base_url) }
+  let(:resource) { Cardiac::Resource.new(base_uri) }
+    
+  subject { resource }
+
+  describe 'decoders built with' do
+    subject do
+      lambda{|*v| builder[resource, *v] ; resource.send(:build_decoders).keys }
+    end
+    
+    after :each do
+      decoders = resource.send(:build_decoders)
+      expect(resource.reset_decoders.send(:build_decoders).keys).to eq(Cardiac::CodecMethods::DEFAULT_DECODERS)
+      expect(resource.decoders(*decoders.keys).send(:build_decoders).keys).to eq(decoders.keys)
+    end
+    
+    describe :decoders do
+      context do
+        let(:builder) { lambda{|r,*v| r.decoders(*v) } }
+      
+        describe '[:xml]' do
+          subject { super()[:xml] }
+          it { is_expected.to eq([:xml]) }
+        end
+
+        describe '[:json]' do
+          subject { super()[:json] }
+          it { is_expected.to eq([:json]) }
+        end
+
+        describe '[:xml, :json, :xml]' do
+          subject { super()[:xml, :json, :xml] }
+          it { is_expected.to eq([:xml, :json]) }
+        end
+      end
+      
+      context do
+        let(:builder) { lambda{|r,*l| l.each{|v| r.decoders(*v) } } }
+      
+        describe '[[:xml]]' do
+          subject { super()[[:xml]] }
+          it { is_expected.to eq([:xml]) }
+        end
+
+        describe '[[:xml],[:json]]' do
+          subject { super()[[:xml],[:json]] }
+          it { is_expected.to eq([:xml, :json]) }
+        end
+
+        describe '[[:xml, :json], [:url_encoded, :xml]]' do
+          subject { super()[[:xml, :json], [:url_encoded, :xml]] }
+          it { is_expected.to eq([:xml, :json, :url_encoded]) }
+        end
+      end
+    end
+    
+  end
+end

data/spec/shared/cardiac/resource/config_methods_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Cardiac::ConfigMethods do
+  
+  let(:base_url) { 'http://localhost/prefix/segment?q=foobar' }
+  let(:base_uri) { URI(base_url) }
+  let(:resource) { Cardiac::Resource.new(base_uri) }
+    
+  subject { resource }
+    
+  it { expect{ subject.send(:build_config) }.not_to raise_error }
+
+  describe 'config built with' do
+    subject do
+      lambda{|*v| builder[resource, *v] ; resource.send(:build_config) }
+    end
+    
+    before :example do
+      @original_config = resource.send(:build_config)
+    end
+    
+    after :each do
+      config = resource.send(:build_config)
+      resource.reconfig
+      expect(resource.send(:build_config)).to eq(@original_config)
+      resource.config.update(config)
+      expect(resource.send(:build_config)).to eq(config)
+    end
+    
+    describe '#config()' do
+      describe 'unwrap_client_exceptions: ...' do
+        let(:builder) { lambda{|r,*v| v.each{|h| r.config.update(h) } } }
+      
+        describe '[{unwrap_client_exceptions: true}]' do
+          subject { super()[{unwrap_client_exceptions: true}] }
+          it { is_expected.to eq({unwrap_client_exceptions: true})  }
+        end
+
+        describe '[{unwrap_client_exceptions: false}]' do
+          subject { super()[{unwrap_client_exceptions: false}] }
+          it { is_expected.to eq({unwrap_client_exceptions: false}) }
+        end
+        
+        it do
+          expect(resource.unwrap_client_exceptions).to be_falsey
+          expect(resource.config).to be_empty
+        end
+      end
+    end
+    
+  end
+end