davinci_pas_test_kit 0.14.0 → 0.15.0

data/lib/davinci_pas_test_kit/generator/profile_metadata.rb

@@ -0,0 +1,86 @@
+module DaVinciPASTestKit
+  class Generator
+    class ProfileMetadata
+      ATTRIBUTES = %i[
+        name
+        class_name
+        version
+        reformatted_version
+        resource
+        conformance_expectation
+        profile_url
+        profile_name
+        profile_version
+        title
+        short_description
+        interactions
+        operations
+        required_concepts
+        must_supports
+        mandatory_elements
+        bindings
+        references
+        tests
+        id
+        file_name
+        delayed_references
+      ].freeze
+
+      ATTRIBUTES.each { |name| attr_accessor name }
+
+      def initialize(metadata)
+        metadata.each do |key, value|
+          raise "Unknown attribute #{key}" unless ATTRIBUTES.include? key
+
+          instance_variable_set(:"@#{key}", value)
+        end
+      end
+
+      def delayed?
+        !['Patient', 'Claim', 'ClaimResponse'].include?(resource)
+      end
+
+      # A sorted, bulleted markdown list of this profile's must support elements (slices, elements,
+      # extensions, and choices), each line prefixed with `indent` spaces. Shared by the per-profile
+      # must support tests and the collapsed attestation tests so both stay in sync with the metadata.
+      def must_support_list_string(indent: 8)
+        slice_names = must_supports[:slices].map { |slice| slice[:slice_id] }
+        element_names = must_supports[:elements].map { |element| "#{resource}.#{element[:path]}" }
+        extension_names = must_supports[:extensions].map { |extension| extension[:id] }
+
+        must_supports[:choices]&.each do |choice|
+          next unless choice.key?(:paths)
+
+          choice[:paths].each { |path| element_names.delete("#{resource}.#{path}") }
+          choice[:extension_ids].each { |id| extension_names.delete(id.to_s) } if choice[:extension_ids].present?
+
+          element_paths = choice[:paths].map { |path| "#{resource}.#{path}" }.join(' or ')
+          extension_ids = choice[:extension_ids].join(' or ')
+
+          element_names << "#{element_paths} or #{extension_ids}"
+        end
+
+        (slice_names + element_names + extension_names)
+          .uniq
+          .sort
+          .map { |name| "#{' ' * indent}* #{name}" }
+          .join("\n")
+      end
+
+      def add_test(id:, file_name:)
+        self.tests ||= []
+
+        test_metadata = {
+          id:,
+          file_name:
+        }
+
+        tests << test_metadata
+      end
+
+      def to_hash
+        ATTRIBUTES.each_with_object({}) { |key, hash| hash[key] = send(key) unless send(key).nil? }
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generator/{group_metadata_extractor.rb → profile_metadata_extractor.rb}

@@ -1,11 +1,11 @@
-require_relative 'group_metadata'
+require_relative 'profile_metadata'
 require_relative 'ig_metadata'
 require_relative 'terminology_binding_metadata_extractor'
-require 'inferno/dsl/must_support_metadata_extractor'
+require_relative 'pas_must_support_metadata_extractor'
 
 module DaVinciPASTestKit
   class Generator
-    class GroupMetadataExtractor
+    class ProfileMetadataExtractor
       attr_accessor :resource_capabilities, :profile_url, :ig_metadata, :ig_resources
 
       def initialize(resource_capabilities, profile_url, ig_metadata, ig_resources)
@@ -15,13 +15,13 @@ module DaVinciPASTestKit
         self.ig_resources = ig_resources
       end
 
-      def group_metadata
-        @group_metadata ||=
-          GroupMetadata.new(group_metadata_hash)
+      def profile_metadata
+        @profile_metadata ||=
+          ProfileMetadata.new(profile_metadata_hash)
       end
 
-      def group_metadata_hash
-        @group_metadata_hash ||=
+      def profile_metadata_hash
+        @profile_metadata_hash ||=
           {
             name:,
             class_name:,
@@ -36,10 +36,6 @@ module DaVinciPASTestKit
             short_description:,
             interactions:,
             operations:,
-            # searches:,
-            # search_definitions:,
-            # include_params:,
-            # revincludes:,
             required_concepts:,
             must_supports:,
             mandatory_elements:,
@@ -47,51 +43,9 @@ module DaVinciPASTestKit
             references:
           }
 
-        # mark_mandatory_and_must_support_searches
-
-        @group_metadata_hash
+        @profile_metadata_hash
       end
 
-      # def mark_mandatory_and_must_support_searches
-      #   searches.each do |search|
-      #     search[:names_not_must_support_or_mandatory] = search[:names].reject do |name|
-      #       full_paths = search_definitions[name.to_sym][:full_paths]
-      #       any_must_support_elements = must_supports[:elements].any? do |element|
-      #         full_must_support_paths = ["#{resource}.#{element[:original_path]}", "#{resource}.#{element[:path]}"]
-
-      #         full_paths.any? do |path|
-      #           # allow for non-choice, choice types, and _id
-      #           name == '_id' ||
-      #                   full_must_support_paths.include?(path) ||
-      #                   full_must_support_paths.include?("#{path}[x]")
-      #         end
-      #       end
-
-      #       any_must_support_slices = must_supports[:slices].any? do |slice|
-      #         # only handle type slices because that is all we need for now
-      #         # for a slice like Observation.effective[x]:effectiveDateTime, the search parameter's expression could
-      #         # be either Observation.effective or Observation.effectiveDateTime.
-      #         if slice[:discriminator] && slice[:discriminator][:type] == 'type'
-      #           full_must_support_path = "#{resource}.#{slice[:path].sub('[x]', slice[:discriminator][:code])}"
-      #           base_must_support_path = "#{resource}.#{slice[:path].sub('[x]', '')}"
-
-      #           full_paths.intersection([full_must_support_path, base_must_support_path]).present?
-      #         else
-      #           false
-      #         end
-      #       end
-
-      #       any_mandatory_elements = mandatory_elements.any? do |element|
-      #         full_paths.include?(element)
-      #       end
-
-      #       any_must_support_elements || any_must_support_slices || any_mandatory_elements
-      #     end
-
-      #     search[:must_support_or_mandatory] = search[:names_not_must_support_or_mandatory].empty?
-      #   end
-      # end
-
       def profile
         @profile ||= ig_resources.profile_by_url(profile_url)
       end
@@ -144,7 +98,6 @@ module DaVinciPASTestKit
       end
 
       def title
-        puts profile.title
         profile.title.gsub(/PAS\s*/, '').gsub(/\s*Profile/, '').strip
       end
 
@@ -174,27 +127,6 @@ module DaVinciPASTestKit
           end
       end
 
-      # def search_metadata_extractor
-      #   @search_metadata_extractor ||=
-      #     SearchMetadataExtractor.new(resource_capabilities, ig_resources, resource, profile_elements)
-      # end
-
-      # def searches
-      #   @searches ||= search_metadata_extractor.searches
-      # end
-
-      # def search_definitions
-      #   @search_definitions ||= search_metadata_extractor.search_definitions
-      # end
-
-      # def include_params
-      #   resource_capabilities.searchInclude || []
-      # end
-
-      # def revincludes
-      #   resource_capabilities.searchRevInclude || []
-      # end
-
       def required_concepts
         return [] if resource == 'Observation'
 
@@ -216,10 +148,11 @@ module DaVinciPASTestKit
 
       def must_support_metadata_extractor
         @must_support_metadata_extractor ||=
-          Inferno::DSL::MustSupportMetadataExtractor.new(profile_elements, profile, resource, ig_resources)
+          PASMustSupportMetadataExtractor.new(profile_elements, profile, resource, ig_resources)
       end
 
       def must_supports
+        # binding.pry if profile_url == 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-claim-inquiry'
         @must_supports ||=
           must_support_metadata_extractor.must_supports
       end

data/lib/davinci_pas_test_kit/generator/server_must_support_group_generator.rb

@@ -0,0 +1,166 @@
+require_relative 'descriptions'
+
+module DaVinciPASTestKit
+  class Generator
+    class ServerMustSupportGroupGenerator
+      class << self
+        def generate(ig_metadata, base_server_output_dir)
+          new(ig_metadata, base_server_output_dir).generate
+        end
+      end
+
+      attr_accessor :ig_metadata, :base_output_dir
+
+      def initialize(ig_metadata, base_output_dir)
+        self.ig_metadata = ig_metadata
+        self.base_output_dir = base_output_dir
+      end
+
+      def template
+        @template ||= File.read(File.join(__dir__, 'templates', 'server_must_support_group.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 class_name
+        'PASServerMustSupportGroup'
+      end
+
+      def module_name
+        "DaVinciPAS#{ig_version_for_id.upcase}"
+      end
+
+      def title
+        'Demonstrate Element Support'
+      end
+
+      def output_file_name
+        File.join(base_output_dir, base_output_file_name)
+      end
+
+      def profile_identifier(profile_metadata)
+        ig_metadata.snake_case_for_profile(profile_metadata)
+      end
+
+      def group_id
+        "pas_server_#{ig_version_for_id}_must_support"
+      end
+
+      def ig_version
+        ig_metadata.ig_version
+      end
+
+      def ig_version_for_id
+        ig_metadata.reformatted_version
+      end
+
+      def generate
+        FileUtils.mkdir_p(base_output_dir)
+        File.write(output_file_name, output)
+        ig_metadata.add_use_case_groups(group_id, base_output_file_name)
+      end
+
+      def test_id_for_profile(profile_metadata, operation, type)
+        "pas_server_#{ig_version_for_id}_#{operation}_#{type}_" \
+          "must_support_#{profile_identifier_for_profile(profile_metadata)}"
+      end
+
+      def test_file_for_profile(profile_metadata, operation, type)
+        profile_id = profile_identifier_for_profile(profile_metadata)
+        File.join(profile_id, "server_#{operation}_#{type}_must_support_#{profile_id}_test")
+      end
+
+      def profile_identifier_for_profile(profile_metadata)
+        ig_metadata.snake_case_for_profile(profile_metadata)
+      end
+
+      def profile_test_ids(operation, type)
+        profiles_for(operation, type).map { |profile_metadata| test_id_for_profile(profile_metadata, operation, type) }
+      end
+
+      def profile_test_files(operation, type)
+        profiles_for(operation, type).map do |profile_metadata|
+          test_file_for_profile(profile_metadata, operation, type)
+        end
+      end
+
+      def profiles_for(operation, type)
+        ig_metadata.profiles.select do |profile|
+          case "#{operation}_#{type}"
+          when 'submit_request'
+            MustSupportTargetProfiles.submit_request_profile?(profile) &&
+              !MustSupportTargetProfiles.request_profile?(profile)
+          when 'submit_response'
+            MustSupportTargetProfiles.submit_response_profile?(profile)
+          when 'inquire_request'
+            MustSupportTargetProfiles.inquire_request_profile?(profile)
+          when 'inquire_response'
+            MustSupportTargetProfiles.inquire_response_profile?(profile)
+          end
+        end
+      end
+
+      def request_profiles
+        ig_metadata.profiles.select { |profile_metadata| MustSupportTargetProfiles.request_profile?(profile_metadata) }
+      end
+
+      def verifies_requirements
+        case ig_metadata.ig_version
+        when 'v2.0.1'
+          ['hl7.fhir.us.davinci-pas_2.0.1@33']
+        end
+      end
+
+      def verifies_must_support_requirements(operation, type)
+        case "#{operation}_#{type}_#{ig_metadata.ig_version}"
+        when 'submit_request_v2.0.1'
+          ['hl7.fhir.us.davinci-pas_2.0.1@35']
+        when 'inquire_request_v2.0.1'
+          ['hl7.fhir.us.davinci-pas_2.0.1@36']
+        end
+      end
+
+      def description
+        <<~DESCRIPTION
+          Demonstrate the ability of the server to support all PAS-defined profiles
+          and the must support elements defined in them. This includes
+
+          - the ability to respond to prior authorization submission and inquiry
+            requests that contain all PAS-defined profiles and their must support
+            elements.
+          - the ability to include in those responses all PAS-defined profiles
+            and their must support elements.
+
+          In order to allow Inferno to observe and validate these criteria, testers
+          are required to provide a set of `$submit` and `$inquire` requests that
+          collectively both themselves contain and elicit server responses that contain
+          all PAS-defined profiles and their must support elements.
+        DESCRIPTION
+      end
+
+      def subgroup_description(operation)
+        <<~DESCRIPTION
+          Check that the provided `$#{operation}` requests both themselves contain
+          and elicit server responses that contain all PAS-defined profiles
+          and their must support elements.
+
+          For `$#{operation}` requests, this includes the following profiles:
+
+          #{Descriptions.profile_links_list(profiles_for(operation, 'request'), ig_version, request_profiles: operation == 'submit' ? request_profiles : nil)}
+
+          For `$#{operation}` responses, this includes the following profiles (NOTE: request-specific
+          profiles that may be echoed from `$#{operation}` requests, such as the Claim instance or request instances,
+          are not currently checked):
+
+          #{Descriptions.profile_links_list(profiles_for(operation, 'response'), ig_version)}
+        DESCRIPTION
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generator/{suite_generator.rb → server_suite_generator.rb}

@@ -1,8 +1,6 @@
-require_relative 'naming'
-
 module DaVinciPASTestKit
   class Generator
-    class SuiteGenerator
+    class ServerSuiteGenerator
       class << self
         def generate(ig_metadata, base_output_dir)
           new(ig_metadata, base_output_dir).generate
@@ -17,7 +15,7 @@ module DaVinciPASTestKit
       end
 
       def template
-        @template ||= File.read(File.join(__dir__, 'templates', 'suite.rb.erb'))
+        @template ||= File.read(File.join(__dir__, 'templates', 'server_suite.rb.erb'))
       end
 
       def output
@@ -53,10 +51,18 @@ module DaVinciPASTestKit
         "hl7.fhir.us.davinci-pas##{version}"
       end
 
+      def validator_igs_expression
+        identifiers = [ig_identifier]
+        identifiers << 'hl7.fhir.us.core#6.1.0' if ig_metadata.ig_version.start_with?('v2.2')
+        identifiers.map(&:inspect).join(', ')
+      end
+
       def ig_link
         case ig_metadata.ig_version
         when 'v2.0.1'
           'https://hl7.org/fhir/us/davinci-pas/STU2/'
+        when 'v2.2.1'
+          'https://hl7.org/fhir/us/davinci-pas/2.2.1/'
         else
           'https://hl7.org/fhir/us/davinci-pas/history.html'
         end
@@ -82,13 +88,34 @@ module DaVinciPASTestKit
       end
 
       def error_group_file_name
-        "../../custom_groups/#{ig_metadata.ig_version}/pas_error_group"
+        "../../#{ig_metadata.ig_version}/pas_error_group"
       end
 
       def error_group_id
         "pas_#{ig_metadata.reformatted_version}_error_group"
       end
 
+      # Claim Updates is a v2.2.x feature (it relies on the PAS Claim Update profile), so it is only
+      # wired into the v2.2+ server suites.
+      def claim_updates_group?
+        ig_metadata.ig_version.start_with?('v2.2')
+      end
+
+      def claim_updates_group_file_name
+        "../../#{ig_metadata.ig_version}/pas_server_claim_updates_group"
+      end
+
+      def claim_updates_group_id
+        "pas_server_#{ig_metadata.reformatted_version}_claim_updates"
+      end
+
+      # The PAS requirement set renamed its server-side actor from "Server" (v2.0.1) to "PAS Payer"
+      # (v2.2.1). The actor must match the requirement source exactly or `verifies_requirements`
+      # annotations will not resolve.
+      def pas_requirement_set_actor
+        ig_metadata.ig_version.start_with?('v2.2') ? 'PAS Payer' : 'Server'
+      end
+
       def must_support_group_id
         @must_support_group_id ||= groups.map { |group| group[:id] }
           .reject { |id| id.include?('client') }

data/lib/davinci_pas_test_kit/generator/templates/client_must_support_group.rb.erb

@@ -0,0 +1,80 @@
+<%- if optional_must_support_enabled? -%>
+require_relative '../../<%= ig_version %>/must_support/must_support_with_attestation_option'
+<%- claim_profiles.each do |profile_metadata| -%>
+require_relative '<%= test_file_for_profile(profile_metadata) %>'
+<%- end -%>
+<%- else -%>
+<%- if operation == 'submit' -%>
+require_relative '../../<%= ig_version %>/must_support/pas_client_must_support_request_profiles_test'
+<%- end -%>
+<%- profile_test_files.each do |file_name| -%>
+require_relative '<%= file_name %>'
+<%- end -%>
+<%- end -%>
+
+module DaVinciPASTestKit
+  module <%= module_name %>
+    class <%= class_name %> < Inferno::TestGroup
+      id :<%= group_id %>
+      title '<%= title %>'
+      description %(
+        <%=description.gsub("\n", "\n" + " "*8) %>
+      )
+      run_as_group
+      
+<%- if optional_must_support_enabled? -%>
+<%- if operation == 'submit' -%>
+      # At least one of the PAS request profiles must be present; unobserved must support
+      # elements on the request profiles that are present may be attested as not collected.
+      test from: :pas_client_<%= ig_version_for_id %>_must_support_with_attestation_option do
+        id :pas_client_<%= ig_version_for_id %>_submit_request_profiles_must_support_with_attestation_option
+        title 'At least one instance of a request profile (PAS Medication Request, PAS Service Request, PAS Device Request, or PAS Nutrition Order) is observed with all of its must support elements'
+        config(
+          options: {
+            require_one_of: true,
+            profiles: [
+<%= attestation_profiles_block(request_profiles) %>
+            ],
+            ig_version: '<%= ig_version %>',
+            type: 'request',
+            operation: '<%= operation %>'
+          }
+        )
+        description MustSupportWithAttestationOption.build_description(config.options)
+      end
+
+<%- end -%>
+<%- claim_profiles.each do |profile_metadata| -%>
+      # Mandatory - the <%= profile_metadata.profile_name %> profile must always be demonstrated.
+      test from: :<%= test_id_for_profile(profile_metadata) %>
+
+<%- end -%>
+      # All other <%= operation %> request profiles - unobserved must support elements may be
+      # attested as not collected by the client system.
+      test from: :pas_client_<%= ig_version_for_id %>_must_support_with_attestation_option do
+        id :pas_client_<%= ig_version_for_id %>_<%= operation %>_request_other_must_support_with_attestation_option
+        title '<%= other_profiles_title %>'
+        config(
+          options: {
+            require_one_of: false,
+            profiles: [
+<%= attestation_profiles_block(other_profiles) %>
+            ],
+            ig_version: '<%= ig_version %>',
+            type: 'request',
+            operation: '<%= operation %>'
+          }
+        )
+        description MustSupportWithAttestationOption.build_description(config.options)
+      end
+<%- else -%>
+      <%- if operation == 'submit' -%>
+      test from: :pas_client_<%= ig_version_for_id %>_must_support_request_profiles
+      <%- end -%>
+      <%- profile_test_ids.each do |id| -%>
+      test from: :<%= id %>
+      <%- end -%>
+<%- end -%>
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generator/templates/client_must_support_response_group.rb.erb

@@ -0,0 +1,43 @@
+<%- profile_test_files.each do |file_name| -%>
+require_relative '<%= file_name %>'
+<%- end -%>
+require_relative '../../<%= ig_version %>/workflows/pas_client_response_attest'
+
+module DaVinciPASTestKit
+  module <%= module_name %>
+    class <%= class_name %> < Inferno::TestGroup
+      id :<%= group_id %>
+      title '<%= title %>'
+      description %(
+        <%= description.gsub("\n", "\n" + " "*8) %>
+      )
+      run_as_group
+
+      <%- profile_tests.each do |profile_test| -%>
+      <%- if profile_test[:optional] -%>
+      test from: :<%= profile_test[:id] %> do
+        optional
+      end
+      <%- else -%>
+      test from: :<%= profile_test[:id] %> do
+        verifies_requirements 'hl7.fhir.us.davinci-pas_2.2.1@conf-7'
+      end
+      <%- end -%>
+      <%- end -%>
+      test from: :pas_client_<%= ig_version_for_id %>_response_attest,
+           title: 'PAS client handled the $<%= operation %> response must support elements',
+           description: %(
+             This test provides the tester an opportunity to verify that their client
+             correctly processed and used the must support elements present in the
+             $<%= operation %> responses received from Inferno during these tests.
+           ),
+           config: { options: {
+             workflow_tag: MUST_SUPPORT_WORKFLOW_TAG,
+             attest_message: "I attest that the client system correctly processed the must support elements " \
+                             "contained in the $<%= operation %> responses received from Inferno and did not error."
+           } } do
+        verifies_requirements 'hl7.fhir.us.davinci-pas_2.2.1@conf-8'
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generator/templates/must_support.rb.erb

@@ -1,13 +1,10 @@
-require_relative '../../../must_support_test'
-require_relative '../../../generator/group_metadata'
-require_relative '../../../tags'
+require_relative '../../../../cross_suite/must_support/must_support_test'
 
 module DaVinciPASTestKit
   module <%= module_name %>
-    class <%= class_name %> < Inferno::Test
-      include DaVinciPASTestKit::MustSupportTest
-
-      title 'All must support elements for Profile <%= profile_name %> are observed across all instances <%= request_type.include?('request') ? 'submitted' : 'returned' %>'
+    class <%= class_name %> < DaVinciPASTestKit::MustSupportTest
+      id :<%= test_id %>
+      title 'All must support elements for profile <%= profile_name %> are observed on $<%= operation %> <%= request_type.include?('request') ? 'requests' : 'responses' %>'
       description %(
         <% if system == 'client' && request_type.include?('request') %>
         PAS client systems are required to be able to populate all
@@ -43,34 +40,16 @@ module DaVinciPASTestKit
       verifies_requirements <%= verifies_requirements.map { |r| "'#{r}'" }.join(', ') %>
       <%- end -%>
 
-      id :<%= test_id %>
-
-      def resource_type
-        '<%= resource_type %>'
-      end
-
-      def user_input_validation
-        <% if system == 'server' && request_type.include?('request') %>true<% else %>false<% end %>
-      end
-
-      def self.metadata
-        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
-      end
-
-      def scratch_resources
-        # The scratch key in MS test should be the same as the scratch key in the validation test for a given profile.
-        scratch[:<%= request_type %>_resources] ||= {}
-      end
-
-      def resources_of_interest
-        collection = tagged_resources(<%= request_type.include?('submit') ? 'SUBMIT_TAG' : 'INQUIRE_TAG' %>).presence || <%= resource_collection_string %>
-        collection.select { |res| res.resourceType == resource_type }
-      end
-
-      run do
-        perform_must_support_test(resources_of_interest)
-        validate_must_support(user_input_validation)
-      end
+      config(
+        options: {
+          resource_type: '<%= resource_type %>',
+          profile_key: '<%= profile_identifier %>',
+          user_input_validation: <% if (system == 'server' && request_type.include?('request')) || (system == 'client' && request_type.include?('response')) %>true<% else %>false<% end %>,
+          ig_version: '<%= profile_metadata.version %>',
+          type: '<%= type %>',
+          operation: '<%= operation %>'
+        }
+      )
     end
   end
 end