us_core_test_kit 0.11.3 → 0.11.4

data/lib/us_core_test_kit/client/generated/v7.0.0/wait_group.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require 'smart_app_launch_test_kit'
+require_relative 'auth_smart_alca_group'
+require_relative 'auth_smart_alcs_group'
+require_relative 'auth_smart_alp_group'
 
 module USCoreTestKit
   module Client
@@ -8,86 +11,93 @@ module USCoreTestKit
       class WaitGroup < Inferno::TestGroup
         include URLs
 
-        id :us_core_client_wait_group_v700
-        title 'Wait for Requests'
+        id :us_core_client_access_group_v700
+        title 'Client Access'
         description %(
-          
-This test will wait for the client under test to submit requests for resources for
-each of the US Core profiles, and for requests including all of the required search
-parameters for each resource type.
-
+          During these tests, Inferno will simulate a US Core FHIR Server for the client to
+          use to access data. Inferno will wait while the client submits requests and will
+          both respond with data and collect the requests for later analysis.
         )
 
+        run_as_group
+
         def suite_id
           return config.options[:endpoint_suite_id] if config.options[:endpoint_suite_id].present?
           
           'us_core_client_v700'
         end
 
-        test do
-          id :us_core_client_wait_test_v700
-          title 'Wait for Requests'
-          description %(
-            
-This test will wait for the client under test to submit requests for resources for
-each of the US Core profiles, and for requests including all of the required search
-parameters for each resource type.
-
-          )
+        group do
+          id :us_core_client_wait_group_v700
+          title 'Perform Data Access'
 
-          input :client_id,
-                title: 'Client Id',
-                type: 'text',
-                optional: true,
-                locked: true,
-                description: SMARTAppLaunch::INPUT_CLIENT_ID_DESCRIPTION_LOCKED
-          input :smart_launch_urls,
-                title: 'SMART App Launch URL(s)',
-                type: 'textarea',
-                locked: true,
-                optional: true,
-                description: SMARTAppLaunch::INPUT_SMART_LAUNCH_URLS_DESCRIPTION_LOCKED
-          input :launch_context,
-                title: 'Launch Context',
-                type: 'textarea',
-                optional: true,
-                description: SMARTAppLaunch::INPUT_LAUNCH_CONTEXT_DESCRIPTION       
-          input :fhir_user_relative_reference,
-                title: 'FHIR User Relative Reference',
-                type: 'text',
-                optional: true,
-                description: SMARTAppLaunch::INPUT_FHIR_USER_RELATIVE_REFERENCE
-          
-          input_order :launch_context, :fhir_user_relative_reference, :smart_launch_urls, :client_id
-          output :launch_key
-          config options: { accepts_multiple_requests: true }
+          test do
+            id :us_core_client_wait_test_v700
+            title 'Wait for Requests'
+            description %(
+              This test will wait for the client under test to submit requests for resources for
+              each of the US Core profiles, and for requests including all of the required search
+              parameters for each resource type.
+            )
 
-          run do
-            if smart_launch_urls.present?
-              launch_key = SecureRandom.hex(32)
-              output(launch_key:)
-            end
+            input :client_id,
+                  title: 'Client Id',
+                  type: 'text',
+                  optional: true,
+                  locked: true,
+                  description: SMARTAppLaunch::INPUT_CLIENT_ID_DESCRIPTION_LOCKED
+            input :smart_launch_urls,
+                  title: 'SMART App Launch URL(s)',
+                  type: 'textarea',
+                  locked: true,
+                  optional: true,
+                  description: SMARTAppLaunch::INPUT_SMART_LAUNCH_URLS_DESCRIPTION_LOCKED
+            input :launch_context,
+                  title: 'Launch Context',
+                  type: 'textarea',
+                  optional: true,
+                  description: SMARTAppLaunch::INPUT_LAUNCH_CONTEXT_DESCRIPTION       
+            input :fhir_user_relative_reference,
+                  title: 'FHIR User Relative Reference',
+                  type: 'text',
+                  optional: true,
+                  description: %(
+                    A FHIR relative reference (<resource type>/<id>) for the FHIR user record to return
+                    when the openid and fhirUser scopes are requested. If populated, ensure that the
+                    referenced resource is available in Inferno's simulated FHIR server so that it can
+                    be accessed.
+                  )
             
-            wait(
-              identifier: client_id,
-              message: %(
-Inferno will now wait for the client under test to make the required requests against the following base URL:
+            input_order :launch_context, :fhir_user_relative_reference, :smart_launch_urls, :client_id
+            output :launch_key
+            config options: { accepts_multiple_requests: true }
+
+            run do
+              if smart_launch_urls.present?
+                launch_key = SecureRandom.hex(32)
+                output(launch_key:)
+              end
+              
+              wait(
+                identifier: client_id,
+                message: %(
+  Inferno will now wait for the client under test to make the required requests against the following base URL:
 
-#{fhir_url}
+  #{fhir_url}
 
-All requests will be recorded. When finished, the requests will be inspected to ensure that the client under test is making the required requests.
-Requests should target the following patient record:
-- **Resource ID**: us-core-client-tests-patient
-- **Name**: ClientTests USCore
-- **Member Identifier**: us-core-client-tests-patient (system: Inferno)
-- **Date of Birth**: 1940-03-29
-- **Gender**: male
+  All requests will be recorded. When finished, the requests will be inspected to ensure that the client under test is making the required requests.
+  Requests should target the following patient record:
+  - **Resource ID**: `us-core-client-tests-patient`
+  - **Name**: ClientTests USCore
+  - **Member Identifier**: `us-core-client-tests-patient` (system: `urn:inferno:mrn`)
+  - **Date of Birth**: 1940-03-29
+  - **Gender**: male
 
-[Click here](#{resume_pass_url}?token=#{client_id}) when finished.
+  [Click here](#{resume_pass_url}?token=#{client_id}) when finished.
 
-The following requirements will be checked:
+  The following requirements will be checked:
 
-* **Patient**
+  * **Patient**
   * read id:
     * us-core-client-tests-patient
   * searches:
@@ -555,12 +565,26 @@ The following requirements will be checked:
     * patient
     * _id
 
-[Click here](#{resume_pass_url}?token=#{client_id}) when finished.
-              ),
-              timeout: 900
-            )
+  [Click here](#{resume_pass_url}?token=#{client_id}) when finished.
+                ),
+                timeout: 900
+              )
+            end
           end
         end
+
+        group from: :us_core_client_v700_auth_smart_alca,
+              required_suite_options: {
+                client_type: USCoreClientOptions::SMART_APP_LAUNCH_CONFIDENTIAL_ASYMMETRIC
+              }
+        group from: :us_core_client_v700_auth_smart_alcs,
+              required_suite_options: {
+                client_type: USCoreClientOptions::SMART_APP_LAUNCH_CONFIDENTIAL_SYMMETRIC
+              }
+        group from: :us_core_client_v700_auth_smart_alp,
+              required_suite_options: {
+                client_type: USCoreClientOptions::SMART_APP_LAUNCH_PUBLIC
+              }
       end
     end
   end

data/lib/us_core_test_kit/client/generator/group_generator.rb

@@ -33,23 +33,52 @@ module USCoreTestKit
 
             # Background
 
-            This test group verifies that the client under test is
-            able to perform the required #{resource_type} queries.
+            This test group verifies that the client can access #{resource_type} data
+            conforming to the #{profile_name}.
 
             # Testing Methodology
+            
+            ## Data Access Supported
+
+            Clients may not be required to support the #{resource_type} FHIR resource type. However, if they
+            do support it, they must support the #{profile_name} and the resource type's search parameters.
+            The tests in this group will not execute if client makes no attempt to access data for the
+            #{resource_type} resource type. In this case, the test will be marked as skip if support
+            for the resource type is required, and omitted otherwise.
 
             ## Reading
-            This sequence will check that the client performed a search with the following ID:
+            This test will check that the client performed a read of the following id:
 
             * `us-core-client-tests-#{profile_identifier.underscore.dasherize}`
 
             ## Searching
-            This sequence will check that the client performed searches with the following parameters:
+            These tests will check that the client performed searches agains the
+            #{resource_type} resource type with the following required parameters:
 
             #{search_param_name_string}
+            
+            Inferno will also look for searches using the following optional parameters:
+
+            #{optional_search_param_name_string}
+            
           DESCRIPTION
         end
 
+        def optional_searches
+          group_metadata.searches.select { |search| search[:expectation] != 'SHALL' }
+        end
+
+        def optional_search_param_name_string
+          optional_searches
+            .map { |search| search[:names].join(' + ') }
+            .map { |names| "* #{names}" }
+            .join("\n")
+        end
+
+        def conformance_optional?
+          group_metadata.resource_conformance_expectation != 'SHALL'
+        end
+
         def generate
           File.write(output_file_name, output)
           group_metadata.id = group_id

data/lib/us_core_test_kit/client/generator/ig_loader.rb

@@ -0,0 +1,14 @@
+require_relative '../generator/ig_loader'
+require_relative 'ig_resources'
+
+module USCoreTestKit
+  module Client
+    class Generator
+      class IGLoader < USCoreTestKit::Generator::IGLoader
+        def ig_resources
+          @ig_resources ||= IGResources.new
+        end
+      end
+    end
+  end
+end

data/lib/us_core_test_kit/client/generator/ig_resources.rb

@@ -0,0 +1,13 @@
+module USCoreTestKit
+  module Client
+    class Generator
+      class IGResources < USCoreTestKit::Generator::IGResources
+        def capability_statement(mode = 'client')
+          resources_by_type['CapabilityStatement'].find do |capability_statement_resource|
+            capability_statement_resource.rest.any? { |r| r.mode == mode }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/us_core_test_kit/client/generator/naming.rb

@@ -0,0 +1,30 @@
+module USCoreTestKit
+  module Client
+    class Generator
+      module Naming
+        ID_SPECIAL_CASE = {
+          # v3.1.1 profile naming mismatches
+          'condition' => 'condition-encounter-diagnosis',
+          'head-circumference' => 'head-circumference-percentile',
+          'bodyheight' => 'body-height',
+          'bodytemp' => 'body-temperature',
+          'bp' => 'blood-pressure',
+          'bodyweight' => 'body-weight',
+          'heartrate' => 'heart-rate',
+          'resprate' => 'respiratory-rate'
+        }.freeze
+
+        class << self
+          def instance_id_for_profile_identifier(profile_identifier)
+            suffix = profile_identifier.underscore.dasherize
+            if ID_SPECIAL_CASE.key?(suffix)
+              suffix = ID_SPECIAL_CASE[suffix]
+            end
+            
+            "us-core-client-tests-#{suffix}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/us_core_test_kit/client/generator/read_test_generator.rb

@@ -3,6 +3,7 @@
 require_relative '../../generator/read_test_generator'
 require_relative '../../generator/naming'
 require_relative '../../generator/special_cases'
+require_relative 'naming'
 
 module USCoreTestKit
   module Client
@@ -33,7 +34,7 @@ module USCoreTestKit
         end
 
         def expected_resource_id
-          "us-core-client-tests-#{profile_identifier.underscore.dasherize}"
+          Naming.instance_id_for_profile_identifier(profile_identifier)
         end
 
         def title

data/lib/us_core_test_kit/client/generator/search_test_generator.rb

@@ -15,8 +15,6 @@ module USCoreTestKit
                        .select { |group| group.searches.present? }
                        .each do |group|
               group.searches.each do |search|
-                next unless search[:expectation] == 'SHALL'
-
                 new(group, search, base_output_dir).generate
               end
             end

data/lib/us_core_test_kit/client/generator/suite_generator.rb

@@ -2,6 +2,7 @@
 
 require_relative '../../generator/suite_generator'
 require_relative '../../generator/special_cases'
+require_relative 'naming'
 
 module USCoreTestKit
   module Client
@@ -50,7 +51,7 @@ module USCoreTestKit
           <<~DESCRIPTION
 
             The US Core Test Kit Client Suite tests client systems for their conformance
-            to the US Core Implementation Guide.
+            to the [US Core Implementation Guide](#{ig_link}).
 
             # Scope
 
@@ -61,42 +62,63 @@ module USCoreTestKit
 
             # Test Methodology
 
-            For these tests Inferno simulates the FHIR server. Inferno's simulated server contains
-            data for each of the following US Core Profiles:
-
-            #{profiles_description}
-
+            For these tests Inferno simulates the FHIR server containing data for each US Core Profile
+            (see the *Available Instances* section below for details on the data served by Inferno).
             During execution, Inferno will wait for the client under test to issue requests and will
             respond to them with the requested data. Inferno will then evaluate the requests in aggregate
             to verify that they demonstrate that the client:
 
-            * Retrieved instances of each profile
+            * Retrieved a target instance for each profile.
             * Performed searches using the required search parameters and search parameter combinations
+              for the profile's resource type.
+
+            # Interpreting the Results
+             
+            These tests will check for support for requesting data for every US Core profile.
+            The "Read & Search" group includes a sub-group for each US Core profile. Groups
+            for profiles of resources that are required by the US Core Client CapabilityStatement
+            are marked as required while groups for others are optional. Each profile group will be
+            evaluated on every run through these tests, but feedback will only be provided on
+            profiles of resource types that the client makes requests for.
+            - If a client makes a request for a given resource type, support for all profiles of that
+              resource type will be evaluated, meaning that the group for each profile of that resource
+              type will be executed, checking that the client read the target instance for that profile
+              and perform searches with all required search parameters and combinations for the resource
+              type. The executed group will pass or fail and include details of the issues encountered by
+              Inferno.
+            - If a client makes no requests for a given resource type, support is not evaluated. If support
+              for the resource type is required, the tests will be marked as skiped, forcing an overall
+              failure. Otherwise, the tests will be marked as omitted on the assumption that the client
+              does not support the optional resource type and profile represented by the group.
+
+            The tests will not pass unless at least one profile group passes.
 
             # Running the Tests
 
             ## Quick Start
 
             Inferno's simulated US Core endpoints require authentication using the OAuth flows
-            conforming to one of the following:
-            - SMART [App Launch flow](https://hl7.org/fhir/smart-app-launch/STU2.2/app-launch.html), or
-            - UDAP [Consumer-Facing flow](https://hl7.org/fhir/us/udap-security/STU1/consumer.html).
+            conforming the SMART [App Launch flow](https://hl7.org/fhir/smart-app-launch/STU2.2/app-launch.html).
 
             When creating a test session, select the Client Security Type corresponding to an
             authentication approach supported by the client. Then, start by running the "Client Registration"
             group which will guide you through the registration process, including what inputs to provide.
             See the *Auth Configuration Details* section below for details.
 
-            Once registration is complete, run the "Read & Search" group to have Inferno wait for US Core
-            read and search requests from the client, return the requested US Core
-            resources to the client, and verify the interactions. The Patient that the client
+            Once registration is complete, run the "Read & Search" group to activate Inferno's
+            simulated US Core server, allowing it to wait for US Core read and search requests
+            from the client and return the requested US Core resources. The Patient that the client
             needs to request data for has the following demographic details:
-            - **Resource ID**: us-core-client-tests-patient
+            - **Resource ID**: `us-core-client-tests-patient`
             - **Name**: ClientTests USCore
-            - **Member Identifier**: us-core-client-tests-patient (system: Inferno)
+            - **Member Identifier**: `us-core-client-tests-patient` (system: `urn:inferno:mrn`)
             - **Date of Birth**: 1940-03-29
             - **Gender**: male
 
+            While waiting, Inferno will display a "User Action Needed" dialog with the above details and
+            more. Once the client has made all the requests, click the link in that dialog to have
+            Inferno evaluate the requests made.
+
             ## Demonstration
 
             To try out these tests without an actual US Core client implementation, you may run them against
@@ -118,40 +140,32 @@ module USCoreTestKit
                may fail.
             4. Select the "US Core FHIR API" group from the list at the left, click the "RUN ALL TESTS" button
                in the upper right, and then click "SUBMIT" at the bottom of the input dialog that appears.
-               These tests will run for a while and may result in test failures around must support and
-               conformance features.
+               These tests will run for a while. Most groups will skip due to incomplete coverage of must support
+               elements in the client test's data set.
             5. Once the server tests have completed, return to the client test session and click the link
                in the "User Action Required" dialog to continue the tests and evaluate the client's
-               interactions. These tests will also run for a while and may result in some failures.
+               interactions. These tests will also run for a while and may result in some failures or skips.
 
             # Input Details
 
             ## Auth Configuration Details
 
-            When running these tests there are 4 options for authentication, which also allows
+            When running these tests there are 3 options for SMART authentication, which also allows
             Inferno to identify which session the requests are for. The choice is made when the
             session is created with the selected Client Security Type option, which determines
-            what details the tester needs to provide during the Client Registration tests:
-
-            - **SMART App Launch Client**: the system under test will manually register
-              with Inferno and request access tokens to use when accessing FHIR endpoints
-              as per the SMART App Luanch specification, which includes providing one or more
-              redirect URI(s) in the **SMART App Launch Redirect URI(s)** input, and optionally,
-              launch URL(s) in the **SMART App Launch URL(s)** input. Additionally, testers may provide
-              a **Client Id** if they want their client assigned a specific one. Depending on the
-              specific SMART flavor chosen, additional inputs for authentication may be needed:
-              - **SMART App Launch Public Client**: no additional authentication inputs
-              - **SMART App Launch Confidential Symmetric Client**: provide a secret using the
-                **SMART Confidential Symmetric Client Secret** input.
-              - **SMART App Launch Confidential Asymmetric Client**: provide a URL that resolves
-                to a JWKS or a raw JWKS in JSON format using the **SMART JSON Web Key Set (JWKS)** input.
-            - **UDAP Authorization Code Client**: the system under test will dynamically register
-              with Inferno and request access tokens used to access FHIR endpoints
-              as per the UDAP specification. It requires the **UDAP Client URI** input
-              to be populated with the URI that the client will use when dynamically
-              registering with Inferno. This will be used to generate a client id (each
-              unique UDAP Client URI will always get the same client id). All other details
-              that Inferno needs will be provided as a part of the dynamic registration.
+            what details the tester needs to provide during manual SMART registration with Inferno.
+
+            In all cases, testers will provide:
+            - One or more redirect URI(s) in the **SMART App Launch Redirect URI(s)** input.
+            - Zero or more launch URL(s) in the **SMART App Launch URL(s)** input.
+            - Optionally, a **Client Id** if they want their client assigned a specific id. 
+              
+            Depending on the specific SMART flavor chosen, additional inputs for authentication may be needed:
+            - **SMART App Launch Public Client**: no additional authentication inputs
+            - **SMART App Launch Confidential Symmetric Client**: provide a secret using the
+              **SMART Confidential Symmetric Client Secret** input.
+            - **SMART App Launch Confidential Asymmetric Client**: provide a URL that resolves
+              to a JWKS or a raw JWKS in JSON format using the **SMART JSON Web Key Set (JWKS)** input.
 
             ## Inputs Controlling Token Responses
 
@@ -170,40 +184,57 @@ module USCoreTestKit
               If populated, ensure that the referenced resource is available in Inferno's simulated
               FHIR server so that it can be accessed.
 
+            # Available Instances
+             
+            Inferno's simulated US Core server includes the following target instances for the test patient
+
+            #{profiles_description}
+
             # Current Limitations
 
             This test suite is still in draft form and does not test all of the client requirements and features
             described in the US Core Implementation guide.
 
-            The current version of this test suite supports:
+            The current version of this test suite supports the following tests using a specific Inferno-specified patient:
             - Testing a client's ability to perform read requests against a FHIR server for all US Core Profiles
-            summarized in the US Core Capability Statement.
-            - Testing a client's ability to perform searches using the SHALL conformance search parameters
-            summarized in the US Core Capability Statement.
+              listed in the [US Core Client CapabilityStatement](#{ig_link}/CapabilityStatement-us-core-client.html).
+            - Testing a client's ability to perform searches using search parameters and combinations
+              listed for each resource type in the [US Core Client CapabilityStatement](#{ig_link}/CapabilityStatement-us-core-client.html).
 
-            The current version of this test suite does not support:
-            - Testing searches with/via:
+            The current version of this test suite does not:
+            - Support esting searches with/via:
               - date comparator
               - multiple-OR
               - _revInclude
-              - The client SHALL provide values precise to the day for elements of datatype date and to the second + time offset for elements of datatype dateTime.
-            - The Must Support Conformance Requirements for clients/requestors specified in US Core IG #{ig_metadata.ig_version}
-            - Clients that cannot follow the SMART App Launch or UDAP Consumer-Facing OAuth flows to obtain an access token.
+            - Verify that date and dateTime search parameter values are provided at the required level of precision.
+            - Check the Must Support Conformance Requirements for clients/requestors specified in US Core IG #{ig_metadata.ig_version}
+            - Support clients that cannot follow the SMART App Launch OAuth flow to obtain an access token.
+            - Allow testers to bring their own data. Testers must manually configure their client system to connect
+              to a specific target patient and must access and process specific curated sample US Core data.
 
           DESCRIPTION
         end
 
+        def read_and_search_description
+          <<~DESCRIPTION
+            
+            During these tests, the US Core client system will interact with Inferno's simulated US Core Server
+            and demonstrate its ability to perform the FHIR interactions described in the [US Core Client CapabilityStatement](#{ig_link}/CapabilityStatement-us-core-client.html).
+          
+          DESCRIPTION
+        end
+
         def profiles_description
           groups
             .map do |group|
               profile = USCoreTestKit::Generator::Naming.snake_case_for_profile(group)
-              "* **#{profile.camelize}**\n  * id: us-core-client-tests-#{profile.underscore.dasherize}"
+              "* **[#{group.profile_name}](#{group.profile_url}|#{group.profile_version})** (id: #{Naming.instance_id_for_profile_identifier(profile)})"
             end
             .join("\n")
         end
 
-        def wait_group_id
-          "us_core_client_wait_group_#{ig_metadata.reformatted_version.downcase}"
+        def access_group_id
+          "us_core_client_access_group_#{ig_metadata.reformatted_version.downcase}"
         end
 
         def registration_group_id

data/lib/us_core_test_kit/client/generator/templates/group.rb.erb

@@ -9,13 +9,11 @@ module USCoreTestKit
     module <%= module_name %>
       class <%= class_name %> < Inferno::TestGroup
         id :<%= group_id %>
-
         title '<%= title %>'
-
         description %(
           <%= description %>
         )
-
+        optional <%= conformance_optional? %>
         run_as_group
 
         <%- test_id_list.each do |test| -%>

data/lib/us_core_test_kit/client/generator/templates/read_endpoint.rb.erb

@@ -2,27 +2,23 @@
 
 require_relative '../../server_proxy'
 require_relative 'tags'
+require_relative 'urls'
 
 module USCoreTestKit
   module Client
     module <%= module_name %>
       class ReadEndpoint < Inferno::DSL::SuiteEndpoint
         include ServerProxy
+        include URLs
 
         def test_run_identifier
-          UDAPSecurityTestKit::MockUDAPServer.issued_token_to_client_id(
+          SMARTAppLaunch::MockSMARTServer.issued_token_to_client_id(
             request.headers['authorization']&.delete_prefix('Bearer ')
           )
         end
 
         def make_response
-          server_response = proxy_request
-          response.status = server_response.status
-          response.body = server_response.body
-        end
-
-        def proxy_request
-          proxy_client.get("#{resource_type}/#{resource_id}", request_params)
+          build_proxied_read_response
         end
 
         def tags
@@ -38,16 +34,12 @@ module USCoreTestKit
           end
         end
 
-        def resource_id
-          request.params[:resource_id]
-        end
-
         def resource_type
           request.params[:resource_type]
         end
 
-        def request_params
-          request.params.to_h.except(:resource_id, :resource_type).stringify_keys
+        def suite_id
+          USCoreClientTestSuite.id
         end
       end
     end