davinci_plan_net_test_kit 0.9.0

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/practitioner_role/practitioner_role_service_search_test.rb

@@ -0,0 +1,41 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciPlanNetTestKit
+  module DaVinciPlanNetV110
+    class PractitionerRoleServiceSearchTest < Inferno::Test
+      include DaVinciPlanNetTestKit::SearchTest
+
+      title 'Server returns valid results for PractitionerRole search by service'
+      description %(
+A server SHALL support searching by
+service on the PractitionerRole 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_role_service_search_test
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'PractitionerRole',
+        search_param_names: ['service']
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:practitioner_role_resources] ||= {}
+      end
+
+      run do
+        run_search_test
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/practitioner_role/practitioner_role_specialty_search_test.rb

@@ -0,0 +1,42 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciPlanNetTestKit
+  module DaVinciPlanNetV110
+    class PractitionerRoleSpecialtySearchTest < Inferno::Test
+      include DaVinciPlanNetTestKit::SearchTest
+
+      title 'Server returns valid results for PractitionerRole search by specialty'
+      description %(
+A server SHALL support searching by
+specialty on the PractitionerRole 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_role_specialty_search_test
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'PractitionerRole',
+        search_param_names: ['specialty'],
+        token_search_params: ['specialty']
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:practitioner_role_resources] ||= {}
+      end
+
+      run do
+        run_search_test
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/practitioner_role/practitioner_role_validation_test.rb

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

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/practitioner_role_group.rb

@@ -0,0 +1,241 @@
+require_relative 'practitioner_role/practitioner_role_no_params_search_test'
+require_relative 'practitioner_role/practitioner_role_read_test'
+require_relative 'practitioner_role/practitioner_role_practitioner_search_test'
+require_relative 'practitioner_role/practitioner_role_organization_search_test'
+require_relative 'practitioner_role/practitioner_role_location_search_test'
+require_relative 'practitioner_role/practitioner_role_service_search_test'
+require_relative 'practitioner_role/practitioner_role_network_search_test'
+require_relative 'practitioner_role/practitioner_role_endpoint_search_test'
+require_relative 'practitioner_role/practitioner_role_role_search_test'
+require_relative 'practitioner_role/practitioner_role_specialty_search_test'
+require_relative 'practitioner_role/practitioner_role_id_search_test'
+require_relative 'practitioner_role/practitioner_role_lastupdated_search_test'
+require_relative 'practitioner_role/practitioner_role_include_practitioner_role_practitioner_search_test'
+require_relative 'practitioner_role/practitioner_role_include_practitioner_role_organization_search_test'
+require_relative 'practitioner_role/practitioner_role_include_practitioner_role_location_search_test'
+require_relative 'practitioner_role/practitioner_role_include_practitioner_role_service_search_test'
+require_relative 'practitioner_role/practitioner_role_include_practitioner_role_network_search_test'
+require_relative 'practitioner_role/practitioner_role_include_practitioner_role_endpoint_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_practitioner_name_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_organization_name_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_organization_address_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_organization_partof_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_organization_type_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_location_address_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_location_address_postalcode_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_location_address_city_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_location_address_state_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_location_organization_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_location_type_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_service_service_category_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_service_organization_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_service_location_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_network_name_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_network_address_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_network_partof_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_network_type_search_test'
+require_relative 'practitioner_role/practitioner_role_forward_chain_endpoint_organization_search_test'
+require_relative 'practitioner_role/practitioner_role_combination_list_practitioners_with_specialty_and_location_search_test'
+require_relative 'practitioner_role/practitioner_role_validation_test'
+require_relative 'practitioner_role/practitioner_role_must_support_test'
+require_relative 'practitioner_role/practitioner_role_reference_resolution_test'
+
+module DaVinciPlanNetTestKit
+  module DaVinciPlanNetV110
+    class PractitionerRoleGroup < Inferno::TestGroup
+      title 'Plan-Net PractitionerRole Tests'
+      short_description 'Verify support for the server capabilities required by the Plan-Net PractitionerRole.'
+      description %(
+  # Background
+
+The Plan-Net PractitionerRole sequence verifies that the system under test is
+able to provide correct responses for PractitionerRole queries. These queries
+must return resources conforming to the Plan-Net PractitionerRole profile as
+specified in the Plan Net v1.1.0 Implementation Guide.
+
+# Testing Methodology
+
+## Instance Gathering
+
+Inferno will first identify and obtain a set of instances to use for the rest
+of the tests, requiring at least one instance to be identified for the test to pass. 
+Instances to gather are indentified in two ways. One or both will be used,
+depending on user input.
+
+### Parameterless searches 
+Instances can be gathered using a query requesting all instances of PractitionerRole 
+(e.g., `GET [FHIR Endpoint]/PractitionerRole`). 
+Gathering through this method is controlled by the following inputs (used for all profiles):
+- "Use parameterless searches to identify instances?": 
+  parameterless searches can be disabled using this input if, for example, 
+  the server under test does not support them, or not all instances on the server 
+  should be expected to conform to Plan Net profiles. In this case the user **MUST**
+  provide specific instance ids to gather.
+- "Maximum number of instances to gather using parameterless searches": sets an upper 
+  bound on the number of instances Inferno will gather from parameterless searches.
+- "Maximum pages of results to consider when using parameterless searches": sets an upper bound 
+  on the number of pages of search results Inferno will load when gathering instances 
+  using parameterless searches.
+
+### User-provided instance ids
+
+If ids are listed in the "ids of Plan-Net PractitionerRole instances" optional input, 
+they will be read and included at the start of the set of gathered instances.
+
+
+## Searching
+This test sequence will perform a search with each required search parameter
+associated with this resource individually. Searches with the
+following parameters will be performed:
+
+* practitioner
+* organization
+* location
+* service
+* network
+* endpoint
+* role
+* specialty
+* _id
+* _lastUpdated
+
+### Search Parameters
+Each search will look for its parameter values
+from the results of the instance gathering step. For example, for a search using
+the `identifier` search parameter, the test searches the gathered instances
+for one with the `identifier` element populated and then uses that value
+as the queried `identifier` value. If a value cannot be found this way, 
+the search test is skipped for that search parameter.
+
+### Search Validation
+Inferno will retrieve all bundle pages of the reply for
+PractitionerRole resources. Each of the returned instances
+is then checked to see if it matches the searched
+parameters in accordance with [FHIR search
+guidelines](https://www.hl7.org/fhir/search.html). The test will fail,
+for example, if a Plan-Net PractitionerRole search for `practitioner=X`
+returns a Plan-Net PractitionerRole instance where `practitioner!=X`
+
+
+## _include Requirement Testing
+This test sequence will perform a search with each required _include search 
+parameter associated with this profile. This sequence will perform searches with the
+following includes:
+
+* PractitionerRole:practitioner
+* PractitionerRole:organization
+* PractitionerRole:location
+* PractitionerRole:service
+* PractitionerRole:network
+* PractitionerRole:endpoint
+
+Each _include search will look for a candidate id that has the target reference element
+populated from the results of instance gathering.  Each search will use the identified 
+Plan-Net PractitionerRole id and the include parameter.
+The returned instances are checked to ensure that any instances of the included
+type are referenced by returned instances of the searched resource type.
+
+
+
+## Forward Chaining Requirement Testing
+This test sequence will perform a search with each required combination of forward chaining 
+search parameters. This sequence will perform searches with the following chaining parameters:
+
+| Search Parameters | Chain Requirements |
+| :---: | :---: |
+| practitioner | name |
+| organization | name, address, partof, type |
+| location | address, address-postalcode, address-city, address-state, organization, type |
+| service | service-category, organization, location |
+| network | name, address, partof, type |
+| endpoint | organization |
+
+
+All forward chain searches will look for candidate instances of the resource being chained through
+from the results of previously run _include tests.  Candidates are chosen from previously returned
+instances that have the chain parameter element filled.  Each search test will use one of these values
+to build the requests for the test.  The test will be skipped if no candidates can be found.
+
+The test will first create and execute the forward chaining request.
+The test will then perform a basic search test on the resource being chained through,
+using the same value in the previous request.  Each resource returned in the first
+request will then be checked, validating that the element being chained through is populated by
+the id of _any_ of the resources returned by the second request.
+
+
+
+
+## Profile Validation
+Each resource identified during instance gathering and other queries run during this test sequence
+is expected to conform to the [Plan-Net PractitionerRole](http://hl7.org/fhir/us/davinci-pdex-plan-net/STU1.1/StructureDefinition/plannet-PractitionerRole). Each element is checked 
+by the HL7 Validator against terminology 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.
+
+## Must Support
+Each profile contains elements marked as "must support". This test
+sequence expects to see each of these elements populated at least once. 
+The test will look through the Plan-Net PractitionerRole instances identified 
+during instance gathering and other queries run during this test sequence.
+If no populated instance can be found for any must support element, 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 :davinci_plan_net_v110_practitioner_role
+      run_as_group
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'practitioner_role', 'metadata.yml'), aliases: true))
+      end
+  
+      test from: :davinci_plan_net_v110_practitioner_role_no_params_search_test
+      test from: :davinci_plan_net_v110_practitioner_role_read_test
+      test from: :davinci_plan_net_v110_practitioner_role_practitioner_search_test
+      test from: :davinci_plan_net_v110_practitioner_role_organization_search_test
+      test from: :davinci_plan_net_v110_practitioner_role_location_search_test
+      test from: :davinci_plan_net_v110_practitioner_role_service_search_test
+      test from: :davinci_plan_net_v110_practitioner_role_network_search_test
+      test from: :davinci_plan_net_v110_practitioner_role_endpoint_search_test
+      test from: :davinci_plan_net_v110_practitioner_role_role_search_test
+      test from: :davinci_plan_net_v110_practitioner_role_specialty_search_test
+      test from: :davinci_plan_net_v110_practitioner_role__id_search_test
+      test from: :davinci_plan_net_v110_practitioner_role__lastUpdated_search_test
+      test from: :davinci_plan_net_v110_include_practitioner_role_practitioner_role_practitioner_search_test
+      test from: :davinci_plan_net_v110_include_practitioner_role_practitioner_role_organization_search_test
+      test from: :davinci_plan_net_v110_include_practitioner_role_practitioner_role_location_search_test
+      test from: :davinci_plan_net_v110_include_practitioner_role_practitioner_role_service_search_test
+      test from: :davinci_plan_net_v110_include_practitioner_role_practitioner_role_network_search_test
+      test from: :davinci_plan_net_v110_include_practitioner_role_practitioner_role_endpoint_search_test
+      test from: :davinci_plan_net_v110_forward_chain_practitioner_name_search_test
+      test from: :davinci_plan_net_v110_forward_chain_organization_name_search_test
+      test from: :davinci_plan_net_v110_forward_chain_organization_address_search_test
+      test from: :davinci_plan_net_v110_forward_chain_organization_partof_search_test
+      test from: :davinci_plan_net_v110_forward_chain_organization_type_search_test
+      test from: :davinci_plan_net_v110_forward_chain_location_address_search_test
+      test from: :davinci_plan_net_v110_forward_chain_location_address_postalcode_search_test
+      test from: :davinci_plan_net_v110_forward_chain_location_address_city_search_test
+      test from: :davinci_plan_net_v110_forward_chain_location_address_state_search_test
+      test from: :davinci_plan_net_v110_forward_chain_location_organization_search_test
+      test from: :davinci_plan_net_v110_forward_chain_location_type_search_test
+      test from: :davinci_plan_net_v110_forward_chain_service_service_category_search_test
+      test from: :davinci_plan_net_v110_forward_chain_service_organization_search_test
+      test from: :davinci_plan_net_v110_forward_chain_service_location_search_test
+      test from: :davinci_plan_net_v110_forward_chain_network_name_search_test
+      test from: :davinci_plan_net_v110_forward_chain_network_address_search_test
+      test from: :davinci_plan_net_v110_forward_chain_network_partof_search_test
+      test from: :davinci_plan_net_v110_forward_chain_network_type_search_test
+      test from: :davinci_plan_net_v110_forward_chain_endpoint_organization_search_test
+      test from: :davinci_plan_net_v110_practitioner_role_combination_list_practitioners_with_specialty_and_location_search_test
+      test from: :davinci_plan_net_v110_practitioner_role_validation_test
+      test from: :davinci_plan_net_v110_practitioner_role_must_support_test
+      test from: :davinci_plan_net_v110_practitioner_role_reference_resolution_test
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generated/v1.1.0/resource_list.rb

@@ -0,0 +1,16 @@
+module DaVinciPlanNetTestKit
+  module DaVinciPlanNetV110
+    module ResourceList
+      RESOURCE_LIST = [
+        'Endpoint',
+      'HealthcareService',
+      'InsurancePlan',
+      'Location',
+      'Organization',
+      'OrganizationAffiliation',
+      'Practitioner',
+      'PractitionerRole'
+      ].freeze
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generator/combination_search_test_generator.rb

@@ -0,0 +1,215 @@
+require_relative 'naming'
+require_relative 'special_cases'
+
+module DaVinciPlanNetTestKit
+  class Generator
+    class CombinationSearchTestGenerator
+      class << self
+        def generate(ig_metadata, examples_hash, base_output_dir)
+          examples_hash.keys.each do |group|
+            examples_hash[group].each do |combination_example| 
+              group_to_add_to = ig_metadata.groups.find { |ig_meta_group| ig_meta_group.name == "plannet_#{group}"}
+              new(group_to_add_to, group_to_add_to.searches.first, base_output_dir, combination_example).generate
+            end
+          end
+        end
+      end
+
+      attr_accessor :group_metadata, :search_metadata, :base_output_dir, :test_data
+
+      def initialize(group_metadata, search_metadata, base_output_dir, combination_example)
+        self.group_metadata = group_metadata
+        self.search_metadata = search_metadata
+        self.base_output_dir = base_output_dir
+        self.test_data = combination_example
+      end
+
+      def template
+        @template ||= File.read(File.join(__dir__, 'templates', 'combination_search_test.rb.erb'))
+      end
+
+      def output
+        @output ||= ERB.new(template).result(binding)
+      end
+
+      def base_output_file_name
+        "#{class_name.underscore}.rb"
+      end
+
+      def output_file_directory
+        File.join(base_output_dir, profile_identifier.downcase)
+      end
+
+      def output_file_name
+        File.join(output_file_directory, base_output_file_name)
+      end
+
+      def profile_identifier
+        Naming.snake_case_for_profile(group_metadata)
+      end
+
+      def test_id
+        "davinci_plan_net_#{group_metadata.reformatted_version}_#{profile_identifier}_#{search_identifier}_search_test"
+      end
+
+      def search_identifier
+        test_data['name'].gsub(/[-:]/, '_').underscore.gsub("organization_affiliation", "org_affil")
+      end
+
+      def search_title
+        search_identifier.camelize
+      end
+
+      def class_name
+        "#{Naming.upper_camel_case_for_profile(group_metadata)}#{search_title}SearchTest"
+      end
+
+      def module_name
+        "DaVinciPlanNet#{group_metadata.reformatted_version.upcase}"
+      end
+
+      def resource_type
+        group_metadata.resource
+      end
+
+      def additional_resource_type
+        test_data['additional_resource_type']
+      end
+
+      def test_description
+        test_data['description']
+      end
+
+      def test_goal
+        test_data['goal']
+      end
+
+      def search_params
+        @search_params ||=
+          test_data['base_search_params'].map do |name|
+            {
+              name: name,
+              path: search_definition(name)[:path]
+            }
+          end
+      end
+
+      def first_search?
+        group_metadata.searches.first == search_metadata
+      end
+
+      def fixed_value_search?
+        #TODO
+        false
+      end
+
+      def fixed_value_search_param_name
+        #TODO
+      end
+
+      def a_or_an(name)
+        ['a','e','i','o','u'].include?(name.first.downcase) ? "an #{name}" : "a #{name}"
+      end
+
+      def search_param_names
+        search_params.map { |param| param[:name] }
+      end
+
+      def search_param_names_array
+        array_of_strings(search_param_names)
+      end
+
+      def path_for_value(path)
+        path == 'class' ? 'local_class' : path
+      end
+
+      def required_comparators_for_param(name)
+        search_definition(name)[:comparators].select { |_comparator, expectation| expectation == 'SHALL' }
+      end
+
+      def required_comparators
+        @required_comparators ||=
+          search_param_names.each_with_object({}) do |name, comparators|
+            required_comparators = required_comparators_for_param(name)
+            comparators[name] = required_comparators if required_comparators.present?
+          end
+      end
+
+      def search_definition(name)
+        group_metadata.search_definitions[name.to_sym]
+      end
+
+      def saves_delayed_references?
+        first_search? && group_metadata.delayed_references.present?
+      end
+
+      def possible_status_search?
+        !search_metadata[:names].include?('status') && group_metadata.search_definitions.key?(:status)
+      end
+
+      def token_search_params
+        @token_search_params ||=
+          search_param_names.select do |name|
+            ['Identifier', 'CodeableConcept', 'Coding'].include? group_metadata.search_definitions[name.to_sym][:type]
+          end
+      end
+
+      def token_search_params_string
+        array_of_strings(token_search_params)
+      end
+
+      def required_comparators_string
+        array_of_strings(required_comparators.keys)
+      end
+
+      def array_of_strings(array)
+        quoted_strings = array.map { |element| "'#{element}'" }
+        "[#{quoted_strings.join(', ')}]"
+      end
+
+      def input_name
+        "#{search_identifier}_input"
+      end
+
+      def optional_input?
+        test_data['optional_input']
+      end
+
+      def input_description
+        test_data['input_description']
+      end
+
+      def search_properties
+        {}.tap do |properties|
+          properties[:fixed_value_search] = 'true' if fixed_value_search?
+          properties[:resource_type] = "'#{resource_type}'"
+          properties[:search_param_names] = search_param_names_array
+          properties[:input_name] = "'#{input_name}'"
+          properties[:include_param] ="'#{test_data['include_param']}'" if !test_data['include_param'].empty?
+          properties[:inc_param_sp] ="'#{test_data['inc_param_sp']}'" if !test_data['inc_param_sp'].empty?
+          properties[:reverse_chain_param] = "'#{test_data['reverse_chain_param']}'" if !test_data['reverse_chain_param'].empty?
+          properties[:reverse_chain_target] = "'#{test_data['reverse_chain_target']}'" if !test_data['reverse_chain_target'].empty?
+          properties[:possible_status_search] = 'true' if possible_status_search?
+          properties[:additional_resource_type] = "'#{additional_resource_type}'"
+          properties[:combination_search] = 'true'
+        end
+      end
+
+      def search_test_properties_string
+        search_properties
+          .map { |key, value| "#{' ' * 10}#{key}: #{value}" }
+          .join(",\n")
+      end
+
+      def generate
+        FileUtils.mkdir_p(output_file_directory)
+        File.open(output_file_name, 'w') { |f| f.write(output) }
+
+        group_metadata.add_test(
+          id: test_id,
+          file_name: base_output_file_name
+        )
+      end
+    end
+  end
+end