rdstation-ruby-client 2.0.0 → 2.4.0

data/spec/lib/rdstation/{authorization_header_spec.rb → authorization_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe RDStation::AuthorizationHeader do
+RSpec.describe RDStation::Authorization do
   
   describe ".initialize" do
     context "when access_token is nil" do
@@ -12,11 +12,11 @@ RSpec.describe RDStation::AuthorizationHeader do
     end
   end
   
-  describe "#to_h" do
+  describe "#headers" do
     let(:access_token) { 'access_token' }
     
     it "generates the correct header" do
-      header = described_class.new(access_token: access_token).to_h
+      header = described_class.new(access_token: access_token).headers
       expect(header['Authorization']).to eq "Bearer #{access_token}"
       expect(header['Content-Type']).to eq "application/json"
     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/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_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)