export { default, setup } from './crud.js'

export const options = {
  discardResponseBodies: false,
  scenarios: {
    warmup: {
      executor: 'constant-vus',
      vus: 10,
      duration: '30s',
      gracefulStop: '30s',
    },
  },
};

Warm up JVMs and caches before measurement

prewarm.js

import http from 'k6/http'
import { check, group } from 'k6'

import { jsonPatch, headers } from './util.js'

import claim from './seed/claim.js'
import encounter from './seed/encounter.js'
import explanationOfBenefit from './seed/explanation-of-benefit.js'
import location from './seed/location.js'
import medicationRequest from './seed/medication-request.js'
import observation from './seed/observation.js'
import organization from './seed/organization.js'
import patient from './seed/patient.js'
import practitioner from './seed/practitioner.js'


export const options = {
  discardResponseBodies: false,
  scenarios: {
    crud: {
      executor: 'constant-vus',
      vus: 300,
      duration: '5m',
      gracefulStop: '30s',
    },
  },
}

export function setup() {
  return {
    baseUrl: __ENV.BASE_URL,
    params: { headers: headers(), },
    seeds: {
      claim: JSON.stringify(claim),
      encounter: JSON.stringify(encounter),
      explanationOfBenefit: JSON.stringify(explanationOfBenefit),
      location: JSON.stringify(location),
      medicationRequest: JSON.stringify(medicationRequest),
      observation: JSON.stringify(observation),
      organization: JSON.stringify(organization),
      patient: JSON.stringify(patient),
      practitioner: JSON.stringify(practitioner),
    }
  }
}

const getRtId = (data, rt) => `${data[rt].resourceType}/${data[rt].id}`

const changeResource = (resource, inplace = true) => {
  const change = {}

  switch (resource.resourceType) {
    case 'Encounter':
      change['status'] = resource.status === 'planned' ? 'in-progress' : 'planned'
      break
    case 'Location':
    case 'Organization':
      change['name'] = `${resource.name}-${+(new Date())}`
      break
    case 'MedicationRequest':
      change['status'] = resource.status === 'on-hold' ? 'draft' : 'on-hold'
      break
    case 'Observation':
      change['issued'] = new Date().toISOString()
      break
    case 'Patient':
    case 'Practitioner':
      change['gender'] = resource.gender === 'unknown' ? 'other' : 'unknown'
      break
    default:
      change['created'] = new Date().toISOString()
  }

  return inplace ? Object.assign(resource, change) : change
}

export default function ({ baseUrl, params, seeds }) {
  const resources = {}

  group('create', () => {
    group('Patient', () => {
      const x = http.post(http.url`${baseUrl}/Patient`, seeds.patient, params)
      if (!check(x, { 'Patient created': ({ status }) => status === 201 })) return;
      resources.Patient = x.json()
    })

    group('Location', () => {
      const x = http.post(http.url`${baseUrl}/Location`, seeds.location, params)
      if (!check(x, { 'Location created': ({ status }) => status === 201 })) return;
      resources.Location = x.json()
    })

    group('Organization', () => {
      const x = http.post(http.url`${baseUrl}/Organization`, seeds.organization, params)
      if (!check(x, { 'Organization created': ({ status }) => status === 201 })) return;
      resources.Organization = x.json()
    })

    group('Practitioner', () => {
      const x = http.post(http.url`${baseUrl}/Practitioner`, seeds.practitioner, params)
      if (!check(x, { 'Practitioner created': ({ status }) => status === 201 })) return;
      resources.Practitioner = x.json()
    })

    group('Encounter', () => {
      const payload = JSON.parse(seeds.encounter)
      jsonPatch(payload, 'subject.reference', getRtId(resources, 'Patient'))
      jsonPatch(payload, 'location.0.location.reference', getRtId(resources, 'Location'))
      jsonPatch(payload, 'participant.0.individual.reference', getRtId(resources, 'Practitioner'))
      jsonPatch(payload, 'serviceProvider.reference', getRtId(resources, 'Organization'))
      const x = http.post(http.url`${baseUrl}/Encounter`, JSON.stringify(payload), params)
      if (!check(x, { 'Encounter created': ({ status }) => status === 201 })) return;
      resources.Encounter = x.json()
    })

    group('Observation', () => {
      const payload = JSON.parse(seeds.observation)
      jsonPatch(payload, 'encounter.reference', getRtId(resources, 'Encounter'))
      jsonPatch(payload, 'subject.reference', getRtId(resources, 'Patient'))
      const x = http.post(http.url`${baseUrl}/Observation`, JSON.stringify(payload), params)
      if (!check(x, { 'Observation created': ({ status }) => status === 201 })) return;
      resources.Observation = x.json()
    })

    group('MedicationRequest', () => {
      const payload = JSON.parse(seeds.medicationRequest)
      jsonPatch(payload, 'encounter.reference', getRtId(resources, 'Encounter'))
      jsonPatch(payload, 'requester.reference', getRtId(resources, 'Practitioner'))
      jsonPatch(payload, 'subject.reference', getRtId(resources, 'Patient'))
      const x = http.post(http.url`${baseUrl}/MedicationRequest`, JSON.stringify(payload), params)
      if (!check(x, { 'MedicationRequest created': ({ status }) => status === 201 })) return;
      resources.MedicationRequest = x.json()
    })

    group('Claim', () => {
      const payload = JSON.parse(seeds.claim)
      jsonPatch(payload, 'patient.reference', getRtId(resources, 'Patient'))
      jsonPatch(payload, 'provider.reference', getRtId(resources, 'Organization'))
      jsonPatch(payload, 'prescription.reference', getRtId(resources, 'MedicationRequest'))
      jsonPatch(payload, 'item.0.encounter.0.reference', getRtId(resources, 'Encounter'))
      const x = http.post(http.url`${baseUrl}/Claim`, JSON.stringify(payload), params)
      if (!check(x, { 'Claim created': ({ status }) => status === 201 })) return;
      resources.Claim = x.json()
    })

    group('ExplanationOfBenefit', () => {
      const payload = JSON.parse(seeds.explanationOfBenefit)
      jsonPatch(payload, 'contained.0.subject.reference', getRtId(resources, 'Patient'))
      jsonPatch(payload, 'contained.0.requester.reference', getRtId(resources, 'Practitioner'))
      jsonPatch(payload, 'contained.0.performer.0.reference', getRtId(resources, 'Patient'))
      jsonPatch(payload, 'contained.1.beneficiary.reference', getRtId(resources, 'Patient'))
      jsonPatch(payload, 'patient.reference', getRtId(resources, 'Patient'))
      jsonPatch(payload, 'provider.reference', getRtId(resources, 'Practitioner'))
      jsonPatch(payload, 'claim.reference', getRtId(resources, 'Claim'))
      jsonPatch(payload, 'careTeam.0.provider.reference', getRtId(resources, 'Practitioner'))
      jsonPatch(payload, 'item.0.encounter.0.reference', getRtId(resources, 'Encounter'))
      const x = http.post(http.url`${baseUrl}/ExplanationOfBenefit`, JSON.stringify(payload), params)
      if (!check(x, { 'ExplanationOfBenefit created': ({ status }) => status === 201 })) return;
      resources.ExplanationOfBenefit = x.json()
    })
  })

  group('read', () => {
    Object.keys(resources).forEach(rt => {
      group(rt, () => {
        const x = http.get(
          http.url`${baseUrl}/${getRtId(resources, rt)}`,
          { ...params, responseType: 'none', tags: { name: `${rt}/?` } }
        )
        check(x, { [`${rt} read`]: ({ status }) => status === 200 })
      })
    })
  })

  group('update', () => {
    Object.entries(resources).forEach(([rt, data]) => {
      group(rt, () => {
        changeResource(data)
        const x = http.put(
          http.url`${baseUrl}/${rt}/${data.id}`,
          JSON.stringify(data),
          { ...params, responseType: 'none', tags: { name: `${rt}/?` } }
        )
        check(x, { [`${rt} update`]: ({ status }) => status === 200 })
      })
    })
  })

  group('delete', () => {
    Object.keys(resources).reverse().forEach(rt => {
      group(rt, () => {
        const x = http.del(
          http.url`${baseUrl}/${getRtId(resources, rt)}`,
          null,
          { ...params, responseType: 'none', tags: { name: `${rt}/?` } }
        )
        check(x, { [`${rt} delete`]: ({ status }) => status === 200 })
      })
    })
  })
}

Create / read / update / delete throughput on FHIR resources

crud.js

import { group } from 'k6'
import { is200, headers } from './util.js'

export const options = {
  discardResponseBodies: true,
  scenarios: {
    search: {
      executor: 'constant-vus',
      vus: 10,
      duration: '5m',
      gracefulStop: '30s',
    },
  },
}

export function setup() {
  return {
    baseUrl: __ENV.BASE_URL,
    params: { headers: headers() },
  }
}

function searchTest(baseUrl, resourceType, query, params) {
  group(resourceType, () => {
    is200(`${baseUrl}/${resourceType}?${query}`, params)
  })
}

const count = 100

export default function({ baseUrl, params }) {
  group('text', () => {
    searchTest(baseUrl, 'Patient', `name=John&_count=${count}`, params)
    searchTest(baseUrl, 'Patient', `name=Undefined&_count=${count}`, params)
    searchTest(baseUrl, 'Patient', `name=Some_long_unexisting_string&_count=${count}`, params)
    searchTest(baseUrl, 'Patient', `name:contains=ohn&_count=${count}`, params)
  })
  group('date', () => {
    searchTest(baseUrl, 'Patient', `birthdate=2007-03-07&_count=${count}`, params)
    searchTest(baseUrl, 'Patient', `birthdate=eq2007-03-07&_count=${count}`, params)
    searchTest(baseUrl, 'Patient', `birthdate=ne2007-03-07&_count=${count}`, params)
    searchTest(baseUrl, 'Patient', `birthdate=lt2007-03-07&_count=${count}`, params)
    searchTest(baseUrl, 'Patient', `birthdate=gt2007-03-07&_count=${count}`, params)
  })
  // group('token', () => {
  //   searchTest(baseUrl, 'Observation', `code=29463-7&_count=${count}`, params)
  //   searchTest(baseUrl, 'Observation', `code=http://loinc.org|29463-7&_count=${count}`, params)
  //   searchTest(baseUrl, 'Observation', `code=|29463-7&_count=${count}`, params)
  //   searchTest(baseUrl, 'Observation', `code=http://loinc.org|&_count=${count}`, params)
  // })
  // group('reference', () => {
  //   searchTest(baseUrl, 'Observation', `patient=184cf049-bb4e-91c1-0a44-41c9512eee0c&_count=${count}`, params)
  // })
  // group('parameters', () => {
  //   searchTest(baseUrl, 'Patient', `_id=184cf049-bb4e-91c1-0a44-41c9512eee0c&_revinclude=Observation:patient&_count=${count}`, params)
  // })
}

Search performance on a pre-loaded Patient dataset with custom indexes

search.js

import http from 'k6/http'
import { check } from 'k6'
import { Counter } from 'k6/metrics'
import { headers } from './util.js'

const bundleSize = new Counter('bundle_size')

export const options = {
  discardResponseBodies: true,
  scenarios: {
    import: {
      executor: 'constant-vus',
      vus: 20,
      duration: '5m',
      gracefulStop: '30s',
    },
  },
}

export function setup() {

  const bundleUrl = __ENV.BUNDLE_URL
  const baseUrl = __ENV.BASE_URL
  const params = { headers: headers(), timeout: '300s' }

  // Reset tgz's rotation cursor so every server starts from bundle #0 — each
  // FHIR impl then imports the exact same set of bundles in the same order.
  http.post(`${bundleUrl}/reset`, null)

  // First - load hospital and practitioner information
  const seeds = ["hospitalInformation.json", "practitionerInformation.json"]
  seeds.forEach(x => {
    const src = http.get(`${bundleUrl}/${x}`, {responseType: 'text'})
    http.post(baseUrl, src.body, params)
  })


  return { baseUrl, bundleUrl, params, }
}

export default function ({ baseUrl, bundleUrl, params, }) {
  const bundle = http.get( bundleUrl, { tags: { group: '::source' }, responseType: 'text' })
  const x = http.post( baseUrl, bundle.body, { ...params, tags: { group: '::import' } })

  if (!check(x, { ['Bundle import']: ({ status }) => status === 200 })) return
  bundleSize.add(JSON.parse(bundle.body).entry.length)
}

Tests

Overview

Scenarios