us_core_test_kit 0.11.2 → 0.11.4

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'smart_app_launch_test_kit'
+require_relative '../../../version'
+require_relative 'tags'
+require_relative 'urls'
+require_relative '../../metadata_helper'
+require_relative 'read_endpoint'
+require_relative 'search_endpoint'
+require_relative '../../test_helper'
+require_relative '../../us_core_client_options'
+require_relative 'registration_group'
+require_relative 'wait_group'
+require_relative 'auth_smart_alca_group'
+require_relative 'auth_smart_alcs_group'
+require_relative 'auth_smart_alp_group'
+<%- group_file_list.each do |group| -%>
+require_relative '<%= group %>'
+<%- end -%>
+
+module USCoreTestKit
+  module Client
+    module <%= module_name %>
+      class <%= class_name %> < Inferno::TestSuite
+        include URLs
+
+        id :<%= suite_id %>
+        title '<%= title %>'
+        description %(
+          <%= description %>
+        )
+
+        links [
+          {
+            type: 'report_issue',
+            label: 'Report Issue',
+            url: 'https://github.com/inferno-framework/us-core-test-kit/issues/'
+          },
+          {
+            type: 'source_code',
+            label: 'Open Source',
+            url: 'https://github.com/inferno-framework/us-core-test-kit/'
+          },
+          {
+            type: 'download',
+            label: 'Download',
+            url: 'https://github.com/inferno-framework/us-core-test-kit/releases/'
+          },
+          {
+            label: 'Implementation Guide',
+            url: '<%= ig_link %>'
+          }
+        ]
+
+        suite_option  :client_type,
+                      title: 'Client Security Type',
+                      list_options: [
+                        {
+                          label: 'SMART App Launch Public Client',
+                          value: USCoreClientOptions::SMART_APP_LAUNCH_PUBLIC
+                        },
+                        {
+                          label: 'SMART App Launch Confidential Symmetric Client',
+                          value: USCoreClientOptions::SMART_APP_LAUNCH_CONFIDENTIAL_SYMMETRIC
+                        },
+                        {
+                          label: 'SMART App Launch Confidential Asymmetric Client',
+                          value: USCoreClientOptions::SMART_APP_LAUNCH_CONFIDENTIAL_ASYMMETRIC
+                        }
+                      ]
+
+        route(:get, METADATA_PATH, USCoreTestKit::Client::MetadataHelper.get_metadata('<%= ig_metadata.reformatted_version.downcase %>'))
+        route(:get, SMARTAppLaunch::SMART_DISCOVERY_PATH, lambda { |_env|
+          SMARTAppLaunch::MockSMARTServer.smart_server_metadata(id)
+        })
+        route(:get, SMARTAppLaunch::OIDC_DISCOVERY_PATH, ->(_env) {SMARTAppLaunch::MockSMARTServer.openid_connect_metadata(id) }) 
+        route(
+          :get,
+          SMARTAppLaunch::OIDC_JWKS_PATH,
+          ->(_env) { [200, { 'Content-Type' => 'application/json' }, [SMARTAppLaunch::OIDCJWKS.jwks_json]] }
+        )
+
+        suite_endpoint :post, SMARTAppLaunch::TOKEN_PATH, SMARTAppLaunch::MockSMARTServer::TokenEndpoint
+        suite_endpoint :get,  SMARTAppLaunch::AUTHORIZATION_PATH, SMARTAppLaunch::MockSMARTServer::AuthorizationEndpoint
+        suite_endpoint :post, SMARTAppLaunch::AUTHORIZATION_PATH, SMARTAppLaunch::MockSMARTServer::AuthorizationEndpoint
+
+        suite_endpoint :post, SEARCH_POST_ROUTE, SearchEndpoint
+        suite_endpoint :get, SEARCH_ROUTE, SearchEndpoint
+        suite_endpoint :get, READ_ROUTE, ReadEndpoint
+
+        resume_test_route :get, RESUME_PASS_ROUTE do |request|
+          request.query_parameters['token']
+        end
+
+        group from: :<%= registration_group_id %>
+
+        group do
+          id :us_core_client_read_search_group_<%= ig_metadata.reformatted_version.downcase %>
+          title 'Read & Search'
+          description %(
+            <%= read_and_search_description %>
+          )
+
+          group from: :<%= access_group_id %>
+
+          <%- group_id_list.each do |group| -%>
+          group from: :<%= group %>
+          <%- end -%>
+
+          run do
+            passing_profile_group = groups.find do |group|
+              next if group.id.include?('wait') || group.id.include?('auth')
+
+              results[group.id]&.result == 'pass'
+            end
+
+            assert passing_profile_group.present?, 'At least one profile group must pass.'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module USCoreTestKit
+  module Client
+    module <%= module_name %>
+      # READ tags
+
+      READ_REQUEST_TAG = 'us_core_read_request'
+
+      <%- resources.each do |resource| -%>
+      READ_<%= resource.underscore.upcase %>_TAG = 'us_core_<%= resource.underscore.downcase %>_read'
+      <%- end -%>
+
+      # SEARCH tags
+
+      SEARCH_REQUEST_TAG = 'us_core_search_request'
+
+      <%- resources.each do |resource| -%>
+      SEARCH_<%= resource.underscore.upcase %>_TAG = 'us_core_<%= resource.underscore.downcase %>_search'
+      <%- end -%>
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module USCoreTestKit
+  module Client
+    module <%= module_name %>
+      RESUME_PASS_ROUTE = '/resume_pass'
+      FHIR_ROUTE = '/fhir'
+      READ_ROUTE = "#{FHIR_ROUTE}/:resource_type/:resource_id"
+      SEARCH_ROUTE = "#{FHIR_ROUTE}/:resource_type"
+      SEARCH_POST_ROUTE = "#{FHIR_ROUTE}/:resource_type/_search"
+      METADATA_PATH = "#{FHIR_ROUTE}/metadata"
+      TOKEN_PATH = '/auth/token'.freeze
+      AUTHORIZATION_PATH = '/auth/authorization'.freeze
+
+      module URLs
+        def base_url
+          "#{Inferno::Application['base_url']}/custom/#{suite_id}"
+        end
+
+        def resume_pass_url
+          base_url + RESUME_PASS_ROUTE
+        end
+
+        def fhir_url
+          base_url + FHIR_ROUTE
+        end
+
+        def client_fhir_base_url # alias for OIDC from SMART client tests
+          fhir_url
+        end
+
+        def read_url
+          base_url + READ_ROUTE
+        end
+
+        def search_url
+          base_url + SEARCH_ROUTE
+        end
+
+        def token_url
+          @token_url ||= base_url + TOKEN_PATH
+        end
+
+        def authorization_url
+          @authorization_url ||= base_url + AUTHORIZATION_PATH
+        end
+
+        def suite_id
+          '<%= suite_id %>'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# 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
+    module USCoreClient<%= ig_metadata.reformatted_version.upcase %>
+      class <%= class_name %> < Inferno::TestGroup
+        include URLs
+
+        id :us_core_client_access_group_<%= ig_metadata.reformatted_version.downcase %>
+        title 'Client Access'
+        description %(
+          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_<%= ig_metadata.reformatted_version.downcase %>'
+        end
+
+        group do
+          id :us_core_client_wait_group_<%= ig_metadata.reformatted_version.downcase %>
+          title 'Perform Data Access'
+
+          test do
+            id :us_core_client_wait_test_<%= ig_metadata.reformatted_version.downcase %>
+            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.
+            )
+
+            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.
+                  )
+            
+            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}
+
+  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.
+
+  The following requirements will be checked:
+
+  <%= check_list %>
+
+  [Click here](#{resume_pass_url}?token=#{client_id}) when finished.
+                ),
+                timeout: 900
+              )
+            end
+          end
+        end
+
+        group from: :us_core_client_<%= ig_metadata.reformatted_version.downcase %>_auth_smart_alca,
+              required_suite_options: {
+                client_type: USCoreClientOptions::SMART_APP_LAUNCH_CONFIDENTIAL_ASYMMETRIC
+              }
+        group from: :us_core_client_<%= ig_metadata.reformatted_version.downcase %>_auth_smart_alcs,
+              required_suite_options: {
+                client_type: USCoreClientOptions::SMART_APP_LAUNCH_CONFIDENTIAL_SYMMETRIC
+              }
+        group from: :us_core_client_<%= ig_metadata.reformatted_version.downcase %>_auth_smart_alp,
+              required_suite_options: {
+                client_type: USCoreClientOptions::SMART_APP_LAUNCH_PUBLIC
+              }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module USCoreTestKit
+  module Client
+    class Generator
+      class UrlsGenerator
+        class << self
+          def generate(ig_metadata, base_output_dir)
+            new(ig_metadata, base_output_dir).generate
+          end
+        end
+
+        attr_accessor :ig_metadata, :base_output_dir
+
+        def initialize(ig_metadata, base_output_dir)
+          self.ig_metadata = ig_metadata
+          self.base_output_dir = base_output_dir
+        end
+
+        def template
+          @template ||= File.read(File.join(__dir__, 'templates', 'urls.rb.erb'))
+        end
+
+        def output
+          @output ||= ERB.new(template).result(binding)
+        end
+
+        def base_output_file_name
+          'urls.rb'
+        end
+
+        def module_name
+          "USCoreClient#{ig_metadata.reformatted_version.upcase}"
+        end
+
+        def output_file_name
+          File.join(base_output_dir, base_output_file_name)
+        end
+
+        def suite_id
+          "us_core_client_#{ig_metadata.reformatted_version}"
+        end
+
+        def generate
+          File.write(output_file_name, output)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module USCoreTestKit
+  module Client
+    class Generator
+      class WaitGroupGenerator
+        class << self
+          def generate(ig_metadata, base_output_dir)
+            new(ig_metadata, base_output_dir).generate
+          end
+        end
+
+        attr_accessor :ig_metadata, :base_output_dir
+
+        def initialize(ig_metadata, base_output_dir)
+          self.ig_metadata = ig_metadata
+          self.base_output_dir = base_output_dir
+        end
+
+        def template
+          @template ||= File.read(File.join(__dir__, 'templates', 'wait_group.rb.erb'))
+        end
+
+        def output
+          @output ||= ERB.new(template).result(binding)
+        end
+
+        def class_name
+          "WaitGroup"
+        end
+
+        def base_output_file_name
+          "#{class_name.underscore}.rb"
+        end
+
+        def output_file_name
+          File.join(base_output_dir, base_output_file_name)
+        end
+
+        def groups
+          ig_metadata.ordered_groups
+            .reject { |group| USCoreTestKit::Generator::SpecialCases.exclude_group? group }
+        end
+
+        def check_list
+          groups
+            .map do |group|
+              profile_name = USCoreTestKit::Generator::Naming.upper_camel_case_for_profile(group)
+              profile_header = "* **#{profile_name}**"
+              profile_id = "  * read id:\n    * us-core-client-tests-#{profile_name.underscore.dasherize}"
+              required_searches = group.searches.each do |search|
+                next unless search[:expectation] == 'SHALL'
+
+                search
+              end
+              searches = "  * searches:"
+              search_list = required_searches.map do |search|
+                "    * #{search[:names].join(' + ')}"
+              end
+              "#{profile_header}\n#{profile_id}\n#{searches}\n#{search_list.join("\n")}"
+            end
+            .join("\n")
+        end
+
+        def generate
+          File.write(output_file_name, output)
+        end
+      end
+    end
+  end
+end

data/lib/us_core_test_kit/client/generator.rb

@@ -0,0 +1,117 @@
+require 'fhir_models'
+require 'inferno/ext/fhir_models'
+
+require_relative 'generator/ig_loader'
+require_relative '../generator/ig_metadata_extractor'
+
+require_relative 'generator/group_generator'
+require_relative 'generator/tags_generator'
+require_relative 'generator/urls_generator'
+require_relative 'generator/suite_generator'
+require_relative 'generator/read_test_generator'
+require_relative 'generator/search_test_generator'
+require_relative 'generator/wait_group_generator'
+require_relative 'generator/read_endpoint_generator'
+require_relative 'generator/search_endpoint_generator'
+require_relative 'generator/auth_smart_group_generator'
+require_relative 'generator/registration_group_generator'
+require_relative 'generator/registration_configuration_display_test_generator'
+
+module USCoreTestKit
+  module Client
+    class Generator
+      def self.generate
+        ig_packages = Dir.glob(File.join(Dir.pwd, 'lib', 'us_core_test_kit', 'igs', '*.tgz'))
+
+        ig_packages.each do |ig_package|
+          new(ig_package).generate
+        end
+      end
+
+      attr_accessor :ig_resources, :ig_metadata, :ig_file_name
+
+      def initialize(ig_file_name)
+        self.ig_file_name = ig_file_name
+      end
+
+      def generate
+        puts "Generating client suites for IG #{File.basename(ig_file_name)}"
+
+        load_ig_package
+        extract_metadata
+
+        generate_tags
+        generate_urls
+        generate_read_tests
+        generate_search_tests
+        generate_wait_group
+        generate_endpoints
+        generate_registration_tests
+        generate_auth_tests
+
+        generate_groups
+        generate_suites
+      end
+
+      def extract_metadata
+        self.ig_metadata = USCoreTestKit::Generator::IGMetadataExtractor.new(ig_resources).extract
+
+        FileUtils.mkdir_p(base_output_dir)
+      end
+
+      def base_output_dir
+        File.join(__dir__, 'generated', ig_metadata.ig_version)
+      end
+
+      def load_ig_package
+        FHIR.logger = Logger.new('/dev/null')
+        self.ig_resources = IGLoader.new(ig_file_name).load
+      end
+
+      def generate_groups
+        GroupGenerator.generate(ig_metadata, base_output_dir)
+      end
+
+      def generate_tags
+        TagsGenerator.generate(ig_metadata, base_output_dir)
+      end
+
+      def generate_urls
+        UrlsGenerator.generate(ig_metadata, base_output_dir)
+      end
+
+      def generate_suites
+        SuiteGenerator.generate(ig_metadata, base_output_dir)
+      end
+
+      def generate_wait_group
+        WaitGroupGenerator.generate(ig_metadata, base_output_dir)
+      end
+      
+      def generate_read_tests
+        ReadTestGenerator.generate(ig_metadata, base_output_dir)
+      end
+
+      def generate_search_tests
+        SearchTestGenerator.generate(ig_metadata, base_output_dir)
+      end
+
+      def generate_endpoints
+        ReadEndpointGenerator.generate(ig_metadata, base_output_dir)
+        SearchEndpointGenerator.generate(ig_metadata, base_output_dir)
+      end
+
+      def generate_registration_tests
+        RegistrationGroupGenerator.generate(ig_metadata, base_output_dir)
+        FileUtils.mkdir_p(File.join(base_output_dir, 'registration'))
+        RegistrationConfigurationDisplayTestGenerator.generate(ig_metadata, base_output_dir, 'smart')
+      end
+
+      def generate_auth_tests
+        AuthSMARTGroupGenerator.generate(ig_metadata, base_output_dir, 'alca')
+        AuthSMARTGroupGenerator.generate(ig_metadata, base_output_dir, 'alcs')
+        AuthSMARTGroupGenerator.generate(ig_metadata, base_output_dir, 'alp')
+      end
+    end
+  end
+end

data/lib/us_core_test_kit/client/metadata/mock_capability_statement.json.erb

@@ -0,0 +1,84 @@
+{
+  "resourceType": "CapabilityStatement",
+  "status": "active",
+  "date": "2021-06-17T18:03:00+00:00",
+  "publisher": "MITRE",
+  "kind": "instance",
+  "instantiates": [
+    "http://hl7.org/fhir/us/core/CapabilityStatement/us-core-server"
+  ],
+  "implementation": {
+    "description": "Inferno US Core Testing Simulation Server",
+    "url": "<%= Inferno::Application['base_url'] %>/custom/us_core_client_<%= version %>/fhir"
+  },
+  "fhirVersion": "4.0.1",
+  "format": [
+    "application/fhir+json"
+  ],
+  "implementationGuide": [
+    "http://hl7.org/fhir/us/core/ImplementationGuide/hl7.fhir.us.core"
+  ],
+  "rest": [
+    {
+      "mode": "server",
+      "security": {
+        "extension": [
+          {
+            "url": "http://fhir-registry.smarthealthit.org/StructureDefinition/oauth-uris",
+            "extension": [
+              {
+                "url": "token",
+                "valueUri": "<%= Inferno::Application['base_url']  %>/custom/us_core_client_<%= version %>/auth/token"
+              },
+              {
+                "url": "authorize",
+                "valueUri": "<%= Inferno::Application['base_url']  %>/custom/us_core_client_<%= version %>/auth/authorization"
+              }
+            ]
+          }
+        ],
+        "service": [
+          {
+            "coding": [
+              {
+                "system": "http://hl7.org/fhir/restful-security-service",
+                "code": "SMART-on-FHIR"
+              }
+            ],
+            "text": "OAuth2 using SMART-on-FHIR profile (see http://docs.smarthealthit.org)"
+          }
+        ]
+      },
+      "resource": [
+        {
+          "type": "Patient",
+          "supportedProfile": [
+            "http://hl7.org/fhir/us/core/StructureDefinition/us-core-patient"
+          ],
+          "interaction": [
+            {
+              "code": "read"
+            },
+            {
+              "code": "search-type"
+            }
+          ]
+        },
+        {
+          "type": "AllergyIntolerance",
+          "supportedProfile": [
+            "http://hl7.org/fhir/us/core/StructureDefinition/us-core-allergyintolerance"
+          ],
+          "interaction": [
+            {
+              "code": "read"
+            },
+            {
+              "code": "search-type"
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

data/lib/us_core_test_kit/client/metadata_helper.rb

@@ -0,0 +1,21 @@
+module USCoreTestKit
+  module Client
+    module MetadataHelper
+      module_function
+
+      def get_metadata(version)
+        erb_template = ERB.new(
+          File.read(
+            File.join(__dir__, 'metadata/mock_capability_statement.json.erb')
+          )
+        )
+        capability_statement = JSON.parse(erb_template.result(binding)).to_json
+
+        proc {
+          [200, { 'Content-Type' => 'application/fhir+json;charset=utf-8', 'Access-Control-Allow-Origin' => '*' },
+          [capability_statement]]
+        }
+      end
+    end
+  end
+end