diff --git a/hapi-fhir-client/src/main/java/ca/uhn/fhir/rest/client/impl/RestfulClientFactory.java b/hapi-fhir-client/src/main/java/ca/uhn/fhir/rest/client/impl/RestfulClientFactory.java index 3c0daa061b7..59f0054154e 100644 --- a/hapi-fhir-client/src/main/java/ca/uhn/fhir/rest/client/impl/RestfulClientFactory.java +++ b/hapi-fhir-client/src/main/java/ca/uhn/fhir/rest/client/impl/RestfulClientFactory.java @@ -330,6 +330,8 @@ public abstract class RestfulClientFactory implements IRestfulClientFactory { serverFhirVersionEnum = FhirVersionEnum.DSTU2_1; } else if (serverFhirVersionString.equals(FhirVersionEnum.DSTU3.getFhirVersionString())) { serverFhirVersionEnum = FhirVersionEnum.DSTU3; + } else if (serverFhirVersionString.equals(FhirVersionEnum.R4.getFhirVersionString())) { + serverFhirVersionEnum = FhirVersionEnum.R4; } else { // we'll be lenient and accept this ourLog.debug("Server conformance statement indicates unknown FHIR version: {}", serverFhirVersionString); diff --git a/hapi-fhir-structures-dstu2.1/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationDstu2_1Test.java b/hapi-fhir-structures-dstu2.1/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationDstu2_1Test.java new file mode 100644 index 00000000000..98bbae280fb --- /dev/null +++ b/hapi-fhir-structures-dstu2.1/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationDstu2_1Test.java @@ -0,0 +1,152 @@ +package ca.uhn.fhir.rest.client; + +import static org.hamcrest.Matchers.containsString; +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.io.InputStream; +import java.io.StringReader; +import java.nio.charset.Charset; + +import ca.uhn.fhir.context.FhirVersionEnum; +import ca.uhn.fhir.rest.api.Constants; +import ca.uhn.fhir.rest.client.api.IGenericClient; +import ca.uhn.fhir.rest.client.api.ServerValidationModeEnum; +import org.apache.commons.io.input.ReaderInputStream; +import org.apache.http.HttpResponse; +import org.apache.http.ProtocolVersion; +import org.apache.http.client.HttpClient; +import org.apache.http.client.methods.HttpUriRequest; +import org.apache.http.message.BasicHeader; +import org.apache.http.message.BasicStatusLine; +import org.hl7.fhir.dstu2016may.model.Conformance; +import org.hl7.fhir.dstu2016may.model.Patient; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Matchers; +import org.mockito.internal.stubbing.defaultanswers.ReturnsDeepStubs; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; + +import ca.uhn.fhir.context.FhirContext; +import ca.uhn.fhir.model.primitive.UriDt; +import ca.uhn.fhir.rest.client.exceptions.FhirClientInappropriateForServerException; +import ca.uhn.fhir.util.TestUtil; + +public class ClientServerValidationDstu2_1Test { + + private FhirContext myCtx; + private HttpClient myHttpClient; + private HttpResponse myHttpResponse; + private boolean myFirstResponse; + + @Before + public void before() { + myHttpClient = mock(HttpClient.class, new ReturnsDeepStubs()); + myHttpResponse = mock(HttpResponse.class, new ReturnsDeepStubs()); + myFirstResponse = true; + + myCtx = FhirContext.forDstu2_1(); + myCtx.getRestfulClientFactory().setHttpClient(myHttpClient); + } + + @Test + public void testServerReturnsAppropriateVersionDstu2_1() throws Exception { + String appropriateFhirVersion = "1.4.0"; + assertThat(appropriateFhirVersion, is(FhirVersionEnum.DSTU2_1.getFhirVersionString())); + Conformance conf = new Conformance(); + conf.setFhirVersion(appropriateFhirVersion); + final String confResource = myCtx.newXmlParser().encodeResourceToString(conf); + + ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); + + when(myHttpResponse.getStatusLine()).thenReturn(new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 200, "OK")); + when(myHttpResponse.getEntity().getContentType()).thenReturn(new BasicHeader("content-type", Constants.CT_FHIR_XML + "; charset=UTF-8")); + when(myHttpResponse.getEntity().getContent()).thenAnswer(new Answer() { + @Override + public InputStream answer(InvocationOnMock theInvocation) throws Throwable { + if (myFirstResponse) { + myFirstResponse=false; + return new ReaderInputStream(new StringReader(confResource), Charset.forName("UTF-8")); + } else { + return new ReaderInputStream(new StringReader(myCtx.newXmlParser().encodeResourceToString(new Patient())), Charset.forName("UTF-8")); + } + }}); + + when(myHttpClient.execute(capt.capture())).thenReturn(myHttpResponse); + + myCtx.getRestfulClientFactory().setServerValidationMode(ServerValidationModeEnum.ONCE); + IGenericClient client = myCtx.newRestfulGenericClient("http://foo"); + + // don't load the conformance until the first time the client is actually used + assertTrue(myFirstResponse); + client.read(new UriDt("http://foo/Patient/123")); + assertFalse(myFirstResponse); + myCtx.newRestfulGenericClient("http://foo").read(new UriDt("http://foo/Patient/123")); + myCtx.newRestfulGenericClient("http://foo").read(new UriDt("http://foo/Patient/123")); + + // Conformance only loaded once, then 3 reads + verify(myHttpClient, times(4)).execute(Matchers.any(HttpUriRequest.class)); + } + + @Test + public void testServerReturnsWrongVersionDstu2_1() throws Exception { + String wrongFhirVersion = "1.0.2"; + assertThat(wrongFhirVersion, is(FhirVersionEnum.DSTU2.getFhirVersionString())); + Conformance conf = new Conformance(); + conf.setFhirVersion(wrongFhirVersion); + String msg = myCtx.newXmlParser().encodeResourceToString(conf); + + ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); + + when(myHttpResponse.getStatusLine()).thenReturn(new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 200, "OK")); + when(myHttpResponse.getEntity().getContentType()).thenReturn(new BasicHeader("content-type", Constants.CT_FHIR_XML + "; charset=UTF-8")); + when(myHttpResponse.getEntity().getContent()).thenReturn(new ReaderInputStream(new StringReader(msg), Charset.forName("UTF-8"))); + + when(myHttpClient.execute(capt.capture())).thenReturn(myHttpResponse); + + myCtx.getRestfulClientFactory().setServerValidationMode(ServerValidationModeEnum.ONCE); + try { + myCtx.newRestfulGenericClient("http://foo").read(new UriDt("http://foo/Patient/1")); + fail(); + } catch (FhirClientInappropriateForServerException e) { + assertThat(e.toString(), containsString("The server at base URL \"http://foo/metadata\" returned a conformance statement indicating that it supports FHIR version \"1.0.2\" which corresponds to DSTU2, but this client is configured to use DSTU2_1 (via the FhirContext)")); + } + } + + @Test + public void testServerReturnsRightVersionDstu2_1() throws Exception { + String appropriateFhirVersion = "1.4.0"; + assertThat(appropriateFhirVersion, is(FhirVersionEnum.DSTU2_1.getFhirVersionString())); + Conformance conf = new Conformance(); + conf.setFhirVersion(appropriateFhirVersion); + String msg = myCtx.newXmlParser().encodeResourceToString(conf); + + ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); + + when(myHttpResponse.getStatusLine()).thenReturn(new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 200, "OK")); + when(myHttpResponse.getEntity().getContentType()).thenReturn(new BasicHeader("content-type", Constants.CT_FHIR_XML + "; charset=UTF-8")); + when(myHttpResponse.getEntity().getContent()).thenReturn(new ReaderInputStream(new StringReader(msg), Charset.forName("UTF-8"))); + + when(myHttpClient.execute(capt.capture())).thenReturn(myHttpResponse); + + myCtx.getRestfulClientFactory().setServerValidationMode(ServerValidationModeEnum.ONCE); + myCtx.newRestfulGenericClient("http://foo").forceConformanceCheck(); + } + + @AfterClass + public static void afterClassClearContext() { + TestUtil.clearAllStaticFieldsForUnitTest(); + } + +} + diff --git a/hapi-fhir-structures-dstu2/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationDstu2Test.java b/hapi-fhir-structures-dstu2/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationDstu2Test.java index 28491dbdb7b..6400f939e23 100644 --- a/hapi-fhir-structures-dstu2/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationDstu2Test.java +++ b/hapi-fhir-structures-dstu2/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationDstu2Test.java @@ -1,6 +1,7 @@ package ca.uhn.fhir.rest.client; import static org.hamcrest.Matchers.containsString; +import static org.hamcrest.Matchers.is; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; @@ -16,6 +17,7 @@ import java.io.InputStream; import java.io.StringReader; import java.nio.charset.Charset; +import ca.uhn.fhir.context.FhirVersionEnum; import org.apache.commons.io.input.ReaderInputStream; import org.apache.http.*; import org.apache.http.client.HttpClient; @@ -67,8 +69,10 @@ public class ClientServerValidationDstu2Test { @Test public void testClientUsesInterceptors() throws Exception { + String appropriateFhirVersion = "1.0.2"; + assertThat(appropriateFhirVersion, is(FhirVersionEnum.DSTU2.getFhirVersionString())); Conformance conf = new Conformance(); - conf.setFhirVersion("1.0.2"); + conf.setFhirVersion(appropriateFhirVersion); final String confResource = myCtx.newXmlParser().encodeResourceToString(conf); ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); @@ -109,8 +113,10 @@ public class ClientServerValidationDstu2Test { @Test public void testForceConformanceCheck() throws Exception { + String appropriateFhirVersion = "1.0.2"; + assertThat(appropriateFhirVersion, is(FhirVersionEnum.DSTU2.getFhirVersionString())); Conformance conf = new Conformance(); - conf.setFhirVersion("1.0.2"); + conf.setFhirVersion(appropriateFhirVersion); final String confResource = myCtx.newXmlParser().encodeResourceToString(conf); ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); @@ -178,46 +184,9 @@ public class ClientServerValidationDstu2Test { } } + // This test can should stay to test the leniency of accepting unknown FHIR versions from the server @Test - public void testServerReturnsAppropriateVersionForDstu2_040() throws Exception { - Conformance conf = new Conformance(); - conf.setFhirVersion("0.5.0"); - final String confResource = myCtx.newXmlParser().encodeResourceToString(conf); - - ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); - - when(myHttpResponse.getStatusLine()).thenReturn(new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 200, "OK")); - when(myHttpResponse.getEntity().getContentType()).thenReturn(new BasicHeader("content-type", Constants.CT_FHIR_XML + "; charset=UTF-8")); - when(myHttpResponse.getEntity().getContent()).thenAnswer(new Answer() { - @Override - public InputStream answer(InvocationOnMock theInvocation) throws Throwable { - if (myFirstResponse) { - myFirstResponse = false; - return new ReaderInputStream(new StringReader(confResource), Charset.forName("UTF-8")); - } else { - return new ReaderInputStream(new StringReader(myCtx.newXmlParser().encodeResourceToString(new Patient())), Charset.forName("UTF-8")); - } - } - }); - - when(myHttpClient.execute(capt.capture())).thenReturn(myHttpResponse); - - myCtx.getRestfulClientFactory().setServerValidationMode(ServerValidationModeEnum.ONCE); - IGenericClient client = myCtx.newRestfulGenericClient("http://foo"); - - // don't load the conformance until the first time the client is actually used - assertTrue(myFirstResponse); - client.read(new UriDt("http://foo/Patient/123")); - assertFalse(myFirstResponse); - myCtx.newRestfulGenericClient("http://foo").read(new UriDt("http://foo/Patient/123")); - myCtx.newRestfulGenericClient("http://foo").read(new UriDt("http://foo/Patient/123")); - - // Conformance only loaded once, then 3 reads - verify(myHttpClient, times(4)).execute(Matchers.any(HttpUriRequest.class)); - } - - @Test - public void testServerReturnsAppropriateVersionForDstu2_050() throws Exception { + public void testServerReturnsAppropriateVersionForUnknownVersion() throws Exception { Conformance conf = new Conformance(); conf.setFhirVersion("0.5.0"); final String confResource = myCtx.newXmlParser().encodeResourceToString(conf); @@ -256,8 +225,10 @@ public class ClientServerValidationDstu2Test { @Test public void testServerReturnsAppropriateVersionForDstu2() throws Exception { + String appropriateFhirVersion = "1.0.2"; + assertThat(appropriateFhirVersion, is(FhirVersionEnum.DSTU2.getFhirVersionString())); Conformance conf = new Conformance(); - conf.setFhirVersion("1.0.2"); + conf.setFhirVersion(appropriateFhirVersion); final String confResource = myCtx.newXmlParser().encodeResourceToString(conf); ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); @@ -294,8 +265,10 @@ public class ClientServerValidationDstu2Test { @Test public void testServerReturnsWrongVersionForDstu2() throws Exception { + String wrongFhirVersion = "3.0.1"; + assertThat(wrongFhirVersion, is(FhirVersionEnum.DSTU3.getFhirVersionString())); // asserting that what we assume to be the DSTU3 FHIR version is still correct Conformance conf = new Conformance(); - conf.setFhirVersion("3.0.1"); + conf.setFhirVersion(wrongFhirVersion); String msg = myCtx.newXmlParser().encodeResourceToString(conf); ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); diff --git a/hapi-fhir-structures-dstu3/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationDstu3Test.java b/hapi-fhir-structures-dstu3/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationDstu3Test.java new file mode 100644 index 00000000000..cdb7a99c235 --- /dev/null +++ b/hapi-fhir-structures-dstu3/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationDstu3Test.java @@ -0,0 +1,150 @@ +package ca.uhn.fhir.rest.client; + +import static org.hamcrest.Matchers.containsString; +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.io.InputStream; +import java.io.StringReader; +import java.nio.charset.Charset; + +import ca.uhn.fhir.context.FhirVersionEnum; +import ca.uhn.fhir.rest.api.Constants; +import ca.uhn.fhir.rest.client.api.IGenericClient; +import ca.uhn.fhir.rest.client.api.ServerValidationModeEnum; +import org.apache.commons.io.input.ReaderInputStream; +import org.apache.http.HttpResponse; +import org.apache.http.ProtocolVersion; +import org.apache.http.client.HttpClient; +import org.apache.http.client.methods.HttpUriRequest; +import org.apache.http.message.BasicHeader; +import org.apache.http.message.BasicStatusLine; +import org.hl7.fhir.dstu3.model.CapabilityStatement; +import org.hl7.fhir.dstu3.model.Patient; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Matchers; +import org.mockito.internal.stubbing.defaultanswers.ReturnsDeepStubs; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; + +import ca.uhn.fhir.context.FhirContext; +import ca.uhn.fhir.model.primitive.UriDt; +import ca.uhn.fhir.rest.client.exceptions.FhirClientInappropriateForServerException; +import ca.uhn.fhir.util.TestUtil; + +public class ClientServerValidationDstu3Test { + + private FhirContext myCtx; + private HttpClient myHttpClient; + private HttpResponse myHttpResponse; + private boolean myFirstResponse; + + @Before + public void before() { + myHttpClient = mock(HttpClient.class, new ReturnsDeepStubs()); + myHttpResponse = mock(HttpResponse.class, new ReturnsDeepStubs()); + myFirstResponse = true; + + myCtx = FhirContext.forDstu3(); + myCtx.getRestfulClientFactory().setHttpClient(myHttpClient); + } + + @Test + public void testServerReturnsAppropriateVersionDstu3() throws Exception { + String appropriateFhirVersion = "3.0.1"; + assertThat(appropriateFhirVersion, is(FhirVersionEnum.DSTU3.getFhirVersionString())); + CapabilityStatement conf = new CapabilityStatement(); + conf.setFhirVersion(appropriateFhirVersion); + final String confResource = myCtx.newXmlParser().encodeResourceToString(conf); + + ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); + + when(myHttpResponse.getStatusLine()).thenReturn(new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 200, "OK")); + when(myHttpResponse.getEntity().getContentType()).thenReturn(new BasicHeader("content-type", Constants.CT_FHIR_XML_NEW + "; charset=UTF-8")); + when(myHttpResponse.getEntity().getContent()).thenAnswer(new Answer() { + @Override + public InputStream answer(InvocationOnMock theInvocation) throws Throwable { + if (myFirstResponse) { + myFirstResponse=false; + return new ReaderInputStream(new StringReader(confResource), Charset.forName("UTF-8")); + } else { + return new ReaderInputStream(new StringReader(myCtx.newXmlParser().encodeResourceToString(new Patient())), Charset.forName("UTF-8")); + } + }}); + + when(myHttpClient.execute(capt.capture())).thenReturn(myHttpResponse); + + myCtx.getRestfulClientFactory().setServerValidationMode(ServerValidationModeEnum.ONCE); + IGenericClient client = myCtx.newRestfulGenericClient("http://foo"); + + // don't load the conformance until the first time the client is actually used + assertTrue(myFirstResponse); + client.read(new UriDt("http://foo/Patient/123")); + assertFalse(myFirstResponse); + myCtx.newRestfulGenericClient("http://foo").read(new UriDt("http://foo/Patient/123")); + myCtx.newRestfulGenericClient("http://foo").read(new UriDt("http://foo/Patient/123")); + + // Conformance only loaded once, then 3 reads + verify(myHttpClient, times(4)).execute(Matchers.any(HttpUriRequest.class)); + } + + @Test + public void testServerReturnsWrongVersionDstu3() throws Exception { + String wrongFhirVersion = "1.0.2"; + assertThat(wrongFhirVersion, is(FhirVersionEnum.DSTU2.getFhirVersionString())); + CapabilityStatement conf = new CapabilityStatement(); + conf.setFhirVersion(wrongFhirVersion); + String msg = myCtx.newXmlParser().encodeResourceToString(conf); + + ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); + + when(myHttpResponse.getStatusLine()).thenReturn(new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 200, "OK")); + when(myHttpResponse.getEntity().getContentType()).thenReturn(new BasicHeader("content-type", Constants.CT_FHIR_XML_NEW + "; charset=UTF-8")); + when(myHttpResponse.getEntity().getContent()).thenReturn(new ReaderInputStream(new StringReader(msg), Charset.forName("UTF-8"))); + + when(myHttpClient.execute(capt.capture())).thenReturn(myHttpResponse); + + myCtx.getRestfulClientFactory().setServerValidationMode(ServerValidationModeEnum.ONCE); + try { + myCtx.newRestfulGenericClient("http://foo").read(new UriDt("http://foo/Patient/1")); + fail(); + } catch (FhirClientInappropriateForServerException e) { + assertThat(e.toString(), containsString("The server at base URL \"http://foo/metadata\" returned a conformance statement indicating that it supports FHIR version \"1.0.2\" which corresponds to DSTU2, but this client is configured to use DSTU3 (via the FhirContext)")); + } + } + + @Test + public void testServerReturnsRightVersionDstu3() throws Exception { + String appropriateFhirVersion = "3.0.1"; + assertThat(appropriateFhirVersion, is(FhirVersionEnum.DSTU3.getFhirVersionString())); + CapabilityStatement conf = new CapabilityStatement(); + conf.setFhirVersion(appropriateFhirVersion); + String msg = myCtx.newXmlParser().encodeResourceToString(conf); + + ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); + + when(myHttpResponse.getStatusLine()).thenReturn(new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 200, "OK")); + when(myHttpResponse.getEntity().getContentType()).thenReturn(new BasicHeader("content-type", Constants.CT_FHIR_XML_NEW + "; charset=UTF-8")); + when(myHttpResponse.getEntity().getContent()).thenReturn(new ReaderInputStream(new StringReader(msg), Charset.forName("UTF-8"))); + + when(myHttpClient.execute(capt.capture())).thenReturn(myHttpResponse); + + myCtx.getRestfulClientFactory().setServerValidationMode(ServerValidationModeEnum.ONCE); + myCtx.newRestfulGenericClient("http://foo").forceConformanceCheck(); + } + + @AfterClass + public static void afterClassClearContext() { + TestUtil.clearAllStaticFieldsForUnitTest(); + } +} diff --git a/hapi-fhir-structures-hl7org-dstu2/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationTestHl7OrgDstu2.java b/hapi-fhir-structures-hl7org-dstu2/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationTestHl7OrgDstu2.java index a6adbce2d2f..af793935302 100644 --- a/hapi-fhir-structures-hl7org-dstu2/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationTestHl7OrgDstu2.java +++ b/hapi-fhir-structures-hl7org-dstu2/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationTestHl7OrgDstu2.java @@ -1,6 +1,7 @@ package ca.uhn.fhir.rest.client; import static org.hamcrest.Matchers.containsString; +import static org.hamcrest.Matchers.is; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; @@ -14,6 +15,8 @@ import java.io.InputStream; import java.io.StringReader; import java.nio.charset.Charset; +import ca.uhn.fhir.context.FhirVersionEnum; +import ca.uhn.fhir.util.TestUtil; import org.apache.commons.io.input.ReaderInputStream; import org.apache.http.HttpResponse; import org.apache.http.ProtocolVersion; @@ -23,6 +26,7 @@ import org.apache.http.message.BasicHeader; import org.apache.http.message.BasicStatusLine; import org.hl7.fhir.instance.model.Conformance; import org.hl7.fhir.instance.model.Patient; +import org.junit.AfterClass; import org.junit.Before; import org.junit.Test; import org.mockito.ArgumentCaptor; @@ -39,8 +43,7 @@ import ca.uhn.fhir.rest.client.api.ServerValidationModeEnum; import ca.uhn.fhir.rest.client.exceptions.FhirClientInappropriateForServerException; public class ClientServerValidationTestHl7OrgDstu2 { - - private static final org.slf4j.Logger ourLog = org.slf4j.LoggerFactory.getLogger(ClientServerValidationTestHl7OrgDstu2.class); + private FhirContext myCtx; private HttpClient myHttpClient; private HttpResponse myHttpResponse; @@ -58,8 +61,10 @@ public class ClientServerValidationTestHl7OrgDstu2 { @Test public void testServerReturnsAppropriateVersionForDstu2() throws Exception { + String appropriateFhirVersion = "1.0.2"; + assertThat(appropriateFhirVersion, is(FhirVersionEnum.DSTU2_HL7ORG.getFhirVersionString())); Conformance conf = new Conformance(); - conf.setFhirVersion("1.0.2"); + conf.setFhirVersion(appropriateFhirVersion); final String confResource = myCtx.newXmlParser().encodeResourceToString(conf); ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); @@ -79,11 +84,11 @@ public class ClientServerValidationTestHl7OrgDstu2 { when(myHttpClient.execute(capt.capture())).thenReturn(myHttpResponse); - myCtx.getRestfulClientFactory().setServerValidationModeEnum(ServerValidationModeEnum.ONCE); + myCtx.getRestfulClientFactory().setServerValidationMode(ServerValidationModeEnum.ONCE); IGenericClient client = myCtx.newRestfulGenericClient("http://foo"); // don't load the conformance until the first time the client is actually used - assertTrue(myFirstResponse); + assertTrue(myFirstResponse); client.read(new UriDt("http://foo/Patient/123")); assertFalse(myFirstResponse); myCtx.newRestfulGenericClient("http://foo").read(new UriDt("http://foo/Patient/123")); @@ -95,8 +100,10 @@ public class ClientServerValidationTestHl7OrgDstu2 { @Test public void testServerReturnsWrongVersionForDstu2() throws Exception { + String wrongFhirVersion = "3.0.1"; + assertThat(wrongFhirVersion, is(FhirVersionEnum.DSTU3.getFhirVersionString())); // asserting that what we assume to be the DSTU3 FHIR version is still correct Conformance conf = new Conformance(); - conf.setFhirVersion("0.0.82"); + conf.setFhirVersion(wrongFhirVersion); String msg = myCtx.newXmlParser().encodeResourceToString(conf); ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); @@ -107,16 +114,37 @@ public class ClientServerValidationTestHl7OrgDstu2 { when(myHttpClient.execute(capt.capture())).thenReturn(myHttpResponse); - myCtx.getRestfulClientFactory().setServerValidationModeEnum(ServerValidationModeEnum.ONCE); + myCtx.getRestfulClientFactory().setServerValidationMode(ServerValidationModeEnum.ONCE); try { - myCtx.newRestfulGenericClient("http://foo").read(new UriDt("http://foo/Patient/123")); + myCtx.newRestfulGenericClient("http://foo").read(new UriDt("http://foo/Patient/1")); fail(); } catch (FhirClientInappropriateForServerException e) { - String out = e.toString(); - String want = "The server at base URL \"http://foo/metadata\" returned a conformance statement indicating that it supports FHIR version \"0.0.82\" which corresponds to DSTU1, but this client is configured to use DSTU2_HL7ORG (via the FhirContext)"; - ourLog.info(out); - ourLog.info(want); - assertThat(out, containsString(want)); + assertThat(e.toString(), containsString("The server at base URL \"http://foo/metadata\" returned a conformance statement indicating that it supports FHIR version \"3.0.1\" which corresponds to DSTU3, but this client is configured to use DSTU2_HL7ORG (via the FhirContext)")); } } + + @Test + public void testServerReturnsRightVersionForDstu2() throws Exception { + String appropriateFhirVersion = "1.0.2"; + assertThat(appropriateFhirVersion, is(FhirVersionEnum.DSTU2_HL7ORG.getFhirVersionString())); + Conformance conf = new Conformance(); + conf.setFhirVersion(appropriateFhirVersion); + String msg = myCtx.newXmlParser().encodeResourceToString(conf); + + ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); + + when(myHttpResponse.getStatusLine()).thenReturn(new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 200, "OK")); + when(myHttpResponse.getEntity().getContentType()).thenReturn(new BasicHeader("content-type", Constants.CT_FHIR_XML + "; charset=UTF-8")); + when(myHttpResponse.getEntity().getContent()).thenReturn(new ReaderInputStream(new StringReader(msg), Charset.forName("UTF-8"))); + + when(myHttpClient.execute(capt.capture())).thenReturn(myHttpResponse); + + myCtx.getRestfulClientFactory().setServerValidationMode(ServerValidationModeEnum.ONCE); + myCtx.newRestfulGenericClient("http://foo").forceConformanceCheck(); + } + + @AfterClass + public static void afterClassClearContext() { + TestUtil.clearAllStaticFieldsForUnitTest(); + } } diff --git a/hapi-fhir-structures-r4/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationDstu1Test.java b/hapi-fhir-structures-r4/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationR4Test.java similarity index 76% rename from hapi-fhir-structures-r4/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationDstu1Test.java rename to hapi-fhir-structures-r4/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationR4Test.java index 850f90b70cc..e0d0561932d 100644 --- a/hapi-fhir-structures-r4/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationDstu1Test.java +++ b/hapi-fhir-structures-r4/src/test/java/ca/uhn/fhir/rest/client/ClientServerValidationR4Test.java @@ -1,13 +1,21 @@ package ca.uhn.fhir.rest.client; import static org.hamcrest.Matchers.containsString; -import static org.junit.Assert.*; -import static org.mockito.Mockito.*; +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; import java.io.InputStream; import java.io.StringReader; import java.nio.charset.Charset; +import ca.uhn.fhir.context.FhirVersionEnum; import org.apache.commons.io.input.ReaderInputStream; import org.apache.http.HttpResponse; import org.apache.http.ProtocolVersion; @@ -32,7 +40,7 @@ import ca.uhn.fhir.rest.client.api.ServerValidationModeEnum; import ca.uhn.fhir.rest.client.exceptions.FhirClientInappropriateForServerException; import ca.uhn.fhir.util.TestUtil; -public class ClientServerValidationDstu1Test { +public class ClientServerValidationR4Test { private FhirContext myCtx; private HttpClient myHttpClient; @@ -50,15 +58,17 @@ public class ClientServerValidationDstu1Test { } @Test - public void testServerReturnsAppropriateVersionDstu() throws Exception { + public void testServerReturnsAppropriateVersionR4() throws Exception { + String appropriateFhirVersion = "3.1.0"; + assertThat(appropriateFhirVersion, is(FhirVersionEnum.R4.getFhirVersionString())); CapabilityStatement conf = new CapabilityStatement(); - conf.setFhirVersion("0.0.8"); + conf.setFhirVersion(appropriateFhirVersion); final String confResource = myCtx.newXmlParser().encodeResourceToString(conf); ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); when(myHttpResponse.getStatusLine()).thenReturn(new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 200, "OK")); - when(myHttpResponse.getEntity().getContentType()).thenReturn(new BasicHeader("content-type", Constants.CT_FHIR_XML + "; charset=UTF-8")); + when(myHttpResponse.getEntity().getContentType()).thenReturn(new BasicHeader("content-type", Constants.CT_FHIR_XML_NEW + "; charset=UTF-8")); when(myHttpResponse.getEntity().getContent()).thenAnswer(new Answer() { @Override public InputStream answer(InvocationOnMock theInvocation) throws Throwable { @@ -87,16 +97,17 @@ public class ClientServerValidationDstu1Test { } @Test - @Ignore - public void testServerReturnsWrongVersionDstu() throws Exception { + public void testServerReturnsWrongVersionR4() throws Exception { + String wrongFhirVersion = "3.0.1"; + assertThat(wrongFhirVersion, is(FhirVersionEnum.DSTU3.getFhirVersionString())); // asserting that what we assume to be the DSTU3 FHIR version is still correct CapabilityStatement conf = new CapabilityStatement(); - conf.setFhirVersion("0.4.0"); + conf.setFhirVersion(wrongFhirVersion); String msg = myCtx.newXmlParser().encodeResourceToString(conf); ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); when(myHttpResponse.getStatusLine()).thenReturn(new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 200, "OK")); - when(myHttpResponse.getEntity().getContentType()).thenReturn(new BasicHeader("content-type", Constants.CT_FHIR_XML + "; charset=UTF-8")); + when(myHttpResponse.getEntity().getContentType()).thenReturn(new BasicHeader("content-type", Constants.CT_FHIR_XML_NEW + "; charset=UTF-8")); when(myHttpResponse.getEntity().getContent()).thenReturn(new ReaderInputStream(new StringReader(msg), Charset.forName("UTF-8"))); when(myHttpClient.execute(capt.capture())).thenReturn(myHttpResponse); @@ -106,20 +117,22 @@ public class ClientServerValidationDstu1Test { myCtx.newRestfulGenericClient("http://foo").read(new UriDt("http://foo/Patient/1")); fail(); } catch (FhirClientInappropriateForServerException e) { - assertThat(e.toString(), containsString("The server at base URL \"http://foo/metadata\" returned a conformance statement indicating that it supports FHIR version \"0.4.0\" which corresponds to DSTU2, but this client is configured to use R4 (via the FhirContext)")); + assertThat(e.toString(), containsString("The server at base URL \"http://foo/metadata\" returned a conformance statement indicating that it supports FHIR version \"3.0.1\" which corresponds to DSTU3, but this client is configured to use R4 (via the FhirContext)")); } } @Test - public void testServerReturnsRightVersionDstu() throws Exception { + public void testServerReturnsRightVersionR4() throws Exception { + String appropriateFhirVersion = "3.1.0"; + assertThat(appropriateFhirVersion, is(FhirVersionEnum.R4.getFhirVersionString())); CapabilityStatement conf = new CapabilityStatement(); - conf.setFhirVersion("3.1.0"); + conf.setFhirVersion(appropriateFhirVersion); String msg = myCtx.newXmlParser().encodeResourceToString(conf); ArgumentCaptor capt = ArgumentCaptor.forClass(HttpUriRequest.class); when(myHttpResponse.getStatusLine()).thenReturn(new BasicStatusLine(new ProtocolVersion("HTTP", 1, 1), 200, "OK")); - when(myHttpResponse.getEntity().getContentType()).thenReturn(new BasicHeader("content-type", Constants.CT_FHIR_XML + "; charset=UTF-8")); + when(myHttpResponse.getEntity().getContentType()).thenReturn(new BasicHeader("content-type", Constants.CT_FHIR_XML_NEW + "; charset=UTF-8")); when(myHttpResponse.getEntity().getContent()).thenReturn(new ReaderInputStream(new StringReader(msg), Charset.forName("UTF-8"))); when(myHttpClient.execute(capt.capture())).thenReturn(myHttpResponse);