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