inferno_core 0.4.20 → 0.4.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccd619a77a04e3fa092d9b2090a1bc1f53b8d0e34027b8cfd3dd0c03a8212d04
-  data.tar.gz: 20191611704b5e4dffac41bf0fa528a38ba79b1d86052b43c20853646af2d9fe
+  metadata.gz: 13f75c775423384dd5bf4a2b13081bc05a155155fca9a6bcea1986d2baf09b15
+  data.tar.gz: 7b6c586b121fad54caa57fb5ae8d8c7300467b543ece25c4222c21cc65ac83c7
 SHA512:
-  metadata.gz: 6fa722f33598020a4ec742729e66148aaa61b652b2f08d07cf79be1f17f6a8120e467432818fb39383d4fbe50a8f902e5384dc93c30cddb654fd53abbadab40e
-  data.tar.gz: 6a2740906607fda7a0dba543b9255a8fb4c0e296288bad0d5044d40dd20347d7e797177b708715328e778c05766600f2dc728244a3863f69521d340cae011b26
+  metadata.gz: 7f0ab91414e4554a430972dd25543339cd39245c0d154dcc42d0a623c83b4aeaccf32709d08074abd4dcae07cf3deb75144a2db3cd3af548a37ddc552b0df909
+  data.tar.gz: 2f328c92cb3d66853eccde4aee267be6e8e668b778f75e1d278a3b5d4ba86840e4f0e260fbc5bf941017ee8bde1cd20699a53153cd9e26ee8e9bee8fa730ab7c

data/lib/inferno/dsl/fhir_client.rb

@@ -60,26 +60,64 @@ module Inferno
         @fhir_clients ||= {}
       end
 
+      # Wrapper for checking if parameter contents are primitive
+      #
+      # @param param [FHIR::Parameters::Parameter] Parameter to be checked
+      # @private
+      def primitive_parameter?(param)
+        param_val = param.to_hash.except('name')
+        param_val.any? { |datatype, param_value| FHIR.primitive?(datatype: datatype[5..], value: param_value) }
+      end
+
+      # Converts a list of FHIR Parameters into a query string for GET requests
+      #
+      # @param body [FHIR::Parameters] Must all be primitive if making GET request
+      # @private
+      def body_to_path(body)
+        query_hashes = body.parameter.map do |param|
+          if primitive_parameter?(param)
+            { param.name => param.to_hash.except('name').values[0] }
+          else
+            Inferno::Application[:logger].error "Cannot use GET request with non-primitive datatype #{param.name}"
+            raise ArgumentError, "Cannot use GET request with non-primitive datatype #{param.name}"
+          end
+        end
+        query_hashes.map(&:to_query).join('&')
+      end
+
       # Perform a FHIR operation
       #
       # @note This is a placeholder method until the FHIR::Client supports
-      #   general operations
+      #   general operations.  Note that while both POST and GET methods are allowed,
+      #   GET is only allowed when the operation does not affect the server's state.
+      #   See https://build.fhir.org/operationdefinition-definitions.html#OperationDefinition.affectsState
+      #
+      # @note Currently does not allow for repeated parameters if using GET
       #
       # @param path [String]
-      # @param body [FHIR::Parameters]
+      # @param body [FHIR::Parameters] Must all be primitive if making GET request
       # @param client [Symbol]
       # @param name [Symbol] Name for this request to allow it to be used by
       #   other tests
       # @param headers [Hash] custom headers for this operation
+      # @param operation_method [Symbol] indicates which request type to use for the operation
       # @return [Inferno::Entities::Request]
-      def fhir_operation(path, body: nil, client: :default, name: nil, headers: {})
+      def fhir_operation(path, body: nil, client: :default, name: nil, headers: {}, operation_method: :post)
         store_request_and_refresh_token(fhir_client(client), name) do
           tcp_exception_handler do
             operation_headers = fhir_client(client).fhir_headers
             operation_headers.merge!('Content-Type' => 'application/fhir+json') if body.present?
             operation_headers.merge!(headers) if headers.present?
-
-            fhir_client(client).send(:post, path, body, operation_headers)
+            case operation_method
+            when :post
+              fhir_client(client).send(:post, path, body, operation_headers)
+            when :get
+              path = "#{path}?#{body_to_path(body)}" if body.present?
+              fhir_client(client).send(:get, path, operation_headers)
+            else
+              Inferno::Application[:logger].error "Cannot perform #{operation_method} requests, use GET or POST"
+              raise ArgumentError, "Cannot perform #{operation_method} requests, use GET or POST"
+            end
           end
         end
       end

data/lib/inferno/dsl/fhir_validation.rb

@@ -116,17 +116,34 @@ module Inferno
         def resource_is_valid?(resource, profile_url, runnable)
           profile_url ||= FHIR::Definitions.resource_definition(resource.resourceType).url
 
-          outcome = FHIR::OperationOutcome.new(JSON.parse(validate(resource, profile_url)))
+          begin
+            response = call_validator(resource, profile_url)
+          rescue StandardError => e
+            # This could be a complete failure to connect (validator isn't running)
+            # or a timeout (validator took too long to respond).
+            runnable.add_message('error', e.message)
+            raise Inferno::Exceptions::ErrorInValidatorException, "Unable to connect to validator at #{url}."
+          end
+          outcome = operation_outcome_from_validator_response(response.body, runnable)
 
-          message_hashes = outcome.issue&.map { |issue| message_hash_from_issue(issue, resource) } || []
+          message_hashes = message_hashes_from_outcome(outcome, resource, profile_url)
 
-          message_hashes.concat(additional_validation_messages(resource, profile_url))
+          message_hashes
+            .each { |message_hash| runnable.add_message(message_hash[:type], message_hash[:message]) }
 
-          filter_messages(message_hashes)
+          unless response.status == 200
+            raise Inferno::Exceptions::ErrorInValidatorException,
+                  'Error occurred in the validator. Review Messages tab or validator service logs for more information.'
+          end
 
           message_hashes
-            .each { |message_hash| runnable.add_message(message_hash[:type], message_hash[:message]) }
             .none? { |message_hash| message_hash[:type] == 'error' }
+        rescue Inferno::Exceptions::ErrorInValidatorException
+          raise
+        rescue StandardError => e
+          runnable.add_message('error', e.message)
+          raise Inferno::Exceptions::ErrorInValidatorException,
+                'Error occurred in the validator. Review Messages tab or validator service logs for more information.'
         end
 
         # @private
@@ -134,6 +151,17 @@ module Inferno
           message_hashes.reject! { |message| exclude_message.call(Entities::Message.new(message)) } if exclude_message
         end
 
+        # @private
+        def message_hashes_from_outcome(outcome, resource, profile_url)
+          message_hashes = outcome.issue&.map { |issue| message_hash_from_issue(issue, resource) } || []
+
+          message_hashes.concat(additional_validation_messages(resource, profile_url))
+
+          filter_messages(message_hashes)
+
+          message_hashes
+        end
+
         # @private
         def message_hash_from_issue(issue, resource)
           {
@@ -173,10 +201,27 @@ module Inferno
         # @param profile_url [String]
         # @return [String] the body of the validation response
         def validate(resource, profile_url)
+          call_validator(resource, profile_url).body
+        end
+
+        # @private
+        def call_validator(resource, profile_url)
           Faraday.new(
             url,
             params: { profile: profile_url }
-          ).post('validate', resource.source_contents).body
+          ).post('validate', resource.source_contents)
+        end
+
+        # @private
+        def operation_outcome_from_validator_response(response, runnable)
+          if response.start_with? '{'
+            FHIR::OperationOutcome.new(JSON.parse(response))
+          else
+            runnable.add_message('error', "Validator Response:\n#{response}")
+            raise Inferno::Exceptions::ErrorInValidatorException,
+                  'Validator response was an unexpected format. '\
+                  'Review Messages tab or validator service logs for more information.'
+          end
         end
       end
 

data/lib/inferno/exceptions.rb

@@ -39,6 +39,19 @@ module Inferno
       end
     end
 
+    # ErrorInValidatorException is used when an exception occurred in
+    # calling the validator service, for example a connection timeout
+    # or an unexpected response format.
+    # Note: This class extends TestResultException instead of RuntimeError
+    # to bypass printing the stack trace in the UI, since
+    # the stack trace of this exception is not likely be useful.
+    # Instead the message should point to where in the validator an error occurred.
+    class ErrorInValidatorException < TestResultException
+      def result
+        'error'
+      end
+    end
+
     class ParentNotLoadedException < RuntimeError
       def initialize(klass, id)
         super("No #{klass.name.demodulize} found with id '#{id}'")