integration-tests/src/test/java/org/opendaylight/protocol/integration/pcep/PcepRpcServicesRoutingTest.java

   1 /*
   2  * Copyright (c) 2013 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 package org.opendaylight.protocol.integration.pcep;
   9
  10 import static org.junit.Assert.assertNotNull;
  11 import static org.junit.Assert.assertNotSame;
  12 import static org.junit.Assert.assertSame;
  13 import static org.mockito.Mockito.mock;
  14 import static org.mockito.Mockito.verify;
  15 import static org.mockito.Mockito.verifyZeroInteractions;
  16 import static org.mockito.Mockito.when;
  17 import static org.ops4j.pax.exam.CoreOptions.frameworkProperty;
  18 import static org.ops4j.pax.exam.CoreOptions.junitBundles;
  19 import static org.ops4j.pax.exam.CoreOptions.mavenBundle;
  20 import static org.ops4j.pax.exam.CoreOptions.options;
  21 import com.google.common.util.concurrent.Futures;
  22 import com.google.common.util.concurrent.ListenableFuture;
  23 import java.lang.reflect.Method;
  24 import org.junit.Test;
  25 import org.junit.runner.RunWith;
  26 import org.mockito.Mockito;
  27 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  28 import org.opendaylight.controller.sal.binding.api.BindingAwareConsumer;
  29 import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.topology.rev140113.NetworkTopologyContext;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.network.topology.rev140113.NetworkTopologyRef;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.programming.rev131106.NetworkTopologyPcepProgrammingService;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.programming.rev131106.SubmitAddLspInput;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.programming.rev131106.SubmitAddLspInputBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.programming.rev131106.SubmitTriggerSyncInput;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.programming.rev131106.SubmitTriggerSyncInputBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.programming.rev131106.SubmitUpdateLspInput;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.programming.rev131106.SubmitUpdateLspInputBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.AddLspInput;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.AddLspInputBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.AddLspOutput;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.EnsureLspOperationalInput;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.EnsureLspOperationalInputBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.NetworkTopologyPcepService;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.TriggerSyncInput;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.TriggerSyncInputBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.pcep.rev131024.TriggerSyncOutput;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.programming.rev131030.PcepCreateP2pTunnelInput;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.programming.rev131030.PcepCreateP2pTunnelInputBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.programming.rev131030.PcepDestroyTunnelInput;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.programming.rev131030.PcepDestroyTunnelInputBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.topology.tunnel.pcep.programming.rev131030.TopologyTunnelPcepProgrammingService;
  53 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  54 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  55 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  56 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  57 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  58 import org.ops4j.pax.exam.Option;
  59 import org.ops4j.pax.exam.junit.PaxExam;
  60 import org.ops4j.pax.exam.options.DefaultCompositeOption;
  61 import org.ops4j.pax.exam.spi.reactors.ExamReactorStrategy;
  62 import org.ops4j.pax.exam.spi.reactors.PerClass;
  63
  64 @RunWith(PaxExam.class)
  65 @ExamReactorStrategy(PerClass.class)
  66 public class PcepRpcServicesRoutingTest extends AbstractPcepOsgiTest {
  67
  68     @Override
  69     protected Option[] getAdditionalOptions() {
  70         // register option to provide Mockito as a bundle dependency
  71         return options(
  72                 new DefaultCompositeOption(
  73                         // Repository required to load harmcrest (OSGi-fied version).
  74                         // Mockito
  75                         mavenBundle("org.mockito", "mockito-core", "1.10.19"),
  76                         mavenBundle("org.objenesis", "objenesis", "2.2"),
  77                         junitBundles(),
  78
  79                 /*
  80                  * Felix has implicit boot delegation enabled by default. It
  81                  * conflicts with Mockito: java.lang.LinkageError: loader
  82                  * constraint violation in interface itable initialization: when
  83                  * resolving method
  84                  * "org.osgi.service.useradmin.User$$EnhancerByMockitoWithCGLIB$$dd2f81dc
  85                  * .
  86                  * newInstance(Lorg/mockito/cglib/proxy/Callback;)Ljava/lang/Object
  87                  * ;" the class loader (instance of
  88                  * org/mockito/internal/creation/jmock/SearchingClassLoader) of
  89                  * the current class, org/osgi/service/useradmin/
  90                  * User$$EnhancerByMockitoWithCGLIB$$dd2f81dc, and the class
  91                  * loader (instance of org/apache/felix/framework/
  92                  * BundleWiringImpl$BundleClassLoaderJava5) for interface
  93                  * org/mockito/cglib/proxy/Factory have different Class objects
  94                  * for the type org/mockito/cglib/ proxy/Callback used in the
  95                  * signature
  96                  *
  97                  * So we disable the bootdelegation. this property has no effect
  98                  * on the other OSGi implementation.
  99                  */
 100                         frameworkProperty("felix.bootdelegation.implicit").value("false"))
 101         );
 102     }
 103
 104     private static <T> T getInputForRpc(final InstanceIdentifier<Topology> topology, final Class<?> builderClass, final Class<T> builtObjectClass) {
 105         try {
 106             final Object builderInstance = builderClass.newInstance();
 107             final Method method = builderClass.getMethod("setNetworkTopologyRef", NetworkTopologyRef.class);
 108             method.invoke(builderInstance, new NetworkTopologyRef(topology));
 109             return builtObjectClass.cast(builderClass.getMethod("build").invoke(builderInstance));
 110         } catch (final Exception e) {
 111             throw new RuntimeException("Unable to create instance from " + builderClass, e);
 112         }
 113     }
 114
 115     @Test
 116     public void testRoutedRpcNetworkTopologyPcepService() throws Exception {
 117         final NetworkTopologyPcepService pcepService1 = mock(NetworkTopologyPcepService.class, "First pcep Service");
 118         final NetworkTopologyPcepService pcepService2 = mock(NetworkTopologyPcepService.class, "Second pcep Service");
 119         initMock(pcepService1);
 120         initMock(pcepService2);
 121         assertNotNull(getBroker());
 122
 123         final InstanceIdentifier<Topology> topology = InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class,
 124                 new TopologyKey(getTopologyId("Topo1"))).build();
 125
 126         final BindingAwareProvider provider1 = new AbstractTestProvider() {
 127
 128             @Override
 129             public void onSessionInitiated(final BindingAwareBroker.ProviderContext session) {
 130                 assertNotNull(session);
 131                 final BindingAwareBroker.RoutedRpcRegistration<NetworkTopologyPcepService> firstReg = session.addRoutedRpcImplementation(
 132                         NetworkTopologyPcepService.class, pcepService1);
 133                 assertNotNull("Registration should not be null", firstReg);
 134                 assertSame(pcepService1, firstReg.getInstance());
 135
 136                 firstReg.registerPath(NetworkTopologyContext.class, topology);
 137             }
 138         };
 139
 140         this.broker.registerProvider(provider1);
 141
 142         final InstanceIdentifier<Topology> topology2 = InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class,
 143                 new TopologyKey(getTopologyId("Topo2"))).build();
 144
 145         final BindingAwareProvider provider2 = new AbstractTestProvider() {
 146
 147             @Override
 148             public void onSessionInitiated(final BindingAwareBroker.ProviderContext session) {
 149                 assertNotNull(session);
 150                 final BindingAwareBroker.RoutedRpcRegistration<NetworkTopologyPcepService> secondReg = session.addRoutedRpcImplementation(
 151                         NetworkTopologyPcepService.class, pcepService2);
 152                 secondReg.registerPath(NetworkTopologyContext.class, topology2);
 153             }
 154         };
 155
 156         this.broker.registerProvider(provider2);
 157
 158         final BindingAwareConsumer consumer = new BindingAwareConsumer() {
 159             @Override
 160             public void onSessionInitialized(final BindingAwareBroker.ConsumerContext session) {
 161                 final NetworkTopologyPcepService consumerPcepService = session.getRpcService(NetworkTopologyPcepService.class);
 162
 163                 assertNotNull(consumerPcepService);
 164                 assertNotSame(pcepService1, consumerPcepService);
 165                 assertNotSame(pcepService2, consumerPcepService);
 166
 167                 testAddLspRpce(consumerPcepService);
 168                 testEnsureLspRpce(consumerPcepService);
 169                 testTriggerSyncRpce(consumerPcepService);
 170             }
 171
 172             private void testAddLspRpce(final NetworkTopologyPcepService consumerPcepService) {
 173                 AddLspInput addLspInput = getInputForRpc(topology, AddLspInputBuilder.class, AddLspInput.class);
 174                 consumerPcepService.addLsp(addLspInput);
 175
 176                 verify(pcepService1).addLsp(addLspInput);
 177                 verifyZeroInteractions(pcepService2);
 178
 179                 addLspInput = getInputForRpc(topology2, AddLspInputBuilder.class, AddLspInput.class);
 180
 181                 consumerPcepService.addLsp(addLspInput);
 182
 183                 verifyZeroInteractions(pcepService1);
 184                 verify(pcepService2).addLsp(addLspInput);
 185             }
 186
 187             private void testTriggerSyncRpce(final NetworkTopologyPcepService consumerPcepService) {
 188                 TriggerSyncInput triggerInput = getInputForRpc(topology, TriggerSyncInputBuilder.class,
 189                         TriggerSyncInput.class);
 190                 consumerPcepService.triggerSync(triggerInput);
 191
 192                 verify(pcepService1).triggerSync(triggerInput);
 193                 verifyZeroInteractions(pcepService2);
 194
 195                 triggerInput = getInputForRpc(topology2, TriggerSyncInputBuilder.class, TriggerSyncInput.class);
 196
 197                 consumerPcepService.triggerSync(triggerInput);
 198
 199                 verifyZeroInteractions(pcepService1);
 200                 verify(pcepService2).triggerSync(triggerInput);
 201             }
 202
 203             private void testEnsureLspRpce(final NetworkTopologyPcepService consumerPcepService) {
 204                 EnsureLspOperationalInput ensureInput = getInputForRpc(topology, EnsureLspOperationalInputBuilder.class,
 205                         EnsureLspOperationalInput.class);
 206
 207                 consumerPcepService.ensureLspOperational(ensureInput);
 208
 209                 verify(pcepService1).ensureLspOperational(ensureInput);
 210                 verifyZeroInteractions(pcepService2);
 211
 212                 ensureInput = getInputForRpc(topology2, EnsureLspOperationalInputBuilder.class, EnsureLspOperationalInput.class);
 213
 214                 consumerPcepService.ensureLspOperational(ensureInput);
 215
 216                 verifyZeroInteractions(pcepService1);
 217                 verify(pcepService2).ensureLspOperational(ensureInput);
 218             }
 219         };
 220         this.broker.registerConsumer(consumer);
 221     }
 222
 223     @SuppressWarnings("unchecked")
 224     private void initMock(final NetworkTopologyPcepService pcepService) {
 225         @SuppressWarnings("rawtypes")
 226         final ListenableFuture future = Futures.immediateFuture(RpcResultBuilder.<AddLspOutput>success().build());
 227         final ListenableFuture futureSyncTrigger = Futures.immediateFuture(RpcResultBuilder.<TriggerSyncOutput>success().build());
 228
 229         when(pcepService.addLsp(Mockito.any())).thenReturn(future);
 230         when(pcepService.removeLsp(Mockito.any())).thenReturn(future);
 231         when(pcepService.triggerSync(Mockito.any())).thenReturn(futureSyncTrigger);
 232         when(pcepService.ensureLspOperational(Mockito.any())).thenReturn(future);
 233         when(pcepService.updateLsp(Mockito.any())).thenReturn(future);
 234
 235     }
 236
 237     @Test
 238     public void testRoutedRpcNetworkTopologyPcepProgrammingService() throws Exception {
 239         final NetworkTopologyPcepProgrammingService pcepService1 = mock(NetworkTopologyPcepProgrammingService.class,
 240                 "First pcep program Service");
 241         final NetworkTopologyPcepProgrammingService pcepService2 = mock(NetworkTopologyPcepProgrammingService.class,
 242                 "Second pcep program Service");
 243         initMock(pcepService1);
 244         initMock(pcepService2);
 245         assertNotNull(getBroker());
 246
 247         final InstanceIdentifier<Topology> topology = InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class,
 248                 new TopologyKey(getTopologyId("Topo1"))).build();
 249
 250         final BindingAwareProvider provider1 = new AbstractTestProvider() {
 251             @Override
 252             public void onSessionInitiated(final BindingAwareBroker.ProviderContext session) {
 253                 assertNotNull(session);
 254                 final BindingAwareBroker.RoutedRpcRegistration<NetworkTopologyPcepProgrammingService> firstReg = session.addRoutedRpcImplementation(
 255                         NetworkTopologyPcepProgrammingService.class, pcepService1);
 256                 assertNotNull("Registration should not be null", firstReg);
 257                 assertSame(pcepService1, firstReg.getInstance());
 258
 259                 firstReg.registerPath(NetworkTopologyContext.class, topology);
 260             }
 261         };
 262
 263         this.broker.registerProvider(provider1);
 264
 265         final InstanceIdentifier<Topology> topology2 = InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class,
 266                 new TopologyKey(getTopologyId("Topo2"))).build();
 267
 268         final BindingAwareProvider provider2 = new AbstractTestProvider() {
 269             @Override
 270             public void onSessionInitiated(final BindingAwareBroker.ProviderContext session) {
 271                 assertNotNull(session);
 272                 final BindingAwareBroker.RoutedRpcRegistration<NetworkTopologyPcepProgrammingService> secondReg = session.addRoutedRpcImplementation(
 273                         NetworkTopologyPcepProgrammingService.class, pcepService2);
 274                 secondReg.registerPath(NetworkTopologyContext.class, topology2);
 275             }
 276         };
 277
 278         this.broker.registerProvider(provider2);
 279
 280         final BindingAwareConsumer consumer = new BindingAwareConsumer() {
 281             @Override
 282             public void onSessionInitialized(final BindingAwareBroker.ConsumerContext session) {
 283                 final NetworkTopologyPcepProgrammingService consumerPcepService = session.getRpcService(NetworkTopologyPcepProgrammingService.class);
 284
 285                 assertNotNull(consumerPcepService);
 286                 assertNotSame(pcepService1, consumerPcepService);
 287                 assertNotSame(pcepService2, consumerPcepService);
 288
 289                 testSubmitAddLspRpc(consumerPcepService);
 290                 testSubmitUpdateLspRpc(consumerPcepService);
 291                 testTriggerSyncRpc(consumerPcepService);
 292             }
 293
 294             private void testSubmitAddLspRpc(final NetworkTopologyPcepProgrammingService consumerPcepService) {
 295                 SubmitAddLspInput addLspInput = getInputForRpc(topology, SubmitAddLspInputBuilder.class, SubmitAddLspInput.class);
 296                 consumerPcepService.submitAddLsp(addLspInput);
 297
 298                 verify(pcepService1).submitAddLsp(addLspInput);
 299                 verifyZeroInteractions(pcepService2);
 300
 301                 addLspInput = getInputForRpc(topology2, SubmitAddLspInputBuilder.class, SubmitAddLspInput.class);
 302
 303                 consumerPcepService.submitAddLsp(addLspInput);
 304
 305                 verifyZeroInteractions(pcepService1);
 306                 verify(pcepService2).submitAddLsp(addLspInput);
 307             }
 308
 309             private void testSubmitUpdateLspRpc(final NetworkTopologyPcepProgrammingService consumerPcepService) {
 310                 SubmitUpdateLspInput submitLspInput = getInputForRpc(topology, SubmitUpdateLspInputBuilder.class,
 311                         SubmitUpdateLspInput.class);
 312                 consumerPcepService.submitUpdateLsp(submitLspInput);
 313
 314                 verify(pcepService1).submitUpdateLsp(submitLspInput);
 315                 verifyZeroInteractions(pcepService2);
 316
 317                 submitLspInput = getInputForRpc(topology2, SubmitUpdateLspInputBuilder.class, SubmitUpdateLspInput.class);
 318
 319                 consumerPcepService.submitUpdateLsp(submitLspInput);
 320
 321                 verifyZeroInteractions(pcepService1);
 322                 verify(pcepService2).submitUpdateLsp(submitLspInput);
 323             }
 324
 325             private void testTriggerSyncRpc(final NetworkTopologyPcepProgrammingService consumerPcepService) {
 326                 SubmitTriggerSyncInput submitTriggerSyncInput = getInputForRpc(topology,
 327                         SubmitTriggerSyncInputBuilder.class,
 328                         SubmitTriggerSyncInput.class);
 329                 consumerPcepService.submitTriggerSync(submitTriggerSyncInput);
 330
 331                 verify(pcepService1).submitTriggerSync(submitTriggerSyncInput);
 332                 verifyZeroInteractions(pcepService2);
 333
 334                 submitTriggerSyncInput = getInputForRpc(topology2, SubmitTriggerSyncInputBuilder.class,
 335                         SubmitTriggerSyncInput.class);
 336
 337                 consumerPcepService.submitTriggerSync(submitTriggerSyncInput);
 338
 339                 verifyZeroInteractions(pcepService1);
 340                 verify(pcepService2).submitTriggerSync(submitTriggerSyncInput);
 341             }
 342         };
 343         this.broker.registerConsumer(consumer);
 344     }
 345
 346     @SuppressWarnings("unchecked")
 347     private void initMock(final NetworkTopologyPcepProgrammingService pcepService) {
 348         @SuppressWarnings("rawtypes")
 349         final ListenableFuture future = Futures.immediateFuture(RpcResultBuilder.<AddLspOutput>success().build());
 350         final ListenableFuture futureTriggerSync = Futures.immediateFuture(RpcResultBuilder.<TriggerSyncOutput>success().build());
 351         when(pcepService.submitAddLsp(Mockito.any())).thenReturn(future);
 352         when(pcepService.submitRemoveLsp(Mockito.any())).thenReturn(future);
 353         when(pcepService.submitTriggerSync(Mockito.any())).thenReturn(futureTriggerSync);
 354         when(pcepService.submitEnsureLspOperational(Mockito.any())).thenReturn(future);
 355         when(pcepService.submitUpdateLsp(Mockito.any())).thenReturn(future);
 356     }
 357
 358     @Test
 359     public void testRoutedRpcTopologyTunnelPcepProgrammingService() throws Exception {
 360         final TopologyTunnelPcepProgrammingService pcepService1 = mock(TopologyTunnelPcepProgrammingService.class,
 361                 "First pcep program Service");
 362         final TopologyTunnelPcepProgrammingService pcepService2 = mock(TopologyTunnelPcepProgrammingService.class,
 363                 "Second pcep program Service");
 364         initMock(pcepService1);
 365         initMock(pcepService2);
 366         assertNotNull(getBroker());
 367
 368         final InstanceIdentifier<Topology> topology = InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class,
 369                 new TopologyKey(getTopologyId("Topo1"))).build();
 370
 371         final BindingAwareProvider provider1 = new AbstractTestProvider() {
 372             @Override
 373             public void onSessionInitiated(final BindingAwareBroker.ProviderContext session) {
 374                 assertNotNull(session);
 375                 final BindingAwareBroker.RoutedRpcRegistration<TopologyTunnelPcepProgrammingService> firstReg = session.addRoutedRpcImplementation(
 376                         TopologyTunnelPcepProgrammingService.class, pcepService1);
 377                 assertNotNull("Registration should not be null", firstReg);
 378                 assertSame(pcepService1, firstReg.getInstance());
 379
 380                 firstReg.registerPath(NetworkTopologyContext.class, topology);
 381             }
 382         };
 383
 384         this.broker.registerProvider(provider1);
 385
 386         final InstanceIdentifier<Topology> topology2 = InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class,
 387                 new TopologyKey(getTopologyId("Topo2"))).build();
 388
 389         final BindingAwareProvider provider2 = new AbstractTestProvider() {
 390             @Override
 391             public void onSessionInitiated(final BindingAwareBroker.ProviderContext session) {
 392                 assertNotNull(session);
 393                 final BindingAwareBroker.RoutedRpcRegistration<TopologyTunnelPcepProgrammingService> secondReg = session.addRoutedRpcImplementation(
 394                         TopologyTunnelPcepProgrammingService.class, pcepService2);
 395                 secondReg.registerPath(NetworkTopologyContext.class, topology2);
 396             }
 397         };
 398
 399         this.broker.registerProvider(provider2);
 400
 401         final BindingAwareConsumer consumer = new BindingAwareConsumer() {
 402             @Override
 403             public void onSessionInitialized(final BindingAwareBroker.ConsumerContext session) {
 404                 final TopologyTunnelPcepProgrammingService consumerPcepService = session.getRpcService(TopologyTunnelPcepProgrammingService.class);
 405
 406                 assertNotNull(consumerPcepService);
 407                 assertNotSame(pcepService1, consumerPcepService);
 408                 assertNotSame(pcepService2, consumerPcepService);
 409
 410                 testCreateP2pTunnel(consumerPcepService);
 411                 testDestroyP2pTunnel(consumerPcepService);
 412             }
 413
 414             private void testCreateP2pTunnel(final TopologyTunnelPcepProgrammingService consumerPcepService) {
 415                 PcepCreateP2pTunnelInput addLspInput = getInputForRpc(topology, PcepCreateP2pTunnelInputBuilder.class,
 416                         PcepCreateP2pTunnelInput.class);
 417                 consumerPcepService.pcepCreateP2pTunnel(addLspInput);
 418
 419                 verify(pcepService1).pcepCreateP2pTunnel(addLspInput);
 420                 verifyZeroInteractions(pcepService2);
 421
 422                 addLspInput = getInputForRpc(topology2, PcepCreateP2pTunnelInputBuilder.class, PcepCreateP2pTunnelInput.class);
 423
 424                 consumerPcepService.pcepCreateP2pTunnel(addLspInput);
 425
 426                 verifyZeroInteractions(pcepService1);
 427                 verify(pcepService2).pcepCreateP2pTunnel(addLspInput);
 428             }
 429
 430             private void testDestroyP2pTunnel(final TopologyTunnelPcepProgrammingService consumerPcepService) {
 431                 PcepDestroyTunnelInput addLspInput = getInputForRpc(topology, PcepDestroyTunnelInputBuilder.class,
 432                         PcepDestroyTunnelInput.class);
 433                 consumerPcepService.pcepDestroyTunnel(addLspInput);
 434
 435                 verify(pcepService1).pcepDestroyTunnel(addLspInput);
 436                 verifyZeroInteractions(pcepService2);
 437
 438                 addLspInput = getInputForRpc(topology2, PcepDestroyTunnelInputBuilder.class, PcepDestroyTunnelInput.class);
 439
 440                 consumerPcepService.pcepDestroyTunnel(addLspInput);
 441
 442                 verifyZeroInteractions(pcepService1);
 443                 verify(pcepService2).pcepDestroyTunnel(addLspInput);
 444             }
 445         };
 446         this.broker.registerConsumer(consumer);
 447     }
 448
 449     private void initMock(final TopologyTunnelPcepProgrammingService pcepService) {
 450         @SuppressWarnings("rawtypes")
 451         final ListenableFuture future = Futures.immediateFuture(RpcResultBuilder.<AddLspOutput>success().build());
 452         when(pcepService.pcepCreateP2pTunnel(Mockito.any())).thenReturn(future);
 453         when(pcepService.pcepDestroyTunnel(Mockito.any())).thenReturn(future);
 454         when(pcepService.pcepUpdateTunnel(Mockito.any())).thenReturn(future);
 455     }
 456
 457 }