davinci_pdex_test_kit 0.11.0 → 0.12.0

data/lib/davinci_pdex_test_kit/pdex_payer_server/provenance/provenance_must_support_test.rb

@@ -0,0 +1,51 @@
+require 'us_core_test_kit/must_support_test'
+require 'us_core_test_kit/generator/group_metadata'
+
+module DaVinciPDexTestKit
+  module PDexPayerServer
+    class ProvenanceMustSupportTest < Inferno::Test
+      include USCoreTestKit::MustSupportTest
+
+      title 'All must support elements are provided in the Provenance resources returned'
+      description %(
+        PDex Responders SHALL be capable of populating all data elements as
+        part of the query results as specified by the PDex Server Capability
+        Statement. This test will look through the Provenance resources
+        found previously for the following must support elements:
+
+        * Provenance.agent
+        * Provenance.agent.onBehalfOf
+        * Provenance.agent.type
+        * Provenance.agent.who
+        * Provenance.agent:ProvenanceAuthor
+        * Provenance.agent:ProvenanceAuthor.type
+        * Provenance.agent:ProvenanceAuthor.who
+        * Provenance.agent:ProvenanceTransmitter
+        * Provenance.agent:ProvenanceTransmitter.type
+        * Provenance.agent:ProvenanceTransmitter.who
+        * Provenance.entity.extension:sourceFormat
+        * Provenance.recorded
+        * Provenance.target
+      )
+
+      id :pdex_provenance_must_support
+
+      def resource_type
+        'Provenance'
+      end
+
+      def self.metadata
+        @metadata ||= USCoreTestKit::Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'),
+                                                                                 aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:provenance_resources] ||= {}
+      end
+
+      run do
+        perform_must_support_test(all_scratch_resources)
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_server/provenance/provenance_read_test.rb

@@ -0,0 +1,26 @@
+require 'us_core_test_kit/read_test'
+
+module DaVinciPDexTestKit
+  module PDexPayerServer
+    class ProvenanceReadTest < Inferno::Test
+      include USCoreTestKit::ReadTest
+
+      title 'Server returns correct Provenance resource from Provenance read interaction'
+      description 'A server SHALL support the Provenance read interaction.'
+
+      id :pdex_provenance_read
+
+      def resource_type
+        'Provenance'
+      end
+
+      def scratch_resources
+        scratch[:provenance_resources] ||= {}
+      end
+
+      run do
+        perform_read_test(all_scratch_resources)
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_server/provenance/provenance_reference_resolution_test.rb

@@ -0,0 +1,46 @@
+require 'us_core_test_kit/reference_resolution_test'
+require 'us_core_test_kit/generator/group_metadata'
+
+module DaVinciPDexTestKit
+  module PDexPayerServer
+    class ProvenanceReferenceResolutionTest < Inferno::Test
+      include USCoreTestKit::ReferenceResolutionTest
+
+      title 'MustSupport references within Provenance resources are valid'
+      description %(
+        This test will attempt to read external references provided within elements
+        marked as 'MustSupport', if any are available.
+
+        It verifies that at least one external reference for each MustSupport Reference element
+        can be accessed by the test client, and conforms to corresponding PDex profile.
+
+        Elements which may provide external references include:
+
+        * Provenance.agent.onBehalfOf
+        * Provenance.agent.who
+        * Provenance.agent:ProvenanceAuthor.who
+        * Provenance.agent:ProvenanceTransmitter.who
+        * Provenance.target
+      )
+
+      id :pdex_provenance_ref_resolution
+
+      def resource_type
+        'Provenance'
+      end
+
+      def self.metadata
+        @metadata ||= USCoreTestKit::Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'),
+                                                                                 aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:provenance_resources] ||= {}
+      end
+
+      run do
+        perform_reference_resolution_test(scratch_resources[:all])
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_server/provenance/provenance_validation_test.rb

@@ -0,0 +1,39 @@
+require 'us_core_test_kit/validation_test'
+
+module DaVinciPDexTestKit
+  module PDexPayerServer
+    class ProvenanceValidationTest < Inferno::Test
+      include USCoreTestKit::ValidationTest
+
+      id :pdex_provenance_validation
+      title 'Provenance resources returned during previous tests conform to the PDex Provenance'
+      description %(
+        This test verifies resources returned from the first search conform to
+        the [PDex Provenance](http://hl7.org/fhir/us/davinci-pdex/StructureDefinition/pdex-provenance).
+        Systems must demonstrate at least one valid example in order to pass this test.
+
+        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.
+      )
+      output :dar_code_found, :dar_extension_found
+
+      def resource_type
+        'Provenance'
+      end
+
+      def scratch_resources
+        scratch[:provenance_resources] ||= {}
+      end
+
+      run do
+        perform_validation_test(scratch_resources[:all] || [],
+                                'http://hl7.org/fhir/us/davinci-pdex/StructureDefinition/pdex-provenance',
+                                '2.0.0',
+                                skip_if_empty: true)
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_server/provenance_group.rb

@@ -0,0 +1,59 @@
+require_relative 'provenance/provenance_read_test'
+require_relative 'provenance/provenance_validation_test'
+require_relative 'provenance/provenance_must_support_test'
+require_relative 'provenance/provenance_reference_resolution_test'
+
+module DaVinciPDexTestKit
+  module PDexPayerServer
+    class ProvenanceGroup < Inferno::TestGroup
+      title 'PDex Provenance Tests'
+      short_description 'Verify support for the server capabilities required by the PDex Provenance.'
+      description %(
+        # Background
+
+        The PDex Provenance sequence verifies that the system under test is
+        able to provide correct responses for Provenance queries. These queries
+        must contain resources conforming to the PDex Provenance as
+        specified in the PDex v2.0.0 Implementation Guide.
+
+        # Testing Methodology
+
+
+        ## Must Support
+        Each profile contains elements marked as "must support". This test
+        sequence expects to see each of these elements at least once. If at
+        least one cannot be found, the test will fail. The test will look
+        through the Provenance resources found in the first test for these
+        elements.
+
+        ## Profile Validation
+        Each resource returned from the first search is expected to conform to
+        the [PDex Provenance](http://hl7.org/fhir/us/davinci-pdex/StructureDefinition/pdex-provenance). Each element is checked against
+        teminology binding and cardinality requirements.
+
+        Elements with a required binding are validated against their bound
+        ValueSet. If the code/system in the element is not part of the ValueSet,
+        then the test will fail.
+
+        ## Reference Validation
+        At least one instance of each external reference in elements marked as
+        "must support" within the resources provided by the system must resolve.
+        The test will attempt to read each reference found and will fail if no
+        read succeeds.
+      )
+
+      id :pdex_provenance
+      run_as_group
+
+      def self.metadata
+        @metadata ||= USCoreTestKit::Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'provenance', 'metadata.yml'),
+                                                                                 aliases: true))
+      end
+
+      test from: :pdex_provenance_read
+      test from: :pdex_provenance_validation
+      test from: :pdex_provenance_must_support
+      test from: :pdex_provenance_ref_resolution
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_server/workflow_clinical_data_group.rb

@@ -18,25 +18,37 @@ module DaVinciPDexTestKit
         for this test. If neither is available tests are skipped.
       }
 
+      verifies_requirements 'hl7.fhir.us.davinci-pdex_2.0.0@42'
+
       input :patient_id,
-        title: 'Patient ID',
-        description: 'Manual Patient ID for testing Clinical Query and $everything without $member-match.',
-        optional: true
+            title: 'Patient ID',
+            description: 'Manual Patient ID for testing Clinical Query and $everything without $member-match.',
+            optional: true
+
+      input :smart_auth_info,
+            title: 'OAuth Credentials',
+            type: :auth_info,
+            optional: true
+
+      fhir_client do
+        url :url
+        auth_info :smart_auth_info
+      end
 
       test do
         id :pdex_workflow_clinical_encounter_query_test
         title 'Server can provide clinical Encounter data from matched member identifier'
-        description %{
+        description %(
           Server receives request `GET [baseURL]/Encounter?subject=Patient/[id]` and returns 200.
-        }
+        )
 
         makes_request :pdex_clinical_query
 
         run do
           skip_if !patient_id,
-            'No Patient FHIR ID was derived from $member-match response or supplied by user input'
+                  'No Patient FHIR ID was derived from $member-match response or supplied by user input'
 
-          fhir_search(FHIR::Encounter, params: {patient: "Patient/#{patient_id}"}, name: :pdex_clinical_query)
+          fhir_search(FHIR::Encounter, params: { patient: "Patient/#{patient_id}" }, name: :pdex_clinical_query)
           assert_response_status(200)
         end
       end
@@ -44,9 +56,9 @@ module DaVinciPDexTestKit
       test do
         id :pdex_workflow_clinical_encounter_test
         title 'Server returned Search bundle with valid Encounter data'
-        description %{
+        description %(
             Server returned search Bundle of Encounters with least 1 resource entry.
-        }
+        )
 
         uses_request :pdex_clinical_query
 
@@ -54,11 +66,10 @@ module DaVinciPDexTestKit
           assert_valid_resource
           assert_resource_type('Bundle')
           assert resource.entry.length > 0, 'Response Bundle must have at least one entry'
-          assert resource.entry.map{|entry| entry.resource}.all? { |res| res.resourceType == 'Encounter' },
+          assert resource.entry.map { |entry| entry.resource }.all? { |res| res.resourceType == 'Encounter' },
                  'Response Bundle must only have Encounter resources'
         end
       end
     end
   end
 end
-

data/lib/davinci_pdex_test_kit/pdex_payer_server/workflow_everything_group.rb

@@ -19,11 +19,22 @@ module DaVinciPDexTestKit
         This test sequence takes a patient id input and executes the `$everything` FHIR operation on it.
       }
 
+      verifies_requirements 'hl7.fhir.us.davinci-pdex_2.0.0@42'
 
       input :patient_id,
-        title: 'Patient ID',
-        description: 'Manual Patient ID for testing Clinical Query and $everything $export without $member-match.',
-        optional: true
+            title: 'Patient ID',
+            description: 'Manual Patient ID for testing Clinical Query and $everything $export without $member-match.',
+            optional: true
+
+      input :smart_auth_info,
+            title: 'OAuth Credentials',
+            type: :auth_info,
+            optional: true
+
+      fhir_client do
+        url :url
+        auth_info :smart_auth_info
+      end
 
       test from: :pdex_patient_operation_in_cap_stmt_validation,
            title: 'Server declares support for Patient everything operation in CapabilityStatement',
@@ -34,11 +45,13 @@ module DaVinciPDexTestKit
       test do
         title 'Server can handle GET /Patient/[ID]/$everything'
 
+        verifies_requirements 'hl7.fhir.us.davinci-pdex_2.0.0@46'
+
         makes_request :pdex_patient_everything
 
         run do
           skip_if !patient_id,
-            "No Patient FHIR ID was derived from $member-match response or supplied by user input"
+                  'No Patient FHIR ID was derived from $member-match response or supplied by user input'
 
           fhir_operation("/Patient/#{patient_id}/$everything", operation_method: :get, name: :pdex_patient_everything)
 
@@ -55,7 +68,7 @@ module DaVinciPDexTestKit
 
         run do
           skip_if !patient_id
-            'No Patient ID was derived from $member-match nor supplied from user input'
+          'No Patient ID was derived from $member-match nor supplied from user input'
           skip_if response[:status] != 200, 'Skipped because previous test did not pass'
 
           assert_valid_resource
@@ -69,7 +82,7 @@ module DaVinciPDexTestKit
         end
       end
 
-      # TODO: convert to attestation    
+      # TODO: convert to attestation
       # test do
       #   title %{
       #     The resources returned SHALL include all the data covered by the meaningful use common data elements as

data/lib/davinci_pdex_test_kit/pdex_payer_server/workflow_export_group.rb

@@ -1,5 +1,4 @@
 require 'bulk_data_test_kit/v2.0.0/bulk_data_patient_export_test_group'
-# require 'bulk_data_test_kit/v1.0.1/patient/bulk_data_patient_export_group'
 require_relative 'export_patient_group'
 require_relative 'export_validation_group'
 
@@ -25,33 +24,41 @@ module DaVinciTestKit
         to be returned by Patient-level export. The tests require a Bulk Data Autthorization Bearer Token.
       }
 
-      config({
-        inputs: {
-          url: { name: :bulk_server_url },
-          # bulk_server_url: { name: :url },
-          bulk_export_url: { default: 'Patient/$export' },
-          bearer_token: { description: 'The authorization bearer token for $export access that is scoped to the same patient found by $member-match or entered as patient id. This is not necessarily the same OAuth token that allows access to the server\'s $member-match. If omitted $export tests will be skipped.' }
+      config(
+        {
+          inputs: {
+            url: { name: :bulk_server_url },
+            bulk_export_url: { default: 'Patient/$export' },
+            smart_auth_info: {
+              name: :bulk_auth_info,
+              title: 'Bulk Data Authorization',
+              description: "The authorization information for $export access that is scoped to the same patient found by $member-match or entered as patient id. This is not necessarily the same authorization information that allows access to the server's $member-match.",
+              options: {
+                mode: 'access'
+              },
+              optional: true
+            }
+          }
         }
-      })
+      )
 
       input :url # inherit properties from test suite
 
-      input :bearer_token # inherit properties from parent
-
       input :patient_id,
-        title: 'Patient ID',
-        description: 'Manual Patient ID for testing Clinical Query, $everything, and $export without $member-match.',
-        optional: true
+            title: 'Patient ID',
+            description: 'Manual Patient ID for testing Clinical Query, $everything, and $export without $member-match.',
+            optional: true
 
       # Required by Bulk Data tests
       fhir_client :bulk_server do
         url :url
-        bearer_token :bearer_token
+        # auth_info :bulk_auth_info # FIXME to respect config, workaround below:
+        headers { 'Authorization' => "Bearer #{bulk_auth_info.access_token}" }
       end
 
       http_client :bulk_server do
         url :url
-        headers {'Authorization' => "Bearer #{bearer_token}"}
+        headers { 'Authorization' => "Bearer #{bulk_auth_info.access_token}" }
       end
 
       group from: :pdex_patient_export
@@ -59,7 +66,6 @@ module DaVinciTestKit
       group from: :pdex_export_validation,
             title: 'Patient Export Validation Tests',
             optional: true
-
     end
   end
 end

data/lib/davinci_pdex_test_kit/pdex_payer_server/workflow_member_match_group.rb

@@ -19,11 +19,11 @@ module DaVinciPDexTestKit
         [required by the PDex Implementation Guide](https://hl7.org/fhir/us/davinci-pdex/STU2/payertopayerexchange.html#member-match-with-consent).
 
         # Testing Methodology
-        
+
         The developer must supply JSON FHIR input parameter conforming to the
         [member match request profile](https://hl7.org/fhir/us/davinci-hrex/STU1/StructureDefinition-hrex-parameters-member-match-in.html). This
         test sequence will:
-        
+
         1. Request the server's capability statement and verify that it asserts support for the $member-match operation
         2. Validate user's member match request input
            + validate Parameters profile conformance
@@ -32,15 +32,25 @@ module DaVinciPDexTestKit
            + optional: validate minimal data on CoverageToLink parameter
         3. POST request to server and validate HTTP 200 response status
         4. validate memeber match response conforms to profile
-        5. use member identifier from response to query for patient id 
+        5. use member identifier from response to query for patient id
       }
 
       run_as_group
 
       input :member_match_request,
-        title: 'Member Match Request for one match',
-        description: "A JSON payload for server's $member-match endpoint that has **exactly one match**",
-        type: 'textarea'
+            title: 'Member Match Request for one match',
+            description: "A JSON payload for server's $member-match endpoint that has **exactly one match**",
+            type: 'textarea'
+
+      input :smart_auth_info,
+            title: 'OAuth Credentials',
+            type: :auth_info,
+            optional: true
+
+      fhir_client do
+        url :url
+        auth_info :smart_auth_info
+      end
 
       test from: :pdex_patient_operation_in_cap_stmt_validation,
            id: :pdex_member_match_operation_in_cap_stmt,
@@ -67,22 +77,22 @@ module DaVinciPDexTestKit
 
       test from: :pdex_coverage_to_link_minimal_validation
       test from: :pdex_coverage_to_link_ms_validation
-   
+
       test do
         id :pdex_member_match_on_server
         title 'Server handles $member-match operation successfully'
         description 'Server receives request `POST [baseURL]/Patient/$member-match` and returns 200'
-           
+
         input :member_match_request
-   
+
         makes_request :member_match
-   
+
         run do
           fhir_operation('/Patient/$member-match', body: FHIR.from_contents(member_match_request), name: :member_match)
           assert_response_status(200)
         end
       end
-  
+
       test do
         id :pdex_member_match_response_profile
         title 'Server $member-match response conforms to profile'
@@ -92,7 +102,7 @@ module DaVinciPDexTestKit
         }
 
         output :member_identifier
-        output :member_identifier_system  
+        output :member_identifier_system
 
         uses_request :member_match
 
@@ -102,17 +112,19 @@ module DaVinciPDexTestKit
           assert_resource_type('Parameters')
 
           # We should save the output before validating every detail of the payload
-          output member_identifier: resource.parameter.find{|p| p.name=='MemberIdentifier'}&.valueIdentifier&.value
-          output member_identifier_system: resource.parameter.find{|p| p.name=='MemberIdentifier'}&.valueIdentifier&.system
+          output member_identifier: resource.parameter.find { |p| p.name == 'MemberIdentifier' }&.valueIdentifier&.value
+          output member_identifier_system: resource.parameter.find { |p|
+            p.name == 'MemberIdentifier'
+          }&.valueIdentifier&.system
 
           assert_valid_resource(profile_url: 'http://hl7.org/fhir/us/davinci-hrex/StructureDefinition/hrex-parameters-member-match-out')
         end
       end
-  
+
       test do
         id :pdex_member_match_identifier_to_id
         title 'Server member identifier from $member-match yields logical Patient id'
-        description %Q{
+        description %(
           The $member-match operation returns a Member Identifier, and subsequent clinical queries and operations
           are only required to support logical Patient FHIR ID. Hence server must be able to provide a Patient
           FHIR ID from Member Identifier.
@@ -120,15 +132,17 @@ module DaVinciPDexTestKit
           Server receives request `GET [baseURL]/Patient?identifier=[member_identifier]`
           and returns 200 and a Bundle with a single FHIR Patient. The `[member_identifier]` is from Member Match Response
           `Parameters.parameter:MemberIdentifier.valueIdentifier.value`.
-        }
+        )
+
+        verifies_requirements 'hl7.fhir.us.davinci-pdex_2.0.0@35'
 
         input :member_identifier
         input :member_identifier_system, optional: true
         output :patient_id
 
         run do
-          skip_if !member_identifier, "No member identifier obtained from $member-match request"
- 
+          skip_if !member_identifier, 'No member identifier obtained from $member-match request'
+
           # We only query by identifier.value, and preset information happens to return a value with a system within it
           # which may be a bug.
           # Other options are to query by system|value or type-of:
@@ -139,19 +153,24 @@ module DaVinciPDexTestKit
           assert_valid_json(response[:body])
           assert_resource_type('Bundle')
 
-          assert resource.entry.find{ |entry| entry.resource&.resourceType == 'Patient' }, "Bundle has no Patient resource."
+          assert resource.entry.find { |entry|
+            entry.resource&.resourceType == 'Patient'
+          }, 'Bundle has no Patient resource.'
 
-          patient_id = resource.entry.reverse_each.find{ |entry| entry.resource&.resourceType == 'Patient' }&.resource&.id
-          assert patient_id, "Patient resource in Bundle has no logical resource id"
+          patient_id = resource.entry.reverse_each.find do |entry|
+            entry.resource&.resourceType == 'Patient'
+          end&.resource&.id
+          assert patient_id, 'Patient resource in Bundle has no logical resource id'
 
-          info "Multiple patients found, using the last patient id." if resource.entry.select{ |entry| entry.resource&.resourceType == 'Patient' }.length > 1
+          info 'Multiple patients found, using the last patient id.' if resource.entry.select do |entry|
+            entry.resource&.resourceType == 'Patient'
+          end.length > 1
 
-          output :patient_id => patient_id
+          output patient_id: patient_id
 
           assert_valid_resource
         end
       end
-
     end
   end
 end