ddy_remote_resource 0.4.11 → 1.0.0.rc1

data/spec/lib/remote_resource/connection_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe RemoteResource::Connection do
+RSpec.describe RemoteResource::Connection do
 
   module RemoteResource
     class ConnectionDummy
@@ -20,42 +20,51 @@ describe RemoteResource::Connection do
     end
   end
 
-  describe '.content_type' do
-    let!(:original_content_type) { dummy_class.content_type }
-
-    context 'when content_type is set' do
-      it 'returns the given content_type' do
-        dummy_class.content_type = '.html'
-
-        expect(dummy_class.content_type).to eql '.html'
+  describe '.default_headers' do
+    it 'returns an empty Hash' do
+      expect(dummy_class.default_headers).to eql({})
+    end
+  end
 
-        dummy_class.content_type = original_content_type
-      end
+  describe '.content_type=' do
+    it 'warns that the method is deprecated' do
+      expect(dummy_class).to receive(:warn).with('[DEPRECATION] `.content_type=` is deprecated. Please use `.extension=` instead.')
+      dummy_class.content_type = '.json'
     end
+  end
 
-    context 'when NO content_type is set' do
-      it 'returns the default content_type' do
-        expect(dummy_class.content_type).to eql '.json'
-      end
+  describe '.content_type' do
+    it 'warns that the method is deprecated' do
+      expect(dummy_class).to receive(:warn).with('[DEPRECATION] `.content_type` is deprecated. Please use `.extension` instead.')
+      dummy_class.content_type
     end
   end
 
-  describe '.headers' do
-    context 'when .extra_headers are set' do
-      it 'returns the default headers merged with the set .extra_headers' do
-        dummy_class.extra_headers = { "Foo" => "Bar" }
+  describe '.extra_headers=' do
+    it 'warns that the method is deprecated' do
+      expect(dummy_class).to receive(:warn).with('[DEPRECATION] `.extra_headers=` is deprecated. Please overwrite the .headers method to set custom headers.')
+      dummy_class.extra_headers = '.json'
+    end
+  end
 
-        expect(dummy_class.headers).to eql({ "Accept" => "application/json", "Foo" => "Bar" })
+  describe '.extra_headers' do
+    it 'warns that the method is deprecated' do
+      expect(dummy_class).to receive(:warn).with('[DEPRECATION] `.extra_headers` is deprecated. Please overwrite the .headers method to set custom headers.')
+      dummy_class.extra_headers
+    end
+  end
 
-        dummy_class.extra_headers = nil
-      end
+  describe '.headers=' do
+    it 'warns that the method is not used to set custom headers' do
+      expect(dummy_class).to receive(:warn).with('[WARNING] `.headers=` can not be used to set custom headers. Please overwrite the .headers method to set custom headers.')
+      dummy_class.headers = { 'Foo' => 'Bar' }
     end
+  end
 
-    context 'when NO .extra_headers are set' do
-      it 'returns the default headers' do
-        expect(dummy_class.headers).to eql({ "Accept" => "application/json" })
-      end
+  describe '.headers' do
+    it 'returns an empty Hash' do
+      expect(dummy_class.headers).to eql({})
     end
   end
 
-end
+end

data/spec/lib/remote_resource/querying/finder_methods_spec.rb

@@ -1,138 +1,265 @@
 require 'spec_helper'
 
-describe RemoteResource::Querying::FinderMethods do
+RSpec.describe RemoteResource::Querying::FinderMethods do
 
-  module RemoteResource
-    module Querying
-      class FinderMethodsDummy
-        include RemoteResource::Base
+  class Post
+    include RemoteResource::Base
 
-        self.site = 'https://foobar.com'
+    self.site         = 'https://www.example.com'
+    self.collection   = true
+    self.root_element = :data
 
-      end
-    end
+    attribute :title, String
+    attribute :body, String
+    attribute :featured, Boolean
+    attribute :created_at, Time
   end
 
-  let(:dummy_class) { RemoteResource::Querying::FinderMethodsDummy }
-  let(:dummy)       { dummy_class.new }
-
   describe '.find' do
-    let(:response) { instance_double(RemoteResource::Response) }
+    let(:response_body) do
+      {
+        data: {
+          id:         12,
+          title:      'Lorem Ipsum',
+          body:       'Lorem ipsum dolor sit amet, consectetur adipiscing elit.',
+          featured:   true,
+          created_at: Time.new(2015, 10, 4, 9, 30, 0),
+        }
+      }
+    end
 
-    before do
-      allow(dummy_class).to receive(:build_resource_from_response)        { dummy }
-      allow_any_instance_of(RemoteResource::Request).to receive(:perform) { response }
+    let!(:expected_request) do
+      mock_request = stub_request(:get, 'https://www.example.com/posts/12.json')
+      mock_request.to_return(status: 200, body: response_body.to_json)
+      mock_request
     end
 
-    it 'performs a RemoteResource::Request with the connection_options no_attributes' do
-      stub_request(:get, 'https://foobar.com/finder_methods_dummy/12.json').to_return(status: 200, body: {}.to_json)
-      expect(RemoteResource::Request).to receive(:new).with(dummy_class, :get, { id: '12' }, { no_attributes: true }).and_call_original
-      expect_any_instance_of(RemoteResource::Request).to receive(:perform).and_call_original
-      dummy_class.find('12')
+    it 'performs the HTTP request' do
+      Post.find(12)
+      expect(expected_request).to have_been_requested
     end
 
-    it 'builds the resource from the RemoteResource::Response' do
-      expect(dummy_class).to receive(:build_resource_from_response).with response
-      dummy_class.find('12')
+    it 'builds the correct resource' do
+      post = Post.find(12)
+
+      aggregate_failures do
+        expect(post.id).to eql 12
+        expect(post.title).to eql 'Lorem Ipsum'
+        expect(post.body).to eql 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.'
+        expect(post.featured).to eql true
+        expect(post.created_at).to eql Time.new(2015, 10, 4, 9, 30, 0)
+      end
     end
 
     it 'does NOT change the given connection_options' do
       connection_options = { headers: { 'Foo' => 'Bar' } }
 
-      expect { dummy_class.find('12', connection_options) }.not_to change { connection_options }.from({ headers: { 'Foo' => 'Bar' } })
+      expect { Post.find(12, connection_options) }.not_to change { connection_options }.from(connection_options.dup)
     end
 
-    context 'with extra params' do
-      it 'performs a RemoteResource::Request with params' do
-        stub_request(:get, 'https://foobar.com/finder_methods_dummy/12.json?skip_associations=true').to_return(status: 200, body: {}.to_json)
-        expect(RemoteResource::Request).to receive(:new).with(dummy_class, :get, { id: '12' }, { params: { skip_associations: true }, no_attributes: true }).and_call_original
-        expect_any_instance_of(RemoteResource::Request).to receive(:perform).and_call_original
-        dummy_class.find('12', params: { skip_associations: true })
-      end
+    xcontext 'return value #success? and NOT #success?' do
     end
   end
 
   describe '.find_by' do
-    let(:response) { instance_double(RemoteResource::Response) }
-    let(:params) do
-      { id: '12' }
+    let(:response_body) do
+      {
+        data: {
+          id:         12,
+          title:      'Lorem Ipsum',
+          body:       'Lorem ipsum dolor sit amet, consectetur adipiscing elit.',
+          featured:   true,
+          created_at: Time.new(2015, 10, 4, 9, 30, 0),
+        }
+      }
     end
 
-    before do
-      allow(dummy_class).to receive(:build_resource_from_response)        { dummy }
-      allow_any_instance_of(RemoteResource::Request).to receive(:perform) { response }
+    let!(:expected_request) do
+      mock_request = stub_request(:get, 'https://www.example.com/posts/current.json')
+      mock_request.with(query: { title: 'Lorem Ipsum', featured: true })
+      mock_request.to_return(status: 200, body: response_body.to_json)
+      mock_request
     end
 
-    it 'performs a RemoteResource::Request' do
-      expect(RemoteResource::Request).to receive(:new).with(dummy_class, :get, params, {}).and_call_original
-      expect_any_instance_of(RemoteResource::Request).to receive(:perform)
-      dummy_class.find_by params
+    it 'performs the HTTP request' do
+      Post.find_by({ title: 'Lorem Ipsum', featured: true }, path_postfix: '/current')
+      expect(expected_request).to have_been_requested
     end
 
-    it 'builds the resource from the RemoteResource::Response' do
-      expect(dummy_class).to receive(:build_resource_from_response).with response
-      dummy_class.find_by params
+    it 'builds the correct resource' do
+      post = Post.find_by({ title: 'Lorem Ipsum', featured: true }, path_postfix: '/current')
+
+      aggregate_failures do
+        expect(post.id).to eql 12
+        expect(post.title).to eql 'Lorem Ipsum'
+        expect(post.body).to eql 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.'
+        expect(post.featured).to eql true
+        expect(post.created_at).to eql Time.new(2015, 10, 4, 9, 30, 0)
+      end
+    end
+
+    it 'does NOT change the given params' do
+      params = { title: 'Lorem Ipsum', featured: true }
+
+      expect { Post.find_by(params, path_postfix: '/current') }.not_to change { params }.from(params.dup)
     end
 
     it 'does NOT change the given connection_options' do
-      connection_options = { headers: { 'Foo' => 'Bar' } }
+      params             = { title: 'Lorem Ipsum', featured: true }
+      connection_options = { path_postfix: '/current', headers: { 'Foo' => 'Bar' } }
+
+      expect { Post.find_by(params, connection_options) }.not_to change { connection_options }.from(connection_options.dup)
+    end
 
-      expect { dummy_class.find_by(params, connection_options) }.not_to change { connection_options }.from({ headers: { 'Foo' => 'Bar' } })
+    xcontext 'return value #success? and NOT #success?' do
     end
   end
 
   describe '.all' do
-    let(:response) { instance_double(RemoteResource::Response) }
+    let(:response_body) do
+      {
+        data: [
+                {
+                  id:         12,
+                  title:      'Lorem Ipsum',
+                  body:       'Lorem ipsum dolor sit amet, consectetur adipiscing elit.',
+                  created_at: Time.new(2015, 10, 4, 9, 30, 0),
+                },
+                {
+                  id:         14,
+                  title:      'Mauris Purus',
+                  body:       'Mauris purus urna, ultrices et suscipit ut, faucibus eget mauris.',
+                  created_at: Time.new(2015, 12, 11, 11, 32, 0),
+                },
+                {
+                  id:         16,
+                  title:      'Vestibulum Commodo',
+                  body:       'Vestibulum commodo fringilla suscipit.',
+                  created_at: Time.new(2016, 2, 6, 18, 45, 0),
+                },
+              ]
+      }
+    end
 
-    before do
-      allow(dummy_class).to receive(:build_collection_from_response)      { dummy }
-      allow_any_instance_of(RemoteResource::Request).to receive(:perform) { response }
+    let!(:expected_request) do
+      mock_request = stub_request(:get, 'https://www.example.com/posts.json')
+      mock_request.to_return(status: 200, body: response_body.to_json)
+      mock_request
     end
 
-    it 'performs a RemoteResource::Request with the connection_options collection' do
-      expect(RemoteResource::Request).to receive(:new).with(dummy_class, :get, {}, { collection: true }).and_call_original
-      expect_any_instance_of(RemoteResource::Request).to receive(:perform)
-      dummy_class.all
+    it 'performs the HTTP request' do
+      Post.all
+      expect(expected_request).to have_been_requested
     end
 
-    it 'builds the resources from the RemoteResource::Response' do
-      expect(dummy_class).to receive(:build_collection_from_response).with response
-      dummy_class.all
+    it 'builds the correct collection of resources' do
+      posts = Post.all
+
+      aggregate_failures do
+        expect(posts).to respond_to :each
+        expect(posts).to all(be_a(Post))
+        expect(posts.size).to eql 3
+
+        expect(posts[0].id).to eql 12
+        expect(posts[0].title).to eql 'Lorem Ipsum'
+        expect(posts[0].body).to eql 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.'
+        expect(posts[0].created_at).to eql Time.new(2015, 10, 4, 9, 30, 0)
+        expect(posts[1].id).to eql 14
+        expect(posts[1].title).to eql 'Mauris Purus'
+        expect(posts[1].body).to eql 'Mauris purus urna, ultrices et suscipit ut, faucibus eget mauris.'
+        expect(posts[1].created_at).to eql Time.new(2015, 12, 11, 11, 32, 0)
+        expect(posts[2].id).to eql 16
+        expect(posts[2].title).to eql 'Vestibulum Commodo'
+        expect(posts[2].body).to eql 'Vestibulum commodo fringilla suscipit.'
+        expect(posts[2].created_at).to eql Time.new(2016, 2, 6, 18, 45, 0)
+      end
     end
 
     it 'does NOT change the given connection_options' do
       connection_options = { headers: { 'Foo' => 'Bar' } }
 
-      expect { dummy_class.all(connection_options) }.not_to change { connection_options }.from({ headers: { 'Foo' => 'Bar' } })
+      expect { Post.all(connection_options) }.not_to change { connection_options }.from(connection_options.dup)
+    end
+
+    xcontext 'return value #success? and NOT #success?' do
     end
   end
 
   describe '.where' do
-    let(:response) { instance_double(RemoteResource::Response) }
-    let(:params) do
-      { username: 'mies' }
+    let(:response_body) do
+      {
+        data: [
+                {
+                  id:         12,
+                  title:      'Lorem Ipsum',
+                  body:       'Lorem ipsum dolor sit amet, consectetur adipiscing elit.',
+                  created_at: Time.new(2015, 10, 4, 9, 30, 0),
+                },
+                {
+                  id:         14,
+                  title:      'Mauris Purus',
+                  body:       'Mauris purus urna, ultrices et suscipit ut, faucibus eget mauris.',
+                  created_at: Time.new(2015, 12, 11, 11, 32, 0),
+                },
+                {
+                  id:         16,
+                  title:      'Vestibulum Commodo',
+                  body:       'Vestibulum commodo fringilla suscipit.',
+                  created_at: Time.new(2016, 2, 6, 18, 45, 0),
+                },
+              ]
+      }
+    end
+
+    let!(:expected_request) do
+      mock_request = stub_request(:get, 'https://www.example.com/posts.json')
+      mock_request.with(query: { pseudonym: 'pseudonym' })
+      mock_request.to_return(status: 200, body: response_body.to_json)
+      mock_request
     end
 
-    before do
-      allow(dummy_class).to receive(:build_collection_from_response)      { dummy }
-      allow_any_instance_of(RemoteResource::Request).to receive(:perform) { response }
+    it 'performs the HTTP request' do
+      Post.where({ pseudonym: 'pseudonym' })
+      expect(expected_request).to have_been_requested
     end
 
-    it 'performs a RemoteResource::Request with the connection_options collection' do
-      expect(RemoteResource::Request).to receive(:new).with(dummy_class, :get, params, { collection: true }).and_call_original
-      expect_any_instance_of(RemoteResource::Request).to receive(:perform)
-      dummy_class.where params
+    it 'builds the correct collection of resources' do
+      posts = Post.where({ pseudonym: 'pseudonym' })
+
+      aggregate_failures do
+        expect(posts).to respond_to :each
+        expect(posts).to all(be_a(Post))
+        expect(posts.size).to eql 3
+
+        expect(posts[0].id).to eql 12
+        expect(posts[0].title).to eql 'Lorem Ipsum'
+        expect(posts[0].body).to eql 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.'
+        expect(posts[0].created_at).to eql Time.new(2015, 10, 4, 9, 30, 0)
+        expect(posts[1].id).to eql 14
+        expect(posts[1].title).to eql 'Mauris Purus'
+        expect(posts[1].body).to eql 'Mauris purus urna, ultrices et suscipit ut, faucibus eget mauris.'
+        expect(posts[1].created_at).to eql Time.new(2015, 12, 11, 11, 32, 0)
+        expect(posts[2].id).to eql 16
+        expect(posts[2].title).to eql 'Vestibulum Commodo'
+        expect(posts[2].body).to eql 'Vestibulum commodo fringilla suscipit.'
+        expect(posts[2].created_at).to eql Time.new(2016, 2, 6, 18, 45, 0)
+      end
     end
 
-    it 'builds the resources from the RemoteResource::Response' do
-      expect(dummy_class).to receive(:build_collection_from_response).with response
-      dummy_class.where params
+    it 'does NOT change the given params' do
+      params = { pseudonym: 'pseudonym' }
+
+      expect { Post.where(params) }.not_to change { params }.from(params.dup)
     end
 
     it 'does NOT change the given connection_options' do
+      params             = { pseudonym: 'pseudonym' }
       connection_options = { headers: { 'Foo' => 'Bar' } }
 
-      expect { dummy_class.where(params, connection_options) }.not_to change { connection_options }.from({ headers: { 'Foo' => 'Bar' } })
+      expect { Post.where(params, connection_options) }.not_to change { connection_options }.from(connection_options.dup)
+    end
+
+    xcontext 'return value #success? and NOT #success?' do
     end
   end
 

data/spec/lib/remote_resource/querying/persistence_methods_spec.rb

@@ -1,342 +1,350 @@
 require 'spec_helper'
 
-describe RemoteResource::Querying::PersistenceMethods do
+RSpec.describe RemoteResource::Querying::PersistenceMethods do
 
-  module RemoteResource
-    module Querying
-      class PersistenceMethodsDummy
-        include RemoteResource::Base
+  class Post
+    include RemoteResource::Base
 
-        self.site = 'https://foobar.com'
+    self.site         = 'https://www.example.com'
+    self.collection   = true
+    self.root_element = :data
 
-        attribute :name
-
-      end
-    end
+    attribute :title, String
+    attribute :body, String
+    attribute :featured, Boolean
+    attribute :created_at, Time
   end
 
-  let(:dummy_class) { RemoteResource::Querying::PersistenceMethodsDummy }
-  let(:dummy)       { dummy_class.new }
-
   describe '.create' do
-    let(:response) { instance_double(RemoteResource::Response) }
-    let(:attributes) do
-      { name: 'Mies' }
-    end
-
-    before do
-      allow_any_instance_of(dummy_class).to receive(:handle_response)
-      allow_any_instance_of(RemoteResource::Request).to receive(:perform) { response }
-    end
-
-    it 'instantiates the resource with the attributes' do
-      expect(dummy_class).to receive(:new).with(attributes).and_call_original
-      dummy_class.create attributes
-    end
-
-    it 'performs a RemoteResource::Request' do
-      expect(RemoteResource::Request).to receive(:new).with(dummy_class, :post, attributes, {}).and_call_original
-      expect_any_instance_of(RemoteResource::Request).to receive(:perform)
-      dummy_class.create attributes
-    end
-
-    it 'handles the RemoteResource::Response' do
-      expect_any_instance_of(dummy_class).to receive(:handle_response).with response
-      dummy_class.create attributes
+    let(:response_body) do
+      {
+        data: {
+          id:         12,
+          title:      'Lorem Ipsum',
+          body:       'Lorem ipsum dolor sit amet, consectetur adipiscing elit.',
+          featured:   true,
+          created_at: Time.new(2015, 10, 4, 9, 30, 0),
+        }
+      }
+    end
+
+    let!(:expected_request) do
+      mock_request = stub_request(:post, 'https://www.example.com/posts.json')
+      mock_request.to_return(status: 201, body: JSON.generate(response_body))
+      mock_request
+    end
+
+    it 'performs the HTTP request' do
+      Post.create(title: 'Lorem Ipsum', body: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', featured: true)
+      expect(expected_request).to have_been_requested
+    end
+
+    it 'builds the correct resource' do
+      post = Post.create(title: 'Lorem Ipsum', body: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', featured: true)
+
+      aggregate_failures do
+        expect(post.persisted?).to eql true
+        expect(post.id).to eql 12
+        expect(post.title).to eql 'Lorem Ipsum'
+        expect(post.body).to eql 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.'
+        expect(post.featured).to eql true
+        expect(post.created_at).to eql Time.new(2015, 10, 4, 9, 30, 0)
+      end
     end
 
     it 'does NOT change the given attributes' do
-      expect { dummy_class.create(attributes) }.not_to change { attributes }.from({ name: 'Mies' })
+      attributes = { title: 'Lorem Ipsum', body: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', featured: true }
+
+      expect { Post.create(attributes) }.not_to change { attributes }.from(attributes.dup)
     end
 
     it 'does NOT change the given connection_options' do
+      attributes         = { title: 'Lorem Ipsum', body: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', featured: true }
       connection_options = { headers: { 'Foo' => 'Bar' } }
 
-      expect { dummy_class.create(attributes, connection_options) }.not_to change { connection_options }.from({ headers: { 'Foo' => 'Bar' } })
+      expect { Post.create(attributes, connection_options) }.not_to change { connection_options }.from(connection_options.dup)
+    end
+
+    xcontext 'return value #success? and NOT #success?' do
     end
   end
 
   describe '.destroy' do
-    let(:response) { instance_double(RemoteResource::Response) }
-
-    before do
-      allow_any_instance_of(dummy_class).to receive(:handle_response)
-      allow_any_instance_of(RemoteResource::Request).to receive(:perform) { response }
+    let(:response_body) do
+      {}
     end
 
-    it 'instantiates the resource without attributes' do
-      expect(dummy_class).to receive(:new).with(no_args()).and_call_original
-      dummy_class.destroy('15')
+    let!(:expected_request) do
+      mock_request = stub_request(:delete, 'https://www.example.com/posts/12.json')
+      mock_request.to_return(status: 204, body: response_body.to_json)
+      mock_request
     end
 
-    it 'performs a RemoteResource::Request' do
-      expect(RemoteResource::Request).to receive(:new).with(dummy_class, :delete, { id: '15' }, { no_attributes: true }).and_call_original
-      expect_any_instance_of(RemoteResource::Request).to receive(:perform)
-      dummy_class.destroy('15')
+    it 'performs the HTTP request' do
+      Post.destroy(12)
+      expect(expected_request).to have_been_requested
     end
 
-    it 'handles the RemoteResource::Response' do
-      expect_any_instance_of(dummy_class).to receive(:handle_response).with response
-      dummy_class.destroy('15')
+    it 'builds the correct non-persistent resource' do
+      post = Post.destroy(12)
+
+      aggregate_failures do
+        expect(post.id).to eql 12
+        expect(post.persisted?).to eql false
+      end
     end
 
     it 'does NOT change the given connection_options' do
       connection_options = { headers: { 'Foo' => 'Bar' } }
 
-      expect { dummy_class.destroy('15', connection_options) }.not_to change { connection_options }.from({ headers: { 'Foo' => 'Bar' } })
+      expect { Post.destroy(12, connection_options) }.not_to change { connection_options }.from(connection_options.dup)
     end
 
-    context 'request' do
-      let(:response) { { status: 200, body: '' } }
-      before { allow_any_instance_of(RemoteResource::Request).to receive(:perform).and_call_original }
-
-      it 'generates correct request url' do
-        stub_request(:delete, 'https://foobar.com/persistence_methods_dummy/15.json').with(body: nil).to_return(response)
-        dummy_class.destroy('15')
-      end
-
-      it 'includes params' do
-        stub_request(:delete, 'https://foobar.com/persistence_methods_dummy/15.json?pseudonym=3s8e3j').with(body: nil).to_return(response)
-        dummy_class.destroy('15', params: { pseudonym: '3s8e3j' })
-      end
+    xcontext 'return value #success? and NOT #success?' do
     end
   end
 
   describe '#update_attributes' do
-    let(:dummy) { dummy_class.new id: 10 }
-
-    let(:attributes) do
-      { name: 'Noot' }
-    end
-
-    before do
-      allow(dummy).to receive(:create_or_update) { dummy }
-      allow(dummy).to receive(:success?)
-    end
-
-    it 'rebuilds the resource with the attributes' do
-      expect(dummy).to receive(:rebuild_resource).with(attributes).and_call_original
-      dummy.update_attributes attributes
-    end
-
-    context 'when the id is given in the attributes' do
-      let(:attributes) do
-        { id: 14, name: 'Noot' }
+    let(:response_body) do
+      {
+        data: {
+          id:         12,
+          title:      'Aliquam lobortis',
+          body:       'Lorem ipsum dolor sit amet, consectetur adipiscing elit.',
+          featured:   true,
+          created_at: Time.new(2015, 10, 4, 9, 30, 0),
+        }
+      }
+    end
+
+    context 'when resource is persisted' do
+      let(:resource) { Post.new(id: 12, title: 'Lorem Ipsum', body: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', featured: true, created_at: Time.new(2015, 10, 4, 9, 30, 0)) }
+
+      let!(:expected_request) do
+        mock_request = stub_request(:patch, 'https://www.example.com/posts/12.json')
+        mock_request.to_return(status: 201, body: JSON.generate(response_body))
+        mock_request
       end
 
-      it 'calls #create_or_update with the attributes and given id' do
-        expect(dummy).to receive(:create_or_update).with(attributes, {})
-        dummy.update_attributes attributes
+      it 'performs the HTTP request' do
+        resource.update_attributes(title: 'Aliquam lobortis', featured: true)
+        expect(expected_request).to have_been_requested
       end
 
-      it 'does NOT change the given attributes' do
-        expect { dummy.update_attributes(attributes) }.not_to change { attributes }.from({ id: 14, name: 'Noot' })
-      end
+      it 'builds the correct resource' do
+        resource.update_attributes(title: 'Aliquam lobortis', featured: true)
 
-      it 'does NOT change the given connection_options' do
-        connection_options = { headers: { 'Foo' => 'Bar' } }
-
-        expect { dummy.update_attributes(attributes, connection_options) }.not_to change { connection_options }.from({ headers: { 'Foo' => 'Bar' } })
-      end
-    end
+        post = resource
 
-    context 'when the id is NOT given in the attributes' do
-      it 'calls #create_or_update with the attributes and #id of resource' do
-        expect(dummy).to receive(:create_or_update).with(attributes.merge(id: dummy.id), {})
-        dummy.update_attributes attributes
+        aggregate_failures do
+          expect(post.persisted?).to eql true
+          expect(post.id).to eql 12
+          expect(post.title).to eql 'Aliquam lobortis'
+          expect(post.body).to eql 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.'
+          expect(post.featured).to eql true
+          expect(post.created_at).to eql Time.new(2015, 10, 4, 9, 30, 0)
+        end
       end
 
       it 'does NOT change the given attributes' do
-        expect { dummy.update_attributes(attributes) }.not_to change { attributes }.from({ name: 'Noot' })
+        attributes = { title: 'Aliquam lobortis', featured: true }
+
+        expect { resource.update_attributes(attributes) }.not_to change { attributes }.from(attributes.dup)
       end
 
       it 'does NOT change the given connection_options' do
+        attributes         = { title: 'Aliquam lobortis', featured: true }
         connection_options = { headers: { 'Foo' => 'Bar' } }
 
-        expect { dummy.update_attributes(attributes, connection_options) }.not_to change { connection_options }.from({ headers: { 'Foo' => 'Bar' } })
+        expect { resource.update_attributes(attributes, connection_options) }.not_to change { connection_options }.from(connection_options.dup)
       end
-    end
-
-    context 'when the save was successful' do
-      it 'returns the resource' do
-        allow(dummy).to receive(:success?) { true }
 
-        expect(dummy.update_attributes attributes).to eql dummy
+      xcontext 'return value #success? and NOT #success?' do
       end
     end
 
-    context 'when the save was NOT successful' do
-      it 'returns false' do
-        allow(dummy).to receive(:success?) { false }
+    context 'when resource is NOT persisted' do
+      let(:resource) { Post.new(title: 'Lorem Ipsum', body: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', featured: true) }
 
-        expect(dummy.update_attributes attributes).to eql false
+      let!(:expected_request) do
+        mock_request = stub_request(:post, 'https://www.example.com/posts.json')
+        mock_request.to_return(status: 201, body: JSON.generate(response_body))
+        mock_request
       end
-    end
-  end
 
-  describe '#save' do
-    let(:attributes) { dummy.attributes }
+      it 'performs the HTTP request' do
+        resource.update_attributes(title: 'Aliquam lobortis', featured: true)
+        expect(expected_request).to have_been_requested
+      end
 
-    before do
-      allow(dummy).to receive(:create_or_update) { dummy }
-      allow(dummy).to receive(:success?)
-    end
+      it 'builds the correct resource' do
+        resource.update_attributes(title: 'Aliquam lobortis', featured: true)
 
-    it 'calls #create_or_update with the attributes' do
-      expect(dummy).to receive(:create_or_update).with(attributes, {})
-      dummy.save
-    end
+        post = resource
 
-    it 'does NOT change the given connection_options' do
-      connection_options = { headers: { 'Foo' => 'Bar' } }
-
-      expect { dummy.save(connection_options) }.not_to change { connection_options }.from({ headers: { 'Foo' => 'Bar' } })
-    end
+        aggregate_failures do
+          expect(post.persisted?).to eql true
+          expect(post.id).to eql 12
+          expect(post.title).to eql 'Aliquam lobortis'
+          expect(post.body).to eql 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.'
+          expect(post.featured).to eql true
+          expect(post.created_at).to eql Time.new(2015, 10, 4, 9, 30, 0)
+        end
+      end
 
-    context 'when the save was successful' do
-      it 'returns the resource' do
-        allow(dummy).to receive(:success?) { true }
+      it 'does NOT change the given attributes' do
+        attributes = { title: 'Aliquam lobortis', featured: true }
 
-        expect(dummy.save).to eql dummy
+        expect { resource.update_attributes(attributes) }.not_to change { attributes }.from(attributes.dup)
       end
-    end
 
-    context 'when the save was NOT successful' do
-      it 'returns false' do
-        allow(dummy).to receive(:success?) { false }
+      it 'does NOT change the given connection_options' do
+        attributes         = { title: 'Aliquam lobortis', featured: true }
+        connection_options = { headers: { 'Foo' => 'Bar' } }
 
-        expect(dummy.save).to eql false
+        expect { resource.update_attributes(attributes, connection_options) }.not_to change { connection_options }.from(connection_options.dup)
       end
-    end
-  end
-
-  describe '#create_or_update' do
-    let(:response) { instance_double(RemoteResource::Response) }
 
-    before do
-      allow(dummy).to receive(:handle_response)                           { dummy }
-      allow_any_instance_of(RemoteResource::Request).to receive(:perform) { response }
+      xcontext 'return value #success? and NOT #success?' do
+      end
     end
+  end
 
-    context 'when the attributes contain an id' do
-      let(:attributes) do
-        { id: 10, name: 'Kees' }
+  describe '#save' do
+    let(:response_body) do
+      {
+        data: {
+          id:         12,
+          title:      'Lorem Ipsum',
+          body:       'Lorem ipsum dolor sit amet, consectetur adipiscing elit.',
+          featured:   false,
+          created_at: Time.new(2015, 10, 4, 9, 30, 0),
+        }
+      }
+    end
+
+    context 'when resource is persisted' do
+      let(:resource) { Post.new(id: 12, title: 'Lorem Ipsum', body: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', featured: false, created_at: Time.new(2015, 10, 4, 9, 30, 0)) }
+
+      let!(:expected_request) do
+        mock_request = stub_request(:patch, 'https://www.example.com/posts/12.json')
+        mock_request.to_return(status: 200, body: JSON.generate(response_body))
+        mock_request
       end
 
-      it 'performs a RemoteResource::Request with rest_action :patch' do
-        expect(RemoteResource::Request).to receive(:new).with(dummy, :patch, attributes, {}).and_call_original
-        expect_any_instance_of(RemoteResource::Request).to receive(:perform)
-        dummy.create_or_update attributes
+      it 'performs the HTTP request' do
+        resource.save
+        expect(expected_request).to have_been_requested
       end
 
-      it 'handles the RemoteResource::Response' do
-        expect(dummy).to receive(:handle_response).with response
-        dummy.create_or_update attributes
-      end
+      it 'builds the correct resource' do
+        resource.save
 
-      it 'does NOT change the given attributes' do
-        expect { dummy.create_or_update(attributes) }.not_to change { attributes }.from({ id: 10, name: 'Kees' })
+        post = resource
+
+        aggregate_failures do
+          expect(post.persisted?).to eql true
+          expect(post.id).to eql 12
+          expect(post.title).to eql 'Lorem Ipsum'
+          expect(post.body).to eql 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.'
+          expect(post.featured).to eql false
+          expect(post.created_at).to eql Time.new(2015, 10, 4, 9, 30, 0)
+        end
       end
 
       it 'does NOT change the given connection_options' do
         connection_options = { headers: { 'Foo' => 'Bar' } }
 
-        expect { dummy.create_or_update(attributes, connection_options) }.not_to change { connection_options }.from({ headers: { 'Foo' => 'Bar' } })
+        expect { resource.save(connection_options) }.not_to change { connection_options }.from(connection_options.dup)
       end
-    end
 
-    context 'when the attributes do NOT contain an id' do
-      let(:attributes) do
-        { name: 'Mies' }
+      xcontext 'return value #success? and NOT #success?' do
       end
+    end
 
-      it 'performs a RemoteResource::Request with rest_action :post' do
-        expect(RemoteResource::Request).to receive(:new).with(dummy, :post, attributes, {}).and_call_original
-        expect_any_instance_of(RemoteResource::Request).to receive(:perform)
-        dummy.create_or_update attributes
+    context 'when resource is NOT persisted' do
+      let(:resource) { Post.new(title: 'Lorem Ipsum', body: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', featured: false) }
+
+      let!(:expected_request) do
+        mock_request = stub_request(:post, 'https://www.example.com/posts.json')
+        mock_request.to_return(status: 201, body: JSON.generate(response_body))
+        mock_request
       end
 
-      it 'handles the RemoteResource::Response' do
-        expect(dummy).to receive(:handle_response).with response
-        dummy.create_or_update attributes
+      it 'performs the HTTP request' do
+        resource.save
+        expect(expected_request).to have_been_requested
       end
 
-      it 'does NOT change the given attributes' do
-        expect { dummy.create_or_update(attributes) }.not_to change { attributes }.from({ name: 'Mies' })
+      it 'builds the correct resource' do
+        resource.save
+
+        post = resource
+
+        aggregate_failures do
+          expect(post.persisted?).to eql true
+          expect(post.id).to eql 12
+          expect(post.title).to eql 'Lorem Ipsum'
+          expect(post.body).to eql 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.'
+          expect(post.featured).to eql false
+          expect(post.created_at).to eql Time.new(2015, 10, 4, 9, 30, 0)
+        end
       end
 
       it 'does NOT change the given connection_options' do
         connection_options = { headers: { 'Foo' => 'Bar' } }
 
-        expect { dummy.create_or_update(attributes, connection_options) }.not_to change { connection_options }.from({ headers: { 'Foo' => 'Bar' } })
+        expect { resource.save(connection_options) }.not_to change { connection_options }.from(connection_options.dup)
+      end
+
+      xcontext 'return value #success? and NOT #success?' do
       end
     end
   end
 
   describe '#destroy' do
-    let(:dummy) { dummy_class.new(id: 18) }
+    let(:resource) { Post.new(id: 12) }
 
-    let(:response) { instance_double(RemoteResource::Response) }
-
-    before do
-      allow(dummy).to receive(:handle_response)                           { dummy }
-      allow_any_instance_of(RemoteResource::Request).to receive(:perform) { response }
-      allow(dummy).to receive(:success?)
+    let(:response_body) do
+      {}
     end
 
-    it 'performs a RemoteResource::Request with rest_action :delete' do
-      expect(RemoteResource::Request).to receive(:new).with(dummy, :delete, { id: dummy.id }, { no_attributes: true }).and_call_original
-      expect_any_instance_of(RemoteResource::Request).to receive(:perform)
-      dummy.destroy
+    let!(:expected_request) do
+      mock_request = stub_request(:delete, 'https://www.example.com/posts/12.json')
+      mock_request.to_return(status: 204, body: response_body.to_json)
+      mock_request
     end
 
-    it 'handles the RemoteResource::Response' do
-      expect(dummy).to receive(:handle_response).with response
-      dummy.destroy
+    it 'performs the HTTP request' do
+      resource.destroy
+      expect(expected_request).to have_been_requested
     end
 
-    it 'does NOT change the given connection_options' do
-      connection_options = { headers: { 'Foo' => 'Bar' } }
-
-      expect { dummy.destroy(connection_options) }.not_to change { connection_options }.from({ headers: { 'Foo' => 'Bar' } })
-    end
+    it 'builds the correct non-persistent resource' do
+      resource.destroy
 
-    context 'request' do
-      let(:response) { { status: 200, body: '' } }
-      before { allow_any_instance_of(RemoteResource::Request).to receive(:perform).and_call_original }
-
-      it 'generates correct request url' do
-        stub_request(:delete, 'https://foobar.com/persistence_methods_dummy/18.json').with(body: nil).to_return(response)
-        dummy.destroy
-      end
+      post = resource
 
-      it 'includes params' do
-        stub_request(:delete, 'https://foobar.com/persistence_methods_dummy/18.json?pseudonym=3s8e3j').with(body: nil).to_return(response)
-        dummy.destroy(params: { pseudonym: '3s8e3j' })
+      aggregate_failures do
+        expect(post.id).to eql 12
+        expect(post.persisted?).to eql false
       end
     end
 
-    context 'when the destroy was successful' do
-      it 'returns the resource' do
-        allow(dummy).to receive(:success?) { true }
+    it 'does NOT change the given connection_options' do
+      connection_options = { headers: { 'Foo' => 'Bar' } }
 
-        expect(dummy.destroy).to eql dummy
-      end
+      expect { resource.destroy(connection_options) }.not_to change { connection_options }.from(connection_options.dup)
     end
 
-    context 'when the destroy was NOT successful' do
-      it 'returns false' do
-        allow(dummy).to receive(:success?) { false }
-
-        expect(dummy.destroy).to eql false
-      end
+    xcontext 'return value #success? and NOT #success?' do
     end
 
     context 'when the id is NOT present' do
-      let(:dummy) { dummy_class.new }
+      let(:resource) { Post.new }
 
       it 'raises the RemoteResource::IdMissingError error' do
-        expect { dummy.destroy }.to raise_error(RemoteResource::IdMissingError, "`id` is missing from resource")
+        expect { resource.destroy }.to raise_error(RemoteResource::IdMissingError, "`id` is missing from resource")
       end
     end
   end