Add APPC LCM Interface

The LCM model code and service provider code is implemented.
This model code is now used for the vCPE use case scenario.

The vFW use case is still using the legacy APPC API as
request by APPC for Policy to use in R1. The APPC
service provider now generates a demo legacy APPC
request with pg-streams.

An A&AI named query is implemented for the vFW use case.
The code for obtaining the generic-vnf.vnf-id is not
in use until we set up the A&AI simulator to work
without having cyclical depenncies inside the POMs.

JUnits for the vFW and vCPE use cases are now supported.
These JUnits test the complete flow of each scenario.

A&AI testing is not supported in the JUnit test yet.
These JUnits use a target type of VM as VNF is not
supported yet. This will be changed when the Target
Lock supports VNF.

Amended to fix Sonar blockers.

Issue-ID: POLICY-104
Change-Id: I46869c5fd5094919da55ad563d608fe6d4b6fea7
Signed-off-by: Daniel Cruz <dc443y@att.com>

3 files changed, 565 insertions, 0 deletions

diff --git a/controlloop/common/actors/actor.appclcm/src/main/java/org/onap/policy/controlloop/actor/appclcm/AppcLcmActorServiceProvider.java b/controlloop/common/actors/actor.appclcm/src/main/java/org/onap/policy/controlloop/actor/appclcm/AppcLcmActorServiceProvider.java
new file mode 100644
index 000000000..c52a7f08e
--- /dev/null
+++ b/controlloop/common/actors/actor.appclcm/src/main/java/org/onap/policy/controlloop/actor/appclcm/AppcLcmActorServiceProvider.java
@@ -0,0 +1,293 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * AppcLcmActorServiceProvider
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.actor.appclcm;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+
+import java.util.AbstractMap;
+import java.util.AbstractMap.SimpleEntry;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import org.onap.policy.aai.AAINQF199.AAINQF199InventoryResponseItem;
+import org.onap.policy.aai.AAINQF199.AAINQF199Manager;
+import org.onap.policy.aai.AAINQF199.AAINQF199Request;
+import org.onap.policy.aai.AAINQF199.AAINQF199Response;
+import org.onap.policy.appclcm.LCMCommonHeader;
+import org.onap.policy.appclcm.LCMRequest;
+import org.onap.policy.appclcm.LCMRequestWrapper;
+import org.onap.policy.appclcm.LCMResponse;
+import org.onap.policy.appclcm.LCMResponseCode;
+import org.onap.policy.appclcm.LCMResponseWrapper;
+import org.onap.policy.controlloop.ControlLoopOperation;
+import org.onap.policy.controlloop.VirtualControlLoopEvent;
+import org.onap.policy.controlloop.actorServiceProvider.spi.Actor;
+import org.onap.policy.controlloop.policy.Policy;
+import org.onap.policy.controlloop.policy.PolicyResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class AppcLcmActorServiceProvider implements Actor {
+    
+    private static final Logger logger = LoggerFactory.getLogger(AppcLcmActorServiceProvider.class);
+    
+    /* The source vnf-id provided from the DCAE onset */
+    private static final String DCAE_VNF_ID = "generic-vnf.vnf-id";
+
+    /* To be used in future releases to restart a single vm */
+    private static final String APPC_VM_ID = "vm-id";
+    
+    /* To be used in future releases when LCM ConfigModify is used */
+    private static final String APPC_REQUEST_PARAMS = "request-parameters";
+    private static final String APPC_CONFIG_PARAMS = "configuration-parameters";
+
+    private static final ImmutableList<String> recipes = ImmutableList.of("Restart", "Rebuild", "Migrate",
+            "ConfigModify");
+    private static final ImmutableMap<String, List<String>> targets = new ImmutableMap.Builder<String, List<String>>()
+            .put("Restart", ImmutableList.of("VM")).put("Rebuild", ImmutableList.of("VM"))
+            .put("Migrate", ImmutableList.of("VM")).put("ConfigModify", ImmutableList.of("VNF")).build();
+    private static final ImmutableMap<String, List<String>> payloads = new ImmutableMap.Builder<String, List<String>>()
+            .put("Restart", ImmutableList.of(APPC_VM_ID))
+            .put("ConfigModify", ImmutableList.of(APPC_REQUEST_PARAMS, APPC_CONFIG_PARAMS)).build();
+
+    @Override
+    public String actor() {
+        return "APPC";
+    }
+
+    @Override
+    public List<String> recipes() {
+        return ImmutableList.copyOf(recipes);
+    }
+
+    @Override
+    public List<String> recipeTargets(String recipe) {
+        return ImmutableList.copyOf(targets.getOrDefault(recipe, Collections.emptyList()));
+    }
+
+    @Override
+    public List<String> recipePayloads(String recipe) {
+        return ImmutableList.copyOf(payloads.getOrDefault(recipe, Collections.emptyList()));
+    }
+        
+    /**
+     * Constructs an A&AI Named Query using a source vnf-id to determine 
+     * the vnf-id of the target entity specified in the policy to act upon.
+     * 
+     * @param resourceId
+     *            the id of the target from the sdc catalog
+     *            
+     * @param sourceVnfId
+     *            the vnf id of the source entity reporting the alert
+     *            
+     * @return the target entities vnf id to act upon
+     */
+    public static String vnfNamedQuery(String resourceId, String sourceVnfId) {
+        String targetVnfId = "";
+        AAINQF199Request aaiRequest = new AAINQF199Request();
+        UUID requestId = UUID.randomUUID();
+        
+        aaiRequest.queryParameters.namedQuery.namedQueryUUID = requestId;
+        
+        Map<String, Map<String, String>> filter = new HashMap<String, Map<String, String>>();
+        
+        Map<String, String> filterItem = new HashMap<String, String>();
+        filterItem.put("vnf-id", sourceVnfId);
+        
+        filter.put("generic-vnf", filterItem);
+        
+        aaiRequest.instanceFilters.instanceFilter.add(filter);
+        
+        //TODO: What is the url to use?
+        AAINQF199Response aaiResponse = AAINQF199Manager.postQuery("http://localhost:6666", "policy", "policy", aaiRequest, requestId);
+        
+        //TODO: What if the resourceId never matches?
+        for (AAINQF199InventoryResponseItem item: aaiResponse.inventoryResponseItems) {
+            if (item.genericVNF.modelInvariantId.equals(resourceId)) {
+                targetVnfId = item.genericVNF.vnfID;
+            }
+        }
+        
+        return targetVnfId;
+    }
+    
+    /**
+     * Constructs an APPC request conforming to the lcm API.
+     * The actual request is constructed and then placed in a 
+     * wrapper object used to send through DMAAP.
+     * 
+     * @param onset
+     *            the event that is reporting the alert for policy
+     *            to perform an action        
+     * @param operation
+     *            the control loop operation specifying the actor,
+     *            operation, target, etc.  
+     * @param policy
+     *            the policy the was specified from the yaml generated
+     *            by CLAMP or through the Policy GUI/API                        
+     * @return an APPC request conforming to the lcm API using the DMAAP wrapper
+     */
+    public static LCMRequestWrapper constructRequest(VirtualControlLoopEvent onset, ControlLoopOperation operation,
+            Policy policy) {
+        
+        /* Construct an APPC request using LCM Model */
+        
+        /*
+         * The actual LCM request is placed in a wrapper used to send
+         * through dmaap. The current version is 2.0 as of R1.
+         */
+        LCMRequestWrapper dmaapRequest = new LCMRequestWrapper();
+        dmaapRequest.setVersion("2.0");
+        dmaapRequest.setCorrelationId(onset.requestID + "-" + operation.subRequestId);
+        dmaapRequest.setRpcName(policy.getRecipe().toLowerCase());
+        dmaapRequest.setType("request");
+        
+        /* This is the actual request that is placed in the dmaap wrapper. */
+        LCMRequest appcRequest = new LCMRequest();
+        
+        /* The common header is a required field for all APPC requests. */
+        LCMCommonHeader requestCommonHeader = new LCMCommonHeader();
+        requestCommonHeader.setOriginatorId(onset.requestID.toString());
+        requestCommonHeader.setRequestId(onset.requestID);
+        requestCommonHeader.setSubRequestId(operation.subRequestId);
+        
+        appcRequest.setCommonHeader(requestCommonHeader);
+
+        /* 
+         * Action Identifiers are required for APPC LCM requests.
+         * For R1, the recipes supported by Policy only require
+         * a vnf-id.
+         */
+        HashMap<String, String> requestActionIdentifiers = new HashMap<>();
+        requestActionIdentifiers.put("vnf-id", onset.AAI.get(DCAE_VNF_ID));
+        appcRequest.setActionIdentifiers(requestActionIdentifiers);
+        
+        /* 
+         * An action is required for all APPC requests, this will 
+         * be the recipe specified in the policy.
+         */
+        appcRequest.setAction(policy.getRecipe().toLowerCase());
+
+        /*
+         * For R1, the payloads will not be required for the Restart, 
+         * Rebuild, or Migrate recipes. APPC will populate the payload
+         * based on A&AI look up of the vnd-id provided in the action
+         * identifiers.
+         */
+        if ("Restart".equalsIgnoreCase(policy.getRecipe()) || "Rebuild".equalsIgnoreCase(policy.getRecipe())
+                || "Migrate".equalsIgnoreCase(policy.getRecipe())) {
+            appcRequest.setPayload(null);
+        }
+        
+        /* 
+         * Once the LCM request is constructed, add it into the 
+         * body of the dmaap wrapper.
+         */
+        dmaapRequest.setBody(appcRequest);
+        
+        /* Return the request to be sent through dmaap. */
+        return dmaapRequest;
+    }
+    
+    /**
+     * Parses the operation attempt using the subRequestId
+     * of APPC response.
+     * 
+     * @param subRequestId
+     *            the sub id used to send to APPC, Policy sets
+     *            this using the operation attempt
+     *            
+     * @return the current operation attempt
+     */
+    public static Integer parseOperationAttempt(String subRequestId) {
+        Integer operationAttempt;
+        try {
+            operationAttempt = Integer.parseInt(subRequestId);
+        } catch (NumberFormatException e) {
+            logger.debug("A NumberFormatException was thrown due to error in parsing the operation attempt");
+            return null;
+        }
+        return operationAttempt;
+    }
+    
+    /**
+     * Processes the APPC LCM response sent from APPC. Determines
+     * if the APPC operation was successful/unsuccessful and maps
+     * this to the corresponding Policy result.
+     * 
+     * @param dmaapResponse
+     *            the dmaap wrapper message that contains the
+     *            actual APPC reponse inside the body field
+     *                       
+     * @return an key-value pair that contains the Policy result
+     * and APPC response message
+     */
+    public static SimpleEntry<PolicyResult, String> processResponse(LCMResponseWrapper dmaapResponse) {
+        /* The actual APPC response is inside the wrapper's body field. */
+        LCMResponse appcResponse = dmaapResponse.getBody();
+        
+        /* The message returned in the APPC response. */
+        String message;
+        
+        /* The Policy result determined from the APPC Response. */
+        PolicyResult result;
+        
+        /* If there is no status, Policy cannot determine if the request was successful. */
+        if (appcResponse.getStatus() == null) {
+            message = "Policy was unable to parse APP-C response status field (it was null).";
+            return new AbstractMap.SimpleEntry<>(PolicyResult.FAILURE_EXCEPTION, message);
+        }
+        
+        /* If there is no code, Policy cannot determine if the request was successful. */
+        String responseValue = LCMResponseCode.toResponseValue(appcResponse.getStatus().getCode());
+        if (responseValue == null) {
+            message = "Policy was unable to parse APP-C response status code field.";
+            return new AbstractMap.SimpleEntry<>(PolicyResult.FAILURE_EXCEPTION, message);
+        }
+        
+        /* Save the APPC response's message for Policy noticiation message. */
+        message = appcResponse.getStatus().getMessage();
+        
+        /* Maps the APPC response result to a Policy result. */
+        switch (responseValue) {
+            case LCMResponseCode.ACCEPTED:
+                /* Nothing to do if code is accept, continue processing */
+                result = null;
+                break;
+            case LCMResponseCode.SUCCESS:
+                result = PolicyResult.SUCCESS;
+                break;
+            case LCMResponseCode.FAILURE:
+                result = PolicyResult.FAILURE;
+                break;
+            case LCMResponseCode.REJECT:
+            case LCMResponseCode.ERROR:
+            default:
+                result = PolicyResult.FAILURE_EXCEPTION;
+        }
+        return new AbstractMap.SimpleEntry<>(result, message);
+    }
+
+}
diff --git a/controlloop/common/actors/actor.appclcm/src/main/resources/META-INF/services/org.onap.policy.controlloop.actorServiceProvider.spi.Actor b/controlloop/common/actors/actor.appclcm/src/main/resources/META-INF/services/org.onap.policy.controlloop.actorServiceProvider.spi.Actor
new file mode 100644
index 000000000..403ad9859
--- /dev/null
+++ b/controlloop/common/actors/actor.appclcm/src/main/resources/META-INF/services/org.onap.policy.controlloop.actorServiceProvider.spi.Actor
@@ -0,0 +1 @@
+org.onap.policy.controlloop.actor.appclcm.AppcLcmActorServiceProvider
\ No newline at end of file
diff --git a/controlloop/common/actors/actor.appclcm/src/test/java/org/onap/policy/controlloop/actor/appclcm/AppcLcmServiceProviderTest.java b/controlloop/common/actors/actor.appclcm/src/test/java/org/onap/policy/controlloop/actor/appclcm/AppcLcmServiceProviderTest.java
new file mode 100644
index 000000000..f1df440a8
--- /dev/null
+++ b/controlloop/common/actors/actor.appclcm/src/test/java/org/onap/policy/controlloop/actor/appclcm/AppcLcmServiceProviderTest.java
@@ -0,0 +1,271 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * AppcServiceProviderTest
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.actor.appclcm;
+
+import static org.junit.Assert.*;
+
+import java.time.Instant;
+import java.util.AbstractMap;
+import java.util.HashMap;
+import java.util.UUID;
+
+import org.junit.Test;
+import org.onap.policy.appclcm.LCMCommonHeader;
+import org.onap.policy.appclcm.LCMRequest;
+import org.onap.policy.appclcm.LCMRequestWrapper;
+import org.onap.policy.appclcm.LCMResponse;
+import org.onap.policy.appclcm.LCMResponseWrapper;
+import org.onap.policy.controlloop.ControlLoopEventStatus;
+import org.onap.policy.controlloop.ControlLoopOperation;
+import org.onap.policy.controlloop.ControlLoopTargetType;
+import org.onap.policy.controlloop.VirtualControlLoopEvent;
+import org.onap.policy.controlloop.policy.Policy;
+import org.onap.policy.controlloop.policy.PolicyResult;
+import org.onap.policy.controlloop.policy.Target;
+import org.onap.policy.controlloop.policy.TargetType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class AppcLcmServiceProviderTest {
+    
+    private static final Logger logger = LoggerFactory.getLogger(AppcLcmServiceProviderTest.class);
+    
+    private static VirtualControlLoopEvent onsetEvent;
+    private static ControlLoopOperation operation;
+    private static Policy policy;
+    private static LCMRequestWrapper dmaapRequest;
+    private static LCMResponseWrapper dmaapResponse;
+
+    static {
+        /* 
+         * Construct an onset with an AAI subtag containing
+         * generic-vnf.vnf-id and a target type of VM.
+         */
+        onsetEvent = new VirtualControlLoopEvent();
+        onsetEvent.closedLoopControlName = "closedLoopControlName-Test";
+        onsetEvent.requestID = UUID.randomUUID();
+        onsetEvent.closedLoopEventClient = "tca.instance00001";
+        onsetEvent.target_type = ControlLoopTargetType.VM;
+        onsetEvent.target = "generic-vnf.vnf-id";
+        onsetEvent.from = "DCAE";
+        onsetEvent.closedLoopAlarmStart = Instant.now();
+        onsetEvent.AAI = new HashMap<>();
+        onsetEvent.AAI.put("generic-vnf.vnf-id", "fw0001vm001fw001");
+        onsetEvent.closedLoopEventStatus = ControlLoopEventStatus.ONSET;
+
+        /* Construct an operation with an APPC actor and restart operation. */
+        operation = new ControlLoopOperation();
+        operation.actor = "APPC";
+        operation.operation = "Restart";
+        operation.target = "VM";
+        operation.end = Instant.now();
+        operation.subRequestId = "1";
+        
+        /* Construct a policy specifying to restart vm. */
+        policy = new Policy();
+        policy.setName("Restart the VM");
+        policy.setDescription("Upon getting the trigger event, restart the VM");
+        policy.setActor("APPC");
+        policy.setTarget(new Target(TargetType.VM));
+        policy.setRecipe("Restart");
+        policy.setPayload(null);
+        policy.setRetry(2);
+        policy.setTimeout(300);
+
+        /* A sample DMAAP request wrapper. */
+        dmaapRequest = new LCMRequestWrapper();
+        dmaapRequest.setCorrelationId(onsetEvent.requestID.toString() + "-" + "1");
+        dmaapRequest.setRpcName(policy.getRecipe().toLowerCase());
+        dmaapRequest.setType("request");
+
+        /* A sample DMAAP response wrapper */
+        dmaapResponse = new LCMResponseWrapper();
+        dmaapResponse.setCorrelationId(onsetEvent.requestID.toString() + "-" + "1");
+        dmaapResponse.setRpcName(policy.getRecipe().toLowerCase());
+        dmaapResponse.setType("response");
+
+        /* A sample APPC LCM request. */
+        LCMRequest appcRequest = new LCMRequest();
+        
+        /* The following code constructs a sample APPC LCM Request */
+        appcRequest.setAction("restart");
+        
+        HashMap<String, String> actionIdentifiers = new HashMap<>();
+        actionIdentifiers.put("vnf-id", "trial-vnf-003");
+        
+        appcRequest.setActionIdentifiers(actionIdentifiers);
+        
+        LCMCommonHeader commonHeader = new LCMCommonHeader();
+        commonHeader.setRequestId(onsetEvent.requestID);
+        commonHeader.setSubRequestId("1");
+        commonHeader.setOriginatorId(onsetEvent.requestID.toString());
+        
+        appcRequest.setCommonHeader(commonHeader);
+        
+        appcRequest.setPayload(null);
+
+        dmaapRequest.setBody(appcRequest);
+
+        /* The following code constructs a sample APPC LCM Response */
+        LCMResponse appcResponse = new LCMResponse(appcRequest);
+        appcResponse.getStatus().setCode(400);
+        appcResponse.getStatus().setMessage("Restart Successful");
+
+        dmaapResponse.setBody(appcResponse);
+    }
+    
+    /**
+     * A test to construct an APPC LCM restart request.
+     */
+    @Test
+    public void constructRestartRequestTest() {
+        
+        LCMRequestWrapper dmaapRequest = AppcLcmActorServiceProvider.constructRequest(onsetEvent, operation, policy);
+
+        /* The service provider must return a non null DMAAP request wrapper */
+        assertNotNull(dmaapRequest);
+
+        /* The DMAAP wrapper's type field must be request */
+        assertEquals(dmaapRequest.getType(), "request");
+        
+        /* The DMAAP wrapper's body field cannot be null */
+        assertNotNull(dmaapRequest.getBody());
+
+        LCMRequest appcRequest = dmaapRequest.getBody();
+        
+        /* A common header is required and cannot be null */
+        assertNotNull(appcRequest.getCommonHeader());
+        assertEquals(appcRequest.getCommonHeader().getRequestId(), onsetEvent.requestID);
+
+        /* An action is required and cannot be null */
+        assertNotNull(appcRequest.getAction());
+        assertEquals(appcRequest.getAction(), "restart");
+
+        /* Action Identifiers are required and cannot be null */
+        assertNotNull(appcRequest.getActionIdentifiers());
+        assertNotNull(appcRequest.getActionIdentifiers().get("vnf-id"));
+        
+        logger.debug("APPC Request: \n" + appcRequest.toString());
+    }
+
+    /**
+     * A test to process a successful APPC restart response.
+     */
+    @Test
+    public void processRestartResponseSuccessTest() {
+        AbstractMap.SimpleEntry<PolicyResult, String> result = AppcLcmActorServiceProvider
+                .processResponse(dmaapResponse);
+        assertEquals(result.getKey(), PolicyResult.SUCCESS);
+        assertEquals(result.getValue(), "Restart Successful");
+    }
+    
+    /**
+     * A test to map APPC response results to corresponding Policy results
+     */
+    @Test
+    public void appcToPolicyResultTest() {
+        
+        AbstractMap.SimpleEntry<PolicyResult, String> result;
+        
+        /* If APPC accepts, PolicyResult is null */
+        dmaapResponse.getBody().getStatus().setCode(100);
+        dmaapResponse.getBody().getStatus().setMessage("ACCEPTED");
+        result = AppcLcmActorServiceProvider.processResponse(dmaapResponse);
+        assertEquals(result.getKey(), null);
+        
+        /* If APPC is successful, PolicyResult is success */
+        dmaapResponse.getBody().getStatus().setCode(400);
+        dmaapResponse.getBody().getStatus().setMessage("SUCCESS");
+        result = AppcLcmActorServiceProvider.processResponse(dmaapResponse);
+        assertEquals(result.getKey(), PolicyResult.SUCCESS);
+        
+        /* If APPC returns an error, PolicyResult is failure exception */
+        dmaapResponse.getBody().getStatus().setCode(200);
+        dmaapResponse.getBody().getStatus().setMessage("ERROR");
+        result = AppcLcmActorServiceProvider.processResponse(dmaapResponse);
+        assertEquals(result.getKey(), PolicyResult.FAILURE_EXCEPTION);
+        
+        /* If APPC rejects, PolicyResult is failure exception */
+        dmaapResponse.getBody().getStatus().setCode(300);
+        dmaapResponse.getBody().getStatus().setMessage("REJECT");
+        result = AppcLcmActorServiceProvider.processResponse(dmaapResponse);
+        assertEquals(result.getKey(), PolicyResult.FAILURE_EXCEPTION);
+        
+        /* Test multiple reject codes */
+        dmaapResponse.getBody().getStatus().setCode(306);
+        dmaapResponse.getBody().getStatus().setMessage("REJECT");
+        result = AppcLcmActorServiceProvider.processResponse(dmaapResponse);
+        assertEquals(result.getKey(), PolicyResult.FAILURE_EXCEPTION);
+        
+        dmaapResponse.getBody().getStatus().setCode(313);
+        dmaapResponse.getBody().getStatus().setMessage("REJECT");
+        result = AppcLcmActorServiceProvider.processResponse(dmaapResponse);
+        assertEquals(result.getKey(), PolicyResult.FAILURE_EXCEPTION);
+        
+        /* If APPC returns failure, PolicyResult is failure */
+        dmaapResponse.getBody().getStatus().setCode(401);
+        dmaapResponse.getBody().getStatus().setMessage("FAILURE");
+        result = AppcLcmActorServiceProvider.processResponse(dmaapResponse);
+        assertEquals(result.getKey(), PolicyResult.FAILURE);
+        
+        /* Test multiple failure codes */
+        dmaapResponse.getBody().getStatus().setCode(406);
+        dmaapResponse.getBody().getStatus().setMessage("FAILURE");
+        result = AppcLcmActorServiceProvider.processResponse(dmaapResponse);
+        assertEquals(result.getKey(), PolicyResult.FAILURE);
+        
+        dmaapResponse.getBody().getStatus().setCode(450);
+        dmaapResponse.getBody().getStatus().setMessage("FAILURE");
+        result = AppcLcmActorServiceProvider.processResponse(dmaapResponse);
+        assertEquals(result.getKey(), PolicyResult.FAILURE);
+        
+        /* If APPC returns partial success, PolicyResult is failure exception */
+        dmaapResponse.getBody().getStatus().setCode(500);
+        dmaapResponse.getBody().getStatus().setMessage("PARTIAL SUCCESS");
+        result = AppcLcmActorServiceProvider.processResponse(dmaapResponse);
+        assertEquals(result.getKey(), PolicyResult.FAILURE_EXCEPTION);
+        
+        /* If APPC returns partial failure, PolicyResult is failure exception */
+        dmaapResponse.getBody().getStatus().setCode(501);
+        dmaapResponse.getBody().getStatus().setMessage("PARTIAL FAILURE");
+        result = AppcLcmActorServiceProvider.processResponse(dmaapResponse);
+        assertEquals(result.getKey(), PolicyResult.FAILURE_EXCEPTION);
+        
+        /* Test multiple partial failure codes */
+        dmaapResponse.getBody().getStatus().setCode(599);
+        dmaapResponse.getBody().getStatus().setMessage("PARTIAL FAILURE");
+        result = AppcLcmActorServiceProvider.processResponse(dmaapResponse);
+        assertEquals(result.getKey(), PolicyResult.FAILURE_EXCEPTION);
+        
+        dmaapResponse.getBody().getStatus().setCode(550);
+        dmaapResponse.getBody().getStatus().setMessage("PARTIAL FAILURE");
+        result = AppcLcmActorServiceProvider.processResponse(dmaapResponse);
+        assertEquals(result.getKey(), PolicyResult.FAILURE_EXCEPTION);
+        
+        /* If APPC code is unknown to Policy, PolicyResult is failure exception */
+        dmaapResponse.getBody().getStatus().setCode(700);
+        dmaapResponse.getBody().getStatus().setMessage("UNKNOWN");
+        result = AppcLcmActorServiceProvider.processResponse(dmaapResponse);
+        assertEquals(result.getKey(), PolicyResult.FAILURE_EXCEPTION);
+    }
+    
+
+}