bgp/rib-impl-config/src/test/java/org/opendaylight/controller/config/yang/bgp/rib/impl/RIBImplModuleTest.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.controller.config.yang.bgp.rib.impl;
   9
  10 import static org.mockito.Matchers.any;
  11 import static org.mockito.Mockito.mock;
  12
  13 import java.math.BigDecimal;
  14 import java.util.Arrays;
  15 import java.util.Collections;
  16 import java.util.List;
  17 import java.util.concurrent.Future;
  18
  19 import javax.management.InstanceAlreadyExistsException;
  20 import javax.management.InstanceNotFoundException;
  21 import javax.management.ObjectName;
  22
  23 import org.junit.After;
  24 import org.junit.Before;
  25 import org.junit.Test;
  26 import org.mockito.Matchers;
  27 import org.mockito.Mock;
  28 import org.mockito.Mockito;
  29 import org.mockito.MockitoAnnotations;
  30 import org.opendaylight.controller.config.api.jmx.CommitStatus;
  31 import org.opendaylight.controller.config.manager.impl.AbstractConfigTest;
  32 import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver;
  33 import org.opendaylight.controller.config.spi.ModuleFactory;
  34 import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
  35 import org.opendaylight.controller.config.yang.bgp.parser.spi.SimpleBGPExtensionProviderContextModuleFactory;
  36 import org.opendaylight.controller.config.yang.bgp.reconnectstrategy.TimedReconnectStrategyModuleTest;
  37 import org.opendaylight.controller.config.yang.bgp.rib.spi.RIBExtensionsImplModuleFactory;
  38 import org.opendaylight.controller.config.yang.bgp.rib.spi.RIBExtensionsImplModuleMXBean;
  39 import org.opendaylight.controller.config.yang.md.sal.binding.impl.DataBrokerImplModuleFactory;
  40 import org.opendaylight.controller.config.yang.md.sal.binding.impl.DataBrokerImplModuleMXBean;
  41 import org.opendaylight.controller.config.yang.md.sal.binding.impl.RuntimeMappingModuleFactory;
  42 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomBrokerImplModuleFactory;
  43 import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomBrokerImplModuleMXBean;
  44 import org.opendaylight.controller.config.yang.md.sal.dom.impl.HashMapDataStoreModuleFactory;
  45 import org.opendaylight.controller.config.yang.md.sal.dom.impl.HashMapDataStoreModuleMXBean;
  46 import org.opendaylight.controller.config.yang.netty.eventexecutor.GlobalEventExecutorModuleFactory;
  47 import org.opendaylight.controller.config.yang.netty.threadgroup.NettyThreadgroupModuleFactory;
  48 import org.opendaylight.controller.config.yang.netty.timer.HashedWheelTimerModuleFactory;
  49 import org.opendaylight.controller.config.yang.reconnectstrategy.TimedReconnectStrategyModuleFactory;
  50 import org.opendaylight.controller.config.yang.store.impl.YangParserWrapper;
  51 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
  52 import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler;
  53 import org.opendaylight.controller.sal.core.api.data.DataModificationTransaction;
  54 import org.opendaylight.controller.sal.core.api.data.DataProviderService;
  55 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.RibId;
  57 import org.opendaylight.yangtools.concepts.Registration;
  58 import org.opendaylight.yangtools.yang.common.RpcResult;
  59 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
  60 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
  61 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  62 import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener;
  63 import org.osgi.framework.Bundle;
  64 import org.osgi.framework.BundleListener;
  65 import org.osgi.framework.Filter;
  66 import org.osgi.framework.ServiceListener;
  67 import org.osgi.framework.ServiceReference;
  68
  69 import com.google.common.collect.Lists;
  70
  71 public class RIBImplModuleTest extends AbstractConfigTest {
  72         private static final String INSTANCE_NAME = GlobalEventExecutorModuleFactory.SINGLETON_NAME;
  73         private static final String TRANSACTION_NAME = "testTransaction";
  74
  75         private RIBImplModuleFactory factory;
  76         private DataBrokerImplModuleFactory dataBrokerFactory;
  77         private TimedReconnectStrategyModuleFactory reconnectFactory;
  78         private BGPDispatcherImplModuleFactory dispactherFactory;
  79         private NettyThreadgroupModuleFactory threadgroupFactory;
  80         private GlobalEventExecutorModuleFactory executorFactory;
  81         private SimpleBGPExtensionProviderContextModuleFactory extensionFactory;
  82         private RIBExtensionsImplModuleFactory ribExtensionsFactory;
  83         private DomBrokerImplModuleFactory domBrokerFactory;
  84         private RuntimeMappingModuleFactory runtimeMappingFactory;
  85         private HashMapDataStoreModuleFactory dataStroreFactory;
  86         private HashedWheelTimerModuleFactory hwtFactory;
  87
  88         @Mock
  89         private DataModificationTransaction mockedTransaction;
  90
  91         @Mock
  92         private DataProviderService mockedDataProvider;
  93
  94         @Mock
  95         private Future<RpcResult<TransactionStatus>> mockedFuture;
  96
  97         @Mock
  98         private RpcResult<TransactionStatus> mockedResult;
  99
 100         @SuppressWarnings("unchecked")
 101         @Before
 102         public void setUp() throws Exception {
 103                 MockitoAnnotations.initMocks(this);
 104
 105                 this.factory = new RIBImplModuleFactory();
 106                 this.dataBrokerFactory = new DataBrokerImplModuleFactory();
 107                 this.executorFactory = new GlobalEventExecutorModuleFactory();
 108                 this.dispactherFactory = new BGPDispatcherImplModuleFactory();
 109                 this.threadgroupFactory = new NettyThreadgroupModuleFactory();
 110                 this.reconnectFactory = new TimedReconnectStrategyModuleFactory();
 111                 this.extensionFactory = new SimpleBGPExtensionProviderContextModuleFactory();
 112                 this.ribExtensionsFactory = new RIBExtensionsImplModuleFactory();
 113                 this.domBrokerFactory = new DomBrokerImplModuleFactory();
 114                 this.runtimeMappingFactory = new RuntimeMappingModuleFactory();
 115                 this.dataStroreFactory = new HashMapDataStoreModuleFactory();
 116                 this.hwtFactory = new HashedWheelTimerModuleFactory();
 117
 118                 List<ModuleFactory> moduleFactories = getModuleFactories();
 119                 super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(mockedContext, moduleFactories
 120                                 .toArray(new ModuleFactory[moduleFactories.size()])));
 121
 122                 Filter mockedFilter = mock(Filter.class);
 123                 Mockito.doReturn(mockedFilter).when(mockedContext).createFilter(Mockito.anyString());
 124
 125                 Mockito.doNothing().when(mockedContext).addServiceListener(any(ServiceListener.class), Mockito.anyString());
 126
 127                 Mockito.doNothing().when(mockedContext).addBundleListener(any(BundleListener.class));
 128
 129                 Mockito.doReturn(new Bundle[]{}).when(mockedContext).getBundles();
 130
 131                 Mockito.doReturn(new ServiceReference[]{}).when(mockedContext).getServiceReferences(Matchers.anyString(), Matchers.anyString());
 132
 133                 ServiceReference<?> emptyServiceReference = mock(ServiceReference.class, "Empty");
 134
 135                 ServiceReference<?> dataProviderServiceReference = mock(ServiceReference.class, "Data Provider");
 136
 137
 138                 Mockito.doReturn(mockedFilter).when(mockedContext).createFilter(Mockito.anyString());
 139
 140                 Mockito.doNothing().when(mockedContext).addServiceListener(any(ServiceListener.class), Mockito.anyString());
 141
 142                 Mockito.doNothing().when(mockedContext).addBundleListener(any(BundleListener.class));
 143
 144                 Mockito.doReturn(new Bundle[]{}).when(mockedContext).getBundles();
 145
 146                 Mockito.doReturn(new ServiceReference[]{}).when(mockedContext).getServiceReferences(Matchers.anyString(), Matchers.anyString());
 147
 148                 //mockedDataProvider = mock(DataProviderService.class);
 149
 150
 151                 Mockito.doReturn("Empty reference").when(emptyServiceReference).toString();
 152                 Mockito.doReturn("Data Provider Service Reference").when(dataProviderServiceReference).toString();
 153                 //
 154                 Mockito.doReturn(emptyServiceReference).when(mockedContext).getServiceReference(any(Class.class));
 155                 Mockito.doReturn(dataProviderServiceReference).when(mockedContext).getServiceReference(DataProviderService.class);
 156
 157                 Mockito.doReturn(mockedDataProvider).when(mockedContext).getService(dataProviderServiceReference);
 158
 159                 //Mockito.doReturn(null).when(mockedContext).getService(dataProviderServiceReference);
 160                 Mockito.doReturn(null).when(mockedContext).getService(emptyServiceReference);
 161
 162
 163                 Registration<DataCommitHandler<InstanceIdentifier, CompositeNode>> registration = mock(Registration.class);
 164                 Mockito.doReturn(registration).when(mockedDataProvider).registerCommitHandler(any(InstanceIdentifier.class),
 165                                 any(DataCommitHandler.class));
 166                 Mockito.doReturn(registration).when(mockedDataProvider).registerCommitHandler(any(InstanceIdentifier.class),
 167                                 any(DataCommitHandler.class));
 168
 169                 Mockito.doReturn(null).when(mockedDataProvider).readOperationalData(any(InstanceIdentifier.class));
 170                 Mockito.doReturn(mockedTransaction).when(mockedDataProvider).beginTransaction();
 171
 172                 Mockito.doNothing().when(mockedTransaction).putOperationalData(any(InstanceIdentifier.class), any(CompositeNode.class));
 173                 Mockito.doNothing().when(mockedTransaction).removeOperationalData(any(InstanceIdentifier.class));
 174
 175                 Mockito.doReturn(mockedFuture).when(mockedTransaction).commit();
 176                 Mockito.doReturn(TRANSACTION_NAME).when(mockedTransaction).getIdentifier();
 177
 178                 Mockito.doReturn(mockedResult).when(mockedFuture).get();
 179                 Mockito.doReturn(true).when(mockedResult).isSuccessful();
 180                 Mockito.doReturn(Collections.emptySet()).when(mockedResult).getErrors();
 181         }
 182
 183         protected List<ModuleFactory> getModuleFactories() {
 184                 return Lists.newArrayList(this.factory,
 185                                 this.dispactherFactory, this.threadgroupFactory,
 186                                 this.reconnectFactory, this.dataBrokerFactory, this.executorFactory, this.extensionFactory,
 187                                 this.ribExtensionsFactory, this.domBrokerFactory, this.runtimeMappingFactory,
 188                                 this.dataStroreFactory, this.hwtFactory);
 189         }
 190
 191         @Override
 192         protected BundleContextServiceRegistrationHandler getBundleContextServiceRegistrationHandler(final Class<?> serviceType) {
 193                 if (serviceType.equals(SchemaServiceListener.class)) {
 194                         return new BundleContextServiceRegistrationHandler() {
 195                                 @Override
 196                                 public void handleServiceRegistration(final Object o) {
 197                                         SchemaServiceListener listener = (SchemaServiceListener) o;
 198                                         listener.onGlobalContextUpdated(getMockedSchemaContext());
 199                                 }
 200                         };
 201                 }
 202
 203                 return super.getBundleContextServiceRegistrationHandler(serviceType);
 204         }
 205
 206         @Test
 207         public void testCreateBean() throws Exception {
 208                 ConfigTransactionJMXClient transaction = configRegistryClient
 209                                 .createTransaction();
 210                 createInstance(transaction, this.factory.getImplementationName(), INSTANCE_NAME,
 211                                 this.dataBrokerFactory.getImplementationName(), this.reconnectFactory.getImplementationName(),
 212                                 this.executorFactory.getImplementationName(), this.dispactherFactory.getImplementationName(),
 213                                 this.ribExtensionsFactory.getImplementationName(), this.domBrokerFactory.getImplementationName(),
 214                                 this.dataStroreFactory.getImplementationName());
 215                 transaction.validateConfig();
 216                 CommitStatus status = transaction.commit();
 217                 Thread.sleep(2000);
 218                 assertBeanCount(1, factory.getImplementationName());
 219                 assertStatus(status, 14, 0, 0);
 220         }
 221
 222         @After
 223         public void closeAllModules() throws Exception {
 224                 super.destroyAllConfigBeans();
 225         }
 226
 227         public static ObjectName createInstance(final ConfigTransactionJMXClient transaction, final String moduleName,
 228                         final String instanceName, final String bindingDataModuleName, final String reconnectModueName,
 229                         final String executorModuleName, final String dispatcherModuleName, final String ribExtensionsModuleName,
 230                         final String domBrokerModuleName, final String dataStroreModuleName)
 231                                         throws Exception {
 232                 ObjectName nameCreated = transaction.createModule(
 233                                 moduleName, instanceName);
 234                 RIBImplModuleMXBean mxBean = transaction.newMXBeanProxy(
 235                                 nameCreated, RIBImplModuleMXBean.class);
 236                 ObjectName reconnectObjectName = TimedReconnectStrategyModuleTest.createInstance(transaction, reconnectModueName, "session-reconnect-strategy", 100, 1000L, new BigDecimal(1.0), 5000L, 2000L, null);
 237                 mxBean.setSessionReconnectStrategy(reconnectObjectName);
 238                 mxBean.setDataProvider(createDataBrokerInstance(transaction, bindingDataModuleName, "data-broker-impl", domBrokerModuleName, dataStroreModuleName));
 239                 ObjectName reconnectStrategyON = TimedReconnectStrategyModuleTest.createInstance(transaction, reconnectModueName, "tcp-reconnect-strategy", 100, 1000L, new BigDecimal(1.0), 5000L, 2000L, null);
 240                 mxBean.setTcpReconnectStrategy(reconnectStrategyON);
 241                 mxBean.setBgpDispatcher(BGPDispatcherImplModuleTest.createInstance(transaction, dispatcherModuleName, "bgp-dispatcher"));
 242                 mxBean.setExtensions(createRibExtensionsInstance(transaction, ribExtensionsModuleName, "rib-extensions-privider1"));
 243                 mxBean.setRibId(new RibId("test"));
 244                 mxBean.setLocalAs(5000L);
 245                 mxBean.setBgpId(new Ipv4Address("192.168.1.1"));
 246                 return nameCreated;
 247         }
 248
 249         public static ObjectName createDataBrokerInstance(final ConfigTransactionJMXClient transaction, final String moduleName,
 250                         final String instanceName, final String domBrokerModuleName, final String dataStroreModuleName) throws
 251                         InstanceAlreadyExistsException, InstanceNotFoundException {
 252                 ObjectName nameCreated = transaction.createModule(
 253                                 moduleName, instanceName);
 254                 DataBrokerImplModuleMXBean mxBean = transaction.newMBeanProxy(
 255                                 nameCreated, DataBrokerImplModuleMXBean.class);
 256                 mxBean.setDomBroker(createDomBrokerInstance(transaction, domBrokerModuleName, "dom-broker1", dataStroreModuleName));
 257                 mxBean.setMappingService(lookupMappingServiceInstance(transaction));
 258                 return nameCreated;
 259         }
 260
 261         public static ObjectName createDomBrokerInstance(final ConfigTransactionJMXClient transaction, final String moduleName,
 262                         final String instanceName, final String dataStroreModuleName) throws InstanceAlreadyExistsException {
 263                 ObjectName nameCreated = transaction.createModule(
 264                                 moduleName, instanceName);
 265                 DomBrokerImplModuleMXBean mxBean = transaction.newMBeanProxy(
 266                                 nameCreated, DomBrokerImplModuleMXBean.class);
 267                 mxBean.setDataStore(createDataStoreInstance(transaction, dataStroreModuleName, "has-map-data-strore-instance"));
 268                 return nameCreated;
 269         }
 270
 271         public static ObjectName createDataStoreInstance(final ConfigTransactionJMXClient transaction, final String moduleName,
 272                         final String instanceName) throws InstanceAlreadyExistsException {
 273                 ObjectName nameCreated = transaction.createModule(
 274                                 moduleName, instanceName);
 275                 transaction.newMBeanProxy(
 276                                 nameCreated, HashMapDataStoreModuleMXBean.class);
 277                 return nameCreated;
 278         }
 279
 280         public static ObjectName lookupMappingServiceInstance(final ConfigTransactionJMXClient transaction) {
 281
 282                 try {
 283                         return transaction.lookupConfigBean(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 284                 } catch (InstanceNotFoundException e) {
 285                         try {
 286                                 return transaction.createModule(RuntimeMappingModuleFactory.NAME, RuntimeMappingModuleFactory.SINGLETON_NAME);
 287                         } catch (InstanceAlreadyExistsException e1) {
 288                                 throw new IllegalStateException(e1);
 289                         }
 290                 }
 291         }
 292
 293         public static ObjectName createRibExtensionsInstance(final ConfigTransactionJMXClient transaction, final String moduleName,
 294                         final String instanceName) throws InstanceAlreadyExistsException {
 295                 ObjectName nameCreated = transaction.createModule(
 296                                 moduleName, instanceName);
 297                 transaction.newMBeanProxy(
 298                                 nameCreated, RIBExtensionsImplModuleMXBean.class);
 299                 return nameCreated;
 300         }
 301
 302         public SchemaContext getMockedSchemaContext() {
 303                 List<String> paths = Arrays.asList("/META-INF/yang/bgp-rib.yang", "/META-INF/yang/ietf-inet-types.yang",
 304                                 "/META-INF/yang/bgp-message.yang", "/META-INF/yang/bgp-multiprotocol.yang", "/META-INF/yang/bgp-types.yang");
 305                 return YangParserWrapper.parseYangFiles(getFilesAsInputStreams(paths));
 306         }
 307 }