finapps_core 5.0.5 → 5.0.10

data/lib/finapps_core/rest/base_client.rb

@@ -31,7 +31,8 @@ module FinAppsCore
       end
 
       # Performs HTTP GET, POST, UPDATE and DELETE requests.
-      # You shouldn't need to use this method directly, but it can be useful for debugging.
+      # You shouldn't need to use this method directly,
+      # but it can be useful for debugging.
       # Returns a hash obtained from parsing the JSON object in the response body.
       #
       # @param [String] path
@@ -42,7 +43,7 @@ module FinAppsCore
         not_blank(path, :path)
         not_blank(method, :method)
 
-        response, error_messages = execute_request(path, method, params)
+        response, error_messages = execute_request(method, path, params)
         result = block_given? ? yield(response) : response_body(response)
 
         [result, error_messages]
@@ -76,26 +77,19 @@ module FinAppsCore
         end
       end
 
-      def execute_request(path, method, params)
-        response = nil
-        errors = []
-
-        begin
-          response = execute_method path, method, params
-        rescue FinAppsCore::InvalidArgumentsError,
-               FinAppsCore::MissingArgumentsError,
-               Faraday::Error::ConnectionFailed => e
-          handle_error e
-        rescue Faraday::Error::ClientError => e
-          errors = handle_client_error(e)
-        end
-
-        [response, errors]
+      def execute_request(method, path, params)
+        [send(method, path, params), []]
+      rescue FinAppsCore::InvalidArgumentsError,
+             FinAppsCore::MissingArgumentsError,
+             Faraday::ConnectionFailed => e
+        [nil, handle_error(e)]
+      rescue Faraday::ClientError => e
+        [nil, handle_client_error(e)]
       end
 
       def handle_error(error)
         logger.fatal "#{self.class}##{__method__} => #{error}"
-        raise error
+        fail error
       end
 
       def handle_client_error(error)
@@ -103,19 +97,13 @@ module FinAppsCore
         error.response && error.response[:error_messages] ? error.response[:error_messages] : [error.message]
       end
 
-      def execute_method(path, method, params)
-        case method
-        when :get
-          get(path)
-        when :post
-          post(path, params)
-        when :put
-          put(path, params)
-        when :delete
-          delete(path, params)
-        else
-          raise FinAppsCore::UnsupportedHttpMethodError, "Method not supported: #{method}."
+      def execute_method(method, path, params)
+        unless %i(get post put delete).include?(method)
+          fail FinAppsCore::UnsupportedHttpMethodError,
+               "Method not supported: #{method}."
         end
+
+        send(method, path, params)
       end
     end
   end

data/lib/finapps_core/rest/configuration.rb

@@ -8,14 +8,13 @@ module FinAppsCore
 
       attr_accessor :tenant_token, :user_identifier, :user_token,
                     :host, :proxy, :timeout, :retry_limit, :rashify,
-                    :log_level, :request_id
+                    :log_level, :request_id, :consumer_id
 
       def initialize(options = {})
         FinAppsCore::REST::Defaults::DEFAULTS.merge(remove_empty_options(options))
                                              .each {|key, value| public_send("#{key}=", value) }
-
-        raise FinAppsCore::InvalidArgumentsError, "Invalid argument. {host: #{host}}" unless valid_host?
-        raise FinAppsCore::InvalidArgumentsError, "Invalid argument. {timeout: #{timeout}}" unless timeout.integer?
+        fail_invalid_host
+        fail_invalid_timeout
       end
 
       def valid_user_credentials?
@@ -24,6 +23,20 @@ module FinAppsCore
 
       private
 
+      def fail_invalid_host
+        return if valid_host?
+
+        fail FinAppsCore::InvalidArgumentsError,
+             "Invalid argument. {host: #{host}}"
+      end
+
+      def fail_invalid_timeout
+        return if timeout.integer?
+
+        fail FinAppsCore::InvalidArgumentsError,
+             "Invalid argument. {timeout: #{timeout}}"
+      end
+
       def valid_host?
         host.start_with?('http://', 'https://')
       end

data/lib/finapps_core/rest/connection.rb

@@ -8,39 +8,49 @@ module FinAppsCore
         options = connection_options config
 
         Faraday.new(options) do |conn|
-          conn.request :accept_json
-          conn.request :user_agent
-          if config.valid_user_credentials?
-            conn.request :no_encoding_basic_authentication, config.user_token
-          else
-            conn.request :tenant_authentication, config.tenant_token
-          end
-          conn.request :json
-          conn.request :retry
-          conn.request :multipart
-          conn.request :url_encoded
-          conn.request :request_id, config.request_id if config.request_id
-
           conn.use FinAppsCore::Middleware::RaiseError
-          conn.response :json,
-                        content_type: /\bjson$/,
-                        parser_options: { symbolize_names: true }
-          conn.response :logger, logger, bodies: true
+          init_connection_request conn, config
+          init_connection_response conn, logger
+          init_connection_auth conn, config
 
           # Adapter (ensure that the adapter is always last.)
           conn.adapter Faraday.default_adapter
         end
       end
-      module_function :faraday
+
+      def init_connection_response(conn, logger)
+        conn.response :logger, logger, bodies: true
+        conn.response :json,
+                      content_type: /\bjson$/,
+                      parser_options: {symbolize_names: true}
+      end
+
+      def init_connection_request(conn, config)
+        conn.request :accept_json
+        conn.request :user_agent
+        conn.request :x_consumer_id, config.consumer_id if config.consumer_id
+        conn.request :json
+        conn.request :retry
+        conn.request :multipart
+        conn.request :url_encoded
+        conn.request :request_id, config.request_id if config.request_id
+      end
+
+      def init_connection_auth(conn, config)
+        if config.valid_user_credentials?
+          conn.request :no_encoding_basic_authentication, config.user_token
+        else
+          conn.request :tenant_authentication, config.tenant_token
+        end
+      end
 
       def connection_options(config)
         {
           url: "#{config.host}/v#{Defaults::API_VERSION}/",
-          request: { open_timeout: config.timeout,
-                     timeout: config.timeout }
+          request: {open_timeout: config.timeout,
+                    timeout: config.timeout}
         }
       end
-      module_function :connection_options
     end
   end
 end

data/lib/finapps_core/rest/defaults.rb

@@ -12,7 +12,7 @@ module FinAppsCore
         host: 'https://api.finclear.io',
         timeout: 30,
         proxy: nil,
-        log_level: Logger::INFO
+        log_level: Logger::UNKNOWN
       }.freeze
     end
   end

data/lib/finapps_core/utils/validatable.rb

@@ -8,7 +8,7 @@ module FinAppsCore
     # Adds validation capabilities when included into other classes
     module Validatable
       def not_blank(value, name = nil)
-        raise FinAppsCore::MissingArgumentsError, name.nil? ? nil : ": #{name}" if nil_or_empty?(value)
+        fail FinAppsCore::MissingArgumentsError, name.nil? ? nil : ": #{name}" if nil_or_empty?(value)
       end
 
       def nil_or_empty?(value)

data/lib/finapps_core/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FinAppsCore
-  VERSION = '5.0.5'
+  VERSION = '5.0.10'
 end

data/spec/core_extensions/object/is_integer_spec.rb

@@ -2,16 +2,15 @@
 
 RSpec.describe ObjectExtensions do
   context 'when refining Object' do
-    using ObjectExtensions
+    using described_class
 
     describe '#integer?' do
-      context 'for integers' do
-        subject { rand(1..10) }
-        it { expect(subject.integer?).to eq(true) }
+      context 'with integers' do
+        it { expect(rand(1..10).integer?).to eq(true) }
       end
-      context 'for non integers' do
-        subject { rand }
-        it { expect(subject.integer?).to eq(false) }
+
+      context 'with non integers' do
+        it { expect(rand.integer?).to eq(false) }
       end
     end
   end

data/spec/middleware/request/accept_json_spec.rb

@@ -2,12 +2,16 @@
 
 RSpec.describe FinAppsCore::Middleware::AcceptJson do
   let(:fake_app) { proc {|env| env } }
+
   describe '#call' do
-    subject { FinAppsCore::Middleware::AcceptJson.new(fake_app) }
-    env = { request_headers: {} }
+    subject(:accept_json) { described_class.new(fake_app) }
+
+    env = {request_headers: {}}
 
     it('generates a UserAgent header') do
-      expect(subject.call(env)[:request_headers][FinAppsCore::Middleware::AcceptJson::KEY]).to eq('application/json')
+      header_key = FinAppsCore::Middleware::AcceptJson::KEY
+      expect(accept_json.call(env)[:request_headers][header_key])
+        .to eq('application/json')
     end
   end
 end

data/spec/middleware/request/no_encoding_basic_authentication_spec.rb

@@ -7,22 +7,31 @@ RSpec.describe FinAppsCore::Middleware::NoEncodingBasicAuthentication do
     app = proc {|env| env }
 
     context 'when credentials were provided' do
-      let(:middleware) { FinAppsCore::Middleware::NoEncodingBasicAuthentication.new(app, :token) }
+      let(:middleware) { described_class.new(app, :token) }
       let(:expected_header_value) { 'Bearer token' }
 
       context 'when header was not previously set' do
-        let(:request_env) { { request_headers: {} } }
         subject(:result) { middleware.call(request_env) }
 
-        it('generates a header') { expect(result[:request_headers][key]).to eq(expected_header_value) }
+        let(:request_env) { {request_headers: {}} }
+
+        it('generates a header') {
+          expect(result[:request_headers][key]).to eq(expected_header_value)
+        }
       end
 
       context 'when header was previously set' do
-        let(:request_env) { { request_headers: { key => 'foo' } } }
         subject(:result) { middleware.call(request_env) }
 
-        it('does not override existing header') { expect(result[:request_headers][key]).to eq('foo') }
-        it('does not generate a header') { expect(result[:request_headers][key]).to_not eq(expected_header_value) }
+        let(:request_env) { {request_headers: {key => 'foo'}} }
+
+        it('does not override existing header') {
+          expect(result[:request_headers][key]).to eq('foo')
+        }
+
+        it('does not generate a header') {
+          expect(result[:request_headers][key]).not_to eq(expected_header_value)
+        }
       end
     end
   end

data/spec/middleware/request/request_id_spec.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 RSpec.describe FinAppsCore::Middleware::RequestId do
-  let(:key) { FinAppsCore::Middleware::RequestId::KEY }
   let(:id) { 'request_id' }
   let(:fake_app) { proc {|env| env } }
-  let(:env) { { request_headers: {} } }
+  let(:env) { {request_headers: {}} }
 
   describe '#call' do
-    subject { FinAppsCore::Middleware::RequestId.new(fake_app, id) }
+    subject(:request_id) { described_class.new(fake_app, id) }
 
     it('generates a X-Request-Id header') do
-      expect(subject.call(env)[:request_headers][key]).to eq(id)
+      key = FinAppsCore::Middleware::RequestId::KEY
+      expect(request_id.call(env)[:request_headers][key]).to eq(id)
     end
   end
 end

data/spec/middleware/request/tenant_authentication_spec.rb

@@ -1,30 +1,37 @@
 # frozen_string_literal: true
 
 RSpec.describe FinAppsCore::Middleware::TenantAuthentication do
-  let(:valid_tenant_options) { VALID_CREDENTIALS }
-  let(:key) { FinAppsCore::Middleware::TenantAuthentication::KEY }
-
   describe '#call' do
-    fake_app = proc {|env| env }
+    subject(:actual_header) do
+      middleware.call(request_env)[:request_headers][key]
+    end
 
     context 'when company credentials were provided' do
-      let(:middleware) { FinAppsCore::Middleware::TenantAuthentication.new(fake_app, VALID_CREDENTIALS[:token]) }
-      let(:expected_header) { valid_tenant_options[:token] }
+      let(:key) { FinAppsCore::Middleware::TenantAuthentication::KEY }
+      let(:middleware) do
+        fake_app = proc {|env| env }
+        described_class.new(fake_app, VALID_CREDENTIALS[:token])
+      end
+      let(:expected_header) { VALID_CREDENTIALS[:token] }
 
       context 'when header was not previously set' do
-        let(:request_env) { { request_headers: {} } }
-        subject(:actual_header) { middleware.call(request_env)[:request_headers][key] }
+        let(:request_env) { {request_headers: {}} }
 
-        it('generates a Tenant Authentication header') { expect(actual_header).to eq(expected_header) }
+        it('generates a Tenant Authentication header') {
+          expect(actual_header).to eq(expected_header)
+        }
       end
 
       context 'when header was previously set' do
-        let(:existing_header) { { FinAppsCore::Middleware::TenantAuthentication::KEY => 'foo' } }
-        let(:request_env) { { request_headers: existing_header } }
-        subject(:actual_header) { middleware.call(request_env)[:request_headers][key] }
+        let(:request_env) { {request_headers: {key => 'foo'}} }
+
+        it('does not override existing Tenant Authentication header') {
+          expect(actual_header).to eq('foo')
+        }
 
-        it('does not override existing Tenant Authentication header') { expect(actual_header).to eq('foo') }
-        it('does not generate a Tenant Authentication header') { expect(actual_header).to_not eq(expected_header) }
+        it('does not generate a Tenant Authentication header') {
+          expect(actual_header).not_to eq(expected_header)
+        }
       end
     end
   end

data/spec/middleware/request/user_agent_spec.rb

@@ -2,12 +2,17 @@
 
 RSpec.describe FinAppsCore::Middleware::UserAgent do
   let(:fake_app) { proc {|env| env } }
+
   describe '#call' do
-    subject { FinAppsCore::Middleware::UserAgent.new(fake_app) }
-    env = { request_headers: {} }
+    subject(:user_agent) { described_class.new(fake_app) }
+
+    let(:key) { FinAppsCore::Middleware::UserAgent::KEY }
+
+    env = {request_headers: {}}
 
     it('generates a UserAgent header') do
-      expect(subject.call(env)[:request_headers][FinAppsCore::Middleware::UserAgent::KEY]).to start_with('finapps-ruby')
+      expect(user_agent.call(env)[:request_headers][key])
+        .to start_with('finapps-ruby')
     end
   end
 end

data/spec/middleware/request/x_consumer_id_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RSpec.describe FinAppsCore::Middleware::XConsumerId do
+  let(:id) { 'valid_consumer_id' }
+  let(:fake_app) { proc {|env| env } }
+  let(:env) { {request_headers: {}} }
+
+  describe '#call' do
+    subject(:x_consumer_id) { described_class.new(fake_app, id) }
+
+    it('generates an X-Consumer-ID header') do
+      key = FinAppsCore::Middleware::XConsumerId::KEY
+      expect(x_consumer_id.call(env)[:request_headers][key]).to eq(id)
+    end
+  end
+end

data/spec/middleware/response/raise_error_spec.rb

@@ -2,39 +2,71 @@
 
 RSpec.describe FinAppsCore::Middleware::RaiseError do
   let(:fake_app) { proc {|env| env } }
-  Env = Struct.new(:status, :response_headers, :body)
+
+  before do
+    stub_const('Env', Struct.new(:status, :response_headers, :body))
+  end
 
   describe '#on_complete' do
-    subject { FinAppsCore::Middleware::RaiseError.new(fake_app) }
+    subject(:error_raiser) { described_class.new(fake_app) }
 
-    context 'for successful requests' do
+    context 'with successful requests' do
       let(:env) { Env.new(200) }
-      it { expect { subject.on_complete(env) }.not_to raise_error }
+
+      it { expect { error_raiser.on_complete(env) }.not_to raise_error }
     end
-    context 'for invalid session errors' do
-      let(:env) { Env.new(401, {}, '{"messages":["Invalid User Identifier or Credentials"]}') }
+
+    context 'with invalid session errors' do
+      let(:env) do
+        body = '{"messages":["Invalid User Identifier or Credentials"]}'
+        Env.new(401, {}, body)
+      end
+
       error_message = 'API Invalid Session'
-      it { expect { subject.on_complete(env) }.to raise_error(FinAppsCore::ApiUnauthenticatedError, error_message) }
+      it {
+        expect { error_raiser.on_complete(env) }
+          .to raise_error(FinAppsCore::ApiUnauthenticatedError, error_message)
+      }
     end
-    context 'for client errors' do
+
+    context 'with client errors' do
       let(:env) { Env.new(404, {}, '{"messages":["Resource Not Found"]}') }
+
       error_message = 'the server responded with status 404'
-      it { expect { subject.on_complete(env) }.to raise_error(Faraday::Error::ClientError, error_message) }
+      it {
+        expect { error_raiser.on_complete(env) }
+          .to raise_error(Faraday::ClientError, error_message)
+      }
     end
-    context 'for connection failed error' do
+
+    context 'with connection failed error' do
       let(:env) { Env.new(407) }
+
       error_message = 'Connection Failed'
-      it { expect { subject.on_complete(env) }.to raise_error(FinAppsCore::ConnectionFailedError, error_message) }
+      it {
+        expect { error_raiser.on_complete(env) }
+          .to raise_error(FinAppsCore::ConnectionFailedError, error_message)
+      }
     end
-    context 'for session timeout error' do
+
+    context 'with session timeout error' do
       let(:env) { Env.new(419) }
+
       error_message = 'API Session Timed out'
-      it { expect { subject.on_complete(env) }.to raise_error(FinAppsCore::ApiSessionTimeoutError, error_message) }
+      it {
+        expect { error_raiser.on_complete(env) }
+          .to raise_error(FinAppsCore::ApiSessionTimeoutError, error_message)
+      }
     end
-    context 'for user lockout error' do
+
+    context 'with user lockout error' do
       let(:env) { Env.new(403, {}, '{"messages":["Account is locked"]}') }
+
       error_message = 'User is Locked'
-      it { expect { subject.on_complete(env) }.to raise_error(FinAppsCore::UserLockoutError, error_message) }
+      it {
+        expect { error_raiser.on_complete(env) }
+          .to raise_error(FinAppsCore::UserLockoutError, error_message)
+      }
     end
   end
 end