LG-6668 safeguard failed message

app/services/doc_auth/acuant/responses/get_results_response.rb

@@ -53,13 +53,14 @@ def response_info
         def create_response_info
           alerts = processed_alerts
 
+          log_alert_formatter = DocAuth::ProcessedAlertToLogAlertFormatter.new
           {
             vendor: 'Acuant',
             billed: result_code.billed,
             doc_auth_result: result_code.name,
             processed_alerts: alerts,
             alert_failure_count: alerts[:failed]&.count.to_i,
-            log_alert_results: log_alerts(alerts),
+            log_alert_results: log_alert_formatter.log_alerts(alerts),
             image_metrics: processed_image_metrics,
             tamper_result: tamper_result_code&.name,
           }
@@ -95,19 +96,6 @@ def processed_alerts
           @processed_alerts ||= process_raw_alerts(raw_alerts)
         end
 
-        def log_alerts(alerts)
-          log_alert_results = {}
-          alerts.keys.each do |key|
-            alerts[key.to_sym].each do |alert|
-              side = alert[:side] || 'no_side'
-              log_alert_results[alert[:name].
-                downcase.
-                parameterize(separator: '_').to_sym] = { "#{side}": alert[:result] }
-            end
-          end
-          log_alert_results
-        end
-
         def processed_image_metrics
           @processed_image_metrics ||= raw_images_data.index_by do |image|
             image.delete('Uri')

app/services/doc_auth/lexis_nexis/responses/true_id_response.rb

@@ -122,21 +122,9 @@ def response_info
           @response_info ||= create_response_info
         end
 
-        def log_alerts(alerts)
-          log_alert_results = {}
-          alerts.keys.each do |key|
-            alerts[key.to_sym].each do |alert|
-              side = alert[:side] || 'no_side'
-              log_alert_results[alert[:name].
-                downcase.
-                parameterize(separator: '_').to_sym] = { "#{side}": alert[:result] }
-            end
-          end
-          log_alert_results
-        end
-
         def create_response_info
           alerts = parsed_alerts
+          log_alert_formatter = DocAuth::ProcessedAlertToLogAlertFormatter.new
 
           {
             liveness_enabled: @liveness_checking_enabled,
@@ -146,7 +134,7 @@ def create_response_info
             doc_auth_result: doc_auth_result,
             processed_alerts: alerts,
             alert_failure_count: alerts[:failed]&.count.to_i,
-            log_alert_results: log_alerts(alerts),
+            log_alert_results: log_alert_formatter.log_alerts(alerts),
             portrait_match_results: true_id_product[:PORTRAIT_MATCH_RESULT],
             image_metrics: parse_image_metrics,
           }

app/services/doc_auth/processed_alert_to_log_alert_formatter.rb

@@ -0,0 +1,34 @@
+module DocAuth
+  class ProcessedAlertToLogAlertFormatter
+    def get_alert_result(log_alert_results, side, alert_name_key, result)
+      if log_alert_results.dig(alert_name_key, side.to_sym).present?
+        alert_value = log_alert_results[alert_name_key][side.to_sym]
+        Rails.logger.
+          info("ALERT ALREADY HAS A VALUE: #{alert_value}, #{result}")
+      end
+      result
+    end
+
+    def log_alerts(alerts)
+      log_alert_results = {}
+
+      alerts.keys.each do |key|
+        alerts[key.to_sym].each do |alert|
+          alert_name_key = alert[:name].
+            downcase.
+            parameterize(separator: '_').to_sym
+          side = alert[:side] || 'no_side'
+
+          log_alert_results[alert_name_key] =
+            { "#{side}": get_alert_result(
+              log_alert_results,
+              side,
+              alert_name_key,
+              alert[:result],
+            ) }
+        end
+      end
+      log_alert_results
+    end
+  end
+end

spec/services/doc_auth/acuant/responses/get_results_response_spec.rb

@@ -162,6 +162,40 @@
       expect(response.result_code.billed?).to eq(false)
     end
 
+    context 'when visiual_pattern passes and fails' do
+      let(:http_response) do
+        [1, 2].each do |index|
+          parsed_response_body['Alerts'] << {
+            Key: 'Visible Pattern',
+            Name: 'Visible Pattern',
+            RegionReferences: [],
+            Result: index,
+          }
+        end
+
+        instance_double(
+          Faraday::Response,
+          body: parsed_response_body.to_json,
+        )
+      end
+
+      it 'returns log_alert_results for visible_pattern with multiple results comma separated' do
+        expect(response.to_h[:processed_alerts]).to eq(
+          passed: [{ name: 'Visible Pattern', result: 'Passed' }],
+          failed:
+            [{ name: 'Document Classification',
+               result: 'Failed' },
+             { name: 'Visible Pattern',
+               result: 'Failed' }],
+        )
+
+        expect(response.to_h[:log_alert_results]).to eq(
+          { visible_pattern: { no_side: 'Failed' },
+            document_classification: { no_side: 'Failed' } },
+        )
+      end
+    end
+
     context 'when with an acuant error message' do
       let(:http_response) do
         parsed_response_body['Alerts'].first['Disposition'] = 'This message does not have a key'

spec/services/doc_auth/lexis_nexis/responses/true_id_response_spec.rb

@@ -102,7 +102,7 @@
         transaction_reason_code: 'trueid_pass',
         product_status: 'pass',
         doc_auth_result: 'Passed',
-        processed_alerts: a_hash_including(:passed, :failed),
+        processed_alerts: a_hash_including(:failed),
         alert_failure_count: a_kind_of(Numeric),
         portrait_match_results: nil,
         image_metrics: a_hash_including(:front, :back),
@@ -185,6 +185,12 @@
       expect(errors[:hints]).to eq(true)
     end
 
+    it 'returns Failed for visible_pattern when it gets passed and failed value ' do
+      output = described_class.new(failure_response_no_liveness, false, config).to_h
+      expect(output.to_h[:log_alert_results]).
+        to match(a_hash_including(visible_pattern: { no_side: 'Failed' }))
+    end
+
     it 'produces appropriate errors with liveness' do
       output = described_class.new(failure_response_with_liveness, true, config).to_h
       errors = output[:errors]

spec/services/doc_auth/processed_alert_to_log_alert_formatter_spec.rb

@@ -0,0 +1,37 @@
+# Take the proccessed alerts and reformat them in a hash so that its easier to search and collect
+# stats through cloudwatch.
+
+require 'rails_helper'
+
+RSpec.describe DocAuth::ProcessedAlertToLogAlertFormatter do
+  let(:alerts) do
+    { passed: [{ alert: 'Alert_1', name: 'Visible Pattern', result: 'Passed' }],
+      failed:
+       [
+         { alert: 'Alert_1', name: '2D Barcode Read', result: 'Failed' },
+         { alert: 'Alert_2', name: 'Layout Valid', result: 'Attention' },
+         { alert: 'Alert_3', name: '2D Barcode Read', result: 'Failed' },
+         { alert: 'Alert_4', name: 'Visible Pattern', result: 'Failed' },
+         { alert: 'Alert_5', name: 'Visible Photo Characteristics', result: 'Failed' },
+       ] }
+  end
+
+  context('when ProcessedAlertToLogAlertFormatter is called') do
+    subject {
+      DocAuth::ProcessedAlertToLogAlertFormatter.new.log_alerts(alerts)
+    }
+
+    it('returns failed if both passed and failed are returned by the alert') do
+      expect(subject).to match(a_hash_including(visible_pattern: { no_side: 'Failed' }))
+    end
+
+    it('returns the formatted log hash') do
+      expect(subject).to eq(
+        { '2d_barcode_read': { no_side: 'Failed' },
+          layout_valid: { no_side: 'Attention' },
+          visible_pattern: { no_side: 'Failed' },
+          visible_photo_characteristics: { no_side: 'Failed' } },
+      )
+    end
+  end
+end