ddy_remote_resource 0.4.2

data/spec/lib/remote_resource/builder_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+
+describe RemoteResource::Builder do
+
+  module RemoteResource
+    class BuilderDummy
+      include RemoteResource::Base
+
+      self.site = 'https://foobar.com'
+
+      attr_accessor :username
+
+    end
+  end
+
+  let(:dummy_class) { RemoteResource::BuilderDummy }
+  let(:dummy)       { dummy_class.new }
+
+  describe '.build_resource_from_response' do
+    let(:response)                { RemoteResource::Response.new double.as_null_object }
+    let(:sanitized_response_body) do
+      { "id" => "12", "username" => "foobar" }
+    end
+
+    before { allow(response).to receive(:sanitized_response_body) { sanitized_response_body } }
+
+    it 'calls the .build_resource' do
+      expect(dummy_class).to receive(:build_resource).with sanitized_response_body, { _response: an_instance_of(RemoteResource::Response) }
+      dummy_class.build_resource_from_response response
+    end
+  end
+
+  describe '.build_resource' do
+    let(:response)      { RemoteResource::Response.new double.as_null_object }
+    let(:response_hash) { dummy_class.send :response_hash, response }
+
+    context 'when collection is a Hash' do
+      let(:collection) do
+        { "id" => "12", "username" => "foobar" }
+      end
+
+      context 'and response_hash is given' do
+        it 'instantiates the resource with the collection AND response_hash' do
+          expect(dummy_class).to receive(:new).with(collection.merge(response_hash)).and_call_original
+          dummy_class.build_resource collection, response_hash
+        end
+
+        it 'returns the resource' do
+          expect(dummy_class.build_resource collection, response_hash).to be_a dummy_class
+        end
+      end
+
+      context 'and NO response_hash is given' do
+        it 'instantiates the resource with the collection' do
+          expect(dummy_class).to receive(:new).with(collection).and_call_original
+          dummy_class.build_resource collection
+        end
+
+        it 'returns the resource' do
+          expect(dummy_class.build_resource collection).to be_a dummy_class
+        end
+      end
+    end
+
+    context 'when collection is NOT a Hash' do
+      let(:collection) { [] }
+
+      it 'returns nil' do
+        expect(dummy_class.build_resource collection, response_hash).to be_nil
+      end
+    end
+  end
+
+  describe '.build_collection_from_response' do
+    let(:response)                { RemoteResource::Response.new double.as_null_object }
+    let(:sanitized_response_body) do
+      [
+        { "id" => "10", "username" => "foobar" },
+        { "id" => "11", "username" => "bazbar" },
+        { "id" => "12", "username" => "aapmies" }
+      ]
+    end
+
+    before { allow(response).to receive(:sanitized_response_body) { sanitized_response_body } }
+
+    it 'calls the .build_collection' do
+      expect(dummy_class).to receive(:build_collection).with sanitized_response_body, { _response: an_instance_of(RemoteResource::Response) }
+      dummy_class.build_collection_from_response response
+    end
+  end
+
+  describe '.build_collection' do
+    let(:response)      { RemoteResource::Response.new double.as_null_object }
+    let(:response_hash) { dummy_class.send :response_hash, response }
+
+    context 'when collection is an Array' do
+      let(:collection) do
+        [
+          { "id" => "10", "username" => "foobar" },
+          { "id" => "11", "username" => "bazbar" },
+          { "id" => "12", "username" => "aapmies" }
+        ]
+      end
+
+      context 'and response_hash is given' do
+        it 'instantiates a RemoteResource::Collection with the class, collection AND response_hash' do
+          expect(RemoteResource::Collection).to receive(:new).with(dummy_class, collection, response_hash).and_call_original
+          dummy_class.build_collection collection, response_hash
+        end
+
+        it 'returns the resources' do
+          resources = dummy_class.build_collection collection, response_hash
+          resources.each { |resource| expect(resource).to be_a dummy_class }
+        end
+      end
+
+      context 'and NO response_hash is given' do
+        it 'instantiates a RemoteResource::Collection with the class and collection' do
+          expect(RemoteResource::Collection).to receive(:new).with(dummy_class, collection, {}).and_call_original
+          dummy_class.build_collection collection
+        end
+
+        it 'returns the resources' do
+          resources = dummy_class.build_collection collection
+          resources.each { |resource| expect(resource).to be_a dummy_class }
+        end
+      end
+    end
+
+    context 'when collection is NOT an Array' do
+      let(:collection) { {} }
+
+      it 'returns nil' do
+        expect(dummy_class.build_collection collection, response_hash).to be_nil
+      end
+    end
+  end
+
+  describe '#rebuild_resource_from_response' do
+    let(:response)                { RemoteResource::Response.new double.as_null_object }
+    let(:sanitized_response_body) do
+      { "id" => "12", "username" => "foobar" }
+    end
+
+    before { allow(response).to receive(:sanitized_response_body) { sanitized_response_body } }
+
+    it 'calls the #rebuild_resource' do
+      expect(dummy).to receive(:rebuild_resource).with sanitized_response_body, { _response: an_instance_of(RemoteResource::Response) }
+      dummy.rebuild_resource_from_response response
+    end
+  end
+
+  describe '#rebuild_resource' do
+    let(:response)      { RemoteResource::Response.new double.as_null_object }
+    let(:response_hash) { dummy.send :response_hash, response }
+
+    before do
+      dummy.id       = nil
+      dummy.username = "foo"
+    end
+
+    context 'when the collection is a Hash' do
+      let(:collection) do
+        { "id" => "12", "username" => "foobar" }
+      end
+
+      context 'and response_hash is given' do
+        it 'mass-assigns the attributes of the resource with the collection AND with response_hash' do
+          expect(dummy.id).to be_nil
+          expect(dummy.username).to eql 'foo'
+          expect(dummy._response).to be_nil
+
+          dummy.rebuild_resource collection, response_hash
+
+          expect(dummy.id).to eql '12'
+          expect(dummy.username).to eql 'foobar'
+          expect(dummy._response).to be_a RemoteResource::Response
+        end
+
+        it 'returns the resource' do
+          expect(dummy.rebuild_resource collection, response_hash).to be_a dummy_class
+        end
+      end
+
+      context 'and NO response_hash is given' do
+        it 'mass-assigns the attributes of the resource with the collection' do
+          expect(dummy.id).to be_nil
+          expect(dummy.username).to eql 'foo'
+          expect(dummy._response).to be_nil
+
+          dummy.rebuild_resource collection
+
+          expect(dummy.id).to eql '12'
+          expect(dummy.username).to eql 'foobar'
+          expect(dummy._response).to be_nil
+        end
+
+        it 'returns the resource' do
+          expect(dummy.rebuild_resource collection).to be_a dummy_class
+        end
+      end
+    end
+
+    context 'when the collection is something else' do
+      let(:collection)  { 'foobar' }
+
+      context 'and response_hash is given' do
+        it 'assigns the response_hash of the resource' do
+          expect(dummy.id).to be_nil
+          expect(dummy.username).to eql 'foo'
+          expect(dummy._response).to be_nil
+
+          dummy.rebuild_resource collection, response_hash
+
+          expect(dummy.id).to be_nil
+          expect(dummy.username).to eql 'foo'
+          expect(dummy._response).to be_a RemoteResource::Response
+        end
+
+        it 'returns the resource' do
+          expect(dummy.rebuild_resource collection, response_hash).to be_a dummy_class
+        end
+      end
+
+      context 'and NO response_hash is given' do
+        it 'does NOT assign the response_hash of the resource' do
+          expect(dummy.id).to be_nil
+          expect(dummy.username).to eql 'foo'
+          expect(dummy._response).to be_nil
+
+          dummy.rebuild_resource collection
+
+          expect(dummy.id).to be_nil
+          expect(dummy.username).to eql 'foo'
+          expect(dummy._response).to be_nil
+        end
+
+        it 'returns the resource' do
+          expect(dummy.rebuild_resource collection).to be_a dummy_class
+        end
+      end
+    end
+  end
+
+end

data/spec/lib/remote_resource/collection_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe RemoteResource::Collection do
+
+  module RemoteResource
+    class CollectionDummy
+      include RemoteResource::Base
+
+      self.site = 'https://foobar.com'
+
+      attr_accessor :username
+    end
+  end
+
+  let(:dummy_class) { RemoteResource::CollectionDummy }
+  let(:dummy)       { dummy_class.new }
+
+  let(:response) { RemoteResource::Response.new double.as_null_object }
+  let(:response_hash) do
+    { _response: response }
+  end
+
+  let(:resources_collection) do
+    [
+      { id: 1, username: 'mies_1' },
+      { id: 2, username: 'mies_2' }
+    ]
+  end
+
+  let(:collection) { described_class.new dummy_class, resources_collection, response_hash }
+
+  specify { expect(described_class).to include Enumerable }
+
+  describe '#[]' do
+    let(:to_a) { collection.dup.to_a }
+
+    it 'delegates to the #to_a' do
+      expect(collection[0].id).to eql to_a[0].id
+    end
+  end
+
+  describe '#at' do
+    let(:to_a) { collection.dup.to_a }
+
+    it 'delegates to the #to_a' do
+      expect(collection.at(0).id).to eql to_a.at(0).id
+    end
+  end
+
+  describe '#reverse' do
+    let(:to_a) { collection.dup.to_a }
+
+    it 'delegates to the #to_a' do
+      expect(collection.reverse[0].id).to eql to_a.reverse[0].id
+    end
+  end
+
+  describe '#size' do
+    let(:to_a) { collection.dup.to_a }
+
+    it 'delegates to the #to_a' do
+      expect(collection.size).to eql to_a.size
+    end
+  end
+
+  describe '#each' do
+    context 'when the resources_collection is an Array' do
+      it 'instantiates each element in the resources_collection as resource' do
+        expect(dummy_class).to receive(:new).with(resources_collection[0].merge(response_hash)).and_call_original
+        expect(dummy_class).to receive(:new).with(resources_collection[1].merge(response_hash)).and_call_original
+        collection.all?
+      end
+
+      it 'returns an Enumerable' do
+        expect(collection).to be_an Enumerable
+      end
+
+      context 'Enumerable' do
+        it 'includes the resources' do
+          expect(collection[0]).to be_a RemoteResource::CollectionDummy
+          expect(collection[1]).to be_a RemoteResource::CollectionDummy
+        end
+
+        it 'includes the instantiated resources' do
+          expect(collection[0].username).to eql 'mies_1'
+          expect(collection[1].username).to eql 'mies_2'
+        end
+
+        it 'includes the responses in the instantiated resources' do
+          expect(collection[0]._response).to eql response
+          expect(collection[1]._response).to eql response
+        end
+      end
+    end
+
+    context 'when the resources_collection is NOT an Array' do
+      let(:resources_collection) { {} }
+
+      it 'returns nil' do
+        expect(collection.each).to be_nil
+      end
+    end
+  end
+
+  describe '#empty?' do
+    context 'when the resources_collection is nil' do
+      let(:resources_collection) { nil }
+
+      it 'returns true' do
+        expect(collection.empty?).to eql true
+      end
+    end
+
+    context 'when the resources_collection is blank' do
+      let(:resources_collection) { '' }
+
+      it 'returns true' do
+        expect(collection.empty?).to eql true
+      end
+    end
+
+    context 'when the resources_collection is NOT nil or blank' do
+      it 'returns false' do
+        expect(collection.empty?).to eql false
+      end
+    end
+  end
+
+  describe '#success?' do
+    context 'when response is successful' do
+      before { allow(response).to receive(:success?) { true } }
+
+      it 'returns true' do
+        expect(collection.success?).to eql true
+      end
+    end
+
+    context 'when response is NOT successful' do
+      before { allow(response).to receive(:success?) { false } }
+
+      it 'returns false' do
+        expect(collection.success?).to eql false
+      end
+    end
+  end
+
+
+end

data/spec/lib/remote_resource/connection_options_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe RemoteResource::ConnectionOptions do
+
+  module RemoteResource
+    class ConnectionOptionsDummy
+      include RemoteResource::Base
+
+      self.site           = 'https://foobar.com'
+      self.content_type   = ''
+      self.extra_headers  = { "X-Locale" => "nl" }
+      self.version        = '/v1'
+      self.path_prefix    = '/prefix'
+      self.path_postfix   = '/postfix'
+      self.content_type   = '.json'
+      self.collection     = true
+      self.root_element   = :test_dummy
+
+    end
+  end
+
+  let(:dummy_class) { RemoteResource::ConnectionOptionsDummy }
+  let(:dummy)       { dummy_class.new }
+
+  let(:connection_options) { described_class.new dummy_class }
+
+  describe '#initialize' do
+    it 'assigns the given class as #base_class' do
+      allow_any_instance_of(described_class).to receive(:initialize_connection_options)
+
+      expect(connection_options.base_class).to eql RemoteResource::ConnectionOptionsDummy
+    end
+
+    context 'RemoteResource::Base::OPTIONS' do
+      it 'calls #initialize_connection_options' do
+        expect_any_instance_of(described_class).to receive(:initialize_connection_options)
+        connection_options
+      end
+
+      it 'sets the accessor of the option from the RemoteResource::Base::OPTIONS' do
+        RemoteResource::Base::OPTIONS.each do |option|
+          expect(connection_options).to respond_to "#{option}"
+          expect(connection_options).to respond_to "#{option}="
+        end
+      end
+
+      it 'assigns the value of the option from the RemoteResource::Base::OPTIONS' do
+        RemoteResource::Base::OPTIONS.each do |option|
+          expect(connection_options.public_send(option)).to eql dummy_class.public_send(option)
+        end
+      end
+    end
+  end
+
+  describe '#merge' do
+    let(:custom_connection_options) do
+      {
+        site: 'https://dummy.foobar.com',
+        content_type: '.xml',
+        root_element: :test_dummy_api
+      }
+    end
+
+    it 'merges the custom connection_options in the connection_options' do
+      connection_options.merge custom_connection_options
+
+      expect(connection_options.site).to eql 'https://dummy.foobar.com'
+      expect(connection_options.content_type).to eql '.xml'
+      expect(connection_options.root_element).to eql :test_dummy_api
+    end
+
+    it 'returns self' do
+      expect(connection_options.merge custom_connection_options).to eql connection_options
+    end
+  end
+
+  describe '#to_hash' do
+    let(:connection_options_hash) do
+      {
+        base_url:         'https://foobar.com/v1/prefix/connection_options_dummies/postfix',
+        site:             'https://foobar.com',
+        headers:          { "Accept" => "application/json", "X-Locale" => "nl" },
+        version:          '/v1',
+        path_prefix:      '/prefix',
+        path_postfix:     '/postfix',
+        content_type:     '.json',
+        collection:       true,
+        collection_name:  nil,
+        root_element:     :test_dummy
+      }
+    end
+
+    it 'returns the connection_options as Hash' do
+      expect(connection_options.to_hash).to eql connection_options_hash
+    end
+  end
+
+  describe '#reload' do
+    it 'does NOT return self' do
+      expect(connection_options.reload).not_to eql connection_options
+    end
+
+    context 'RemoteResource::Base::OPTIONS' do
+      it 'calls #initialize_connection_options' do
+        expect_any_instance_of(described_class).to receive(:initialize_connection_options).twice
+        connection_options.reload
+      end
+    end
+  end
+
+  describe '#reload!' do
+    it 'returns self' do
+      expect(connection_options.reload!).to eql connection_options
+    end
+
+    context 'RemoteResource::Base::OPTIONS' do
+      it 'calls #initialize_connection_options' do
+        expect_any_instance_of(described_class).to receive(:initialize_connection_options).twice
+        connection_options.reload!
+      end
+    end
+  end
+
+end