davinci_pas_test_kit 0.14.1 → 0.15.0

data/lib/davinci_pas_test_kit/generator/validation_test_generator.rb

@@ -1,172 +0,0 @@
-require 'pry'
-require_relative 'naming'
-
-module DaVinciPASTestKit
-  class Generator
-    class ValidationTestGenerator
-      class << self
-        def generate(ig_metadata, base_output_dir)
-          ig_metadata.bundle_groups.each do |group|
-            new(group, base_output_dir:).generate
-          end
-        end
-      end
-
-      attr_accessor :group_metadata, :medication_request_metadata, :base_output_dir, :workflow
-
-      def initialize(group_metadata, workflow = nil, medication_request_metadata = nil, base_output_dir:)
-        self.group_metadata = group_metadata
-        self.workflow = workflow
-        self.medication_request_metadata = medication_request_metadata
-        self.base_output_dir = base_output_dir
-      end
-
-      def template
-        @template ||= File.read(File.join(__dir__, 'templates', 'validation.rb.erb'))
-      end
-
-      def output
-        @output ||= ERB.new(template, trim_mode: '-').result(binding)
-      end
-
-      def base_output_file_name
-        "#{class_name.underscore}.rb"
-      end
-
-      def output_file_directory
-        File.join(base_output_dir, directory_name)
-      end
-
-      def output_file_name
-        File.join(output_file_directory, base_output_file_name)
-      end
-
-      def directory_name
-        Naming.snake_case_for_profile(medication_request_metadata || group_metadata)
-      end
-
-      def profile_identifier
-        Naming.snake_case_for_profile(group_metadata)
-      end
-
-      def profile_url
-        group_metadata.profile_url
-      end
-
-      def profile_name
-        group_metadata.profile_name
-      end
-
-      def profile_version
-        group_metadata.profile_version
-      end
-
-      def formatted_workflow
-        workflow.to_s.split('_').first.to_s
-      end
-
-      def test_id
-        pref = "pas_server_#{group_metadata.reformatted_version}_#{formatted_workflow}".delete_suffix('_')
-        "#{pref}_#{profile_identifier}_validation_test"
-      end
-
-      def class_name
-        pref = "Server#{formatted_workflow.camelize}"
-        "#{pref}#{Naming.upper_camel_case_for_profile(group_metadata)}ValidationTest"
-      end
-
-      def module_name
-        "DaVinciPAS#{group_metadata.reformatted_version.upcase}"
-      end
-
-      def resource_type
-        group_metadata.resource
-      end
-
-      def conformance_expectation
-        read_interaction[:expectation]
-      end
-
-      def skip_if_empty
-        # Return true if a system must demonstrate at least one example of the resource type.
-        # This drives omit vs. skip result statuses in this test.
-        resource_type != 'Medication'
-      end
-
-      def request_type
-        Naming.request_type_for_bundle_or_claim[profile_name]
-      end
-
-      def generate
-        FileUtils.mkdir_p(output_file_directory)
-        File.write(output_file_name, output)
-
-        test_metadata = {
-          id: test_id,
-          file_name: base_output_file_name
-        }
-        group_metadata.add_test(**test_metadata)
-      end
-
-      def title
-        pref = user_input? ? '[USER INPUT VALIDATION] ' : ''
-        "#{pref}#{group_metadata.title} is valid"
-      end
-
-      def user_input?
-        request_type.include?('request')
-      end
-
-      def verifies_requirements
-        case test_id
-        when 'pas_server_v201_pas_inquiry_response_bundle_validation_test'
-          ['hl7.fhir.us.davinci-pas_2.0.1@131']
-        when 'pas_server_v201_pas_response_bundle_validation_test'
-          ['hl7.fhir.us.davinci-pas_2.0.1@64', 'hl7.fhir.us.davinci-pas_2.0.1@100',
-           'hl7.fhir.us.davinci-pas_2.0.1@101', 'hl7.fhir.us.davinci-pas_2.0.1@102',
-           'hl7.fhir.us.davinci-pas_2.0.1@103', 'hl7.fhir.us.davinci-pas_2.0.1@107']
-        end
-      end
-
-      def description
-        <<~DESCRIPTION
-          #{description_user_input_validation if user_input?}
-
-          This test validates the conformity of the
-          #{request_type.include?('request') ? 'user input' : "server's response"} to the
-          [#{profile_name}](#{profile_url})#{' '}
-          structure#{request_type.include?('request') ? ', ensuring subsequent tests can accurately simulate content.' : '.'}
-
-          It also checks that other conformance requirements defined in the [PAS Formal
-          Specification](https://hl7.org/fhir/us/davinci-pas/STU2/specification.html),
-          such as the presence of all referenced instances within the bundle and the
-          conformance of those instances to the appropriate profiles, are met.
-
-          It verifies the presence of mandatory elements and that elements with
-          required bindings contain appropriate values. CodeableConcept element
-          bindings will fail if none of their codings have a code/system belonging
-          to the bound ValueSet. Quantity, Coding, and code element bindings will
-          fail if their code/system are not found in the valueset.
-
-          Note that because X12 value sets are not public, elements bound to value
-          sets containing X12 codes are not validated.
-
-          **Limitations**
-
-          Due to recognized errors in the PAS IG around extension context definitions,
-          this test may not pass due to spurious errors of the form "The extension
-          [extension url] is not allowed at this point". See [this
-          issue](https://github.com/inferno-framework/davinci-pas-test-kit/issues/11)
-          for additional details.
-        DESCRIPTION
-      end
-
-      def description_user_input_validation
-        <<~USER_INPUT_INTRO
-          **USER INPUT VALIDATION**: This test validates input provided by the user instead of the system under test.
-          Errors encountered will be treated as a skip instead of a failure.
-        USER_INPUT_INTRO
-      end
-    end
-  end
-end

data/lib/davinci_pas_test_kit/generator/value_extractor.rb

@@ -1,51 +0,0 @@
-module DaVinciPASTestKit
-  class Generator
-    class ValueExactor
-      attr_accessor :ig_resources, :resource
-
-      def initialize(ig_resources, resource)
-        self.ig_resources = ig_resources
-        self.resource = resource
-      end
-
-      def value_set_binding(the_element)
-        the_element&.binding
-      end
-
-      def value_set(the_element)
-        ig_resources.value_set_by_url(value_set_binding(the_element)&.valueSet)
-      end
-
-      def bound_systems(the_element)
-        vs = value_set(the_element)
-        return unless vs.present?
-
-        vs.compose&.include&.reject { |code| code.concept.nil? }
-      end
-
-      def values_from_value_set_binding(the_element)
-        bound_systems = bound_systems(the_element)
-
-        return [] if bound_systems.blank?
-
-        bound_systems.flat_map { |system| system.concept.map(&:code) }.uniq
-      end
-
-      def fhir_metadata(current_path)
-        FHIR.const_get(resource)::METADATA[current_path]
-      end
-
-      def values_from_resource_metadata(paths)
-        values = []
-
-        paths.each do |current_path|
-          current_metadata = fhir_metadata(current_path)
-
-          values += current_metadata['valid_codes'].values.flatten if current_metadata&.dig('valid_codes').present?
-        end
-
-        values
-      end
-    end
-  end
-end

data/lib/davinci_pas_test_kit/must_support_test.rb

@@ -1,71 +0,0 @@
-require_relative 'fhir_resource_navigation'
-
-module DaVinciPASTestKit
-  module MustSupportTest
-    extend Forwardable
-    include FHIRResourceNavigation
-
-    def_delegators 'self.class', :metadata
-
-    def all_scratch_resources
-      scratch_resources[:all] ||= []
-    end
-
-    def reset_variables
-      @missing_elements = @missing_slices = @missing_extensions = nil
-    end
-
-    def tagged_resources(tag)
-      resources = []
-      load_tagged_requests(tag)
-      return resources if requests.empty?
-
-      requests.each do |req|
-        begin
-          bundle = FHIR.from_contents(req.request_body)
-        rescue StandardError
-          next
-        end
-
-        next unless bundle.is_a?(FHIR::Bundle)
-
-        resources << bundle
-        entry_resources = bundle.entry.map(&:resource)
-        resources.concat(entry_resources)
-      end
-
-      resources
-    end
-
-    def all_must_support_errors
-      @all_must_support_errors ||= []
-    end
-
-    def validate_must_support(user_input_validation)
-      if user_input_validation
-        skip_if !all_must_support_errors.empty?, all_must_support_errors.join("\n")
-      else
-        assert all_must_support_errors.empty?, all_must_support_errors.join("\n")
-      end
-    end
-
-    def perform_must_support_test(resources)
-      assert resources.present?, "No #{resource_type} resources were found"
-
-      missing_must_support_strings = missing_must_support_elements(resources, nil, metadata:)
-
-      return unless missing_must_support_strings.any?
-
-      all_must_support_errors << "Could not find #{missing_must_support_strings.join(', ')} " \
-                                 "in the #{resources.length} provided #{resource_type} resource(s)."
-
-      all_must_support_errors.reject! { |err| err.downcase.include?('x12') }
-      reset_variables
-
-      # pass if (missing_elements + missing_slices + missing_extensions).empty?
-
-      # assert false, "Could not find #{missing_must_support_strings.join(', ')} in the #{resources.length} " \
-      #               "provided #{resource_type} resource(s)"
-    end
-  end
-end

data/lib/davinci_pas_test_kit/pas_subscription_verification.rb

@@ -1,30 +0,0 @@
-module DaVinciPASTestKit
-  module PASSubscriptionVerification
-    def verify_pas_subscription(subscription_json_str)
-      assert_valid_json(subscription_json_str)
-      subscription = JSON.parse(subscription_json_str)
-
-      unless subscription['criteria'] == 'http://hl7.org/fhir/us/davinci-pas/SubscriptionTopic/PASSubscriptionTopic'
-        add_message('error', %(
-          The Subscription must use the PAS-defined Subscription topic
-          `http://hl7.org/fhir/us/davinci-pas/SubscriptionTopic/PASSubscriptionTopic`
-          in the `Subscription.criteria` element.
-        ))
-      end
-
-      filter_criteria = subscription.dig('_criteria', 'extension')
-        &.select do |ext|
-          ext['url'] == 'http://hl7.org/fhir/uv/subscriptions-backport/StructureDefinition/backport-filter-criteria'
-        end
-      unless filter_criteria&.length == 1
-        add_message('error', %(
-            The Subscription must include a single filter on the submitting organization
-            in the `Subscription.criteria.extension` element.
-          ))
-      end
-
-      assert messages.none? { |msg| msg[:type] == 'error' },
-             'The Subscription does not conform to PAS requirements - see messages for details.'
-    end
-  end
-end

data/lib/davinci_pas_test_kit/tags.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module DaVinciPASTestKit
-  AUTH_TAG = 'pas_auth'
-  SUBMIT_TAG = 'pas_submit'
-  INQUIRE_TAG = 'pas_inquire'
-  APPROVAL_WORKFLOW_TAG = 'pas_approved_workflow'
-  DENIAL_WORKFLOW_TAG = 'pas_denied_workflow'
-  PENDED_WORKFLOW_TAG = 'pas_pended_workflow'
-  NOTIFICATION_TAG = 'subscription_notification'
-  SUBSCRIPTION_CREATE_TAG = 'subscription_create'
-  SUBSCRIPTION_READ_TAG = 'subscription_read'
-  SUBSCRIPTION_STATUS_TAG = 'subscription_status'
-  REST_HOOK_HANDSHAKE_NOTIFICATION_TAG = 'rest_hook_handshake_notification'
-  REST_HOOK_EVENT_NOTIFICATION_TAG = 'rest_hook_event_notification'
-  OTHER_AUTH_TAG = 'other_auth'
-end

data/lib/davinci_pas_test_kit/user_input_response.rb

@@ -1,35 +0,0 @@
-module DaVinciPASTestKit
-  module UserInputResponse
-    def self.included(klass)
-      klass.extend ClassMethods
-    end
-
-    def self.user_inputted_response(configurable, operation, result)
-      config_key = operation == 'submit' ? :submit_respond_with : :inquire_respond_with
-      input_key = configurable.config.options[config_key]
-      return unless input_key.present?
-
-      JSON.parse(result.input_json)&.find { |i| i['name'] == input_key.to_s }&.dig('value')
-    rescue JSON::ParserError
-      nil
-    end
-
-    def user_inputted_response?(input_key)
-      send(input_key).present?
-    end
-
-    def input_title(input_key)
-      config.inputs[input_key]&.title || config.inputs[input_key]&.name
-    end
-
-    module ClassMethods
-      def submit_respond_with(key)
-        config options: { submit_respond_with: key }
-      end
-
-      def inquire_respond_with(key)
-        config options: { inquire_respond_with: key }
-      end
-    end
-  end
-end

data/lib/davinci_pas_test_kit/validation_test.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module DaVinciPASTestKit
-  module ValidationTest
-    DAR_CODE_SYSTEM_URL = 'http://terminology.hl7.org/CodeSystem/data-absent-reason'
-    DAR_EXTENSION_URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason'
-
-    def perform_validation_test(resources,
-                                profile_url,
-                                profile_version,
-                                skip_if_empty: true)
-      skip_if skip_if_empty && resources.blank?,
-              "No #{resource_type} resources conforming to the #{profile_url} profile were returned"
-
-      omit_if resources.blank?,
-              "No #{resource_type} resources provided so the #{profile_url} profile does not apply"
-
-      profile_with_version = "#{profile_url}|#{profile_version}"
-      resources.each do |resource|
-        resource_is_valid?(resource:, profile_url: profile_with_version)
-        check_for_dar(resource)
-      end
-
-      errors_found = messages.any? { |message| message[:type] == 'error' }
-
-      assert !errors_found, "Resource does not conform to the profile #{profile_with_version}"
-    end
-
-    def check_for_dar(resource)
-      unless scratch[:dar_code_found]
-        resource.each_element do |element, _meta, _path|
-          next unless element.is_a?(FHIR::Coding)
-
-          check_for_dar_code(element)
-        end
-      end
-
-      return if scratch[:dar_extension_found]
-
-      check_for_dar_extension(resource)
-    end
-
-    def check_for_dar_code(coding)
-      return unless coding.code == 'unknown' && coding.system == DAR_CODE_SYSTEM_URL
-
-      scratch[:dar_code_found] = true
-      output dar_code_found: 'true'
-    end
-
-    def check_for_dar_extension(resource)
-      return unless resource.source_contents&.include? DAR_EXTENSION_URL
-
-      scratch[:dar_extension_found] = true
-      output dar_extension_found: 'true'
-    end
-  end
-end