davinci_dtr_test_kit 0.12.0 → 0.13.0

data/lib/davinci_dtr_test_kit/mock_auth_server.rb

@@ -1,16 +1,37 @@
+# frozen_string_literal: true
+
 require_relative 'urls'
-require_relative 'fixtures'
 
 module DaVinciDTRTestKit
   module MockAuthServer
-    include Fixtures
+    AUTHORIZED_PRACTITIONER_ID = 'pra1234' # Must exist on the FHIR_REFERENCE_SERVER (env var)
+
+    RSA_PRIVATE_KEY = OpenSSL::PKey::RSA.generate(2048)
+    RSA_PUBLIC_KEY = RSA_PRIVATE_KEY.public_key
+    SUPPORTED_SCOPES = ['launch', 'patient/*.rs', 'user/*.rs', 'offline_access', 'openid', 'fhirUser'].freeze
+
+    def requests_repo
+      @requests_repo ||= Inferno::Repositories::Requests.new
+    end
+
+    def auth_server_jwks(_env)
+      response_body = {
+        keys: [
+          {
+            kty: 'RSA',
+            alg: 'RS256',
+            n: Base64.urlsafe_encode64(RSA_PUBLIC_KEY.n.to_s(2), padding: false),
+            e: Base64.urlsafe_encode64(RSA_PUBLIC_KEY.e.to_s(2), padding: false),
+            use: 'sig'
+          }
+        ]
+      }.to_json
+
+      [200, { 'Content-Type' => 'application/json', 'Access-Control-Allow-Origin' => '*' }, [response_body]]
+    end
 
     def ehr_smart_config(env)
-      protocol = env['rack.url_scheme']
-      host = env['HTTP_HOST']
-      path = env['REQUEST_PATH'] || env['PATH_INFO']
-      path.gsub!(%r{#{SMART_CONFIG_PATH}(/)?}, '')
-      base_url = "#{protocol}://#{host + path}"
+      base_url = env_base_url(env, SMART_CONFIG_PATH)
       response_body =
         {
           authorization_endpoint: base_url + EHR_AUTHORIZE_PATH,
@@ -18,7 +39,7 @@ module DaVinciDTRTestKit
           token_endpoint_auth_methods_supported: ['private_key_jwt'],
           token_endpoint_auth_signing_alg_values_supported: ['RS256'],
           grant_types_supported: ['authorization_code'],
-          scopes_supported: ['launch', 'patient/*.rs', 'user/*.rs', 'offline_access'],
+          scopes_supported: SUPPORTED_SCOPES,
           response_types_supported: ['code'],
           code_challenge_methods_supported: ['S256'],
           capabilities: [
@@ -34,9 +55,23 @@ module DaVinciDTRTestKit
       [200, { 'Content-Type' => 'application/json', 'Access-Control-Allow-Origin' => '*' }, [response_body]]
     end
 
+    def ehr_openid_config(env)
+      base_url = env_base_url(env, OPENID_CONFIG_PATH)
+      response_body = {
+        issuer: base_url + FHIR_BASE_PATH,
+        authorization_endpoint: base_url + EHR_AUTHORIZE_PATH,
+        token_endpoint: base_url + EHR_TOKEN_PATH,
+        jwks_uri: base_url + JKWS_PATH,
+        response_types_supported: ['id_token'],
+        subject_types_supported: ['public'],
+        id_token_signing_alg_values_supported: ['RS256']
+      }.to_json
+      [200, { 'Content-Type' => 'application/json', 'Access-Control-Allow-Origin' => '*' }, [response_body]]
+    end
+
     def ehr_authorize(request, _test = nil, _test_result = nil)
       # Authorization requests can bet GET or POST
-      params = request.verb == 'get' ? request.query_parameters : URI.decode_www_form(request.request_body)&.to_h
+      params = params_hash(request)
       if params['redirect_uri'].present?
         redirect_uri = "#{params['redirect_uri']}?" \
                        "code=#{SecureRandom.hex}&" \
@@ -57,25 +92,34 @@ module DaVinciDTRTestKit
 
     def ehr_token_response(request, _test = nil, test_result = nil)
       client_id = extract_client_id_from_token_request(request)
-      token = JWT.encode({ inferno_client_id: client_id }, nil, 'none')
-      response = { access_token: token, token_type: 'bearer', expires_in: 3600 }
-      test_input = JSON.parse(test_result.input_json)
+      access_token = JWT.encode({ inferno_client_id: client_id }, nil, 'none')
+      granted_scopes = SUPPORTED_SCOPES & requested_scopes(test_result.test_session_id)
 
-      fhir_context_input = test_input.find { |input| input['name'] == 'smart_fhir_context' }
-      fhir_context_input_value = fhir_context_input['value'] if fhir_context_input.present?
+      response = { access_token:, scope: granted_scopes.join(' '), token_type: 'bearer', expires_in: 3600 }
+
+      if granted_scopes.include?('openid')
+        response.merge!(id_token: create_id_token(request, client_id, fhir_user: granted_scopes.include?('fhirUser')))
+      end
+
+      fhir_context_input = find_test_input(test_result, 'smart_fhir_context')
+      fhir_context_input_value = fhir_context_input['value'] if fhir_context_input
       begin
         fhir_context = JSON.parse(fhir_context_input_value)
       rescue StandardError
         fhir_context = nil
       end
-      response.merge!({ fhirContext: fhir_context }) if fhir_context
+      response.merge!(fhirContext: fhir_context) if fhir_context
 
-      smart_patient_input = test_input.find { |input| input['name'] == 'smart_patient_id' }
+      smart_patient_input = find_test_input(test_result, 'smart_patient_id')
       smart_patient_input_value = smart_patient_input['value'] if smart_patient_input.present?
-      response.merge!({ patient: smart_patient_input_value }) if smart_patient_input_value
+      response.merge!(patient: smart_patient_input_value) if smart_patient_input_value
 
       request.response_body = response.to_json
-      request.response_headers = { 'Access-Control-Allow-Origin' => '*' }
+      request.response_headers = {
+        'Cache-Control' => 'no-store',
+        'Pragma' => 'no-cache',
+        'Access-Control-Allow-Origin' => '*'
+      }
       request.status = 200
     end
 
@@ -141,5 +185,44 @@ module DaVinciDTRTestKit
     def extract_token_from_query_params(request)
       request.query_parameters['token']
     end
+
+    def create_id_token(request, client_id, fhir_user: false)
+      # No point in mocking an identity provider, just always use known Practitioner as the authorized user
+      suite_base_url = request.url.split(EHR_TOKEN_PATH).first
+      id_token_hash = {
+        iss: suite_base_url + FHIR_BASE_PATH,
+        sub: AUTHORIZED_PRACTITIONER_ID,
+        aud: client_id,
+        exp: Time.now.to_i + (24 * 60 * 60), # 24 hrs
+        iat: Time.now.to_i
+      }
+      id_token_hash.merge!(fhirUser: "#{suite_base_url}/fhir/Practitioner/#{AUTHORIZED_PRACTITIONER_ID}") if fhir_user
+
+      JWT.encode(id_token_hash, RSA_PRIVATE_KEY, 'RS256')
+    end
+
+    def requested_scopes(test_session_id)
+      auth_request = requests_repo.tagged_requests(test_session_id, [EHR_AUTHORIZE_TAG]).last
+      return [] unless auth_request
+
+      scope_str = params_hash(auth_request)&.dig('scope')
+      scope_str ? URI.decode_www_form_component(scope_str).split : []
+    end
+
+    def find_test_input(test_result, input_name)
+      JSON.parse(test_result.input_json)&.find { |input| input['name'] == input_name }
+    end
+
+    def params_hash(request)
+      request.verb == 'get' ? request.query_parameters : URI.decode_www_form(request.request_body)&.to_h
+    end
+
+    def env_base_url(env, endpoint_path)
+      protocol = env['rack.url_scheme']
+      host = env['HTTP_HOST']
+      path = env['REQUEST_PATH'] || env['PATH_INFO']
+      path.gsub!(%r{#{endpoint_path}(/)?}, '')
+      "#{protocol}://#{host + path}"
+    end
   end
 end

data/lib/davinci_dtr_test_kit/mock_ehr.rb

@@ -27,16 +27,10 @@ module DaVinciDTRTestKit
     end
 
     def get_fhir_resource(request, _test = nil, test_result = nil)
-      resource_type, id = resource_type_and_id_from_url(request.url)
+      fhir_class, id = fhir_class_and_id_from_url(request.url)
       request.response_headers = RESPONSE_HEADERS
 
-      begin
-        fhir_class = FHIR.const_get(resource_type)
-      rescue NameError
-        resource_type = nil
-      end
-
-      if resource_type.blank?
+      if fhir_class.nil?
         request.status = 400
         request.response_headers = { 'Content-Type': 'application/json' }
         request.response_body = FHIR::OperationOutcome.new(
@@ -49,18 +43,9 @@ module DaVinciDTRTestKit
       end
 
       # Respond with user-inputted resource if there is one that matches the request
-      begin
-        ehr_bundle_input = JSON.parse(test_result.input_json).find { |input| input['name'] == 'ehr_bundle' }
-        ehr_bundle_input_value = ehr_bundle_input_value = ehr_bundle_input['value'] if ehr_bundle_input.present?
-        ehr_bundle = FHIR.from_contents(ehr_bundle_input_value) if ehr_bundle_input_value.present?
-      rescue StandardError
-        ehr_bundle = nil
-      end
-
-      if id.present? && ehr_bundle.present? && ehr_bundle.is_a?(FHIR::Bundle)
-        matching_resource = ehr_bundle.entry&.find do |entry|
-          entry.resource.is_a?(fhir_class) && entry.resource&.id == id
-        end&.resource
+      ehr_bundle = ehr_input_bundle(test_result)
+      if id.present? && ehr_bundle.present?
+        matching_resource = find_resource_in_bundle(ehr_bundle, fhir_class, id)
         if matching_resource.present?
           request.status = 200
           request.response_headers = { 'Content-Type': 'application/json' }
@@ -85,13 +70,36 @@ module DaVinciDTRTestKit
       request.response_body = request.request_body
     end
 
-    # Pull resource type and ID from url
-    # e.g. http://example.org/fhir/Patient/123 -> ['Patient', '123']
+    def ehr_input_bundle(test_result)
+      ehr_bundle_input = JSON.parse(test_result.input_json).find { |input| input['name'] == 'ehr_bundle' }
+      ehr_bundle_input_value = ehr_bundle_input_value = ehr_bundle_input['value'] if ehr_bundle_input.present?
+      ehr_bundle = FHIR.from_contents(ehr_bundle_input_value) if ehr_bundle_input_value.present?
+      ehr_bundle if ehr_bundle.is_a?(FHIR::Bundle)
+    rescue StandardError
+      nil
+    end
+
+    def find_resource_in_bundle(bundle, fhir_class, id)
+      bundle.entry&.find do |entry|
+        entry.resource.is_a?(fhir_class) && entry.resource&.id == id
+      end&.resource
+    end
+
+    # Pull resource type class and ID from url
+    # e.g. http://example.org/fhir/Patient/123 -> [FHIR::Patient, '123']
     # @private
-    def resource_type_and_id_from_url(url)
+    def fhir_class_and_id_from_url(url)
       path = url.split('?').first.split('/fhir/').second
       path.sub!(%r{/$}, '')
-      path.split('/')
+      resource_type, id = path.split('/')
+
+      begin
+        fhir_class = FHIR.const_get(resource_type)
+      rescue NameError
+        fhir_class = nil
+      end
+
+      [fhir_class, id]
     end
   end
 end

data/lib/davinci_dtr_test_kit/mock_payer.rb

@@ -4,14 +4,12 @@ require_relative 'fixtures'
 
 module DaVinciDTRTestKit
   module MockPayer
-    include Fixtures
-
     RESPONSE_HEADERS = { 'Content-Type' => 'application/json', 'Access-Control-Allow-Origin' => '*' }.freeze
 
     def questionnaire_package_response(request, _test = nil, test_result = nil)
       request.status = 200
       request.response_headers = RESPONSE_HEADERS
-      request.response_body = build_package_questionnaire_response(request, test_result.test_id).to_json
+      request.response_body = build_questionnaire_package_response(request, test_result.test_id).to_json
     end
 
     def payer_questionnaire_response(request, _test = nil, test_result = nil)
@@ -45,79 +43,58 @@ module DaVinciDTRTestKit
       !test.config.options[:accepts_multiple_requests]
     end
 
-    def build_package_questionnaire_response(request, test_id)
-      test_questionnaire_canonical = find_questionnaire_canonical_for_test_id(test_id)
-      test_questionnaire_loaded = false
-
-      bundles = []
-      issues = []
-
-      # first try the parameters - load the questionnaire specified by the questionnaire parameter
-      input_parameters = FHIR.from_contents(request.request_body)
-      input_parameters.parameter.each do |one_parameter|
-        next unless one_parameter.name == 'questionnaire'
-        next unless one_parameter.valueCanonical
+    private
 
-        # don't load test questionnaire if it is also specified explicitly
-        test_questionnaire_loaded = true if one_parameter.valueCanonical == test_questionnaire_canonical
+    def build_questionnaire_package_response(request, test_id)
+      begin
+        input_parameters = FHIR.from_contents(request.request_body)
+      rescue StandardError
+        return operation_outcome('error', 'invalid', 'No valid input parameters')
+      end
 
-        add_questionnaire_canonical_to_response(one_parameter.valueCanonical, bundles, issues)
+      questionnaire_package = Fixtures.questionnaire_package_for_test(test_id)
+      unless questionnaire_package
+        return operation_outcome('error', 'business-rule', "No Questionnaire found for Inferno test #{test_id}")
       end
 
-      unless test_questionnaire_loaded
-        if test_questionnaire_canonical
-          add_questionnaire_canonical_to_response(test_questionnaire_canonical, bundles, issues)
-
-        elsif bundles.empty?
-          # no questionnaire for this test ...
-          operation_outcome_issue = FHIR::OperationOutcome::Issue.new
-          operation_outcome_issue.severity = 'error'
-          operation_outcome_issue.code = 'business-rule'
-          details = FHIR::CodeableConcept.new
-          details.text = "no questionnaire found for test #{test_id}"
-          operation_outcome_issue.details = details
-          issues << operation_outcome_issue
-        end
+      questionnaire_canonical = find_questionnaire_canonical(questionnaire_package)
+
+      other_questionnaire_params = input_parameters.parameter.filter do |param|
+        param.name == 'questionnaire' && param.valueCanonical != questionnaire_canonical
       end
 
-      build_package_questionnaire_response_from_lists(bundles, issues)
+      return questionnaire_package unless other_questionnaire_params.any?
+
+      FHIR::Parameters.new(
+        parameter: [
+          FHIR::Parameters::Parameter.new(
+            name: 'PackageBundle',
+            resource: questionnaire_package
+          ),
+          FHIR::Parameters::Parameter.new(
+            name: 'Outcome',
+            resource: FHIR::OperationOutcome.new(
+              issue: other_questionnaire_params.map do |param|
+                outcome_issue('warning', 'not-found', "Questionnaire #{param.valueCanonical} does not exist")
+              end
+            )
+          )
+        ]
+      )
     end
 
-    def add_questionnaire_canonical_to_response(questionnaire_canonical, bundles, issues)
-      questionnaire_bundle = get_questionnaire_packcage_for_canonical(questionnaire_canonical)
-
-      if questionnaire_bundle
-        bundles << questionnaire_bundle
-      else
-        operation_outcome_issue = FHIR::OperationOutcome::Issue.new
-        operation_outcome_issue.severity = 'warning'
-        operation_outcome_issue.code = 'value'
-        details = FHIR::CodeableConcept.new
-        details.text = "Questionnaire Canonical #{questionnaire_canonical} does not exist"
-        operation_outcome_issue.details = details
-        issues << operation_outcome_issue
-      end
+    def find_questionnaire_canonical(questionnaire_package)
+      questionnaire_package&.entry&.find { |e| e.resource.is_a?(FHIR::Questionnaire) }&.resource&.url
     end
 
-    def build_package_questionnaire_response_from_lists(bundles, issues)
-      response = FHIR::Parameters.new
-      bundles.each do |one_bundle|
-        return_param = FHIR::Parameters::Parameter.new
-        return_param.name = 'return'
-        return_param.resource = one_bundle
-        response.parameter << return_param
-      end
+    def operation_outcome(severity, code, text = nil)
+      FHIR::OperationOutcome.new(issue: outcome_issue(severity, code, text))
+    end
 
-      unless issues.empty?
-        outcome = FHIR::OperationOutcome.new
-        outcome.issue = issues
-        outcome_param = FHIR::Parameters::Parameter.new
-        outcome_param.name = 'outcome'
-        outcome_param.resource = outcome
-        response.parameter << outcome_param
+    def outcome_issue(severity, code, text = nil)
+      FHIR::OperationOutcome::Issue.new(severity:, code:).tap do |issue|
+        issue.details = FHIR::CodeableConcept.new(text:) if text.present?
       end
-
-      response
     end
   end
 end

data/lib/davinci_dtr_test_kit/payer_server_groups/adaptive_next_questionnaire_expressions_test.rb

@@ -6,8 +6,8 @@ module DaVinciDTRTestKit
     id :dtr_v201_payer_adaptive_next_form_expressions_test
     title 'Questionnaire(s) contains items with expressions necessary for pre-population'
     description %(
-      Inferno checks that the payer server response to $next-question operation has appropriate expressions and that expressions are
-       written in cql.
+      Inferno checks that the payer server response to $next-question operation has appropriate expressions and that
+      expressions are written in cql.
     )
 
     run do

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_request_validation_test.rb

@@ -22,7 +22,8 @@ module DaVinciDTRTestKit
       if initial_adaptive_questionnaire_request.nil?
         requests = load_tagged_requests(QUESTIONNAIRE_TAG)
         skip_if requests.blank?, 'No request resource received from the client.'
-        # making the assumption that only one request was made here - if there were multiple, we are only validating the first
+        # making the assumption that only one request was made here - if there were multiple, we are only validating the
+        # first
         resource_is_valid?(resource: FHIR.from_contents(requests[0].request[:body]), profile_url: profile_with_version)
       else
         request = FHIR.from_contents(initial_adaptive_questionnaire_request)

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_adaptive_response_validation_test.rb

@@ -24,21 +24,22 @@ module DaVinciDTRTestKit
       profile_with_version = 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/dtr-qpackage-output-parameters|2.0.1'
       endpoint = custom_endpoint.blank? ? '/Questionnaire/$questionnaire-package' : custom_endpoint
       if initial_adaptive_questionnaire_request.nil?
-        # making the assumption that only one response was received - if there were multiple, we are only validating the first
+        # making the assumption that only one response was received - if there were multiple, we are only validating the
+        # first
         response = load_tagged_requests(QUESTIONNAIRE_TAG)[0]
         scratch[:adaptive_responses] = [response]
         resource = FHIR.from_contents(response.response[:body])
       else
         response = fhir_operation("#{url}#{endpoint}", body: JSON.parse(initial_adaptive_questionnaire_request),
-                                                              headers: { 'Content-Type': 'application/json' })
+                                                       headers: { 'Content-Type': 'application/json' })
         resource = FHIR.from_contents(response.response[:body])
         scratch[:adaptive_responses] = [response]
       end
-      
+
       assert !scratch[:adaptive_responses].nil?, 'No resources to validate.'
       assert_response_status([200, 201], response: response.response)
-      assert_resource_type(:parameters, resource: resource)
-      assert_valid_resource(resource: resource, profile_url: profile_with_version)
+      assert_resource_type(:parameters, resource:)
+      assert_valid_resource(resource:, profile_url: profile_with_version)
       questionnaire_bundle = resource.parameter.find { |param| param.resource.resourceType == 'Bundle' }&.resource
       assert questionnaire_bundle, 'No questionnaire bundle found in the response'
       assert_valid_resource(resource: questionnaire_bundle, profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/DTR-QPackageBundle|2.0.1')

data/lib/davinci_dtr_test_kit/payer_server_groups/payer_server_next_request_validation_test.rb

@@ -50,7 +50,7 @@ module DaVinciDTRTestKit
         )
       else
         messages << { type: 'error',
-        message: format_markdown("No resources were of type 'Parameters' or 'QuestionnaireResponse'") }
+                      message: format_markdown("No resources were of type 'Parameters' or 'QuestionnaireResponse'") }
       end
       errors_found = messages.any? { |message| message[:type] == 'error' }
       skip_if errors_found, "No resources conform to the profiles http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaireresponse-adapt

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_request_validation_test.rb

@@ -24,7 +24,8 @@ module DaVinciDTRTestKit
         skip_if access_token.nil?, 'No access token provided - required for client flow.'
         requests = load_tagged_requests(QUESTIONNAIRE_TAG)
         skip_if requests.blank?, 'No request resource received from the client.'
-        # making the assumption that only one request was made here - if there were multiple, we are only validating the first
+        # making the assumption that only one request was made here - if there were multiple, we are only validating the
+        # first
         resource_is_valid?(resource: FHIR.from_contents(requests[0].request[:body]), profile_url: profile_with_version)
       else
         request = FHIR.from_contents(initial_static_questionnaire_request)

data/lib/davinci_dtr_test_kit/payer_server_groups/static_form_response_validation_test.rb

@@ -26,8 +26,10 @@ module DaVinciDTRTestKit
         resources = load_tagged_requests(QUESTIONNAIRE_TAG)
         skip_if resources.nil?, 'No request resource received from the client.'
         scratch[:output_parameters] = resources
-        # making the assumption that only one response was received- if there were multiple, we are only validating the first
-        assert_valid_resource(resource: FHIR.from_contents(resources[0].request[:body]), profile_url: profile_with_version)
+        # making the assumption that only one response was received- if there were multiple, we are only validating the
+        # first
+        assert_valid_resource(resource: FHIR.from_contents(resources[0].request[:body]),
+                              profile_url: profile_with_version)
       else
         request = fhir_operation("#{url}/Questionnaire/$questionnaire-package",
                                  body: JSON.parse(initial_static_questionnaire_request),
@@ -36,8 +38,8 @@ module DaVinciDTRTestKit
         resource = FHIR.from_contents(request.response[:body])
         scratch[:output_parameters] = resource
         assert_response_status([200, 201], response: request.response)
-        assert_resource_type(:parameters, resource: resource)
-        assert_valid_resource(resource: resource, profile_url: profile_with_version)
+        assert_resource_type(:parameters, resource:)
+        assert_valid_resource(resource:, profile_url: profile_with_version)
         questionnaire_bundle = resource.parameter.find { |param| param.resource.resourceType == 'Bundle' }&.resource
         assert questionnaire_bundle, 'No questionnaire bundle found in the response'
         assert_valid_resource(resource: questionnaire_bundle, profile_url: 'http://hl7.org/fhir/us/davinci-dtr/StructureDefinition/DTR-QPackageBundle|2.0.1')

data/lib/davinci_dtr_test_kit/tags.rb

@@ -5,4 +5,5 @@ module DaVinciDTRTestKit
   NEXT_TAG = 'payer_server_adaptive_questionnaire_package'
   QUESTIONNAIRE_PACKAGE_TAG = 'dtr_questionnaire_package'
   SMART_APP_EHR_REQUEST_TAG = 'dtr_smart_app_ehr_request'
+  EHR_AUTHORIZE_TAG = 'dtr_smart_app_ehr_authorize'
 end

data/lib/davinci_dtr_test_kit/urls.rb

@@ -1,17 +1,20 @@
 # frozen_string_literal: true
 
 module DaVinciDTRTestKit
-  SMART_CONFIG_PATH = '/fhir/.well-known/smart-configuration'
-  EHR_AUTHORIZE_PATH = '/mock_ehr_auth/authorize'
-  EHR_TOKEN_PATH = '/mock_ehr_auth/token'
-  PAYER_TOKEN_PATH = '/mock_payer_auth/token'
-  QUESTIONNAIRE_PACKAGE_PATH = '/fhir/Questionnaire/$questionnaire-package'
-  NEXT_PATH = '/fhir/Questionnaire/$next-question'
-  QUESTIONNAIRE_RESPONSE_PATH = '/fhir/QuestionnaireResponse'
+  FHIR_BASE_PATH = '/fhir'
+  SMART_CONFIG_PATH = "#{FHIR_BASE_PATH}/.well-known/smart-configuration".freeze
+  OPENID_CONFIG_PATH = "#{FHIR_BASE_PATH}/.well-known/openid-configuration".freeze
+  JKWS_PATH = "#{FHIR_BASE_PATH}/.well-known/jwks.json".freeze
+  EHR_AUTHORIZE_PATH = "#{FHIR_BASE_PATH}/mock_ehr_auth/authorize".freeze
+  EHR_TOKEN_PATH = "#{FHIR_BASE_PATH}/mock_ehr_auth/token".freeze
+  PAYER_TOKEN_PATH = "#{FHIR_BASE_PATH}/mock_payer_auth/token".freeze
+  QUESTIONNAIRE_PACKAGE_PATH = "#{FHIR_BASE_PATH}/Questionnaire/$questionnaire-package".freeze
+  NEXT_PATH = "#{FHIR_BASE_PATH}/Questionnaire/$next-question".freeze
+  QUESTIONNAIRE_RESPONSE_PATH = "#{FHIR_BASE_PATH}/QuestionnaireResponse".freeze
+  FHIR_RESOURCE_PATH = "#{FHIR_BASE_PATH}/:resource/:id".freeze
+  FHIR_SEARCH_PATH = "#{FHIR_BASE_PATH}/:resource".freeze
   RESUME_PASS_PATH = '/resume_pass'
   RESUME_FAIL_PATH = '/resume_fail'
-  FHIR_RESOURCE_PATH = '/fhir/:resource/:id'
-  FHIR_SEARCH_PATH = '/fhir/:resource'
 
   module URLs
     def base_url
@@ -43,7 +46,7 @@ module DaVinciDTRTestKit
     end
 
     def fhir_base_url
-      @fhir_base_url ||= "#{base_url}/fhir"
+      @fhir_base_url ||= base_url + FHIR_BASE_PATH
     end
 
     def resume_pass_url

data/lib/davinci_dtr_test_kit/validation_test.rb

@@ -42,7 +42,8 @@ module DaVinciDTRTestKit
         else
           if resource.url != resource_url
             messages << { type: 'warning',
-                          message: format_markdown("Request made to wrong URL: #{resource.request[:url]}. Should instead be to #{resource_url}") }
+                          message: format_markdown(%(Request made to wrong URL: #{resource.request[:url]}.
+                                                     Should instead be to #{resource_url})) }
           end
           fhir_resource = FHIR.from_contents(resource.request[:body])
         end

data/lib/davinci_dtr_test_kit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DaVinciDTRTestKit
-  VERSION = '0.12.0'
+  VERSION = '0.13.0'
 end

data/lib/davinci_dtr_test_kit.rb

@@ -1,4 +1,4 @@
 require_relative 'davinci_dtr_test_kit/dtr_payer_server_suite'
 require_relative 'davinci_dtr_test_kit/dtr_smart_app_suite'
 require_relative 'davinci_dtr_test_kit/dtr_full_ehr_suite'
-# require_relative 'davinci_dtr_test_kit/dtr_light_ehr_suite'
+require_relative 'davinci_dtr_test_kit/dtr_light_ehr_suite'