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).onGlobalModified(any(),any(),any());
 289         doNothing().when(this.bgpDeployer).onNeighborModified(any(),any(),any());
 290         doReturn(NEIGHBOR).when(this.bgpMappingService).fromBgpPeer(any(), any(),
 291                 any(), any(), any(), any(), any(), any(), any(), any(), any());
 292         doReturn(NEIGHBOR).when(this.bgpMappingService).fromApplicationPeer(any(), any());
 293         doReturn(this.mockedFuture).when(this.bgpDeployer).writeConfiguration(any(), any());
 294         doReturn(this.mockedFuture).when(this.bgpDeployer).removeConfiguration(any());
 295         doReturn(this.bgpMappingService).when(this.bgpDeployer).getMappingService();
 296         doReturn(OPENCONFIG_IID).when(this.bgpDeployer).getInstanceIdentifier();
 297         final DOMTransactionChain mockedChain = mock(DOMTransactionChain.class);
 298         final DOMDataWriteTransaction mockedWTx = mock(DOMDataWriteTransaction.class);
 299         doNothing().when(mockedWTx).put(any(), any(), any());
 300         doNothing().when(mockedWTx).delete(any(), any());
 301         doReturn(this.mockedFuture).when(mockedWTx).submit();
 302         doReturn(mockedWTx).when(mockedChain).newWriteOnlyTransaction();
 303         doReturn(mockedChain).when(this.mockedRIB).createPeerChain(any());
 304         doNothing().when(mockedChain).close();
 305         doReturn(YangInstanceIdentifier.of(BgpRib.QNAME)).when(this.mockedRIB).getYangRibId();
 306         doReturn(new AsNumber(123456l)).when(this.mockedRIB).getLocalAs();
 307         doReturn(BGP_ID).when(this.mockedRIB).getBgpIdentifier();
 308         doReturn(Optional.absent()).when(this.mockedRIB).getOpenConfigProvider();
 309         final BGPRenderStats mockedRenderStats = mock(BGPRenderStats.class);
 310         doReturn(new UnsignedInt32Counter("counter")).when(mockedRenderStats).getConfiguredPeerCounter();
 311         doReturn(mockedRenderStats).when(this.mockedRIB).getRenderStats();
 312         final DOMDataTreeChangeService mockedTreeChangeService = mock(DOMDataTreeChangeService.class);
 313         final ListenerRegistration mockedListenerReg = mock(ListenerRegistration.class);
 314         doNothing().when(mockedListenerReg).close();
 315         doReturn(mockedListenerReg).when(mockedTreeChangeService).registerDataTreeChangeListener(any(), any());
 316         doReturn(mockedTreeChangeService).when(this.mockedRIB).getService();
 317         final ImportPolicyPeerTracker mockedImportPolicy = mock(ImportPolicyPeerTracker.class);
 318         doNothing().when(mockedImportPolicy).peerRoleChanged(any(), any());
 319         doReturn(null).when(mockedImportPolicy).policyFor(any());
 320         doReturn(mockedImportPolicy).when(this.mockedRIB).getImportPolicyPeerTracker();
 321         doReturn(mock(RIBSupportContextRegistry.class)).when(this.mockedRIB).getRibSupportContext();
 322         doReturn(Collections.emptySet()).when(this.mockedRIB).getLocalTablesKeys();
 323         doReturn(Collections.emptySet()).when(this.mockedRIB).getLocalTables();
 324         doReturn(this.mockedBGPDispatcher).when(this.mockedRIB).getDispatcher();
 325         doReturn(InstanceIdentifier.create(BgpRib.class).child(Rib.class, new RibKey(RIB_ID))).when(this.mockedRIB).getInstanceIdentifier();
 326
 327         setupMockService(RIB.class, this.mockedRIB);
 328
 329         setupMockService(RIBExtensionProviderContext.class, new SimpleRIBExtensionProviderContext());
 330
 331         setupMockService(BGPPeerRegistry.class, StrictBGPPeerRegistry.GLOBAL);
 332
 333         setupMockService(BGPPeerRuntimeMXBean.class, this.mockedPeer);
 334     }
 335
 336     protected void setupMockService(final Class<?> serviceInterface, final Object instance) throws Exception {
 337         final ServiceReference<?> mockServiceRef = mock(ServiceReference.class);
 338         doReturn(new ServiceReference[]{mockServiceRef}).when(this.mockedContext).
 339         getServiceReferences(anyString(), contains(serviceInterface.getName()));
 340         doReturn(new ServiceReference[]{mockServiceRef}).when(this.mockedContext).
 341         getServiceReferences(serviceInterface.getName(), null);
 342         doReturn(instance).when(this.mockedContext).getService(mockServiceRef);
 343         doReturn("test").when(mockServiceRef).toString();
 344     }
 345
 346     private static SchemaContext parseYangStreams(final Collection<ByteSource> streams) {
 347         final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR
 348                 .newBuild();
 349         try {
 350             return reactor.buildEffective(streams);
 351         } catch (final ReactorException | IOException e) {
 352             throw new RuntimeException("Unable to build schema context from " + streams, e);
 353         }
 354     }
 355
 356     protected List<ModuleFactory> getModuleFactories() {
 357         return Lists.newArrayList(new RIBImplModuleFactory(), new GlobalEventExecutorModuleFactory(),
 358                 new BGPDispatcherImplModuleFactory(), new NettyThreadgroupModuleFactory(),
 359                 new RIBExtensionsImplModuleFactory(), new DomBrokerImplModuleFactory(), new RuntimeMappingModuleFactory(),
 360                 new HashedWheelTimerModuleFactory(), new BindingAsyncDataBrokerImplModuleFactory(),
 361                 new DomInmemoryDataBrokerModuleFactory(), new SchemaServiceImplSingletonModuleFactory(),
 362                 new NotificationBrokerImplModuleFactory(), new ForwardedCompatibleDataBrokerImplModuleFactory(),
 363                 new BindingBrokerImplModuleFactory());
 364     }
 365
 366     @Override
 367     protected BundleContextServiceRegistrationHandler getBundleContextServiceRegistrationHandler(final Class<?> serviceType) {
 368         if (serviceType.equals(SchemaContextListener.class)) {
 369             return (clazz, serviceInstance, props) -> {
 370                 final SchemaContextListener listener = (SchemaContextListener) serviceInstance;
 371                 final SchemaContext context = parseYangStreams(getFilesAsByteSources(getYangModelsPaths()));
 372                 listener.onGlobalContextUpdated(context);
 373             };
 374         }
 375
 376         return super.getBundleContextServiceRegistrationHandler(serviceType);
 377     }
 378
 379     @After
 380     public void closeAllModules() throws Exception {
 381         super.destroyAllConfigBeans();
 382
 383     }
 384
 385     protected CommitStatus createInstance() throws Exception {
 386         final ConfigTransactionJMXClient transaction = this.configRegistryClient.createTransaction();
 387         createRIBImplModuleInstance(transaction);
 388         return transaction.commit();
 389     }
 390
 391     protected CommitStatus createRIBImplModuleInstance(final RibId ribId, final AsNumber localAs, final BgpId bgpId, final ClusterIdentifier clusterId) throws Exception {
 392         final ConfigTransactionJMXClient transaction = this.configRegistryClient.createTransaction();
 393         createRIBImplModuleInstance(transaction, ribId, localAs, bgpId, clusterId, createAsyncDataBrokerInstance(transaction));
 394         return transaction.commit();
 395     }
 396
 397     private ObjectName createRIBImplModuleInstance(final ConfigTransactionJMXClient transaction, final RibId ribId, final AsNumber localAs,
 398             final BgpId bgpId, final ClusterIdentifier clusterId, final ObjectName dataBroker) throws Exception {
 399         final ObjectName nameCreated = transaction.createModule(FACTORY_NAME, INSTANCE_NAME);
 400         final RIBImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, RIBImplModuleMXBean.class);
 401         mxBean.setDataProvider(dataBroker);
 402         mxBean.setDomDataProvider(lookupDomAsyncDataBroker(transaction));
 403         mxBean.setCodecTreeFactory(lookupMappingServiceInstance(transaction));
 404         mxBean.setBgpDispatcher(createBGPDispatcherImplInstance(transaction));
 405         mxBean.setExtensions(createRibExtensionsInstance(transaction));
 406         mxBean.setRibId(ribId);
 407         mxBean.setLocalAs(localAs);
 408         mxBean.setBgpRibId(bgpId);
 409         mxBean.setClusterId(clusterId);
 410         return nameCreated;
 411     }
 412
 413     public static ObjectName createBGPDispatcherImplInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 414         final ObjectName nameCreated = transaction.createModule(BGPDispatcherImplModuleFactory.NAME, "bgp-message-fct");
 415         final BGPDispatcherImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, BGPDispatcherImplModuleMXBean.class);
 416         return nameCreated;
 417     }
 418
 419     protected ObjectName createRIBImplModuleInstance(final ConfigTransactionJMXClient transaction) throws Exception {
 420         return createRIBImplModuleInstance(transaction, RIB_ID, AS_NUMBER, BGP_ID, CLUSTER_ID,
 421                 createAsyncDataBrokerInstance(transaction));
 422     }
 423
 424     public ObjectName createRIBImplModuleInstance(final ConfigTransactionJMXClient transaction, final ObjectName dataBroker)
 425             throws Exception {
 426         return createRIBImplModuleInstance(transaction, RIB_ID, AS_NUMBER, BGP_ID, CLUSTER_ID, dataBroker);
 427     }
 428
 429     public ObjectName createAsyncDataBrokerInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException, InstanceNotFoundException {
 430         final ObjectName nameCreated = transaction.createModule(BindingAsyncDataBrokerImplModuleFactory.NAME, BINDING_ASYNC_BROKER_INSTANCE_NAME);
 431         final BindingAsyncDataBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, BindingAsyncDataBrokerImplModuleMXBean.class);
 432         mxBean.setBindingMappingService(lookupMappingServiceInstance(transaction));
 433         mxBean.setDomAsyncBroker(lookupDomAsyncDataBroker(transaction));
 434         mxBean.setSchemaService(lookupSchemaServiceInstance(transaction));
 435         return nameCreated;
 436     }
 437
 438     public static ObjectName lookupDomAsyncDataBroker(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 439         try {
 440             return transaction.lookupConfigBean(DomInmemoryDataBrokerModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 441         } catch (final InstanceNotFoundException e) {
 442             try {
 443                 final ObjectName nameCreated = transaction.createModule(DomInmemoryDataBrokerModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 444                 final DomInmemoryDataBrokerModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, DomInmemoryDataBrokerModuleMXBean.class);
 445                 mxBean.setSchemaService(lookupSchemaServiceInstance(transaction));
 446                 return nameCreated;
 447             } catch (final InstanceAlreadyExistsException e1) {
 448                 throw new IllegalStateException(e1);
 449             }
 450         }
 451     }
 452
 453     private static ObjectName lookupMappingServiceInstance(final ConfigTransactionJMXClient transaction) {
 454         try {
 455             return transaction.lookupConfigBean(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 456         } catch (final InstanceNotFoundException e) {
 457             try {
 458                 return transaction.createModule(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 459             } catch (final InstanceAlreadyExistsException e1) {
 460                 throw new IllegalStateException(e1);
 461             }
 462         }
 463     }
 464
 465     private static ObjectName lookupSchemaServiceInstance(final ConfigTransactionJMXClient transaction) {
 466         try {
 467             return transaction.lookupConfigBean(SchemaServiceImplSingletonModuleFactory.NAME, SchemaServiceImplSingletonModuleFactory.SINGLETON_NAME);
 468         } catch (final InstanceNotFoundException e) {
 469             try {
 470                 return transaction.createModule(SchemaServiceImplSingletonModuleFactory.NAME, SchemaServiceImplSingletonModuleFactory.SINGLETON_NAME);
 471             } catch (final InstanceAlreadyExistsException e1) {
 472                 throw new IllegalStateException(e1);
 473             }
 474         }
 475     }
 476
 477     private static ObjectName createRibExtensionsInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 478         final ObjectName nameCreated = transaction.createModule(RIBExtensionsImplModuleFactory.NAME, RIB_EXTENSIONS_INSTANCE_NAME);
 479         transaction.newMXBeanProxy(nameCreated, RIBExtensionsImplModuleMXBean.class);
 480         return nameCreated;
 481     }
 482
 483     public List<String> getYangModelsPaths() {
 484         final List<String> paths = Lists.newArrayList("/META-INF/yang/bgp-rib.yang", "/META-INF/yang/ietf-inet-types@2013-07-15.yang",
 485                 "/META-INF/yang/bgp-message.yang", "/META-INF/yang/bgp-multiprotocol.yang", "/META-INF/yang/bgp-types.yang",
 486                 "/META-INF/yang/network-concepts.yang", "/META-INF/yang/ieee754.yang", "/META-INF/yang/yang-ext.yang");
 487         return paths;
 488     }
 489
 490     // TODO move back to AbstractConfigTest
 491     private static Collection<ByteSource> getFilesAsByteSources(final List<String> paths) {
 492         final Collection<ByteSource> resources = new ArrayList<>();
 493         final List<String> failedToFind = new ArrayList<>();
 494         for (final String path : paths) {
 495             final URL url = AbstractRIBImplModuleTest.class.getResource(path);
 496             if (url == null) {
 497                 failedToFind.add(path);
 498             } else {
 499                 resources.add(Resources.asByteSource(url));
 500             }
 501         }
 502         Assert.assertEquals("Some files were not found", Collections.<String> emptyList(), failedToFind);
 503
 504         return resources;
 505     }
 506
 507     public ObjectName createBindingBrokerImpl(final ConfigTransactionJMXClient transaction, final ObjectName dataBrokerON,
 508             final ObjectName notificationBrokerON) throws Exception {
 509         final ObjectName objectName = transaction.createModule(BindingBrokerImplModuleFactory.NAME, BINDING_BROKER_INSTANCE_NAME);
 510         final BindingBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(objectName, BindingBrokerImplModuleMXBean.class);
 511         mxBean.setDataBroker(dataBrokerON);
 512         mxBean.setNotificationService(notificationBrokerON);
 513         mxBean.setBindingMappingService(lookupMappingServiceInstance(transaction));
 514         mxBean.setDomAsyncBroker(lookupDomBrokerInstance(transaction));
 515         return objectName;
 516     }
 517
 518     public static ObjectName lookupDomBrokerInstance(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
 519         try {
 520             return transaction.lookupConfigBean(DomBrokerImplModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 521         } catch (final InstanceNotFoundException e) {
 522             try {
 523                 final ObjectName nameCreated = transaction.createModule(DomBrokerImplModuleFactory.NAME, DOM_BROKER_INSTANCE_NAME);
 524                 final DomBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, DomBrokerImplModuleMXBean.class);
 525                 mxBean.setAsyncDataBroker(lookupDomAsyncDataBroker(transaction));
 526                 return nameCreated;
 527             } catch (final InstanceAlreadyExistsException e1) {
 528                 throw new IllegalStateException(e1);
 529             }
 530         }
 531     }
 532
 533     public ObjectName createCompatibleDataBrokerInstance(final ConfigTransactionJMXClient transaction)
 534             throws InstanceAlreadyExistsException, InstanceNotFoundException {
 535         final ObjectName nameCreated = transaction.createModule(ForwardedCompatibleDataBrokerImplModuleFactory.NAME, COMPATIBLE_DATA_BROKER_INSTANCE_NAME);
 536         final ForwardedCompatibleDataBrokerImplModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, ForwardedCompatibleDataBrokerImplModuleMXBean.class);
 537         mxBean.setDataBroker(lookupDataBrokerInstance(transaction));
 538         return nameCreated;
 539     }
 540
 541     private static ObjectName lookupDataBrokerInstance(final ConfigTransactionJMXClient transaction) {
 542         try {
 543             return transaction.lookupConfigBean(BindingAsyncDataBrokerImplModuleFactory.NAME, BINDING_ASYNC_BROKER_INSTANCE_NAME);
 544         } catch (final InstanceNotFoundException e) {
 545             try {
 546                 return transaction.createModule(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 547             } catch (final InstanceAlreadyExistsException e1) {
 548                 throw new IllegalStateException(e1);
 549             }
 550         }
 551     }
 552
 553     public ObjectName createNotificationBrokerInstance(final ConfigTransactionJMXClient transaction) throws Exception {
 554         final ObjectName objectName = transaction.createModule(NotificationBrokerImplModuleFactory.NAME, NOTIFICATION_BROKER_INSTANCE_NAME);
 555         return objectName;
 556     }
 557 }