rdstation-ruby-client 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c632e94efb06e81ab00f5272d042b0c5b26cf55f
-  data.tar.gz: c947e738844beb8671118a0d76df0468f8361528
+  metadata.gz: ea20e4d5e37030b98d697da5b71892ff892a3204
+  data.tar.gz: 027a431a05b01d94279b40d194d334d8a5235cf4
 SHA512:
-  metadata.gz: edc33857fcf8af5535d2446da9d0cd3327cd2a092b47d722cb1107887ff649f127a65c301cb80e45c4fae9997713e568eb88b81cfe72498971bbc348f07e6a4e
-  data.tar.gz: cd2315fe944d7790336f50586ad68ef9240092550ca75e2b8327863f880d59ba36ccb8a0012cf9d9fefda4901d2d2ab348a033a51812488136d38c463f7d94de
+  metadata.gz: 7a1bedc3f94bd5f532ab9073d0abc9651ef1a9159e0b339b13b9061e8c476967683b5a66bb659a12a6848fc7396a854be6153655acab97bef9f205ad50ada11b
+  data.tar.gz: ebbf843ae9cc9293850070b0b40cf638a8e1a7e61655f2022def1d01e3987b78dd2a4227e43ccb403a28d3e941f3813238595b542b6978433ecc86e1462fdd20

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rdstation-ruby-client (1.0.0)
+    rdstation-ruby-client (1.0.1)
       httparty (~> 0.12)
 
 GEM

data/lib/rdstation/error.rb

@@ -1,12 +1,20 @@
 module RDStation
 
   class Error < StandardError
-    attr_reader :http_status, :headers, :body
+    attr_reader :details, :http_status, :headers, :body
+
+    def initialize(details)
+      @details = details
+      message = details['error_message']
+      raise ArgumentError, 'The details hash must contain an error message' unless message
+
+      # Those three arguments are kept only for compatibility reasons.
+      # They aren't needed since we can get them directly in the details hash.
+      # Consider removing them when update the major version.
+      @http_status = details['http_status']
+      @headers = details['headers']
+      @body = details['body']
 
-    def initialize(message, api_response_error)
-      @http_status = api_response_error.code
-      @headers = api_response_error.headers
-      @body = JSON.parse(api_response_error.body)
       super(message)
     end
 

data/lib/rdstation/error/format.rb

@@ -0,0 +1,30 @@
+module RDStation
+  class Error
+    class Format
+      FLAT_HASH = 'FLAT_HASH'.freeze
+      HASH_OF_ARRAYS = 'HASH_OF_ARRAYS'.freeze
+      ARRAY_OF_HASHES = 'ARRAY_OF_HASHES'.freeze
+
+      def initialize(errors)
+        @errors = errors
+      end
+
+      def format
+        return FLAT_HASH if flat_hash?
+        return HASH_OF_ARRAYS if hash_of_arrays?
+        ARRAY_OF_HASHES
+      end
+
+      private
+
+      def flat_hash?
+        return unless @errors.is_a?(Hash)
+        @errors.key?('error_type')
+      end
+
+      def hash_of_arrays?
+        @errors.is_a?(Hash) && @errors.values.all? { |error| error.is_a? Array }
+      end
+    end
+  end
+end

data/lib/rdstation/error/formatter.rb

@@ -0,0 +1,40 @@
+require_relative './format'
+
+module RDStation
+  class Error
+    class Formatter
+      def initialize(errors)
+        @errors = errors
+      end
+
+      def to_array
+        case error_format.format
+        when RDStation::Error::Format::FLAT_HASH
+          from_flat_hash
+        when RDStation::Error::Format::HASH_OF_ARRAYS
+          from_hash_of_arrays
+        else
+          @errors
+        end
+      end
+
+      def from_flat_hash
+        [@errors]
+      end
+
+      def from_hash_of_arrays
+        @errors.each_with_object([]) do |errors, array_of_errors|
+          attribute_name = errors.first
+          attribute_errors = errors.last
+          path = { 'path' => "body.#{attribute_name}" }
+          errors = attribute_errors.map { |error| error.merge(path) }
+          array_of_errors.push(*errors)
+        end
+      end
+
+      def error_format
+        @error_format ||= RDStation::Error::Format.new(@errors)
+      end
+    end
+  end
+end

data/lib/rdstation/error_handler.rb

@@ -1,3 +1,4 @@
+require_relative 'error/formatter'
 require_relative 'error_handler/conflicting_field'
 require_relative 'error_handler/default'
 require_relative 'error_handler/expired_access_token'
@@ -23,16 +24,37 @@ module RDStation
     end
 
     def raise_errors
-      errors.each(&:raise_error)
-      # Raise only the exception message when the error is not recognized
-      unrecognized_error = @response['errors']
-      raise unrecognized_error['error_message']
+      error_types.each(&:raise_error)
     end
 
     private
 
-    def errors
-      ERROR_TYPES.map { |error| error.new(@response) }
+    attr_reader :response
+
+    def array_of_errors
+      error_formatter.to_array.map do |error|
+        error.merge(additional_error_attributes)
+      end
+    end
+
+    def error_types
+      ERROR_TYPES.map { |error_type| error_type.new(array_of_errors) }
+    end
+
+    def response_errors
+      JSON.parse(response.body)['errors']
+    end
+
+    def error_formatter
+      @error_formatter = RDStation::Error::Formatter.new(response_errors)
+    end
+
+    def additional_error_attributes
+      {
+        'headers' => response.headers,
+        'body' => JSON.parse(response.body),
+        'http_status' => response.code
+      }
     end
   end
 end

data/lib/rdstation/error_handler/conflicting_field.rb

@@ -1,25 +1,23 @@
 module RDStation
   class ErrorHandler
     class ConflictingField
-      attr_reader :api_response, :response_body, :error
+      attr_reader :errors
 
       ERROR_CODE = 'CONFLICTING_FIELD'.freeze
-      EXCEPTION_CLASS = RDStation::Error::ConflictingField
 
-      def initialize(api_response)
-        @api_response = api_response
-        @error = JSON.parse(api_response.body)['errors']
+      def initialize(errors)
+        @errors = errors
       end
 
       def raise_error
-        return unless conflicting_field?
-        raise EXCEPTION_CLASS.new(error['error_message'], api_response)
+        return if conflicting_field_errors.empty?
+        raise RDStation::Error::ConflictingField, conflicting_field_errors.first
       end
 
       private
 
-      def conflicting_field?
-        error['error_type'] == ERROR_CODE
+      def conflicting_field_errors
+        errors.select { |error| error['error_type'] == ERROR_CODE }
       end
     end
   end

data/lib/rdstation/error_handler/default.rb

@@ -1,18 +1,14 @@
 module RDStation
   class ErrorHandler
     class Default
-      attr_reader :api_response
-      EXCEPTION_CLASS = RDStation::Error::Default
+      attr_reader :errors
 
-      def initialize(api_response)
-        @api_response = api_response
+      def initialize(errors)
+        @errors = errors
       end
 
       def raise_error
-        raise RDStation::Error::Default.new(
-          'An unrecognized error has occurred.',
-          api_response
-        )
+        raise RDStation::Error::Default, errors.first
       end
     end
   end

data/lib/rdstation/error_handler/expired_access_token.rb

@@ -1,29 +1,33 @@
 module RDStation
   class ErrorHandler
     class ExpiredAccessToken
-      attr_reader :api_response, :response_headers, :error
+      attr_reader :errors
 
-      EXCEPTION_CLASS = RDStation::Error::ExpiredAccessToken
+      EXPIRED_TOKEN_ERROR = 'error="expired_token"'.freeze
 
-      def initialize(api_response)
-        @api_response = api_response
-        @error = JSON.parse(api_response.body)['errors']
-        @response_headers = api_response.headers
+      def initialize(errors)
+        @errors = errors
       end
 
       def raise_error
-        return unless expired_token?
-        raise EXCEPTION_CLASS.new(error['error_message'], api_response)
+        return if expired_token_errors.empty?
+        raise RDStation::Error::ExpiredAccessToken, expired_token_errors.first
       end
 
       private
 
-      def expired_token?
-        auth_header = response_headers['x-amzn-remapped-www-authenticate'] ||
-                      response_headers['www-authenticate']
+      def expired_token_errors
+        errors.select do |error|
+          error_header = error['headers']
+          next unless error_header
+          expired_token_error?(error_header)
+        end
+      end
 
+      def expired_token_error?(error_header)
+        auth_header = error_header['x-amzn-remapped-www-authenticate'] || error_header['www-authenticate']
         return unless auth_header
-        auth_header.include?('error="expired_token"')
+        auth_header.include?(EXPIRED_TOKEN_ERROR)
       end
     end
   end

data/lib/rdstation/error_handler/expired_code_grant.rb

@@ -1,26 +1,23 @@
 module RDStation
   class ErrorHandler
     class ExpiredCodeGrant
-      attr_reader :api_response, :response_headers, :error
+      attr_reader :errors
 
       ERROR_CODE = 'EXPIRED_CODE_GRANT'.freeze
-      EXCEPTION_CLASS = RDStation::Error::ExpiredCodeGrant
 
-      def initialize(api_response)
-        @api_response = api_response
-        @error = JSON.parse(api_response.body)['errors']
-        @response_headers = api_response.headers
+      def initialize(errors)
+        @errors = errors
       end
 
       def raise_error
-        return unless expired_code?
-        raise EXCEPTION_CLASS.new(error['error_message'], api_response)
+        return if expired_code_errors.empty?
+        raise RDStation::Error::ExpiredCodeGrant, expired_code_errors.first
       end
 
       private
 
-      def expired_code?
-        error['error_type'] == ERROR_CODE
+      def expired_code_errors
+        errors.select { |error| error['error_type'] == ERROR_CODE }
       end
     end
   end

data/lib/rdstation/error_handler/invalid_credentials.rb

@@ -1,25 +1,23 @@
 module RDStation
   class ErrorHandler
     class InvalidCredentials
-      attr_reader :api_response, :error
+      attr_reader :errors
 
       ERROR_CODE = 'ACCESS_DENIED'.freeze
-      EXCEPTION_CLASS = RDStation::Error::InvalidCredentials
 
-      def initialize(api_response)
-        @api_response = api_response
-        @error = JSON.parse(api_response.body)['errors']
+      def initialize(errors)
+        @errors = errors
       end
 
       def raise_error
-        return unless credentials_errors?
-        raise EXCEPTION_CLASS.new(error['error_message'], api_response)
+        return if invalid_credentials_error.empty?
+        raise RDStation::Error::InvalidCredentials, invalid_credentials_error.first
       end
 
       private
 
-      def credentials_errors?
-        error['error_type'] == ERROR_CODE
+      def invalid_credentials_error
+        errors.select { |error| error['error_type'] == ERROR_CODE }
       end
     end
   end

data/lib/rdstation/error_handler/resource_not_found.rb

@@ -1,25 +1,23 @@
 module RDStation
   class ErrorHandler
     class ResourceNotFound
-      attr_reader :api_response, :error
+      attr_reader :errors
 
       ERROR_CODE = 'RESOURCE_NOT_FOUND'.freeze
-      EXCEPTION_CLASS = RDStation::Error::ResourceNotFound
 
-      def initialize(api_response)
-        @api_response = api_response
-        @error = JSON.parse(api_response.body)['errors']
+      def initialize(errors)
+        @errors = errors
       end
 
       def raise_error
-        return unless resource_not_found?
-        raise EXCEPTION_CLASS.new(error['error_message'], api_response)
+        return if resource_not_found_errors.empty?
+        raise RDStation::Error::ResourceNotFound, resource_not_found_errors.first
       end
 
       private
 
-      def resource_not_found?
-        error['error_type'] == ERROR_CODE
+      def resource_not_found_errors
+        errors.select { |error| error['error_type'] == ERROR_CODE }
       end
     end
   end

data/lib/rdstation/error_handler/unauthorized.rb

@@ -1,25 +1,23 @@
 module RDStation
   class ErrorHandler
     class Unauthorized
-      attr_reader :api_response, :response_body, :error
+      attr_reader :errors
 
       ERROR_CODE = 'UNAUTHORIZED'.freeze
-      EXCEPTION_CLASS = RDStation::Error::Unauthorized
 
-      def initialize(api_response)
-        @api_response = api_response
-        @error = JSON.parse(api_response.body)['errors']
+      def initialize(errors)
+        @errors = errors
       end
 
       def raise_error
-        return unless unauthorized?
-        raise EXCEPTION_CLASS.new(error['error_message'], api_response)
+        return if unauthorized_errors.empty?
+        raise RDStation::Error::Unauthorized, unauthorized_errors.first
       end
 
       private
 
-      def unauthorized?
-        error['error_type'] == ERROR_CODE
+      def unauthorized_errors
+        errors.select { |error| error['error_type'] == ERROR_CODE }
       end
     end
   end

data/lib/rdstation/version.rb

@@ -1,3 +1,3 @@
 module RDStation
-  VERSION = '1.0.0'.freeze
+  VERSION = '1.0.1'.freeze
 end

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

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+RSpec.describe RDStation::Error::Format do
+  describe '#format' do
+    subject(:error_format) { described_class.new(errors) }
+
+    context 'when receives a flat hash of errors' do
+      let(:errors) do
+        {
+          'error_type' => 'CONFLICTING_FIELD',
+          'error_message' => 'The payload contains an attribute that was used to identify the lead'
+        }
+      end
+
+      it 'returns the FLAT_HASH format' do
+        result = error_format.format
+        expect(result).to eq(RDStation::Error::Format::FLAT_HASH)
+      end
+    end
+
+    context 'when receives a hash of arrays of errors' do
+      let(:errors) do
+        {
+          'name' => [
+            {
+              'error_type' => 'MUST_BE_STRING',
+              'error_message' => 'Name must be string.'
+            }
+          ]
+        }
+      end
+
+      it 'returns the HASH_OF_ARRAYS format' do
+        result = error_format.format
+        expect(result).to eq(RDStation::Error::Format::HASH_OF_ARRAYS)
+      end
+    end
+
+    context 'when receives an array of errors' do
+      let(:errors) do
+        [
+          {
+            'error_type' => 'CANNOT_BE_NULL',
+            'error_message' => 'Cannot be null.',
+            'path' => 'body.client_secret'
+          }
+        ]
+      end
+
+      it 'returns the ARRAY_OF_HASHES format' do
+        result = error_format.format
+        expect(result).to eq(RDStation::Error::Format::ARRAY_OF_HASHES)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+RSpec.describe RDStation::Error::Formatter do
+  describe '#to_array' do
+    before do
+      allow(RDStation::Error::Format).to receive(:new).and_return(error_format)
+    end
+
+    context 'when receives a flat hash of errors' do
+      let(:error_format) { instance_double(RDStation::Error::Format, format: RDStation::Error::Format::FLAT_HASH) }
+
+      let(:errors) do
+        {
+          'error_type' => 'CONFLICTING_FIELD',
+          'error_message' => 'The payload contains an attribute that was used to identify the lead'
+        }
+      end
+
+      let(:error_formatter) { described_class.new(errors) }
+
+      let(:expected_result) do
+        [
+          {
+            'error_type' => 'CONFLICTING_FIELD',
+            'error_message' => 'The payload contains an attribute that was used to identify the lead'
+          }
+        ]
+      end
+
+      it 'returns an array of errors including the status code and headers' do
+        result = error_formatter.to_array
+        expect(result).to eq(expected_result)
+      end
+    end
+
+    context 'when receives a hash of arrays of errors' do
+      let(:error_format) { instance_double(RDStation::Error::Format, format: RDStation::Error::Format::HASH_OF_ARRAYS) }
+
+      let(:errors) do
+        {
+          'name' => [
+            {
+              'error_type' => 'MUST_BE_STRING',
+              'error_message' => 'Name must be string.'
+            }
+          ]
+        }
+      end
+
+      let(:error_formatter) { described_class.new(errors) }
+
+      let(:expected_result) do
+        [
+          {
+            'error_type' => 'MUST_BE_STRING',
+            'error_message' => 'Name must be string.',
+            'path' => 'body.name'
+          }
+        ]
+      end
+
+      it 'returns an array of errors including the status code and headers' do
+        result = error_formatter.to_array
+        expect(result).to eq(expected_result)
+      end
+    end
+
+    context 'when receives an array of errors' do
+      let(:error_format) { instance_double(RDStation::Error::Format, format: RDStation::Error::Format::ARRAY_OF_HASHES) }
+
+      let(:errors) do
+        [
+          {
+            'error_type' => 'CANNOT_BE_NULL',
+            'error_message' => 'Cannot be null.',
+            'path' => 'body.client_secret'
+          }
+        ]
+      end
+
+      let(:error_formatter) { described_class.new(errors) }
+
+      let(:expected_result) do
+        [
+          {
+            'error_type' => 'CANNOT_BE_NULL',
+            'error_message' => 'Cannot be null.',
+            'path' => 'body.client_secret'
+          }
+        ]
+      end
+
+      it 'returns an array of errors including the status code and headers' do
+        result = error_formatter.to_array
+        expect(result).to eq(expected_result)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+RSpec.describe RDStation::ErrorHandler::ConflictingField do
+  describe '#raise_error' do
+    subject(:conflicting_field_errors) { described_class.new(errors) }
+
+    context 'when none of the errors are conflicting field errors' do
+      let(:errors) do
+        [
+          {
+            'error_type' => 'RANDOM_ERROR_TYPE',
+            'error_message' => 'Random error message'
+          }
+        ]
+      end
+
+      it 'does not raise the error' do
+        result = conflicting_field_errors.raise_error
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when there is a conflict field errors' do
+      let(:errors) do
+        [
+          {
+            'error_type' => 'CONFLICTING_FIELD',
+            'error_message' => 'The payload contains an attribute that was used to identify the lead'
+          }
+        ]
+      end
+
+      it 'raises the error' do
+        expect do
+          conflicting_field_errors.raise_error
+        end.to raise_error(RDStation::Error::ConflictingField)
+      end
+    end
+
+    context 'when there are no errors' do
+      let(:errors) { [] }
+
+      it 'does not raise the error' do
+        result = conflicting_field_errors.raise_error
+        expect(result).to be_nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+RSpec.describe RDStation::ErrorHandler::Default do
+  describe '#raise_error' do
+    let(:errors) { [{ 'error_message' => 'Error Message' }] }
+    let(:default_error) { described_class.new(errors) }
+
+    it 'raises the received error' do
+      expect do
+        default_error.raise_error
+      end.to raise_error(RDStation::Error::Default, errors.first['error_message'])
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+RSpec.describe RDStation::ErrorHandler::ExpiredAccessToken do
+  describe '#raise_error' do
+
+    subject(:expired_access_token_error) { described_class.new(errors) }
+
+    context 'when there is an expired token error' do
+      let(:errors) do
+        [
+          {
+            'headers' => {
+              'www-authenticate' => 'Bearer realm="https://api.rd.services/", error="expired_token", error_description="The access token expired"'
+            },
+            'error_message' => 'Error Message',
+            'error_type' => 'EXPIRED_TOKEN_ERROR'
+          }
+        ]
+      end
+
+      it 'raises an ExpiredAccessToken error' do
+        expect do
+          expired_access_token_error.raise_error
+        end.to raise_error(RDStation::Error::ExpiredAccessToken, 'Error Message')
+      end
+    end
+
+    context 'when the errors does not contain a header' 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 ExpiredAccessToken error' do
+        result = expired_access_token_error.raise_error
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when none of the errors are expired token errors' do
+      let(:errors) do
+        [
+          {
+            'headers' => {
+              'Content-Type' => 'application/json'
+            },
+            'error_message' => 'Error Message',
+            'error_type' => 'RANDOM_ERROR_TYPE'
+          },
+          {
+            'headers' => {
+              'Content-Type' => 'application/json'
+            },
+            'error_message' => 'Another Error Message',
+            'error_type' => 'ANOTHER_RANDOM_ERROR_TYPE'
+          }
+        ]
+      end
+
+      it 'does not raise an ExpiredAccessToken error' do
+        result = expired_access_token_error.raise_error
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when there are no errors' do
+      let(:errors) { [] }
+
+      it 'does not raise an ExpiredAccessToken error' do
+        result = expired_access_token_error.raise_error
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when the expired token header is x-amzn-remapped-www-authenticate' do
+      let(:errors) do
+        [
+          {
+            'headers' => {
+              'x-amzn-remapped-www-authenticate' => 'Bearer realm="https://api.rd.services/", error="expired_token", error_description="The access token expired"'
+            },
+            'error_message' => 'Error Message',
+            'error_type' => 'EXPIRED_TOKEN_ERROR'
+          }
+        ]
+      end
+
+      it 'raises an ExpiredAccessToken error' do
+        expect do
+          expired_access_token_error.raise_error
+        end.to raise_error(RDStation::Error::ExpiredAccessToken, 'Error Message')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+RSpec.describe RDStation::ErrorHandler::ExpiredCodeGrant do
+  describe '#raise_error' do
+
+    subject(:expired_code_grant_error) { described_class.new(errors) }
+
+    context 'when there is an expired code grant error' do
+      let(:errors) do
+        [
+          {
+            'error_message' => 'Error Message',
+            'error_type' => 'EXPIRED_CODE_GRANT'
+          }
+        ]
+      end
+
+      it 'raises an ExpiredCodeGrant error' do
+        expect do
+          expired_code_grant_error.raise_error
+        end.to raise_error(RDStation::Error::ExpiredCodeGrant, 'Error Message')
+      end
+    end
+
+    context 'when none of the errors are expired code grant 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 ExpiredCodeGrant error' do
+        result = expired_code_grant_error.raise_error
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when there are no errors' do
+      let(:errors) { [] }
+
+      it 'does not raise an ExpiredCodeGrant error' do
+        result = expired_code_grant_error.raise_error
+        expect(result).to be_nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+RSpec.describe RDStation::ErrorHandler::InvalidCredentials do
+  describe '#raise_error' do
+
+    subject(:invalid_credentials_error) { described_class.new(errors) }
+
+    context 'when there are invalid credentials errors' do
+      let(:errors) do
+        [
+          {
+            'error_message' => 'Error Message',
+            'error_type' => 'ACCESS_DENIED'
+          }
+        ]
+      end
+
+      it 'raises an InvalidCredentials error' do
+        expect do
+          invalid_credentials_error.raise_error
+        end.to raise_error(RDStation::Error::InvalidCredentials, 'Error Message')
+      end
+    end
+
+    context 'when none of the errors are invalid credentials 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 InvalidCredentials error' do
+        result = invalid_credentials_error.raise_error
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when there are no errors' do
+      let(:errors) { [] }
+
+      it 'does not raise an InvalidCredentials error' do
+        result = invalid_credentials_error.raise_error
+        expect(result).to be_nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+RSpec.describe RDStation::ErrorHandler::ResourceNotFound do
+  describe '#raise_error' do
+
+    subject(:resource_not_found_error) { described_class.new(errors) }
+
+    context 'when there is a resource not found error' do
+      let(:errors) do
+        [
+          {
+            'error_message' => 'Error Message',
+            'error_type' => 'RESOURCE_NOT_FOUND'
+          }
+        ]
+      end
+
+      it 'raises an ResourceNotFound error' do
+        expect do
+          resource_not_found_error.raise_error
+        end.to raise_error(RDStation::Error::ResourceNotFound, 'Error Message')
+      end
+    end
+
+    context 'when none of the errors are resource not found 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 ResourceNotFound error' do
+        result = resource_not_found_error.raise_error
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when there are no errors' do
+      let(:errors) { [] }
+
+      it 'does not raise an ResourceNotFound error' do
+        result = resource_not_found_error.raise_error
+        expect(result).to be_nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+RSpec.describe RDStation::ErrorHandler::Unauthorized do
+  describe '#raise_error' do
+
+    subject(:unauthorized_error) { described_class.new(errors) }
+
+    context 'when there is an unauthorized error' do
+      let(:errors) do
+        [
+          {
+            'error_message' => 'Error Message',
+            'error_type' => 'UNAUTHORIZED'
+          }
+        ]
+      end
+
+      it 'raises an Unauthorized error' do
+        expect do
+          unauthorized_error.raise_error
+        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

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+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: {
+            'errors' => {
+              'error_type' => 'CONFLICTING_FIELD',
+              'error_message' => 'Error Message'
+            }
+          }.to_json
+        )
+      end
+
+      it 'raises the corresponding error class' do
+        expect { error_handler.raise_errors }.to raise_error(RDStation::Error::ConflictingField, 'Error Message')
+      end
+    end
+
+    context 'when the error type is not recognized' 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
+        )
+      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
+      end
+    end
+  end
+end

data/spec/lib/rdstation/error_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+RSpec.describe RDStation::Error do
+  describe '.new' do
+    context 'with a valid details hash' do
+      let(:error_details) { { 'error_message' => 'message', 'error_type' => 'ERROR_TYPE' } }
+      let(:result) { described_class.new(error_details) }
+
+      it 'creates a new instance of errors with details' do
+        expect(result.details).to eq(error_details)
+      end
+    end
+
+    context 'with an invalid details hash' do
+      let(:error_details) { { 'error_type' => 'ERROR_TYPE' } }
+
+      it 'raises an invalid argument error' do
+        expect do
+          described_class.new(error_details)
+        end.to raise_error(ArgumentError, 'The details hash must contain an error message')
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rdstation-ruby-client
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Paulo L F Casaretto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-11 00:00:00.000000000 Z
+date: 2018-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -112,6 +112,8 @@ files:
 - lib/rdstation/client.rb
 - lib/rdstation/contacts.rb
 - lib/rdstation/error.rb
+- lib/rdstation/error/format.rb
+- lib/rdstation/error/formatter.rb
 - lib/rdstation/error_handler.rb
 - lib/rdstation/error_handler/conflicting_field.rb
 - lib/rdstation/error_handler/default.rb
@@ -126,6 +128,17 @@ files:
 - spec/lib/rdstation-ruby-client_spec.rb
 - spec/lib/rdstation/authentication_spec.rb
 - spec/lib/rdstation/contacts_spec.rb
+- spec/lib/rdstation/error/format_spec.rb
+- spec/lib/rdstation/error/formatter_spec.rb
+- spec/lib/rdstation/error_handler/conflicting_field_spec.rb
+- spec/lib/rdstation/error_handler/default_spec.rb
+- spec/lib/rdstation/error_handler/expired_access_token_spec.rb
+- spec/lib/rdstation/error_handler/expired_code_grant_spec.rb
+- spec/lib/rdstation/error_handler/invalid_credentials_spec.rb
+- spec/lib/rdstation/error_handler/resource_not_found_spec.rb
+- spec/lib/rdstation/error_handler/unauthorized_spec.rb
+- spec/lib/rdstation/error_handler_spec.rb
+- spec/lib/rdstation/error_spec.rb
 - spec/lib/rdstation/fields_spec.rb
 - spec/spec_helper.rb
 homepage: http://resultadosdigitais.com.br
@@ -148,7 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Ruby API wrapper for RD Station
@@ -156,5 +169,16 @@ test_files:
 - spec/lib/rdstation-ruby-client_spec.rb
 - spec/lib/rdstation/authentication_spec.rb
 - spec/lib/rdstation/contacts_spec.rb
+- spec/lib/rdstation/error/format_spec.rb
+- spec/lib/rdstation/error/formatter_spec.rb
+- spec/lib/rdstation/error_handler/conflicting_field_spec.rb
+- spec/lib/rdstation/error_handler/default_spec.rb
+- spec/lib/rdstation/error_handler/expired_access_token_spec.rb
+- spec/lib/rdstation/error_handler/expired_code_grant_spec.rb
+- spec/lib/rdstation/error_handler/invalid_credentials_spec.rb
+- spec/lib/rdstation/error_handler/resource_not_found_spec.rb
+- spec/lib/rdstation/error_handler/unauthorized_spec.rb
+- spec/lib/rdstation/error_handler_spec.rb
+- spec/lib/rdstation/error_spec.rb
 - spec/lib/rdstation/fields_spec.rb
 - spec/spec_helper.rb