bgp/rib-impl/src/test/java/org/opendaylight/controller/config/yang/bgp/rib/impl/AbstractRIBImplModuleTest.java

   1 /*
   2  * Copyright (c) 2014 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.controller.config.yang.bgp.rib.impl;
   9
  10 import static org.mockito.Matchers.any;
  11 import static org.mockito.Matchers.anyInt;
  12 import static org.mockito.Matchers.anyString;
  13 import static org.mockito.Matchers.contains;
  14 import static org.mockito.Mockito.doAnswer;
  15 import static org.mockito.Mockito.doNothing;
  16 import static org.mockito.Mockito.doReturn;
  17 import static org.mockito.Mockito.mock;
  18
  19 import com.google.common.base.Optional;
  20 import com.google.common.collect.Lists;
  21 import com.google.common.io.ByteSource;
  22 import com.google.common.io.Resources;
  23 import com.google.common.util.concurrent.CheckedFuture;
  24 import io.netty.channel.EventLoopGroup;
  25 import io.netty.util.concurrent.EventExecutor;
  26 import io.netty.util.concurrent.ImmediateEventExecutor;
  27 import io.netty.util.concurrent.SucceededFuture;
  28 import java.io.IOException;
  29 import java.net.InetSocketAddress;
  30 import java.net.URL;
  31 import java.util.ArrayList;
  32 import java.util.Collection;
  33 import java.util.Collections;
  34 import java.util.List;
  35 import javax.management.InstanceAlreadyExistsException;
  36 import javax.management.InstanceNotFoundException;
  37 import javax.management.ObjectName;
  38 import org.junit.After;
  39 import org.junit.Assert;
  40 import org.junit.Before;
  41 import org.mockito.Matchers;
  42 import org.mockito.Mock;
  43 import org.mockito.Mockito;
  44 import org.mockito.MockitoAnnotations;
  45 import org.opendaylight.controller.config.api.jmx.CommitStatus;
  46 import org.opendaylight.controller.config.manager.impl.AbstractConfigTest;
  47 import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver;
  48 import org.opendaylight.controller.config.spi.ModuleFactory;
  49 import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
  50 import org.opendaylight.controller.config.yang.bgp.rib.spi.RIBExtensionsImplModuleFactory;
  51 import org.opendaylight.controller.config.yang.bgp.rib.spi.RIBExtensionsImplModuleMXBean;
  52 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingAsyncDataBrokerImplModuleFactory;
  53 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingAsyncDataBrokerImplModuleMXBean;
  54 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingBrokerImplModuleFactory;
  55 import org.opendaylight.controller.config.yang.md.sal.binding.impl.BindingBrokerImplModuleMXBean;
  56 import org.opendaylight.controller.config.yang.md.sal.binding.impl.ForwardedCompatibleDataBrokerImplModuleFactory;
  57 import org.opendaylight.controller.config.yang.md.sal.binding.impl.ForwardedCompatibleDataBrokerImplModuleMXBean;
  58 import org.opendaylight.controller.config.yang.md.sal.binding.impl.NotificationBrokerImplModuleFactory;
  59 import org.opendaylight.controller.config.yang.md.sal.binding.impl.RuntimeMappingModuleFactory;
  60 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomBrokerImplModuleFactory;
  61 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomBrokerImplModuleMXBean;
  62 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomInmemoryDataBrokerModuleFactory;
  63 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomInmemoryDataBrokerModuleMXBean;
  64 import org.opendaylight.controller.config.yang.md.sal.dom.impl.SchemaServiceImplSingletonModuleFactory;
  65 import org.opendaylight.controller.config.yang.netty.eventexecutor.AutoCloseableEventExecutor;
  66 import org.opendaylight.controller.config.yang.netty.eventexecutor.GlobalEventExecutorModuleFactory;
  67 import org.opendaylight.controller.config.yang.netty.threadgroup.NettyThreadgroupModuleFactory;
  68 import org.opendaylight.controller.config.yang.netty.threadgroup.NioEventLoopGroupCloseable;
  69 import org.opendaylight.controller.config.yang.netty.timer.HashedWheelTimerModuleFactory;
  70 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  71 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  72 import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
  73 import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodecFactory;
  74 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
  75 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  76 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  77 import org.opendaylight.controller.md.sal.dom.api.DOMDataTreeChangeService;
  78 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
  79 import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
  80 import org.opendaylight.controller.md.sal.dom.api.DOMNotificationPublishService;
  81 import org.opendaylight.controller.md.sal.dom.api.DOMNotificationService;
  82 import org.opendaylight.controller.md.sal.dom.api.DOMRpcProviderService;
  83 import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
  84 import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
  85 import org.opendaylight.controller.sal.core.api.model.SchemaService;
  86 import org.opendaylight.controller.sal.core.api.model.YangTextSourceProvider;
  87 import org.opendaylight.protocol.bgp.openconfig.spi.BGPOpenConfigMappingService;
  88 import org.opendaylight.protocol.bgp.parser.spi.BGPExtensionProviderContext;
  89 import org.opendaylight.protocol.bgp.parser.spi.MessageRegistry;
  90 import org.opendaylight.protocol.bgp.rib.impl.StrictBGPPeerRegistry;
  91 import org.opendaylight.protocol.bgp.rib.impl.spi.BGPDispatcher;
  92 import org.opendaylight.protocol.bgp.rib.impl.spi.BGPPeerRegistry;
  93 import org.opendaylight.protocol.bgp.rib.impl.spi.BgpDeployer;
  94 import org.opendaylight.protocol.bgp.rib.impl.spi.ImportPolicyPeerTracker;
  95 import org.opendaylight.protocol.bgp.rib.impl.spi.RIB;
  96 import org.opendaylight.protocol.bgp.rib.impl.spi.RIBSupportContextRegistry;
  97 import org.opendaylight.protocol.bgp.rib.impl.stats.UnsignedInt32Counter;
  98 import org.opendaylight.protocol.bgp.rib.impl.stats.rib.impl.BGPRenderStats;
  99 import org.opendaylight.protocol.bgp.rib.spi.RIBExtensionProviderContext;
 100 import org.opendaylight.protocol.bgp.rib.spi.SimpleRIBExtensionProviderContext;
 101 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.neighbors.Neighbor;
 102 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.neighbors.NeighborBuilder;
 103 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.neighbors.NeighborKey;
 104 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.top.Bgp;
 105 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.bgp.rev151009.bgp.top.bgp.Global;
 106 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.NetworkInstances;
 107 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.NetworkInstance;
 108 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.NetworkInstanceKey;
 109 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.network.instance.protocols.ProtocolBuilder;
 110 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.network.instance.rev151018.network.instance.top.network.instances.network.instance.protocols.ProtocolKey;
 111 import org.opendaylight.yang.gen.v1.http.openconfig.net.yang.policy.types.rev151009.BGP;
 112 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.AsNumber;
 113 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
 114 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev160614.Protocol1;
 115 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.openconfig.extensions.rev160614.Protocol1Builder;
 116 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.BgpRib;
 117 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.RibId;
 118 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.bgp.rib.Rib;
 119 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.bgp.rib.RibKey;
 120 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.BgpId;
 121 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.ClusterIdentifier;
 122 import org.opendaylight.yangtools.concepts.ListenerRegistration;
 123 import org.opendaylight.yangtools.sal.binding.generator.api.ClassLoadingStrategy;
 124 import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy;
 125 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 126 import org.opendaylight.yangtools.yang.common.RpcResult;
 127 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 128 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
 129 import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
 130 import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
 131 import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
 132 import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.YangInferencePipeline;
 133 import org.osgi.framework.Bundle;
 134 import org.osgi.framework.BundleListener;
 135 import org.osgi.framework.Filter;
 136 import org.osgi.framework.ServiceListener;
 137 import org.osgi.framework.ServiceReference;
 138
 139 public abstract class AbstractRIBImplModuleTest extends AbstractConfigTest {
 140
 141     private static final String INSTANCE_NAME = "rib-impl";
 142     private static final String FACTORY_NAME = RIBImplModuleFactory.NAME;
 143     private static final String TRANSACTION_NAME = "testTransaction";
 144
 145     protected static final RibId RIB_ID = new RibId("test");
 146     protected static final BgpId BGP_ID = new BgpId("192.168.1.1");
 147     private static final Neighbor NEIGHBOR = new NeighborBuilder().setKey(new NeighborKey(new IpAddress(BGP_ID))).build();
 148     protected static final ClusterIdentifier CLUSTER_ID = new ClusterIdentifier("192.168.1.2");
 149
 150     private static final AsNumber AS_NUMBER = new AsNumber(5000L);
 151     private static final String SESSION_RS_INSTANCE_NAME = "session-reconnect-strategy-factory";
 152     private static final String TCP_RS_INSTANCE_NAME = "tcp-reconnect-strategy-factory";
 153     private static final String RIB_EXTENSIONS_INSTANCE_NAME = "rib-extensions-impl";
 154     private static final String DOM_BROKER_INSTANCE_NAME = "dom-broker-impl";
 155     private static final String BINDING_ASYNC_BROKER_INSTANCE_NAME = "binding-async-broker-instance";
 156     private static final String DOM_ASYNC_DATA_BROKER_INSTANCE = "dom-inmemory-data-broker";
 157     private static final String BINDING_BROKER_INSTANCE_NAME = "binding-broker-impl";
 158     private static final String COMPATIBLE_DATA_BROKER_INSTANCE_NAME = "binding-data-compatible-broker-instance";
 159     private static final String NOTIFICATION_BROKER_INSTANCE_NAME = "notification-broker-impl";
 160
 161     private static final InstanceIdentifier<NetworkInstance> OPENCONFIG_IID = InstanceIdentifier.create(NetworkInstances.class).child(NetworkInstance.class,
 162             new NetworkInstanceKey("global-bgp"));
 163
 164     @Mock
 165     private ReadWriteTransaction mockedTransaction;
 166
 167     @Mock
 168     private DataBroker mockedDataProvider;
 169
 170     @Mock
 171     private CheckedFuture<Void, TransactionCommitFailedException> mockedFuture;
 172
 173     @Mock
 174     private RpcResult<TransactionStatus> mockedResult;
 175
 176     @Mock
 177     protected BGPDispatcher mockedBGPDispatcher;
 178
 179     @Mock
 180     private RIB mockedRIB;
 181
 182     @Mock
 183     private BgpDeployer bgpDeployer;
 184
 185     @Mock
 186     private BGPOpenConfigMappingService bgpMappingService;
 187
 188     @Mock
 189     private BGPPeerRuntimeMXBean mockedPeer;
 190
 191     @SuppressWarnings("unchecked")
 192     @Before
 193     public void setUp() throws Exception {
 194         MockitoAnnotations.initMocks(this);
 195
 196         final List<ModuleFactory> moduleFactories = getModuleFactories();
 197         super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(this.mockedContext, moduleFactories.toArray(new ModuleFactory[moduleFactories.size()])));
 198
 199         doAnswer(invocation -> {
 200             final String str = invocation.getArgumentAt(0, String.class);
 201             final Filter mockFilter = mock(Filter.class);
 202             doReturn(str).when(mockFilter).toString();
 203             return mockFilter;
 204         }).when(this.mockedContext).createFilter(anyString());
 205
 206         final ServiceReference<?> emptyServiceReference = mock(ServiceReference.class, "Empty");
 207         final ServiceReference<?> classLoadingStrategySR = mock(ServiceReference.class, "ClassLoadingStrategy");
 208         final ServiceReference<?> dataProviderServiceReference = mock(ServiceReference.class, "Data Provider");
 209
 210         Mockito.doNothing().when(this.mockedContext).addServiceListener(any(ServiceListener.class), Mockito.anyString());
 211         Mockito.doNothing().when(this.mockedContext).removeServiceListener(any(ServiceListener.class));
 212
 213         Mockito.doNothing().when(this.mockedContext).addBundleListener(any(BundleListener.class));
 214         Mockito.doNothing().when(this.mockedContext).removeBundleListener(any(BundleListener.class));
 215
 216         Mockito.doReturn(new Bundle[] {}).when(this.mockedContext).getBundles();
 217
 218         Mockito.doReturn(new ServiceReference[] {}).when(this.mockedContext).getServiceReferences(Matchers.anyString(), Matchers.anyString());
 219
 220         Mockito.doReturn("Empty reference").when(emptyServiceReference).toString();
 221         Mockito.doReturn("Data Provider Service Reference").when(dataProviderServiceReference).toString();
 222         Mockito.doReturn("Class loading stategy reference").when(classLoadingStrategySR).toString();
 223
 224         Mockito.doReturn(emptyServiceReference).when(this.mockedContext).getServiceReference(Mockito.anyString());
 225         Mockito.doReturn(dataProviderServiceReference).when(this.mockedContext).getServiceReference(DataBroker.class);
 226         Mockito.doReturn(classLoadingStrategySR).when(this.mockedContext).getServiceReference(GeneratedClassLoadingStrategy.class);
 227         Mockito.doReturn(classLoadingStrategySR).when(this.mockedContext).getServiceReference(ClassLoadingStrategy.class);
 228
 229         Mockito.doReturn(this.mockedDataProvider).when(this.mockedContext).getService(dataProviderServiceReference);
 230         Mockito.doReturn(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy()).when(this.mockedContext).getService(classLoadingStrategySR);
 231         Mockito.doReturn(null).when(this.mockedContext).getService(emptyServiceReference);
 232
 233         Mockito.doReturn(this.mockedTransaction).when(this.mockedDataProvider).newReadWriteTransaction();
 234
 235         Mockito.doReturn(null).when(this.mockedTransaction).read(Mockito.eq(LogicalDatastoreType.OPERATIONAL), Mockito.any());
 236         Mockito.doNothing().when(this.mockedTransaction).put(Mockito.eq(LogicalDatastoreType.OPERATIONAL), Mockito.any(), Mockito.any());
 237         Mockito.doNothing().when(this.mockedTransaction).delete(Mockito.eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));
 238
 239         Mockito.doReturn(this.mockedFuture).when(this.mockedTransaction).submit();
 240         Mockito.doReturn(TRANSACTION_NAME).when(this.mockedTransaction).getIdentifier();
 241
 242         Mockito.doReturn(null).when(this.mockedFuture).get();
 243         Mockito.doReturn(null).when(this.mockedFuture).checkedGet();
 244
 245         final SchemaContext context = parseYangStreams(getFilesAsByteSources(getYangModelsPaths()));
 246         final SchemaService mockedSchemaService = mock(SchemaService.class);
 247         doReturn(context).when(mockedSchemaService).getGlobalContext();
 248         doAnswer(invocation -> {
 249             invocation.getArgumentAt(0, SchemaContextListener.class).onGlobalContextUpdated(context);
 250             final ListenerRegistration<SchemaContextListener> reg = mock(ListenerRegistration.class);
 251             doNothing().when(reg).close();
 252             return reg;
 253         }).when(mockedSchemaService).registerSchemaContextListener(any(SchemaContextListener.class));
 254
 255         setupMockService(SchemaService.class, mockedSchemaService);
 256         setupMockService(YangTextSourceProvider.class, mock(YangTextSourceProvider.class));
 257
 258         final BindingToNormalizedNodeCodec bindingCodec = BindingToNormalizedNodeCodecFactory.newInstance(
 259                 GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy());
 260         BindingToNormalizedNodeCodecFactory.registerInstance(bindingCodec, mockedSchemaService);
 261         setupMockService(BindingToNormalizedNodeCodec.class, bindingCodec);
 262
 263         final BGPExtensionProviderContext mockContext = mock(BGPExtensionProviderContext.class);
 264         doReturn(mock(MessageRegistry.class)).when(mockContext).getMessageRegistry();
 265         setupMockService(BGPExtensionProviderContext.class, mockContext);
 266
 267         setupMockService(EventLoopGroup.class, NioEventLoopGroupCloseable.newInstance(0));
 268         setupMockService(EventExecutor.class, AutoCloseableEventExecutor.CloseableEventExecutorMixin.globalEventExecutor());
 269
 270         setupMockService(DOMNotificationService.class, mock(DOMNotificationService.class));
 271         setupMockService(DOMNotificationPublishService.class, mock(DOMNotificationPublishService.class));
 272         setupMockService(DOMRpcService.class, mock(DOMRpcService.class));
 273         setupMockService(DOMRpcProviderService.class, mock(DOMRpcProviderService.class));
 274         setupMockService(DOMMountPointService.class, mock(DOMMountPointService.class));
 275
 276         setupMockService(BGPDispatcher.class, this.mockedBGPDispatcher);
 277         doReturn(new SucceededFuture<>(ImmediateEventExecutor.INSTANCE, null)).when(this.mockedBGPDispatcher).createReconnectingClient(
 278                 any(InetSocketAddress.class), any(BGPPeerRegistry.class), anyInt(), any(Optional.class));
 279
 280         setupMockService(BgpDeployer.class, this.bgpDeployer);
 281         final Global global = mock(Global.class);
 282         final Bgp globalBgp = mock(Bgp.class);
 283         doReturn(global).when(globalBgp).getGlobal();
 284         doReturn("global").when(global).toString();
 285         doReturn(new ProtocolBuilder().setKey(new ProtocolKey(BGP.class, "bgp"))
 286             .addAugmentation(Protocol1.class, new Protocol1Builder().setBgp(globalBgp).build()).build())
 287             .when(this.bgpMappingService).fromRib(any(), any(), any(), any(), any(), any());
 288         doNothing().when(this.bgpDeployer).onGlobalCreated(any(),any(),any());
 289         doReturn(NEIGHBOR).when(this.bgpMappingService).fromBgpPeer(any(), any(),
 290                 any(), any(), any(), any(), any(), any(), any(), any(), any());
 291         doReturn(NEIGHBOR).when(this.bgpMappingService).fromApplicationPeer(any(), any());
 292         doReturn(this.mockedFuture).when(this.bgpDeployer).writeConfiguration(any(), any());
 293         doReturn(this.mockedFuture).when(this.bgpDeployer).removeConfiguration(any());
 294         doReturn(this.bgpMappingService).when(this.bgpDeployer).getMappingService();
 295         doReturn(OPENCONFIG_IID).when(this.bgpDeployer).getInstanceIdentifier();
 296         final DOMTransactionChain mockedChain = mock(DOMTransactionChain.class);
 297         final DOMDataWriteTransaction mockedWTx = mock(DOMDataWriteTransaction.class);
 298         doNothing().when(mockedWTx).put(any(), any(), any());
 299         doNothing().when(mockedWTx).delete(any(), any());
 300         doReturn(this.mockedFuture).when(mockedWTx).submit();
 301         doReturn(mockedWTx).when(mockedChain).newWriteOnlyTransaction();
 302         doReturn(mockedChain).when(this.mockedRIB).createPeerChain(any());
 303         doNothing().when(mockedChain).close();
 304         doReturn(YangInstanceIdentifier.of(BgpRib.QNAME)).when(this.mockedRIB).getYangRibId();
 305         doReturn(new AsNumber(123456l)).when(this.mockedRIB).getLocalAs();
 306         doReturn(BGP_ID).when(this.mockedRIB).getBgpIdentifier();
 307         doReturn(Optional.absent()).when(this.mockedRIB).getOpenConfigProvider();
 308         final BGPRenderStats mockedRenderStats = mock(BGPRenderStats.class);
 309         doReturn(new UnsignedInt32Counter("counter")).when(mockedRenderStats).getConfiguredPeerCounter();
 310         doReturn(mockedRenderStats).when(this.mockedRIB).getRenderStats();
 311         final DOMDataTreeChangeService mockedTreeChangeService = mock(DOMDataTreeChangeService.class);
 312         final ListenerRegistration mockedListenerReg = mock(ListenerRegistration.class);
 313         doNothing().when(mockedListenerReg).close();
 314         doReturn(mockedListenerReg).when(mockedTreeChangeService).registerDataTreeChangeListener(any(), any());
 315         doReturn(mockedTreeChangeService).when(this.mockedRIB).getService();
 316         final ImportPolicyPeerTracker mockedImportPolicy = mock(ImportPolicyPeerTracker.class);
 317         doNothing().when(mockedImportPolicy).peerRoleChanged(any(), any());
 318         doReturn(null).when(mockedImportPolicy).policyFor(any());
 319         doReturn(mockedImportPolicy).when(this.mockedRIB).getImportPolicyPeerTracker();
 320         doReturn(mock(RIBSupportContextRegistry.class)).when(this.mockedRIB).getRibSupportContext();
 321         doReturn(Collections.emptySet()).when(this.mockedRIB).getLocalTablesKeys();
 322         doReturn(Collections.emptySet()).when(this.mockedRIB).getLocalTables();
 323         doReturn(this.mockedBGPDispatcher).when(this.mockedRIB).getDispatcher();
 324         doReturn(InstanceIdentifier.create(BgpRib.class).child(Rib.class, new RibKey(RIB_ID))).when(this.mockedRIB).getInstanceIdentifier();
 325
 326         setupMockService(RIB.class, this.mockedRIB);
 327
 328         setupMockService(RIBExtensionProviderContext.class, new SimpleRIBExtensionProviderContext());
 329
 330         setupMockService(BGPPeerRegistry.class, StrictBGPPeerRegistry.GLOBAL);
 331
 332         setupMockService(BGPPeerRuntimeMXBean.class, this.mockedPeer);
 333     }
 334
 335     protected void setupMockService(final Class<?> serviceInterface, final Object instance) throws Exception {
 336         final ServiceReference<?> mockServiceRef = mock(ServiceReference.class);
 337         doReturn(new ServiceReference[]{mockServiceRef}).when(this.mockedContext).
 338         getServiceReferences(anyString(), contains(serviceInterface.getName()));
 339         doReturn(new ServiceReference[]{mockServiceRef}).when(this.mockedContext).
 340         getServiceReferences(serviceInterface.getName(), null);
 341         doReturn(instance).when(this.mockedContext).getService(mockServiceRef);
 342         doReturn("test").when(mockServiceRef).toString();
 343     }
 344
 345     private static SchemaContext parseYangStreams(final Collection<ByteSource> streams) {
 346         final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR
 347                 .newBuild();
 348         try {
 349             return reactor.buildEffective(streams);
 350         } catch (final ReactorException | IOException e) {
 351             throw new RuntimeException("Unable to build schema context from " + streams, e);
 352         }
 353     }
 354
 355     protected List<ModuleFactory> getModuleFactories() {
 356         return Lists.newArrayList(new RIBImplModuleFactory(), new GlobalEventExecutorModuleFactory(),
 357                 new BGPDispatcherImplModuleFactory(), new NettyThreadgroupModuleFactory(),
 358                 new RIBExtensionsImplModuleFactory(), new DomBrokerImplModuleFactory(), new RuntimeMappingModuleFactory(),
 359                 new HashedWheelTimerModuleFactory(), new BindingAsyncDataBrokerImplModuleFactory(),
 360                 new DomInmemoryDataBrokerModuleFactory(), new SchemaServiceImplSingletonModuleFactory(),
 361                 new NotificationBrokerImplModuleFactory(), new ForwardedCompatibleDataBrokerImplModuleFactory(),
 362                 new BindingBrokerImplModuleFactory());
 363     }
 364
 365     @Override
 366     protected BundleContextServiceRegistrationHandler getBundleContextServiceRegistrationHandler(final Class<?> serviceType) {
 367         if (serviceType.equals(SchemaContextListener.class)) {
 368             return (clazz, serviceInstance, props) -> {
 369                 final SchemaContextListener listener = (SchemaContextListener) serviceInstance;
 370                 final SchemaContext context = parseYangStreams(getFilesAsByteSources(getYangModelsPaths()));
 371                 listener.onGlobalContextUpdated(context);
 372             };
 373         }
 374
 375         return super.getBundleContextServiceRegistrationHandler(serviceType);
 376     }
 377
 378     @After
 379     public void closeAllModules() throws Exception {
 380         super.destroyAllConfigBeans();
 381
 382     }
 383
 384     protected CommitStatus createInstance() throws Exception {
 385         final ConfigTransactionJMXClient transaction = this.configRegistryClient.createTransaction();
 386         createRIBImplModuleInstance(transaction);
 387         return transaction.commit();
 388     }
 389
 390     protected CommitStatus createRIBImplModuleInstance(final RibId ribId, final AsNumber localAs, final BgpId bgpId, final ClusterIdentifier clusterId) throws Exception {
 391         final ConfigTransactionJMXClient transaction = this.configRegistryClient.createTransaction();
 392         createRIBImplModuleInstance(transaction, ribId, localAs, bgpId, clusterId, createAsyncDataBrokerInstance(transaction));
 393         return transaction.commit();
 394     }
 395
 396     private ObjectName createRIBImplModuleInstance(final ConfigTransactionJMXClient transaction, final RibId ribId, final AsNumber localAs,
 397             final BgpId bgpId, final ClusterIdentifier clusterId, final ObjectName dataBroker) throws Exception {
 398         final ObjectName nameCreated = transaction.createModule(FACTORY_NAME, INSTANCE_NAME);
 399         final RIBImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, RIBImplModuleMXBean.class);
 400         mxBean.setDataProvider(dataBroker);
 401         mxBean.setDomDataProvider(lookupDomAsyncDataBroker(transaction));
 402         mxBean.setCodecTreeFactory(lookupMappingServiceInstance(transaction));
 403         mxBean.setBgpDispatcher(createBGPDispatcherImplInstance(transaction));
 404         mxBean.setExtensions(createRibExtensionsInstance(transaction));
 405         mxBean.setRibId(ribId);
 406         mxBean.setLocalAs(localAs);
 407         mxBean.setBgpRibId(bgpId);
 408         mxBean.setClusterId(clusterId);
 409         return nameCreated;
 410     }
 411
 412     public static ObjectName createBGPDispatcherImplInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 413         final ObjectName nameCreated = transaction.createModule(BGPDispatcherImplModuleFactory.NAME, "bgp-message-fct");
 414         final BGPDispatcherImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, BGPDispatcherImplModuleMXBean.class);
 415         return nameCreated;
 416     }
 417
 418     protected ObjectName createRIBImplModuleInstance(final ConfigTransactionJMXClient transaction) throws Exception {
 419         return createRIBImplModuleInstance(transaction, RIB_ID, AS_NUMBER, BGP_ID, CLUSTER_ID,
 420                 createAsyncDataBrokerInstance(transaction));
 421     }
 422
 423     public ObjectName createRIBImplModuleInstance(final ConfigTransactionJMXClient transaction, final ObjectName dataBroker)
 424             throws Exception {
 425         return createRIBImplModuleInstance(transaction, RIB_ID, AS_NUMBER, BGP_ID, CLUSTER_ID, dataBroker);
 426     }
 427
 428     public ObjectName createAsyncDataBrokerInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException, InstanceNotFoundException {
 429         final ObjectName nameCreated = transaction.createModule(BindingAsyncDataBrokerImplModuleFactory.NAME, BINDING_ASYNC_BROKER_INSTANCE_NAME);
 430         final BindingAsyncDataBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, BindingAsyncDataBrokerImplModuleMXBean.class);
 431         mxBean.setBindingMappingService(lookupMappingServiceInstance(transaction));
 432         mxBean.setDomAsyncBroker(lookupDomAsyncDataBroker(transaction));
 433         mxBean.setSchemaService(lookupSchemaServiceInstance(transaction));
 434         return nameCreated;
 435     }
 436
 437     public static ObjectName lookupDomAsyncDataBroker(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 438         try {
 439             return transaction.lookupConfigBean(DomInmemoryDataBrokerModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 440         } catch (final InstanceNotFoundException e) {
 441             try {
 442                 final ObjectName nameCreated = transaction.createModule(DomInmemoryDataBrokerModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 443                 final DomInmemoryDataBrokerModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, DomInmemoryDataBrokerModuleMXBean.class);
 444                 mxBean.setSchemaService(lookupSchemaServiceInstance(transaction));
 445                 return nameCreated;
 446             } catch (final InstanceAlreadyExistsException e1) {
 447                 throw new IllegalStateException(e1);
 448             }
 449         }
 450     }
 451
 452     private static ObjectName lookupMappingServiceInstance(final ConfigTransactionJMXClient transaction) {
 453         try {
 454             return transaction.lookupConfigBean(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 455         } catch (final InstanceNotFoundException e) {
 456             try {
 457                 return transaction.createModule(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 458             } catch (final InstanceAlreadyExistsException e1) {
 459                 throw new IllegalStateException(e1);
 460             }
 461         }
 462     }
 463
 464     private static ObjectName lookupSchemaServiceInstance(final ConfigTransactionJMXClient transaction) {
 465         try {
 466             return transaction.lookupConfigBean(SchemaServiceImplSingletonModuleFactory.NAME, SchemaServiceImplSingletonModuleFactory.SINGLETON_NAME);
 467         } catch (final InstanceNotFoundException e) {
 468             try {
 469                 return transaction.createModule(SchemaServiceImplSingletonModuleFactory.NAME, SchemaServiceImplSingletonModuleFactory.SINGLETON_NAME);
 470             } catch (final InstanceAlreadyExistsException e1) {
 471                 throw new IllegalStateException(e1);
 472             }
 473         }
 474     }
 475
 476     private static ObjectName createRibExtensionsInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 477         final ObjectName nameCreated = transaction.createModule(RIBExtensionsImplModuleFactory.NAME, RIB_EXTENSIONS_INSTANCE_NAME);
 478         transaction.newMXBeanProxy(nameCreated, RIBExtensionsImplModuleMXBean.class);
 479         return nameCreated;
 480     }
 481
 482     public List<String> getYangModelsPaths() {
 483         final List<String> paths = Lists.newArrayList("/META-INF/yang/bgp-rib.yang", "/META-INF/yang/ietf-inet-types@2013-07-15.yang",
 484                 "/META-INF/yang/bgp-message.yang", "/META-INF/yang/bgp-multiprotocol.yang", "/META-INF/yang/bgp-types.yang",
 485                 "/META-INF/yang/network-concepts.yang", "/META-INF/yang/ieee754.yang", "/META-INF/yang/yang-ext.yang");
 486         return paths;
 487     }
 488
 489     // TODO move back to AbstractConfigTest
 490     private static Collection<ByteSource> getFilesAsByteSources(final List<String> paths) {
 491         final Collection<ByteSource> resources = new ArrayList<>();
 492         final List<String> failedToFind = new ArrayList<>();
 493         for (final String path : paths) {
 494             final URL url = AbstractRIBImplModuleTest.class.getResource(path);
 495             if (url == null) {
 496                 failedToFind.add(path);
 497             } else {
 498                 resources.add(Resources.asByteSource(url));
 499             }
 500         }
 501         Assert.assertEquals("Some files were not found", Collections.<String> emptyList(), failedToFind);
 502
 503         return resources;
 504     }
 505
 506     public ObjectName createBindingBrokerImpl(final ConfigTransactionJMXClient transaction, final ObjectName dataBrokerON,
 507             final ObjectName notificationBrokerON) throws Exception {
 508         final ObjectName objectName = transaction.createModule(BindingBrokerImplModuleFactory.NAME, BINDING_BROKER_INSTANCE_NAME);
 509         final BindingBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(objectName, BindingBrokerImplModuleMXBean.class);
 510         mxBean.setDataBroker(dataBrokerON);
 511         mxBean.setNotificationService(notificationBrokerON);
 512         mxBean.setBindingMappingService(lookupMappingServiceInstance(transaction));
 513         mxBean.setDomAsyncBroker(lookupDomBrokerInstance(transaction));
 514         return objectName;
 515     }
 516
 517     public static ObjectName lookupDomBrokerInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 518         try {
 519             return transaction.lookupConfigBean(DomBrokerImplModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 520         } catch (final InstanceNotFoundException e) {
 521             try {
 522                 final ObjectName nameCreated = transaction.createModule(DomBrokerImplModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 523                 final DomBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, DomBrokerImplModuleMXBean.class);
 524                 mxBean.setAsyncDataBroker(lookupDomAsyncDataBroker(transaction));
 525                 return nameCreated;
 526             } catch (final InstanceAlreadyExistsException e1) {
 527                 throw new IllegalStateException(e1);
 528             }
 529         }
 530     }
 531
 532     public ObjectName createCompatibleDataBrokerInstance(final ConfigTransactionJMXClient transaction)
 533             throws InstanceAlreadyExistsException, InstanceNotFoundException {
 534         final ObjectName nameCreated = transaction.createModule(ForwardedCompatibleDataBrokerImplModuleFactory.NAME, COMPATIBLE_DATA_BROKER_INSTANCE_NAME);
 535         final ForwardedCompatibleDataBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, ForwardedCompatibleDataBrokerImplModuleMXBean.class);
 536         mxBean.setDataBroker(lookupDataBrokerInstance(transaction));
 537         return nameCreated;
 538     }
 539
 540     private static ObjectName lookupDataBrokerInstance(final ConfigTransactionJMXClient transaction) {
 541         try {
 542             return transaction.lookupConfigBean(BindingAsyncDataBrokerImplModuleFactory.NAME, BINDING_ASYNC_BROKER_INSTANCE_NAME);
 543         } catch (final InstanceNotFoundException e) {
 544             try {
 545                 return transaction.createModule(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 546             } catch (final InstanceAlreadyExistsException e1) {
 547                 throw new IllegalStateException(e1);
 548             }
 549         }
 550     }
 551
 552     public ObjectName createNotificationBrokerInstance(final ConfigTransactionJMXClient transaction) throws Exception {
 553         final ObjectName objectName = transaction.createModule(NotificationBrokerImplModuleFactory.NAME, NOTIFICATION_BROKER_INSTANCE_NAME);
 554         return objectName;
 555     }
 556 }