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