currency_cloud 0.9.0 → 0.10.0

data/lib/currency_cloud/purpose_code.rb

@@ -0,0 +1,5 @@
+module CurrencyCloud
+  class PurposeCode
+    include CurrencyCloud::Resource
+  end
+end

data/lib/currency_cloud/reference.rb

@@ -4,11 +4,6 @@ module CurrencyCloud
 
     resource :reference
 
-    def self.currencies
-      response = client.get('currencies')
-      response['currencies'].map { |c| Currency.new(c) }
-    end
-
     def self.beneficiary_required_details(params = {})
       client.get('beneficiary_required_details', params)['details']
     end
@@ -18,6 +13,26 @@ module CurrencyCloud
       ConversionDates.new(dates)
     end
 
+    def self.currencies
+      response = client.get('currencies')
+      response['currencies'].map { |c| Currency.new(c) }
+    end
+
+    def self.payer_required_details(params)
+      response = client.get('payer_required_details', params)
+      response['details'].map { |prd| PayerRequiredDetails.new(prd) }
+    end
+
+    def self.payment_dates(params)
+      dates = client.get('payment_dates', params)
+      PaymentDates.new(dates)
+    end
+
+    def self.payment_purpose_codes(params)
+      response = client.get('payment_purpose_codes', params)
+      response['purpose_codes'].map { |pc| PurposeCode.new(pc) }
+    end
+
     def self.settlement_accounts(params = {})
       response = client.get('settlement_accounts', params)
       response['settlement_accounts'].map { |s| SettlementAccount.new(s) }

data/lib/currency_cloud/request_handler.rb

@@ -42,15 +42,13 @@ module CurrencyCloud
       response_handler.process
     rescue ApiError, UnexpectedError
       raise
-    rescue => e
+    rescue StandardError => e
       raise UnexpectedError.new(verb, full_url, params, e)
     end
 
     def process_options(opts)
       options = { headers: headers }
-      # options[:debug_output] = $stdout
       options.merge(opts)
-      # options
     end
 
     def process_params(params)

data/lib/currency_cloud/response_handler.rb

@@ -22,13 +22,13 @@ module CurrencyCloud
 
     def handle_failure
       error_class = case response.code
-        when 400 then BadRequestError
-        when 401 then AuthenticationError
-        when 403 then ForbiddenError
-        when 404 then NotFoundError
-        when 429 then TooManyRequestsError
-        when 500 then InternalApplicationError
-      end
+                    when 400 then BadRequestError
+                    when 401 then AuthenticationError
+                    when 403 then ForbiddenError
+                    when 404 then NotFoundError
+                    when 429 then TooManyRequestsError
+                    when 500 then InternalApplicationError
+                    end
       raise error_class.new(verb, route, params, response) if error_class
       raise UnexpectedError.new(verb, route, params, response)
     end

data/lib/currency_cloud/session.rb

@@ -10,9 +10,8 @@ module CurrencyCloud
     attr_accessor :token, :on_behalf_of
 
     def self.validate_environment(environment)
-      unless ENVIRONMENTS.keys.include?(environment)
-        raise CurrencyCloud::GeneralError, "'#{environment}' is not a valid environment, must be one of: #{ENVIRONMENTS.keys.join(', ')}"
-      end
+      return if ENVIRONMENTS.key?(environment)
+      raise "'#{environment}' is not a valid environment. Must be one of: #{ENVIRONMENTS.keys.join(', ')}"
     end
 
     def initialize(environment, login_id, api_key, token)

data/lib/currency_cloud/transfer.rb

@@ -0,0 +1,8 @@
+module CurrencyCloud
+  class Transfer
+    include CurrencyCloud::Resource
+
+    resource :transfers
+    actions :create, :retrieve, :find
+  end
+end

data/lib/currency_cloud/version.rb

@@ -2,5 +2,5 @@
 
 module CurrencyCloud
   API_VERSION = 'v2'.freeze # API Version
-  VERSION = '0.9.0'.freeze # Gem Version
+  VERSION = '0.10.0'.freeze # Gem Version
 end

data/lib/currency_cloud/virtual_account.rb

@@ -0,0 +1,22 @@
+module CurrencyCloud
+  class VirtualAccount
+    include CurrencyCloud::Resource
+
+    resource :virtual_accounts
+
+    def self.find(params = {})
+      result = client.get('/', params)
+      VirtualAccounts.new(:virtual_accounts, self, result)
+    end
+
+    def self.for_subaccount(subaccount_id, params = {})
+      result = client.get("subaccounts/#{subaccount_id}", params)
+      VirtualAccounts.new(:virtual_accounts, self, result)
+    end
+
+    def self.for_subaccounts(params = {})
+      result = client.get("subaccounts/find", params)
+      VirtualAccounts.new(:virtual_accounts, self, result)
+    end
+  end
+end

data/lib/currency_cloud/virtual_accounts.rb

@@ -0,0 +1,6 @@
+require 'currency_cloud/resourceful_collection'
+
+module CurrencyCloud
+  class VirtualAccounts < CurrencyCloud::ResourcefulCollection
+  end
+end

data/spec/currency_cloud_spec.rb

@@ -17,23 +17,23 @@ describe CurrencyCloud do
 
   describe '#login_id' do
     it 'can set the login_id' do
-      CurrencyCloud.login_id = 'test@example.com'
-      expect(CurrencyCloud.login_id).to eq('test@example.com')
+      CurrencyCloud.login_id = 'development@currencycloud.com'
+      expect(CurrencyCloud.login_id).to eq('development@currencycloud.com')
     end
   end
 
   describe '#api_key' do
     it 'can set the api_key' do
-      CurrencyCloud.api_key = 'e3b0d6895f91f46d9eaf5c95aa0f64dca9007b7ab0778721b6cdc0a8bc7c563b'
-      expect(CurrencyCloud.api_key).to eq('e3b0d6895f91f46d9eaf5c95aa0f64dca9007b7ab0778721b6cdc0a8bc7c563b')
+      CurrencyCloud.api_key = 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef'
+      expect(CurrencyCloud.api_key).to eq('deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef')
     end
   end
 
   describe '#session' do
     it 'returns a session object' do
       CurrencyCloud.environment = :demonstration
-      CurrencyCloud.login_id = 'test@example.com'
-      CurrencyCloud.api_key = 'e3b0d6895f91f46d9eaf5c95aa0f64dca9007b7ab0778721b6cdc0a8bc7c563b'
+      CurrencyCloud.login_id = 'development@currencycloud.com'
+      CurrencyCloud.api_key = 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef'
 
       request_handler = double('RequestHandler')
       expect(request_handler).to receive(:post).and_return('auth_token' => '123')
@@ -45,13 +45,13 @@ describe CurrencyCloud do
     it 'raises an error if the environment is not set' do
       CurrencyCloud.environment = nil
       expect { CurrencyCloud.session }
-        .to raise_error(CurrencyCloud::GeneralError, "'' is not a valid environment, must be one of: production, demonstration, uat")
+        .to raise_error(RuntimeError)
     end
 
     it 'raises an error if the environment is invalid' do
       CurrencyCloud.environment = :invalid
       expect { CurrencyCloud.session }
-        .to raise_error(CurrencyCloud::GeneralError, "'invalid' is not a valid environment, must be one of: production, demonstration, uat")
+        .to raise_error(RuntimeError)
     end
 
     it 'raises an error if the login_id is not set' do
@@ -62,7 +62,7 @@ describe CurrencyCloud do
 
     it 'raises an error if the api_key is not set' do
       CurrencyCloud.environment = :demonstration
-      CurrencyCloud.login_id = 'test@example.com'
+      CurrencyCloud.login_id = 'development@currencycloud.com'
       expect { CurrencyCloud.session }
         .to raise_error(CurrencyCloud::GeneralError, 'api_key must be set using CurrencyCloud.api_key=')
     end

data/spec/integration/authentication_spec.rb

@@ -4,8 +4,8 @@ describe 'Authentication', vcr: true do
   before do
     CurrencyCloud.reset_session
     CurrencyCloud.environment = :demonstration
-    CurrencyCloud.login_id = 'rjnienaber@gmail.com'
-    CurrencyCloud.api_key = 'ef0fd50fca1fb14c1fab3a8436b9ecb65f02f129fd87eafa45ded8ae257528f0'
+    CurrencyCloud.login_id = 'development@currencycloud.com'
+    CurrencyCloud.api_key = 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef'
     CurrencyCloud.token = nil
   end
 

data/spec/integration/conversions_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe 'Conversions', vcr: true do
+  let(:conversion_params) do
+    {
+      buy_currency: 'USD',
+      sell_currency: 'GBP',
+      fixed_side: :buy,
+      amount: 95_000,
+      reason: 'SDK conversion testing',
+      term_agreement: true
+    }
+  end
+
+  describe 'can #cancel conversion' do
+    context 'without notes' do
+      it 'has a empty "notes" attribute' do
+        conversion = CurrencyCloud::Conversion.create(conversion_params)
+        cancelled_conversion = conversion.cancel
+
+        expect(cancelled_conversion).to have_attributes(
+          'account_id' => '67e1b252-40a7-454d-a097-8f77d385889d',
+          'contact_id' => '04d0c252-7b78-4d72-b408-df78841e3ddc',
+          'event_account_id' => '67e1b252-40a7-454d-a097-8f77d385889d',
+          'event_contact_id' => '04d0c252-7b78-4d72-b408-df78841e3ddc',
+          'conversion_id' => conversion.id,
+          'event_type' => 'self_service_cancellation',
+          'amount' => '-9.58',
+          'currency' => 'GBP',
+          'notes' => ''
+        )
+      end
+    end
+
+    context 'with notes' do
+      it 'has a non-empty "notes" attribute' do
+        conversion = CurrencyCloud::Conversion.create(conversion_params)
+        cancelled_conversion = conversion.cancel(notes: 'Business Terminated Contract')
+
+        expect(cancelled_conversion).to have_attributes(
+          'account_id' => '67e1b252-40a7-454d-a097-8f77d385889d',
+          'contact_id' => '04d0c252-7b78-4d72-b408-df78841e3ddc',
+          'event_account_id' => '67e1b252-40a7-454d-a097-8f77d385889d',
+          'event_contact_id' => '04d0c252-7b78-4d72-b408-df78841e3ddc',
+          'conversion_id' => conversion.id,
+          'event_type' => 'self_service_cancellation',
+          'amount' => '-9.58',
+          'currency' => 'GBP',
+          'notes' => 'Business Terminated Contract'
+        )
+      end
+    end
+  end
+
+  it 'can #date_change conversion' do
+    new_settlement_date = Time.now + 86400
+
+    conversion = CurrencyCloud::Conversion.create(conversion_params)
+
+    conversion_with_date_changed = conversion.date_change(new_settlement_date: new_settlement_date)
+
+    expect(conversion_with_date_changed).to have_attributes(
+      'conversion_id' => conversion.id,
+      'amount' => '-14.38',
+      'currency' => 'GBP',
+      'new_conversion_date' => '2018-07-17T00:00:00+00:00',
+      'new_settlement_date' => '2018-07-17T15:30:00+00:00',
+      'old_conversion_date' => '2018-07-18T00:00:00+00:00',
+      'old_settlement_date' => '2018-07-18T15:30:00+00:00'
+    )
+  end
+
+  it 'can #split conversion' do
+    conversion = CurrencyCloud::Conversion.create(conversion_params)
+
+    split_conversion = conversion.split(amount: 45_000)
+
+    expect(split_conversion.parent_conversion['sell_amount']).to eq('35513.88')
+    expect(split_conversion.parent_conversion['sell_currency']).to eq('GBP')
+    expect(split_conversion.parent_conversion['buy_amount']).to eq('50000.00')
+    expect(split_conversion.parent_conversion['buy_currency']).to eq('USD')
+    expect(split_conversion.parent_conversion['settlement_date']).to eq('2018-07-18T15:30:00+00:00')
+    expect(split_conversion.parent_conversion['conversion_date']).to eq('2018-07-18T00:00:00+00:00')
+    expect(split_conversion.parent_conversion['status']).to eq('awaiting_funds')
+
+    expect(split_conversion.child_conversion['sell_amount']).to eq('31962.50')
+    expect(split_conversion.child_conversion['sell_currency']).to eq('GBP')
+    expect(split_conversion.child_conversion['buy_amount']).to eq('45000.00')
+    expect(split_conversion.child_conversion['buy_currency']).to eq('USD')
+    expect(split_conversion.child_conversion['settlement_date']).to eq('2018-07-18T15:30:00+00:00')
+    expect(split_conversion.child_conversion['conversion_date']).to eq('2018-07-18T00:00:00+00:00')
+    expect(split_conversion.child_conversion['status']).to eq('awaiting_funds')
+  end
+end

data/spec/integration/error_utils_spec.rb

@@ -1,30 +1,30 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe "ErrorUtils" do
+describe 'ErrorUtils' do
   module CurrencyCloud
     class ErrorUtilTester
       extend ErrorUtils
     end
   end
 
-  it "can #redact_params" do
+  it 'can #redact_params' do
     params = {
-      unaffected: "value",
-      api_key: "value",
-      login_id: "value",
-      token: "value"
+      unaffected: 'value',
+      api_key: 'value',
+      login_id: 'value',
+      token: 'value'
     }
 
     redacted = CurrencyCloud::ErrorUtilTester.redacted_params(params)
 
-    expect(redacted[:unaffected]).to eq "value"
+    expect(redacted[:unaffected]).to eq 'value'
     expect(redacted[:api_key]).to eq CurrencyCloud::ErrorUtils::REDACTED_STRING
     expect(redacted[:login_id]).to eq CurrencyCloud::ErrorUtils::REDACTED_STRING
     expect(redacted[:token]).to eq CurrencyCloud::ErrorUtils::REDACTED_STRING
 
-    expect(params[:unaffected]).to eq "value"
-    expect(params[:api_key]).to eq "value"
-    expect(params[:login_id]).to eq "value"
-    expect(params[:token]).to eq "value"
+    expect(params[:unaffected]).to eq 'value'
+    expect(params[:api_key]).to eq 'value'
+    expect(params[:login_id]).to eq 'value'
+    expect(params[:token]).to eq 'value'
   end
 end

data/spec/integration/errors_spec.rb

@@ -2,28 +2,23 @@ require 'spec_helper'
 require 'net/http'
 
 describe 'Error', vcr: true do
+  include CurrencyCloud::ErrorUtils
+
   before(:each) do
     CurrencyCloud.reset_session
     CurrencyCloud.environment = :demonstration
-    CurrencyCloud.login_id = 'rjnienaber@gmail.com'
-    CurrencyCloud.api_key = 'ef0fd50fca1fb14c1fab3a8436b9ecb65f02f129fd87eafa45ded8ae257528f0'
+    CurrencyCloud.login_id = 'development@currencycloud.com'
+    CurrencyCloud.api_key = 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef'
     CurrencyCloud.token = nil
   end
 
   it 'contains full details for api error' do
     CurrencyCloud.login_id = 'non-existent-login-id'
-    CurrencyCloud.api_key = 'ef0fd50fca1fb14c1fab3a8436b9ecb57528f0'
-
-    error = nil
-    begin
-      CurrencyCloud.session
-      raise 'Should have failed'
-    rescue CurrencyCloud::BadRequestError => error
-    end
+    CurrencyCloud.api_key = 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef'
 
     expected_error = %{CurrencyCloud::BadRequestError
 ---
-platform: #{error.platform}
+platform: #{platform}
 request:
   parameters:
     login_id: REDACTED
@@ -41,68 +36,62 @@ errors:
   params:
     length: 64
 }
-    expect(error.to_s).to eq(expected_error)
+
+    expect { CurrencyCloud.session }.to raise_error(CurrencyCloud::BadRequestError, expected_error)
   end
 
   it 'is raised on a bad request' do
     CurrencyCloud.login_id = 'non-existent-login-id'
-    CurrencyCloud.api_key = 'ef0fd50fca1fb14c1fab3a8436b9ecb57528f0'
+    CurrencyCloud.api_key = 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef'
 
-    error = nil
     begin
       CurrencyCloud.session
-      raise 'Should have failed'
+      expect(0).to eq 1, 'expected exception that was not raised'
     rescue CurrencyCloud::BadRequestError => error
+      expect(error.code).to eq('auth_invalid_user_login_details')
+      expect(error.raw_response).to_not be_nil
+      expect(error.status_code).to eq(400)
+      expect(error.messages.length).to eq(1)
+
+      error_message = error.messages[0]
+      expect(error_message.field).to eq('api_key')
+      expect(error_message.code).to eq('api_key_length_is_invalid')
+      expect(error_message.message).to eq('api_key should be 64 character(s) long')
+      expect(error_message.params).to include('length' => 64)
     end
-
-    expect(error.code).to eq('auth_invalid_user_login_details')
-    expect(error.raw_response).to_not be_nil
-    expect(error.status_code).to eq(400)
-    expect(error.messages.length).to eq(1)
-
-    error_message = error.messages[0]
-    expect(error_message.field).to eq('api_key')
-    expect(error_message.code).to eq('api_key_length_is_invalid')
-    expect(error_message.message).to eq('api_key should be 64 character(s) long')
-    expect(error_message.params).to include('length' => 64)
   end
 
   it 'is raised on incorrect authentication details' do
     CurrencyCloud.login_id = 'non-existent-login-id'
-    CurrencyCloud.api_key = 'efb5ae2af84978b7a37f18dd61c8bbe139b403009faea83484405a3dcb64c4d8'
+    CurrencyCloud.api_key = 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef'
 
-    error = nil
     begin
       CurrencyCloud.session
-      raise 'Should have failed'
+      expect(0).to eq 1, 'expected exception that was not raised'
     rescue CurrencyCloud::AuthenticationError => error
+      expect(error.code).to eq('auth_failed')
+      expect(error.raw_response).to_not be_nil
+      expect(error.status_code).to eq(401)
+      expect(error.messages.length).to eq(1)
+
+      error_message = error.messages[0]
+      expect(error_message.field).to eq('username')
+      expect(error_message.code).to eq('invalid_supplied_credentials')
+      expect(error_message.message).to eq('Authentication failed with the supplied credentials')
+      expect(error_message.params).to be_empty
     end
-
-    expect(error.code).to eq('auth_failed')
-    expect(error.raw_response).to_not be_nil
-    expect(error.status_code).to eq(401)
-    expect(error.messages.length).to eq(1)
-
-    error_message = error.messages[0]
-    expect(error_message.field).to eq('username')
-    expect(error_message.code).to eq('invalid_supplied_credentials')
-    expect(error_message.message).to eq('Authentication failed with the supplied credentials')
-    expect(error_message.params).to be_empty
   end
 
   it 'is raised on unexpected error' do
     allow(HTTParty).to receive(:post).and_raise(Timeout::Error)
 
-    error = nil
     begin
       CurrencyCloud.session
-      raise 'Should have failed'
+      expect(0).to eq 1, 'expected exception that was not raised'
     rescue CurrencyCloud::UnexpectedError => error
-    end
-
-    expected_error = %(CurrencyCloud::UnexpectedError
+      expected_error = %(CurrencyCloud::UnexpectedError
 ---
-platform: #{error.platform}
+platform: #{platform}
 request:
   parameters:
     login_id: REDACTED
@@ -112,92 +101,85 @@ request:
 inner_error: Timeout::Error
 )
 
-    expect(error.to_s).to eq(expected_error)
-    expect(error.inner_error).to_not be_nil
-    expect(error.inner_error.class).to eq(Timeout::Error)
+      expect(error.to_s).to eq(expected_error)
+      expect(error.inner_error).to_not be_nil
+      expect(error.inner_error.class).to eq(Timeout::Error)
+    end
   end
 
   it 'is raised on a forbidden request' do
-    error = nil
     begin
       CurrencyCloud.session
-      raise 'Should have failed'
+      expect(0).to eq 1, 'expected exception that was not raised'
     rescue CurrencyCloud::ForbiddenError => error
+      expect(error.code).to eq('auth_failed')
+      expect(error.raw_response).to_not be_nil
+      expect(error.status_code).to eq(403)
+      expect(error.messages.length).to eq(1)
+
+      error_message = error.messages[0]
+      expect(error_message.field).to eq('username')
+      expect(error_message.code).to eq('invalid_supplied_credentials')
+      expect(error_message.message).to eq('Authentication failed with the supplied credentials')
+      expect(error_message.params).to be_empty
     end
-
-    expect(error.code).to eq('auth_failed')
-    expect(error.raw_response).to_not be_nil
-    expect(error.status_code).to eq(403)
-    expect(error.messages.length).to eq(1)
-
-    error_message = error.messages[0]
-    expect(error_message.field).to eq('username')
-    expect(error_message.code).to eq('invalid_supplied_credentials')
-    expect(error_message.message).to eq('Authentication failed with the supplied credentials')
-    expect(error_message.params).to be_empty
   end
 
   it 'is raised when a resource is not found' do
     CurrencyCloud.token = '656485646b068f6e9c81e3d885fa54f5'
-    error = nil
     begin
       CurrencyCloud::Beneficiary.retrieve('081596c9-02de-483e-9f2a-4cf55dcdf98c')
-      raise 'Should fail'
+      expect(0).to eq 1, 'expected exception that was not raised'
     rescue CurrencyCloud::NotFoundError => error
+      expect(error.code).to eq('beneficiary_not_found')
+      expect(error.raw_response).to_not be_nil
+      expect(error.status_code).to eq(404)
+      expect(error.messages.length).to eq(1)
+
+      error_message = error.messages[0]
+      expect(error_message.field).to eq('id')
+      expect(error_message.code).to eq('beneficiary_not_found')
+      expect(error_message.message).to eq('Beneficiary was not found for this id')
+      expect(error_message.params).to be_empty
     end
-
-    expect(error.code).to eq('beneficiary_not_found')
-    expect(error.raw_response).to_not be_nil
-    expect(error.status_code).to eq(404)
-    expect(error.messages.length).to eq(1)
-
-    error_message = error.messages[0]
-    expect(error_message.field).to eq('id')
-    expect(error_message.code).to eq('beneficiary_not_found')
-    expect(error_message.message).to eq('Beneficiary was not found for this id')
-    expect(error_message.params).to be_empty
   end
 
   it 'is raised on an internal server error' do
-    error = nil
     begin
       CurrencyCloud.session
-      raise 'Should have failed'
+      expect(0).to eq 1, 'expected exception that was not raised'
     rescue CurrencyCloud::InternalApplicationError => error
+      expect(error.code).to eq('internal_application_error')
+      expect(error.raw_response).to_not be_nil
+      expect(error.status_code).to eq(500)
+      expect(error.messages.length).to eq(1)
+
+      error_message = error.messages[0]
+      expect(error_message.field).to eq('base')
+      expect(error_message.code).to eq('internal_application_error')
+      expect(error_message.message).to eq('A general application error occurred')
+      expect(error_message.params).to include('request_id' => 2771875643610572878)
     end
-
-    expect(error.code).to eq('internal_application_error')
-    expect(error.raw_response).to_not be_nil
-    expect(error.status_code).to eq(500)
-    expect(error.messages.length).to eq(1)
-
-    error_message = error.messages[0]
-    expect(error_message.field).to eq('base')
-    expect(error_message.code).to eq('internal_application_error')
-    expect(error_message.message).to eq('A general application error occurred')
-    expect(error_message.params).to include('request_id' => 2771875643610572878)
   end
 
   it 'is raised when too many requests have been issued' do
-    CurrencyCloud.login_id = 'rjnienaber@gmail.com2'
+    CurrencyCloud.login_id = 'development@currencycloud.com'
 
-    error = nil
     begin
       CurrencyCloud.session
 
-      raise 'Should have failed'
+      expect(0).to eq 1, 'expected exception that was not raised'
     rescue CurrencyCloud::TooManyRequestsError => error
+      expect(error.code).to eq('too_many_requests')
+      expect(error.raw_response).to_not be_nil
+      expect(error.status_code).to eq(429)
+      expect(error.messages.length).to eq(1)
+
+      error_message = error.messages[0]
+      expect(error_message.field).to eq('base')
+      expect(error_message.code).to eq('too_many_requests')
+      expect(error_message.message).to eq('Too many requests have been made to the api. Please refer to the Developer Center for more information')
+      expect(error_message.params).to be_empty
     end
-
-    expect(error.code).to eq('too_many_requests')
-    expect(error.raw_response).to_not be_nil
-    expect(error.status_code).to eq(429)
-    expect(error.messages.length).to eq(1)
-
-    error_message = error.messages[0]
-    expect(error_message.field).to eq('base')
-    expect(error_message.code).to eq('too_many_requests')
-    expect(error_message.message).to eq('Too many requests have been made to the api. Please refer to the Developer Center for more information')
-    expect(error_message.params).to be_empty
   end
 end