finapps 6.4.3 → 6.7.0

data/spec/rest/operators_spec.rb

@@ -1,251 +1,245 @@
 # frozen_string_literal: true
 
 require 'spec_helpers/client'
+require 'spec_helpers/api_request'
 
 RSpec.describe FinApps::REST::Operators do
-  context 'when initialized with valid FinApps::Client object' do
-    include SpecHelpers::Client
-    subject(:operators) { described_class.new(client) }
+  include SpecHelpers::Client
 
-    describe '#list' do
-      let(:list) { subject.list(params) }
-      let(:results) { list[0] }
-      let(:error_messages) { list[1] }
+  let(:results) { subject[RESULTS] }
+  let(:error_messages) { subject[ERROR_MESSAGES] }
 
-      context 'when missing params' do
-        let(:params) { nil }
-
-        it { expect { list }.not_to raise_error }
+  describe '#list' do
+    subject(:list) { described_class.new(client).list(params) }
 
-        it('performs a get and returns the response') do
-          expect(results).to have_key(:records)
+    context 'with valid params' do
+      RSpec.shared_examples 'a filtereable GET index request' do |filter|
+        it_behaves_like 'an API request'
+        it_behaves_like 'a successful request'
+        it_behaves_like 'a GET index request'
+        it 'builds query and sends proper request' do
+          query_string = ("?filter=#{ERB::Util.url_encode filter.to_json}" if filter)
+          url = "#{versioned_api_path}/operators#{query_string}"
+          list
+          expect(WebMock).to have_requested(:get, url)
         end
+      end
 
-        it('returns an array of records') do
-          expect(results[:records]).to be_a(Array)
-        end
+      context 'with searchTerm' do
+        let(:params) { {searchTerm: 'le term'} }
+
+        it_behaves_like 'a filtereable GET index request', {
+          '$or': [
+            {email: 'le term'},
+            {last_name: 'le term'}
+          ]
+        }
+      end
 
-        it('returns no error messages') { expect(error_messages).to be_empty }
+      context 'with valid role' do
+        let(:params) { {role: 1} }
+
+        it_behaves_like 'a filtereable GET index request', {role: {'$in': [1]}}
       end
 
-      context 'when invalid params are provided' do
-        let(:params) { ['invalid array'] }
+      context 'with empty params' do
+        let(:params) { nil }
 
-        it { expect { list }.to raise_error(FinAppsCore::InvalidArgumentsError) }
+        it_behaves_like 'a filtereable GET index request', nil
       end
 
-      context 'when including valid params' do
+      context 'with searchTerm, page, sort, requested and role' do
         let(:params) do
           {
+            searchTerm: 't',
             page: 2,
             sort: 'date_created',
             requested: 25,
-            searchTerm: 'term',
             role: 2
           }
         end
 
-        it { expect { list }.not_to raise_error }
+        it_behaves_like 'an API request'
+        it_behaves_like 'a successful request'
+        it_behaves_like 'a GET index request'
+        it 'builds a full filter and query and sends the request' do
+          list
 
-        it('performs a get and returns the response') do
-          expect(results).to have_key(:records)
+          filter = {'$or': [{email: 't'}, {last_name: 't'}], role: {'$in': [2]}}
+          expect(WebMock).to have_requested(:get, "#{versioned_api_path}/operators"\
+                                                  "?filter=#{ERB::Util.url_encode filter.to_json}"\
+                                                  '&page=2&requested=25&sort=date_created')
         end
+      end
+    end
 
-        it('returns an array of records') do
-          expect(results[:records]).to be_a(Array)
-        end
+    context 'with invalid role' do
+      let(:params) { {role: 'ADMIN'} }
 
-        it('returns no error messages') { expect(error_messages).to be_empty }
+      it { expect { list }.to raise_error(ArgumentError) }
+    end
 
-        it 'builds query and sends proper request' do
-          list
-          url =
-            "#{versioned_api_path}/operators?filter=%7B%22last_name%22:%22term%22," \
-            '%22role%22:2%7D&page=2&requested=25&sort=date_created'
-          expect(WebMock).to have_requested(:get, url)
-        end
-      end
+    context 'with invalid params' do
+      let(:params) { :anything_but_a_hash }
+
+      it { expect { list }.to raise_error(FinAppsCore::InvalidArgumentsError) }
     end
+  end
 
-    describe '#show' do
-      let(:results) { show[0] }
-      let(:error_messages) { show[1] }
+  RSpec.shared_examples 'a missing id' do
+    it { expect { subject }.to raise_error(FinAppsCore::MissingArgumentsError) }
+  end
 
-      context 'when missing id' do
-        let(:show) { subject.show(nil) }
+  RSpec.shared_examples 'an invalid id' do
+    it { expect { subject }.not_to raise_error }
+    it('results is nil') { expect(results).to be_nil }
 
-        it { expect { show }.to raise_error(FinAppsCore::MissingArgumentsError) }
-      end
+    it('error messages array is populated') do
+      expect(error_messages.first.downcase).to eq('resource not found')
+    end
+  end
 
-      context 'with invalid id' do
-        let(:show) { subject.show(:invalid_id) }
+  RSpec.shared_examples 'a missing params' do
+    it { expect { subject }.to raise_error(FinAppsCore::MissingArgumentsError) }
+  end
 
-        it { expect { show }.not_to raise_error }
-        it('results is nil') { expect(results).to be_nil }
+  describe '#show' do
+    subject(:show) { described_class.new(client).show(id) }
 
-        it('error messages array is populated') do
-          expect(error_messages.first.downcase).to eq('resource not found')
-        end
-      end
+    context 'when missing id' do
+      let(:id) { nil }
 
-      context 'with valid id' do
-        let(:show) { subject.show(:valid_id) }
+      it_behaves_like 'a missing id'
+    end
 
-        it { expect { show }.not_to raise_error }
-        it('returns an array') { expect(show).to be_a(Array) }
+    context 'with invalid id' do
+      let(:id) { :invalid_id }
 
-        it('performs a get and returns the response') do
-          expect(results).to have_key(:public_id)
-        end
+      it_behaves_like 'an invalid id'
+    end
+
+    context 'with valid id' do
+      let(:id) { :valid_id }
 
-        it('returns no error messages') { expect(error_messages).to be_empty }
+      it_behaves_like 'an API request'
+      it_behaves_like 'a successful request'
+      it('performs a get and returns the response') do
+        expect(results).to have_key(:public_id)
       end
     end
+  end
 
-    describe '#create' do
-      let(:results) { create[0] }
-      let(:error_messages) { create[1] }
+  describe '#create' do
+    subject(:create) { described_class.new(client).create(params) }
 
-      context 'when missing params' do
-        let(:create) { subject.create(nil) }
+    context 'when missing params' do
+      let(:params) { nil }
 
-        it do
-          expect { create }.to raise_error(FinAppsCore::MissingArgumentsError)
-        end
-      end
+      it_behaves_like 'a missing params'
+    end
 
-      context 'when invalid params are provided' do
-        let(:create) { subject.create(params: 'invalid') }
+    context 'when invalid params are provided' do
+      let(:params) { :invalid }
 
-        it { expect { create }.not_to raise_error }
-        it('results is nil') { expect(results).to be_nil }
+      it_behaves_like 'an API request'
+      it('results is nil') { expect(results).to be_nil }
 
-        it('error messages array is populated') do
-          expect(error_messages.first.downcase).to eq('invalid request body')
-        end
+      it('error messages array is populated') do
+        expect(error_messages.first.downcase).to eq('invalid request body')
       end
+    end
 
-      context 'when valid params are provided' do
-        let(:create) { subject.create(params: 'valid') }
+    context 'when valid params are provided' do
+      let(:params) { {params: :valid} }
 
-        it { expect { create }.not_to raise_error }
-        it('returns an array') { expect(create).to be_a(Array) }
-        it { expect(results).to have_key(:public_id) }
-        it { expect(results).to have_key(:role) }
-        it('returns no error messages') { expect(error_messages).to be_empty }
-      end
+      it_behaves_like 'an API request'
+      it_behaves_like 'a successful request'
+      it { expect(results).to have_key(:public_id) }
+      it { expect(results).to have_key(:role) }
     end
+  end
 
-    describe '#update' do
-      let(:results) { update[0] }
-      let(:error_messages) { update[1] }
-
-      context 'when missing id' do
-        let(:update) { subject.update(nil, params: 'params') }
+  describe '#update' do
+    subject(:update) { described_class.new(client).update(id, params) }
 
-        it do
-          expect { update }.to raise_error(FinAppsCore::MissingArgumentsError)
-        end
-      end
+    context 'when missing id' do
+      let(:id) { nil }
+      let(:params) { {params: :valid} }
 
-      context 'when missing params' do
-        let(:update) { subject.update(:valid_id, nil) }
+      it_behaves_like 'a missing id'
+    end
 
-        it do
-          expect { update }.to raise_error(FinAppsCore::MissingArgumentsError)
-        end
-      end
+    context 'when missing params' do
+      let(:id) { :id }
+      let(:params) { nil }
 
-      context 'with invalid params' do
-        let(:update) { subject.update(:invalid_id, params: 'params') }
+      it_behaves_like 'a missing params'
+    end
 
-        it { expect { update }.not_to raise_error }
-        it('results is nil') { expect(results).to be_nil }
+    context 'with invalid id' do
+      let(:id) { :invalid_id }
+      let(:params) { {params: :valid} }
 
-        it('error messages array is populated') do
-          expect(error_messages.first.downcase).to eq('resource not found')
-        end
-      end
+      it_behaves_like 'an invalid id'
+    end
 
-      context 'with valid params' do
-        let(:update) { subject.update(:valid_id, params: 'valid params') }
+    context 'with valid params' do
+      let(:id) { :valid_id }
+      let(:params) { {params: :valid} }
 
-        it { expect { update }.not_to raise_error }
-        it('returns an array') { expect(update).to be_a(Array) }
-        it { expect(results).to have_key(:email) }
-        it { expect(results).to have_key(:role) }
-        it('returns no error messages') { expect(error_messages).to be_empty }
-      end
+      it_behaves_like 'an API request'
+      it_behaves_like 'a successful request'
+      it { expect(results).to have_key(:email) }
+      it { expect(results).to have_key(:role) }
     end
+  end
 
-    describe '#update_password' do
-      let(:results) { update_password[0] }
-      let(:error_messages) { update_password[1] }
+  describe '#update_password' do
+    subject(:update_password) { described_class.new(client).update_password(params) }
 
-      context 'when missing params' do
-        let(:update_password) { subject.update_password(nil) }
+    context 'when missing params' do
+      let(:params) { nil }
 
-        it do
-          expect { update_password }.to raise_error(
-            FinAppsCore::MissingArgumentsError
-          )
-        end
-      end
+      it_behaves_like 'a missing params'
+    end
 
-      context 'with invalid params' do
-        let(:update_password) { subject.update_password(password: 'invalid') }
+    context 'with invalid params' do
+      let(:params) { {foo: :bar} }
 
-        it do
-          expect { update_password }.to raise_error(
-            FinAppsCore::InvalidArgumentsError
-          )
-        end
-      end
+      it { expect { update_password }.to raise_error(FinAppsCore::InvalidArgumentsError) }
+    end
 
-      context 'with valid params' do
-        let(:valid_params) do
-          {password: 'valid password', password_confirm: 'valid_password'}
-        end
-        let(:update_password) { subject.update_password(valid_params) }
+    context 'with valid params' do
+      let(:params) { {password: 'valid', password_confirm: 'valid'} }
 
-        it { expect { update_password }.not_to raise_error }
-        it('returns an array') { expect(update_password).to be_a(Array) }
-        it { expect(results).to have_key(:public_id) }
-        it { expect(results).to have_key(:role) }
-        it('returns no error messages') { expect(error_messages).to be_empty }
-      end
+      it_behaves_like 'an API request'
+      it_behaves_like 'a successful request'
+      it { expect(results).to have_key(:email) }
+      it { expect(results).to have_key(:role) }
     end
+  end
 
-    describe '#destroy' do
-      let(:results) { destroy[0] }
-      let(:error_messages) { destroy[1] }
-
-      context 'when missing id' do
-        let(:destroy) { subject.destroy(nil) }
+  describe '#destroy' do
+    subject(:destroy) { described_class.new(client).destroy(id) }
 
-        it do
-          expect { destroy }.to raise_error(FinAppsCore::MissingArgumentsError)
-        end
-      end
+    context 'when missing id' do
+      let(:id) { nil }
 
-      context 'with invalid id' do
-        let(:destroy) { subject.destroy(:invalid_id) }
+      it_behaves_like 'a missing id'
+    end
 
-        it { expect { destroy }.not_to raise_error }
-        it('results is nil') { expect(results).to be_nil }
+    context 'with invalid id' do
+      let(:id) { :invalid_id }
 
-        it('error messages array is populated') do
-          expect(error_messages.first.downcase).to eq('resource not found')
-        end
-      end
+      it_behaves_like 'an invalid id'
+    end
 
-      context 'with valid id' do
-        let(:destroy) { subject.destroy(:valid_id) }
+    context 'with valid id' do
+      let(:id) { :valid_id }
 
-        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
+      it_behaves_like 'an API request'
+      it_behaves_like 'a successful request'
+      it('results is nil') { expect(results).to be_nil }
     end
   end
 end

data/spec/rest/plaid/plaid_account_permissions_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helpers/client'
-require 'rest/api_request'
+require 'spec_helpers/api_request'
 
 RSpec.describe FinApps::REST::PlaidAccountPermissions do
   include SpecHelpers::Client

data/spec/rest/plaid/plaid_accounts_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helpers/client'
-require 'rest/api_request'
+require 'spec_helpers/api_request'
 
 RSpec.describe FinApps::REST::PlaidAccounts do
   include SpecHelpers::Client

data/spec/rest/plaid/plaid_consumer_institutions_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helpers/client'
-require 'rest/api_request'
+require 'spec_helpers/api_request'
 
 RSpec.describe FinApps::REST::PlaidConsumerInstitutions do
   include SpecHelpers::Client

data/spec/rest/plaid/plaid_institution_logos_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helpers/client'
-require 'rest/api_request'
+require 'spec_helpers/api_request'
 
 RSpec.describe FinApps::REST::PlaidInstitutionLogos do
   include SpecHelpers::Client

data/spec/rest/plaid/plaid_webhooks_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helpers/client'
-require 'rest/api_request'
+require 'spec_helpers/api_request'
 
 RSpec.describe FinApps::REST::PlaidWebhooks do
   include SpecHelpers::Client

data/spec/rest/screening_metadatas_spec.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'spec_helpers/client'
+require 'spec_helpers/api_request'
+
+RSpec.describe FinApps::REST::ScreeningMetadatas do
+  include SpecHelpers::Client
+
+  let(:results) { subject[RESULTS] }
+  let(:error_messages) { subject[ERROR_MESSAGES] }
+
+  describe '#show' do
+    subject(:show_metadata) { described_class.new(client).show(id, key) }
+
+    context 'with valid params' do
+      let(:id) { :session_id }
+      let(:key) { :key }
+
+      before { show_metadata }
+
+      it 'sends proper request' do
+        url = "#{versioned_api_path}/screenings/session_id/meta/key"
+
+        expect(WebMock).to have_requested(:get, url)
+      end
+
+      it_behaves_like 'an API request'
+      it_behaves_like 'a successful request'
+    end
+
+    context 'with invalid params' do
+      let(:id) { :something_else }
+      let(:key) { :key }
+
+      it_behaves_like 'an API request'
+      it('results is nil') { expect(results).to be_nil }
+
+      it('error messages array is populated') do
+        expect(error_messages.first.downcase).to eq('the screening id was not found')
+      end
+    end
+
+    context 'with missing params' do
+      let(:id) { nil }
+      let(:key) { nil }
+
+      it_behaves_like 'a request that raises an error'
+    end
+  end
+
+  describe '#create' do
+    subject(:create_metadata) { described_class.new(client).create(id, key, value) }
+
+    context 'with valid params' do
+      let(:id) { :session_id }
+      let(:key) { :key }
+      let(:value) { :value }
+
+      before { create_metadata }
+
+      it 'sends proper request' do
+        url = "#{versioned_api_path}/screenings/session_id/meta"
+
+        expect(WebMock).to have_requested(:post, url)
+      end
+
+      it_behaves_like 'an API request'
+      it_behaves_like 'a successful request'
+    end
+
+    context 'with invalid params' do
+      let(:id) { :something_else }
+      let(:key) { :key }
+      let(:value) { :value }
+
+      it_behaves_like 'an API request'
+      it('results is nil') { expect(results).to be_nil }
+
+      it('error messages array is populated') do
+        expect(error_messages.first.downcase).to eq('the screening id was not found')
+      end
+    end
+
+    context 'with missing params' do
+      let(:id) { nil }
+      let(:key) { nil }
+      let(:value) { nil }
+
+      it_behaves_like 'a request that raises an error'
+    end
+  end
+
+  describe '#destroy' do
+    subject(:destroy_metadata) { described_class.new(client).destroy(id, key) }
+
+    context 'with valid params' do
+      let(:id) { :session_id }
+      let(:key) { :key }
+
+      before { destroy_metadata }
+
+      it 'sends proper request' do
+        url = "#{versioned_api_path}/screenings/session_id/meta/key"
+
+        expect(WebMock).to have_requested(:delete, url)
+      end
+
+      it_behaves_like 'an API request'
+      it_behaves_like 'a successful request'
+    end
+
+    context 'with invalid params' do
+      let(:id) { :something_else }
+      let(:key) { :key }
+
+      it_behaves_like 'an API request'
+      it('results is nil') { expect(results).to be_nil }
+
+      it('error messages array is populated') do
+        expect(error_messages.first.downcase).to eq('the screening id was not found')
+      end
+    end
+
+    context 'with missing params' do
+      let(:id) { nil }
+      let(:key) { nil }
+
+      it_behaves_like 'a request that raises an error'
+    end
+  end
+end

data/spec/rest/screenings_spec.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 require 'spec_helpers/client'
-require 'rest/api_request'
+require 'spec_helpers/api_request'
 
 RSpec.describe FinApps::REST::Screenings do
   include SpecHelpers::Client
 
-  let(:results) { subject[0] }
-  let(:error_messages) { subject[1] }
+  let(:results) { subject[RESULTS] }
+  let(:error_messages) { subject[ERROR_MESSAGES] }
 
   describe '#list' do
     subject(:list) { described_class.new(client).list(params) }
@@ -15,14 +15,10 @@ RSpec.describe FinApps::REST::Screenings do
     context 'with valid params' do
       let(:params) { {} }
 
-      RSpec.shared_examples 'a GET request' do
-        it { expect(results).to have_key(:records) }
-      end
-
       RSpec.shared_examples 'a correct query builder' do |filter|
         it_behaves_like 'an API request'
         it_behaves_like 'a successful request'
-        it_behaves_like 'a GET request'
+        it_behaves_like 'a GET index request'
         it 'builds query and sends proper request' do
           list
           encoded_filter = ERB::Util.url_encode filter.to_json
@@ -68,13 +64,13 @@ RSpec.describe FinApps::REST::Screenings do
       end
 
       context 'with invalid progress' do
-        let(:params) { {progress: 'xyz'} }
+        let(:params) { {progress: 'not-an-integer'} }
 
-        it_behaves_like 'a correct query builder', {progress: 0}
+        it { expect { list }.to raise_error(ArgumentError) }
       end
 
       context 'with valid progress' do
-        let(:params) { {progress: 10} }
+        let(:params) { {progress: '10'} }
 
         it_behaves_like 'a correct query builder', {progress: 10}
       end
@@ -107,7 +103,7 @@ RSpec.describe FinApps::REST::Screenings do
 
       it_behaves_like 'an API request'
       it_behaves_like 'a successful request'
-      it_behaves_like 'a GET request'
+      it_behaves_like 'a GET index request'
     end
   end
 

data/spec/rest/signed_documents_downloads_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helpers/client'
-require 'rest/api_request'
+require 'spec_helpers/api_request'
 
 RSpec.describe FinApps::REST::SignedDocumentsDownloads do
   include SpecHelpers::Client