ddy_remote_resource 1.0.0.rc2 → 1.0.0.rc3

data/spec/lib/remote_resource/collection_spec.rb

@@ -8,27 +8,27 @@ RSpec.describe RemoteResource::Collection do
 
       self.site = 'https://foobar.com'
 
-      attr_accessor :username
+      attr_accessor :name
     end
   end
 
   let(:dummy_class) { RemoteResource::CollectionDummy }
   let(:dummy)       { dummy_class.new }
 
-  let(:response) { RemoteResource::Response.new double.as_null_object }
-  let(:response_meta) { { total: '1' } }
-  let(:response_hash) do
-    { _response: response, meta: response_meta }
+  let(:request) { instance_double(RemoteResource::Request) }
+  let(:response) { instance_double(RemoteResource::Response) }
+  let(:options) do
+    { last_request: request, last_response: response, meta: { 'total' => 10 } }
   end
 
   let(:resources_collection) do
     [
-      { id: 1, username: 'mies_1' },
-      { id: 2, username: 'mies_2' }
+      { 'id' => 1, 'name' => 'mies_1' },
+      { 'id' => 2, 'name' => 'mies_2' }
     ]
   end
 
-  let(:collection) { described_class.new dummy_class, resources_collection, response_hash }
+  let(:collection) { described_class.new(dummy_class, resources_collection, options) }
 
   specify { expect(described_class).to include Enumerable }
 
@@ -66,9 +66,9 @@ RSpec.describe RemoteResource::Collection do
 
   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
+      it 'instantiates each element in the resources_collection as resource with the given options' do
+        expect(dummy_class).to receive(:new).with(resources_collection[0].merge(options)).and_call_original
+        expect(dummy_class).to receive(:new).with(resources_collection[1].merge(options)).and_call_original
         collection.all?
       end
 
@@ -78,24 +78,38 @@ RSpec.describe RemoteResource::Collection do
 
       context 'Enumerable' do
         it 'includes the resources' do
-          expect(collection[0]).to be_a RemoteResource::CollectionDummy
-          expect(collection[1]).to be_a RemoteResource::CollectionDummy
+          aggregate_failures do
+            expect(collection[0]).to be_a RemoteResource::CollectionDummy
+            expect(collection[1]).to be_a RemoteResource::CollectionDummy
+          end
         end
 
         it 'includes the instantiated resources' do
-          expect(collection[0].username).to eql 'mies_1'
-          expect(collection[1].username).to eql 'mies_2'
+          aggregate_failures do
+            expect(collection[0].id).to eql 1
+            expect(collection[0].name).to eql 'mies_1'
+
+            expect(collection[1].id).to eql 2
+            expect(collection[1].name).to eql 'mies_2'
+          end
         end
 
-        it 'includes the responses in the instantiated resources' do
-          expect(collection[0]._response).to eql response
-          expect(collection[1]._response).to eql response
+        it 'includes the last request, last response and meta information in the instantiated resources' do
+          aggregate_failures do
+            expect(collection[0].last_request).to eql request
+            expect(collection[0].last_response).to eql response
+            expect(collection[0].meta).to eql({ 'total' => 10 })
+
+            expect(collection[1].last_request).to eql request
+            expect(collection[1].last_response).to eql response
+            expect(collection[1].meta).to eql({ 'total' => 10 })
+          end
         end
       end
 
       it 'returns the same objects each time' do
         expected = collection.collect(&:object_id)
-        actual = collection.collect(&:object_id)
+        actual   = collection.collect(&:object_id)
 
         aggregate_failures do
           expect(expected.length).to eq(2)
@@ -138,26 +152,79 @@ RSpec.describe RemoteResource::Collection do
   end
 
   describe '#success?' do
-    context 'when response is successful' do
-      before { allow(response).to receive(:success?) { true } }
-
+    context 'when last response is successful' do
       it 'returns true' do
+        collection.last_response = instance_double(RemoteResource::Response, success?: true)
+
         expect(collection.success?).to eql true
       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
+        collection.last_response = instance_double(RemoteResource::Response, success?: false)
+
         expect(collection.success?).to eql false
       end
     end
   end
 
+  describe '#last_request' do
+    context 'when last request is in the options' do
+      it 'returns the last request of the options' do
+        expect(collection.last_request).to eql request
+      end
+    end
+
+    context 'when last request is set' do
+      let(:other_request) { instance_double(RemoteResource::Request) }
+
+      it 'returns the set request' do
+        collection.last_request = other_request
+
+        expect(collection.last_request).to eql other_request
+      end
+    end
+  end
+
+  describe '#last_response' do
+    context 'when last response is in the options' do
+      it 'returns the last response of the options' do
+        expect(collection.last_response).to eql response
+      end
+    end
+
+    context 'when last response is set' do
+      let(:other_response) { instance_double(RemoteResource::Response) }
+
+      it 'returns the set response' do
+        collection.last_response = other_response
+
+        expect(collection.last_response).to eql other_response
+      end
+    end
+  end
+
   describe '#meta' do
-    it 'returns :meta' do
-      expect(collection.meta).to eql(response_meta)
+    context 'when meta information is in the options' do
+      it 'returns the meta information of the options' do
+        expect(collection.meta).to eql({ 'total' => 10 })
+      end
+    end
+
+    context 'when meta is set' do
+      it 'returns the set meta information' do
+        collection.meta = { 'total' => 15 }
+
+        expect(collection.meta).to eql({ 'total' => 15 })
+      end
+    end
+  end
+
+  describe '#_response' do
+    it 'warns that the method is deprecated' do
+      expect(collection).to receive(:warn).with('[DEPRECATION] `._response` is deprecated. Please use `.last_response` instead.')
+      collection._response
     end
   end
 

data/spec/lib/remote_resource/request_spec.rb

@@ -118,16 +118,26 @@ RSpec.describe RemoteResource::Request do
 
     shared_examples 'a conditional construct for the response' do
       context 'when the response is #success?' do
-        it 'returns a RemoteResource::Response object' do
-          expect(request.perform).to be_a RemoteResource::Response
+        it 'returns a RemoteResource::Response object with the request' do
+          aggregate_failures do
+            result = request.perform
+
+            expect(result).to be_a RemoteResource::Response
+            expect(result.request).to eql request
+          end
         end
       end
 
       context 'when the response is #unprocessable_entity? (response_code=422)' do
         let(:response_code) { 422 }
 
-        it 'returns a RemoteResource::Response object' do
-          expect(request.perform).to be_a RemoteResource::Response
+        it 'returns a RemoteResource::Response object with the request' do
+          aggregate_failures do
+            result = request.perform
+
+            expect(result).to be_a RemoteResource::Response
+            expect(result.request).to eql request
+          end
         end
       end
 

data/spec/lib/remote_resource/response_spec.rb

@@ -2,252 +2,185 @@ require 'spec_helper'
 
 RSpec.describe RemoteResource::Response do
 
-  describe '#original_response' do
-    it 'is private' do
-      expect(described_class.private_method_defined?(:original_response)).to be_truthy
+  module RemoteResource
+    class ResponseDummy
+      include RemoteResource::Base
+
+      self.site = 'http://www.foobar.com'
+
+      attr_accessor :name
+
     end
   end
 
-  describe '#original_request' do
-    it 'is private' do
-      expect(described_class.private_method_defined?(:original_request)).to be_truthy
-    end
+  let(:dummy_class) { RemoteResource::ResponseDummy }
+  let(:dummy)       { dummy_class.new(id: '12') }
+
+  let(:connection_options) do
+    { collection: true }
   end
+  let(:request)             { RemoteResource::Request.new(dummy_class, :post, { name: 'Mies' }, connection_options) }
+  let(:connection_response) { Typhoeus::Response.new(mock: true, code: 201, body: { id: 12, name: 'Mies' }.to_json, headers: { 'Content-Type' => 'application/json', 'Server' => 'nginx/1.4.6 (Ubuntu)' }) }
+  let(:connection_request)  { Typhoeus::Request.new('http://www.foobar.com/response_dummies.json', method: :post, body: { name: 'Mies' }.to_json, headers: { 'Content-Type' => 'application/json' }) }
 
-  describe 'Typhoeus::Response' do
-    let(:typhoeus_options)  { { body: 'typhoeus_response_body', code: 200, headers: { 'Content-Type' => 'application/json', 'Server' => 'nginx/1.4.6 (Ubuntu)' } } }
-    let(:typhoeus_response) { Typhoeus::Response.new typhoeus_options }
-    let(:response)          { described_class.new typhoeus_response }
+  let(:response) { described_class.new(connection_response, connection_options.merge(request: request, connection_request: connection_request)) }
 
-    describe '#success?' do
-      it 'calls the Typhoeus::Response#success?' do
-        expect(typhoeus_response).to receive(:success?)
-        response.success?
+  describe '#request' do
+    it 'returns the RemoteResource::Request' do
+      aggregate_failures do
+        expect(response.request).to be_a RemoteResource::Request
+        expect(response.request).to eql request
       end
     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'
+  describe '#success?' do
+    context 'when the response is successful' do
+      it 'returns true' do
+        expect(response.success?).to eql true
       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
+    context 'when the response is NOT successful' do
+      let(:connection_response) { Typhoeus::Response.new(mock: true, code: 422, body: { errors: { name: ['is invalid'] } }.to_json, headers: { 'Content-Type' => 'application/json', 'Server' => 'nginx/1.4.6 (Ubuntu)' }) }
 
-    describe '#response_headers' do
-      it 'returns the response headers of the original response' do
-        expect(response.response_headers).to eql({ 'Content-Type' => 'application/json', 'Server' => 'nginx/1.4.6 (Ubuntu)' })
+      it 'returns false' do
+        expect(response.success?).to eql false
       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 }
+      let(:connection_response) { Typhoeus::Response.new(mock: true, code: 422, body: { errors: { name: ['is invalid'] } }.to_json, headers: { 'Content-Type' => 'application/json', 'Server' => 'nginx/1.4.6 (Ubuntu)' }) }
 
-        expect(response.unprocessable_entity?).to be_truthy
+      it 'returns true' do
+        expect(response.unprocessable_entity?).to eql true
       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
+        expect(response.unprocessable_entity?).to eql false
       end
     end
   end
 
-  describe '#sanitized_response_body' do
-    let(:response) { described_class.new double.as_null_object }
+  describe '#response_code' do
+    it 'returns the response code' do
+      expect(response.response_code).to eql 201
+    end
+  end
 
-    before { allow(response).to receive(:response_body) { response_body } }
+  describe '#headers' do
+    it 'returns the response headers' do
+      expect(response.headers).to eql({ 'Content-Type' => 'application/json', 'Server' => 'nginx/1.4.6 (Ubuntu)' })
+    end
+  end
 
-    context 'when response_body is nil' do
-      let(:response_body) { nil }
+  describe '#body' do
+    it 'returns the response body' do
+      expect(response.body).to eql '{"id":12,"name":"Mies"}'
+    end
+  end
 
-      it 'returns an empty Hash' do
-        expect(response.sanitized_response_body).to eql({})
-      end
+  describe '#parsed_body' do
+    it 'returns the parsed JSON of the response body' do
+      expect(response.parsed_body).to eql({ 'id' => 12, 'name' => 'Mies' })
     end
 
-    context 'when response_body is empty' do
-      let(:response_body) { '' }
+    context 'when the response body is nil' do
+      let(:connection_response) { Typhoeus::Response.new(mock: true, code: 500, body: nil, headers: { 'Content-Type' => 'application/json', 'Server' => 'nginx/1.4.6 (Ubuntu)' }) }
 
       it 'returns an empty Hash' do
-        expect(response.sanitized_response_body).to eql({})
+        expect(response.parsed_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 }
+    context 'when the response body is empty' do
+      let(:connection_response) { Typhoeus::Response.new(mock: true, code: 500, body: '', headers: { 'Content-Type' => 'application/json', 'Server' => 'nginx/1.4.6 (Ubuntu)' }) }
 
       it 'returns an empty Hash' do
-        expect(response.sanitized_response_body).to eql({})
+        expect(response.parsed_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"}}' }
+    context 'when the response body is NOT JSON' do
+      let(:connection_response) { Typhoeus::Response.new(mock: true, code: 500, body: 'foo', headers: { 'Content-Type' => 'application/json', 'Server' => 'nginx/1.4.6 (Ubuntu)' }) }
 
-        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
+      it 'returns an empty Hash' do
+        expect(response.parsed_body).to eql({})
       end
     end
   end
 
-  describe '#sanitized_response_meta' do
-    let(:response) { described_class.new double.as_null_object }
-
-    before { allow(response).to receive(:response_body) { response_body } }
+  describe '#attributes' do
+    it 'returns the attributes from the parsed response body' do
+      expect(response.attributes).to eql({ 'id' => 12, 'name' => 'Mies' })
+    end
 
-    context 'when response_body is nil' do
-      let(:response_body) { nil }
+    context 'when connection_options[:root_element] is present' do
+      let(:connection_options) do
+        { root_element: :data, collection: true }
+      end
+      let(:connection_response) { Typhoeus::Response.new(mock: true, code: 201, body: { data: { id: 12, name: 'Mies' } }.to_json, headers: { 'Content-Type' => 'application/json', 'Server' => 'nginx/1.4.6 (Ubuntu)' }) }
 
-      it 'returns an empty Hash' do
-        expect(response.sanitized_response_meta).to eql({})
+      it 'returns the attributes wrapped in the connection_options[:root_element] from the parsed response body' do
+        expect(response.attributes).to eql({ 'id' => 12, 'name' => 'Mies' })
       end
     end
 
-    context 'when response_body is empty' do
-      let(:response_body) { '' }
+    context 'when the parsed response body is NOT present' do
+      let(:connection_response) { Typhoeus::Response.new(mock: true, code: 500, body: '', headers: { 'Content-Type' => 'application/json', 'Server' => 'nginx/1.4.6 (Ubuntu)' }) }
 
       it 'returns an empty Hash' do
-        expect(response.sanitized_response_meta).to eql({})
+        expect(response.attributes).to eql({})
       end
     end
+  end
 
-    context 'when response_body is NOT parseable' do
-      let(:response_body) { 'foo' }
-
-      before { allow(JSON).to receive(:parse).and_raise JSON::ParserError }
+  describe '#errors' do
+    context 'when the parsed response body contains "errors"' do
+      let(:connection_response) { Typhoeus::Response.new(mock: true, code: 422, body: { errors: { name: ['is invalid'] } }.to_json, headers: { 'Content-Type' => 'application/json', 'Server' => 'nginx/1.4.6 (Ubuntu)' }) }
 
-      it 'returns an empty Hash' do
-        expect(response.sanitized_response_meta).to eql({})
+      it 'returns the errors from the parsed response body' do
+        expect(response.errors).to eql({ 'name' => ['is invalid'] })
       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"},"meta":{"total":"1"}}' }
-
-        it 'returns the parsed meta from root' do
-          expect(response.sanitized_response_meta).to match({ 'total' => '1' })
-        end
+    context 'when the attributes contains "errors", e.g. when connection_options[:root_element] is present' do
+      let(:connection_options) do
+        { root_element: :data, collection: true }
       end
+      let(:connection_response) { Typhoeus::Response.new(mock: true, code: 422, body: { data: { errors: { name: ['is invalid'] } } }.to_json, headers: { 'Content-Type' => 'application/json', 'Server' => 'nginx/1.4.6 (Ubuntu)' }) }
 
-      context 'and the connection_options do NOT contain a root_element' do
-        let(:response_body) { '{"id":"12","meta":{"total":"1"}}' }
-
-        it 'returns the parsed meta from root' do
-          expect(response.sanitized_response_meta).to match({ 'total' => '1' })
-        end
+      it 'returns the errors from the attributes' do
+        expect(response.errors).to eql({ 'name' => ['is invalid'] })
       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 }
 
+    context 'when the "errors" are NOT present' do
       it 'returns an empty Hash' do
-        expect(response.error_messages_response_body).to eql({})
+        expect(response.errors).to eql({})
       end
     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({})
+  describe '#meta' do
+    context 'when the parsed response body contains "meta"' do
+      let(:connection_options) do
+        { root_element: :data, collection: true }
       end
-    end
+      let(:connection_response) { Typhoeus::Response.new(mock: true, code: 201, body: { data: { id: 12, name: 'Mies' }, meta: { total: 10 } }.to_json, headers: { 'Content-Type' => 'application/json', 'Server' => 'nginx/1.4.6 (Ubuntu)' }) }
 
-    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({})
+      it 'returns the meta information from the parsed response body' do
+        expect(response.meta).to eql({ 'total' => 10 })
       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
+    context 'when the parsed response body does NOT contain "meta"' do
+      it 'returns an empty Hash' do
+        expect(response.meta).to eql({})
       end
     end
   end

data/spec/lib/remote_resource/version_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 RSpec.describe RemoteResource::VERSION do
-  it { is_expected.to eql '1.0.0.rc2' }
+  it { is_expected.to eql '1.0.0.rc3' }
 end
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddy_remote_resource
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc2
+  version: 1.0.0.rc3
 platform: ruby
 authors:
 - Jan van der Pas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-12 00:00:00.000000000 Z
+date: 2016-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler