inferno_core 0.0.1

data/lib/inferno/dsl.rb

@@ -0,0 +1,35 @@
+require_relative 'dsl/assertions'
+require_relative 'dsl/fhir_client'
+require_relative 'dsl/fhir_manipulation'
+require_relative 'dsl/fhir_validation'
+require_relative 'dsl/http_client'
+require_relative 'dsl/results'
+require_relative 'dsl/runnable'
+
+module Inferno
+  # The DSL for writing tests.
+  module DSL
+    INCLUDABLE_DSL_MODULES = [
+      Assertions,
+      FHIRClient,
+      HTTPClient,
+      Results,
+      FHIRValidation,
+      FHIRManipulation
+    ].freeze
+
+    EXTENDABLE_DSL_MODULES = [
+      Runnable
+    ].freeze
+
+    def self.included(klass)
+      INCLUDABLE_DSL_MODULES.each do |dsl_module|
+        klass.include dsl_module
+      end
+
+      EXTENDABLE_DSL_MODULES.each do |dsl_module|
+        klass.extend dsl_module
+      end
+    end
+  end
+end

data/lib/inferno/dsl/assertions.rb

@@ -0,0 +1,93 @@
+require_relative '../exceptions'
+
+module Inferno
+  module DSL
+    module Assertions
+      def assert(test, message = '')
+        raise Exceptions::AssertionException, message unless test
+      end
+
+      def bad_response_status_message(expected, received)
+        "Bad response status: expected #{Array.wrap(expected).join(', ')}, but received #{received}"
+      end
+
+      def assert_response_status(status, response: self.response)
+        assert Array.wrap(status).include?(response[:status]), bad_response_status_message(status, response[:status])
+      end
+
+      def bad_resource_type_message(expected, received)
+        "Bad resource type received: expected #{expected}, but received #{received}"
+      end
+
+      def assert_resource_type(resource_type, resource: self.resource)
+        resource_type_name = normalize_resource_type(resource_type)
+
+        assert resource&.resourceType == resource_type_name,
+               bad_resource_type_message(resource_type_name, resource&.resourceType)
+      end
+
+      def invalid_resource_message(profile_url)
+        "Resource does not conform to the profile: #{profile_url}"
+      end
+
+      def assert_valid_resource(resource: self.resource, profile_url: nil)
+        assert resource_is_valid?(resource: resource, profile_url: profile_url),
+               invalid_resource_message(profile_url)
+      end
+
+      def assert_valid_bundle_entries(bundle: resource, resource_types: {})
+        assert_resource_type('Bundle', resource: bundle)
+
+        types_to_check = normalize_types_to_check(resource_types)
+
+        invalid_resources =
+          bundle
+            .entry
+            .map(&:resource)
+            .select { |resource| types_to_check.empty? || types_to_check.include?(resource.resourceType) }
+            .reject do |resource|
+              validation_params = { resource: resource }
+              profile = types_to_check[resource.resourceType]
+              validation_params[:profile_url] = profile if profile
+
+              resource_is_valid?(**validation_params)
+            end
+
+        assert invalid_resources.empty?, invalid_bundle_entries_message(invalid_resources)
+      end
+
+      def invalid_bundle_entries_message(invalid_resources)
+        identifier_strings =
+          invalid_resources
+            .map { |resource| "#{resource.resourceType}##{resource.id}" }
+            .join(', ')
+        "The following bundle entries are invalid: #{identifier_strings}"
+      end
+
+      def normalize_resource_type(resource_type)
+        if resource_type.is_a? Class
+          resource_type.name.demodulize
+        else
+          resource_type.to_s.camelize
+        end
+      end
+
+      def normalize_types_to_check(resource_types)
+        case resource_types
+        when Hash
+          resource_types.transform_keys { |type| normalize_resource_type(type) }
+        when String
+          { normalize_resource_type(resource_types) => nil }
+        when Array
+          resource_types.each_with_object({}) { |type, types| types[normalize_resource_type(type)] = nil }
+        end
+      end
+
+      def assert_valid_json(maybe_json_string, message = '')
+        assert JSON.parse(maybe_json_string)
+      rescue JSON::ParserError
+        assert false, "Invalid JSON. #{message}"
+      end
+    end
+  end
+end

data/lib/inferno/dsl/fhir_client.rb

@@ -0,0 +1,152 @@
+require_relative 'request_storage'
+
+module Inferno
+  module DSL
+    # This module contains the FHIR DSL available to test writers.
+    #
+    # @example
+    #   class MyTestGroup < Inferno::TestGroup
+    #     # create a "default" client for a group
+    #     fhir_client do
+    #       url 'https://example.com/fhir'
+    #     end
+    #
+    #     # create a named client for a group
+    #     fhir_client :with_custom_header do
+    #       url 'https://example.com/fhir'
+    #       headers { 'X-my-custom-header': 'ABC123' }
+    #     end
+    #
+    #     test :some_test do
+    #       run do
+    #         # uses the default client
+    #         fhir_read('Patient', 5)
+    #
+    #         # uses a named client
+    #         fhir_read('Patient', 5, client: :with_custom_header)
+    #
+    #         request  # the most recent request
+    #         response # the most recent response
+    #         resource # the resource from the most recent response
+    #         requests # all of the requests which have been made in this test
+    #       end
+    #     end
+    #   end
+    # @see Inferno::FHIRClientBuilder Documentation for the client
+    #   configuration DSL
+    module FHIRClient
+      # @api private
+      def self.included(klass)
+        klass.extend ClassMethods
+        klass.extend Forwardable
+        klass.include RequestStorage
+
+        klass.def_delegators 'self.class', :profile_url, :validator_url
+      end
+
+      # Return a previously defined FHIR client
+      #
+      # @param client [Symbol] the name of the client
+      # @return [FHIR::Client]
+      # @see Inferno::FHIRClientBuilder
+      def fhir_client(client = :default)
+        fhir_clients[client] ||=
+          FHIRClientBuilder.new.build(self, self.class.fhir_client_definitions[client])
+      end
+
+      # @api private
+      def fhir_clients
+        @fhir_clients ||= {}
+      end
+
+      # Perform a FHIR operation
+      #
+      # @note This is a placeholder method until the FHIR::Client supports
+      #   general operations
+      #
+      # @param path [String]
+      # @param body [FHIR::Parameters]
+      # @param client [Symbol]
+      # @param name [Symbol] Name for this request to allow it to be used by
+      #   other tests
+      # @param _options [Hash] TODO
+      # @return [Inferno::Entities::Request]
+      def fhir_operation(path, body: nil, client: :default, name: nil, **_options)
+        store_request('outgoing', name) do
+          headers = fhir_client(client).fhir_headers
+          headers.merge!('Content-Type' => 'application/fhir+json') if body.present?
+          fhir_client(client).send(:post, path, body, headers)
+        end
+      end
+
+      # Fetch the capability statement.
+      #
+      # @param client [Symbol]
+      # @param name [Symbol] Name for this request to allow it to be used by
+      #   other tests
+      # @param _options [Hash] TODO
+      # @return [Inferno::Entities::Request]
+      def fhir_get_capability_statement(client: :default, name: nil, **_options)
+        store_request('outgoing', name) do
+          fhir_client(client).conformance_statement
+          fhir_client(client).reply
+        end
+      end
+
+      # Perform a FHIR read interaction.
+      #
+      # @param resource_type [String, Symbol, Class]
+      # @param id [String]
+      # @param client [Symbol]
+      # @param name [Symbol] Name for this request to allow it to be used by
+      #   other tests
+      # @param _options [Hash] TODO
+      # @return [Inferno::Entities::Request]
+      def fhir_read(resource_type, id, client: :default, name: nil, **_options)
+        store_request('outgoing', name) do
+          fhir_client(client).read(fhir_class_from_resource_type(resource_type), id)
+        end
+      end
+
+      # Perform a FHIR search interaction.
+      #
+      # @param resource_type [String, Symbol, Class]
+      # @param client [Symbol]
+      # @param params [Hash] the search params
+      # @param name [Symbol] Name for this request to allow it to be used by
+      #   other tests
+      # @param _options [Hash] TODO
+      # @return [Inferno::Entities::Request]
+      def fhir_search(resource_type, client: :default, params: {}, name: nil, **_options)
+        store_request('outgoing', name) do
+          fhir_client(client)
+            .search(fhir_class_from_resource_type(resource_type), search: { parameters: params })
+        end
+      end
+
+      # @todo Make this a FHIR class method? Something like
+      #   FHIR.class_for(resource_type)
+      # @api private
+      def fhir_class_from_resource_type(resource_type)
+        FHIR.const_get(resource_type.to_s.camelize)
+      end
+
+      module ClassMethods
+        # @api private
+        def fhir_client_definitions
+          @fhir_client_definitions ||= {}
+        end
+
+        # Define a FHIR client to be used by a Runnable.
+        #
+        # @param name [Symbol] a name used to reference this particular client
+        # @param block a block to configure the client
+        # @see Inferno::FHIRClientBuilder Documentation for the client
+        #   configuration DSL
+        def fhir_client(name = :default, &block)
+          fhir_client_definitions[name] = block
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/fhir_client_builder.rb

@@ -0,0 +1,56 @@
+require 'fhir_client'
+
+module Inferno
+  module DSL
+    # DSL for configuring FHIR clients
+    class FHIRClientBuilder
+      attr_accessor :runnable
+
+      # @api private
+      def build(runnable, block)
+        self.runnable = runnable
+        instance_exec(self, &block)
+
+        FHIR::Client.new(url).tap do |client|
+          client.additional_headers = headers if headers
+          client.default_json
+        end
+      end
+
+      # Define the base FHIR url for a client. A string or symbol can be provided.
+      # A string is interpreted as a url. A symbol is interpreted as the name of
+      # an input to the Runnable.
+      #
+      # @param url [String, Symbol]
+      # @return [void]
+      def url(url = nil)
+        @url ||=
+          if url.is_a? Symbol
+            runnable.send(url)
+          else
+            url
+          end
+      end
+
+      # Define custom headers for a client
+      #
+      # @param headers [Hash]
+      # @return [void]
+      def headers(headers = nil)
+        @headers ||= headers
+      end
+
+      # @api private
+      def method_missing(name, *args, &block)
+        return runnable.call(name, *args, &block) if runnable.respond_to? name
+
+        super
+      end
+
+      # @api private
+      def respond_to_missing?(name)
+        runnable.respond_to?(name) || super
+      end
+    end
+  end
+end

data/lib/inferno/dsl/fhir_manipulation.rb

@@ -0,0 +1,25 @@
+module Inferno
+  module DSL
+    module FHIRManipulation
+      def walk_resource(resource, path = nil, &block)
+        resource.class::METADATA.each do |field_name, meta|
+          local_name = meta.fetch :local_name, field_name
+          values = [resource.instance_variable_get("@#{local_name}")].flatten.compact
+          next if values.empty?
+
+          values.each_with_index do |value, i|
+            child_path = if path.nil?
+                           field_name
+                         elsif meta['max'] > 1
+                           "#{path}.#{field_name}[#{i}]"
+                         else
+                           "#{path}.#{field_name}"
+                         end
+            yield value, meta, child_path
+            walk_resource value, child_path, &block unless FHIR::PRIMITIVES.include? meta['type']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inferno/dsl/fhir_validation.rb

@@ -0,0 +1,111 @@
+module Inferno
+  module DSL
+    module FHIRValidation
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      def resource_is_valid?(resource: self.resource, profile_url: nil, validator: :default)
+        find_validator(validator).resource_is_valid?(resource, profile_url, self)
+      end
+
+      def find_validator(validator_name)
+        self.class.find_validator(validator_name)
+      end
+
+      class Validator
+        def initialize(&block)
+          instance_eval(&block)
+        end
+
+        def default_validator_url
+          ENV.fetch('VALIDATOR_URL')
+        end
+
+        def url(validator_url = nil)
+          @url = validator_url if validator_url
+
+          @url
+        end
+
+        def exclude_message(&block)
+          @exclude_message = block if block_given?
+          @exclude_message
+        end
+
+        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)))
+
+          message_hashes = outcome.issue&.map { |issue| message_hash_from_issue(issue) } || []
+
+          filter_messages(message_hashes)
+
+          message_hashes
+            .each { |message_hash| runnable.add_message(message_hash[:type], message_hash[:message]) }
+            .none? { |message_hash| message_hash[:type] == 'error' }
+        end
+
+        def filter_messages(message_hashes)
+          message_hashes.reject! { |message| exclude_message.call(Entities::Message.new(message)) } if exclude_message
+        end
+
+        def message_hash_from_issue(issue)
+          {
+            type: issue_severity(issue),
+            message: issue_message(issue)
+          }
+        end
+
+        def issue_severity(issue)
+          case issue.severity
+          when 'warning'
+            'warning'
+          when 'information'
+            'info'
+          else
+            'error'
+          end
+        end
+
+        def issue_message(issue)
+          location = if issue.respond_to?(:expression)
+                       issue.expression&.join(', ')
+                     else
+                       issue.location&.join(', ')
+                     end
+
+          "#{location}: #{issue&.details&.text}"
+        end
+
+        def validate(resource, profile_url)
+          RestClient.post(
+            "#{url}/validate",
+            resource.to_json,
+            params: { profile: profile_url }
+          ).body
+        end
+      end
+
+      module ClassMethods
+        # @api private
+        def fhir_validators
+          @fhir_validators ||= {}
+        end
+
+        def validator(name = :default, &block)
+          fhir_validators[name] = Inferno::DSL::FHIRValidation::Validator.new(&block)
+        end
+
+        def find_validator(validator_name)
+          validator = fhir_validators[validator_name] || parent&.find_validator(validator_name)
+
+          raise Exceptions::ValidatorNotFoundException, validator_name if validator.nil?
+
+          validator
+        end
+      end
+    end
+  end
+end