davinci_pdex_test_kit 0.9.1

data/lib/davinci_pdex_test_kit/pdex_payer_client/collection.rb

@@ -0,0 +1,46 @@
+module DaVinciPDexTestKit
+  SET_TO_BE_GATHERED = {AllergyIntolerance: ['pdex-AllergyIntolerance'],
+                        CarePlan: ['pdex-CarePlan'],
+                        CareTeam: ['pdex-CareTeam'],
+                        Condition: ['pdex-Condition'],
+                        Device: ['pdex-Device'],
+                        DiagnosticReport: ['pdex-DiagnosticReport'],
+                        DocumentReference: ['pdex-DocumentReference'],
+                        Encounter: ['pdex-Encounter'],
+                        ExplanationOfBenefit: ['pdex-ExplanationOfBenefit'],
+                        Goal: ['pdex-Goal'],
+                        Immunization: ['pdex-Immunization'],
+                        Location: ['pdex-Location'],
+                        MedicationDispense: ['pdex-MedicationDispense'],
+                        MedicationRequest: ['pdex-MedicationRequest'],
+                        Observation: ['pdex-Observation'],
+                        Organization: ['pdex-Organization'],
+                        Patient: ['999'],
+                        Practitioner: ['pdex-Practitioner'],
+                        PractitionerRole: ['pdex-PractitionerRole'],
+                        Procedure: ['pdex-Procedure']
+                        #TODO: What about Provenance?
+                      }
+
+  SEARCHES_BY_PRIORITY = {AllergyIntolerance: [['patient']],
+                          CarePlan: [['category', 'patient']],
+                          CareTeam: [['patient', 'status']],
+                          Condition: [['category', 'patient'], ['patient']],
+                          Device: [['patient', 'type'], ['patient']],
+                          DiagnosticReport: [['category', 'date', 'patient'], ['code', 'patient'], ['category', 'patient'], ['patient']],
+                          DocumentReference: [['_id'], ['category', 'date', 'patient'], ['patient', 'type'], ['category', 'patient'], ['patient']],
+                          Encounter: [['_id'], ['date', 'patient'], ['patient']],
+                          ExplanationOfBenefit: [['_id'], ['patient'], ['identifier'], ['_lastUpdated'], ['service-date'], ['type']],
+                          Goal: [['patient']],
+                          Immunization: [['patient']],
+                          Location: [['name'], ['address']],
+                          MedicationDispense: [['patient']],
+                          MedicationRequest: [['intent', 'patient']],
+                          Observation: [['category', 'date', 'patient'], ['code', 'patient'], ['category', 'patient']],
+                          Organization: [['name'], ['address']],
+                          Patient: [['_id'], ['identifier'], ['birthdate', 'name'], ['gender', 'name'], ['name']],
+                          Practitioner: [['identifier'], ['name']],
+                          PractitionerRole: [['practitioner'], ['specialty']],
+                          Procedure: [['date', 'patient'], ['patient']],
+                        }
+end

data/lib/davinci_pdex_test_kit/pdex_payer_client_suite.rb

@@ -0,0 +1,152 @@
+require 'inferno/dsl/oauth_credentials'
+require_relative 'ext/inferno_core/record_response_route'
+require_relative 'ext/inferno_core/runnable'
+require_relative 'ext/inferno_core/request'
+require_relative 'urls'
+require_relative 'mock_server'
+require_relative 'tags'
+require_relative 'pdex_payer_client/collection'
+require_relative 'must_support_test'
+require_relative 'pdex_payer_client/client_validation_test'
+
+require_relative 'pdex_payer_client/clinical_data_request_tests/initial_wait_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/initial_scratch_storing'
+require_relative 'pdex_payer_client/clinical_data_request_tests/allergyintolerance_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/careplan_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/careteam_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/condition_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/device_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/diagnosticreport_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/documentreference_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/encounter_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/explanationofbenefit_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/goal_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/immunization_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/location_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/medicationdispense_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/medicationrequest_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/observation_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/organization_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/patient_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/practitioner_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/practitionerrole_clinical_data_request_test'
+require_relative 'pdex_payer_client/clinical_data_request_tests/procedure_clinical_data_request_test'
+
+require_relative 'pdex_payer_client/client_member_match_tests/client_member_match_submit_test'
+require_relative 'pdex_payer_client/client_member_match_tests/client_member_match_validation_test'
+# require_relative 'pdex_payer_client/client_must_support_tests/client_member_match_must_support_submit_test'
+# require_relative 'pdex_payer_client/client_must_support_tests/client_member_match_must_support_validation_test'
+
+
+module DaVinciPDexTestKit
+    class PDexPayerClientSuite < Inferno::TestSuite
+      extend MockServer
+      extend ClientValidationTest
+
+      id :pdex_payer_client
+      title 'Da Vinci PDex Payer Client Test Suite'
+      description File.read(File.join(__dir__, 'docs', 'payer_client_suite_description_v200.md'))
+
+      def self.test_resumes?(test)
+        !test.config.options[:accepts_multiple_requests]
+      end
+      
+      # All FHIR validation requests will use this FHIR validator
+      validator do
+        url ENV.fetch('VALIDATOR_URL')  
+      end
+
+      record_response_route :post, TOKEN_PATH, AUTH_TAG, method(:token_response) do |request|
+        PDexPayerClientSuite.extract_client_id(request)
+      end
+
+      record_response_route :get, PATIENT_PATH, SUBMIT_TAG, method(:claim_response), # Patient needs a specific definition
+                            resumes: method(:test_resumes?) do |request|
+        PDexPayerClientSuite.extract_bearer_token(request)
+      end
+  
+      record_response_route :get, SUBMIT_PATH, SUBMIT_TAG, method(:claim_response),
+                            resumes: method(:test_resumes?) do |request|
+        PDexPayerClientSuite.extract_bearer_token(request)
+      end
+
+      record_response_route :get, EVERYTHING_PATH, EVERYTHING_TAG, method(:everything_response),
+                            resumes: method(:test_resumes?) do |request|
+        PDexPayerClientSuite.extract_bearer_token(request)
+      end
+
+      # record_response_route :get, EXPORT_PATH, EXPORT_TAG, method(:export_response),
+      #                       resumes: method(:test_resumes?) do |request|
+      #   PDexPayerClientSuite.extract_bearer_token(request)
+      # end
+
+      record_response_route :post, MEMBER_MATCH_PATH, MEMBER_MATCH_TAG, method(:member_match_response),
+                            resumes: method(:test_resumes?) do |request|
+        PDexPayerClientSuite.extract_bearer_token(request)
+      end
+
+      record_response_route :get, BASE_FHIR_PATH, SUBMIT_TAG, method(:read_next_page),
+                            resumes: method(:test_resumes?) do |request|
+        PDexPayerClientSuite.extract_bearer_token(request)
+      end
+  
+      resume_test_route :get, RESUME_PASS_PATH do |request|
+        PDexPayerClientSuite.extract_token_from_query_params(request)
+      end
+
+      resume_test_route :get, RESUME_CLINICAL_DATA_PATH do |request|
+        PDexPayerClientSuite.extract_token_from_query_params(request)
+      end
+  
+      resume_test_route :get, RESUME_FAIL_PATH, result: 'fail' do |request|
+        PDexPayerClientSuite.extract_token_from_query_params(request)
+      end
+
+      route(:get, METADATA_PATH, get_metadata)
+
+      group do
+        run_as_group
+        title "Workflow Tests"
+        group do
+          title "$member-match validation"
+          test from: :initial_member_match_submit_test
+          test from: :initial_member_match_validation_test
+        end
+        group do
+          title "Clinical data request tests"
+          test from: :initial_wait_test
+          test from: :initial_scratch_storing
+          test from: :allergyintolerance_clinical_data_request_test
+          test from: :careplan_clinical_data_request_test
+          test from: :careteam_clinical_data_request_test
+          test from: :condition_clinical_data_request_test
+          test from: :device_clinical_data_request_test
+          test from: :diagnosticreport_clinical_data_request_test
+          test from: :documentreference_clinical_data_request_test
+          test from: :encounter_clinical_data_request_test
+          test from: :explanationofbenefit_clinical_data_request_test
+          test from: :goal_clinical_data_request_test
+          test from: :immunization_clinical_data_request_test
+          test from: :location_clinical_data_request_test
+          test from: :medicationdispense_clinical_data_request_test
+          test from: :medicationrequest_clinical_data_request_test
+          test from: :observation_clinical_data_request_test
+          test from: :organization_clinical_data_request_test
+          test from: :patient_clinical_data_request_test
+          test from: :practitioner_clinical_data_request_test
+          test from: :practitionerrole_clinical_data_request_test
+          test from: :procedure_clinical_data_request_test
+        end
+      end
+      
+      # group do
+      #   title "Must Support validation"
+      #   group do
+      #     title "$member-match Must Support tests"
+      #     test from: :initial_member_match_must_support_submit_test
+      #     test from: :initial_member_match_must_support_validation_test
+      #   end
+      # end
+    end
+  end
+  

data/lib/davinci_pdex_test_kit/pdex_payer_server/abstract_member_match_request_conformance_test.rb

@@ -0,0 +1,33 @@
+module DaVinciPDexTestKit
+  module PDexPayerServer
+
+    # Exists to factorize input validation
+    class AbstractMemberMatchRequestConformanceTest < Inferno::Test      
+      id :abstract_member_match_request_conformance
+      input :member_match_request
+
+      def assert_local_patient_references(member_match_request_parameters)
+        # $member-match has references requirements on its Parameters profile not coded as FHIR constraints
+        # see https://hl7.org/fhir/us/davinci-hrex/STU1/OperationDefinition-member-match.html#resolving-parameter-references
+        parameter_patient_id = member_match_request_parameters.parameter.find{|p| p.name== 'MemberPatient'}.resource.id
+        assert member_match_request_parameters.parameter.find{|p| p.name== 'Consent'}&.resource&.patient&.reference == "Patient/#{parameter_patient_id}",
+          "The reference to Patient resource in Consent parameter must be a local reference referring to MemberPatient with matching id"
+        assert member_match_request_parameters.parameter.find{|p| p.name== 'CoverageToMatch'}&.resource.beneficiary.reference == "Patient/#{parameter_patient_id}",
+          "The reference to Patient resource in CoverageToMatch parameter must be a local reference referring to MemberPatient with matching id"
+      end
+
+      def assert_member_match_request(member_match_request_json)
+        # assert_valid_json(member_match_request_json)
+        member_match_request_resource = FHIR.from_contents(member_match_request_json) # TODO: handle case if it fails to parse as FHIR, but is valid JSON
+        assert_valid_resource(resource: member_match_request_resource, profile_url: 'http://hl7.org/fhir/us/davinci-hrex/StructureDefinition/hrex-parameters-member-match-in')
+        assert_local_patient_references(member_match_request_resource)
+      end
+
+      run do
+        skip_if !member_match_request, "No input provided."
+
+        assert_member_match_request(member_match_request)
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_server/abstract_member_match_request_local_references_test.rb

@@ -0,0 +1,35 @@
+module DaVinciPDexTestKit
+  module PDexPayerServer
+
+    # Exists to factorize input validation
+    class AbstractMemberMatchRequestLocalReferencesTest < Inferno::Test
+      id :abstract_member_match_request_local_references
+      title '[USER INPUT VALIDATION] Member match request only uses local references'
+      description %{
+        This test confirms that all Patient references inside the Consent and CoverageToMatch parameters are local references to the MemberPatient
+        parameter. See
+        [resolving parameter references](http://hl7.org/fhir/us/davinci-hrex/STU1/OperationDefinition-member-match.html#resolving-parameter-references)
+        from the HRex 1.0.0. Implementation Guide.
+      }
+
+      input :member_match_request # [String]
+
+      # @param member_match_request_parameters [FHIR::Parameters]
+      def assert_local_patient_references(member_match_request_parameters)
+        # $member-match has references requirements on its Parameters profile not coded as FHIR constraints
+        # see https://hl7.org/fhir/us/davinci-hrex/STU1/OperationDefinition-member-match.html#resolving-parameter-references
+        parameter_patient_id = member_match_request_parameters.parameter.find{|p| p.name== 'MemberPatient'}.resource.id
+        assert member_match_request_parameters.parameter.find{|p| p.name== 'Consent'}&.resource&.patient&.reference == "Patient/#{parameter_patient_id}",
+          "The reference to Patient resource in Consent parameter must be a local reference referring to MemberPatient with matching id"
+        assert member_match_request_parameters.parameter.find{|p| p.name== 'CoverageToMatch'}&.resource&.beneficiary&.reference == "Patient/#{parameter_patient_id}",
+          "The reference to Patient resource in CoverageToMatch parameter must be a local reference referring to MemberPatient with matching id"
+      end
+
+      run do
+        skip_if !member_match_request, "No input provided."
+
+        assert_local_patient_references( FHIR.from_contents(member_match_request) )
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_server/coverage_to_link_has_minimal_data_test.rb

@@ -0,0 +1,52 @@
+
+module DaVinciPDexTestKit
+  module PDexPayerServer
+    class CoverageToLinkHasMinimalDataTest < Inferno::Test
+
+      id :coverage_to_link_has_minimal_data
+      title '[USER INPUT VALIDATION] CoverageToLink parameter should not include any data elements not marked as mustSupport'
+      optional
+      description %{
+        This test will skip if there is no CoverageToLink parameter in the member match request input for one match.
+
+        If that resource is present, it will check conformance against the
+        [HRex Coverage Profile](https://hl7.org/fhir/us/davinci-hrex/STU1/StructureDefinition-hrex-coverage.html)
+        and check that no elements that are neither MustSupport nor Mandatory are present.
+
+        If certain MustSupport elements are missing this test may still pass.
+
+        See [notes](https://hl7.org/fhir/us/davinci-hrex/STU1/OperationDefinition-member-match.html#notes) in HRex Implementation Guide,
+        as required by PDex Implementation Guide.
+      }
+
+      input :member_match_request
+
+      run do
+        member_match_request_resource = FHIR.from_contents(member_match_request)
+        skip_if !member_match_request_resource.parameter.find{|p| p.name=='CoverageToLink'},
+                "No CoverageToLink parameter provided"
+
+        coverage = member_match_request_resource.parameter.find{|p| p.name=='CoverageToLink'}.resource
+
+        assert_resource_type(:coverage, resource: coverage)
+        assert !coverage.type
+        assert !coverage.policyHolder
+        assert !coverage.subscriber
+        assert !coverage.relationship
+        assert !coverage.period
+        assert !coverage.local_class.any? do |backbone_element|
+          backbone_element.type.coding.any? do |coding|
+            !(coding.code == 'group' && 
+              coding.system == 'http://terminology.hl7.org/CodeSystem/coverage-class')
+          end
+        end
+        assert !coverage.order
+        assert !coverage.network
+        assert coverage.costToBeneficiary.empty?
+        assert coverage.subrogation.nil?
+        assert !coverage.contract
+      end
+
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_server/coverage_to_link_must_support_test.rb

@@ -0,0 +1,28 @@
+
+module DaVinciPDexTestKit
+  module PDexPayerServer
+    class CoverageToLinkMustSupportTest < Inferno::Test
+
+      id :coverage_to_link_must_support
+      title '[USER INPUT VALIDATION] CoverageToLink parameter is optional for generic FHIR clients, but required for Payer systems.'
+      description 'See [CoverageToLink parameter documentation](https://hl7.org/fhir/us/davinci-hrex/STU1/OperationDefinition-member-match.html).'
+      optional
+
+      input :member_match_request
+
+      # Special test for 'CoverageToLink' test in Member Match Request, which is "MustSupport":
+      # https://hl7.org/fhir/us/davinci-hrex/STU1/OperationDefinition-member-match.html
+      #
+      # > This parameter is optional as this operation may be invoked by non-payer systems. However, it is considered 'mustSupport'.
+      # > If the client invoking the operation is a payer, they SHALL include their coverage information for the member when invoking
+      # > the operation.
+      run do
+        member_match_request_resource = FHIR.from_contents(member_match_request)
+
+        assert member_match_request_resource.parameter.find{|p| p.name=='CoverageToLink'}&.resource, "No CoverageToLink parameter provided."
+        assert_resource_type(:coverage, resource: member_match_request_resource.parameter.find{|p| p.name=='CoverageToLink'}&.resource)
+      end
+
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_server/explanation_of_benefit/explanation_of_benefit_id_search_test.rb

@@ -0,0 +1,58 @@
+require 'us_core_test_kit/search_test'
+require 'us_core_test_kit/search_test_properties'
+require 'us_core_test_kit/generator/group_metadata'
+
+module DaVinciPDexTestKit
+  module PDexPayerServer
+    class ExplanationOfBenefitIdSearchTest < Inferno::Test
+      include USCoreTestKit::SearchTest
+
+      title 'Server returns valid results for Patient search by _id'
+      description %(
+A server SHALL support searching by
+_id on the ExplanationOfBenefit resource. This test
+will pass if resources are returned and match the search criteria. If
+none are returned, the test is skipped.
+
+Because this is the first search of the sequence, resources in the
+response will be used for subsequent tests.
+
+Additionally, this test will check that GET and POST search methods
+return the same number of results. Search by POST is required by the
+FHIR R4 specification, and these tests interpret search by GET as a
+requirement of DaVinci PDex v2.0.0.
+
+[PDex Server CapabilityStatement](https://hl7.org/fhir/us/davinci-pdex/STU2/CapabilityStatement-pdex-server.html)
+
+      )
+
+      id :pdex_explanation_of_benefit__id_search_test
+
+      input :patient_ids,
+        title: 'Patient IDs',
+        description: 'Comma separated list of patient IDs that in sum contain all MUST SUPPORT elements'
+
+      # TODO: test if this test runs
+
+      def self.properties
+        @properties ||= USCoreTestKit::SearchTestProperties.new(
+          resource_type: 'ExplanationOfBenefit',
+          search_param_names: ['_id']
+          # TODO: any more search test properties?
+        )
+      end
+
+      def self.metadata
+        @metadata ||= USCoreTestKit::Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:patient_resources] ||= {}
+      end
+
+      run do
+        run_search_test
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_server/explanation_of_benefit/explanation_of_benefit_identifier_search_test.rb

@@ -0,0 +1,58 @@
+require 'us_core_test_kit/search_test'
+require 'us_core_test_kit/search_test_properties'
+require 'us_core_test_kit/generator/group_metadata'
+
+module DaVinciPDexTestKit
+  module PDexPayerServer
+    class ExplanationOfBenefitIdentifierSearchTest < Inferno::Test
+      include USCoreTestKit::SearchTest
+
+      title 'Server returns valid results for Patient search by identifier'
+      description %(
+A server SHALL support searching by
+identifier on the ExplanationOfBenefit resource. This test
+will pass if resources are returned and match the search criteria. If
+none are returned, the test is skipped.
+
+Because this is the first search of the sequence, resources in the
+response will be used for subsequent tests.
+
+Additionally, this test will check that GET and POST search methods
+return the same number of results. Search by POST is required by the
+FHIR R4 specification, and these tests interpret search by GET as a
+requirement of DaVinci PDex v2.0.0.
+
+[PDex Server CapabilityStatement](https://hl7.org/fhir/us/davinci-pdex/STU2/CapabilityStatement-pdex-server.html)
+
+      )
+
+      id :pdex_explanation_of_benefit_identifier_search_test
+
+      input :patient_ids,
+        title: 'Patient IDs',
+        description: 'Comma separated list of patient IDs that in sum contain all MUST SUPPORT elements'
+
+      # TODO: test if this test runs
+
+      def self.properties
+        @properties ||= USCoreTestKit::SearchTestProperties.new(
+          resource_type: 'ExplanationOfBenefit',
+          search_param_names: ['identifier']
+          # TODO: any more search test properties?
+        )
+      end
+
+      def self.metadata
+        @metadata ||= USCoreTestKit::Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:patient_resources] ||= {}
+      end
+
+      run do
+        run_search_test
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_server/explanation_of_benefit/explanation_of_benefit_must_support_test.rb

@@ -0,0 +1,40 @@
+require 'us_core_test_kit/must_support_test'
+require 'us_core_test_kit/generator/group_metadata'
+
+module DaVinciPDexTestKit
+  module PDexPayerServer
+    class ExplanationOfBenefitMustSupportTest < Inferno::Test
+      include USCoreTestKit::MustSupportTest
+
+      title 'All must support elements are provided in the ExplanationOfBenefit resources returned'
+      description %(
+        US Core Responders SHALL be capable of populating all data elements as
+        part of the query results as specified by the US Core Server Capability
+        Statement. This test will look through the ExplanationOfBenefit resources
+        found previously for the following must support elements:
+
+        #### TODO: list out MS elements:
+
+        * ...
+      )
+
+      id :pdex_explanation_of_benefit_must_support_test
+
+      def resource_type
+        'ExplanationOfBenefit'
+      end
+
+      def self.metadata
+        @metadata ||= USCoreTestKit::Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:explanation_of_benefit_resources] ||= {}
+      end
+
+      run do
+        perform_must_support_test(all_scratch_resources)
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_server/explanation_of_benefit/explanation_of_benefit_patient_last_updated_search_test.rb

@@ -0,0 +1,63 @@
+require 'us_core_test_kit/search_test'
+require 'us_core_test_kit/search_test_properties'
+require 'us_core_test_kit/generator/group_metadata'
+
+module DaVinciPDexTestKit
+  module PDexPayerServer
+    class ExplanationOfBenefitPatientLastUpdatedSearchTest < Inferno::Test
+      include USCoreTestKit::SearchTest
+
+      title 'Server returns valid results for ExplanationOfBenefit search by patient + _lastUpdated'
+      description %(
+A server SHALL support searching by
+patient + _lastUpdated on the ExplanationOfBenefit resource. This test
+will pass if resources are returned and match the search criteria. If
+none are returned, the test is skipped.
+
+This test verifies that the server supports searching by reference using
+the form `patient=[id]` as well as `patient=Patient/[id]`. The two
+different forms are expected to return the same number of results. US
+Core requires that both forms are supported by US Core responders, and
+PDex expands upon US Core.
+
+Because this is the first search of the sequence, resources in the
+response will be used for subsequent tests.
+
+Additionally, this test will check that GET and POST search methods
+return the same number of results. Search by POST is required by the
+FHIR R4 specification, and these tests interpret search by GET as a
+requirement of PDex v2.0.0.
+
+[PDex Server CapabilityStatement](https://hl7.org/fhir/us/davinci-pdex/STU2/CapabilityStatement-pdex-server.html)
+
+      )
+
+      id :pdex_explanation_of_benefit_patient__last_updated_search_test
+
+      input :patient_ids,
+        title: 'Patient IDs',
+        description: 'Comma separated list of patient IDs that in sum contain all MUST SUPPORT elements'
+  
+      def self.properties
+        @properties ||= USCoreTestKit::SearchTestProperties.new(
+          resource_type: 'ExplanationOfBenefit',
+          search_param_names: ['patient', '_lastUpdated'],
+          test_post_search: true
+          # TODO other properties?
+        )
+      end
+
+      def self.metadata
+        @metadata ||= USCoreTestKit::Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:explanation_of_benefit_resources] ||= {}
+      end
+
+      run do
+        run_search_test
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/pdex_payer_server/explanation_of_benefit/explanation_of_benefit_patient_service_date_search_test.rb

@@ -0,0 +1,63 @@
+require 'us_core_test_kit/search_test'
+require 'us_core_test_kit/search_test_properties'
+require 'us_core_test_kit/generator/group_metadata'
+
+module DaVinciPDexTestKit
+  module PDexPayerServer
+    class ExplanationOfBenefitPatientServiceDateSearchTest < Inferno::Test
+      include USCoreTestKit::SearchTest
+
+      title 'Server returns valid results for ExplanationOfBenefit search by patient + service-date'
+      description %(
+A server SHALL support searching by
+patient + service-date on the ExplanationOfBenefit resource. This test
+will pass if resources are returned and match the search criteria. If
+none are returned, the test is skipped.
+
+This test verifies that the server supports searching by reference using
+the form `patient=[id]` as well as `patient=Patient/[id]`. The two
+different forms are expected to return the same number of results. US
+Core requires that both forms are supported by US Core responders, and
+PDex expands upon US Core.
+
+Because this is the first search of the sequence, resources in the
+response will be used for subsequent tests.
+
+Additionally, this test will check that GET and POST search methods
+return the same number of results. Search by POST is required by the
+FHIR R4 specification, and these tests interpret search by GET as a
+requirement of PDex v2.0.0.
+
+[PDex Server CapabilityStatement](https://hl7.org/fhir/us/davinci-pdex/STU2/CapabilityStatement-pdex-server.html)
+
+      )
+
+      id :pdex_explanation_of_benefit_patient_service_date_search_test
+
+      input :patient_ids,
+        title: 'Patient IDs',
+        description: 'Comma separated list of patient IDs that in sum contain all MUST SUPPORT elements'
+  
+      def self.properties
+        @properties ||= USCoreTestKit::SearchTestProperties.new(
+          resource_type: 'ExplanationOfBenefit',
+          search_param_names: ['patient', 'service-date'],
+          test_post_search: true
+          # TODO other properties?
+        )
+      end
+
+      def self.metadata
+        @metadata ||= USCoreTestKit::Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:explanation_of_benefit_resources] ||= {}
+      end
+
+      run do
+        run_search_test
+      end
+    end
+  end
+end