finapps_core 5.0.7 → 5.0.8

data/lib/finapps_core/rest/configuration.rb

@@ -13,9 +13,8 @@ module FinAppsCore
       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,40 +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 :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
-
           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.7'
+  VERSION = '5.0.8'
 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

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

data/spec/rest/base_client_spec.rb

@@ -1,96 +1,140 @@
 # frozen_string_literal: true
 
 RSpec.describe FinAppsCore::REST::BaseClient do
-  let(:valid_tenant_options) { { tenant_token: VALID_CREDENTIALS[:token] } }
-  subject { FinAppsCore::REST::BaseClient.new(valid_tenant_options) }
+  subject(:base_client) { described_class.new(valid_tenant_options) }
 
-  RESPONSE = 0
-  ERROR_MESSAGES = 1
-  let(:return_array) { %i[RESPONSE ERROR_MESSAGES] }
+  let(:valid_tenant_options) { {tenant_token: VALID_CREDENTIALS[:token]} }
+
+  before do
+    stub_const 'RESPONSE', 0
+    stub_const 'ERROR_MESSAGES', 1
+  end
 
   describe '#new' do
     it 'assigns @config' do
-      expect(subject.config).to be_a(FinAppsCore::REST::Configuration)
+      expect(base_client.config).to be_a(FinAppsCore::REST::Configuration)
     end
   end
 
   describe '#connection' do
     it 'created a Faraday connection object' do
-      expect(subject.connection).to be_a(Faraday::Connection)
+      expect(base_client.connection).to be_a(Faraday::Connection)
     end
 
     it 'memoizes the results' do
-      first = subject.connection
-      second = subject.connection
+      first = base_client.connection
+      second = base_client.connection
       expect(first.object_id).to eq(second.object_id)
     end
   end
 
   describe '#send_request' do
-    it 'should raise FinAppsCore::InvalidArgumentsError if method is NOT supported' do
-      expect { subject.send_request('fake_path', :option) }.to raise_error(FinAppsCore::UnsupportedHttpMethodError,
-                                                                           'Method not supported: option.')
+    it 'raises FinAppsCore::InvalidArgumentsError if method is NOT supported' do
+      expect { base_client.send_request('fake_path', :option) }
+        .to(raise_error NoMethodError)
     end
 
-    it 'should raise FinAppsCore::MissingArgumentsError if method is NOT provided' do
-      expect { subject.send_request(nil, :get) }.to raise_error(FinAppsCore::MissingArgumentsError,
-                                                                ': path')
+    it 'raises FinAppsCore::MissingArgumentsError if method is NOT provided' do
+      expect { base_client.send_request(nil, :get) }
+        .to(raise_error(FinAppsCore::MissingArgumentsError, ': path'))
     end
 
-    it 'should raise FinAppsCore::MissingArgumentsError if path is NOT provided' do
-      expect { subject.send_request('fake_path', nil) }.to raise_error(FinAppsCore::MissingArgumentsError,
-                                                                       ': method')
+    it 'raises FinAppsCore::MissingArgumentsError if path is NOT provided' do
+      expect { base_client.send_request('fake_path', nil) }
+        .to raise_error(FinAppsCore::MissingArgumentsError, ': method')
     end
 
     context 'when method and path are provided' do
-      subject { FinAppsCore::REST::BaseClient.new(valid_tenant_options).send_request('relevance/ruleset/names', :get) }
-      let(:return_array) { %i[RESPONSE ERROR_MESSAGES] }
+      subject(:results) do
+        described_class.new(valid_tenant_options)
+                       .send_request('relevance/ruleset/names', :get)
+      end
+
+      it('returns an array') do
+        expect(results).to be_a(Array)
+      end
 
-      it('returns an array of 2 items') do
-        expect(subject).to be_a(Array)
-        expect(subject.size).to eq(return_array.length)
+      it('returns an array of length=2') do
+        expect(results.size).to eq(2)
       end
 
-      context 'for client errors' do
-        subject { FinAppsCore::REST::BaseClient.new(valid_tenant_options).send_request('client_error', :get) }
+      context 'with client errors' do
+        subject(:client_error) do
+          described_class.new(valid_tenant_options)
+                         .send_request('client_error', :get)
+        end
 
-        it('result is null') { expect(subject[RESPONSE]).to be_nil }
-        it('error_messages is an array') { expect(subject[ERROR_MESSAGES]).to be_a(Array) }
-        it('error_messages gets populated') { expect(subject[ERROR_MESSAGES].first).to eq 'Password Minimum size is 8' }
+        it('result is null') { expect(client_error[RESPONSE]).to be_nil }
+
+        it('error_messages is an array') {
+          expect(client_error[ERROR_MESSAGES]).to be_a(Array)
+        }
+
+        it('error_messages gets populated') {
+          expect(client_error[ERROR_MESSAGES].first)
+            .to eq 'Password Minimum size is 8'
+        }
       end
 
-      context 'for server errors' do
-        subject { FinAppsCore::REST::BaseClient.new(valid_tenant_options).send_request('server_error', :get) }
+      context 'with server errors' do
+        subject(:server_error) do
+          described_class.new(valid_tenant_options)
+                         .send_request('server_error', :get)
+        end
+
+        it('the result should be nil') {
+          expect(server_error[RESPONSE]).to be_nil
+        }
+
+        it('error messages should not be nil') {
+          expect(server_error[ERROR_MESSAGES]).not_to be_nil
+        }
+
+        it('error messages should be an array') {
+          expect(server_error[ERROR_MESSAGES]).to be_a(Array)
+        }
 
-        it('the result should be nil') { expect(subject[RESPONSE]).to be_nil }
-        it { expect(subject[ERROR_MESSAGES]).not_to be_nil }
-        it { expect(subject[ERROR_MESSAGES]).to be_a(Array) }
-        it { expect(subject[ERROR_MESSAGES].first).to eq 'the server responded with status 500' }
+        it('the first error message should match') {
+          expect(server_error[ERROR_MESSAGES].first)
+            .to eq 'the server responded with status 500'
+        }
       end
 
-      context 'for proxy errors' do
-        subject { FinAppsCore::REST::BaseClient.new(valid_tenant_options).send_request('proxy_error', :get) }
-        it { expect { subject }.to raise_error(FinAppsCore::ConnectionFailedError, 'Connection Failed') }
+      context 'with proxy errors' do
+        subject(:proxy_error) do
+          described_class.new(valid_tenant_options)
+                         .send_request('proxy_error', :get)
+        end
+
+        it {
+          expect { proxy_error }
+            .to(raise_error(FinAppsCore::ConnectionFailedError,
+                            'Connection Failed'))
+        }
       end
     end
 
-    context 'if a block is provided' do
+    context 'when a block is provided' do
       it('gets executed on the response and returned as the result') do
-        expect(subject.send_request('relevance/ruleset/names', :get) {|r| r.body.length }).to eq([45, []])
+        expect(base_client
+          .send_request('relevance/ruleset/names', :get) {|r| r.body.length })
+          .to eq([45, []])
       end
     end
   end
 
   describe '#method_missing' do
-    context 'for unsupported methods' do
-      it { expect { subject.unsupported }.to raise_error(NoMethodError) }
+    context 'with unsupported methods' do
+      it { expect { base_client.unsupported }.to raise_error(NoMethodError) }
     end
   end
 
   describe '#respond_to_missing?' do
-    context 'for supported methods' do
+    context 'with supported methods' do
       %i[get post put delete].each do |method|
-        it("responds to #{method}") { expect(subject).to respond_to(method) }
+        it("responds to #{method}") {
+          expect(base_client).to respond_to(method)
+        }
       end
     end
   end