ddy_remote_resource 0.4.11 → 1.0.0.rc1

data/spec/integration/where_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+RSpec.describe '.where' do
+
+  class Post
+    include RemoteResource::Base
+
+    self.site         = 'https://www.example.com'
+    self.collection   = true
+    self.root_element = :data
+
+    attribute :title, String
+    attribute :body, String
+    attribute :created_at, Time
+  end
+
+  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_default_headers) do
+    { 'Accept' => 'application/json', 'User-Agent' => "RemoteResource #{RemoteResource::VERSION}" }
+  end
+
+  describe 'default behaviour' do
+    let!(:expected_request) do
+      mock_request = stub_request(:get, 'https://www.example.com/posts.json')
+      mock_request.with(query: { pseudonym: 'pseudonym' }, body: nil, headers: expected_default_headers)
+      mock_request.to_return(status: 200, body: response_body.to_json)
+      mock_request
+    end
+
+    it 'performs the correct HTTP GET request' do
+      Post.where({ pseudonym: 'pseudonym' })
+      expect(expected_request).to have_been_requested
+    end
+
+    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
+  end
+
+  describe 'with connection_options[:headers]' do
+    let!(:expected_request) do
+      mock_request = stub_request(:get, 'https://www.example.com/posts.json')
+      mock_request.with(query: { pseudonym: 'pseudonym' }, body: nil, headers: expected_default_headers.merge({ 'X-Pseudonym' => 'pseudonym' }))
+      mock_request.to_return(status: 200, body: response_body.to_json)
+      mock_request
+    end
+
+    it 'performs the correct HTTP GET request' do
+      Post.where({ pseudonym: 'pseudonym' }, headers: { 'X-Pseudonym' => 'pseudonym' })
+      expect(expected_request).to have_been_requested
+    end
+  end
+
+  describe 'with a 404 response' do
+    let!(:expected_request) do
+      mock_request = stub_request(:get, 'https://www.example.com/posts.json')
+      mock_request.with(query: { pseudonym: 'pseudonym' }, body: nil, headers: expected_default_headers.merge({ 'X-Pseudonym' => 'pseudonym' }))
+      mock_request.to_return(status: 404)
+      mock_request
+    end
+
+    it 'raises the not found error' do
+      expect { Post.where({ pseudonym: 'pseudonym' }, headers: { 'X-Pseudonym' => 'pseudonym' }) }.to raise_error RemoteResource::HTTPNotFound
+    end
+
+    it 'adds metadata to the raised error' do
+      begin
+        Post.where({ pseudonym: 'pseudonym' }, headers: { 'X-Pseudonym' => 'pseudonym' })
+      rescue RemoteResource::HTTPNotFound => error
+        aggregate_failures do
+          expect(error.message).to eql 'HTTP request failed for Post with response_code=404 with http_action=get with request_url=https://www.example.com/posts.json'
+          expect(error.request_url).to eql 'https://www.example.com/posts.json'
+          expect(error.response_code).to eql 404
+          expect(error.request_query).to eql(RemoteResource::Util.encode_params_to_query({ pseudonym: 'pseudonym' }))
+          expect(error.request_headers).to eql(expected_default_headers.merge({ 'X-Pseudonym' => 'pseudonym' }))
+        end
+      end
+    end
+  end
+
+  describe 'with a 500 response' do
+    let!(:expected_request) do
+      mock_request = stub_request(:get, 'https://www.example.com/posts.json')
+      mock_request.with(query: { pseudonym: 'pseudonym' }, body: nil, headers: expected_default_headers.merge({ 'X-Pseudonym' => 'pseudonym' }))
+      mock_request.to_return(status: 500)
+      mock_request
+    end
+
+    it 'raises the server error' do
+      expect { Post.where({ pseudonym: 'pseudonym' }, headers: { 'X-Pseudonym' => 'pseudonym' }) }.to raise_error RemoteResource::HTTPServerError
+    end
+
+    it 'adds metadata to the raised error' do
+      begin
+        Post.where({ pseudonym: 'pseudonym' }, headers: { 'X-Pseudonym' => 'pseudonym' })
+      rescue RemoteResource::HTTPServerError => error
+        aggregate_failures do
+          expect(error.message).to eql 'HTTP request failed for Post with response_code=500 with http_action=get with request_url=https://www.example.com/posts.json'
+          expect(error.request_url).to eql 'https://www.example.com/posts.json'
+          expect(error.response_code).to eql 500
+          expect(error.request_query).to eql(RemoteResource::Util.encode_params_to_query({ pseudonym: 'pseudonym' }))
+          expect(error.request_headers).to eql(expected_default_headers.merge({ 'X-Pseudonym' => 'pseudonym' }))
+        end
+      end
+    end
+  end
+
+
+end

data/spec/lib/extensions/ethon/easy/queryable_spec.rb

@@ -1,7 +1,7 @@
 require 'ethon'
 require_relative '../../../../../lib/extensions/ethon/easy/queryable'
 
-describe Ethon::Easy::Queryable do
+RSpec.describe Ethon::Easy::Queryable, order: :defined do
 
   let(:hash)    { {} }
   let!(:easy)   { Ethon::Easy.new }
@@ -70,7 +70,7 @@ describe Ethon::Easy::Queryable do
       end
 
       context "when file" do
-        let(:file) { File.open("spec/spec_helper.rb") }
+        let(:file) { File.open("spec/fixtures/text_file.txt") }
         let(:file_info) { params.method(:file_info).call(file) }
         let(:hash) { {:a => {:b => [file]}} }
         let(:mime_type) { file_info[1] }
@@ -82,7 +82,7 @@ describe Ethon::Easy::Queryable do
         context "when MIME" do
           context "when mime type" do
             it "sets mime type to text" do
-              expect(mime_type).to eq("application/x-ruby")
+              expect(mime_type).to eq("text/plain")
             end
           end
 
@@ -132,4 +132,4 @@ describe Ethon::Easy::Queryable do
       end
     end
   end
-end
+end

data/spec/lib/remote_resource/base_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe RemoteResource::Base do
+RSpec.describe RemoteResource::Base do
 
   module RemoteResource
     class Dummy
@@ -22,12 +22,6 @@ describe RemoteResource::Base do
   specify { expect(described_class.const_defined?('RemoteResource::Querying::FinderMethods')).to be_truthy }
   specify { expect(described_class.const_defined?('RemoteResource::Querying::PersistenceMethods')).to be_truthy }
 
-  describe 'OPTIONS' do
-    let(:options) { [:base_url, :site, :headers, :version, :path_prefix, :path_postfix, :collection_prefix, :content_type, :collection, :collection_name, :root_element] }
-
-    specify { expect(described_class::OPTIONS).to eql options }
-  end
-
   describe 'attributes' do
     it '#id' do
       expect(dummy.attributes).to have_key :id
@@ -45,7 +39,7 @@ describe RemoteResource::Base do
     after { described_class.global_headers = nil }
 
     it 'sets the global headers Thread variable' do
-      expect{ described_class.global_headers = global_headers }.to change{ Thread.current[:global_headers] }.from(nil).to global_headers
+      expect{ described_class.global_headers = global_headers }.to change{ described_class.global_headers }.from({}).to(global_headers)
     end
   end
 
@@ -90,76 +84,33 @@ describe RemoteResource::Base do
   end
 
   describe '.with_connection_options' do
-    let(:connection_options) { {} }
-
-    let(:block_with_connection_options) do
-      dummy_class.with_connection_options(connection_options) do
-        dummy_class.find_by({ username: 'foobar' }, { content_type: '.json' })
-        dummy_class.create({ username: 'bazbar' }, { content_type: '.xml' })
-      end
-    end
-
-    before { allow_any_instance_of(Typhoeus::Request).to receive(:run) { double.as_null_object } }
-
     it 'yields the block' do
-      expect(dummy_class).to receive(:find_by).with({ username: 'foobar' }, { content_type: '.json' }).and_call_original
-      expect(dummy_class).to receive(:create).with({ username: 'bazbar' }, { content_type: '.xml' }).and_call_original
-      block_with_connection_options
-    end
-
-    it 'ensures to set the threaded_connection_options Thread variable to nil' do
-      dummy_class.threaded_connection_options
-
-      expect{ block_with_connection_options }.to change{ Thread.current['remote_resource.dummy.threaded_connection_options'] }.from(an_instance_of(Hash)).to nil
-    end
+      expect(dummy_class).to receive(:find_by).with({ username: 'foobar' }, { path_prefix: '/archive' })
+      expect(dummy_class).to receive(:create).with({ username: 'bazbar' }, { path_prefix: '/featured' })
 
-    context 'when the given connection_options contain headers' do
-      let(:connection_options) do
-        {
-          headers: { "Foo" => "Bar" }
-        }
-      end
-
-      it 'uses the headers of the given connection_options' do
-        expect(Typhoeus::Request).to receive(:get).with('https://foobar.com/dummy.json', params: { username: 'foobar' }, headers: { "Accept" => "application/json", "Foo" => "Bar" }).and_call_original
-        expect(Typhoeus::Request).to receive(:post).with('https://foobar.com/dummy.xml', body: { username: 'bazbar' }, headers: { "Accept" => "application/json", "Foo" => "Bar" }).and_call_original
-        block_with_connection_options
+      dummy_class.with_connection_options({ version: '/api/v1', headers: { 'Foo' => 'Bar' } }) do
+        dummy_class.find_by({ username: 'foobar' }, { path_prefix: '/archive' })
+        dummy_class.create({ username: 'bazbar' }, { path_prefix: '/featured' })
       end
     end
 
-    context 'when the given connection_options contain base_url' do
-      let(:connection_options) do
-        {
-          base_url: 'https://api.foobar.eu/dummy'
-        }
-      end
+    it 'ensures to set the threaded_connection_options back to the default' do
+      allow(dummy_class).to receive(:find_by)
+      allow(dummy_class).to receive(:create)
 
-      it 'uses the base_url of the given connection_options' do
-        expect(Typhoeus::Request).to receive(:get).with('https://api.foobar.eu/dummy.json', params: { username: 'foobar' }, headers: { "Accept" => "application/json" }).and_call_original
-        expect(Typhoeus::Request).to receive(:post).with('https://api.foobar.eu/dummy.xml', body: { username: 'bazbar' }, headers: { "Accept" => "application/json" }).and_call_original
-        block_with_connection_options
-      end
-    end
+      expect(dummy_class.threaded_connection_options).to eql({})
 
-    context 'when the given connection_options contain something else' do
-      let(:connection_options) do
-        {
-          collection: true,
-          path_prefix: '/api',
-          root_element: :bazbar
-        }
+      dummy_class.with_connection_options({ version: '/api/v1', headers: { 'Foo' => 'Bar' } }) do
+        dummy_class.find_by({ username: 'foobar' }, { path_prefix: '/archive' })
+        dummy_class.create({ username: 'bazbar' }, { path_prefix: '/featured' })
       end
 
-      it 'uses the given connection_options' do
-        expect(Typhoeus::Request).to receive(:get).with('https://foobar.com/api/dummies.json', params: { username: 'foobar' }, headers: { "Accept" => "application/json" }).and_call_original
-        expect(Typhoeus::Request).to receive(:post).with('https://foobar.com/api/dummies.xml', body:  { 'bazbar' => { username: 'bazbar' } }, headers: { "Accept" => "application/json" }).and_call_original
-        block_with_connection_options
-      end
+      expect(dummy_class.threaded_connection_options).to eql({})
     end
   end
 
   describe '#connection_options' do
-    it 'instanties as a RemoteResource::ConnectionOptions' do
+    it 'instantiates as a RemoteResource::ConnectionOptions' do
       expect(dummy.connection_options).to be_a RemoteResource::ConnectionOptions
     end
 
@@ -168,6 +119,22 @@ describe RemoteResource::Base do
     end
   end
 
+  describe '#persistence' do
+    context 'when #persisted?' do
+      it 'returns the resource' do
+        dummy.id = 10
+        expect(dummy.persistence).to eql dummy
+      end
+    end
+
+    context 'when NOT #persisted?' do
+      it 'returns nil' do
+        dummy.id = nil
+        expect(dummy.persistence).to be_nil
+      end
+    end
+  end
+
   describe '#persisted?' do
     context 'when id is present' do
       it 'returns true' do
@@ -176,26 +143,41 @@ describe RemoteResource::Base do
       end
     end
 
-    context 'when is is NOT present' do
+    context 'when id is present and destroyed is present' do
       it 'returns false' do
+        dummy.id = 10
+        dummy.destroyed = true
+        expect(dummy.persisted?).to eql false
+      end
+    end
+
+    context 'when id is NOT present' do
+      it 'returns false' do
+        dummy.id = nil
+        expect(dummy.persisted?).to eql false
+      end
+    end
+
+    context 'when id is NOT present and destroyed is present' do
+      it 'returns false' do
+        dummy.id = nil
+        dummy.destroyed = true
         expect(dummy.persisted?).to eql false
       end
     end
   end
 
   describe '#new_record?' do
-    context 'when instance persisted' do
+    context 'when #persisted?' do
       it 'returns false' do
-        allow(dummy).to receive(:persisted?) { true }
-
+        dummy.id = 10
         expect(dummy.new_record?).to eql false
       end
     end
 
-    context 'when instance does NOT persist' do
+    context 'when NOT #persisted?' do
       it 'returns true' do
-        allow(dummy).to receive(:persisted?) { false }
-
+        dummy.id = nil
         expect(dummy.new_record?).to eql true
       end
     end
@@ -302,43 +284,5 @@ describe RemoteResource::Base do
     end
   end
 
-  describe '#assign_errors' do
-    context 'with errors in the error_messages' do
-      let(:error_messages) do
-        {
-          "foo" => ["is required"],
-          "bar" => ["must be greater than 5"]
-        }
-      end
-
-      it 'assigns the error_messages as errors' do
-        dummy.send :assign_errors, error_messages
-        expect(dummy.errors.messages).to eql foo: ["is required"], bar: ["must be greater than 5"]
-      end
-    end
-
-    context 'with an empty Hash in the error_messages' do
-      let(:error_messages) do
-        {}
-      end
-
-      it 'does NOT assign the error_messages as errors' do
-        dummy.send :assign_errors, error_messages
-        expect(dummy.errors.messages).to eql({})
-      end
-    end
-
-    context 'with a String in the error_messages' do
-      let(:error_messages) do
-        "unauthorized"
-      end
-
-      it 'does NOT assign the error_messages as errors' do
-        dummy.send :assign_errors, error_messages
-        expect(dummy.errors.messages).to eql({})
-      end
-    end
-  end
-
 end
 

data/spec/lib/remote_resource/builder_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe RemoteResource::Builder do
+RSpec.describe RemoteResource::Builder do
 
   module RemoteResource
     class BuilderDummy

data/spec/lib/remote_resource/collection_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe RemoteResource::Collection do
+RSpec.describe RemoteResource::Collection do
 
   module RemoteResource
     class CollectionDummy

data/spec/lib/remote_resource/connection_options_spec.rb

@@ -1,22 +1,25 @@
 require 'spec_helper'
 
-describe RemoteResource::ConnectionOptions do
+RSpec.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.extension         = ''
+      self.default_headers   = { 'Accept' => 'application/vnd+json' }
       self.version           = '/v1'
       self.path_prefix       = '/prefix'
       self.path_postfix      = '/postfix'
-      self.content_type      = '.json'
       self.collection_prefix = '/parent/:parent_id'
       self.collection        = true
       self.root_element      = :test_dummy
 
+      def self.headers
+        { 'Authorization' => 'Bearer <token>' }
+      end
+
     end
   end
 
@@ -32,21 +35,21 @@ describe RemoteResource::ConnectionOptions do
       expect(connection_options.base_class).to eql RemoteResource::ConnectionOptionsDummy
     end
 
-    context 'RemoteResource::Base::OPTIONS' do
+    context 'RemoteResource::ConnectionOptions::AVAILABLE_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|
+      it 'sets the accessor of the option from the RemoteResource::ConnectionOptions::AVAILABLE_OPTIONS' do
+        RemoteResource::ConnectionOptions::AVAILABLE_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|
+      it 'assigns the value of the option from the RemoteResource::ConnectionOptions::AVAILABLE_OPTIONS' do
+        RemoteResource::ConnectionOptions::AVAILABLE_OPTIONS.each do |option|
           expect(connection_options.public_send(option)).to eql dummy_class.public_send(option)
         end
       end
@@ -57,7 +60,7 @@ describe RemoteResource::ConnectionOptions do
     let(:custom_connection_options) do
       {
         site: 'https://dummy.foobar.com',
-        content_type: '.xml',
+        version: '/api/v2',
         root_element: :test_dummy_api
       }
     end
@@ -66,7 +69,7 @@ describe RemoteResource::ConnectionOptions 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.version).to eql '/api/v2'
       expect(connection_options.root_element).to eql :test_dummy_api
     end
 
@@ -78,13 +81,13 @@ describe RemoteResource::ConnectionOptions do
   describe '#to_hash' do
     let(:connection_options_hash) do
       {
-        base_url:          'https://foobar.com/v1/prefix/parent/:parent_id/connection_options_dummies/postfix',
         site:              'https://foobar.com',
-        headers:           { "Accept" => "application/json", "X-Locale" => "nl" },
+        default_headers:   { 'Accept' => 'application/vnd+json' },
+        headers:           { 'Authorization' => 'Bearer <token>' },
         version:           '/v1',
         path_prefix:       '/prefix',
         path_postfix:      '/postfix',
-        content_type:      '.json',
+        extension:         '',
         collection_prefix: '/parent/:parent_id',
         collection:        true,
         collection_name:   nil,
@@ -102,7 +105,7 @@ describe RemoteResource::ConnectionOptions do
       expect(connection_options.reload).not_to eql connection_options
     end
 
-    context 'RemoteResource::Base::OPTIONS' do
+    context 'RemoteResource::ConnectionOptions::AVAILABLE_OPTIONS' do
       it 'calls #initialize_connection_options' do
         expect_any_instance_of(described_class).to receive(:initialize_connection_options).twice
         connection_options.reload
@@ -115,7 +118,7 @@ describe RemoteResource::ConnectionOptions do
       expect(connection_options.reload!).to eql connection_options
     end
 
-    context 'RemoteResource::Base::OPTIONS' do
+    context 'RemoteResource::ConnectionOptions::AVAILABLE_OPTIONS' do
       it 'calls #initialize_connection_options' do
         expect_any_instance_of(described_class).to receive(:initialize_connection_options).twice
         connection_options.reload!
@@ -123,4 +126,4 @@ describe RemoteResource::ConnectionOptions do
     end
   end
 
-end
+end