honeymoose
/
hapi-fhir
mirror of https://github.com/hapifhir/hapi-fhir.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Make cache timeout configurable

This commit is contained in:
James Agnew 2019-10-15 09:34:48 -04:00
parent 48e2960c71
commit 9a050461a8
6 changed files with 214 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/annotation/Metadata.java
View File

@ -36,5 +36,7 @@ import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME) @Retention(RetentionPolicy.RUNTIME)
@Target(value=ElementType.METHOD) @Target(value=ElementType.METHOD)
public @interface Metadata { public @interface Metadata {
// nothing for now
long cacheMillis() default 60 * 1000L;
} }

6
hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/provider/r4/ResourceProviderR4Test.java
View File

@ -2669,15 +2669,11 @@ public class ResourceProviderR4Test extends BaseResourceProviderR4Test {
@Test @Test
public void testMetadata() throws Exception { public void testMetadata() throws Exception {
HttpGet get = new HttpGet(ourServerBase + "/metadata"); HttpGet get = new HttpGet(ourServerBase + "/metadata");
CloseableHttpResponse response = ourHttpClient.execute(get); try (CloseableHttpResponse response = ourHttpClient.execute(get)) {
try {
String resp = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8); String resp = IOUtils.toString(response.getEntity().getContent(), StandardCharsets.UTF_8);
ourLog.info(resp); ourLog.info(resp);
assertEquals(200, response.getStatusLine().getStatusCode()); assertEquals(200, response.getStatusLine().getStatusCode());
assertThat(resp, stringContainsInOrder("THIS IS THE DESC")); assertThat(resp, stringContainsInOrder("THIS IS THE DESC"));
} finally {
response.getEntity().getContent().close();
response.close();
} }
} }

64
hapi-fhir-server/src/main/java/ca/uhn/fhir/rest/server/method/ConformanceMethodBinding.java
View File

@ -20,22 +20,14 @@ package ca.uhn.fhir.rest.server.method;
* #L% * #L%
*/ */
import java.lang.reflect.Method;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;
import ca.uhn.fhir.interceptor.api.HookParams;
import ca.uhn.fhir.interceptor.api.Pointcut;
import ca.uhn.fhir.rest.api.CacheControlDirective;
import ca.uhn.fhir.rest.api.Constants;
import ca.uhn.fhir.rest.server.interceptor.IServerInterceptor;
import ca.uhn.fhir.rest.server.servlet.ServletRequestDetails;
import org.hl7.fhir.instance.model.api.IBaseConformance;
import org.hl7.fhir.instance.model.api.IBaseResource;
import ca.uhn.fhir.context.ConfigurationException; import ca.uhn.fhir.context.ConfigurationException;
import ca.uhn.fhir.context.FhirContext; import ca.uhn.fhir.context.FhirContext;
import ca.uhn.fhir.interceptor.api.HookParams;
import ca.uhn.fhir.interceptor.api.Pointcut;
import ca.uhn.fhir.model.valueset.BundleTypeEnum; import ca.uhn.fhir.model.valueset.BundleTypeEnum;
import ca.uhn.fhir.rest.annotation.Metadata;
import ca.uhn.fhir.rest.api.CacheControlDirective;
import ca.uhn.fhir.rest.api.Constants;
import ca.uhn.fhir.rest.api.RequestTypeEnum; import ca.uhn.fhir.rest.api.RequestTypeEnum;
import ca.uhn.fhir.rest.api.RestOperationTypeEnum; import ca.uhn.fhir.rest.api.RestOperationTypeEnum;
import ca.uhn.fhir.rest.api.server.IBundleProvider; import ca.uhn.fhir.rest.api.server.IBundleProvider;
@ -44,12 +36,17 @@ import ca.uhn.fhir.rest.api.server.RequestDetails;
import ca.uhn.fhir.rest.server.SimpleBundleProvider; import ca.uhn.fhir.rest.server.SimpleBundleProvider;
import ca.uhn.fhir.rest.server.exceptions.BaseServerResponseException; import ca.uhn.fhir.rest.server.exceptions.BaseServerResponseException;
import ca.uhn.fhir.rest.server.exceptions.MethodNotAllowedException; import ca.uhn.fhir.rest.server.exceptions.MethodNotAllowedException;
import ca.uhn.fhir.rest.server.interceptor.IServerInterceptor;
import ca.uhn.fhir.rest.server.servlet.ServletRequestDetails;
import org.hl7.fhir.instance.model.api.IBaseConformance;
import org.hl7.fhir.instance.model.api.IBaseResource;
import javax.annotation.Nonnull; import javax.annotation.Nonnull;
import java.lang.reflect.Method;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;
public class ConformanceMethodBinding extends BaseResourceReturningMethodBinding { public class ConformanceMethodBinding extends BaseResourceReturningMethodBinding {
private static final long CACHE_MILLIS = 60 * 1000;
/* /*
* Note: This caching mechanism should probably be configurable and maybe * Note: This caching mechanism should probably be configurable and maybe
* even applicable to other bindings. It's particularly important for this * even applicable to other bindings. It's particularly important for this
@ -57,7 +54,7 @@ public class ConformanceMethodBinding extends BaseResourceReturningMethodBinding
*/ */
private final AtomicReference<IBaseResource> myCachedResponse = new AtomicReference<>(); private final AtomicReference<IBaseResource> myCachedResponse = new AtomicReference<>();
private final AtomicLong myCachedResponseExpires = new AtomicLong(0L); private final AtomicLong myCachedResponseExpires = new AtomicLong(0L);
private long myCacheMillis = 60 * 1000;
ConformanceMethodBinding(Method theMethod, FhirContext theContext, Object theProvider) { ConformanceMethodBinding(Method theMethod, FhirContext theContext, Object theProvider) {
super(theMethod.getReturnType(), theMethod, theContext, theProvider); super(theMethod.getReturnType(), theMethod, theContext, theProvider);
@ -68,6 +65,35 @@ public class ConformanceMethodBinding extends BaseResourceReturningMethodBinding
throw new ConfigurationException("Conformance resource provider method '" + theMethod.getName() + "' should return a Conformance resource class, returns: " + theMethod.getReturnType()); throw new ConfigurationException("Conformance resource provider method '" + theMethod.getName() + "' should return a Conformance resource class, returns: " + theMethod.getReturnType());
} }
Metadata metadata = theMethod.getAnnotation(Metadata.class);
if (metadata != null) {
setCacheMillis(metadata.cacheMillis());
}
}
/**
* Returns the number of milliseconds to cache the generated CapabilityStatement for. Default is one minute, and can be
* set to 0 to never cache.
*
* @see #setCacheMillis(long)
* @see Metadata#cacheMillis()
* @since 4.1.0
*/
private long getCacheMillis() {
return myCacheMillis;
}
/**
* Returns the number of milliseconds to cache the generated CapabilityStatement for. Default is one minute, and can be
* set to 0 to never cache.
*
* @see #getCacheMillis()
* @see Metadata#cacheMillis()
* @since 4.1.0
*/
private void setCacheMillis(long theCacheMillis) {
myCacheMillis = theCacheMillis;
} }
@Override @Override
@ -116,8 +142,10 @@ public class ConformanceMethodBinding extends BaseResourceReturningMethodBinding
if (conf == null) { if (conf == null) {
conf = (IBaseResource) invokeServerMethod(theServer, theRequest, theMethodParams); conf = (IBaseResource) invokeServerMethod(theServer, theRequest, theMethodParams);
myCachedResponse.set(conf); if (myCacheMillis > 0) {
myCachedResponseExpires.set(System.currentTimeMillis() + CACHE_MILLIS); myCachedResponse.set(conf);
myCachedResponseExpires.set(System.currentTimeMillis() + getCacheMillis());
}
} }
return new SimpleBundleProvider(conf); return new SimpleBundleProvider(conf);

127
hapi-fhir-server/src/test/java/ca/uhn/fhir/rest/server/method/ConformanceMethodBindingTest.java
View File

@ -1,29 +1,18 @@
package ca.uhn.fhir.rest.server.method; package ca.uhn.fhir.rest.server.method;
import ca.uhn.fhir.context.FhirContext; import ca.uhn.fhir.context.FhirContext;
import ca.uhn.fhir.context.RuntimeResourceDefinition; import ca.uhn.fhir.rest.annotation.Metadata;
import ca.uhn.fhir.rest.annotation.OptionalParam;
import ca.uhn.fhir.rest.annotation.RequiredParam;
import ca.uhn.fhir.rest.annotation.Search;
import ca.uhn.fhir.rest.api.Constants; import ca.uhn.fhir.rest.api.Constants;
import ca.uhn.fhir.rest.api.server.IBundleProvider;
import ca.uhn.fhir.rest.api.server.IRestfulServer; import ca.uhn.fhir.rest.api.server.IRestfulServer;
import ca.uhn.fhir.rest.api.server.RequestDetails; import ca.uhn.fhir.rest.api.server.RequestDetails;
import ca.uhn.fhir.rest.server.IResourceProvider;
import ca.uhn.fhir.rest.server.util.BaseServerCapabilityStatementProvider;
import com.google.common.collect.Lists; import com.google.common.collect.Lists;
import org.hl7.fhir.instance.model.api.IBaseConformance; import org.hl7.fhir.instance.model.api.IBaseConformance;
import org.hl7.fhir.instance.model.api.IBaseMetaType;
import org.hl7.fhir.instance.model.api.IBaseResource;
import org.hl7.fhir.instance.model.api.IIdType;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method; import java.lang.reflect.Method;
import java.util.Arrays;
import static org.junit.Assert.*;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*; import static org.mockito.Mockito.*;
@ -31,40 +20,130 @@ public class ConformanceMethodBindingTest {
private FhirContext fhirContext; private FhirContext fhirContext;
private ConformanceMethodBinding conformanceMethodBinding; private ConformanceMethodBinding conformanceMethodBinding;
private TestResourceProvider dummy;
@Before @Before
public void setUp() throws NoSuchMethodException { public void setUp() {
fhirContext = mock(FhirContext.class); fhirContext = mock(FhirContext.class);
dummy = spy(new TestResourceProvider()); }
Method method = dummy.getClass().getDeclaredMethod("getServerConformance", HttpServletRequest.class, RequestDetails.class);
conformanceMethodBinding = new ConformanceMethodBinding(method, fhirContext, dummy);
private <T> T init(T theCapabilityStatementProvider) throws NoSuchMethodException {
T provider = spy(theCapabilityStatementProvider);
Method method = provider.getClass().getDeclaredMethod("getServerConformance", HttpServletRequest.class, RequestDetails.class);
conformanceMethodBinding = new ConformanceMethodBinding(method, fhirContext, provider);
return provider;
} }
@Test @Test
public void invokeServerCached() { public void invokeServerCached() throws NoSuchMethodException {
TestResourceProvider provider = init(new TestResourceProvider());
conformanceMethodBinding.invokeServer(mock(IRestfulServer.class, RETURNS_DEEP_STUBS), mock(RequestDetails.class, RETURNS_DEEP_STUBS), new Object[]{mock(HttpServletRequest.class), mock(RequestDetails.class)}); conformanceMethodBinding.invokeServer(mock(IRestfulServer.class, RETURNS_DEEP_STUBS), mock(RequestDetails.class, RETURNS_DEEP_STUBS), new Object[]{mock(HttpServletRequest.class), mock(RequestDetails.class)});
verify(dummy, times(1)).getServerConformance(any(), any()); verify(provider, times(1)).getServerConformance(any(), any());
conformanceMethodBinding.invokeServer(mock(IRestfulServer.class, RETURNS_DEEP_STUBS), mock(RequestDetails.class, RETURNS_DEEP_STUBS), new Object[]{mock(HttpServletRequest.class), mock(RequestDetails.class)}); conformanceMethodBinding.invokeServer(mock(IRestfulServer.class, RETURNS_DEEP_STUBS), mock(RequestDetails.class, RETURNS_DEEP_STUBS), new Object[]{mock(HttpServletRequest.class), mock(RequestDetails.class)});
verify(dummy, times(1)).getServerConformance(any(), any()); verify(provider, times(1)).getServerConformance(any(), any());
} }
@Test @Test
public void invokeServerNotCached_ClientControlled() { public void invokeServerCacheExpires() throws NoSuchMethodException {
TestResourceProviderSmallCache provider = init(new TestResourceProviderSmallCache());
conformanceMethodBinding.invokeServer(mock(IRestfulServer.class, RETURNS_DEEP_STUBS), mock(RequestDetails.class, RETURNS_DEEP_STUBS), new Object[]{mock(HttpServletRequest.class), mock(RequestDetails.class)});
verify(provider, times(1)).getServerConformance(any(), any());
sleepAtLeast(20);
conformanceMethodBinding.invokeServer(mock(IRestfulServer.class, RETURNS_DEEP_STUBS), mock(RequestDetails.class, RETURNS_DEEP_STUBS), new Object[]{mock(HttpServletRequest.class), mock(RequestDetails.class)});
verify(provider, times(2)).getServerConformance(any(), any());
}
@Test
public void invokeServerCacheDisabled() throws NoSuchMethodException {
TestResourceProviderNoCache provider = init(new TestResourceProviderNoCache());
conformanceMethodBinding.invokeServer(mock(IRestfulServer.class, RETURNS_DEEP_STUBS), mock(RequestDetails.class, RETURNS_DEEP_STUBS), new Object[]{mock(HttpServletRequest.class), mock(RequestDetails.class)});
verify(provider, times(1)).getServerConformance(any(), any());
conformanceMethodBinding.invokeServer(mock(IRestfulServer.class, RETURNS_DEEP_STUBS), mock(RequestDetails.class, RETURNS_DEEP_STUBS), new Object[]{mock(HttpServletRequest.class), mock(RequestDetails.class)});
verify(provider, times(2)).getServerConformance(any(), any());
}
@Test
public void invokeServerCacheDisabledInSuperclass() throws NoSuchMethodException {
TestResourceProviderNoCache2 provider = init(new TestResourceProviderNoCache2());
conformanceMethodBinding.invokeServer(mock(IRestfulServer.class, RETURNS_DEEP_STUBS), mock(RequestDetails.class, RETURNS_DEEP_STUBS), new Object[]{mock(HttpServletRequest.class), mock(RequestDetails.class)});
verify(provider, times(1)).getServerConformance(any(), any());
// We currently don't scan the annotation on the superclass...Perhaps we should
conformanceMethodBinding.invokeServer(mock(IRestfulServer.class, RETURNS_DEEP_STUBS), mock(RequestDetails.class, RETURNS_DEEP_STUBS), new Object[]{mock(HttpServletRequest.class), mock(RequestDetails.class)});
verify(provider, times(1)).getServerConformance(any(), any());
}
@Test
public void invokeServerNotCached_ClientControlled() throws NoSuchMethodException {
TestResourceProvider provider = init(new TestResourceProvider());
RequestDetails requestDetails = mock(RequestDetails.class, RETURNS_DEEP_STUBS); RequestDetails requestDetails = mock(RequestDetails.class, RETURNS_DEEP_STUBS);
when(requestDetails.getHeaders(Constants.HEADER_CACHE_CONTROL)).thenReturn(Lists.newArrayList(Constants.CACHE_CONTROL_NO_CACHE)); when(requestDetails.getHeaders(Constants.HEADER_CACHE_CONTROL)).thenReturn(Lists.newArrayList(Constants.CACHE_CONTROL_NO_CACHE));
conformanceMethodBinding.invokeServer(mock(IRestfulServer.class, RETURNS_DEEP_STUBS), requestDetails, new Object[]{mock(HttpServletRequest.class), mock(RequestDetails.class)}); conformanceMethodBinding.invokeServer(mock(IRestfulServer.class, RETURNS_DEEP_STUBS), requestDetails, new Object[]{mock(HttpServletRequest.class), mock(RequestDetails.class)});
verify(dummy, times(1)).getServerConformance(any(), any()); verify(provider, times(1)).getServerConformance(any(), any());
conformanceMethodBinding.invokeServer(mock(IRestfulServer.class, RETURNS_DEEP_STUBS), requestDetails, new Object[]{mock(HttpServletRequest.class), mock(RequestDetails.class)}); conformanceMethodBinding.invokeServer(mock(IRestfulServer.class, RETURNS_DEEP_STUBS), requestDetails, new Object[]{mock(HttpServletRequest.class), mock(RequestDetails.class)});
verify(dummy, times(2)).getServerConformance(any(), any()); verify(provider, times(2)).getServerConformance(any(), any());
} }
class TestResourceProvider { @SuppressWarnings("unused")
static class TestResourceProvider {
@Metadata
public IBaseConformance getServerConformance(HttpServletRequest theRequest, RequestDetails theRequestDetails) { public IBaseConformance getServerConformance(HttpServletRequest theRequest, RequestDetails theRequestDetails) {
return mock(IBaseConformance.class, RETURNS_DEEP_STUBS); return mock(IBaseConformance.class, RETURNS_DEEP_STUBS);
} }
} }
@SuppressWarnings("unused")
static class TestResourceProviderSmallCache {
@Metadata(cacheMillis = 10)
public IBaseConformance getServerConformance(HttpServletRequest theRequest, RequestDetails theRequestDetails) {
return mock(IBaseConformance.class, RETURNS_DEEP_STUBS);
}
}
@SuppressWarnings("unused")
static class TestResourceProviderNoCache {
@Metadata(cacheMillis = 0)
public IBaseConformance getServerConformance(HttpServletRequest theRequest, RequestDetails theRequestDetails) {
return mock(IBaseConformance.class, RETURNS_DEEP_STUBS);
}
}
@SuppressWarnings("unused")
static class TestResourceProviderNoCache2 extends TestResourceProviderNoCache {
// No @Metadata
@Override
public IBaseConformance getServerConformance(HttpServletRequest theRequest, RequestDetails theRequestDetails) {
return mock(IBaseConformance.class, RETURNS_DEEP_STUBS);
}
}
private static void sleepAtLeast(long theMillis) {
long start = System.currentTimeMillis();
while (System.currentTimeMillis() <= start + theMillis) {
try {
long timeSinceStarted = System.currentTimeMillis() - start;
long timeToSleep = Math.max(0, theMillis - timeSinceStarted);
Thread.sleep(timeToSleep);
} catch (InterruptedException theE) {
// ignore
}
}
}
} }

123
hapi-fhir-structures-dstu3/src/test/java/ca/uhn/fhir/rest/server/MetadataConformanceDstu3Test.java
View File

@ -1,21 +1,19 @@
package ca.uhn.fhir.rest.server; package ca.uhn.fhir.rest.server;
import static org.hamcrest.Matchers.containsString; import ca.uhn.fhir.context.FhirContext;
import static org.hamcrest.Matchers.not; import ca.uhn.fhir.context.FhirVersionEnum;
import static org.hamcrest.Matchers.stringContainsInOrder; import ca.uhn.fhir.rest.annotation.OptionalParam;
import static org.junit.Assert.assertEquals; import ca.uhn.fhir.rest.annotation.ResourceParam;
import static org.junit.Assert.assertThat; import ca.uhn.fhir.rest.annotation.Search;
import ca.uhn.fhir.rest.annotation.Validate;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.TimeUnit;
import ca.uhn.fhir.rest.api.EncodingEnum; import ca.uhn.fhir.rest.api.EncodingEnum;
import ca.uhn.fhir.rest.api.MethodOutcome;
import ca.uhn.fhir.rest.param.StringParam;
import ca.uhn.fhir.test.utilities.JettyUtil;
import ca.uhn.fhir.util.TestUtil;
import ca.uhn.fhir.util.VersionUtil;
import org.apache.commons.io.IOUtils; import org.apache.commons.io.IOUtils;
import org.apache.http.client.methods.CloseableHttpResponse; import org.apache.http.client.methods.*;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.impl.client.CloseableHttpClient; import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager; import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
@ -28,28 +26,23 @@ import org.junit.AfterClass;
import org.junit.BeforeClass; import org.junit.BeforeClass;
import org.junit.Test; import org.junit.Test;
import ca.uhn.fhir.context.FhirContext; import java.nio.charset.StandardCharsets;
import ca.uhn.fhir.context.FhirVersionEnum; import java.util.List;
import ca.uhn.fhir.rest.annotation.OptionalParam; import java.util.concurrent.TimeUnit;
import ca.uhn.fhir.rest.annotation.ResourceParam;
import ca.uhn.fhir.rest.annotation.Search; import static org.hamcrest.Matchers.*;
import ca.uhn.fhir.rest.annotation.Validate; import static org.junit.Assert.assertEquals;
import ca.uhn.fhir.rest.api.MethodOutcome; import static org.junit.Assert.assertThat;
import ca.uhn.fhir.rest.param.StringParam;
import ca.uhn.fhir.test.utilities.JettyUtil;
import ca.uhn.fhir.util.TestUtil;
import ca.uhn.fhir.util.VersionUtil;
public class MetadataConformanceDstu3Test { public class MetadataConformanceDstu3Test {
private static final org.slf4j.Logger ourLog = org.slf4j.LoggerFactory.getLogger(MetadataConformanceDstu3Test.class);
private static CloseableHttpClient ourClient; private static CloseableHttpClient ourClient;
private static FhirContext ourCtx = FhirContext.forDstu3(); private static FhirContext ourCtx = FhirContext.forDstu3();
private static int ourPort; private static int ourPort;
private static Server ourServer; private static Server ourServer;
private static RestfulServer ourServlet; private static RestfulServer ourServlet;
private static final org.slf4j.Logger ourLog = org.slf4j.LoggerFactory.getLogger(MetadataConformanceDstu3Test.class);
@Test @Test
public void testSummary() throws Exception { public void testSummary() throws Exception {
String output; String output;
@ -61,7 +54,7 @@ public class MetadataConformanceDstu3Test {
output = IOUtils.toString(status.getEntity().getContent(), StandardCharsets.UTF_8); output = IOUtils.toString(status.getEntity().getContent(), StandardCharsets.UTF_8);
assertEquals(200, status.getStatusLine().getStatusCode()); assertEquals(200, status.getStatusLine().getStatusCode());
ourLog.info(output); ourLog.info(output);
assertThat(output, containsString("<CapabilityStatement")); assertThat(output, containsString("<CapabilityStatement"));
assertThat(output, stringContainsInOrder("<meta>", "SUBSETTED", "</meta>")); assertThat(output, stringContainsInOrder("<meta>", "SUBSETTED", "</meta>"));
assertThat(output, not(stringContainsInOrder("searchParam"))); assertThat(output, not(stringContainsInOrder("searchParam")));
} finally { } finally {
@ -75,7 +68,7 @@ public class MetadataConformanceDstu3Test {
output = IOUtils.toString(status.getEntity().getContent(), StandardCharsets.UTF_8); output = IOUtils.toString(status.getEntity().getContent(), StandardCharsets.UTF_8);
assertEquals(200, status.getStatusLine().getStatusCode()); assertEquals(200, status.getStatusLine().getStatusCode());
ourLog.info(output); ourLog.info(output);
assertThat(output, containsString("<CapabilityStatement")); assertThat(output, containsString("<CapabilityStatement"));
assertThat(output, not(stringContainsInOrder("<meta>", "SUBSETTED", "</meta>"))); assertThat(output, not(stringContainsInOrder("<meta>", "SUBSETTED", "</meta>")));
assertThat(output, stringContainsInOrder("searchParam")); assertThat(output, stringContainsInOrder("searchParam"));
} finally { } finally {
@ -104,38 +97,55 @@ public class MetadataConformanceDstu3Test {
public void testHttpMethods() throws Exception { public void testHttpMethods() throws Exception {
String output; String output;
HttpRequestBase httpPost = new HttpGet("http://localhost:" + ourPort + "/metadata"); HttpRequestBase httpOperation = new HttpGet("http://localhost:" + ourPort + "/metadata");
CloseableHttpResponse status = ourClient.execute(httpPost); try (CloseableHttpResponse status = ourClient.execute(httpOperation)) {
try {
output = IOUtils.toString(status.getEntity().getContent(), StandardCharsets.UTF_8); output = IOUtils.toString(status.getEntity().getContent(), StandardCharsets.UTF_8);
assertEquals(200, status.getStatusLine().getStatusCode()); assertEquals(200, status.getStatusLine().getStatusCode());
assertThat(output, containsString("<CapabilityStatement")); assertThat(output, containsString("<CapabilityStatement"));
assertEquals("HAPI FHIR " + VersionUtil.getVersion() + " REST Server (FHIR Server; FHIR " + FhirVersionEnum.DSTU3.getFhirVersionString() + "/DSTU3)", status.getFirstHeader("X-Powered-By").getValue()); assertEquals("HAPI FHIR " + VersionUtil.getVersion() + " REST Server (FHIR Server; FHIR " + FhirVersionEnum.DSTU3.getFhirVersionString() + "/DSTU3)", status.getFirstHeader("X-Powered-By").getValue());
} finally {
IOUtils.closeQuietly(status.getEntity().getContent());
} }
try { httpOperation = new HttpOptions("http://localhost:" + ourPort);
httpPost = new HttpPost("http://localhost:" + ourPort + "/metadata"); try (CloseableHttpResponse status = ourClient.execute(httpOperation)) {
status = ourClient.execute(httpPost); output = IOUtils.toString(status.getEntity().getContent(), StandardCharsets.UTF_8);
assertEquals(200, status.getStatusLine().getStatusCode());
assertThat(output, containsString("<CapabilityStatement"));
assertEquals("HAPI FHIR " + VersionUtil.getVersion() + " REST Server (FHIR Server; FHIR " + FhirVersionEnum.DSTU3.getFhirVersionString() + "/DSTU3)", status.getFirstHeader("X-Powered-By").getValue());
}
httpOperation = new HttpPost("http://localhost:" + ourPort + "/metadata");
try (CloseableHttpResponse status = ourClient.execute(httpOperation)) {
output = IOUtils.toString(status.getEntity().getContent(), StandardCharsets.UTF_8); output = IOUtils.toString(status.getEntity().getContent(), StandardCharsets.UTF_8);
assertEquals(405, status.getStatusLine().getStatusCode()); assertEquals(405, status.getStatusLine().getStatusCode());
assertEquals("<OperationOutcome xmlns=\"http://hl7.org/fhir\"><issue><severity value=\"error\"/><code value=\"processing\"/><diagnostics value=\"/metadata request must use HTTP GET\"/></issue></OperationOutcome>", output); assertEquals("<OperationOutcome xmlns=\"http://hl7.org/fhir\"><issue><severity value=\"error\"/><code value=\"processing\"/><diagnostics value=\"/metadata request must use HTTP GET\"/></issue></OperationOutcome>", output);
} finally {
IOUtils.closeQuietly(status.getEntity().getContent());
} }
/* /*
* There is no @read on the RP below, so this should fail. Otherwise it * There is no @read on the RP below, so this should fail. Otherwise it
* would be interpreted as a read on ID "metadata" * would be interpreted as a read on ID "metadata"
*/ */
try { httpOperation = new HttpGet("http://localhost:" + ourPort + "/Patient/metadata");
httpPost = new HttpGet("http://localhost:" + ourPort + "/Patient/metadata"); try (CloseableHttpResponse status = ourClient.execute(httpOperation)) {
status = ourClient.execute(httpPost);
output = IOUtils.toString(status.getEntity().getContent(), StandardCharsets.UTF_8);
assertEquals(400, status.getStatusLine().getStatusCode()); assertEquals(400, status.getStatusLine().getStatusCode());
} finally { }
IOUtils.closeQuietly(status.getEntity().getContent()); }
@SuppressWarnings("unused")
public static class DummyPatientResourceProvider implements IResourceProvider {
@Override
public Class<Patient> getResourceType() {
return Patient.class;
}
@Search
public List<Patient> search(@OptionalParam(name = "foo") StringParam theFoo) {
throw new UnsupportedOperationException();
}
@Validate()
public MethodOutcome validate(@ResourceParam Patient theResource) {
return new MethodOutcome();
} }
} }
@ -160,7 +170,7 @@ public class MetadataConformanceDstu3Test {
proxyHandler.addServletWithMapping(servletHolder, "/*"); proxyHandler.addServletWithMapping(servletHolder, "/*");
ourServer.setHandler(proxyHandler); ourServer.setHandler(proxyHandler);
JettyUtil.startServer(ourServer); JettyUtil.startServer(ourServer);
ourPort = JettyUtil.getPortForStartedServer(ourServer); ourPort = JettyUtil.getPortForStartedServer(ourServer);
PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(5000, TimeUnit.MILLISECONDS); PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(5000, TimeUnit.MILLISECONDS);
HttpClientBuilder builder = HttpClientBuilder.create(); HttpClientBuilder builder = HttpClientBuilder.create();
@ -169,23 +179,4 @@ public class MetadataConformanceDstu3Test {
} }
@SuppressWarnings("unused")
public static class DummyPatientResourceProvider implements IResourceProvider {
@Override
public Class<Patient> getResourceType() {
return Patient.class;
}
@Search
public List<Patient> search(@OptionalParam(name="foo") StringParam theFoo) {
throw new UnsupportedOperationException();
}
@Validate()
public MethodOutcome validate(@ResourceParam Patient theResource) {
return new MethodOutcome();
}
}
} }

4
src/changes/changes.xml
View File

@ -363,6 +363,10 @@
The server CapabilityStatement (/metadata) endpoint now respects the Cache-Control header. Thanks The server CapabilityStatement (/metadata) endpoint now respects the Cache-Control header. Thanks
to Jens Villadsen for the pull request! to Jens Villadsen for the pull request!
</action> </action>
<action type="add">
The @Metadata annotation now has an attribute that can be used to control
the cache timeout
</action>
</release> </release>
<release version="4.0.3" date="2019-09-03" description="Igloo (Point Release)"> <release version="4.0.3" date="2019-09-03" description="Igloo (Point Release)">
<action type="fix"> <action type="fix">