inferno_core 1.1.2 → 1.2.1

data/lib/inferno/apps/cli/session/start_run.rb

@@ -0,0 +1,245 @@
+require 'faraday'
+require_relative 'connection'
+require_relative 'errors'
+require_relative 'session_data'
+require_relative 'session_details'
+
+module Inferno
+  module CLI
+    module Session
+      class StartRun
+        include Connection
+        include Errors
+
+        COMMAND_OPTIONS = {
+          inputs: {
+            aliases: ['-i'],
+            type: :hash,
+            desc: 'Inputs (i.e: --inputs=foo:bar goo:baz); will merge and override current session inputs ' \
+                  '(from preset or previous runs)'
+          }
+        }.freeze
+
+        attr_accessor :session_id, :options
+
+        def initialize(session_id, options)
+          self.session_id = session_id
+          self.options = options
+        end
+
+        def run
+          puts JSON.pretty_generate(start_run)
+          exit(0)
+        end
+
+        def start_run
+          request_body = {
+            test_session_id: session_id,
+            "#{target_runnable_key}": target_runnable_id,
+            inputs: runnable_inputs
+          }
+
+          response = post('api/test_runs', request_body.to_json, content_type: 'application/json')
+
+          handle_web_api_error(response, :start_run) if response.status != 200
+
+          JSON.parse(response.body)
+        end
+
+        def session_details
+          @session_details ||= SessionDetails.new(session_id, options).details_for_session
+        end
+
+        def target_runnable_details
+          @target_runnable_details ||= find_target_runnable
+        end
+
+        def target_runnable_key
+          if target_runnable_details.key?('suite_summary')
+            'test_suite_id'
+          elsif target_runnable_details.key?('run_as_group')
+            'test_group_id'
+          else
+            'test_id'
+          end
+        end
+
+        def target_runnable_id
+          target_runnable_details['id']
+        end
+
+        def session_inputs
+          @session_inputs ||= SessionData.new(session_id, options).data_for_session(session_id)
+        end
+
+        def user_inputs
+          @user_inputs ||= normalize_inputs(options[:inputs] || {})
+        end
+
+        def normalize_inputs(inputs)
+          inputs.transform_values do |value|
+            next value.to_json if value.is_a?(Array) || value.is_a?(Hash)
+            next value unless value.to_s.start_with?('@')
+
+            path = File.expand_path(value[1..])
+            unless File.exist?(path)
+              puts JSON.pretty_generate({ errors: "File input not found: #{path}" })
+              exit(3)
+            end
+            File.read(path)
+          end
+        end
+
+        def runnable_inputs
+          @runnable_inputs ||= calculate_inputs
+        end
+
+        # runnable_to_find can be a complete internal id, an internal id suffix, or short id displayed in the UI.
+        # Use 'suite' to run the whole suite.
+        def find_target_runnable
+          if options[:runnable].blank?
+            error_object = { errors: 'No runnable specified. Use a group/test id or "suite" to run the whole suite.' }
+            puts error_object.to_json
+            exit(3)
+          end
+
+          target_runnable = options[:runnable] == 'suite' ? session_details['test_suite_id'] : options[:runnable]
+          target_runnable = target_runnable.to_s unless target_runnable.is_a?(String)
+
+          candidates = []
+          runnable_search(session_details['test_suite'], target_runnable, candidates)
+          if candidates.blank?
+            error_object =
+              { errors: "Runnable '#{target_runnable}' not found in suite '#{session_details['test_suite_id']}'" }
+            puts error_object.to_json
+            exit(3)
+          elsif candidates.size > 1
+            error_object =
+              { errors: "Runnable '#{target_runnable}' not unique in suite '#{session_details['test_suite_id']}'" }
+            puts error_object.to_json
+            exit(3)
+          end
+
+          candidates.first
+        end
+
+        def runnable_search(runnable_details, runnable_to_find, matches)
+          matches << runnable_details if runnable_matches?(runnable_details, runnable_to_find)
+          runnable_details['test_groups']&.each { |group| runnable_search(group, runnable_to_find, matches) }
+          runnable_details['tests']&.each { |test| runnable_search(test, runnable_to_find, matches) }
+        end
+
+        def runnable_matches?(runnable_details, runnable_to_find)
+          runnable_details['id'] == runnable_to_find ||
+            runnable_details['id']&.ends_with?("-#{runnable_to_find}") ||
+            runnable_details['short_id'] == runnable_to_find
+        end
+
+        # trying to replicate the process used in the UI
+        def calculate_inputs
+          target_runnable_details['inputs'].map do |runnable_input|
+            input_run_value(runnable_input)
+          end
+        end
+
+        def input_run_value(runnable_input)
+          input_name = runnable_input['name']
+          value = session_value_for_input(session_inputs, input_name)
+          value = user_inputs[input_name] if user_inputs[input_name].present?
+          value = runnable_input['default'] if value == '' && runnable_input['default'].present?
+          if runnable_input['type'] == 'auth_info'
+            component_object = value == '' ? {} : JSON.parse(value)
+            add_auth_info_component_defaults(component_object, runnable_input)
+            value = component_object.to_json
+          end
+
+          { 'name' => input_name, 'value' => value }
+        end
+
+        def session_value_for_input(session_inputs, input_name)
+          session_input = session_inputs.find { |input| input['name'] == input_name }
+          session_input&.dig('value') || ''
+        end
+
+        def add_auth_info_component_defaults(component_object, runnable_input)
+          default_from_runnable_components(component_object, runnable_input)
+          default_component_from_definitions(component_object, auth_info_mode_from_runnable_input(runnable_input))
+        end
+
+        def auth_info_mode_from_runnable_input(runnable_input)
+          mode = runnable_input.dig('options', 'mode')
+          if mode.nil?
+            'access'
+          elsif ['access', 'auth'].include?(mode)
+            mode
+          else
+            puts JSON.pretty_generate({ errors: "Failed to create run: unknown auth_info mode '#{mode}'." })
+            exit(3)
+          end
+        end
+
+        def default_component_from_definitions(component_object, mode)
+          component_object['auth_type'] = 'public' if component_object['auth_type'].blank?
+          auth_type = component_object['auth_type']
+          components_to_default = components_to_default(mode)
+
+          components_to_default.each do |component|
+            default_value = default_from_auth_info_component_definition(component, mode, auth_type)
+            if (component_object[component].blank? || component_object[component] == '') && !default_value.blank?
+              component_object[component] = default_value
+            end
+          end
+        end
+
+        def default_from_runnable_components(component_object, runnable_input)
+          runnable_input.dig('options', 'components')&.each do |component|
+            component_name = component['name']
+            unless component_object.key?(component_name) || component['default'].blank?
+              component_object[component_name] = component['default']
+            end
+          end
+        end
+
+        AUTH_INFO_COMPONENT_AUTH_MODE_DEFAULTS = {
+          'use_discovery' => 'true',
+          'pkce_support' => 'enabled',
+          'pkce_code_challenge_method' => 'S256',
+          'auth_request_method' => 'GET'
+        }.freeze
+
+        AUTH_INFO_COMPONENT_ACCESS_MODE_DEFAULTS = {
+          'access_token' => '',
+          'refresh_token' => '',
+          'issue_time' => '',
+          'expires_in' => ''
+        }.freeze
+
+        def components_to_default(mode)
+          components_to_default =
+            case mode
+            when 'access'
+              AUTH_INFO_COMPONENT_ACCESS_MODE_DEFAULTS.keys
+            when 'auth'
+              AUTH_INFO_COMPONENT_AUTH_MODE_DEFAULTS.keys
+            end
+          components_to_default << 'encryption_algorithm'
+
+          components_to_default
+        end
+
+        def default_from_auth_info_component_definition(component, mode, auth_type)
+          return 'public' if component == 'auth_type'
+          return 'ES384' if component == 'encryption_algorithm' && ['backend_services',
+                                                                    'asymmetric'].include?(auth_type)
+
+          case mode
+          when 'auth'
+            AUTH_INFO_COMPONENT_AUTH_MODE_DEFAULTS[component]
+          when 'access'
+            AUTH_INFO_COMPONENT_ACCESS_MODE_DEFAULTS[component]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inferno/apps/cli/session_commands.rb

@@ -0,0 +1,66 @@
+require_relative 'session/cancel_run'
+require_relative 'session/create_session'
+require_relative 'session/start_run'
+require_relative 'session/session_status'
+require_relative 'session/session_results'
+require_relative 'session/session_data'
+require_relative 'session/session_compare'
+
+module Inferno
+  module CLI
+    module Session
+      class SessionCommands < Thor
+        def initialize(args = [], local_options = {}, config = {})
+          super
+          return unless @options[:inferno_base_url]
+
+          @options = @options.merge(inferno_base_url: "#{@options[:inferno_base_url].delete_suffix('/')}/")
+        end
+
+        class_option :inferno_base_url,
+                     aliases: ['-I'],
+                     type: :string,
+                     desc: 'URL of the target Inferno service.'
+
+        desc 'create SUITE', 'Create a new session for a suite (internal ID, title, or short title).'
+        CreateSession::COMMAND_OPTIONS.each { |name, opts| option name, **opts }
+        def create(suite_id)
+          CreateSession.new(suite_id, options).run
+        end
+
+        desc 'cancel_run SESSION_ID', 'Cancel the current in-progress run for a session.'
+        def cancel_run(session_id)
+          CancelRun.new(session_id, options).run
+        end
+
+        desc 'start_run SESSION_ID RUNNABLE_ID', 'Initiate a test run on a session.'
+        StartRun::COMMAND_OPTIONS.each { |name, opts| option name, **opts }
+        def start_run(session_id, runnable_id)
+          StartRun.new(session_id, options.merge(runnable: runnable_id)).run
+        end
+
+        desc 'status SESSION_ID', 'Get the current run status of a session.'
+        def status(session_id)
+          SessionStatus.new(session_id, options).run
+        end
+
+        desc 'data SESSION_ID', 'Get the current session data (inputs) for a session.'
+        def data(session_id)
+          SessionData.new(session_id, options).run
+        end
+
+        desc 'results SESSION_ID', 'Get the results for a session.'
+        def results(session_id)
+          SessionResults.new(session_id, options).run
+        end
+
+        desc 'compare SESSION_ID',
+             'Compare the results of a session to expected results (from file or another session).'
+        SessionCompare::COMMAND_OPTIONS.each { |name, opts| option name, **opts }
+        def compare(session_id)
+          SessionCompare.new(session_id, options).run
+        end
+      end
+    end
+  end
+end

data/lib/inferno/apps/cli/templates/%library_name%.gemspec.tt

@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
   spec.metadata['inferno_test_kit'] = 'true'
   # spec.metadata['homepage_uri'] = spec.homepage
   # spec.metadata['source_code_uri'] = 'TODO'
-  spec.files         = `[ -d .git ] && git ls-files -z lib config/presets LICENSE`.split("\x0")
+  spec.files         = `[ -d .git ] && git ls-files -z lib config/presets execution_scripts LICENSE`.split("\x0")
 
   spec.require_paths = ['lib']
 end

data/lib/inferno/apps/cli/templates/.gitignore

@@ -20,3 +20,7 @@
 /docs/yard
 .yardoc
 node_modules
+
+# execution script failed run artifacts
+execution_scripts/**/*_actual_results*.json
+execution_scripts/**/*_compared_results*.csv

data/lib/inferno/apps/cli/templates/README.md.tt

@@ -25,6 +25,20 @@ More information about what is included in this repository can be [found here](h
 - [Ruby API documentation](https://inferno-framework.github.io/inferno-core/docs/)
 - [JSON API documentation](https://inferno-framework.github.io/inferno-core/api-docs/)
 
+## Verifying Test Kit Logic
+
+This template test kit includes examples for two tools that can be used to verify Inferno test kit logic:
+- Unit tests written in rspec: test kit code is verified in isolation from other components. Examples
+  of these can be found in the `spec` directory. Those examples and any others defined in that directory
+  will be executed by the ruby.yml workflow (`.github/workflows/ruby.yml`)
+  if this test kit is committed to a Github repository.
+- Execution scripts: test kit code is verified against previous results in a deployed Inferno
+  environment including the associated services. See [CI/CD Usage](https://inferno-framework.github.io/docs/ci-cd-usage.html)
+  in the Inferno documentation for more details on creating execution scripts. Examples of
+  these can be found in the `execution_scripts` directory. Those examples and any other defined in that directory
+  will be executed by the run_inferno_execution_scripts.yml workflow (`.github/workflows/run_inferno_execution_scripts.yml`)
+  if this test kit is committed to a Github repository.
+
 ## Example Inferno Test Kits
 
 A list of all Test Kits registered with the Inferno Team can be found on the [Test Kit Registry](https://inferno-framework.github.io/community/test-kits.html) page.

data/lib/inferno/apps/cli/templates/Rakefile.tt

@@ -5,6 +5,19 @@ begin
 rescue LoadError # rubocop:disable Lint/SuppressedException
 end
 
+namespace :execute_scripts do
+  desc 'Run all execution script YAML files against a local Inferno instance (already running). ' \
+       'Optional FILTER env var restricts by File.fnmatch pattern, e.g. FILTER="execution_scripts/demo/*". ' \
+       'Optional INFERNO_BASE_URL env var sets the target Inferno URL, e.g. INFERNO_BASE_URL="http://localhost:4567/"'
+  task :run_all do
+    require 'inferno/utils/execution_script_runner'
+    Inferno::Utils::ExecutionScriptRunner.run_all(
+      pattern: ENV.fetch('FILTER', 'execution_scripts/**/*.yaml'),
+      inferno_base_url: ENV.fetch('INFERNO_BASE_URL', nil)
+    )
+  end
+end
+
 namespace :db do
   desc 'Apply changes to the database'
   task :migrate do

data/lib/inferno/apps/cli/templates/execution_scripts/%library_name%_script.yaml.tt

@@ -0,0 +1,20 @@
+sessions:
+  - suite: <%= test_suite_id %>
+
+steps:
+  - state_description: Session Created
+    status: created
+    start_run:
+      runnable: suite
+      inputs:
+        url: https://inferno.healthit.gov/reference-server/r4
+        credentials:
+          access_token: SAMPLE_TOKEN
+        patient_id: 85
+    action_description: Run the entire suite
+
+  - state_description: Suite executed (The second (last) test in the patient (last) group has just finished)
+    status: done
+    last_completed: suite
+    action: END_SCRIPT
+    action_description: Complete the script

data/lib/inferno/apps/cli/templates/execution_scripts/%library_name%_script_expected.json.tt

@@ -0,0 +1,244 @@
+[
+  {
+    "id": "c7770e47-3e51-43fd-b8cd-a971959c006d",
+    "created_at": "2026-03-02T22:36:46.497-05:00",
+    "inputs": [
+      {
+        "name": "url",
+        "value": "https://inferno.healthit.gov/reference-server/r4",
+        "type": "text"
+      },
+      {
+        "name": "credentials",
+        "value": "{\"auth_type\":\"public\",\"access_token\":\"SAMPLE_TOKEN\",\"issue_time\":\"2026-03-02T22:36:46-05:00\",\"name\":\"credentials\"}",
+        "type": "auth_info"
+      }
+    ],
+    "optional": false,
+    "outputs": [],
+    "requests": [
+      {
+        "id": "7d67c8ca-76d2-4253-acb4-e1e5a0f90c1a",
+        "direction": "outgoing",
+        "index": 1,
+        "result_id": "c7770e47-3e51-43fd-b8cd-a971959c006d",
+        "status": 200,
+        "timestamp": "2026-03-02T22:36:46.498-05:00",
+        "url": "https://inferno.healthit.gov/reference-server/r4/metadata",
+        "verb": "get"
+      }
+    ],
+    "result": "pass",
+    "test_id": "<%= test_suite_id %>-capability_statement-capability_statement_read",
+    "test_run_id": "d0c43855-184a-4dcd-976e-83d6f99a996c",
+    "test_session_id": "eVoeqbmbIJV",
+    "updated_at": "2026-03-02T22:36:46.497-05:00"
+  },
+  {
+    "id": "6e3dd213-c012-4a3c-b6de-3d1ad0c5951d",
+    "created_at": "2026-03-02T22:36:46.508-05:00",
+    "inputs": [
+      {
+        "name": "url",
+        "label": "FHIR Server Base Url",
+        "description": null,
+        "value": "https://inferno.healthit.gov/reference-server/r4",
+        "type": "text"
+      },
+      {
+        "name": "credentials",
+        "label": "OAuth Credentials",
+        "description": null,
+        "value": "{\"auth_type\":\"public\",\"access_token\":\"SAMPLE_TOKEN\",\"issue_time\":\"2026-03-02T22:36:46-05:00\",\"name\":\"credentials\"}",
+        "type": "auth_info"
+      }
+    ],
+    "optional": false,
+    "outputs": [],
+    "requests": [],
+    "result": "pass",
+    "test_group_id": "<%= test_suite_id %>-capability_statement",
+    "test_run_id": "d0c43855-184a-4dcd-976e-83d6f99a996c",
+    "test_session_id": "eVoeqbmbIJV",
+    "updated_at": "2026-03-02T22:36:46.508-05:00"
+  },
+  {
+    "id": "98887da7-6525-4545-bb12-865c376f1889",
+    "created_at": "2026-03-02T22:36:46.629-05:00",
+    "inputs": [
+      {
+        "name": "patient_id",
+        "value": "85",
+        "type": "text"
+      },
+      {
+        "name": "url",
+        "value": "https://inferno.healthit.gov/reference-server/r4",
+        "type": "text"
+      },
+      {
+        "name": "credentials",
+        "value": "{\"auth_type\":\"public\",\"access_token\":\"SAMPLE_TOKEN\",\"issue_time\":\"2026-03-02T22:36:46-05:00\",\"name\":\"credentials\"}",
+        "type": "auth_info"
+      }
+    ],
+    "optional": false,
+    "outputs": [],
+    "requests": [
+      {
+        "id": "694ec151-aa8f-455b-82d7-9f7d2771cf09",
+        "direction": "outgoing",
+        "index": 2,
+        "result_id": "98887da7-6525-4545-bb12-865c376f1889",
+        "status": 200,
+        "timestamp": "2026-03-02T22:36:46.630-05:00",
+        "url": "https://inferno.healthit.gov/reference-server/r4/Patient/85",
+        "verb": "get"
+      }
+    ],
+    "result": "pass",
+    "test_id": "<%= test_suite_id %>-patient_group-Test01",
+    "test_run_id": "d0c43855-184a-4dcd-976e-83d6f99a996c",
+    "test_session_id": "eVoeqbmbIJV",
+    "updated_at": "2026-03-02T22:36:46.629-05:00"
+  },
+  {
+    "id": "8e822421-cef1-4889-99cf-b25212a66884",
+    "created_at": "2026-03-02T22:36:50.645-05:00",
+    "inputs": [
+      {
+        "name": "url",
+        "value": "https://inferno.healthit.gov/reference-server/r4",
+        "type": "text"
+      },
+      {
+        "name": "credentials",
+        "value": "{\"auth_type\":\"public\",\"access_token\":\"SAMPLE_TOKEN\",\"issue_time\":\"2026-03-02T22:36:46-05:00\",\"name\":\"credentials\"}",
+        "type": "auth_info"
+      }
+    ],
+    "messages": [
+      {
+        "message": "Patient/85: Patient.meta.profile[0]: A definition could not be found for Canonical URL 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient'",
+        "type": "info"
+      },
+      {
+        "message": "Patient/85: Patient.extension[0]: Unknown extension http://hl7.org/fhir/us/core/StructureDefinition/us-core-race",
+        "type": "info"
+      },
+      {
+        "message": "Patient/85: Patient.extension[0].extension[0].value.ofType(Coding): The definition for the Code System with URI 'urn:oid:2.16.840.1.113883.6.238' doesn't provide any codes so the code cannot be validated",
+        "type": "info"
+      },
+      {
+        "message": "Patient/85: Patient.extension[1]: Unknown extension http://hl7.org/fhir/us/core/StructureDefinition/us-core-ethnicity",
+        "type": "info"
+      },
+      {
+        "message": "Patient/85: Patient.extension[1].extension[0].value.ofType(Coding): The definition for the Code System with URI 'urn:oid:2.16.840.1.113883.6.238' doesn't provide any codes so the code cannot be validated",
+        "type": "info"
+      },
+      {
+        "message": "Patient/85: Patient.extension[2]: Unknown extension http://hl7.org/fhir/us/core/StructureDefinition/us-core-birthsex",
+        "type": "info"
+      },
+      {
+        "message": "Patient/85: Patient.identifier[2].type: None of the codings provided are in the value set 'IdentifierType' (http://hl7.org/fhir/ValueSet/identifier-type|4.0.1), and a coding should come from this value set unless it has no suitable code (note that the validator cannot judge what is suitable) (codes = http://terminology.hl7.org/CodeSystem/v2-0203#SS)",
+        "type": "warning"
+      },
+      {
+        "message": "Patient/85: Patient.meta.profile[0]: Profile reference 'http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient' has not been checked because it could not be found, and the validator is set to not fetch unknown profiles",
+        "type": "warning"
+      }
+    ],
+    "optional": false,
+    "outputs": [],
+    "requests": [
+      {
+        "id": "694ec151-aa8f-455b-82d7-9f7d2771cf09",
+        "direction": "outgoing",
+        "index": 2,
+        "result_id": "98887da7-6525-4545-bb12-865c376f1889",
+        "status": 200,
+        "timestamp": "2026-03-02T22:36:46.630-05:00",
+        "url": "https://inferno.healthit.gov/reference-server/r4/Patient/85",
+        "verb": "get"
+      }
+    ],
+    "result": "pass",
+    "test_id": "<%= test_suite_id %>-patient_group-Test02",
+    "test_run_id": "d0c43855-184a-4dcd-976e-83d6f99a996c",
+    "test_session_id": "eVoeqbmbIJV",
+    "updated_at": "2026-03-02T22:36:50.645-05:00"
+  },
+  {
+    "id": "52466b2f-c11f-4697-9570-6fe88b552a1e",
+    "created_at": "2026-03-02T22:36:50.656-05:00",
+    "inputs": [
+      {
+        "name": "patient_id",
+        "label": "Patient ID",
+        "description": null,
+        "value": "85",
+        "type": "text"
+      },
+      {
+        "name": "url",
+        "label": "FHIR Server Base Url",
+        "description": null,
+        "value": "https://inferno.healthit.gov/reference-server/r4",
+        "type": "text"
+      },
+      {
+        "name": "credentials",
+        "label": "OAuth Credentials",
+        "description": null,
+        "value": "{\"auth_type\":\"public\",\"access_token\":\"SAMPLE_TOKEN\",\"issue_time\":\"2026-03-02T22:36:46-05:00\",\"name\":\"credentials\"}",
+        "type": "auth_info"
+      }
+    ],
+    "optional": false,
+    "outputs": [],
+    "requests": [],
+    "result": "pass",
+    "test_group_id": "<%= test_suite_id %>-patient_group",
+    "test_run_id": "d0c43855-184a-4dcd-976e-83d6f99a996c",
+    "test_session_id": "eVoeqbmbIJV",
+    "updated_at": "2026-03-02T22:36:50.656-05:00"
+  },
+  {
+    "id": "9d550f22-08de-4b39-b05a-93b69cf979e7",
+    "created_at": "2026-03-02T22:36:50.659-05:00",
+    "inputs": [
+      {
+        "name": "url",
+        "label": "FHIR Server Base Url",
+        "description": null,
+        "value": "https://inferno.healthit.gov/reference-server/r4",
+        "type": "text"
+      },
+      {
+        "name": "credentials",
+        "label": "OAuth Credentials",
+        "description": null,
+        "value": "{\"auth_type\":\"public\",\"access_token\":\"SAMPLE_TOKEN\",\"issue_time\":\"2026-03-02T22:36:46-05:00\",\"name\":\"credentials\"}",
+        "type": "auth_info"
+      },
+      {
+        "name": "patient_id",
+        "label": "Patient ID",
+        "description": null,
+        "value": "85",
+        "type": "text"
+      }
+    ],
+    "optional": false,
+    "outputs": [],
+    "requests": [],
+    "result": "pass",
+    "test_run_id": "d0c43855-184a-4dcd-976e-83d6f99a996c",
+    "test_session_id": "eVoeqbmbIJV",
+    "test_suite_id": "<%= test_suite_id %>",
+    "updated_at": "2026-03-02T22:36:50.659-05:00"
+  }
+]

data/lib/inferno/apps/cli/templates/execution_scripts/README.md.tt

@@ -0,0 +1,16 @@
+# Using Core Execution Scripts
+
+This directory contains [execution scripts](https://inferno-framework.github.io/docs/advanced-test-features/scripting-execution.html)
+that demonstrate and validate the behavior of suites defined
+by this test kit in the context of running Inferno services
+allowing for end-to-end executions that check for expected suite execution
+results when using Inferno services like the FHIR Validator and FHIR Path
+Service as well as dependency services that Inferno does not control such
+as `tx.fhir.org`.
+
+Execution scripts defined here will
+be [executed](https://inferno-framework.github.io/docs/advanced-test-features/scripting-execution.html#execution)
+automatically on pull requests as a part of the github
+workflows and can also be executed locally using the
+[`execute_script` CLI](https://inferno-framework.github.io/docs/getting-started/inferno-cli.html#complex-scripted-execution)
+on individual scripts or the `execute_scripts:run_all` rake task.