ddy_remote_resource 1.0.0.rc2 → 1.0.0.rc3

data/spec/lib/remote_resource/base_spec.rb

@@ -8,6 +8,8 @@ RSpec.describe RemoteResource::Base do
 
       self.site = 'https://foobar.com'
 
+      attr_accessor :name
+
     end
   end
 
@@ -184,47 +186,42 @@ RSpec.describe RemoteResource::Base do
   end
 
   describe '#success?' do
-    let(:response) { instance_double(RemoteResource::Response) }
-
-    before { allow(dummy).to receive(:_response) { response } }
-
-    context 'when response is successful' do
-      before { allow(response).to receive(:success?) { true } }
+    context 'when last response is successful' do
+      it 'returns true' do
+        dummy.last_response = instance_double(RemoteResource::Response, success?: true)
 
-      context 'and the resource has NO errors present' do
-        it 'returns true' do
-          expect(dummy.success?).to eql true
-        end
+        expect(dummy.success?).to eql true
       end
+    end
 
-      context 'and the resource has errors present' do
-        it 'returns false' do
-          dummy.errors.add :id, 'must be present'
+    context 'when last response is successful and (validation) errors are present' do
+      it 'returns false' do
+        dummy.last_response = instance_double(RemoteResource::Response, success?: true)
+        dummy.errors.add(:id, 'is invalid')
 
-          expect(dummy.success?).to eql false
-        end
+        expect(dummy.success?).to eql false
       end
     end
 
-    context 'when response is NOT successful' do
-      before { allow(response).to receive(:success?) { false } }
-
+    context 'when last response is NOT successful' do
       it 'returns false' do
+        dummy.last_response = instance_double(RemoteResource::Response, success?: false)
+
         expect(dummy.success?).to eql false
       end
     end
   end
 
   describe '#errors?' do
-    context 'when resource has errors present' do
+    context 'when (validation) errors are present' do
       it 'returns true' do
-        dummy.errors.add :id, 'must be present'
+        dummy.errors.add(:id, 'is invalid')
 
         expect(dummy.errors?).to eql true
       end
     end
 
-    context 'when resource has NO errors present' do
+    context 'when (validation) errors are NOT present' do
       it 'returns false' do
         expect(dummy.errors?).to eql false
       end
@@ -232,55 +229,70 @@ RSpec.describe RemoteResource::Base do
   end
 
   describe '#handle_response' do
-    let(:response) { instance_double(RemoteResource::Response) }
-
-    before { allow(dummy).to receive(:rebuild_resource_from_response) { dummy } }
-
     context 'when the response is a unprocessable_entity' do
-      before do
-        allow(response).to receive(:unprocessable_entity?) { true }
+      let(:response) { instance_double(RemoteResource::Response, success?: false, unprocessable_entity?: true, attributes: {}, errors: { 'name' => ['is required'] }, meta: {}, request: instance_double(RemoteResource::Request)) }
 
-        allow(dummy).to receive(:assign_errors_from_response)
+      it 'calls #rebuild_resource_from_response with the response' do
+        expect(dummy).to receive(:rebuild_resource_from_response).with(response).and_call_original
+        dummy.handle_response(response)
       end
 
-      it 'rebuilds the resource from the response' do
-        expect(dummy).to receive(:rebuild_resource_from_response).with response
-        dummy.handle_response response
+      it 'calls #assign_errors_from_response with the response' do
+        expect(dummy).to receive(:assign_errors_from_response).with(response).and_call_original
+        dummy.handle_response(response)
       end
 
-      it 'assigns the errors from the response to the resource' do
-        expect(dummy).to receive(:assign_errors_from_response).with response
-        dummy.handle_response response
+      it 'returns the same resource' do
+        expected_object_id = dummy.object_id
+
+        expect(dummy.handle_response(response).object_id).to eql expected_object_id
       end
     end
 
     context 'when the response is NOT a unprocessable_entity' do
-      before { allow(response).to receive(:unprocessable_entity?) { false } }
+      let(:response) { instance_double(RemoteResource::Response, success?: true, unprocessable_entity?: false, attributes: { 'id' => 12, 'name' => 'Mies' }, errors: {}, meta: {}, request: instance_double(RemoteResource::Request)) }
 
-      it 'rebuilds the resource from the response' do
-        expect(dummy).to receive(:rebuild_resource_from_response).with response
-        dummy.handle_response response
+      it 'calls #rebuild_resource_from_response with the response' do
+        expect(dummy).to receive(:rebuild_resource_from_response).with(response).and_call_original
+        dummy.handle_response(response)
+      end
+
+      it 'does NOT calls #assign_errors_from_response' do
+        expect(dummy).not_to receive(:assign_errors_from_response)
+        dummy.handle_response(response)
       end
-    end
-  end
 
-  describe '#assign_response' do
-    let(:response) { instance_double(RemoteResource::Response) }
+      it 'returns the same resource' do
+        expected_object_id = dummy.object_id
 
-    it 'assigns the #_response' do
-      expect{ dummy.assign_response response }.to change{ dummy._response }.from(nil).to response
+        expect(dummy.handle_response(response).object_id).to eql expected_object_id
+      end
     end
   end
 
   describe '#assign_errors_from_response' do
-    let(:response)                      { instance_double(RemoteResource::Response) }
-    let(:error_messages_response_body)  { double('error_messages_response_body') }
+    let(:response) { instance_double(RemoteResource::Response, success?: false, unprocessable_entity?: true, attributes: {}, errors: { 'name' => ['is required'], 'virtual_attribute' => ['is invalid'] }, meta: {}, request: instance_double(RemoteResource::Request)) }
 
-    it 'calls the #assign_errors method with the #error_messages_response_body of the response' do
-      allow(response).to receive(:error_messages_response_body) { error_messages_response_body }
+    it 'calls #assign_errors with the errors of the response' do
+      expect(dummy).to receive(:assign_errors).with(response.errors).and_call_original
+      dummy.assign_errors_from_response(response)
+    end
+
+    it 'assigns the errors of the response' do
+      expect(dummy.errors).to be_blank
+
+      dummy.assign_errors_from_response(response)
+
+      expect(dummy.errors).to be_present
+      expect(dummy.errors[:name]).to match_array ['is required']
+      expect(dummy.errors[:base]).to match_array ['is invalid']
+    end
+  end
 
-      expect(dummy).to receive(:assign_errors).with error_messages_response_body
-      dummy.assign_errors_from_response response
+  describe '#_response' do
+    it 'warns that the method is deprecated' do
+      expect(dummy).to receive(:warn).with('[DEPRECATION] `._response` is deprecated. Please use `.last_response` instead.')
+      dummy._response
     end
   end
 

data/spec/lib/remote_resource/builder_spec.rb

@@ -8,7 +8,7 @@ RSpec.describe RemoteResource::Builder do
 
       self.site = 'https://foobar.com'
 
-      attr_accessor :username
+      attr_accessor :name
 
     end
   end
@@ -16,245 +16,241 @@ RSpec.describe RemoteResource::Builder do
   let(:dummy_class) { RemoteResource::BuilderDummy }
   let(:dummy)       { dummy_class.new }
 
+  let(:request) { instance_double(RemoteResource::Request) }
+  let(:response) { instance_double(RemoteResource::Response, request: request, attributes: {}, meta: { 'total' => 10 }) }
+
   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
-    let(:sanitized_response_meta) do
-      { 'total' => '1'}
-    end
+    let(:response) { instance_double(RemoteResource::Response, request: request, attributes: { 'id' => 12, 'name' => 'Mies' }, meta: { 'total' => 10 }) }
 
-    before do
-      allow(response).to receive(:sanitized_response_body) { sanitized_response_body }
-      allow(response).to receive(:sanitized_response_meta) { sanitized_response_meta }
-    end
+    it 'returns the instantiated resource from the response' do
+      result = dummy_class.build_resource_from_response(response)
 
-    it 'calls the .build_resource' do
-      expect(dummy_class).to receive(:build_resource).with sanitized_response_body, { _response: an_instance_of(RemoteResource::Response), meta: sanitized_response_meta }
-      dummy_class.build_resource_from_response response
+      aggregate_failures do
+        expect(result).to be_a dummy_class
+        expect(result.id).to eql 12
+        expect(result.name).to eql 'Mies'
+      end
     end
-  end
 
-  describe '.build_resource' do
-    let(:response)      { RemoteResource::Response.new double.as_null_object }
-    let(:response_hash) { dummy_class.send :response_hash, response }
+    it 'includes the last request, last response and meta information in the instantiated resource' do
+      result = dummy_class.build_resource_from_response(response)
 
-    context 'when collection is a Hash' do
-      let(:collection) do
-        { "id" => "12", "username" => "foobar" }
+      aggregate_failures do
+        expect(result.last_request).to eql request
+        expect(result.last_response).to eql response
+        expect(result.meta).to eql({ 'total' => 10 })
       end
+    end
+  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
+  describe '.build_resource' do
+    let(:collection) do
+      { 'id' => 12, 'name' => 'Mies' }
+    end
 
-        it 'returns the resource' do
-          expect(dummy_class.build_resource collection, response_hash).to be_a dummy_class
-        end
-      end
+    it 'instantiates the resource from the given collection and options' do
+      expect(dummy_class).to receive(:new).with(collection.merge({ meta: 'meta' })).and_call_original
+      dummy_class.build_resource(collection, { meta: 'meta' })
+    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 instantiated resource' do
+      result = dummy_class.build_resource(collection)
 
-        it 'returns the resource' do
-          expect(dummy_class.build_resource collection).to be_a dummy_class
-        end
+      aggregate_failures do
+        expect(result).to be_a dummy_class
+        expect(result.id).to eql 12
+        expect(result.name).to eql 'Mies'
       end
     end
 
-    context 'when collection is NOT a Hash' do
-      let(:collection) { [] }
-
+    context 'when the given collection is NOT a Hash' do
       it 'returns nil' do
-        expect(dummy_class.build_resource collection, response_hash).to be_nil
+        aggregate_failures do
+          expect(dummy_class.build_resource(nil)).to be_nil
+          expect(dummy_class.build_resource([])).to be_nil
+          expect(dummy_class.build_resource('')).to be_nil
+        end
       end
     end
   end
 
   describe '.build_collection_from_response' do
-    let(:response)                { RemoteResource::Response.new double.as_null_object }
-    let(:sanitized_response_body) do
+    let(:attributes) do
       [
-        { "id" => "10", "username" => "foobar" },
-        { "id" => "11", "username" => "bazbar" },
-        { "id" => "12", "username" => "aapmies" }
+        { 'id' => 10, 'name' => 'Mies' },
+        { 'id' => 11, 'name' => 'Aap' },
+        { 'id' => 12, 'name' => 'Noot' }
       ]
     end
-    let(:sanitized_response_meta) do
-      { 'total' => '3'}
+    let(:response) { instance_double(RemoteResource::Response, request: request, attributes: attributes, meta: { 'total' => 10 }) }
+
+    it 'returns the collection of instantiated resources from the response' do
+      result = dummy_class.build_collection_from_response(response)
+
+      aggregate_failures do
+        expect(result).to be_a RemoteResource::Collection
+        expect(result[0]).to be_a dummy_class
+        expect(result[0].id).to eql 10
+        expect(result[0].name).to eql 'Mies'
+        expect(result[1]).to be_a dummy_class
+        expect(result[1].id).to eql 11
+        expect(result[1].name).to eql 'Aap'
+        expect(result[2]).to be_a dummy_class
+        expect(result[2].id).to eql 12
+        expect(result[2].name).to eql 'Noot'
+      end
     end
 
-    before do
-      allow(response).to receive(:sanitized_response_body) { sanitized_response_body }
-      allow(response).to receive(:sanitized_response_meta) { sanitized_response_meta }
-    end
+    it 'includes the last request, last response and meta information in the collection of instantiated resources' do
+      result = dummy_class.build_collection_from_response(response)
 
-    it 'calls the .build_collection' do
-      expect(dummy_class).to receive(:build_collection).with sanitized_response_body, { _response: an_instance_of(RemoteResource::Response), meta: sanitized_response_meta }
-      dummy_class.build_collection_from_response response
+      aggregate_failures do
+        expect(result.last_request).to eql request
+        expect(result.last_response).to eql response
+        expect(result.meta).to eql({ 'total' => 10 })
+      end
     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
+    let(:collection) do
+      [
+        { 'id' => 10, 'name' => 'Mies' },
+        { 'id' => 11, 'name' => 'Aap' },
+        { 'id' => 12, 'name' => 'Noot' }
+      ]
+    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 'instantiates collection of resources from the given collection and options' do
+      expect(RemoteResource::Collection).to receive(:new).with(dummy_class, collection, { meta: 'meta' }).and_call_original
+      dummy_class.build_collection(collection, { meta: 'meta' })
+    end
 
-        it 'returns the resources' do
-          resources = dummy_class.build_collection collection
-          resources.each { |resource| expect(resource).to be_a dummy_class }
-        end
+    it 'returns the collection of instantiated resources' do
+      result = dummy_class.build_collection(collection)
+
+      aggregate_failures do
+        expect(result).to be_a RemoteResource::Collection
+        expect(result[0]).to be_a dummy_class
+        expect(result[0].id).to eql 10
+        expect(result[0].name).to eql 'Mies'
+        expect(result[1]).to be_a dummy_class
+        expect(result[1].id).to eql 11
+        expect(result[1].name).to eql 'Aap'
+        expect(result[2]).to be_a dummy_class
+        expect(result[2].id).to eql 12
+        expect(result[2].name).to eql 'Noot'
       end
     end
 
-    context 'when collection is NOT an Array' do
-      let(:collection) { {} }
-
+    context 'when the given collection is NOT an Array' do
       it 'returns nil' do
-        expect(dummy_class.build_collection collection, response_hash).to be_nil
+        aggregate_failures do
+          expect(dummy_class.build_collection(nil)).to be_nil
+          expect(dummy_class.build_collection({})).to be_nil
+          expect(dummy_class.build_collection('')).to be_nil
+        end
       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
-    let(:sanitized_response_meta) do
-      { 'total' => '1'}
-    end
+    let(:response) { instance_double(RemoteResource::Response, request: request, attributes: { 'name' => 'Mies' }, meta: { 'total' => 10 }) }
 
-    before do
-      allow(response).to receive(:sanitized_response_body) { sanitized_response_body }
-      allow(response).to receive(:sanitized_response_meta) { sanitized_response_meta }
-    end
+    before { dummy.id = 12 }
 
-    it 'calls the #rebuild_resource' do
-      expect(dummy).to receive(:rebuild_resource).with sanitized_response_body, { _response: an_instance_of(RemoteResource::Response), meta: sanitized_response_meta }
-      dummy.rebuild_resource_from_response response
-    end
-  end
+    it 'returns the same resource' do
+      expected_object_id = dummy.object_id
 
-  describe '#rebuild_resource' do
-    let(:response)      { RemoteResource::Response.new double.as_null_object }
-    let(:response_hash) { dummy.send :response_hash, response }
+      result = dummy.rebuild_resource_from_response(response)
 
-    before do
-      dummy.id       = nil
-      dummy.username = "foo"
+      expect(result.object_id).to eql expected_object_id
     end
 
-    context 'when the collection is a Hash' do
-      let(:collection) do
-        { "id" => "12", "username" => "foobar" }
+    it 'updates the resource from the response' do
+      aggregate_failures do
+        expect(dummy.id).to eql 12
+        expect(dummy.name).to be_blank
       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
+      dummy.rebuild_resource_from_response(response)
 
-        it 'returns the resource' do
-          expect(dummy.rebuild_resource collection, response_hash).to be_a dummy_class
-        end
+      aggregate_failures do
+        expect(dummy.id).to eql 12
+        expect(dummy.name).to eql 'Mies'
       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
+    it 'includes the last request, last response and meta information in the resource' do
+      aggregate_failures do
+        expect(dummy.last_request).to be_blank
+        expect(dummy.last_response).to be_blank
+        expect(dummy.meta).to be_blank
+      end
 
-          expect(dummy.id).to eql '12'
-          expect(dummy.username).to eql 'foobar'
-          expect(dummy._response).to be_nil
-        end
+      dummy.rebuild_resource_from_response(response)
 
-        it 'returns the resource' do
-          expect(dummy.rebuild_resource collection).to be_a dummy_class
-        end
+      aggregate_failures do
+        expect(dummy.last_request).to eql request
+        expect(dummy.last_response).to eql response
+        expect(dummy.meta).to eql({ 'total' => 10 })
       end
     end
+  end
 
-    context 'when the collection is something else' do
-      let(:collection)  { 'foobar' }
+  describe '#rebuild_resource' do
+    let(:collection) do
+      { 'name' => 'Mies' }
+    end
 
-      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
+    before { dummy.id = 12 }
 
-          dummy.rebuild_resource collection, response_hash
+    it 'returns the same resource' do
+      expected_object_id = dummy.object_id
 
-          expect(dummy.id).to be_nil
-          expect(dummy.username).to eql 'foo'
-          expect(dummy._response).to be_a RemoteResource::Response
-        end
+      result = dummy.rebuild_resource(collection)
 
-        it 'returns the resource' do
-          expect(dummy.rebuild_resource collection, response_hash).to be_a dummy_class
-        end
+      expect(result.object_id).to eql expected_object_id
+    end
+
+    it 'updates the resource, using mass-assignment, from the given collection and options' do
+      expect(dummy).to receive(:attributes=).with(collection.merge({ meta: 'meta' })).and_call_original
+      dummy.rebuild_resource(collection, { meta: 'meta' })
+    end
+
+    it 'updates the resource' do
+      aggregate_failures do
+        expect(dummy.id).to eql 12
+        expect(dummy.name).to be_blank
       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)
 
-          dummy.rebuild_resource collection
+      aggregate_failures do
+        expect(dummy.id).to eql 12
+        expect(dummy.name).to eql 'Mies'
+      end
+    end
 
-          expect(dummy.id).to be_nil
-          expect(dummy.username).to eql 'foo'
-          expect(dummy._response).to be_nil
+    context 'when the given collection is NOT a Hash' do
+      it 'does NOT update the resource' do
+        aggregate_failures do
+          expect { dummy.rebuild_resource(nil) }.not_to change { dummy.attributes }.from({ id: 12 })
+          expect { dummy.rebuild_resource([]) }.not_to change { dummy.attributes }.from({ id: 12 })
+          expect { dummy.rebuild_resource('') }.not_to change { dummy.attributes }.from({ id: 12 })
         end
+      end
+    end
 
-        it 'returns the resource' do
-          expect(dummy.rebuild_resource collection).to be_a dummy_class
+    context 'when the given collection is NOT a Hash and options are given' do
+      it 'updates the resource with only the options' do
+        aggregate_failures do
+          dummy.meta = nil
+          expect { dummy.rebuild_resource(nil, meta: { 'total' => 10 }) }.to change { dummy.meta }.to({ 'total' => 10 })
+          dummy.meta = nil
+          expect { dummy.rebuild_resource([], meta: { 'total' => 10 }) }.to change { dummy.meta }.to({ 'total' => 10 })
+          dummy.meta = nil
+          expect { dummy.rebuild_resource('', meta: { 'total' => 10 }) }.to change { dummy.meta }.to({ 'total' => 10 })
         end
       end
     end