plan_executor 1.0.2

data/lib/tests/suites/argonaut_sprint_1_test.rb

@@ -0,0 +1,187 @@
+module Crucible
+  module Tests
+    class ArgonautSprint1Test < BaseSuite
+      attr_accessor :rc
+      attr_accessor :conformance
+      attr_accessor :searchParams
+      attr_reader   :canSearchById
+      attr_accessor :patient_id
+
+      def id
+        'ArgonautSprint1Test'
+      end
+
+      def description
+        'Argonaut Sprint 1 tests for testing Argonauts Sprint 1 goals: read patient by ID, search for patients by various demographics.'
+      end
+
+      def details
+        {
+          'Overview' => 'Argonaut Sprint 1 tests for testing Argonauts Sprint 1 goals: read patient by ID, search for patients by various demographics.',
+          'Instructions' => 'Servers should provide the following information for the sprint: Organization name and contact, FHIR endpoint URL, List of FHIR Patient IDs (that is, Patient.id, not Patient.identifier), Authorization token(s), which are simple fixed values for now (Note: some servers, including Argonaut\'s reference server, may need to issue different tokens to different clients for policy reasons)',
+          'FHIR API Calls' => 'We\'ll focus on the basics, beginning with two FHIR API calls that every participating server should expose, and every participating client should invoke: GET /Patient/{id} Retrieve a patient\'s basic demographics and identifiers, given a unique patient id. Think of this as the "Hello world" of FHIR. And cross-patient demographics search, using a single FHIR API call: GET /Patient?[parameters] Find patients based on a variety of demographic criteria. The following search parameters must be supported at a minimum: (name, family, given, identifier, gender, birthdate)',
+          'Authorization' => 'The first Argonaut sprint will focus on getting data services up and running even before a complete authorization flow is implemented. This way we can ensure that all participating servers have correctly exposed FHIR API endpoints before we lock those endpoints down with a full OAuth approval process. So for this first sprint, each server will publish its FHIR endpoint URL along with an access token that clients can include in an HTTP Authorization header with each API call',
+        }
+      end
+
+      def initialize(client1, client2=nil)
+        super(client1, client2)
+        @tags.append('argonautp1')
+        @category = {id: 'argonautp1', title: 'Argonaut Phase 1'}
+      end
+
+      def setup
+        @searchParams = [:name, :family, :given, :identifier, :gender, :birthdate]
+        @rc = FHIR::Patient
+
+        if !@client.client.try(:params).nil? && @client.client.params["patient"]
+          @patient_id = @client.client.params["patient"]
+        end
+      end
+
+      def get_patient_by_param(params = {}, flag = true)
+        assert !params.empty?, "No params for patient"
+        options = {
+          :search => {
+            :flag => flag,
+            :compartment => nil,
+            :parameters => params
+          }
+        }
+        reply = @client.search(@rc, options)
+        assert_response_ok(reply)
+        assert_bundle_response(reply)
+        assert reply.resource.get_by_id(@patient_id).equals?(@patient, ['_id', "text", "meta", "lastUpdated"]), 'Server returned wrong patient.'
+      end
+
+      def define_metadata(method)
+        links "#{REST_SPEC_LINK}##{method}"
+        links "#{BASE_SPEC_LINK}/#{@rc.name.demodulize.downcase}.html"
+        validates resource: @rc.name.demodulize, methods: [method]
+      end
+
+      # [SprinklerTest("R001", "Result headers on normal read")]
+      test 'AS001', 'Get patient by ID' do
+        metadata {
+          links "#{REST_SPEC_LINK}#read"
+          requires resource: "Patient", methods: ["read", "search"]
+          validates resource: "Patient", methods: ["read", "search"]
+        }
+
+        begin
+          options = {
+            :search => {
+              :flag => true,
+              :compartment => nil,
+              :parameters => {
+                _count: 1
+              }
+            }
+          }
+          @patient_id ||= @client.search(@rc, options).resource.entry.first.resource.xmlId
+        rescue NoMethodError
+          @patient = nil
+        end
+
+        skip if !@patient_id
+
+        reply = @client.read(FHIR::Patient, @patient_id)
+        assert_response_ok(reply)
+        assert_equal @patient_id, reply.id, 'Server returned wrong patient.'
+        @patient = reply.resource
+        assert @patient, "could not get patient by id: #{@patient_id}"
+        warning { assert_valid_resource_content_type_present(reply) }
+        warning { assert_last_modified_present(reply) }
+      end
+
+      test 'AS002', 'Search by identifier' do
+        metadata {
+          define_metadata('search')
+        }
+        skip if !@patient
+        get_patient_by_param(:identifier => @patient[:identifier].first.try(:value))
+      end
+
+      test 'AS003', 'Identifier without search keyword' do
+        metadata {
+          define_metadata('search')
+        }
+        skip if !@patient
+        get_patient_by_param({ :identifier => @patient[:identifier].first.try(:value) }, false)
+      end
+
+      test 'AS004', 'Search by Family & Given' do
+        metadata {
+          define_metadata('search')
+        }
+        skip if !@patient
+        family = @patient[:name].first.try(:family).try(:first)
+        given = @patient[:name].first.try(:given).try(:first)
+        assert family, "Patient family name not returned"
+        assert given, "Patient given name not returned"
+        get_patient_by_param(family: family, given: given)
+      end
+
+      test 'AS005', 'Family & Given without search keyword' do
+        metadata {
+          define_metadata('search')
+        }
+        skip if !@patient
+        family = @patient[:name].first.try(:family).try(:first)
+        given = @patient[:name].first.try(:given).try(:first)
+        assert family, "Patient family name not provided"
+        assert given, "Patient given name not provided"
+        get_patient_by_param({ family: family, given: given }, false)
+      end
+
+      test 'AS006', 'Search by name and gender' do
+        metadata {
+          define_metadata('search')
+        }
+        skip if !@patient
+        name = @patient[:name].first.try(:family).try(:first)
+        gender = @patient[:gender]
+        assert name, "Patient name not provided"
+        assert gender, "Patient gender not provided"
+        get_patient_by_param(name: name, gender: gender)
+      end
+
+      test 'AS007', 'Name and gender without search keyword' do
+        metadata {
+          define_metadata('search')
+        }
+        skip if !@patient
+        name = @patient[:name].first.try(:family).try(:first)
+        gender = @patient[:gender]
+        assert name, "Patient name not provided"
+        assert gender, "Patient gender not provided"
+        get_patient_by_param(name: name, gender: gender)
+      end
+
+      test 'AS008', 'Search by Birthdate' do
+        metadata {
+          define_metadata('search')
+        }
+        skip if !@patient
+        birthdate = @patient[:birthDate]
+        gender = @patient[:gender]
+        assert birthdate, "Patient birthdate not provided"
+        assert gender, "Patient gender not provided"
+        get_patient_by_param(birthdate: birthdate, gender: gender)
+      end
+
+      test 'AS009', 'Birthdate without search keyword' do
+        metadata {
+          define_metadata('search')
+        }
+        skip if !@patient
+        birthdate = @patient[:birthDate]
+        gender = @patient[:gender]
+        assert birthdate, "Patient birthdate not provided"
+        assert gender, "Patient gender not provided"
+        get_patient_by_param({ birthdate: birthdate, gender: gender }, false)
+      end
+
+    end
+  end
+end

data/lib/tests/suites/argonaut_sprint_2_test.rb

@@ -0,0 +1,115 @@
+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

@@ -0,0 +1,208 @@
+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