LG-11718: make sure err http status is handled.

app/services/doc_auth/lexis_nexis/request.rb

@@ -54,7 +54,11 @@ def handle_connection_error(exception)
           success: false,
           errors: { network: true },
           exception: exception,
-          extra: { vendor: 'TrueID' },
+          extra: {
+            vendor: 'TrueID',
+            selfie_live: false,
+            selfie_quality_good: false,
+          },
         )
       end
 

spec/features/idv/doc_auth/redo_document_capture_spec.rb

@@ -186,6 +186,8 @@
       complete_doc_auth_steps_before_document_capture_step
       mock_doc_auth_trueid_http_non2xx_status(438)
       attach_and_submit_images
+      # verify it's a network error
+      expect(page).to have_content(I18n.t('doc_auth.errors.general.network_error'))
       click_try_again
     end
 
@@ -199,6 +201,8 @@
       complete_doc_auth_steps_before_document_capture_step
       mock_doc_auth_trueid_http_non2xx_status(500)
       attach_and_submit_images
+      # verify it's a network error
+      expect(page).to have_content(I18n.t('doc_auth.errors.general.network_error'))
       click_try_again
     end
     it_behaves_like 'image re-upload allowed'

spec/forms/idv/api_image_upload_form_spec.rb

@@ -268,8 +268,10 @@
           extra: { remaining_attempts: IdentityConfig.store.doc_auth_max_attempts - 1 },
         )
       end
+      let(:doc_auth_client) { double(DocAuth::LexisNexis::LexisNexisClient) }
       before do
-        allow(subject).to receive(:post_images_to_client).and_return(failed_response)
+        subject.instance_variable_set(:@doc_auth_client, doc_auth_client)
+        allow(doc_auth_client).to receive(:post_images) { failed_response }
       end
 
       it 'is not successful' do
@@ -279,6 +281,7 @@
         expect(response.success?).to eq(false)
         expect(response.attention_with_barcode?).to eq(false)
         expect(response.pii_from_doc).to eq({})
+        expect(response.doc_auth_success?).to eq(false)
       end
 
       it 'includes remaining_attempts' do
@@ -300,6 +303,24 @@
         expect(response.errors).to have_key(:front)
         expect(response.errors).to have_value([I18n.t('doc_auth.errors.doc.resubmit_failed_image')])
       end
+
+      it 'logs analytics event' do
+        form.submit
+        expect(fake_analytics).to have_logged_event(
+          'IdV: doc auth image upload vendor submitted',
+          hash_including(
+            doc_auth_result: nil,
+            errors: { front: 'glare' },
+            success: false,
+            doc_type_supported: boolean,
+            doc_auth_success: boolean,
+            liveness_checking_required: boolean,
+            selfie_status: :not_processed,
+            selfie_live: boolean,
+            selfie_quality_good: boolean,
+          ),
+        )
+      end
     end
 
     context 'PII validation from client response fails' do

spec/services/doc_auth/lexis_nexis/lexis_nexis_client_spec.rb

@@ -17,6 +17,8 @@
       trueid_account_id: 'test_account',
       trueid_noliveness_cropping_workflow: 'NOLIVENESS.CROPPING.WORKFLOW',
       trueid_noliveness_nocropping_workflow: 'NOLIVENESS.NOCROPPING.WORKFLOW',
+      trueid_liveness_cropping_workflow: 'LIVENESS.CROPPING.WORKFLOW',
+      trueid_liveness_nocropping_workflow: 'LIVENESS.NOCROPPING.WORKFLOW',
     )
   end
 
@@ -117,4 +119,85 @@
       )
     end
   end
+
+  context 'with selfie check enabled' do
+    ## enable feature
+    let(:workflow) { 'LIVENESS.CROPPING.WORKFLOW' }
+    before do
+      allow(FeatureManagement).to receive(:idv_allow_selfie_check?).and_return(true)
+    end
+    describe 'when success response returned' do
+      before do
+        stub_request(:post, image_upload_url).to_return(
+          body: LexisNexisFixtures.true_id_response_success_with_liveness,
+        )
+      end
+      it 'returns a successful response' do
+        result = client.post_images(
+          front_image: DocAuthImageFixtures.document_front_image,
+          back_image: DocAuthImageFixtures.document_back_image,
+          image_source: image_source,
+          selfie_image: DocAuthImageFixtures.selfie_image,
+          liveness_checking_required: true,
+        )
+        expect(result.success?).to eq(true)
+        expect(result.class).to eq(DocAuth::LexisNexis::Responses::TrueIdResponse)
+        expect(result.doc_auth_success?).to eq(true)
+        expect(result.selfie_live?).to eq(true)
+        expect(result.selfie_quality_good?).to eq(true)
+        expect(result.selfie_check_performed?).to eq(true)
+      end
+    end
+
+    describe 'when selfie failure response returned' do
+      before do
+        stub_request(:post, image_upload_url).to_return(
+          body: LexisNexisFixtures.true_id_response_failure_with_liveness,
+        )
+      end
+
+      it 'returns a response indicate all failures' do
+        result = client.post_images(
+          front_image: DocAuthImageFixtures.document_front_image,
+          back_image: DocAuthImageFixtures.document_back_image,
+          image_source: image_source,
+          selfie_image: DocAuthImageFixtures.selfie_image,
+          liveness_checking_required: true,
+        )
+        expect(result.success?).to eq(false)
+        expect(result.class).to eq(DocAuth::LexisNexis::Responses::TrueIdResponse)
+        expect(result.doc_auth_success?).to eq(false)
+        result_hash = result.to_h
+        expect(result_hash[:selfie_status]).to eq(:fail)
+        expect(result.selfie_live?).to eq(true)
+        expect(result.selfie_quality_good?).to eq(false)
+        expect(result.selfie_check_performed?).to eq(true)
+      end
+    end
+
+    describe 'when http request failed' do
+      it 'return failed response with correct statuses' do
+        stub_request(:post, image_upload_url).to_return(body: '', status: 401)
+
+        result = client.post_images(
+          front_image: DocAuthImageFixtures.document_front_image,
+          back_image: DocAuthImageFixtures.document_back_image,
+          image_source: image_source,
+          selfie_image: DocAuthImageFixtures.selfie_image,
+          liveness_checking_required: true,
+        )
+
+        expect(result.success?).to eq(false)
+        expect(result.errors).to eq(network: true)
+        expect(result.exception.message).to eq(
+          'DocAuth::LexisNexis::Requests::TrueIdRequest Unexpected HTTP response 401',
+        )
+        result_hash = result.to_h
+        expect(result_hash[:vendor]).to eq('TrueID')
+        expect(result_hash[:doc_auth_success]).to eq(false)
+        expect(result_hash[:selfie_status]).to eq(:not_processed)
+        expect(result.class).to eq(DocAuth::Response)
+      end
+    end
+  end
 end

spec/services/doc_auth/lexis_nexis/request_spec.rb

@@ -87,13 +87,18 @@
           expect(response.class).to eq(DocAuth::Response)
         end
 
-        it 'includes information on the error' do
-          response = subject.fetch
+        it 'includes information on the error and notifies NewRelic' do
           expected_message = [
             subject.class.name,
             'Unexpected HTTP response',
             status,
           ].join(' ')
+          expect(NewRelic::Agent).to receive(:notice_error) do |arg|
+            expect(arg).to be_an_instance_of(DocAuth::RequestError)
+            expect(arg.message).to eq(expected_message)
+            expect(arg.error_code).to eq(status)
+          end
+          response = subject.fetch
 
           expect(response.exception.message).to eq(expected_message)
         end

spec/services/doc_auth/lexis_nexis/requests/true_id_request_spec.rb

@@ -3,19 +3,24 @@
 RSpec.describe DocAuth::LexisNexis::Requests::TrueIdRequest do
   let(:image_source) { nil }
   let(:account_id) { 'test_account' }
-  let(:workflow) { nil }
   let(:base_url) { 'https://lexis.nexis.example.com' }
+  let(:workflow) { subject.send(:workflow) }
   let(:path) { "/restws/identity/v3/accounts/#{account_id}/workflows/#{workflow}/conversations" }
   let(:full_url) { base_url + path }
   let(:applicant) { { uuid: SecureRandom.uuid, uuid_prefix: '123' } }
+  let(:non_cropping_non_liveness_flow) { 'test_workflow' }
+  let(:cropping_non_liveness_flow) { 'test_workflow_cropping' }
+  let(:non_cropping_liveness_flow) { 'test_workflow_liveness' }
+  let(:cropping_liveness_flow) { 'test_workflow_liveness_cropping' }
+
   let(:config) do
     DocAuth::LexisNexis::Config.new(
       trueid_account_id: account_id,
       base_url: base_url,
-      trueid_noliveness_cropping_workflow: 'test_workflow_cropping',
-      trueid_noliveness_nocropping_workflow: 'test_workflow',
-      trueid_liveness_cropping_workflow: 'test_workflow_liveness_cropping',
-      trueid_liveness_nocropping_workflow: 'test_workflow_liveness',
+      trueid_noliveness_cropping_workflow: cropping_non_liveness_flow,
+      trueid_noliveness_nocropping_workflow: non_cropping_non_liveness_flow,
+      trueid_liveness_cropping_workflow: cropping_liveness_flow,
+      trueid_liveness_nocropping_workflow: non_cropping_liveness_flow,
     )
   end
   let(:selfie_image) { DocAuthImageFixtures.selfie_image }
@@ -100,35 +105,40 @@ def include_liveness_expected
     context 'when liveness checking is NOT required' do
       let(:liveness_checking_required) { false }
       context 'with acuant image source' do
-        let(:workflow) { 'test_workflow' }
         let(:image_source) { DocAuth::ImageSources::ACUANT_SDK }
         it_behaves_like 'a successful request'
-
+        it 'uses non-cropping non-liveness workflow' do
+          expect(subject.send(:workflow)).to eq(non_cropping_non_liveness_flow)
+        end
         it 'does not include a nil selfie in the request body sent to TrueID' do
           body_as_json = subject.send(:body)
           body_as_hash = JSON.parse(body_as_json)
           expect(body_as_hash['Document']).not_to have_key('Selfie')
         end
       end
       context 'with unknown image source' do
-        let(:workflow) { 'test_workflow_cropping' }
         let(:image_source) { DocAuth::ImageSources::UNKNOWN }
-
+        it 'uses cropping non-liveness workflow' do
+          expect(subject.send(:workflow)).to eq(cropping_non_liveness_flow)
+        end
         it_behaves_like 'a successful request'
       end
     end
 
     context 'when liveness checking is required' do
       let(:liveness_checking_required) { true }
       context 'with acuant image source' do
-        let(:workflow) { 'test_workflow' }
         let(:image_source) { DocAuth::ImageSources::ACUANT_SDK }
+        it 'uses non-cropping non-liveness workflow' do
+          expect(subject.send(:workflow)).to eq(non_cropping_non_liveness_flow)
+        end
         it_behaves_like 'a successful request'
       end
       context 'with unknown image source' do
-        let(:workflow) { 'test_workflow_cropping' }
         let(:image_source) { DocAuth::ImageSources::UNKNOWN }
-
+        it 'uses cropping non-liveness workflow' do
+          expect(subject.send(:workflow)).to eq(cropping_non_liveness_flow)
+        end
         it_behaves_like 'a successful request'
       end
     end
@@ -144,60 +154,67 @@ def include_liveness_expected
     context 'when liveness checking is NOT required' do
       let(:liveness_checking_required) { false }
       context 'with acuant image source' do
-        let(:workflow) { 'test_workflow' }
         let(:image_source) { DocAuth::ImageSources::ACUANT_SDK }
+        it 'use non-cropping non-liveness workflow' do
+          expect(subject.send(:workflow)).to eq(non_cropping_non_liveness_flow)
+        end
         it_behaves_like 'a successful request'
       end
       context 'with unknown image source' do
-        let(:workflow) { 'test_workflow_cropping' }
         let(:image_source) { DocAuth::ImageSources::UNKNOWN }
-
+        it 'use cropping non-liveness workflow' do
+          expect(subject.send(:workflow)).to eq(cropping_non_liveness_flow)
+        end
         it_behaves_like 'a successful request'
       end
     end
 
     context 'when liveness checking is required' do
       let(:liveness_checking_required) { true }
       context 'with acuant image source' do
-        let(:workflow) { 'test_workflow_liveness' }
         let(:image_source) { DocAuth::ImageSources::ACUANT_SDK }
-
+        it 'use non-cropping liveness workflow' do
+          expect(subject.send(:workflow)).to eq(non_cropping_liveness_flow)
+        end
         it_behaves_like 'a successful request'
       end
       context 'with unknown image source' do
-        let(:workflow) { 'test_workflow_liveness_cropping' }
         let(:image_source) { DocAuth::ImageSources::UNKNOWN }
-
+        it 'use cropping liveness workflow' do
+          expect(subject.send(:workflow)).to eq(cropping_liveness_flow)
+        end
         it_behaves_like 'a successful request'
       end
 
       context 'when hosted env is prod' do
         let(:selfie_check_allowed) { false }
         context 'with acuant image source' do
-          let(:workflow) { 'test_workflow' }
           let(:image_source) { DocAuth::ImageSources::ACUANT_SDK }
+          it 'use non-cropping non-liveness workflow' do
+            expect(subject.send(:workflow)).to eq(non_cropping_non_liveness_flow)
+          end
           it_behaves_like 'a successful request'
         end
         context 'with unknown image source' do
-          let(:workflow) { 'test_workflow_cropping' }
           let(:image_source) { DocAuth::ImageSources::UNKNOWN }
-
+          it 'use cropping non-liveness workflow' do
+            expect(subject.send(:workflow)).to eq(cropping_non_liveness_flow)
+          end
           it_behaves_like 'a successful request'
         end
       end
     end
   end
 
   context 'with non 200 http status code' do
-    let(:workflow) { 'test_workflow' }
     let(:image_source) { DocAuth::ImageSources::ACUANT_SDK }
     it 'is a network error with 5xx status' do
       stub_request(:post, full_url).to_return(body: '{}', status: 500)
       response = subject.fetch
       expect(response.network_error?).to eq(true)
     end
-    it 'is not a network error with 440, 438, 439' do
-      stub_request(:post, full_url).to_return(body: '{}', status: 443)
+    it 'is a network error with non 5xx error' do
+      stub_request(:post, full_url).to_return(body: '{}', status: 401)
       response = subject.fetch
       expect(response.network_error?).to eq(true)
     end