finapps 5.0.34 → 5.0.35

data/spec/rest/password_resets_spec.rb

@@ -5,39 +5,39 @@ RSpec.describe FinApps::REST::PasswordResets do
 
   describe '#create' do
     context 'when missing id' do
-      subject { described_class.new(client).create(nil) }
+      subject(:create) { described_class.new(client).create(nil) }
 
       it do
-        expect { subject }.to raise_error(FinAppsCore::MissingArgumentsError)
+        expect { create }.to raise_error(FinAppsCore::MissingArgumentsError)
       end
     end
 
     context 'when invalid id is provided' do
-      subject do
+      subject(:create) do
         described_class.new(client).create(:invalid_user_id)
       end
 
-      it { expect { subject }.not_to raise_error }
-      it('results is nil') { expect(subject[0]).to be_nil }
+      it { expect { create }.not_to raise_error }
+      it('results is nil') { expect(create[0]).to be_nil }
 
       it('error messages array is populated') do
-        expect(subject[1]).not_to be_nil
+        expect(create[1]).not_to be_nil
       end
     end
 
     context 'when valid id is provided' do
-      subject do
+      subject(:create) do
         described_class.new(client).create(:valid_user_id)
       end
 
-      it { expect { subject }.not_to raise_error }
-      it('returns an array') { expect(subject).to be_a(Array) }
+      it { expect { create }.not_to raise_error }
+      it('returns an array') { expect(create).to be_a(Array) }
 
       it('performs a post and returns the response') do
-        expect(subject[0]).to have_key(:token)
+        expect(create[0]).to have_key(:token)
       end
 
-      it('returns no error messages') { expect(subject[1]).to be_empty }
+      it('returns no error messages') { expect(create[1]).to be_empty }
     end
   end
 
@@ -46,71 +46,71 @@ RSpec.describe FinApps::REST::PasswordResets do
     let(:invalid_params) { {token: 'invalid_token'} }
 
     context 'when missing id' do
-      subject { described_class.new(client).update(nil, :params) }
+      subject(:update) { described_class.new(client).update(nil, :params) }
 
       it do
-        expect { subject }.to raise_error(FinAppsCore::MissingArgumentsError)
+        expect { update }.to raise_error(FinAppsCore::MissingArgumentsError)
       end
     end
 
     context 'when missing params' do
-      subject do
+      subject(:update) do
         described_class.new(client).update(:valid_user_id, nil)
       end
 
       it do
-        expect { subject }.to raise_error(FinAppsCore::MissingArgumentsError)
+        expect { update }.to raise_error(FinAppsCore::MissingArgumentsError)
       end
     end
 
     context 'when invalid id is provided' do
-      subject do
+      subject(:update) do
         described_class.new(client).update(
           :invalid_user_id,
           valid_params
         )
       end
 
-      it { expect { subject }.not_to raise_error }
-      it('results is nil') { expect(subject[0]).to be_nil }
+      it { expect { update }.not_to raise_error }
+      it('results is nil') { expect(update[0]).to be_nil }
 
       it('error messages array is populated') do
-        expect(subject[1]).not_to be_nil
+        expect(update[1]).not_to be_nil
       end
     end
 
     context 'when invalid params are provided' do
-      subject do
+      subject(:update) do
         described_class.new(client).update(
           :valid_user_id,
           invalid_params
         )
       end
 
-      it { expect { subject }.not_to raise_error }
-      it('results is nil') { expect(subject[0]).to be_nil }
+      it { expect { update }.not_to raise_error }
+      it('results is nil') { expect(update[0]).to be_nil }
 
       it('error messages array is populated') do
-        expect(subject[1]).not_to be_nil
+        expect(update[1]).not_to be_nil
       end
     end
 
     context 'when valid params are provided' do
-      subject do
+      subject(:update) do
         described_class.new(client).update(
           :valid_user_id,
           valid_params
         )
       end
 
-      it { expect { subject }.not_to raise_error }
-      it('returns an array') { expect(subject).to be_a(Array) }
+      it { expect { update }.not_to raise_error }
+      it('returns an array') { expect(update).to be_a(Array) }
 
       it('performs a post and returns the response') do
-        expect(subject[0]).to have_key(:token)
+        expect(update[0]).to have_key(:token)
       end
 
-      it('returns no error messages') { expect(subject[1]).to be_empty }
+      it('returns no error messages') { expect(update[1]).to be_empty }
     end
   end
 end

data/spec/rest/plaid/plaid_consumer_institutions_spec.rb

@@ -48,7 +48,7 @@ RSpec.describe FinApps::REST::PlaidConsumerInstitutions do
       it_behaves_like 'a successful request'
       it_behaves_like 'a request that returns institution data'
       it('returns institution account data') do
-        expect(subject[RESULTS]).to have_key(:accounts)
+        expect(show[RESULTS]).to have_key(:accounts)
       end
     end
   end

data/spec/rest/portfolios_alerts_spec.rb

@@ -23,12 +23,12 @@ RSpec.describe FinApps::REST::PortfoliosAlerts do
       it { expect { list }.not_to raise_error }
       it('returns an array') { expect(list).to be_a(Array) }
 
-      it('performs a get and returns array of alert definitions') do
+      it('performs a get and returns a results array') do
         expect(results).to be_a(Array)
-        expect(results.first).to have_key(:_id)
-        expect(results.first).to have_key(:rule_name)
       end
 
+      it { expect(results.first).to have_key(:_id) }
+      it { expect(results.first).to have_key(:rule_name) }
       it('returns no error messages') { expect(errors).to be_empty }
     end
 

data/spec/rest/portfolios_consumers_spec.rb

@@ -97,7 +97,7 @@ RSpec.describe FinApps::REST::PortfoliosConsumers do
       end
     end
 
-    context 'for bulk subscribe' do
+    context 'with bulk subscribe' do
       context 'when valid id and params are provided' do
         let(:portfolio_id) { 'valid_id' }
         let(:params) { %w[id1 id2 id3] }
@@ -130,7 +130,7 @@ RSpec.describe FinApps::REST::PortfoliosConsumers do
       end
     end
 
-    context 'for single subscribe' do
+    context 'with single subscribe' do
       context 'when valid ids are provided' do
         let(:portfolio_id) { 'valid_id' }
         let(:params) { portfolio_id }

data/spec/rest/portfolios_spec.rb

@@ -67,12 +67,8 @@ RSpec.describe FinApps::REST::Portfolios do
 
       it { expect { show }.not_to raise_error }
       it('returns an array') { expect(show).to be_a(Array) }
-
-      it('performs a get and returns the response') do
-        expect(results).to have_key(:_id)
-        expect(results).to have_key(:product)
-      end
-
+      it { expect(results).to have_key(:_id) }
+      it { expect(results).to have_key(:product) }
       it('returns no error messages') { expect(errors).to be_empty }
     end
 
@@ -112,12 +108,8 @@ RSpec.describe FinApps::REST::Portfolios do
 
       it { expect { create }.not_to raise_error }
       it('returns an array') { expect(create).to be_a(Array) }
-
-      it('performs a get and returns the response') do
-        expect(results).to have_key(:_id)
-        expect(results).to have_key(:product)
-      end
-
+      it { expect(results).to have_key(:_id) }
+      it { expect(results).to have_key(:product) }
       it('returns no error messages') { expect(errors).to be_empty }
     end
 
@@ -180,12 +172,8 @@ RSpec.describe FinApps::REST::Portfolios do
 
       it { expect { update }.not_to raise_error }
       it('returns an array') { expect(update).to be_a(Array) }
-
-      it('performs a get and returns the response') do
-        expect(results).to have_key(:_id)
-        expect(results).to have_key(:product)
-      end
-
+      it { expect(results).to have_key(:_id) }
+      it { expect(results).to have_key(:product) }
       it('returns no error messages') { expect(errors).to be_empty }
     end
   end

data/spec/rest/products_spec.rb

@@ -2,25 +2,26 @@
 
 require 'spec_helpers/client'
 
-RSpec.describe FinApps::REST::Products,
-               'initialized with valid FinApps::Client object' do
-  include SpecHelpers::Client
-  subject(:products) { described_class.new(client) }
+RSpec.describe FinApps::REST::Products do
+  context 'when initialized with valid FinApps::Client object' do
+    include SpecHelpers::Client
+    subject(:products) { described_class.new(client) }
 
-  describe '#list' do
-    context 'when called' do
-      let(:list) { subject.list }
-      let(:results) { list[0] }
-      let(:error_messages) { list[1] }
+    describe '#list' do
+      context 'when called' do
+        let(:list) { subject.list }
+        let(:results) { list[0] }
+        let(:error_messages) { list[1] }
 
-      it { expect { list }.not_to raise_error }
-      it('returns an array of records') { expect(results).to be_a(Array) }
+        it { expect { list }.not_to raise_error }
+        it('returns an array of records') { expect(results).to be_a(Array) }
 
-      it('performs a get and returns the response') do
-        expect(results[0]).to have_key(:code)
-      end
+        it('performs a get and returns the response') do
+          expect(results[0]).to have_key(:code)
+        end
 
-      it('returns no error messages') { expect(error_messages).to be_empty }
+        it('returns no error messages') { expect(error_messages).to be_empty }
+      end
     end
   end
 end

data/spec/rest/sessions_spec.rb

@@ -2,80 +2,81 @@
 
 require 'spec_helpers/client'
 
-RSpec.describe FinApps::REST::Sessions,
-               'initialized with valid FinApps::Client object' do
-  include SpecHelpers::Client
-  subject { described_class.new(client) }
-
-  describe '#create' do
-    let(:create) { subject.create(credentials) }
-    let(:results) { create[0] }
-    let(:error_messages) { create[1] }
-
-    context 'when missing email or password' do
-      message = 'Invalid argument: params.'
-      it do
-        expect do
-          subject.create(email: nil, password: 'password')
-        end.to raise_error(FinAppsCore::InvalidArgumentsError, message)
+RSpec.describe FinApps::REST::Sessions do
+  context 'when initialized with valid FinApps::Client object' do
+    include SpecHelpers::Client
+    subject(:session) { described_class.new(client) }
+
+    describe '#create' do
+      let(:create) { session.create(credentials) }
+      let(:results) { create[0] }
+      let(:error_messages) { create[1] }
+
+      context 'when missing email or password' do
+        message = 'Invalid argument: params.'
+        it do
+          expect do
+            session.create(email: nil, password: 'password')
+          end.to raise_error(FinAppsCore::InvalidArgumentsError, message)
+        end
+
+        it do
+          expect { session.create(email: 'email', password: nil) }.to raise_error(
+            FinAppsCore::InvalidArgumentsError,
+            message
+          )
+        end
       end
 
-      it do
-        expect { subject.create(email: 'email', password: nil) }.to raise_error(
-          FinAppsCore::InvalidArgumentsError,
-          message
-        )
-      end
-    end
+      context 'with invalid credentials' do
+        let(:credentials) do
+          {email: 'email@domain.com', password: 'invalid_password'}
+        end
 
-    context 'for invalid credentials' do
-      let(:credentials) do
-        {email: 'email@domain.com', password: 'invalid_password'}
+        it { expect { create }.not_to raise_error }
+        it('results is nil') { expect(results).to be_nil }
+
+        error_message = 'Invalid Consumer Identifier or Credentials'
+        it('error_messages are populated') do
+          expect(error_messages.first).to eq(error_message)
+        end
       end
 
-      it { expect { create }.not_to raise_error }
-      it('results is nil') { expect(results).to be_nil }
+      context 'with valid credentials' do
+        let(:credentials) do
+          {email: 'email@domain.com', password: 'valid_password'}
+        end
 
-      error_message = 'Invalid Consumer Identifier or Credentials'
-      it('error_messages are populated') do
-        expect(error_messages.first).to eq(error_message)
+        it('results is a Hash') { expect(results).to be_a(Hash) }
+        it('token value is in the result') { expect(results).to have_key(:token) }
+        it('error_messages is empty') { expect(error_messages).to be_empty }
       end
-    end
 
-    context 'for valid credentials' do
-      let(:credentials) do
-        {email: 'email@domain.com', password: 'valid_password'}
-      end
+      context 'with valid credentials & path argument' do
+        let(:create) { subject.create(credentials, 'operators/login') }
+        let(:credentials) do
+          {email: 'email@domain.com', password: 'valid_password'}
+        end
 
-      it('results is a Hash') { expect(results).to be_a(Hash) }
-      it('token value is in the result') { expect(results).to have_key(:token) }
-      it('error_messages is empty') { expect(error_messages).to be_empty }
-    end
+        it('results is a Hash') { expect(results).to be_a(Hash) }
+        it('token value is in the result') { expect(results).to have_key(:token) }
 
-    context 'for valid credentials & path argument' do
-      let(:create) { subject.create(credentials, 'operators/login') }
-      let(:credentials) do
-        {email: 'email@domain.com', password: 'valid_password'}
-      end
-
-      it('results is a Hash') { expect(results).to be_a(Hash) }
-      it('token value is in the result') { expect(results).to have_key(:token) }
+        it('returns operator for operator path') do
+          expect(results).to have_key(:role)
+        end
 
-      it('returns operator for operator path') do
-        expect(results).to have_key(:role)
+        it('error_messages is empty') { expect(error_messages).to be_empty }
       end
-
-      it('error_messages is empty') { expect(error_messages).to be_empty }
     end
-  end
 
-  describe '#destroy' do
-    let(:destroy) { subject.destroy }
-    let(:results) { destroy[0] }
-    let(:error_messages) { destroy[1] }
+    describe '#destroy' do
+      let(:destroy) { subject.destroy }
+      let(:results) { destroy[0] }
+      let(:error_messages) { destroy[1] }
 
-    it { expect { destroy }.not_to raise_error }
-    it('results is nil') { expect(results).to be_nil }
-    it('error_messages array is empty') { expect(error_messages).to eq([]) }
+      it { expect { destroy }.not_to raise_error }
+      it('results is nil') { expect(results).to be_nil }
+      it('error_messages array is empty') { expect(error_messages).to eq([]) }
+    end
   end
 end

data/spec/rest/signed_documents_downloads_spec.rb

@@ -10,15 +10,19 @@ RSpec.describe FinApps::REST::SignedDocumentsDownloads do
   let(:document) { described_class.new(api_client) }
 
   describe '#show' do
-    context 'when missing parameters' do
-      subject { document.show(:consumer_id, nil) }
+    context 'when missing signature request id' do
+      subject(:show) { document.show(:consumer_id, nil) }
 
       it 'raises an error when missing consumer id' do
-        expect { subject }.to raise_error(FinAppsCore::MissingArgumentsError)
+        expect { show }.to raise_error(FinAppsCore::MissingArgumentsError)
       end
+    end
+
+    context 'when missing consumer id' do
+      subject(:show) { document.show(nil, :signature_request_id) }
 
       it 'raises an error when missing signature request id' do
-        expect { subject }.to raise_error(FinAppsCore::MissingArgumentsError)
+        expect { show }.to raise_error(FinAppsCore::MissingArgumentsError)
       end
     end
 

data/spec/rest/verix/verix_documents_spec.rb

@@ -11,10 +11,10 @@ RSpec.describe FinApps::REST::VerixDocuments do
 
   describe '#list' do
     context 'when missing parameters' do
-      subject { document.list(nil) }
+      subject(:list) { document.list(nil) }
 
       it 'raises an error when missing record id' do
-        expect { subject }.to raise_error(FinAppsCore::MissingArgumentsError)
+        expect { list }.to raise_error(FinAppsCore::MissingArgumentsError)
       end
     end