renderers/ios-xe/src/test/java/org/opendaylight/groupbasedpolicy/renderer/ios_xe_provider/impl/util/ServiceChainingUtilTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.util;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertFalse;
  13 import static org.junit.Assert.assertNotNull;
  14 import static org.junit.Assert.assertNull;
  15 import static org.junit.Assert.assertTrue;
  16 import static org.mockito.Matchers.any;
  17 import static org.mockito.Mockito.mock;
  18 import static org.mockito.Mockito.times;
  19 import static org.mockito.Mockito.verifyNoMoreInteractions;
  20 import static org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.PolicyManagerImpl.ActionCase.ALLOW;
  21 import static org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.PolicyManagerImpl.ActionCase.CHAIN;
  22 import static org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection.Direction.In;
  23 import static org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection.Direction.Out;
  24 import static org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.EndpointPolicyParticipation.PROVIDER;
  25 import static org.powermock.api.mockito.PowerMockito.verifyStatic;
  26 import static org.powermock.api.support.membermodification.MemberMatcher.method;
  27 import static org.powermock.api.support.membermodification.MemberModifier.stub;
  28
  29 import javax.annotation.Nonnull;
  30 import java.util.ArrayList;
  31 import java.util.Collections;
  32 import java.util.List;
  33 import java.util.Map;
  34 import com.google.common.collect.Lists;
  35 import org.junit.Before;
  36 import org.junit.Test;
  37 import org.junit.runner.RunWith;
  38 import org.mockito.ArgumentCaptor;
  39 import org.mockito.Captor;
  40 import org.mockito.Mock;
  41 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  42 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  43 import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.PolicyConfigurationContext;
  44 import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.PolicyManagerImpl;
  45 import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.PolicyManagerImpl.ActionCase;
  46 import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.util.PolicyManagerUtil.ActionInDirection;
  47 import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.writer.PolicyWriterUtil;
  48 import org.opendaylight.sfc.provider.api.SfcProviderRenderedPathAPI;
  49 import org.opendaylight.sfc.provider.api.SfcProviderServiceForwarderAPI;
  50 import org.opendaylight.sfc.provider.api.SfcProviderServicePathAPI;
  51 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.common.rev151017.RspName;
  52 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.common.rev151017.SfName;
  53 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.common.rev151017.SfcName;
  54 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.common.rev151017.SffName;
  55 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.common.rev151017.SfpName;
  56 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.rsp.rev140701.CreateRenderedPathInput;
  57 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.rsp.rev140701.rendered.service.paths.RenderedServicePath;
  58 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.rsp.rev140701.rendered.service.paths.RenderedServicePathBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.rsp.rev140701.rendered.service.paths.rendered.service.path.RenderedServicePathHop;
  60 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.rsp.rev140701.rendered.service.paths.rendered.service.path.RenderedServicePathHopBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarder.base.SffDataPlaneLocatorBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarder.base.sff.data.plane.locator.DataPlaneLocatorBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.ServiceFunctionForwarderBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.ServiceFunctionForwarderKey;
  65 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev140701.ServiceFunctionPaths;
  66 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev140701.ServiceFunctionPathsBuilder;
  67 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev140701.service.function.paths.ServiceFunctionPath;
  68 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev140701.service.function.paths.ServiceFunctionPathBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sl.rev140701.data.plane.locator.locator.type.IpBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  71 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  72 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ClassMap;
  73 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.ServiceChain;
  74 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.policy.map.Class;
  75 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.ServiceFfName;
  76 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.ServiceFfNameBuilder;
  77 import org.opendaylight.yang.gen.v1.urn.ios.rev160308._native.service.chain.service.function.forwarder.ServiceFfNameKey;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection.Direction;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValueBuilder;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.rule.group.with.renderer.endpoint.participation.RuleGroupWithRendererEndpointParticipationBuilder;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.RendererEndpointBuilder;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerEndpoint;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.endpoints.renderer.endpoint.PeerEndpointBuilder;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.actions.Action;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.actions.ActionBuilder;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
  91 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  92 import org.powermock.api.mockito.PowerMockito;
  93 import org.powermock.core.classloader.annotations.PrepareForTest;
  94 import org.powermock.modules.junit4.PowerMockRunner;
  95
  96 /**
  97  * Test for {@link ServiceChainingUtil}.
  98  */
  99 @RunWith(PowerMockRunner.class)
 100 @PrepareForTest({
 101         SfcProviderServiceForwarderAPI.class,
 102         SfcProviderServicePathAPI.class,
 103         SfcProviderRenderedPathAPI.class,
 104         PolicyManagerUtil.class,
 105         PolicyWriterUtil.class
 106 })
 107 public class ServiceChainingUtilTest {
 108
 109     private final String SFC_CHAIN_NAME = "sfc-chain-name";
 110     private final String SFC_PATH_NAME = "sfc-path-name";
 111     private final String TENANT_ID = "tenant-id";
 112     private final String IP_ADDRESS = "170.0.0.1";
 113     private final String SERVICE_FUNCTION_FORWARDER = "service-function-forwarder";
 114     private final RuleName RULE_NAME = new RuleName("rule-name");
 115
 116     private DataBroker dataBroker;
 117     private PolicyWriterUtil policyWriterUtil;
 118
 119
 120     @Captor
 121     private ArgumentCaptor<RspName> rspNameCaptor;
 122     @Captor
 123     private ArgumentCaptor<SffName> sffNameCaptor;
 124     @Captor
 125     private ArgumentCaptor<ServiceFunctionPath> sfpCaptor;
 126     @Captor
 127     private ArgumentCaptor<CreateRenderedPathInput> createRspCaptor;
 128     @Captor
 129     private ArgumentCaptor<RenderedServicePath> rspCaptor;
 130     @Captor
 131     private ArgumentCaptor<Class> listClassCaptor;
 132     @Captor
 133     private ArgumentCaptor<ClassMap> classMapCaptor;
 134     @Mock
 135     private ReadWriteTransaction rwTx;
 136
 137     @Before
 138     public void setUp() {
 139         dataBroker = mock(DataBroker.class);
 140         policyWriterUtil = mock(PolicyWriterUtil.class);
 141     }
 142
 143     @Test
 144     public void testResolveNewChainAction_actionAllow() {
 145         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 146         final Action action = actionBuilder(null);
 147         final PolicyConfigurationContext context = policyConfigurationContextBuilder();
 148
 149         ServiceChainingUtil.newChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 150                 resolvedActionBuilder(RULE_NAME, ALLOW, action, In), context, dataBroker);
 151
 152         verifyNoMoreInteractions(policyWriterUtil);
 153         verifyNoMoreInteractions(dataBroker);
 154     }
 155
 156     @Test
 157     public void testResolveNewChainAction_noParameterValue() {
 158         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 159         final Action action = actionBuilder(null);
 160         final PolicyConfigurationContext context = policyConfigurationContextBuilder();
 161
 162         ServiceChainingUtil.newChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 163                 resolvedActionBuilder(RULE_NAME, CHAIN, action, In), context, dataBroker);
 164
 165         verifyNoMoreInteractions(policyWriterUtil);
 166         verifyNoMoreInteractions(dataBroker);
 167     }
 168
 169     @Test
 170     public void testResolveNewChainAction_noTenantId() {
 171         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 172         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 173         final ParameterValue parameterValue = parameterValueBuilder.build();
 174
 175         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 176         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME));
 177         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 178         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 179
 180         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 181         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 182         final PolicyConfigurationContext context = policyConfigurationContextBuilder();
 183
 184         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths"))
 185             .toReturn(pathsBuilder.build());
 186         stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(null);
 187
 188         ServiceChainingUtil.newChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 189                 resolvedActionBuilder(RULE_NAME, CHAIN, action, In), context, dataBroker);
 190
 191         verifyNoMoreInteractions(policyWriterUtil);
 192         verifyNoMoreInteractions(dataBroker);
 193     }
 194
 195     @Test
 196     public void testResolveNewChainAction_asymmetricChainOpposite() {
 197         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 198         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 199         final ParameterValue parameterValue = parameterValueBuilder.build();
 200
 201         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 202         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
 203                 .setSymmetric(false);
 204         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 205         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 206
 207         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 208         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 209         final PolicyConfigurationContext context = policyConfigurationContextBuilder();
 210
 211         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 212         stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(new TenantId(TENANT_ID));
 213
 214         ServiceChainingUtil.newChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 215                 resolvedActionBuilder(RULE_NAME, CHAIN, action, In), context, dataBroker);
 216
 217         verifyNoMoreInteractions(policyWriterUtil);
 218         verifyNoMoreInteractions(dataBroker);
 219     }
 220
 221     @Test
 222     public void testResolveNewChainAction_asymmetricChain() {
 223         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 224         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 225         final ParameterValue parameterValue = parameterValueBuilder.build();
 226
 227         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 228         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
 229                 .setSymmetric(false);
 230         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 231         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 232
 233         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 234         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 235         final PolicyConfigurationContext context = policyConfigurationContextBuilder();
 236
 237         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 238         stub(method(PolicyWriterUtil.class, "writeClassMap")).toReturn(true);
 239         stub(method(PolicyWriterUtil.class, "writePolicyMapEntry")).toReturn(true);
 240
 241         ServiceChainingUtil.newChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 242                 resolvedActionBuilder(RULE_NAME, CHAIN, action, Out), context, dataBroker);
 243
 244         verifyStatic(times(1));
 245         PolicyWriterUtil.writeClassMap(any(ClassMap.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 246         PolicyWriterUtil.writePolicyMapEntry(any(Class.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 247     }
 248
 249     @Test
 250     public void testResolveNewChainAction_symmetricChainDirect() {
 251         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 252         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 253         final ParameterValue parameterValue = parameterValueBuilder.build();
 254
 255         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 256         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
 257                 .setSymmetric(true);
 258         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 259         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 260
 261         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 262         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 263         final PolicyConfigurationContext context = policyConfigurationContextBuilder();
 264
 265         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 266         stub(method(PolicyWriterUtil.class, "writeClassMap")).toReturn(true);
 267         stub(method(PolicyWriterUtil.class, "writePolicyMapEntry")).toReturn(true);
 268
 269         ServiceChainingUtil.newChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 270                 resolvedActionBuilder(RULE_NAME, CHAIN, action, Out), context, dataBroker);
 271
 272         verifyStatic(times(1));
 273         PolicyWriterUtil.writeClassMap(any(ClassMap.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 274         PolicyWriterUtil.writePolicyMapEntry(any(Class.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 275     }
 276
 277     @Test
 278     public void testResolveNewChainAction_symmetricChainReversed() {
 279         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 280         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 281         final ParameterValue parameterValue = parameterValueBuilder.build();
 282
 283         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 284         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
 285                 .setSymmetric(true);
 286         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 287         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 288
 289         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 290         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 291         final PolicyConfigurationContext context = policyConfigurationContextBuilder();
 292
 293         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 294         stub(method(PolicyWriterUtil.class, "writeClassMap")).toReturn(true);
 295         stub(method(PolicyWriterUtil.class, "writePolicyMapEntry")).toReturn(true);
 296
 297         ServiceChainingUtil.newChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 298                 resolvedActionBuilder(RULE_NAME, CHAIN, action, In), context, dataBroker);
 299
 300         verifyStatic(times(1));
 301         PolicyWriterUtil.writeClassMap(any(ClassMap.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 302         PolicyWriterUtil.writePolicyMapEntry(any(Class.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 303     }
 304
 305     @Test
 306     public void testResolveRemovedChainAction_noParameterValue() {
 307         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 308         context.setPolicyMapLocation(getLocation());
 309         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 310         final Action action = actionBuilder(null);
 311
 312         ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 313                 resolvedActionBuilder(new RuleName("rule-name"), CHAIN, action, In), context);
 314
 315         verifyNoMoreInteractions(policyWriterUtil);
 316     }
 317
 318     @Test
 319     public void testResolveRemovedChainAction_noTenantId() {
 320         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 321         context.setPolicyMapLocation(getLocation());
 322         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 323         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 324         final ParameterValue parameterValue = parameterValueBuilder.build();
 325
 326         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 327         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME));
 328         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 329         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 330
 331         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 332         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 333
 334         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 335         stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(null);
 336
 337         ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 338                 resolvedActionBuilder(new RuleName("rule-name"), CHAIN, action, In), context);
 339
 340         verifyNoMoreInteractions(policyWriterUtil);
 341     }
 342
 343     @Test
 344     public void testResolveRemovedChainAction_asymmetricChainOpposite() {
 345         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 346         context.setPolicyMapLocation(getLocation());
 347         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 348         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 349         final ParameterValue parameterValue = parameterValueBuilder.build();
 350
 351         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 352         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
 353                 .setSymmetric(false);
 354         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 355         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 356
 357         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 358         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 359
 360         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 361         stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(new TenantId(TENANT_ID));
 362
 363         ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 364                 resolvedActionBuilder(new RuleName("rule-name"), CHAIN, action, In), context);
 365
 366         verifyNoMoreInteractions(policyWriterUtil);
 367     }
 368
 369     @Test
 370     public void testResolveRemovedChainAction_asymmetricChainDirect() {
 371         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 372         context.setPolicyMapLocation(getLocation());
 373         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 374         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 375         final ParameterValue parameterValue = parameterValueBuilder.build();
 376         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 377         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
 378                 .setSymmetric(false);
 379         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 380         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 381         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 382         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 383         final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
 384         hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
 385         final ServiceFunctionForwarderBuilder forwarder = new ServiceFunctionForwarderBuilder();
 386         forwarder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
 387                 .setIpMgmtAddress(new IpAddress(new Ipv4Address(IP_ADDRESS)));
 388
 389         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 390         stub(method(PolicyWriterUtil.class, "removeClassMap")).toReturn(true);
 391         stub(method(PolicyWriterUtil.class, "removePolicyMapEntry")).toReturn(true);
 392         stub(method(PolicyWriterUtil.class, "removeServicePath")).toReturn(true);
 393         stub(method(PolicyWriterUtil.class, "removeRemote")).toReturn(true);
 394
 395         ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 396                 resolvedActionBuilder(new RuleName("rule-name"), CHAIN, action, Out), context);
 397
 398         verifyStatic(times(1));
 399         PolicyWriterUtil.removeClassMap(any(ClassMap.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 400         PolicyWriterUtil.removePolicyMapEntry(any(Class.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 401         PolicyWriterUtil.removeServicePath(any(ServiceChain.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 402         PolicyWriterUtil.removeRemote(any(ServiceFfName.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 403     }
 404
 405     @Test
 406     public void testResolveRemovedChainAction_symmetricChainDirect() {
 407         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 408         context.setPolicyMapLocation(getLocation());
 409         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 410         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 411         final ParameterValue parameterValue = parameterValueBuilder.build();
 412         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 413         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
 414                 .setSymmetric(true);
 415         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 416         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 417         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 418         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 419         final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
 420         hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
 421         final ServiceFunctionForwarderBuilder forwarder = new ServiceFunctionForwarderBuilder();
 422         forwarder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
 423                 .setIpMgmtAddress(new IpAddress(new Ipv4Address(IP_ADDRESS)));
 424
 425         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 426         stub(method(PolicyWriterUtil.class, "removeClassMap")).toReturn(true);
 427         stub(method(PolicyWriterUtil.class, "removePolicyMapEntry")).toReturn(true);
 428         stub(method(PolicyWriterUtil.class, "removeServicePath")).toReturn(true);
 429         stub(method(PolicyWriterUtil.class, "removeRemote")).toReturn(true);
 430
 431         ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 432                 resolvedActionBuilder(new RuleName("rule-name"), CHAIN, action, Out), context);
 433
 434         verifyStatic(times(1));
 435         PolicyWriterUtil.removeClassMap(any(ClassMap.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 436         PolicyWriterUtil.removePolicyMapEntry(any(Class.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 437         PolicyWriterUtil.removeServicePath(any(ServiceChain.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 438         PolicyWriterUtil.removeRemote(any(ServiceFfName.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 439     }
 440
 441     @Test
 442     public void testResolveRemovedChainAction_symmetricChainReversed() {
 443         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 444         context.setPolicyMapLocation(getLocation());
 445         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 446         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 447         final ParameterValue parameterValue = parameterValueBuilder.build();
 448         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 449         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
 450                 .setSymmetric(true);
 451         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 452         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 453         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 454         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 455         final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
 456         hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
 457         final ServiceFunctionForwarderBuilder forwarder = new ServiceFunctionForwarderBuilder();
 458         forwarder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
 459                 .setIpMgmtAddress(new IpAddress(new Ipv4Address(IP_ADDRESS)));
 460
 461         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 462         stub(method(PolicyWriterUtil.class, "removeClassMap")).toReturn(true);
 463         stub(method(PolicyWriterUtil.class, "removePolicyMapEntry")).toReturn(true);
 464         stub(method(PolicyWriterUtil.class, "removeServicePath")).toReturn(true);
 465         stub(method(PolicyWriterUtil.class, "removeRemote")).toReturn(true);
 466
 467         ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 468                 resolvedActionBuilder(new RuleName("rule-name"), CHAIN, action, In), context);
 469
 470         verifyStatic(times(1));
 471         PolicyWriterUtil.removeClassMap(any(ClassMap.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 472         PolicyWriterUtil.removePolicyMapEntry(any(Class.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 473         PolicyWriterUtil.removeServicePath(any(ServiceChain.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 474         PolicyWriterUtil.removeRemote(any(ServiceFfName.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 475     }
 476
 477     @Test
 478     public void testResolveRemoteSfcComponents_noForwarder() {
 479         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 480         context.setPolicyMapLocation(getLocation());
 481         boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(buildRsp(), context);
 482         assertFalse(result);
 483     }
 484
 485     @Test
 486     public void testResolveRemoteSfcComponents_noForwarderLocator() {
 487         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 488         context.setPolicyMapLocation(getLocation());
 489         final ServiceFunctionForwarderBuilder forwarderBuilder = new ServiceFunctionForwarderBuilder();
 490         forwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER));
 491         final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
 492         hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
 493         final RenderedServicePathBuilder rspBuilder = new RenderedServicePathBuilder();
 494         rspBuilder.setRenderedServicePathHop(Collections.singletonList(hopBuilder.build()));
 495
 496         stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder"))
 497             .toReturn(forwarderBuilder.build());
 498
 499         boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(rspBuilder.build(), context);
 500         assertFalse(result);
 501     }
 502
 503     @Test
 504     public void testResolveRemoteSfcComponents_dplWithoutLocatorType() {
 505         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 506         context.setPolicyMapLocation(getLocation());
 507         final DataPlaneLocatorBuilder dplBuilder = new DataPlaneLocatorBuilder();
 508         final SffDataPlaneLocatorBuilder sffDplBuilder = new SffDataPlaneLocatorBuilder();
 509         sffDplBuilder.setDataPlaneLocator(dplBuilder.build());
 510         final ServiceFunctionForwarderBuilder forwarderBuilder = new ServiceFunctionForwarderBuilder();
 511         forwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
 512                 .setSffDataPlaneLocator(Collections.singletonList(sffDplBuilder.build()));
 513         final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
 514         hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
 515         final RenderedServicePathBuilder rspBuilder = new RenderedServicePathBuilder();
 516         rspBuilder.setRenderedServicePathHop(Collections.singletonList(hopBuilder.build()));
 517
 518         stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder"))
 519             .toReturn(forwarderBuilder.build());
 520
 521         boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(rspBuilder.build(), context);
 522         assertFalse(result);
 523     }
 524
 525     @Test
 526     public void testResolveRemoteSfcComponents_dplWithoutIp() {
 527         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 528         context.setPolicyMapLocation(getLocation());
 529         final DataPlaneLocatorBuilder dplBuilder = new DataPlaneLocatorBuilder();
 530         dplBuilder.setLocatorType(new IpBuilder().build());
 531         final SffDataPlaneLocatorBuilder sffDplBuilder = new SffDataPlaneLocatorBuilder();
 532         sffDplBuilder.setDataPlaneLocator(dplBuilder.build());
 533         final ServiceFunctionForwarderBuilder forwarderBuilder = new ServiceFunctionForwarderBuilder();
 534         forwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
 535                 .setSffDataPlaneLocator(Collections.singletonList(sffDplBuilder.build()));
 536         final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
 537         hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
 538         final RenderedServicePathBuilder rspBuilder = new RenderedServicePathBuilder();
 539         rspBuilder.setRenderedServicePathHop(Collections.singletonList(hopBuilder.build()));
 540
 541         stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder"))
 542             .toReturn(forwarderBuilder.build());
 543
 544         boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(rspBuilder.build(), context);
 545         assertFalse(result);
 546     }
 547
 548     @Test
 549     public void testResolveRemoteSfcComponents_sffWithoutMgmtAddress() {
 550         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 551         context.setPolicyMapLocation(getLocation());
 552         final DataPlaneLocatorBuilder dplBuilder = new DataPlaneLocatorBuilder();
 553         dplBuilder.setLocatorType(new IpBuilder().setIp(new IpAddress(new Ipv4Address(IP_ADDRESS))).build());
 554         final SffDataPlaneLocatorBuilder sffDplBuilder = new SffDataPlaneLocatorBuilder();
 555         sffDplBuilder.setDataPlaneLocator(dplBuilder.build());
 556         final ServiceFunctionForwarderBuilder forwarderBuilder = new ServiceFunctionForwarderBuilder();
 557         forwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
 558                 .setSffDataPlaneLocator(Collections.singletonList(sffDplBuilder.build()));
 559         final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
 560         hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
 561         final RenderedServicePathBuilder rspBuilder = new RenderedServicePathBuilder();
 562         rspBuilder.setRenderedServicePathHop(Collections.singletonList(hopBuilder.build()));
 563
 564         stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder"))
 565             .toReturn(forwarderBuilder.build());
 566
 567         boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(rspBuilder.build(), context);
 568         assertFalse(result);
 569     }
 570
 571     @Test
 572     public void testResolveRemoteSfcComponents_remoteCase() {
 573         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 574         context.setPolicyMapLocation(getLocation());
 575         final DataPlaneLocatorBuilder dplBuilder = new DataPlaneLocatorBuilder();
 576         dplBuilder.setLocatorType(new IpBuilder().setIp(new IpAddress(new Ipv4Address("190.1.1.12"))).build());
 577         final SffDataPlaneLocatorBuilder sffDplBuilder = new SffDataPlaneLocatorBuilder();
 578         sffDplBuilder.setDataPlaneLocator(dplBuilder.build());
 579         final ServiceFunctionForwarderBuilder forwarderBuilder = new ServiceFunctionForwarderBuilder();
 580         forwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
 581                 .setSffDataPlaneLocator(Collections.singletonList(sffDplBuilder.build()))
 582                 .setIpMgmtAddress(new IpAddress(new Ipv4Address(IP_ADDRESS)));
 583         final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
 584         hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
 585         final RenderedServicePathBuilder rspBuilder = new RenderedServicePathBuilder();
 586         rspBuilder.setRenderedServicePathHop(Collections.singletonList(hopBuilder.build()));
 587
 588         stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder"))
 589             .toReturn(forwarderBuilder.build());
 590         stub(method(PolicyWriterUtil.class, "writeServicePath")).toReturn(true);
 591         stub(method(PolicyWriterUtil.class, "writeRemote")).toReturn(true);
 592
 593         boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(rspBuilder.build(), context);
 594         assertTrue(result);
 595         verifyStatic(times(1));
 596         PolicyWriterUtil.writeServicePath(any(ServiceChain.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 597         PolicyWriterUtil.writeRemote(any(ServiceFfName.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 598     }
 599
 600     @Test
 601     public void testFindServicePathFromParameterValues_noParams() {
 602         final ServiceFunctionPath result =
 603             ServiceChainingUtil.findServicePathFromParameterValues(Collections.emptyList());
 604         assertNull(result);
 605     }
 606
 607     @Test
 608     public void testFindServicePathFromParameterValues_differentActionDefinition() {
 609         final ParameterValueBuilder noNamePVBuilder = new ParameterValueBuilder();
 610         final ParameterValue noNamePV = noNamePVBuilder.build();
 611         final ParameterValueBuilder intValuePMBuilder = new ParameterValueBuilder();
 612         String PARAMETER_VALUE_1 = "parameter-value-1";
 613         intValuePMBuilder.setName(new ParameterName(PARAMETER_VALUE_1))
 614                 .setIntValue(1L);
 615         final ParameterValue intValuePV = intValuePMBuilder.build();
 616         final ParameterValueBuilder stringValuePVBuilder = new ParameterValueBuilder();
 617         String PARAMETER_VALUE_2 = "parameter-value-2";
 618         stringValuePVBuilder.setName(new ParameterName(PARAMETER_VALUE_2))
 619                 .setStringValue(PARAMETER_VALUE_2);
 620         final ParameterValue stringValuePV = stringValuePVBuilder.build();
 621         final List<ParameterValue> parameterValues = new ArrayList<>();
 622         parameterValues.add(noNamePV);
 623         parameterValues.add(intValuePV);
 624         parameterValues.add(stringValuePV);
 625         final ServiceFunctionPath result = ServiceChainingUtil.findServicePathFromParameterValues(parameterValues);
 626         assertNull(result);
 627     }
 628
 629     @Test
 630     public void testFindServicePathFromParameterValues_noPathFound() {
 631         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 632         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME))
 633                 .setStringValue(SFC_CHAIN_NAME);
 634         final List<ParameterValue> parameterValues = Collections.singletonList(parameterValueBuilder.build());
 635         final ServiceFunctionPathsBuilder serviceFunctionPathsBuilder = new ServiceFunctionPathsBuilder();
 636         final ServiceFunctionPaths serviceFunctionPaths = serviceFunctionPathsBuilder.build();
 637
 638         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(serviceFunctionPaths);
 639
 640         final ServiceFunctionPath result = ServiceChainingUtil.findServicePathFromParameterValues(parameterValues);
 641         assertNull(result);
 642     }
 643
 644     @Test
 645     public void testFindServicePathFromParameterValues() {
 646         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 647         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME))
 648                 .setStringValue(SFC_CHAIN_NAME);
 649         final List<ParameterValue> parameterValues = Collections.singletonList(parameterValueBuilder.build());
 650         final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
 651         serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME));
 652         final ServiceFunctionPathsBuilder serviceFunctionPathsBuilder = new ServiceFunctionPathsBuilder();
 653         serviceFunctionPathsBuilder.setServiceFunctionPath(Collections.singletonList(serviceFunctionPathBuilder.build()));
 654         final ServiceFunctionPaths serviceFunctionPaths = serviceFunctionPathsBuilder.build();
 655
 656         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(serviceFunctionPaths);
 657
 658         final ServiceFunctionPath result = ServiceChainingUtil.findServicePathFromParameterValues(parameterValues);
 659         assertNotNull(result);
 660     }
 661
 662     @Test
 663     public void findServiceFunctionPathFromServiceChainName_noPaths() {
 664         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(null);
 665
 666         final ServiceFunctionPath result =
 667             ServiceChainingUtil.findServiceFunctionPathFromServiceChainName(new SfcName(SFC_CHAIN_NAME));
 668         assertNull(result);
 669     }
 670
 671     @Test
 672     public void findServiceFunctionPathFromServiceChainName_noPathFound() {
 673         final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
 674         final ServiceFunctionPathsBuilder serviceFunctionPathsBuilder = new ServiceFunctionPathsBuilder();
 675         serviceFunctionPathsBuilder
 676             .setServiceFunctionPath(Collections.singletonList(serviceFunctionPathBuilder.build()));
 677
 678         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths"))
 679             .toReturn(serviceFunctionPathsBuilder.build());
 680
 681         final ServiceFunctionPath result =
 682             ServiceChainingUtil.findServiceFunctionPathFromServiceChainName(new SfcName(SFC_CHAIN_NAME));
 683         assertNull(result);
 684     }
 685
 686     @Test
 687     public void findServiceFunctionPathFromServiceChainName_pathFound() {
 688         final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
 689         serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME))
 690                 .setServiceChainName(new SfcName(SFC_CHAIN_NAME));
 691         final ServiceFunctionPathsBuilder serviceFunctionPathsBuilder = new ServiceFunctionPathsBuilder();
 692         serviceFunctionPathsBuilder
 693             .setServiceFunctionPath(Collections.singletonList(serviceFunctionPathBuilder.build()));
 694
 695         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths"))
 696             .toReturn(serviceFunctionPathsBuilder.build());
 697
 698         final ServiceFunctionPath result =
 699             ServiceChainingUtil.findServiceFunctionPathFromServiceChainName(new SfcName(SFC_CHAIN_NAME));
 700         assertNotNull(result);
 701     }
 702
 703     @Test
 704     public void testCreateRenderedPath_renderedPathFound() {
 705         final Sgt sourceSgt = new Sgt(1);
 706         final Sgt destinationSgt = new Sgt(2);
 707         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 708         context.setPolicyMapLocation(getLocation());
 709         final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
 710         serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME))
 711                 .setSymmetric(true);
 712         final ServiceFunctionPath serviceFunctionPath = serviceFunctionPathBuilder.build();
 713         final TenantId tenantId = new TenantId(TENANT_ID);
 714
 715         stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath",RspName.class))
 716             .toReturn(new RenderedServicePathBuilder().build());
 717
 718         final RenderedServicePath result = ServiceChainingUtil.resolveRenderedServicePath(serviceFunctionPath, tenantId,
 719                 dataBroker, sourceSgt, destinationSgt, context);
 720         assertNotNull(result);
 721     }
 722
 723     @Test
 724     public void testCreateRenderedPath_renderedPathCreated() {
 725         ServiceChainingUtil.setTimeout(1L);
 726         final Sgt sourceSgt = new Sgt(1);
 727         final Sgt destinationSgt = new Sgt(2);
 728         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 729         context.setPolicyMapLocation(getLocation());
 730         final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
 731         serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME))
 732                 .setSymmetric(true);
 733         final ServiceFunctionPath serviceFunctionPath = serviceFunctionPathBuilder.build();
 734         final TenantId tenantId = new TenantId(TENANT_ID);
 735
 736         stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath",RspName.class))
 737             .toReturn(null);
 738         stub(method(SfcProviderRenderedPathAPI.class, "createRenderedServicePathAndState", ServiceFunctionPath.class,
 739                 CreateRenderedPathInput.class)).toReturn(new RenderedServicePathBuilder().build());
 740
 741         final RenderedServicePath result = ServiceChainingUtil.resolveRenderedServicePath(serviceFunctionPath, tenantId,
 742                 dataBroker, sourceSgt, destinationSgt, context);
 743         assertNotNull(result);
 744     }
 745
 746     @Test
 747     public void testCreateReversedRenderedPath_renderedPathFound() {
 748         final Sgt sourceSgt = new Sgt(1);
 749         final Sgt destinationSgt = new Sgt(2);
 750         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 751         context.setPolicyMapLocation(getLocation());
 752         final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
 753         serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME))
 754                 .setSymmetric(true);
 755         final ServiceFunctionPath serviceFunctionPath = serviceFunctionPathBuilder.build();
 756         final TenantId tenantId = new TenantId(TENANT_ID);
 757
 758         stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath",RspName.class))
 759             .toReturn(new RenderedServicePathBuilder().build());
 760
 761         final RenderedServicePath result = ServiceChainingUtil.resolveReversedRenderedServicePath(serviceFunctionPath,
 762                 tenantId, dataBroker, sourceSgt, destinationSgt, context);
 763         assertNotNull(result);
 764     }
 765
 766     @Test
 767     public void testCreateReversedRenderedPath_renderedPathCreated() {
 768         ServiceChainingUtil.setTimeout(1L);
 769         final Sgt sourceSgt = new Sgt(1);
 770         final Sgt destinationSgt = new Sgt(2);
 771         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 772         context.setPolicyMapLocation(getLocation());
 773         final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
 774         serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME))
 775                 .setSymmetric(true);
 776         final ServiceFunctionPath serviceFunctionPath = serviceFunctionPathBuilder.build();
 777         final TenantId tenantId = new TenantId(TENANT_ID);
 778
 779         stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath",RspName.class))
 780             .toReturn(null);
 781         stub(method(SfcProviderRenderedPathAPI.class, "createReverseRenderedServicePathEntry"))
 782                 .toReturn(new RenderedServicePathBuilder().build());
 783
 784         final RenderedServicePath result = ServiceChainingUtil.resolveReversedRenderedServicePath(serviceFunctionPath,
 785                 tenantId, dataBroker, sourceSgt, destinationSgt, context);
 786         assertNotNull(result);
 787     }
 788
 789     @Test
 790     public void testCreateRemoteForwarder() {
 791         final ServiceFfNameBuilder serviceFfNameBuilder = new ServiceFfNameBuilder();
 792         serviceFfNameBuilder.setName(SERVICE_FUNCTION_FORWARDER)
 793                 .setKey(new ServiceFfNameKey(SERVICE_FUNCTION_FORWARDER));
 794         final ServiceFfName testForwarder = serviceFfNameBuilder.build();
 795         final ServiceFunctionForwarderBuilder serviceFunctionForwarderBuilder = new ServiceFunctionForwarderBuilder();
 796         serviceFunctionForwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
 797                 .setKey(new ServiceFunctionForwarderKey(new SffName(SERVICE_FUNCTION_FORWARDER)));
 798         final ServiceFfName result = ServiceChainingUtil.createRemoteForwarder(serviceFunctionForwarderBuilder.build());
 799         assertEquals(testForwarder, result);
 800     }
 801
 802     @Test
 803     public void testGetServicePath() throws Exception {
 804         final String sfcNameValue = "123";
 805         final ServiceFunctionPath sfcPath = createSfp(sfcNameValue);
 806         final ServiceFunctionPaths sfcPaths = new ServiceFunctionPathsBuilder()
 807                 .setServiceFunctionPath(Collections.singletonList(sfcPath))
 808                 .build();
 809
 810         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(sfcPaths);
 811
 812         final ServiceFunctionPath servicePath =
 813             ServiceChainingUtil.findServicePathFromParameterValues(
 814                 Lists.newArrayList(createParameterValue(sfcNameValue)));
 815         assertEquals(sfcPath, servicePath);
 816     }
 817
 818     private ParameterValue createParameterValue(final String value) {
 819         return new ParameterValueBuilder().setName(new ParameterName("sfc-chain-name")).setStringValue(value).build();
 820     }
 821
 822     @Test
 823     public void testCreateRenderedPath() throws Exception {
 824         final String sfcNameValue = "123";
 825         final ServiceFunctionPath sfp = createSfp(sfcNameValue);
 826         final TenantId tenantId = new TenantId("unit-tenant-01");
 827         final Sgt sourceSgt = new Sgt(1);
 828         final Sgt destinationSgt = new Sgt(2);
 829         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 830         context.setPolicyMapLocation(getLocation());
 831
 832         final RenderedServicePath rsp = createRsp("unit-rsp-01");
 833
 834         PowerMockito.mockStatic(SfcProviderRenderedPathAPI.class);
 835         PowerMockito.when(SfcProviderRenderedPathAPI.readRenderedServicePath(rspNameCaptor.capture())).thenReturn(rsp);
 836
 837         final RenderedServicePath renderedPath = ServiceChainingUtil.resolveRenderedServicePath(sfp, tenantId,
 838                 dataBroker, sourceSgt, destinationSgt, context);
 839
 840         assertEquals("123_plain-unit-tenant-01-gbp-rsp", rspNameCaptor.getValue().getValue());
 841         assertEquals(rsp, renderedPath);
 842     }
 843
 844     @Test
 845     public void testCreateSymmetricRenderedPath() throws Exception {
 846         final ServiceFunctionPath sfp = createSfp("unit-sfp-02");
 847         final RenderedServicePath rsp = createRsp("unit-rsp-02");
 848         final TenantId tenantId = new TenantId("tenant-02");
 849         final Sgt sourceSgt = new Sgt(1);
 850         final Sgt destinationSgt = new Sgt(2);
 851         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 852         context.setPolicyMapLocation(getLocation());
 853
 854         PowerMockito.mockStatic(SfcProviderRenderedPathAPI.class);
 855         PowerMockito.when(SfcProviderRenderedPathAPI.readRenderedServicePath(rspNameCaptor.capture())).thenReturn(rsp);
 856         stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder"))
 857                 .toReturn(new ServiceFunctionForwarderBuilder().setName(new SffName("sff-name")).build());
 858
 859         final RenderedServicePath symmetricRenderedPath = ServiceChainingUtil.resolveReversedRenderedServicePath(sfp,
 860                 tenantId, dataBroker, sourceSgt, destinationSgt, context);
 861
 862         assertEquals("unit-sfp-02_plain-tenant-02-gbp-rsp-Reverse", rspNameCaptor.getValue().getValue());
 863         assertEquals(rsp, symmetricRenderedPath);
 864     }
 865
 866     @Test
 867     public void testFindServiceFunctionPath() throws Exception {
 868         final String sfcNameValue = "123";
 869         final ServiceFunctionPath sfcPath = createSfp(sfcNameValue);
 870         final ServiceFunctionPaths sfcPaths = new ServiceFunctionPathsBuilder()
 871                 .setServiceFunctionPath(Collections.singletonList(sfcPath))
 872                 .build();
 873
 874         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(sfcPaths);
 875
 876         final ServiceFunctionPath servicePath =
 877             ServiceChainingUtil.findServiceFunctionPathFromServiceChainName(new SfcName(sfcNameValue));
 878         assertEquals(sfcPath, servicePath);
 879     }
 880
 881     // Auxiliary methods
 882
 883     private RenderedServicePath buildRsp() {
 884         RenderedServicePathBuilder renderedServicePathBuilder = new RenderedServicePathBuilder();
 885         renderedServicePathBuilder.setRenderedServicePathHop(null);
 886         return renderedServicePathBuilder.build();
 887     }
 888
 889     private RenderedServicePath createRsp(final String rspNameValue) {
 890         return new RenderedServicePathBuilder()
 891                 .setName(new RspName(rspNameValue))
 892                 .setRenderedServicePathHop(Lists.newArrayList(createRspHop()))
 893                 .build();
 894     }
 895
 896     private RenderedServicePathHop createRspHop() {
 897         return new RenderedServicePathHopBuilder()
 898                 .setServiceFunctionName(new SfName("rsp-hop-01-sf"))
 899                 .setServiceFunctionForwarder(new SffName("rsp-hop-01-sf" + "+sff"))
 900                 .build();
 901     }
 902
 903     private ServiceFunctionPath createSfp(final String sfcNameValue) {
 904         return new ServiceFunctionPathBuilder()
 905                 .setServiceChainName(new SfcName(sfcNameValue))
 906                 .setName(new SfpName(sfcNameValue + "_plain"))
 907                 .setSymmetric(false)
 908                 .build();
 909     }
 910
 911     private PeerEndpoint peerEndpointBuilder() {
 912         final PeerEndpointBuilder peerEndpointBuilder = new PeerEndpointBuilder();
 913         final RuleGroupWithRendererEndpointParticipationBuilder ruleGroupBuilder =
 914                 new RuleGroupWithRendererEndpointParticipationBuilder();
 915         peerEndpointBuilder
 916             .setRuleGroupWithRendererEndpointParticipation(Collections.singletonList(ruleGroupBuilder.build()));
 917         return peerEndpointBuilder.build();
 918     }
 919
 920     private Map<ActionCase, ActionInDirection> resolvedActionBuilder(@Nonnull final RuleName ruleName,
 921                                                                      @Nonnull final ActionCase actionCase,
 922                                                                      @Nonnull final Action action,
 923                                                                      @Nonnull final Direction direction) {
 924         final ActionInDirection actionInDirection = new ActionInDirection(ruleName, action, PROVIDER, direction);
 925         return Collections.singletonMap(actionCase, actionInDirection);
 926     }
 927
 928     private PolicyConfigurationContext policyConfigurationContextBuilder() {
 929         final RendererEndpointBuilder rendererEndpointBuilder = new RendererEndpointBuilder();
 930         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 931         context.setCurrentRendererEP(rendererEndpointBuilder.build());
 932         return context;
 933     }
 934
 935     private Sgt sgtBuilder(final int value) {
 936         return new Sgt(value);
 937     }
 938
 939     private Action actionBuilder(final List<ParameterValue> parameters) {
 940         final ActionBuilder actionBuilder = new ActionBuilder();
 941         actionBuilder.setParameterValue(parameters);
 942         return actionBuilder.build();
 943     }
 944
 945     private PolicyManagerImpl.PolicyMapLocation getLocation() {
 946         final String POLICY_MAP = "policy-map";
 947         final String INTERFACE = "interface";
 948         final NodeId nodeId = new NodeId("node-id");
 949         final String IP_ADDRESS = "ip-address";
 950         return new PolicyManagerImpl.PolicyMapLocation(POLICY_MAP, INTERFACE, nodeId, IP_ADDRESS, dataBroker);
 951     }
 952 }