Link the existing InstantiationController with the generated code

Issue-ID: POLICY-4467
Change-Id: Ibe9206ee4189e73357271211d83b0603edfb86da
Signed-off-by: FrancescoFioraEst <francesco.fiora@est.tech>

11 files changed, 322 insertions, 582 deletions

diff --git a/runtime-acm/pom.xml b/runtime-acm/pom.xml
index c16bd15ab..903d527aa 100644
--- a/runtime-acm/pom.xml
+++ b/runtime-acm/pom.xml
@@ -79,7 +79,8 @@
                                 InstancePropertiesResponse=org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstancePropertiesResponse,
                                 CommissioningResponse=org.onap.policy.clamp.models.acm.messages.rest.commissioning.CommissioningResponse,
                                 InstantiationCommand=org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationCommand,
-                                InstantiationResponse=org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationResponse
+                                InstantiationResponse=org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationResponse,
+                                InstantiationUpdate=org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationUpdate
                             </importMappings>
                             <configOptions>
                                 <sourceFolder>src/gen/java</sourceFolder>
diff --git a/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/commissioning/CommissioningProvider.java b/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/commissioning/CommissioningProvider.java
index 19d4afe11..66a67a304 100644
--- a/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/commissioning/CommissioningProvider.java
+++ b/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/commissioning/CommissioningProvider.java
@@ -94,10 +94,6 @@ public class CommissioningProvider {
      */
     public CommissioningResponse createAutomationCompositionDefinitions(ToscaServiceTemplate serviceTemplate) {
 
-        if (verifyIfDefinitionExists()) {
-            throw new PfModelRuntimeException(Status.BAD_REQUEST,
-                    "Delete instances, to commission automation composition definitions");
-        }
         var acmDefinition = acDefinitionProvider.createAutomationCompositionDefinition(serviceTemplate);
         serviceTemplate = acmDefinition.getServiceTemplate();
         var participantList = participantProvider.getParticipants();
@@ -191,13 +187,4 @@ public class CommissioningProvider {
     private boolean verifyIfInstanceExists(UUID compositionId) {
         return !acProvider.getAcInstancesByCompositionId(compositionId).isEmpty();
     }
-
-    /**
-     * Validates to see if there is any instance saved.
-     *
-     * @return true if exists instance
-     */
-    private boolean verifyIfDefinitionExists() {
-        return !acDefinitionProvider.getAllAcDefinitions().isEmpty();
-    }
 }
diff --git a/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/instantiation/AutomationCompositionInstantiationProvider.java b/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/instantiation/AutomationCompositionInstantiationProvider.java
index 03a2f4e25..374c94f5d 100644
--- a/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/instantiation/AutomationCompositionInstantiationProvider.java
+++ b/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/instantiation/AutomationCompositionInstantiationProvider.java
@@ -22,6 +22,7 @@
 package org.onap.policy.clamp.acm.runtime.instantiation;
 
 import java.util.List;
+import java.util.UUID;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import javax.ws.rs.core.Response;
@@ -29,12 +30,14 @@ import javax.ws.rs.core.Response.Status;
 import lombok.AllArgsConstructor;
 import org.onap.policy.clamp.acm.runtime.supervision.SupervisionHandler;
 import org.onap.policy.clamp.common.acm.exception.AutomationCompositionException;
+import org.onap.policy.clamp.common.acm.exception.AutomationCompositionRuntimeException;
 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionState;
 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositions;
 import org.onap.policy.clamp.models.acm.concepts.Participant;
 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationCommand;
 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationResponse;
+import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationUpdate;
 import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
 import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
 import org.onap.policy.clamp.models.acm.persistence.provider.ParticipantProvider;
@@ -43,7 +46,6 @@ import org.onap.policy.common.parameters.BeanValidationResult;
 import org.onap.policy.common.parameters.ObjectValidationResult;
 import org.onap.policy.common.parameters.ValidationStatus;
 import org.onap.policy.models.base.PfModelRuntimeException;
-import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -55,6 +57,7 @@ import org.springframework.transaction.annotation.Transactional;
 @AllArgsConstructor
 public class AutomationCompositionInstantiationProvider {
     private static final String AUTOMATION_COMPOSITION_NODE_ELEMENT_TYPE = "AutomationCompositionElement";
+    private static final String DO_NOT_MATCH = " do not match with ";
 
     private final AutomationCompositionProvider automationCompositionProvider;
     private final SupervisionHandler supervisionHandler;
@@ -65,11 +68,16 @@ public class AutomationCompositionInstantiationProvider {
     /**
      * Create automation composition.
      *
+     * @param compositionId The UUID of the automation composition definition
      * @param automationComposition the automation composition
      * @return the result of the instantiation operation
      */
-    public InstantiationResponse createAutomationComposition(AutomationComposition automationComposition) {
-
+    public InstantiationResponse createAutomationComposition(UUID compositionId,
+            AutomationComposition automationComposition) {
+        if (!compositionId.equals(automationComposition.getCompositionId())) {
+            throw new PfModelRuntimeException(Response.Status.BAD_REQUEST,
+                    automationComposition.getCompositionId() + DO_NOT_MATCH + compositionId);
+        }
         var checkAutomationCompositionOpt =
                 automationCompositionProvider.findAutomationComposition(automationComposition.getKey().asIdentifier());
         if (checkAutomationCompositionOpt.isPresent()) {
@@ -93,20 +101,34 @@ public class AutomationCompositionInstantiationProvider {
     /**
      * Update automation composition.
      *
-     * @param automationComposition the automation composition
-     * @return the result of the instantiation operation
+     * @param compositionId The UUID of the automation composition definition
+     * @param instanceId The UUID of the automation composition instance
+     * @param instanceUpdate the automation composition
+     * @return the result of the update
      */
-    public InstantiationResponse updateAutomationComposition(AutomationComposition automationComposition) {
-        var validationResult = validateAutomationComposition(automationComposition);
-        if (!validationResult.isValid()) {
-            throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, validationResult.getResult());
+    public InstantiationResponse updateAutomationComposition(UUID compositionId, UUID instanceId,
+            InstantiationUpdate instanceUpdate) {
+        var automationComposition = automationCompositionProvider.getAutomationComposition(instanceId);
+        if (!compositionId.equals(automationComposition.getCompositionId())) {
+            throw new PfModelRuntimeException(Response.Status.BAD_REQUEST,
+                    automationComposition.getCompositionId() + DO_NOT_MATCH + compositionId);
+        }
+        if (instanceUpdate.getElements() != null) {
+            automationComposition.setElements(instanceUpdate.getElements());
+            var validationResult = validateAutomationComposition(automationComposition);
+            if (!validationResult.isValid()) {
+                throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, validationResult.getResult());
+            }
+            automationComposition = automationCompositionProvider.updateAutomationComposition(automationComposition);
+        }
+
+        if (instanceUpdate.getInstantiationCommand() != null) {
+            issueAutomationCompositionCommand(automationComposition, instanceUpdate.getInstantiationCommand());
         }
-        automationCompositionProvider.updateAutomationComposition(automationComposition);
 
         var response = new InstantiationResponse();
-        response.setInstanceId(automationComposition.getInstanceId());
+        response.setInstanceId(instanceId);
         response.setAffectedAutomationComposition(automationComposition.getKey().asIdentifier());
-
         return response;
     }
 
@@ -130,19 +152,35 @@ public class AutomationCompositionInstantiationProvider {
     }
 
     /**
+     * Get Automation Composition.
+     *
+     * @param compositionId The UUID of the automation composition definition
+     * @param instanceId The UUID of the automation composition instance
+     * @return the Automation Composition
+     */
+    @Transactional(readOnly = true)
+    public AutomationComposition getAutomationComposition(UUID compositionId, UUID instanceId) {
+        var automationComposition = automationCompositionProvider.getAutomationComposition(instanceId);
+        if (!automationComposition.getCompositionId().equals(compositionId)) {
+            throw new PfModelRuntimeException(Response.Status.BAD_REQUEST,
+                    "Composition Id " + compositionId + DO_NOT_MATCH + automationComposition.getCompositionId());
+        }
+        return automationComposition;
+    }
+
+    /**
      * Delete the automation composition with the given name and version.
      *
-     * @param name the name of the automation composition to delete
-     * @param version the version of the automation composition to delete
+     * @param compositionId The UUID of the automation composition definition
+     * @param instanceId The UUID of the automation composition instance
      * @return the result of the deletion
      */
-    public InstantiationResponse deleteAutomationComposition(String name, String version) {
-        var automationCompositionOpt =
-                automationCompositionProvider.findAutomationComposition(new ToscaConceptIdentifier(name, version));
-        if (automationCompositionOpt.isEmpty()) {
-            throw new PfModelRuntimeException(Response.Status.NOT_FOUND, "Automation composition not found");
+    public InstantiationResponse deleteAutomationComposition(UUID compositionId, UUID instanceId) {
+        var automationComposition = automationCompositionProvider.getAutomationComposition(instanceId);
+        if (!compositionId.equals(automationComposition.getCompositionId())) {
+            throw new PfModelRuntimeException(Response.Status.BAD_REQUEST,
+                    automationComposition.getCompositionId() + DO_NOT_MATCH + compositionId);
         }
-        var automationComposition = automationCompositionOpt.get();
         if (!AutomationCompositionState.UNINITIALISED.equals(automationComposition.getState())) {
             throw new PfModelRuntimeException(Response.Status.BAD_REQUEST,
                     "Automation composition state is still " + automationComposition.getState());
@@ -174,42 +212,33 @@ public class AutomationCompositionInstantiationProvider {
     /**
      * Issue a command to automation compositions, setting their ordered state.
      *
+     * @param automationComposition the AutomationComposition
      * @param command the command to issue to automation compositions
-     * @return the result of the initiation command
-     * @throws AutomationCompositionException on ordered state invalid
      */
-    public InstantiationResponse issueAutomationCompositionCommand(InstantiationCommand command)
-            throws AutomationCompositionException {
+    public void issueAutomationCompositionCommand(AutomationComposition automationComposition,
+            InstantiationCommand command) {
 
         if (command.getOrderedState() == null) {
-            throw new AutomationCompositionException(Status.BAD_REQUEST,
+            throw new AutomationCompositionRuntimeException(Status.BAD_REQUEST,
                     "ordered state invalid or not specified on command");
         }
 
         var participants = participantProvider.getParticipants();
         if (participants.isEmpty()) {
-            throw new AutomationCompositionException(Status.BAD_REQUEST, "No participants registered");
-        }
-        var automationCompositionOpt =
-                automationCompositionProvider.findAutomationComposition(command.getAutomationCompositionIdentifier());
-        if (automationCompositionOpt.isEmpty()) {
-            throw new AutomationCompositionException(Response.Status.BAD_REQUEST,
-                    "AutomationComposition with id " + command.getAutomationCompositionIdentifier() + " not found");
+            throw new AutomationCompositionRuntimeException(Status.BAD_REQUEST, "No participants registered");
         }
-
-        var automationComposition = automationCompositionOpt.get();
         var validationResult = validateIssueAutomationComposition(automationComposition, participants);
         if (!validationResult.isValid()) {
-            throw new AutomationCompositionException(Response.Status.BAD_REQUEST, validationResult.getResult());
+            throw new AutomationCompositionRuntimeException(Response.Status.BAD_REQUEST, validationResult.getResult());
         }
 
         automationComposition.setCascadedOrderedState(command.getOrderedState());
-        supervisionHandler.triggerAutomationCompositionSupervision(automationComposition);
+        try {
+            supervisionHandler.triggerAutomationCompositionSupervision(automationComposition);
+        } catch (AutomationCompositionException e) {
+            throw new AutomationCompositionRuntimeException(Response.Status.BAD_REQUEST, e.getMessage());
+        }
         automationCompositionProvider.updateAutomationComposition(automationComposition);
-        var response = new InstantiationResponse();
-        response.setAffectedAutomationComposition(command.getAutomationCompositionIdentifier());
-
-        return response;
     }
 
     private BeanValidationResult validateIssueAutomationComposition(AutomationComposition automationComposition,
diff --git a/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/main/rest/InstantiationController.java b/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/main/rest/InstantiationController.java
index d575a690e..e828843a6 100644
--- a/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/main/rest/InstantiationController.java
+++ b/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/main/rest/InstantiationController.java
@@ -21,32 +21,16 @@
 
 package org.onap.policy.clamp.acm.runtime.main.rest;
 
-import io.swagger.annotations.ApiOperation;
-import io.swagger.annotations.ApiParam;
-import io.swagger.annotations.ApiResponse;
-import io.swagger.annotations.ApiResponses;
-import io.swagger.annotations.Authorization;
-import io.swagger.annotations.Extension;
-import io.swagger.annotations.ExtensionProperty;
-import io.swagger.annotations.ResponseHeader;
 import java.util.UUID;
 import lombok.RequiredArgsConstructor;
 import org.onap.policy.clamp.acm.runtime.instantiation.AutomationCompositionInstantiationProvider;
+import org.onap.policy.clamp.acm.runtime.main.rest.gen.AutomationCompositionInstanceApi;
 import org.onap.policy.clamp.acm.runtime.main.web.AbstractRestController;
-import org.onap.policy.clamp.common.acm.exception.AutomationCompositionException;
 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositions;
-import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationCommand;
 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationResponse;
-import org.springframework.http.MediaType;
+import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationUpdate;
 import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.DeleteMapping;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.PutMapping;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestHeader;
-import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
 /**
@@ -54,129 +38,55 @@ import org.springframework.web.bind.annotation.RestController;
  */
 @RestController
 @RequiredArgsConstructor
-public class InstantiationController extends AbstractRestController {
-
-    private static final String TAGS = "Clamp Automation Composition Instantiation API";
+public class InstantiationController extends AbstractRestController implements AutomationCompositionInstanceApi {
 
     // The Automation Composition provider for instantiation requests
     private final AutomationCompositionInstantiationProvider provider;
 
     /**
-     * Creates a automation composition.
+     * Creates an automation composition.
      *
-     * @param requestId request ID used in ONAP logging
+     * @param compositionId The UUID of the automation composition definition
      * @param automationComposition the automation composition
+     * @param requestId request ID used in ONAP logging
      * @return a response
      */
-    // @formatter:off
-    @PostMapping(value = "/instantiation",
-            produces = {MediaType.APPLICATION_JSON_VALUE, APPLICATION_YAML},
-            consumes = {MediaType.APPLICATION_JSON_VALUE, APPLICATION_YAML})
-    @ApiOperation(
-            value = "Commissions automation composition definitions",
-            notes = "Commissions automation composition definitions, returning the automation composition IDs",
-            response = InstantiationResponse.class,
-            tags = {TAGS},
-            authorizations = @Authorization(value = AUTHORIZATION_TYPE),
-            responseHeaders = {
-                @ResponseHeader(
-                    name = VERSION_MINOR_NAME,
-                    description = VERSION_MINOR_DESCRIPTION,
-                    response = String.class),
-                @ResponseHeader(
-                    name = VERSION_PATCH_NAME,
-                    description = VERSION_PATCH_DESCRIPTION,
-                    response = String.class),
-                @ResponseHeader(
-                    name = VERSION_LATEST_NAME,
-                    description = VERSION_LATEST_DESCRIPTION,
-                    response = String.class),
-                @ResponseHeader(
-                    name = REQUEST_ID_NAME,
-                    description = REQUEST_ID_HDR_DESCRIPTION,
-                    response = UUID.class)
-                },
-            extensions = {
-                @Extension
-                    (
-                        name = EXTENSION_NAME,
-                        properties = {
-                            @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),
-                            @ExtensionProperty(name = LAST_MOD_NAME, value = LAST_MOD_RELEASE)
-                        }
-                    )
-            }
-        )
-    @ApiResponses(
-            value = {
-                @ApiResponse(code = AUTHENTICATION_ERROR_CODE, message = AUTHENTICATION_ERROR_MESSAGE),
-                @ApiResponse(code = AUTHORIZATION_ERROR_CODE, message = AUTHORIZATION_ERROR_MESSAGE),
-                @ApiResponse(code = SERVER_ERROR_CODE, message = SERVER_ERROR_MESSAGE)
-            }
-        )
-    // @formatter:on
-    public ResponseEntity<InstantiationResponse> createCompositionInstance(
-        @RequestHeader(name = REQUEST_ID_NAME, required = false) @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId,
-        @ApiParam(
-            value = "Entity Body of automation composition",
-            required = true) @RequestBody AutomationComposition automationComposition) {
+    @Override
+    public ResponseEntity<InstantiationResponse> createCompositionInstance(UUID compositionId,
+            AutomationComposition automationComposition, UUID requestId) {
+
+        var response = provider.createAutomationComposition(compositionId, automationComposition);
+        return ResponseEntity
+                .created(createUri("/compositions/" + compositionId + "/instances/" + response.getInstanceId()))
+                .body(response);
+    }
 
-        return ResponseEntity.ok().body(provider.createAutomationComposition(automationComposition));
+    /**
+     * Gets an automation composition.
+     *
+     * @param compositionId The UUID of the automation composition definition
+     * @param instanceId The UUID of the automation composition instance
+     * @param requestId request ID used in ONAP logging
+     * @return the automation composition instance
+     */
+    @Override
+    public ResponseEntity<AutomationComposition> getCompositionInstance(UUID compositionId, UUID instanceId,
+            UUID requestId) {
+        return ResponseEntity.ok().body(provider.getAutomationComposition(compositionId, instanceId));
     }
 
     /**
      * Queries details of all automation compositions.
      *
-     * @param requestId request ID used in ONAP logging
+     * @param compositionId The UUID of the automation composition definition
      * @param name the name of the automation composition to get, null for all automation compositions
      * @param version the version of the automation composition to get, null for all automation compositions
+     * @param requestId request ID used in ONAP logging
      * @return the automation compositions
      */
-    // @formatter:off
-    @GetMapping(value = "/instantiation",
-            produces = {MediaType.APPLICATION_JSON_VALUE, APPLICATION_YAML})
-    @ApiOperation(value = "Query details of the requested automation compositions",
-            notes = "Queries details of the requested automation compositions, returning all composition details",
-            response = AutomationCompositions.class,
-            tags = {TAGS},
-            authorizations = @Authorization(value = AUTHORIZATION_TYPE),
-            responseHeaders = {
-                @ResponseHeader(
-                    name = VERSION_MINOR_NAME, description = VERSION_MINOR_DESCRIPTION,
-                    response = String.class),
-                @ResponseHeader(name = VERSION_PATCH_NAME, description = VERSION_PATCH_DESCRIPTION,
-                    response = String.class),
-                @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,
-                    response = String.class),
-                @ResponseHeader(name = REQUEST_ID_NAME, description = REQUEST_ID_HDR_DESCRIPTION,
-                    response = UUID.class)},
-            extensions = {
-                @Extension
-                     (
-                         name = EXTENSION_NAME,
-                         properties = {
-                             @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),
-                             @ExtensionProperty(name = LAST_MOD_NAME, value = LAST_MOD_RELEASE)
-                         }
-                    )
-                }
-        )
-    @ApiResponses(
-            value = {
-                @ApiResponse(code = AUTHENTICATION_ERROR_CODE, message = AUTHENTICATION_ERROR_MESSAGE),
-                @ApiResponse(code = AUTHORIZATION_ERROR_CODE, message = AUTHORIZATION_ERROR_MESSAGE),
-                @ApiResponse(code = SERVER_ERROR_CODE, message = SERVER_ERROR_MESSAGE)
-            }
-        )
-    // @formatter:on
-    public ResponseEntity<AutomationCompositions> queryCompositionInstances(
-        @RequestHeader(name = REQUEST_ID_NAME, required = false) @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId,
-        @ApiParam(value = "Automation composition  definition name", required = false) @RequestParam(
-            value = "name",
-            required = false) String name,
-        @ApiParam(value = "Automation composition  definition version", required = false) @RequestParam(
-            value = "version",
-            required = false) String version) {
+    @Override
+    public ResponseEntity<AutomationCompositions> queryCompositionInstances(UUID compositionId, String name,
+            String version, UUID requestId) {
 
         return ResponseEntity.ok().body(provider.getAutomationCompositions(name, version));
     }
@@ -184,182 +94,32 @@ public class InstantiationController extends AbstractRestController {
     /**
      * Updates a automation composition.
      *
+     * @param compositionId The UUID of the automation composition definition
+     * @param instanceId The UUID of the automation composition instance
+     * @param instanceUpdate the automation composition to update
      * @param requestId request ID used in ONAP logging
-     * @param automationComposition the automation composition
      * @return a response
      */
-    // @formatter:off
-    @PutMapping(value = "/instantiation",
-            produces = {MediaType.APPLICATION_JSON_VALUE, APPLICATION_YAML},
-            consumes = {MediaType.APPLICATION_JSON_VALUE, APPLICATION_YAML})
-    @ApiOperation(
-            value = "Updates automation composition definitions",
-            notes = "Updates automation composition definitions, returning the updated composition definition IDs",
-            response = InstantiationResponse.class,
-            tags = {TAGS},
-            authorizations = @Authorization(value = AUTHORIZATION_TYPE),
-            responseHeaders = {
-                @ResponseHeader(
-                    name = VERSION_MINOR_NAME,
-                    description = VERSION_MINOR_DESCRIPTION,
-                    response = String.class),
-                @ResponseHeader(
-                    name = VERSION_PATCH_NAME,
-                    description = VERSION_PATCH_DESCRIPTION,
-                    response = String.class),
-                @ResponseHeader(
-                    name = VERSION_LATEST_NAME,
-                    description = VERSION_LATEST_DESCRIPTION,
-                    response = String.class),
-                @ResponseHeader(
-                    name = REQUEST_ID_NAME,
-                    description = REQUEST_ID_HDR_DESCRIPTION,
-                    response = UUID.class)
-            },
-            extensions = {
-                @Extension
-                    (
-                        name = EXTENSION_NAME,
-                        properties = {
-                            @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),
-                            @ExtensionProperty(name = LAST_MOD_NAME, value = LAST_MOD_RELEASE)
-                        }
-                    )
-            }
-        )
-    @ApiResponses(
-            value = {
-                @ApiResponse(code = AUTHENTICATION_ERROR_CODE, message = AUTHENTICATION_ERROR_MESSAGE),
-                @ApiResponse(code = AUTHORIZATION_ERROR_CODE, message = AUTHORIZATION_ERROR_MESSAGE),
-                @ApiResponse(code = SERVER_ERROR_CODE, message = SERVER_ERROR_MESSAGE)
-            }
-        )
-    // @formatter:on
-    public ResponseEntity<InstantiationResponse> updateCompositionInstance(
-        @RequestHeader(name = REQUEST_ID_NAME, required = false) @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId,
-        @ApiParam(
-            value = "Entity Body of Automation Composition",
-            required = true) @RequestBody AutomationComposition automationComposition) {
+    @Override
+    public ResponseEntity<InstantiationResponse> updateCompositionInstance(UUID compositionId, UUID instanceId,
+            InstantiationUpdate instanceUpdate, UUID requestId) {
 
-        return ResponseEntity.ok().body(provider.updateAutomationComposition(automationComposition));
+        return ResponseEntity.ok()
+                .body(provider.updateAutomationComposition(compositionId, instanceId, instanceUpdate));
     }
 
     /**
      * Deletes a automation composition definition.
      *
+     * @param compositionId The UUID of the automation composition definition
+     * @param instanceId The UUID of the automation composition instance
      * @param requestId request ID used in ONAP logging
-     * @param name the name of the automation composition to delete
-     * @param version the version of the automation composition to delete
      * @return a response
      */
-    // @formatter:off
-    @DeleteMapping(value = "/instantiation",
-            produces = {MediaType.APPLICATION_JSON_VALUE, APPLICATION_YAML})
-    @ApiOperation(value = "Delete a automation composition",
-            notes = "Deletes a automation composition, returning optional error details",
-            response = InstantiationResponse.class,
-            tags = {TAGS},
-            authorizations = @Authorization(value = AUTHORIZATION_TYPE),
-            responseHeaders = {
-                @ResponseHeader(
-                    name = VERSION_MINOR_NAME,
-                    description = VERSION_MINOR_DESCRIPTION,
-                    response = String.class),
-                @ResponseHeader(
-                    name = VERSION_PATCH_NAME,
-                    description = VERSION_PATCH_DESCRIPTION,
-                    response = String.class),
-                @ResponseHeader(
-                    name = VERSION_LATEST_NAME,
-                    description = VERSION_LATEST_DESCRIPTION,
-                    response = String.class),
-                @ResponseHeader(
-                    name = REQUEST_ID_NAME,
-                    description = REQUEST_ID_HDR_DESCRIPTION,
-                    response = UUID.class)},
-            extensions = {
-                @Extension
-                    (
-                        name = EXTENSION_NAME,
-                        properties = {
-                            @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),
-                            @ExtensionProperty(name = LAST_MOD_NAME, value = LAST_MOD_RELEASE)
-                        }
-                    )
-                }
-        )
-    @ApiResponses(
-        value = {
-            @ApiResponse(code = AUTHENTICATION_ERROR_CODE, message = AUTHENTICATION_ERROR_MESSAGE),
-            @ApiResponse(code = AUTHORIZATION_ERROR_CODE, message = AUTHORIZATION_ERROR_MESSAGE),
-            @ApiResponse(code = SERVER_ERROR_CODE, message = SERVER_ERROR_MESSAGE)
-        }
-    )
-    // @formatter:on
-
-    public ResponseEntity<InstantiationResponse> deleteCompositionInstance(
-        @RequestHeader(name = REQUEST_ID_NAME, required = false) @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId,
-        @ApiParam(value = "Automation composition  definition name", required = true) @RequestParam("name") String name,
-        @ApiParam(value = "Automation composition  definition version") @RequestParam(
-            value = "version",
-            required = true) String version) {
-
-        return ResponseEntity.ok().body(provider.deleteAutomationComposition(name, version));
-    }
-
-    /**
-     * Issues automation composition commands to automation compositions.
-     *
-     * @param requestId request ID used in ONAP logging
-     * @param command the command to issue to automation compositions
-     * @return the automation composition definitions
-     * @throws AutomationCompositionException on errors issuing a command
-     */
-    // @formatter:off
-    @PutMapping(value = "/instantiation/command",
-            produces = {MediaType.APPLICATION_JSON_VALUE, APPLICATION_YAML},
-            consumes = {MediaType.APPLICATION_JSON_VALUE, APPLICATION_YAML})
-    @ApiOperation(value = "Issue a command to the requested automation compositions",
-            notes = "Issues a command to an automation composition, ordering a state change on the composition",
-            response = InstantiationResponse.class,
-            tags = {TAGS},
-            authorizations = @Authorization(value = AUTHORIZATION_TYPE),
-            responseHeaders = {
-                @ResponseHeader(
-                    name = VERSION_MINOR_NAME, description = VERSION_MINOR_DESCRIPTION,
-                    response = String.class),
-                @ResponseHeader(name = VERSION_PATCH_NAME, description = VERSION_PATCH_DESCRIPTION,
-                    response = String.class),
-                @ResponseHeader(name = VERSION_LATEST_NAME, description = VERSION_LATEST_DESCRIPTION,
-                    response = String.class),
-                @ResponseHeader(name = REQUEST_ID_NAME, description = REQUEST_ID_HDR_DESCRIPTION,
-                    response = UUID.class)},
-            extensions = {
-                @Extension
-                    (
-                        name = EXTENSION_NAME,
-                        properties = {
-                            @ExtensionProperty(name = API_VERSION_NAME, value = API_VERSION),
-                            @ExtensionProperty(name = LAST_MOD_NAME, value = LAST_MOD_RELEASE)
-                        }
-                    )
-                }
-        )
-    @ApiResponses(
-            value = {
-                @ApiResponse(code = AUTHENTICATION_ERROR_CODE, message = AUTHENTICATION_ERROR_MESSAGE),
-                @ApiResponse(code = AUTHORIZATION_ERROR_CODE, message = AUTHORIZATION_ERROR_MESSAGE),
-                @ApiResponse(code = SERVER_ERROR_CODE, message = SERVER_ERROR_MESSAGE)
-            }
-        )
-    // @formatter:on
-    public ResponseEntity<InstantiationResponse> issueAutomationCompositionCommand(
-        @RequestHeader(name = REQUEST_ID_NAME, required = false) @ApiParam(REQUEST_ID_PARAM_DESCRIPTION) UUID requestId,
-        @ApiParam(
-            value = "Entity Body of automation composition command",
-            required = true) @RequestBody InstantiationCommand command)
-        throws AutomationCompositionException {
+    @Override
+    public ResponseEntity<InstantiationResponse> deleteCompositionInstance(UUID compositionId, UUID instanceId,
+            UUID requestId) {
 
-        return ResponseEntity.accepted().body(provider.issueAutomationCompositionCommand(command));
+        return ResponseEntity.ok().body(provider.deleteAutomationComposition(compositionId, instanceId));
     }
 }
diff --git a/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/main/web/AbstractRestController.java b/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/main/web/AbstractRestController.java
index 61522dd66..736f258ee 100644
--- a/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/main/web/AbstractRestController.java
+++ b/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/main/web/AbstractRestController.java
@@ -20,13 +20,6 @@
 
 package org.onap.policy.clamp.acm.runtime.main.web;
 
-import io.swagger.annotations.Api;
-import io.swagger.annotations.BasicAuthDefinition;
-import io.swagger.annotations.Info;
-import io.swagger.annotations.SecurityDefinition;
-import io.swagger.annotations.SwaggerDefinition;
-import io.swagger.annotations.Tag;
-import java.net.HttpURLConnection;
 import java.net.URI;
 import java.net.URISyntaxException;
 import javax.ws.rs.core.MediaType;
@@ -37,57 +30,11 @@ import org.springframework.web.bind.annotation.RequestMapping;
 /**
  * Common superclass to provide REST endpoints for the participant simulator.
  */
-// @formatter:off
 @RequestMapping(value = "/v2",
     produces = {MediaType.APPLICATION_JSON, AbstractRestController.APPLICATION_YAML})
-@Api(value = "Automation Composition Commissioning API")
-@SwaggerDefinition(
-        info = @Info(description =
-                        "Automation Composition Service", version = "v1.0",
-                        title = "Automation Composition"),
-        consumes = {MediaType.APPLICATION_JSON, AbstractRestController.APPLICATION_YAML},
-        produces = {MediaType.APPLICATION_JSON, AbstractRestController.APPLICATION_YAML},
-        schemes = {SwaggerDefinition.Scheme.HTTP, SwaggerDefinition.Scheme.HTTPS},
-        tags = {@Tag(name = "automationcomposition", description = "Automation Composition Service")},
-        securityDefinition = @SecurityDefinition(basicAuthDefinitions = {@BasicAuthDefinition(key = "basicAuth")}))
-// @formatter:on
 public abstract class AbstractRestController {
     public static final String APPLICATION_YAML = "application/yaml";
 
-    public static final String EXTENSION_NAME = "interface info";
-
-    public static final String API_VERSION_NAME = "api-version";
-    public static final String API_VERSION = "1.0.0";
-
-    public static final String LAST_MOD_NAME = "last-mod-release";
-    public static final String LAST_MOD_RELEASE = "Istanbul";
-
-    public static final String VERSION_MINOR_NAME = "X-MinorVersion";
-    public static final String VERSION_MINOR_DESCRIPTION =
-            "Used to request or communicate a MINOR version back from the client"
-                    + " to the server, and from the server back to the client";
-
-    public static final String VERSION_PATCH_NAME = "X-PatchVersion";
-    public static final String VERSION_PATCH_DESCRIPTION = "Used only to communicate a PATCH version in a response for"
-            + " troubleshooting purposes only, and will not be provided by" + " the client on request";
-
-    public static final String VERSION_LATEST_NAME = "X-LatestVersion";
-    public static final String VERSION_LATEST_DESCRIPTION = "Used only to communicate an API's latest version";
-
-    public static final String REQUEST_ID_NAME = "X-ONAP-RequestID";
-    public static final String REQUEST_ID_HDR_DESCRIPTION = "Used to track REST transactions for logging purpose";
-    public static final String REQUEST_ID_PARAM_DESCRIPTION = "RequestID for http transaction";
-
-    public static final String AUTHORIZATION_TYPE = "basicAuth";
-
-    public static final int AUTHENTICATION_ERROR_CODE = HttpURLConnection.HTTP_UNAUTHORIZED;
-    public static final int AUTHORIZATION_ERROR_CODE = HttpURLConnection.HTTP_FORBIDDEN;
-    public static final int SERVER_ERROR_CODE = HttpURLConnection.HTTP_INTERNAL_ERROR;
-
-    public static final String AUTHENTICATION_ERROR_MESSAGE = "Authentication Error";
-    public static final String AUTHORIZATION_ERROR_MESSAGE = "Authorization Error";
-    public static final String SERVER_ERROR_MESSAGE = "Internal Server Error";
-
     /**
      * Constructor.
      */
diff --git a/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/main/web/GlobalControllerExceptionHandler.java b/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/main/web/GlobalControllerExceptionHandler.java
index fef358bb1..96d3bb2a7 100644
--- a/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/main/web/GlobalControllerExceptionHandler.java
+++ b/runtime-acm/src/main/java/org/onap/policy/clamp/acm/runtime/main/web/GlobalControllerExceptionHandler.java
@@ -20,7 +20,7 @@
 
 package org.onap.policy.clamp.acm.runtime.main.web;
 
-import org.onap.policy.clamp.common.acm.exception.AutomationCompositionException;
+import org.onap.policy.clamp.common.acm.exception.AutomationCompositionRuntimeException;
 import org.onap.policy.clamp.models.acm.messages.rest.SimpleResponse;
 import org.onap.policy.clamp.models.acm.rest.RestUtils;
 import org.onap.policy.models.base.PfModelException;
@@ -33,13 +33,13 @@ import org.springframework.web.bind.annotation.RestControllerAdvice;
 public class GlobalControllerExceptionHandler {
 
     /**
-     * Handle AutomationCompositionException.
+     * Handle AutomationCompositionRuntimeException.
      *
-     * @param ex AutomationCompositionException
+     * @param ex AutomationCompositionRuntimeException
      * @return ResponseEntity
      */
-    @ExceptionHandler(AutomationCompositionException.class)
-    public ResponseEntity<SimpleResponse> handleBadRequest(AutomationCompositionException ex) {
+    @ExceptionHandler(AutomationCompositionRuntimeException.class)
+    public ResponseEntity<SimpleResponse> handleBadRequest(AutomationCompositionRuntimeException ex) {
         return RestUtils.toSimpleResponse(ex);
     }
 
diff --git a/runtime-acm/src/main/resources/openapi/openapi.yaml b/runtime-acm/src/main/resources/openapi/openapi.yaml
index de7b26ead..65d2c6b08 100644
--- a/runtime-acm/src/main/resources/openapi/openapi.yaml
+++ b/runtime-acm/src/main/resources/openapi/openapi.yaml
@@ -968,14 +968,12 @@ paths:
         content:
           application/json:
             schema:
-              title: InstantiationUpdate
-              type: object
+              $ref: '#/components/schemas/InstantiationUpdate'
             example:
               externalValue: 'https://raw.githubusercontent.com/onap/policy-clamp/master/runtime-acm/src/main/resources/openapi/examples/putCompositionInstanceUpdate.json'
           application/yaml:
             schema:
-              title: InstantiationUpdate
-              type: object
+              $ref: '#/components/schemas/InstantiationUpdate'
             example:
               externalValue: 'https://raw.githubusercontent.com/onap/policy-clamp/master/runtime-acm/src/main/resources/openapi/examples/putCompositionInstanceUpdate.yaml'
         required: true
@@ -1228,6 +1226,9 @@ components:
     CommissioningResponse:
       title: CommissioningResponse
       type: object
+    InstantiationUpdate:
+      title: InstantiationUpdate
+      type: object
     InstantiationResponse:
       title: InstantiationResponse
       type: object
diff --git a/runtime-acm/src/test/java/org/onap/policy/clamp/acm/runtime/commissioning/rest/CommissioningControllerTest.java b/runtime-acm/src/test/java/org/onap/policy/clamp/acm/runtime/commissioning/rest/CommissioningControllerTest.java
index d1c26e002..d99bf2df6 100644
--- a/runtime-acm/src/test/java/org/onap/policy/clamp/acm/runtime/commissioning/rest/CommissioningControllerTest.java
+++ b/runtime-acm/src/test/java/org/onap/policy/clamp/acm/runtime/commissioning/rest/CommissioningControllerTest.java
@@ -31,15 +31,11 @@ import static org.onap.policy.clamp.acm.runtime.util.CommonTestData.TOSCA_SERVIC
 import java.util.HashMap;
 import java.util.UUID;
 import javax.ws.rs.client.Entity;
-import javax.ws.rs.client.Invocation;
 import javax.ws.rs.core.Response;
-import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.jupiter.api.parallel.Execution;
-import org.junit.jupiter.api.parallel.ExecutionMode;
 import org.onap.policy.clamp.acm.runtime.instantiation.InstantiationUtils;
 import org.onap.policy.clamp.acm.runtime.util.rest.CommonRestController;
 import org.onap.policy.clamp.models.acm.messages.rest.commissioning.CommissioningResponse;
@@ -57,12 +53,10 @@ import org.springframework.test.context.junit.jupiter.SpringExtension;
 @ExtendWith(SpringExtension.class)
 @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
 @ActiveProfiles("test")
-@Execution(ExecutionMode.SAME_THREAD)
 class CommissioningControllerTest extends CommonRestController {
 
     private static final String COMMISSIONING_ENDPOINT = "compositions";
     private static ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
-    private UUID compositionId;
 
     @Autowired
     private AcDefinitionProvider acDefinitionProvider;
@@ -83,11 +77,6 @@ class CommissioningControllerTest extends CommonRestController {
         super.setHttpPrefix(randomServerPort);
     }
 
-    @AfterEach
-    public void cleanDatabase() throws Exception {
-        deleteEntryInDB();
-    }
-
     @Test
     void testSwagger() {
         super.testSwagger(COMMISSIONING_ENDPOINT);
@@ -110,27 +99,29 @@ class CommissioningControllerTest extends CommonRestController {
 
     @Test
     void testCreateBadRequest() {
-        Invocation.Builder invocationBuilder = super.sendRequest(COMMISSIONING_ENDPOINT);
-        Response resp = invocationBuilder.post(Entity.json("NotToscaServiceTempalte"));
+        var invocationBuilder = super.sendRequest(COMMISSIONING_ENDPOINT);
+        var resp = invocationBuilder.post(Entity.json("NotToscaServiceTempalte"));
 
         assertThat(Response.Status.BAD_REQUEST.getStatusCode()).isEqualTo(resp.getStatus());
-        CommissioningResponse commissioningResponse = resp.readEntity(CommissioningResponse.class);
+        var commissioningResponse = resp.readEntity(CommissioningResponse.class);
         assertThat(commissioningResponse.getErrorDetails()).isNotNull();
         assertThat(commissioningResponse.getAffectedAutomationCompositionDefinitions()).isNull();
     }
 
     @Test
     void testCreate() {
-        Invocation.Builder invocationBuilder = super.sendRequest(COMMISSIONING_ENDPOINT);
-        Response resp = invocationBuilder.post(Entity.json(serviceTemplate));
+        var serviceTemplateCreate = new ToscaServiceTemplate(serviceTemplate);
+        serviceTemplateCreate.setName("Create");
+
+        var invocationBuilder = super.sendRequest(COMMISSIONING_ENDPOINT);
+        var resp = invocationBuilder.post(Entity.json(serviceTemplateCreate));
         assertEquals(Response.Status.CREATED.getStatusCode(), resp.getStatus());
-        CommissioningResponse commissioningResponse = resp.readEntity(CommissioningResponse.class);
-        compositionId = commissioningResponse.getCompositionId();
+        var commissioningResponse = resp.readEntity(CommissioningResponse.class);
         assertNotNull(commissioningResponse);
         assertNull(commissioningResponse.getErrorDetails());
         // Response should return the number of node templates present in the service template
         assertThat(commissioningResponse.getAffectedAutomationCompositionDefinitions()).hasSize(7);
-        for (String nodeTemplateName : serviceTemplate.getToscaTopologyTemplate().getNodeTemplates().keySet()) {
+        for (var nodeTemplateName : serviceTemplateCreate.getToscaTopologyTemplate().getNodeTemplates().keySet()) {
             assertTrue(commissioningResponse.getAffectedAutomationCompositionDefinitions().stream()
                     .anyMatch(ac -> ac.getName().equals(nodeTemplateName)));
         }
@@ -138,12 +129,6 @@ class CommissioningControllerTest extends CommonRestController {
 
     @Test
     void testUpdate() {
-        var invocationBuilder = super.sendRequest(COMMISSIONING_ENDPOINT);
-        var resp = invocationBuilder.post(Entity.json(serviceTemplate));
-        assertEquals(Response.Status.CREATED.getStatusCode(), resp.getStatus());
-        var commissioningResponse = resp.readEntity(CommissioningResponse.class);
-        compositionId = commissioningResponse.getCompositionId();
-
         var toscaDataType = new ToscaDataType();
         toscaDataType.setName("org.onap.datatypes.policy.clamp.Configuration");
         toscaDataType.setDerivedFrom("tosca.datatypes.Root");
@@ -153,17 +138,18 @@ class CommissioningControllerTest extends CommonRestController {
         toscaProperty.setType("onap.datatypes.ToscaConceptIdentifier");
         toscaDataType.getProperties().put(toscaProperty.getName(), toscaProperty);
 
+        var compositionId = createEntryInDB("forUpdate");
         var serviceTemplateUpdate = new ToscaServiceTemplate(serviceTemplate);
         serviceTemplateUpdate.getDataTypes().put(toscaDataType.getName(), toscaDataType);
-        invocationBuilder = super.sendRequest(COMMISSIONING_ENDPOINT + "/" + compositionId);
-        resp = invocationBuilder.put(Entity.json(serviceTemplateUpdate));
+        var invocationBuilder = super.sendRequest(COMMISSIONING_ENDPOINT + "/" + compositionId);
+        var resp = invocationBuilder.put(Entity.json(serviceTemplateUpdate));
         assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
-        commissioningResponse = resp.readEntity(CommissioningResponse.class);
+        var commissioningResponse = resp.readEntity(CommissioningResponse.class);
         assertNotNull(commissioningResponse);
         assertNull(commissioningResponse.getErrorDetails());
         // Response should return the number of node templates present in the service template
         assertThat(commissioningResponse.getAffectedAutomationCompositionDefinitions()).hasSize(7);
-        for (String nodeTemplateName : serviceTemplate.getToscaTopologyTemplate().getNodeTemplates().keySet()) {
+        for (var nodeTemplateName : serviceTemplateUpdate.getToscaTopologyTemplate().getNodeTemplates().keySet()) {
             assertTrue(commissioningResponse.getAffectedAutomationCompositionDefinitions().stream()
                     .anyMatch(ac -> ac.getName().equals(nodeTemplateName)));
         }
@@ -176,61 +162,52 @@ class CommissioningControllerTest extends CommonRestController {
     }
 
     @Test
-    void testQuery_NoResultWithThisName() throws Exception {
-        createEntryInDB();
-
-        Invocation.Builder invocationBuilder = super.sendRequest(COMMISSIONING_ENDPOINT + "?name=noResultWithThisName");
-        Response rawresp = invocationBuilder.buildGet().invoke();
+    void testQuery_NoResultWithThisName() {
+        var invocationBuilder = super.sendRequest(COMMISSIONING_ENDPOINT + "?name=noResultWithThisName");
+        var rawresp = invocationBuilder.buildGet().invoke();
         assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
         var entityList = rawresp.readEntity(ToscaServiceTemplate.class);
         assertThat(entityList.getNodeTypes()).isNull();
     }
 
     @Test
-    void testQuery() throws Exception {
-        createEntryInDB();
+    void testQuery() {
+        createEntryInDB("forQuery");
 
-        Invocation.Builder invocationBuilder = super.sendRequest(COMMISSIONING_ENDPOINT);
-        Response rawresp = invocationBuilder.buildGet().invoke();
+        var invocationBuilder = super.sendRequest(COMMISSIONING_ENDPOINT);
+        var rawresp = invocationBuilder.buildGet().invoke();
         assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
         var entityList = rawresp.readEntity(ToscaServiceTemplate.class);
         assertNotNull(entityList);
     }
 
     @Test
-    void testDeleteBadRequest() throws Exception {
-        createEntryInDB();
+    void testDeleteBadRequest() {
+        createEntryInDB("DeleteBadRequest");
 
-        Invocation.Builder invocationBuilder = super.sendRequest(COMMISSIONING_ENDPOINT + "/" + UUID.randomUUID());
+        var invocationBuilder = super.sendRequest(COMMISSIONING_ENDPOINT + "/" + UUID.randomUUID());
         // Call delete with no info
-        Response resp = invocationBuilder.delete();
+        var resp = invocationBuilder.delete();
         assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resp.getStatus());
     }
 
     @Test
-    void testDelete() throws Exception {
-        createEntryInDB();
+    void testDelete() {
+        var compositionId = createEntryInDB("forDelete");
 
-        Invocation.Builder invocationBuilder = super.sendRequest(COMMISSIONING_ENDPOINT + "/" + compositionId);
+        var invocationBuilder = super.sendRequest(COMMISSIONING_ENDPOINT + "/" + compositionId);
         // Call delete with no info
-        Response resp = invocationBuilder.delete();
+        var resp = invocationBuilder.delete();
         assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
 
-        var templatesInDB = acDefinitionProvider.getAllAcDefinitions();
+        var templatesInDB = acDefinitionProvider.findAcDefinition(compositionId);
         assertThat(templatesInDB).isEmpty();
     }
 
-    private synchronized void createEntryInDB() throws Exception {
-        deleteEntryInDB();
-        var acmDefinition = acDefinitionProvider.createAutomationCompositionDefinition(serviceTemplate);
-        compositionId = acmDefinition.getCompositionId();
-    }
-
-    // Delete entries from the DB after relevant tests
-    private synchronized void deleteEntryInDB() throws Exception {
-        var list = acDefinitionProvider.getAllAcDefinitions();
-        if (!list.isEmpty()) {
-            acDefinitionProvider.deleteAcDefintion(compositionId);
-        }
+    private UUID createEntryInDB(String name) {
+        var serviceTemplateCreate = new ToscaServiceTemplate(serviceTemplate);
+        serviceTemplateCreate.setName(name);
+        var acmDefinition = acDefinitionProvider.createAutomationCompositionDefinition(serviceTemplateCreate);
+        return acmDefinition.getCompositionId();
     }
 }
diff --git a/runtime-acm/src/test/java/org/onap/policy/clamp/acm/runtime/instantiation/AutomationCompositionInstantiationProviderTest.java b/runtime-acm/src/test/java/org/onap/policy/clamp/acm/runtime/instantiation/AutomationCompositionInstantiationProviderTest.java
index 115adcb50..0657c7e0c 100644
--- a/runtime-acm/src/test/java/org/onap/policy/clamp/acm/runtime/instantiation/AutomationCompositionInstantiationProviderTest.java
+++ b/runtime-acm/src/test/java/org/onap/policy/clamp/acm/runtime/instantiation/AutomationCompositionInstantiationProviderTest.java
@@ -37,15 +37,14 @@ import org.mockito.Mockito;
 import org.onap.policy.clamp.acm.runtime.supervision.SupervisionHandler;
 import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
 import org.onap.policy.clamp.common.acm.exception.AutomationCompositionException;
-import org.onap.policy.clamp.common.acm.exception.AutomationCompositionRuntimeException;
 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionState;
 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationCommand;
+import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationUpdate;
 import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
 import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
 import org.onap.policy.clamp.models.acm.persistence.provider.ParticipantProvider;
 import org.onap.policy.clamp.models.acm.persistence.provider.ProviderUtils;
-import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
 import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate;
 
@@ -62,7 +61,6 @@ class AutomationCompositionInstantiationProviderTest {
             "src/test/resources/rest/acm/AutomationCompositionElementsNotFound.json";
     private static final String AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON =
             "src/test/resources/rest/acm/AutomationCompositionNotFound.json";
-    private static final String AUTOMATION_COMPOSITION_NOT_FOUND = "Automation composition not found";
     private static final String DELETE_BAD_REQUEST = "Automation composition state is still %s";
     private static final String ORDERED_STATE_INVALID = "ordered state invalid or not specified on command";
     private static final String AC_ELEMENT_NAME_NOT_FOUND =
@@ -74,6 +72,7 @@ class AutomationCompositionInstantiationProviderTest {
     private static final String AC_DEFINITION_NOT_FOUND = "\"AutomationComposition\" INVALID, item has status INVALID\n"
             + "  item \"ServiceTemplate\" value \"\" INVALID,"
             + " Commissioned automation composition definition not found\n";
+    private static final String DO_NOT_MATCH = " do not match with ";
 
     private static ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
 
@@ -104,7 +103,8 @@ class AutomationCompositionInstantiationProviderTest {
         when(acProvider.createAutomationComposition(automationCompositionCreate))
                 .thenReturn(automationCompositionCreate);
 
-        var instantiationResponse = instantiationProvider.createAutomationComposition(automationCompositionCreate);
+        var instantiationResponse = instantiationProvider.createAutomationComposition(
+                automationCompositionCreate.getCompositionId(), automationCompositionCreate);
         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
 
         verify(acProvider).createAutomationComposition(automationCompositionCreate);
@@ -117,33 +117,41 @@ class AutomationCompositionInstantiationProviderTest {
         assertThat(automationCompositionCreate)
                 .isEqualTo(automationCompositionsGet.getAutomationCompositionList().get(0));
 
+        var instanceUpdate = new InstantiationUpdate();
         var automationCompositionUpdate =
                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
         automationCompositionUpdate.setCompositionId(compositionId);
+        instanceUpdate.setElements(automationCompositionUpdate.getElements());
+        when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
+                .thenReturn(automationCompositionUpdate);
+        when(acProvider.updateAutomationComposition(automationCompositionUpdate))
+                .thenReturn(automationCompositionUpdate);
 
-        instantiationResponse = instantiationProvider.updateAutomationComposition(automationCompositionUpdate);
+        instantiationResponse =
+                instantiationProvider.updateAutomationComposition(automationCompositionUpdate.getCompositionId(),
+                        automationCompositionUpdate.getInstanceId(), instanceUpdate);
         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
 
         verify(acProvider).updateAutomationComposition(automationCompositionUpdate);
 
-        when(acProvider.findAutomationComposition(automationCompositionUpdate.getKey().asIdentifier()))
-                .thenReturn(Optional.of(automationCompositionUpdate));
-        when(acProvider.deleteAutomationComposition(automationCompositionUpdate.getInstanceId()))
-                .thenReturn(automationCompositionUpdate);
-
+        var instanceUpdateCommand = new InstantiationUpdate();
         var instantiationCommand =
-                InstantiationUtils.getInstantiationCommandFromResource(AC_INSTANTIATION_CHANGE_STATE_JSON, "Crud");
-        instantiationResponse = instantiationProvider.issueAutomationCompositionCommand(instantiationCommand);
-        InstantiationUtils.assertInstantiationResponse(instantiationResponse, instantiationCommand);
+                InstantiationUtils.getInstantiationCommandFromResource(AC_INSTANTIATION_CHANGE_STATE_JSON);
+        instanceUpdateCommand.setInstantiationCommand(instantiationCommand);
+        instantiationResponse =
+                instantiationProvider.updateAutomationComposition(automationCompositionUpdate.getCompositionId(),
+                        automationCompositionUpdate.getInstanceId(), instanceUpdateCommand);
+        InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
 
         verify(supervisionHandler).triggerAutomationCompositionSupervision(automationCompositionUpdate);
 
         // in order to delete a automationComposition the state must be UNINITIALISED
         automationCompositionCreate.setState(AutomationCompositionState.UNINITIALISED);
-        instantiationProvider.updateAutomationComposition(automationCompositionCreate);
 
-        instantiationProvider.deleteAutomationComposition(automationCompositionCreate.getName(),
-                automationCompositionCreate.getVersion());
+        when(acProvider.deleteAutomationComposition(automationCompositionUpdate.getInstanceId()))
+                .thenReturn(automationCompositionUpdate);
+        instantiationProvider.deleteAutomationComposition(automationCompositionCreate.getCompositionId(),
+                automationCompositionCreate.getInstanceId());
 
         verify(acProvider).deleteAutomationComposition(automationCompositionCreate.getInstanceId());
     }
@@ -161,8 +169,14 @@ class AutomationCompositionInstantiationProviderTest {
         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
                 participantProvider, acDefinitionProvider);
 
-        assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(automationComposition.getName(),
-                automationComposition.getVersion())).hasMessageMatching(AUTOMATION_COMPOSITION_NOT_FOUND);
+        when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
+                .thenReturn(automationComposition);
+
+        var wrongCompositionId = UUID.randomUUID();
+        var instanceId = automationComposition.getInstanceId();
+        var compositionId = automationComposition.getCompositionId();
+        assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(wrongCompositionId, instanceId))
+                .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 
         for (var state : AutomationCompositionState.values()) {
             if (!AutomationCompositionState.UNINITIALISED.equals(state)) {
@@ -170,16 +184,9 @@ class AutomationCompositionInstantiationProviderTest {
             }
         }
         automationComposition.setState(AutomationCompositionState.UNINITIALISED);
-        automationComposition.setInstanceId(UUID.randomUUID());
-
-        when(acProvider.findAutomationComposition(
-                new ToscaConceptIdentifier(automationComposition.getName(), automationComposition.getVersion())))
-                        .thenReturn(Optional.of(automationComposition));
-        when(acProvider.deleteAutomationComposition(automationComposition.getInstanceId()))
-                .thenReturn(automationComposition);
+        when(acProvider.deleteAutomationComposition(instanceId)).thenReturn(automationComposition);
 
-        instantiationProvider.deleteAutomationComposition(automationComposition.getName(),
-                automationComposition.getVersion());
+        instantiationProvider.deleteAutomationComposition(compositionId, instanceId);
     }
 
     private void assertThatDeleteThrownBy(AutomationComposition automationComposition,
@@ -193,11 +200,13 @@ class AutomationCompositionInstantiationProviderTest {
         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
                 participantProvider, acDefinitionProvider);
 
-        var key = new ToscaConceptIdentifier(automationComposition.getName(), automationComposition.getVersion());
-        when(acProvider.findAutomationComposition(key)).thenReturn(Optional.of(automationComposition));
+        when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
+                .thenReturn(automationComposition);
 
-        assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(automationComposition.getName(),
-                automationComposition.getVersion())).hasMessageMatching(String.format(DELETE_BAD_REQUEST, state));
+        var compositionId = automationComposition.getCompositionId();
+        var instanceId = automationComposition.getInstanceId();
+        assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(compositionId, instanceId))
+                .hasMessageMatching(String.format(DELETE_BAD_REQUEST, state));
     }
 
     @Test
@@ -221,14 +230,16 @@ class AutomationCompositionInstantiationProviderTest {
         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
                 participantProvider, acDefinitionProvider);
 
-        var instantiationResponse = instantiationProvider.createAutomationComposition(automationCompositionCreate);
+        var instantiationResponse = instantiationProvider.createAutomationComposition(
+                automationCompositionCreate.getCompositionId(), automationCompositionCreate);
         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
 
         when(acProvider.findAutomationComposition(automationCompositionCreate.getKey().asIdentifier()))
                 .thenReturn(Optional.of(automationCompositionCreate));
 
-        assertThatThrownBy(() -> instantiationProvider.createAutomationComposition(automationCompositionCreate))
-                .hasMessageMatching(automationCompositionCreate.getKey().asIdentifier() + " already defined");
+        assertThatThrownBy(
+                () -> instantiationProvider.createAutomationComposition(compositionId, automationCompositionCreate))
+                        .hasMessageMatching(automationCompositionCreate.getKey().asIdentifier() + " already defined");
     }
 
     @Test
@@ -246,41 +257,70 @@ class AutomationCompositionInstantiationProviderTest {
         var provider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
                 participantProvider, acDefinitionProvider);
 
-        assertThatThrownBy(() -> provider.createAutomationComposition(automationComposition))
+        assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 
-        assertThatThrownBy(() -> provider.updateAutomationComposition(automationComposition))
+        when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
+                .thenReturn(automationComposition);
+        var instanceUpdate = new InstantiationUpdate();
+        instanceUpdate.setElements(automationComposition.getElements());
+
+        var instanceId = automationComposition.getInstanceId();
+        assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, instanceId, instanceUpdate))
                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
     }
 
     @Test
-    void testCreateAutomationCompositions_CommissionedAcNotFound() throws Exception {
+    void testCreateAutomationCompositions_CommissionedAcNotFound() {
         var automationComposition = InstantiationUtils
                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 
         var participantProvider = Mockito.mock(ParticipantProvider.class);
         var acProvider = mock(AutomationCompositionProvider.class);
+        when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
+                .thenReturn(automationComposition);
         var supervisionHandler = mock(SupervisionHandler.class);
         var acDefinitionProvider = mock(AcDefinitionProvider.class);
         var provider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
                 participantProvider, acDefinitionProvider);
 
-        assertThatThrownBy(() -> provider.createAutomationComposition(automationComposition))
+        var compositionId = automationComposition.getCompositionId();
+        assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
                 .hasMessageMatching(AC_DEFINITION_NOT_FOUND);
 
-        assertThatThrownBy(() -> provider.updateAutomationComposition(automationComposition))
+        var instanceUpdate = new InstantiationUpdate();
+        instanceUpdate.setElements(automationComposition.getElements());
+        var instanceId = automationComposition.getInstanceId();
+        assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, instanceId, instanceUpdate))
                 .hasMessageMatching(AC_DEFINITION_NOT_FOUND);
+
+        var wrongCompositionId = UUID.randomUUID();
+        assertThatThrownBy(() -> provider.createAutomationComposition(wrongCompositionId, automationComposition))
+                .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
+
+        assertThatThrownBy(() -> provider.updateAutomationComposition(wrongCompositionId, instanceId, instanceUpdate))
+                .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
     }
 
     @Test
-    void testIssueAutomationCompositionCommand_OrderedStateInvalid() throws AutomationCompositionRuntimeException {
+    void testIssueAutomationCompositionCommand_OrderedStateInvalid() {
         var participantProvider = Mockito.mock(ParticipantProvider.class);
         var acProvider = mock(AutomationCompositionProvider.class);
         var supervisionHandler = mock(SupervisionHandler.class);
         var acDefinitionProvider = mock(AcDefinitionProvider.class);
         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
                 participantProvider, acDefinitionProvider);
-        assertThatThrownBy(() -> instantiationProvider.issueAutomationCompositionCommand(new InstantiationCommand()))
-                .hasMessageMatching(ORDERED_STATE_INVALID);
+        var instanceUpdate = new InstantiationUpdate();
+        instanceUpdate.setInstantiationCommand(new InstantiationCommand());
+        var automationComposition = InstantiationUtils
+                .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
+        when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
+                .thenReturn(automationComposition);
+
+        var compositionId = automationComposition.getCompositionId();
+        var instanceId = automationComposition.getInstanceId();
+        assertThatThrownBy(
+                () -> instantiationProvider.updateAutomationComposition(compositionId, instanceId, instanceUpdate))
+                        .hasMessageMatching(ORDERED_STATE_INVALID);
     }
 }
diff --git a/runtime-acm/src/test/java/org/onap/policy/clamp/acm/runtime/instantiation/InstantiationUtils.java b/runtime-acm/src/test/java/org/onap/policy/clamp/acm/runtime/instantiation/InstantiationUtils.java
index 8b0ccd74e..a5ffacc6a 100644
--- a/runtime-acm/src/test/java/org/onap/policy/clamp/acm/runtime/instantiation/InstantiationUtils.java
+++ b/runtime-acm/src/test/java/org/onap/policy/clamp/acm/runtime/instantiation/InstantiationUtils.java
@@ -33,6 +33,7 @@ import org.onap.policy.common.utils.coder.CoderException;
 import org.onap.policy.common.utils.coder.StandardCoder;
 import org.onap.policy.common.utils.coder.StandardYamlCoder;
 import org.onap.policy.common.utils.resources.ResourceUtils;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
 
 /**
@@ -67,17 +68,11 @@ public class InstantiationUtils {
      * Gets InstantiationCommand from Resource.
      *
      * @param path path of the resource
-     * @param suffix suffix to add to all names in AutomationCompositions
      * @return the InstantiationCommand
      */
-    public static InstantiationCommand getInstantiationCommandFromResource(final String path, final String suffix) {
+    public static InstantiationCommand getInstantiationCommandFromResource(final String path) {
         try {
-            var instantiationCommand = CODER.decode(new File(path), InstantiationCommand.class);
-
-            // add suffix to the name
-            var id = instantiationCommand.getAutomationCompositionIdentifier();
-            id.setName(id.getName() + suffix);
-            return instantiationCommand;
+            return CODER.decode(new File(path), InstantiationCommand.class);
         } catch (CoderException e) {
             fail("Cannot read or decode " + path);
             return null;
@@ -88,11 +83,12 @@ public class InstantiationUtils {
      * Assert that Instantiation Response contains proper AutomationCompositions.
      *
      * @param response InstantiationResponse
-     * @param command InstantiationCommand
+     * @param affectedAutomationComposition ToscaConceptIdentifier
      */
-    public static void assertInstantiationResponse(InstantiationResponse response, InstantiationCommand command) {
+    public static void assertInstantiationResponse(InstantiationResponse response,
+            ToscaConceptIdentifier affectedAutomationComposition) {
         assertThat(response).isNotNull();
-        assertEquals(response.getAffectedAutomationComposition(), command.getAutomationCompositionIdentifier());
+        assertEquals(response.getAffectedAutomationComposition(), affectedAutomationComposition);
     }
 
     /**
diff --git a/runtime-acm/src/test/java/org/onap/policy/clamp/acm/runtime/instantiation/rest/InstantiationControllerTest.java b/runtime-acm/src/test/java/org/onap/policy/clamp/acm/runtime/instantiation/rest/InstantiationControllerTest.java
index 9c364b2db..b93d214cb 100644
--- a/runtime-acm/src/test/java/org/onap/policy/clamp/acm/runtime/instantiation/rest/InstantiationControllerTest.java
+++ b/runtime-acm/src/test/java/org/onap/policy/clamp/acm/runtime/instantiation/rest/InstantiationControllerTest.java
@@ -30,7 +30,6 @@ import static org.onap.policy.clamp.acm.runtime.util.CommonTestData.TOSCA_SERVIC
 import java.util.UUID;
 import javax.ws.rs.client.Entity;
 import javax.ws.rs.core.Response;
-import org.junit.Ignore;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
@@ -44,6 +43,7 @@ import org.onap.policy.clamp.acm.runtime.util.rest.CommonRestController;
 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositions;
 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationCommand;
 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationResponse;
+import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationUpdate;
 import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
 import org.onap.policy.clamp.models.acm.persistence.provider.ParticipantProvider;
 import org.onap.policy.clamp.models.acm.persistence.repository.AutomationCompositionRepository;
@@ -65,19 +65,17 @@ import org.springframework.test.context.junit.jupiter.SpringExtension;
 @ActiveProfiles("test")
 class InstantiationControllerTest extends CommonRestController {
 
-    private static final String AC_INSTANTIATION_CREATE_JSON =
-            "src/test/resources/rest/acm/AutomationComposition.json";
+    private static final String AC_INSTANTIATION_CREATE_JSON = "src/test/resources/rest/acm/AutomationComposition.json";
 
     private static final String AC_INSTANTIATION_UPDATE_JSON =
             "src/test/resources/rest/acm/AutomationCompositionUpdate.json";
 
     private static final String AC_INSTANTIATION_CHANGE_STATE_JSON = "src/test/resources/rest/acm/PassiveCommand.json";
 
-    private static final String INSTANTIATION_ENDPOINT = "instantiation";
-    private static final String INSTANTIATION_COMMAND_ENDPOINT = "instantiation/command";
+    private static final String INSTANTIATION_ENDPOINT = "compositions/%s/instances";
 
     private static ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
-    private UUID compositionId;
+    private UUID compositionId = UUID.randomUUID();
 
     @Autowired
     private AutomationCompositionRepository automationCompositionRepository;
@@ -100,7 +98,7 @@ class InstantiationControllerTest extends CommonRestController {
     }
 
     @BeforeEach
-    public void populateDb() throws Exception {
+    public void populateDb() {
         createEntryInDB();
     }
 
@@ -110,15 +108,21 @@ class InstantiationControllerTest extends CommonRestController {
     }
 
     @AfterEach
-    public void cleanDatabase() throws Exception {
+    public void cleanDatabase() {
         deleteEntryInDB();
     }
 
-    @Ignore
+    private String getInstanceEndPoint() {
+        return String.format(INSTANTIATION_ENDPOINT, compositionId.toString());
+    }
+
+    private String getInstanceEndPoint(UUID instanceId) {
+        return String.format(INSTANTIATION_ENDPOINT, compositionId.toString()) + "/" + instanceId;
+    }
+
     @Test
     void testSwagger() {
-        // TODO: Reimplement using springdoc when Impelmentation endpoint is refactored
-        super.testSwagger(INSTANTIATION_ENDPOINT);
+        super.testSwagger(String.format(INSTANTIATION_ENDPOINT, "{compositionId}"));
     }
 
     @Test
@@ -126,33 +130,25 @@ class InstantiationControllerTest extends CommonRestController {
         var automationComposition =
                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Unauthorized");
 
-        assertUnauthorizedPost(INSTANTIATION_ENDPOINT, Entity.json(automationComposition));
+        assertUnauthorizedPost(getInstanceEndPoint(), Entity.json(automationComposition));
     }
 
     @Test
     void testQuery_Unauthorized() {
-        assertUnauthorizedGet(INSTANTIATION_ENDPOINT);
+        assertUnauthorizedGet(getInstanceEndPoint());
     }
 
     @Test
-    void testUpdate_Unauthorized() throws Exception {
+    void testUpdate_Unauthorized() {
         var automationComposition =
                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Unauthorized");
 
-        assertUnauthorizedPut(INSTANTIATION_ENDPOINT, Entity.json(automationComposition));
+        assertUnauthorizedPut(getInstanceEndPoint(), Entity.json(automationComposition));
     }
 
     @Test
     void testDelete_Unauthorized() {
-        assertUnauthorizedDelete(INSTANTIATION_ENDPOINT);
-    }
-
-    @Test
-    void testCommand_Unauthorized() {
-        var instantiationCommand = InstantiationUtils
-                .getInstantiationCommandFromResource(AC_INSTANTIATION_CHANGE_STATE_JSON, "Unauthorized");
-
-        assertUnauthorizedPut(INSTANTIATION_COMMAND_ENDPOINT, Entity.json(instantiationCommand));
+        assertUnauthorizedDelete(getInstanceEndPoint());
     }
 
     @Test
@@ -161,19 +157,18 @@ class InstantiationControllerTest extends CommonRestController {
                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Create");
         automationCompositionFromRsc.setCompositionId(compositionId);
 
-        var invocationBuilder = super.sendRequest(INSTANTIATION_ENDPOINT);
+        var invocationBuilder = super.sendRequest(getInstanceEndPoint());
         var resp = invocationBuilder.post(Entity.json(automationCompositionFromRsc));
-        assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
+        assertEquals(Response.Status.CREATED.getStatusCode(), resp.getStatus());
         var instResponse = resp.readEntity(InstantiationResponse.class);
         InstantiationUtils.assertInstantiationResponse(instResponse, automationCompositionFromRsc);
         automationCompositionFromRsc.setInstanceId(instResponse.getInstanceId());
 
-        var automationCompositionsFromDb = instantiationProvider.getAutomationCompositions(
-                automationCompositionFromRsc.getKey().getName(), automationCompositionFromRsc.getKey().getVersion());
+        var automationCompositionFromDb =
+                instantiationProvider.getAutomationComposition(compositionId, instResponse.getInstanceId());
 
-        assertNotNull(automationCompositionsFromDb);
-        assertThat(automationCompositionsFromDb.getAutomationCompositionList()).hasSize(1);
-        assertEquals(automationCompositionFromRsc, automationCompositionsFromDb.getAutomationCompositionList().get(0));
+        assertNotNull(automationCompositionFromDb);
+        assertEquals(automationCompositionFromRsc, automationCompositionFromDb);
 
     }
 
@@ -183,9 +178,9 @@ class InstantiationControllerTest extends CommonRestController {
                 .getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "CreateBadRequest");
         automationCompositionFromRsc.setCompositionId(compositionId);
 
-        var invocationBuilder = super.sendRequest(INSTANTIATION_ENDPOINT);
+        var invocationBuilder = super.sendRequest(getInstanceEndPoint());
         var resp = invocationBuilder.post(Entity.json(automationCompositionFromRsc));
-        assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
+        assertEquals(Response.Status.CREATED.getStatusCode(), resp.getStatus());
 
         // testing Bad Request: AC already defined
         resp = invocationBuilder.post(Entity.json(automationCompositionFromRsc));
@@ -197,7 +192,7 @@ class InstantiationControllerTest extends CommonRestController {
 
     @Test
     void testQuery_NoResultWithThisName() {
-        var invocationBuilder = super.sendRequest(INSTANTIATION_ENDPOINT + "?name=noResultWithThisName");
+        var invocationBuilder = super.sendRequest(getInstanceEndPoint() + "?name=noResultWithThisName");
         var rawresp = invocationBuilder.buildGet().invoke();
         assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
         var resp = rawresp.readEntity(AutomationCompositions.class);
@@ -210,10 +205,10 @@ class InstantiationControllerTest extends CommonRestController {
                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Query");
         automationComposition.setCompositionId(compositionId);
 
-        instantiationProvider.createAutomationComposition(automationComposition);
+        instantiationProvider.createAutomationComposition(compositionId, automationComposition);
 
         var invocationBuilder =
-                super.sendRequest(INSTANTIATION_ENDPOINT + "?name=" + automationComposition.getKey().getName());
+                super.sendRequest(getInstanceEndPoint() + "?name=" + automationComposition.getKey().getName());
         var rawresp = invocationBuilder.buildGet().invoke();
         assertEquals(Response.Status.OK.getStatusCode(), rawresp.getStatus());
         var automationCompositionsQuery = rawresp.readEntity(AutomationCompositions.class);
@@ -228,13 +223,15 @@ class InstantiationControllerTest extends CommonRestController {
                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Update");
         automationCompositionCreate.setCompositionId(compositionId);
 
-        var response = instantiationProvider.createAutomationComposition(automationCompositionCreate);
+        var response = instantiationProvider.createAutomationComposition(compositionId, automationCompositionCreate);
 
-        var invocationBuilder = super.sendRequest(INSTANTIATION_ENDPOINT);
         var automationComposition =
                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Update");
         automationComposition.setCompositionId(compositionId);
         automationComposition.setInstanceId(response.getInstanceId());
+        var instantiationUpdate = new InstantiationUpdate();
+        instantiationUpdate.setElements(automationComposition.getElements());
+        var invocationBuilder = super.sendRequest(getInstanceEndPoint(response.getInstanceId()));
         var resp = invocationBuilder.put(Entity.json(automationComposition));
         assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
 
@@ -255,14 +252,13 @@ class InstantiationControllerTest extends CommonRestController {
                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
         automationCompositionFromRsc.setCompositionId(compositionId);
 
-        instantiationProvider.createAutomationComposition(automationCompositionFromRsc);
+        var instResponse =
+                instantiationProvider.createAutomationComposition(compositionId, automationCompositionFromRsc);
 
-        var invocationBuilder =
-                super.sendRequest(INSTANTIATION_ENDPOINT + "?name=" + automationCompositionFromRsc.getKey().getName()
-                        + "&version=" + automationCompositionFromRsc.getKey().getVersion());
+        var invocationBuilder = super.sendRequest(getInstanceEndPoint(instResponse.getInstanceId()));
         var resp = invocationBuilder.delete();
         assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
-        var instResponse = resp.readEntity(InstantiationResponse.class);
+        instResponse = resp.readEntity(InstantiationResponse.class);
         InstantiationUtils.assertInstantiationResponse(instResponse, automationCompositionFromRsc);
 
         var automationCompositionsFromDb = instantiationProvider.getAutomationCompositions(
@@ -271,33 +267,38 @@ class InstantiationControllerTest extends CommonRestController {
     }
 
     @Test
-    void testDeleteBadRequest() {
+    void testDeleteNotFound() {
         var automationCompositionFromRsc =
-                InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "DelBadRequest");
+                InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "DelNotFound");
         automationCompositionFromRsc.setCompositionId(compositionId);
 
-        instantiationProvider.createAutomationComposition(automationCompositionFromRsc);
+        instantiationProvider.createAutomationComposition(compositionId, automationCompositionFromRsc);
 
-        var invocationBuilder =
-                super.sendRequest(INSTANTIATION_ENDPOINT + "?name=" + automationCompositionFromRsc.getKey().getName());
+        var invocationBuilder = super.sendRequest(getInstanceEndPoint(UUID.randomUUID()));
         var resp = invocationBuilder.delete();
-        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resp.getStatus());
+        assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resp.getStatus());
     }
 
     @Test
     void testCommand_NotFound1() {
-        var invocationBuilder = super.sendRequest(INSTANTIATION_COMMAND_ENDPOINT);
-        var resp = invocationBuilder.put(Entity.json(new InstantiationCommand()));
-        assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resp.getStatus());
+        var invocationBuilder = super.sendRequest(getInstanceEndPoint(UUID.randomUUID()));
+        var resp = invocationBuilder.put(Entity.json(new InstantiationUpdate()));
+        assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resp.getStatus());
     }
 
     @Test
     void testCommand_NotFound2() {
-        var command =
-                InstantiationUtils.getInstantiationCommandFromResource(AC_INSTANTIATION_CHANGE_STATE_JSON, "Command");
-        command.setOrderedState(null);
+        var acFromRsc =
+                InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "DelNotFound");
+        acFromRsc.setCompositionId(compositionId);
+
+        var instResponse = instantiationProvider.createAutomationComposition(compositionId, acFromRsc);
+
+        var command = new InstantiationUpdate();
+        command.setInstantiationCommand(new InstantiationCommand());
+        command.getInstantiationCommand().setOrderedState(null);
 
-        var invocationBuilder = super.sendRequest(INSTANTIATION_COMMAND_ENDPOINT);
+        var invocationBuilder = super.sendRequest(getInstanceEndPoint(instResponse.getInstanceId()));
         var resp = invocationBuilder.put(Entity.json(command));
         assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resp.getStatus());
     }
@@ -307,24 +308,25 @@ class InstantiationControllerTest extends CommonRestController {
         var automationComposition =
                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Command");
         automationComposition.setCompositionId(compositionId);
-        instantiationProvider.createAutomationComposition(automationComposition);
+        var instResponse = instantiationProvider.createAutomationComposition(compositionId, automationComposition);
 
         var participants = CommonTestData.createParticipants();
         for (var participant : participants) {
             participantProvider.saveParticipant(participant);
         }
 
-        var command =
-                InstantiationUtils.getInstantiationCommandFromResource(AC_INSTANTIATION_CHANGE_STATE_JSON, "Command");
+        var instantiationUpdate = new InstantiationUpdate();
+        var command = InstantiationUtils.getInstantiationCommandFromResource(AC_INSTANTIATION_CHANGE_STATE_JSON);
+        instantiationUpdate.setInstantiationCommand(command);
 
-        var invocationBuilder = super.sendRequest(INSTANTIATION_COMMAND_ENDPOINT);
-        var resp = invocationBuilder.put(Entity.json(command));
-        assertEquals(Response.Status.ACCEPTED.getStatusCode(), resp.getStatus());
-        InstantiationResponse instResponse = resp.readEntity(InstantiationResponse.class);
-        InstantiationUtils.assertInstantiationResponse(instResponse, command);
+        var invocationBuilder = super.sendRequest(getInstanceEndPoint(instResponse.getInstanceId()));
+        var resp = invocationBuilder.put(Entity.json(instantiationUpdate));
+        assertEquals(Response.Status.OK.getStatusCode(), resp.getStatus());
+        instResponse = resp.readEntity(InstantiationResponse.class);
+        InstantiationUtils.assertInstantiationResponse(instResponse, automationComposition);
 
         // check passive state on DB
-        var toscaConceptIdentifier = command.getAutomationCompositionIdentifier();
+        var toscaConceptIdentifier = instResponse.getAffectedAutomationComposition();
         var automationCompositionsGet = instantiationProvider
                 .getAutomationCompositions(toscaConceptIdentifier.getName(), toscaConceptIdentifier.getVersion());
         assertThat(automationCompositionsGet.getAutomationCompositionList()).hasSize(1);
@@ -332,15 +334,15 @@ class InstantiationControllerTest extends CommonRestController {
                 automationCompositionsGet.getAutomationCompositionList().get(0).getOrderedState());
     }
 
-    private synchronized void deleteEntryInDB() throws Exception {
+    private synchronized void deleteEntryInDB() {
         automationCompositionRepository.deleteAll();
-        var list = acDefinitionProvider.getAllAcDefinitions();
+        var list = acDefinitionProvider.findAcDefinition(compositionId);
         if (!list.isEmpty()) {
             acDefinitionProvider.deleteAcDefintion(compositionId);
         }
     }
 
-    private synchronized void createEntryInDB() throws Exception {
+    private synchronized void createEntryInDB() {
         deleteEntryInDB();
         var acmDefinition = acDefinitionProvider.createAutomationCompositionDefinition(serviceTemplate);
         compositionId = acmDefinition.getCompositionId();