ios-xe increased UT coverage

	- ServiceChainingUtil

Change-Id: I72ee9447073f2b744a6c53eb9e09c82c80485a80
Signed-off-by: Vladimir Lavor <vlavor@cisco.com>

diff --git a/renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/util/ServiceChainingUtil.java b/renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/util/ServiceChainingUtil.java
index cb1b37bc45200db0aa0f54bf16a87a86ef5bfd0e..dbbba527470357ef9ba6464108642995729814a9 100644 (file)
--- a/renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/util/ServiceChainingUtil.java
+++ b/renderers/ios-xe/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/util/ServiceChainingUtil.java
@@ -20,6 +20,7 @@ import static org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.pol
 import static org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.EndpointPolicyParticipation.CONSUMER;
 import static org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.EndpointPolicyParticipation.PROVIDER;
 
+import javax.annotation.Nonnull;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -27,6 +28,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Optional;
 import com.google.common.util.concurrent.CheckedFuture;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
@@ -98,6 +100,7 @@ public class ServiceChainingUtil {
     private static final Logger LOG = LoggerFactory.getLogger(ServiceChainingUtil.class);
     private static final String RSP_SUFFIX = "-gbp-rsp";
     private static final String RSP_REVERSED_SUFFIX = "-gbp-rsp-Reverse";
+    private static long timeout = 5000L;
 
     /**
      * According to input, creates class-maps ({@link ClassMap}) and entries into policy-map ({@link Class}). These
@@ -115,6 +118,9 @@ public class ServiceChainingUtil {
                                       final Sgt destinationSgt, final Map<PolicyManagerImpl.ActionCase, ActionInDirection> actionMap,
                                       final PolicyConfigurationContext context, final DataBroker dataBroker) {
         final ActionInDirection actionInDirection = actionMap.get(ActionCase.CHAIN);
+        if (actionInDirection == null) {
+            return;
+        }
         // Rule action + orientation
         final Action action = actionInDirection.getAction();
         final EndpointPolicyParticipation participation = actionInDirection.getParticipation();
@@ -231,7 +237,7 @@ public class ServiceChainingUtil {
                     if (!sffMgmtIpValue.equals(policyWriter.getManagementIpAddress())) {
                         // Remove service chain and remote forwarder
                         final ServiceChain serviceChain = createServiceChain(renderedServicePath);
-                        final ServiceFfName remoteForwarder = findRemoteForwarder(firstHopSff);
+                        final ServiceFfName remoteForwarder = createRemoteForwarder(firstHopSff);
                         policyWriter.cache(serviceChain);
                         policyWriter.cache(remoteForwarder);
                     }
@@ -252,7 +258,7 @@ public class ServiceChainingUtil {
                     if (!reversedSffMgmtIpValue.equals(policyWriter.getManagementIpAddress())) {
                         // Remove service chain and remote forwarder
                         final ServiceChain serviceChain = createServiceChain(reversedRenderedServicePath);
-                        final ServiceFfName remoteForwarder = findRemoteForwarder(reversedFirstHopSff);
+                        final ServiceFfName remoteForwarder = createRemoteForwarder(reversedFirstHopSff);
                         policyWriter.cache(serviceChain);
                         policyWriter.cache(remoteForwarder);
                     }
@@ -276,7 +282,7 @@ public class ServiceChainingUtil {
                 if (!sffMgmtIpValue.equals(policyWriter.getManagementIpAddress())) {
                     // Remove service chain and remote forwarder
                     final ServiceChain serviceChain = createServiceChain(renderedServicePath);
-                    final ServiceFfName remoteForwarder = findRemoteForwarder(firstHopSff);
+                    final ServiceFfName remoteForwarder = createRemoteForwarder(firstHopSff);
                     policyWriter.cache(serviceChain);
                     policyWriter.cache(remoteForwarder);
                 }
@@ -295,7 +301,7 @@ public class ServiceChainingUtil {
      * @param policyWriter        policy entries writer
      * @return true if everything went good, false otherwise
      */
-    private static boolean resolveRemoteSfcComponents(final RenderedServicePath renderedServicePath, PolicyWriter policyWriter) {
+    static boolean resolveRemoteSfcComponents(final RenderedServicePath renderedServicePath, PolicyWriter policyWriter) {
         final ServiceFunctionForwarder forwarder = getFirstHopSff(renderedServicePath);
         if (forwarder == null) {
             return false;
@@ -391,23 +397,19 @@ public class ServiceChainingUtil {
         return serviceFunctionPath;
     }
 
-    static ServiceFunctionPath findServiceFunctionPathFromServiceChainName(final SfcName chainName) {
+    static ServiceFunctionPath findServiceFunctionPathFromServiceChainName(@Nonnull final SfcName chainName) {
         final ServiceFunctionPaths allPaths = SfcProviderServicePathAPI.readAllServiceFunctionPaths();
+        if (allPaths == null || allPaths.getServiceFunctionPath() == null || allPaths.getServiceFunctionPath().isEmpty()) {
+            return null;
+        }
         for (ServiceFunctionPath serviceFunctionPath : allPaths.getServiceFunctionPath()) {
-            if (serviceFunctionPath.getServiceChainName().equals(chainName)) {
+            if (chainName.equals(serviceFunctionPath.getServiceChainName())) {
                 return serviceFunctionPath;
             }
         }
         return null;
     }
 
-    private static ServiceFfName findRemoteForwarder(ServiceFunctionForwarder firstHopSff) {
-        ServiceFfNameBuilder serviceFfNameBuilder = new ServiceFfNameBuilder();
-        serviceFfNameBuilder.setName(firstHopSff.getName().getValue())
-                .setKey(new ServiceFfNameKey(firstHopSff.getName().getValue()));
-        return serviceFfNameBuilder.build();
-    }
-
     /**
      * Creates {@link RenderedServicePath} if not exist. If created, ios-xe renderer in SFC is invoked, so this method
      * has to wait till SFC part is done to prevent transaction collisions in {@link this#checkRspManagerStatus(RspName,
@@ -466,14 +468,26 @@ public class ServiceChainingUtil {
         return reversedRenderedPath;
     }
 
-    static ServiceTypeChoice createForwarderTypeChoice(final String forwarderName) {
+    static ServiceFfName createRemoteForwarder(ServiceFunctionForwarder firstHopSff) {
+        final ServiceFfNameBuilder serviceFfNameBuilder = new ServiceFfNameBuilder();
+        serviceFfNameBuilder.setName(firstHopSff.getName().getValue());
+        return serviceFfNameBuilder.build();
+    }
+
+    private static ServiceTypeChoice createForwarderTypeChoice(final String forwarderName) {
         final ServiceFunctionForwarderBuilder sffBuilder = new ServiceFunctionForwarderBuilder();
         sffBuilder.setServiceFunctionForwarder(forwarderName);
         return sffBuilder.build();
     }
 
+    /**
+     * Creates service-chain with name/key only, using rendered service path id. This object contains no data, it is used
+     * to create instance identifier when appropriate service-chain is removed from particular device
+     *
+     * @param renderedServicePath - it's path id is used as a identifier
+     * @return service-chain object with id
+     */
     private static ServiceChain createServiceChain(final RenderedServicePath renderedServicePath) {
-        // Construct service chain with key
         final Long pathId = renderedServicePath.getPathId();
         final ServicePathBuilder servicePathBuilder = new ServicePathBuilder();
         final ServiceChainBuilder serviceChainBuilder = new ServiceChainBuilder();
@@ -513,9 +527,8 @@ public class ServiceChainingUtil {
     }
 
     private static void checkRspManagerStatus(final RspName rspName, final DataBroker dataBroker) {
-        /** TODO A better way to do this is to register listener and wait for notification than using hardcoded timeout
-         *  with Thread.sleep(). Example in class BridgeDomainManagerImpl
-         */
+        // TODO A better way to do this is to register listener and wait for notification than using hardcoded timeout
+        // with Thread.sleep(). Example in class BridgeDomainManagerImpl
         ConfiguredRenderedPath renderedPath = null;
         LOG.debug("Waiting for SFC to configure path {} ...", rspName.getValue());
 
@@ -524,7 +537,7 @@ public class ServiceChainingUtil {
             attempt++;
             // Wait
             try {
-                Thread.sleep(5000L);
+                Thread.sleep(timeout);
             } catch (InterruptedException e) {
                 LOG.error("Thread interrupted while waiting ... {} ", e);
             }
@@ -558,7 +571,7 @@ public class ServiceChainingUtil {
             } else if (renderedPath.getPathStatus().equals(ConfiguredRenderedPath.PathStatus.Success)) {
                 LOG.debug("RSP {} configured by SFC", rspName.getValue());
                 try {
-                    Thread.sleep(5000); // Just for sure, maybe will be safe to remove this
+                    Thread.sleep(timeout); // Just for sure, maybe will be safe to remove this
                 } catch (InterruptedException e) {
                     LOG.error("Thread interrupted while waiting ... {} ", e);
                 }
@@ -568,4 +581,13 @@ public class ServiceChainingUtil {
         while (attempt <= 6);
         LOG.warn("Maximum number of attempts reached");
     }
+
+    /**
+     * Only for test purposes
+     * @param value - set actual timeout value
+     */
+    @VisibleForTesting
+    public static void setTimeout(long value) {
+        timeout = value;
+    }
 }

diff --git a/renderers/ios-xe/src/test/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/util/ServiceChainingUtilTest.java b/renderers/ios-xe/src/test/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/util/ServiceChainingUtilTest.java
index c932bd79ab06b94481eaa679e5767b35521f902f..ddaa2e069f6e1253860591af91b5e0c85ea9cff3 100644 (file)
--- a/renderers/ios-xe/src/test/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/util/ServiceChainingUtilTest.java
+++ b/renderers/ios-xe/src/test/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/util/ServiceChainingUtilTest.java
@@ -8,31 +8,42 @@
 
 package org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.util;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.PolicyManagerImpl.ActionCase.ALLOW;
+import static org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.PolicyManagerImpl.ActionCase.CHAIN;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection.Direction.In;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection.Direction.Out;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.EndpointPolicyParticipation.PROVIDER;
 import static org.powermock.api.support.membermodification.MemberMatcher.method;
 import static org.powermock.api.support.membermodification.MemberModifier.stub;
 
-import com.google.common.base.Optional;
+import javax.annotation.Nonnull;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
 import com.google.common.collect.Lists;
-import com.google.common.util.concurrent.Futures;
-import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.ArgumentCaptor;
-import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.util.PolicyManagerUtil.ActionInDirection;
 import org.mockito.Captor;
-import org.mockito.Matchers;
 import org.mockito.Mock;
-import org.mockito.Mockito;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.groupbasedpolicy.api.sf.ChainActionDefinition;
 import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.PolicyConfigurationContext;
-import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.PolicyManagerImpl;
-import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.writer.NetconfTransactionCreator;
+import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.PolicyManagerImpl.ActionCase;
+import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.util.PolicyManagerUtil.ActionInDirection;
 import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.writer.PolicyWriter;
-import org.opendaylight.groupbasedpolicy.util.IetfModelCodec;
 import org.opendaylight.sfc.provider.api.SfcProviderRenderedPathAPI;
 import org.opendaylight.sfc.provider.api.SfcProviderServiceForwarderAPI;
 import org.opendaylight.sfc.provider.api.SfcProviderServicePathAPI;
@@ -55,56 +66,53 @@ import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev1407
 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev140701.service.function.paths.ServiceFunctionPath;
 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev140701.service.function.paths.ServiceFunctionPathBuilder;
 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sl.rev140701.data.plane.locator.locator.type.IpBuilder;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ClassMap;
 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ServiceChain;
 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.policy.map.Class;
-import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.Local;
 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.ServiceFfName;
-import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.path.config.service.chain.path.mode.service.index.services.ServiceTypeChoice;
-import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.path.config.service.chain.path.mode.service.index.services.service.type.choice.ServiceFunction;
-import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.path.config.service.chain.path.mode.service.index.services.service.type.choice.ServiceFunctionForwarder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
+import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.ServiceFfNameBuilder;
+import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.ServiceFfNameKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection.Direction;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValueBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.EndpointPolicyParticipation;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.rule.group.with.renderer.endpoint.participation.RuleGroupWithRendererEndpointParticipationBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpoint;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerEndpoint;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerEndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.actions.Action;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.actions.ActionBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.powermock.api.mockito.PowerMockito;
 import org.powermock.core.classloader.annotations.PrepareForTest;
 import org.powermock.modules.junit4.PowerMockRunner;
 
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
 /**
  * Test for {@link ServiceChainingUtil}.
  */
 @RunWith(PowerMockRunner.class)
 @PrepareForTest({
-        ServiceChainingUtil.class,
+        SfcProviderServiceForwarderAPI.class,
         SfcProviderServicePathAPI.class,
         SfcProviderRenderedPathAPI.class,
-        SfcProviderServiceForwarderAPI.class,
-        NetconfTransactionCreator.class
+        PolicyManagerUtil.class,
+        PolicyWriter.class
 })
 public class ServiceChainingUtilTest {
 
+    private final String SFC_CHAIN_NAME = "sfc-chain-name";
+    private final String SFC_PATH_NAME = "sfc-path-name";
+    private final String TENANT_ID = "tenant-id";
+    private final String IP_ADDRESS = "170.0.0.1";
+    private final String SERVICE_FUNCTION_FORWARDER = "service-function-forwarder";
+
+    private DataBroker dataBroker;
+    private PolicyWriter policyWriter;
+
+
     @Captor
     private ArgumentCaptor<RspName> rspNameCaptor;
     @Captor
@@ -120,368 +128,680 @@ public class ServiceChainingUtilTest {
     @Captor
     private ArgumentCaptor<ClassMap> classMapCaptor;
     @Mock
-    private PolicyWriter policyWriter;
-    @Mock
-    private DataBroker dataBroker;
-    @Mock
     private ReadWriteTransaction rwTx;
 
-    private PolicyConfigurationContext policyConfigurationContext;
-
     @Before
-    public void setUp() throws Exception {
-        final NodeId currentNodeId = new NodeId("unit-node-01");
-        Mockito.when(policyWriter.getNodeId()).thenReturn(currentNodeId);
+    public void setUp() {
+        dataBroker = mock(DataBroker.class);
+        policyWriter = mock(PolicyWriter.class);
+    }
 
-        final String managementIpAddress = "1.2.3.5";
-        Mockito.when(policyWriter.getManagementIpAddress()).thenReturn(managementIpAddress);
+    @Test
+    public void testResolveNewChainAction_actionAllow() {
+        final PeerEndpoint peerEndpoint = peerEndpointBuilder();
+        final Action action = actionBuilder(null);
+        final PolicyConfigurationContext context = policyConfigurationContextBuilder();
 
-        Mockito.when(policyWriter.getMountpoint()).thenReturn(dataBroker);
-        Mockito.when(dataBroker.newReadWriteTransaction()).thenReturn(rwTx);
+        ServiceChainingUtil.resolveNewChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
+                resolvedActionBuilder(ALLOW, action, In), context, dataBroker);
 
-        policyConfigurationContext = new PolicyConfigurationContext();
-        policyConfigurationContext.setPolicyWriter(policyWriter);
+        verifyNoMoreInteractions(policyWriter);
+        verifyNoMoreInteractions(dataBroker);
     }
 
     @Test
-    public void testGetServicePath() throws Exception {
-        final String sfcNameValue = "123";
-        final ServiceFunctionPath sfcPath = createSfp(sfcNameValue, false);
-        final ServiceFunctionPaths sfcPaths = new ServiceFunctionPathsBuilder()
-                .setServiceFunctionPath(Collections.singletonList(sfcPath))
-                .build();
+    public void testResolveNewChainAction_noParameterValue() {
+        final PeerEndpoint peerEndpoint = peerEndpointBuilder();
+        final Action action = actionBuilder(null);
+        final PolicyConfigurationContext context = policyConfigurationContextBuilder();
 
-        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(sfcPaths);
-
-        final ServiceFunctionPath servicePath = ServiceChainingUtil.findServicePathFromParameterValues(Lists.newArrayList(
-                createParameterValue("sfc-chain-name", sfcNameValue)
-        ));
-        Assert.assertEquals(sfcPath, servicePath);
-    }
+        ServiceChainingUtil.resolveNewChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
+                resolvedActionBuilder(CHAIN, action, In), context, dataBroker);
 
-    private ParameterValue createParameterValue(final String name, final String value) {
-        return new ParameterValueBuilder().setName(new ParameterName(name)).setStringValue(value).build();
+        verifyNoMoreInteractions(policyWriter);
+        verifyNoMoreInteractions(dataBroker);
     }
 
     @Test
-    public void testResolveChainAction_full() throws Exception {
-        final PeerEndpoint peerEndpoint = createPeerEndpoint();
-        final Sgt sourceSgt = new Sgt(1);
-        final Sgt destinationSgt = new Sgt(2);
-        final Map<PolicyManagerImpl.ActionCase, PolicyManagerUtil.ActionInDirection> actionMap = createActionMap();
-        final String classMapName = "unit-class-map-name-01";
+    public void testResolveNewChainAction_noTenantId() {
+        final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
+        parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
+        final ParameterValue parameterValue = parameterValueBuilder.build();
 
-        final String sfcNameValue = "123";
-        final ServiceFunctionPath sfcPath = createSfp(sfcNameValue, false);
-        final ServiceFunctionPaths sfcPaths = new ServiceFunctionPathsBuilder()
-                .setServiceFunctionPath(Collections.singletonList(sfcPath))
-                .build();
+        final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
+        pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME));
+        final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
+        pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 
-        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(sfcPaths);
+        final PeerEndpoint peerEndpoint = peerEndpointBuilder();
+        final Action action = actionBuilder(Collections.singletonList(parameterValue));
+        final PolicyConfigurationContext context = policyConfigurationContextBuilder();
 
-        final RenderedServicePath rsp = createRsp("unit-rsp-02");
-        stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(rsp);
+        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
+        stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(null);
 
-        ServiceChainingUtil.resolveNewChainAction(peerEndpoint, sourceSgt, destinationSgt, actionMap, policyConfigurationContext, dataBroker);
+        ServiceChainingUtil.resolveNewChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
+                resolvedActionBuilder(CHAIN, action, In), context, dataBroker);
 
-        Mockito.verifyNoMoreInteractions(policyWriter);
+        verifyNoMoreInteractions(policyWriter);
+        verifyNoMoreInteractions(dataBroker);
     }
 
     @Test
-    public void testResolveChainAction_fullSymmetric() throws Exception {
-        final PeerEndpoint peerEndpoint = createPeerEndpoint();
-        final Sgt sourceSgt = new Sgt(1);
-        final Sgt destinationSgt = new Sgt(2);
-        final Map<PolicyManagerImpl.ActionCase, ActionInDirection> actionMap = createActionMap();
-        final String classMapName = "unit-class-map-name-01";
+    public void testResolveNewChainAction_asymmetricChainOpposite() {
+        final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
+        parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
+        final ParameterValue parameterValue = parameterValueBuilder.build();
 
-        final String sfcNameValue = "123";
-        final ServiceFunctionPath sfcPath = createSfp(sfcNameValue, true);
-        final ServiceFunctionPaths sfcPaths = new ServiceFunctionPathsBuilder()
-                .setServiceFunctionPath(Collections.singletonList(sfcPath))
-                .build();
-        final org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.ServiceFunctionForwarder serviceFunctionForwarder
-                = new ServiceFunctionForwarderBuilder()
-                .setName(new SffName("sff"))
-                .setKey(new ServiceFunctionForwarderKey(new SffName("sff"))).build();
+        final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
+        pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
+                .setSymmetric(false);
+        final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
+        pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 
-        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(sfcPaths);
+        final PeerEndpoint peerEndpoint = peerEndpointBuilder();
+        final Action action = actionBuilder(Collections.singletonList(parameterValue));
+        final PolicyConfigurationContext context = policyConfigurationContextBuilder();
 
-        final RenderedServicePath rsp = createRsp("unit-rsp-02");
-        stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(rsp);
-        stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder")).toReturn(serviceFunctionForwarder);
+        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
+        stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(new TenantId(TENANT_ID));
 
-        ServiceChainingUtil.resolveNewChainAction(peerEndpoint, sourceSgt, destinationSgt, actionMap, policyConfigurationContext, dataBroker);
+        ServiceChainingUtil.resolveNewChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
+                resolvedActionBuilder(CHAIN, action, In), context, dataBroker);
 
-        Mockito.verify(policyWriter).cache(classMapCaptor.capture());
-        Mockito.verify(policyWriter).cache(listClassCaptor.capture());
-        Mockito.verifyNoMoreInteractions(policyWriter);
-        Assert.assertNotNull(listClassCaptor.getValue());
+        verifyNoMoreInteractions(policyWriter);
+        verifyNoMoreInteractions(dataBroker);
     }
 
     @Test
-    public void testResolveChainAction_partial01() throws Exception {
-        final PeerEndpoint peerEndpoint = createPeerEndpoint();
-        final Sgt sourceSgt = new Sgt(1);
-        final Sgt destinationSgt = new Sgt(2);
-        final Map<PolicyManagerImpl.ActionCase, ActionInDirection> actionMap = createActionMap();
-        final String classMapName = "unit-class-map-name-01";
+    public void testResolveNewChainAction_asymmetricChain() {
+        final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
+        parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
+        final ParameterValue parameterValue = parameterValueBuilder.build();
+
+        final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
+        pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
+                .setSymmetric(false);
+        final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
+        pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
+
+        final PeerEndpoint peerEndpoint = peerEndpointBuilder();
+        final Action action = actionBuilder(Collections.singletonList(parameterValue));
+        final PolicyConfigurationContext context = policyConfigurationContextBuilder();
+
+        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
+        stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(buildRsp(null));
+        stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(new TenantId(TENANT_ID));
+
+        ServiceChainingUtil.resolveNewChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
+                resolvedActionBuilder(CHAIN, action, Out), context, dataBroker);
+
+        verify(policyWriter).cache(any(ClassMap.class));
+        verify(policyWriter).cache(any(Class.class));
+        verifyNoMoreInteractions(policyWriter);
+        verifyNoMoreInteractions(dataBroker);
+    }
 
-        final String sfcNameValue = "123";
-        final ServiceFunctionPath sfcPath = createSfp(sfcNameValue, true);
-        final ServiceFunctionPaths sfcPaths = new ServiceFunctionPathsBuilder()
-                .setServiceFunctionPath(Collections.singletonList(sfcPath))
-                .build();
-        final org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.ServiceFunctionForwarder serviceFunctionForwarder
-                = new ServiceFunctionForwarderBuilder()
-                .setName(new SffName("sff"))
-                .setKey(new ServiceFunctionForwarderKey(new SffName("sff"))).build();
+    @Test
+    public void testResolveNewChainAction_symmetricChainDirect() {
+        final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
+        parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
+        final ParameterValue parameterValue = parameterValueBuilder.build();
+
+        final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
+        pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
+                .setSymmetric(true);
+        final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
+        pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
+
+        final PeerEndpoint peerEndpoint = peerEndpointBuilder();
+        final Action action = actionBuilder(Collections.singletonList(parameterValue));
+        final PolicyConfigurationContext context = policyConfigurationContextBuilder();
+
+        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
+        stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(buildRsp(null));
+        stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(new TenantId(TENANT_ID));
+
+        ServiceChainingUtil.resolveNewChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
+                resolvedActionBuilder(CHAIN, action, Out), context, dataBroker);
+
+        verify(policyWriter).cache(any(ClassMap.class));
+        verify(policyWriter).cache(any(Class.class));
+        verifyNoMoreInteractions(policyWriter);
+        verifyNoMoreInteractions(dataBroker);
+    }
 
-        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(sfcPaths);
+    @Test
+    public void testResolveNewChainAction_symmetricChainReversed() {
+        final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
+        parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
+        final ParameterValue parameterValue = parameterValueBuilder.build();
+
+        final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
+        pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
+                .setSymmetric(true);
+        final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
+        pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
+
+        final PeerEndpoint peerEndpoint = peerEndpointBuilder();
+        final Action action = actionBuilder(Collections.singletonList(parameterValue));
+        final PolicyConfigurationContext context = policyConfigurationContextBuilder();
+
+        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
+        stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(buildRsp(null));
+        stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(new TenantId(TENANT_ID));
+
+        ServiceChainingUtil.resolveNewChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
+                resolvedActionBuilder(CHAIN, action, In), context, dataBroker);
+
+        verify(policyWriter).cache(any(ClassMap.class));
+        verify(policyWriter).cache(any(Class.class));
+        verifyNoMoreInteractions(policyWriter);
+        verifyNoMoreInteractions(dataBroker);
+    }
 
-        final RenderedServicePath rsp = createRsp("unit-rsp-02");
-        stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(rsp);
-        stub(method(ServiceChainingUtil.class, "createReversedRenderedPath")).toReturn(null);
-        stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder")).toReturn(serviceFunctionForwarder);
+    @Test
+    public void testResolveRemovedChainAction_noParameterValue() {
+        final PeerEndpoint peerEndpoint = peerEndpointBuilder();
+        final Action action = actionBuilder(null);
 
-        policyConfigurationContext.setCurrentRendererEP(createRendererEP(
-                "unit-address", new ContextId("unit-conext-1"), Collections.emptyList())
-        );
+        ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
+                resolvedActionBuilder(CHAIN, action, In), policyWriter);
 
-        ServiceChainingUtil.resolveNewChainAction(peerEndpoint, sourceSgt, destinationSgt, actionMap,
-                policyConfigurationContext, dataBroker);
-        Mockito.verify(policyWriter).cache(classMapCaptor.capture());
-        Mockito.verify(policyWriter).cache(listClassCaptor.capture());
-        Mockito.verifyNoMoreInteractions(policyWriter);
+        verifyNoMoreInteractions(policyWriter);
     }
 
     @Test
-    public void testResolveChainAction_partial02() throws Exception {
-        final PeerEndpoint peerEndpoint = createPeerEndpoint();
-        final Sgt sourceSgt = new Sgt(1);
-        final Sgt destinationSgt = new Sgt(2);
-        final Map<PolicyManagerImpl.ActionCase, ActionInDirection> actionMap = createActionMap();
-        final String classMapName = "unit-class-map-name-01";
+    public void testResolveRemovedChainAction_noTenantId() {
+        final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
+        parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
+        final ParameterValue parameterValue = parameterValueBuilder.build();
 
-        final String sfcNameValue = "123";
-        final ServiceFunctionPath sfcPath = createSfp(sfcNameValue, false);
-        final ServiceFunctionPaths sfcPaths = new ServiceFunctionPathsBuilder()
-                .setServiceFunctionPath(Collections.singletonList(sfcPath))
-                .build();
+        final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
+        pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME));
+        final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
+        pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 
-        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(sfcPaths);
+        final PeerEndpoint peerEndpoint = peerEndpointBuilder();
+        final Action action = actionBuilder(Collections.singletonList(parameterValue));
 
-        final RenderedServicePath rsp = createRsp("unit-rsp-02");
-        stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(rsp);
+        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
+        stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(null);
 
-        ServiceChainingUtil.resolveNewChainAction(peerEndpoint, sourceSgt, destinationSgt, actionMap, policyConfigurationContext, dataBroker);
+        ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
+                resolvedActionBuilder(CHAIN, action, In), policyWriter);
 
-        Mockito.verifyNoMoreInteractions(policyWriter);
+        verifyNoMoreInteractions(policyWriter);
     }
 
     @Test
-    public void testResolveChainAction_partial03() throws Exception {
-        final PeerEndpoint peerEndpoint = createPeerEndpoint(null);
-        final Sgt sourceSgt = new Sgt(1);
-        final Sgt destinationSgt = new Sgt(2);
-        final Map<PolicyManagerImpl.ActionCase, ActionInDirection> actionMap = createActionMap();
-        final String classMapName = "unit-class-map-name-01";
+    public void testResolveRemovedChainAction_asymmetricChainOpposite() {
+        final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
+        parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
+        final ParameterValue parameterValue = parameterValueBuilder.build();
 
-        final String sfcNameValue = "123";
-        final ServiceFunctionPath sfcPath = createSfp(sfcNameValue, false);
-        final ServiceFunctionPaths sfcPaths = new ServiceFunctionPathsBuilder()
-                .setServiceFunctionPath(Collections.singletonList(sfcPath))
-                .build();
+        final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
+        pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
+                .setSymmetric(false);
+        final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
+        pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 
-        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(sfcPaths);
+        final PeerEndpoint peerEndpoint = peerEndpointBuilder();
+        final Action action = actionBuilder(Collections.singletonList(parameterValue));
 
-        final RenderedServicePath rsp = createRsp("unit-rsp-02");
-        stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(rsp);
+        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
+        stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(new TenantId(TENANT_ID));
 
-        policyConfigurationContext.setCurrentRendererEP(createRendererEP(
-                "unit-address", new ContextId("unit-conext-1"), Collections.emptyList())
-        );
+        ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
+                resolvedActionBuilder(CHAIN, action, In), policyWriter);
 
-        ServiceChainingUtil.resolveNewChainAction(peerEndpoint, sourceSgt, destinationSgt, actionMap, policyConfigurationContext, dataBroker);
+        verifyNoMoreInteractions(policyWriter);
+    }
 
-        Mockito.verifyNoMoreInteractions(policyWriter);
+    @Test
+    public void testResolveRemovedChainAction_asymmetricChainDirect() {
+        final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
+        parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
+        final ParameterValue parameterValue = parameterValueBuilder.build();
+        final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
+        pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
+                .setSymmetric(false);
+        final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
+        pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
+        final PeerEndpoint peerEndpoint = peerEndpointBuilder();
+        final Action action = actionBuilder(Collections.singletonList(parameterValue));
+        final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
+        hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
+        final List<RenderedServicePathHop> hops = Collections.singletonList(hopBuilder.build());
+        final ServiceFunctionForwarderBuilder forwarder = new ServiceFunctionForwarderBuilder();
+        forwarder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
+                .setIpMgmtAddress(new IpAddress(new Ipv4Address(IP_ADDRESS)));
+
+        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
+        stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder")).toReturn(forwarder.build());
+        stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(buildRsp(hops));
+        stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(new TenantId(TENANT_ID));
+
+        ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
+                resolvedActionBuilder(CHAIN, action, Out), policyWriter);
+
+        verify(policyWriter).cache(any(ClassMap.class));
+        verify(policyWriter).cache(any(Class.class));
+        verify(policyWriter).getManagementIpAddress();
+        verify(policyWriter).cache(any(ServiceChain.class));
+        verify(policyWriter).cache(any(ServiceFfName.class));
+        verifyNoMoreInteractions(policyWriter);
     }
 
     @Test
-    public void testResolveChainAction_partial04() throws Exception {
-        final PeerEndpoint peerEndpoint = createPeerEndpoint(null);
-        final Sgt sourceSgt = new Sgt(1);
-        final Sgt destinationSgt = new Sgt(2);
-        final Map<PolicyManagerImpl.ActionCase, ActionInDirection> actionMap = createActionMap(false);
-        final String classMapName = "unit-class-map-name-01";
+    public void testResolveRemovedChainAction_symmetricChainDirect() {
+        final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
+        parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
+        final ParameterValue parameterValue = parameterValueBuilder.build();
+        final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
+        pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
+                .setSymmetric(true);
+        final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
+        pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
+        final PeerEndpoint peerEndpoint = peerEndpointBuilder();
+        final Action action = actionBuilder(Collections.singletonList(parameterValue));
+        final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
+        hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
+        final List<RenderedServicePathHop> hops = Collections.singletonList(hopBuilder.build());
+        final ServiceFunctionForwarderBuilder forwarder = new ServiceFunctionForwarderBuilder();
+        forwarder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
+                .setIpMgmtAddress(new IpAddress(new Ipv4Address(IP_ADDRESS)));
+
+        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
+        stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder")).toReturn(forwarder.build());
+        stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(buildRsp(hops));
+        stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(new TenantId(TENANT_ID));
+
+        ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
+                resolvedActionBuilder(CHAIN, action, Out), policyWriter);
+
+        verify(policyWriter).cache(any(ClassMap.class));
+        verify(policyWriter).cache(any(Class.class));
+        verify(policyWriter).getManagementIpAddress();
+        verify(policyWriter).cache(any(ServiceChain.class));
+        verify(policyWriter).cache(any(ServiceFfName.class));
+        verifyNoMoreInteractions(policyWriter);
+    }
 
-        policyConfigurationContext.setCurrentRendererEP(createRendererEP(
-                "unit-address", new ContextId("unit-conext-1"), Collections.emptyList())
-        );
+    @Test
+    public void testResolveRemovedChainAction_symmetricChainReversed() {
+        final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
+        parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
+        final ParameterValue parameterValue = parameterValueBuilder.build();
+        final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
+        pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
+                .setSymmetric(true);
+        final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
+        pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
+        final PeerEndpoint peerEndpoint = peerEndpointBuilder();
+        final Action action = actionBuilder(Collections.singletonList(parameterValue));
+        final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
+        hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
+        final List<RenderedServicePathHop> hops = Collections.singletonList(hopBuilder.build());
+        final ServiceFunctionForwarderBuilder forwarder = new ServiceFunctionForwarderBuilder();
+        forwarder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
+                .setIpMgmtAddress(new IpAddress(new Ipv4Address(IP_ADDRESS)));
+
+        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
+        stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder")).toReturn(forwarder.build());
+        stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(buildRsp(hops));
+        stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(new TenantId(TENANT_ID));
+
+        ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
+                resolvedActionBuilder(CHAIN, action, In), policyWriter);
+
+        verify(policyWriter).cache(any(ClassMap.class));
+        verify(policyWriter).cache(any(Class.class));
+        verify(policyWriter).getManagementIpAddress();
+        verify(policyWriter).cache(any(ServiceChain.class));
+        verify(policyWriter).cache(any(ServiceFfName.class));
+        verifyNoMoreInteractions(policyWriter);
+    }
 
-        ServiceChainingUtil.resolveNewChainAction(peerEndpoint, sourceSgt, destinationSgt, actionMap, policyConfigurationContext, dataBroker);
+    @Test
+    public void testResolveRemoteSfcComponents_noForwarder() {
+        boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(buildRsp(null), policyWriter);
+        assertFalse(result);
+    }
 
-        Mockito.verifyNoMoreInteractions(policyWriter);
+    @Test
+    public void testResolveRemoteSfcComponents_noForwarderLocator() {
+        final ServiceFunctionForwarderBuilder forwarderBuilder = new ServiceFunctionForwarderBuilder();
+        forwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER));
+        final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
+        hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
+        final RenderedServicePathBuilder rspBuilder = new RenderedServicePathBuilder();
+        rspBuilder.setRenderedServicePathHop(Collections.singletonList(hopBuilder.build()));
+
+        stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder")).toReturn(forwarderBuilder.build());
+
+        boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(rspBuilder.build(), policyWriter);
+        assertFalse(result);
+        verifyZeroInteractions(policyWriter);
     }
 
-    private Map<PolicyManagerImpl.ActionCase, ActionInDirection> createActionMap() {
-        return createActionMap(true);
+    @Test
+    public void testResolveRemoteSfcComponents_dplWithoutLocatorType() {
+        final DataPlaneLocatorBuilder dplBuilder = new DataPlaneLocatorBuilder();
+        final SffDataPlaneLocatorBuilder sffDplBuilder = new SffDataPlaneLocatorBuilder();
+        sffDplBuilder.setDataPlaneLocator(dplBuilder.build());
+        final ServiceFunctionForwarderBuilder forwarderBuilder = new ServiceFunctionForwarderBuilder();
+        forwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
+                .setSffDataPlaneLocator(Collections.singletonList(sffDplBuilder.build()));
+        final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
+        hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
+        final RenderedServicePathBuilder rspBuilder = new RenderedServicePathBuilder();
+        rspBuilder.setRenderedServicePathHop(Collections.singletonList(hopBuilder.build()));
+
+        stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder")).toReturn(forwarderBuilder.build());
+
+        boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(rspBuilder.build(), policyWriter);
+        assertFalse(result);
+        verifyZeroInteractions(policyWriter);
     }
 
-    private Map<PolicyManagerImpl.ActionCase, ActionInDirection> createActionMap(final boolean fillParamValue) {
-        final Map<PolicyManagerImpl.ActionCase, ActionInDirection> actionMap = new HashMap<>();
-        final ActionBuilder actionValue = new ActionBuilder();
-        if (fillParamValue) {
-            actionValue.setParameterValue(Collections.singletonList(new ParameterValueBuilder()
-                    .setName(new ParameterName(ChainActionDefinition.SFC_CHAIN_NAME))
-                    .setStringValue("123")
-                    .build()));
-        }
-        ActionInDirection actionInDirection = new ActionInDirection(actionValue.build(),
-                EndpointPolicyParticipation.CONSUMER, HasDirection.Direction.Out);
-        actionMap.put(PolicyManagerImpl.ActionCase.CHAIN, actionInDirection);
-        return actionMap;
+    @Test
+    public void testResolveRemoteSfcComponents_dplWithoutIp() {
+        final DataPlaneLocatorBuilder dplBuilder = new DataPlaneLocatorBuilder();
+        dplBuilder.setLocatorType(new IpBuilder().build());
+        final SffDataPlaneLocatorBuilder sffDplBuilder = new SffDataPlaneLocatorBuilder();
+        sffDplBuilder.setDataPlaneLocator(dplBuilder.build());
+        final ServiceFunctionForwarderBuilder forwarderBuilder = new ServiceFunctionForwarderBuilder();
+        forwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
+                .setSffDataPlaneLocator(Collections.singletonList(sffDplBuilder.build()));
+        final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
+        hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
+        final RenderedServicePathBuilder rspBuilder = new RenderedServicePathBuilder();
+        rspBuilder.setRenderedServicePathHop(Collections.singletonList(hopBuilder.build()));
+
+        stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder")).toReturn(forwarderBuilder.build());
+
+        boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(rspBuilder.build(), policyWriter);
+        assertFalse(result);
+        verifyZeroInteractions(policyWriter);
     }
 
-    private RendererEndpoint createRendererEP(final String address, final ContextId contextId, final List<PeerEndpoint> peerEndpoints) {
-        return new RendererEndpointBuilder()
-                .setAddress(address)
-                .setAddressType(IpPrefixType.class)
-                .setContextId(contextId)
-                .setContextType(L3Context.class)
-                .setPeerEndpoint(peerEndpoints)
-                .build();
+    @Test
+    public void testResolveRemoteSfcComponents_sffWithoutMgmtAddress() {
+        final DataPlaneLocatorBuilder dplBuilder = new DataPlaneLocatorBuilder();
+        dplBuilder.setLocatorType(new IpBuilder().setIp(new IpAddress(new Ipv4Address(IP_ADDRESS))).build());
+        final SffDataPlaneLocatorBuilder sffDplBuilder = new SffDataPlaneLocatorBuilder();
+        sffDplBuilder.setDataPlaneLocator(dplBuilder.build());
+        final ServiceFunctionForwarderBuilder forwarderBuilder = new ServiceFunctionForwarderBuilder();
+        forwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
+                .setSffDataPlaneLocator(Collections.singletonList(sffDplBuilder.build()));
+        final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
+        hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
+        final RenderedServicePathBuilder rspBuilder = new RenderedServicePathBuilder();
+        rspBuilder.setRenderedServicePathHop(Collections.singletonList(hopBuilder.build()));
+
+        stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder")).toReturn(forwarderBuilder.build());
+
+        boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(rspBuilder.build(), policyWriter);
+        assertFalse(result);
+        verifyZeroInteractions(policyWriter);
     }
 
-    private PeerEndpoint createPeerEndpoint() {
-        return createPeerEndpoint(new TenantId("unit-tenant-06"));
+    @Test
+    public void testResolveRemoteSfcComponents_remoteCase() {
+        final DataPlaneLocatorBuilder dplBuilder = new DataPlaneLocatorBuilder();
+        dplBuilder.setLocatorType(new IpBuilder().setIp(new IpAddress(new Ipv4Address("190.1.1.12"))).build());
+        final SffDataPlaneLocatorBuilder sffDplBuilder = new SffDataPlaneLocatorBuilder();
+        sffDplBuilder.setDataPlaneLocator(dplBuilder.build());
+        final ServiceFunctionForwarderBuilder forwarderBuilder = new ServiceFunctionForwarderBuilder();
+        forwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
+                .setSffDataPlaneLocator(Collections.singletonList(sffDplBuilder.build()))
+                .setIpMgmtAddress(new IpAddress(new Ipv4Address(IP_ADDRESS)));
+        final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
+        hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
+        final RenderedServicePathBuilder rspBuilder = new RenderedServicePathBuilder();
+        rspBuilder.setRenderedServicePathHop(Collections.singletonList(hopBuilder.build()));
+
+        stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder")).toReturn(forwarderBuilder.build());
+
+        boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(rspBuilder.build(), policyWriter);
+        assertTrue(result);
+        verify(policyWriter).getManagementIpAddress();
+        verify(policyWriter).cache(any(ServiceChain.class));
+        verify(policyWriter).cache(any(ServiceFfName.class));
+        verifyNoMoreInteractions(policyWriter);
     }
 
-    private PeerEndpoint createPeerEndpoint(final TenantId tenantId) {
-        return new PeerEndpointBuilder()
-                .setRuleGroupWithRendererEndpointParticipation(Collections.singletonList(
-                        new RuleGroupWithRendererEndpointParticipationBuilder()
-                                .setTenantId(tenantId)
-                                .build()
-                ))
-                .build();
+    @Test
+    public void testFindServicePathFromParameterValues_noParams() {
+        final ServiceFunctionPath result = ServiceChainingUtil.findServicePathFromParameterValues(Collections.emptyList());
+        assertNull(result);
     }
 
     @Test
-    public void testCreateRenderedPath() throws Exception {
-        final String sfcNameValue = "123";
-        final ServiceFunctionPath sfp = createSfp(sfcNameValue, false);
-        final TenantId tenantId = new TenantId("unit-tennant-01");
+    public void testFindServicePathFromParameterValues_differentActionDefinition() {
+        final ParameterValueBuilder noNamePVBuilder = new ParameterValueBuilder();
+        final ParameterValue noNamePV = noNamePVBuilder.build();
+        final ParameterValueBuilder intValuePMBuilder = new ParameterValueBuilder();
+        String PARAMETER_VALUE_1 = "parameter-value-1";
+        intValuePMBuilder.setName(new ParameterName(PARAMETER_VALUE_1))
+                .setIntValue(1L);
+        final ParameterValue intValuePV = intValuePMBuilder.build();
+        final ParameterValueBuilder stringValuePVBuilder = new ParameterValueBuilder();
+        String PARAMETER_VALUE_2 = "parameter-value-2";
+        stringValuePVBuilder.setName(new ParameterName(PARAMETER_VALUE_2))
+                .setStringValue(PARAMETER_VALUE_2);
+        final ParameterValue stringValuePV = stringValuePVBuilder.build();
+        final List<ParameterValue> parameterValues = new ArrayList<>();
+        parameterValues.add(noNamePV);
+        parameterValues.add(intValuePV);
+        parameterValues.add(stringValuePV);
+        final ServiceFunctionPath result = ServiceChainingUtil.findServicePathFromParameterValues(parameterValues);
+        assertNull(result);
+    }
 
-        final RenderedServicePath rsp = createRsp("unit-rsp-01");
+    @Test
+    public void testFindServicePathFromParameterValues_noPathFound() {
+        final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
+        parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME))
+                .setStringValue(SFC_CHAIN_NAME);
+        final List<ParameterValue> parameterValues = Collections.singletonList(parameterValueBuilder.build());
+        final ServiceFunctionPathsBuilder serviceFunctionPathsBuilder = new ServiceFunctionPathsBuilder();
+        final ServiceFunctionPaths serviceFunctionPaths = serviceFunctionPathsBuilder.build();
+
+        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(serviceFunctionPaths);
+
+        final ServiceFunctionPath result = ServiceChainingUtil.findServicePathFromParameterValues(parameterValues);
+        assertNull(result);
+    }
 
-        PowerMockito.mockStatic(SfcProviderRenderedPathAPI.class);
-        final SfcProviderRenderedPathAPI api = PowerMockito.mock(SfcProviderRenderedPathAPI.class);
-        PowerMockito.when(api.readRenderedServicePath(rspNameCaptor.capture())).thenReturn(rsp);
+    @Test
+    public void testFindServicePathFromParameterValues() {
+        final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
+        parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME))
+                .setStringValue(SFC_CHAIN_NAME);
+        final List<ParameterValue> parameterValues = Collections.singletonList(parameterValueBuilder.build());
+        final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
+        serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME));
+        final ServiceFunctionPathsBuilder serviceFunctionPathsBuilder = new ServiceFunctionPathsBuilder();
+        serviceFunctionPathsBuilder.setServiceFunctionPath(Collections.singletonList(serviceFunctionPathBuilder.build()));
+        final ServiceFunctionPaths serviceFunctionPaths = serviceFunctionPathsBuilder.build();
+
+        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(serviceFunctionPaths);
+
+        final ServiceFunctionPath result = ServiceChainingUtil.findServicePathFromParameterValues(parameterValues);
+        assertNotNull(result);
+    }
 
-        final RenderedServicePath renderedPath = ServiceChainingUtil.createRenderedPath(sfp, tenantId, dataBroker);
+    @Test
+    public void findServiceFunctionPathFromServiceChainName_noPaths() {
+        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(null);
 
-        Assert.assertEquals("123_plain-unit-tennant-01-gbp-rsp", rspNameCaptor.getValue().getValue());
-        Assert.assertEquals(rsp, renderedPath);
+        final ServiceFunctionPath result = ServiceChainingUtil.findServiceFunctionPathFromServiceChainName(new SfcName(SFC_CHAIN_NAME));
+        assertNull(result);
     }
 
     @Test
-    public void testCreateRenderedPath_notExisting() throws Exception {
-        final String sfcNameValue = "123";
-        final ServiceFunctionPath sfp = createSfp(sfcNameValue, false);
-        final TenantId tenantId = new TenantId("unit-tennant-01");
+    public void findServiceFunctionPathFromServiceChainName_noPathFound() {
+        final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
+        final ServiceFunctionPathsBuilder serviceFunctionPathsBuilder = new ServiceFunctionPathsBuilder();
+        serviceFunctionPathsBuilder.setServiceFunctionPath(Collections.singletonList(serviceFunctionPathBuilder.build()));
 
-        final RenderedServicePath rsp = createRsp("unit-rsp-01");
+        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(serviceFunctionPathsBuilder.build());
 
-        PowerMockito.mockStatic(SfcProviderRenderedPathAPI.class);
-        final SfcProviderRenderedPathAPI api = PowerMockito.mock(SfcProviderRenderedPathAPI.class);
-        PowerMockito.when(api.readRenderedServicePath(rspNameCaptor.capture())).thenReturn(null);
-        PowerMockito.when(api.createRenderedServicePathAndState(
-                sfpCaptor.capture(), createRspCaptor.capture()
-        )).thenReturn(rsp);
-        PowerMockito.mockStatic(NetconfTransactionCreator.class);
-        final NetconfTransactionCreator creator = PowerMockito.mock(NetconfTransactionCreator.class);
-        PowerMockito.when(creator.netconfReadWriteTransaction(dataBroker)).thenReturn(java.util.Optional.empty());
+        final ServiceFunctionPath result = ServiceChainingUtil.findServiceFunctionPathFromServiceChainName(new SfcName(SFC_CHAIN_NAME));
+        assertNull(result);
+    }
 
-        final RenderedServicePath renderedPath = ServiceChainingUtil.createRenderedPath(sfp, tenantId, dataBroker);
+    @Test
+    public void findServiceFunctionPathFromServiceChainName_pathFound() {
+        final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
+        serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME))
+                .setServiceChainName(new SfcName(SFC_CHAIN_NAME));
+        final ServiceFunctionPathsBuilder serviceFunctionPathsBuilder = new ServiceFunctionPathsBuilder();
+        serviceFunctionPathsBuilder.setServiceFunctionPath(Collections.singletonList(serviceFunctionPathBuilder.build()));
 
-        Assert.assertEquals("123_plain-unit-tennant-01-gbp-rsp", rspNameCaptor.getValue().getValue());
+        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(serviceFunctionPathsBuilder.build());
 
-        final ServiceFunctionPath serviceFunctionPath = sfpCaptor.getValue();
-        Assert.assertEquals("123_plain", serviceFunctionPath.getName().getValue());
-        Assert.assertFalse(serviceFunctionPath.isSymmetric());
+        final ServiceFunctionPath result = ServiceChainingUtil.findServiceFunctionPathFromServiceChainName(new SfcName(SFC_CHAIN_NAME));
+        assertNotNull(result);
+    }
+
+    @Test
+    public void testCreateRenderedPath_renderedPathFound() {
+        final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
+        serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME))
+                .setSymmetric(true);
+        final ServiceFunctionPath serviceFunctionPath = serviceFunctionPathBuilder.build();
+        final TenantId tenantId = new TenantId(TENANT_ID);
 
-        final CreateRenderedPathInput createRPInput = createRspCaptor.getValue();
-        Assert.assertFalse(createRPInput.isSymmetric());
-        Assert.assertEquals("123_plain", createRPInput.getParentServiceFunctionPath());
-        Assert.assertEquals("123_plain-unit-tennant-01-gbp-rsp", createRPInput.getName());
+        stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(new RenderedServicePathBuilder().build());
 
-        Assert.assertEquals(rsp, renderedPath);
+        final RenderedServicePath result = ServiceChainingUtil.createRenderedPath(serviceFunctionPath, tenantId, dataBroker);
+        assertNotNull(result);
     }
 
-    private RenderedServicePath createRsp(final String rspNameValue) {
-        return new RenderedServicePathBuilder()
-                .setName(new RspName(rspNameValue))
-                .setRenderedServicePathHop(Lists.newArrayList(createRspHop("rsp-hop-01-sf")))
-                .build();
+    @Test
+    public void testCreateRenderedPath_renderedPathCreated() {
+        ServiceChainingUtil.setTimeout(1L);
+        final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
+        serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME))
+                .setSymmetric(true);
+        final ServiceFunctionPath serviceFunctionPath = serviceFunctionPathBuilder.build();
+        final TenantId tenantId = new TenantId(TENANT_ID);
+
+        stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(null);
+        stub(method(SfcProviderRenderedPathAPI.class, "createRenderedServicePathAndState", ServiceFunctionPath.class,
+                CreateRenderedPathInput.class)).toReturn(new RenderedServicePathBuilder().build());
+
+        final RenderedServicePath result = ServiceChainingUtil.createRenderedPath(serviceFunctionPath, tenantId, dataBroker);
+        assertNotNull(result);
     }
 
-    private RenderedServicePathHop createRspHop(final String sfNameValue) {
-        return new RenderedServicePathHopBuilder()
-                .setServiceFunctionName(new SfName(sfNameValue))
-                .setServiceFunctionForwarder(new SffName(sfNameValue + "+sff"))
-                .build();
+    @Test
+    public void testCreateReversedRenderedPath_renderedPathFound() {
+        final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
+        serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME))
+                .setSymmetric(true);
+        final ServiceFunctionPath serviceFunctionPath = serviceFunctionPathBuilder.build();
+        final TenantId tenantId = new TenantId(TENANT_ID);
+
+        stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(new RenderedServicePathBuilder().build());
+
+        final RenderedServicePath result = ServiceChainingUtil.createReversedRenderedPath(serviceFunctionPath, null,
+                tenantId, dataBroker);
+        assertNotNull(result);
     }
 
-    private ServiceFunctionPath createSfp(final String sfcNameValue, final boolean symmetric) {
-        return new ServiceFunctionPathBuilder()
-                .setServiceChainName(new SfcName(sfcNameValue))
-                .setName(new SfpName(sfcNameValue + "_plain"))
-                .setSymmetric(symmetric)
+    @Test
+    public void testCreateReversedRenderedPath_renderedPathCreated() {
+        ServiceChainingUtil.setTimeout(1L);
+        final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
+        serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME))
+                .setSymmetric(true);
+        final ServiceFunctionPath serviceFunctionPath = serviceFunctionPathBuilder.build();
+        final TenantId tenantId = new TenantId(TENANT_ID);
+        final RenderedServicePath renderedServicePath = new RenderedServicePathBuilder().build();
+
+        stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(null);
+        stub(method(SfcProviderRenderedPathAPI.class, "createReverseRenderedServicePathEntry"))
+                .toReturn(new RenderedServicePathBuilder().build());
+
+        final RenderedServicePath result = ServiceChainingUtil.createReversedRenderedPath(serviceFunctionPath, renderedServicePath,
+                tenantId, dataBroker);
+        assertNotNull(result);
+    }
+
+    @Test
+    public void testCreateRemoteForwarder() {
+        final ServiceFfNameBuilder serviceFfNameBuilder = new ServiceFfNameBuilder();
+        serviceFfNameBuilder.setName(SERVICE_FUNCTION_FORWARDER)
+                .setKey(new ServiceFfNameKey(SERVICE_FUNCTION_FORWARDER));
+        final ServiceFfName testForwarder = serviceFfNameBuilder.build();
+        final ServiceFunctionForwarderBuilder serviceFunctionForwarderBuilder = new ServiceFunctionForwarderBuilder();
+        serviceFunctionForwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
+                .setKey(new ServiceFunctionForwarderKey(new SffName(SERVICE_FUNCTION_FORWARDER)));
+        final ServiceFfName result = ServiceChainingUtil.createRemoteForwarder(serviceFunctionForwarderBuilder.build());
+        assertEquals(testForwarder, result);
+    }
+
+
+    @Test
+    public void testGetServicePath() throws Exception {
+        final String sfcNameValue = "123";
+        final ServiceFunctionPath sfcPath = createSfp(sfcNameValue);
+        final ServiceFunctionPaths sfcPaths = new ServiceFunctionPathsBuilder()
+                .setServiceFunctionPath(Collections.singletonList(sfcPath))
                 .build();
+
+        stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(sfcPaths);
+
+        final ServiceFunctionPath servicePath = ServiceChainingUtil.findServicePathFromParameterValues(Lists.newArrayList(
+                createParameterValue(sfcNameValue)
+        ));
+        assertEquals(sfcPath, servicePath);
+    }
+
+    private ParameterValue createParameterValue(final String value) {
+        return new ParameterValueBuilder().setName(new ParameterName("sfc-chain-name")).setStringValue(value).build();
     }
 
     @Test
-    public void testCreateSymmetricRenderedPath() throws Exception {
-        final ServiceFunctionPath sfp = createSfp("unit-sfp-02", false);
-        final RenderedServicePath rsp = createRsp("unit-rsp-02");
-        final TenantId tennantId = new TenantId("tenant-02");
+    public void testCreateRenderedPath() throws Exception {
+        final String sfcNameValue = "123";
+        final ServiceFunctionPath sfp = createSfp(sfcNameValue);
+        final TenantId tenantId = new TenantId("unit-tenant-01");
+
+        final RenderedServicePath rsp = createRsp("unit-rsp-01");
 
         PowerMockito.mockStatic(SfcProviderRenderedPathAPI.class);
-        final SfcProviderRenderedPathAPI api = PowerMockito.mock(SfcProviderRenderedPathAPI.class);
-        PowerMockito.when(api.readRenderedServicePath(rspNameCaptor.capture())).thenReturn(rsp);
+        PowerMockito.when(SfcProviderRenderedPathAPI.readRenderedServicePath(rspNameCaptor.capture())).thenReturn(rsp);
 
-        final RenderedServicePath symmetricRenderedPath = ServiceChainingUtil.createReversedRenderedPath(sfp, rsp, tennantId, dataBroker);
+        final RenderedServicePath renderedPath = ServiceChainingUtil.createRenderedPath(sfp, tenantId, dataBroker);
 
-        Assert.assertEquals("unit-sfp-02_plain-tenant-02-gbp-rsp-Reverse", rspNameCaptor.getValue().getValue());
-        Assert.assertEquals(rsp, symmetricRenderedPath);
+        assertEquals("123_plain-unit-tenant-01-gbp-rsp", rspNameCaptor.getValue().getValue());
+        assertEquals(rsp, renderedPath);
     }
 
     @Test
-    public void testCreateSymmetricRenderedPath_notExisting() throws Exception {
-        final ServiceFunctionPath sfp = createSfp("unit-sfp-02", false);
+    public void testCreateSymmetricRenderedPath() throws Exception {
+        final ServiceFunctionPath sfp = createSfp("unit-sfp-02");
         final RenderedServicePath rsp = createRsp("unit-rsp-02");
-        final TenantId tennantId = new TenantId("tenant-02");
+        final TenantId tenantId = new TenantId("tenant-02");
 
         PowerMockito.mockStatic(SfcProviderRenderedPathAPI.class);
-        final SfcProviderRenderedPathAPI api = PowerMockito.mock(SfcProviderRenderedPathAPI.class);
-        PowerMockito.when(api.readRenderedServicePath(rspNameCaptor.capture())).thenReturn(null);
-        PowerMockito.when(api.createReverseRenderedServicePathEntry(rspCaptor.capture())).thenReturn(rsp);
-        PowerMockito.mockStatic(NetconfTransactionCreator.class);
-        final NetconfTransactionCreator creator = PowerMockito.mock(NetconfTransactionCreator.class);
-        PowerMockito.when(creator.netconfReadWriteTransaction(dataBroker)).thenReturn(java.util.Optional.empty());
+        PowerMockito.when(SfcProviderRenderedPathAPI.readRenderedServicePath(rspNameCaptor.capture())).thenReturn(rsp);
 
-        final RenderedServicePath symmetricRenderedPath = ServiceChainingUtil.createReversedRenderedPath(sfp, rsp, tennantId, dataBroker);
+        final RenderedServicePath symmetricRenderedPath = ServiceChainingUtil.createReversedRenderedPath(sfp, rsp, tenantId, dataBroker);
 
-        Assert.assertEquals("unit-sfp-02_plain-tenant-02-gbp-rsp-Reverse", rspNameCaptor.getValue().getValue());
-        Assert.assertEquals(rsp, rspCaptor.getValue());
-        Assert.assertEquals(rsp, symmetricRenderedPath);
+        assertEquals("unit-sfp-02_plain-tenant-02-gbp-rsp-Reverse", rspNameCaptor.getValue().getValue());
+        assertEquals(rsp, symmetricRenderedPath);
     }
 
     @Test
     public void testFindServiceFunctionPath() throws Exception {
         final String sfcNameValue = "123";
-        final ServiceFunctionPath sfcPath = createSfp(sfcNameValue, false);
+        final ServiceFunctionPath sfcPath = createSfp(sfcNameValue);
         final ServiceFunctionPaths sfcPaths = new ServiceFunctionPathsBuilder()
                 .setServiceFunctionPath(Collections.singletonList(sfcPath))
                 .build();
@@ -489,16 +809,69 @@ public class ServiceChainingUtilTest {
         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(sfcPaths);
 
         final ServiceFunctionPath servicePath = ServiceChainingUtil.findServiceFunctionPathFromServiceChainName(new SfcName(sfcNameValue));
-        Assert.assertEquals(sfcPath, servicePath);
+        assertEquals(sfcPath, servicePath);
     }
 
-    @Test
-    public void testForwarderTypeChoice() throws Exception {
-        final String sffValue = "unit-xx";
-        final ServiceTypeChoice fwChoice = ServiceChainingUtil.createForwarderTypeChoice(sffValue);
+    // Auxiliary methods
+
+    private RenderedServicePath buildRsp(List<RenderedServicePathHop> hop) {
+        RenderedServicePathBuilder renderedServicePathBuilder = new RenderedServicePathBuilder();
+        renderedServicePathBuilder.setRenderedServicePathHop(hop);
+        return renderedServicePathBuilder.build();
+    }
+
+    private RenderedServicePath createRsp(final String rspNameValue) {
+        return new RenderedServicePathBuilder()
+                .setName(new RspName(rspNameValue))
+                .setRenderedServicePathHop(Lists.newArrayList(createRspHop()))
+                .build();
+    }
+
+    private RenderedServicePathHop createRspHop() {
+        return new RenderedServicePathHopBuilder()
+                .setServiceFunctionName(new SfName("rsp-hop-01-sf"))
+                .setServiceFunctionForwarder(new SffName("rsp-hop-01-sf" + "+sff"))
+                .build();
+    }
+
+    private ServiceFunctionPath createSfp(final String sfcNameValue) {
+        return new ServiceFunctionPathBuilder()
+                .setServiceChainName(new SfcName(sfcNameValue))
+                .setName(new SfpName(sfcNameValue + "_plain"))
+                .setSymmetric(false)
+                .build();
+    }
+
+    private PeerEndpoint peerEndpointBuilder() {
+        final PeerEndpointBuilder peerEndpointBuilder = new PeerEndpointBuilder();
+        final RuleGroupWithRendererEndpointParticipationBuilder ruleGroupBuilder =
+                new RuleGroupWithRendererEndpointParticipationBuilder();
+        peerEndpointBuilder.setRuleGroupWithRendererEndpointParticipation(Collections.singletonList(ruleGroupBuilder.build()));
+        return peerEndpointBuilder.build();
+    }
+
+    private Map<ActionCase, ActionInDirection> resolvedActionBuilder(@Nonnull final ActionCase actionCase,
+                                                                     @Nonnull final Action action,
+                                                                     @Nonnull final Direction direction) {
+        final ActionInDirection actionInDirection = new ActionInDirection(action, PROVIDER, direction);
+        return Collections.singletonMap(actionCase, actionInDirection);
+    }
+
+    private PolicyConfigurationContext policyConfigurationContextBuilder() {
+        final RendererEndpointBuilder rendererEndpointBuilder = new RendererEndpointBuilder();
+        final PolicyConfigurationContext context = new PolicyConfigurationContext();
+        context.setPolicyWriter(policyWriter);
+        context.setCurrentRendererEP(rendererEndpointBuilder.build());
+        return context;
+    }
+
+    private Sgt sgtBuilder(final int value) {
+        return new Sgt(value);
+    }
 
-        Assert.assertTrue(fwChoice instanceof ServiceFunctionForwarder);
-        final ServiceFunctionForwarder sff = (ServiceFunctionForwarder) fwChoice;
-        Assert.assertEquals(sffValue, sff.getServiceFunctionForwarder());
+    private Action actionBuilder(final List<ParameterValue> parameters) {
+        final ActionBuilder actionBuilder = new ActionBuilder();
+        actionBuilder.setParameterValue(parameters);
+        return actionBuilder.build();
     }
 }
\ No newline at end of file