finapps_core 5.0.7 → 5.0.13

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/request/x_tenant_id_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RSpec.describe FinAppsCore::Middleware::XTenantId do
+  let(:id) { 'valid_tenant_id' }
+  let(:fake_app) { proc {|env| env } }
+  let(:env) { {request_headers: {}} }
+
+  describe '#call' do
+    subject(:x_tenant_id) { described_class.new(fake_app, id) }
+
+    it('generates an X-Tenant-ID header') do
+      key = FinAppsCore::Middleware::XTenantId::KEY
+      expect(x_tenant_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 NoMethodError if method is NOT supported' do
+      expect { base_client.send_request('fake_path', :option) }
+        .to(raise_error(NoMethodError, /undefined method `option/))
     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

data/spec/rest/configuration_spec.rb

@@ -4,41 +4,48 @@ require 'finapps_core/error'
 
 RSpec.describe FinAppsCore::REST::Configuration do
   describe '#new' do
-    context 'for invalid timeout configuration' do
-      subject { FinAppsCore::REST::Configuration.new(timeout: 'whatever') }
+    context 'with invalid timeout configuration' do
+      subject(:configuration) { described_class.new(timeout: 'whatever') }
+
       expected_error = FinAppsCore::InvalidArgumentsError
-      it { expect { subject }.to raise_error(expected_error, 'Invalid argument. {timeout: whatever}') }
+      it { expect { configuration }.to raise_error(expected_error, 'Invalid argument. {timeout: whatever}') }
     end
 
-    context 'for missing timeout configuration' do
-      subject { FinAppsCore::REST::Configuration.new(timeout: nil) }
-      it 'should have a default timeout value' do
-        expect(subject.timeout).to eq(FinAppsCore::REST::Defaults::DEFAULTS[:timeout])
+    context 'with missing timeout configuration' do
+      subject(:configuration) { described_class.new(timeout: nil) }
+
+      it 'has a default timeout value' do
+        expect(configuration.timeout).to eq(FinAppsCore::REST::Defaults::DEFAULTS[:timeout])
       end
     end
 
-    context 'for invalid host configuration' do
-      subject { FinAppsCore::REST::Configuration.new(host: 'whatever') }
+    context 'with invalid host configuration' do
+      subject(:configuration) { described_class.new(host: 'whatever') }
+
       expected_error = FinAppsCore::InvalidArgumentsError
-      it { expect { subject }.to raise_error(expected_error, 'Invalid argument. {host: whatever}') }
+      it { expect { configuration }.to raise_error(expected_error, 'Invalid argument. {host: whatever}') }
     end
 
-    context 'for missing host configuration' do
-      subject { FinAppsCore::REST::Configuration.new(host: nil) }
-      it 'should have a default host value' do
-        expect(subject.host).to eq(FinAppsCore::REST::Defaults::DEFAULTS[:host])
+    context 'with missing host configuration' do
+      subject(:configuration) { described_class.new(host: nil) }
+
+      it 'has a default host value' do
+        expect(configuration.host).to eq(FinAppsCore::REST::Defaults::DEFAULTS[:host])
       end
     end
   end
 
   describe '#valid_user_credentials??' do
     context 'when user credentials were not set' do
-      subject { FinAppsCore::REST::Configuration.new(host: nil) }
-      it { expect(subject.valid_user_credentials?).to eq(false) }
+      subject(:configuration) { described_class.new(host: nil) }
+
+      it { expect(configuration.valid_user_credentials?).to eq(false) }
     end
+
     context 'when user credentials were set' do
-      subject { FinAppsCore::REST::Configuration.new(user_identifier: 1, user_token: 2) }
-      it { expect(subject.valid_user_credentials?).to eq(true) }
+      subject(:configuration) { described_class.new(user_identifier: 1, user_token: 2) }
+
+      it { expect(configuration.valid_user_credentials?).to eq(true) }
     end
   end
 end