rdstation-ruby-client 2.1.0 → 2.5.0

data/spec/lib/rdstation/client_spec.rb

@@ -4,27 +4,27 @@ RSpec.describe RDStation::Client do
   context "when access_token is given" do
     let(:access_token) { 'access_token' }
     let(:client) { described_class.new(access_token: access_token) }
-    let(:mock_authorization_header) { double(RDStation::AuthorizationHeader) }
+    let(:mock_authorization) { double(RDStation::Authorization) }
 
-    before { allow(RDStation::AuthorizationHeader).to receive(:new).and_return mock_authorization_header }
+    before { allow(RDStation::Authorization).to receive(:new).and_return mock_authorization }
 
     it 'returns Contacts endpoint' do
-      expect(RDStation::Contacts).to receive(:new).with({ authorization_header: mock_authorization_header }).and_call_original
+      expect(RDStation::Contacts).to receive(:new).with({ authorization: mock_authorization }).and_call_original
       expect(client.contacts).to be_instance_of RDStation::Contacts
     end
 
     it 'returns Events endpoint' do
-      expect(RDStation::Events).to receive(:new).with({ authorization_header: mock_authorization_header }).and_call_original
+      expect(RDStation::Events).to receive(:new).with({ authorization: mock_authorization }).and_call_original
       expect(client.events).to be_instance_of RDStation::Events
     end
 
     it 'returns Fields endpoint' do
-      expect(RDStation::Fields).to receive(:new).with({ authorization_header: mock_authorization_header }).and_call_original
+      expect(RDStation::Fields).to receive(:new).with({ authorization: mock_authorization }).and_call_original
       expect(client.fields).to be_instance_of RDStation::Fields
     end
 
     it 'returns Webhooks endpoint' do
-      expect(RDStation::Webhooks).to receive(:new).with({ authorization_header: mock_authorization_header }).and_call_original
+      expect(RDStation::Webhooks).to receive(:new).with({ authorization: mock_authorization }).and_call_original
       expect(client.webhooks).to be_instance_of RDStation::Webhooks
     end
   end

data/spec/lib/rdstation/contacts_spec.rb

@@ -16,13 +16,13 @@ RSpec.describe RDStation::Contacts do
   let(:expired_access_token) { 'expired_access_token' }
 
   let(:contact_with_valid_token) do
-    described_class.new(authorization_header: RDStation::AuthorizationHeader.new(access_token: valid_access_token))
+    described_class.new(authorization: RDStation::Authorization.new(access_token: valid_access_token))
   end
   let(:contact_with_expired_token) do
-    described_class.new(authorization_header: RDStation::AuthorizationHeader.new(access_token: expired_access_token))
+    described_class.new(authorization: RDStation::Authorization.new(access_token: expired_access_token))
   end
   let(:contact_with_invalid_token) do
-    described_class.new(authorization_header: RDStation::AuthorizationHeader.new(access_token: invalid_access_token))
+    described_class.new(authorization: RDStation::Authorization.new(access_token: invalid_access_token))
   end
 
 
@@ -109,6 +109,11 @@ RSpec.describe RDStation::Contacts do
   end
 
   describe '#by_uuid' do
+    it 'calls retryable_request' do
+      expect(contact_with_valid_token).to receive(:retryable_request)
+      contact_with_valid_token.by_uuid('valid_uuid')
+    end
+
     context 'with a valid auth token' do
       context 'when the contact exists' do
         let(:contact) do
@@ -172,6 +177,11 @@ RSpec.describe RDStation::Contacts do
   end
 
   describe '#by_email' do
+    it 'calls retryable_request' do
+      expect(contact_with_valid_token).to receive(:retryable_request)
+      contact_with_valid_token.by_email('x@xpto.com')
+    end
+
     context 'with a valid auth token' do
       context 'when the contact exists' do
         let(:contact) do
@@ -235,6 +245,11 @@ RSpec.describe RDStation::Contacts do
   end
 
   describe '#update' do
+    it 'calls retryable_request' do
+      expect(contact_with_valid_token).to receive(:retryable_request)
+      contact_with_valid_token.update('valid_uuid', {})
+    end
+
     context 'with a valid access_token' do
       let(:valid_access_token) { 'valid_access_token' }
       let(:headers) do
@@ -322,6 +337,11 @@ RSpec.describe RDStation::Contacts do
   end
 
   describe '#upsert' do
+    it 'calls retryable_request' do
+      expect(contact_with_valid_token).to receive(:retryable_request)
+      contact_with_valid_token.upsert('email', 'valid@email.com', {})
+    end
+
     context 'with a valid access_token' do
       let(:valid_access_token) { 'valid_access_token' }
 

data/spec/lib/rdstation/error/format_spec.rb

@@ -52,5 +52,68 @@ RSpec.describe RDStation::Error::Format do
         expect(result).to eq(RDStation::Error::Format::ARRAY_OF_HASHES)
       end
     end
+
+    context 'when receives a mixed type of errors' do
+      let(:errors) do
+        {
+          'label': {
+            'pt-BR': [
+              {
+                'error_type': 'CANNOT_BE_BLANK',
+                'error_message': 'cannot be blank'
+              }
+            ]
+          },
+          'api_identifier': [
+            {
+              'error_type': 'CANNOT_BE_BLANK',
+              'error_message': 'cannot be blank'
+            }
+          ]
+        }
+      end
+
+      it 'returns the HASH_OF_MULTIPLE_TYPES format' do
+        result = error_format.format
+        expect(result).to eq(RDStation::Error::Format::HASH_OF_MULTIPLE_TYPES)
+      end
+    end
+
+    context 'when receives a hash of hashes errors' do
+      let(:errors) do
+        {
+          label: {
+            'pt-BR': [
+              {
+                'error_type': 'CANNOT_BE_BLANK',
+                'error_message': 'cannot be blank'
+              }
+            ]
+          }
+        }
+      end
+
+      it 'returns the HASH_OF_MULTILINGUAL format' do
+        result = error_format.format
+        expect(result).to eq(RDStation::Error::Format::HASH_OF_HASHES)
+      end
+    end
+
+    context 'when receives a single hash with error' do
+      let(:errors) do
+        {
+          'error' => "'lead_limiter' rate limit exceeded for 86400 second(s) period for key ...",
+          'max' => 24,
+          'usage' => 55,
+          'remaining_time' => 20745,
+        }
+      end
+
+      it 'returns the SINGLE_HASH format' do
+        result = error_format.format
+        expect(result).to eq(RDStation::Error::Format::SINGLE_HASH)
+      end
+
+    end
   end
 end

data/spec/lib/rdstation/error/formatter_spec.rb

@@ -132,5 +132,118 @@ RSpec.describe RDStation::Error::Formatter do
         expect(result).to eq(expected_result)
       end
     end
+
+    context 'when receives a hash of multiple type errors' do
+      let(:error_format) { instance_double(RDStation::Error::Format, format: RDStation::Error::Format::HASH_OF_MULTIPLE_TYPES) }
+
+      let(:error_response) do
+        {
+          'errors' => {
+            'label' => {
+              'pt-BR' => [
+                {
+                  'error_type' => 'CANNOT_BE_BLANK',
+                  'error_message' => 'cannot be blank'
+                }
+              ]
+            },
+            'api_identifier' => [
+              {
+                'error_type' => 'CANNOT_BE_BLANK',
+                'error_message' => 'cannot be blank'
+              }
+            ]
+          }
+        }
+      end
+
+      let(:error_formatter) { described_class.new(error_response) }
+
+      let(:expected_result) do
+        [
+          {
+            'error_type' => 'CANNOT_BE_BLANK',
+            'error_message' => 'cannot be blank',
+            'path' => 'body.label.pt-BR'
+          },
+          {
+            'error_type' => 'CANNOT_BE_BLANK',
+            'error_message' => 'cannot be blank',
+            'path' => 'body.api_identifier'
+          }
+        ]
+      end
+
+      it 'returns an array of errors' do
+        result = error_formatter.to_array
+        expect(result).to eq(expected_result)
+      end
+    end
+
+    context 'when receives a hash of hashes type errors' do
+      let(:error_format) { instance_double(RDStation::Error::Format, format: RDStation::Error::Format::HASH_OF_HASHES) }
+
+      let(:error_response) do
+        {
+          'errors' => {
+            'label' => {
+              'pt-BR' => [
+                {
+                  'error_type' => 'CANNOT_BE_BLANK',
+                  'error_message' => 'cannot be blank'
+                }
+              ]
+            }
+          }
+        }
+      end
+
+      let(:error_formatter) { described_class.new(error_response) }
+
+      let(:expected_result) do
+        [
+          {
+            'error_type' => 'CANNOT_BE_BLANK',
+            'error_message' => 'cannot be blank',
+            'path' => 'body.label.pt-BR'
+          }
+        ]
+      end
+
+      it 'returns an array of errors' do
+        result = error_formatter.to_array
+        expect(result).to eq(expected_result)
+      end
+    end
+
+    context 'when receives a single hash of errors' do
+      let(:error_format) { instance_double(RDStation::Error::Format, format: RDStation::Error::Format::SINGLE_HASH) }
+
+      let(:error_response) do
+        {
+          'error' => "'lead_limiter' rate limit exceeded for 86400 second(s) period for key",
+          'max' => 24,
+          'usage' => 55,
+          'remaining_time' => 20745
+        }
+      end
+
+      let(:error_formatter) { described_class.new(error_response) }
+
+      let(:expected_result) do
+        [
+          {
+            'error_type' => 'TOO_MANY_REQUESTS',
+            'error_message' => "'lead_limiter' rate limit exceeded for 86400 second(s) period for key",
+            'details' => { 'max' => 24, 'usage' => 55, 'remaining_time' => 20745 }
+          }
+        ]
+      end
+
+      it 'returns an array of errors' do
+        result = error_formatter.to_array
+        expect(result).to eq(expected_result)
+      end
+    end
   end
 end

data/spec/lib/rdstation/error_handler/invalid_refresh_token_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+RSpec.describe RDStation::ErrorHandler::InvalidRefreshToken do
+  describe '#raise_error' do
+    subject(:invalid_refresh_token) { described_class.new(errors) }
+
+    context 'when the refresh token is invalid or was revoked' do
+      let(:errors) do
+        [
+          {
+            'error_type' => 'INVALID_REFRESH_TOKEN',
+            'error_message' => 'Error Message',
+          }
+        ]
+      end
+
+      it 'raises an InvalidRefreshToken error' do
+        expect do
+          invalid_refresh_token.raise_error
+        end.to raise_error(RDStation::Error::InvalidRefreshToken, 'Error Message')
+      end
+    end
+
+    context 'when none of the errors are invalid refresh token errors' do
+      let(:errors) do
+        [
+          {
+            'error_message' => 'Error Message',
+            'error_type' => 'RANDOM_ERROR_TYPE'
+          },
+          {
+            'error_message' => 'Another Error Message',
+            'error_type' => 'ANOTHER_RANDOM_ERROR_TYPE'
+          }
+        ]
+      end
+
+      it 'does not raise an InvalidRefreshToken error' do
+        result = invalid_refresh_token.raise_error
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when there are no errors' do
+      let(:errors) { [] }
+
+      it 'does not raise an InvalidRefreshToken error' do
+        result = invalid_refresh_token.raise_error
+        expect(result).to be_nil
+      end
+    end
+  end
+end

data/spec/lib/rdstation/error_handler_spec.rb

@@ -151,6 +151,7 @@ RSpec.describe RDStation::ErrorHandler do
         expect { error_handler.raise_error }.to raise_error(RDStation::Error::ServiceUnavailable, 'Error Message')
       end
     end
+
     context 'with 5xx error' do
       let(:http_status) { 505 }
 
@@ -158,5 +159,27 @@ RSpec.describe RDStation::ErrorHandler do
         expect { error_handler.raise_error }.to raise_error(RDStation::Error::ServerError, 'Error Message')
       end
     end
+
+    context "when response body is not JSON-parseable" do
+      let(:error_response) do
+        OpenStruct.new(
+          code: 502,
+          headers: { 'error' => 'header' },
+          body: '<html><body>HTML error response</body></html>'
+        )
+      end
+
+      it 'raises the correct error' do
+        expect { error_handler.raise_error }.to raise_error(RDStation::Error::BadGateway, '<html><body>HTML error response</body></html>')
+      end
+    end
+
+    context 'with an unknown error' do
+      let(:http_status) { 123 }
+
+      it 'raises a unknown error' do
+        expect { error_handler.raise_error }.to raise_error(RDStation::Error::UnknownError, 'Error Message')
+      end
+    end
   end
 end

data/spec/lib/rdstation/events_spec.rb

@@ -6,13 +6,13 @@ RSpec.describe RDStation::Events do
   let(:expired_access_token) { 'expired_access_token' }
 
   let(:event_with_valid_token) do
-    described_class.new(authorization_header: RDStation::AuthorizationHeader.new(access_token: valid_access_token))
+    described_class.new(authorization: RDStation::Authorization.new(access_token: valid_access_token))
   end
   let(:event_with_expired_token) do
-    described_class.new(authorization_header: RDStation::AuthorizationHeader.new(access_token: expired_access_token))
+    described_class.new(authorization: RDStation::Authorization.new(access_token: expired_access_token))
   end
   let(:event_with_invalid_token) do
-    described_class.new(authorization_header: RDStation::AuthorizationHeader.new(access_token: invalid_access_token))
+    described_class.new(authorization: RDStation::Authorization.new(access_token: invalid_access_token))
   end
 
   let(:events_endpoint) { 'https://api.rd.services/platform/events' }
@@ -108,6 +108,11 @@ RSpec.describe RDStation::Events do
       }
     end
 
+    it 'calls retryable_request' do
+      expect(event_with_valid_token).to receive(:retryable_request)
+      event_with_valid_token.create({})
+    end
+
     context 'with a valid auth token' do
       before do
         stub_request(:post, events_endpoint)

data/spec/lib/rdstation/fields_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 RSpec.describe RDStation::Fields do
   let(:valid_access_token) { 'valid_access_token' }
   let(:rdstation_fields_with_valid_token) do
-    described_class.new(authorization_header: RDStation::AuthorizationHeader.new(access_token: valid_access_token))
+    described_class.new(authorization: RDStation::Authorization.new(access_token: valid_access_token))
   end
 
   let(:valid_headers) do
@@ -38,6 +38,11 @@ RSpec.describe RDStation::Fields do
       }
     end
 
+    it 'calls retryable_request' do
+      expect(rdstation_fields_with_valid_token).to receive(:retryable_request)
+      rdstation_fields_with_valid_token.all
+    end
+
     context 'with a valid auth token' do
       before do
         stub_request(:get, fields_endpoint)

data/spec/lib/rdstation/retryable_request_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+class DummyClass
+  include ::RDStation::RetryableRequest
+end
+
+RSpec.describe RDStation::RetryableRequest do
+  let(:subject) { DummyClass.new }
+  describe '.retryable_request' do
+    context 'when authorization has a valid refresh_token and config is provided' do
+      let (:access_token) { 'access_token' }
+      let (:new_access_token) { 'new_access_token' }
+      let (:refresh_token) { 'refresh_token' }
+      let (:auth) do
+         ::RDStation::Authorization.new(access_token: access_token, 
+                                        refresh_token: refresh_token
+                                        )
+      end
+      context 'original request was successful' do
+        it 'yields control to the given block' do
+          expect do |block|
+            subject.retryable_request(auth, &block)
+          end.to yield_with_args(auth)
+        end
+      end
+
+      context 'original request raised a retryable exception' do
+        let (:auth_new_access_token) do
+          ::RDStation::Authorization.new(access_token: new_access_token, 
+                                         refresh_token: refresh_token
+                                         )
+        end 
+
+        let(:new_credentials) do
+          {
+            'access_token' => new_access_token,
+            'expires_in' => 86_400,
+            'refresh_token' => refresh_token
+          }
+        end
+        let(:authentication_client) {instance_double(::RDStation::Authentication) }
+
+        before do
+          RDStation.configure do |config|
+            config.client_id = "123"
+            config.client_secret = "312"
+            config.on_access_token_refresh do
+              'callback code'
+            end
+          end
+          allow(::RDStation::Authentication).to receive(:new)
+                                            .with(no_args)
+                                            .and_return(authentication_client)
+          allow(authentication_client).to receive(:update_access_token)
+                                            .with(auth.refresh_token).
+                                            and_return(new_credentials)
+        end
+
+        it 'refreshes the access_token and retries the request' do
+          dummy_request = double("dummy_request")
+          expect(dummy_request).to receive(:call).twice do |auth|
+            expired_token = ::RDStation::Error::ExpiredAccessToken.new({'error_message' => 'x'})
+            raise expired_token unless auth.access_token == new_access_token
+          end
+        
+          expect(RDStation.configuration.access_token_refresh_callback)
+            .to receive(:call)
+            .once do |authorization|
+              expect(authorization.access_token).to eq new_access_token
+            end
+
+          expect do
+            subject.retryable_request(auth) { |yielded_auth| dummy_request.call(yielded_auth) }
+          end.not_to raise_error
+        end
+
+        context 'and keeps raising retryable exception event after token refreshed' do
+          it 'retries only once' do
+            dummy_request = double("dummy_request")
+            expect(dummy_request).to receive(:call).twice do |_|
+              raise ::RDStation::Error::ExpiredAccessToken.new({'error_message' => 'x'})
+            end
+          
+            expect do
+              subject.retryable_request(auth) { |yielded_auth| dummy_request.call(yielded_auth) }
+            end.to raise_error ::RDStation::Error::ExpiredAccessToken
+          end
+        end
+
+        context 'and access token refresh callback is not set' do
+          before do
+            RDStation.configure do |config|
+              config.on_access_token_refresh(&nil)
+            end
+          end
+
+          it 'executes the refresh and retry without raising an error' do
+            dummy_request = double("dummy_request")
+            expect(dummy_request).to receive(:call).twice do |auth|
+              expired_token = ::RDStation::Error::ExpiredAccessToken.new({'error_message' => 'x'})
+              raise expired_token unless auth.access_token == new_access_token
+            end
+
+            expect do
+              subject.retryable_request(auth) { |yielded_auth| dummy_request.call(yielded_auth) }
+            end.not_to raise_error
+          end
+        end
+      end
+
+      context 'original request raised a non retryable exception' do
+        it 'raises error' do
+          dummy_request = double("dummy_request")
+          expect(dummy_request).to receive(:call).once do |_|
+            raise RuntimeError.new("a non retryable error")
+          end
+        
+          expect do
+            subject.retryable_request(auth) { |yielded_auth| dummy_request.call(yielded_auth) }
+          end.to raise_error RuntimeError
+        end
+      end
+    end
+
+    context 'all legacy scenarios' do
+      let (:access_token) { 'access_token' }
+      let (:auth) { ::RDStation::Authorization.new(access_token: access_token) }
+
+      it 'implement me' do
+        dummy_request = double("dummy_request")
+        expect(dummy_request).to receive(:call).once do |_|
+          raise ::RDStation::Error::ExpiredAccessToken.new({'error_message' => 'x'})
+        end
+      
+        expect do
+          subject.retryable_request(auth) { |yielded_auth| dummy_request.call(yielded_auth) }
+        end.to raise_error ::RDStation::Error::ExpiredAccessToken
+      end
+    end
+
+  end
+end