Merge pull request #3918 from LinuxForHealth/issue-2964-followon

issue-2964 - adding validations for interaction, mode paramter and in…

Author: lmsurpre

fhir-server-test/src/test/java/org/linuxforhealth/fhir/server/test/FHIROperationTest.java

@@ -1,5 +1,5 @@
 /*
- * (C) Copyright IBM Corp. 2017,2019
+ * (C) Copyright IBM Corp. 2017, 2022
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -276,7 +276,7 @@ public void testGetHelloOperation() throws Exception {
         assertEquals(((org.linuxforhealth.fhir.model.type.String) output.getParameter().get(0).getValue()).getValue(),
                 message);
     }
-    
+
     @Test(groups = { "fhir-operation" })
     // Testcase for GET [baseUrl]/${operationName}?input-boolean=true&input-canonical="https://examples.com"&input-code...
     public void testGetHelloOperationWithPrimitives() throws Exception {
@@ -309,7 +309,7 @@ public void testGetHelloOperationWithPrimitives() throws Exception {
         assertFalse(output.getParameter().isEmpty());
         assertEquals(output.getParameter().size(), 16);
     }
-    
+
     @Test(groups = { "fhir-operation" })
     // Testcase for GET [baseUrl]/${operationName}"
     public void testGetHelloOperationWithEmptyBody() throws Exception {
@@ -351,11 +351,7 @@ public void testGetRscValidateOperation() throws Exception {
         assertEquals(response.getStatus(), Response.Status.BAD_REQUEST.getStatusCode());
         OperationOutcome operationOutcome = response.getResource(OperationOutcome.class);
         String text = operationOutcome.getIssue().get(0).getDetails().getText().getValue();
-        if (text.contains("Input parameter 'resource' is required")) {
-            assertTrue(true); // Force assertion to true
-        } else {
-            assertTrue(false); // Force assertion to false
-        }
+        assertTrue(text.contains("Input parameter 'resource' must be present"), "Issue detail must say 'resource' is required");
     }
 
     @Test(groups = { "fhir-operation" }, dependsOnMethods = { "testCreatePractitioner", "testCreatePatient" })

operation/fhir-operation-validate/src/main/java/org/linuxforhealth/fhir/operation/validate/ValidateOperation.java

@@ -51,49 +51,34 @@ protected Parameters doInvoke(FHIROperationContext operationContext, Class<? ext
         try {
             Parameter resourceParameter = getParameter(parameters, "resource");
             String resourceTypeName = resourceType != null ? resourceType.getSimpleName() : null;
-            Resource resource;
-            // If $validate is on resource-instance level, fetch the resource from database.
-            if (operationContext != null && FHIROperationContext.Type.INSTANCE.equals(operationContext.getType()) && resourceParameter == null) {
-                resource = resourceHelper.doRead(resourceTypeName, logicalId).getResource();
-                if (resource == null) {
-                    throw buildExceptionWithIssue(resourceTypeName + " with id '" + logicalId + "' was not found", IssueType.NOT_FOUND);
-                }
-            } else if (resourceParameter == null) {
-                throw buildExceptionWithIssue("Input parameter 'resource' is required for the $validate operation", IssueType.INVALID);
-            } else {
-                resource = resourceParameter.getResource();
-            }
+            Parameter modeParameter = getParameter(parameters, "mode");
+            ModeType modeType = getModeType(modeParameter);
+            // Validate the resource parameter
+            Resource resource = validateResource(operationContext, logicalId, resourceHelper, resourceParameter, resourceTypeName, modeType);
 
             List<OperationOutcome.Issue> issues;
             Parameter profileParameter = getParameter(parameters, "profile");
-            Parameter modeParameter = getParameter(parameters, "mode");
 
-            // Only valid "mode" codes are accepted by the $validate operation.
-            validateModeParameter(modeParameter);
+            // Validate mode parameter.
+            validateModeParameter(modeType, resourceHelper, resourceTypeName, operationContext, logicalId);
 
             if (profileParameter != null && profileParameter.getValue() != null) {
                 // If the 'profile' parameter is specified, always validate the resource against that profile.
                 Uri profileUri = profileParameter.getValue().as(Uri.class);
                 String profile = profileUri == null ? null : profileUri.getValue();
                 issues = FHIRValidator.validator().validate(resource, profile);
-            } else if (modeParameter != null && modeParameter.getValue() != null
-                    && ("create".equals(modeParameter.getValue().as(Code.class).getValue())
-                            || "update".equals(modeParameter.getValue().as(Code.class).getValue()))) {
+            } else if (modeType == ModeType.CREATE || modeType == ModeType.UPDATE) {
                 // If the 'mode' parameter is specified and its value is 'create' or 'update', validate the resource
                 // against the FHIR server config's profile properties and the resource's asserted profiles.
                 issues = resourceHelper.validateResource(resource);
-            } else if (modeParameter != null 
-                    && modeParameter.getValue() != null
-                    && ModeType.DELETE.value().equals(modeParameter.getValue().as(Code.class).getValue())
-                    && FHIROperationContext.Type.INSTANCE.equals(operationContext.getType())) {
+            } else if (modeType == ModeType.DELETE && operationContext.getType() == FHIROperationContext.Type.INSTANCE) {
                 // If the 'mode' parameter is specified and its value is 'delete' and delete is invoked at the resource-instance level,
                 // validate if the persistence layer implementation supports the "delete" operation
                 issues = validateDeleteResource(resourceTypeName, logicalId, operationContext);
             } else {
                 // Standard validation against the resource's asserted profiles.
                 issues = FHIRValidator.validator().validate(resource);
-            }
-
+            } 
             return FHIROperationUtil.getOutputParameters(buildResourceValidOperationOutcome(issues));
         } catch (FHIROperationException e) {
             throw e;
@@ -131,21 +116,90 @@ private OperationOutcome buildResourceValidOperationOutcome(List<Issue> issues)
 
 
     /**
-     * Check if a resource validation mode code is valid.
+     * This method does the following validations if modeType(mode parameter) is not null. If the mode parameter is null then the below validations are skipped.
+     * 1. Validate an interaction for a specified resource type.
+     * 2. Validate if persistence layer implementation supports update/create mode if mode = create.
+     * 3. Validate if persistence layer implementation supports update/create mode if mode = update but the resource doesnot exist yet in the DB.
+     * 4. Validate if modes update and delete are only be used when the operation is invoked at the resource instance level
      *
      * @param modeParameter resource validation mode code to be validated
-     * @throws FHIROperationException when the resource validation mode code is invalid
+     * @param resourceHelper Resource operation provider for loading related Library resources
+     * @param resourceType a valid resource type string
+     * @param operationContext the FHIROperationContext associated with the request
+     * @throws Exception 
+     */
+    private void validateModeParameter(ModeType modetype, FHIRResourceHelpers resourceHelper, String resourceType, FHIROperationContext operationContext, String logicalId) throws Exception {
+        if (modetype == null) {
+            return;
+        }
+        // Validate an interaction for a specified resource type.
+        if ((modetype == ModeType.CREATE  
+                || modetype == ModeType.UPDATE 
+                || modetype == ModeType.DELETE)
+                && resourceType != null) {
+            FHIRResourceHelpers.Interaction interaction = FHIRResourceHelpers.Interaction.from(modetype.value());
+            resourceHelper.validateInteraction(interaction, resourceType);
+        }
+        // Validate if persistence layer implementation supports update/create mode if mode = create.
+        if (operationContext != null && operationContext.getType() == FHIROperationContext.Type.INSTANCE 
+                && modetype == ModeType.CREATE) {
+            validateUpdateCreateEnabled(modetype, resourceType, operationContext);
+        }
+        // Validate if persistence layer implementation supports update/create mode if mode = update but the resource does not exist yet in the DB.
+        if (operationContext != null && operationContext.getType() == FHIROperationContext.Type.INSTANCE 
+                && modetype == ModeType.UPDATE) {
+            Resource existingResource = resourceHelper.doRead(resourceType, logicalId).getResource();
+            if (existingResource == null) {
+                validateUpdateCreateEnabled(modetype, resourceType, operationContext);    
+            }
+        }
+        // Validate if modes update and delete are only be used when the operation is invoked at the resource instance level
+        if (operationContext != null && operationContext.getType() == FHIROperationContext.Type.RESOURCE_TYPE && 
+                (modetype == ModeType.UPDATE || modetype == ModeType.DELETE)) {
+            
+            throw buildExceptionWithIssue(IssueSeverity.ERROR, IssueType.NOT_SUPPORTED, "Modes update and delete can only be used when the operation is invoked at the resource instance level.", null);
+        }
+    }
+
+    /**
+     * This method when invoked checks if the persistence layer implementation supports update/create.
+     * If the persistence layer implementation does not support update/create a FHIROperationException with issue is thrown.
+     * @param modetype
+     * @param resourceType
+     * @param operationContext
+     * @throws FHIROperationException
      */
-    private void validateModeParameter(Parameter modeParameter) throws FHIROperationException {
+    private void validateUpdateCreateEnabled(ModeType modetype, String resourceType, FHIROperationContext operationContext) throws FHIROperationException {
+        FHIRPersistence persistence =
+                (FHIRPersistence) operationContext.getProperty(FHIROperationContext.PROPNAME_PERSISTENCE_IMPL);
+        if (!persistence.isUpdateCreateEnabled()) {
+            throw buildExceptionWithIssue(IssueSeverity.ERROR, IssueType.NOT_SUPPORTED, "Resource " + modetype.value() +  ", of type '"
+                    + resourceType + "', is not supported.", null);  
+        }
+    }
+
+    /**
+     * If the mode parameter is not null, this method validates if a resource validation mode code is valid and
+     * returns valid resource validation mode code from ModeType enum.
+     * If mode parameter is null this method returns null.
+     * If mode parameter is not valid this method throws FHIROperationException with issues.
+     * @param modeParameter resource validation mode code
+     * @return The corresponding ModeType or null if a null value was passed
+     * @throws FHIROperationException
+     */
+    private ModeType getModeType(Parameter modeParameter) throws FHIROperationException {
         if (modeParameter != null && modeParameter.getValue() != null) {
+            ModeType modetype;
             try {
-                ModeType.from(modeParameter.getValue().as(Code.class).getValue());
+                modetype =  ModeType.from(modeParameter.getValue().as(Code.class).getValue());
             } catch (IllegalArgumentException e) {
                 String msg = "'" + modeParameter.getValue().as(Code.class).getValue() + "' is not a valid resource validation mode";
-                throw buildExceptionWithIssue(msg, IssueType.VALUE);
+                throw buildExceptionWithIssue(IssueSeverity.ERROR, IssueType.NOT_SUPPORTED, msg, null);
             }
+            return modetype;
+            
         }
-        
+        return null;
     }
 
 
@@ -163,9 +217,72 @@ public List<Issue> validateDeleteResource(String type, String id, FHIROperationC
         FHIRPersistence persistence =
                 (FHIRPersistence) operationContext.getProperty(FHIROperationContext.PROPNAME_PERSISTENCE_IMPL);
         if (!persistence.isDeleteSupported()) {
-            warnings.add(FHIRUtil.buildOperationOutcomeIssue(IssueSeverity.WARNING, IssueType.NOT_SUPPORTED, "Resource deletion of type '"
-                    + type + "' with id '" + id + "' is not supported."));
+            warnings.add(FHIRUtil.buildOperationOutcomeIssue(IssueSeverity.ERROR, IssueType.NOT_SUPPORTED, "Resource deletion, of type '"
+                    + type + "', with id '" + id + "', is not supported."));
         }
         return warnings;
     }
+    
+    /**
+     * Method to build the OperationOutcome error response
+     * @param severity the issue severity
+     * @param issueType describes the type of issue
+     * @param msg describes the error message
+     * @param cause the throwable that causes this OperationOutcome/Exception
+     * @return FHIROperationException with issues
+     * @throws FHIROperationException
+     */
+    protected FHIROperationException buildExceptionWithIssue(IssueSeverity severity, IssueType issueType, String msg, Throwable cause) throws FHIROperationException {
+        OperationOutcome.Issue ooi = FHIRUtil.buildOperationOutcomeIssue(severity, issueType, msg);
+        return new FHIROperationException(msg, cause).withIssue(ooi);
+    }
+    
+    /**
+     * Method to validate the resource parameter. The below validations are performed by this method.
+     * 1. if $validate is invoked at instance level and mode = create, check if the resource already exists.
+     * 2. resource parameter must be present unless the mode is "delete" (or "profile" per https://jira.hl7.org/browse/FHIR-37998)
+     * 3. if mode=profile AND no resource parameter value is provided then the resource at this id is read and validated against the nominated profile
+     * @param operationContext - the FHIROperationContext associated with the request
+     * @param logicalId - the logical id of the FHIR resource
+     * @param resourceHelper - Resource operation provider for loading related Library resources
+     * @param resourceParameter - the input resource parameter
+     * @param resourceType  - a valid resource type string
+     * @param modeType - a valid resource validation mode code
+     * @return Resource - a FHIR Resource object
+     * @throws Exception
+     * @throws FHIROperationException
+     */
+    private Resource validateResource(FHIROperationContext operationContext, String logicalId, FHIRResourceHelpers resourceHelper, Parameter resourceParameter,
+        String resourceType, ModeType modeType) throws Exception, FHIROperationException {
+        Resource resource = null;
+        // if $validate is invoked at instance level and mode = create, check if the resource already exists. 
+        if (operationContext != null && operationContext.getType() == FHIROperationContext.Type.INSTANCE 
+                && modeType == ModeType.CREATE) {
+            Resource existingResource = resourceHelper.doRead(resourceType, logicalId).getResource();
+            if (existingResource != null) {
+                throw buildExceptionWithIssue(IssueSeverity.ERROR, IssueType.NOT_SUPPORTED, resourceType + " with id '" + logicalId + "' already exists", null);
+            }
+        }
+        // resource parameter must be present unless the mode is "delete" (or "profile" per https://jira.hl7.org/browse/FHIR-37998)
+        if (resourceParameter == null 
+                && (modeType == null 
+                || modeType == ModeType.CREATE 
+                || modeType == ModeType.UPDATE)) {
+            throw buildExceptionWithIssue(IssueSeverity.ERROR, IssueType.INVALID, "Input parameter 'resource' must be present unless the mode is 'delete' or 'profile'", null);
+        }
+        // if mode=profile AND no resource parameter value is provided then the resource at this id is read and validated against the nominated profile
+        if (resourceParameter == null && operationContext != null && operationContext.getType() == FHIROperationContext.Type.INSTANCE 
+                && modeType == ModeType.PROFILE) {
+            resource = resourceHelper.doRead(resourceType, logicalId).getResource();
+            if (resource == null) {
+                throw buildExceptionWithIssue(IssueSeverity.ERROR, IssueType.INVALID, resourceType + " with id '" + logicalId + "' does not exist", null);
+            }
+        }
+        
+        if (resourceParameter != null) {
+            resource = resourceParameter.getResource();
+        }
+        return resource;
+    }
+    
 }

operation/fhir-operation-validate/src/main/java/org/linuxforhealth/fhir/operation/validate/type/ModeType.java

@@ -14,7 +14,7 @@ public enum ModeType {
     CREATE("create"),
     UPDATE("update"),
     DELETE("delete"),
-    PROFILE("PROFILE");
+    PROFILE("profile");
 
     private String value;