Testing the Tests with RSpec

module ExampleTestKit
  class ExampleServerSuite < Inferno::TestSuite
    id 'example_server_suite'

    input :url
    input :bearer_token
    input :encounter_id

    fhir_client do
      url :url
      bearer_token :bearer_token
    end

    fhir_resource_validator do
    end

    group do
      id :encounter_group

      test do
        id :read
        title 'Read Encounter'

        makes_request :encounter_read

        run do
          fhir_read(:encounter, encounter_id, name: :encounter_read)

          assert_response_status(200)
          assert_resource_type(FHIR::Encounter)
        end
      end

      test do
        id :validate
        title 'Validate Encounter Resource'

        uses_request :encounter_read

        run do
          assert_valid_resource
        end
      end
    end
  end
end

require 'example_test_kit/example_server_suite'

RSpec.describe ExampleTestKit::ExampleServerSuite do
  let(:suite_id) { 'example_server_suite' } # This is always required by Inferno Core's shared context
  let(:url) { 'https://fhir.example.com' }
  let(:bearer_token) { 'dummy_token' }
  let(:encounter_id) { '123' }

  let(:encounter_fixture_json) do
    File.read('spec/fixtures/encounter.json')
  end

  describe 'encounter group' do
    describe 'read test' do
      let(:test) { find_test(suite, 'read') } # `find_test` and `suite` are from Inferno Core
      # `find_test` will load the test its parents inputs
      # `described_class` will load the test with only its own inputs

      it 'passes if an Encounter was received' do
        stub_request(:get, "#{url}/Encounter/#{encounter_id}") # Stub FHIR server endpoint
          .to_return(status: 200, body: encounter_fixture_json)

        result = run(test, { url:, bearer_token:, encounter_id: }, {}) # `run(runnable, inputs, scratch)` is from Inferno Core

        expect(result.result).to eq('pass'), result.result_message
      end

      it 'fails if a Patient was recieved' do
        stub_request(:get, "#{url}/Encounter/#{encounter_id}")
          .to_return(status: 200, body: FHIR::Patient.new.to_json)

        result = run(test, { url:, bearer_token:, encounter_id: })
        expect(result.result).to eq('fail'), result.result_message
      end
    end

    describe 'validate test' do
      let(:test) { find_test(suite, 'validate') }
      let(:validation_success) do # stubbed response from Inferno Validator
        {
          outcomes: [{
                       issues: []
                     }],
          sessionId: test_session.id # `test_session` is from Inferno Core
        }.to_json
      end

      it 'passes if the resource is valid' do
        stub_request(:post, validation_url) # `validation_url` is from Inferno Core
          .to_return(status: 200, body: validation_success)

        repo_create(                            # `repo_create` is from Inferno Core
          :request,
          name: :encounter_read,                # stub for `uses_request`
          test_session_id: test_session.id,
          response_body: encounter_fixture_json
        )

        result = run(test, { url:, bearer_token:, encounter_id: })
        expect(result.result).to eq('pass'), result.result_message
      end
    end
  end
end

class MyTest < Inferno::Test
  include MyModule
  # ... Inferno test code ...
end

RSpec.describe MyModule, :runnable do
  # ... RSpec test code ...
end

module ExampleTestKit
  class EncounterEndpoint < Inferno::DSL::SuiteEndpoint
    def test_run_identifier
      request.headers['authorization']&.delete_prefix('Bearer ')
    end

    def make_response
      response.status = 200
      response.body = FHIR::Encounter.new(id: request.params[:id]).to_json
      response.format = :json
    end

    def update_result
      results_repo.update(result.id, result: 'pass')
    end

    def tags
      ['encounter_request']
    end
  end

  class ExampleClientSuite < Inferno::TestSuite
    id :example_client_suite
    input :bearer_token

    suite_endpoint :get, '/Encounter/:id', EncounterEndpoint

    group do
      id :client_group

      test do
        id :retrieve
        title 'Retrieve Encounter Resource'

        run do
          assert load_tagged_requests('encounter_request').any?
        end
      end
    end
  end
end

require 'example_test_kit/example_client_suite'

RSpec.describe ExampleTestKit::ExampleClientSuite do
  let(:suite_id) { 'example_client_suite' }
  let(:bearer_token) { 'dummy_token' }

  describe 'retrieve encounter test' do
    let(:test) { find_test(suite, 'retrieve') }

    it 'passes after read encounter request received' do
      allow(test).to receive_messages(suite:)

      result = run(test, bearer_token:)
      expect(result.result).to eq('fail') # Assert test is fail before Encounter request

      repo_create(                        # Mock the Encounter retrieval request
        :request,
        verb: 'get',
        url: 'https://fhir.example.com/Encounter/123',
        direction: 'incoming',
        result_id: result.id,
        test_session_id: test_session.id,
        tags: ['encounter_request']
      )

      result = run(test, bearer_token:)   # Re-run test now that Encounter request was mocked
      expect(result.result).to eq('pass') # Assert test is pass after Encounter request
    end
  end
end

RSpec.describe ExampleTestKit, order: :defined do
  it_behaves_like 'platform_deployable_test_kit'
end