plan_executor 1.0.2

data/lib/tests/suites/daf_profiles_test.rb

@@ -0,0 +1,431 @@
+module Crucible
+  module Tests
+    class DataAccessFrameworkProfilesTest < BaseSuite
+
+      def id
+        'DataAccessFrameworkProfilesTest'
+      end
+
+      def description
+        'Test support for the U.S. Data Access Framework (DAF) Implementation Guide'
+      end
+
+      def initialize(client1, client2=nil)
+        super(client1, client2)
+        @tags.append('argonaut')
+        @category = {id: 'core_functionality', title: 'Core Functionality'}
+      end
+
+      def setup
+        @server_side_resources = {}
+        @resources = Crucible::Generator::Resources.new
+        @daf_conformance = @resources.daf_conformance
+
+        # Try to create a DAF patient on the server.
+        # This will facilitate SEARCH testing, if it succeeds.
+        # Do not assert that the creation worked, because CREATE is *not*
+        # required by DAF. This is a read-only test.
+        @daf_patient = Crucible::Tests::DAFResourceGenerator.daf_patient
+        reply = @client.create(@daf_patient)
+        @daf_patient.xmlId = reply.id if !reply.id.nil?
+        # assert_response_created(reply)
+      end
+
+      def teardown
+        # delete resources
+        @client.destroy(FHIR::Patient, @daf_patient.xmlId) if @daf_patient && !@daf_patient.xmlId.nil?
+      end
+
+      # Check Conformance for DAF Profiles
+      test 'DAF00','Check Conformance for DAF Profiles' do
+        metadata {
+          links "#{REST_SPEC_LINK}#conformance"
+          links "#{BASE_SPEC_LINK}/conformance.html"
+          links "#{BASE_SPEC_LINK}/daf/daf.html"
+          requires resource: 'Conformance', methods: ['read']
+          validates resource: 'Conformance', methods: ['read']
+        }
+
+        @conformance = @client.conformanceStatement
+
+        # Collect the list of DAF profiles
+        daf_profiles = @daf_conformance.profile.map{|x|x.reference}
+
+        # Check that the conformance declares support for all the DAF profiles
+        root_profiles = @conformance.profile.map{|x|x.try(:reference)}.compact
+        rest_profiles = @conformance.rest.map{|r|r.resource.map{|r|r.try(:profile).try(:reference)}}.flatten.compact
+
+        missing_daf_profiles = daf_profiles - root_profiles - rest_profiles
+        assert(missing_daf_profiles.compact.empty?, "The Conformance statement does not declare support for the following DAF profiles: #{missing_daf_profiles}", @conformance.to_xml)
+      end
+
+      # Check Conformance for SMART Security Extensions
+      test 'DAF01','Check Conformance for SMART-on-FHIR Security Extensions' do
+        metadata {
+          links "#{REST_SPEC_LINK}#conformance"
+          links "#{BASE_SPEC_LINK}/conformance.html"
+          links "#{BASE_SPEC_LINK}/daf/daf.html"
+          requires resource: 'Conformance', methods: ['read']
+          validates resource: 'Conformance', methods: ['read']
+        }
+
+        smart_security_base = 'http://fhir-registry.smarthealthit.org/StructureDefinition/oauth-uris'
+        smart_security_extensions = ['register','authorize','token']
+
+        @rest_index = nil
+        @found_smart_code = false 
+        found_smart_base = false
+
+        @conformance.rest.each_with_index do |rest,index|
+          service = rest.try(:security).try(:service)
+          if !service.nil? && !service.empty?
+            service.each do |concept|
+              concept.coding.each do |coding|
+                @found_smart_code = (!coding.nil? && coding.code=='SMART-on-FHIR' && coding.system=='http://hl7.org/fhir/restful-security-service')
+                if @found_smart_code
+                  @rest_index = index
+                  rest.security.extension.each do |x|
+                    found_smart_base = (x.url == smart_security_base)
+                    if found_smart_base
+                      x.extension.each do |y|
+                        smart_security_extensions.delete(y.url)
+                      end
+                    end
+                  end # each extension
+                end
+              end # each security code
+            end
+          end
+        end # each restful endpoint
+
+        assert(@found_smart_code,'Conformance does not declare the SMART-on-FHIR security service for any REST endpoints.',@conformance.to_xml)
+        assert((found_smart_base && smart_security_extensions.empty?),"Conformance does not declare the SMART-on-FHIR security extensions: #{smart_security_base} #{smart_security_extensions}",@conformance.to_xml)
+      end
+
+      # Check that Conformance Resource Interactions
+      test 'DAF02','Check Conformance Resource Interactions against DAF Conformance' do
+        metadata {
+          links "#{REST_SPEC_LINK}#conformance"
+          links "#{BASE_SPEC_LINK}/conformance.html"
+          links "#{BASE_SPEC_LINK}/daf/daf.html"
+          requires resource: 'Conformance', methods: ['read']
+          validates resource: 'Conformance', methods: ['read']
+        }
+
+        rest = @conformance.rest.first
+        rest = @conformance.rest[@rest_index] if @found_smart_code
+
+        @daf_conformance.rest.first.resource.each do |daf_resource|
+          resource = rest.resource.select{|r|r.fhirType==daf_resource.fhirType}.first
+          assert(!resource.nil?, "Server does not declare support for the #{daf_resource.fhirType} resource.")
+
+          # TODO move rest.resource.profile checks into DAF00
+          # check profile match
+          warning { assert(resource.profile.reference==daf_resource.profile.reference,"Profile for #{resource.fhirType} does not match #{daf_resource.profile.reference}",resource.profile.reference) }
+
+          # check interaction.code (and interaction.extension.valueCode for SHALL/SHOULD)
+          shall_interactions = daf_resource.interaction.select{|x|x.extension.first.value.value=='SHALL'}.map{|x|x.code}
+          should_interactions = daf_resource.interaction.select{|x|x.extension.first.value.value=='SHOULD'}.map{|x|x.code}
+
+          resource.interaction.each do |interaction|
+            should_interactions.delete(interaction.code)
+            shall_interactions.delete(interaction.code)
+          end
+
+          warning { assert(should_interactions.empty?,"Server does not declare support for the following SHOULD interactions on #{resource.fhirType}: #{should_interactions}") }
+          assert(shall_interactions.empty?,"Server does not declare support for the following SHALL interactions on #{resource.fhirType}: #{shall_interactions}")
+        end
+      end      
+
+      # Check that Conformance searchParams
+      test 'DAF03','Check Conformance Search Parameters against DAF Conformance' do
+        metadata {
+          links "#{REST_SPEC_LINK}#conformance"
+          links "#{BASE_SPEC_LINK}/conformance.html"
+          links "#{BASE_SPEC_LINK}/daf/daf.html"
+          requires resource: 'Conformance', methods: ['read']
+          validates resource: 'Conformance', methods: ['read']
+        }
+
+        rest = @conformance.rest.first
+        rest = @conformance.rest[@rest_index] if @found_smart_code
+
+        @daf_conformance.rest.first.resource.each do |daf_resource|
+          resource = rest.resource.select{|r|r.fhirType==daf_resource.fhirType}.first
+          assert(!resource.nil?, "Server does not declare support for the #{daf_resource.fhirType} resource.")
+
+          # check searchParam.name
+          shall_params = daf_resource.searchParam.select{|x|x.extension.first.value.value=='SHALL'}.map{|x|x.name}
+          should_params = daf_resource.searchParam.select{|x|x.extension.first.value.value=='SHOULD'}.map{|x|x.name}
+
+          resource.searchParam.each do |searchParam|
+            should_params.delete(searchParam.name)
+            shall_params.delete(searchParam.name)
+          end
+
+          warning { assert(should_params.empty?,"Server does not declare support for the following SHOULD searchParams on #{resource.fhirType}: #{should_params}") }
+          assert(shall_params.empty?,"Server does not declare support for the following SHALL searchParams on #{resource.fhirType}: #{shall_params}")
+
+          # search chains
+          shall_chain = daf_resource.searchParam.select{|x|x.extension.first.value.value=='SHALL'}.map{|x|x.chain}.flatten
+          should_chain = daf_resource.searchParam.select{|x|x.extension.first.value.value=='SHOULD'}.map{|x|x.chain}.flatten
+
+          resource.searchParam.each do |searchParam|
+            should_chain -= searchParam.chain
+            shall_chain -= searchParam.chain
+          end
+
+          warning { assert(should_chain.empty?,"Server does not declare support for the following SHOULD searchParam.chain on #{resource.fhirType}: #{should_chain}") }
+          assert(shall_chain.empty?,"Server does not declare support for the following SHALL searchParam.chain on #{resource.fhirType}: #{shall_chain}")
+
+          # search includes
+          search_includes = daf_resource.searchInclude.map(&:clone)
+          search_includes -= resource.searchInclude
+          assert(search_includes.empty?,"Server does not declare support for the following SHALL searchIncludes on #{resource.fhirType}: #{search_includes}")
+        end
+      end      
+
+      # Check Conformance for $everything on Patient and Encounter
+      test 'DAF04','Check Conformance for $everything on Patient and Encounter' do
+        metadata {
+          links "#{REST_SPEC_LINK}#conformance"
+          links "#{BASE_SPEC_LINK}/conformance.html"
+          links "#{BASE_SPEC_LINK}/daf/daf.html"
+          links "#{BASE_SPEC_LINK}/patient-operations.html#everything"
+          requires resource: 'Conformance', methods: ['read']
+          validates resource: 'Conformance', methods: ['read']
+        }
+
+        rest = @conformance.rest.first
+        rest = @conformance.rest[@rest_index] if @found_smart_code
+
+        supports_ambiguous_everything = rest.operation.any?{|x|['$everything','everything'].include?(x.name.downcase) && x.definition.reference.downcase.ends_with?('everything')}
+        supports_patient_everything = rest.operation.any?{|x|['$everything','everything'].include?(x.name.downcase) && x.definition.reference.downcase.ends_with?('patient-everything')}
+        supports_encounter_everything = rest.operation.any?{|x|['$everything','everything'].include?(x.name.downcase) && x.definition.reference.downcase.ends_with?('encounter-everything')}
+
+        message = 'Excerpt from patient-operations.html#everything and encounter-operations.html#everything: In the US Realm, at a minimum, the resources returned SHALL include all the data covered by the meaningful use common data elements as defined in DAF.'
+
+        assert((supports_patient_everything || supports_encounter_everything || supports_ambiguous_everything), message)
+        warning{ assert((supports_patient_everything || supports_encounter_everything), "Ambiguous everything operation: cannot determine applicable resources. #{message}") }
+        warning{ assert(supports_patient_everything, "Cannot find Patient $everything operation. #{message}")}
+        warning{ assert(supports_encounter_everything, "Cannot find Encounter $everything operation. #{message}")}        
+      end
+
+      # Check Conformance for $validate operation support
+      # NOT REQUIRED BY DAF IMPLEMENTATION GUIDE -- WARNING ONLY
+      test 'DAF05','Optional: Check Conformance for $validate Operation Support' do
+        metadata {
+          links "#{REST_SPEC_LINK}#conformance"
+          links "#{BASE_SPEC_LINK}/conformance.html"
+          links "#{BASE_SPEC_LINK}/daf/daf.html"
+          links "#{BASE_SPEC_LINK}/resource-operations.html#validate"
+          requires resource: 'Conformance', methods: ['read']
+          validates resource: 'Conformance', methods: ['read']
+        }
+
+        rest = @conformance.rest.first
+        rest = @conformance.rest[@rest_index] if @found_smart_code
+
+        @supports_validate = rest.operation.any?{|x|['$validate','validate'].include?(x.name.downcase) && x.definition.reference.downcase.ends_with?('validate')}
+        message = 'Although not required by the DAF Implementation Guide, the server should support resource validation to ensure resources correctly conform to the DAF profiles.'
+        warning{ assert(@supports_validate, message) }
+      end
+
+      # Check Conformance for transaction support
+      # NOT REQUIRED BY DAF IMPLEMENTATION GUIDE -- WARNING ONLY
+      test 'DAF06','Optional: Check Conformance for Transaction Support' do
+        metadata {
+          links "#{REST_SPEC_LINK}#conformance"
+          links "#{BASE_SPEC_LINK}/conformance.html"
+          links "#{BASE_SPEC_LINK}/daf/daf.html"
+          links "#{REST_SPEC_LINK}#transaction"
+          requires resource: 'Conformance', methods: ['read']
+          validates resource: 'Conformance', methods: ['read']
+        }
+
+        rest = @conformance.rest.first
+        rest = @conformance.rest[@rest_index] if @found_smart_code
+
+        has_transaction_interaction = rest.interaction.any?{|x|x.code=='transaction'}
+        has_transaction_mode = (!rest.transactionMode.nil? && rest.transactionMode!='not-supported')
+
+        message = 'Although not required by the DAF Implementation Guide, the server should support transaction (preferred) or batch, to facilitate the transfer of patient records.'
+
+        warning{ assert((has_transaction_interaction || has_transaction_mode), message) }
+      end
+
+      # Create DAF Profile fixtures
+      # => all MUST SUPPORT fields
+      # => using DAF bindings
+      # => with all DAF EXTENSIONS
+      # BUT THE DAF IMPLEMENTATION GUIDE DOES NOT REQUIRE CREATE/WRITE SUPPORT.
+      # TRY TO VALIDATE THESE FIXTURES... BUT VALIDATE OPERATION IS NOT REQUIRED BY DAF IG EITHER.
+      # TRY TO SEARCH FOR DAF PROFILED RESOURCES... AND THEN HAVE OUR CLIENT VALIDATE THEM, IF THEY EXIST.
+      resources = Crucible::Generator::Resources.new
+      daf_conformance = resources.daf_conformance
+      daf_conformance.rest.first.resource.each do |daf_resource|
+
+        test "DAFS0_#{daf_resource.fhirType}", "Search #{daf_resource.fhirType} for DAF-#{daf_resource.fhirType} compliant resources" do
+          metadata {
+            links "#{BASE_SPEC_LINK}/resource.html#profile-tags"
+            links "#{BASE_SPEC_LINK}/daf/daf-#{daf_resource.fhirType.downcase}.html"
+            links "#{REST_SPEC_LINK}#search"
+            requires resource: "#{daf_resource.fhirType}", methods: ['search']
+            validates resource: "#{daf_resource.fhirType}", methods: ['search']
+          }
+
+          klass = "FHIR::#{daf_resource.fhirType}".constantize
+          options = {
+            :search => {
+              :parameters => {
+                '_profile' => daf_resource.profile.reference
+              }
+            }
+          }
+          # search on the resource by ?_profile=
+          reply = @client.search(klass,options)
+          assert_response_ok(reply)
+          assert_bundle_response(reply)
+          warning{ assert((1 >= reply.resource.entry.size), "The server did not return any DAF-#{daf_resource.fhirType}s.") }
+
+          if reply.resource.entry.size > 0
+            # store any results to a @server_side_resources
+            @server_side_resources[daf_resource.fhirType] = reply.resource.entry.map{|x|x.resource}
+          end
+        end
+
+        test "DAFV0_#{daf_resource.fhirType}", "Client-side validation of DAF-#{daf_resource.fhirType} search results" do
+          metadata {
+            links "#{BASE_SPEC_LINK}/resource-operations.html#validate"
+            links "#{BASE_SPEC_LINK}/daf/daf-#{daf_resource.fhirType.downcase}.html"
+          }
+          resource = @server_side_resources[daf_resource.fhirType]
+          skip if resource.nil? || resource.empty?
+          
+          profiles = FHIR::StructureDefinition.get_profiles_for_resource(daf_resource.fhirType)
+          profile = profiles.select{|x|x.xmlId.start_with?'daf'}.first
+          skip if profile.nil?
+
+          resource.each do |r|
+            assert(profile.is_valid?(r),"The #{daf_resource.fhirType} with ID #{r.xmlId} is not DAF compliant but claims to be.",r.to_xml)
+          end
+        end
+
+        # if there are any profiled results in the @variable, and the server supports $validate, then $validate them
+        test "DAFV1_#{daf_resource.fhirType}", "Server-side validation of DAF-#{daf_resource.fhirType} search results" do
+          metadata {
+            links "#{BASE_SPEC_LINK}/resource-operations.html#validate"
+            links "#{BASE_SPEC_LINK}/daf/daf-#{daf_resource.fhirType.downcase}.html"
+            validates resource: "#{daf_resource.fhirType}", methods: ['$validate']
+            validates profiles: ['validate-profile']
+          }
+          skip unless @supports_validate
+          resource = @server_side_resources[daf_resource.fhirType]
+          skip if resource.nil? || resource.empty?
+
+          resource.each do |r|
+            reply = @client.validate(r,{profile_uri: daf_resource.profile.reference})
+            assert_response_ok(reply)
+            if !reply.id.nil?
+              assert( !reply.id.include?('validate'), "Server created an #{daf_resource.fhirType} with the ID `#{reply.resource.xmlId}` rather than validate the resource.", reply.id)
+            end
+          end
+        end
+
+      end
+
+      # Validate invalid DAF patient
+      test 'DAFV2', 'Optional: Server should not $validate an invalid DAF-Patient' do
+        metadata {
+          links "#{BASE_SPEC_LINK}/patient.html"
+          links "#{BASE_SPEC_LINK}/daf/daf-patient.html"
+          links "#{BASE_SPEC_LINK}/resource-operations.html#validate"
+          links "#{BASE_SPEC_LINK}/operation-resource-validate.html"
+          requires resource: 'Patient', methods: ['$validate']
+          validates profiles: ['validate-profile']
+        }
+        skip unless @supports_validate
+
+        # Removing the identifier and adding an "animal" to the 
+        # Patient violates the DAF-Patient profile.
+        patient = Crucible::Tests::DAFResourceGenerator.daf_patient
+        patient.identifier = nil
+        patient.animal = Crucible::Tests::DAFResourceGenerator.minimal_animal
+
+        reply = @client.validate(patient,{profile_uri: patient.meta.profile.first})
+        assert_response_ok(reply)
+        assert_resource_type(reply,FHIR::OperationOutcome)
+        failed = reply.resource.issue.any?{|x|['fatal','error'].include?(x.severity) || x.code=='invalid' }
+        assert(failed,'The server failed to reject an invalid DAF-Patient.')
+      end
+
+      # Create Invalid DAF Profile fixtures, server should reject
+      # Validate valid and invalid DAF fixtures (server should PASS and FAIL appropriately)
+      # Search for DAF Profile fixtures (including by using DAF extensions)
+
+      # Test $everything on Patient and Encounter
+      test 'DAF20','Test $everything on Patient' do
+        metadata {
+          links "#{BASE_SPEC_LINK}/daf/daf.html"
+          links "#{BASE_SPEC_LINK}/patient-operations.html#everything"
+          requires resource: 'Patient', methods: ['search', '$everything']
+          validates resource: 'Patient', methods: ['search', '$everything']
+        }
+
+        resource = @server_side_resources['Patient']
+        if resource.nil? || resource.empty?
+          options = {
+            :search => {
+              :flag => nil,
+              :compartment => nil,
+              :parameters => nil
+            }
+          }
+          reply = @client.search(FHIR::Patient, options)
+          assert_response_ok(reply)
+          assert_bundle_response(reply)
+          resource = reply.resource.entry.map{|x|x.resource}
+        end
+        skip if resource.nil? || resource.empty?
+
+        reply = @client.fetch_patient_record(resource.first.xmlId)
+
+        assert_response_ok(reply)
+        assert_bundle_response(reply)
+      end
+
+      test 'DAF21','Test $everything on Encounter' do
+        metadata {
+          links "#{BASE_SPEC_LINK}/daf/daf.html"
+          links "#{BASE_SPEC_LINK}/encounter-operations.html#everything"
+          requires resource: 'Encounter', methods: ['search', '$everything']
+          validates resource: 'Encounter', methods: ['search', '$everything']
+        }
+
+        resource = @server_side_resources['Encounter']
+        if resource.nil? || resource.empty?
+          options = {
+            :search => {
+              :flag => nil,
+              :compartment => nil,
+              :parameters => nil
+            }
+          }
+          reply = @client.search(FHIR::Encounter, options)
+          assert_response_ok(reply)
+          assert_bundle_response(reply)
+          resource = reply.resource.entry.map{|x|x.resource}
+        end     
+        skip if resource.nil? || resource.empty?
+
+        reply = @client.fetch_encounter_record(resource.first.xmlId)
+
+        assert_response_ok(reply)
+        assert_bundle_response(reply)
+      end
+
+      # The DAF Responder SHALL identify the DAF profile(s) supported as part of the FHIR BaseResource.Meta.profile attribute for each instance.
+      
+    end
+  end
+end