ips_test_kit 0.0.1

data/lib/ips/device_observer.rb

@@ -0,0 +1,40 @@
+module IPS
+  class DeviceObserver < Inferno::TestGroup
+    title 'Device (performer, observer) Tests'
+    description 'Verify support for the server capabilities required by the Device (performer, observer) profile.'
+    id :ips_device_observer
+
+    test do
+      title 'Server returns correct Device resource from the Device read interaction'
+      description %(
+        This test will verify that Device resources can be read from the server.
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition/Device-observer-uv-ips'
+
+      input :device_id
+      makes_request :device_observer
+
+      run do
+        fhir_read(:device, device_id, name: :device_observer)
+
+        assert_response_status(200)
+        assert_resource_type(:device)
+        assert resource.id == device_id,
+               "Requested resource with id #{device_id}, received resource with id #{resource.id}"
+      end
+    end
+
+    test do
+      title 'Server returns Device resource that matches the Device (performer, observer) profile'
+      description %(
+        This test will validate that the Device resource returned from the server matches the Device (performer, observer) profile.
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition/Device-observer-uv-ips'
+      uses_request :device_observer
+
+      run do
+        assert_valid_resource(profile_url: 'http://hl7.org/fhir/uv/ips/StructureDefinition/Device-observer-uv-ips')
+      end
+    end
+  end
+end

data/lib/ips/device_use_statement.rb

@@ -0,0 +1,40 @@
+module IPS
+  class DeviceUseStatement < Inferno::TestGroup
+    title 'Device Use Statement (IPS) Tests'
+    description 'Verify support for the server capabilities required by the Device Use Statement (IPS) profile.'
+    id :ips_device_use_statement
+
+    test do
+      title 'Server returns correct DeviceUseStatement resource from the DeviceUseStatement read interaction'
+      description %(
+        This test will verify that DeviceUseStatement resources can be read from the server.
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition/DeviceUseStatement-uv-ips'
+
+      input :device_use_statement_id
+      makes_request :device_use_statement
+
+      run do
+        fhir_read(:device_use_statement, device_use_statement_id, name: :device_use_statement)
+
+        assert_response_status(200)
+        assert_resource_type(:device_use_statement)
+        assert resource.id == device_use_statement_id,
+               "Requested resource with id #{device_use_statement_id}, received resource with id #{resource.id}"
+      end
+    end
+
+    test do
+      title 'Server returns DeviceUseStatement resource that matches the Device Use Statement (IPS) profile'
+      description %(
+        This test will validate that the DeviceUseStatement resource returned from the server matches the Device Use Statement (IPS) profile.
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition/DeviceUseStatement-uv-ips'
+      uses_request :device_use_statement
+
+      run do
+        assert_valid_resource(profile_url: 'http://hl7.org/fhir/uv/ips/StructureDefinition/DeviceUseStatement-uv-ips')
+      end
+    end
+  end
+end

data/lib/ips/diagnostic_report.rb

@@ -0,0 +1,40 @@
+module IPS
+  class DiagnosticReport < Inferno::TestGroup
+    title 'DiagnosticReport (IPS) Tests'
+    description 'Verify support for the server capabilities required by the DiagnosticReport (IPS) profile.'
+    id :ips_diagnostic_report
+
+    test do
+      title 'Server returns correct DiagnosticReport resource from the DiagnosticReport read interaction'
+      description %(
+        This test will verify that DiagnosticReport resources can be read from the server.
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition/DiagnosticReport-uv-ips'
+
+      input :diagnostic_report_id
+      makes_request :diagnostic_report
+
+      run do
+        fhir_read(:diagnostic_report, diagnostic_report_id, name: :diagnostic_report)
+
+        assert_response_status(200)
+        assert_resource_type(:diagnostic_report)
+        assert resource.id == diagnostic_report_id,
+               "Requested resource with id #{diagnostic_report_id}, received resource with id #{resource.id}"
+      end
+    end
+
+    test do
+      title 'Server returns DiagnosticReport resource that matches the DiagnosticReport (IPS) profile'
+      description %(
+        This test will validate that the DiagnosticReport resource returned from the server matches the DiagnosticReport (IPS) profile.
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition/DiagnosticReport-uv-ips'
+      uses_request :diagnostic_report
+
+      run do
+        assert_valid_resource(profile_url: 'http://hl7.org/fhir/uv/ips/StructureDefinition/DiagnosticReport-uv-ips')
+      end
+    end
+  end
+end

data/lib/ips/document_operation.rb

@@ -0,0 +1,192 @@
+module IPS
+  class DocumentOperation < Inferno::TestGroup
+    title 'Document Operation Tests'
+    description 'Verify support for the $document operation required by the Specimen (IPS) profile.'
+    id :ips_document_operation
+
+    test do
+      title 'IPS Server declares support for $document operation in CapabilityStatement'
+      description %(
+        The IPS Server SHALL declare support for Composition/[id]/$document operation in its server CapabilityStatement
+      )
+      # link 'http://build.fhir.org/composition-operation-document.html'
+
+      run do
+        fhir_get_capability_statement
+        assert_response_status(200)
+        assert_resource_type(:capability_statement)
+
+        operations = resource.rest&.flat_map do |rest|
+          rest.resource
+            &.select { |r| r.type == 'Composition' && r.respond_to?(:operation) }
+            &.flat_map(&:operation)
+        end&.compact
+
+        operation_defined = operations.any? do |operation|
+          operation.definition == 'http://hl7.org/fhir/OperationDefinition/Composition-document' ||
+            ['document', 'composition-document'].include?(operation.name.downcase)
+        end
+
+        assert operation_defined, 'Server CapabilityStatement did not declare support for $document operation in Composition resource.'
+      end
+    end
+
+    test do
+      title 'Server returns a fully bundled document from a Composition resource'
+      description %(
+        This test will perform the $document operation on the chosen composition resource with the persist option on.
+        It will verify that all referenced resources in the composition are in the document bundle and that we are able to retrieve the bundle after it's generated.
+      )
+      # link 'https://www.hl7.org/fhir/composition-operation-document.html'
+
+      input :composition_id
+      makes_request :document_operation
+
+      run do
+        fhir_read(:composition, composition_id)
+
+        assert_response_status(200)
+        assert_resource_type(:composition)
+        assert resource.id == composition_id,
+               "Requested resource with id #{composition_id}, received resource with id #{resource.id}"
+
+        assert_valid_resource(profile_url: 'http://hl7.org/fhir/uv/ips/StructureDefinition/Composition-uv-ips')
+
+        composition = resource
+        references_in_composition = []
+        walk_resource(composition) do |value, meta, _path|
+          next if meta['type'] != 'Reference'
+          next if value.reference.blank?
+
+          references_in_composition << value
+        end
+
+        fhir_operation("Composition/#{composition.id}/$document?persist=true", name: :document_operation)
+        assert_response_status(200)
+        assert_resource_type(:bundle)
+
+        bundled_resources = resource.entry.map(&:resource)
+        missing_resources =
+          references_in_composition
+            .select(&:relative?)
+            .select do |reference|
+              resource_class = reference.resource_class
+              resource_id = reference.reference.split('/').last
+              bundled_resources.none? do |resource|
+                resource.instance_of?(resource_class) && resource.id == resource_id
+              end
+            end
+
+        assert missing_resources.empty?,
+               'The following resources were missing in the response from the document ' \
+               "operation: #{missing_resources.map(&:reference).join(',')}"
+      end
+    end
+
+    test do
+      title 'IPS Server returns Bundle resource for Composition/id/$document operation'
+      description %(
+        IPS Server return valid IPS Bundle resource as successful result of $document operation
+
+        POST [base]/Composition/id/$document
+      )
+      # link 'https://www.hl7.org/fhir/composition-operation-document.html'
+      uses_request :document_operation
+
+      run do
+        skip_if !resource.is_a?(FHIR::Bundle), 'No Bundle returned from document operation'
+
+        assert_valid_resource(profile_url: 'http://hl7.org/fhir/uv/ips/StructureDefinition/Bundle-uv-ips')
+      end
+    end
+
+    test do
+      title 'IPS Server returns Bundle resource containing valid IPS Composition entry'
+      description %(
+        IPS Server return valid IPS Composition resource in the Bundle as first entry
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition-Composition-uv-ips.html'
+      uses_request :document_operation
+
+      run do
+        skip_if !resource.is_a?(FHIR::Bundle), 'No Bundle returned from document operation'
+
+        assert resource.entry.length.positive?, 'Bundle has no entries'
+
+        entry = resource.entry.first
+
+        assert entry.resource.is_a?(FHIR::Composition), 'The first entry in the Bundle is not a Composition'
+        assert_valid_resource(resource: entry, profile_url: 'http://hl7.org/fhir/uv/ips/StructureDefinition/Composition-uv-ips')
+      end
+    end
+
+    test do
+      title 'IPS Server returns Bundle resource containing valid IPS MedicationStatement entry'
+      description %(
+        IPS Server return valid IPS MedicationStatement resource in the Bundle as first entry
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition-MedicationStatement-uv-ips.html'
+      uses_request :document_operation
+
+      run do
+        skip_if !resource.is_a?(FHIR::Bundle), 'No Bundle returned from document operation'
+
+        resources_present = resource.entry.any? { |r| r.resource.is_a?(FHIR::MedicationStatement) }
+
+        assert resources_present, 'Bundle does not contain any MedicationStatement resources'
+
+        assert_valid_bundle_entries(
+          resource_types: {
+            medication_statement: 'http://hl7.org/fhir/uv/ips/StructureDefinition/MedicationStatement-uv-ips'
+          }
+        )
+      end
+    end
+
+    test do
+      title 'IPS Server returns Bundle resource containing valid IPS AllergyIntolerance entry'
+      description %(
+        IPS Server return valid IPS AllergyIntolerance resource in the Bundle as first entry
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition-AllergyIntolerance-uv-ips.html'
+      uses_request :document_operation
+
+      run do
+        skip_if !resource.is_a?(FHIR::Bundle), 'No Bundle returned from document operation'
+
+        resources_present = resource.entry.any? { |r| r.resource.is_a?(FHIR::AllergyIntolerance) }
+
+        assert resources_present, 'Bundle does not contain any AllergyIntolerance resources'
+
+        assert_valid_bundle_entries(
+          resource_types: {
+            allergy_intolerance: 'http://hl7.org/fhir/uv/ips/StructureDefinition/AllergyIntolerance-uv-ips'
+          }
+        )
+      end
+    end
+
+    test do
+      title 'IPS Server returns Bundle resource containing valid IPS Condition entry'
+      description %(
+        IPS Server return valid IPS Condition resource in the Bundle as first entry
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition-Condition-uv-ips.html'
+      uses_request :document_operation
+
+      run do
+        skip_if !resource.is_a?(FHIR::Bundle), 'No Bundle returned from document operation'
+
+        resources_present = resource.entry.any? { |r| r.resource.is_a?(FHIR::Condition) }
+
+        assert resources_present, 'Bundle does not contain any Condition resources'
+
+        assert_valid_bundle_entries(
+          resource_types: {
+            condition: 'http://hl7.org/fhir/uv/ips/StructureDefinition/Condition-uv-ips'
+          }
+        )
+      end
+    end
+  end
+end

data/lib/ips/imaging_study.rb

@@ -0,0 +1,40 @@
+module IPS
+  class ImagingStudy < Inferno::TestGroup
+    title 'Imaging Study (IPS) Tests'
+    description 'Verify support for the server capabilities required by the Imaging Study (IPS) profile.'
+    id :ips_imaging_study
+
+    test do
+      title 'Server returns correct ImagingStudy resource from the ImagingStudy read interaction'
+      description %(
+        This test will verify that ImagingStudy resources can be read from the server.
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition/ImagingStudy-uv-ips'
+
+      input :imaging_study_id
+      makes_request :imaging_study
+
+      run do
+        fhir_read(:imaging_study, imaging_study_id, name: :imaging_study)
+
+        assert_response_status(200)
+        assert_resource_type(:imaging_study)
+        assert resource.id == imaging_study_id,
+               "Requested resource with id #{imaging_study_id}, received resource with id #{resource.id}"
+      end
+    end
+
+    test do
+      title 'Server returns ImagingStudy resource that matches the Imaging Study (IPS) profile'
+      description %(
+        This test will validate that the ImagingStudy resource returned from the server matches the Imaging Study (IPS) profile.
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition/ImagingStudy-uv-ips'
+      uses_request :imaging_study
+
+      run do
+        assert_valid_resource(profile_url: 'http://hl7.org/fhir/uv/ips/StructureDefinition/ImagingStudy-uv-ips')
+      end
+    end
+  end
+end

data/lib/ips/immunization.rb

@@ -0,0 +1,40 @@
+module IPS
+  class Immunization < Inferno::TestGroup
+    title 'Immunization (IPS) Tests'
+    description 'Verify support for the server capabilities required by the Immunization (IPS) profile.'
+    id :ips_immunization
+
+    test do
+      title 'Server returns correct Immunization resource from the Immunization read interaction'
+      description %(
+        This test will verify that Immunization resources can be read from the server.
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition/Immunization-uv-ips'
+
+      input :immunization_id
+      makes_request :immunization
+
+      run do
+        fhir_read(:immunization, immunization_id, name: :immunization)
+
+        assert_response_status(200)
+        assert_resource_type(:immunization)
+        assert resource.id == immunization_id,
+               "Requested resource with id #{immunization_id}, received resource with id #{resource.id}"
+      end
+    end
+
+    test do
+      title 'Server returns Immunization resource that matches the Immunization (IPS) profile'
+      description %(
+        This test will validate that the Immunization resource returned from the server matches the Immunization (IPS) profile.
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition/Immunization-uv-ips'
+      uses_request :immunization
+
+      run do
+        assert_valid_resource(profile_url: 'http://hl7.org/fhir/uv/ips/StructureDefinition/Immunization-uv-ips')
+      end
+    end
+  end
+end

data/lib/ips/media_observation.rb

@@ -0,0 +1,40 @@
+module IPS
+  class MediaObservation < Inferno::TestGroup
+    title 'Media observation (Results: laboratory, media) Tests'
+    description 'Verify support for the server capabilities required by the Media observation (Results: laboratory, media) profile.'
+    id :ips_media_observation
+
+    test do
+      title 'Server returns correct Media resource from the Media read interaction'
+      description %(
+        This test will verify that Media resources can be read from the server.
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition/Media-observation-uv-ips'
+
+      input :media_id
+      makes_request :media
+
+      run do
+        fhir_read(:media, media_id, name: :media)
+
+        assert_response_status(200)
+        assert_resource_type(:media)
+        assert resource.id == media_id,
+               "Requested resource with id #{media_id}, received resource with id #{resource.id}"
+      end
+    end
+
+    test do
+      title 'Server returns Media resource that matches the Media observation (Results: laboratory, media) profile'
+      description %(
+        This test will validate that the Media resource returned from the server matches the Media observation (Results: laboratory, media) profile.
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition/Media-observation-uv-ips'
+      uses_request :media
+
+      run do
+        assert_valid_resource(profile_url: 'http://hl7.org/fhir/uv/ips/StructureDefinition/Media-observation-uv-ips')
+      end
+    end
+  end
+end

data/lib/ips/medication.rb

@@ -0,0 +1,40 @@
+module IPS
+  class Medication < Inferno::TestGroup
+    title 'Medication (IPS) Tests'
+    description 'Verify support for the server capabilities required by the Medication (IPS) profile.'
+    id :ips_medication
+
+    test do
+      title 'Server returns correct Medication resource from the Medication read interaction'
+      description %(
+        This test will verify that Medication resources can be read from the server.
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition/Medication-uv-ips'
+
+      input :medication_id
+      makes_request :medication
+
+      run do
+        fhir_read(:medication, medication_id, name: :medication)
+
+        assert_response_status(200)
+        assert_resource_type(:medication)
+        assert resource.id == medication_id,
+               "Requested resource with id #{medication_id}, received resource with id #{resource.id}"
+      end
+    end
+
+    test do
+      title 'Server returns Medication resource that matches the Medication (IPS) profile'
+      description %(
+        This test will validate that the Medication resource returned from the server matches the Medication (IPS) profile.
+      )
+      # link 'http://hl7.org/fhir/uv/ips/StructureDefinition/Medication-uv-ips'
+      uses_request :medication
+
+      run do
+        assert_valid_resource(profile_url: 'http://hl7.org/fhir/uv/ips/StructureDefinition/Medication-uv-ips')
+      end
+    end
+  end
+end