davinci_plan_net_test_kit 0.10.0 → 0.11.0

data/lib/davinci_plan_net_test_kit/generator/templates/search.rb.erb

@@ -0,0 +1,40 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciPlanNetTestKit
+  module <%= module_name %>
+    class <%= class_name %> < Inferno::Test
+      include DaVinciPlanNetTestKit::SearchTest
+
+      title 'Server returns valid results for <%= resource_type %> search by <%= search_param_name_string %>'
+      description %(
+<%= description %>
+      )
+
+      id :<%= test_id %><% if optional? %>
+      optional
+  <% end %><% if needs_resource_id? %>
+      input :<%= resource_type %>_ids,
+        title: '<%= resource_type %> IDs',
+        description: 'Comma separated list of <%= resource_type %> IDs that in sum contain all MUST SUPPORT elements'
+  <% end %>
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+  <%= search_test_properties_string %>
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:<%= profile_identifier %>_resources] ||= {}
+      end
+
+      run do
+        run_search_test
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generator/templates/search_no_params.rb.erb

@@ -0,0 +1,45 @@
+require_relative '../../../search_test'
+require_relative '../../../generator/group_metadata'
+
+module DaVinciPlanNetTestKit
+  module <%= module_name %>
+    class <%= class_name %> < Inferno::Test
+      include DaVinciPlanNetTestKit::SearchTest
+
+      title 'Client can identify instances of <%= profile_name %> on the server'
+      description %(
+<%= description %>
+      )
+
+      id :<%= test_id %><% if optional? %>
+      optional
+  <% end %>
+
+      input :<%= test_id %>_ids,
+        title: 'ids of <%= profile_name %> instances',
+        optional: true,
+        description: 'Required if parameterless searches are not being used for instance gathering.'
+      input :no_param_search
+      input :max_instances
+      input :max_pages
+
+      def self.properties
+        @properties ||= SearchTestProperties.new(
+  <%= search_test_properties_string %>
+        )
+      end
+
+      def self.metadata
+        @metadata ||= Generator::GroupMetadata.new(YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true))
+      end
+
+      def scratch_resources
+        scratch[:<%= profile_identifier %>_resources] ||= {}
+      end
+
+      run do
+        run_search_no_params_test(<%= test_id %>_ids)
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generator/templates/suite.rb.erb

@@ -0,0 +1,222 @@
+require 'inferno/dsl/oauth_credentials'
+require_relative '../../version'
+require_relative '<%= capability_statement_file_name %>'
+<% group_file_list.each do |file_name| %>require_relative '<%= file_name %>'
+<% end %>
+module DaVinciPlanNetTestKit
+  module <%= module_name %>
+    class <%= class_name %> < Inferno::TestSuite
+      title '<%= title %>'
+      description %(
+        The Plan Net Test Kit tests servers for their conformance to the [Plan Net
+        Implementation Guide](<%=ig_link %>).
+
+        ## Scope
+
+        These tests are a **DRAFT** intended to allow Plan Net server implementers to perform 
+        preliminary checks of their servers against Plan Net IG requirements and [provide 
+        feedback](https://github.com/inferno-framework/davinci-plan-net-test-kit/issues) 
+        to ONC on the tests. Future versions of these tests may validate other 
+        requirements and may change the test validation logic.
+
+        ## Test Methodology
+
+        Inferno will act as a client and make a series of requests to the 
+        server under test. The responses will be checked for conformance to the Plan
+        Net IG requirements individually and used in aggregate to determine whether
+        required features and functionality are present.
+
+        HL7® FHIR® resources are validated with the Java validator using
+        `tx.fhir.org` as the terminology server.
+
+        ## Running the Tests
+        
+        ### Quick Start
+
+        The tests are designed to be runnable with a single input from the user: 
+        the base FHIR URL of the server under test. To run in this mode:
+        1. Click the `RUN ALL TESTS` button in the upper right
+        2. Provide the URL for the server in the first "FHIR Endpoint (required)" input
+        3. Click the `Submit` button in the lower right of the input display
+        4. Wait for Inferno to run the tests (will take several minutes)
+        5. Expand tests with failures to determine the reason
+
+        If you would like to try out the tests but don't have a Plan Net server implementation, 
+        you can use the publicly available reference implementation available at URL 
+        https://plan-net-ri.davinci.hl7.org/fhir. Select this endpoint by using that URL as the
+        "FHIR Endpoint (required)" input or prepopulating it by selecting the 
+        `Da Vinci Plan Net Reference Server` preset in the upper left. Note that this
+        system is not currently expected to pass all of the tests.
+
+        The feedback provided may require
+        - Configuration updates (see *Test Configuration Details* below) to better guide Inferno's test execution.
+        - Additional data within the system under test, e.g., to demonstrate all Must Support elements.
+        - Fixes to the system under test.
+
+        Note that this mode requires that the server support parameterless searches against 
+        Plan Net resource types (e.g., `GET [FHIR Endpoint]/InsurancePlan`), which are not required 
+        by the Plan Net IG. If your server does not support these searches, or some returned instances
+        will not conform to Plan Net profiles, see the *Instance Gathering* section under
+        *Test Configuration Details* below for how to disable these searches and direct the tests
+        toward specific instances of each profile instead.
+
+        ### Running Groups Individually
+
+        Each test group listed on the left can be run individually using the `RUN TESTS` 
+        button in the upper right of the group page. However, note that running 
+        them individually requires additional inputs so that Inferno can find appropriate values for searches
+        (see *Determination of Search Values When Running Single Groups* below for details).
+
+        ## Test Configuration Details
+
+        The details provided here supplement the documentation of individual inputs in the input dialog
+        that appears when initiating a test run.
+
+        ### Authentication
+
+        The Plan Net IG requires that "A conformant Plan-Net service SHALL NOT 
+        require a directory mobile application to send consumer identifying information 
+        in order to query content." A simple way to ensure this is to not require authentication,
+        which is safe because the information in scope does not include PHI. Thus, the
+        tests do not send authentication details by default.
+
+        If a server under test requires authentication information to be sent, an access token 
+        may be provided using the "OAuth Credentials - Access Token" input. When populated, 
+        requests to the server will include an HTTP header of the form `Authorization: Bearer [access token]`.
+
+        ### Instance Gathering
+
+        Inferno needs to identify instances of each profile to use to validate conformance to
+        structural and search API requirements. Inferno will use one or a combination of the 
+        following two approaches as directed by the inputs.
+
+        #### Parameterless searches (default)
+        
+        Inferno will use a search against the base resource type without any search 
+        parameters (`GET [FHIR Endpoint]/[Resource Type]`) to identify instances of each profile. 
+        This behavior can be controlled using the following inputs:
+        - "Use parameterless searches to identify instances?": if the server under test does not support
+          parameterless searches, this can be set to `No` to disable parameterless searches.
+        - "Maximum number of instances to gather using parameterless searches (required)" and 
+          "Maximum pages of results to consider when using parameterless searches (required)": if fewer 
+          instances (e.g., to improve performance) or more instances (e.g., to improve Must Support 
+          element coverage) should be gathered, these inputs can be adjusted to tune the number
+          of instances that Inferno will gather using parameterless searches.
+        
+        #### Specific instance ids
+        
+        Inputs of the form "ids of [profile] instances" can be used by the user to specify particular 
+        instances for Inferno to gather for use in testing. Inferno will perform a read on each provided id
+        to gather the instances. When parameterless searches are not used, all inputs of this form must be populated. 
+        When instance ids are provided in addition to parameterless searches, instances provided by the user
+        are prioritized for use in determining search values for search tests.
+        
+        ### Determination of Search Values When Running Single Groups
+
+        Validation of search parameters requires Inferno to identify values that are expected 
+        to return instances. By default, Inferno does this by examining gathered instances of each profile 
+        to identify search values that should return results when performed against the server under
+        test. For `_revinclude` and reverse chaining tests, Inferno needs access to instances of other profiles
+        in order to determine appropriate search values. When test groups are run individually, Inferno will not 
+        have access to instances identified while running other groups. Thus, when running at the group level, 
+        two additional inputs are required to allow the tests to identify appropriate search values:
+        - "[target profile] instance ids referenced in [referencing profile].[reference element]": 
+          used by `_revinclude` tests on [target profile] when run as a group to identify 
+          instances of the [target profile] that have instances of [referencing profile] that reference it.
+        - "'[constraining element]' value from a [referencing profile] instance with '[reference element]' populated": used by reverse chaining tests 
+          on the [target profile] referenced in the [reference element] element when run as a single group 
+          to identify the value to use when performing the reverse chain search.
+      )
+      version VERSION
+
+      VALIDATION_MESSAGE_FILTERS = [
+        %r{Sub-extension url 'introspect' is not defined by the Extension http://fhir-registry\.smarthealthit\.org/StructureDefinition/oauth-uris},
+        %r{Sub-extension url 'revoke' is not defined by the Extension http://fhir-registry\.smarthealthit\.org/StructureDefinition/oauth-uris},
+        /Observation\.effective\.ofType\(Period\): .*us-core-1:/, # Invalid invariant in US Core v3.1.1
+        /\A\S+: \S+: URL value '.*' does not resolve/,
+      ].freeze
+
+      VERSION_SPECIFIC_MESSAGE_FILTERS = <%=version_specific_message_filters%>.freeze
+
+      def self.metadata
+        @metadata ||= YAML.load_file(File.join(__dir__, 'metadata.yml'), aliases: true)[:groups].map do |raw_metadata|
+            Generator::GroupMetadata.new(raw_metadata)
+          end
+      end
+
+      id :<%= suite_id %>
+
+      fhir_resource_validator do
+        igs '<%= ig_identifier %>'
+
+        message_filters = VALIDATION_MESSAGE_FILTERS + VERSION_SPECIFIC_MESSAGE_FILTERS
+
+        exclude_message do |message|
+
+          message_filters.any? { |filter| filter.match? message.message }
+        end
+
+        perform_additional_validation do |resource, profile_url|
+          ProvenanceValidator.validate(resource) if resource.instance_of?(FHIR::Provenance)
+        end
+      end
+
+      links [
+        {
+          label: 'Report Issue',
+          url: 'https://github.com/inferno-framework/davinci-plan-net-test-kit/issues'
+        },
+        {
+          label: 'Source Code',
+          url: 'https://github.com/inferno-framework/davinci-plan-net-test-kit'
+        },
+        {
+          label: 'Implementation Guide',
+          url: '<%=ig_link %>'
+        }
+      ]
+
+      input :url,
+        title: 'FHIR Endpoint',
+        description: 'URL of the FHIR endpoint'
+      input :smart_credentials,
+        title: 'OAuth Credentials',
+        type: :oauth_credentials,
+        optional: true
+      input :no_param_search,
+        title: 'Use parameterless searches to identify instances?',
+        type: 'radio',
+        options: {
+            list_options: [
+              {
+                label: 'Yes',
+                value: 'true'
+              },
+              {
+                label: 'No',
+                value: 'false'
+              }
+            ]
+          },
+        default: 'true',
+        description: 'If `Yes`, Inferno will gather instances of each profile using searches of the form `GET [FHIR Endpoint]/[resource type]`. If searches of this form are not supported or some instances on the server will not be expected to conform to Plan Net profiles, select `No` and enter instance ids of each profile in the "ids of [profile] instances" inputs.'
+      input :max_instances,
+        title: 'Maximum number of instances to gather using parameterless searches',
+        default: '200',
+        description: 'Only used with parameterless searches. A higher number will gather more instances for the tests, if they are available. The test will stop looking when the page limit has been reached.'
+      input :max_pages,
+        title: 'Maximum pages of results to consider when using parameterless searches',
+        default: '20',
+        description: 'Only used with parameterless searches. A higher number will gather more instances for the tests, if they are available. The test will not consider further pages once the maximum number of instances has been reached.'
+      
+      fhir_client do
+        url :url
+        oauth_credentials :smart_credentials
+      end
+
+      group from: :<%= capability_statement_group_id %>
+  <% group_id_list.each do |id| %>
+      group from: :<%= id %><% end %>
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/generator/templates/validation.rb.erb

@@ -0,0 +1,31 @@
+require_relative '../../../validation_test'
+
+module DaVinciPlanNetTestKit
+  module <%= module_name %>
+    class <%= class_name %> < Inferno::Test
+      include DaVinciPlanNetTestKit::ValidationTest
+
+      id :<%= test_id %>
+      title '<%= resource_type %> resources returned during previous tests conform to the <%= profile_name %>'
+      description %(
+<%= description %>
+      )
+      output :dar_code_found, :dar_extension_found
+
+      def resource_type
+        '<%= resource_type %>'
+      end
+
+      def scratch_resources
+        scratch[:<%= profile_identifier %>_resources] ||= {}
+      end
+
+      run do
+        perform_validation_test(scratch_resources[:all] || [],
+                                '<%= profile_url %>',
+                                '<%= profile_version %>',
+                                skip_if_empty: <%= skip_if_empty %>)
+      end
+    end
+  end
+end

data/lib/davinci_plan_net_test_kit/igs/README.md

@@ -0,0 +1,21 @@
+# Note on this IGs folder
+
+There are three reasons why it would be necessary to put an IG package.tgz in this folder. If none of these apply, you do not need to put any files here, or can consider removing any existing files to make it clear they are unused.
+
+## 1. Generated Test Suites
+Some test kits use a "generator" to automatically generate the contents of a test suite for an IG. The IG files are required every time the test suites need to be regenerated. Examples of test kits that use this approach are the US Core Test Kit and CARIN IG for Blue Button® Test Kit.
+
+
+## 2. Non-published IG
+If your IG, or the specific version of the IG you want to test against, is not published, then the validator service needs to load the IG from file in order to be able to validate resources with it. The IG must be referenced in the `fhir_resource_validator` block in the test suite definition by filename, ie:
+
+```ruby
+      fhir_resource_validator do
+        igs 'igs/filename.tgz'
+
+        ...
+      end
+```
+
+## 3. Inferno Validator UI
+The Inferno Validator UI is configured to auto-load any IGs present in the igs folder and include them in all validations. The Inferno Validator UI is currently disabled by default, so this is only relevant if you choose to re-enable it. In general, the Inferno team is currently leaving IGs in this folder even if not otherwise necessary to make it easy to re-enable the validator UI.

data/lib/davinci_plan_net_test_kit/metadata.rb

@@ -0,0 +1,64 @@
+module DaVinciPlanNetTestKit
+  class Metadata < Inferno::TestKit
+    id :davinci_plan_net_test_kit
+    title 'Da Vinci Plan Net Test Kit'
+    suite_ids [ 'davinci_plan_net_server_v110' ]
+    tags ['Da Vinci']
+    last_updated ::DaVinciPlanNetTestKit::LAST_UPDATED
+    version ::DaVinciPlanNetTestKit::VERSION
+    maturity 'Low'
+    authors ['Karl Naden']
+    repo 'https://github.com/inferno-framework/davinci-plan-net-test-kit'
+    description <<~DESCRIPTION
+        The DaVinci Plan Net Test Kit validates the conformance of a server
+        implementation to version 1.1.0 of the
+        [DaVinci PDEX Plan Net Implementation Guide](http://hl7.org/fhir/us/davinci-pdex-plan-net/STU1.1).
+
+        <!-- break -->
+
+        Inferno will act as a client and make a series of requests to the
+        server under test. The responses will be checked for conformance
+        to the Plan Net IG requirements individually and used in aggregate
+        to determine whether required features and functionality are present.
+
+        The test kit currently tests the following requirements:
+
+         - Support for Must Support Elements
+         - JSON Support
+         - Support for all Plan Net Profiles
+         - Read Interaction
+         - Individual Search Parameters
+         - _include Searches
+         - _revinclude Searches
+         - Forward Chain Searches
+         - Reverse Chain Searches
+         - Search Parameters in Combination
+
+        The DaVinci Plan Net Test Kit is built using the
+        [Inferno Framework](https://inferno-framework.github.io/).
+        The Inferno Framework is designed for reuse and aims to make it easier
+        to build test kits for any FHIR-based data exchange.
+
+        ### Known Limitations
+
+        The following areas of the IG are not fully tested in this draft version
+        of the test kit:
+
+         - All search parameter combinations: the tests check for support of only
+           specific combinations of search parameters driven by
+           [anticipated searches listed in the IG](http://hl7.org/fhir/us/davinci-pdex-plan-net/implementation.html#Representing).
+         - Response classes: the Plan Net IG lists HTTP response codes that the
+           server needs to be able to return, but does not indicate specific
+           criteria for requests that elicit these status codes.
+
+        Additional details on these and other areas where the tests may not align
+        with the IGs requirements, see this requirements analysis spreadsheet.
+
+        ## Reporting Issues
+
+        Please report any issues with this set of tests in the
+        [GitHub Issues](https://github.com/inferno-framework/davinci-plan-net-test-kit/issues)
+        section of this repository.
+    DESCRIPTION
+  end
+end

data/lib/davinci_plan_net_test_kit/search_test.rb

@@ -203,7 +203,7 @@ module DaVinciPlanNetTestKit
         
             check_search_response
 
-            returned_resources = fetch_all_bundled_resources(additional_resource_types: [additional_resource_type])
+            returned_resources = fetch_all_bundled_resources(resource_type: self.resource_type, additional_resource_types: [additional_resource_type])
             
             base_resources = returned_resources
               .select { |res| res.resourceType == resource_type }
@@ -238,7 +238,7 @@ module DaVinciPlanNetTestKit
 
             check_search_response
             
-            matching_resources = fetch_all_bundled_resources(additional_resource_types: [additional_resource_type])
+            matching_resources = fetch_all_bundled_resources(resource_type: self.resource_type, additional_resource_types: [additional_resource_type])
               .select { |res| res.resourceType == additional_resource_type }
               .reject { |res| res.id == params[:_id] }
             
@@ -306,7 +306,7 @@ module DaVinciPlanNetTestKit
       fhir_search additional_resource_type, params: additional_resource_params
 
       check_search_response
-      additional_resources = fetch_all_bundled_resources(additional_resource_types: [additional_resource_type])
+      additional_resources = fetch_all_bundled_resources(resource_type: self.resource_type, additional_resource_types: [additional_resource_type])
         .select { |res| res.resourceType == additional_resource_type }
 
       additional_resources.each { |res| check_resource_against_params(res, additional_resource_params) }
@@ -328,7 +328,7 @@ module DaVinciPlanNetTestKit
 
             check_search_response
 
-            returned_resources = fetch_all_bundled_resources(additional_resource_types: [additional_resource_type])
+            returned_resources = fetch_all_bundled_resources(resource_type: self.resource_type, additional_resource_types: [additional_resource_type])
             assert !returned_resources.empty?, "No #{resource_type} resources returned"
             base_resources = returned_resources
               .select { |res| res.resourceType == resource_type }
@@ -356,7 +356,7 @@ module DaVinciPlanNetTestKit
 
             check_search_response
 
-            returned_resources = fetch_all_bundled_resources(additional_resource_types: [additional_resource_type])
+            returned_resources = fetch_all_bundled_resources(resource_type: self.resource_type, additional_resource_types: [additional_resource_type])
             input_based_skip_assert(returned_resources, "No resources found.")
             base_resources = returned_resources
               .select { |res| res.resourceType == resource_type }
@@ -380,7 +380,7 @@ module DaVinciPlanNetTestKit
 
       check_search_response
 
-      returned_resources = fetch_all_bundled_resources(additional_resource_types: [additional_resource_type])
+      returned_resources = fetch_all_bundled_resources(resource_type: self.resource_type, additional_resource_types: [additional_resource_type])
       assert !returned_resources.empty?, "No #{resource_type} resources found"
 
       base_resources = returned_resources
@@ -424,7 +424,7 @@ module DaVinciPlanNetTestKit
       check_search_response
 
       resources_returned =
-        fetch_all_bundled_resources.select { |resource| resource.resourceType == resource_type }
+        fetch_all_bundled_resources(resource_type: self.resource_type).select { |resource| resource.resourceType == resource_type }
 
       return [] if resources_returned.blank?
 
@@ -456,7 +456,7 @@ module DaVinciPlanNetTestKit
 
       check_search_response
 
-      post_search_resources = fetch_all_bundled_resources.select { |resource| resource.resourceType == resource_type }
+      post_search_resources = fetch_all_bundled_resources(resource_type: self.resource_type).select { |resource| resource.resourceType == resource_type }
 
       filter_conditions(post_search_resources) if resource_type == 'Condition' && metadata.version == 'v5.0.1'
       filter_devices(post_search_resources) if resource_type == 'Device'
@@ -562,7 +562,7 @@ module DaVinciPlanNetTestKit
 
           search_and_check_response(params_with_comparator)
 
-          fetch_all_bundled_resources.each do |resource|
+          fetch_all_bundled_resources(resource_type: self.resource_type).each do |resource|
             check_resource_against_params(resource, params_with_comparator) if resource.resourceType == resource_type
           end
         end
@@ -578,7 +578,7 @@ module DaVinciPlanNetTestKit
       new_search_params = params.merge(resource_type.underscore => "#{resource_type}/#{params['resource']}")
       search_and_check_response(new_search_params)
 
-      reference_with_type_resources = fetch_all_bundled_resources.select { |resource| resource.resourceType == resource_type }
+      reference_with_type_resources = fetch_all_bundled_resources(resource_type: self.resource_type).select { |resource| resource.resourceType == resource_type }
 
 
       new_resource_count = reference_with_type_resources.count
@@ -601,7 +601,7 @@ module DaVinciPlanNetTestKit
       search_and_check_response(search_params)
 
       resources_returned =
-        fetch_all_bundled_resources
+        fetch_all_bundled_resources(resource_type: self.resource_type)
           .select { |resource| resource.resourceType == resource_type }
 
       assert resources_returned.present?, "No resources were returned when searching by `system|code`"
@@ -672,7 +672,7 @@ module DaVinciPlanNetTestKit
         search_and_check_response(search_params)
 
         resources_returned =
-          fetch_all_bundled_resources
+          fetch_all_bundled_resources(resource_type: self.resource_type)
             .select { |resource| resource.resourceType == resource_type }
 
         multiple_or_search_params.each do |param_name|
@@ -855,54 +855,6 @@ module DaVinciPlanNetTestKit
       "#{msg}."
     end
 
-    def fetch_all_bundled_resources(
-          reply_handler: nil,
-          max_pages: 0,
-          additional_resource_types: [],
-          resource_type: self.resource_type
-        )
-      page_count = 1
-      resources = []
-      bundle = resource
-      resources += bundle&.entry&.map { |entry| entry&.resource }
-
-      until bundle.nil? || (page_count == max_pages && max_pages != 0)
-        
-        next_bundle_link = bundle&.link&.find { |link| link.relation == 'next' }&.url
-        reply_handler&.call(response)
-
-        break if next_bundle_link.blank?
-
-        reply = fhir_client.raw_read_url(next_bundle_link)
-
-        store_request('outgoing') { reply }
-        error_message = cant_resolve_next_bundle_message(next_bundle_link)
-
-        assert_response_status(200)
-        assert_valid_json(reply.body, error_message)
-
-        bundle = fhir_client.parse_reply(FHIR::Bundle, fhir_client.default_format, reply)
-        resources += bundle&.entry&.map { |entry| entry&.resource }
-
-        page_count += 1
-      end
-
-      valid_resource_types = [resource_type, 'OperationOutcome'].concat(additional_resource_types)
-
-      invalid_resource_types =
-        resources.reject { |entry| valid_resource_types.include? entry.resourceType }
-                 .map(&:resourceType)
-                 .uniq
-
-      if invalid_resource_types.any?
-        info "Received resource type(s) #{invalid_resource_types.join(', ')} in search bundle, " \
-             "but only expected resource types #{valid_resource_types.join(', ')}. " + \
-             "This is unusual but allowed if the server believes additional resource types are relevant."
-      end
-
-      resources
-    end
-
     def fetch_matching_bundled_resources(
           max_pages: 20,
           max_instances: 200,

data/lib/davinci_plan_net_test_kit/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module DaVinciPlanNetTestKit
-  VERSION = '0.10.0'
+  VERSION = '0.11.0'
+  LAST_UPDATED = '2025-02-25'
 end

data/lib/davinci_plan_net_test_kit.rb

@@ -1 +1,2 @@
+require_relative 'davinci_plan_net_test_kit/metadata.rb'
 require_relative 'davinci_plan_net_test_kit/generated/v1.1.0/davinci_plan_net_test_suite'