LG-8693: Verify residential address with LexisNexis

app/services/proofing/resolution/progressive_proofer.rb

@@ -33,27 +33,41 @@ def proof(
           user_email: user_email,
         )
 
-        # todo(LG-8693): Begin verifying both the user's residential address and identity document
-        # address
-        applicant_pii = with_state_id_address(applicant_pii) if double_address_verification
-
-        resolution_result = proof_resolution(
+        residential_instant_verify_result = proof_residential_address_if_needed(
           applicant_pii: applicant_pii,
           timer: timer,
+          double_address_verification: double_address_verification,
         )
-        state_id_result = proof_state_id_if_needed(
-          applicant_pii: applicant_pii,
+
+        applicant_pii_transformed = applicant_pii.clone
+        if double_address_verification
+          applicant_pii_transformed = with_state_id_address(applicant_pii_transformed)
+        end
+
+        instant_verify_result = proof_id_address_with_lexis_nexis_if_needed(
+          applicant_pii: applicant_pii_transformed,
           timer: timer,
-          resolution_result: resolution_result,
+          residential_instant_verify_result: residential_instant_verify_result,
+          double_address_verification: double_address_verification,
+        )
+
+        state_id_result = proof_id_with_aamva_if_needed(
+          applicant_pii: applicant_pii_transformed,
+          timer: timer,
+          residential_instant_verify_result: residential_instant_verify_result,
+          instant_verify_result: instant_verify_result,
           should_proof_state_id: should_proof_state_id,
+          double_address_verification: double_address_verification,
         )
 
         ResultAdjudicator.new(
           device_profiling_result: device_profiling_result,
           double_address_verification: double_address_verification,
-          resolution_result: resolution_result,
+          resolution_result: instant_verify_result,
           should_proof_state_id: should_proof_state_id,
           state_id_result: state_id_result,
+          residential_resolution_result: residential_instant_verify_result,
+          same_address_as_id: applicant_pii[:same_address_as_id],
         )
       end
 
@@ -86,20 +100,70 @@ def proof_with_threatmetrix_if_needed(
         end
       end
 
-      def proof_resolution(applicant_pii:, timer:)
+      def proof_residential_address_if_needed(
+        applicant_pii:,
+        timer:,
+        double_address_verification:
+      )
+        return residential_address_unnecessary_result unless double_address_verification
+
+        timer.time('residential address') do
+          resolution_proofer.proof(applicant_pii)
+        end
+      end
+
+      def residential_address_unnecessary_result
+        Proofing::AddressResult.new(
+          success: true, errors: {}, exception: nil, vendor_name: 'ResidentialAddressNotRequired',
+        )
+      end
+
+      def resolution_cannot_pass
+        Proofing::AddressResult.new(
+          success: false, errors: {}, exception: nil, vendor_name: 'ResolutionCannotPass',
+        )
+      end
+
+      def proof_id_address_with_lexis_nexis_if_needed(applicant_pii:, timer:,
+                                                      residential_instant_verify_result:,
+                                                      double_address_verification:)
+        if applicant_pii[:same_address_as_id] == 'true' && double_address_verification == true
+          return residential_instant_verify_result
+        end
+        return resolution_cannot_pass unless residential_instant_verify_result.success?
+
         timer.time('resolution') do
           resolution_proofer.proof(applicant_pii)
         end
       end
 
-      def proof_state_id_if_needed(
+      def should_proof_state_id_with_aamva?(double_address_verification:, same_address_as_id:,
+                                            should_proof_state_id:, instant_verify_result:,
+                                            residential_instant_verify_result:)
+        return false unless should_proof_state_id
+        if double_address_verification == false || same_address_as_id == 'true'
+          user_can_pass_after_state_id_check?(instant_verify_result)
+        else
+          residential_instant_verify_result.success?
+        end
+      end
+
+      def proof_id_with_aamva_if_needed(
         applicant_pii:, timer:,
-        resolution_result:,
-        should_proof_state_id:
+        residential_instant_verify_result:,
+        instant_verify_result:,
+        should_proof_state_id:,
+        double_address_verification:
       )
-        unless should_proof_state_id && user_can_pass_after_state_id_check?(resolution_result)
-          return out_of_aamva_jurisdiction_result
-        end
+        same_address_as_id = applicant_pii[:same_address_as_id]
+        should_proof_state_id_with_aamva = should_proof_state_id_with_aamva?(
+          double_address_verification:,
+          same_address_as_id:,
+          should_proof_state_id:,
+          instant_verify_result:,
+          residential_instant_verify_result:,
+        )
+        return out_of_aamva_jurisdiction_result unless should_proof_state_id_with_aamva
 
         timer.time('state_id') do
           state_id_proofer.proof(applicant_pii)

app/services/proofing/resolution/result_adjudicator.rb

@@ -2,20 +2,24 @@ module Proofing
   module Resolution
     class ResultAdjudicator
       attr_reader :resolution_result, :state_id_result, :device_profiling_result,
-                  :double_address_verification
+                  :double_address_verification, :residential_resolution_result, :same_address_as_id
 
       def initialize(
-        resolution_result:,
-        state_id_result:,
+        resolution_result:, # InstantVerify
+        state_id_result:, # AAMVA
+        residential_resolution_result:, # InstantVerify Residential
         should_proof_state_id:,
         double_address_verification:,
-        device_profiling_result:
+        device_profiling_result:,
+        same_address_as_id:
       )
         @resolution_result = resolution_result
         @state_id_result = state_id_result
         @should_proof_state_id = should_proof_state_id
         @double_address_verification = double_address_verification
         @device_profiling_result = device_profiling_result
+        @residential_resolution_result = residential_resolution_result
+        @same_address_as_id = same_address_as_id # this is a string, "true" or "false"
       end
 
       def adjudicated_result
@@ -78,7 +82,10 @@ def device_profiling_result_and_reason
       end
 
       def resolution_result_and_reason
-        if resolution_result.success? && state_id_result.success?
+        if !residential_resolution_result.success? &&
+           same_address_as_id == 'false' && double_address_verification == true
+          [false, :fail_resolution_skip_state_id]
+        elsif resolution_result.success? && state_id_result.success?
           [true, :pass_resolution_and_state_id]
         elsif !state_id_result.success?
           [false, :fail_state_id]

lib/idp/constants.rb

@@ -109,6 +109,16 @@ module Vendors
       identity_doc_city: 'Best City',
       identity_doc_zipcode: '12345',
       identity_doc_address_state: 'VA',
+      same_address_as_id: 'false',
+    ).freeze
+
+    MOCK_IDV_APPLICANT_SAME_ADDRESS_AS_ID = MOCK_IDV_APPLICANT_WITH_SSN.merge(
+      identity_doc_address1: MOCK_IDV_APPLICANT_WITH_SSN[:address1],
+      identity_doc_address2: MOCK_IDV_APPLICANT_WITH_SSN[:address2],
+      identity_doc_city: MOCK_IDV_APPLICANT_WITH_SSN[:city],
+      identity_doc_zipcode: MOCK_IDV_APPLICANT_WITH_SSN[:zipcode],
+      identity_doc_address_state: MOCK_IDV_APPLICANT_WITH_SSN[:state],
+      same_address_as_id: 'true',
     ).freeze
 
     MOCK_IDV_APPLICANT_WITH_PHONE = MOCK_IDV_APPLICANT_WITH_SSN.merge(phone: '12025551212').freeze

spec/jobs/resolution_proofing_job_spec.rb

@@ -300,6 +300,17 @@
     context "when the user's state ID address does not match their residential address" do
       let(:pii) { Idp::Constants::MOCK_IDV_APPLICANT_STATE_ID_ADDRESS }
 
+      let(:residential_address) do
+        {
+          address1: pii[:address1],
+          address2: pii[:address2],
+          city: pii[:city],
+          state: pii[:state],
+          state_id_jurisdiction: pii[:state_id_jurisdiction],
+          zipcode: pii[:zipcode],
+        }
+      end
+
       let(:identity_doc_address) do
         {
           address1: pii[:identity_doc_address1],
@@ -324,11 +335,15 @@
         )
       end
 
-      it 'verifies the state ID address with AAMVA and LexisNexis' do
+      it 'verifies ID address with AAMVA & LexisNexis & residential address with LexisNexis' do
         stub_vendor_requests
 
+        expect_any_instance_of(Proofing::LexisNexis::InstantVerify::Proofer).to receive(:proof).
+          with(hash_including(residential_address)).and_call_original
+
         expect_any_instance_of(Proofing::LexisNexis::InstantVerify::Proofer).to receive(:proof).
           with(hash_including(identity_doc_address)).and_call_original
+
         expect_any_instance_of(Proofing::Aamva::Proofer).to receive(:proof).with(
           hash_including(identity_doc_address),
         ).and_call_original