plan_executor 1.0.2 → 1.8.0

data/lib/tests/suites/argonaut_sprint_2_test.rb

@@ -1,115 +0,0 @@
-module Crucible
-  module Tests
-    class ArgonautSprint2Test < BaseSuite
-      attr_accessor :rc
-      attr_accessor :conformance
-      attr_accessor :searchParams
-      attr_reader   :canSearchById
-
-      def id
-        'ArgonautSprint2Test'
-      end
-
-      def description
-        'Argonaut Sprint 2 tests for testing Argonauts Sprint 2 goals: builds on sprint 1 and provides authorization.'
-      end
-
-      def details
-        {
-          'Overview' => 'Argonaut Implementation Sprint 2 focuses on a scenario where an end-user launches an app from outside of the EHR, and the app gets access to search demographics for a population of patients. That is, the app obtains "user-level" authorization to search whatever patients the end-user is allowed to see.',
-          'Instructions' => 'This sprint builds directly on Sprint 1, adding a FHIR conformance statement and a basic OAuth 2 implementation for authorization.',
-          'FHIR API Calls' => 'Sprint 2 builds on the demographics call from Sprint 1: GET /Patient?[parameters] See Sprint 1 for details. We also add support for a server-specific FHIR Conformance statement, which is a necessary component for endpoint discovery in the authorization protocol. The API call looks like: GET /metadata or (equivalently) OPTIONS / Obtain the FHIR conformance statement for this RESTful server. Each server\'s metadata must include SMART\'s endpoint discovery extensions to enable the OAuth 2.0 process described below.',
-          'Authorization' => 'This sprint introduces the SMART on FHIR OAuth 2.0 authorization process. SMART\'s authorization specs define a number of advanced features, including the ability to pass context from the EHR to a contained app, and to authorize access to a single patient record at a time — but for this sprint, we support only the most basic functionality: delegating a user\'s rights to an app.',
-        }
-      end
-
-      def requires_authorization
-        false
-      end
-
-      def initialize(client1, client2=nil)
-        super(client1, client2)
-        @tags.append('argonaut')
-        @category = {id: 'argonaut', title: 'Argonaut'}
-      end
-
-      def setup
-      end
-
-      test 'AS2001', 'Test conformance statement contains an authorize url' do
-        metadata {
-          links "#{BASE_SPEC_LINK}/resource.html#metadata"
-          requires resource: "Conformance", methods: ["read"]
-          validates resource: "Conformance", methods: ["read"]
-          validates resource: nil, methods: ['OAuth2', 'Authorization/Access Control']
-          requires resource: nil, methods: ['OAuth2', 'Authorization/Access Control']
-        }
-
-        conformance = @client.conformanceStatement
-        options = get_security_options(conformance)
-
-        assert options[:authorize_url], "Authorize Url was not found in the conformance"
-
-      end
-
-
-      test 'AS2002', 'Test conformance statement contains a token url' do
-        metadata {
-          links "#{BASE_SPEC_LINK}/resource.html#metadata"
-          requires resource: "Conformance", methods: ["read"]
-          validates resource: "Conformance", methods: ["read"]
-          validates resource: nil, methods: ['OAuth2', 'Authorization/Access Control']
-          requires resource: nil, methods: ['OAuth2', 'Authorization/Access Control']
-        }
-
-        conformance = @client.conformanceStatement
-        options = get_security_options(conformance)
-
-        assert options[:token_url], "Token Url was not found in the conformance"
-
-      end
-
-      def get_security_options(conformance)
-        oauth_extension = 'http://fhir-registry.smarthealthit.org/StructureDefinition/oauth-uris'
-        authorize_extension = 'authorize'
-        token_extension = 'token'
-
-        options = nil
-        conformance.rest.each do |rest|
-          assert !rest.security.nil?, "could not get authorization extensions, no security section"
-          assert !rest.security.service.nil?, "could not get authorization extensions, no security/service section"
-          rest.security.service.each do |service|
-            assert !service.coding.nil?, "could not get authorization extensions, no codings on sercurity/service"
-            found_oauth2_code = false
-            service.coding.each do |coding|
-              if coding.code == 'SMART-on-FHIR'
-                found_oauth2_code = true
-                assert !rest.security.extension.nil?, "could not get authorization extensions, no security extensions"
-                found_oauth_extension = false
-                options = {}
-                rest.security.extension.where({url: oauth_extension}).first.extension.each do |ext|
-                  found_oauth_extension = true
-                  case ext.url
-                  when authorize_extension
-                    options[:authorize_url] = ext.value.value
-                  when "#{oauth_extension}\##{authorize_extension}"
-                    options[:authorize_url] = ext.value.value
-                  when token_extension
-                    options[:token_url] = ext.value.value
-                  when "#{oauth_extension}\##{token_extension}"
-                    options[:token_url] = ext.value.value
-                  end
-                end
-                assert found_oauth_extension, "an OAuth extension could not be found"
-              end
-              assert found_oauth2_code, "a security coding set to SMART-on-FHIR could not be found"
-            end
-          end
-        end
-        assert !options.nil?, "could not get authorization extensions"
-        options
-      end
-
-    end
-  end
-end

data/lib/tests/suites/argonaut_sprint_3_test.rb

@@ -1,208 +0,0 @@
-module Crucible
-  module Tests
-    class ArgonautSprint3Test < BaseSuite
-      def id
-        'ArgonautSprint3Test'
-      end
-
-      def description
-        'Argonaut Project Sprint 3 Test, to test success of servers at implementing goals of Argonaut Sprint 3'
-      end
-
-      def details
-        {
-          'Overview' => 'Argonaut Implementation Sprint 3 focuses on the scenario where a user approves an app with limited permissions, scoped down to a a single patient record. The app will have access to patient demographics and any "documents" available about that patient.',
-          'Instructions' => 'Please sign up!  If you\'re working on a server, please complete the "servers" tab of the Sprint 3 Spreadsheet. This time around you\'ll need to update the status flag to indicate whether you\'ve begun work (or completed work), so clients will know when to start testing. You\'ll also share details about how a developer can obtain OAuth client credentials (client_id for public apps, or a client_id and client_secret for confidential apps) as well as user login credentials. You might consider simply sharing a set of fixed credentials in this spreadsheet, or else directing users to a web page where they can complete self-service registration. If absolutely necessary, you can ask developers to e-mail you directly.  If you\'re working on a client, please complete the "clients" tab of the Sprint 3 Spreadsheet. You\'ll also need to update the status flag to indicate whether you\'ve begun work (or completed work).',
-          'FHIR API Calls' => 'GET /Patient/{id} Retrieve a patient\'s basic demographics and identifiers, given a unique patient id.  GET /Patient/{id}/DocumentReference?type={}&created={} Search for available documents about a patient, given a unique patient id. Optional search parameters can filter results on:   - type a code describing this document (see below for details)   - created creation date   - Notes  Argonaut Document Access provides background on how the DocumentReference endpoint works — but note this guide is a work in progress, and our first sprint starts with just a subset of functionality.  The Argonaut Implementation Program now uses FHIR DSTU2.',
-          'Authorization' => 'This sprint builds on our introduction to the SMART on FHIR OAuth 2.0 authorization process. Recall that in Sprint 2, we authorized access at a very coarse level, delegating all of a user\'s read privileges to an app. This time, we add support for apps that don\'t need access to an entire population of patient records, but instead require just one record. We accomplish this through a set of "launch scopes". In terms of SMART\'s authorization guide, we\'ll make the following assumptions:  Standalone launch sequence only Public clients and confidential clients are both supported Access scopes include: launch/patient (indicates to the EHR that a single patient must be selected to complete the launch process) patient/*.read (to ensure a patient-specific access token) Onecontext parameter is returned to the app upon successful authorization:   - patient (indicates the patient currently open in the EHR) - No single-sign-on (OpenID Connect) is required'
-        }
-      end
-
-      def initialize(client1, client2 = nil)
-        super
-        @tags.append('argonaut')
-        @category = {id: 'argonaut', title: 'Argonaut'}
-      end
-
-      # [SprinklerTest("AS3001", "GET patient by ID")]
-      test 'AS3001', 'GET patient by ID' do
-        metadata {
-          links "#{REST_SPEC_LINK}#read"
-          requires resource: "Patient", methods: ["read"]
-          validates resource: "Patient", methods: ["read"]
-        }
-
-        assert !@client.client.try(:params).nil?, "The client was not authorized for the test"
-        assert @client.client.params["patient"], "No patient parameter was passed to the client"
-
-        patient_id = @client.client.params["patient"]
-
-        reply = @client.read(FHIR::Patient, patient_id, FHIR::Formats::ResourceFormat::RESOURCE_JSON)
-
-        assert_response_ok(reply)
-        assert_equal patient_id.to_s, reply.id.to_s, 'Server returned wrong patient.'
-        warning { assert_valid_resource_content_type_present(reply) }
-        warning { assert_etag_present(reply) }
-        warning { assert_last_modified_present(reply) }
-      end
-
-      test 'AS3002', 'GET DocumentReference Patient Compartment for a specific patient' do
-        metadata {
-          links "#{REST_SPEC_LINK}#search"
-          requires resource: "Patient", methods: ['read', "search"]
-          validates resource: "Patient", methods: ['read', "search"]
-          requires resource: 'DocumentReference', methods: ['read']
-          validates resource: 'DocumentReference', methods: ['read']
-          requires resource: nil, methods: ['DOCUMENTS']
-          validates resource: nil, methods: ['DOCUMENTS']
-        }
-
-        assert !@client.client.try(:params).nil?, "The client was not authorized for the test"
-        assert @client.client.params["patient"], "No patient parameter was passed to the client"
-
-        patient_id = @client.client.params["patient"]
-
-        options = {
-          :id => patient_id,
-          :search => {
-            :flag => false,
-            :compartment => "DocumentReference",
-            :parameters => nil
-          }
-        }
-
-        reply = @client.search(FHIR::Patient, options)
-
-        assert_response_ok(reply)
-
-        reply.resource.entry.each do |entry|
-          assert !entry.resource.content.empty?, "DocumentReference must have at least one 'content' BackboneElement"
-          entry.resource.content.each do |content|
-            attachment = @client.get(URI::encode(@client.strip_base(content.attachment.url)), @client.fhir_headers())
-            assert_response_ok(attachment)
-          end
-        end
-      end
-
-      test 'AS3003', 'GET DocumentReferences with Patient IDs' do
-        metadata {
-          links "#{REST_SPEC_LINK}#search"
-          requires resource: "Patient", methods: ["read", "search"]
-          validates resource: "Patient", methods: ["read", "search"]
-          requires resource: 'DocumentReference', methods: ['read']
-          validates resource: 'DocumentReference', methods: ['read']
-          requires resource: nil, methods: ['DOCUMENTS']
-          validates resource: nil, methods: ['DOCUMENTS']
-        }
-
-        assert !@client.client.try(:params).nil?, "The client was not authorized for the test"
-        assert @client.client.params["patient"], "No patient parameter was passed to the client"
-
-        patient_id = @client.client.params["patient"]
-
-        options = {
-          search: {
-            flag: false,
-            compartment: nil,
-            parameters: {
-              patient: patient_id
-            }
-          }
-        }
-
-        reply = @client.search(FHIR::DocumentReference, options)
-
-        assert_response_ok(reply)
-
-        reply.resource.entry.each do |entry|
-          assert !entry.resource.content.empty?, "DocumentReference must have at least one 'content' BackboneElement"
-          entry.resource.content.each do |content|
-            attachment = @client.get(URI::encode(@client.strip_base(content.attachment.url)), @client.fhir_headers())
-            assert_response_ok(attachment)
-          end
-        end
-      end
-
-      test 'AS3004', 'GET DocumentReference by Created Date' do
-        metadata {
-          links "#{REST_SPEC_LINK}#search"
-          requires resource: "Patient", methods: ["read"]
-          validates resource: "Patient", methods: ["read"]
-          requires resource: 'DocumentReference', methods: ['read', 'search']
-          validates resource: 'DocumentReference', methods: ['read', 'search']
-          requires resource: nil, methods: ['DOCUMENTS']
-          validates resource: nil, methods: ['DOCUMENTS']
-        }
-
-        assert !@client.client.try(:params).nil?, "The client was not authorized for the test"
-        assert @client.client.params["patient"], "No patient parameter was passed to the client"
-
-        patient_id = @client.client.params["patient"]
-
-        options = {
-          search: {
-            flag: false,
-            compartment: nil,
-            parameters: {
-              patient: patient_id,
-              created: '2015'
-            }
-          }
-        }
-
-        reply = @client.search(FHIR::DocumentReference, options)
-
-        assert_response_ok(reply)
-
-        reply.resource.entry.each do |entry|
-          assert !entry.resource.content.empty?, "DocumentReference must have at least one 'content' BackboneElement"
-          entry.resource.content.each do |content|
-            attachment = @client.get(URI::encode(@client.strip_base(content.attachment.url)), @client.fhir_headers())
-            assert_response_ok(attachment)
-          end
-        end
-      end
-
-      test 'AS3005', 'GET DocumentReference by Type' do
-        metadata {
-          links "#{REST_SPEC_LINK}#search"
-          requires resource: "Patient", methods: ["read", "search"]
-          validates resource: "Patient", methods: ["read", "search"]
-          requires resource: 'DocumentReference', methods: ['read', 'search']
-          validates resource: 'DocumentReference', methods: ['read', 'search']
-          requires resource: nil, methods: ['DOCUMENTS']
-          validates resource: nil, methods: ['DOCUMENTS']
-        }
-
-        assert !@client.client.try(:params).nil?, "The client was not authorized for the test"
-        assert @client.client.params["patient"], "No patient parameter was passed to the client"
-
-        patient_id = @client.client.params["patient"]
-
-        options = {
-          search: {
-            flag: false,
-            compartment: nil,
-            parameters: {
-              patient: patient_id,
-              type: 'http://loinc.org|34133-9'
-            }
-          }
-        }
-
-        reply = @client.search(FHIR::DocumentReference, options)
-
-        assert_response_ok(reply)
-
-        reply.resource.entry.each do |entry|
-          assert !entry.resource.content.empty?, "DocumentReference must have at least one 'content' BackboneElement"
-          entry.resource.content.each do |content|
-            attachment = @client.get(URI::encode(@client.strip_base(content.attachment.url)), @client.fhir_headers())
-            assert_response_ok(attachment)
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/tests/suites/argonaut_sprint_4_test.rb

@@ -1,335 +0,0 @@
-module Crucible
-  module Tests
-    class ArgonautSprint4Test < BaseSuite
-      def id
-        'ArgonautSprint4Test'
-      end
-
-      def description
-        'Argonaut Project Sprint 4 Test, to test success of servers at implementing goals of Argonaut Sprint 4'
-      end
-
-      def details
-        {
-          'Overview' => 'Argonaut Implementation Sprint 4 focuses on the scenario where a clinician launches a medication list app from within the EHR. The app is given EHR context using SMART\'s "EHR Launch Flow", meaning that it knows the currently-open patient record (as well as the current user -- but we\'ll tackle that in Sprint 5). On successful launch, the app is authorized to view a set of patient-specific medication-related data.',
-          'Instructions' => 'If you\'re working on a server, please complete the "servers" tab of the Sprint 4 Spreadsheet. This time around you\'ll need to update the status flag to indicate whether you\'ve begun work (or completed work), so clients will know when to start testing. You\'ll also share details about how a developer can obtain OAuth client credentials (client_id for public apps, or a client_id and client_secret for confidential apps) as well as user login credentials. You might consider simply sharing a set of fixed credentials in this spreadsheet, or else directing users to a web page where they can complete self-service registration. If absolutely necessary, you can ask developers to e-mail you directly.',
-          'FHIR API Calls' => 'FHIR provides a rich set of resource definitions for medication data. These include MedicationStatement, which expresses a high-level claim that a patient is (or is not) taking a specific drug, without further details about who prescribed it or how it was dispensed. MedicationOrder, MedicationDispense, MedicationAdministration, which are more detailed, workflow-oriented resources describing exactly what was prescribed, how it was dispensed, and how it was administered to the patient. The following search parameters must be supported at a minimum (code, identifier, medication, patient, status, effectivedate (for for MedicationStatement), datewritten (for MedicationOrder), prescriber (for MedicationOrder)). For this sprint, we ask EHRs to focus on two resources: GET /Patient/{id}/MedicationOrder or GET /MedicationOrder?patient={id} Retrieve any medications where the EHR directly manages a prescription. GET /Patient/{id}/MedicationStatement or GET /MedicationStatement?patient={id} Retrieve any other medications, including patient-reported over-the-counter drugs, or drugs manage by an outside provider or system.',
-          'Authorization' => 'This sprint builds on our introduction to the SMART on FHIR OAuth 2.0 authorization process. Recall that in Sprint 2, we authorized access at a very coarse level, delegating all of a user\'s read privileges to an app. This time, we add support for apps that don\'t need access to an entire population of patient records, but instead require just one record. We accomplish this through a set of "launch scopes". In terms of SMART\'s authorization guide, we\'ll make the following assumptions:  Standalone launch sequence only Public clients and confidential clients are both supported Access scopes include: launch/patient (indicates to the EHR that a single patient must be selected to complete the launch process) patient/*.read (to ensure a patient-specific access token) Onecontext parameter is returned to the app upon successful authorization:   - patient (indicates the patient currently open in the EHR) - No single-sign-on (OpenID Connect) is required'
-        }
-      end
-
-      def initialize(client1, client2 = nil)
-        super
-        @tags.append('argonautp1')
-        @category = {id: 'argonautp1', title: 'Argonaut Phase 1'}
-      end
-
-      # [SprinklerTest("AS3001", "GET patient by ID")]
-      test 'AS4001', 'GET patient by ID' do
-        metadata {
-          links "#{REST_SPEC_LINK}#read"
-          requires resource: "Patient", methods: ["read"]
-          validates resource: "Patient", methods: ["read"]
-        }
-
-        assert !@client.client.try(:params).nil?, "The client was not authorized for the test"
-        assert @client.client.params["patient"], "No patient parameter was passed to the client"
-
-        patient_id = @client.client.params["patient"]
-
-        reply = @client.read(FHIR::Patient, patient_id, FHIR::Formats::ResourceFormat::RESOURCE_JSON)
-
-        assert_response_ok(reply)
-        assert_equal patient_id, reply.id, 'Server returned wrong patient.'
-        warning { assert_valid_resource_content_type_present(reply) }
-        warning { assert_etag_present(reply) }
-        warning { assert_last_modified_present(reply) }
-      end
-
-      test 'AS4002', 'GET MedicationOrder Patient Compartment for a specific patient' do
-        metadata {
-          links "#{REST_SPEC_LINK}#search"
-          requires resource: "Patient", methods: ["search"]
-          validates resource: "Patient", methods: ["search"]
-          requires resource: 'MedicationOrder', methods: ['read']
-          validates resource: 'MedicationOrder', methods: ['read']
-        }
-
-        assert !@client.client.try(:params).nil?, "The client was not authorized for the test"
-        assert @client.client.params["patient"], "No patient parameter was passed to the client"
-
-        patient_id = @client.client.params["patient"]
-
-        options = {
-          :id => patient_id,
-          :search => {
-            :flag => false,
-            :compartment => "MedicationOrder",
-            :parameters => nil
-          }
-        }
-
-        reply = @client.search(FHIR::Patient, options)
-
-        assert_response_ok(reply)
-
-        reply.resource.entry.each do |entry|
-          assert (!entry.resource.medicationReference.nil? || !entry.resource.medicationCodeableConcept.nil?), "MedicationOrder was missing a medication reference or codeable concept"
-        end
-      end
-
-      test 'AS4003', 'GET MedicationOrder with Patient IDs' do
-        metadata {
-          links "#{REST_SPEC_LINK}#search"
-          requires resource: "Patient", methods: ["read", "search"]
-          validates resource: "Patient", methods: ["read", "search"]
-          requires resource: 'MedicationOrder', methods: ['read', 'search']
-          validates resource: 'MedicationOrder', methods: ['read', 'search']
-        }
-
-        assert !@client.client.try(:params).nil?, "The client was not authorized for the test"
-        assert @client.client.params["patient"], "No patient parameter was passed to the client"
-
-        patient_id = @client.client.params["patient"]
-
-        options = {
-          search: {
-            flag: false,
-            compartment: nil,
-            parameters: {
-              patient: patient_id
-            }
-          }
-        }
-
-        reply = @client.search(FHIR::MedicationOrder, options)
-
-        assert_response_ok(reply)
-
-        reply.resource.entry.each do |entry|
-          assert (!entry.resource.medicationReference.nil? || !entry.resource.medicationCodeableConcept.nil?), "MedicationOrder was missing a medication reference or codeable concept"
-        end
-      end
-
-      test 'AS4004', 'GET MedicationStatement Patient Compartment for a specific patient' do
-        metadata {
-          links "#{REST_SPEC_LINK}#search"
-          requires resource: "Patient", methods: ["search"]
-          validates resource: "Patient", methods: ["search"]
-          requires resource: 'MedicationOrder', methods: ['read']
-          validates resource: 'MedicationOrder', methods: ['read']
-        }
-
-        assert !@client.client.try(:params).nil?, "The client was not authorized for the test"
-        assert @client.client.params["patient"], "No patient parameter was passed to the client"
-
-        patient_id = @client.client.params["patient"]
-
-        options = {
-          :id => patient_id,
-          :search => {
-            :flag => false,
-            :compartment => "MedicationStatement",
-            :parameters => nil
-          }
-        }
-
-        reply = @client.search(FHIR::Patient, options)
-
-        assert_response_ok(reply)
-
-        reply.resource.entry.each do |entry|
-          assert (!entry.resource.medicationReference.nil? || !entry.resource.medicationCodeableConcept.nil?), "MedicationStatement was missing a medication reference or codeable concept"
-        end
-      end
-
-      test 'AS4005', 'GET MedicationStatement with Patient IDs' do
-        metadata {
-          links "#{REST_SPEC_LINK}#search"
-          requires resource: "Patient", methods: ["read", "search"]
-          validates resource: "Patient", methods: ["read", "search"]
-          requires resource: 'MedicationOrder', methods: ['read', 'search']
-          validates resource: 'MedicationOrder', methods: ['read', 'search']
-        }
-
-        assert !@client.client.try(:params).nil?, "The client was not authorized for the test"
-        assert @client.client.params["patient"], "No patient parameter was passed to the client"
-
-        patient_id = @client.client.params["patient"]
-
-        options = {
-          search: {
-            flag: false,
-            compartment: nil,
-            parameters: {
-              patient: patient_id
-            }
-          }
-        }
-
-        reply = @client.search(FHIR::MedicationStatement, options)
-
-        assert_response_ok(reply)
-
-        reply.resource.entry.each do |entry|
-          assert (!entry.resource.medicationReference.nil? || !entry.resource.medicationCodeableConcept.nil?), "MedicationStatement was missing a medication reference or codeable concept"
-        end
-      end
-
-      # TODO: Medication and Prescriber - need to handle references
-      ['code', 'identifier', 'status', 'dateWritten'].each do |field|
-
-        test "AS4006_#{field}", "Search for MedicationOrder by #{field}" do
-          metadata {
-            links "#{REST_SPEC_LINK}#search"
-            links "#{BASE_SPEC_LINK}/MedicationOrder.html"
-            requires resource: 'MedicationOrder', methods: ['read', 'search']
-            validates resource: "MedicationOrder", methods: ['read', "search"]
-          }
-
-          resources = getResources(FHIR::MedicationOrder)
-
-          match_target = resources.select {|r| r.resource.respond_to?(field.to_sym) && !r.resource.send(field).nil?}.first
-          search_string = match_target.resource.send(field) unless match_target.nil?
-          case field
-          when 'code'
-            begin
-              match_target = resources.select {|r| !r.resource.medicationCodeableConcept.nil?}.first
-              coding = match_target.resource.medicationCodeableConcept.coding.first
-              search_string = "#{coding.system}|#{coding.code}"
-            rescue
-              assert false, "could not get a code to search on"
-            end
-          when 'identifier'
-            search_string = search_string.first.value unless search_string.blank?
-          end
-
-          warning {assert !search_string.blank? && !match_target.nil?, "could not get a MedicationOrder with a #{field} value to search on"}
-          if search_string.blank? || match_target.nil?
-            skip
-          end
-
-          options = {
-            :search => {
-              :flag => false,
-              :compartment => nil,
-              :parameters => {
-                field.downcase => search_string
-              }
-            }
-          }
-          reply = @client.search(FHIR::MedicationOrder, options)
-          assert_response_ok(reply)
-          assert_bundle_response(reply)
-          assert reply.resource, "Search did not return any MedicationOrders for #{field.downcase} => #{search_string}, should have matched Medication Order id: #{match_target.resource.xmlId}"
-          assert (reply.resource.entry && reply.resource.entry.length > 0), "Search did not return any MedicationOrders for #{field.downcase} => #{search_string}, should have matched Medication Order id: #{match_target.resource.xmlId}"
-          assert getIdList(reply.resource).select {|id| id == match_target.resource.xmlId}.length > 0, "Search did not find the expected MedicationOrder with ID: #{match_target.resource.xmlId}"
-        end
-
-      end
-
-      ['code', 'identifier', 'status', 'effectiveDateTime'].each do |field|
-
-        test "AS4007_#{field}", "Search for MedicationStatement by #{field}" do
-          metadata {
-            links "#{REST_SPEC_LINK}#search"
-            links "#{BASE_SPEC_LINK}/MedicationStatement.html"
-            requires resource: 'MedicationStatement', methods: ['read', 'search']
-            validates resource: "MedicationStatement", methods: ['read', "search"]
-          }
-
-          resources = getResources(FHIR::MedicationStatement)
-
-          match_target = resources.select {|r| r.resource.respond_to?(field.to_sym) && !r.resource.send(field).nil?}.first
-          search_string = match_target.resource.send(field) unless match_target.nil?
-          case field
-          when 'code'
-            begin
-              match_target = resources.select {|r| !r.resource.medicationCodeableConcept.nil?}.first
-              coding = match_target.resource.medicationCodeableConcept.coding.first
-              search_string = "#{coding.system}|#{coding.code}"
-            rescue
-              assert false, "could not get a code to search on"
-            end
-          when 'identifier'
-            search_string = search_string.first.value unless search_string.blank?
-          end
-
-          warning {assert !search_string.blank? && !match_target.nil?, "could not get a MedicationStatement with a #{field} value to search on"}
-          if search_string.blank? || match_target.nil?
-            skip
-          end
-
-          options = {
-            :search => {
-              :flag => false,
-              :compartment => nil,
-              :parameters => {
-                field.downcase => search_string
-              }
-            }
-          }
-          reply = @client.search(FHIR::MedicationStatement, options)
-          assert_response_ok(reply)
-          assert_bundle_response(reply)
-          assert reply.resource, "Search did not return any MedicationStatements for #{field.downcase} => #{search_string}, should have matched Medication Order id: #{match_target.resource.xmlId}"
-          assert (reply.resource.entry && reply.resource.entry.length > 0), "Search did not return any MedicationStatements for #{field.downcase} => #{search_string}, should have matched Medication Order id: #{match_target.resource.xmlId}"
-          assert getIdList(reply.resource).select {|id| id == match_target.resource.xmlId}.length > 0, "Search did not find the expected MedicationStatements with ID: #{match_target.resource.xmlId}"
-        end
-
-      end
-
-
-      def getResources(type)
-
-        assert !@client.client.try(:params).nil?, "The client was not authorized for the test"
-        assert @client.client.params["patient"], "No patient parameter was passed to the client"
-
-        patient_id = @client.client.params["patient"]
-
-        options = {
-          search: {
-            flag: false,
-            compartment: nil,
-            parameters: {
-              patient: patient_id
-            }
-          }
-        }
-
-        reply = @client.search(type, options)
-
-        return reply.resource.entry if (reply.resource && reply.resource.entry && reply.resource.entry.length > 0)
-
-        options = {
-          :id => patient_id,
-          :search => {
-            :flag => false,
-            :compartment => type.to_s.demodulize,
-            :parameters => nil
-          }
-        }
-
-        reply = @client.search(FHIR::Patient, options)
-
-        return reply.resource.entry if (reply.resource && reply.resource.entry && reply.resource.entry.length > 0)
-
-        return []
-
-      end
-
-      def getIdList(bundle)
-        return [] unless bundle.entry
-        bundle.entry.map do |entry|
-          if (entry.fullUrl)
-            FHIR::ResourceAddress.pull_out_id(entry.resourceType, entry.fullUrl)
-          elsif entry.resource
-            entry.resource.xmlId
-          else
-            nil
-          end
-        end
-      end
-    end
-  end
-end