finapps 5.0.30 → 5.0.35

data/spec/rest/order_notifications_spec.rb

@@ -6,10 +6,11 @@ RSpec.describe FinApps::REST::OrderNotifications do
   include SpecHelpers::Client
 
   describe '#update' do
-    subject(:orders) { FinApps::REST::OrderNotifications.new(client) }
+    subject(:orders) { described_class.new(client) }
 
     context 'when missing id' do
       let(:update) { subject.update(nil) }
+
       it('returns missing argument error') do
         expect { update }.to raise_error(FinAppsCore::MissingArgumentsError)
       end
@@ -22,12 +23,13 @@ RSpec.describe FinApps::REST::OrderNotifications do
 
       it { expect { update }.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')
       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

@@ -4,11 +4,12 @@ require 'spec_helpers/client'
 
 RSpec.describe FinApps::REST::OrderRefreshes do
   include SpecHelpers::Client
-  subject { FinApps::REST::OrderRefreshes.new(client) }
+  subject { described_class.new(client) }
 
   describe '#create' do
     context 'when missing id' do
       let(:create) { subject.create(nil) }
+
       it do
         expect { create }.to raise_error(FinAppsCore::MissingArgumentsError)
       end
@@ -16,12 +17,12 @@ RSpec.describe FinApps::REST::OrderRefreshes do
 
     context 'when valid id is provided' do
       let(:create) { subject.create(:valid_id) }
+
       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
       end
@@ -29,9 +30,11 @@ RSpec.describe FinApps::REST::OrderRefreshes do
 
     context 'when invalid id is provided' do
       let(:create) { subject.create(:invalid_id) }
+
       it { expect { create }.not_to raise_error }
       it('returns an array') { expect(create).to be_a(Array) }
       it('results is nil') { expect(create[RESULTS]).to be_nil }
+
       it('error messages array is populated') do
         expect(create[ERROR_MESSAGES].first.downcase).to eq(
           'resource not found'

data/spec/rest/order_reports_spec.rb

@@ -5,47 +5,53 @@ require 'spec_helpers/client'
 RSpec.describe FinApps::REST::OrderReports do
   include SpecHelpers::Client
 
-  let(:order_report) { FinApps::REST::OrderReports.new client }
+  let(:order_report) { described_class.new client }
 
   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 { show }.not_to raise_error }
 
-      it { expect { subject }.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 { show }.not_to raise_error }
+      it('results is nil') { expect(show[0]).to be_nil }
 
-      it { expect { subject }.not_to raise_error }
-      it('results is nil') { expect(subject[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,31 +5,35 @@ RSpec.describe FinApps::REST::OrderStatuses do
 
   describe '#show' do
     context 'when missing id' do
-      subject { FinApps::REST::OrderStatuses.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 { FinApps::REST::OrderStatuses.new(client).show(:valid_id) }
+      subject(:show) { described_class.new(client).show(:valid_id) }
+
+      it { expect { show }.not_to raise_error }
 
-      it { expect { subject }.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 { FinApps::REST::OrderStatuses.new(client).show(:invalid_id) }
+      subject(:show) { described_class.new(client).show(:invalid_id) }
+
+      it { expect { show }.not_to raise_error }
+      it('results is nil') { expect(show[RESULTS]).to be_nil }
 
-      it { expect { subject }.not_to raise_error }
-      it('results is nil') { expect(subject[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,40 +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) { FinApps::REST::OrderTokens.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) }
-      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)
+      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('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) }
-      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')
+      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('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,60 +7,63 @@ RSpec.describe FinApps::REST::Orders do
 
   describe '#show' do
     context 'when missing params' do
-      subject { FinApps::REST::Orders.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 { FinApps::REST::Orders.new(client).show(:valid_id) }
+      subject(:show) { described_class.new(client).show(:valid_id) }
+
+      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 { 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('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 { FinApps::REST::Orders.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 { FinApps::REST::Orders.new(client).create(valid_params) }
+      subject(:create) { described_class.new(client).create(valid_params) }
+
       let(:valid_params) do
-        { applicant: 'valid', institutions: 'valid', product: 'valid' }
+        {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 { FinApps::REST::Orders.new(client).create(invalid_params) }
-      let(:invalid_params) { { applicant: 'valid' } }
+      subject(:create) { described_class.new(client).create(invalid_params) }
+
+      let(:invalid_params) { {applicant: 'valid'} }
+
+      it { expect { create }.not_to raise_error }
+      it('results is nil') { expect(create[RESULTS]).to be_nil }
 
-      it { expect { subject }.not_to raise_error }
-      it('results is nil') { expect(subject[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
@@ -71,29 +74,34 @@ RSpec.describe FinApps::REST::Orders do
     context 'when missing params' do
       # use defaults
 
-      subject { FinApps::REST::Orders.new(client).list }
-      it { expect { subject }.not_to raise_error }
+      subject(:list) { described_class.new(client).list }
+
+      it { expect { list }.not_to raise_error }
+
+      it('returns an array') { expect(list).to be_a(Array) }
 
-      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(: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 { FinApps::REST::Orders.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 { FinApps::REST::Orders.new(client).list(params) }
+      subject(:list) { described_class.new(client).list(params) }
+
       let(:params) do
         {
           page: 2,
@@ -107,61 +115,88 @@ 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
-        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'
+        list
+        url = "#{versioned_api_path}/orders?"\
+        '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
-        url =
-          "#{versioned_api_path}/orders?filter=%7B%22status%22:%7B%22$in%22:%5B1,7%5D%7D," \
-          '%22assignment.operator_id%22:%22valid_operator%22,%22consumer_id%22:%22valid_consumer_id%22,' \
-          '%22$or%22:%5B%7B%22public_id%22:%7B%22$in%22:%5B%22valid_order_id%22%5D%7D%7D,%7B%22original_order_id%22:' \
-          '%7B%22$in%22:%5B%22valid_order_id%22%5D%7D%7D%5D%7D&page=2&requested=25&sort=status'
+        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,'\
+          '%22consumer_id%22:%22valid_consumer_id%22,' \
+          '%22$or%22:%5B%7B%22public_id%22:%7B%22$in%22:%5B%22valid_order_id%22%5D%7D%7D,'\
+          '%7B%22original_order_id%22:%7B%22$in%22:%5B%22valid_order_id%22%5D%7D%7D%5D%7D&'\
+          'page=2&requested=25&sort=status'
+        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
-        FinApps::REST::Orders.new(client).list(assignment: '')
+        described_class.new(client).list(assignment: '')
 
-        url =
-          "#{versioned_api_path}/orders?filter=%7B%22assignment.operator_id%22:null%7D"
+        url = "#{versioned_api_path}/orders?"\
+          'filter=%7B%22assignment.operator_id%22:null%7D'
         expect(WebMock).to have_requested(:get, url)
       end
     end
   end
 
   describe '#update' do
-    subject(:orders) { FinApps::REST::Orders.new(client) }
+    subject(:orders) { described_class.new(client) }
 
     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)
         end
       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] }
 
@@ -171,12 +206,13 @@ 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] }
 
         it { expect { update }.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')
         end
@@ -185,14 +221,15 @@ 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
         end
       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] }
 
@@ -202,12 +239,13 @@ 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] }
 
         it { expect { update }.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('invalid request body')
         end
@@ -215,39 +253,49 @@ RSpec.describe FinApps::REST::Orders do
     end
   end
 
+  # Test it calls update while making rubocop happy
   describe '#create_and_submit' do
-    subject(:orders) { FinApps::REST::Orders.new(client) }
-    let(:params) { { params: 'valid' } }
-    it('calls #update') do
-      expect(subject).to receive(:update).with(nil, params)
-      subject.create_and_submit(params)
+    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('error messages array is empty') do
+      expect(error_messages).to eq([])
     end
   end
 
   describe '#destroy' do
-    subject(:orders) { FinApps::REST::Orders.new(client) }
+    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)
       end
     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] }
 
       it { expect { destroy }.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')
       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] }