finapps 5.0.34 → 5.0.35

data/spec/rest/order_notifications_spec.rb

@@ -29,7 +29,7 @@ RSpec.describe FinApps::REST::OrderNotifications do
       end
     end
 
-    context 'for valid id' do
+    context 'with valid id' do
       let(:update) { subject.update(:valid_id) }
       let(:results) { update[RESULTS] }
       let(:error_messages) { update[ERROR_MESSAGES] }

data/spec/rest/order_refreshes_spec.rb

@@ -20,11 +20,8 @@ RSpec.describe FinApps::REST::OrderRefreshes do
 
       it { expect { create }.not_to raise_error }
       it('returns an array') { expect(create).to be_a(Array) }
-
-      it('performs a post and returns new refreshed order response') do
-        expect(create[RESULTS]).to have_key(:public_id)
-        expect(create[RESULTS]).to have_key(:original_order_id)
-      end
+      it { expect(create[RESULTS]).to have_key(:public_id) }
+      it { expect(create[RESULTS]).to have_key(:original_order_id) }
 
       it('returns no error messages') do
         expect(create[ERROR_MESSAGES]).to be_empty

data/spec/rest/order_reports_spec.rb

@@ -9,49 +9,49 @@ RSpec.describe FinApps::REST::OrderReports do
 
   describe '#show' do
     context 'when missing id' do
-      subject { order_report.show(nil, :pdf) }
+      subject(:show) { order_report.show(nil, :pdf) }
 
       it do
-        expect { subject }.to raise_error(FinAppsCore::MissingArgumentsError)
+        expect { show }.to raise_error(FinAppsCore::MissingArgumentsError)
       end
     end
 
     context 'when missing format' do
-      subject { order_report.show(:valid_id, nil) }
+      subject(:show) { order_report.show(:valid_id, nil) }
 
       it do
-        expect { subject }.to raise_error(FinAppsCore::MissingArgumentsError)
+        expect { show }.to raise_error(FinAppsCore::MissingArgumentsError)
       end
     end
 
     context 'when invalid format is provided' do
-      subject { order_report.show(:valid_id, :xml) }
+      subject(:show) { order_report.show(:valid_id, :xml) }
 
       it do
-        expect { subject }.to raise_error(FinAppsCore::InvalidArgumentsError)
+        expect { show }.to raise_error(FinAppsCore::InvalidArgumentsError)
       end
     end
 
     context 'when valid params are provided' do
-      subject { order_report.show(:valid_id, :json) }
+      subject(:show) { order_report.show(:valid_id, :json) }
 
-      it { expect { subject }.not_to raise_error }
+      it { expect { show }.not_to raise_error }
 
       it('performs a get and returns the response') do
-        expect(subject[0]).to have_key(:days_requested)
+        expect(show[0]).to have_key(:days_requested)
       end
 
-      it('returns no error messages') { expect(subject[1]).to be_empty }
+      it('returns no error messages') { expect(show[1]).to be_empty }
     end
 
     context 'when invalid id is provided' do
-      subject { order_report.show(:invalid_id, :json) }
+      subject(:show) { order_report.show(:invalid_id, :json) }
 
-      it { expect { subject }.not_to raise_error }
-      it('results is nil') { expect(subject[0]).to be_nil }
+      it { expect { show }.not_to raise_error }
+      it('results is nil') { expect(show[0]).to be_nil }
 
       it('error messages array is populated') do
-        expect(subject[1].first.downcase).to eq('resource not found')
+        expect(show[1].first.downcase).to eq('resource not found')
       end
     end
   end

data/spec/rest/order_statuses_spec.rb

@@ -5,35 +5,35 @@ RSpec.describe FinApps::REST::OrderStatuses do
 
   describe '#show' do
     context 'when missing id' do
-      subject { described_class.new(client).show(nil) }
+      subject(:show) { described_class.new(client).show(nil) }
 
       it do
-        expect { subject }.to raise_error(FinAppsCore::MissingArgumentsError)
+        expect { show }.to raise_error(FinAppsCore::MissingArgumentsError)
       end
     end
 
     context 'when valid id is provided' do
-      subject { described_class.new(client).show(:valid_id) }
+      subject(:show) { described_class.new(client).show(:valid_id) }
 
-      it { expect { subject }.not_to raise_error }
+      it { expect { show }.not_to raise_error }
 
       it('performs a get and returns the response') do
-        expect(subject[RESULTS]).to have_key(:status)
+        expect(show[RESULTS]).to have_key(:status)
       end
 
       it('returns no error messages') do
-        expect(subject[ERROR_MESSAGES]).to be_empty
+        expect(show[ERROR_MESSAGES]).to be_empty
       end
     end
 
     context 'when invalid id is provided' do
-      subject { described_class.new(client).show(:invalid_id) }
+      subject(:show) { described_class.new(client).show(:invalid_id) }
 
-      it { expect { subject }.not_to raise_error }
-      it('results is nil') { expect(subject[RESULTS]).to be_nil }
+      it { expect { show }.not_to raise_error }
+      it('results is nil') { expect(show[RESULTS]).to be_nil }
 
       it('error messages array is populated') do
-        expect(subject[ERROR_MESSAGES].first.downcase).to eq(
+        expect(show[ERROR_MESSAGES].first.downcase).to eq(
           'resource not found'
         )
       end

data/spec/rest/order_tokens_spec.rb

@@ -2,46 +2,47 @@
 
 require 'spec_helpers/client'
 
-RSpec.describe FinApps::REST::OrderTokens,
-               'initialized with valid FinApps::Client object' do
-  include SpecHelpers::Client
-
-  describe '#show' do
-    subject(:order_tokens) { described_class.new(client) }
-
-    let(:results) { show[RESULTS] }
-    let(:error_messages) { show[ERROR_MESSAGES] }
-
-    context 'when missing token' do
-      it do
-        expect { subject.show(nil) }.to raise_error(
-          FinAppsCore::MissingArgumentsError,
-          ': token'
-        )
+RSpec.describe FinApps::REST::OrderTokens do
+  context 'when initialized with valid FinApps::Client object' do
+    include SpecHelpers::Client
+
+    describe '#show' do
+      subject(:order_tokens) { described_class.new(client) }
+
+      let(:results) { show[RESULTS] }
+      let(:error_messages) { show[ERROR_MESSAGES] }
+
+      context 'when missing token' do
+        it do
+          expect { order_tokens.show(nil) }.to raise_error(
+            FinAppsCore::MissingArgumentsError,
+            ': token'
+          )
+        end
       end
-    end
 
-    context 'for valid token' do
-      let(:show) { subject.show(:valid_token) }
+      context 'with valid token' do
+        let(:show) { subject.show(:valid_token) }
 
-      it { expect { show }.not_to raise_error }
-      it('results is a Hash') { expect(results).to be_a(Hash) }
+        it { expect { show }.not_to raise_error }
+        it('results is a Hash') { expect(results).to be_a(Hash) }
 
-      it('results contains a consumer_id') do
-        expect(results).to have_key(:consumer_id)
-      end
+        it('results contains a consumer_id') do
+          expect(results).to have_key(:consumer_id)
+        end
 
-      it('error_messages array is empty') { expect(error_messages).to eq([]) }
-    end
+        it('error_messages array is empty') { expect(error_messages).to eq([]) }
+      end
 
-    context 'for invalid token' do
-      let(:show) { subject.show(:invalid_token) }
+      context 'with invalid token' do
+        let(:show) { subject.show(:invalid_token) }
 
-      it { expect { show }.not_to raise_error }
-      it('results is nil') { expect(results).to be_nil }
+        it { expect { show }.not_to raise_error }
+        it('results is nil') { expect(results).to be_nil }
 
-      it('error messages array is populated') do
-        expect(error_messages.first.downcase).to eq('resource not found')
+        it('error messages array is populated') do
+          expect(error_messages.first.downcase).to eq('resource not found')
+        end
       end
     end
   end

data/spec/rest/orders_spec.rb

@@ -7,69 +7,63 @@ RSpec.describe FinApps::REST::Orders do
 
   describe '#show' do
     context 'when missing params' do
-      subject { described_class.new(client).show(nil) }
+      subject(:show) { described_class.new(client).show(nil) }
 
       it do
-        expect { subject }.to raise_error(FinAppsCore::MissingArgumentsError)
+        expect { show }.to raise_error(FinAppsCore::MissingArgumentsError)
       end
     end
 
     context 'when valid params are provided' do
-      subject { described_class.new(client).show(:valid_id) }
+      subject(:show) { described_class.new(client).show(:valid_id) }
 
-      it { expect { subject }.not_to raise_error }
-      it('returns an array') { expect(subject).to be_a(Array) }
-
-      it('performs a get and returns the response') do
-        expect(subject[RESULTS]).to have_key(:public_id)
-        expect(subject[RESULTS]).to have_key(:consumer_id)
-      end
+      it { expect { show }.not_to raise_error }
+      it('returns an array') { expect(show).to be_a(Array) }
+      it { expect(show[RESULTS]).to have_key(:public_id) }
+      it { expect(show[RESULTS]).to have_key(:consumer_id) }
 
       it('returns no error messages') do
-        expect(subject[ERROR_MESSAGES]).to be_empty
+        expect(show[ERROR_MESSAGES]).to be_empty
       end
     end
   end
 
   describe '#create' do
     context 'when missing params' 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 valid params are provided' do
-      subject { described_class.new(client).create(valid_params) }
+      subject(:create) { described_class.new(client).create(valid_params) }
 
       let(:valid_params) do
         {applicant: 'valid', institutions: 'valid', product: 'valid'}
       end
 
-      it { expect { subject }.not_to raise_error }
-      it('returns an array') { expect(subject).to be_a(Array) }
-
-      it('performs a post and returns the response') do
-        expect(subject[RESULTS]).to have_key(:public_id)
-        expect(subject[RESULTS]).to have_key(:consumer_id)
-      end
+      it { expect { create }.not_to raise_error }
+      it('returns an array') { expect(create).to be_a(Array) }
+      it { expect(create[RESULTS]).to have_key(:public_id) }
+      it { expect(create[RESULTS]).to have_key(:consumer_id) }
 
       it('returns no error messages') do
-        expect(subject[ERROR_MESSAGES]).to be_empty
+        expect(create[ERROR_MESSAGES]).to be_empty
       end
     end
 
     context 'when invalid params are provided' do
-      subject { described_class.new(client).create(invalid_params) }
+      subject(:create) { described_class.new(client).create(invalid_params) }
 
       let(:invalid_params) { {applicant: 'valid'} }
 
-      it { expect { subject }.not_to raise_error }
-      it('results is nil') { expect(subject[RESULTS]).to be_nil }
+      it { expect { create }.not_to raise_error }
+      it('results is nil') { expect(create[RESULTS]).to be_nil }
 
       it('error messages array is populated') do
-        expect(subject[ERROR_MESSAGES].first.downcase).to eq(
+        expect(create[ERROR_MESSAGES].first.downcase).to eq(
           'invalid request body'
         )
       end
@@ -80,33 +74,33 @@ RSpec.describe FinApps::REST::Orders do
     context 'when missing params' do
       # use defaults
 
-      subject { described_class.new(client).list }
+      subject(:list) { described_class.new(client).list }
 
-      it { expect { subject }.not_to raise_error }
+      it { expect { list }.not_to raise_error }
 
-      it('returns an array') { expect(subject).to be_a(Array) }
+      it('returns an array') { expect(list).to be_a(Array) }
 
       it('performs a get and returns the response') do
-        expect(subject[RESULTS]).to have_key(:orders)
+        expect(list[RESULTS]).to have_key(:orders)
       end
 
       it('returns no error messages') do
-        expect(subject[ERROR_MESSAGES]).to be_empty
+        expect(list[ERROR_MESSAGES]).to be_empty
       end
     end
 
     context 'when invalid params are provided' do
-      subject { described_class.new(client).list(invalid_params) }
+      subject(:list) { described_class.new(client).list(invalid_params) }
 
       let(:invalid_params) { %w[this is an array] }
 
       it do
-        expect { subject }.to raise_error(FinAppsCore::InvalidArgumentsError)
+        expect { list }.to raise_error(FinAppsCore::InvalidArgumentsError)
       end
     end
 
     context 'when including valid params' do
-      subject { described_class.new(client).list(params) }
+      subject(:list) { described_class.new(client).list(params) }
 
       let(:params) do
         {
@@ -121,40 +115,37 @@ RSpec.describe FinApps::REST::Orders do
         }
       end
 
-      it { expect { subject }.not_to raise_error }
-      it('returns an array') { expect(subject).to be_a(Array) }
+      it { expect { list }.not_to raise_error }
+      it('returns an array') { expect(list).to be_a(Array) }
 
       it('performs a get and returns the response') do
-        expect(subject[RESULTS]).to have_key(:orders)
+        expect(list[RESULTS]).to have_key(:orders)
       end
 
       it('each order contains a consumer_id') do
-        expect(subject[RESULTS][:orders]).to all(have_key(:consumer_id))
+        expect(list[RESULTS][:orders]).to all(have_key(:consumer_id))
       end
 
       it('returns no error messages') do
-        expect(subject[ERROR_MESSAGES]).to be_empty
+        expect(list[ERROR_MESSAGES]).to be_empty
       end
 
       it 'builds query and sends proper request' do
-        subject
+        list
         url = "#{versioned_api_path}/orders?"\
-          'filter=%7B%22$or%22:%5B%7B%22public_id%22:' \
-          '%7B%22$regex%22:%22%5Eterm%22,%22$options%22:%22i%22%7D%7D,'\
-          '%7B%22applicant.last_name%22:%22' \
-          'term%22%7D,%7B%22assignment.last_name%22:%22term%22%7D,'\
-          '%7B%22requestor.reference_no%22:%7B%22' \
-          '$regex%22:%22%5Eterm%22,%22$options%22:%22i%22%7D%7D%5D,'\
-          '%22status%22:%7B%22$in%22:%5B1,7%5D%7D,' \
-          '%22assignment.operator_id%22:%22valid_operator%22,'\
-          '%22consumer_id%22:%22valid_consumer_id%22%7D' \
-          '&page=2&requested=25&sort=status'
+        'filter=%7B%22$or%22:%5B%7B%22public_id%22:%7B%22$regex%22:%22%5E'\
+        'term%22,%22$options%22:%22i%22%7D%7D,%7B%22assignment.last_name%22:%22'\
+        'term%22%7D,%7B%22applicant.first_name%22:%22term%22%7D,%7B%22'\
+        'applicant.last_name%22:%22term%22%7D,%7B%22requestor.reference_no'\
+        '%22:%7B%22$regex%22:%22%5Eterm%22,%22$options%22:%22i%22%7D%7D%5D,%22'\
+        'status%22:%7B%22$in%22:%5B1,7%5D%7D,%22assignment.operator_id%22:%22'\
+        'valid_operator%22,%22consumer_id%22:%22valid_consumer_id%22%7D&page=2&requested=25&sort=status'
         expect(WebMock).to have_requested(:get, url)
       end
 
       it 'builds query and sends proper request with searchTerm/relation exclusivity' do
         params[:searchTerm] = nil
-        subject
+        list
         url = "#{versioned_api_path}/orders?"\
           'filter=%7B%22status%22:%7B%22$in%22:%5B1,7%5D%7D,' \
           '%22assignment.operator_id%22:%22valid_operator%22,'\
@@ -165,6 +156,23 @@ RSpec.describe FinApps::REST::Orders do
         expect(WebMock).to have_requested(:get, url)
       end
 
+      it 'handles space in search term for consumer' do
+        params[:searchTerm] = 'Spacing Out'
+        list
+        url = "#{versioned_api_path}/orders?"\
+        'filter=%7B%22$or%22:%5B%7B%22public_id%22:%7B%22$regex%22:%22%5E'\
+        'Spacing%20Out%22,%22$options%22:%22i%22%7D%7D,%7B%22assignment.last_name'\
+        '%22:%22Spacing%20Out%22%7D,%7B%22applicant.first_name%22:%22'\
+        'Spacing%20Out%22%7D,%7B%22applicant.last_name%22:%22Spacing%20Out'\
+        '%22%7D,%7B%22requestor.reference_no%22:%7B%22$regex%22:%22%5ESpacing%20Out'\
+        '%22,%22$options%22:%22i%22%7D%7D,%7B%22applicant.first_name%22:%22Spacing'\
+        '%22%7D,%7B%22applicant.last_name%22:%22Spacing%22%7D,%7B%22applicant.first_name'\
+        '%22:%22Out%22%7D,%7B%22applicant.last_name%22:%22Out%22%7D%5D,%22status'\
+        '%22:%7B%22$in%22:%5B1,7%5D%7D,%22assignment.operator_id%22:%22valid_operator'\
+        '%22,%22consumer_id%22:%22valid_consumer_id%22%7D&page=2&requested=25&sort=status'
+        expect(WebMock).to have_requested(:get, url)
+      end
+
       it 'builds null assignment query properly when supplied w/ empty string' do
         described_class.new(client).list(assignment: '')
 
@@ -180,7 +188,7 @@ RSpec.describe FinApps::REST::Orders do
 
     context 'with nil params' do
       context 'when missing id' do
-        let(:update) { subject.update(nil) }
+        let(:update) { orders.update(nil) }
 
         it('returns missing argument error') do
           expect { update }.to raise_error(FinAppsCore::MissingArgumentsError)
@@ -188,7 +196,7 @@ RSpec.describe FinApps::REST::Orders do
       end
 
       context 'when valid id is provided' do
-        let(:update) { subject.update('valid_id') } # how to stub params
+        let(:update) { orders.update('valid_id') } # how to stub params
         let(:results) { update[RESULTS] }
         let(:error_messages) { update[ERROR_MESSAGES] }
 
@@ -198,7 +206,7 @@ RSpec.describe FinApps::REST::Orders do
       end
 
       context 'when invalid id is provided' do
-        let(:update) { subject.update('invalid_id') }
+        let(:update) { orders.update('invalid_id') }
         let(:results) { update[RESULTS] }
         let(:error_messages) { update[ERROR_MESSAGES] }
 
@@ -213,7 +221,7 @@ RSpec.describe FinApps::REST::Orders do
 
     context 'with params' do
       context 'when missing id' do
-        let(:update) { subject.update(nil, params: 'valid') }
+        let(:update) { orders.update(nil, params: 'valid') }
 
         it('does not raise error') do
           expect { update }.not_to raise_error
@@ -221,7 +229,7 @@ RSpec.describe FinApps::REST::Orders do
       end
 
       context 'when valid params are provided' do
-        let(:update) { subject.update(nil, params: 'valid') }
+        let(:update) { orders.update(nil, params: 'valid') }
         let(:results) { update[RESULTS] }
         let(:error_messages) { update[ERROR_MESSAGES] }
 
@@ -231,7 +239,7 @@ RSpec.describe FinApps::REST::Orders do
       end
 
       context 'when invalid params are provided' do
-        let(:update) { subject.update(nil, params: 'invalid') }
+        let(:update) { orders.update(nil, params: 'invalid') }
         let(:results) { update[RESULTS] }
         let(:error_messages) { update[ERROR_MESSAGES] }
 
@@ -245,14 +253,20 @@ RSpec.describe FinApps::REST::Orders do
     end
   end
 
+  # Test it calls update while making rubocop happy
   describe '#create_and_submit' do
     subject(:orders) { described_class.new(client) }
 
+    let(:create_submit) { orders.create_and_submit(params) }
     let(:params) { {params: 'valid'} }
+    let(:results) { create_submit[RESULTS] }
+    let(:error_messages) { create_submit[ERROR_MESSAGES] }
+
+    it { expect { create_submit }.not_to raise_error }
+    it('results is nil') { expect(results).to be_nil }
 
-    it('calls #update') do
-      expect(subject).to receive(:update).with(nil, params)
-      subject.create_and_submit(params)
+    it('error messages array is empty') do
+      expect(error_messages).to eq([])
     end
   end
 
@@ -260,7 +274,7 @@ RSpec.describe FinApps::REST::Orders do
     subject(:orders) { described_class.new(client) }
 
     context 'when missing id' do
-      let(:destroy) { subject.destroy(nil) }
+      let(:destroy) { orders.destroy(nil) }
 
       it('returns missing argument error') do
         expect { destroy }.to raise_error(FinAppsCore::MissingArgumentsError)
@@ -268,7 +282,7 @@ RSpec.describe FinApps::REST::Orders do
     end
 
     context 'when invalid id is provided' do
-      let(:destroy) { subject.destroy(:invalid_id) }
+      let(:destroy) { orders.destroy(:invalid_id) }
       let(:results) { destroy[RESULTS] }
       let(:error_messages) { destroy[ERROR_MESSAGES] }
 
@@ -280,8 +294,8 @@ RSpec.describe FinApps::REST::Orders do
       end
     end
 
-    context 'for valid id' do
-      let(:destroy) { subject.destroy(:valid_id) }
+    context 'with valid id' do
+      let(:destroy) { orders.destroy(:valid_id) }
       let(:results) { destroy[RESULTS] }
       let(:error_messages) { destroy[ERROR_MESSAGES] }