+
+ )
+}
+
+Layout.propTypes = {
+ children: PropTypes.node.isRequired,
+}
+
+export default Layout
diff --git a/docs/src/components/seo.js b/docs/src/components/seo.js
new file mode 100644
index 000000000..e15f59958
--- /dev/null
+++ b/docs/src/components/seo.js
@@ -0,0 +1,88 @@
+/**
+ * SEO component that queries for data with
+ * Gatsby's useStaticQuery React hook
+ *
+ * See: https://www.gatsbyjs.org/docs/use-static-query/
+ */
+
+import React from "react"
+import PropTypes from "prop-types"
+import Helmet from "react-helmet"
+import { useStaticQuery, graphql } from "gatsby"
+
+function SEO({ description, lang, meta, title }) {
+ const { site } = useStaticQuery(
+ graphql`
+ query {
+ site {
+ siteMetadata {
+ title
+ description
+ author
+ }
+ }
+ }
+ `
+ )
+
+ const metaDescription = description || site.siteMetadata.description
+
+ return (
+
+ )
+}
+
+SEO.defaultProps = {
+ lang: `en`,
+ meta: [],
+ description: ``,
+}
+
+SEO.propTypes = {
+ description: PropTypes.string,
+ lang: PropTypes.string,
+ meta: PropTypes.arrayOf(PropTypes.object),
+ title: PropTypes.string.isRequired,
+}
+
+export default SEO
diff --git a/docs/src/gatsby-theme-docz/components/index.js b/docs/src/gatsby-theme-docz/components/index.js
new file mode 100644
index 000000000..73c8e66eb
--- /dev/null
+++ b/docs/src/gatsby-theme-docz/components/index.js
@@ -0,0 +1,11 @@
+import * as headings from "gatsby-theme-docz/src/components/Headings";
+import { Layout } from "gatsby-theme-docz/src/components/Layout";
+import { Playground } from "gatsby-theme-docz/src/components/Playground";
+import { Props } from "gatsby-theme-docz/src/components/Props";
+
+export default {
+ ...headings,
+ playground: Playground,
+ layout: Layout,
+ props: Props
+};
diff --git a/docs/src/images/gatsby-astronaut.png b/docs/src/images/gatsby-astronaut.png
new file mode 100644
index 000000000..da58ece0a
Binary files /dev/null and b/docs/src/images/gatsby-astronaut.png differ
diff --git a/docs/src/images/gatsby-icon.png b/docs/src/images/gatsby-icon.png
new file mode 100644
index 000000000..908bc78a7
Binary files /dev/null and b/docs/src/images/gatsby-icon.png differ
diff --git a/docs/src/pages/404.js b/docs/src/pages/404.js
new file mode 100644
index 000000000..bc4c31d79
--- /dev/null
+++ b/docs/src/pages/404.js
@@ -0,0 +1,14 @@
+import React from "react"
+
+import Layout from "../components/layout"
+import SEO from "../components/seo"
+
+const NotFoundPage = () => (
+
+
+
NOT FOUND
+
You just hit a route that doesn't exist... the sadness.
+
+)
+
+export default NotFoundPage
diff --git a/docs/src/pages/Contribute.md b/docs/src/pages/Contribute.md
new file mode 100644
index 000000000..1fca8d153
--- /dev/null
+++ b/docs/src/pages/Contribute.md
@@ -0,0 +1,38 @@
+---
+name: Contribute to Spark
+route: /contribute
+---
+
+# Contributions
+You are welcome to contribute to this project. The Spark server is used in several commercial and open source projects. Therefore we have a high quality standard and we carefully review submissions.
+
+When you want to contribute changes:
+- Contact us before start working on a major change.
+- Fork and send us a pull request
+
+### Pull requests
+When you send us a pull request
+- Make sure it builds
+- Make sure it's tested
+- The pull request should cover only one change
+- Accept that we might reject it because it conflicts with our strategy.
+
+We do appreciate suggestions, but the Spark FHIR server code is used by us for commercial projects, so we will most probably reject substantial changes unless you coordinate them with us first.
+
+### GIT branching strategy
+Our strategy for git branching:
+- R4:
+ - Current stable: **r4/master**
+ - Current nightly build: **r4/develop**
+- STU3:
+ - Current stable: **stu3/master**
+ - Current nightly build: **stu3/develop**
+- DSTU2:
+ - Current stable: **master**
+ - Current nightly build: **develop**
+- Feature branches: **feature**/topic
+- bugfixes: **bugfix/**issue
+
+Based on:
+- [NVIE](http://nvie.com/posts/a-successful-git-branching-model/)
+- Or see: [Git workflow](https://www.atlassian.com/git/workflows#!workflow-gitflow)
\ No newline at end of file
diff --git a/docs/src/pages/Deployment/Deploy_spark.md b/docs/src/pages/Deployment/Deploy_spark.md
new file mode 100644
index 000000000..47f667d80
--- /dev/null
+++ b/docs/src/pages/Deployment/Deploy_spark.md
@@ -0,0 +1,150 @@
+---
+name: Spark FHIR server
+route: /deployment
+menu: Deployment
+---
+
+This page describes how to deploy Spark from the source code onto a Windows machine, either virtual or physical. The instructions are based on Windows Server 2012.
+
+# Install prerequisites
+
+Install the following prerequisites.
+
+Please make sure to install IIS first, and ASP.Net 4.6 later. IIS comes with ASP.Net 4.5, and if you do 4.6 first, the IIS installation will break 4.6.
+
+## Install Internet Information Server (IIS)
+
+If you do not already have a recent version of IIS (7 or 8), install it.
+
+1. Open Server Manager > Dashboard
+2. Click 'Add roled and features'
+3. Select 'Web Server (IIS)'
+4. Make sure to include Management Tools > Management Service
+You need this if you want to enable [Web Deploy](http://www.iis.net/learn/publish/using-web-deploy/introduction-to-web-deploy) for non-administrators.
+
+## Install Web Deploy
+
+1. Download the [Web Platform Installer](https://www.microsoft.com/web/downloads/platform.aspx) and run it (wpilauncher.exe).
+2. Select 'WebDeploy 3.6 for Hosting Servers'
+3. Install
+
+Read [more info](https://www.iis.net/learn/install/installing-publishing-technologies/installing-and-configuring-web-deploy-on-iis-80-or-later) about Web Deploy, especially for configuring Web Deploy for non-administrators.
+
+## Install ASP.NET 4.6
+
+If you do not already have it installed, install ASP.NET 4.6 (version 4.5 is not enough).
+
+1. Download it from [Microsoft](http://www.microsoft.com/en-us/download/details.aspx?id=48130).
+2. Install it by running the just downloaded NDP46-KB3045560-Web.exe.
+
+## Install MongoDB
+
+Spark uses MongoDB for storage. Install it as a service. These instructions are based on the [MongoDB documentation](https://docs.mongodb.com/v3.0/tutorial/install-mongodb-on-windows/).
+
+1. Download [MongoDB](https://www.mongodb.com/download-center?jmp=nav#community), choose the Community Edition, 'Windows Server 2008 R2 and later, with SSL support'.
+2. Run the installer.
+By default it will be installed in C:\Program Files\MongoDB\Server
+3. Create directories for the database, log files and configuration of Mongo. For example:
+
+ * C:\Spark\MongoDb\Data
+ * C:\Spark\MongoDb\Log
+ * C:\Spark\MongoDb\Config
+
+4. Create a configuration file for MongoDb in the Config directory, name it SparkMongoDB.cfg and add the following to it (adjust to your previously created directories). Please note the indentation: it is relevant (MongoDB uses YAML for this configuration file).
+
+ ```yaml
+ systemLog:
+ destination: file
+ path: c:\Spark\MongoDB\Log\mongod.log
+ storage:
+ dbPath: c:\Spark\MongoDB\Data
+ ```
+
+5. Run the command below in a Command Window, as Administrator. It will register MongoDB as a Windows Service.
+
+ ```bash
+ c:\Program Files\MongoDB\Server\3.2\bin>mongod.exe --config "C:\Spark\MongoDB\Config\SparkMongoDB.cfg" --install
+ ```
+
+# Opening Ports
+
+If you want to deploy Spark with Web Deploy from within Visual Studio to this machine, you will have to open the relevant ports for it for inbound traffic:
+
+* http (80)
+* https (443)
+* WebDeploy (8172)
+
+Depending on your network configuration you may need to open 8172 locally for outbound traffic.
+
+If you want to manage the MongoDB database remotely, you also have to open:
+
+* 27017
+
+Please take precautions when you do this (refer to MongoDB documentation for further information).
+
+* Configure MongoDB security
+* Start MongoDB in secure mode
+
+# Deploy Spark
+
+## By Web Deploy
+
+1. Open Spark.sln in Visual Studio
+2. Choose Build | Publish Spark
+
+ 1. On the Profile tab, create a new profile for this Virtual Machine:
+ 2. Publish target 'Custom' > choose a name (something that refers to this machine)
+ 3. Connection
+
+ 1. Publish method: Web Deploy
+ 2. Server: the ip address of your Virtual Machine
+ 3. Site name: Default Web Site/spark
+ 4. User name: login name for your VM
+ 5. Password: matching the User name
+ 6. Destination URL: can be left blank
+ 7. Validate Connection
+ 8. If the connection does not validate, check with the system administrator if the firewall lets you through.
+
+ 4. Settings
+
+ 1. Configuration: Release
+
+ 5. Publish
+
+## By Web Deploy Package
+
+1. Open Spark.sln in Visual Studio
+1. Choose Build | Publish Spark
+ 1. On the Profile tab, create a new profile.
+ 2. Publish target 'Custom' > choose a name (it may or may not refer to this specific machine, since you can deploy the package to other machines as well).
+ 3. Connection
+ 1. Publish method: Web Deploy Package
+ 2. Package location: choose as suitable directory on your disk.
+ 3. Site name: Default Web Site/spark
+ 4. Settings
+ 1. Configuration: Release
+ 5. Publish
+1. Connect Remote Desktop Manager to your VM, and select the option to make your local disks available to the VM.
+1. In the VM, open Windows Explorer and copy the deployment package to a local directory on the VM.
+1. Read (from the deployment directory) the Spark.deploy-readme.txt.
+1. Start a Command Window as Administrator and run (from the deployment directory)
+
+ Spark.deploy.cmd /Y
+
+# Check Spark
+
+Open a browser on the server and try http://localhost/spark. If that works, try the same from your own machine, with http://ip-address/spark
+
+# FAQ
+
+## Bad Module
+
+When I first try to open Spark in the browser I get this error:
+
+ Handler "ExtensionlessUrlHandler-Integrated-4.0" has a bad module "ManagedPipelineHandler" in its module list
+
+Something must have gone wrong with installing ASP.Net in IIS. I (Christiaan) had this and solved it by running in a Command Window (as Administrator):
+
+ dism.exe /Online /Enable-Feature /all /FeatureName:IIS-ASPNET45
+
+Source of this fix: https://www.microsoft.com/en-us/download/details.aspx?id=44989
diff --git a/docs/src/pages/Deployment/Performance.md b/docs/src/pages/Deployment/Performance.md
new file mode 100644
index 000000000..c92d4fab6
--- /dev/null
+++ b/docs/src/pages/Deployment/Performance.md
@@ -0,0 +1,19 @@
+---
+name: Performance
+route: /performance
+menu: Deployment
+---
+
+# Performance
+
+We have no performance figures of Spark yet. Spark is already being used in production scenarios, so it is fit for real use. If you have measured performance of Spark yourself, please share the results!
+
+In the near future we will develop performance tests for Spark to get you an idea whether or how it will fit your performance needs.
+
+If you are concerned Spark will not handle your load as fast as you would like, consider the following possibilities for spreading the load.
+
+* If you are FHIR-enabling multiple source systems, you could provide every system with it's own FHIR front-end, implemented by Spark. Instead of feeding data from all the source systems into one instance of Spark. You will however need a way to route requests to the correct instance of Spark.
+
+* If there is a logical attribute in your data to split the whole set into multiple sets, you could deploy Spark multiple times, each one on a 'shard' of the data. You will need a way to route requests to the correct instance of Spark, based on the chosen attribute.
+
+* MongoDB supports sharding, as described in the [MongoDB documentation](https://docs.mongodb.com/manual/sharding/). You will have to choose a shard key based upon expected use. To use this in Spark, you will probably have to tweak the Spark Mongo implementation.
diff --git a/docs/src/pages/Deployment/Using_Spark.md b/docs/src/pages/Deployment/Using_Spark.md
new file mode 100644
index 000000000..3639a2721
--- /dev/null
+++ b/docs/src/pages/Deployment/Using_Spark.md
@@ -0,0 +1,39 @@
+---
+name: Fitting Spark in my environment
+route: /using_spark
+menu: Deployment
+---
+
+There are essentially two ways in which you can fit Spark in your own environment. One is using Spark as-is, the other requires you to modify the storage layer.
+
+## Using Spark as-is
+
+In this mode, Spark handles everything FHIR for you, but it requires it's own storage of resources and the search index to do so. This means you have to feed the data that you want to serve as FHIR Resources into the Spark REST interface. So you create a copy of (part of) your data, held in the Spark MongoDB database. These are roughly the steps to follow:
+
+* Define how the data in your own system(s) maps to FHIR resources. This is the logical mapping.
+* Create a piece of software that:
+ * performs this logical mapping on actual data
+ * uploads the result of it to Spark (with a FHIR Create operation on the POST `[base]/fhir/` endpoint)
+The FhirClient from the Hl7.Fhir API is very useful to program this.
+* If you need periodic updates from your system to Spark, run the software from the previous step periodically by any means you see fit. It is advised that only updates since the previous run can be recognized in your data, and you feed them into Spark instead of reloading all the data every time.
+
+## Using Spark directly against your own datastore
+
+In this mode, Spark presents the FHIR REST interface to the outside world, but data retrieval (and eventually storage) is handled by an existing datastore. This requires quite some work in adapting Spark, because you have to replace Spark.Mongo with an implementation targeting your own datastore. Depending on the FHIR interactions that you intend to support, this may or may not be feasible. We think this is a valid option if you:
+
+* provide read-only access
+* to a limited number of Resource types
+* supporting only a few search parameters
+
+Please be aware that:
+
+* A FHIR Resource has a server-assigned id, by which it can be retrieved again. Because a resource may span several datastructures in your own datastore, management of these id's is not always straightforward.
+* A search must be translated to a (usually SQL-) query into your own datastore. Therefore, supporting many search parameters will probably require a lot of work.
+
+You will have to do roughly these steps:
+
+* Define how the data in your own system maps to FHIR resources. This is the logical mapping.
+* Implement the interfaces regarding storage (see [[Architecture](./architecture)]. Perform the actual mapping when retrieving the data for a resource from your system.
+* Adjust the ConformanceBuilder, so the resulting ConformanceStatement states exactly what you support (which Resource types, which operations).
+* Use the dependency injection framework to inject your implementations for the storage interfaces (in UnityConfig.cs).
+
diff --git a/docs/src/pages/Get_started/Architecture.md b/docs/src/pages/Get_started/Architecture.md
new file mode 100644
index 000000000..faa1f0cc5
--- /dev/null
+++ b/docs/src/pages/Get_started/Architecture.md
@@ -0,0 +1,52 @@
+---
+name: Spark Architecture
+route: /architecture
+menu: Get started
+---
+
+# Spark FHIR server
+
+Spark is built in three layers:
+
+1. Spark Server (Spark.Web for Asp.net core 2.1, or Spark.csproj for ASP.net 4.6): An ASP.Net MVC application hosting both a (minimal) visual interface, the FHIR (REST) endpoint and a Maintenance operation.
+2. Spark Engine (Spark.Engine.csproj): The implementation of everything FHIR: the REST interface, indexing of the search parameters and interpreting search requests, construction of FHIR responses etc.
+3. Spark Mongo (Spark.Mongo.csproj): Storage and retrieval of both resources and the index based on MongoDB.
+
+# Spark is built on the .NET FHIR API
+
+Spark uses the .NET FHIR API to parse and serialize resources, and as a source of metadata about the FHIR specification: what Resource types are available, what is the definition of the SearchParameters and so on. The parsing and serialization in this API is heavily optimized. Using Spark you get the benefits of that. It also means that Spark is bound to a specific version of the API, which is currently the DSTU2 version.
+
+# Spark Engine
+
+Spark Engine provides:
+
+1. Interfaces for the various functions that must be implemented by the storage layer:
+ * IFhirStore: Add and retrieve resources.
+ * IFhirIndex: Process resources to index entries, search resources using the index.
+ * IIndexStore: Save and delete index entries.
+ * ISnapShotStore: Save and retrieve snapshots of search results for paging.
+ * IHistoryStore: Get previous versions of a resource, a resource type or the whole system.
+ * IGenerator: Generate ID's for new resources and new versions of resources.
+2. Services for handling generic FHIR functionality
+ * SearchService: Combine IFhirIndex and ISnapShotStore to paging results.
+ * ElementIndexer: Translate FHIR DataTypes to parts of an Index entry.
+ * ConformanceService: Provide the conformance statement of Spark.
+3. ASP.NET Filters for handling cross cutting FHIR concerns:
+ * Translating Exceptions to FHIR Response Messages (an http error or OperationOutcome)
+ * (De)compression of request and response data.
+4. ASP.NET Formatters for several wire formats:
+ * JSON
+ * XML
+ * Binary
+ * HTML
+5. All kinds of model and helper classes to assist in the functions above.
+
+This all accumulates in (I)FhirService, that presents all the FHIR functions.
+
+# Spark Mongo
+
+The MongoDB implementation of Spark stores the resources, the index, the snapshots and the generated ID's in MongoDB, with one collection for each. Previous versions of resources are also in the Resources collection. The Index collection contains only the current version of every resource.
+
+MongoSearcher implements the actual searching mechanism on the MongoDB index, using the generic ResourceVisitor and Criterium classes in Spark Engine.
+
+Be aware that MongoDB is heavily used (especially on searches), so it should be on an endpoint with very little latency.
\ No newline at end of file
diff --git a/docs/src/pages/Get_started/Installing_spark.md b/docs/src/pages/Get_started/Installing_spark.md
new file mode 100644
index 000000000..5f6768d00
--- /dev/null
+++ b/docs/src/pages/Get_started/Installing_spark.md
@@ -0,0 +1,23 @@
+---
+name: Installing Spark
+route: /install
+menu: Get started
+---
+
+# Getting Started
+
+## Database
+
+Spark FHIR server supports MongoDB as it´s persistence layer. The following options are supported:
+
+- MongoDB Atlas. Sign up for a [free trial account](https://www.mongodb.com/download-center) and run your database in the cloud.
+- MongoDB Community Server. [Download](https://www.mongodb.com/download-center/community) and install locally
+- MongoDB Enterprise. [Download](https://www.mongodb.com/download-center/enterprise) and install locally.
+- MongoDB in docker. Checkt the example [docker-compose.yml](https://github.com/FirelyTeam/spark/blob/master/docker-compose.yml) for setup.
+
+## Install Spark
+
+The core packages Spark.Engine and Spark.Mongo are running on NetStandard 2.0. For the web application you may choose between:
+
+- `Spark.Web` which runs on ASP.Net Core 2.1, or
+- `Spark` which runs on ASP.Net 4.6 or later.
diff --git a/docs/src/pages/Get_started/Quickstart.md b/docs/src/pages/Get_started/Quickstart.md
new file mode 100644
index 000000000..8420a5c0b
--- /dev/null
+++ b/docs/src/pages/Get_started/Quickstart.md
@@ -0,0 +1,219 @@
+---
+name: Quickstart
+route: /quickstart
+menu: Get started
+---
+
+## Overview
+
+This quickstart section will teach you how to set up a new FHIR Server from scratch using the NuGet packages with MongoDB as your storage media.
+
+This tutorial assumes a local installation of MongoDB exists. Set up [MongoDB Community edition](https://docs.mongodb.com/manual/administration/install-community/) if you do not already have a local installation.
+
+Sample code for this tutorial is located here: [spark-example](https://github.com/kennethmyhra/spark-example)
+
+
+## Setting up the ASP.NET core application
+
+First create an empty ASP.NET Core project:
+
+```bash
+dotnet new web --framework netcoreapp3.1
+```
+
+Add the core package:
+```bash
+dotnet add package Spark.Engine.R4
+```
+
+Add the MongoDB store:
+```bash
+dotnet add package Spark.Mongo.R4
+```
+
+For testing purposes restore one of the examples database.
+
+Windows:
+```bash
+mongorestore /host:localhost /db:spark-test /archive:.\dockers\mongo-spark-r4\r4.archive.gz /gzip
+```
+
+Linux/Mac OS X:
+```bash
+mongorestore --host:localhost --db:spark-test --archive:./dockers/mongo-spark-r4/r4.archive.gz --gzip
+```
+
+## Configuration and infrastrucuture
+
+For the sake of simplicity in this tutorial all configuration is set up in code.
+
+In Startup.cs add the following code:
+```cs
+public void ConfigureServices(IServiceCollection services)
+{
+ // Sets up DI context and adds neccessary infrastructure, like ASP.NET MVC
+ services.AddFhir(new SparkSettings
+ {
+ Endpoint = new Uri("https://localhost:5001/fhir")
+ },
+ options => options.EnableEndpointRouting = false
+ ).SetCompatibilityVersion(CompatibilityVersion.Version_3_0);
+
+ // Adds support for MongoDB Store
+ services.AddMongoFhirStore(new StoreSettings
+ {
+ // Connection string for your MongoDB Store
+ ConnectionString = "mongodb://localhost/spark-r4"
+ });
+}
+
+public void Configure(IApplicationBuilder app, IHostingEnvironment env)
+{
+ if (env.IsDevelopment())
+ {
+ app.UseDeveloperExceptionPage();
+ }
+
+ // Sets up internal middleware, as well as ASP.NET MVC
+ app.UseFhir(r => r.MapRoute(name: "default", template: "{controller}/{id?}"));
+}
+```
+
+## Defining the API endpoint
+
+Add a new folder called Controllers to the root of your application, then add to that folder a new controller FhirController.cs.
+
+In FhirController.cs add the following code:
+
+```cs
+[ApiController]
+public class FhirController : ControllerBase
+{
+ // Interface which adds and retrieve resources.
+ private readonly IFhirService _fhirService;
+ // Settings for your server
+ private readonly SparkSettings _settings;
+
+ public FhirController(IFhirService fhirService, SparkSettings settings)
+ {
+ _fhirService = fhirService ?? throw new ArgumentNullException(nameof(fhirService));
+ _settings = settings ?? throw new ArgumentNullException(nameof(settings));
+ }
+}
+```
+
+### Read interaction
+Add the read interaction to your FHIR server by adding the following method to FhirController.cs
+
+```cs
+[HttpGet("{type}/{id}")]
+public ActionResult Read(string type, string id)
+{
+ ConditionalHeaderParameters parameters = new ConditionalHeaderParameters(Request);
+ Key key = Key.Create(type, id);
+ return new ActionResult(_fhirService.Read(key, parameters));
+}
+```
+
+If you restored the example database you should now be able to retrieve your first FHIR resource:
+
+```bash
+curl -H "Accept: application/fhir+json; charset=utf-8" http://localhost:5000/Patient/example
+```
+
+### Search interaction
+Add the search interaction to your FHIR Server by adding the following method to FhirController.cs:
+
+```cs
+[HttpGet("{type}")]
+public FhirResponse Search(string type)
+{
+ int start = FhirParameterParser.ParseIntParameter(Request.GetParameter(FhirParameter.SNAPSHOT_INDEX)) ?? 0;
+ var searchparams = Request.GetSearchParams();
+
+ return _fhirService.Search(type, searchparams, start);
+}
+```
+
+Try out the search interaction by running the following command:
+
+```bash
+curl -H "Accept: application/fhir+json; charset=utf-8" http://localhost:5000/Observation?subject=example
+```
+
+### Create interaction
+Add the create interaction to your FHIR server by adding the following method to FhirController.cs:
+
+```cs
+[HttpPost("{type}")]
+public FhirResponse Create(string type, Resource resource)
+{
+ Key key = Key.Create(type, resource?.Id);
+
+ if (Request.Headers.ContainsKey(FhirHttpHeaders.IfNoneExist))
+ {
+ NameValueCollection searchQueryString = HttpUtility.ParseQueryString(Request.GetTypedHeaders().IfNoneExist());
+ IEnumerable> searchValues =
+ searchQueryString.Keys.Cast()
+ .Select(k => new Tuple(k, searchQueryString[k]));
+
+ return _fhirService.ConditionalCreate(key, resource, SearchParams.FromUriParamList(searchValues));
+ }
+
+ return _fhirService.Create(key, resource);
+}
+```
+
+Try out the create interaction by running the following command:
+
+```bash
+curl -d '{"resourceType":"Patient","active":true,"name":[{"use":"official","family":"Doe","given":["John"]}],"gender":"male"}' -H "Content-Type: application/fhir+json" -X POST http://localhost:5000/Patient
+```
+
+### Update interaction
+Add the update interaction to your FHIR server by adding the following method to FhirController.cs:
+
+```cs
+[HttpPut("{type}/{id?}")]
+public ActionResult Update(string type, Resource resource, string id = null)
+{
+ string versionId = Request.GetTypedHeaders().IfMatch?.FirstOrDefault()?.Tag.Buffer;
+ Key key = Key.Create(type, id, versionId);
+ if(key.HasResourceId())
+ {
+ Request.TransferResourceIdIfRawBinary(resource, id);
+
+ return new ActionResult(_fhirService.Update(key, resource));
+ }
+ else
+ {
+ return new ActionResult(_fhirService.ConditionalUpdate(key, resource,
+ SearchParams.FromUriParamList(Request.TupledParameters())));
+ }
+}
+```
+
+Using the id from the create example try out the update interaction by running the following command:
+
+```bash
+curl -d '{"resourceType":"Patient","id":"6","active":true,"name":[{"use":"official","family":"Doe","given":["Jane"]}],"gender":"female"}' -H "Content-Type: application/fhir+json" -X PUT http://localhost:5000/Patient/6
+```
+
+### Delete interaction
+Add the delete interaction to your FHIR server by adding the following method to FhirController.cs:
+
+```cs
+[HttpDelete("{type}/{id}")]
+public FhirResponse Delete(string type, string id)
+{
+ Key key = Key.Create(type, id);
+ FhirResponse response = _fhirService.Delete(key);
+ return response;
+}
+```
+
+Using the id from the create and update examples try out the delete interaction by running the following command:
+
+```bash
+curl -H "Accept: application/fhir+json" -X DELETE http://localhost:5000/Patient/6
+```
diff --git a/docs/src/pages/Get_started/Run_with_Docker.md b/docs/src/pages/Get_started/Run_with_Docker.md
new file mode 100644
index 000000000..0e303b849
--- /dev/null
+++ b/docs/src/pages/Get_started/Run_with_Docker.md
@@ -0,0 +1,79 @@
+---
+name: Running Spark in Docker
+route: /install/docker
+menu: Get started
+---
+
+# Running Spark in Docker
+
+Spark can run in a Docker. This is a sample Dockerfile for running Spark.
+
+```
+FROM mcr.microsoft.com/dotnet/core/aspnet:2.2-stretch-slim AS base
+WORKDIR /app
+EXPOSE 80
+EXPOSE 443
+
+FROM mcr.microsoft.com/dotnet/core/sdk:2.2-stretch AS build
+WORKDIR /src
+COPY ["./src/Spark.Web/", "Spark.Web/"]
+COPY ["./src/Spark.Engine/", "Spark.Engine/"]
+COPY ["./src/Spark.Mongo/", "Spark.Mongo/"]
+RUN dotnet restore "/src/Spark.Web/Spark.Web.csproj"
+COPY . .
+RUN dotnet build "/src/Spark.Web/Spark.Web.csproj" -c Release -o /app
+
+FROM build AS publish
+RUN dotnet publish "/src/Spark.Web/Spark.Web.csproj" -c Release -o /app
+
+FROM base AS final
+WORKDIR /app
+COPY --from=publish /app .
+# COPY --from=build /src/Spark.Web/example_data/fhir_examples ./fhir_examples
+
+ENTRYPOINT ["dotnet", "Spark.Web.dll"]
+```
+
+If you want to run the Mongo database as well, you could configure it with a `docker-compse.yml`-file:
+
+```
+version: "3"
+services:
+ spark:
+ container_name: spark
+ restart: always
+ build:
+ context: .
+ dockerfile: Dockerfile
+ environment:
+ - StoreSettings__ConnectionString=mongodb://root:CosmicTopSecret@mongodb:27017/spark?authSource=admin
+ - SparkSettings__Endpoint=http://localhost:5555/fhir
+ ports:
+ - "5555:80"
+ - "44348:443"
+ links:
+ - mongodb
+ depends_on:
+ - mongodb
+ mongodb:
+ container_name: mongodb
+ image: mongo
+ environment:
+ MONGO_INITDB_ROOT_USERNAME: root
+ MONGO_INITDB_ROOT_PASSWORD: CosmicTopSecret
+ ports:
+ - "17017:27017"
+ mongosetup:
+ container_name: mongosetup
+ image: mongo
+ volumes:
+ - ./src/Spark.Web/example_data/db_dump:/data/db_dump
+ depends_on:
+ - mongodb
+ links:
+ - mongodb
+ entrypoint:
+ ["mongorestore", "--uri=mongodb://root:CosmicTopSecret@mongodb:27017/spark", "--drop", "--archive=/data/db_dump/dstu2.archive.gz", "--gzip"]
+ environment:
+ WAIT_HOSTS: mongodb:27017
+```
diff --git a/docs/src/pages/Resources/Forge.md b/docs/src/pages/Resources/Forge.md
new file mode 100644
index 000000000..b8cbae89e
--- /dev/null
+++ b/docs/src/pages/Resources/Forge.md
@@ -0,0 +1,10 @@
+---
+name: Forge
+menu: Resources
+---
+
+# Forge
+
+Download [Forge](https://simplifier.net/forge) to start editing profiles such as structure definitions and extensions.
+
+Forge is the official HL7 FHIR profile editor. Tailoring the FHIR specification to a specific use-case is an important aspect of the FHIR standard. This process is also known as profiling. While the FHIR spec targets all countries and all use cases, profiling allows you to define local use of FHIR.
diff --git a/docs/src/pages/Resources/Simplifier_net.md b/docs/src/pages/Resources/Simplifier_net.md
new file mode 100644
index 000000000..fb352372c
--- /dev/null
+++ b/docs/src/pages/Resources/Simplifier_net.md
@@ -0,0 +1,11 @@
+---
+name: Simplifier.net
+route: /resources/simplifier
+menu: Resources
+---
+
+# Simplifier.net
+
+[simplifier.net](https://simplifier.net/) is the most feature complete FHIR registry server on the internet.
+
+Create an account now for free and you can Publish your conformance resourceIdentifiers (profiles) on [simplifier.net](https://simplifier.net/)
diff --git a/docs/src/pages/index.md b/docs/src/pages/index.md
new file mode 100644
index 000000000..c3c0c69fa
--- /dev/null
+++ b/docs/src/pages/index.md
@@ -0,0 +1,40 @@
+---
+name: Introduction
+route: /
+---
+
+# Spark FHIR server
+
+## About
+Spark is a public domain FHIR server developed in C#, initially built by Firely and as of recently being maintained by Kufu.
+
+Spark implements a major part of the FHIR specification and has been used and tested during several HL7 WGM Connectathons.
+
+Spark is the C# reference implementation of the FHIR specification. It supports all the resource types, all the search parameters and a lot of the more sophisticated interactions. To understand Spark and how you can use it, it is neccessary that you understand (at least the basics of) FHIR first.
+
+Spark supports three versions of the FHIR specification: DSTU2, STU3 and R4.
+
+As of recently the task of maintaining Spark has been taken upon by the community and is led by Kufu.
+Kufu and the community, will keep enhancing this server to support the latest versions and add functionality.
+We also welcome anyone who wants to support this effort and help us make Spark a better reference
+platform and playground for FHIR.
+
+You can try a running instance of Spark on https://spark.kufu.no. Retrieve your first patient resource on https://spark.kufu.no/fhir/Patient/example. If you want to know about how Spark is structured, read about the [Architecture](./architecture). It makes it easier to understand everything else. Spark is open source and your [contribution](./Contribute) is welcome.
+
+## Quickstart
+The easiest way to test Spark FHIR server is by using Docker. Make sure you have installed [Docker](https://docs.docker.com/install/). On Linux you will need to install [Docker Compose](https://docs.docker.com/compose/install/) as well. After installing Docker you could run Spark server by running the command for your operating system:
+
+R4:
+ * Mac OS X / Windows: `curl 'https://raw.githubusercontent.com/firelyteam/spark/develop/dockers/spark-r4/docker-compose.yml' > docker-compose.yml && docker-compose up`
+ * Linux: `curl 'https://raw.githubusercontent.com/FirelyTeam/spark/develop/dockers/spark-r4/docker-compose.yml' > docker-compose.yml && sudo docker-compose up`
+
+STU3:
+ * Mac OS X / Windows: `curl 'https://raw.githubusercontent.com/firelyteam/spark/develop/dockers/spark-stu3/docker-compose.yml' > docker-compose.yml && docker-compose up`
+ * Linux: `curl 'https://raw.githubusercontent.com/FirelyTeam/spark/develop/dockers/spark-stu3/docker-compose.yml' > docker-compose.yml && sudo docker-compose up`
+
+DSTU2:
+ * Mac OS X / Windows: `curl 'https://raw.githubusercontent.com/firelyteam/spark/develop/dockers/spark-dstu2/docker-compose.yml' > docker-compose.yml && docker-compose up`
+ * Linux: `curl 'https://raw.githubusercontent.com/FirelyTeam/spark/develop/dockers/spark-dstu2/docker-compose.yml' > docker-compose.yml && sudo docker-compose up`
+
+Spark FHIR server will be available after startup at `http://localhost:5555`.
+
diff --git a/scripts/CreateIndexes.bat b/scripts/CreateIndexes.bat
new file mode 100644
index 000000000..6c8b74a6a
--- /dev/null
+++ b/scripts/CreateIndexes.bat
@@ -0,0 +1 @@
+mongo spark CreateIndexes.js > CreateIndexes.log
diff --git a/scripts/CreateIndexes.js b/scripts/CreateIndexes.js
new file mode 100644
index 000000000..a513b4ef1
--- /dev/null
+++ b/scripts/CreateIndexes.js
@@ -0,0 +1,15 @@
+print("indexes for just about any operation, including create / update");
+printjson(db.searchindex.createIndex({ "internal_resource" : 1, "identifier.code" : 1, "identifier.system" : 1}, { "name" : "ix_resource_identifier", "background" : true}));
+printjson(db.searchindex.createIndex({"internal_id":1, "internal_selflink":1},{"name":"ix_internal_id_selflink", "background":true}));
+printjson(db.resources.createIndex({"@REFERENCE" : 1, "@state" : 1}, { "name" : "ix_REFERENCE_state", "background" : "true" }));
+
+print("indexes for when you query by Patient.name or Patient.family a lot");
+printjson(db.searchindex.createIndex({"name" : 1}, { "name" : "ix_Patient_name", partialFilterExpression : { "internal_resource" : "Patient" }, "background" : "true" }));
+printjson(db.searchindex.createIndex({"family" : 1}, { "name" : "ix_Patient_family", partialFilterExpression : { "internal_resource" : "Patient" }, "background" : "true" }));
+
+print("specific index for Encounter.serviceprovider");
+printjson(db.searchindex.createIndex({"internal_resource" : 1, "serviceprovider" : 1}, { "name" : "ix_Encounter_serviceProvider", partialFilterExpression : { "internal_resource" : "Encounter" }, "background" : "true" }));
+print("specific index for references to patient, from any resources that has a 'patient' search parameter");
+printjson(db.searchindex.createIndex({"internal_resource" : 1, "patient" : 1}, { "name" : "ix_patient_reference", "background" : "true" }));
+print("specific index for Observation.code");
+printjson(db.searchindex.createIndex({"code.code" : 1, "code.system" : 1}, { "name" : "ix_Observation_code", partialFilterExpression : { "internal_resource" : "Observation" }, "background" : "true" }));
diff --git a/scripts/RemoveDuplicateId.bat b/scripts/RemoveDuplicateId.bat
new file mode 100644
index 000000000..c1f7d286f
--- /dev/null
+++ b/scripts/RemoveDuplicateId.bat
@@ -0,0 +1 @@
+mongo spark RemoveDuplicateId.js > RemoveDuplicateId.log
diff --git a/scripts/RemoveDuplicateId.js b/scripts/RemoveDuplicateId.js
new file mode 100644
index 000000000..5795bda9d
--- /dev/null
+++ b/scripts/RemoveDuplicateId.js
@@ -0,0 +1,2 @@
+print("Removing duplicate Ids");
+printjson(db.resources.update({}, {$unset: {Id:1}}, {multi: true}));
diff --git a/src/Spark.Engine.Test/Auxiliary/LimitedStreamTests.cs b/src/Spark.Engine.Test/Auxiliary/LimitedStreamTests.cs
new file mode 100644
index 000000000..609c105ba
--- /dev/null
+++ b/src/Spark.Engine.Test/Auxiliary/LimitedStreamTests.cs
@@ -0,0 +1,141 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.IO;
+using Spark.Engine.Auxiliary;
+
+namespace Spark.Engine.Test.Auxiliary
+{
+ [TestClass]
+ public class LimitedStreamTests
+ {
+ [TestMethod]
+ public void TestWriteWithinLimit()
+ {
+ MemoryStream innerStream = new MemoryStream();
+ LimitedStream sut = new LimitedStream(innerStream, 10);
+
+ sut.Write(new byte[5] { (byte)1, (byte)2, (byte)3, (byte)4, (byte)5 }, 0, 5);
+
+ byte[] actual = new byte[5];
+ innerStream.Seek(0, SeekOrigin.Begin);
+ innerStream.Read(actual, 0, 5);
+
+ Assert.AreEqual((byte)1, actual[0]);
+ Assert.AreEqual((byte)5, actual[4]);
+ }
+
+ [TestMethod]
+ [ExpectedException(typeof(ArgumentOutOfRangeException))]
+ public void TestWriteAboveLimit()
+ {
+ MemoryStream innerStream = new MemoryStream();
+ LimitedStream sut = new LimitedStream(innerStream, 3);
+
+ sut.Write(new byte[5] { (byte)1, (byte)2, (byte)3, (byte)4, (byte)5 }, 0, 5);
+ }
+
+ [TestMethod]
+ [ExpectedException(typeof(ArgumentOutOfRangeException))]
+ public void TestWriteWithinThenAboveLimit()
+ {
+ MemoryStream innerStream = new MemoryStream();
+ LimitedStream sut = new LimitedStream(innerStream, 10);
+
+ sut.Write(new byte[5] { (byte)1, (byte)2, (byte)3, (byte)4, (byte)5 }, 0, 5);
+
+ byte[] actual5 = new byte[5];
+ innerStream.Seek(0, SeekOrigin.Begin);
+ innerStream.Read(actual5, 0, 5);
+
+ Assert.AreEqual((byte)1, actual5[0]);
+ Assert.AreEqual((byte)5, actual5[4]);
+
+ sut.Write(new byte[5] { (byte)6, (byte)7, (byte)8, (byte)9, (byte)10 }, 0, 5);
+
+ byte[] actual10 = new byte[10];
+ innerStream.Seek(0, SeekOrigin.Begin);
+ innerStream.Read(actual10, 0, 10);
+
+ Assert.AreEqual((byte)1, actual10[0]);
+ Assert.AreEqual((byte)10, actual10[9]);
+
+ sut.Write(new byte[1] { (byte)11}, 0, 1);
+ }
+
+ [TestMethod]
+ public void TestWriteWithinLimitWithOffset()
+ {
+ MemoryStream innerStream = new MemoryStream();
+ LimitedStream sut = new LimitedStream(innerStream, 3);
+
+ sut.Write(new byte[5] { (byte)1, (byte)2, (byte)3, (byte)4, (byte)5 }, 2, 3);
+
+ byte[] actual3 = new byte[3];
+ innerStream.Seek(0, SeekOrigin.Begin);
+ innerStream.Read(actual3, 0, 3);
+
+ Assert.AreEqual((byte)3, actual3[0]);
+ Assert.AreEqual((byte)5, actual3[2]);
+ }
+
+ [TestMethod]
+ [ExpectedException(typeof(ArgumentOutOfRangeException))]
+ public void TestWriteAboveLimitWithByteLengthShorterThanCount()
+ {
+ MemoryStream innerStream = new MemoryStream();
+ LimitedStream sut = new LimitedStream(innerStream, 3);
+
+ sut.Write(new byte[5] { (byte)1, (byte)2, (byte)3, (byte)4, (byte)5 }, 1, 13);
+ }
+
+ [TestMethod]
+ public void TestCopyToWithinLimit()
+ {
+ MemoryStream innerStream = new MemoryStream();
+ LimitedStream sut = new LimitedStream(innerStream, 5);
+
+ MemoryStream sourceStream = new MemoryStream(new byte[5] { (byte)1, (byte)2, (byte)3, (byte)4, (byte)5 });
+
+ sourceStream.CopyTo(sut);
+
+ byte[] actual = new byte[5];
+ innerStream.Seek(0, SeekOrigin.Begin);
+ innerStream.Read(actual, 0, 5);
+
+ Assert.AreEqual((byte)1, actual[0]);
+ Assert.AreEqual((byte)5, actual[4]);
+ }
+
+ [TestMethod]
+ [ExpectedException(typeof(ArgumentOutOfRangeException))]
+ public void TestCopyToAboveLimit()
+ {
+ MemoryStream innerStream = new MemoryStream();
+ LimitedStream sut = new LimitedStream(innerStream, 3);
+
+ MemoryStream sourceStream = new MemoryStream(new byte[5] { (byte)1, (byte)2, (byte)3, (byte)4, (byte)5 });
+
+ sourceStream.CopyTo(sut);
+ }
+
+ [TestMethod]
+ public void TestCopyToAsyncAboveLimit()
+ {
+ MemoryStream innerStream = new MemoryStream();
+ LimitedStream sut = new LimitedStream(innerStream, 3);
+
+ MemoryStream sourceStream = new MemoryStream(new byte[5] { (byte)1, (byte)2, (byte)3, (byte)4, (byte)5 });
+
+ try
+ {
+ var t = sourceStream.CopyToAsync(sut);
+ t.Wait();
+ }
+ catch (AggregateException ae)
+ {
+ Assert.IsInstanceOfType(ae.InnerException, typeof(ArgumentOutOfRangeException));
+ }
+ }
+
+ }
+}
diff --git a/src/Spark.Engine.Test/Core/FhirModelTests.cs b/src/Spark.Engine.Test/Core/FhirModelTests.cs
new file mode 100644
index 000000000..8db9a7f5d
--- /dev/null
+++ b/src/Spark.Engine.Test/Core/FhirModelTests.cs
@@ -0,0 +1,29 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Spark.Engine.Core;
+using System.Linq;
+using Hl7.Fhir.Model;
+
+namespace Spark.Engine.Test.Core
+{
+ [TestClass]
+ public class FhirModelTests
+ {
+ private static FhirModel sut;
+
+ [ClassInitialize]
+ public static void ClassInitialize(TestContext testContext)
+ {
+ sut = new FhirModel();
+ }
+
+ [TestMethod]
+ public void TestCompartments()
+ {
+ var actual = sut.FindCompartmentInfo(ResourceType.Patient);
+
+ Assert.IsNotNull(actual);
+ Assert.IsTrue(actual.ReverseIncludes.Any());
+ }
+ }
+}
diff --git a/src/Spark.Engine.Test/Core/FhirPropertyIndexTests.cs b/src/Spark.Engine.Test/Core/FhirPropertyIndexTests.cs
index fe5099875..45e57ddd5 100644
--- a/src/Spark.Engine.Test/Core/FhirPropertyIndexTests.cs
+++ b/src/Spark.Engine.Test/Core/FhirPropertyIndexTests.cs
@@ -1,12 +1,8 @@
using Hl7.Fhir.Model;
using Microsoft.VisualStudio.TestTools.UnitTesting;
-using Moq;
using Spark.Engine.Core;
using System;
using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
namespace Spark.Engine.Test.Search
{
@@ -42,7 +38,7 @@ public void TestExistingPropertyIsFound()
[TestMethod]
public void TestTypedNameIsFound()
{
- var index = new FhirPropertyIndex(_fhirModel, new List { typeof(ClinicalImpression) });
+ var index = new FhirPropertyIndex(_fhirModel, new List { typeof(ClinicalImpression), typeof(CodeableConcept) });
var pm = index.findPropertyInfo("ClinicalImpression", "triggerCodeableConcept");
Assert.IsNotNull(pm);
diff --git a/src/Spark.Engine.Test/Core/ResourceVisitorTests.cs b/src/Spark.Engine.Test/Core/ResourceVisitorTests.cs
index 487f31efd..226e58a0e 100644
--- a/src/Spark.Engine.Test/Core/ResourceVisitorTests.cs
+++ b/src/Spark.Engine.Test/Core/ResourceVisitorTests.cs
@@ -172,7 +172,7 @@ public void TestVisitSinglePathWithPredicateAndFollowingProperty()
_actualActionCounter++;
if (ob.ToString() != "Sjimmie")
Assert.Fail();
- }, "name(given=Sjimmie).given");
+ }, "name[given=Sjimmie].given");
}
[TestMethod]
@@ -185,7 +185,7 @@ public void TestVisitSinglePathWithPredicate()
_actualActionCounter++;
Assert.IsInstanceOfType(ob, typeof(HumanName));
Assert.AreEqual("Sjimmie", (ob as HumanName).GivenElement.First().ToString());
- }, "name(given=Sjimmie)");
+ }, "name[given=Sjimmie]");
}
}
}
diff --git a/src/Spark.Engine.Test/Extensions/HttpRequestFhirExtensionsTests.cs b/src/Spark.Engine.Test/Extensions/HttpRequestFhirExtensionsTests.cs
new file mode 100644
index 000000000..068a33d4c
--- /dev/null
+++ b/src/Spark.Engine.Test/Extensions/HttpRequestFhirExtensionsTests.cs
@@ -0,0 +1,59 @@
+using Spark.Engine.Extensions;
+using System;
+using System.Net.Http;
+using Hl7.Fhir.Rest;
+using Spark.Engine.Utility;
+using System.Linq;
+using Xunit;
+
+namespace Spark.Engine.Test.Extensions
+{
+ public class HttpRequestFhirExtensionsTests
+ {
+ [Fact]
+ public void TestGetDateParameter()
+ {
+ //CK: apparently only works well if you escape at least the '+' sign at the start of the offset (by %2B) .
+ var httpRequest = new HttpRequestMessage(HttpMethod.Get, new Uri("http://spark.furore.com/fhir/Encounter/_history?_since=2017-01-01T00%3A00%3A00%2B01%3A00", UriKind.Absolute));
+ var expected = new DateTimeOffset(2017, 1, 1, 0, 0, 0, new TimeSpan(1, 0, 0));
+ var actual = FhirParameterParser.ParseDateParameter(httpRequest.GetParameter("_since"));
+ Assert.Equal(expected, actual);
+ }
+
+ [Theory]
+ [InlineData("http://example.org/fhir/Patient", SummaryType.False)] // Default is SummaryType.False
+ [InlineData("http://example.org/fhir/Patient?_summary=text", SummaryType.Text)] // _summary=text is SummaryType.Text
+ [InlineData("http://example.org/fhir/Patient?_summary=data", SummaryType.Data)] // _summary=data is SummaryType.Data
+ [InlineData("http://example.org/fhir/Patient?_summary=true", SummaryType.True)] // _summary=true is SummaryType.True
+ [InlineData("http://example.org/fhir/Patient?_summary=false", SummaryType.False)] // _summary=false is SummaryType.False
+ [InlineData("http://example.org/fhir/Patient?_summary=count", SummaryType.Count)] // _summary=count is SummaryType.Count
+ [InlineData("http://example.org/fhir/Patient?_summary=", SummaryType.False)] // _summary= is SummaryType.False
+ public void RequestSummary_SummaryTypeDefaultIsFalse(string url, SummaryType expected)
+ {
+ var request = new HttpRequestMessage(HttpMethod.Get, url);
+ var actual = request.RequestSummary();
+ Assert.Equal(expected, actual);
+ }
+
+ [Fact]
+ public void TupledParameters_WithMultipleIncludes()
+ {
+ var request = new HttpRequestMessage(HttpMethod.Get, "http://example.org/fhir/Patient?_include=A&_include=B");
+
+ var parameters = request.TupledParameters();
+
+ Assert.NotNull(parameters.FirstOrDefault(p => p.Equals(Tuple.Create("_include", "A"))));
+ Assert.NotNull(parameters.FirstOrDefault(p => p.Equals(Tuple.Create("_include", "B"))));
+ }
+
+ [Fact]
+ public void TupledParameters_MustPreserveComma()
+ {
+ var request = new HttpRequestMessage(HttpMethod.Get, "http://example.org/fhir/Patient?arg=A,B");
+
+ var parameters = request.TupledParameters();
+
+ Assert.NotNull(parameters.FirstOrDefault(p => p.Equals(Tuple.Create("arg", "A,B"))));
+ }
+ }
+}
diff --git a/src/Spark.Engine.Test/Extensions/OperationOutcomeExtensionsTests.cs b/src/Spark.Engine.Test/Extensions/OperationOutcomeExtensionsTests.cs
new file mode 100644
index 000000000..7c1d1d98a
--- /dev/null
+++ b/src/Spark.Engine.Test/Extensions/OperationOutcomeExtensionsTests.cs
@@ -0,0 +1,74 @@
+using Hl7.Fhir.Model;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Spark.Engine.Extensions;
+using System;
+
+namespace Spark.Engine.Test.Extensions
+{
+ [TestClass]
+ public class OperationOutcomeExtensionsTests
+ {
+ [TestMethod]
+ public void Three_Level_InnerErrors_Test()
+ {
+ OperationOutcome outcome;
+
+ try
+ {
+ try
+ {
+ try
+ {
+ throw new Exception("Third error level");
+ }
+ catch (Exception e3)
+ {
+ throw new Exception("Second error level", e3);
+ }
+ }
+ catch (Exception e2)
+ {
+ throw new Exception("First error level", e2);
+ }
+ }
+ catch (Exception e1)
+ {
+ outcome = new OperationOutcome().AddAllInnerErrors(e1);
+ }
+
+ Assert.IsTrue(outcome.Issue.FindIndex(i => i.Diagnostics.Equals("Exception: First error level")) == 0, "First error level should be at index 0");
+ Assert.IsTrue(outcome.Issue.FindIndex(i => i.Diagnostics.Equals("Exception: Second error level")) == 1, "Second error level should be at index 1");
+ Assert.IsTrue(outcome.Issue.FindIndex(i => i.Diagnostics.Equals("Exception: Third error level")) == 2, "Third error level should be at index 2");
+ }
+
+ [TestMethod]
+ public void IssueSeverity_Is_Information_When_HttpStatusCode_Is_Continue_Test()
+ {
+ Assert.AreEqual(OperationOutcome.IssueSeverity.Information, OperationOutcomeExtensions.IssueSeverityOf(System.Net.HttpStatusCode.Continue));
+ }
+
+ [TestMethod]
+ public void IssueSeverity_Is_Information_When_HttpStatusCode_Is_Created_Test()
+ {
+ Assert.AreEqual(OperationOutcome.IssueSeverity.Information, OperationOutcomeExtensions.IssueSeverityOf(System.Net.HttpStatusCode.Created));
+ }
+
+ [TestMethod]
+ public void IssueSeverity_Is_Warning_When_HttpStatusCode_Is_MovedPermanently_Test()
+ {
+ Assert.AreEqual(OperationOutcome.IssueSeverity.Warning, OperationOutcomeExtensions.IssueSeverityOf(System.Net.HttpStatusCode.MovedPermanently));
+ }
+
+ [TestMethod]
+ public void IssueSeverity_Is_Error_When_HttpStatusCode_Is_BadRequest_Test()
+ {
+ Assert.AreEqual(OperationOutcome.IssueSeverity.Error, OperationOutcomeExtensions.IssueSeverityOf(System.Net.HttpStatusCode.BadRequest));
+ }
+
+ [TestMethod]
+ public void IssueSeverity_Is_Fatal_When_HttpStatusCode_Is_InternalServerError_Test()
+ {
+ Assert.AreEqual(OperationOutcome.IssueSeverity.Fatal, OperationOutcomeExtensions.IssueSeverityOf(System.Net.HttpStatusCode.InternalServerError));
+ }
+ }
+}
diff --git a/src/Spark.Engine.Test/Extensions/RegexExtensionsTests.cs b/src/Spark.Engine.Test/Extensions/RegexExtensionsTests.cs
new file mode 100644
index 000000000..63868b841
--- /dev/null
+++ b/src/Spark.Engine.Test/Extensions/RegexExtensionsTests.cs
@@ -0,0 +1,45 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Text.RegularExpressions;
+using Spark.Engine.Extensions;
+
+namespace Spark.Engine.Test.Extensions
+{
+ [TestClass]
+ public class RegexExtensionsTests
+ {
+ public static Regex sut = new Regex(@"[^a]*(?a)[^a]*");
+
+ [TestMethod]
+ public void TestReplaceNamedGroupNoSuchGroup()
+ {
+ var input = @"bababa";
+ var result = sut.ReplaceGroup(input, "blabla", "c");
+ Assert.AreEqual(@"bababa", result);
+ }
+
+ [TestMethod]
+ public void TestReplaceNamedGroupNoCaptures()
+ {
+ var input = @"bbbbbb";
+ var result = sut.ReplaceGroup(input, "alpha", "c");
+ Assert.AreEqual(@"bbbbbb", result);
+ }
+
+ [TestMethod]
+ public void TestReplaceNamedGroupSingleCapture()
+ {
+ var input = @"babbbb";
+ var result = sut.ReplaceGroup(input, "alpha", "c");
+ Assert.AreEqual(@"bcbbbb", result);
+ }
+
+ [TestMethod]
+ public void TestReplaceNamedGroupMultipleCaptures()
+ {
+ var input = @"bababa";
+ var result = sut.ReplaceGroup(input, "alpha", "c");
+ Assert.AreEqual(@"bcbcbc", result);
+ }
+ }
+}
diff --git a/src/Spark.Engine.Test/Extensions/SearchParameterExtensionsTests.cs b/src/Spark.Engine.Test/Extensions/SearchParameterExtensionsTests.cs
index 0a33de392..43b40f5e6 100644
--- a/src/Spark.Engine.Test/Extensions/SearchParameterExtensionsTests.cs
+++ b/src/Spark.Engine.Test/Extensions/SearchParameterExtensionsTests.cs
@@ -5,6 +5,7 @@
using System.Collections.Generic;
using System.Linq;
using System.Text;
+using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace Spark.Engine.Test.Extensions
@@ -54,5 +55,34 @@ public void TestGetPropertyPathWithMultiplePath()
Assert.IsTrue(paths.Contains("participant.reference"));
Assert.IsTrue(paths.Contains("object.reference"));
}
+
+ [TestMethod]
+ public void TestSetPropertyPathWithPredicate()
+ {
+ SearchParameter sut = new SearchParameter();
+ sut.Base = ResourceType.Slot;
+ sut.SetPropertyPath(new string[] { "Slot.extension(url=http://foo.com/myextension).valueReference" });
+
+ Assert.AreEqual("//extension(url=http://foo.com/myextension)/valueReference", sut.Xpath);
+ }
+
+ [TestMethod]
+ public void TestGetPropertyPathWithPredicate()
+ {
+ SearchParameter sut = new SearchParameter();
+ sut.Xpath = "//extension(url=http://foo.com/myextension)/valueReference";
+
+ var paths = sut.GetPropertyPath();
+ Assert.AreEqual(1, paths.Count());
+ Assert.AreEqual(@"extension(url=http://foo.com/myextension).valueReference", paths[0]);
+ }
+
+ [TestMethod]
+ public void TestMatchExtension()
+ {
+ var input = "//extension(url=http://foo.com/myextension)/valueReference";
+ var result = SearchParameterExtensions.xpathPattern.Match(input).Value;
+ Assert.AreEqual(input, result);
+ }
}
}
diff --git a/src/Spark.Engine.Test/FhirVersion.cs b/src/Spark.Engine.Test/FhirVersion.cs
new file mode 100644
index 000000000..2b390d97d
--- /dev/null
+++ b/src/Spark.Engine.Test/FhirVersion.cs
@@ -0,0 +1,19 @@
+using Hl7.Fhir.Utility;
+using Spark.Engine.Test.Utility;
+
+namespace Spark.Engine.Test
+{
+ public enum FhirVersionMoniker
+ {
+ [EnumLiteral("")]
+ None = 0,
+ [EnumLiteral(FhirVersionUtility.VERSION_R2)]
+ R2 = 2,
+ [EnumLiteral(FhirVersionUtility.VERSION_R3)]
+ R3 = 3,
+ [EnumLiteral(FhirVersionUtility.VERSION_R4)]
+ R4 = 4,
+ [EnumLiteral(FhirVersionUtility.VERSION_R5)]
+ R5 = 5,
+ }
+}
\ No newline at end of file
diff --git a/src/Spark.Engine.Test/Formatters/FormatterTestBase.cs b/src/Spark.Engine.Test/Formatters/FormatterTestBase.cs
new file mode 100644
index 000000000..cc9e252a6
--- /dev/null
+++ b/src/Spark.Engine.Test/Formatters/FormatterTestBase.cs
@@ -0,0 +1,51 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.Formatters;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
+using System;
+using System.IO;
+
+namespace Spark.Engine.Test.Formatters
+{
+ public class FormatterTestBase
+ {
+ protected string GetResourceFromFileAsString(string path)
+ {
+ using TextReader reader = new StreamReader(path);
+ return reader.ReadToEnd();
+ }
+
+ protected static HttpContext GetHttpContext(
+ byte[] contentBytes,
+ string contentType)
+ {
+ return GetHttpContext(new MemoryStream(contentBytes), contentType);
+ }
+
+ protected static HttpContext GetHttpContext(Stream requestStream, string contentType)
+ {
+ var httpContext = new DefaultHttpContext();
+ httpContext.Request.Body = requestStream;
+ httpContext.Request.ContentType = contentType;
+
+ return httpContext;
+ }
+
+ protected static InputFormatterContext CreateInputFormatterContext(
+ Type modelType,
+ HttpContext httpContext,
+ string modelName = null,
+ bool treatEmptyInputAsDefaultValue = false)
+ {
+ var provider = new EmptyModelMetadataProvider();
+ var metadata = provider.GetMetadataForType(modelType);
+
+ return new InputFormatterContext(
+ httpContext,
+ modelName: modelName ?? string.Empty,
+ modelState: new ModelStateDictionary(),
+ metadata: metadata,
+ readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader,
+ treatEmptyInputAsDefaultValue: treatEmptyInputAsDefaultValue);
+ }
+ }
+}
diff --git a/src/Spark.Engine.Test/Formatters/NonSeekableReadStream.cs b/src/Spark.Engine.Test/Formatters/NonSeekableReadStream.cs
new file mode 100644
index 000000000..ac0ce1b0d
--- /dev/null
+++ b/src/Spark.Engine.Test/Formatters/NonSeekableReadStream.cs
@@ -0,0 +1,57 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Spark.Engine.Test.Formatters
+{
+ internal class NonSeekableReadStream : Stream
+ {
+ private Stream _inner;
+
+ public NonSeekableReadStream(byte[] data)
+ {
+ _inner = new MemoryStream(data);
+ }
+
+ public override bool CanRead => _inner.CanRead;
+
+ public override bool CanSeek => false;
+
+ public override bool CanWrite => false;
+
+ public override long Length => throw new NotSupportedException();
+
+ public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
+
+ public override void Flush()
+ {
+ throw new NotImplementedException();
+ }
+
+ public override int Read(byte[] buffer, int offset, int count)
+ {
+ return _inner.Read(buffer, offset, count);
+ }
+
+ public override long Seek(long offset, SeekOrigin origin)
+ {
+ throw new NotImplementedException();
+ }
+
+ public override void SetLength(long value)
+ {
+ throw new NotImplementedException();
+ }
+
+ public override void Write(byte[] buffer, int offset, int count)
+ {
+ throw new NotImplementedException();
+ }
+
+ public override Task ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+ {
+ return _inner.ReadAsync(buffer, offset, count, cancellationToken);
+ }
+ }
+}
diff --git a/src/Spark.Engine.Test/Formatters/ResourceJsonInputFormatterTests.cs b/src/Spark.Engine.Test/Formatters/ResourceJsonInputFormatterTests.cs
new file mode 100644
index 000000000..43790ddcd
--- /dev/null
+++ b/src/Spark.Engine.Test/Formatters/ResourceJsonInputFormatterTests.cs
@@ -0,0 +1,122 @@
+using Hl7.Fhir.Model;
+using Hl7.Fhir.Serialization;
+using Microsoft.AspNetCore.Http;
+using Spark.Engine.Core;
+using Spark.Engine.Formatters;
+using Spark.Engine.Test.Utility;
+using System.Buffers;
+using System.IO;
+using System.Net;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Spark.Engine.Test.Formatters
+{
+ public class ResourceJsonInputFormatterTests : FormatterTestBase
+ {
+ private const string DEFAULT_CONTENT_TYPE = "application/json";
+
+ [Theory]
+ [InlineData("application/fhir+json", true)]
+ [InlineData("application/json+fhir", true)]
+ [InlineData("application/json", true)]
+ [InlineData("application/*", false)]
+ [InlineData("*/*", false)]
+ [InlineData("text/json", true)]
+ [InlineData("text/*", false)]
+ [InlineData("text/xml", false)]
+ [InlineData("application/xml", false)]
+ [InlineData("application/some.entity+json", false)]
+ [InlineData("application/some.entity+json;v=2", false)]
+ [InlineData("application/some.entity+xml", false)]
+ [InlineData("application/some.entity+*", false)]
+ [InlineData("text/some.entity+json", false)]
+ [InlineData("", false)]
+ [InlineData(null, false)]
+ [InlineData("invalid", false)]
+ public void CanRead_ReturnsTrueForSupportedContent(string contentType, bool expectedCanRead)
+ {
+ var formatter = GetInputFormatter();
+
+ var contentBytes = Encoding.UTF8.GetBytes("{ \"resourceType\": \"Patient\", \"id\": \"example\", \"active\": true }");
+ var httpContext = GetHttpContext(contentBytes, contentType);
+
+ var formatterContext = CreateInputFormatterContext(typeof(Resource), httpContext);
+
+ var result = formatter.CanRead(formatterContext);
+
+ Assert.Equal(expectedCanRead, result);
+ }
+
+ [Fact]
+ public void SupportedMediaTypes_DefaultMediaType_ReturnsApplicationJson()
+ {
+ var formatter = GetInputFormatter();
+
+ var mediaType = formatter.SupportedMediaTypes[0];
+
+ Assert.Equal("application/json", mediaType.ToString());
+ }
+
+ [Fact]
+ public async Task ReadAsync_RequestBody_IsBuffered_And_IsSeekable()
+ {
+ var formatter = GetInputFormatter();
+
+ var fhirVersionMoniker = FhirVersionUtility.GetFhirVersionMoniker();
+ var content = GetResourceFromFileAsString(Path.Combine("TestData", fhirVersionMoniker.ToString(), "patient-example.json"));
+ var contentBytes = Encoding.UTF8.GetBytes(content);
+ var httpContext = new DefaultHttpContext();
+ httpContext.Request.ContentType = DEFAULT_CONTENT_TYPE;
+ httpContext.Request.Body = new NonSeekableReadStream(contentBytes);
+
+ var formatterContext = CreateInputFormatterContext(typeof(Resource), httpContext);
+
+ var result = await formatter.ReadAsync(formatterContext);
+
+ Assert.False(result.HasError);
+
+ var patient = Assert.IsType(result.Model);
+ Assert.Equal("example", patient.Id);
+ Assert.Equal(true, patient.Active);
+
+ Assert.True(httpContext.Request.Body.CanSeek);
+ httpContext.Request.Body.Seek(0L, SeekOrigin.Begin);
+
+ // Try again
+
+ result = await formatter.ReadAsync(formatterContext);
+
+ Assert.False(result.HasError);
+
+ patient = Assert.IsType(result.Model);
+ Assert.Equal("example", patient.Id);
+ Assert.Equal(true, patient.Active);
+ }
+
+ [Fact]
+ public async Task ReadAsync_ThrowsSparkException_BadRequest_OnNonUtf8Content()
+ {
+ var formatter = GetInputFormatter();
+
+ var content = "ɊɋɌɍɎɏ";
+ var contentBytes = Encoding.Unicode.GetBytes(content);
+
+ var httpContext = GetHttpContext(contentBytes, DEFAULT_CONTENT_TYPE);
+
+ var formatterContext = CreateInputFormatterContext(typeof(Resource), httpContext);
+
+ SparkException exception = await Assert.ThrowsAsync(() => formatter.ReadAsync(formatterContext));
+ Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode);
+ }
+
+ protected static ResourceJsonInputFormatter GetInputFormatter(ParserSettings parserSettings = null)
+ {
+ if (parserSettings == null) parserSettings = new ParserSettings { PermissiveParsing = false };
+ return new ResourceJsonInputFormatter(
+ new FhirJsonParser(parserSettings),
+ ArrayPool.Shared);
+ }
+ }
+}
diff --git a/src/Spark.Engine.Test/Formatters/ResourceXmlInputFormatterTests.cs b/src/Spark.Engine.Test/Formatters/ResourceXmlInputFormatterTests.cs
new file mode 100644
index 000000000..7b19e9a6c
--- /dev/null
+++ b/src/Spark.Engine.Test/Formatters/ResourceXmlInputFormatterTests.cs
@@ -0,0 +1,102 @@
+using Hl7.Fhir.Model;
+using Hl7.Fhir.Serialization;
+using Microsoft.AspNetCore.Http;
+using Spark.Engine.Formatters;
+using Spark.Engine.Test.Utility;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Spark.Engine.Test.Formatters
+{
+ public class ResourceXmlInputFormatterTests : FormatterTestBase
+ {
+ private const string DEFAULT_CONTENT_TYPE = "application/xml";
+
+ [Theory]
+ [InlineData("application/fhir+xml", true)]
+ [InlineData("application/xml+fhir", true)]
+ [InlineData("application/xml", true)]
+ [InlineData("application/*", false)]
+ [InlineData("*/*", false)]
+ [InlineData("text/xml", true)]
+ [InlineData("text/*", false)]
+ [InlineData("text/json", false)]
+ [InlineData("application/json", false)]
+ [InlineData("application/some.entity+xml", false)]
+ [InlineData("application/some.entity+xml;v=2", false)]
+ [InlineData("application/some.entity+json", false)]
+ [InlineData("application/some.entity+*", false)]
+ [InlineData("text/some.entity+xml", false)]
+ [InlineData("", false)]
+ [InlineData(null, false)]
+ [InlineData("invalid", false)]
+ public void CanRead_ReturnsTrueForSupportedContent(string contentType, bool expectedCanRead)
+ {
+ var formatter = GetInputFormatter();
+
+ var contentBytes = Encoding.UTF8.GetBytes("{ \"resourceType\": \"Patient\", \"id\": \"example\", \"active\": true }");
+ var httpContext = GetHttpContext(contentBytes, contentType);
+
+ var formatterContext = CreateInputFormatterContext(typeof(Resource), httpContext);
+
+ var result = formatter.CanRead(formatterContext);
+
+ Assert.Equal(expectedCanRead, result);
+ }
+
+ [Fact]
+ public void SupportedMediaTypes_DefaultMediaType_ReturnsApplicationJson()
+ {
+ var formatter = GetInputFormatter();
+
+ var mediaType = formatter.SupportedMediaTypes[0];
+
+ Assert.Equal("application/xml", mediaType.ToString());
+ }
+
+ [Fact]
+ public async Task ReadAsync_RequestBody_IsBuffered_And_IsSeekable()
+ {
+ var formatter = GetInputFormatter();
+
+ var fhirVersionMoniker = FhirVersionUtility.GetFhirVersionMoniker();
+ var content = GetResourceFromFileAsString(Path.Combine("TestData", fhirVersionMoniker.ToString(), "patient-example.xml"));
+ var contentBytes = Encoding.UTF8.GetBytes(content);
+ var httpContext = new DefaultHttpContext();
+ httpContext.Request.ContentType = DEFAULT_CONTENT_TYPE;
+ httpContext.Request.Body = new NonSeekableReadStream(contentBytes);
+
+ var formatterContext = CreateInputFormatterContext(typeof(Resource), httpContext);
+
+ var result = await formatter.ReadAsync(formatterContext);
+
+ Assert.False(result.HasError);
+
+ var patient = Assert.IsType(result.Model);
+ Assert.Equal("example", patient.Id);
+ Assert.Equal(true, patient.Active);
+
+ Assert.True(httpContext.Request.Body.CanSeek);
+ httpContext.Request.Body.Seek(0L, SeekOrigin.Begin);
+
+ // Try again
+
+ result = await formatter.ReadAsync(formatterContext);
+
+ Assert.False(result.HasError);
+
+ patient = Assert.IsType(result.Model);
+ Assert.Equal("example", patient.Id);
+ Assert.Equal(true, patient.Active);
+ }
+
+ protected static ResourceXmlInputFormatter GetInputFormatter(ParserSettings parserSettings = null)
+ {
+ if (parserSettings == null) parserSettings = new ParserSettings { PermissiveParsing = false };
+ return new ResourceXmlInputFormatter(
+ new FhirXmlParser(parserSettings));
+ }
+ }
+}
diff --git a/src/Spark.Engine.Test/Formatters/TestHttpRequestStreamReaderFactory.cs b/src/Spark.Engine.Test/Formatters/TestHttpRequestStreamReaderFactory.cs
new file mode 100644
index 000000000..4f7256c51
--- /dev/null
+++ b/src/Spark.Engine.Test/Formatters/TestHttpRequestStreamReaderFactory.cs
@@ -0,0 +1,15 @@
+using Microsoft.AspNetCore.Mvc.Infrastructure;
+using Microsoft.AspNetCore.WebUtilities;
+using System.IO;
+using System.Text;
+
+namespace Spark.Engine.Test.Formatters
+{
+ public class TestHttpRequestStreamReaderFactory : IHttpRequestStreamReaderFactory
+ {
+ public TextReader CreateReader(Stream stream, Encoding encoding)
+ {
+ return new HttpRequestStreamReader(stream, encoding);
+ }
+ }
+}
diff --git a/src/Spark.Engine.Test/Maintenance/MaintenanceModeTests.cs b/src/Spark.Engine.Test/Maintenance/MaintenanceModeTests.cs
new file mode 100644
index 000000000..7c9dc6bd7
--- /dev/null
+++ b/src/Spark.Engine.Test/Maintenance/MaintenanceModeTests.cs
@@ -0,0 +1,133 @@
+using Spark.Engine.Maintenance;
+using System.Linq;
+using System.Net;
+using Xunit;
+
+namespace Spark.Engine.Test.Maintenance
+{
+ public class MaintenanceModeTests
+ {
+ [Theory]
+ [MemberData(nameof(AllLockModes))]
+ internal void IsEnabled_Should_Return_False_If_Maintenance_Mode_Is_Not_Enabled(MaintenanceLockMode mode)
+ {
+ Assert.False(MaintenanceMode.IsEnabled(mode));
+ }
+
+ [Theory]
+ [MemberData(nameof(AllLockModes))]
+ internal void IsEnabled_Should_Not_Lock_If_Lock_None_Is_Provided(MaintenanceLockMode mode)
+ {
+ using (MaintenanceMode.Enable(MaintenanceLockMode.None))
+ {
+ Assert.False(MaintenanceMode.IsEnabled(mode));
+ }
+ }
+
+ [Fact]
+ internal void IsEnabled_Should_Not_Lock_Read_If_Write_Only_Mock_Mode_Is_Provided()
+ {
+ using (MaintenanceMode.Enable(MaintenanceLockMode.Write))
+ {
+ Assert.True(MaintenanceMode.IsEnabled(MaintenanceLockMode.None));
+ Assert.True(MaintenanceMode.IsEnabled(MaintenanceLockMode.Write));
+ Assert.False(MaintenanceMode.IsEnabled(MaintenanceLockMode.Full));
+ }
+ }
+
+ [Fact]
+ internal void IsEnabled_Full_Lock_Mode_Should_Lock_Read_And_Write()
+ {
+ using (MaintenanceMode.Enable(MaintenanceLockMode.Full))
+ {
+ Assert.True(MaintenanceMode.IsEnabled(MaintenanceLockMode.None));
+ Assert.True(MaintenanceMode.IsEnabled(MaintenanceLockMode.Write));
+ Assert.True(MaintenanceMode.IsEnabled(MaintenanceLockMode.Full));
+ }
+ }
+
+ [Theory]
+ [MemberData(nameof(ActualLockModes))]
+ internal void Should_Not_Allow_To_Lock_Twice(MaintenanceLockMode mode)
+ {
+ using (MaintenanceMode.Enable(mode))
+ {
+ var e = Assert.Throws(() => MaintenanceMode.Enable(mode));
+ Assert.Equal(HttpStatusCode.ServiceUnavailable, e.StatusCode);
+ }
+ }
+
+ [Theory]
+ [MemberData(nameof(AllHttpMethods))]
+ internal void IsEnabledForHttpMethod_Should_Return_False_If_Maintenance_Mode_Is_Not_Enabled(string method)
+ {
+ Assert.False(MaintenanceMode.IsEnabledForHttpMethod(method));
+ }
+
+ [Theory]
+ [MemberData(nameof(ReadHttpMethods))]
+ internal void IsEnabledForHttpMethod_Should_Return_False_For_Read_Methods_Write_Only_Lock(string method)
+ {
+ using (MaintenanceMode.Enable(MaintenanceLockMode.Write))
+ {
+ Assert.False(MaintenanceMode.IsEnabledForHttpMethod(method));
+ }
+ }
+
+ [Theory]
+ [MemberData(nameof(ReadHttpMethods))]
+ internal void IsEnabledForHttpMethod_Should_Return_True_For_Read_Methods_Full_Lock(string method)
+ {
+ using (MaintenanceMode.Enable(MaintenanceLockMode.Full))
+ {
+ Assert.True(MaintenanceMode.IsEnabledForHttpMethod(method));
+ }
+ }
+
+ [Theory]
+ [MemberData(nameof(WriteHttpMethods))]
+ internal void IsEnabledForHttpMethod_Should_Return_True_For_Update_Methods_Write_Only_Lock(string method)
+ {
+ using (MaintenanceMode.Enable(MaintenanceLockMode.Write))
+ {
+ Assert.True(MaintenanceMode.IsEnabledForHttpMethod(method));
+ }
+ }
+
+ [Theory]
+ [MemberData(nameof(WriteHttpMethods))]
+ internal void IsEnabledForHttpMethod_Should_Return_True_For_Update_Methods_Full_Lock(string method)
+ {
+ using (MaintenanceMode.Enable(MaintenanceLockMode.Full))
+ {
+ Assert.True(MaintenanceMode.IsEnabledForHttpMethod(method));
+ }
+ }
+
+ public static object[][] ReadHttpMethods => new[]
+ {
+ new object[] {"GET"},
+ new object[] {"HEAD"},
+ new object[] {"OPTIONS"}
+ };
+
+ public static object[][] WriteHttpMethods => new[]
+ {
+ new object[] {"POST"},
+ new object[] {"PUT"},
+ new object[] {"PATCH"},
+ new object[] {"DELETE"}
+ };
+
+ public static object[][] AllHttpMethods => ReadHttpMethods.Concat(WriteHttpMethods).ToArray();
+
+ public static object[][] AllLockModes => ((MaintenanceLockMode[])typeof(MaintenanceLockMode).GetEnumValues())
+ .Select(v => new object[] { v })
+ .ToArray();
+
+ public static object[][] ActualLockModes => ((MaintenanceLockMode[])typeof(MaintenanceLockMode).GetEnumValues())
+ .Where(m => m != MaintenanceLockMode.None)
+ .Select(v => new object[] { v })
+ .ToArray();
+ }
+}
diff --git a/src/Spark.Engine.Test/Search/CriteriumTests.cs b/src/Spark.Engine.Test/Search/CriteriumTests.cs
index bf6826e52..b2ce4297d 100644
--- a/src/Spark.Engine.Test/Search/CriteriumTests.cs
+++ b/src/Spark.Engine.Test/Search/CriteriumTests.cs
@@ -21,7 +21,8 @@ public class PortableCriteriumTests
public class CriteriumTests
#endif
{
- [TestMethod]
+#if DSTU1_ENABLED
+ [TestMethod]
public void ParseCriteriumDSTU1()
{
var crit = Criterium.Parse("paramX=18");
@@ -54,77 +55,96 @@ public void ParseCriteriumDSTU1()
Assert.IsNull(crit.Modifier);
Assert.AreEqual(Operator.NOTNULL, crit.Operator);
}
-
+#endif
///
/// In DSTU2, prefixes have changed from > to gt, < to lt etc.
///
[TestMethod]
public void ParseCriteriumDSTU2()
{
- var crit = Criterium.Parse("paramX=18");
- Assert.AreEqual("paramX", crit.ParamName);
+ var crit = Criterium.Parse("birthdate=2018-01-01");
+ Assert.AreEqual("birthdate", crit.ParamName);
Assert.IsNull(crit.Modifier);
- Assert.AreEqual("18", crit.Operand.ToString());
+ Assert.AreEqual("2018-01-01", crit.Operand.ToString());
Assert.AreEqual(Operator.EQ, crit.Operator);
- crit = Criterium.Parse("paramX=eq18");
- Assert.AreEqual("paramX", crit.ParamName);
+ crit = Criterium.Parse("birthdate=eq2018-01-01");
+ Assert.AreEqual("birthdate", crit.ParamName);
Assert.IsNull(crit.Modifier);
- Assert.AreEqual("18", crit.Operand.ToString());
+ Assert.AreEqual("2018-01-01", crit.Operand.ToString());
Assert.AreEqual(Operator.EQ, crit.Operator);
- crit = Criterium.Parse("paramX=ne18");
- Assert.AreEqual("paramX", crit.ParamName);
+ crit = Criterium.Parse("birthdate=ne2018-01-01");
+ Assert.AreEqual("birthdate", crit.ParamName);
Assert.IsNull(crit.Modifier);
- Assert.AreEqual("18", crit.Operand.ToString());
+ Assert.AreEqual("2018-01-01", crit.Operand.ToString());
Assert.AreEqual(Operator.NOT_EQUAL, crit.Operator);
- crit = Criterium.Parse("paramX=gt18");
- Assert.AreEqual("paramX", crit.ParamName);
+ crit = Criterium.Parse("birthdate=gt2018-01-01");
+ Assert.AreEqual("birthdate", crit.ParamName);
Assert.IsNull(crit.Modifier);
- Assert.AreEqual("18", crit.Operand.ToString());
+ Assert.AreEqual("2018-01-01", crit.Operand.ToString());
Assert.AreEqual(Operator.GT, crit.Operator);
- crit = Criterium.Parse("paramX=ge18");
- Assert.AreEqual("paramX", crit.ParamName);
+ crit = Criterium.Parse("birthdate=ge2018-01-01");
+ Assert.AreEqual("birthdate", crit.ParamName);
Assert.IsNull(crit.Modifier);
- Assert.AreEqual("18", crit.Operand.ToString());
+ Assert.AreEqual("2018-01-01", crit.Operand.ToString());
Assert.AreEqual(Operator.GTE, crit.Operator);
- crit = Criterium.Parse("paramX=lt18");
- Assert.AreEqual("paramX", crit.ParamName);
+ crit = Criterium.Parse("birthdate=lt2018-01-01");
+ Assert.AreEqual("birthdate", crit.ParamName);
Assert.IsNull(crit.Modifier);
- Assert.AreEqual("18", crit.Operand.ToString());
+ Assert.AreEqual("2018-01-01", crit.Operand.ToString());
Assert.AreEqual(Operator.LT, crit.Operator);
- crit = Criterium.Parse("paramX=le18");
- Assert.AreEqual("paramX", crit.ParamName);
+ crit = Criterium.Parse("birthdate=le2018-01-01");
+ Assert.AreEqual("birthdate", crit.ParamName);
Assert.IsNull(crit.Modifier);
- Assert.AreEqual("18", crit.Operand.ToString());
+ Assert.AreEqual("2018-01-01", crit.Operand.ToString());
Assert.AreEqual(Operator.LTE, crit.Operator);
- crit = Criterium.Parse("paramX:modif1=ap18");
- Assert.AreEqual("paramX", crit.ParamName);
- Assert.AreEqual("18", crit.Operand.ToString());
+ crit = Criterium.Parse("birthdate:modif1=ap2018-01-01");
+ Assert.AreEqual("birthdate", crit.ParamName);
+ Assert.AreEqual("2018-01-01", crit.Operand.ToString());
Assert.AreEqual("modif1", crit.Modifier);
Assert.AreEqual(Operator.APPROX, crit.Operator);
- crit = Criterium.Parse("paramX:missing=true");
- Assert.AreEqual("paramX", crit.ParamName);
+ crit = Criterium.Parse("birthdate:missing=true");
+ Assert.AreEqual("birthdate", crit.ParamName);
Assert.IsNull(crit.Operand);
Assert.IsNull(crit.Modifier);
Assert.AreEqual(Operator.ISNULL, crit.Operator);
- crit = Criterium.Parse("paramX:missing=false");
- Assert.AreEqual("paramX", crit.ParamName);
+ crit = Criterium.Parse("birthdate:missing=false");
+ Assert.AreEqual("birthdate", crit.ParamName);
Assert.IsNull(crit.Operand);
Assert.IsNull(crit.Modifier);
Assert.AreEqual(Operator.NOTNULL, crit.Operator);
}
-
-
-
- [TestMethod]
+
+ [TestMethod]
+ public void ParseComparatorOperatorForDate()
+ {
+ var criterium = Criterium.Parse("birthdate=lt2018-01-01");
+ Assert.AreEqual(Operator.LT, criterium.Operator);
+ }
+
+ [TestMethod]
+ public void ParseComparatorOperatorForQuantity()
+ {
+ var criterium = Criterium.Parse("value-quantity=le5.4|http://unitsofmeasure.org|mg");
+ Assert.AreEqual(Operator.LTE, criterium.Operator);
+ }
+
+ [TestMethod]
+ public void ParseComparatorOperatorForNumber()
+ {
+ var criterium = Criterium.Parse("length=gt20");
+ Assert.AreEqual(Operator.GT, criterium.Operator);
+ }
+
+ [TestMethod]
public void ParseChain()
{
var crit = Criterium.Parse("par1:type1.par2.par3:text=hoi");
@@ -411,35 +431,5 @@ public void HandleComposites()
Assert.AreEqual(14.8M, ((UntypedValue)comp1.Components[1]).AsNumberValue().Value);
Assert.AreEqual("http://somesuch.org|NOK", ((UntypedValue)crit1.Choices[1]).AsTokenValue().ToString());
}
-
- //[TestMethod]
- //public void HandleCombinedParam()
- //{
- // var p1 = new CombinedParamValue(new TokenParamValue("NOK"), new IntegerParamValue(18));
- // Assert.AreEqual("NOK$18", p1.QueryValue);
-
- // var p2 = CombinedParamValue.FromQueryValue("!NOK$>=18");
- // Assert.AreEqual(2, p2.Values.Count());
- // Assert.AreEqual("NOK", ((UntypedParamValue)p2.Values.First()).AsTokenParam().Value);
- // Assert.AreEqual(18, ((UntypedParamValue)p2.Values.Skip(1).First()).AsIntegerParam().Value);
- //}
-
- //[TestMethod]
- //public void ParseSearchParam()
- //{
- // var p1 = new SearchParam("dummy", "exact", new IntegerParamValue(ComparisonOperator.LTE,18),
- // new CombinedParamValue( new StringParamValue("ewout"), new ReferenceParamValue("patient","1")));
- // Assert.AreEqual("dummy:exact=<=18,\"ewout\"$patient/1", p1.QueryPair);
-
- // var p2 = new SearchParam("name", isMissing:true);
- // Assert.AreEqual("name:missing=true", p2.QueryPair);
-
- // var p3 = SearchParam.FromQueryKeyAndValue("dummy:exact", "<=18,\"ewout\"$patient/1");
- // Assert.AreEqual("dummy", p3.Name);
- // Assert.AreEqual("exact", p3.Modifier);
- // Assert.AreEqual(2, p3.Values.Count());
- // Assert.AreEqual(18, ((UntypedParamValue)p3.Values.First()).AsIntegerParam().Value);
- // Assert.AreEqual("\"ewout\"$patient/1", ((UntypedParamValue)p3.Values.Skip(1).First()).AsCombinedParam().QueryValue);
- //}
}
}
\ No newline at end of file
diff --git a/src/Spark.Engine.Test/Search/ElementIndexerTests.cs b/src/Spark.Engine.Test/Search/ElementIndexerTests.cs
index 3f1152a12..7dcc1c06e 100644
--- a/src/Spark.Engine.Test/Search/ElementIndexerTests.cs
+++ b/src/Spark.Engine.Test/Search/ElementIndexerTests.cs
@@ -1,14 +1,14 @@
using Hl7.Fhir.Model;
+using Microsoft.Practices.EnterpriseLibrary.SemanticLogging;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Spark.Engine.Core;
+using Spark.Engine.Logging;
using Spark.Engine.Model;
-using Spark.Engine.Search;
using Spark.Search;
using System;
using System.Collections.Generic;
+using System.Diagnostics.Tracing;
using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
namespace Spark.Engine.Search.Tests
{
@@ -16,11 +16,38 @@ namespace Spark.Engine.Search.Tests
public class ElementIndexerTests
{
private ElementIndexer sut;
+ private ObservableEventListener eventListener;
+ private EventEntry lastLogEntry;
+
+ private class LogObserver : IObserver
+ {
+ private Action _resultAction;
+ public LogObserver(Action resultAction )
+ {
+ _resultAction = resultAction;
+ }
+ public void OnCompleted()
+ {
+ }
+
+ public void OnError(Exception error)
+ {
+ }
+
+ public void OnNext(EventEntry value)
+ {
+ _resultAction(value);
+ }
+ }
[TestInitialize]
public void InitializeTest()
{
var fhirModel = new FhirModel();
+ eventListener = new ObservableEventListener();
+ eventListener.EnableEvents(SparkEngineEventSource.Log, EventLevel.LogAlways,
+ Keywords.All);
+ eventListener.Subscribe(new LogObserver(result => lastLogEntry = result));
sut = new ElementIndexer(fhirModel);
}
@@ -32,15 +59,13 @@ public void ElementIndexerTest()
}
[TestMethod()]
- [ExpectedException (typeof(NotImplementedException))]
public void ElementMapTest()
{
var input = new Annotation();
input.Text = "Text of the annotation";
var result = sut.Map(input);
- //Assert.AreEqual(1, result.Count);
- //Assert.IsInstanceOfType(result.First(), typeof(StringValue));
- //Assert.AreEqual(input.ToString(), ((StringValue)result.First()).Value);
+
+ Assert.AreEqual(2, lastLogEntry.EventId); //EventId 2 is related to Unsupported features.
}
[TestMethod()]
@@ -93,7 +118,7 @@ public void FhirDateTimeMapTest()
{
var input = new FhirDateTime(2015, 3, 14);
var result = sut.Map(input);
- CheckPeriod(result, "2015-03-14T00:00:00+01:00", "2015-03-15T00:00:00+01:00");
+ CheckPeriod(result, "2015-03-14T00:00:00+00:00", "2015-03-15T00:00:00+00:00");
}
[TestMethod()]
@@ -103,7 +128,7 @@ public void PeriodWithStartAndEndMapTest()
input.StartElement = new FhirDateTime("2015-02");
input.EndElement = new FhirDateTime("2015-03");
var result = sut.Map(input);
- CheckPeriod(result, "2015-02-01T00:00:00+01:00", "2015-04-01T00:00:00+01:00");
+ CheckPeriod(result, "2015-02-01T00:00:00+00:00", "2015-04-01T00:00:00+00:00");
}
[TestMethod()]
@@ -112,7 +137,7 @@ public void PeriodWithJustStartMapTest()
var input = new Period();
input.StartElement = new FhirDateTime("2015-02");
var result = sut.Map(input);
- CheckPeriod(result, "2015-02-01T00:00:00+01:00", null);
+ CheckPeriod(result, "2015-02-01T00:00:00+00:00", null);
}
[TestMethod()]
@@ -121,7 +146,7 @@ public void PeriodWithJustEndMapTest()
var input = new Period();
input.EndElement = new FhirDateTime("2015-03");
var result = sut.Map(input);
- CheckPeriod(result, null, "2015-04-01T00:00:00+01:00");
+ CheckPeriod(result, null, "2015-04-01T00:00:00+00:00");
}
[TestMethod()]
@@ -142,42 +167,29 @@ public void CodingMapTest()
private static void CheckCoding(CompositeValue comp, string code, string system, string text)
{
- var nrOfElements = new List { code, system, text }.Where(s => s != null).Count();
+ CheckCodingFlexible(comp, new Dictionary() { { "code", code }, { "system", system }, { "text", text } });
+ }
+
+ private static void CheckCodingFlexible(CompositeValue comp, Dictionary elements)
+ {
+ var elementsToCheck = elements.Where(e => e.Value != null);
+ var nrOfElements = elementsToCheck.Count();
Assert.AreEqual(nrOfElements, comp.Components.Count());
foreach (var c in comp.Components)
{
Assert.IsInstanceOfType(c, typeof(IndexValue));
}
- if (code != null)
- {
- var codeIV = (IndexValue)comp.Components.Where(c => (c as IndexValue).Name == "code").FirstOrDefault();
- Assert.IsNotNull(codeIV);
- Assert.AreEqual(1, codeIV.Values.Count());
- Assert.IsInstanceOfType(codeIV.Values[0], typeof(StringValue));
- var codeSV = (StringValue)codeIV.Values[0];
- Assert.AreEqual(code, codeSV.Value);
- }
-
- if (system != null)
+ foreach (var element in elementsToCheck)
{
- var systemIV = (IndexValue)comp.Components.Where(c => (c as IndexValue).Name == "system").FirstOrDefault();
- Assert.IsNotNull(systemIV);
- Assert.AreEqual(1, systemIV.Values.Count());
- Assert.IsInstanceOfType(systemIV.Values[0], typeof(StringValue));
- var systemSV = (StringValue)systemIV.Values[0];
- Assert.AreEqual(system, systemSV.Value);
+ var elementIV = (IndexValue)comp.Components.Where(c => (c as IndexValue).Name == element.Key).FirstOrDefault();
+ Assert.IsNotNull(elementIV, $"Expected a component '{element.Key}'");
+ Assert.AreEqual(1, elementIV.Values.Count(), $"Expected exactly one component '{element.Key}'");
+ Assert.IsInstanceOfType(elementIV.Values[0], typeof(StringValue), $"Expected component '{element.Key}' to be of type {nameof(StringValue)}");
+ var codeSV = (StringValue)elementIV.Values[0];
+ Assert.AreEqual(element.Value, codeSV.Value, $"Expected component '{element.Key}' to have the value '{element.Value}'");
}
- if (text != null)
- {
- var textIV = (IndexValue)comp.Components.Where(c => (c as IndexValue).Name == "text").FirstOrDefault();
- Assert.IsNotNull(textIV);
- Assert.AreEqual(1, textIV.Values.Count());
- Assert.IsInstanceOfType(textIV.Values[0], typeof(StringValue));
- var textSV = (StringValue)textIV.Values[0];
- Assert.AreEqual(text, textSV.Value);
- }
}
[TestMethod()]
@@ -202,7 +214,7 @@ public void CodeableConceptMapTest()
var result = sut.Map(input);
- Assert.AreEqual(2, result.Count()); //1 with text and 1 with the codings below it
+ Assert.AreEqual(3, result.Count()); //1 with text and 2 with the codings it
//Check wether CodeableConcept.Text is in the result.
var textIVs = result.Where(c => c.GetType() == typeof(IndexValue) && (c as IndexValue).Name == "text").ToList();
@@ -214,11 +226,7 @@ public void CodeableConceptMapTest()
Assert.AreEqual("bla text", (textIV.Values[0] as StringValue).Value);
//Check wether both codings are in the result.
- var codingIVs = result.Where(c => c.GetType() == typeof(IndexValue) && (c as IndexValue).Name == "coding").ToList();
- Assert.AreEqual(1, codingIVs.Count());
- var codingIV = (IndexValue)codingIVs.First();
-
- var codeIVs = codingIV.Values.Where(c => c.GetType() == typeof(CompositeValue)).ToList();
+ var codeIVs = result.Where(c => c.GetType() == typeof(CompositeValue)).ToList();
Assert.AreEqual(2, codeIVs.Count());
var codeIV1 = (CompositeValue)codeIVs[0];
@@ -264,7 +272,18 @@ public void ContactPointMapTest()
Assert.IsInstanceOfType(result[0], typeof(CompositeValue));
var comp = (CompositeValue)result[0];
- CheckCoding(comp, code: "cp-value", system: "Mobile", text: null);
+ var codeIV = (IndexValue)comp.Components.Where(c => (c as IndexValue).Name == "code").FirstOrDefault();
+ Assert.IsNotNull(codeIV, "Expected a component 'code'");
+ Assert.AreEqual(1, codeIV.Values.Count());
+ Assert.IsInstanceOfType(codeIV.Values[0], typeof(StringValue));
+ var codeSV = (StringValue)codeIV.Values[0];
+ Assert.AreEqual("cp-value", codeSV.Value);
+
+ var useIV = (IndexValue)comp.Components.Where(c => (c as IndexValue).Name == "use").FirstOrDefault();
+ Assert.IsNotNull(codeIV, "Expected a component 'use'");
+ var useCode = (CompositeValue)useIV.Values.Where(c => (c is CompositeValue)).FirstOrDefault();
+ Assert.IsNotNull(useCode, $"Expected a value of type {nameof(CompositeValue)} in the 'use' component");
+ CheckCoding(useCode, "mobile", null, null);
}
[TestMethod()]
@@ -278,7 +297,7 @@ public void FhirBooleanMapTest()
Assert.IsInstanceOfType(result[0], typeof(CompositeValue));
var comp = (CompositeValue)result[0];
- CheckCoding(comp, code: "False", system: null, text: null);
+ CheckCoding(comp, code: "false", system: null, text: null);
}
[TestMethod()]
@@ -420,12 +439,12 @@ public void QuantityValueSystemCodeMapTest()
{
var input = new Quantity();
input.Value = 10;
- input.System = "http://unitsofmeasure.org/";
+ input.System = "http://unitsofmeasure.org";
input.Code = "kg";
var result = sut.Map(input);
- CheckQuantity(result, value: 10000, unit: "g", system: "http://unitsofmeasure.org/", decimals: "gE4x1.0");
+ CheckQuantity(result, value: 10000, unit: "g", system: "http://unitsofmeasure.org", decimals: "gE04x1.0");
}
[TestMethod()]
@@ -449,9 +468,9 @@ public void CodedEnumMapTest()
var result = sut.Map(input);
Assert.AreEqual(1, result.Count());
- Assert.IsInstanceOfType(result[0], typeof(StringValue));
+ Assert.IsInstanceOfType(result[0], typeof(CompositeValue));
- Assert.AreEqual("male", (result[0] as StringValue).Value);
+ CheckCoding(result[0] as CompositeValue, "male", null, null);
}
[TestMethod()]
diff --git a/src/Spark.Engine.Test/Search/ReverseIncludeTests.cs b/src/Spark.Engine.Test/Search/ReverseIncludeTests.cs
new file mode 100644
index 000000000..ee46a137f
--- /dev/null
+++ b/src/Spark.Engine.Test/Search/ReverseIncludeTests.cs
@@ -0,0 +1,40 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Spark.Engine.Search.Model;
+
+namespace Spark.Engine.Test.Search
+{
+ [TestClass]
+ public class ReverseIncludeTests
+ {
+ [TestMethod]
+ public void TestParseValid()
+ {
+ ReverseInclude sut = ReverseInclude.Parse("Patient.actor");
+
+ Assert.AreEqual("Patient", sut.ResourceType);
+ Assert.AreEqual("actor", sut.SearchPath);
+ }
+ [TestMethod]
+ public void TestParseValidLongerPath()
+ {
+ ReverseInclude sut = ReverseInclude.Parse("Provenance.target.patient");
+
+ Assert.AreEqual("Provenance", sut.ResourceType);
+ Assert.AreEqual("target.patient", sut.SearchPath);
+ }
+ [TestMethod]
+ [ExpectedException(typeof(ArgumentNullException))]
+ public void TestParseNull()
+ {
+ ReverseInclude sut = ReverseInclude.Parse(null);
+ }
+
+ [TestMethod]
+ [ExpectedException(typeof(ArgumentException))]
+ public void TestParseInvalid()
+ {
+ ReverseInclude sut = ReverseInclude.Parse("bla;foo");
+ }
+ }
+}
diff --git a/src/Spark.Engine.Test/Service/IndexServiceTests.cs b/src/Spark.Engine.Test/Service/IndexServiceTests.cs
index aa0a6adc5..c76de39c7 100644
--- a/src/Spark.Engine.Test/Service/IndexServiceTests.cs
+++ b/src/Spark.Engine.Test/Service/IndexServiceTests.cs
@@ -1,25 +1,23 @@
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Hl7.Fhir.Model;
-using Spark.Engine.Service;
using Spark.Engine.Core;
using System.Collections.Generic;
using Spark.Engine.Search;
using Spark.Engine.Model;
using Spark.Search;
using static Hl7.Fhir.Model.ModelInfo;
-using Spark.Engine.Interfaces;
using Moq;
using Hl7.Fhir.Serialization;
using System.Linq;
+using Spark.Engine.Service.FhirServiceExtensions;
+using Spark.Engine.Store.Interfaces;
namespace Spark.Engine.Test.Service
{
[TestClass]
public class IndexServiceTests
{
-
-
private IndexService sutLimited;
private IndexService sutFull;
@@ -36,23 +34,22 @@ public void TestInitialize()
var spPatientName = new SearchParamDefinition() { Resource = "Patient", Name = "name", Description = @"A portion of either family or given name of the patient", Type = SearchParamType.String, Path = new string[] { "Patient.name", } };
var searchParameters = new List { spPatientName };
var resources = new Dictionary { { typeof(Patient), "Patient" }, { typeof(HumanName), "HumanName" } };
- var enums = new List();
//CK: I use real objects: saves me a lot of mocking and provides for a bit of integration testing.
- _fhirModel = new FhirModel(resources, searchParameters, enums);
+ _fhirModel = new FhirModel(resources, searchParameters);
_propIndex = new FhirPropertyIndex(_fhirModel, new List { typeof(Patient), typeof(HumanName) });
_resourceVisitor = new ResourceVisitor(_propIndex);
_elementIndexer = new ElementIndexer(_fhirModel);
//_indexStoreMock.Setup(ixs => ixs.Save(It.IsAny))
- sutLimited = new IndexService(_fhirModel, _propIndex, _resourceVisitor, _elementIndexer, _indexStoreMock.Object);
+ sutLimited = new IndexService(_fhirModel, _resourceVisitor, _elementIndexer, _indexStoreMock.Object);
_fhirModel = new FhirModel(); //For this test I want all available types and searchparameters.
_propIndex = new FhirPropertyIndex(_fhirModel);
_resourceVisitor = new ResourceVisitor(_propIndex);
_elementIndexer = new ElementIndexer(_fhirModel);
- sutFull = new IndexService(_fhirModel, _propIndex, _resourceVisitor, _elementIndexer, _indexStoreMock.Object);
+ sutFull = new IndexService(_fhirModel, _resourceVisitor, _elementIndexer, _indexStoreMock.Object);
}
[TestMethod]
@@ -66,9 +63,8 @@ public void TestIndexResourceSimple()
IndexValue result = sutLimited.IndexResource(patient, patientKey);
Assert.AreEqual("root", result.Name);
- Assert.AreEqual(5, result.Values.Count, "Expected 1 result for searchparameter 'name' and 4 for meta info");
- Assert.IsInstanceOfType(result.Values[0], typeof(IndexValue));
- var first = (IndexValue)result.Values[0];
+ Assert.AreEqual(1, result.NonInternalValues().Count(), "Expected 1 non-internal result for searchparameter 'name'");
+ var first = result.NonInternalValues().First();
Assert.AreEqual("name", first.Name);
Assert.AreEqual(2, first.Values.Count);
Assert.IsInstanceOfType(first.Values[0], typeof(StringValue));
@@ -78,7 +74,8 @@ public void TestIndexResourceSimple()
[TestMethod]
public void TestIndexResourcePatientComplete()
{
- var patientResource = FhirParser.ParseResourceFromJson(examplePatientJson);
+ FhirJsonParser parser = new FhirJsonParser();
+ var patientResource = parser.Parse(examplePatientJson);
IKey patientKey = new Key("http://localhost/", "Patient", "001", null);
@@ -90,7 +87,8 @@ public void TestIndexResourcePatientComplete()
[TestMethod]
public void TestIndexResourceAppointmentComplete()
{
- var appResource = FhirParser.ParseResourceFromJson(exampleAppointmentJson);
+ FhirJsonParser parser = new FhirJsonParser();
+ var appResource = parser.Parse(exampleAppointmentJson);
IKey appKey = new Key("http://localhost/", "Appointment", "2docs", null);
@@ -102,7 +100,8 @@ public void TestIndexResourceAppointmentComplete()
[TestMethod]
public void TestIndexResourceCareplanWithContainedGoal()
{
- var cpResource = FhirParser.ParseResourceFromJson(careplanWithContainedGoal);
+ FhirJsonParser parser = new FhirJsonParser();
+ var cpResource = parser.Parse(careplanWithContainedGoal);
IKey cpKey = new Key("http://localhost/", "Careplan", "f002", null);
@@ -115,7 +114,8 @@ public void TestIndexResourceCareplanWithContainedGoal()
[TestMethod]
public void TestIndexResourceObservation()
{
- var obsResource = FhirParser.ParseResourceFromJson(exampleObservationJson);
+ FhirJsonParser parser = new FhirJsonParser();
+ var obsResource = parser.Parse(exampleObservationJson);
IKey cpKey = new Key("http://localhost/", "Observation", "blood-pressure", null);
diff --git a/src/Spark.Engine.Test/Service/IndexValueTestExtensions.cs b/src/Spark.Engine.Test/Service/IndexValueTestExtensions.cs
new file mode 100644
index 000000000..a4669d01a
--- /dev/null
+++ b/src/Spark.Engine.Test/Service/IndexValueTestExtensions.cs
@@ -0,0 +1,14 @@
+using Spark.Engine.Model;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Spark.Engine.Test.Service
+{
+ public static class IndexValueTestExtensions
+ {
+ public static IEnumerable NonInternalValues(this IndexValue root)
+ {
+ return root.IndexValues().Where(v => !v.Name.StartsWith("internal_"));
+ }
+ }
+}
diff --git a/src/Spark.Engine.Test/Spark.Engine.Test.csproj b/src/Spark.Engine.Test/Spark.Engine.Test.csproj
index 735a8ae38..6370b9b2e 100644
--- a/src/Spark.Engine.Test/Spark.Engine.Test.csproj
+++ b/src/Spark.Engine.Test/Spark.Engine.Test.csproj
@@ -1,120 +1,35 @@
-
-
+
+
- Debug
- AnyCPU
- {5CA90A21-AC2E-4C30-B618-A459A1E5B04F}
- Library
- Properties
- Spark.Engine.Test
- Spark.Engine.Test
- v4.6
- 512
- {3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}
- 10.0
- $(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)
- $(ProgramFiles)\Common Files\microsoft shared\VSTT\$(VisualStudioVersion)\UITestExtensionPackages
- False
- UnitTest
-
+ netcoreapp3.1
+ false
-
- true
- full
- false
- bin\Debug\
- DEBUG;TRACE
- prompt
- 4
-
-
- pdbonly
- true
- bin\Release\
- TRACE
- prompt
- 4
-
-
-
- ..\..\packages\Fhir.Metrics.0.9.8\lib\net40\Fhir.Metrics.dll
- True
-
-
- ..\..\packages\Hl7.Fhir.DSTU2.0.90.5-alpha1\lib\net45\Hl7.Fhir.DSTU2.Core.dll
- True
-
-
- ..\..\packages\Moq.4.2.1510.2205\lib\net40\Moq.dll
- True
-
-
- ..\..\packages\Newtonsoft.Json.8.0.2\lib\net45\Newtonsoft.Json.dll
- True
-
-
-
-
-
-
-
-
-
-
-
-
- False
-
-
-
-
+
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+ all
+ runtime; build; native; contentfiles; analyzers; buildtransitive
+
+
-
-
+
+
-
- {426991a6-546c-43d5-b055-a38d0175824f}
- Spark.Engine
-
+
+ PreserveNewest
+
+
+ PreserveNewest
+
-
-
-
-
- False
-
-
- False
-
-
- False
-
-
- False
-
-
-
-
-
-
-
+
\ No newline at end of file
diff --git a/src/Spark.Engine.Test/TestData/R2/patient-example.json b/src/Spark.Engine.Test/TestData/R2/patient-example.json
new file mode 100644
index 000000000..f40ec03d0
--- /dev/null
+++ b/src/Spark.Engine.Test/TestData/R2/patient-example.json
@@ -0,0 +1,154 @@
+{
+ "resourceType": "Patient",
+ "id": "example",
+ "text": {
+ "status": "generated",
+ "div": "