messages = new ArrayList<>();
ProfileKnowledgeProvider profileKnowledgeProvider = new ProfileKnowledgeWorkerR5(myCtx);
- IWorkerContext context =
- new VersionSpecificWorkerContextWrapper(theValidationSupportContext, myVersionCanonicalizer);
- ProfileUtilities profileUtilities = new ProfileUtilities(context, messages, profileKnowledgeProvider);
+
+ ProfileUtilities profileUtilities;
+ if (myWorkerContext == null) {
+ IWorkerContext context =
+ new VersionSpecificWorkerContextWrapper(theValidationSupportContext, myVersionCanonicalizer);
+ profileUtilities = new ProfileUtilities(context, messages, profileKnowledgeProvider);
+ } else {
+ profileUtilities =
+ new ProfileUtilities(myWorkerContext, messages, profileKnowledgeProvider, myFHIRPathEngine);
+ }
+
profileUtilities.generateSnapshot(baseCanonical, inputCanonical, theUrl, theWebUrl, theProfileName);
switch (getFhirVersionEnum(
diff --git a/hapi-fhir-validation/src/main/java/org/hl7/fhir/common/hapi/validation/support/ValidationSupportChain.java b/hapi-fhir-validation/src/main/java/org/hl7/fhir/common/hapi/validation/support/ValidationSupportChain.java
index 4eea50efc11..16b3dadb3da 100644
--- a/hapi-fhir-validation/src/main/java/org/hl7/fhir/common/hapi/validation/support/ValidationSupportChain.java
+++ b/hapi-fhir-validation/src/main/java/org/hl7/fhir/common/hapi/validation/support/ValidationSupportChain.java
@@ -1,5 +1,6 @@
package org.hl7.fhir.common.hapi.validation.support;
+import ca.uhn.fhir.context.BaseRuntimeElementDefinition;
import ca.uhn.fhir.context.ConfigurationException;
import ca.uhn.fhir.context.FhirContext;
import ca.uhn.fhir.context.FhirVersionEnum;
@@ -10,40 +11,231 @@ import ca.uhn.fhir.context.support.TranslateConceptResults;
import ca.uhn.fhir.context.support.ValidationSupportContext;
import ca.uhn.fhir.context.support.ValueSetExpansionOptions;
import ca.uhn.fhir.i18n.Msg;
+import ca.uhn.fhir.rest.server.exceptions.ResourceNotFoundException;
+import ca.uhn.fhir.sl.cache.Cache;
+import ca.uhn.fhir.sl.cache.CacheFactory;
+import ca.uhn.fhir.util.FhirTerser;
import ca.uhn.fhir.util.Logs;
import jakarta.annotation.Nonnull;
+import jakarta.annotation.Nullable;
+import jakarta.annotation.PostConstruct;
+import jakarta.annotation.PreDestroy;
import org.apache.commons.lang3.Validate;
+import org.apache.commons.lang3.concurrent.BasicThreadFactory;
import org.hl7.fhir.instance.model.api.IBaseResource;
import org.hl7.fhir.instance.model.api.IPrimitiveType;
import org.slf4j.Logger;
+import java.time.Duration;
import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
-import java.util.Optional;
+import java.util.Map;
+import java.util.Objects;
import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
import java.util.function.Function;
+import java.util.function.Supplier;
+import static org.apache.commons.lang3.ObjectUtils.defaultIfNull;
+import static org.apache.commons.lang3.StringUtils.defaultIfBlank;
import static org.apache.commons.lang3.StringUtils.isBlank;
import static org.apache.commons.lang3.StringUtils.isNotBlank;
+/**
+ * This validation support module has two primary purposes: It can be used to
+ * chain multiple backing modules together, and it can optionally cache the
+ * results.
+ *
+ * The following chaining logic is used:
+ *
+ * -
+ * Calls to {@literal fetchAll...} methods such as {@link #fetchAllConformanceResources()}
+ * and {@link #fetchAllStructureDefinitions()} will call every method in the chain in
+ * order, and aggregate the results into a single list to return.
+ *
+ * -
+ * Calls to fetch or validate codes, such as {@link #validateCode(ValidationSupportContext, ConceptValidationOptions, String, String, String, String)}
+ * and {@link #lookupCode(ValidationSupportContext, LookupCodeRequest)} will first test
+ * each module in the chain using the {@link #isCodeSystemSupported(ValidationSupportContext, String)}
+ * or {@link #isValueSetSupported(ValidationSupportContext, String)}
+ * methods (depending on whether a ValueSet URL is present in the method parameters)
+ * and will invoke any methods in the chain which return that they can handle the given
+ * CodeSystem/ValueSet URL. The first non-null value returned by a method in the chain
+ * that can support the URL will be returned to the caller.
+ *
+ * -
+ * All other methods will invoke each method in the chain in order, and will stop processing and return
+ * immediately as soon as the first non-null value is returned.
+ *
+ *
+ *
+ *
+ * The following caching logic is used if caching is enabled using {@link CacheConfiguration}.
+ * You can use {@link CacheConfiguration#disabled()} if you want to disable caching.
+ *
+ * -
+ * Calls to fetch StructureDefinitions including {@link #fetchAllStructureDefinitions()}
+ * and {@link #fetchStructureDefinition(String)} are cached in a non-expiring cache.
+ * This is because the {@link org.hl7.fhir.common.hapi.validation.validator.FhirInstanceValidator}
+ * module makes assumptions that these objects will not change for the lifetime
+ * of the validator for performance reasons.
+ *
+ * -
+ * Calls to all other {@literal fetchAll...} methods including
+ * {@link #fetchAllConformanceResources()} and {@link #fetchAllSearchParameters()}
+ * cache their results in an expiring cache, but will refresh that cache asynchronously.
+ *
+ * -
+ * Results of {@link #generateSnapshot(ValidationSupportContext, IBaseResource, String, String, String)}
+ * are not cached, since this method is generally called in contexts where the results
+ * are cached.
+ *
+ * -
+ * Results of all other methods are stored in an expiring cache.
+ *
+ *
+ *
+ *
+ * Note that caching functionality used to be provided by a separate provider
+ * called {@literal CachingValidationSupport} but that functionality has been
+ * moved into this class as of HAPI FHIR 8.0.0, because it is possible to
+ * provide a more efficient chain when these functions are combined.
+ *
+ */
public class ValidationSupportChain implements IValidationSupport {
+ public static final ValueSetExpansionOptions EMPTY_EXPANSION_OPTIONS = new ValueSetExpansionOptions();
static Logger ourLog = Logs.getTerminologyTroubleshootingLog();
+ private final List myChain = new ArrayList<>();
- private List myChain;
+ @Nullable
+ private final Cache, Object> myExpiringCache;
+
+ @Nullable
+ private final Map, Object> myNonExpiringCache;
/**
- * Constructor
+ * See class documentation for an explanation of why this is separate
+ * and non-expiring. Note that this field is non-synchronized. If you
+ * access it, you should first wrap the call in
+ * synchronized(myStructureDefinitionsByUrl).
+ */
+ @Nonnull
+ private final Map myStructureDefinitionsByUrl = new HashMap<>();
+ /**
+ * See class documentation for an explanation of why this is separate
+ * and non-expiring. Note that this field is non-synchronized. If you
+ * access it, you should first wrap the call in
+ * synchronized(myStructureDefinitionsByUrl) (synchronize on
+ * the other field because both collections are expected to be modified
+ * at the same time).
+ */
+ @Nonnull
+ private final List myStructureDefinitionsAsList = new ArrayList<>();
+
+ private final ThreadPoolExecutor myBackgroundExecutor;
+ private final CacheConfiguration myCacheConfiguration;
+ private boolean myEnabledValidationForCodingsLogicalAnd;
+ private String myName = getClass().getSimpleName();
+ private ValidationSupportChainMetrics myMetrics;
+ private volatile boolean myHaveFetchedAllStructureDefinitions = false;
+
+ /**
+ * Constructor which initializes the chain with no modules (modules
+ * must subsequently be registered using {@link #addValidationSupport(IValidationSupport)}).
+ * The cache will be enabled using {@link CacheConfiguration#defaultValues()}.
*/
public ValidationSupportChain() {
- myChain = new ArrayList<>();
+ /*
+ * Note, this constructor is called by default when
+ * FhirContext#getValidationSupport() is called, so it should
+ * provide sensible defaults.
+ */
+ this(Collections.emptyList());
+ }
+
+ /**
+ * Constructor which initializes the chain with the given modules.
+ * The cache will be enabled using {@link CacheConfiguration#defaultValues()}.
+ */
+ public ValidationSupportChain(IValidationSupport... theValidationSupportModules) {
+ this(
+ theValidationSupportModules != null
+ ? Arrays.asList(theValidationSupportModules)
+ : Collections.emptyList());
+ }
+
+ /**
+ * Constructor which initializes the chain with the given modules.
+ * The cache will be enabled using {@link CacheConfiguration#defaultValues()}.
+ */
+ public ValidationSupportChain(List theValidationSupportModules) {
+ this(CacheConfiguration.defaultValues(), theValidationSupportModules);
}
/**
* Constructor
+ *
+ * @param theCacheConfiguration The caching configuration
+ * @param theValidationSupportModules The initial modules to add to the chain
*/
- public ValidationSupportChain(IValidationSupport... theValidationSupportModules) {
- this();
+ public ValidationSupportChain(
+ @Nonnull CacheConfiguration theCacheConfiguration, IValidationSupport... theValidationSupportModules) {
+ this(
+ theCacheConfiguration,
+ theValidationSupportModules != null
+ ? Arrays.asList(theValidationSupportModules)
+ : Collections.emptyList());
+ }
+
+ /**
+ * Constructor
+ *
+ * @param theCacheConfiguration The caching configuration
+ * @param theValidationSupportModules The initial modules to add to the chain
+ */
+ public ValidationSupportChain(
+ @Nonnull CacheConfiguration theCacheConfiguration,
+ @Nonnull List theValidationSupportModules) {
+
+ Validate.notNull(theCacheConfiguration, "theCacheConfiguration must not be null");
+ Validate.notNull(theValidationSupportModules, "theValidationSupportModules must not be null");
+
+ myCacheConfiguration = theCacheConfiguration;
+ if (theCacheConfiguration.getCacheSize() == 0 || theCacheConfiguration.getCacheTimeout() == 0) {
+ myExpiringCache = null;
+ myNonExpiringCache = null;
+ myBackgroundExecutor = null;
+ } else {
+ myExpiringCache =
+ CacheFactory.build(theCacheConfiguration.getCacheTimeout(), theCacheConfiguration.getCacheSize());
+ myNonExpiringCache = Collections.synchronizedMap(new HashMap<>());
+
+ LinkedBlockingQueue executorQueue = new LinkedBlockingQueue<>(1000);
+ BasicThreadFactory threadFactory = new BasicThreadFactory.Builder()
+ .namingPattern("CachingValidationSupport-%d")
+ .daemon(false)
+ .priority(Thread.NORM_PRIORITY)
+ .build();
+
+ // NOTE: We're not using ThreadPoolUtil here, because that class depends on Spring and
+ // we want the validator infrastructure to not require spring dependencies.
+ myBackgroundExecutor = new ThreadPoolExecutor(
+ 1,
+ 1,
+ 0L,
+ TimeUnit.MILLISECONDS,
+ executorQueue,
+ threadFactory,
+ new ThreadPoolExecutor.DiscardPolicy());
+ }
+
for (IValidationSupport next : theValidationSupportModules) {
if (next != null) {
addValidationSupport(next);
@@ -51,63 +243,174 @@ public class ValidationSupportChain implements IValidationSupport {
}
}
+ @Override
+ public String getName() {
+ return myName;
+ }
+
+ /**
+ * Sets a name for this chain. This name will be returned by
+ * {@link #getName()} and used by OpenTelemetry.
+ */
+ public void setName(String theName) {
+ Validate.notBlank(theName, "theName must not be blank");
+ myName = theName;
+ }
+
+ @PostConstruct
+ public void start() {
+ if (myMetrics == null) {
+ myMetrics = new ValidationSupportChainMetrics(this);
+ myMetrics.start();
+ }
+ }
+
+ @PreDestroy
+ public void stop() {
+ if (myMetrics != null) {
+ myMetrics.stop();
+ myMetrics = null;
+ }
+ }
+
+ @Override
+ public boolean isCodeableConceptValidationSuccessfulIfNotAllCodingsAreValid() {
+ return myEnabledValidationForCodingsLogicalAnd;
+ }
+
+ /**
+ * When validating a CodeableConcept containing multiple codings, this method can be used to control whether
+ * the validator requires all codings in the CodeableConcept to be valid in order to consider the
+ * CodeableConcept valid.
+ *
+ * See VersionSpecificWorkerContextWrapper#validateCode in hapi-fhir-validation, and the refer to the values below
+ * for the behaviour associated with each value.
+ *
+ *
+ *
+ * - If
false (default setting) the validation for codings will return a positive result only if
+ * ALL codings are valid.
+ * - If
true the validation for codings will return a positive result if ANY codings are valid.
+ *
+ *
+ *
+ *
+ * @return true or false depending on the desired coding validation behaviour.
+ */
+ public ValidationSupportChain setCodeableConceptValidationSuccessfulIfNotAllCodingsAreValid(
+ boolean theEnabledValidationForCodingsLogicalAnd) {
+ myEnabledValidationForCodingsLogicalAnd = theEnabledValidationForCodingsLogicalAnd;
+ return this;
+ }
+
@Override
public TranslateConceptResults translateConcept(TranslateCodeRequest theRequest) {
- TranslateConceptResults retVal = null;
- for (IValidationSupport next : myChain) {
- TranslateConceptResults translations = next.translateConcept(theRequest);
- if (translations != null) {
- if (retVal == null) {
- retVal = new TranslateConceptResults();
- }
+ TranslateConceptKey key = new TranslateConceptKey(theRequest);
+ CacheValue retVal = getFromCache(key);
+ if (retVal == null) {
- if (retVal.getMessage() == null) {
- retVal.setMessage(translations.getMessage());
- }
+ /*
+ * The chain behaviour for this method is to call every element in the
+ * chain and aggregate the results (as opposed to just using the first
+ * module which provides a response).
+ */
+ retVal = CacheValue.empty();
- if (translations.getResult() && !retVal.getResult()) {
- retVal.setResult(translations.getResult());
- retVal.setMessage(translations.getMessage());
- }
+ TranslateConceptResults outcome = null;
+ for (IValidationSupport next : myChain) {
+ TranslateConceptResults translations = next.translateConcept(theRequest);
+ if (translations != null) {
+ if (outcome == null) {
+ outcome = new TranslateConceptResults();
+ }
- if (!translations.isEmpty()) {
- if (ourLog.isDebugEnabled()) {
+ if (outcome.getMessage() == null) {
+ outcome.setMessage(translations.getMessage());
+ }
+
+ if (translations.getResult() && !outcome.getResult()) {
+ outcome.setResult(translations.getResult());
+ outcome.setMessage(translations.getMessage());
+ }
+
+ if (!translations.isEmpty()) {
ourLog.debug(
"{} found {} concept translation{} for {}",
next.getName(),
translations.size(),
translations.size() > 1 ? "s" : "",
theRequest);
+ outcome.getResults().addAll(translations.getResults());
}
- retVal.getResults().addAll(translations.getResults());
}
}
+
+ if (outcome != null) {
+ retVal = new CacheValue<>(outcome);
+ }
+
+ putInCache(key, retVal);
}
- return retVal;
+
+ return retVal.getValue();
}
@Override
public void invalidateCaches() {
ourLog.debug("Invalidating caches in {} validation support modules", myChain.size());
+ myHaveFetchedAllStructureDefinitions = false;
for (IValidationSupport next : myChain) {
next.invalidateCaches();
}
+ if (myNonExpiringCache != null) {
+ myNonExpiringCache.clear();
+ }
+ if (myExpiringCache != null) {
+ myExpiringCache.invalidateAll();
+ }
+ synchronized (myStructureDefinitionsByUrl) {
+ myStructureDefinitionsByUrl.clear();
+ myStructureDefinitionsAsList.clear();
+ }
+ }
+
+ /**
+ * Invalidate the expiring cache, but not the permanent StructureDefinition cache
+ *
+ * @since 8.0.0
+ */
+ public void invalidateExpiringCaches() {
+ if (myExpiringCache != null) {
+ myExpiringCache.invalidateAll();
+ }
}
@Override
public boolean isValueSetSupported(ValidationSupportContext theValidationSupportContext, String theValueSetUrl) {
for (IValidationSupport next : myChain) {
- boolean retVal = next.isValueSetSupported(theValidationSupportContext, theValueSetUrl);
+ boolean retVal = isValueSetSupported(theValidationSupportContext, next, theValueSetUrl);
if (retVal) {
- if (ourLog.isDebugEnabled()) {
- ourLog.debug("ValueSet {} found in {}", theValueSetUrl, next.getName());
- }
+ ourLog.debug("ValueSet {} found in {}", theValueSetUrl, next.getName());
return true;
}
}
return false;
}
+ private boolean isValueSetSupported(
+ ValidationSupportContext theValidationSupportContext,
+ IValidationSupport theValidationSupport,
+ String theValueSetUrl) {
+ IsValueSetSupportedKey key = new IsValueSetSupportedKey(theValidationSupport, theValueSetUrl);
+ CacheValue value = getFromCache(key);
+ if (value == null) {
+ value = new CacheValue<>(
+ theValidationSupport.isValueSetSupported(theValidationSupportContext, theValueSetUrl));
+ putInCache(key, value);
+ }
+ return value.getValue();
+ }
+
@Override
public IBaseResource generateSnapshot(
ValidationSupportContext theValidationSupportContext,
@@ -115,13 +418,22 @@ public class ValidationSupportChain implements IValidationSupport {
String theUrl,
String theWebUrl,
String theProfileName) {
+
+ /*
+ * No caching for this method because we typically cache the results anyhow.
+ * If this ever changes, make sure to update the class javadocs and the
+ * HAPI FHIR documentation which indicate that this isn't cached.
+ */
+
for (IValidationSupport next : myChain) {
IBaseResource retVal =
next.generateSnapshot(theValidationSupportContext, theInput, theUrl, theWebUrl, theProfileName);
if (retVal != null) {
- if (ourLog.isDebugEnabled()) {
- ourLog.debug("Profile snapshot for {} generated by {}", theInput.getIdElement(), next.getName());
- }
+ ourLog.atDebug()
+ .setMessage("Profile snapshot for {} generated by {}")
+ .addArgument(() -> theInput.getIdElement())
+ .addArgument(() -> next.getName())
+ .log();
return retVal;
}
}
@@ -130,7 +442,7 @@ public class ValidationSupportChain implements IValidationSupport {
@Override
public FhirContext getFhirContext() {
- if (myChain.size() == 0) {
+ if (myChain.isEmpty()) {
return null;
}
return myChain.get(0).getFhirContext();
@@ -160,6 +472,7 @@ public class ValidationSupportChain implements IValidationSupport {
*/
public void addValidationSupport(int theIndex, IValidationSupport theValidationSupport) {
Validate.notNull(theValidationSupport, "theValidationSupport must not be null");
+ invalidateCaches();
if (theValidationSupport.getFhirContext() == null) {
String message = "Can not add validation support: getFhirContext() returns null";
@@ -189,58 +502,134 @@ public class ValidationSupportChain implements IValidationSupport {
myChain.remove(theValidationSupport);
}
+ @Nullable
+ @Override
+ public ValueSetExpansionOutcome expandValueSet(
+ ValidationSupportContext theValidationSupportContext,
+ @Nullable ValueSetExpansionOptions theExpansionOptions,
+ @Nonnull String theValueSetUrlToExpand)
+ throws ResourceNotFoundException {
+ ValueSetExpansionOptions expansionOptions = defaultIfNull(theExpansionOptions, EMPTY_EXPANSION_OPTIONS);
+ ExpandValueSetKey key = new ExpandValueSetKey(expansionOptions, null, theValueSetUrlToExpand);
+ CacheValue retVal = getFromCache(key);
+
+ if (retVal == null) {
+ retVal = CacheValue.empty();
+ for (IValidationSupport next : myChain) {
+ if (isValueSetSupported(theValidationSupportContext, next, theValueSetUrlToExpand)) {
+ ValueSetExpansionOutcome expanded =
+ next.expandValueSet(theValidationSupportContext, expansionOptions, theValueSetUrlToExpand);
+ if (expanded != null) {
+ ourLog.debug("ValueSet {} expanded by URL by {}", theValueSetUrlToExpand, next.getName());
+ retVal = new CacheValue<>(expanded);
+ break;
+ }
+ }
+ }
+
+ putInCache(key, retVal);
+ }
+
+ return retVal.getValue();
+ }
+
@Override
public ValueSetExpansionOutcome expandValueSet(
ValidationSupportContext theValidationSupportContext,
ValueSetExpansionOptions theExpansionOptions,
@Nonnull IBaseResource theValueSetToExpand) {
- for (IValidationSupport next : myChain) {
- // TODO: test if code system is supported?
- ValueSetExpansionOutcome expanded =
- next.expandValueSet(theValidationSupportContext, theExpansionOptions, theValueSetToExpand);
- if (expanded != null) {
- if (ourLog.isDebugEnabled()) {
+
+ ValueSetExpansionOptions expansionOptions = defaultIfNull(theExpansionOptions, EMPTY_EXPANSION_OPTIONS);
+ String id = theValueSetToExpand.getIdElement().getValue();
+ ExpandValueSetKey key = null;
+ CacheValue retVal = null;
+ if (isNotBlank(id)) {
+ key = new ExpandValueSetKey(expansionOptions, id, null);
+ retVal = getFromCache(key);
+ }
+ if (retVal == null) {
+ retVal = CacheValue.empty();
+ for (IValidationSupport next : myChain) {
+ ValueSetExpansionOutcome expanded =
+ next.expandValueSet(theValidationSupportContext, expansionOptions, theValueSetToExpand);
+ if (expanded != null) {
ourLog.debug("ValueSet {} expanded by {}", theValueSetToExpand.getIdElement(), next.getName());
+ retVal = new CacheValue<>(expanded);
+ break;
}
- return expanded;
+ }
+
+ if (key != null) {
+ putInCache(key, retVal);
}
}
- return null;
+
+ return retVal.getValue();
}
@Override
public boolean isRemoteTerminologyServiceConfigured() {
- if (myChain != null) {
- Optional remoteTerminologyService = myChain.stream()
- .filter(RemoteTerminologyServiceValidationSupport.class::isInstance)
- .findFirst();
- if (remoteTerminologyService.isPresent()) {
- return true;
- }
- }
- return false;
+ return myChain.stream().anyMatch(RemoteTerminologyServiceValidationSupport.class::isInstance);
}
@Override
public List fetchAllConformanceResources() {
- List retVal = new ArrayList<>();
- for (IValidationSupport next : myChain) {
- List candidates = next.fetchAllConformanceResources();
- if (candidates != null) {
- retVal.addAll(candidates);
+ FetchAllKey key = new FetchAllKey(FetchAllKey.TypeEnum.ALL);
+ Supplier> loader = () -> {
+ List allCandidates = new ArrayList<>();
+ for (IValidationSupport next : myChain) {
+ List candidates = next.fetchAllConformanceResources();
+ if (candidates != null) {
+ allCandidates.addAll(candidates);
+ }
}
- }
- return retVal;
+ return allCandidates;
+ };
+
+ return getFromCacheWithAsyncRefresh(key, loader);
}
+ @SuppressWarnings("unchecked")
@Override
+ @Nonnull
public List fetchAllStructureDefinitions() {
- return doFetchStructureDefinitions(t -> t.fetchAllStructureDefinitions());
+ if (!myHaveFetchedAllStructureDefinitions) {
+ FhirTerser terser = getFhirContext().newTerser();
+ List allStructureDefinitions =
+ doFetchStructureDefinitions(IValidationSupport::fetchAllStructureDefinitions);
+ if (myExpiringCache != null) {
+ synchronized (myStructureDefinitionsByUrl) {
+ for (IBaseResource structureDefinition : allStructureDefinitions) {
+ String url = terser.getSinglePrimitiveValueOrNull(structureDefinition, "url");
+ url = defaultIfBlank(url, UUID.randomUUID().toString());
+ if (myStructureDefinitionsByUrl.putIfAbsent(url, structureDefinition) == null) {
+ myStructureDefinitionsAsList.add(structureDefinition);
+ }
+ }
+ }
+ }
+ myHaveFetchedAllStructureDefinitions = true;
+ }
+ return Collections.unmodifiableList(new ArrayList<>(myStructureDefinitionsAsList));
}
+ @SuppressWarnings("unchecked")
@Override
public List fetchAllNonBaseStructureDefinitions() {
- return doFetchStructureDefinitions(t -> t.fetchAllNonBaseStructureDefinitions());
+ FetchAllKey key = new FetchAllKey(FetchAllKey.TypeEnum.ALL_NON_BASE_STRUCTUREDEFINITIONS);
+ Supplier> loader =
+ () -> doFetchStructureDefinitions(IValidationSupport::fetchAllNonBaseStructureDefinitions);
+ return getFromCacheWithAsyncRefresh(key, loader);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Nullable
+ @Override
+ public List fetchAllSearchParameters() {
+ FetchAllKey key = new FetchAllKey(FetchAllKey.TypeEnum.ALL_SEARCHPARAMETERS);
+ Supplier> loader =
+ () -> doFetchStructureDefinitions(IValidationSupport::fetchAllSearchParameters);
+ return (List) getFromCacheWithAsyncRefresh(key, loader);
}
private List doFetchStructureDefinitions(
@@ -267,84 +656,98 @@ public class ValidationSupportChain implements IValidationSupport {
@Override
public IBaseResource fetchCodeSystem(String theSystem) {
- for (IValidationSupport next : myChain) {
- IBaseResource retVal = next.fetchCodeSystem(theSystem);
- if (retVal != null) {
- if (ourLog.isDebugEnabled()) {
- ourLog.debug(
- "CodeSystem {} with System {} fetched by {}",
- retVal.getIdElement(),
- theSystem,
- next.getName());
+ Function invoker = v -> v.fetchCodeSystem(theSystem);
+ ResourceByUrlKey key = new ResourceByUrlKey<>(ResourceByUrlKey.TypeEnum.CODESYSTEM, theSystem);
+ return fetchValue(key, invoker, theSystem);
+ }
+
+ private T fetchValue(ResourceByUrlKey theKey, Function theInvoker, String theUrl) {
+ CacheValue retVal = getFromCache(theKey);
+
+ if (retVal == null) {
+ retVal = CacheValue.empty();
+ for (IValidationSupport next : myChain) {
+ T outcome = theInvoker.apply(next);
+ if (outcome != null) {
+ ourLog.debug("{} {} with URL {} fetched by {}", theKey.myType, outcome, theUrl, next.getName());
+ retVal = new CacheValue<>(outcome);
+ break;
}
- return retVal;
}
+ putInCache(theKey, retVal);
}
- return null;
+
+ return retVal.getValue();
}
@Override
public IBaseResource fetchValueSet(String theUrl) {
- for (IValidationSupport next : myChain) {
- IBaseResource retVal = next.fetchValueSet(theUrl);
- if (retVal != null) {
- if (ourLog.isDebugEnabled()) {
- ourLog.debug(
- "ValueSet {} with URL {} fetched by {}", retVal.getIdElement(), theUrl, next.getName());
- }
- return retVal;
- }
- }
- return null;
+ Function invoker = v -> v.fetchValueSet(theUrl);
+ ResourceByUrlKey key = new ResourceByUrlKey<>(ResourceByUrlKey.TypeEnum.VALUESET, theUrl);
+ return fetchValue(key, invoker, theUrl);
}
+ @SuppressWarnings("unchecked")
@Override
public T fetchResource(Class theClass, String theUri) {
- for (IValidationSupport next : myChain) {
- T retVal = next.fetchResource(theClass, theUri);
- if (retVal != null) {
- if (ourLog.isDebugEnabled()) {
- ourLog.debug(
- "Resource {} with URI {} fetched by {}", retVal.getIdElement(), theUri, next.getName());
+
+ /*
+ * If we're looking for a common type with a dedicated fetch method, use that
+ * so that we can use a common cache location for lookups wanting a given
+ * URL on both methods (the validator will call both paths when looking for a
+ * specific URL so this improves cache efficiency).
+ */
+ if (theClass != null) {
+ BaseRuntimeElementDefinition elementDefinition = getFhirContext().getElementDefinition(theClass);
+ if (elementDefinition != null) {
+ switch (elementDefinition.getName()) {
+ case "ValueSet":
+ return (T) fetchValueSet(theUri);
+ case "CodeSystem":
+ return (T) fetchCodeSystem(theUri);
+ case "StructureDefinition":
+ return (T) fetchStructureDefinition(theUri);
}
- return retVal;
}
}
- return null;
+
+ Function invoker = v -> v.fetchResource(theClass, theUri);
+ TypedResourceByUrlKey key = new TypedResourceByUrlKey<>(theClass, theUri);
+ return fetchValue(key, invoker, theUri);
}
@Override
- public byte[] fetchBinary(String key) {
- for (IValidationSupport next : myChain) {
- byte[] retVal = next.fetchBinary(key);
- if (retVal != null) {
- if (ourLog.isDebugEnabled()) {
- ourLog.debug("Binary with key {} fetched by {}", key, next.getName());
- }
- return retVal;
- }
- }
- return null;
+ public byte[] fetchBinary(String theKey) {
+ Function invoker = v -> v.fetchBinary(theKey);
+ ResourceByUrlKey key = new ResourceByUrlKey<>(ResourceByUrlKey.TypeEnum.BINARY, theKey);
+ return fetchValue(key, invoker, theKey);
}
@Override
public IBaseResource fetchStructureDefinition(String theUrl) {
- for (IValidationSupport next : myChain) {
- IBaseResource retVal = next.fetchStructureDefinition(theUrl);
- if (retVal != null) {
- if (ourLog.isDebugEnabled()) {
- ourLog.debug("StructureDefinition with URL {} fetched by {}", theUrl, next.getName());
+ synchronized (myStructureDefinitionsByUrl) {
+ IBaseResource candidate = myStructureDefinitionsByUrl.get(theUrl);
+ if (candidate == null) {
+ Function invoker = v -> v.fetchStructureDefinition(theUrl);
+ ResourceByUrlKey key =
+ new ResourceByUrlKey<>(ResourceByUrlKey.TypeEnum.STRUCTUREDEFINITION, theUrl);
+ candidate = fetchValue(key, invoker, theUrl);
+ if (myExpiringCache != null) {
+ if (candidate != null) {
+ if (myStructureDefinitionsByUrl.putIfAbsent(theUrl, candidate) == null) {
+ myStructureDefinitionsAsList.add(candidate);
+ }
+ }
}
- return retVal;
}
+ return candidate;
}
- return null;
}
@Override
public boolean isCodeSystemSupported(ValidationSupportContext theValidationSupportContext, String theSystem) {
for (IValidationSupport next : myChain) {
- if (next.isCodeSystemSupported(theValidationSupportContext, theSystem)) {
+ if (isCodeSystemSupported(theValidationSupportContext, next, theSystem)) {
if (ourLog.isDebugEnabled()) {
ourLog.debug("CodeSystem with System {} is supported by {}", theSystem, next.getName());
}
@@ -354,6 +757,20 @@ public class ValidationSupportChain implements IValidationSupport {
return false;
}
+ private boolean isCodeSystemSupported(
+ ValidationSupportContext theValidationSupportContext,
+ IValidationSupport theValidationSupport,
+ String theCodeSystemUrl) {
+ IsCodeSystemSupportedKey key = new IsCodeSystemSupportedKey(theValidationSupport, theCodeSystemUrl);
+ CacheValue value = getFromCache(key);
+ if (value == null) {
+ value = new CacheValue<>(
+ theValidationSupport.isCodeSystemSupported(theValidationSupportContext, theCodeSystemUrl));
+ putInCache(key, value);
+ }
+ return value.getValue();
+ }
+
@Override
public CodeValidationResult validateCode(
@Nonnull ValidationSupportContext theValidationSupportContext,
@@ -362,14 +779,24 @@ public class ValidationSupportChain implements IValidationSupport {
String theCode,
String theDisplay,
String theValueSetUrl) {
- for (IValidationSupport next : myChain) {
- if ((isBlank(theValueSetUrl) && next.isCodeSystemSupported(theValidationSupportContext, theCodeSystem))
- || (isNotBlank(theValueSetUrl)
- && next.isValueSetSupported(theValidationSupportContext, theValueSetUrl))) {
- CodeValidationResult retVal = next.validateCode(
- theValidationSupportContext, theOptions, theCodeSystem, theCode, theDisplay, theValueSetUrl);
- if (retVal != null) {
- if (ourLog.isDebugEnabled()) {
+
+ ValidateCodeKey key = new ValidateCodeKey(theOptions, theCodeSystem, theCode, theDisplay, theValueSetUrl);
+ CacheValue retVal = getFromCache(key);
+ if (retVal == null) {
+ retVal = CacheValue.empty();
+
+ for (IValidationSupport next : myChain) {
+ if ((isBlank(theValueSetUrl) && isCodeSystemSupported(theValidationSupportContext, next, theCodeSystem))
+ || (isNotBlank(theValueSetUrl)
+ && isValueSetSupported(theValidationSupportContext, next, theValueSetUrl))) {
+ CodeValidationResult outcome = next.validateCode(
+ theValidationSupportContext,
+ theOptions,
+ theCodeSystem,
+ theCode,
+ theDisplay,
+ theValueSetUrl);
+ if (outcome != null) {
ourLog.debug(
"Code {}|{} '{}' in ValueSet {} validated by {}",
theCodeSystem,
@@ -377,12 +804,16 @@ public class ValidationSupportChain implements IValidationSupport {
theDisplay,
theValueSetUrl,
next.getName());
+ retVal = new CacheValue<>(outcome);
+ break;
}
- return retVal;
}
}
+
+ putInCache(key, retVal);
}
- return null;
+
+ return retVal.getValue();
}
@Override
@@ -393,56 +824,522 @@ public class ValidationSupportChain implements IValidationSupport {
String theCode,
String theDisplay,
@Nonnull IBaseResource theValueSet) {
+ String url = CommonCodeSystemsTerminologyService.getValueSetUrl(getFhirContext(), theValueSet);
+
+ ValidateCodeKey key = null;
+ CacheValue retVal = null;
+ if (isNotBlank(url)) {
+ key = new ValidateCodeKey(theOptions, theCodeSystem, theCode, theDisplay, url);
+ retVal = getFromCache(key);
+ }
+ if (retVal != null) {
+ return retVal.getValue();
+ }
+
+ retVal = CacheValue.empty();
for (IValidationSupport next : myChain) {
- String url = CommonCodeSystemsTerminologyService.getValueSetUrl(getFhirContext(), theValueSet);
- if (isBlank(url) || next.isValueSetSupported(theValidationSupportContext, url)) {
- CodeValidationResult retVal = next.validateCodeInValueSet(
+ if (isBlank(url) || isValueSetSupported(theValidationSupportContext, next, url)) {
+ CodeValidationResult outcome = next.validateCodeInValueSet(
theValidationSupportContext, theOptions, theCodeSystem, theCode, theDisplay, theValueSet);
- if (retVal != null) {
- if (ourLog.isDebugEnabled()) {
- ourLog.debug(
- "Code {}|{} '{}' in ValueSet {} validated by {}",
- theCodeSystem,
- theCode,
- theDisplay,
- theValueSet.getIdElement(),
- next.getName());
- }
- return retVal;
+ if (outcome != null) {
+ ourLog.debug(
+ "Code {}|{} '{}' in ValueSet {} validated by {}",
+ theCodeSystem,
+ theCode,
+ theDisplay,
+ theValueSet.getIdElement(),
+ next.getName());
+ retVal = new CacheValue<>(outcome);
+ break;
}
}
}
- return null;
+
+ if (key != null) {
+ putInCache(key, retVal);
+ }
+
+ return retVal.getValue();
}
@Override
public LookupCodeResult lookupCode(
ValidationSupportContext theValidationSupportContext, @Nonnull LookupCodeRequest theLookupCodeRequest) {
- for (IValidationSupport next : myChain) {
- final String system = theLookupCodeRequest.getSystem();
- final String code = theLookupCodeRequest.getCode();
- final String displayLanguage = theLookupCodeRequest.getDisplayLanguage();
- if (next.isCodeSystemSupported(theValidationSupportContext, system)) {
- LookupCodeResult lookupCodeResult = next.lookupCode(theValidationSupportContext, theLookupCodeRequest);
- if (lookupCodeResult == null) {
- /*
- This branch has been added as a fall-back mechanism for supporting lookupCode
- methods marked as deprecated in interface IValidationSupport.
- */
- lookupCodeResult = next.lookupCode(theValidationSupportContext, system, code, displayLanguage);
+
+ LookupCodeKey key = new LookupCodeKey(theLookupCodeRequest);
+ CacheValue retVal = getFromCache(key);
+ if (retVal == null) {
+
+ retVal = CacheValue.empty();
+ for (IValidationSupport next : myChain) {
+ final String system = theLookupCodeRequest.getSystem();
+ final String code = theLookupCodeRequest.getCode();
+ final String displayLanguage = theLookupCodeRequest.getDisplayLanguage();
+ if (isCodeSystemSupported(theValidationSupportContext, next, system)) {
+ LookupCodeResult lookupCodeResult =
+ next.lookupCode(theValidationSupportContext, theLookupCodeRequest);
+ if (lookupCodeResult == null) {
+ /*
+ This branch has been added as a fall-back mechanism for supporting lookupCode
+ methods marked as deprecated in interface IValidationSupport.
+ */
+ //noinspection deprecation
+ lookupCodeResult = next.lookupCode(theValidationSupportContext, system, code, displayLanguage);
+ }
+ if (lookupCodeResult != null) {
+ ourLog.debug(
+ "Code {}|{}{} {} by {}",
+ system,
+ code,
+ isBlank(displayLanguage) ? "" : " (" + theLookupCodeRequest.getDisplayLanguage() + ")",
+ lookupCodeResult.isFound() ? "found" : "not found",
+ next.getName());
+ retVal = new CacheValue<>(lookupCodeResult);
+ break;
+ }
}
- if (ourLog.isDebugEnabled()) {
- ourLog.debug(
- "Code {}|{}{} {} by {}",
- system,
- code,
- isBlank(displayLanguage) ? "" : " (" + theLookupCodeRequest.getDisplayLanguage() + ")",
- lookupCodeResult != null && lookupCodeResult.isFound() ? "found" : "not found",
- next.getName());
- }
- return lookupCodeResult;
+ }
+
+ putInCache(key, retVal);
+ }
+
+ return retVal.getValue();
+ }
+
+ /**
+ * Returns a view of the {@link IValidationSupport} modules within
+ * this chain. The returned collection is unmodifiable and will reflect
+ * changes to the underlying list.
+ *
+ * @since 8.0.0
+ */
+ public List getValidationSupports() {
+ return Collections.unmodifiableList(myChain);
+ }
+
+ private void putInCache(BaseKey key, CacheValue theValue) {
+ if (myExpiringCache != null) {
+ myExpiringCache.put(key, theValue);
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private CacheValue getFromCache(BaseKey key) {
+ if (myExpiringCache != null) {
+ return (CacheValue) myExpiringCache.getIfPresent(key);
+ } else {
+ return null;
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private List getFromCacheWithAsyncRefresh(
+ FetchAllKey theKey, Supplier> theLoader) {
+ if (myExpiringCache == null || myNonExpiringCache == null) {
+ return theLoader.get();
+ }
+
+ CacheValue> retVal = getFromCache(theKey);
+ if (retVal == null) {
+ retVal = (CacheValue>) myNonExpiringCache.get(theKey);
+ if (retVal != null) {
+ Runnable loaderTask = () -> {
+ List loadedItem = theLoader.get();
+ CacheValue> value = new CacheValue<>(loadedItem);
+ myNonExpiringCache.put(theKey, value);
+ putInCache(theKey, value);
+ };
+ List returnValue = retVal.getValue();
+
+ myBackgroundExecutor.execute(loaderTask);
+
+ return returnValue;
+ } else {
+ retVal = new CacheValue<>(theLoader.get());
+ myNonExpiringCache.put(theKey, retVal);
+ putInCache(theKey, retVal);
}
}
- return null;
+
+ return retVal.getValue();
+ }
+
+ public void logCacheSizes() {
+ String b = "Cache sizes:" + "\n * Expiring: "
+ + (myExpiringCache != null ? myExpiringCache.estimatedSize() : "(disabled)")
+ + "\n * Non-Expiring: "
+ + (myNonExpiringCache != null ? myNonExpiringCache.size() : "(disabled)");
+ ourLog.info(b);
+ }
+
+ long getMetricExpiringCacheEntries() {
+ if (myExpiringCache != null) {
+ return myExpiringCache.estimatedSize();
+ } else {
+ return 0;
+ }
+ }
+
+ int getMetricNonExpiringCacheEntries() {
+ synchronized (myStructureDefinitionsByUrl) {
+ int size = myNonExpiringCache != null ? myNonExpiringCache.size() : 0;
+ return size + myStructureDefinitionsAsList.size();
+ }
+ }
+
+ int getMetricExpiringCacheMaxSize() {
+ return myCacheConfiguration.getCacheSize();
+ }
+
+ /**
+ * @since 5.4.0
+ */
+ public static class CacheConfiguration {
+
+ private long myCacheTimeout;
+ private int myCacheSize;
+
+ /**
+ * Non-instantiable. Use the factory methods.
+ */
+ private CacheConfiguration() {
+ super();
+ }
+
+ public long getCacheTimeout() {
+ return myCacheTimeout;
+ }
+
+ public CacheConfiguration setCacheTimeout(Duration theCacheTimeout) {
+ Validate.isTrue(theCacheTimeout.toMillis() >= 0, "Cache timeout must not be negative");
+ myCacheTimeout = theCacheTimeout.toMillis();
+ return this;
+ }
+
+ public int getCacheSize() {
+ return myCacheSize;
+ }
+
+ public CacheConfiguration setCacheSize(int theCacheSize) {
+ Validate.isTrue(theCacheSize >= 0, "Cache size must not be negative");
+ myCacheSize = theCacheSize;
+ return this;
+ }
+
+ /**
+ * Creates a cache configuration with sensible default values:
+ * 10 minutes expiry, and 5000 cache entries.
+ */
+ public static CacheConfiguration defaultValues() {
+ return new CacheConfiguration()
+ .setCacheTimeout(Duration.ofMinutes(10))
+ .setCacheSize(5000);
+ }
+
+ public static CacheConfiguration disabled() {
+ return new CacheConfiguration().setCacheSize(0).setCacheTimeout(Duration.ofMillis(0));
+ }
+ }
+
+ /**
+ * @param The value type associated with this key
+ */
+ @SuppressWarnings("unused")
+ abstract static class BaseKey {
+
+ @Override
+ public abstract boolean equals(Object theO);
+
+ @Override
+ public abstract int hashCode();
+ }
+
+ static class ExpandValueSetKey extends BaseKey {
+
+ private final ValueSetExpansionOptions myOptions;
+ private final String myId;
+ private final String myUrl;
+ private final int myHashCode;
+
+ private ExpandValueSetKey(ValueSetExpansionOptions theOptions, String theId, String theUrl) {
+ myOptions = theOptions;
+ myId = theId;
+ myUrl = theUrl;
+ myHashCode = Objects.hash(myOptions, myId, myUrl);
+ }
+
+ @Override
+ public boolean equals(Object theO) {
+ if (this == theO) return true;
+ if (!(theO instanceof ExpandValueSetKey)) return false;
+ ExpandValueSetKey that = (ExpandValueSetKey) theO;
+ return Objects.equals(myOptions, that.myOptions)
+ && Objects.equals(myId, that.myId)
+ && Objects.equals(myUrl, that.myUrl);
+ }
+
+ @Override
+ public int hashCode() {
+ return myHashCode;
+ }
+ }
+
+ static class FetchAllKey extends BaseKey> {
+
+ private final TypeEnum myType;
+ private final int myHashCode;
+
+ private FetchAllKey(TypeEnum theType) {
+ myType = theType;
+ myHashCode = Objects.hash(myType);
+ }
+
+ @Override
+ public boolean equals(Object theO) {
+ if (this == theO) return true;
+ if (!(theO instanceof FetchAllKey)) return false;
+ FetchAllKey that = (FetchAllKey) theO;
+ return myType == that.myType;
+ }
+
+ @Override
+ public int hashCode() {
+ return myHashCode;
+ }
+
+ private enum TypeEnum {
+ ALL,
+ ALL_STRUCTUREDEFINITIONS,
+ ALL_NON_BASE_STRUCTUREDEFINITIONS,
+ ALL_SEARCHPARAMETERS
+ }
+ }
+
+ static class ResourceByUrlKey extends BaseKey {
+
+ private final TypeEnum myType;
+ private final String myUrl;
+ private final int myHashCode;
+
+ private ResourceByUrlKey(TypeEnum theType, String theUrl) {
+ this(theType, theUrl, Objects.hash("ResourceByUrl", theType, theUrl));
+ }
+
+ private ResourceByUrlKey(TypeEnum theType, String theUrl, int theHashCode) {
+ myType = theType;
+ myUrl = theUrl;
+ myHashCode = theHashCode;
+ }
+
+ @Override
+ public boolean equals(Object theO) {
+ if (this == theO) return true;
+ if (!(theO instanceof ResourceByUrlKey)) return false;
+ ResourceByUrlKey that = (ResourceByUrlKey) theO;
+ return myType == that.myType && Objects.equals(myUrl, that.myUrl);
+ }
+
+ @Override
+ public int hashCode() {
+ return myHashCode;
+ }
+
+ private enum TypeEnum {
+ CODESYSTEM,
+ VALUESET,
+ RESOURCE,
+ BINARY,
+ STRUCTUREDEFINITION
+ }
+ }
+
+ static class TypedResourceByUrlKey extends ResourceByUrlKey {
+
+ private final Class myType;
+
+ private TypedResourceByUrlKey(Class theType, String theUrl) {
+ super(ResourceByUrlKey.TypeEnum.RESOURCE, theUrl, Objects.hash("TypedResourceByUrl", theType, theUrl));
+ myType = theType;
+ }
+
+ @Override
+ public boolean equals(Object theO) {
+ if (this == theO) return true;
+ if (!(theO instanceof TypedResourceByUrlKey)) return false;
+ if (!super.equals(theO)) return false;
+ TypedResourceByUrlKey that = (TypedResourceByUrlKey) theO;
+ return Objects.equals(myType, that.myType);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(super.hashCode(), myType);
+ }
+ }
+
+ static class IsValueSetSupportedKey extends BaseKey {
+
+ private final String myValueSetUrl;
+ private final IValidationSupport myValidationSupport;
+ private final int myHashCode;
+
+ private IsValueSetSupportedKey(IValidationSupport theValidationSupport, String theValueSetUrl) {
+ myValidationSupport = theValidationSupport;
+ myValueSetUrl = theValueSetUrl;
+ myHashCode = Objects.hash("IsValueSetSupported", theValidationSupport, myValueSetUrl);
+ }
+
+ @Override
+ public boolean equals(Object theO) {
+ if (this == theO) return true;
+ if (!(theO instanceof IsValueSetSupportedKey)) return false;
+ IsValueSetSupportedKey that = (IsValueSetSupportedKey) theO;
+ return myValidationSupport == that.myValidationSupport && Objects.equals(myValueSetUrl, that.myValueSetUrl);
+ }
+
+ @Override
+ public int hashCode() {
+ return myHashCode;
+ }
+ }
+
+ static class IsCodeSystemSupportedKey extends BaseKey {
+
+ private final String myCodeSystemUrl;
+ private final IValidationSupport myValidationSupport;
+ private final int myHashCode;
+
+ private IsCodeSystemSupportedKey(IValidationSupport theValidationSupport, String theCodeSystemUrl) {
+ myValidationSupport = theValidationSupport;
+ myCodeSystemUrl = theCodeSystemUrl;
+ myHashCode = Objects.hash("IsCodeSystemSupported", theValidationSupport, myCodeSystemUrl);
+ }
+
+ @Override
+ public boolean equals(Object theO) {
+ if (this == theO) return true;
+ if (!(theO instanceof IsCodeSystemSupportedKey)) return false;
+ IsCodeSystemSupportedKey that = (IsCodeSystemSupportedKey) theO;
+ return myValidationSupport == that.myValidationSupport
+ && Objects.equals(myCodeSystemUrl, that.myCodeSystemUrl);
+ }
+
+ @Override
+ public int hashCode() {
+ return myHashCode;
+ }
+ }
+
+ static class LookupCodeKey extends BaseKey {
+
+ private final LookupCodeRequest myRequest;
+ private final int myHashCode;
+
+ private LookupCodeKey(LookupCodeRequest theRequest) {
+ myRequest = theRequest;
+ myHashCode = Objects.hash("LookupCode", myRequest);
+ }
+
+ @Override
+ public boolean equals(Object theO) {
+ if (this == theO) return true;
+ if (!(theO instanceof LookupCodeKey)) return false;
+ LookupCodeKey that = (LookupCodeKey) theO;
+ return Objects.equals(myRequest, that.myRequest);
+ }
+
+ @Override
+ public int hashCode() {
+ return myHashCode;
+ }
+ }
+
+ static class TranslateConceptKey extends BaseKey {
+
+ private final TranslateCodeRequest myRequest;
+ private final int myHashCode;
+
+ private TranslateConceptKey(TranslateCodeRequest theRequest) {
+ myRequest = theRequest;
+ myHashCode = Objects.hash("TranslateConcept", myRequest);
+ }
+
+ @Override
+ public boolean equals(Object theO) {
+ if (this == theO) return true;
+ if (!(theO instanceof TranslateConceptKey)) return false;
+ TranslateConceptKey that = (TranslateConceptKey) theO;
+ return Objects.equals(myRequest, that.myRequest);
+ }
+
+ @Override
+ public int hashCode() {
+ return myHashCode;
+ }
+ }
+
+ static class ValidateCodeKey extends BaseKey {
+ private final String mySystem;
+ private final String myCode;
+ private final String myDisplay;
+ private final String myValueSetUrl;
+ private final int myHashCode;
+ private final ConceptValidationOptions myOptions;
+
+ private ValidateCodeKey(
+ ConceptValidationOptions theOptions,
+ String theSystem,
+ String theCode,
+ String theDisplay,
+ String theValueSetUrl) {
+ myOptions = theOptions;
+ mySystem = theSystem;
+ myCode = theCode;
+ myDisplay = theDisplay;
+ myValueSetUrl = theValueSetUrl;
+ myHashCode = Objects.hash("ValidateCodeKey", myOptions, mySystem, myCode, myDisplay, myValueSetUrl);
+ }
+
+ @Override
+ public boolean equals(Object theO) {
+ if (this == theO) return true;
+ if (!(theO instanceof ValidateCodeKey)) return false;
+ ValidateCodeKey that = (ValidateCodeKey) theO;
+ return Objects.equals(myOptions, that.myOptions)
+ && Objects.equals(mySystem, that.mySystem)
+ && Objects.equals(myCode, that.myCode)
+ && Objects.equals(myDisplay, that.myDisplay)
+ && Objects.equals(myValueSetUrl, that.myValueSetUrl);
+ }
+
+ @Override
+ public int hashCode() {
+ return myHashCode;
+ }
+ }
+
+ /**
+ * This class is basically the same thing as Optional, but is a distinct thing
+ * because we want to use it as a method parameter value, and compare instances of
+ * it with null. Both of these things generate warnings in various linters.
+ */
+ private static class CacheValue {
+
+ private static final CacheValue EMPTY = new CacheValue<>(null);
+
+ private final T myValue;
+
+ private CacheValue(T theValue) {
+ myValue = theValue;
+ }
+
+ public T getValue() {
+ return myValue;
+ }
+
+ @SuppressWarnings("unchecked")
+ public static CacheValue empty() {
+ return (CacheValue) EMPTY;
+ }
}
}
diff --git a/hapi-fhir-validation/src/main/java/org/hl7/fhir/common/hapi/validation/support/ValidationSupportChainMetrics.java b/hapi-fhir-validation/src/main/java/org/hl7/fhir/common/hapi/validation/support/ValidationSupportChainMetrics.java
new file mode 100644
index 00000000000..05fb8229541
--- /dev/null
+++ b/hapi-fhir-validation/src/main/java/org/hl7/fhir/common/hapi/validation/support/ValidationSupportChainMetrics.java
@@ -0,0 +1,93 @@
+package org.hl7.fhir.common.hapi.validation.support;
+
+import ca.uhn.fhir.rest.api.Constants;
+import io.opentelemetry.api.GlobalOpenTelemetry;
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.metrics.BatchCallback;
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.api.metrics.MeterBuilder;
+import io.opentelemetry.api.metrics.ObservableLongMeasurement;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static io.opentelemetry.api.common.AttributeKey.stringKey;
+
+/**
+ * This class provides OpenTelemetry metrics for the {@link ValidationSupportChain} cache.
+ */
+public class ValidationSupportChainMetrics {
+
+ /*
+ * See ValidationSupportChainTest#testMetrics for a unit test
+ * which exercises the functionality in this class.
+ */
+
+ public static final String CLASS_OPENTELEMETRY_BASE_NAME =
+ Constants.OPENTELEMETRY_BASE_NAME + ".validation_support_chain";
+ static final String INSTRUMENTATION_NAME = CLASS_OPENTELEMETRY_BASE_NAME;
+ private static final AttributeKey INSTANCE_NAME = stringKey(INSTRUMENTATION_NAME + ".instance_name");
+ public static final String EXPIRING_CACHE_MAXIMUM_SIZE =
+ CLASS_OPENTELEMETRY_BASE_NAME + ".expiring_cache.maximum_size";
+ public static final String EXPIRING_CACHE_CURRENT_ENTRIES =
+ CLASS_OPENTELEMETRY_BASE_NAME + ".expiring_cache.current_entries";
+ public static final String NON_EXPIRING_CACHE_CURRENT_ENTRIES =
+ CLASS_OPENTELEMETRY_BASE_NAME + ".non_expiring_cache.current_entries";
+ private static final Logger ourLog = LoggerFactory.getLogger(ValidationSupportChainMetrics.class);
+ private final ValidationSupportChain myValidationSupportChain;
+ private BatchCallback myBatchCallback;
+
+ public ValidationSupportChainMetrics(ValidationSupportChain theValidationSupportChain) {
+ myValidationSupportChain = theValidationSupportChain;
+ }
+
+ public void start() {
+ OpenTelemetry openTelemetry = GlobalOpenTelemetry.get();
+ MeterBuilder meterBuilder = openTelemetry.getMeterProvider().meterBuilder(INSTRUMENTATION_NAME);
+ Meter meter = meterBuilder.build();
+
+ Attributes baseAttribute = Attributes.of(INSTANCE_NAME, myValidationSupportChain.getName());
+
+ ObservableLongMeasurement expiringCacheMaxSize = meter.gaugeBuilder(EXPIRING_CACHE_MAXIMUM_SIZE)
+ .ofLongs()
+ .setUnit("{entries}")
+ .setDescription("The maximum number of cache entries in the expiring cache.")
+ .buildObserver();
+ ObservableLongMeasurement expiringCacheCurrentEntries = meter.gaugeBuilder(EXPIRING_CACHE_CURRENT_ENTRIES)
+ .ofLongs()
+ .setUnit("{entries}")
+ .setDescription("The current number of cache entries in the expiring cache.")
+ .buildObserver();
+ ObservableLongMeasurement nonExpiringCacheCurrentEntries = meter.gaugeBuilder(
+ NON_EXPIRING_CACHE_CURRENT_ENTRIES)
+ .ofLongs()
+ .setUnit("{entries}")
+ .setDescription("The current number of cache entries in the non-expiring cache.")
+ .buildObserver();
+
+ myBatchCallback = meter.batchCallback(
+ () -> {
+ long expiringCacheEntries = myValidationSupportChain.getMetricExpiringCacheEntries();
+ int expiringCacheMaxSizeValue = myValidationSupportChain.getMetricExpiringCacheMaxSize();
+ int nonExpiringCacheEntries = myValidationSupportChain.getMetricNonExpiringCacheEntries();
+ ourLog.trace(
+ "ExpiringMax[{}] ExpiringEntries[{}] NonExpiringEntries[{}]",
+ expiringCacheMaxSizeValue,
+ expiringCacheEntries,
+ nonExpiringCacheEntries);
+ expiringCacheMaxSize.record(expiringCacheMaxSizeValue, baseAttribute);
+ expiringCacheCurrentEntries.record(expiringCacheEntries, baseAttribute);
+ nonExpiringCacheCurrentEntries.record(nonExpiringCacheEntries, baseAttribute);
+ },
+ expiringCacheMaxSize,
+ expiringCacheCurrentEntries,
+ nonExpiringCacheCurrentEntries);
+ }
+
+ public void stop() {
+ if (myBatchCallback != null) {
+ myBatchCallback.close();
+ }
+ }
+}
diff --git a/hapi-fhir-validation/src/main/java/org/hl7/fhir/common/hapi/validation/validator/VersionSpecificWorkerContextWrapper.java b/hapi-fhir-validation/src/main/java/org/hl7/fhir/common/hapi/validation/validator/VersionSpecificWorkerContextWrapper.java
index 393d8ce1dc5..ac4eb92581c 100644
--- a/hapi-fhir-validation/src/main/java/org/hl7/fhir/common/hapi/validation/validator/VersionSpecificWorkerContextWrapper.java
+++ b/hapi-fhir-validation/src/main/java/org/hl7/fhir/common/hapi/validation/validator/VersionSpecificWorkerContextWrapper.java
@@ -1,21 +1,23 @@
package org.hl7.fhir.common.hapi.validation.validator;
+import ca.uhn.fhir.context.FhirContext;
import ca.uhn.fhir.context.FhirVersionEnum;
import ca.uhn.fhir.context.support.ConceptValidationOptions;
+import ca.uhn.fhir.context.support.DefaultProfileValidationSupport;
import ca.uhn.fhir.context.support.IValidationSupport;
import ca.uhn.fhir.context.support.ValidationSupportContext;
import ca.uhn.fhir.i18n.Msg;
+import ca.uhn.fhir.rest.server.exceptions.BaseServerResponseException;
import ca.uhn.fhir.rest.server.exceptions.InternalErrorException;
-import ca.uhn.fhir.sl.cache.CacheFactory;
-import ca.uhn.fhir.sl.cache.LoadingCache;
-import ca.uhn.fhir.system.HapiSystemProperties;
import ca.uhn.hapi.converters.canonical.VersionCanonicalizer;
import jakarta.annotation.Nonnull;
import jakarta.annotation.Nullable;
import org.apache.commons.lang3.Validate;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
+import org.apache.commons.lang3.exception.ExceptionUtils;
import org.fhir.ucum.UcumService;
+import org.hl7.fhir.common.hapi.validation.support.SnapshotGeneratingValidationSupport;
import org.hl7.fhir.common.hapi.validation.support.ValidationSupportUtils;
import org.hl7.fhir.exceptions.FHIRException;
import org.hl7.fhir.exceptions.TerminologyServiceException;
@@ -23,6 +25,7 @@ import org.hl7.fhir.instance.model.api.IBaseResource;
import org.hl7.fhir.r5.context.IContextResourceLoader;
import org.hl7.fhir.r5.context.IWorkerContext;
import org.hl7.fhir.r5.context.IWorkerContextManager;
+import org.hl7.fhir.r5.fhirpath.FHIRPathEngine;
import org.hl7.fhir.r5.model.CodeSystem;
import org.hl7.fhir.r5.model.CodeableConcept;
import org.hl7.fhir.r5.model.Coding;
@@ -56,11 +59,13 @@ import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
+import java.util.stream.Collectors;
import static ca.uhn.fhir.context.support.IValidationSupport.CodeValidationIssueCoding.INVALID_DISPLAY;
import static java.util.stream.Collectors.collectingAndThen;
@@ -70,68 +75,33 @@ import static org.apache.commons.lang3.StringUtils.isNotBlank;
public class VersionSpecificWorkerContextWrapper extends I18nBase implements IWorkerContext {
private static final Logger ourLog = LoggerFactory.getLogger(VersionSpecificWorkerContextWrapper.class);
+
+ /**
+ * When we fetch conformance resources such as StructureDefinitions from {@link IValidationSupport}
+ * they will be returned using whatever version of FHIR the underlying infrastructure is
+ * configured to support. But we need to convert it to R5 since that's what the validator
+ * uses. In order to avoid repeated conversions, we put the converted version of the resource
+ * in the {@link org.hl7.fhir.instance.model.api.IAnyResource#getUserData(String)} map
+ * using this key. Since conformance resources returned by validation support are typically
+ * cached by {@link org.hl7.fhir.common.hapi.validation.support.ValidationSupportChain},
+ * the converted version gets cached too.
+ */
+ private static final String CANONICAL_USERDATA_KEY =
+ VersionSpecificWorkerContextWrapper.class.getName() + "_CANONICAL_USERDATA_KEY";
+
+ public static final FhirContext FHIR_CONTEXT_R5 = FhirContext.forR5();
private final ValidationSupportContext myValidationSupportContext;
private final VersionCanonicalizer myVersionCanonicalizer;
- private final LoadingCache myFetchResourceCache;
private volatile List myAllStructures;
private volatile Set myAllPrimitiveTypes;
private Parameters myExpansionProfile;
+ private volatile FHIRPathEngine myFHIRPathEngine;
public VersionSpecificWorkerContextWrapper(
ValidationSupportContext theValidationSupportContext, VersionCanonicalizer theVersionCanonicalizer) {
myValidationSupportContext = theValidationSupportContext;
myVersionCanonicalizer = theVersionCanonicalizer;
- long timeoutMillis = HapiSystemProperties.getTestValidationResourceCachesMs();
-
- myFetchResourceCache = CacheFactory.build(timeoutMillis, 10000, key -> {
- String fetchResourceName = key.getResourceName();
- if (myValidationSupportContext
- .getRootValidationSupport()
- .getFhirContext()
- .getVersion()
- .getVersion()
- == FhirVersionEnum.DSTU2) {
- if ("CodeSystem".equals(fetchResourceName)) {
- fetchResourceName = "ValueSet";
- }
- }
-
- Class fetchResourceType;
- if (fetchResourceName.equals("Resource")) {
- fetchResourceType = null;
- } else {
- fetchResourceType = myValidationSupportContext
- .getRootValidationSupport()
- .getFhirContext()
- .getResourceDefinition(fetchResourceName)
- .getImplementingClass();
- }
-
- IBaseResource fetched = myValidationSupportContext
- .getRootValidationSupport()
- .fetchResource(fetchResourceType, key.getUri());
-
- Resource canonical = myVersionCanonicalizer.resourceToValidatorCanonical(fetched);
-
- if (canonical instanceof StructureDefinition) {
- StructureDefinition canonicalSd = (StructureDefinition) canonical;
- if (canonicalSd.getSnapshot().isEmpty()) {
- ourLog.info("Generating snapshot for StructureDefinition: {}", canonicalSd.getUrl());
- fetched = myValidationSupportContext
- .getRootValidationSupport()
- .generateSnapshot(theValidationSupportContext, fetched, "", null, "");
- Validate.isTrue(
- fetched != null,
- "StructureDefinition %s has no snapshot, and no snapshot generator is configured",
- key.getUri());
- canonical = myVersionCanonicalizer.resourceToValidatorCanonical(fetched);
- }
- }
-
- return canonical;
- });
-
setValidationMessageLanguage(getLocale());
}
@@ -237,21 +207,45 @@ public class VersionSpecificWorkerContextWrapper extends I18nBase implements IWo
myExpansionProfile = expParameters;
}
- private List allStructures() {
+ private List allStructureDefinitions() {
List retVal = myAllStructures;
if (retVal == null) {
- retVal = new ArrayList<>();
- for (IBaseResource next :
- myValidationSupportContext.getRootValidationSupport().fetchAllStructureDefinitions()) {
- try {
- StructureDefinition converted = myVersionCanonicalizer.structureDefinitionToCanonical(next);
- retVal.add(converted);
- } catch (FHIRException e) {
- throw new InternalErrorException(Msg.code(659) + e);
- }
- }
+ List allStructureDefinitions =
+ myValidationSupportContext.getRootValidationSupport().fetchAllStructureDefinitions();
+ assert allStructureDefinitions != null;
+
+ /*
+ * This method (allStructureDefinitions()) gets called recursively - As we
+ * try to return all StructureDefinitions, we want to generate snapshots for
+ * any that don't already have a snapshot. But the snapshot generator in turn
+ * also calls allStructureDefinitions() - That specific call doesn't require
+ * that the returned SDs have snapshots generated though.
+ *
+ * So, we first just convert to canonical version and store a list containing
+ * the canonical versions. That way any recursive calls will return the
+ * stored list. But after that we'll generate all the snapshots and
+ * store that list instead. If the canonicalization fails with an
+ * unexpected exception, we wipe the stored list. This is probably an
+ * unrecoverable failure since this method will probably always
+ * fail if it fails once. But at least this way we're likley to
+ * generate useful error messages for the user.
+ */
+ retVal = allStructureDefinitions.stream()
+ .map(t -> myVersionCanonicalizer.structureDefinitionToCanonical(t))
+ .collect(Collectors.toList());
myAllStructures = retVal;
+
+ try {
+ for (IBaseResource next : allStructureDefinitions) {
+ Resource converted = convertToCanonicalVersionAndGenerateSnapshot(next, false);
+ retVal.add((StructureDefinition) converted);
+ }
+ myAllStructures = retVal;
+ } catch (Exception e) {
+ ourLog.error("Failure during snapshot generation", e);
+ myAllStructures = null;
+ }
}
return retVal;
@@ -477,9 +471,9 @@ public class VersionSpecificWorkerContextWrapper extends I18nBase implements IWo
}
}
- ResourceKey key = new ResourceKey(class_.getSimpleName(), uri);
+ String resourceType = getResourceType(class_);
@SuppressWarnings("unchecked")
- T retVal = (T) myFetchResourceCache.get(key);
+ T retVal = (T) fetchResource(resourceType, uri);
return retVal;
}
@@ -574,7 +568,7 @@ public class VersionSpecificWorkerContextWrapper extends I18nBase implements IWo
@Override
public List fetchTypeDefinitions(String theTypeName) {
- List allStructures = new ArrayList<>(allStructures());
+ List allStructures = new ArrayList<>(allStructureDefinitions());
allStructures.removeIf(sd -> !sd.hasType() || !sd.getType().equals(theTypeName));
return allStructures;
}
@@ -593,7 +587,7 @@ public class VersionSpecificWorkerContextWrapper extends I18nBase implements IWo
Set retVal = myAllPrimitiveTypes;
if (retVal == null) {
// Collector may be changed to Collectors.toUnmodifiableSet() when switching to Android API level >= 33
- retVal = allStructures().stream()
+ retVal = allStructureDefinitions().stream()
.filter(structureDefinition ->
structureDefinition.getKind() == StructureDefinition.StructureDefinitionKind.PRIMITIVETYPE)
.map(StructureDefinition::getName)
@@ -636,8 +630,15 @@ public class VersionSpecificWorkerContextWrapper extends I18nBase implements IWo
return false;
}
- ResourceKey key = new ResourceKey(class_.getSimpleName(), uri);
- return myFetchResourceCache.get(key) != null;
+ String resourceType = getResourceType(class_);
+ return fetchResource(resourceType, uri) != null;
+ }
+
+ private static String getResourceType(Class theClass) {
+ if (theClass.getSimpleName().equals("Resource")) {
+ return "Resource";
+ }
+ return FHIR_CONTEXT_R5.getResourceType(theClass);
}
@Override
@@ -815,7 +816,7 @@ public class VersionSpecificWorkerContextWrapper extends I18nBase implements IWo
.getRootValidationSupport()
.validateCodeInValueSet(
myValidationSupportContext, theValidationOptions, theSystem, theCode, theDisplay, theValueSet);
- if (result != null && theSystem != null) {
+ if (result != null && isNotBlank(theSystem)) {
/* We got a value set result, which could be successful, or could contain errors/warnings. The code
might also be invalid in the code system, so we will check that as well and add those issues
to our result.
@@ -878,7 +879,7 @@ public class VersionSpecificWorkerContextWrapper extends I18nBase implements IWo
}
if (code.getCoding().size() > 0) {
- if (!myValidationSupportContext.isEnabledValidationForCodingsLogicalAnd()) {
+ if (!myValidationSupportContext.isCodeableConceptValidationSuccessfulIfNotAllCodingsAreValid()) {
if (validationResultsOk.size() == code.getCoding().size()) {
return validationResultsOk.get(0);
}
@@ -905,13 +906,13 @@ public class VersionSpecificWorkerContextWrapper extends I18nBase implements IWo
}
public void invalidateCaches() {
- myFetchResourceCache.invalidateAll();
+ // nothing for now
}
@Override
public List fetchResourcesByType(Class theClass) {
if (theClass.equals(StructureDefinition.class)) {
- return (List) allStructures();
+ return (List) allStructureDefinitions();
}
throw new UnsupportedOperationException(Msg.code(650) + "Unable to fetch resources of type: " + theClass);
}
@@ -1033,4 +1034,109 @@ public class VersionSpecificWorkerContextWrapper extends I18nBase implements IWo
public boolean isServerSideSystem(String url) {
return false;
}
+
+ private IBaseResource fetchResource(String theResourceType, String theUrl) {
+ String fetchResourceName = theResourceType;
+ if (myValidationSupportContext
+ .getRootValidationSupport()
+ .getFhirContext()
+ .getVersion()
+ .getVersion()
+ == FhirVersionEnum.DSTU2) {
+ if ("CodeSystem".equals(fetchResourceName)) {
+ fetchResourceName = "ValueSet";
+ }
+ }
+
+ Class fetchResourceType;
+ if (fetchResourceName.equals("Resource")) {
+ fetchResourceType = null;
+ } else {
+ fetchResourceType = myValidationSupportContext
+ .getRootValidationSupport()
+ .getFhirContext()
+ .getResourceDefinition(fetchResourceName)
+ .getImplementingClass();
+ }
+
+ IBaseResource fetched =
+ myValidationSupportContext.getRootValidationSupport().fetchResource(fetchResourceType, theUrl);
+
+ if (fetched == null) {
+ return null;
+ }
+
+ return convertToCanonicalVersionAndGenerateSnapshot(fetched, true);
+ }
+
+ private Resource convertToCanonicalVersionAndGenerateSnapshot(
+ @Nonnull IBaseResource theResource, boolean thePropagateSnapshotException) {
+ Resource canonical;
+ synchronized (theResource) {
+ canonical = (Resource) theResource.getUserData(CANONICAL_USERDATA_KEY);
+ if (canonical == null) {
+ boolean storeCanonical = true;
+ canonical = myVersionCanonicalizer.resourceToValidatorCanonical(theResource);
+
+ if (canonical instanceof StructureDefinition) {
+ StructureDefinition canonicalSd = (StructureDefinition) canonical;
+ if (canonicalSd.getSnapshot().isEmpty()) {
+ ourLog.info("Generating snapshot for StructureDefinition: {}", canonicalSd.getUrl());
+ IBaseResource resource = theResource;
+ try {
+
+ FhirContext fhirContext = myValidationSupportContext
+ .getRootValidationSupport()
+ .getFhirContext();
+ SnapshotGeneratingValidationSupport snapshotGenerator =
+ new SnapshotGeneratingValidationSupport(fhirContext, this, getFHIRPathEngine());
+ resource = snapshotGenerator.generateSnapshot(
+ myValidationSupportContext, resource, "", null, "");
+ Validate.isTrue(
+ resource != null,
+ "StructureDefinition %s has no snapshot, and no snapshot generator is configured",
+ canonicalSd.getUrl());
+
+ } catch (BaseServerResponseException e) {
+ if (thePropagateSnapshotException) {
+ throw e;
+ }
+ String message = e.toString();
+ Throwable rootCause = ExceptionUtils.getRootCause(e);
+ if (rootCause != null) {
+ message = rootCause.getMessage();
+ }
+ ourLog.warn(
+ "Failed to generate snapshot for profile with URL[{}]: {}",
+ canonicalSd.getUrl(),
+ message);
+ storeCanonical = false;
+ }
+
+ canonical = myVersionCanonicalizer.resourceToValidatorCanonical(resource);
+ }
+ }
+
+ String sourcePackageId =
+ (String) theResource.getUserData(DefaultProfileValidationSupport.SOURCE_PACKAGE_ID);
+ if (sourcePackageId != null) {
+ canonical.setSourcePackage(new PackageInformation(sourcePackageId, null, null, new Date()));
+ }
+
+ if (storeCanonical) {
+ theResource.setUserData(CANONICAL_USERDATA_KEY, canonical);
+ }
+ }
+ }
+ return canonical;
+ }
+
+ private FHIRPathEngine getFHIRPathEngine() {
+ FHIRPathEngine retVal = myFHIRPathEngine;
+ if (retVal == null) {
+ retVal = new FHIRPathEngine(this);
+ myFHIRPathEngine = retVal;
+ }
+ return retVal;
+ }
}
diff --git a/hapi-fhir-validation/src/test/java/org/hl7/fhir/common/hapi/validation/support/CachingValidationSupportTest.java b/hapi-fhir-validation/src/test/java/org/hl7/fhir/common/hapi/validation/support/CachingValidationSupportTest.java
index 6eb2894630e..d59fe708c0d 100644
--- a/hapi-fhir-validation/src/test/java/org/hl7/fhir/common/hapi/validation/support/CachingValidationSupportTest.java
+++ b/hapi-fhir-validation/src/test/java/org/hl7/fhir/common/hapi/validation/support/CachingValidationSupportTest.java
@@ -7,6 +7,7 @@ import jakarta.annotation.Nonnull;
import jakarta.annotation.Nullable;
import org.hl7.fhir.instance.model.api.IBaseResource;
import org.hl7.fhir.r4.model.StructureDefinition;
+import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.NullSource;
@@ -21,98 +22,43 @@ import static ca.uhn.fhir.util.TestUtil.sleepAtLeast;
import static org.assertj.core.api.Assertions.assertThat;
import static org.awaitility.Awaitility.await;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+/**
+ * CachingValidationSupport is deprecated and is just a passthrough now. This
+ * test verifies that it works that way.
+ */
+@SuppressWarnings("removal")
@ExtendWith(MockitoExtension.class)
public class CachingValidationSupportTest {
private static final FhirContext ourCtx = FhirContext.forR4Cached();
@Mock
- private IValidationSupport myValidationSupport;
+ private IValidationSupport myValidationSupport0;
- @ParameterizedTest
- @NullSource
- @ValueSource(booleans = {true, false})
- public void testAsyncBackgroundLoading(Boolean theIsEnabledValidationForCodingsLogicalAnd) {
- StructureDefinition sd0 = (StructureDefinition) new StructureDefinition().setId("SD0");
- StructureDefinition sd1 = (StructureDefinition) new StructureDefinition().setId("SD1");
- StructureDefinition sd2 = (StructureDefinition) new StructureDefinition().setId("SD2");
- List responses = Collections.synchronizedList(Lists.newArrayList(
- sd0, sd1, sd2
- ));
+ @Test
+ public void testNoCaching() {
+ when(myValidationSupport0.getFhirContext()).thenReturn(ourCtx);
+ when(myValidationSupport0.fetchStructureDefinition(any())).thenAnswer(t->new StructureDefinition());
- when(myValidationSupport.getFhirContext()).thenReturn(ourCtx);
- when(myValidationSupport.fetchAllNonBaseStructureDefinitions()).thenAnswer(t -> {
- Thread.sleep(2000);
- return Collections.singletonList(responses.remove(0));
- });
+ CachingValidationSupport support = new CachingValidationSupport(myValidationSupport0);
- final CachingValidationSupport.CacheTimeouts cacheTimeouts = CachingValidationSupport.CacheTimeouts
- .defaultValues()
- .setMiscMillis(1000);
- final CachingValidationSupport support = getSupport(cacheTimeouts, theIsEnabledValidationForCodingsLogicalAnd);
-
- assertThat(responses).hasSize(3);
- List fetched = support.fetchAllNonBaseStructureDefinitions();
- assert fetched != null;
- assertThat(fetched.get(0)).isSameAs(sd0);
- assertThat(responses).hasSize(2);
-
- sleepAtLeast(1200);
- fetched = support.fetchAllNonBaseStructureDefinitions();
- assert fetched != null;
- assertThat(fetched.get(0)).isSameAs(sd0);
- assertThat(responses).hasSize(2);
-
- await().until(() -> responses.size() == 1);
- assertThat(responses).hasSize(1);
- fetched = support.fetchAllNonBaseStructureDefinitions();
- assert fetched != null;
- assertThat(fetched.get(0)).isSameAs(sd1);
- assertThat(responses).hasSize(1);
-
- assertEquals(theIsEnabledValidationForCodingsLogicalAnd != null && theIsEnabledValidationForCodingsLogicalAnd, support.isEnabledValidationForCodingsLogicalAnd());
+ IBaseResource actual0 = support.fetchStructureDefinition("http://foo");
+ IBaseResource actual1 = support.fetchStructureDefinition("http://foo");
+ assertNotSame(actual0, actual1);
}
- @ParameterizedTest
- @NullSource
- @ValueSource(booleans = {true, false})
- public void fetchBinary_normally_accessesSuperOnlyOnce(Boolean theIsEnabledValidationForCodingsLogicalAnd) {
- final byte[] EXPECTED_BINARY = "dummyBinaryContent".getBytes();
- final String EXPECTED_BINARY_KEY = "dummyBinaryKey";
- when(myValidationSupport.getFhirContext()).thenReturn(ourCtx);
- when(myValidationSupport.fetchBinary(EXPECTED_BINARY_KEY)).thenReturn(EXPECTED_BINARY);
-
- final CachingValidationSupport support = getSupport(null, theIsEnabledValidationForCodingsLogicalAnd);
-
- final byte[] firstActualBinary = support.fetchBinary(EXPECTED_BINARY_KEY);
- assertEquals(EXPECTED_BINARY, firstActualBinary);
- verify(myValidationSupport, times(1)).fetchBinary(EXPECTED_BINARY_KEY);
-
- final byte[] secondActualBinary = support.fetchBinary(EXPECTED_BINARY_KEY);
- assertEquals(EXPECTED_BINARY, secondActualBinary);
- verify(myValidationSupport, times(1)).fetchBinary(EXPECTED_BINARY_KEY);
-
- assertEquals(theIsEnabledValidationForCodingsLogicalAnd != null && theIsEnabledValidationForCodingsLogicalAnd, support.isEnabledValidationForCodingsLogicalAnd());
+ @Test
+ public void testEnabledValidationForCodingsLogicalAnd() {
+ when(myValidationSupport0.getFhirContext()).thenReturn(ourCtx);
+ CachingValidationSupport support = new CachingValidationSupport(myValidationSupport0, true);
+ assertTrue(support.isCodeableConceptValidationSuccessfulIfNotAllCodingsAreValid());
}
- @Nonnull
- private CachingValidationSupport getSupport(@Nullable CachingValidationSupport.CacheTimeouts theCacheTimeouts, @Nullable Boolean theIsEnabledValidationForCodingsLogicalAnd) {
- if (theCacheTimeouts == null) {
- if (theIsEnabledValidationForCodingsLogicalAnd == null) {
- return new CachingValidationSupport(myValidationSupport);
- }
-
- return new CachingValidationSupport(myValidationSupport, theIsEnabledValidationForCodingsLogicalAnd);
- }
-
- if (theIsEnabledValidationForCodingsLogicalAnd == null) {
- return new CachingValidationSupport(myValidationSupport, theCacheTimeouts);
- }
-
- return new CachingValidationSupport(myValidationSupport, theCacheTimeouts, theIsEnabledValidationForCodingsLogicalAnd);
- }
}
diff --git a/hapi-fhir-validation/src/test/java/org/hl7/fhir/common/hapi/validation/support/ValidationSupportChainTest.java b/hapi-fhir-validation/src/test/java/org/hl7/fhir/common/hapi/validation/support/ValidationSupportChainTest.java
index cbb8f87ac4d..c04c9af3376 100644
--- a/hapi-fhir-validation/src/test/java/org/hl7/fhir/common/hapi/validation/support/ValidationSupportChainTest.java
+++ b/hapi-fhir-validation/src/test/java/org/hl7/fhir/common/hapi/validation/support/ValidationSupportChainTest.java
@@ -2,41 +2,108 @@ package org.hl7.fhir.common.hapi.validation.support;
import ca.uhn.fhir.context.ConfigurationException;
import ca.uhn.fhir.context.FhirContext;
-import ca.uhn.fhir.context.FhirVersionEnum;
+import ca.uhn.fhir.context.support.ConceptValidationOptions;
import ca.uhn.fhir.context.support.DefaultProfileValidationSupport;
import ca.uhn.fhir.context.support.IValidationSupport;
-import ca.uhn.fhir.fhirpath.BaseValidationTestWithInlineMocks;
+import ca.uhn.fhir.context.support.LookupCodeRequest;
+import ca.uhn.fhir.context.support.TranslateConceptResult;
+import ca.uhn.fhir.context.support.TranslateConceptResults;
+import ca.uhn.fhir.context.support.ValidationSupportContext;
+import ca.uhn.fhir.context.support.ValueSetExpansionOptions;
import ca.uhn.fhir.i18n.Msg;
+import ca.uhn.fhir.test.BaseTest;
+import ca.uhn.fhir.util.TestUtil;
+import com.google.common.collect.Lists;
+import io.opentelemetry.instrumentation.testing.LibraryTestRunner;
+import io.opentelemetry.sdk.metrics.data.Data;
+import io.opentelemetry.sdk.metrics.data.LongPointData;
+import io.opentelemetry.sdk.metrics.data.MetricData;
+import jakarta.annotation.Nonnull;
+import org.hl7.fhir.instance.model.api.IBaseResource;
+import org.hl7.fhir.r4.model.ListResource;
+import org.hl7.fhir.r4.model.SearchParameter;
+import org.hl7.fhir.r4.model.StructureDefinition;
+import org.hl7.fhir.r4.model.ValueSet;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.awaitility.Awaitility.await;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.mockito.Mockito.mock;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
-public class ValidationSupportChainTest extends BaseValidationTestWithInlineMocks {
+@ExtendWith(MockitoExtension.class)
+public class ValidationSupportChainTest extends BaseTest {
+ public static final String CODE_SYSTEM_URL_0 = "http://code-system-url-0";
+ public static final String CODE_0 = "code-0";
+ public static final String DISPLAY_0 = "display-0";
+ public static final String VALUE_SET_URL_0 = "http://value-set-url-0";
+ private static final Logger ourLog = LoggerFactory.getLogger(ValidationSupportChainTest.class);
+ @Mock(strictness = Mock.Strictness.LENIENT)
+ private IValidationSupport myValidationSupport0;
+ @Mock(strictness = Mock.Strictness.LENIENT)
+ private IValidationSupport myValidationSupport1;
+ @Mock(strictness = Mock.Strictness.LENIENT)
+ private IValidationSupport myValidationSupport2;
@Test
public void testVersionCheck() {
-
- DefaultProfileValidationSupport ctx3 = new DefaultProfileValidationSupport(FhirContext.forDstu3());
- DefaultProfileValidationSupport ctx4 = new DefaultProfileValidationSupport(FhirContext.forR4());
+ DefaultProfileValidationSupport ctx3 = new DefaultProfileValidationSupport(FhirContext.forDstu3Cached());
+ DefaultProfileValidationSupport ctx4 = new DefaultProfileValidationSupport(FhirContext.forR4Cached());
try {
new ValidationSupportChain(ctx3, ctx4);
} catch (ConfigurationException e) {
assertEquals(Msg.code(709) + "Trying to add validation support of version R4 to chain with 1 entries of version DSTU3", e.getMessage());
}
+ }
+
+
+ @Test
+ public void testFetchIndividualStructureDefinitionThenAll() {
+ DefaultProfileValidationSupport ctx = new DefaultProfileValidationSupport(FhirContext.forR4Cached());
+ ValidationSupportChain chain = new ValidationSupportChain(ctx);
+
+ assertNotNull(chain.fetchStructureDefinition("http://hl7.org/fhir/StructureDefinition/Patient"));
+ assertEquals(649, chain.fetchAllStructureDefinitions().size());
}
+
@Test
public void testMissingContext() {
- IValidationSupport ctx = mock(IValidationSupport.class);
+ when(myValidationSupport0.getFhirContext()).thenReturn(null);
+
try {
- new ValidationSupportChain(ctx);
+ new ValidationSupportChain(myValidationSupport0);
} catch (ConfigurationException e) {
assertEquals(Msg.code(708) + "Can not add validation support: getFhirContext() returns null", e.getMessage());
}
@@ -44,39 +111,657 @@ public class ValidationSupportChainTest extends BaseValidationTestWithInlineMock
@Test
public void fetchBinary_normally_returnsExpectedBinaries() {
-
+ // Setup
final byte[] EXPECTED_BINARY_CONTENT_1 = "dummyBinaryContent1".getBytes();
final byte[] EXPECTED_BINARY_CONTENT_2 = "dummyBinaryContent2".getBytes();
final String EXPECTED_BINARY_KEY_1 = "dummyBinaryKey1";
final String EXPECTED_BINARY_KEY_2 = "dummyBinaryKey2";
+ prepareMock(myValidationSupport0);
+ prepareMock(myValidationSupport1);
+ createMockValidationSupportWithSingleBinary(myValidationSupport0, EXPECTED_BINARY_KEY_1, EXPECTED_BINARY_CONTENT_1);
+ createMockValidationSupportWithSingleBinary(myValidationSupport1, EXPECTED_BINARY_KEY_2, EXPECTED_BINARY_CONTENT_2);
- IValidationSupport validationSupport1 = createMockValidationSupportWithSingleBinary(EXPECTED_BINARY_KEY_1, EXPECTED_BINARY_CONTENT_1);
- IValidationSupport validationSupport2 = createMockValidationSupportWithSingleBinary(EXPECTED_BINARY_KEY_2, EXPECTED_BINARY_CONTENT_2);
-
- ValidationSupportChain validationSupportChain = new ValidationSupportChain(validationSupport1, validationSupport2);
-
- final byte[] actualBinaryContent1 = validationSupportChain.fetchBinary(EXPECTED_BINARY_KEY_1 );
- final byte[] actualBinaryContent2 = validationSupportChain.fetchBinary(EXPECTED_BINARY_KEY_2 );
+ // Test
+ ValidationSupportChain validationSupportChain = new ValidationSupportChain(myValidationSupport0, myValidationSupport1);
+ final byte[] actualBinaryContent1 = validationSupportChain.fetchBinary(EXPECTED_BINARY_KEY_1);
+ final byte[] actualBinaryContent2 = validationSupportChain.fetchBinary(EXPECTED_BINARY_KEY_2);
+ // Verify
assertThat(actualBinaryContent1).containsExactly(EXPECTED_BINARY_CONTENT_1);
assertThat(actualBinaryContent2).containsExactly(EXPECTED_BINARY_CONTENT_2);
assertNull(validationSupportChain.fetchBinary("nonExistentKey"));
}
+ @ParameterizedTest
+ @ValueSource(booleans = {true, false})
+ public void testValidateCode_WithValueSetUrl(boolean theUseCache) {
+ // Setup
+ prepareMock(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ ValidationSupportChain chain = new ValidationSupportChain(newCacheConfiguration(theUseCache), myValidationSupport0, myValidationSupport1, myValidationSupport2);
- private static IValidationSupport createMockValidationSupport() {
- IValidationSupport validationSupport;
- validationSupport = mock(IValidationSupport.class);
- FhirContext mockContext = mock(FhirContext.class);
- when(mockContext.getVersion()).thenReturn(FhirVersionEnum.R4.getVersionImplementation());
- when(validationSupport.getFhirContext()).thenReturn(mockContext);
- return validationSupport;
+ when(myValidationSupport0.isValueSetSupported(any(), eq(VALUE_SET_URL_0))).thenReturn(false);
+ when(myValidationSupport1.isValueSetSupported(any(), eq(VALUE_SET_URL_0))).thenReturn(true);
+ when(myValidationSupport1.validateCode(any(), any(), any(), any(), any(), any())).thenAnswer(t -> new IValidationSupport.CodeValidationResult());
+
+ // Test
+ IValidationSupport.CodeValidationResult result = chain.validateCode(newValidationCtx(chain), new ConceptValidationOptions(), CODE_SYSTEM_URL_0, CODE_0, DISPLAY_0, VALUE_SET_URL_0);
+
+ // Verify
+ verify(myValidationSupport0, times(1)).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport1, times(1)).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport2, never()).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport0, never()).validateCode(any(), any(), any(), any(), any(), any());
+ verify(myValidationSupport1, times(1)).validateCode(any(), any(), any(), any(), any(), any());
+ verify(myValidationSupport2, never()).validateCode(any(), any(), any(), any(), any(), any());
+
+ // Setup for second execution (should use cache this time)
+ prepareMock(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ when(myValidationSupport0.isValueSetSupported(any(), eq(VALUE_SET_URL_0))).thenReturn(false);
+ when(myValidationSupport1.isValueSetSupported(any(), eq(VALUE_SET_URL_0))).thenReturn(true);
+ when(myValidationSupport1.validateCode(any(), any(), any(), any(), any(), any())).thenAnswer(t -> new IValidationSupport.CodeValidationResult());
+
+ // Test again (should use cache)
+ IValidationSupport.CodeValidationResult result2 = chain.validateCode(newValidationCtx(chain), new ConceptValidationOptions(), CODE_SYSTEM_URL_0, CODE_0, DISPLAY_0, VALUE_SET_URL_0);
+
+ // Verify
+ if (theUseCache) {
+ assertSame(result, result2);
+ verifyNoInteractions(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ } else {
+ assertNotSame(result, result2);
+ verify(myValidationSupport0, times(1)).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport1, times(1)).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport2, never()).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport0, never()).validateCode(any(), any(), any(), any(), any(), any());
+ verify(myValidationSupport1, times(1)).validateCode(any(), any(), any(), any(), any(), any());
+ verify(myValidationSupport2, never()).validateCode(any(), any(), any(), any(), any(), any());
+ }
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {true, false})
+ public void testValidateCode_WithoutValueSetUrl(boolean theUseCache) {
+ // Setup
+ prepareMock(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ ValidationSupportChain chain = new ValidationSupportChain(newCacheConfiguration(theUseCache), myValidationSupport0, myValidationSupport1, myValidationSupport2);
+
+ when(myValidationSupport0.isCodeSystemSupported(any(), eq(CODE_SYSTEM_URL_0))).thenReturn(false);
+ when(myValidationSupport1.isCodeSystemSupported(any(), eq(CODE_SYSTEM_URL_0))).thenReturn(true);
+ when(myValidationSupport1.validateCode(any(), any(), any(), any(), any(), any())).thenAnswer(t -> new IValidationSupport.CodeValidationResult());
+
+ // Test
+ IValidationSupport.CodeValidationResult result = chain.validateCode(newValidationCtx(chain), new ConceptValidationOptions(), CODE_SYSTEM_URL_0, CODE_0, DISPLAY_0, null);
+
+ // Verify
+ verify(myValidationSupport0, times(1)).isCodeSystemSupported(any(), eq(CODE_SYSTEM_URL_0));
+ verify(myValidationSupport1, times(1)).isCodeSystemSupported(any(), eq(CODE_SYSTEM_URL_0));
+ verify(myValidationSupport2, never()).isCodeSystemSupported(any(), any());
+ verify(myValidationSupport0, never()).validateCode(any(), any(), any(), any(), any(), any());
+ verify(myValidationSupport1, times(1)).validateCode(any(), any(), any(), any(), any(), any());
+ verify(myValidationSupport2, never()).validateCode(any(), any(), any(), any(), any(), any());
+
+ // Setup for second execution (should use cache this time)
+ prepareMock(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ when(myValidationSupport0.isCodeSystemSupported(any(), eq(CODE_SYSTEM_URL_0))).thenReturn(false);
+ when(myValidationSupport1.isCodeSystemSupported(any(), eq(CODE_SYSTEM_URL_0))).thenReturn(true);
+ when(myValidationSupport1.validateCode(any(), any(), any(), any(), any(), any())).thenAnswer(t -> new IValidationSupport.CodeValidationResult());
+
+ // Test again (should use cache)
+ IValidationSupport.CodeValidationResult result2 = chain.validateCode(newValidationCtx(chain), new ConceptValidationOptions(), CODE_SYSTEM_URL_0, CODE_0, DISPLAY_0, null);
+
+ // Verify
+ if (theUseCache) {
+ assertSame(result, result2);
+ verifyNoInteractions(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ } else {
+ assertNotSame(result, result2);
+ verify(myValidationSupport0, times(1)).isCodeSystemSupported(any(), eq(CODE_SYSTEM_URL_0));
+ verify(myValidationSupport1, times(1)).isCodeSystemSupported(any(), eq(CODE_SYSTEM_URL_0));
+ verify(myValidationSupport2, never()).isCodeSystemSupported(any(), any());
+ verify(myValidationSupport0, never()).validateCode(any(), any(), any(), any(), any(), any());
+ verify(myValidationSupport1, times(1)).validateCode(any(), any(), any(), any(), any(), any());
+ verify(myValidationSupport2, never()).validateCode(any(), any(), any(), any(), any(), any());
+ }
+ }
+
+ @ParameterizedTest
+ @CsvSource({
+ "true, true",
+ "true, false",
+ "false, true",
+ "false, false",
+ })
+ public void testValidateCodeInValueSet(boolean theUseCache, boolean theValueSetHasUrl) {
+ // Setup
+ prepareMock(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ ValidationSupportChain chain = new ValidationSupportChain(newCacheConfiguration(theUseCache), myValidationSupport0, myValidationSupport1, myValidationSupport2);
+
+ when(myValidationSupport0.isValueSetSupported(any(), eq(VALUE_SET_URL_0))).thenReturn(false);
+ when(myValidationSupport1.isValueSetSupported(any(), eq(VALUE_SET_URL_0))).thenReturn(true);
+ when(myValidationSupport1.validateCodeInValueSet(any(), any(), any(), any(), any(), any())).thenAnswer(t -> new IValidationSupport.CodeValidationResult());
+
+ ValueSet inputValueSet = new ValueSet();
+ if (theValueSetHasUrl) {
+ inputValueSet.setUrl(VALUE_SET_URL_0);
+ }
+
+ // Test
+ IValidationSupport.CodeValidationResult result = chain.validateCodeInValueSet(newValidationCtx(chain), new ConceptValidationOptions(), CODE_SYSTEM_URL_0, CODE_0, DISPLAY_0, inputValueSet);
+
+ // Verify
+ if (theValueSetHasUrl) {
+ verify(myValidationSupport0, times(1)).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport1, times(1)).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport2, never()).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport0, never()).validateCodeInValueSet(any(), any(), any(), any(), any(), any());
+ verify(myValidationSupport1, times(1)).validateCodeInValueSet(any(), any(), any(), any(), any(), any());
+ verify(myValidationSupport2, never()).validateCodeInValueSet(any(), any(), any(), any(), any(), any());
+ } else {
+ verify(myValidationSupport0, never()).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport1, never()).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport2, never()).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport0, times(1)).validateCodeInValueSet(any(), any(), any(), any(), any(), any());
+ verify(myValidationSupport1, times(1)).validateCodeInValueSet(any(), any(), any(), any(), any(), any());
+ verify(myValidationSupport2, never()).validateCodeInValueSet(any(), any(), any(), any(), any(), any());
+ }
+
+ // Setup for second execution (should use cache this time)
+ prepareMock(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ when(myValidationSupport0.isValueSetSupported(any(), eq(VALUE_SET_URL_0))).thenReturn(false);
+ when(myValidationSupport1.isValueSetSupported(any(), eq(VALUE_SET_URL_0))).thenReturn(true);
+ when(myValidationSupport1.validateCodeInValueSet(any(), any(), any(), any(), any(), any())).thenAnswer(t -> new IValidationSupport.CodeValidationResult());
+
+ // Test again (should use cache)
+ IValidationSupport.CodeValidationResult result2 = chain.validateCodeInValueSet(newValidationCtx(chain), new ConceptValidationOptions(), CODE_SYSTEM_URL_0, CODE_0, DISPLAY_0, inputValueSet);
+
+ // Verify
+ if (theUseCache && theValueSetHasUrl) {
+ assertSame(result, result2);
+ if (theValueSetHasUrl) {
+ verify(myValidationSupport0, times(1)).getFhirContext();
+ }
+ verifyNoMoreInteractions(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ } else {
+ assertNotSame(result, result2);
+ if (theValueSetHasUrl) {
+ verify(myValidationSupport0, times(1)).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport1, times(1)).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport2, never()).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport0, never()).validateCodeInValueSet(any(), any(), any(), any(), any(), any());
+ } else {
+ verify(myValidationSupport0, never()).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport1, never()).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport2, never()).isValueSetSupported(any(), eq(VALUE_SET_URL_0));
+ verify(myValidationSupport0, times(1)).validateCodeInValueSet(any(), any(), any(), any(), any(), any());
+ }
+
+ verify(myValidationSupport1, times(1)).validateCodeInValueSet(any(), any(), any(), any(), any(), any());
+ verify(myValidationSupport2, never()).validateCodeInValueSet(any(), any(), any(), any(), any(), any());
+ }
+ }
+
+ @ParameterizedTest
+ @CsvSource({
+ "true, true",
+ "true, false",
+ "false, true",
+ "false, false",
+ })
+ public void testExpandValueSet_ValueSetParam(boolean theUseCache, boolean theValueSetHasUrl) {
+ // Setup
+ prepareMock(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ ValidationSupportChain chain = new ValidationSupportChain(newCacheConfiguration(theUseCache), myValidationSupport0, myValidationSupport1, myValidationSupport2);
+
+ when(myValidationSupport0.isValueSetSupported(any(), eq(VALUE_SET_URL_0))).thenReturn(true);
+ when(myValidationSupport0.expandValueSet(any(), any(), any(IBaseResource.class))).thenReturn(null);
+ when(myValidationSupport1.isValueSetSupported(any(), eq(VALUE_SET_URL_0))).thenReturn(true);
+ when(myValidationSupport1.expandValueSet(any(), any(), any(IBaseResource.class))).thenAnswer(t -> new IValidationSupport.ValueSetExpansionOutcome(new ValueSet()));
+
+ ValueSet valueSetToExpand = new ValueSet();
+ if (theValueSetHasUrl) {
+ valueSetToExpand.setId("123");
+ valueSetToExpand.setUrl("http://foo");
+ }
+
+ // Test
+ IValidationSupport.ValueSetExpansionOutcome result = chain.expandValueSet(newValidationCtx(chain), new ValueSetExpansionOptions(), valueSetToExpand);
+
+ // Verify
+ verify(myValidationSupport0, times(1)).expandValueSet(any(), any(), any(IBaseResource.class));
+ verify(myValidationSupport1, times(1)).expandValueSet(any(), any(), any(IBaseResource.class));
+ verify(myValidationSupport2, times(0)).expandValueSet(any(), any(), any(IBaseResource.class));
+
+ // Test again (should use cache)
+ IValidationSupport.ValueSetExpansionOutcome result2 = chain.expandValueSet(newValidationCtx(chain), new ValueSetExpansionOptions(), valueSetToExpand);
+
+ // Verify
+ if (theUseCache && theValueSetHasUrl) {
+ assertSame(result, result2);
+ verify(myValidationSupport0, times(1)).expandValueSet(any(), any(), any(IBaseResource.class));
+ verify(myValidationSupport1, times(1)).expandValueSet(any(), any(), any(IBaseResource.class));
+ verify(myValidationSupport2, times(0)).expandValueSet(any(), any(), any(IBaseResource.class));
+ } else {
+ verify(myValidationSupport0, times(2)).expandValueSet(any(), any(), any(IBaseResource.class));
+ verify(myValidationSupport1, times(2)).expandValueSet(any(), any(), any(IBaseResource.class));
+ verify(myValidationSupport2, times(0)).expandValueSet(any(), any(), any(IBaseResource.class));
+ }
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {true, false})
+ public void testExpandValueSet_StringParam(boolean theUseCache) {
+ // Setup
+ prepareMock(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ ValidationSupportChain chain = new ValidationSupportChain(newCacheConfiguration(theUseCache), myValidationSupport0, myValidationSupport1, myValidationSupport2);
+
+ when(myValidationSupport0.isValueSetSupported(any(), eq(VALUE_SET_URL_0))).thenReturn(true);
+ when(myValidationSupport0.expandValueSet(any(), any(), any(String.class))).thenReturn(null);
+ when(myValidationSupport1.isValueSetSupported(any(), eq(VALUE_SET_URL_0))).thenReturn(true);
+ when(myValidationSupport1.expandValueSet(any(), any(), any(String.class))).thenAnswer(t -> new IValidationSupport.ValueSetExpansionOutcome(new ValueSet()));
+
+ // Test
+ IValidationSupport.ValueSetExpansionOutcome result = chain.expandValueSet(newValidationCtx(chain), new ValueSetExpansionOptions(), VALUE_SET_URL_0);
+
+ // Verify
+ verify(myValidationSupport0, times(1)).expandValueSet(any(), any(), any(String.class));
+ verify(myValidationSupport1, times(1)).expandValueSet(any(), any(), any(String.class));
+ verify(myValidationSupport2, times(0)).expandValueSet(any(), any(), any(String.class));
+
+ // Test again (should use cache)
+ IValidationSupport.ValueSetExpansionOutcome result2 = chain.expandValueSet(newValidationCtx(chain), new ValueSetExpansionOptions(), VALUE_SET_URL_0);
+
+ // Verify
+ if (theUseCache) {
+ assertSame(result, result2);
+ verify(myValidationSupport0, times(1)).expandValueSet(any(), any(), any(String.class));
+ verify(myValidationSupport1, times(1)).expandValueSet(any(), any(), any(String.class));
+ verify(myValidationSupport2, times(0)).expandValueSet(any(), any(), any(String.class));
+ } else {
+ verify(myValidationSupport0, times(2)).expandValueSet(any(), any(), any(String.class));
+ verify(myValidationSupport1, times(2)).expandValueSet(any(), any(), any(String.class));
+ verify(myValidationSupport2, times(0)).expandValueSet(any(), any(), any(String.class));
+ }
+ }
+
+ @Test
+ public void testFetchAllNonBaseStructureDefinitions() {
+ // Setup
+ prepareMock(myValidationSupport0);
+
+ StructureDefinition sd0 = (StructureDefinition) new StructureDefinition().setId("SD0");
+ StructureDefinition sd1 = (StructureDefinition) new StructureDefinition().setId("SD1");
+ StructureDefinition sd2 = (StructureDefinition) new StructureDefinition().setId("SD2");
+ List responses = Collections.synchronizedList(Lists.newArrayList(
+ sd0, sd1, sd2
+ ));
+
+ // Each time this is called it will return a slightly shorter list
+ when(myValidationSupport0.fetchAllNonBaseStructureDefinitions()).thenAnswer(t -> {
+ Thread.sleep(1000);
+ return new ArrayList<>(responses);
+ });
+
+ final ValidationSupportChain.CacheConfiguration cacheTimeouts = ValidationSupportChain.CacheConfiguration
+ .defaultValues()
+ .setCacheTimeout(Duration.ofMillis(500));
+ ValidationSupportChain chain = new ValidationSupportChain(cacheTimeouts, myValidationSupport0);
+
+ // First call should return the full list
+ assertEquals(3, chain.fetchAllNonBaseStructureDefinitions().size());
+ assertEquals(3, chain.fetchAllNonBaseStructureDefinitions().size());
+
+ // Remove one from the backing list and wait for the cache to expire
+ responses.remove(0);
+ TestUtil.sleepAtLeast(750);
+
+ // The cache is expired, but we should still return the old list and
+ // start a background job to update the backing list
+ assertEquals(3, chain.fetchAllNonBaseStructureDefinitions().size());
+
+ // Eventually we should refresh
+ await().until(() -> chain.fetchAllNonBaseStructureDefinitions().size(), t -> t == 2);
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {true, false})
+ public void testFetchAllSearchParameters(boolean theUseCache) {
+ // Setup
+ prepareMock(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ when(myValidationSupport0.fetchAllSearchParameters()).thenReturn(List.of(
+ new SearchParameter().setId("01"),
+ new SearchParameter().setId("02")
+ ));
+ when(myValidationSupport1.fetchAllSearchParameters()).thenReturn(List.of(
+ new SearchParameter().setId("11"),
+ new SearchParameter().setId("12")
+ ));
+ when(myValidationSupport2.fetchAllSearchParameters()).thenReturn(null);
+ ValidationSupportChain.CacheConfiguration cache = theUseCache ? ValidationSupportChain.CacheConfiguration.defaultValues() : ValidationSupportChain.CacheConfiguration.disabled();
+ ValidationSupportChain chain = new ValidationSupportChain(cache, myValidationSupport0, myValidationSupport1, myValidationSupport2);
+
+ // Test
+ List actual = chain.fetchAllSearchParameters();
+
+ // Verify
+ assert actual != null;
+ assertThat(actual.stream().map(t -> t.getIdElement().getIdPart()).toList()).asList().containsExactly(
+ "01", "02", "11", "12"
+ );
+ verify(myValidationSupport0, times(1)).fetchAllSearchParameters();
+ verify(myValidationSupport1, times(1)).fetchAllSearchParameters();
+ verify(myValidationSupport2, times(1)).fetchAllSearchParameters();
+
+ // Test a second time
+ actual = chain.fetchAllSearchParameters();
+
+ // Verify
+ assert actual != null;
+ assertThat(actual.stream().map(t -> t.getIdElement().getIdPart()).toList()).asList().containsExactly(
+ "01", "02", "11", "12"
+ );
+ if (theUseCache) {
+ verify(myValidationSupport0, times(1)).fetchAllSearchParameters();
+ verify(myValidationSupport1, times(1)).fetchAllSearchParameters();
+ verify(myValidationSupport2, times(1)).fetchAllSearchParameters();
+ } else {
+ verify(myValidationSupport0, times(2)).fetchAllSearchParameters();
+ verify(myValidationSupport1, times(2)).fetchAllSearchParameters();
+ verify(myValidationSupport2, times(2)).fetchAllSearchParameters();
+ }
+
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {true, false})
+ public void testLookupCode(boolean theUseCache) {
+ // Setup
+ prepareMock(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ ValidationSupportChain chain = new ValidationSupportChain(newCacheConfiguration(theUseCache), myValidationSupport0, myValidationSupport1, myValidationSupport2);
+
+ when(myValidationSupport0.isCodeSystemSupported(any(), eq(CODE_SYSTEM_URL_0))).thenReturn(true);
+ when(myValidationSupport1.isCodeSystemSupported(any(), eq(CODE_SYSTEM_URL_0))).thenReturn(true);
+ when(myValidationSupport0.lookupCode(any(), any(LookupCodeRequest.class))).thenReturn(null);
+ when(myValidationSupport1.lookupCode(any(), any(LookupCodeRequest.class))).thenAnswer(t -> new IValidationSupport.LookupCodeResult());
+
+ // Test
+ IValidationSupport.LookupCodeResult result = chain.lookupCode(newValidationCtx(chain), new LookupCodeRequest(CODE_SYSTEM_URL_0, CODE_0));
+
+ // Verify
+ verify(myValidationSupport0, times(1)).lookupCode(any(), any(LookupCodeRequest.class));
+ verify(myValidationSupport1, times(1)).lookupCode(any(), any(LookupCodeRequest.class));
+ verify(myValidationSupport2, times(0)).lookupCode(any(), any(LookupCodeRequest.class));
+
+ // Test again (should use cache)
+ IValidationSupport.LookupCodeResult result2 = chain.lookupCode(newValidationCtx(chain), new LookupCodeRequest(CODE_SYSTEM_URL_0, CODE_0));
+
+ // Verify
+ if (theUseCache) {
+ assertSame(result, result2);
+ verify(myValidationSupport0, times(1)).lookupCode(any(), any(LookupCodeRequest.class));
+ verify(myValidationSupport1, times(1)).lookupCode(any(), any(LookupCodeRequest.class));
+ verify(myValidationSupport2, times(0)).lookupCode(any(), any(LookupCodeRequest.class));
+ } else {
+ verify(myValidationSupport0, times(2)).lookupCode(any(), any(LookupCodeRequest.class));
+ verify(myValidationSupport1, times(2)).lookupCode(any(), any(LookupCodeRequest.class));
+ verify(myValidationSupport2, times(0)).lookupCode(any(), any(LookupCodeRequest.class));
+ }
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {true, false})
+ public void testFetchValueSet(boolean theUseCache) {
+ // Setup
+ prepareMock(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ ValidationSupportChain chain = new ValidationSupportChain(newCacheConfiguration(theUseCache), myValidationSupport0, myValidationSupport1, myValidationSupport2);
+
+ when(myValidationSupport0.fetchValueSet(any())).thenReturn(null);
+ when(myValidationSupport1.fetchValueSet(any())).thenAnswer(t -> new ValueSet());
+
+ // Test
+ IBaseResource result = chain.fetchValueSet(VALUE_SET_URL_0);
+
+ // Verify
+ verify(myValidationSupport0, times(1)).fetchValueSet(any());
+ verify(myValidationSupport1, times(1)).fetchValueSet(any());
+ verify(myValidationSupport2, times(0)).fetchValueSet(any());
+
+ // Test again (should use cache)
+ IBaseResource result2 = chain.fetchValueSet(VALUE_SET_URL_0);
+
+ // Verify
+ if (theUseCache) {
+ assertSame(result, result2);
+ verify(myValidationSupport0, times(1)).fetchValueSet(any());
+ verify(myValidationSupport1, times(1)).fetchValueSet(any());
+ verify(myValidationSupport2, times(0)).fetchValueSet(any());
+ } else {
+ verify(myValidationSupport0, times(2)).fetchValueSet(any());
+ verify(myValidationSupport1, times(2)).fetchValueSet(any());
+ verify(myValidationSupport2, times(0)).fetchValueSet(any());
+ }
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {true, false})
+ public void testResource_ValueSet(boolean theUseCache) {
+ // Setup
+ prepareMock(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ ValidationSupportChain chain = new ValidationSupportChain(newCacheConfiguration(theUseCache), myValidationSupport0, myValidationSupport1, myValidationSupport2);
+
+ when(myValidationSupport0.fetchValueSet(any())).thenReturn(null);
+ when(myValidationSupport1.fetchValueSet(any())).thenAnswer(t -> new ValueSet());
+
+ // Test
+ IBaseResource result = chain.fetchResource(ValueSet.class, VALUE_SET_URL_0);
+
+ // Verify
+ verify(myValidationSupport0, times(1)).fetchValueSet( any());
+ verify(myValidationSupport1, times(1)).fetchValueSet( any());
+ verify(myValidationSupport2, times(0)).fetchValueSet(any());
+
+ // Test again (should use cache)
+ IBaseResource result2 = chain.fetchResource(ValueSet.class, VALUE_SET_URL_0);
+
+ // Verify
+ if (theUseCache) {
+ assertSame(result, result2);
+ verify(myValidationSupport0, times(1)).fetchValueSet( any());
+ verify(myValidationSupport1, times(1)).fetchValueSet( any());
+ verify(myValidationSupport2, times(0)).fetchValueSet( any());
+ } else {
+ verify(myValidationSupport0, times(2)).fetchValueSet( any());
+ verify(myValidationSupport1, times(2)).fetchValueSet( any());
+ verify(myValidationSupport2, times(0)).fetchValueSet(any());
+ }
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {true, false})
+ public void testResource_Arbitrary(boolean theUseCache) {
+ // Setup
+ prepareMock(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ ValidationSupportChain chain = new ValidationSupportChain(newCacheConfiguration(theUseCache), myValidationSupport0, myValidationSupport1, myValidationSupport2);
+
+ when(myValidationSupport0.fetchResource(any(), any())).thenReturn(null);
+ when(myValidationSupport1.fetchResource(any(), any())).thenAnswer(t -> new ListResource());
+
+ // Test
+ IBaseResource result = chain.fetchResource(ListResource.class, "http://foo");
+
+ // Verify
+ verify(myValidationSupport0, times(1)).fetchResource(any(), any());
+ verify(myValidationSupport1, times(1)).fetchResource(any(), any());
+ verify(myValidationSupport2, times(0)).fetchResource(any(), any());
+
+ // Test again (should use cache)
+ IBaseResource result2 = chain.fetchResource(ListResource.class, "http://foo");
+
+ // Verify
+ if (theUseCache) {
+ assertSame(result, result2);
+ verify(myValidationSupport0, times(1)).fetchResource(any(), any());
+ verify(myValidationSupport1, times(1)).fetchResource(any(), any());
+ verify(myValidationSupport2, times(0)).fetchResource(any(), any());
+ } else {
+ verify(myValidationSupport0, times(2)).fetchResource(any(), any());
+ verify(myValidationSupport1, times(2)).fetchResource(any(), any());
+ verify(myValidationSupport2, times(0)).fetchResource(any(), any());
+ }
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {true, false})
+ public void testTranslateCode(boolean theUseCache) {
+ // Setup
+ prepareMock(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ ValidationSupportChain chain = new ValidationSupportChain(newCacheConfiguration(theUseCache), myValidationSupport0, myValidationSupport1, myValidationSupport2);
+
+ when(myValidationSupport0.translateConcept(any())).thenReturn(null);
+ TranslateConceptResults backingResult1 = new TranslateConceptResults();
+ backingResult1.setMessage("Message 1");
+ backingResult1.setResult(true);
+ backingResult1.getResults().add(new TranslateConceptResult().setCode("A"));
+ when(myValidationSupport1.translateConcept(any())).thenReturn(backingResult1);
+ TranslateConceptResults backingResult2 = new TranslateConceptResults();
+ backingResult2.setMessage("Message 2");
+ backingResult2.setResult(true);
+ backingResult2.getResults().add(new TranslateConceptResult().setCode("B"));
+ when(myValidationSupport2.translateConcept(any())).thenReturn(backingResult2);
+
+ // Test
+ TranslateConceptResults result = chain.translateConcept(new IValidationSupport.TranslateCodeRequest(List.of(), CODE_SYSTEM_URL_0));
+
+ // Verify
+ assertEquals("Message 1", result.getMessage());
+ assertTrue(result.getResult());
+ assertEquals(2, result.getResults().size());
+ verify(myValidationSupport0, times(1)).translateConcept(any());
+ verify(myValidationSupport1, times(1)).translateConcept(any());
+ verify(myValidationSupport2, times(1)).translateConcept(any());
+
+ // Test again (should use cache)
+ TranslateConceptResults result2 = chain.translateConcept(new IValidationSupport.TranslateCodeRequest(List.of(), CODE_SYSTEM_URL_0));
+
+ // Verify
+ if (theUseCache) {
+ assertSame(result, result2);
+ verify(myValidationSupport0, times(1)).translateConcept(any());
+ verify(myValidationSupport1, times(1)).translateConcept(any());
+ verify(myValidationSupport2, times(1)).translateConcept(any());
+ } else {
+ assertNotSame(result, result2);
+ verify(myValidationSupport0, times(2)).translateConcept(any());
+ verify(myValidationSupport1, times(2)).translateConcept(any());
+ verify(myValidationSupport2, times(2)).translateConcept(any());
+ }
+ }
+
+ /**
+ * Verify that OpenTelemetry metrics are generated correctly
+ */
+ @ParameterizedTest
+ @ValueSource(booleans = {true, false})
+ public void testMetrics(boolean theUseCache) {
+ LibraryTestRunner libraryTestRunner = LibraryTestRunner.instance();
+
+ /*
+ * As of version 2.10.0 of the opentelemetry-testing-common library,
+ * the following doesn't actually clear the stored metrics. Hopefully
+ * this will be fixed in a future release.
+ */
+ libraryTestRunner.clearAllExportedData();
+
+ prepareMock(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ when(myValidationSupport0.fetchStructureDefinition("http://foo")).thenReturn(new StructureDefinition().setUrl("http://foo"));
+ ValidationSupportChain chain = new ValidationSupportChain(newCacheConfiguration(theUseCache), myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ chain.setName("FOO_NAME");
+
+ chain.start();
+ try {
+ if (theUseCache) {
+ assertEquals(5000L, getLastMetricValue(libraryTestRunner, ValidationSupportChainMetrics.EXPIRING_CACHE_MAXIMUM_SIZE));
+ assertEquals(0L, getLastMetricValue(libraryTestRunner, ValidationSupportChainMetrics.EXPIRING_CACHE_CURRENT_ENTRIES));
+ assertEquals(0L, getLastMetricValue(libraryTestRunner, ValidationSupportChainMetrics.NON_EXPIRING_CACHE_CURRENT_ENTRIES));
+ } else {
+ assertEquals(0L, getLastMetricValue(libraryTestRunner, ValidationSupportChainMetrics.EXPIRING_CACHE_MAXIMUM_SIZE));
+ assertEquals(0L, getLastMetricValue(libraryTestRunner, ValidationSupportChainMetrics.EXPIRING_CACHE_CURRENT_ENTRIES));
+ assertEquals(0L, getLastMetricValue(libraryTestRunner, ValidationSupportChainMetrics.NON_EXPIRING_CACHE_CURRENT_ENTRIES));
+ }
+
+ // Test
+ assertNotNull(chain.fetchStructureDefinition("http://foo"));
+
+ // Verify
+ if (theUseCache) {
+ assertEquals(5000L, getLastMetricValue(libraryTestRunner, "io.hapifhir.validation_support_chain.expiring_cache.maximum_size"));
+ assertEquals(1L, getLastMetricValue(libraryTestRunner, "io.hapifhir.validation_support_chain.expiring_cache.current_entries"));
+ assertEquals(1L, getLastMetricValue(libraryTestRunner, "io.hapifhir.validation_support_chain.non_expiring_cache.current_entries"));
+ } else {
+ assertEquals(0L, getLastMetricValue(libraryTestRunner, "io.hapifhir.validation_support_chain.expiring_cache.maximum_size"));
+ assertEquals(0L, getLastMetricValue(libraryTestRunner, "io.hapifhir.validation_support_chain.expiring_cache.current_entries"));
+ assertEquals(0L, getLastMetricValue(libraryTestRunner, "io.hapifhir.validation_support_chain.non_expiring_cache.current_entries"));
+ }
+ } finally {
+ chain.stop();
+ }
}
- private static IValidationSupport createMockValidationSupportWithSingleBinary(String expected_binary_key, byte[] expected_binary_content) {
- IValidationSupport validationSupport1 = createMockValidationSupport();
- when(validationSupport1.fetchBinary(expected_binary_key)).thenReturn(expected_binary_content);
- return validationSupport1;
+ @Test
+ public void testModifyingServiceInvalidatesCache() {
+ // Setup
+ prepareMock(myValidationSupport0, myValidationSupport1, myValidationSupport2);
+ when(myValidationSupport0.isCodeSystemSupported(any(), eq("http://foo"))).thenReturn(true);
+ when(myValidationSupport1.isCodeSystemSupported(any(), eq("http://foo"))).thenReturn(true);
+
+ ValidationSupportChain svc = new ValidationSupportChain(myValidationSupport0, myValidationSupport1);
+ assertTrue(svc.isCodeSystemSupported(newValidationCtx(svc), "http://foo"));
+
+ // Test
+ svc.addValidationSupport(myValidationSupport2);
+ when(myValidationSupport0.isCodeSystemSupported(any(), eq("http://foo"))).thenReturn(false);
+ when(myValidationSupport1.isCodeSystemSupported(any(), eq("http://foo"))).thenReturn(false);
+ when(myValidationSupport2.isCodeSystemSupported(any(), eq("http://foo"))).thenReturn(false);
+ boolean actual = svc.isCodeSystemSupported(newValidationCtx(svc), "http://foo");
+
+ // Verify
+ assertFalse(actual);
}
+
+
+ private static long getLastMetricValue(LibraryTestRunner libraryTestRunner, String metricName) {
+ List metrics = libraryTestRunner.getExportedMetrics();
+ List metricsList = metrics.stream().filter(t -> t.getName().equals(metricName)).toList();
+ ourLog.info("Have metrics {}\n * {}", metricName, metricsList.stream().map(t -> t.getData().getPoints().toString()).collect(Collectors.joining("\n * ")));
+ MetricData metric = metricsList.get(metricsList.size() - 1);
+ assertEquals("io.hapifhir.validation_support_chain", metric.getInstrumentationScopeInfo().getName());
+ Data data = metric.getData();
+ ArrayList dataPoints = new ArrayList<>(data.getPoints());
+ assertEquals(1, dataPoints.size());
+ LongPointData pointData = (LongPointData) dataPoints.get(0);
+ return pointData.getValue();
+ }
+
+
+ private static ValidationSupportChain.CacheConfiguration newCacheConfiguration(boolean theUseCache) {
+ return theUseCache ? ValidationSupportChain.CacheConfiguration.defaultValues() : ValidationSupportChain.CacheConfiguration.disabled();
+ }
+
+ @Nonnull
+ private static ValidationSupportContext newValidationCtx(ValidationSupportChain validationSupportChain) {
+ return new ValidationSupportContext(validationSupportChain);
+ }
+
+
+ private static void prepareMock(IValidationSupport... theMock) {
+ reset(theMock);
+ for (var mock : theMock) {
+ when(mock.getFhirContext()).thenReturn(FhirContext.forR4Cached());
+ }
+ }
+
+ private static void createMockValidationSupportWithSingleBinary(IValidationSupport theValidationSupport, String theExpectedBinaryKey, byte[] theExpectedBinaryContent) {
+ when(theValidationSupport.fetchBinary(theExpectedBinaryKey)).thenReturn(theExpectedBinaryContent);
+ }
+
}
diff --git a/hapi-fhir-validation/src/test/java/org/hl7/fhir/common/hapi/validation/validator/VersionSpecificWorkerContextWrapperCoreTest.java b/hapi-fhir-validation/src/test/java/org/hl7/fhir/common/hapi/validation/validator/VersionSpecificWorkerContextWrapperCoreTest.java
index 10548169c0f..9a03a81d262 100644
--- a/hapi-fhir-validation/src/test/java/org/hl7/fhir/common/hapi/validation/validator/VersionSpecificWorkerContextWrapperCoreTest.java
+++ b/hapi-fhir-validation/src/test/java/org/hl7/fhir/common/hapi/validation/validator/VersionSpecificWorkerContextWrapperCoreTest.java
@@ -2,16 +2,13 @@ package org.hl7.fhir.common.hapi.validation.validator;
import ca.uhn.fhir.context.FhirContext;
import ca.uhn.fhir.context.support.DefaultProfileValidationSupport;
-
import ca.uhn.fhir.context.support.IValidationSupport;
import ca.uhn.fhir.context.support.ValidationSupportContext;
import ca.uhn.fhir.test.utilities.LoggingExtension;
import ca.uhn.fhir.validation.FhirValidator;
import ca.uhn.hapi.converters.canonical.VersionCanonicalizer;
import com.google.common.base.Charsets;
-
import org.apache.commons.io.IOUtils;
-import org.hl7.fhir.common.hapi.validation.support.CachingValidationSupport;
import org.hl7.fhir.common.hapi.validation.support.CommonCodeSystemsTerminologyService;
import org.hl7.fhir.common.hapi.validation.support.InMemoryTerminologyServerValidationSupport;
import org.hl7.fhir.common.hapi.validation.support.UnknownCodeSystemWarningValidationSupport;
@@ -24,6 +21,8 @@ import org.hl7.fhir.exceptions.DefinitionException;
import org.hl7.fhir.exceptions.FHIRException;
import org.hl7.fhir.exceptions.FHIRFormatError;
import org.hl7.fhir.instance.model.api.IBaseResource;
+import org.hl7.fhir.r5.formats.JsonParser;
+import org.hl7.fhir.r5.formats.XmlParser;
import org.hl7.fhir.r5.model.CodeSystem;
import org.hl7.fhir.r5.model.Constants;
import org.hl7.fhir.r5.model.Parameters;
@@ -41,6 +40,9 @@ import org.junit.jupiter.api.extension.RegisterExtension;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.quality.Strictness;
+import org.mockito.stubbing.Answer;
import java.io.File;
import java.io.FileNotFoundException;
@@ -50,14 +52,7 @@ import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;
-import org.hl7.fhir.r5.formats.JsonParser;
-import org.hl7.fhir.r5.formats.XmlParser;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.quality.Strictness;
-import org.mockito.stubbing.Answer;
-
import static org.junit.jupiter.api.Assertions.assertNull;
-
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.mock;
@@ -114,7 +109,7 @@ public class VersionSpecificWorkerContextWrapperCoreTest {
private FhirInstanceValidator myInstanceVal;
private Map mySupportedCodeSystemsForExpansion;
private FhirValidator myVal;
- private CachingValidationSupport myValidationSupport;
+ private ValidationSupportChain myValidationSupport;
private static final String VALIDATE_CODE_OPERATION = "validate-code";
@@ -176,14 +171,13 @@ public class VersionSpecificWorkerContextWrapperCoreTest {
UnknownCodeSystemWarningValidationSupport unknownCodeSystemWarningValidationSupport = new UnknownCodeSystemWarningValidationSupport(ourCtx);
unknownCodeSystemWarningValidationSupport.setNonExistentCodeSystemSeverity(IValidationSupport.IssueSeverity.WARNING);
- myValidationSupport = new CachingValidationSupport(
+ myValidationSupport =
new ValidationSupportChain(
mockSupport,
myDefaultValidationSupport,
new InMemoryTerminologyServerValidationSupport(ourCtx),
new CommonCodeSystemsTerminologyService(ourCtx),
- unknownCodeSystemWarningValidationSupport)
- );
+ unknownCodeSystemWarningValidationSupport);
myInstanceVal = new FhirInstanceValidator(myValidationSupport);
wrapper = new VersionSpecificWorkerContextWrapper(new ValidationSupportContext(myValidationSupport), versionCanonicalizer);
diff --git a/hapi-fhir-validation/src/test/java/org/hl7/fhir/common/hapi/validation/validator/VersionSpecificWorkerContextWrapperTest.java b/hapi-fhir-validation/src/test/java/org/hl7/fhir/common/hapi/validation/validator/VersionSpecificWorkerContextWrapperTest.java
index cbc79fadc98..a6162c2b67c 100644
--- a/hapi-fhir-validation/src/test/java/org/hl7/fhir/common/hapi/validation/validator/VersionSpecificWorkerContextWrapperTest.java
+++ b/hapi-fhir-validation/src/test/java/org/hl7/fhir/common/hapi/validation/validator/VersionSpecificWorkerContextWrapperTest.java
@@ -1,39 +1,50 @@
package org.hl7.fhir.common.hapi.validation.validator;
import ca.uhn.fhir.context.FhirContext;
-import ca.uhn.fhir.context.FhirVersionEnum;
+import ca.uhn.fhir.context.support.DefaultProfileValidationSupport;
import ca.uhn.fhir.context.support.IValidationSupport;
import ca.uhn.fhir.context.support.ValidationSupportContext;
-import ca.uhn.fhir.fhirpath.BaseValidationTestWithInlineMocks;
-import ca.uhn.fhir.i18n.HapiLocalizer;
+import ca.uhn.fhir.test.BaseTest;
import ca.uhn.hapi.converters.canonical.VersionCanonicalizer;
+import org.hl7.fhir.r5.model.PackageInformation;
import org.hl7.fhir.r5.model.Resource;
import org.hl7.fhir.r5.model.StructureDefinition;
import org.hl7.fhir.r5.model.StructureDefinition.StructureDefinitionKind;
import org.hl7.fhir.r5.model.ValueSet;
import org.hl7.fhir.utilities.validation.ValidationOptions;
import org.junit.jupiter.api.Test;
-import org.mockito.quality.Strictness;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.List;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import static org.mockito.Mockito.withSettings;
-public class VersionSpecificWorkerContextWrapperTest extends BaseValidationTestWithInlineMocks {
+@ExtendWith(MockitoExtension.class)
+public class VersionSpecificWorkerContextWrapperTest extends BaseTest {
final byte[] EXPECTED_BINARY_CONTENT_1 = "dummyBinaryContent1".getBytes();
final byte[] EXPECTED_BINARY_CONTENT_2 = "dummyBinaryContent2".getBytes();
final String EXPECTED_BINARY_KEY_1 = "dummyBinaryKey1";
final String EXPECTED_BINARY_KEY_2 = "dummyBinaryKey2";
final String NON_EXISTENT_BINARY_KEY = "nonExistentBinaryKey";
+ @Mock
+ private ValidationSupportContext myValidationSupportContext;
+ @Mock
+ private IValidationSupport myValidationSupport;
@Test
public void hasBinaryKey_normally_returnsExpected() {
@@ -90,7 +101,7 @@ public class VersionSpecificWorkerContextWrapperTest extends BaseValidationTestW
ValueSet valueSet = new ValueSet();
valueSet.getCompose().addInclude().setSystem("http://codesystems.com/system").addConcept().setCode("code0");
valueSet.getCompose().addInclude().setSystem("http://codesystems.com/system2").addConcept().setCode("code2");
- when(validationSupport.validateCodeInValueSet(any(), any(), any(), any(), any(), any())).thenReturn(mock(IValidationSupport.CodeValidationResult.class));
+ when(validationSupport.validateCodeInValueSet(any(), any(), any(), any(), any(), any())).thenReturn(new IValidationSupport.CodeValidationResult());
// execute
wrapper.validateCode(new ValidationOptions(), "code0", valueSet);
@@ -157,6 +168,49 @@ public class VersionSpecificWorkerContextWrapperTest extends BaseValidationTestW
assertThat(wrapper.isPrimitiveType("Unknown")).isFalse();
}
+ @Test
+ public void testFetchResource_ResourceParameter() {
+ // setup
+ IValidationSupport validationSupport = mockValidationSupport();
+ ValidationSupportContext mockContext = mockValidationSupportContext(validationSupport);
+ VersionCanonicalizer versionCanonicalizer = new VersionCanonicalizer(validationSupport.getFhirContext());
+ VersionSpecificWorkerContextWrapper wrapper = new VersionSpecificWorkerContextWrapper(mockContext, versionCanonicalizer);
+
+ org.hl7.fhir.r4.model.StructureDefinition expected = new org.hl7.fhir.r4.model.StructureDefinition();
+ expected.setUrl("http://foo");
+ expected.getSnapshot().addElement().setId("FOO");
+ when(mockContext.getRootValidationSupport().fetchResource(isNull(), eq("http://foo"))).thenReturn(expected);
+
+ // Test
+ StructureDefinition actual = (StructureDefinition) wrapper.fetchResource(Resource.class, "http://foo");
+
+ // Verify
+ assertEquals("FOO", actual.getSnapshot().getElementFirstRep().getId());
+ }
+
+ @Test
+ public void testFetchResource_StructureDefinitionParameter() {
+ // setup
+ IValidationSupport validationSupport = mockValidationSupport();
+ ValidationSupportContext mockContext = mockValidationSupportContext(validationSupport);
+ VersionCanonicalizer versionCanonicalizer = new VersionCanonicalizer(validationSupport.getFhirContext());
+ VersionSpecificWorkerContextWrapper wrapper = new VersionSpecificWorkerContextWrapper(mockContext, versionCanonicalizer);
+
+ org.hl7.fhir.r4.model.StructureDefinition expected = new org.hl7.fhir.r4.model.StructureDefinition();
+ expected.setUrl("http://foo");
+ expected.getSnapshot().addElement().setId("FOO");
+ expected.setUserData(DefaultProfileValidationSupport.SOURCE_PACKAGE_ID, "hl7.fhir.r999.core");
+ when(mockContext.getRootValidationSupport().fetchResource(eq(org.hl7.fhir.r4.model.StructureDefinition.class), eq("http://foo"))).thenReturn(expected);
+
+ // Test
+ StructureDefinition actual = wrapper.fetchResource(StructureDefinition.class, "http://foo");
+
+ // Verify
+ assertEquals("FOO", actual.getSnapshot().getElementFirstRep().getId());
+ PackageInformation sourcePackage = actual.getSourcePackage();
+ assertEquals("hl7.fhir.r999.core", sourcePackage.getId());
+ }
+
private List createStructureDefinitions() {
StructureDefinition stringType = createPrimitive("string");
StructureDefinition boolType = createPrimitive("boolean");
@@ -166,20 +220,25 @@ public class VersionSpecificWorkerContextWrapperTest extends BaseValidationTestW
return List.of(personType, boolType, orgType, stringType);
}
- private StructureDefinition createComplex(String name){
+ private StructureDefinition createComplex(String name) {
return createStructureDefinition(name).setKind(StructureDefinitionKind.COMPLEXTYPE);
}
- private StructureDefinition createPrimitive(String name){
+ private StructureDefinition createPrimitive(String name) {
return createStructureDefinition(name).setKind(StructureDefinitionKind.PRIMITIVETYPE);
}
private StructureDefinition createStructureDefinition(String name) {
StructureDefinition sd = new StructureDefinition();
- sd.setUrl("http://hl7.org/fhir/StructureDefinition/"+name).setName(name);
+ sd.setUrl("http://hl7.org/fhir/StructureDefinition/" + name).setName(name);
+ addFakeSnapshot(sd);
return sd;
}
+ private static void addFakeSnapshot(StructureDefinition sd) {
+ sd.getSnapshot().addElement().setId("FOO");
+ }
+
private IValidationSupport mockValidationSupportWithTwoBinaries() {
IValidationSupport validationSupport;
validationSupport = mockValidationSupport();
@@ -188,22 +247,14 @@ public class VersionSpecificWorkerContextWrapperTest extends BaseValidationTestW
return validationSupport;
}
-
- private static ValidationSupportContext mockValidationSupportContext(IValidationSupport validationSupport) {
- ValidationSupportContext mockContext;
- mockContext = mock(ValidationSupportContext.class);
+ private ValidationSupportContext mockValidationSupportContext(IValidationSupport validationSupport) {
+ ValidationSupportContext mockContext = myValidationSupportContext;
when(mockContext.getRootValidationSupport()).thenReturn(validationSupport);
return mockContext;
}
-
- private static IValidationSupport mockValidationSupport() {
- IValidationSupport mockValidationSupport;
- mockValidationSupport = mock(IValidationSupport.class);
- FhirContext mockFhirContext = mock(FhirContext.class, withSettings().strictness(Strictness.LENIENT));
- when(mockFhirContext.getLocalizer()).thenReturn(new HapiLocalizer());
- when(mockFhirContext.getVersion()).thenReturn(FhirVersionEnum.R4.getVersionImplementation());
- when(mockValidationSupport.getFhirContext()).thenReturn(mockFhirContext);
- return mockValidationSupport;
+ private IValidationSupport mockValidationSupport() {
+ when(myValidationSupport.getFhirContext()).thenReturn(FhirContext.forR4Cached());
+ return myValidationSupport;
}
}
diff --git a/hapi-fhir-validation/src/test/java/org/hl7/fhir/dstu3/hapi/validation/FhirInstanceValidatorDstu3Test.java b/hapi-fhir-validation/src/test/java/org/hl7/fhir/dstu3/hapi/validation/FhirInstanceValidatorDstu3Test.java
index cfbeca68626..34fc831525f 100644
--- a/hapi-fhir-validation/src/test/java/org/hl7/fhir/dstu3/hapi/validation/FhirInstanceValidatorDstu3Test.java
+++ b/hapi-fhir-validation/src/test/java/org/hl7/fhir/dstu3/hapi/validation/FhirInstanceValidatorDstu3Test.java
@@ -15,7 +15,6 @@ import ca.uhn.fhir.validation.SingleValidationMessage;
import ca.uhn.fhir.validation.ValidationResult;
import com.google.common.base.Charsets;
import org.apache.commons.io.IOUtils;
-import org.hl7.fhir.common.hapi.validation.support.CachingValidationSupport;
import org.hl7.fhir.common.hapi.validation.support.CommonCodeSystemsTerminologyService;
import org.hl7.fhir.common.hapi.validation.support.InMemoryTerminologyServerValidationSupport;
import org.hl7.fhir.common.hapi.validation.support.SnapshotGeneratingValidationSupport;
@@ -115,7 +114,7 @@ public class FhirInstanceValidatorDstu3Test extends BaseValidationTestWithInline
private HashMap myCodeSystems;
private HashMap myValueSets;
private HashMap myQuestionnaires;
- private CachingValidationSupport myValidationSupport;
+ private ValidationSupportChain myValidationSupport;
private void addValidConcept(String theSystem, String theCode) {
addValidConcept(theSystem, theCode, true);
@@ -139,12 +138,12 @@ public class FhirInstanceValidatorDstu3Test extends BaseValidationTestWithInline
IValidationSupport mockSupport = mock(IValidationSupport.class, withSettings().strictness(Strictness.LENIENT));
when(mockSupport.getFhirContext()).thenReturn(ourCtx);
- myValidationSupport = new CachingValidationSupport(new ValidationSupportChain(
+ myValidationSupport = new ValidationSupportChain(
mockSupport,
myDefaultValidationSupport,
new InMemoryTerminologyServerValidationSupport(ourCtx),
new CommonCodeSystemsTerminologyService(ourCtx),
- new SnapshotGeneratingValidationSupport(ourCtx)));
+ new SnapshotGeneratingValidationSupport(ourCtx));
myInstanceVal = new FhirInstanceValidator(myValidationSupport);
myVal.registerValidatorModule(myInstanceVal);
diff --git a/hapi-fhir-validation/src/test/java/org/hl7/fhir/dstu3/hapi/validation/QuestionnaireResponseValidatorDstu3Test.java b/hapi-fhir-validation/src/test/java/org/hl7/fhir/dstu3/hapi/validation/QuestionnaireResponseValidatorDstu3Test.java
index 57591b31e76..4c7d0749585 100644
--- a/hapi-fhir-validation/src/test/java/org/hl7/fhir/dstu3/hapi/validation/QuestionnaireResponseValidatorDstu3Test.java
+++ b/hapi-fhir-validation/src/test/java/org/hl7/fhir/dstu3/hapi/validation/QuestionnaireResponseValidatorDstu3Test.java
@@ -169,7 +169,7 @@ public class QuestionnaireResponseValidatorDstu3Test {
when(myValSupport.fetchResource(eq(Questionnaire.class),
eq(QUESTIONNAIRE_URL))).thenReturn(q);
when(myValSupport.fetchCodeSystem(eq("http://codesystems.com/system"))).thenReturn(codeSystem);
- when(myValSupport.fetchResource(eq(ValueSet.class), eq("http://somevalueset"))).thenReturn(options);
+ when(myValSupport.fetchValueSet(eq("http://somevalueset"))).thenReturn(options);
when(myValSupport.validateCodeInValueSet(any(), any(), eq("http://codesystems.com/system"), eq("code0"), any(), nullable(ValueSet.class)))
.thenReturn(new IValidationSupport.CodeValidationResult().setCode("code0"));
@@ -242,7 +242,7 @@ public class QuestionnaireResponseValidatorDstu3Test {
ValueSet options = new ValueSet();
options.getCompose().addInclude().setSystem("http://codesystems.com/system").addConcept().setCode("code0");
options.getCompose().addInclude().setSystem("http://codesystems.com/system2").addConcept().setCode("code2");
- when(myValSupport.fetchResource(eq(ValueSet.class), eq("http://somevalueset"))).thenReturn(options);
+ when(myValSupport.fetchValueSet(eq("http://somevalueset"))).thenReturn(options);
when(myValSupport.validateCode(any(), any(), eq("http://codesystems.com/system"), eq("code0"), any(), nullable(String.class)))
.thenReturn(new IValidationSupport.CodeValidationResult().setCode(CODE_ICC_SCHOOLTYPE_PT));
@@ -802,7 +802,7 @@ public class QuestionnaireResponseValidatorDstu3Test {
ValueSet options = new ValueSet();
options.getCompose().addInclude().setSystem(codeSystemUrl).addConcept().setCode(codeValue);
- when(myValSupport.fetchResource(eq(ValueSet.class), eq(valueSetRef)))
+ when(myValSupport.fetchValueSet(eq(valueSetRef)))
.thenReturn(options);
when(myValSupport.validateCode(any(), any(), eq(codeSystemUrl), eq(codeValue), any(String.class), anyString()))
.thenReturn(new IValidationSupport.CodeValidationResult().setCode(codeValue));
@@ -858,7 +858,7 @@ public class QuestionnaireResponseValidatorDstu3Test {
ValueSet options = new ValueSet();
options.getCompose().addInclude().setSystem(codeSystemUrl).addConcept().setCode(codeValue);
- when(myValSupport.fetchResource(eq(ValueSet.class), eq(valueSetRef)))
+ when(myValSupport.fetchValueSet(eq(valueSetRef)))
.thenReturn(options);
when(myValSupport.validateCode(any(), any(), eq(codeSystemUrl), eq(codeValue), any(String.class), anyString()))
.thenReturn(new IValidationSupport.CodeValidationResult().setCode(codeValue));
@@ -981,7 +981,7 @@ public class QuestionnaireResponseValidatorDstu3Test {
.setValue(new Coding(SYSTEMURI_ICC_SCHOOLTYPE, CODE_ICC_SCHOOLTYPE_PT, ""));
when(myValSupport.fetchResource(eq(Questionnaire.class), eq(questionnaireResponse.getQuestionnaire().getReference()))).thenReturn(questionnaire);
- when(myValSupport.fetchResource(eq(ValueSet.class), eq(ID_VS_SCHOOLTYPE.getValue()))).thenReturn(iccSchoolTypeVs);
+ when(myValSupport.fetchValueSet(eq(ID_VS_SCHOOLTYPE.getValue()))).thenReturn(iccSchoolTypeVs);
when(myValSupport.validateCodeInValueSet(any(), any(), eq(SYSTEMURI_ICC_SCHOOLTYPE), eq(CODE_ICC_SCHOOLTYPE_PT), any(), nullable(ValueSet.class)))
.thenReturn(new IValidationSupport.CodeValidationResult().setCode(CODE_ICC_SCHOOLTYPE_PT));
when(myValSupport.fetchCodeSystem(eq(SYSTEMURI_ICC_SCHOOLTYPE))).thenReturn(codeSystem);
@@ -1053,7 +1053,7 @@ public class QuestionnaireResponseValidatorDstu3Test {
options.setUrl("http://somevalueset");
options.getCompose().addInclude().setSystem("http://codesystems.com/system").addConcept().setCode("code0");
options.getCompose().addInclude().setSystem("http://codesystems.com/system2").addConcept().setCode("code2");
- when(myValSupport.fetchResource(eq(ValueSet.class), eq("http://somevalueset"))).thenReturn(options);
+ when(myValSupport.fetchValueSet(eq("http://somevalueset"))).thenReturn(options);
when(myValSupport.isValueSetSupported(any(), eq("http://somevalueset"))).thenReturn(true);
@@ -1095,7 +1095,7 @@ public class QuestionnaireResponseValidatorDstu3Test {
assertThat(errors.getMessages()).hasSize(2);
assertThat(errors.getMessages().get(0).getMessage()).contains("A code with no system has no defined meaning, and it cannot be validated. A system should be provided");
assertThat(errors.getMessages().get(0).getLocationString()).contains("QuestionnaireResponse.item[0].answer[0]");
- assertThat(errors.getMessages().get(1).getMessage()).contains("The code 'code1' in the system 'null' is not in the options value set (ValueSet[http://somevalueset]) specified by the questionnaire. Terminology Error: Validation failed");
+ assertThat(errors.getMessages().get(1).getMessage()).contains("The code 'code1' in the system 'null' is not in the options value set (ValueSet[http://somevalueset]) specified by the questionnaire. Terminology Error: Unknown code 'code1' for in-memory expansion of ValueSet 'http://somevalueset'");
assertThat(errors.getMessages().get(1).getLocationString()).contains("QuestionnaireResponse.item[0].answer[0]");
qa = new QuestionnaireResponse();
@@ -1108,7 +1108,7 @@ public class QuestionnaireResponseValidatorDstu3Test {
assertThat(errors.getMessages()).hasSize(2);
assertThat(errors.getMessages().get(0).getMessage()).contains("A code with no system has no defined meaning, and it cannot be validated. A system should be provided");
assertThat(errors.getMessages().get(0).getLocationString()).contains("QuestionnaireResponse.item[0].answer[0]");
- assertThat(errors.getMessages().get(1).getMessage()).contains("The code 'code1' in the system 'null' is not in the options value set (ValueSet[http://somevalueset]) specified by the questionnaire. Terminology Error: Validation failed");
+ assertThat(errors.getMessages().get(1).getMessage()).contains("The code 'code1' in the system 'null' is not in the options value set (ValueSet[http://somevalueset]) specified by the questionnaire. Terminology Error: Unknown code 'code1' for in-memory expansion of ValueSet 'http://somevalueset'");
assertThat(errors.getMessages().get(1).getLocationString()).contains("QuestionnaireResponse.item[0].answer[0]");
qa = new QuestionnaireResponse();
diff --git a/hapi-fhir-validation/src/test/java/org/hl7/fhir/r4/validation/FhirInstanceValidatorR4Test.java b/hapi-fhir-validation/src/test/java/org/hl7/fhir/r4/validation/FhirInstanceValidatorR4Test.java
index fb46f7f8008..ff5d8e2e1fe 100644
--- a/hapi-fhir-validation/src/test/java/org/hl7/fhir/r4/validation/FhirInstanceValidatorR4Test.java
+++ b/hapi-fhir-validation/src/test/java/org/hl7/fhir/r4/validation/FhirInstanceValidatorR4Test.java
@@ -21,7 +21,6 @@ import ca.uhn.hapi.converters.canonical.VersionCanonicalizer;
import com.google.common.base.Charsets;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.Validate;
-import org.hl7.fhir.common.hapi.validation.support.CachingValidationSupport;
import org.hl7.fhir.common.hapi.validation.support.CommonCodeSystemsTerminologyService;
import org.hl7.fhir.common.hapi.validation.support.InMemoryTerminologyServerValidationSupport;
import org.hl7.fhir.common.hapi.validation.support.PrePopulatedValidationSupport;
@@ -133,7 +132,7 @@ public class FhirInstanceValidatorR4Test extends BaseValidationTestWithInlineMoc
private Set myValidSystemsNotReturningIssues = new HashSet<>();
private Set myValidValueSets = new HashSet<>();
private Map myStructureDefinitionMap = new HashMap<>();
- private CachingValidationSupport myValidationSupport;
+ private IValidationSupport myValidationSupport;
private IValidationSupport myMockSupport;
private void addValidConcept(String theSystem, String theCode) {
@@ -909,7 +908,7 @@ public class FhirInstanceValidatorR4Test extends BaseValidationTestWithInlineMoc
public void testValidateProfileWithExtension() throws IOException, FHIRException {
PrePopulatedValidationSupport valSupport = new PrePopulatedValidationSupport(ourCtx);
DefaultProfileValidationSupport defaultSupport = new DefaultProfileValidationSupport(ourCtx);
- CachingValidationSupport support = new CachingValidationSupport(new ValidationSupportChain(defaultSupport, valSupport, new InMemoryTerminologyServerValidationSupport(ourCtx)), false);
+ ValidationSupportChain support = new ValidationSupportChain(defaultSupport, valSupport, new InMemoryTerminologyServerValidationSupport(ourCtx)).setCodeableConceptValidationSuccessfulIfNotAllCodingsAreValid(false);
// Prepopulate SDs
valSupport.addStructureDefinition(loadStructureDefinition(defaultSupport, "/r4/myconsent-profile.xml"));
@@ -1929,7 +1928,7 @@ public class FhirInstanceValidatorR4Test extends BaseValidationTestWithInlineMoc
new CommonCodeSystemsTerminologyService(ourCtx),
new InMemoryTerminologyServerValidationSupport(ourCtx),
new SnapshotGeneratingValidationSupport(ourCtx));
- myValidationSupport = new CachingValidationSupport(chain, theLogicalAnd);
+ myValidationSupport = chain.setCodeableConceptValidationSuccessfulIfNotAllCodingsAreValid(theLogicalAnd);
myInstanceVal = new FhirInstanceValidator(myValidationSupport);
myFhirValidator.registerValidatorModule(myInstanceVal);
}
diff --git a/hapi-fhir-validation/src/test/java/org/hl7/fhir/r4/validation/QuestionnaireResponseValidatorR4Test.java b/hapi-fhir-validation/src/test/java/org/hl7/fhir/r4/validation/QuestionnaireResponseValidatorR4Test.java
index 4a5b10e6cb3..17c347740b4 100644
--- a/hapi-fhir-validation/src/test/java/org/hl7/fhir/r4/validation/QuestionnaireResponseValidatorR4Test.java
+++ b/hapi-fhir-validation/src/test/java/org/hl7/fhir/r4/validation/QuestionnaireResponseValidatorR4Test.java
@@ -110,7 +110,7 @@ public class QuestionnaireResponseValidatorR4Test {
ValueSet options = new ValueSet();
options.getCompose().addInclude().setSystem("http://codesystems.com/system").addConcept().setCode("code0");
- when(myValSupport.fetchResource(eq(ValueSet.class), eq("http://somevalueset"))).thenReturn(options);
+ when(myValSupport.fetchValueSet(eq("http://somevalueset"))).thenReturn(options);
int itemCnt = 16;
QuestionnaireItemType[] questionnaireItemTypes = new QuestionnaireItemType[itemCnt];
@@ -241,7 +241,7 @@ public class QuestionnaireResponseValidatorR4Test {
ValueSet options = new ValueSet();
options.getCompose().addInclude().setSystem("http://codesystems.com/system").addConcept().setCode("code0");
options.getCompose().addInclude().setSystem("http://codesystems.com/system2").addConcept().setCode("code2");
- when(myValSupport.fetchResource(eq(ValueSet.class), eq("http://somevalueset"))).thenReturn(options);
+ when(myValSupport.fetchValueSet(eq("http://somevalueset"))).thenReturn(options);
QuestionnaireResponse qa;
ValidationResult errors;
@@ -376,7 +376,7 @@ public class QuestionnaireResponseValidatorR4Test {
ValueSet options = new ValueSet();
options.getCompose().addInclude().setSystem(codeSystemUrl).addConcept().setCode(codeValue);
- when(myValSupport.fetchResource(eq(ValueSet.class), eq(valueSetRef)))
+ when(myValSupport.fetchValueSet(eq(valueSetRef)))
.thenReturn(options);
when(myValSupport.validateCode(any(), any(), eq(codeSystemUrl), eq(codeValue), any(String.class), anyString()))
.thenReturn(new IValidationSupport.CodeValidationResult().setCode(codeValue));
@@ -433,7 +433,7 @@ public class QuestionnaireResponseValidatorR4Test {
ValueSet options = new ValueSet();
options.getCompose().addInclude().setSystem(codeSystemUrl).addConcept().setCode(codeValue);
- when(myValSupport.fetchResource(eq(ValueSet.class), eq(valueSetRef)))
+ when(myValSupport.fetchValueSet(eq(valueSetRef)))
.thenReturn(options);
when(myValSupport.validateCode(any(), any(), eq(codeSystemUrl), eq(codeValue), any(String.class), anyString()))
.thenReturn(new IValidationSupport.CodeValidationResult().setCode(codeValue));
@@ -553,7 +553,7 @@ public class QuestionnaireResponseValidatorR4Test {
ValueSet options = new ValueSet();
options.getCompose().addInclude().setSystem("http://codesystems.com/system").addConcept().setCode("code0");
options.getCompose().addInclude().setSystem("http://codesystems.com/system2").addConcept().setCode("code2");
- when(myValSupport.fetchResource(eq(ValueSet.class), eq("http://somevalueset"))).thenReturn(options);
+ when(myValSupport.fetchValueSet(eq("http://somevalueset"))).thenReturn(options);
when(myValSupport.validateCode(any(), any(), eq("http://codesystems.com/system"), eq("code0"), any(), nullable(String.class)))
.thenReturn(new IValidationSupport.CodeValidationResult().setCode("code0"));
when(myValSupport.validateCode(any(), any(), eq("http://codesystems.com/system"), eq("code1"), any(), nullable(String.class)))
@@ -833,7 +833,7 @@ public class QuestionnaireResponseValidatorR4Test {
.setValue(new Coding(SYSTEMURI_ICC_SCHOOLTYPE, CODE_ICC_SCHOOLTYPE_PT, ""));
when(myValSupport.fetchResource(eq(Questionnaire.class), eq(qa.getQuestionnaire()))).thenReturn(questionnaire);
- when(myValSupport.fetchResource(eq(ValueSet.class), eq(ID_VS_SCHOOLTYPE))).thenReturn(iccSchoolTypeVs);
+ when(myValSupport.fetchValueSet(eq(ID_VS_SCHOOLTYPE))).thenReturn(iccSchoolTypeVs);
when(myValSupport.validateCodeInValueSet(any(), any(), any(), any(), any(), any(ValueSet.class))).thenReturn(new IValidationSupport.CodeValidationResult().setCode(CODE_ICC_SCHOOLTYPE_PT));
when(myValSupport.fetchCodeSystem(eq(SYSTEMURI_ICC_SCHOOLTYPE))).thenReturn(codeSystem);
ValidationResult errors = myVal.validateWithResult(qa);
diff --git a/hapi-fhir-validation/src/test/java/org/hl7/fhir/r4b/validation/FhirInstanceValidatorR4BTest.java b/hapi-fhir-validation/src/test/java/org/hl7/fhir/r4b/validation/FhirInstanceValidatorR4BTest.java
index d5035a8048e..8b1d4df1051 100644
--- a/hapi-fhir-validation/src/test/java/org/hl7/fhir/r4b/validation/FhirInstanceValidatorR4BTest.java
+++ b/hapi-fhir-validation/src/test/java/org/hl7/fhir/r4b/validation/FhirInstanceValidatorR4BTest.java
@@ -20,7 +20,6 @@ import ca.uhn.fhir.validation.ValidationResult;
import com.google.common.base.Charsets;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.Validate;
-import org.hl7.fhir.common.hapi.validation.support.CachingValidationSupport;
import org.hl7.fhir.common.hapi.validation.support.CommonCodeSystemsTerminologyService;
import org.hl7.fhir.common.hapi.validation.support.InMemoryTerminologyServerValidationSupport;
import org.hl7.fhir.common.hapi.validation.support.PrePopulatedValidationSupport;
@@ -118,7 +117,7 @@ public class FhirInstanceValidatorR4BTest extends BaseValidationTestWithInlineMo
private ArrayList myValidConcepts;
private Set myValidSystems = new HashSet<>();
private Map myStructureDefinitionMap = new HashMap<>();
- private CachingValidationSupport myValidationSupport;
+ private IValidationSupport myValidationSupport;
private IValidationSupport myMockSupport;
private void addValidConcept(String theSystem, String theCode) {
@@ -812,7 +811,7 @@ public class FhirInstanceValidatorR4BTest extends BaseValidationTestWithInlineMo
public void testValidateProfileWithExtension() throws IOException, FHIRException {
PrePopulatedValidationSupport valSupport = new PrePopulatedValidationSupport(ourCtx);
DefaultProfileValidationSupport defaultSupport = new DefaultProfileValidationSupport(ourCtx);
- CachingValidationSupport support = new CachingValidationSupport(new ValidationSupportChain(defaultSupport, valSupport, new InMemoryTerminologyServerValidationSupport(ourCtx)), false);
+ ValidationSupportChain support = new ValidationSupportChain(defaultSupport, valSupport, new InMemoryTerminologyServerValidationSupport(ourCtx)).setCodeableConceptValidationSuccessfulIfNotAllCodingsAreValid(false);
// Prepopulate SDs
valSupport.addStructureDefinition(loadStructureDefinition(defaultSupport, "/r4/myconsent-profile.xml"));
@@ -1694,7 +1693,7 @@ public class FhirInstanceValidatorR4BTest extends BaseValidationTestWithInlineMo
new CommonCodeSystemsTerminologyService(ourCtx),
new InMemoryTerminologyServerValidationSupport(ourCtx),
new SnapshotGeneratingValidationSupport(ourCtx));
- myValidationSupport = new CachingValidationSupport(chain, theLogicalAnd);
+ myValidationSupport = chain.setCodeableConceptValidationSuccessfulIfNotAllCodingsAreValid(theLogicalAnd);
myInstanceVal = new FhirInstanceValidator(myValidationSupport);
myFhirValidator.registerValidatorModule(myInstanceVal);
}
diff --git a/hapi-fhir-validation/src/test/java/org/hl7/fhir/r5/validation/FhirInstanceValidatorR5Test.java b/hapi-fhir-validation/src/test/java/org/hl7/fhir/r5/validation/FhirInstanceValidatorR5Test.java
index abcb0f94704..7a58d4f7d25 100644
--- a/hapi-fhir-validation/src/test/java/org/hl7/fhir/r5/validation/FhirInstanceValidatorR5Test.java
+++ b/hapi-fhir-validation/src/test/java/org/hl7/fhir/r5/validation/FhirInstanceValidatorR5Test.java
@@ -16,9 +16,9 @@ import ca.uhn.fhir.validation.SingleValidationMessage;
import ca.uhn.fhir.validation.ValidationResult;
import com.google.common.base.Charsets;
import org.apache.commons.io.IOUtils;
-import org.hl7.fhir.common.hapi.validation.support.CachingValidationSupport;
import org.hl7.fhir.common.hapi.validation.support.CommonCodeSystemsTerminologyService;
import org.hl7.fhir.common.hapi.validation.support.InMemoryTerminologyServerValidationSupport;
+import org.hl7.fhir.common.hapi.validation.support.SnapshotGeneratingValidationSupport;
import org.hl7.fhir.common.hapi.validation.support.ValidationSupportChain;
import org.hl7.fhir.common.hapi.validation.validator.FhirInstanceValidator;
import org.hl7.fhir.instance.model.api.IBaseResource;
@@ -100,7 +100,7 @@ public class FhirInstanceValidatorR5Test extends BaseValidationTestWithInlineMoc
private Set mySupportedValueSets = new HashSet<>();
private Set myValidSystems = new HashSet<>();
private Set myValidSystemsNotReturningIssues = new HashSet<>();
- private CachingValidationSupport myValidationSupport;
+ private IValidationSupport myValidationSupport;
private void addValidConcept(String theSystem, String theCode) {
addValidConcept(theSystem, theCode, true);
@@ -141,7 +141,7 @@ public class FhirInstanceValidatorR5Test extends BaseValidationTestWithInlineMoc
myMockSupport = mock(IValidationSupport.class);
when(myMockSupport.getFhirContext()).thenReturn(ourCtx);
- myValidationSupport = new CachingValidationSupport(new ValidationSupportChain(myMockSupport, myDefaultValidationSupport, new InMemoryTerminologyServerValidationSupport(ourCtx), new CommonCodeSystemsTerminologyService(ourCtx)));
+ myValidationSupport = new ValidationSupportChain(myMockSupport, myDefaultValidationSupport, new InMemoryTerminologyServerValidationSupport(ourCtx), new CommonCodeSystemsTerminologyService(ourCtx), new SnapshotGeneratingValidationSupport(ourCtx));
myInstanceVal = new FhirInstanceValidator(myValidationSupport);
myVal.registerValidatorModule(myInstanceVal);
@@ -222,7 +222,7 @@ public class FhirInstanceValidatorR5Test extends BaseValidationTestWithInlineMoc
when(myMockSupport.fetchStructureDefinition(nullable(String.class))).thenAnswer(new Answer() {
@Override
public StructureDefinition answer(InvocationOnMock theInvocation) {
- StructureDefinition retVal = (StructureDefinition) myDefaultValidationSupport.fetchStructureDefinition((String) theInvocation.getArguments()[1]);
+ StructureDefinition retVal = (StructureDefinition) myDefaultValidationSupport.fetchStructureDefinition((String) theInvocation.getArguments()[0]);
ourLog.debug("fetchStructureDefinition({}) : {}", new Object[]{theInvocation.getArguments()[0], retVal});
return retVal;
}
diff --git a/hapi-fhir-validation/src/test/java/org/hl7/fhir/r5/validation/QuestionnaireResponseValidatorR5Test.java b/hapi-fhir-validation/src/test/java/org/hl7/fhir/r5/validation/QuestionnaireResponseValidatorR5Test.java
index ebd1679278b..fbd25fbad33 100644
--- a/hapi-fhir-validation/src/test/java/org/hl7/fhir/r5/validation/QuestionnaireResponseValidatorR5Test.java
+++ b/hapi-fhir-validation/src/test/java/org/hl7/fhir/r5/validation/QuestionnaireResponseValidatorR5Test.java
@@ -112,7 +112,7 @@ public class QuestionnaireResponseValidatorR5Test {
ValueSet options = new ValueSet();
options.getCompose().addInclude().setSystem("http://codesystems.com/system").addConcept().setCode("code0");
- when(myValSupport.fetchResource(eq(ValueSet.class), eq("http://somevalueset"))).thenReturn(options);
+ when(myValSupport.fetchValueSet(eq("http://somevalueset"))).thenReturn(options);
when(myValSupport.validateCode(any(), any(), any(), any(), any(), nullable(String.class)))
.thenReturn(new IValidationSupport.CodeValidationResult().setSeverity(IValidationSupport.IssueSeverity.ERROR).setMessage("Unknown code"));
@@ -241,7 +241,7 @@ public class QuestionnaireResponseValidatorR5Test {
ValueSet options = new ValueSet();
options.getCompose().addInclude().setSystem("http://codesystems.com/system").addConcept().setCode("code0");
options.getCompose().addInclude().setSystem("http://codesystems.com/system2").addConcept().setCode("code2");
- when(myValSupport.fetchResource(eq(ValueSet.class), eq("http://somevalueset"))).thenReturn(options);
+ when(myValSupport.fetchValueSet(eq("http://somevalueset"))).thenReturn(options);
QuestionnaireResponse qa;
ValidationResult errors;
@@ -374,7 +374,7 @@ public class QuestionnaireResponseValidatorR5Test {
ValueSet options = new ValueSet();
options.getCompose().addInclude().setSystem(codeSystemUrl).addConcept().setCode(codeValue);
- when(myValSupport.fetchResource(eq(ValueSet.class), eq(valueSetRef)))
+ when(myValSupport.fetchValueSet(eq(valueSetRef)))
.thenReturn(options);
when(myValSupport.validateCode(any(), any(), eq(codeSystemUrl), eq(codeValue), any(String.class), anyString()))
.thenReturn(new IValidationSupport.CodeValidationResult().setCode(codeValue));
@@ -435,7 +435,8 @@ public class QuestionnaireResponseValidatorR5Test {
ValueSet options = new ValueSet();
options.getCompose().addInclude().setSystem(codeSystemUrl).addConcept().setCode(codeValue);
- when(myValSupport.fetchResource(eq(ValueSet.class), eq(valueSetRef)))
+ when(myValSupport.isValueSetSupported(any(), eq(valueSetRef))).thenReturn(true);
+ when(myValSupport.fetchValueSet(eq(valueSetRef)))
.thenReturn(options);
when(myValSupport.validateCode(any(), any(), eq(codeSystemUrl), eq(codeValue), any(String.class), anyString()))
.thenReturn(new IValidationSupport.CodeValidationResult().setCode(codeValue));
@@ -564,7 +565,7 @@ public class QuestionnaireResponseValidatorR5Test {
ValueSet options = new ValueSet();
options.getCompose().addInclude().setSystem("http://codesystems.com/system").addConcept().setCode("code0");
options.getCompose().addInclude().setSystem("http://codesystems.com/system2").addConcept().setCode("code2");
- when(myValSupport.fetchResource(eq(ValueSet.class), eq("http://somevalueset"))).thenReturn(options);
+ when(myValSupport.fetchValueSet(eq("http://somevalueset"))).thenReturn(options);
when(myValSupport.validateCode(any(), any(), eq("http://codesystems.com/system"), eq("code0"), any(), nullable(String.class)))
.thenReturn(new IValidationSupport.CodeValidationResult().setCode("code0"));
@@ -721,7 +722,7 @@ public class QuestionnaireResponseValidatorR5Test {
.setValue(new Coding(SYSTEMURI_ICC_SCHOOLTYPE, CODE_ICC_SCHOOLTYPE_PT, ""));
when(myValSupport.fetchResource(eq(Questionnaire.class), eq(qa.getQuestionnaire()))).thenReturn(questionnaire);
- when(myValSupport.fetchResource(eq(ValueSet.class), eq(ID_VS_SCHOOLTYPE))).thenReturn(iccSchoolTypeVs);
+ when(myValSupport.fetchValueSet(eq(ID_VS_SCHOOLTYPE))).thenReturn(iccSchoolTypeVs);
when(myValSupport.validateCodeInValueSet(any(), any(), any(), any(), any(), any(ValueSet.class))).thenReturn(new IValidationSupport.CodeValidationResult().setCode(CODE_ICC_SCHOOLTYPE_PT));
when(myValSupport.fetchCodeSystem(eq(SYSTEMURI_ICC_SCHOOLTYPE))).thenReturn(codeSystem);
ValidationResult errors = myVal.validateWithResult(qa);
diff --git a/hapi-tinder-plugin/pom.xml b/hapi-tinder-plugin/pom.xml
index d3fa30406ab..93b151848b7 100644
--- a/hapi-tinder-plugin/pom.xml
+++ b/hapi-tinder-plugin/pom.xml
@@ -5,7 +5,7 @@
ca.uhn.hapi.fhir
hapi-fhir
- 7.7.7-SNAPSHOT
+ 7.7.8-SNAPSHOT
../pom.xml
diff --git a/hapi-tinder-test/pom.xml b/hapi-tinder-test/pom.xml
index db18a5dad1f..15b14e92ac8 100644
--- a/hapi-tinder-test/pom.xml
+++ b/hapi-tinder-test/pom.xml
@@ -4,7 +4,7 @@
ca.uhn.hapi.fhir
hapi-fhir
- 7.7.7-SNAPSHOT
+ 7.7.8-SNAPSHOT
../pom.xml
diff --git a/pom.xml b/pom.xml
index 9b19056b43d..05227daf415 100644
--- a/pom.xml
+++ b/pom.xml
@@ -8,7 +8,7 @@
ca.uhn.hapi.fhir
hapi-fhir
pom
- 7.7.7-SNAPSHOT
+ 7.7.8-SNAPSHOT
HAPI-FHIR
An open-source implementation of the FHIR specification in Java.
@@ -1033,7 +1033,13 @@
3.3.0
1.8
4.12.0
+
2.8.0
+ ${otel_instrumentation.version}-alpha
4.1.2
1.4
6.2.9.Final
@@ -2306,6 +2312,16 @@
pom
import