testscript_engine 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 62797fbc421b27cc8445d64ad741cb2272cf25d33ecbc27e62bbfbafa494d789
+  data.tar.gz: 9fbb57ad276b50107d7bd4eb9ca9a58c9f4137e0efa177dbf9e13b6ac9b23c84
+SHA512:
+  metadata.gz: f97edd627ee92665dde3491725ebabe1fb7309d43edfce3afc7e5bd923746cae05aa4dceefc29c77155d237da208f6acd19c41ef4b7b51336fb801b6de3cb881
+  data.tar.gz: e6e6afe08421e2812604a6834a0e9e05d89018b43fb07543867e314a67816689c41611db444967597e7cd3dfa1de19653b474eeece6a28ddbccd5b168d77978b

data/bin/testscript_engine

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+require 'pry-nav'
+require 'testscript_engine'
+
+@test_server_url = "http://hapi.fhir.org/baseR4"
+@testscript_path = "./"
+@testreport_path = "./TestReports"
+
+Dir.glob("#{Dir.getwd}/**").each do |path|
+	@testscript_path = path if path.split('/').last.downcase == 'testscripts'
+	@testreport_path = path if path.split('/').last.downcase == 'testreports'
+end
+
+def configuration
+%(The configuration is as follows: \n
+	SERVER UNDER TEST: [#{@test_server_url}]
+	TESTSCRIPT INPUT DIRECTORY or FILE: [#{@testscript_path}]
+	TESTREPORT OUTPUT DIRECTORY: [#{@testreport_path}] \n
+Would you like to modify this configuration? [Y/N] )
+end
+
+def validate_path(path)
+	while true
+		break if File.file?(path) || File.directory?(path)
+		print "	Invalid file or directory path given. Current working directory: [#{Dir.getwd}]. Try again: "
+		path = gets.chomp
+	end
+	path
+end
+
+def modify_configuration
+	print "Set [SERVER UNDER TEST] (press return to skip): "
+	input = gets.chomp
+	@test_server_url = input unless input.strip == ""
+
+	print "Set [TESTSCRIPT INPUT DIRECTORY or FILE] (press return to skip): "
+	input = gets.chomp
+	unless input.strip == ""
+		@testscript_path = validate_path(input.strip)
+	end
+
+	print "Set [TESTREPORT OUTPUT DIRECTORY] (press return to skip): "
+	input = gets.chomp
+	unless input.strip == ""
+		@testreport_path = validate_path(input.strip)
+	end
+
+	puts
+end
+
+def approve_configuration
+	while true
+		print configuration
+		input = gets.chomp
+		puts
+		if input.strip.downcase == 'y'
+			modify_configuration
+		else
+			break
+		end
+	end
+end
+
+print "Hello from the TestScriptEngine! "
+approve_configuration
+
+engine = TestScriptEngine.new(@test_server_url, @testscript_path, @testreport_path)
+engine.load_scripts
+engine.make_runnables
+
+print "Now able to execute runnables. \n"
+
+while true
+	puts
+	print "The SERVER UNDER TEST is [#{@test_server_url}]. Would you like to change the SERVER UNDER TEST? [Y/N] "
+	input = gets.chomp
+	if input.strip.downcase == 'y'
+		puts
+		print "Set [SERVER UNDER TEST]: "
+		input = gets.chomp
+		@test_server_url = input unless input.strip == ""
+		engine.new_client(@test_server_url)
+	end
+
+	puts
+
+	print "Enter the ID of a runnable to execute, or press return to execute all runnables: "
+	input = gets.chomp
+	if input.strip == ''
+		input = nil
+	else
+		while !engine.verify_runnable(input)
+			print "	Invalid runnable ID given. Please try again: "
+			input = gets.chomp
+		end
+	end
+
+	engine.execute_runnables(input)
+
+	puts
+	print "Execution finished. Enter (q) to quit, and press any other key to continue execution: "
+	input = gets.chomp
+	break if input == 'q'
+end
+
+engine.write_reports
+
+print "Goodbye!"

data/lib/testscript_engine/assertion.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+module Assertion
+  class AssertionException < StandardError
+    attr_reader :details, :outcome
+
+    def initialize(details, outcome)
+      @details = details
+      @outcome = outcome
+			super(details)
+    end
+  end
+
+  ASSERT_TYPES_MATCHER = /(?<=\p{Ll})(?=\p{Lu})|(?<=\p{Lu})(?=\p{Lu}\p{Ll})/
+
+  ASSERT_TYPES = [
+    "contentType",
+    "expression",
+    "headerField",
+    "minimumId",
+    "navigationLinks",
+    "path",
+    "requestMethod",
+    "resource",
+    "responseCode",
+    "response",
+    "validateProfileId",
+    "requestURL"
+  ]
+
+  CODE_MAP = {
+    '200' => 'okay',
+    '201' => 'created',
+    '204' => 'noContent',
+    '304' => 'notModified',
+    '400' => 'bad',
+    '403' => 'forbidden',
+    '404' => 'notFound',
+    '405' => 'methodNotAllowed',
+    '409' => 'conflict',
+    '410' => 'gone',
+    '412' => 'preconditionFailed',
+    '422' => 'unprocessable'
+  }
+
+  def evaluate(assert)
+    @direction = assert.direction
+    assert_elements = assert.to_hash.keys
+    assert_type = determine_assert_type(assert_elements)
+
+    outcome_message = send(assert_type.to_sym, assert)
+
+    pass(:eval_assert_result, outcome_message)
+  end
+
+  def determine_assert_type(all_elements)
+    assert_type = all_elements.detect { |elem| ASSERT_TYPES.include? elem }
+    return assert_type.split(ASSERT_TYPES_MATCHER).map(&:downcase).join('_')
+  end
+
+  def direction
+    @direction ||= 'response'
+  end
+
+  def determine_expected_value(assert)
+    if assert.value
+      assert.value
+    elsif assert.compareToSourceExpression
+      FHIRPath.evaluate(assert.compareToSourceExpression,
+        get_resource(assert.compareToSourceId).to_hash)
+    elsif assert.compareToSourcePath
+      evaluate_path(assert.compareToSourcePath,
+        get_resource(assert.compareToSourceId))
+    end
+  end
+
+  def compare(assert_type, received, operator, expected = nil)
+    operator = 'equals' unless operator
+    outcome = begin
+      case operator
+      when 'equals'
+        expected == received
+      when 'notEquals'
+        expected != received
+      when 'in'
+        expected.split(',').include? received
+      when 'notIn'
+        !expected.split(',').include? received
+      when 'greaterThan'
+        received.to_i > expected.to_i
+      when 'lessThan'
+        received.to_i < expected.to_i
+      when 'empty'
+        received.blank?
+      when 'notEmpty'
+        received.present?
+      when 'contains'
+        received&.include? expected
+      when 'notContains'
+        !received&.include? expected
+      end
+    end
+
+    if outcome
+      pass_message(assert_type, received, operator, expected)
+    else
+      fail_message = fail_message(assert_type, received, operator, expected)
+      raise AssertionException.new(fail_message, :fail)
+    end
+  end
+
+  def pass_message(assert_type, received, operator, expected)
+    received = Array(received)
+    expected = Array(expected)
+    message = "#{assert_type}: As expected, #{assert_type} #{operator}"
+    message = message + (expected ? " #{expected}."  : '.')
+    message + " Found #{received}." if received
+  end
+
+  def fail_message(assert_type, received, operator, expected)
+    received = Array(received)
+    expected = Array(expected)
+    message = "#{assert_type}: Expected #{assert_type} #{operator}"
+    message = message + " #{expected}" if expected
+    message + ", but found #{received}."
+  end
+
+  def content_type(assert)
+    received = request_header(assert.sourceId, 'Content-Type')
+    compare("Content-Type", received, assert.operator, assert.contentType)
+  end
+
+  def expression(assert)
+    resource = get_resource(assert.sourceId)
+    raise AssertionException.new('No resource given by sourceId.', :fail) unless resource
+
+    received = FHIRPath.evaluate(assert.expression, resource.to_hash)
+    expected = determine_expected_value(assert)
+    compare("Expression", received, assert.operator, expected)
+  end
+
+  def header_field(assert)
+    received = begin
+      if direction == 'request'
+        request_header(assert.sourceId, assert.headerField)
+      else
+        response_header(assert.sourceId, assert.headerField)
+      end
+    end
+
+    expected = determine_expected_value(assert)
+    compare("Header #{assert.headerField}", received, assert.operator, expected)
+  end
+
+  def minimum_id(assert)
+    received = get_resource(assert.sourceId)
+
+    raise AssertionException.new('minimumId assert not yet supported.', :skip)
+    # result = client.validate(received, { profile_uri: assert.validateProfileId })
+  end
+
+  def navigation_links(assert)
+    received = get_resource(assert.sourceId)
+    result = received&.first_link && received&.last_link && received&.next_link
+
+    return "Navigation Links: As expected, all navigation links found." if result
+
+    raise AssertionException.new("Navigation Links: Expected all navigation links, but did not receive.", :fail)
+  end
+
+  def path(assert)
+    resource = get_resource(assert.sourceId)
+    received = evaluate_path(assert.path, resource)
+    expected = determine_expected_value(assert)
+    compare("Path", received, assert.operator, expected)
+  end
+
+  def request_method(assert)
+    request = assert.sourceId ? request_map[assert.sourceId] : reply.request
+    received = request[:method]
+    expected = determine_expected_value(assert)
+    compare("Request Method", received, assert.operator, expected)
+  end
+
+  def resource(assert)
+    received = get_resource(assert.sourceId)
+    compare("Resource", received&.resourceType, assert.operator, assert.resource)
+  end
+
+  def response_code(assert)
+    received = get_response(assert.sourceId)&.[](:code).to_s
+    compare("Response Code", received, assert.operator, assert.responseCode)
+  end
+
+  def response(assert)
+    received_code = get_response(assert.sourceId)&.[](:code).to_s
+    received = CODE_MAP[received_code]
+    compare("Response", received, assert.operator, assert.response)
+  end
+
+  def validate_profile_id(assert)
+    received = get_resource(assert.sourceId)
+
+    raise AssertionException.new('validateProfileId assert not yet supported.', :skip)
+    # result = client.validate(received, { profile_uri: assert.validateProfileId })
+  end
+
+  def request_url(assert)
+    received = get_request(assert.sourceId)[:url]
+    compare("RequestURL", received, assert.operator, assert.requestURL)
+  end
+
+  # <--- TO DO: MOVE TO UTILITIES MODULE --->
+
+  def get_resource(id)
+    if direction == 'request'
+      get_request(id)&.[](:payload)
+    else
+      get_response(id)&.[](:body) || fixtures[id]
+    end
+  end
+
+  def get_response(id)
+    return response_map[id] if id
+    reply&.response
+  end
+
+  def get_request(id)
+    return request_map[id] if id
+    reply&.request
+  end
+
+  def response_header(responseId = nil, header_name = nil)
+    response = responseId ? response_map[responseId] : reply&.response
+    return unless response
+
+    headers = response[:headers]
+    return unless headers
+
+    headers.transform_keys!(&:downcase)
+    header_name ? headers[header_name.downcase] : headers
+  end
+
+  def request_header(requestId = nil, header_name = nil)
+    request = requestId ? request_map[requestId] : reply&.request
+    return unless request
+
+    headers = request[:headers]
+    return unless headers
+
+    headers.transform_keys!(&:downcase)
+    header_name ? headers[header_name.downcase] : headers
+  end
+
+  def evaluate_path(path, resource)
+    return unless path and resource
+
+    begin
+      # Then, try xpath if necessary
+      result = extract_xpath_value(resource.to_xml, path)
+    rescue
+      # If xpath fails, see if JSON path will work...
+      result = JsonPath.new(path).first(resource.to_json)
+    end
+    return result
+  end
+
+  def extract_xpath_value(resource_xml, resource_xpath)
+    # Massage the xpath if it doesn't have fhir: namespace or if doesn't end in @value
+    # Also make it look in the entire xml document instead of just starting at the root
+    xpath = resource_xpath.split('/').map do |s|
+      s.start_with?('fhir:') || s.length.zero? || s.start_with?('@') ? s : "fhir:#{s}"
+    end.join('/')
+    xpath = "#{xpath}/@value" unless xpath.end_with? '@value'
+    xpath = "//#{xpath}"
+
+    resource_doc = Nokogiri::XML(resource_xml)
+    resource_doc.root.add_namespace_definition('fhir', 'http://hl7.org/fhir')
+    resource_element = resource_doc.xpath(xpath)
+
+    # This doesn't work on warningOnly; consider putting back in place
+    # raise AssertionException.new("[#{resource_xpath}] resolved to multiple values instead of a single value", resource_element.to_s) if resource_element.length>1
+    resource_element.first.value
+  end
+end