plan_executor 1.0.2

data/lib/tests/suites/search_test.rb

@@ -0,0 +1,219 @@
+module Crucible
+  module Tests
+    class SearchTest < BaseSuite
+
+      attr_accessor :resource_class
+      attr_accessor :conformance
+      attr_accessor :searchParams
+      attr_reader   :canSearchById
+
+      def execute(resource_class=nil)
+        if resource_class
+          @resource_class = resource_class
+          {"SearchTest_#{@resource_class.name.demodulize}" => execute_test_methods}
+        else
+          results = {}
+          fhir_resources.each do | klass |
+            @resource_class = klass
+            results.merge!({"SearchTest_#{@resource_class.name.demodulize}" => execute_test_methods})
+          end
+          results
+        end
+      end
+
+      def id
+        suffix = resource_class
+        suffix = resource_class.name.demodulize if !resource_class.nil?
+        "SearchTest_#{suffix}"
+      end
+
+      def description
+        "Execute suite of searches for #{resource_class.name.demodulize} resources."
+      end
+
+      def category
+        resource = @resource_class.nil? ? "Uncategorized" : resource_category(@resource_class.name.demodulize)
+        {id: "search_#{resource.parameterize}", title: "#{resource} Search"}
+      end
+
+      def initialize(client1, client2=nil)
+        super(client1, client2)
+      end
+
+      # this allows results to have unique ids for resource based tests
+      def result_id_suffix
+        resource_class.name.demodulize
+      end
+
+      def supplement_test_description(desc)
+        "#{desc} #{resource_class.name.demodulize}"
+      end
+
+      #
+      # Search Test
+      # 1. First, get the conformance statement.
+      # 2. Lookup the allowed search parameters for each resource.
+      # 3. Perform suite of tests against each resource.
+      #
+      def setup
+        @conformance = @client.conformanceStatement if @conformance.nil?
+
+        @canSearchById = false
+
+        unless @conformance.nil?
+          @conformance.rest.each do |rest|
+            rest.resource.each do |resource|
+              @searchParams = resource.searchParam if(resource.fhirType.downcase == "#{@resource_class.name.demodulize.downcase}" )
+            end
+          end
+        end
+
+        index = @searchParams.find_index {|item| item.name=="_id" } if !@searchParams.nil?
+        @canSearchById = !index.nil?
+      end
+
+      test 'S000', 'Compare supported search parameters with specification' do
+        metadata {
+          define_metadata('search')
+        }
+        searchParamNames = []
+        searchParamNames = @searchParams.map { |item| item.name } if !@searchParams.nil?
+        assert ((@resource_class::SEARCH_PARAMS-searchParamNames).size <= 0), 'The server does not support searching all the parameters specified by the specification.'
+      end
+
+      #
+      # Test the extent of the search capabilities supported.
+      # x  no criteria [SE01]
+      # x  limit by _count [S003]
+      # x  non-existing resource [SE02]
+      # x  id [S001,S002]
+      # x  parameters [SE03,SE04]
+      # x  parameters [SE24,SE25]
+      # parameter modifiers (
+      # x  :missing, [SE23]
+      # :exact,
+      # :text,
+      # :[type])
+      # x  numbers (= >= significant-digits) [SE21,SE22]
+      # date (all of the permutations?)
+      # token
+      # x  quantities [SE21,SE22]
+      # x  references [SE05]
+      # chained parameters
+      # composite parameters
+      # text search logical operators
+      # tags [TA08], profile, security label
+      # _filter parameter
+      # result relevance
+      # result sorting (_sort parameter)
+      # result paging
+      # x  _include parameter [SE06]
+      # _summary parameter
+      # result server conformance (report params actually used)
+      # advanced searching with "Query" or _query param (valueset 'expand' and 'validate' queries should be standard)
+      #
+
+      # Parameters for all resources
+      #   _id
+      #   _lastUpdated
+      #   _tag
+      #   _profile
+      #   _security
+      #   _text
+      #   _content
+      #   _list
+      #   _query
+      # Search result parameters
+      #   _sort
+      #   _count
+      #   _include
+      #   _revinclude
+      #   _summary
+      #   _elements
+      #   _contained
+      #   _containedType
+      
+    [true,false].each do |flag|  
+      action = 'GET'
+      action = 'POST' if flag
+
+      test "S001#{action[0]}", "Search by ID (#{action})" do
+        metadata {
+          define_metadata('search')
+        }
+        options = {
+          :search => {
+            :flag => flag,
+            :compartment => nil,
+            :parameters => {
+              '_id' => '0'
+            }
+          }
+        }
+        reply = @client.search(@resource_class, options)
+        assert_response_ok(reply)
+        assert_bundle_response(reply)
+      end
+
+      test "S003#{action[0]}", "Search limit by _count (#{action})" do
+        metadata {
+          define_metadata('search')
+        }
+        options = {
+          :search => {
+            :flag => flag,
+            :compartment => nil,
+            :parameters => {
+              '_count' => '1'
+            }
+          }
+        }
+        reply = @client.search(@resource_class, options)
+        assert_response_ok(reply)
+        assert_bundle_response(reply)
+        assert (1 >= reply.resource.entry.size), 'The server did not return the correct number of results.'
+      end
+
+      # ********************************************************* #
+      # _____________________Sprinkler Tests_____________________ #
+      # ********************************************************* #
+
+      test "SE01#{action[0]}", "Search without criteria (#{action})" do
+        metadata {
+          links "#{BASE_SPEC_LINK}/#{resource_class.name.demodulize.downcase}.html"
+          links "#{REST_SPEC_LINK}#search"
+          links "#{REST_SPEC_LINK}#read"
+          validates resource: resource_class.name.demodulize, methods: ['read', 'search']
+        }
+        options = {
+          :search => {
+            :flag => flag,
+            :compartment => nil,
+            :parameters => nil
+          }
+        }
+        reply = @client.search(@resource_class, options)
+        assert_response_ok(reply)
+        assert_bundle_response(reply)
+
+        replyB = @client.read_feed(@resource_class)
+
+        # AuditEvent
+        if resource_class==FHIR::AuditEvent
+          count = (reply.resource.total-replyB.resource.total).abs
+          assert (count <= 1), 'Searching without criteria did not return all the results.'
+        else
+          assert_equal replyB.resource.total, reply.resource.total, 'Searching without criteria did not return all the results.'
+        end
+      end
+    end
+
+      def define_metadata(method)
+        links "#{REST_SPEC_LINK}##{method}"
+        links "#{BASE_SPEC_LINK}/#{resource_class.name.demodulize.downcase}.html"
+        validates resource: resource_class.name.demodulize, methods: [method]
+      end
+
+    end
+  end
+end

data/lib/tests/suites/search_test_robust.rb

@@ -0,0 +1,172 @@
+module Crucible
+  module Tests
+    class RobustSearchTest < BaseSuite
+
+      def id
+        'Search002'
+      end
+
+      def description
+        'Deeper testing of search capabilities.'
+      end
+
+      def initialize(client1, client2=nil)
+        super(client1, client2)
+        @category = {id: 'core_functionality', title: 'Core Functionality'}
+      end
+
+      def setup
+        # Create a patient with gender:missing
+        @resources = Crucible::Generator::Resources.new
+        @patient = @resources.minimal_patient
+        @patient.identifier = [FHIR::Identifier.new]
+        @patient.identifier[0].value = SecureRandom.urlsafe_base64
+        result = @client.create(@patient)
+        @patient_id = result.id
+
+        # read all the patients
+        @read_entire_feed=true
+        @client.use_format_param = true
+        reply = @client.read_feed(FHIR::Patient)
+        @read_entire_feed=false if (!reply.nil? && reply.code!=200)
+        @total_count = 0
+        @entries = []
+
+        while reply != nil && !reply.resource.nil?
+          @total_count += reply.resource.entry.size
+          @entries += reply.resource.entry
+          reply = @client.next_page(reply)
+          @read_entire_feed=false if (!reply.nil? && reply.code!=200)
+        end
+
+        # create a condition matching the first patient
+        @condition = ResourceGenerator.generate(FHIR::Condition,1)
+        @condition['patient'] = ResourceGenerator.generate(FHIR::Reference)
+        @condition.patient.xmlId = @entries.try(:[],0).try(:resource).try(:xmlId)
+        options = {
+          :id => @entries.try(:[],0).try(:resource).try(:xmlId),
+          :resource => @entries.try(:[],0).try(:resource).try(:class)
+        }
+        temp = @client.use_format_param
+        @client.use_format_param = false
+        patient_url = @client.resource_url(options)
+        patient_url = patient_url[1..-1] if patient_url[0]=='/'
+        @client.use_format_param = temp
+        @condition.patient.reference = patient_url
+        reply = @client.create(@condition)
+        @condition_id = reply.id
+
+        # create some observations
+        @obs_a = create_observation(4.12345)
+        @obs_b = create_observation(4.12346)
+        @obs_c = create_observation(4.12349)
+        @obs_d = create_observation(5.12)
+        @obs_e = create_observation(6.12)
+      end
+
+      def create_observation(value)
+        observation = FHIR::Observation.new
+        observation.status = 'preliminary'
+        code = FHIR::Coding.new
+        code.system = 'http://loinc.org'
+        code.code = '2164-2'
+        observation.code = FHIR::CodeableConcept.new
+        observation.code.coding = [ code ]
+        observation.valueQuantity = FHIR::Quantity.new
+        observation.valueQuantity.system = 'http://unitofmeasure.org'
+        observation.valueQuantity.value = value
+        observation.valueQuantity.unit = 'mmol'
+        body = FHIR::Coding.new
+        body.system = 'http://snomed.info/sct'
+        body.code = '182756003'
+        observation.bodySite = FHIR::CodeableConcept.new
+        observation.bodySite.coding = [ body ]
+        reply = @client.create(observation)
+        reply.id
+      end
+
+      def teardown
+        @client.use_format_param = false
+        @client.destroy(FHIR::Patient, @patient_id) if @patient_id
+        @client.destroy(FHIR::Condition, @condition_id) if @condition_id
+        @client.destroy(FHIR::Observation, @obs_a) if @obs_a
+        @client.destroy(FHIR::Observation, @obs_b) if @obs_b
+        @client.destroy(FHIR::Observation, @obs_c) if @obs_c
+        @client.destroy(FHIR::Observation, @obs_d) if @obs_d
+        @client.destroy(FHIR::Observation, @obs_e) if @obs_e
+      end
+
+    [true,false].each do |flag|  
+      action = 'GET'
+      action = 'POST' if flag
+
+      test "SR01#{action[0]}","Patient Matching using an MPI (#{action})" do
+        metadata {
+          links "#{BASE_SPEC_LINK}/patient.html#match"
+          validates resource: 'Patient', methods: ['search']
+          validates extensions: ['extensions']
+        }
+        options = {
+          :search => {
+            :flag => flag,
+            :compartment => nil,
+            :parameters => {
+              '_query' => 'mpi',
+              'given' => @patient.name[0].given[0]
+            }
+          }
+        }
+        reply = @client.search(FHIR::Patient, options)
+        assert_response_ok(reply)
+        assert_bundle_response(reply)        
+ 
+        has_mpi_data = true
+        has_score = true
+        reply.resource.entry.each do |entry|
+          has_score = has_score && entry.try(:search).try(:score)
+          entry_has_mpi_data = false
+          if entry.search
+            entry.search.extension.each do |e|
+              if (e.url=='http://hl7.org/fhir/StructureDefinition/patient-mpi-match' && e.value && e.value.type=='code' && ['certain','probable','possible','certainly-not'].include?(e.value.value))
+                entry_has_mpi_data = true
+              end
+            end
+          end
+          has_mpi_data = has_mpi_data && entry_has_mpi_data
+        end
+        assert( has_score && has_mpi_data, "Every Patient Matching result requires a score and 'patient-mpi-match' extension.", reply.body)
+      end
+
+# Search Parameter Types    
+#   Number
+#   Date/DateTime
+#   String
+#   Token
+#   Reference
+#   Composite
+#   Quantity
+#   URI
+# Parameters for all resources
+#   _id
+#   _lastUpdated
+#   _tag
+#   _profile
+#   _security
+#   _text
+#   _content
+#   _list
+#   _query
+# Search result parameters
+#   _sort
+#   _count
+#   _include
+#   _revinclude
+#   _summary
+#   _elements
+#   _contained
+#   _containedType
+    end # EOF [true,false].each
+
+    end
+  end
+end