rdstation-ruby-client 1.2.1 → 2.3.1

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

@@ -52,5 +52,51 @@ 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
   end
 end

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

@@ -132,5 +132,88 @@ 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
   end
 end

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

@@ -21,34 +21,5 @@ RSpec.describe RDStation::ErrorHandler::Unauthorized do
         end.to raise_error(RDStation::Error::Unauthorized, 'Error Message')
       end
     end
-
-    context 'when none of the errors are unauthorized 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 Unauthorized error' do
-        result = unauthorized_error.raise_error
-        expect(result).to be_nil
-      end
-    end
-
-    context 'when there are no errors' do
-      let(:errors) { [] }
-
-      it 'does not raise an Unauthorized error' do
-        result = unauthorized_error.raise_error
-        expect(result).to be_nil
-      end
-    end
   end
 end

data/spec/lib/rdstation/error_handler_spec.rb

@@ -4,45 +4,181 @@ RSpec.describe RDStation::ErrorHandler do
   describe '#raise_errors' do
     subject(:error_handler) { described_class.new(error_response) }
 
-    context 'when the error type is recognized' do
-      let(:error_response) do
-        OpenStruct.new(
-          code: 400,
-          body: {
+    let(:array_of_errors) do
+      [
+        {
+          'error_type' => 'ERROR_TYPE',
+          'error_message' => 'Error Message',
+          'headers' => { 'error' => 'header' },
+          'http_status' => http_status,
+          'body' => {
             'errors' => {
-              'error_type' => 'CONFLICTING_FIELD',
+              'error_type' => 'ERROR_TYPE',
               'error_message' => 'Error Message'
             }
-          }.to_json
-        )
+          }
+        }
+      ]
+    end
+
+    let(:error_response) do
+      OpenStruct.new(
+        code: http_status,
+        headers: { 'error' => 'header' },
+        body: {
+          'errors' => {
+            'error_type' => 'ERROR_TYPE',
+            'error_message' => 'Error Message'
+          }
+        }.to_json
+      )
+    end
+
+    context 'with an error 400' do
+      let(:http_status) { 400 }
+
+      let(:bad_request_handler) { instance_double(RDStation::ErrorHandler::BadRequest, raise_error: 'raised error') }
+
+      before do
+        allow(RDStation::ErrorHandler::BadRequest).to receive(:new).with(array_of_errors).and_return(bad_request_handler)
+      end
+
+      it 'calls the bad request error handler' do
+        error_handler.raise_error
+        expect(bad_request_handler).to have_received(:raise_error)
+      end
+    end
+
+    context 'with an error 401' do
+      let(:http_status) { 401 }
+
+      let(:unauthorized_handler) { instance_double(RDStation::ErrorHandler::Unauthorized, raise_error: 'raised error') }
+
+      before do
+        allow(RDStation::ErrorHandler::Unauthorized).to receive(:new).with(array_of_errors).and_return(unauthorized_handler)
+      end
+
+      it 'calls the unauthorized error handler' do
+        error_handler.raise_error
+        expect(unauthorized_handler).to have_received(:raise_error)
       end
+    end
+
+    context 'with an error 403' do
+      let(:http_status) { 403 }
+
+      it 'raises a forbidden error' do
+        expect { error_handler.raise_error }.to raise_error(RDStation::Error::Forbidden, 'Error Message')
+      end
+    end
+
+    context 'with an error 404' do
+      let(:http_status) { 404 }
+
+      it 'raises a not found error' do
+        expect { error_handler.raise_error }.to raise_error(RDStation::Error::NotFound, 'Error Message')
+      end
+    end
+
+    context 'with an error 405' do
+      let(:http_status) { 405 }
+
+      it 'raises a method not allowed error' do
+        expect { error_handler.raise_error }.to raise_error(RDStation::Error::MethodNotAllowed, 'Error Message')
+      end
+    end
+
+    context 'with an error 406' do
+      let(:http_status) { 406 }
+
+      it 'raises a not acceptable error' do
+        expect { error_handler.raise_error }.to raise_error(RDStation::Error::NotAcceptable, 'Error Message')
+      end
+    end
+
+    context 'with an error 409' do
+      let(:http_status) { 409 }
 
-      it 'raises the corresponding error class' do
-        expect { error_handler.raise_errors }.to raise_error(RDStation::Error::ConflictingField, 'Error Message')
+      it 'raises a conflict error' do
+        expect { error_handler.raise_error }.to raise_error(RDStation::Error::Conflict, 'Error Message')
       end
     end
 
-    context 'when the error type is not recognized' do
+    context 'with an error 415' do
+      let(:http_status) { 415 }
+
+      it 'raises an unsupported media type error' do
+        expect { error_handler.raise_error }.to raise_error(RDStation::Error::UnsupportedMediaType, 'Error Message')
+      end
+    end
+
+    context 'with an error 422' do
+      let(:http_status) { 422 }
+
+      it 'raises an unprocessable entity error' do
+        expect { error_handler.raise_error }.to raise_error(RDStation::Error::UnprocessableEntity, 'Error Message')
+      end
+    end
+
+    context 'with an error 500' do
+      let(:http_status) { 500 }
+
+      it 'raises an internal server error' do
+        expect { error_handler.raise_error }.to raise_error(RDStation::Error::InternalServerError, 'Error Message')
+      end
+    end
+
+    context 'with an error 501' do
+      let(:http_status) { 501 }
+
+      it 'raises a not implemented error' do
+        expect { error_handler.raise_error }.to raise_error(RDStation::Error::NotImplemented, 'Error Message')
+      end
+    end
+
+    context 'with an error 502' do
+      let(:http_status) { 502 }
+
+      it 'raises a bad gateway error' do
+        expect { error_handler.raise_error }.to raise_error(RDStation::Error::BadGateway, 'Error Message')
+      end
+    end
+
+    context 'with an error 503' do
+      let(:http_status) { 503 }
+
+      it 'raises a service unavailable error' 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 }
+
+      it 'raises a server error' 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: 400,
-          headers: { 'Content-Type' => 'application/json' },
-          body: {
-            'errors' => {
-              'error_type' => 'UNRECOGNIZED_ERROR_TYPE',
-              'error_message' => 'Error Message'
-            }
-          }.to_json
+          code: 502,
+          headers: { 'error' => 'header' },
+          body: '<html><body>HTML error response</body></html>'
         )
       end
 
-      it 'raises the Default error' do
-        expect { error_handler.raise_errors }.to raise_error(RDStation::Error::Default, 'Error Message') do |error|
-          expect(error.details).to be
-          expect(error.headers).to be
-          expect(error.body).to be
-          expect(error.http_status).to be
-        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

data/spec/lib/rdstation/events_spec.rb

@@ -1,13 +1,19 @@
 require 'spec_helper'
 
 RSpec.describe RDStation::Events do
-  let(:valid_auth_token) { 'valid_auth_token' }
-  let(:invalid_auth_token) { 'invalid_auth_token' }
-  let(:expired_auth_token) { 'expired_auth_token' }
+  let(:valid_access_token) { 'valid_access_token' }
+  let(:invalid_access_token) { 'invalid_access_token' }
+  let(:expired_access_token) { 'expired_access_token' }
 
-  let(:event_with_valid_token) { described_class.new(valid_auth_token) }
-  let(:event_with_expired_token) { described_class.new(expired_auth_token) }
-  let(:event_with_invalid_token) { described_class.new(invalid_auth_token) }
+  let(:event_with_valid_token) do
+    described_class.new(authorization: RDStation::Authorization.new(access_token: valid_access_token))
+  end
+  let(:event_with_expired_token) do
+    described_class.new(authorization: RDStation::Authorization.new(access_token: expired_access_token))
+  end
+  let(:event_with_invalid_token) do
+    described_class.new(authorization: RDStation::Authorization.new(access_token: invalid_access_token))
+  end
 
   let(:events_endpoint) { 'https://api.rd.services/platform/events' }
 
@@ -45,21 +51,21 @@ RSpec.describe RDStation::Events do
 
   let(:valid_headers) do
     {
-      'Authorization' => "Bearer #{valid_auth_token}",
+      'Authorization' => "Bearer #{valid_access_token}",
       'Content-Type' => 'application/json'
     }
   end
 
   let(:invalid_token_headers) do
     {
-      'Authorization' => "Bearer #{invalid_auth_token}",
+      'Authorization' => "Bearer #{invalid_access_token}",
       'Content-Type' => 'application/json'
     }
   end
 
   let(:expired_token_headers) do
     {
-      'Authorization' => "Bearer #{expired_auth_token}",
+      'Authorization' => "Bearer #{expired_access_token}",
       'Content-Type' => 'application/json'
     }
   end
@@ -102,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

@@ -1,12 +1,14 @@
 require 'spec_helper'
 
 RSpec.describe RDStation::Fields do
-  let(:valid_auth_token) { 'valid_auth_token' }
-  let(:rdstation_fields_with_valid_token) { described_class.new(valid_auth_token) }
+  let(:valid_access_token) { 'valid_access_token' }
+  let(:rdstation_fields_with_valid_token) do
+    described_class.new(authorization: RDStation::Authorization.new(access_token: valid_access_token))
+  end
 
   let(:valid_headers) do
     {
-      'Authorization' => "Bearer #{valid_auth_token}",
+      'Authorization' => "Bearer #{valid_access_token}",
       'Content-Type' => 'application/json'
     }
   end
@@ -36,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)