Simplify error handling in imms api

Jira-Issue: MAV-1477

Author: misaka

app/lib/nhs/immunisations_api.rb

@@ -1,43 +1,35 @@
 # frozen_string_literal: true
 
 module NHS::ImmunisationsAPI
-  class PatientNotFound < StandardError
-  end
-
   class << self
     def record_immunisation(vaccination_record)
       NHS::API.connection.post(
         "/immunisation-fhir-api/FHIR/R4/Immunization",
         vaccination_record.fhir_record.to_json,
         "Content-Type" => "application/fhir+json"
       )
-    rescue Faraday::Error => e
-      info = extract_error_info(e.response[:body])
-      Rails.logger.error(
-        "Error recording vaccination record (#{vaccination_record.id}):" \
-          " [#{info[:code]}] #{info[:diagnostics]}"
-      )
-      raise e
+    rescue Faraday::ClientError => e
+      if (diagnostics = extract_error_diagnostics(e&.response)).present?
+        raise "Error syncing vaccination #{vaccination_record.id} record to" \
+                " Immunisations API: #{diagnostics}"
+      else
+        raise
+      end
     end
 
-    def extract_error_info(response_body)
-      return { code: nil, diagnostics: "No response body" } unless response_body
-
-      response = JSON.parse(response_body, symbolize_names: true)
+    private
 
-      if response.empty?
-        { code: nil, diagnostics: "No response body" }
-      elsif response[:issue].blank?
-        { code: nil, diagnostics: "No issues in response" }
-      elsif response[:issue].first[:severity] != "error"
-        { code: nil, diagnostics: "Issue is not an error" }
-      else
-        diagnostics = response[:issue].first[:diagnostics]
-        if diagnostics.match?(/NHS Number: \d{10} is invalid.*/)
-          diagnostics.replace("NHS Number is invalid or it doesn't exist")
-        end
+    def extract_error_diagnostics(response)
+      return nil if response.nil? || response[:body].blank?
 
-        { code: response[:issue].first[:code], diagnostics: diagnostics }
+      begin
+        JSON.parse(response[:body], symbolize_names: true).dig(
+          :issue,
+          0,
+          :diagnostics
+        )
+      rescue JSON::ParserError
+        nil
       end
     end
   end

spec/lib/nhs/immunisations_api_spec.rb

@@ -75,113 +75,66 @@
     end
 
     context "an error is returned by the api" do
-      let(:response) do
-        { issue: [{ severity: "error", code:, diagnostics: }] }.to_json
-      end
-
-      before do
-        stub_request(
-          :post,
-          "https://sandbox.api.service.nhs.uk/immunisation-fhir-api/FHIR/R4/Immunization"
-        ).to_return(status: 400, body: response, headers: {})
-
-        allow(Rails.logger).to receive(:error).and_return(true)
-      end
+      context "4XX error" do
+        let(:response) do
+          {
+            resourceType: "OperationOutcome",
+            id: "bc2c3c82-4392-4314-9d6b-a7345f82d923",
+            meta: {
+              profile: [
+                "https://simplifier.net/guide/UKCoreDevelopment2/ProfileUKCore-OperationOutcome"
+              ]
+            },
+            issue: [
+              {
+                severity: "error",
+                code: "invalid",
+                details: {
+                  coding: [
+                    {
+                      system: "https://fhir.nhs.uk/Codesystem/http-error-codes",
+                      code: "NOT-FOUND"
+                    }
+                  ]
+                },
+                diagnostics: "Invalid patient ID"
+              }
+            ]
+          }.to_json
+        end
 
-      context "generic error" do
-        let(:code) { "invalid" }
-        let(:diagnostics) { "Invalid patient ID" }
+        before do
+          stub_request(
+            :post,
+            "https://sandbox.api.service.nhs.uk/immunisation-fhir-api/FHIR/R4/Immunization"
+          ).to_return(status: 404, body: response, headers: {})
+        end
 
-        it "raises an error with the correct message" do
-          begin
+        it "raises an error with the diagnostic message" do
+          expect {
             described_class.record_immunisation(vaccination_record)
-          rescue StandardError
-            nil
-          end
-
-          expect(Rails.logger).to have_received(:error).with(
-            /\[invalid\] Invalid patient ID/
+          }.to raise_error(
+            StandardError,
+            "Error syncing vaccination #{vaccination_record.id} record to" \
+              " Immunisations API: Invalid patient ID"
           )
         end
       end
 
-      context "the error is invalid NHS number" do
-        let(:code) { "exception" }
-        let(:diagnostics) do
-          "NHS Number: 1234567890 is invalid or it doesn't exist"
+      context "generic error" do
+        before do
+          stub_request(
+            :post,
+            "https://sandbox.api.service.nhs.uk/immunisation-fhir-api/FHIR/R4/Immunization"
+          ).to_return(status: 500, body: nil, headers: {})
         end
 
-        it "raises an error with the correct message" do
-          begin
+        it "raises an error with the diagnostic message" do
+          expect {
             described_class.record_immunisation(vaccination_record)
-          rescue StandardError
-            nil
-          end
-
-          expect(Rails.logger).to have_received(:error).with(
-            /\[exception\] NHS Number is invalid or it doesn't exist/
-          )
+          }.to raise_error(Faraday::Error)
         end
       end
     end
   end
-
-  describe "extract_error_info" do
-    subject(:error_info) { described_class.extract_error_info(response) }
-
-    context "response body has an error" do
-      let(:response) do
-        {
-          issue: [
-            {
-              severity: "error",
-              code: "invalid",
-              diagnostics: "Invalid patient ID"
-            }
-          ]
-        }.to_json
-      end
-
-      its([:code]) { should eq "invalid" }
-      its([:diagnostics]) { should eq "Invalid patient ID" }
-    end
-
-    context "when the response body is empty" do
-      let(:response) { nil }
-
-      its([:code]) { should be_nil }
-      its([:diagnostics]) { should eq "No response body" }
-    end
-
-    context "when the response body has no issue attribute" do
-      let(:response) { "{}" }
-
-      its([:code]) { should be_nil }
-      its([:diagnostics]) { should eq "No response body" }
-    end
-
-    context "when the response body has no issues" do
-      let(:response) { '{"issues": [] }' }
-
-      its([:code]) { should be_nil }
-      its([:diagnostics]) { should eq "No issues in response" }
-    end
-
-    context "the issue severity is not 'error'" do
-      let(:response) do
-        {
-          issue: [
-            {
-              severity: "warning",
-              code: "not-found",
-              diagnostics: "Patient not found"
-            }
-          ]
-        }.to_json
-      end
-
-      its([:code]) { should be_nil }
-      its([:diagnostics]) { should eq "Issue is not an error" }
-    end
-  end
 end