rdstation-ruby-client 2.2.0 → 2.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ade7306767c00b8d39afdeb149d4aaebe84dfd35b389e2bf1435e623dfabfb7
-  data.tar.gz: 3bdc3dc84ff1395fa65dc86e172b5ca967696e88b60bf9774723fcd33c785fbe
+  metadata.gz: 97ef40283572e980be5fee4c7d98d02d267a48e2eca8c948b8d51be95f5e807b
+  data.tar.gz: ebba8f50fef8eaa254c1187f6f2e5e0e9bbf393ad94e185870f250cb2f9bd14d
 SHA512:
-  metadata.gz: fddd4b51c76c965cbd44bda5e36712f26f694fbabd59a7c0b008174cfcacd4225b73ce7640b32e9aeaed2495950ff0c19b70a555b5d8bf0dab79eaf2ce060136
-  data.tar.gz: 90d96ef3c8d917deb7adbfe0aff6e2625b7f4f1d925d6b54e806df9aa3fd3de6378358521bbfce024eb32af06695f0974ca0f0dd8b9684ed1c537f2d228c97de
+  metadata.gz: 467b42ba1b17c256dba0ed6ab2ed632e83c437ae1067d043ccb97c4274244376cc26dd770ef112c8b81eb31c40fd37486bfb4b28f83b16f9dc0a47730a3d6e07
+  data.tar.gz: 6bdcada4a7418e8fd4cab9d4b121d3192667ebccac2869f9fdae759966e291e0698cc914dd1681c6c8493f78717599d063ac868a5ea5e9e23e13da003215563e

data/CHANGELOG.md

@@ -1,3 +1,80 @@
+## 2.5.1
+
+- Fixed checking `empty?` for nil values inside of InvalidRefreshToken class
+
+## 2.5.0
+
+- InvalidRefreshToken error added. This error will be raised when the refresh token is invalid or it was revoked. When you get this error, you can safely disconnect the user from RD Station.
+
+Usage example:
+
+```ruby
+begin
+  rdstation.update_access_token(refresh_token)
+rescue RDStation::Error::InvalidRefreshToken
+  # Disconnect user
+end
+```
+
+## 2.4.0
+
+- Add the TooManyRequests errors in case of rate limit exceeded. See [API request limit](https://developers.rdstation.com/en/request-limit) for more details
+
+## 2.3.1
+
+- Fixed a bug when no error is found in the known errors list (issue [#52](https://github.com/ResultadosDigitais/rdstation-ruby-client/issues/52))
+
+## 2.3.0
+
+### Additions
+
+#### 1. New Field methods
+
+The following methods were added to "Fields" client:
+
+- create
+- update
+- delete
+
+Besides reading, this client is now capable of create, update or delete a field.
+
+Usage example:
+
+```ruby
+client = RDStation::Client.new(access_token: 'ACCESS_TOKEN', refresh_token: 'REFRESH_TOKEN')
+client.fields.delete('FIELD_UUID')
+```
+
+#### 2. New format of errors supported
+
+Two new formats of errors are now supported by the error handler:
+
+##### `HASH_OF_HASHES`
+
+When the error message is a hash containing other hashes as values, for example:
+
+```ruby
+{
+  'error' => {
+    'field1' => {...},
+    'field2' => {...}
+  }
+}
+```
+
+##### `HASH_OF_MULTIPLE_TYPES`
+
+When the error message is a hash that could contain multiple data types as values, for example:
+
+```ruby
+{
+  'error' => {
+    'field1' => [...] # Array,
+    'field2' => {...} # Hash
+  }
+}
+```
+
 ## 2.2.0
 
 ### Additions
@@ -37,7 +114,7 @@ end
 
 Providing `client_id` and `client_secret` directly to `RDStation::Authentication.new` is deprecated and will be removed in future versions. Use `RDStation.configure` instead.
 
-Specifying refresh_token in `RDStation::Client.new(access_token: 'at', refresh_token: 'rt')` is optional right now, but will be mandatory in future versions. 
+Specifying refresh_token in `RDStation::Client.new(access_token: 'at', refresh_token: 'rt')` is optional right now, but will be mandatory in future versions.
 
 ## 2.1.1
 
@@ -94,7 +171,7 @@ In case of a Bad Request (400), the following specific errors may be raised (tho
 - `RDStation::Error::ConflictingField`
 - `RDStation::Error::InvalidEventType`
 
-In cause of Unahtorized (401), the following specific errors may be raised (those are subclasses of `RDStation::Error::Unauthorized`):
+In cause of Unauthorized (401), the following specific errors may be raised (those are subclasses of `RDStation::Error::Unauthorized`):
 - `RDStation::Error::ExpiredAccessToken`
 - `RDStation::Error::ExpiredCodeGrant`
 - `RDStation::Error::InvalidCredentials`

data/README.md

@@ -93,7 +93,7 @@ RDStation.configure do |config|
     # authorization.access_token_expires_in is the time (in seconds for with the token is valid)
     # authorization.access_token is the new token
     # authorization.refresh_token is the existing refresh_token
-    # 
+    #
     # If you are using ActiveRecord, you may want to update the stored access_token, like in the following code:
     MyStoredAuth.where(refresh_token: authorization.refresh_token).update_all(access_token: authorization.access_token)
   end
@@ -206,6 +206,55 @@ client = RDStation::Client.new(access_token: 'access_token', refresh_token: 'ref
 client.fields.all
 ```
 
+#### Create a field
+
+```ruby
+payload = {} # hash representing the payload
+client = RDStation::Client.new(access_token: 'access_token', refresh_token: 'refresh_token')
+client.fields.create payload
+```
+Or you can use the new `RDStation::Builder::Field`
+
+```ruby
+payload = {} # hash representing the payload
+builder = RDStation::Builder::Field.new payload['api_identifier']
+builder.data_type(payload['data_type'])
+builder.presentation_type(payload['presentation_type'])
+builder.name('pt-BR', payload['name'])
+builder.label('pt-BR', payload['label'])
+
+client = RDStation::Client.new(access_token: 'access_token', refresh_token: 'refresh_token')
+client.fields.create builder.build
+```
+
+#### Update a field
+
+```ruby
+payload = {} # hash representing the payload
+client = RDStation::Client.new(access_token: 'access_token', refresh_token: 'refresh_token')
+client.fields.update('FIELD_UUID', payload)
+```
+Or you can use the new `RDStation::Builder::Field`
+
+```ruby
+payload = {} # hash representing the payload
+builder = RDStation::Builder::Field.new payload['api_identifier']
+builder.data_type(payload['data_type'])
+builder.presentation_type(payload['presentation_type'])
+builder.name('pt-BR', payload['name'])
+builder.label('pt-BR', payload['label'])
+
+client = RDStation::Client.new(access_token: 'access_token', refresh_token: 'refresh_token')
+client.fields.update('FIELD_UUID', builder.build)
+```
+#### Deleting a field
+
+```ruby
+client = RDStation::Client.new(access_token: 'access_token', refresh_token: 'refresh_token')
+client.fields.delete('FIELD_UUID')
+```
+
+
 ### Webhooks
 
 Webhooks provide the ability to receive real-time data updates about your contact activity.
@@ -266,6 +315,7 @@ Each endpoint may raise errors accoording to the HTTP response code from RDStati
 - `RDStation::Error::Conflict` (409)
 - `RDStation::Error::UnsupportedMediaType` (415)
 - `RDStation::Error::UnprocessableEntity` (422)
+- `RDStation::Error::TooManyRequests` (429)
 - `RDStation::Error::InternalServerError` (500)
 - `RDStation::Error::NotImplemented` (501)
 - `RDStation::Error::BadGateway` (502)

data/Rakefile

@@ -5,3 +5,7 @@ RSpec::Core::RakeTask.new
 
 task :default => :spec
 task :test => :spec
+
+task :console do
+  exec 'pry -r rdstation-ruby-client -I ./lib'
+end

data/lib/rdstation-ruby-client.rb

@@ -17,3 +17,6 @@ require 'rdstation/webhooks'
 # Error handling
 require 'rdstation/error'
 require 'rdstation/error_handler'
+
+# Builders
+require 'rdstation/builder/field'

data/lib/rdstation/builder/field.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RDStation
+  class Builder
+    # More info: https://developers.rdstation.com/pt-BR/reference/fields#methodPostDetails
+    class Field
+      DATA_TYPES = %w(STRING INTEGER BOOLEAN STRING[]).freeze
+      PRESENTATION_TYPES = %w[TEXT_INPUT TEXT_AREA URL_INPUT PHONE_INPUT
+                              EMAIL_INPUT CHECK_BOX NUMBER_INPUT COMBO_BOX
+                              RADIO_BUTTON MULTIPLE_CHOICE].freeze
+
+      REQUIRED_FIELDS = %w[api_identifier data_type presentation_type label name].freeze
+
+      def initialize(api_identifier)
+        raise 'api_identifier required' unless api_identifier
+        unless valid_identifier(api_identifier)
+          raise 'api_identifier is not in a valid format, need start with "cf_"'
+        end
+
+        @values = {}
+        @values['api_identifier'] = api_identifier
+      end
+
+      def data_type(data_type)
+        raise "Not valid data_type - #{DATA_TYPES}" unless DATA_TYPES.include? data_type
+
+        @values['data_type'] = data_type
+      end
+
+      def presentation_type(presentation_type)
+        unless PRESENTATION_TYPES.include? presentation_type
+          raise "Not valid presentation_type - #{PRESENTATION_TYPES}"
+        end
+
+        @values['presentation_type'] = presentation_type
+      end
+
+      def label(language, label)
+        @values['label'] = { language.to_s => label }
+      end
+
+      def name(language, name)
+        @values['name'] = { language.to_s => name }
+      end
+
+      def validation_rules(validation_rules)
+        @values['validation_rules'] = validation_rules
+      end
+
+      def valid_options(valid_options)
+        @values['valid_options'] = valid_options
+      end
+
+      def build
+        empty_fields = REQUIRED_FIELDS.select { |field| @values[field].nil? }
+        unless empty_fields.empty?
+          raise "Required fields are missing - #{empty_fields}"
+        end
+
+        @values
+      end
+
+      private
+
+      def valid_identifier(api_identifier)
+        api_identifier.start_with? 'cf_'
+      end
+    end
+  end
+end

data/lib/rdstation/error.rb

@@ -19,11 +19,13 @@ module RDStation
     class Conflict < Error; end
     class UnsupportedMediaType < Error; end
     class UnprocessableEntity < Error; end
+    class TooManyRequests < Error; end
     class InternalServerError < Error; end
     class NotImplemented < Error; end
     class BadGateway < Error; end
     class ServiceUnavailable < Error; end
     class ServerError < Error; end
+    class UnknownError < Error; end
 
     # 400 - Bad Request
     class ConflictingField < BadRequest; end
@@ -33,5 +35,6 @@ module RDStation
     class ExpiredAccessToken < Unauthorized; end
     class ExpiredCodeGrant < Unauthorized; end
     class InvalidCredentials < Unauthorized; end
+    class InvalidRefreshToken < Unauthorized; end
   end
 end

data/lib/rdstation/error/format.rb

@@ -1,9 +1,14 @@
+# frozen_string_literal: true
+
 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
+      FLAT_HASH = 'FLAT_HASH'
+      HASH_OF_ARRAYS = 'HASH_OF_ARRAYS'
+      ARRAY_OF_HASHES = 'ARRAY_OF_HASHES'
+      HASH_OF_MULTIPLE_TYPES = 'HASH_OF_MULTIPLE_TYPES'
+      HASH_OF_HASHES = 'HASH_OF_HASHES'
+      SINGLE_HASH = 'SINGLE_HASH'
 
       def initialize(errors)
         @errors = errors
@@ -11,20 +16,41 @@ module RDStation
 
       def format
         return FLAT_HASH if flat_hash?
+        return SINGLE_HASH if single_hash?
         return HASH_OF_ARRAYS if hash_of_arrays?
+        return HASH_OF_HASHES if hash_of_hashes?
+        return HASH_OF_MULTIPLE_TYPES if hash_of_multiple_types?
+
         ARRAY_OF_HASHES
       end
 
       private
 
+      def single_hash?
+        return unless @errors.is_a?(Hash)
+
+        @errors.key?('error')
+      end
+
       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
+
+      def hash_of_hashes?
+        @errors.is_a?(Hash) && @errors.values.all? { |error| error.is_a? Hash }
+      end
+
+      def hash_of_multiple_types?
+        @errors.is_a?(Hash) &&
+          @errors.values.any? { |error| error.is_a? Hash } &&
+          @errors.values.any? { |error| error.is_a? Array }
+      end
     end
   end
 end

data/lib/rdstation/error/formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative './format'
 
 module RDStation
@@ -11,27 +13,61 @@ module RDStation
         return @error_response unless @error_response.is_a?(Hash)
 
         case error_format.format
+        when RDStation::Error::Format::SINGLE_HASH
+          return from_single_hash
         when RDStation::Error::Format::FLAT_HASH
           return from_flat_hash
         when RDStation::Error::Format::HASH_OF_ARRAYS
           return from_hash_of_arrays
+        when RDStation::Error::Format::HASH_OF_HASHES
+          return from_hash_of_hashes
+        when RDStation::Error::Format::HASH_OF_MULTIPLE_TYPES
+          return from_hash_of_multiple_types
         end
 
         errors
       end
 
+      def from_single_hash
+        error_hash = @error_response.dup
+        error_message = error_hash.delete('error')
+
+        [
+          {
+            'error_type' => 'TOO_MANY_REQUESTS',
+            'error_message' => error_message,
+            'details' => error_hash
+          }
+        ]
+      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)
+      def from_hash_of_multiple_types
+        array_of_errors = []
+        errors.each do |attribute_name, errors|
+          if errors.is_a? Array
+            result = build_error_from_array(attribute_name, errors)
+          end
+          if errors.is_a? Hash
+            result = build_error_from_multilingual_hash(attribute_name, errors)
+          end
+          array_of_errors.push(*result)
         end
+
+        array_of_errors
+      end
+
+      def from_hash_of_hashes
+        array_of_errors = []
+        errors.each do |attribute_name, errors|
+          result = build_error_from_multilingual_hash(attribute_name, errors)
+          array_of_errors.push(*result)
+        end
+
+        array_of_errors
       end
 
       def error_format
@@ -39,7 +75,32 @@ module RDStation
       end
 
       def errors
-        @errors ||= @error_response['errors']
+        @errors ||= @error_response.fetch('errors', @error_response)
+      end
+
+      private
+
+      def build_error_from_array(attribute_name, attribute_errors)
+        path = { 'path' => "body.#{attribute_name}" }
+        attribute_errors.map { |error| error.merge(path) }
+      end
+
+      def build_error_from_multilingual_hash(attribute_name, errors_by_language)
+        array_of_errors = []
+        errors_by_language.each do |language, errors|
+          result = build_error_from_array("#{attribute_name}.#{language}", errors)
+          array_of_errors.push(*result)
+        end
+        array_of_errors
+      end
+
+      def from_hash_of_arrays
+        errors.each_with_object([]) do |errors, array_of_errors|
+          attribute_name = errors.first
+          attribute_errors = errors.last
+          errors = build_error_from_array(attribute_name, attribute_errors)
+          array_of_errors.push(*errors)
+        end
       end
     end
   end

data/lib/rdstation/error_handler.rb

@@ -32,11 +32,14 @@ module RDStation
       when 409      then RDStation::Error::Conflict
       when 415      then RDStation::Error::UnsupportedMediaType
       when 422      then RDStation::Error::UnprocessableEntity
+      when 429      then RDStation::Error::TooManyRequests
       when 500      then RDStation::Error::InternalServerError
       when 501      then RDStation::Error::NotImplemented
       when 502      then RDStation::Error::BadGateway
       when 503      then RDStation::Error::ServiceUnavailable
       when 500..599 then RDStation::Error::ServerError
+      else
+        RDStation::Error::UnknownError
       end
     end
 
@@ -55,7 +58,7 @@ module RDStation
     end
 
     def additional_error_attributes
-      {
+      attrs = {
         'headers' => response.headers,
         'body' => JSON.parse(response.body),
         'http_status' => response.code,

data/lib/rdstation/error_handler/invalid_refresh_token.rb

@@ -0,0 +1,25 @@
+module RDStation
+  class ErrorHandler
+    class InvalidRefreshToken
+      attr_reader :errors
+
+      ERROR_CODE = 'INVALID_REFRESH_TOKEN'.freeze
+
+      def initialize(errors)
+        @errors = errors
+      end
+
+      def raise_error
+        return unless invalid_refresh_token_error
+
+        raise RDStation::Error::InvalidRefreshToken, invalid_refresh_token_error
+      end
+
+      private
+
+      def invalid_refresh_token_error
+        errors.find { |error| error['error_type'] == ERROR_CODE }
+      end
+    end
+  end
+end

data/lib/rdstation/error_handler/unauthorized.rb

@@ -1,6 +1,7 @@
 require_relative 'expired_access_token'
 require_relative 'expired_code_grant'
 require_relative 'invalid_credentials'
+require_relative 'invalid_refresh_token'
 
 module RDStation
   class ErrorHandler
@@ -9,6 +10,7 @@ module RDStation
         ErrorHandler::ExpiredAccessToken,
         ErrorHandler::ExpiredCodeGrant,
         ErrorHandler::InvalidCredentials,
+        ErrorHandler::InvalidRefreshToken,
       ].freeze
 
       def initialize(array_of_errors)

data/lib/rdstation/events.rb

@@ -12,16 +12,8 @@ module RDStation
     def create(payload)
       retryable_request(@authorization) do |authorization|
         response = self.class.post(EVENTS_ENDPOINT, headers: authorization.headers, body: payload.to_json)
-        response_body = JSON.parse(response.body)
-        return response_body unless errors?(response_body)
-        RDStation::ErrorHandler.new(response).raise_error
+        ApiResponse.build(response)
       end
     end
-
-    private
-
-    def errors?(response_body)
-      response_body.is_a?(Array) || response_body['errors']
-    end
   end
 end

data/lib/rdstation/fields.rb

@@ -1,12 +1,12 @@
 # encoding: utf-8
 module RDStation
-  # More info: https://developers.rdstation.com/pt-BR/reference/contacts
+  # More info: https://developers.rdstation.com/pt-BR/reference/fields
   class Fields
     include HTTParty
     include ::RDStation::RetryableRequest
 
     BASE_URL = 'https://api.rd.services/platform/contacts/fields'.freeze
-    
+
     def initialize(authorization:)
       @authorization = authorization
     end
@@ -18,5 +18,31 @@ module RDStation
       end
     end
 
+    def create(payload)
+      retryable_request(@authorization) do |authorization|
+        response = self.class.post(BASE_URL, headers: authorization.headers, body: payload.to_json)
+        ApiResponse.build(response)
+      end
+    end
+
+    def update(uuid, payload)
+      retryable_request(@authorization) do |authorization|
+        response = self.class.patch(base_url(uuid), headers: authorization.headers, body: payload.to_json)
+        ApiResponse.build(response)
+      end
+    end
+
+    def delete(uuid)
+      retryable_request(@authorization) do |authorization|
+        response = self.class.delete(base_url(uuid), headers: authorization.headers)
+        ApiResponse.build(response)
+      end
+    end
+
+    private
+
+    def base_url(path = '')
+      "#{BASE_URL}/#{path}"
+    end
   end
 end

data/lib/rdstation/version.rb

@@ -1,3 +1,3 @@
 module RDStation
-  VERSION = '2.2.0'.freeze
+  VERSION = '2.5.1'.freeze
 end

data/spec/lib/rdstation/authentication_spec.rb

@@ -217,19 +217,32 @@ RSpec.describe RDStation::Authentication do
     end
 
     context 'when the refresh token is invalid' do
+      let(:invalid_refresh_token_response) do
+        {
+          status: 401,
+          headers: { 'Content-Type' => 'application/json' },
+          body: {
+            errors: {
+              error_type: 'INVALID_REFRESH_TOKEN',
+              error_message: 'The provided refresh token is invalid or was revoked.'
+            }
+          }.to_json
+        }
+      end
+
       before do
         stub_request(:post, token_endpoint)
           .with(
             headers: request_headers,
             body: token_request_with_invalid_refresh_token.to_json
           )
-          .to_return(invalid_code_response)
+          .to_return(invalid_refresh_token_response)
       end
 
       it 'returns an auth error' do
         expect do
           authentication.update_access_token('invalid_refresh_token')
-        end.to raise_error(RDStation::Error::InvalidCredentials)
+        end.to raise_error(RDStation::Error::InvalidRefreshToken)
       end
     end
 

data/spec/lib/rdstation/builder/field_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe RDStation::Builder::Field do
+  def valid_builder
+    described_class.new('cf_identifier')
+  end
+
+  describe 'when create a builder' do
+    context 'valid' do
+      let(:initial_parameters) do
+        'cf_api_identifier'
+      end
+
+      let(:builder) { described_class.new(initial_parameters) }
+
+      let(:expected_result) do
+        {
+          'api_identifier' => 'cf_api_identifier',
+          'data_type' => 'STRING',
+          'presentation_type' => 'TEXT_INPUT',
+          'label' => { 'pt-BR' => 'My label' },
+          'name' => { 'pt-BR' => 'My name' }
+        }
+      end
+
+      it 'returns an hash of required values' do
+        builder.label 'pt-BR', 'My label'
+        builder.name 'pt-BR', 'My name'
+        builder.data_type 'STRING'
+        builder.presentation_type 'TEXT_INPUT'
+
+        result = builder.build
+        expect(result).to eq(expected_result)
+      end
+    end
+    
+    context 'invalid' do
+      it 'using invalid api_identifier ' do
+        expect { described_class.new('invald_identifier') }.to raise_error(
+          'api_identifier is not in a valid format, need start with "cf_"'
+        )
+      end
+
+      it 'using invalid data_type ' do
+        expect { valid_builder.data_type('invalid_data_type') }.to raise_error(
+          'Not valid data_type - ["STRING", "INTEGER", "BOOLEAN", "STRING[]"]'
+        )
+      end
+
+      it 'using invalid presentation_type ' do
+        expect { valid_builder.presentation_type('invalid presentation_type') }.to raise_error(
+          'Not valid presentation_type - ["TEXT_INPUT", "TEXT_AREA", "URL_INPUT", "PHONE_INPUT", "EMAIL_INPUT", "CHECK_BOX", "NUMBER_INPUT", "COMBO_BOX", "RADIO_BUTTON", "MULTIPLE_CHOICE"]'
+        )
+      end
+
+      it 'without api_identifier' do
+        expect { described_class.new(nil) }.to raise_error('api_identifier required')
+      end
+
+      it 'without required fields' do
+        expect { valid_builder.build }.to raise_error(
+          'Required fields are missing - ["data_type", "presentation_type", "label", "name"]'
+        )
+      end
+    end
+  end
+end

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 }
 
@@ -172,5 +173,13 @@ RSpec.describe RDStation::ErrorHandler 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rdstation-ruby-client
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.5.1
 platform: ruby
 authors:
 - Paulo L F Casaretto
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-12-13 00:00:00.000000000 Z
+date: 2020-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -143,6 +143,7 @@ files:
 - lib/rdstation/api_response.rb
 - lib/rdstation/authentication.rb
 - lib/rdstation/authorization.rb
+- lib/rdstation/builder/field.rb
 - lib/rdstation/client.rb
 - lib/rdstation/contacts.rb
 - lib/rdstation/error.rb
@@ -155,6 +156,7 @@ files:
 - lib/rdstation/error_handler/expired_code_grant.rb
 - lib/rdstation/error_handler/invalid_credentials.rb
 - lib/rdstation/error_handler/invalid_event_type.rb
+- lib/rdstation/error_handler/invalid_refresh_token.rb
 - lib/rdstation/error_handler/unauthorized.rb
 - lib/rdstation/events.rb
 - lib/rdstation/fields.rb
@@ -166,6 +168,7 @@ files:
 - spec/lib/rdstation/api_response_spec.rb
 - spec/lib/rdstation/authentication_spec.rb
 - spec/lib/rdstation/authorization_spec.rb
+- spec/lib/rdstation/builder/field_spec.rb
 - spec/lib/rdstation/client_spec.rb
 - spec/lib/rdstation/contacts_spec.rb
 - spec/lib/rdstation/error/format_spec.rb
@@ -175,6 +178,7 @@ files:
 - spec/lib/rdstation/error_handler/expired_code_grant_spec.rb
 - spec/lib/rdstation/error_handler/invalid_credentials_spec.rb
 - spec/lib/rdstation/error_handler/invalid_event_type_spec.rb
+- spec/lib/rdstation/error_handler/invalid_refresh_token_spec.rb
 - spec/lib/rdstation/error_handler/unauthorized_spec.rb
 - spec/lib/rdstation/error_handler_spec.rb
 - spec/lib/rdstation/error_spec.rb
@@ -188,7 +192,7 @@ homepage: http://resultadosdigitais.com.br
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -203,8 +207,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
 summary: Ruby API wrapper for RD Station
 test_files:
@@ -212,6 +216,7 @@ test_files:
 - spec/lib/rdstation/api_response_spec.rb
 - spec/lib/rdstation/authentication_spec.rb
 - spec/lib/rdstation/authorization_spec.rb
+- spec/lib/rdstation/builder/field_spec.rb
 - spec/lib/rdstation/client_spec.rb
 - spec/lib/rdstation/contacts_spec.rb
 - spec/lib/rdstation/error/format_spec.rb
@@ -221,6 +226,7 @@ test_files:
 - spec/lib/rdstation/error_handler/expired_code_grant_spec.rb
 - spec/lib/rdstation/error_handler/invalid_credentials_spec.rb
 - spec/lib/rdstation/error_handler/invalid_event_type_spec.rb
+- spec/lib/rdstation/error_handler/invalid_refresh_token_spec.rb
 - spec/lib/rdstation/error_handler/unauthorized_spec.rb
 - spec/lib/rdstation/error_handler_spec.rb
 - spec/lib/rdstation/error_spec.rb