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")).toReturn(pathsBuilder.build());
 185         stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(null);
 186
 187         ServiceChainingUtil.newChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 188                 resolvedActionBuilder(RULE_NAME, CHAIN, action, In), context, dataBroker);
 189
 190         verifyNoMoreInteractions(policyWriterUtil);
 191         verifyNoMoreInteractions(dataBroker);
 192     }
 193
 194     @Test
 195     public void testResolveNewChainAction_asymmetricChainOpposite() {
 196         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 197         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 198         final ParameterValue parameterValue = parameterValueBuilder.build();
 199
 200         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 201         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
 202                 .setSymmetric(false);
 203         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 204         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 205
 206         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 207         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 208         final PolicyConfigurationContext context = policyConfigurationContextBuilder();
 209
 210         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 211         stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(new TenantId(TENANT_ID));
 212
 213         ServiceChainingUtil.newChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 214                 resolvedActionBuilder(RULE_NAME, CHAIN, action, In), context, dataBroker);
 215
 216         verifyNoMoreInteractions(policyWriterUtil);
 217         verifyNoMoreInteractions(dataBroker);
 218     }
 219
 220     @Test
 221     public void testResolveNewChainAction_asymmetricChain() {
 222         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 223         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 224         final ParameterValue parameterValue = parameterValueBuilder.build();
 225
 226         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 227         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
 228                 .setSymmetric(false);
 229         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 230         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 231
 232         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 233         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 234         final PolicyConfigurationContext context = policyConfigurationContextBuilder();
 235
 236         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 237         stub(method(PolicyWriterUtil.class, "writeClassMap")).toReturn(true);
 238         stub(method(PolicyWriterUtil.class, "writePolicyMapEntry")).toReturn(true);
 239
 240         ServiceChainingUtil.newChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 241                 resolvedActionBuilder(RULE_NAME, CHAIN, action, Out), context, dataBroker);
 242
 243         verifyStatic(times(1));
 244         PolicyWriterUtil.writeClassMap(any(ClassMap.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 245         PolicyWriterUtil.writePolicyMapEntry(any(Class.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 246     }
 247
 248     @Test
 249     public void testResolveNewChainAction_symmetricChainDirect() {
 250         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 251         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 252         final ParameterValue parameterValue = parameterValueBuilder.build();
 253
 254         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 255         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
 256                 .setSymmetric(true);
 257         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 258         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 259
 260         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 261         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 262         final PolicyConfigurationContext context = policyConfigurationContextBuilder();
 263
 264         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 265         stub(method(PolicyWriterUtil.class, "writeClassMap")).toReturn(true);
 266         stub(method(PolicyWriterUtil.class, "writePolicyMapEntry")).toReturn(true);
 267
 268         ServiceChainingUtil.newChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 269                 resolvedActionBuilder(RULE_NAME, CHAIN, action, Out), context, dataBroker);
 270
 271         verifyStatic(times(1));
 272         PolicyWriterUtil.writeClassMap(any(ClassMap.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 273         PolicyWriterUtil.writePolicyMapEntry(any(Class.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 274     }
 275
 276     @Test
 277     public void testResolveNewChainAction_symmetricChainReversed() {
 278         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 279         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 280         final ParameterValue parameterValue = parameterValueBuilder.build();
 281
 282         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 283         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
 284                 .setSymmetric(true);
 285         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 286         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 287
 288         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 289         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 290         final PolicyConfigurationContext context = policyConfigurationContextBuilder();
 291
 292         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 293         stub(method(PolicyWriterUtil.class, "writeClassMap")).toReturn(true);
 294         stub(method(PolicyWriterUtil.class, "writePolicyMapEntry")).toReturn(true);
 295
 296         ServiceChainingUtil.newChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 297                 resolvedActionBuilder(RULE_NAME, CHAIN, action, In), context, dataBroker);
 298
 299         verifyStatic(times(1));
 300         PolicyWriterUtil.writeClassMap(any(ClassMap.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 301         PolicyWriterUtil.writePolicyMapEntry(any(Class.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 302     }
 303
 304     @Test
 305     public void testResolveRemovedChainAction_noParameterValue() {
 306         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 307         context.setPolicyMapLocation(getLocation());
 308         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 309         final Action action = actionBuilder(null);
 310
 311         ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 312                 resolvedActionBuilder(new RuleName("rule-name"), CHAIN, action, In), context);
 313
 314         verifyNoMoreInteractions(policyWriterUtil);
 315     }
 316
 317     @Test
 318     public void testResolveRemovedChainAction_noTenantId() {
 319         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 320         context.setPolicyMapLocation(getLocation());
 321         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 322         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 323         final ParameterValue parameterValue = parameterValueBuilder.build();
 324
 325         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 326         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME));
 327         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 328         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 329
 330         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 331         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 332
 333         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 334         stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(null);
 335
 336         ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 337                 resolvedActionBuilder(new RuleName("rule-name"), CHAIN, action, In), context);
 338
 339         verifyNoMoreInteractions(policyWriterUtil);
 340     }
 341
 342     @Test
 343     public void testResolveRemovedChainAction_asymmetricChainOpposite() {
 344         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 345         context.setPolicyMapLocation(getLocation());
 346         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 347         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 348         final ParameterValue parameterValue = parameterValueBuilder.build();
 349
 350         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 351         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
 352                 .setSymmetric(false);
 353         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 354         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 355
 356         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 357         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 358
 359         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 360         stub(method(PolicyManagerUtil.class, "getTenantId")).toReturn(new TenantId(TENANT_ID));
 361
 362         ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 363                 resolvedActionBuilder(new RuleName("rule-name"), CHAIN, action, In), context);
 364
 365         verifyNoMoreInteractions(policyWriterUtil);
 366     }
 367
 368     @Test
 369     public void testResolveRemovedChainAction_asymmetricChainDirect() {
 370         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 371         context.setPolicyMapLocation(getLocation());
 372         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 373         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 374         final ParameterValue parameterValue = parameterValueBuilder.build();
 375         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 376         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
 377                 .setSymmetric(false);
 378         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 379         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 380         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 381         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 382         final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
 383         hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
 384         final ServiceFunctionForwarderBuilder forwarder = new ServiceFunctionForwarderBuilder();
 385         forwarder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
 386                 .setIpMgmtAddress(new IpAddress(new Ipv4Address(IP_ADDRESS)));
 387
 388         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 389         stub(method(PolicyWriterUtil.class, "removeClassMap")).toReturn(true);
 390         stub(method(PolicyWriterUtil.class, "removePolicyMapEntry")).toReturn(true);
 391         stub(method(PolicyWriterUtil.class, "removeServicePath")).toReturn(true);
 392         stub(method(PolicyWriterUtil.class, "removeRemote")).toReturn(true);
 393
 394         ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 395                 resolvedActionBuilder(new RuleName("rule-name"), CHAIN, action, Out), context);
 396
 397         verifyStatic(times(1));
 398         PolicyWriterUtil.removeClassMap(any(ClassMap.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 399         PolicyWriterUtil.removePolicyMapEntry(any(Class.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 400         PolicyWriterUtil.removeServicePath(any(ServiceChain.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 401         PolicyWriterUtil.removeRemote(any(ServiceFfName.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 402     }
 403
 404     @Test
 405     public void testResolveRemovedChainAction_symmetricChainDirect() {
 406         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 407         context.setPolicyMapLocation(getLocation());
 408         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 409         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 410         final ParameterValue parameterValue = parameterValueBuilder.build();
 411         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 412         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
 413                 .setSymmetric(true);
 414         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 415         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 416         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 417         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 418         final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
 419         hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
 420         final ServiceFunctionForwarderBuilder forwarder = new ServiceFunctionForwarderBuilder();
 421         forwarder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
 422                 .setIpMgmtAddress(new IpAddress(new Ipv4Address(IP_ADDRESS)));
 423
 424         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 425         stub(method(PolicyWriterUtil.class, "removeClassMap")).toReturn(true);
 426         stub(method(PolicyWriterUtil.class, "removePolicyMapEntry")).toReturn(true);
 427         stub(method(PolicyWriterUtil.class, "removeServicePath")).toReturn(true);
 428         stub(method(PolicyWriterUtil.class, "removeRemote")).toReturn(true);
 429
 430         ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 431                 resolvedActionBuilder(new RuleName("rule-name"), CHAIN, action, Out), context);
 432
 433         verifyStatic(times(1));
 434         PolicyWriterUtil.removeClassMap(any(ClassMap.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 435         PolicyWriterUtil.removePolicyMapEntry(any(Class.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 436         PolicyWriterUtil.removeServicePath(any(ServiceChain.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 437         PolicyWriterUtil.removeRemote(any(ServiceFfName.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 438     }
 439
 440     @Test
 441     public void testResolveRemovedChainAction_symmetricChainReversed() {
 442         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 443         context.setPolicyMapLocation(getLocation());
 444         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 445         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME)).setStringValue(SFC_CHAIN_NAME);
 446         final ParameterValue parameterValue = parameterValueBuilder.build();
 447         final ServiceFunctionPathBuilder pathBuilder = new ServiceFunctionPathBuilder();
 448         pathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME))
 449                 .setSymmetric(true);
 450         final ServiceFunctionPathsBuilder pathsBuilder = new ServiceFunctionPathsBuilder();
 451         pathsBuilder.setServiceFunctionPath(Collections.singletonList(pathBuilder.build()));
 452         final PeerEndpoint peerEndpoint = peerEndpointBuilder();
 453         final Action action = actionBuilder(Collections.singletonList(parameterValue));
 454         final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
 455         hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
 456         final ServiceFunctionForwarderBuilder forwarder = new ServiceFunctionForwarderBuilder();
 457         forwarder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
 458                 .setIpMgmtAddress(new IpAddress(new Ipv4Address(IP_ADDRESS)));
 459
 460         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(pathsBuilder.build());
 461         stub(method(PolicyWriterUtil.class, "removeClassMap")).toReturn(true);
 462         stub(method(PolicyWriterUtil.class, "removePolicyMapEntry")).toReturn(true);
 463         stub(method(PolicyWriterUtil.class, "removeServicePath")).toReturn(true);
 464         stub(method(PolicyWriterUtil.class, "removeRemote")).toReturn(true);
 465
 466         ServiceChainingUtil.resolveRemovedChainAction(peerEndpoint, sgtBuilder(10), sgtBuilder(20),
 467                 resolvedActionBuilder(new RuleName("rule-name"), CHAIN, action, In), context);
 468
 469         verifyStatic(times(1));
 470         PolicyWriterUtil.removeClassMap(any(ClassMap.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 471         PolicyWriterUtil.removePolicyMapEntry(any(Class.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 472         PolicyWriterUtil.removeServicePath(any(ServiceChain.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 473         PolicyWriterUtil.removeRemote(any(ServiceFfName.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 474     }
 475
 476     @Test
 477     public void testResolveRemoteSfcComponents_noForwarder() {
 478         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 479         context.setPolicyMapLocation(getLocation());
 480         boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(buildRsp(), context);
 481         assertFalse(result);
 482     }
 483
 484     @Test
 485     public void testResolveRemoteSfcComponents_noForwarderLocator() {
 486         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 487         context.setPolicyMapLocation(getLocation());
 488         final ServiceFunctionForwarderBuilder forwarderBuilder = new ServiceFunctionForwarderBuilder();
 489         forwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER));
 490         final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
 491         hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
 492         final RenderedServicePathBuilder rspBuilder = new RenderedServicePathBuilder();
 493         rspBuilder.setRenderedServicePathHop(Collections.singletonList(hopBuilder.build()));
 494
 495         stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder")).toReturn(forwarderBuilder.build());
 496
 497         boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(rspBuilder.build(), context);
 498         assertFalse(result);
 499     }
 500
 501     @Test
 502     public void testResolveRemoteSfcComponents_dplWithoutLocatorType() {
 503         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 504         context.setPolicyMapLocation(getLocation());
 505         final DataPlaneLocatorBuilder dplBuilder = new DataPlaneLocatorBuilder();
 506         final SffDataPlaneLocatorBuilder sffDplBuilder = new SffDataPlaneLocatorBuilder();
 507         sffDplBuilder.setDataPlaneLocator(dplBuilder.build());
 508         final ServiceFunctionForwarderBuilder forwarderBuilder = new ServiceFunctionForwarderBuilder();
 509         forwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
 510                 .setSffDataPlaneLocator(Collections.singletonList(sffDplBuilder.build()));
 511         final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
 512         hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
 513         final RenderedServicePathBuilder rspBuilder = new RenderedServicePathBuilder();
 514         rspBuilder.setRenderedServicePathHop(Collections.singletonList(hopBuilder.build()));
 515
 516         stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder")).toReturn(forwarderBuilder.build());
 517
 518         boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(rspBuilder.build(), context);
 519         assertFalse(result);
 520     }
 521
 522     @Test
 523     public void testResolveRemoteSfcComponents_dplWithoutIp() {
 524         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 525         context.setPolicyMapLocation(getLocation());
 526         final DataPlaneLocatorBuilder dplBuilder = new DataPlaneLocatorBuilder();
 527         dplBuilder.setLocatorType(new IpBuilder().build());
 528         final SffDataPlaneLocatorBuilder sffDplBuilder = new SffDataPlaneLocatorBuilder();
 529         sffDplBuilder.setDataPlaneLocator(dplBuilder.build());
 530         final ServiceFunctionForwarderBuilder forwarderBuilder = new ServiceFunctionForwarderBuilder();
 531         forwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
 532                 .setSffDataPlaneLocator(Collections.singletonList(sffDplBuilder.build()));
 533         final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
 534         hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
 535         final RenderedServicePathBuilder rspBuilder = new RenderedServicePathBuilder();
 536         rspBuilder.setRenderedServicePathHop(Collections.singletonList(hopBuilder.build()));
 537
 538         stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder")).toReturn(forwarderBuilder.build());
 539
 540         boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(rspBuilder.build(), context);
 541         assertFalse(result);
 542     }
 543
 544     @Test
 545     public void testResolveRemoteSfcComponents_sffWithoutMgmtAddress() {
 546         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 547         context.setPolicyMapLocation(getLocation());
 548         final DataPlaneLocatorBuilder dplBuilder = new DataPlaneLocatorBuilder();
 549         dplBuilder.setLocatorType(new IpBuilder().setIp(new IpAddress(new Ipv4Address(IP_ADDRESS))).build());
 550         final SffDataPlaneLocatorBuilder sffDplBuilder = new SffDataPlaneLocatorBuilder();
 551         sffDplBuilder.setDataPlaneLocator(dplBuilder.build());
 552         final ServiceFunctionForwarderBuilder forwarderBuilder = new ServiceFunctionForwarderBuilder();
 553         forwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
 554                 .setSffDataPlaneLocator(Collections.singletonList(sffDplBuilder.build()));
 555         final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
 556         hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
 557         final RenderedServicePathBuilder rspBuilder = new RenderedServicePathBuilder();
 558         rspBuilder.setRenderedServicePathHop(Collections.singletonList(hopBuilder.build()));
 559
 560         stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder")).toReturn(forwarderBuilder.build());
 561
 562         boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(rspBuilder.build(), context);
 563         assertFalse(result);
 564     }
 565
 566     @Test
 567     public void testResolveRemoteSfcComponents_remoteCase() {
 568         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 569         context.setPolicyMapLocation(getLocation());
 570         final DataPlaneLocatorBuilder dplBuilder = new DataPlaneLocatorBuilder();
 571         dplBuilder.setLocatorType(new IpBuilder().setIp(new IpAddress(new Ipv4Address("190.1.1.12"))).build());
 572         final SffDataPlaneLocatorBuilder sffDplBuilder = new SffDataPlaneLocatorBuilder();
 573         sffDplBuilder.setDataPlaneLocator(dplBuilder.build());
 574         final ServiceFunctionForwarderBuilder forwarderBuilder = new ServiceFunctionForwarderBuilder();
 575         forwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
 576                 .setSffDataPlaneLocator(Collections.singletonList(sffDplBuilder.build()))
 577                 .setIpMgmtAddress(new IpAddress(new Ipv4Address(IP_ADDRESS)));
 578         final RenderedServicePathHopBuilder hopBuilder = new RenderedServicePathHopBuilder();
 579         hopBuilder.setServiceFunctionForwarder(new SffName(SERVICE_FUNCTION_FORWARDER));
 580         final RenderedServicePathBuilder rspBuilder = new RenderedServicePathBuilder();
 581         rspBuilder.setRenderedServicePathHop(Collections.singletonList(hopBuilder.build()));
 582
 583         stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder")).toReturn(forwarderBuilder.build());
 584         stub(method(PolicyWriterUtil.class, "writeServicePath")).toReturn(true);
 585         stub(method(PolicyWriterUtil.class, "writeRemote")).toReturn(true);
 586
 587         boolean result = ServiceChainingUtil.resolveRemoteSfcComponents(rspBuilder.build(), context);
 588         assertTrue(result);
 589         verifyStatic(times(1));
 590         PolicyWriterUtil.writeServicePath(any(ServiceChain.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 591         PolicyWriterUtil.writeRemote(any(ServiceFfName.class), any(PolicyManagerImpl.PolicyMapLocation.class));
 592     }
 593
 594     @Test
 595     public void testFindServicePathFromParameterValues_noParams() {
 596         final ServiceFunctionPath result = ServiceChainingUtil.findServicePathFromParameterValues(Collections.emptyList());
 597         assertNull(result);
 598     }
 599
 600     @Test
 601     public void testFindServicePathFromParameterValues_differentActionDefinition() {
 602         final ParameterValueBuilder noNamePVBuilder = new ParameterValueBuilder();
 603         final ParameterValue noNamePV = noNamePVBuilder.build();
 604         final ParameterValueBuilder intValuePMBuilder = new ParameterValueBuilder();
 605         String PARAMETER_VALUE_1 = "parameter-value-1";
 606         intValuePMBuilder.setName(new ParameterName(PARAMETER_VALUE_1))
 607                 .setIntValue(1L);
 608         final ParameterValue intValuePV = intValuePMBuilder.build();
 609         final ParameterValueBuilder stringValuePVBuilder = new ParameterValueBuilder();
 610         String PARAMETER_VALUE_2 = "parameter-value-2";
 611         stringValuePVBuilder.setName(new ParameterName(PARAMETER_VALUE_2))
 612                 .setStringValue(PARAMETER_VALUE_2);
 613         final ParameterValue stringValuePV = stringValuePVBuilder.build();
 614         final List<ParameterValue> parameterValues = new ArrayList<>();
 615         parameterValues.add(noNamePV);
 616         parameterValues.add(intValuePV);
 617         parameterValues.add(stringValuePV);
 618         final ServiceFunctionPath result = ServiceChainingUtil.findServicePathFromParameterValues(parameterValues);
 619         assertNull(result);
 620     }
 621
 622     @Test
 623     public void testFindServicePathFromParameterValues_noPathFound() {
 624         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 625         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME))
 626                 .setStringValue(SFC_CHAIN_NAME);
 627         final List<ParameterValue> parameterValues = Collections.singletonList(parameterValueBuilder.build());
 628         final ServiceFunctionPathsBuilder serviceFunctionPathsBuilder = new ServiceFunctionPathsBuilder();
 629         final ServiceFunctionPaths serviceFunctionPaths = serviceFunctionPathsBuilder.build();
 630
 631         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(serviceFunctionPaths);
 632
 633         final ServiceFunctionPath result = ServiceChainingUtil.findServicePathFromParameterValues(parameterValues);
 634         assertNull(result);
 635     }
 636
 637     @Test
 638     public void testFindServicePathFromParameterValues() {
 639         final ParameterValueBuilder parameterValueBuilder = new ParameterValueBuilder();
 640         parameterValueBuilder.setName(new ParameterName(SFC_CHAIN_NAME))
 641                 .setStringValue(SFC_CHAIN_NAME);
 642         final List<ParameterValue> parameterValues = Collections.singletonList(parameterValueBuilder.build());
 643         final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
 644         serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME)).setServiceChainName(new SfcName(SFC_CHAIN_NAME));
 645         final ServiceFunctionPathsBuilder serviceFunctionPathsBuilder = new ServiceFunctionPathsBuilder();
 646         serviceFunctionPathsBuilder.setServiceFunctionPath(Collections.singletonList(serviceFunctionPathBuilder.build()));
 647         final ServiceFunctionPaths serviceFunctionPaths = serviceFunctionPathsBuilder.build();
 648
 649         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(serviceFunctionPaths);
 650
 651         final ServiceFunctionPath result = ServiceChainingUtil.findServicePathFromParameterValues(parameterValues);
 652         assertNotNull(result);
 653     }
 654
 655     @Test
 656     public void findServiceFunctionPathFromServiceChainName_noPaths() {
 657         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(null);
 658
 659         final ServiceFunctionPath result = ServiceChainingUtil.findServiceFunctionPathFromServiceChainName(new SfcName(SFC_CHAIN_NAME));
 660         assertNull(result);
 661     }
 662
 663     @Test
 664     public void findServiceFunctionPathFromServiceChainName_noPathFound() {
 665         final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
 666         final ServiceFunctionPathsBuilder serviceFunctionPathsBuilder = new ServiceFunctionPathsBuilder();
 667         serviceFunctionPathsBuilder.setServiceFunctionPath(Collections.singletonList(serviceFunctionPathBuilder.build()));
 668
 669         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(serviceFunctionPathsBuilder.build());
 670
 671         final ServiceFunctionPath result = ServiceChainingUtil.findServiceFunctionPathFromServiceChainName(new SfcName(SFC_CHAIN_NAME));
 672         assertNull(result);
 673     }
 674
 675     @Test
 676     public void findServiceFunctionPathFromServiceChainName_pathFound() {
 677         final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
 678         serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME))
 679                 .setServiceChainName(new SfcName(SFC_CHAIN_NAME));
 680         final ServiceFunctionPathsBuilder serviceFunctionPathsBuilder = new ServiceFunctionPathsBuilder();
 681         serviceFunctionPathsBuilder.setServiceFunctionPath(Collections.singletonList(serviceFunctionPathBuilder.build()));
 682
 683         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(serviceFunctionPathsBuilder.build());
 684
 685         final ServiceFunctionPath result = ServiceChainingUtil.findServiceFunctionPathFromServiceChainName(new SfcName(SFC_CHAIN_NAME));
 686         assertNotNull(result);
 687     }
 688
 689     @Test
 690     public void testCreateRenderedPath_renderedPathFound() {
 691         final Sgt sourceSgt = new Sgt(1);
 692         final Sgt destinationSgt = new Sgt(2);
 693         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 694         context.setPolicyMapLocation(getLocation());
 695         final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
 696         serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME))
 697                 .setSymmetric(true);
 698         final ServiceFunctionPath serviceFunctionPath = serviceFunctionPathBuilder.build();
 699         final TenantId tenantId = new TenantId(TENANT_ID);
 700
 701         stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(new RenderedServicePathBuilder().build());
 702
 703         final RenderedServicePath result = ServiceChainingUtil.resolveRenderedServicePath(serviceFunctionPath, tenantId,
 704                 dataBroker, sourceSgt, destinationSgt, context);
 705         assertNotNull(result);
 706     }
 707
 708     @Test
 709     public void testCreateRenderedPath_renderedPathCreated() {
 710         ServiceChainingUtil.setTimeout(1L);
 711         final Sgt sourceSgt = new Sgt(1);
 712         final Sgt destinationSgt = new Sgt(2);
 713         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 714         context.setPolicyMapLocation(getLocation());
 715         final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
 716         serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME))
 717                 .setSymmetric(true);
 718         final ServiceFunctionPath serviceFunctionPath = serviceFunctionPathBuilder.build();
 719         final TenantId tenantId = new TenantId(TENANT_ID);
 720
 721         stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(null);
 722         stub(method(SfcProviderRenderedPathAPI.class, "createRenderedServicePathAndState", ServiceFunctionPath.class,
 723                 CreateRenderedPathInput.class)).toReturn(new RenderedServicePathBuilder().build());
 724
 725         final RenderedServicePath result = ServiceChainingUtil.resolveRenderedServicePath(serviceFunctionPath, tenantId,
 726                 dataBroker, sourceSgt, destinationSgt, context);
 727         assertNotNull(result);
 728     }
 729
 730     @Test
 731     public void testCreateReversedRenderedPath_renderedPathFound() {
 732         final Sgt sourceSgt = new Sgt(1);
 733         final Sgt destinationSgt = new Sgt(2);
 734         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 735         context.setPolicyMapLocation(getLocation());
 736         final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
 737         serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME))
 738                 .setSymmetric(true);
 739         final ServiceFunctionPath serviceFunctionPath = serviceFunctionPathBuilder.build();
 740         final TenantId tenantId = new TenantId(TENANT_ID);
 741
 742         stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(new RenderedServicePathBuilder().build());
 743
 744         final RenderedServicePath result = ServiceChainingUtil.resolveReversedRenderedServicePath(serviceFunctionPath,
 745                 tenantId, dataBroker, sourceSgt, destinationSgt, context);
 746         assertNotNull(result);
 747     }
 748
 749     @Test
 750     public void testCreateReversedRenderedPath_renderedPathCreated() {
 751         ServiceChainingUtil.setTimeout(1L);
 752         final Sgt sourceSgt = new Sgt(1);
 753         final Sgt destinationSgt = new Sgt(2);
 754         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 755         context.setPolicyMapLocation(getLocation());
 756         final ServiceFunctionPathBuilder serviceFunctionPathBuilder = new ServiceFunctionPathBuilder();
 757         serviceFunctionPathBuilder.setName(new SfpName(SFC_PATH_NAME))
 758                 .setSymmetric(true);
 759         final ServiceFunctionPath serviceFunctionPath = serviceFunctionPathBuilder.build();
 760         final TenantId tenantId = new TenantId(TENANT_ID);
 761
 762         stub(method(SfcProviderRenderedPathAPI.class, "readRenderedServicePath")).toReturn(null);
 763         stub(method(SfcProviderRenderedPathAPI.class, "createReverseRenderedServicePathEntry"))
 764                 .toReturn(new RenderedServicePathBuilder().build());
 765
 766         final RenderedServicePath result = ServiceChainingUtil.resolveReversedRenderedServicePath(serviceFunctionPath,
 767                 tenantId, dataBroker, sourceSgt, destinationSgt, context);
 768         assertNotNull(result);
 769     }
 770
 771     @Test
 772     public void testCreateRemoteForwarder() {
 773         final ServiceFfNameBuilder serviceFfNameBuilder = new ServiceFfNameBuilder();
 774         serviceFfNameBuilder.setName(SERVICE_FUNCTION_FORWARDER)
 775                 .setKey(new ServiceFfNameKey(SERVICE_FUNCTION_FORWARDER));
 776         final ServiceFfName testForwarder = serviceFfNameBuilder.build();
 777         final ServiceFunctionForwarderBuilder serviceFunctionForwarderBuilder = new ServiceFunctionForwarderBuilder();
 778         serviceFunctionForwarderBuilder.setName(new SffName(SERVICE_FUNCTION_FORWARDER))
 779                 .setKey(new ServiceFunctionForwarderKey(new SffName(SERVICE_FUNCTION_FORWARDER)));
 780         final ServiceFfName result = ServiceChainingUtil.createRemoteForwarder(serviceFunctionForwarderBuilder.build());
 781         assertEquals(testForwarder, result);
 782     }
 783
 784     @Test
 785     public void testGetServicePath() throws Exception {
 786         final String sfcNameValue = "123";
 787         final ServiceFunctionPath sfcPath = createSfp(sfcNameValue);
 788         final ServiceFunctionPaths sfcPaths = new ServiceFunctionPathsBuilder()
 789                 .setServiceFunctionPath(Collections.singletonList(sfcPath))
 790                 .build();
 791
 792         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(sfcPaths);
 793
 794         final ServiceFunctionPath servicePath = ServiceChainingUtil.findServicePathFromParameterValues(Lists.newArrayList(
 795                 createParameterValue(sfcNameValue)
 796         ));
 797         assertEquals(sfcPath, servicePath);
 798     }
 799
 800     private ParameterValue createParameterValue(final String value) {
 801         return new ParameterValueBuilder().setName(new ParameterName("sfc-chain-name")).setStringValue(value).build();
 802     }
 803
 804     @Test
 805     public void testCreateRenderedPath() throws Exception {
 806         final String sfcNameValue = "123";
 807         final ServiceFunctionPath sfp = createSfp(sfcNameValue);
 808         final TenantId tenantId = new TenantId("unit-tenant-01");
 809         final Sgt sourceSgt = new Sgt(1);
 810         final Sgt destinationSgt = new Sgt(2);
 811         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 812         context.setPolicyMapLocation(getLocation());
 813
 814         final RenderedServicePath rsp = createRsp("unit-rsp-01");
 815
 816         PowerMockito.mockStatic(SfcProviderRenderedPathAPI.class);
 817         PowerMockito.when(SfcProviderRenderedPathAPI.readRenderedServicePath(rspNameCaptor.capture())).thenReturn(rsp);
 818
 819         final RenderedServicePath renderedPath = ServiceChainingUtil.resolveRenderedServicePath(sfp, tenantId,
 820                 dataBroker, sourceSgt, destinationSgt, context);
 821
 822         assertEquals("123_plain-unit-tenant-01-gbp-rsp", rspNameCaptor.getValue().getValue());
 823         assertEquals(rsp, renderedPath);
 824     }
 825
 826     @Test
 827     public void testCreateSymmetricRenderedPath() throws Exception {
 828         final ServiceFunctionPath sfp = createSfp("unit-sfp-02");
 829         final RenderedServicePath rsp = createRsp("unit-rsp-02");
 830         final TenantId tenantId = new TenantId("tenant-02");
 831         final Sgt sourceSgt = new Sgt(1);
 832         final Sgt destinationSgt = new Sgt(2);
 833         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 834         context.setPolicyMapLocation(getLocation());
 835
 836         PowerMockito.mockStatic(SfcProviderRenderedPathAPI.class);
 837         PowerMockito.when(SfcProviderRenderedPathAPI.readRenderedServicePath(rspNameCaptor.capture())).thenReturn(rsp);
 838         stub(method(SfcProviderServiceForwarderAPI.class, "readServiceFunctionForwarder"))
 839                 .toReturn(new ServiceFunctionForwarderBuilder().setName(new SffName("sff-name")).build());
 840
 841         final RenderedServicePath symmetricRenderedPath = ServiceChainingUtil.resolveReversedRenderedServicePath(sfp,
 842                 tenantId, dataBroker, sourceSgt, destinationSgt, context);
 843
 844         assertEquals("unit-sfp-02_plain-tenant-02-gbp-rsp-Reverse", rspNameCaptor.getValue().getValue());
 845         assertEquals(rsp, symmetricRenderedPath);
 846     }
 847
 848     @Test
 849     public void testFindServiceFunctionPath() throws Exception {
 850         final String sfcNameValue = "123";
 851         final ServiceFunctionPath sfcPath = createSfp(sfcNameValue);
 852         final ServiceFunctionPaths sfcPaths = new ServiceFunctionPathsBuilder()
 853                 .setServiceFunctionPath(Collections.singletonList(sfcPath))
 854                 .build();
 855
 856         stub(method(SfcProviderServicePathAPI.class, "readAllServiceFunctionPaths")).toReturn(sfcPaths);
 857
 858         final ServiceFunctionPath servicePath = ServiceChainingUtil.findServiceFunctionPathFromServiceChainName(new SfcName(sfcNameValue));
 859         assertEquals(sfcPath, servicePath);
 860     }
 861
 862     // Auxiliary methods
 863
 864     private RenderedServicePath buildRsp() {
 865         RenderedServicePathBuilder renderedServicePathBuilder = new RenderedServicePathBuilder();
 866         renderedServicePathBuilder.setRenderedServicePathHop(null);
 867         return renderedServicePathBuilder.build();
 868     }
 869
 870     private RenderedServicePath createRsp(final String rspNameValue) {
 871         return new RenderedServicePathBuilder()
 872                 .setName(new RspName(rspNameValue))
 873                 .setRenderedServicePathHop(Lists.newArrayList(createRspHop()))
 874                 .build();
 875     }
 876
 877     private RenderedServicePathHop createRspHop() {
 878         return new RenderedServicePathHopBuilder()
 879                 .setServiceFunctionName(new SfName("rsp-hop-01-sf"))
 880                 .setServiceFunctionForwarder(new SffName("rsp-hop-01-sf" + "+sff"))
 881                 .build();
 882     }
 883
 884     private ServiceFunctionPath createSfp(final String sfcNameValue) {
 885         return new ServiceFunctionPathBuilder()
 886                 .setServiceChainName(new SfcName(sfcNameValue))
 887                 .setName(new SfpName(sfcNameValue + "_plain"))
 888                 .setSymmetric(false)
 889                 .build();
 890     }
 891
 892     private PeerEndpoint peerEndpointBuilder() {
 893         final PeerEndpointBuilder peerEndpointBuilder = new PeerEndpointBuilder();
 894         final RuleGroupWithRendererEndpointParticipationBuilder ruleGroupBuilder =
 895                 new RuleGroupWithRendererEndpointParticipationBuilder();
 896         peerEndpointBuilder.setRuleGroupWithRendererEndpointParticipation(Collections.singletonList(ruleGroupBuilder.build()));
 897         return peerEndpointBuilder.build();
 898     }
 899
 900     private Map<ActionCase, ActionInDirection> resolvedActionBuilder(@Nonnull final RuleName ruleName,
 901                                                                      @Nonnull final ActionCase actionCase,
 902                                                                      @Nonnull final Action action,
 903                                                                      @Nonnull final Direction direction) {
 904         final ActionInDirection actionInDirection = new ActionInDirection(ruleName, action, PROVIDER, direction);
 905         return Collections.singletonMap(actionCase, actionInDirection);
 906     }
 907
 908     private PolicyConfigurationContext policyConfigurationContextBuilder() {
 909         final RendererEndpointBuilder rendererEndpointBuilder = new RendererEndpointBuilder();
 910         final PolicyConfigurationContext context = new PolicyConfigurationContext();
 911         context.setCurrentRendererEP(rendererEndpointBuilder.build());
 912         return context;
 913     }
 914
 915     private Sgt sgtBuilder(final int value) {
 916         return new Sgt(value);
 917     }
 918
 919     private Action actionBuilder(final List<ParameterValue> parameters) {
 920         final ActionBuilder actionBuilder = new ActionBuilder();
 921         actionBuilder.setParameterValue(parameters);
 922         return actionBuilder.build();
 923     }
 924
 925     private PolicyManagerImpl.PolicyMapLocation getLocation() {
 926         final String POLICY_MAP = "policy-map";
 927         final String INTERFACE = "interface";
 928         final NodeId nodeId = new NodeId("node-id");
 929         final String IP_ADDRESS = "ip-address";
 930         return new PolicyManagerImpl.PolicyMapLocation(POLICY_MAP, INTERFACE, nodeId, IP_ADDRESS, dataBroker);
 931     }
 932 }