davinci_plan_net_test_kit 0.9.0

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/practitioner/practitioner_lastupdated_search_test.rb

@@ -0,0 +1,43 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciPlanNetTestKit
+  module DaVinciPlanNetV110
+    class PractitionerLastupdatedSearchTest < Inferno::Test
+      include DaVinciPlanNetTestKit::SearchTest
+
+      title 'Server returns valid results for Practitioner search by _lastUpdated'
+      description %(
+A server SHALL support searching by
+_lastUpdated on the Practitioner resource. This test
+will pass if resources are returned and match the search criteria. If
+none are returned, the test is skipped.
+
+[Plan Net Server CapabilityStatement](http://hl7.org/fhir/us/davinci-pdex-plan-net/STU1.1/CapabilityStatement/plan-net)
+
+      )
+
+      id :davinci_plan_net_v110_practitioner__lastUpdated_search_test
+      optional
+  
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'Practitioner',
+        search_param_names: ['_lastUpdated']
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:practitioner_resources] ||= {}
+      end
+
+      run do
+        run_search_test
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/practitioner/practitioner_must_support_test.rb

@@ -0,0 +1,57 @@
+require_relative '../../../must_support_test'
+
+module DaVinciPlanNetTestKit
+  module DaVinciPlanNetV110
+    class PractitionerMustSupportTest < Inferno::Test
+      include DaVinciPlanNetTestKit::MustSupportTest
+
+      title 'All must support elements are provided in the Practitioner resources returned'
+      description %(
+        Plan Net Responders SHALL be capable of populating all data elements as
+        part of the query results as specified by the Plan Net Server Capability
+        Statement. This test will look through the Practitioner resources
+        found previously for the following must support elements:
+
+        * Practitioner.active
+        * Practitioner.address
+        * Practitioner.address.extension:geolocation
+        * Practitioner.communication
+        * Practitioner.communication.extension:communication-proficiency
+        * Practitioner.identifier
+        * Practitioner.identifier.system
+        * Practitioner.identifier.type
+        * Practitioner.identifier.value
+        * Practitioner.identifier:NPI
+        * Practitioner.name
+        * Practitioner.name.family
+        * Practitioner.name.given
+        * Practitioner.name.text
+        * Practitioner.qualification
+        * Practitioner.qualification.code
+        * Practitioner.qualification.extension:practitioner-qualification
+        * Practitioner.qualification.identifier
+        * Practitioner.qualification.issuer
+        * Practitioner.qualification.period
+        * Practitioner.telecom
+      )
+
+      id :davinci_plan_net_v110_practitioner_must_support_test
+
+      def resource_type
+        'Practitioner'
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:practitioner_resources] ||= {}
+      end
+
+      run do
+        perform_must_support_test(all_scratch_resources)
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/practitioner/practitioner_name_search_test.rb

@@ -0,0 +1,41 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciPlanNetTestKit
+  module DaVinciPlanNetV110
+    class PractitionerNameSearchTest < Inferno::Test
+      include DaVinciPlanNetTestKit::SearchTest
+
+      title 'Server returns valid results for Practitioner search by name'
+      description %(
+A server SHALL support searching by
+name on the Practitioner resource. This test
+will pass if resources are returned and match the search criteria. If
+none are returned, the test is skipped.
+
+[Plan Net Server CapabilityStatement](http://hl7.org/fhir/us/davinci-pdex-plan-net/STU1.1/CapabilityStatement/plan-net)
+
+      )
+
+      id :davinci_plan_net_v110_practitioner_name_search_test
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'Practitioner',
+        search_param_names: ['name']
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:practitioner_resources] ||= {}
+      end
+
+      run do
+        run_search_test
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/practitioner/practitioner_no_params_search_test.rb

@@ -0,0 +1,49 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciPlanNetTestKit
+  module DaVinciPlanNetV110
+    class PractitionerNoParamsSearchTest < Inferno::Test
+      include DaVinciPlanNetTestKit::SearchTest
+
+      title 'Client can identify instances of Plan-Net Practitioner on the server'
+      description %(
+This test gathers instances expected to conform to the target profile
+for use in the rest of the tests in this sequence. It will perform
+an unparameterized search and/or read instance ids provided by the tester
+as described in the "Instance Gathering" section of the group description above.
+
+      )
+
+      id :davinci_plan_net_v110_practitioner_no_params_search_test
+
+      input :davinci_plan_net_v110_practitioner_no_params_search_test_ids,
+        title: 'ids of Plan-Net Practitioner instances',
+        optional: true,
+        description: 'Required if parameterless searches are not being used for instance gathering.'
+      input :no_param_search
+      input :max_instances
+      input :max_pages
+
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          first_search: true,
+        resource_type: 'Practitioner',
+        test_post_search: false
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:practitioner_resources] ||= {}
+      end
+
+      run do
+        run_search_no_params_test(davinci_plan_net_v110_practitioner_no_params_search_test_ids)
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/practitioner/practitioner_read_test.rb

@@ -0,0 +1,26 @@
+require_relative '../../../read_test'
+
+module DaVinciPlanNetTestKit
+  module DaVinciPlanNetV110
+    class PractitionerReadTest < Inferno::Test
+      include DaVinciPlanNetTestKit::ReadTest
+
+      title 'Server returns correct Practitioner resource from Practitioner read interaction'
+      description 'A server SHALL support the Practitioner read interaction.'
+
+      id :davinci_plan_net_v110_practitioner_read_test
+
+      def resource_type
+        'Practitioner'
+      end
+
+      def scratch_resources
+        scratch[:practitioner_resources] ||= {}
+      end
+
+      run do
+        perform_read_test(all_scratch_resources)
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/practitioner/practitioner_reference_resolution_test.rb

@@ -0,0 +1,42 @@
+require_relative '../../../reference_resolution_test'
+require_relative '../resource_list'
+
+module DaVinciPlanNetTestKit
+  module DaVinciPlanNetV110
+    class PractitionerReferenceResolutionTest < Inferno::Test
+      include DaVinciPlanNetTestKit::ReferenceResolutionTest
+      include ResourceList
+
+      title 'MustSupport references within Practitioner 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 Plan Net profile.
+
+        Elements which may provide external references include:
+
+        * Practitioner.qualification.issuer
+      )
+
+      id :davinci_plan_net_v110_practitioner_reference_resolution_test
+
+      def resource_type
+        'Practitioner'
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:practitioner_resources] ||= {}
+      end
+
+      run do
+        perform_reference_resolution_test(scratch_resources[:all])
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/practitioner/practitioner_reverse_chain_practitioner_role_practitioner_location_search_test.rb

@@ -0,0 +1,62 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciPlanNetTestKit
+  module DaVinciPlanNetV110
+    class PractitionerReverseChainPractitionerRolePractitionerLocationSearchTest < Inferno::Test
+      include DaVinciPlanNetTestKit::SearchTest
+
+      title 'Server capable of reverse chaining through PractitionerRole\'s location element'
+      description %(
+        Test will perform a search using the reverse chaining parameter 
+        _has:PractitionerRole:practitioner:location
+        using a value from either a previously identified PractitionerRole when 
+        run from the suite level, or the "\'location\' value from a PractitionerRole 
+        instance with \'practitioner\' populated" input when run at the group level. To validate the 
+        returned instances, the test will perform a search 
+        on the PractitionerRole resource type using the same location search 
+        parameter and value and check that the instances returned by the tested search are all referenced
+        by the practitioner element of instances returned by the additional search.
+      )
+      
+      id :davinci_plan_net_v110_practitioner_reverse_chain_practitioner_role_practitioner_location_search_test
+      input :practitioner_role_practitioner_location_input,
+        title: '\'location\' value from a PractitionerRole instance with \'practitioner\' populated',
+        description: 'Single value from the \'location\' element of a PractitionerRole
+        on an instance that also references a Practitioner instance in its \'practitioner\' element to be used for test 
+        \'Server capable of reverse chaining through PractitionerRole\'s location element\' when run at the group level.',
+        optional: true
+
+      def properties
+        @properties ||= SearchTestProperties.new(
+            resource_type: 'Practitioner',
+          search_param_names: [],
+          input_name: 'practitioner_role_practitioner_location_input',
+          reverse_chain_param: 'location',
+          reverse_chain_target: 'practitioner',
+          additional_resource_type: 'PractitionerRole'
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml')))
+      end
+
+      def self.additional_metadata
+        @additional_metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, '..', 'practitioner_role', 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:practitioner_resources] ||= {}
+      end
+
+      def scratch_additional_resources
+        scratch[:practitioner_role_resources] ||= {}
+      end
+
+      run do
+        run_reverse_chain_search_test
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/practitioner/practitioner_reverse_chain_practitioner_role_practitioner_network_search_test.rb

@@ -0,0 +1,62 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciPlanNetTestKit
+  module DaVinciPlanNetV110
+    class PractitionerReverseChainPractitionerRolePractitionerNetworkSearchTest < Inferno::Test
+      include DaVinciPlanNetTestKit::SearchTest
+
+      title 'Server capable of reverse chaining through PractitionerRole\'s network element'
+      description %(
+        Test will perform a search using the reverse chaining parameter 
+        _has:PractitionerRole:practitioner:network
+        using a value from either a previously identified PractitionerRole when 
+        run from the suite level, or the "\'network\' value from a PractitionerRole 
+        instance with \'practitioner\' populated" input when run at the group level. To validate the 
+        returned instances, the test will perform a search 
+        on the PractitionerRole resource type using the same network search 
+        parameter and value and check that the instances returned by the tested search are all referenced
+        by the practitioner element of instances returned by the additional search.
+      )
+      
+      id :davinci_plan_net_v110_practitioner_reverse_chain_practitioner_role_practitioner_network_search_test
+      input :practitioner_role_practitioner_network_input,
+        title: '\'network\' value from a PractitionerRole instance with \'practitioner\' populated',
+        description: 'Single value from the \'network\' element of a PractitionerRole
+        on an instance that also references a Practitioner instance in its \'practitioner\' element to be used for test 
+        \'Server capable of reverse chaining through PractitionerRole\'s network element\' when run at the group level.',
+        optional: true
+
+      def properties
+        @properties ||= SearchTestProperties.new(
+            resource_type: 'Practitioner',
+          search_param_names: [],
+          input_name: 'practitioner_role_practitioner_network_input',
+          reverse_chain_param: 'network',
+          reverse_chain_target: 'practitioner',
+          additional_resource_type: 'PractitionerRole'
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml')))
+      end
+
+      def self.additional_metadata
+        @additional_metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, '..', 'practitioner_role', 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:practitioner_resources] ||= {}
+      end
+
+      def scratch_additional_resources
+        scratch[:practitioner_role_resources] ||= {}
+      end
+
+      run do
+        run_reverse_chain_search_test
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/practitioner/practitioner_reverse_chain_practitioner_role_practitioner_role_search_test.rb

@@ -0,0 +1,62 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciPlanNetTestKit
+  module DaVinciPlanNetV110
+    class PractitionerReverseChainPractitionerRolePractitionerRoleSearchTest < Inferno::Test
+      include DaVinciPlanNetTestKit::SearchTest
+
+      title 'Server capable of reverse chaining through PractitionerRole\'s role element'
+      description %(
+        Test will perform a search using the reverse chaining parameter 
+        _has:PractitionerRole:practitioner:role
+        using a value from either a previously identified PractitionerRole when 
+        run from the suite level, or the "\'role\' value from a PractitionerRole 
+        instance with \'practitioner\' populated" input when run at the group level. To validate the 
+        returned instances, the test will perform a search 
+        on the PractitionerRole resource type using the same role search 
+        parameter and value and check that the instances returned by the tested search are all referenced
+        by the practitioner element of instances returned by the additional search.
+      )
+      
+      id :davinci_plan_net_v110_practitioner_reverse_chain_practitioner_role_practitioner_role_search_test
+      input :practitioner_role_practitioner_role_input,
+        title: '\'role\' value from a PractitionerRole instance with \'practitioner\' populated',
+        description: 'Single value from the \'role\' element of a PractitionerRole
+        on an instance that also references a Practitioner instance in its \'practitioner\' element to be used for test 
+        \'Server capable of reverse chaining through PractitionerRole\'s role element\' when run at the group level.',
+        optional: true
+
+      def properties
+        @properties ||= SearchTestProperties.new(
+            resource_type: 'Practitioner',
+          search_param_names: [],
+          input_name: 'practitioner_role_practitioner_role_input',
+          reverse_chain_param: 'role',
+          reverse_chain_target: 'practitioner',
+          additional_resource_type: 'PractitionerRole'
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml')))
+      end
+
+      def self.additional_metadata
+        @additional_metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, '..', 'practitioner_role', 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:practitioner_resources] ||= {}
+      end
+
+      def scratch_additional_resources
+        scratch[:practitioner_role_resources] ||= {}
+      end
+
+      run do
+        run_reverse_chain_search_test
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/practitioner/practitioner_reverse_chain_practitioner_role_practitioner_specialty_search_test.rb

@@ -0,0 +1,62 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciPlanNetTestKit
+  module DaVinciPlanNetV110
+    class PractitionerReverseChainPractitionerRolePractitionerSpecialtySearchTest < Inferno::Test
+      include DaVinciPlanNetTestKit::SearchTest
+
+      title 'Server capable of reverse chaining through PractitionerRole\'s specialty element'
+      description %(
+        Test will perform a search using the reverse chaining parameter 
+        _has:PractitionerRole:practitioner:specialty
+        using a value from either a previously identified PractitionerRole when 
+        run from the suite level, or the "\'specialty\' value from a PractitionerRole 
+        instance with \'practitioner\' populated" input when run at the group level. To validate the 
+        returned instances, the test will perform a search 
+        on the PractitionerRole resource type using the same specialty search 
+        parameter and value and check that the instances returned by the tested search are all referenced
+        by the practitioner element of instances returned by the additional search.
+      )
+      
+      id :davinci_plan_net_v110_practitioner_reverse_chain_practitioner_role_practitioner_specialty_search_test
+      input :practitioner_role_practitioner_specialty_input,
+        title: '\'specialty\' value from a PractitionerRole instance with \'practitioner\' populated',
+        description: 'Single value from the \'specialty\' element of a PractitionerRole
+        on an instance that also references a Practitioner instance in its \'practitioner\' element to be used for test 
+        \'Server capable of reverse chaining through PractitionerRole\'s specialty element\' when run at the group level.',
+        optional: true
+
+      def properties
+        @properties ||= SearchTestProperties.new(
+            resource_type: 'Practitioner',
+          search_param_names: [],
+          input_name: 'practitioner_role_practitioner_specialty_input',
+          reverse_chain_param: 'specialty',
+          reverse_chain_target: 'practitioner',
+          additional_resource_type: 'PractitionerRole'
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml')))
+      end
+
+      def self.additional_metadata
+        @additional_metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, '..', 'practitioner_role', 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:practitioner_resources] ||= {}
+      end
+
+      def scratch_additional_resources
+        scratch[:practitioner_role_resources] ||= {}
+      end
+
+      run do
+        run_reverse_chain_search_test
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/practitioner/practitioner_revinclude_practitioner_role_practitioner_search_test.rb

@@ -0,0 +1,60 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciPlanNetTestKit
+  module DaVinciPlanNetV110
+    class PractitionerRevincludePractitionerRolePractitionerSearchTest < Inferno::Test
+      include DaVinciPlanNetTestKit::SearchTest
+
+      title 'Server returns PractitionerRole resources from Practitioner search with _revinclude=PractitionerRole:practitioner'
+      description %(
+        A server SHALL be capable of supporting searches _revincludes on search parameter PractitionerRole:practitioner.
+
+        This test will perform a search on Practitioner with _revinclude=PractitionerRole:practitioner and the '_id'
+        search parameter using an id previously identified during a suite level run or an id provided
+        in the "Practitioner instance ids referenced in PractitionerRole.practitioner" input if run at the group level.
+        The test will pass if at least one PractitionerRole resource found in the response
+        and each instance that does includes a reference to the Practitioner with the searched id.
+      )
+
+      id :davinci_plan_net_v110_revinclude_practitioner_practitioner_role_practitioner_search_test
+      input :practitioner_role_practitioner_input,
+        title: 'Practitioner instance ids referenced in PractitionerRole.practitioner',
+        description: %(Comma separated list of Practitioner instance ids that are referenced by a PractitionerRole
+        instance in its practitioner element. Used for test "Server returns PractitionerRole resources from Practitioner search with _revinclude=PractitionerRole:practitioner"
+        when run at the group level.),
+        optional: true
+        
+      def properties
+        @properties ||= SearchTestProperties.new(
+            resource_type: 'Practitioner',
+          search_param_names: [],
+          input_name: 'practitioner_role_practitioner_input',
+          revinclude_param: 'PractitionerRole:practitioner',
+          rev_param_sp: 'practitioner',
+          additional_resource_type: 'PractitionerRole'
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml')))
+      end
+
+      def self.additional_metadata
+        @additional_metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, '..', 'practitioner_role', 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:practitioner_resources] ||= {}
+      end
+
+      def scratch_additional_resources
+        scratch[:practitioner_role_resources] ||= {}
+      end
+
+      run do
+        run_revinclude_search_test
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/practitioner/practitioner_validation_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../../validation_test'
+
+module DaVinciPlanNetTestKit
+  module DaVinciPlanNetV110
+    class PractitionerValidationTest < Inferno::Test
+      include DaVinciPlanNetTestKit::ValidationTest
+
+      id :davinci_plan_net_v110_practitioner_validation_test
+      title 'Practitioner resources returned during previous tests conform to the Plan-Net Practitioner'
+      description %(
+This test verifies resources returned from the first search conform to
+the [Plan-Net Practitioner](http://hl7.org/fhir/us/davinci-pdex-plan-net/STU1.1/StructureDefinition/plannet-Practitioner).
+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
+        'Practitioner'
+      end
+
+      def scratch_resources
+        scratch[:practitioner_resources] ||= {}
+      end
+
+      run do
+        perform_validation_test(scratch_resources[:all] || [],
+                                'http://hl7.org/fhir/us/davinci-pdex-plan-net/StructureDefinition/plannet-Practitioner',
+                                '1.1.0',
+                                skip_if_empty: true)
+      end
+    end
+  end
+end