us_quality_core_test_kit 0.1.0

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module USQualityCoreTestKit
+  module Client
+    module USQualityCoreClient<%= ig_metadata.reformatted_version.upcase %>
+      class <%= class_name %> < Inferno::TestGroup
+        include URLs
+
+        id :us_quality_core_client_access_group_<%= ig_metadata.reformatted_version.downcase %>
+        title 'Client Access'
+        description %(
+          During these tests, Inferno will simulate a US Quality 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_quality_core_client_<%= ig_metadata.reformatted_version.downcase %>'
+        end
+
+        group do
+          id :us_quality_core_client_wait_group_<%= ig_metadata.reformatted_version.downcase %>
+          title 'Perform Data Access'
+
+          test do
+            id :us_quality_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 Quality Core profiles, and for requests including all of the required search
+              parameters for each resource type.
+            )
+
+            output :access_token
+
+            run do
+              token = SecureRandom.uuid
+              output access_token: token
+
+              wait(
+                identifier: token,
+                message: %(
+  Inferno will now wait for the client under test to make the required requests against the following base URL:
+
+  #{fhir_url}
+
+  Inferno generated this access token for the current run:
+
+  `#{token}`
+
+  Configure the client under test to send the following HTTP header with every request.
+  Clients must send this exact value as the bearer token for this run.
+  If the client system already adds the `Bearer` scheme, enter only the access
+  token value shown above in the client configuration.
+
+  `Authorization: Bearer #{token}`
+
+  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**: `usqualitycore-patient`
+
+  [Click here](#{resume_pass_url}?token=#{token}) when finished.
+
+  The following requirements will be checked:
+
+  <%= check_list %>
+                ),
+                timeout: 900
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module USQualityCoreTestKit
+  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
+          "USQualityCoreClient#{ig_metadata.reformatted_version.upcase}"
+        end
+
+        def output_file_name
+          File.join(base_output_dir, base_output_file_name)
+        end
+
+        def suite_id
+          "us_quality_core_client_#{ig_metadata.reformatted_version}"
+        end
+
+        def generate
+          File.write(output_file_name, output)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module USQualityCoreTestKit
+  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| USQualityCoreTestKit::Generator::SpecialCases.exclude_group? group }
+        end
+
+        def check_list
+          groups
+            .map do |group|
+              profile_name = USQualityCoreTestKit::Generator::Naming.upper_camel_case_for_profile(group)
+              profile_header = "* **#{profile_name}**"
+              read_id = "  * read id:\n#{read_ids_for(group).map { |id| "    * #{id}" }.join("\n")}"
+              required_searches = group.searches.each do |search|
+                next unless search[:expectation] == 'SHALL'
+              end
+              searches = '  * searches:'
+              search_list = required_searches.map do |search|
+                "    * #{search[:names].join(' + ')}"
+              end
+              "#{profile_header}\n#{read_id}\n#{searches}\n#{search_list.join("\n")}"
+            end
+            .join("\n")
+        end
+
+        def read_ids_for(group)
+          naming = USQualityCoreTestKit::Generator::Naming
+          profile_identifier = naming.snake_case_for_profile(group)
+          read_ids = [naming.instance_id_for_profile(profile_identifier)]
+
+          read_ids << naming.instance_id_for_profile('observation_lab') if profile_identifier == 'observation_clinical_result'
+
+          read_ids
+        end
+
+        def generate
+          File.write(output_file_name, output)
+        end
+      end
+    end
+  end
+end

data/lib/us_quality_core_test_kit/client/generator.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+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/capability_statement_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/example_client_generator'
+
+module USQualityCoreTestKit
+  module Client
+    class Generator
+      def self.generate
+        ig_packages = Dir.glob(File.join(Dir.pwd, 'lib', 'us_quality_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 suite for #{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_groups
+        generate_suites
+
+        generate_example_client
+        generate_capability_statement
+
+        puts 'done.'
+      end
+
+      def extract_metadata
+        self.ig_metadata = USQualityCoreTestKit::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(File::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_example_client
+        ExampleClientGenerator.generate(ig_metadata, base_output_dir)
+      end
+
+      def generate_capability_statement
+        CapabilityStatementGenerator.generate(ig_metadata, ig_resources, base_output_dir)
+      end
+    end
+  end
+end

data/lib/us_quality_core_test_kit/client/metadata_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module USQualityCoreTestKit
+  module Client
+    module MetadataHelper
+      module_function
+
+      def get_metadata(version, metadata_path)
+        rendered_capability_statement = nil
+
+        proc {
+          [200, { 'Content-Type' => 'application/fhir+json;charset=utf-8', 'Access-Control-Allow-Origin' => '*' },
+           [rendered_capability_statement ||= capability_statement(metadata_path, version)]]
+        }
+      end
+
+      def capability_statement(metadata_path, version)
+        ERB.new(File.read(metadata_path), trim_mode: '-').result_with_hash(
+          client_suite_base_url: client_suite_base_url(version)
+        )
+      end
+
+      def client_suite_base_url(version)
+        "#{Inferno::Application['base_url']}/custom/us_quality_core_client_#{version}"
+      end
+    end
+  end
+end

data/lib/us_quality_core_test_kit/client/server_proxy.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module USQualityCoreTestKit
+  module Client
+    module ServerProxy
+      def proxy_client
+        @proxy_client ||= Faraday.new(
+          url: ENV.fetch('FHIR_REFERENCE_SERVER'),
+          params: {},
+          headers: request_headers
+        ) do |proxy|
+          proxy.use FaradayMiddleware::Gzip
+          proxy.options.params_encoder = Faraday::FlatParamsEncoder
+        end
+      end
+
+      def request_headers
+        {
+          'Content-Type' => 'application/json',
+          'Authorization' => 'Bearer SAMPLE_TOKEN'
+        }
+      end
+
+      def build_proxied_read_response
+        resource_id = request.params[:resource_id]
+        resource_type = request.params[:resource_type]
+        request_params = request.params.to_h.except(:resource_id, :resource_type).stringify_keys
+
+        server_response = proxy_client.get("#{resource_type}/#{resource_id}", request_params)
+        response.status = server_response.status
+        response.body = server_response.body
+        response.headers.merge!(server_response.headers)
+        remove_transfer_encoding_and_content_length_header(response.headers)
+        response.headers.delete('content-location') if response.headers['content-location'].present?
+      end
+
+      def build_proxied_search_response
+        resource_type = request.params[:resource_type]
+        request_params = request.params.to_h.except(:resource_type).stringify_keys
+
+        server_response = proxy_client.get(resource_type, request_params)
+        response.status = server_response.status
+        response.body = if response.status == 200
+                          replace_bundle_urls(FHIR.from_contents(server_response.body)).to_json
+                        else
+                          server_response.body
+                        end
+        response.headers.merge!(server_response.headers)
+        remove_transfer_encoding_and_content_length_header(response.headers)
+      end
+
+      def remove_transfer_encoding_and_content_length_header(headers)
+        headers.delete('transfer-encoding') if headers['transfer-encoding'].present?
+        headers.delete('Content-Length') if headers['Content-Length'].present?
+
+        nil
+      end
+
+      def replace_bundle_urls(bundle)
+        reference_server_base = ENV.fetch('FHIR_REFERENCE_SERVER')
+        bundle&.link&.map! { |link| { relation: link.relation, url: link.url.gsub(reference_server_base, new_link) } }
+        bundle&.entry&.map! do |bundled_resource|
+          { fullUrl: bundled_resource.fullUrl.gsub(reference_server_base, new_link),
+            resource: bundled_resource.resource,
+            search: bundled_resource.search }
+        end
+        bundle
+      end
+
+      def new_link
+        "#{Inferno::Application['base_url']}/custom/#{suite_id}/fhir"
+      end
+    end
+  end
+end

data/lib/us_quality_core_test_kit/client/test_helper.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module USQualityCoreTestKit
+  module Client
+    module TestHelper
+      def filter_requests_by_resource_type(requests, resource_type)
+        requests.select do |request|
+          request.url.split('/').any? { |segment| segment.split('?').first&.casecmp?(resource_type) }
+        end
+      end
+
+      def filter_requests_by_resource_id(requests, resource_id)
+        Array(resource_id).flat_map do |id|
+          requests.select do |request|
+            request.url.split('/').last.split('?').first&.casecmp?(id)
+          end
+        end
+      end
+
+      def filter_requests_by_search_parameters(requests, search_parameters)
+        requests.select do |request|
+          included_params =
+            if request.verb.downcase == 'get'
+              url_params(request.url).keys
+            elsif request.verb.downcase == 'post'
+              CGI.parse(request.request_body).keys
+            end
+          next unless included_params.present?
+
+          search_parameters.all? { |param| included_params.include? param }
+        end
+      end
+
+      def url_params(url)
+        CGI.parse(URI.parse(url).query)
+      end
+    end
+  end
+end

data/lib/us_quality_core_test_kit/generated/v0.5.0/adverse_event/adverse_event_must_support_test.rb

@@ -0,0 +1,45 @@
+require_relative '../../../must_support_test'
+
+module USQualityCoreTestKit
+  module USQualityCoreV050
+    class AdverseEventMustSupportTest < Inferno::Test
+      include USQualityCoreTestKit::MustSupportTest
+
+      title 'All must support elements are provided in the AdverseEvent resources returned'
+
+      description %(
+        This test will look through the AdverseEvent resources
+        found previously for the following Must Support and USCDI-flagged elements:
+
+
+
+        For ONC USCDI+ Quality requirements, each AdverseEvent must support the following additional elements:
+
+        * AdverseEvent.category
+        * AdverseEvent.date
+        * AdverseEvent.detected
+        * AdverseEvent.event
+        * AdverseEvent.recordedDate
+        * AdverseEvent.suspectEntity.instance
+      )
+
+      id :us_quality_core_v050_adverse_event_must_support_test
+
+      def resource_type
+        'AdverseEvent'
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:adverse_event_resources] ||= {}
+      end
+
+      run do
+        perform_must_support_test(all_scratch_resources)
+      end
+    end
+  end
+end

data/lib/us_quality_core_test_kit/generated/v0.5.0/adverse_event/adverse_event_provenance_revinclude_search_test.rb

@@ -0,0 +1,51 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module USQualityCoreTestKit
+  module USQualityCoreV050
+    class AdverseEventProvenanceRevincludeSearchTest < Inferno::Test
+      include USQualityCoreTestKit::SearchTest
+
+      title 'Server returns Provenance resources from AdverseEvent search by subject + revInclude:Provenance:target'
+      description %(
+        A server SHALL be capable of supporting _revIncludes:Provenance:target.
+
+        This test will perform a search by subject + revInclude:Provenance:target and
+        will pass if a Provenance resource is found in the response.
+      %)
+
+      id :us_quality_core_v050_adverse_event_provenance_revinclude_search_test
+  
+      input :patient_ids,
+        title: 'Patient IDs',
+        description: 'Comma separated list of patient IDs that in sum contain all MUST SUPPORT elements'
+  
+      def properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'AdverseEvent',
+        search_param_names: ['subject']
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml')))
+      end
+
+      def self.provenance_metadata
+        @provenance_metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, '..', 'provenance', 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:adverse_event_resources] ||= {}
+      end
+
+      def scratch_provenance_resources
+        scratch[:provenance_resources] ||= {}
+      end
+
+      run do
+        run_provenance_revinclude_search_test
+      end
+    end
+  end
+end

data/lib/us_quality_core_test_kit/generated/v0.5.0/adverse_event/adverse_event_read_test.rb

@@ -0,0 +1,27 @@
+require_relative '../../../read_test'
+
+module USQualityCoreTestKit
+  module USQualityCoreV050
+    class AdverseEventReadTest < Inferno::Test
+      include USQualityCoreTestKit::ReadTest
+
+      title 'Server returns correct AdverseEvent resource from AdverseEvent read interaction'
+
+      description 'A server SHALL support the AdverseEvent read interaction.'
+
+      id :us_quality_core_v050_adverse_event_read_test
+
+      def resource_type
+        'AdverseEvent'
+      end
+
+      def scratch_resources
+        scratch[:adverse_event_resources] ||= {}
+      end
+
+      run do
+        perform_read_test(all_scratch_resources)
+      end
+    end
+  end
+end

data/lib/us_quality_core_test_kit/generated/v0.5.0/adverse_event/adverse_event_reference_resolution_test.rb

@@ -0,0 +1,41 @@
+require_relative '../../../reference_resolution_test'
+
+module USQualityCoreTestKit
+  module USQualityCoreV050
+    class AdverseEventReferenceResolutionTest < Inferno::Test
+      include USQualityCoreTestKit::ReferenceResolutionTest
+
+      title 'MustSupport references within AdverseEvent resources are valid'
+
+      description %(
+        This test will attempt to read external references provided within elements
+        marked as 'MustSupport', if any are available.
+
+        It verifies that at least one external reference for each MustSupport Reference element
+        can be accessed by the test client.
+
+        Elements which may provide external references include:
+
+        * AdverseEvent.suspectEntity.instance
+      )
+
+      id :us_quality_core_v050_adverse_event_reference_resolution_test
+
+      def resource_type
+        'AdverseEvent'
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:adverse_event_resources] ||= {}
+      end
+
+      run do
+        perform_reference_resolution_test(scratch_resources[:all])
+      end
+    end
+  end
+end

data/lib/us_quality_core_test_kit/generated/v0.5.0/adverse_event/adverse_event_subject_event_search_test.rb

@@ -0,0 +1,52 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+require_relative '../../../search_test_properties'
+
+module USQualityCoreTestKit
+  module USQualityCoreV050
+    class AdverseEventSubjectEventSearchTest < Inferno::Test
+      include USQualityCoreTestKit::SearchTest
+
+      title 'Server returns valid results for AdverseEvent search by subject + event'
+
+      description %(
+A server SHALL support searching by
+subject + event on the AdverseEvent resource. This test
+will pass if resources are returned and match the search criteria. If
+none are returned, the test is skipped.
+
+
+      )
+
+      id :us_quality_core_v050_adverse_event_subject_event_search_test
+
+  
+
+  
+      input :patient_ids,
+        title: 'Patient IDs',
+        description: 'Comma separated list of patient IDs that in sum contain all MUST SUPPORT elements'
+  
+
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+          resource_type: 'AdverseEvent',
+        search_param_names: ['subject', 'event'],
+        token_search_params: ['event']
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:adverse_event_resources] ||= {}
+      end
+
+      run do
+        run_search_test
+      end
+    end
+  end
+end