ddy_remote_resource 0.4.2

data/spec/lib/remote_resource/response_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+
+describe RemoteResource::Response do
+
+  describe '#original_response' do
+    it 'is private' do
+      expect(described_class.private_method_defined?(:original_response)).to be_truthy
+    end
+  end
+
+  describe '#original_request' do
+    it 'is private' do
+      expect(described_class.private_method_defined?(:original_request)).to be_truthy
+    end
+  end
+
+  describe 'Typhoeus::Response' do
+    let(:typhoeus_options)  { { body: 'typhoeus_response_body', code: 200 } }
+    let(:typhoeus_response) { Typhoeus::Response.new typhoeus_options }
+    let(:response)          { described_class.new typhoeus_response }
+
+    describe '#success?' do
+      it 'calls the Typhoeus::Response#success?' do
+        expect(typhoeus_response).to receive(:success?)
+        response.success?
+      end
+    end
+
+    describe '#response_body' do
+      it 'returns the response body of the original response' do
+        expect(response.response_body).to eql 'typhoeus_response_body'
+      end
+    end
+
+    describe '#response_code' do
+      it 'returns the response code of the original response' do
+        expect(response.response_code).to eql 200
+      end
+    end
+  end
+
+  describe '#unprocessable_entity?' do
+    let(:response) { described_class.new double.as_null_object }
+
+    context 'when the response code is 422' do
+      it 'returns true' do
+        allow(response).to receive(:response_code) { 422 }
+
+        expect(response.unprocessable_entity?).to be_truthy
+      end
+    end
+
+    context 'when the response code is NOT 422' do
+      it 'returns false' do
+        allow(response).to receive(:response_code) { 200 }
+
+        expect(response.unprocessable_entity?).to be_falsey
+      end
+    end
+  end
+
+  describe '#sanitized_response_body' do
+    let(:response) { described_class.new double.as_null_object }
+
+    before { allow(response).to receive(:response_body) { response_body } }
+
+    context 'when response_body is nil' do
+      let(:response_body) { nil }
+
+      it 'returns an empty Hash' do
+        expect(response.sanitized_response_body).to eql({})
+      end
+    end
+
+    context 'when response_body is empty' do
+      let(:response_body) { '' }
+
+      it 'returns an empty Hash' do
+        expect(response.sanitized_response_body).to eql({})
+      end
+    end
+
+    context 'when response_body is NOT parseable' do
+      let(:response_body) { 'foo' }
+
+      before { allow(JSON).to receive(:parse).and_raise JSON::ParserError }
+
+      it 'returns an empty Hash' do
+        expect(response.sanitized_response_body).to eql({})
+      end
+    end
+
+    context 'when response_body is parseable' do
+      context 'and the connection_options contain a root_element' do
+        let(:connection_options) { { root_element: :foobar } }
+        let(:response)           { described_class.new double.as_null_object, connection_options }
+
+        let(:response_body)      { '{"foobar":{"id":"12"}}' }
+
+        it 'returns the parsed response_body unpacked from the root_element' do
+          expect(response.sanitized_response_body).to match({ "id" => "12" })
+        end
+      end
+
+      context 'and the connection_options do NOT contain a root_element' do
+        let(:response_body) { '{"id":"12"}' }
+
+        it 'returns the parsed response_body' do
+          expect(response.sanitized_response_body).to match({ "id" => "12" })
+        end
+      end
+    end
+  end
+
+  describe '#error_messages_response_body' do
+    let(:response) { described_class.new double.as_null_object }
+
+    before { allow(response).to receive(:response_body) { response_body } }
+
+    context 'when response_body is nil' do
+      let(:response_body) { nil }
+
+      it 'returns an empty Hash' do
+        expect(response.error_messages_response_body).to eql({})
+      end
+    end
+
+    context 'when response_body is empty' do
+      let(:response_body) { '' }
+
+      it 'returns an empty Hash' do
+        expect(response.error_messages_response_body).to eql({})
+      end
+    end
+
+    context 'when response_body is NOT parseable' do
+      let(:response_body) { 'foo' }
+
+      before { allow(JSON).to receive(:parse).and_raise JSON::ParserError }
+
+      it 'returns an empty Hash' do
+        expect(response.error_messages_response_body).to eql({})
+      end
+    end
+
+    context 'when response_body is parseable' do
+      context 'and the connection_options contain a root_element' do
+        let(:connection_options) { { root_element: :foobar } }
+        let(:response)           { described_class.new double.as_null_object, connection_options }
+
+        context 'and the response_body contains an error key' do
+          let(:response_body) { '{"errors":{"foo":["is required"]}}' }
+
+          it 'returns the error_messages in the parsed response_body' do
+            expect(response.error_messages_response_body).to eql({ "foo"=>["is required"] })
+          end
+        end
+
+        context 'and the response_body contains an error key packed in the root_element' do
+          let(:response_body) { '{"foobar":{"errors":{"foo":["is required"]}}}' }
+
+          it 'returns the error_messages in the parsed response_body unpacked from the root_element' do
+            expect(response.error_messages_response_body).to eql({ "foo"=>["is required"] })
+          end
+        end
+
+        context 'and the response_body does NOT contain an error key' do
+          let(:response_body) { '{"id":"12"}' }
+
+          it 'returns an empty Hash' do
+            expect(response.error_messages_response_body).to eql({})
+          end
+        end
+      end
+
+      context 'and the connection_options do NOT contain a root_element' do
+        context 'and the response_body contains an error key' do
+          let(:response_body) { '{"errors":{"foo":["is required"]}}' }
+
+          it 'returns the error_messages in the parsed response_body' do
+            expect(response.error_messages_response_body).to eql({ "foo"=>["is required"] })
+          end
+        end
+
+        context 'and the response_body does NOT contain an error key' do
+          let(:response_body) { '{"id":"12"}' }
+
+          it 'returns an empty Hash' do
+            expect(response.error_messages_response_body).to eql({})
+          end
+        end
+      end
+    end
+  end
+
+end

data/spec/lib/remote_resource/rest_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe RemoteResource::REST do
+
+  module RemoteResource
+    class RESTDummy
+      include RemoteResource::Base
+
+      self.site = 'https://foobar.com'
+
+    end
+  end
+
+  let(:dummy_class) { RemoteResource::RESTDummy }
+  let(:dummy)       { dummy_class.new }
+
+  let(:attributes) do
+    { name: 'Mies' }
+  end
+  let(:params) do
+    { id: '12' }
+  end
+  let(:connection_options) do
+    {
+      version: '/v1',
+      path_prefix: '/api'
+    }
+  end
+
+  let(:response) { instance_double(RemoteResource::Response) }
+
+  before { allow_any_instance_of(RemoteResource::Request).to receive(:perform) { response } }
+
+  describe '.get' do
+    it 'performs a RemoteResource::Request with the rest_action :get' do
+      expect(RemoteResource::Request).to receive(:new).with(dummy_class, :get, params, connection_options).and_call_original
+      expect_any_instance_of(RemoteResource::Request).to receive(:perform)
+      dummy_class.get params, connection_options
+    end
+  end
+
+  describe '.put' do
+    it 'performs a RemoteResource::Request with the rest_action :put' do
+      expect(RemoteResource::Request).to receive(:new).with(dummy_class, :put, attributes, connection_options).and_call_original
+      expect_any_instance_of(RemoteResource::Request).to receive(:perform)
+      dummy_class.put attributes, connection_options
+    end
+  end
+
+  describe '.patch' do
+    it 'performs a RemoteResource::Request with the rest_action :patch' do
+      expect(RemoteResource::Request).to receive(:new).with(dummy_class, :patch, attributes, connection_options).and_call_original
+      expect_any_instance_of(RemoteResource::Request).to receive(:perform)
+      dummy_class.patch attributes, connection_options
+    end
+  end
+
+  describe '.post' do
+    it 'performs a RemoteResource::Request with the rest_action :post' do
+      expect(RemoteResource::Request).to receive(:new).with(dummy_class, :post, attributes, connection_options).and_call_original
+      expect_any_instance_of(RemoteResource::Request).to receive(:perform)
+      dummy_class.post attributes, connection_options
+    end
+  end
+
+  describe '#get' do
+    it 'performs a RemoteResource::Request with the rest_action :get' do
+      expect(RemoteResource::Request).to receive(:new).with(dummy, :get, params, connection_options).and_call_original
+      expect_any_instance_of(RemoteResource::Request).to receive(:perform)
+      dummy.get params, connection_options
+    end
+  end
+
+  describe '#put' do
+    it 'performs a RemoteResource::Request with the rest_action :put' do
+      expect(RemoteResource::Request).to receive(:new).with(dummy, :put, attributes, connection_options).and_call_original
+      expect_any_instance_of(RemoteResource::Request).to receive(:perform)
+      dummy.put attributes, connection_options
+    end
+  end
+
+  describe '#patch' do
+    it 'performs a RemoteResource::Request with the rest_action :patch' do
+      expect(RemoteResource::Request).to receive(:new).with(dummy, :patch, attributes, connection_options).and_call_original
+      expect_any_instance_of(RemoteResource::Request).to receive(:perform)
+      dummy.patch attributes, connection_options
+    end
+  end
+
+  describe '#post' do
+    it 'performs a RemoteResource::Request with the rest_action :post' do
+      expect(RemoteResource::Request).to receive(:new).with(dummy, :post, attributes, connection_options).and_call_original
+      expect_any_instance_of(RemoteResource::Request).to receive(:perform)
+      dummy.post attributes, connection_options
+    end
+  end
+
+end

data/spec/lib/remote_resource/url_naming_determination_spec.rb

@@ -0,0 +1,225 @@
+require 'spec_helper'
+
+describe RemoteResource::UrlNamingDetermination do
+
+  module RemoteResource
+    class UrlNamingDeterminationDummy
+      include RemoteResource::Base
+
+      self.site = 'http://www.foobar.com'
+
+    end
+  end
+
+  let(:dummy_class) { RemoteResource::UrlNamingDeterminationDummy }
+
+  let(:connection_options)       { {} }
+  let(:url_naming_determination) { described_class.new dummy_class, connection_options }
+
+  describe '#base_url' do
+    context 'site' do
+      context 'when the connection_options contain a site' do
+        let(:connection_options) do
+          { site: 'http://www.bazbar.com' }
+        end
+
+        it 'uses the site of the connection_options' do
+          expect(url_naming_determination.base_url).to eql 'http://www.bazbar.com/url_naming_determination_dummy'
+        end
+      end
+
+      context 'when the connection_options do NOT contain a site' do
+        it 'uses the site of the resource_klass' do
+          expect(url_naming_determination.base_url).to eql 'http://www.foobar.com/url_naming_determination_dummy'
+        end
+      end
+    end
+
+    context 'version' do
+      context 'when the connection_options contain a version' do
+        let(:connection_options) do
+          { version: '/v2' }
+        end
+
+        it 'uses the version of the connection_options' do
+          expect(url_naming_determination.base_url).to eql 'http://www.foobar.com/v2/url_naming_determination_dummy'
+        end
+      end
+
+      context 'when the connection_options do NOT contain a version' do
+        context 'and the resource_klass contains a version' do
+          it 'uses the version of the resource_klass' do
+            dummy_class.version = '/version_4'
+
+            expect(url_naming_determination.base_url).to eql 'http://www.foobar.com/version_4/url_naming_determination_dummy'
+
+            dummy_class.version = nil
+          end
+        end
+
+        context 'and the resource_klass does NOT contain a version' do
+          it 'does NOT use the version' do
+            expect(url_naming_determination.base_url).to eql 'http://www.foobar.com/url_naming_determination_dummy'
+          end
+        end
+      end
+    end
+
+    context 'path_prefix' do
+      context 'when the connection_options contain a path_prefix' do
+        let(:connection_options) do
+          { path_prefix: '/api' }
+        end
+
+        it 'uses the path_prefix of the connection_options' do
+          expect(url_naming_determination.base_url).to eql 'http://www.foobar.com/api/url_naming_determination_dummy'
+        end
+      end
+
+      context 'when the connection_options do NOT contain a path_prefix' do
+        context 'and the resource_klass contains a path_prefix' do
+          it 'uses the path_prefix of the resource_klass' do
+            dummy_class.path_prefix = '/external_endpoint'
+
+            expect(url_naming_determination.base_url).to eql 'http://www.foobar.com/external_endpoint/url_naming_determination_dummy'
+
+            dummy_class.path_prefix = nil
+          end
+        end
+
+        context 'and the resource_klass does NOT contain a path_prefix' do
+          it 'does NOT use the path_prefix' do
+            expect(url_naming_determination.base_url).to eql 'http://www.foobar.com/url_naming_determination_dummy'
+          end
+        end
+      end
+    end
+
+    context 'id' do
+      context 'when an id is specified' do
+        it 'uses that id in the base url' do
+          expect(url_naming_determination.base_url(:id)).to eql 'http://www.foobar.com/url_naming_determination_dummy/id'
+        end
+      end
+
+      context 'when an id is NOT specified' do
+        it 'creates a base url without it' do
+          expect(url_naming_determination.base_url).to eql 'http://www.foobar.com/url_naming_determination_dummy'
+        end
+      end
+    end
+
+    context 'path_postfix' do
+      context 'when the connection_options contain a path_postfix' do
+        let(:connection_options) do
+          { path_postfix: '/custom' }
+        end
+
+        it 'uses the path_postfix of the connection_options' do
+          expect(url_naming_determination.base_url).to eql 'http://www.foobar.com/url_naming_determination_dummy/custom'
+        end
+
+        context 'and an id is specified' do
+          it 'uses the path_postfix of the connection_options and places the id before it' do
+            expect(url_naming_determination.base_url(:id)).to eql 'http://www.foobar.com/url_naming_determination_dummy/id/custom'
+          end
+        end
+      end
+
+      context 'when the connection_options do NOT contain a path_postfix' do
+        context 'and the resource_klass contains a path_postfix' do
+          it 'uses the path_postfix of the resource_klass' do
+            dummy_class.path_postfix = '/cancel'
+
+            expect(url_naming_determination.base_url).to eql 'http://www.foobar.com/url_naming_determination_dummy/cancel'
+
+            dummy_class.path_postfix = nil
+          end
+
+          context 'and an id is specified' do
+            it 'uses the path_postfix of the resource_klass and places the id before it' do
+              dummy_class.path_postfix = '/cancel'
+
+              expect(url_naming_determination.base_url(:id)).to eql 'http://www.foobar.com/url_naming_determination_dummy/id/cancel'
+
+              dummy_class.path_postfix = nil
+            end
+          end
+        end
+
+        context 'and the resource_klass does NOT contain a path_postfix' do
+          it 'does NOT use the path_postfix' do
+            expect(url_naming_determination.base_url).to eql 'http://www.foobar.com/url_naming_determination_dummy'
+          end
+
+          context 'and an id is specified' do
+            it 'places the id after the url safe relative name' do
+              expect(url_naming_determination.base_url(:id)).to eql 'http://www.foobar.com/url_naming_determination_dummy/id'
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe '#url_safe_relative_name' do
+    context 'when the connection_options contain a collection' do
+      let(:connection_options) do
+        { collection: true }
+      end
+
+      it 'uses the underscored, downcased and pluralized relative_name' do
+        expect(url_naming_determination.url_safe_relative_name).to eql 'url_naming_determination_dummies'
+      end
+    end
+
+    context 'when the connection_options do NOT contain a collection' do
+      context 'and the resource_klass contains a collection' do
+        it 'uses the underscored, downcased and pluralized relative_name' do
+          dummy_class.collection = true
+
+          expect(url_naming_determination.url_safe_relative_name).to eql 'url_naming_determination_dummies'
+
+          dummy_class.collection = false
+        end
+      end
+
+      context 'and the resource_klass does NOT contain a collection' do
+        it 'uses the underscored and downcased relative_name' do
+          expect(url_naming_determination.url_safe_relative_name).to eql 'url_naming_determination_dummy'
+        end
+      end
+    end
+  end
+
+  describe '#relative_name' do
+    context 'when the connection_options contain a collection_name' do
+      let(:connection_options) do
+        { collection_name: 'people' }
+      end
+
+      it 'uses the collection_name of the connection_options' do
+        expect(url_naming_determination.relative_name).to eql 'people'
+      end
+    end
+
+    context 'when the connection_options do NOT contain a collection_name' do
+      context 'and the resource_klass contains a collection_name' do
+        it 'uses the collection_name of the resource_klass' do
+          dummy_class.collection_name = 'cars'
+
+          expect(url_naming_determination.relative_name).to eql 'cars'
+
+          dummy_class.collection_name = nil
+        end
+      end
+
+      context 'and the resource_klass does NOT contain a collection_name' do
+        it 'uses the demodulized name of the resource_klass' do
+          expect(url_naming_determination.relative_name).to eql 'UrlNamingDeterminationDummy'
+        end
+      end
+    end
+  end
+
+end