davinci_us_drug_formulary_test_kit 0.9.0

data/lib/davinci_us_drug_formulary_test_kit/fhir_resource_navigation.rb

@@ -0,0 +1,155 @@
+module DaVinciUSDrugFormularyTestKit
+  module FHIRResourceNavigation
+    DAR_EXTENSION_URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason'.freeze
+
+    def resolve_path(elements, path)
+      elements = Array.wrap(elements)
+      return elements if path.blank?
+
+      paths = path.split(/(?<!hl7)\./)
+      segment = paths.first
+      remaining_path = paths.drop(1).join('.')
+
+      elements.flat_map do |element|
+        child = get_next_value(element, segment)
+        resolve_path(child, remaining_path)
+      end.compact
+    end
+
+    def find_a_value_at(element, path, include_dar: false, &block)
+      return nil if element.nil?
+
+      elements = Array.wrap(element)
+
+      if path.empty?
+        unless include_dar
+          elements = elements.reject do |el|
+            el.respond_to?(:extension) && el.extension.any? { |ext| ext.url == DAR_EXTENSION_URL }
+          end
+        end
+
+        return elements.find(&block) if block_given?
+
+        return elements.first
+      end
+
+      path_segments = path.split(/(?<!hl7)\./)
+      segment = path_segments.shift.delete_suffix('[x]').gsub(/^class$/, 'local_class').gsub('[x]:', ':').to_sym
+
+      no_elements_present =
+        elements.none? do |element|
+          child = get_next_value(element, segment)
+
+          child.present? || child == false
+        end
+
+      return nil if no_elements_present
+
+      remaining_path = path_segments.join('.')
+
+      elements.each do |element|
+        child = get_next_value(element, segment)
+        element_found =
+          if block_given?
+            find_a_value_at(child, remaining_path, include_dar:, &block)
+          else
+            find_a_value_at(child, remaining_path, include_dar:)
+          end
+
+        return element_found if element_found.present? || element_found == false
+      end
+
+      nil
+    end
+
+    def get_next_value(element, property)
+      extension_url = property[/(?<=where\(url=').*(?='\))/]
+
+      if extension_url.present?
+        element.url == extension_url ? element : nil
+      elsif property.to_s.include?(':') && !property.to_s.include?('url')
+        find_slice_via_discriminator(element, property)
+
+      else
+        element.send(property)
+      end
+    rescue NoMethodError
+      nil
+    end
+
+    def find_slice_via_discriminator(element, property)
+      element_name = property.to_s.split(':')[0].gsub(/^class$/, 'local_class')
+      slice_name = property.to_s.split(':')[1].gsub(/^class$/, 'local_class')
+      if metadata.present?
+        slice_by_name = metadata.must_supports[:slices].find { |slice| slice[:slice_name] == slice_name }
+        discriminator = slice_by_name[:discriminator]
+        slices = Array.wrap(element.send(element_name))
+        slices.find do |slice|
+          case discriminator[:type]
+          when 'patternCodeableConcept'
+            slice_value = discriminator[:path].present? ? slice.send((discriminator[:path]).to_s).coding : slice.coding
+            slice_value.any? { |coding| coding.code == discriminator[:code] && coding.system == discriminator[:system] }
+          when 'patternCoding'
+            slice_value = discriminator[:path].present? ? slice.send(discriminator[:path]) : slice
+            slice_value.code == discriminator[:code] && slice_value.system == discriminator[:system]
+          when 'patternIdentifier'
+            slice.identifier.system == discriminator[:system]
+          when 'value'
+            values = discriminator[:values].map { |value| value.merge(path: value[:path].split('.')) }
+            verify_slice_by_values(slice, values)
+          when 'type'
+            case discriminator[:code]
+            when 'Date'
+              begin
+                Date.parse(slice)
+              rescue ArgumentError
+                false
+              end
+            when 'DateTime'
+              begin
+                DateTime.parse(slice)
+              rescue ArgumentError
+                false
+              end
+            when 'String'
+              slice.is_a? String
+            else
+              slice.is_a? FHIR.const_get(discriminator[:code])
+            end
+          when 'requiredBinding'
+            discriminator[:path].present? ? slice.send((discriminator[:path]).to_s).coding : slice.coding
+            slice_value { |coding| discriminator[:values].include?(coding.code) }
+          end
+        end
+      else
+        # TODO: Error handling for if this file doesn't have access to metadata for some reason (begin/rescue with StandardError?)
+      end
+    end
+
+    def verify_slice_by_values(element, value_definitions)
+      path_prefixes = value_definitions.map { |value_definition| value_definition[:path].first }.uniq
+      path_prefixes.all? do |path_prefix|
+        value_definitions_for_path =
+          value_definitions
+            .select { |value_definition| value_definition[:path].first == path_prefix }
+            .each { |value_definition| value_definition[:path].shift }
+        find_a_value_at(element, path_prefix) do |el_found|
+          child_element_value_definitions, current_element_value_definitions =
+            value_definitions_for_path.partition { |value_definition| value_definition[:path].present? }
+
+          current_element_values_match =
+            current_element_value_definitions
+              .all? { |value_definition| value_definition[:value] == el_found }
+
+          child_element_values_match =
+            if child_element_value_definitions.present?
+              verify_slice_by_values(el_found, child_element_value_definitions)
+            else
+              true
+            end
+          current_element_values_match && child_element_values_match
+        end
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generated/v2.0.1/basic/basic_code_search_test.rb

@@ -0,0 +1,54 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciUSDrugFormularyTestKit
+  module DaVinciUSDrugFormularyV201
+    class BasicCodeSearchTest < Inferno::Test
+      include DaVinciUSDrugFormularyTestKit::SearchTest
+
+      title 'Server returns valid results for Basic search by code'
+      description %(
+A server SHALL support searching by
+code on the Basic 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 US Core v2.0.1.
+
+[US Drug Formulary](http://hl7.org/fhir/us/davinci-drug-formulary/STU2/CapabilityStatement-usdf-server.html)
+
+      )
+
+      id :usdf_v201_basic_code_search_test
+  
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          first_search: true,
+          fixed_value_search: true,
+          resource_type: 'Basic',
+          search_param_names: ['code'],
+          token_search_params: ['code'],
+          test_post_search: true
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:basic_resources] ||= {}
+      end
+
+      run do
+        run_search_test 
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generated/v2.0.1/basic/basic_drug_tier_search_test.rb

@@ -0,0 +1,43 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciUSDrugFormularyTestKit
+  module DaVinciUSDrugFormularyV201
+    class BasicDrugTierSearchTest < Inferno::Test
+      include DaVinciUSDrugFormularyTestKit::SearchTest
+
+      title 'Server returns valid results for Basic search by drug-tier'
+      description %(
+A server SHALL support searching by
+drug-tier on the Basic resource. This test
+will pass if resources are returned and match the search criteria. If
+none are returned, the test is skipped.
+
+[US Drug Formulary](http://hl7.org/fhir/us/davinci-drug-formulary/STU2/CapabilityStatement-usdf-server.html)
+
+      )
+
+      id :usdf_v201_basic_drug_tier_search_test
+  
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'Basic',
+          search_param_names: ['drug-tier'],
+          token_search_params: ['drug-tier']
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:basic_resources] ||= {}
+      end
+
+      run do
+        run_search_test 
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generated/v2.0.1/basic/basic_formulary_include_search_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciUSDrugFormularyTestKit
+  module DaVinciUSDrugFormularyV201
+    class BasicFormularyIncludeSearchTest < Inferno::Test
+      include DaVinciUSDrugFormularyTestKit::SearchTest
+
+      title 'Server returns InsurancePlan resources from Basic search by _include=formulary'
+      description %(
+        A server SHALL be capable of supporting _includes for formulary.
+
+        This test will perform a search using _include=formulary and
+        will pass if the referenced InsurancePlan is included in the response.
+      )
+
+      id :usdf_v201_basic_formulary_include_search_test
+
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'Basic',
+          search_param_names: ["code"],
+          include_param: 'formulary'
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml')))
+      end
+
+      def self.include_metadata
+        @include_metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, '..', 'InsurancePlan', 'metadata.yml'), aliases: true))
+      end
+
+      run do
+        run_include_search_test
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generated/v2.0.1/basic/basic_formulary_search_test.rb

@@ -0,0 +1,43 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciUSDrugFormularyTestKit
+  module DaVinciUSDrugFormularyV201
+    class BasicFormularySearchTest < Inferno::Test
+      include DaVinciUSDrugFormularyTestKit::SearchTest
+
+      title 'Server returns valid results for Basic search by formulary'
+      description %(
+A server SHALL support searching by
+formulary on the Basic resource. This test
+will pass if resources are returned and match the search criteria. If
+none are returned, the test is skipped.
+
+[US Drug Formulary](http://hl7.org/fhir/us/davinci-drug-formulary/STU2/CapabilityStatement-usdf-server.html)
+
+      )
+
+      id :usdf_v201_basic_formulary_search_test
+  
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'Basic',
+          search_param_names: ['formulary'],
+          test_reference_variants: true
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:basic_resources] ||= {}
+      end
+
+      run do
+        run_search_test 
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generated/v2.0.1/basic/basic_id_search_test.rb

@@ -0,0 +1,42 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciUSDrugFormularyTestKit
+  module DaVinciUSDrugFormularyV201
+    class BasicIdSearchTest < Inferno::Test
+      include DaVinciUSDrugFormularyTestKit::SearchTest
+
+      title 'Server returns valid results for Basic search by _id'
+      description %(
+A server SHALL support searching by
+_id on the Basic resource. This test
+will pass if resources are returned and match the search criteria. If
+none are returned, the test is skipped.
+
+[US Drug Formulary](http://hl7.org/fhir/us/davinci-drug-formulary/STU2/CapabilityStatement-usdf-server.html)
+
+      )
+
+      id :usdf_v201_basic__id_search_test
+  
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'Basic',
+          search_param_names: ['_id']
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:basic_resources] ||= {}
+      end
+
+      run do
+        run_search_test 
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generated/v2.0.1/basic/basic_lastupdated_search_test.rb

@@ -0,0 +1,42 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciUSDrugFormularyTestKit
+  module DaVinciUSDrugFormularyV201
+    class BasicLastupdatedSearchTest < Inferno::Test
+      include DaVinciUSDrugFormularyTestKit::SearchTest
+
+      title 'Server returns valid results for Basic search by _lastUpdated'
+      description %(
+A server SHALL support searching by
+_lastUpdated on the Basic resource. This test
+will pass if resources are returned and match the search criteria. If
+none are returned, the test is skipped.
+
+[US Drug Formulary](http://hl7.org/fhir/us/davinci-drug-formulary/STU2/CapabilityStatement-usdf-server.html)
+
+      )
+
+      id :usdf_v201_basic__lastUpdated_search_test
+  
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'Basic',
+          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[:basic_resources] ||= {}
+      end
+
+      run do
+        run_search_test 
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generated/v2.0.1/basic/basic_must_support_test.rb

@@ -0,0 +1,46 @@
+require_relative '../../../must_support_test'
+
+module DaVinciUSDrugFormularyTestKit
+  module DaVinciUSDrugFormularyV201
+    class BasicMustSupportTest < Inferno::Test
+      include DaVinciUSDrugFormularyTestKit::MustSupportTest
+
+      title 'All must support elements are provided in the Basic resources returned'
+      description %(
+        US Drug Formulary Responders SHALL be capable of populating all data elements as
+        part of the query results as specified by the US Drug Formulary Capability
+        Statement. This test will look through the Basic resources
+        found previously for the following must support elements:
+
+        * Basic.extension:usdf-AvailabilityPeriod-extension
+        * Basic.extension:usdf-AvailabilityStatus-extension
+        * Basic.extension:usdf-DrugTierID-extension
+        * Basic.extension:usdf-FormularyReference-extension
+        * Basic.extension:usdf-PharmacyBenefitType-extension
+        * Basic.extension:usdf-PriorAuthorization-extension
+        * Basic.extension:usdf-QuantityLimit-extension
+        * Basic.extension:usdf-StepTherapyLimit-extension
+        * Basic.meta.lastUpdated
+        * Basic.subject
+      )
+
+      id :usdf_v201_basic_must_support_test
+
+      def resource_type
+        'Basic'
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:basic_resources] ||= {}
+      end
+
+      run do
+        perform_must_support_test(all_scratch_resources)
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generated/v2.0.1/basic/basic_period_search_test.rb

@@ -0,0 +1,42 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciUSDrugFormularyTestKit
+  module DaVinciUSDrugFormularyV201
+    class BasicPeriodSearchTest < Inferno::Test
+      include DaVinciUSDrugFormularyTestKit::SearchTest
+
+      title 'Server returns valid results for Basic search by period'
+      description %(
+A server SHALL support searching by
+period on the Basic resource. This test
+will pass if resources are returned and match the search criteria. If
+none are returned, the test is skipped.
+
+[US Drug Formulary](http://hl7.org/fhir/us/davinci-drug-formulary/STU2/CapabilityStatement-usdf-server.html)
+
+      )
+
+      id :usdf_v201_basic_period_search_test
+  
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'Basic',
+          search_param_names: ['period']
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:basic_resources] ||= {}
+      end
+
+      run do
+        run_search_test 
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generated/v2.0.1/basic/basic_pharmacy_benefit_type_search_test.rb

@@ -0,0 +1,43 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciUSDrugFormularyTestKit
+  module DaVinciUSDrugFormularyV201
+    class BasicPharmacyBenefitTypeSearchTest < Inferno::Test
+      include DaVinciUSDrugFormularyTestKit::SearchTest
+
+      title 'Server returns valid results for Basic search by pharmacy-benefit-type'
+      description %(
+A server SHALL support searching by
+pharmacy-benefit-type on the Basic resource. This test
+will pass if resources are returned and match the search criteria. If
+none are returned, the test is skipped.
+
+[US Drug Formulary](http://hl7.org/fhir/us/davinci-drug-formulary/STU2/CapabilityStatement-usdf-server.html)
+
+      )
+
+      id :usdf_v201_basic_pharmacy_benefit_type_search_test
+  
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'Basic',
+          search_param_names: ['pharmacy-benefit-type'],
+          token_search_params: ['pharmacy-benefit-type']
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:basic_resources] ||= {}
+      end
+
+      run do
+        run_search_test 
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generated/v2.0.1/basic/basic_read_test.rb

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

data/lib/davinci_us_drug_formulary_test_kit/generated/v2.0.1/basic/basic_reference_resolution_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../../reference_resolution_test'
+
+module DaVinciUSDrugFormularyTestKit
+  module DaVinciUSDrugFormularyV201
+    class BasicReferenceResolutionTest < Inferno::Test
+      include DaVinciUSDrugFormularyTestKit::ReferenceResolutionTest
+
+      title 'MustSupport references within Basic 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 US Core profile.
+
+        Elements which may provide external references include:
+
+        * Basic.subject
+      )
+
+      id :usdf_v201_basic_reference_resolution_test
+
+      def resource_type
+        'Basic'
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:basic_resources] ||= {}
+      end
+
+      run do
+        perform_reference_resolution_test(scratch_resources[:all])
+      end
+    end
+  end
+end

data/lib/davinci_us_drug_formulary_test_kit/generated/v2.0.1/basic/basic_status_search_test.rb

@@ -0,0 +1,42 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciUSDrugFormularyTestKit
+  module DaVinciUSDrugFormularyV201
+    class BasicStatusSearchTest < Inferno::Test
+      include DaVinciUSDrugFormularyTestKit::SearchTest
+
+      title 'Server returns valid results for Basic search by status'
+      description %(
+A server SHALL support searching by
+status on the Basic resource. This test
+will pass if resources are returned and match the search criteria. If
+none are returned, the test is skipped.
+
+[US Drug Formulary](http://hl7.org/fhir/us/davinci-drug-formulary/STU2/CapabilityStatement-usdf-server.html)
+
+      )
+
+      id :usdf_v201_basic_status_search_test
+  
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'Basic',
+          search_param_names: ['status']
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:basic_resources] ||= {}
+      end
+
+      run do
+        run_search_test 
+      end
+    end
+  end
+end