auscvdrisk_inferno 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bcbe60d262e2e5db84dbd5d0c5dd5d89ecbe1a80ce5a30db952f7c1c96c60a29
+  data.tar.gz: 9938beb41fa23bf852e852f31d7015506b17b9a559853a01396b00357863c0f7
+SHA512:
+  metadata.gz: bef956f3427cef93e9b595018a7d74e028d27705dd7e6aec017769fc75d0ed49c9806cb2ef3dd2fe7f6aa67179451546cdf0af32b1edadd51deb76e44c112539
+  data.tar.gz: 06adbbce609d183edb91bd6e2d450f34f86b80b6178f5746324f21bff229ffea58a830c0246188fcf40fc55507433b9acd65eac48a18dfeb85f460e0977622f6

data/lib/auscvdrisk/context.rb

@@ -0,0 +1,195 @@
+require_relative 'helpers'
+
+module AusCVDRisk
+  class Context < Inferno::TestGroup
+    include AusCVDRisk::Helpers
+
+    title 'Context'
+    id :context
+
+    test do
+      title 'Server declares support for reading Patient resources'
+
+      run do
+        fhir_get_capability_statement
+
+        assert_response_status(200)
+        assert_resource_type(:capability_statement)
+        capability_statement = resource
+
+        resource_type = 'Patient'
+        interaction = 'read'
+
+        rest_component = capability_statement.rest&.find { |r| r.mode == 'server' }
+        assert rest_component.present?, 'CapabilityStatement does not have a REST component with mode "server"'
+
+        resource_component = rest_component.resource&.find { |r| r.type == resource_type }
+        assert resource_component.present?, "CapabilityStatement does not declare support for #{resource_type} resource"
+
+        has_interaction = resource_component.interaction&.any? { |i| i.code == interaction }
+        assert has_interaction, "CapabilityStatement does not declare support for #{interaction} interaction on #{resource_type} resource"
+      end
+    end
+
+    test do
+      title 'Server declares support for reading Practitioner resources'
+
+      run do
+        fhir_get_capability_statement
+
+        assert_response_status(200)
+        assert_resource_type(:capability_statement)
+        capability_statement = resource
+
+        resource_type = 'Practitioner'
+        interaction = 'read'
+
+        rest_component = capability_statement.rest&.find { |r| r.mode == 'server' }
+        assert rest_component.present?, 'CapabilityStatement does not have a REST component with mode "server"'
+
+        resource_component = rest_component.resource&.find { |r| r.type == resource_type }
+        assert resource_component.present?, "CapabilityStatement does not declare support for #{resource_type} resource"
+
+        has_interaction = resource_component.interaction&.any? { |i| i.code == interaction }
+        assert has_interaction, "CapabilityStatement does not declare support for #{interaction} interaction on #{resource_type} resource"
+      end
+    end
+
+    test do
+      title 'Server declares support for AU Core Patient profile'
+
+      run do
+        fhir_get_capability_statement
+
+        assert_response_status(200)
+        assert_resource_type(:capability_statement)
+        capability_statement = resource
+
+        resource_type = 'Patient'
+        profile_url = 'http://hl7.org.au/fhir/core/StructureDefinition/au-core-patient'
+
+        has_profile = check_capability_statement_for_profile(capability_statement, resource_type, profile_url)
+
+        assert has_profile, "CapabilityStatement does not declare support for AU Core Patient profile"
+      end
+    end
+
+    test do
+      title 'Server declares support for AU Core Practitioner profile'
+
+      run do
+        fhir_get_capability_statement
+
+        assert_response_status(200)
+        assert_resource_type(:capability_statement)
+        capability_statement = resource
+
+        resource_type = 'Practitioner'
+        profile_url = 'http://hl7.org.au/fhir/core/StructureDefinition/au-core-practitioner'
+
+        has_profile = check_capability_statement_for_profile(capability_statement, resource_type, profile_url)
+
+        assert has_profile, "CapabilityStatement does not declare support for AU Core Practitioner profile"
+      end
+    end
+
+    test do
+      title 'Test Patient conforms to AU Core profile'
+
+      input :patient_id,
+            title: 'Patient ID',
+            description: 'ID of a patient resource on the server'
+
+      run do
+        skip_if patient_id.blank?, 'No patient ID provided'
+
+        fhir_read(:patient, patient_id)
+
+        assert_response_status(200)
+        assert_resource_type(:patient)
+
+        assert_valid_resource(profile_url: 'https://www.cvdcheck.org.au/fhir/StructureDefinition/CVDRiskPatient')
+        assert_valid_resource(profile_url: 'http://hl7.org.au/fhir/core/StructureDefinition/au-core-patient')
+
+        pass 'Test Patient has no validation errors'
+      end
+    end
+
+    test do
+      title 'Test Practitioner conforms to AU Core profile'
+
+      input :practitioner_id,
+            title: 'Practitioner ID',
+            description: 'ID of a practitioner resource on the server'
+
+      run do
+        skip_if practitioner_id.blank?, 'No practitioner ID provided'
+
+        fhir_read(:practitioner, practitioner_id)
+
+        assert_response_status(200)
+        assert_resource_type(:practitioner)
+
+        assert_valid_resource(profile_url: 'http://hl7.org.au/fhir/core/StructureDefinition/au-core-practitioner')
+
+        pass 'Test Practitioner has no validation errors'
+      end
+    end
+
+    test do
+      optional
+      title 'Server declares support for reading Encounter resources'
+
+      run do
+        fhir_get_capability_statement
+
+        assert_response_status(200)
+        assert_resource_type(:capability_statement)
+        capability_statement = resource
+
+        resource_type = 'Encounter'
+        interaction = 'read'
+
+        rest_component = capability_statement.rest&.find { |r| r.mode == 'server' }
+        assert rest_component.present?, 'CapabilityStatement does not have a REST component with mode "server"'
+
+        resource_component = rest_component.resource&.find { |r| r.type == resource_type }
+
+        if resource_component.present?
+          has_interaction = resource_component.interaction&.any? { |i| i.code == interaction }
+
+          if has_interaction
+            pass "Server declares support for reading Encounter resources in its CapabilityStatement"
+          else
+            warning "CapabilityStatement declares support for Encounter resource but not the read interaction"
+          end
+        else
+          warning "CapabilityStatement does not declare support for Encounter resource, but this is a SHOULD requirement"
+        end
+      end
+    end
+
+    test do
+      optional
+      title 'Test Encounter conforms to AU Core profile'
+
+      input :encounter_id,
+            title: 'Encounter ID',
+            description: 'ID of an encounter resource on the server',
+            optional: true
+
+      run do
+        assert encounter_id.present?, 'No encounter ID provided'
+
+        fhir_read(:encounter, encounter_id)
+
+        assert_response_status(200)
+        assert_resource_type(:encounter)
+
+        assert_valid_resource(profile_url: 'http://hl7.org.au/fhir/core/StructureDefinition/au-core-encounter')
+
+        pass 'Test Encounter has no validation errors'
+      end
+    end
+  end
+end

data/lib/auscvdrisk/helpers.rb

@@ -0,0 +1,125 @@
+module AusCVDRisk
+  module Helpers
+    def fhir_get_capability_statement
+      fhir_client.capabilities.resource
+      @resource = fhir_client.reply.resource
+      @response = fhir_client.reply.response
+    end
+
+    def check_capability_statement_for_profile(capability_statement, resource_type, profile_url)
+      rest_component = capability_statement.rest&.find { |r| r.mode == 'server' }
+      return false unless rest_component.present?
+
+      resource_component = rest_component.resource&.find { |r| r.type == resource_type }
+      return false unless resource_component.present?
+
+      # Check if the profile is supported
+      has_profile = resource_component.supportedProfile&.any? { |p| p.include?(profile_url) } ||
+        resource_component.profile&.include?(profile_url)
+
+      has_profile
+    end
+
+    def check_search_parameter_support(capability_statement, resource_type, parameter_name)
+      rest_component = capability_statement.rest&.find { |r| r.mode == 'server' }
+      return false unless rest_component.present?
+
+      resource_component = rest_component.resource&.find { |r| r.type == resource_type }
+      return false unless resource_component.present?
+
+      # Check if the search parameter is supported
+      has_parameter = resource_component.searchParam&.any? { |p| p.name == parameter_name }
+
+      has_parameter
+    end
+
+    def check_global_search_parameter_support(capability_statement, parameter_name)
+      rest_component = capability_statement.rest&.find { |r| r.mode == 'server' }
+      return false unless rest_component.present?
+
+      # Check if the search parameter is supported
+      has_parameter = rest_component.searchParam&.any? { |p| p.name == parameter_name }
+
+      has_parameter
+    end
+
+    def check_search_combination_support(capability_statement, resource_type, parameter_names)
+      rest_component = capability_statement.rest&.find { |r| r.mode == 'server' }
+      return false unless rest_component.present?
+
+      resource_component = rest_component.resource&.find { |r| r.type == resource_type }
+      return false unless resource_component.present?
+
+      # Check if all individual parameters are supported
+      all_params_supported = parameter_names.all? do |param|
+        resource_component.searchParam&.any? { |p| p.name == param }
+      end
+
+      # Check if the combination is explicitly supported
+      combination_supported = resource_component.searchInclude&.any? do |combo|
+        combo == parameter_names.join('+')
+      end
+
+      all_params_supported && combination_supported
+    end
+
+    def check_include_support(capability_statement, resource_type, include_param)
+      rest_component = capability_statement.rest&.find { |r| r.mode == 'server' }
+      return false unless rest_component.present?
+
+      resource_component = rest_component.resource&.find { |r| r.type == resource_type }
+      return false unless resource_component.present?
+
+      # Check if the _include parameter is supported
+      has_include = resource_component.searchInclude&.any? { |p| p == include_param }
+
+      has_include
+    end
+
+    # Verify that all search parameters in the original query are present in the self link
+    def verify_search_parameters_in_self_link(bundle, original_params)
+      assert bundle.key?('link'), 'No link found in the search results bundle'
+      self_link = bundle['link'].find { |link| link['relation'] == 'self' }
+      assert self_link.present?, 'Self link not found in the search results bundle'
+
+      # Extract the query part from the self link URL
+      query_string = self_link['url'].split('?').last
+
+      # Parse the original parameters and the self link parameters
+      original_params_hash = parse_query_string(original_params)
+      self_link_params_hash = parse_query_string(query_string)
+
+      # Check that all original parameters are in the self link
+      original_params_hash.each do |key, value|
+        return false unless self_link_params_hash.key?(key)
+
+        # For parameters that can have multiple values (comma-separated)
+        if value.include?(',')
+          original_values = value.split(',').map(&:strip)
+          self_values = if self_link_params_hash[key].include?(',')
+                          self_link_params_hash[key].split(',').map(&:strip)
+                        else
+                          [self_link_params_hash[key]]
+                        end
+
+          original_values.each do |val|
+            return false unless self_values.include?(val)
+          end
+        else
+          return false unless value == self_link_params_hash[key]
+        end
+      end
+      true
+    end
+
+    # Parse a query string into a hash of parameters
+    def parse_query_string(query_string)
+      result = {}
+      query_string.split('&').each do |param|
+        key, value = param.split('=')
+        result[key] = URI.decode_www_form_component(value) if key && value
+      end
+      result
+    end
+  end
+end

data/lib/auscvdrisk/igs/README.md

@@ -0,0 +1,21 @@
+# Note on this IGs folder
+
+There are three reasons why it would be necessary to put an IG package.tgz in this folder. If none of these apply, you do not need to put any files here, or can consider removing any existing files to make it clear they are unused.
+
+## 1. Generated Test Suites
+Some test kits use a "generator" to automatically generate the contents of a test suite for an IG. The IG files are required every time the test suites need to be regenerated. Examples of test kits that use this approach are the US Core Test Kit and CARIN IG for Blue Button® Test Kit.
+
+
+## 2. Non-published IG
+If your IG, or the specific version of the IG you want to test against, is not published, then the validator service needs to load the IG from file in order to be able to validate resources with it. The IG must be referenced in the `fhir_resource_validator` block in the test suite definition by filename, ie:
+
+```ruby
+      fhir_resource_validator do
+        igs 'igs/filename.tgz'
+
+        ...
+      end
+```
+
+## 3. Inferno Validator UI
+The Inferno Validator UI is configured to auto-load any IGs present in the igs folder and include them in all validations. In general, the Inferno team is currently leaving IGs in this folder even if not otherwise necessary to make it easy to re-enable the validator UI.

data/lib/auscvdrisk/metadata.rb

@@ -0,0 +1,18 @@
+require_relative 'version'
+
+module AusCVDRisk
+  class Metadata < Inferno::TestKit
+    id :auscvdrisk
+    title 'Aus CVD Risk-i Test Kit'
+    description <<~DESCRIPTION
+      Provides tests to aid in the integration with the Aus CVD Risk-i Calculator application.
+    DESCRIPTION
+    suite_ids [:auscvdrisk]
+    # tags ['SMART App Launch', 'US Core']
+    # last_updated '2024-03-07'
+    version VERSION
+    maturity 'Low'
+    authors ['Australian e-Health Research Centre, CSIRO']
+    # repo 'TODO'
+  end
+end

data/lib/auscvdrisk/prepop/demographics.rb

@@ -0,0 +1,58 @@
+require_relative '../helpers'
+
+module AusCVDRisk
+  module PrePopulation
+    class Demographics < Inferno::TestGroup
+      include AusCVDRisk::Helpers
+
+      title 'Pre-population: Demographics'
+      id :prepop_demographics
+
+      test do
+        optional
+        title 'Server declares support for CVD Risk Patient profile'
+
+        run do
+          fhir_get_capability_statement
+
+          assert_response_status(200)
+          assert_resource_type(:capability_statement)
+          capability_statement = resource
+
+          resource_type = 'Patient'
+          profile_url = 'https://www.cvdcheck.org.au/fhir/StructureDefinition/CVDRiskPatient'
+
+          has_profile = check_capability_statement_for_profile(capability_statement, resource_type, profile_url)
+
+          if has_profile
+            pass "Server declares support for CVD Risk Patient profile"
+          else
+            assert false, "CapabilityStatement does not declare support for CVD Risk Patient profile"
+          end
+        end
+      end
+
+      test do
+        optional
+        title 'Test Patient conforms to CVD Risk Patient profile'
+
+        input :patient_id,
+              title: 'Patient ID',
+              description: 'ID of a patient resource on the server'
+
+        run do
+          skip_if patient_id.blank?, 'No patient ID provided'
+
+          fhir_read(:patient, patient_id)
+
+          assert_response_status(200)
+          assert_resource_type(:patient)
+
+          assert_valid_resource(profile_url: 'https://www.cvdcheck.org.au/fhir/StructureDefinition/CVDRiskPatient')
+
+          pass 'Test Patient has no validation errors'
+        end
+      end
+    end
+  end
+end