pcep/impl-config/src/test/java/org/opendaylight/controller/config/yang/pcep/impl/PCEPDispatcherImplModuleTest.java

   1 package org.opendaylight.controller.config.yang.pcep.impl;
   2
   3 import static org.junit.Assert.assertTrue;
   4 import static org.junit.Assert.fail;
   5
   6 import javax.management.InstanceAlreadyExistsException;
   7 import javax.management.InstanceNotFoundException;
   8 import javax.management.ObjectName;
   9
  10 import org.junit.Before;
  11 import org.junit.Test;
  12 import org.opendaylight.controller.config.api.ConflictingVersionException;
  13 import org.opendaylight.controller.config.api.ValidationException;
  14 import org.opendaylight.controller.config.api.jmx.CommitStatus;
  15 import org.opendaylight.controller.config.manager.impl.AbstractConfigTest;
  16 import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver;
  17 import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
  18 import org.opendaylight.controller.config.yang.netty.threadgroup.NettyThreadgroupModuleFactory;
  19 import org.opendaylight.controller.config.yang.netty.threadgroup.NettyThreadgroupModuleMXBean;
  20 import org.opendaylight.controller.config.yang.netty.timer.HashedWheelTimerModuleFactory;
  21 import org.opendaylight.controller.config.yang.netty.timer.HashedWheelTimerModuleMXBean;
  22 import org.opendaylight.controller.config.yang.pcep.spi.SimplePCEPExtensionProviderContextModuleFactory;
  23 import org.opendaylight.controller.config.yang.pcep.spi.SimplePCEPExtensionProviderContextModuleMXBean;
  24
  25 public class PCEPDispatcherImplModuleTest extends AbstractConfigTest {
  26
  27         private final String instanceName = "pcep-dispatcher";
  28
  29         private PCEPDispatcherImplModuleFactory factory;
  30
  31         private PCEPSessionProposalFactoryImplModuleFactory sessionFactory;
  32
  33         private NettyThreadgroupModuleFactory threadgroupFactory;
  34
  35         private SimplePCEPExtensionProviderContextModuleFactory extensionsFactory;
  36
  37         private HashedWheelTimerModuleFactory timerFactory;
  38
  39         @Before
  40         public void setUp() throws Exception {
  41                 this.factory = new PCEPDispatcherImplModuleFactory();
  42                 this.sessionFactory = new PCEPSessionProposalFactoryImplModuleFactory();
  43                 this.threadgroupFactory = new NettyThreadgroupModuleFactory();
  44                 this.extensionsFactory = new SimplePCEPExtensionProviderContextModuleFactory();
  45                 this.timerFactory = new HashedWheelTimerModuleFactory();
  46                 super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(
  47                                 factory, sessionFactory, threadgroupFactory, extensionsFactory,
  48                                 timerFactory));
  49         }
  50
  51         @Test
  52         public void testValidationExceptionMaxUnknownMessagesNotSet()
  53                         throws InstanceAlreadyExistsException {
  54                 try {
  55                         ConfigTransactionJMXClient transaction = configRegistryClient
  56                                         .createTransaction();
  57                         createInstance(transaction, this.factory.getImplementationName(),
  58                                         instanceName, null,
  59                                         this.sessionFactory.getImplementationName(),
  60                                         this.threadgroupFactory.getImplementationName(),
  61                                         this.extensionsFactory.getImplementationName(),
  62                                         this.timerFactory.getImplementationName());
  63                         transaction.validateConfig();
  64                         fail();
  65                 } catch (ValidationException e) {
  66                         assertTrue(e.getMessage().contains(
  67                                         "MaxUnknownMessages value is not set"));
  68                 }
  69         }
  70
  71         @Test
  72         public void testValidationExceptionMaxUnknownMessagesMinValue()
  73                         throws InstanceAlreadyExistsException {
  74                 try {
  75                         ConfigTransactionJMXClient transaction = configRegistryClient
  76                                         .createTransaction();
  77                         createInstance(transaction, this.factory.getImplementationName(),
  78                                         instanceName, 0,
  79                                         this.sessionFactory.getImplementationName(),
  80                                         this.threadgroupFactory.getImplementationName(),
  81                                         this.extensionsFactory.getImplementationName(),
  82                                         this.timerFactory.getImplementationName());
  83                         transaction.validateConfig();
  84                         fail();
  85                 } catch (ValidationException e) {
  86                         assertTrue(e.getMessage().contains("must be greater than 0"));
  87                 }
  88         }
  89
  90         @Test
  91         public void testCreateBean() throws Exception {
  92                 ConfigTransactionJMXClient transaction = configRegistryClient
  93                                 .createTransaction();
  94                 createInstance(transaction, this.factory.getImplementationName(),
  95                                 instanceName, 5, this.sessionFactory.getImplementationName(),
  96                                 this.threadgroupFactory.getImplementationName(),
  97                                 this.extensionsFactory.getImplementationName(),
  98                                 this.timerFactory.getImplementationName());
  99                 transaction.validateConfig();
 100                 CommitStatus status = transaction.commit();
 101                 assertBeanCount(1, factory.getImplementationName());
 102                 assertStatus(status, 6, 0, 0);
 103         }
 104
 105         @Test
 106         public void testReusingOldInstance() throws InstanceAlreadyExistsException,
 107         ConflictingVersionException, ValidationException {
 108                 ConfigTransactionJMXClient transaction = configRegistryClient
 109                                 .createTransaction();
 110                 createInstance(transaction, this.factory.getImplementationName(),
 111                                 instanceName, 5, this.sessionFactory.getImplementationName(),
 112                                 this.threadgroupFactory.getImplementationName(),
 113                                 this.extensionsFactory.getImplementationName(),
 114                                 this.timerFactory.getImplementationName());
 115                 transaction.commit();
 116                 transaction = configRegistryClient.createTransaction();
 117                 assertBeanCount(1, factory.getImplementationName());
 118                 CommitStatus status = transaction.commit();
 119                 assertBeanCount(1, factory.getImplementationName());
 120                 assertStatus(status, 0, 0, 6);
 121         }
 122
 123         @Test
 124         public void testReconfigure() throws InstanceAlreadyExistsException,
 125         ConflictingVersionException, ValidationException,
 126         InstanceNotFoundException {
 127                 ConfigTransactionJMXClient transaction = configRegistryClient
 128                                 .createTransaction();
 129                 createInstance(transaction, this.factory.getImplementationName(),
 130                                 instanceName, 5, this.sessionFactory.getImplementationName(),
 131                                 this.threadgroupFactory.getImplementationName(),
 132                                 this.extensionsFactory.getImplementationName(),
 133                                 this.timerFactory.getImplementationName());
 134                 transaction.commit();
 135                 transaction = configRegistryClient.createTransaction();
 136                 assertBeanCount(1, factory.getImplementationName());
 137                 PCEPDispatcherImplModuleMXBean mxBean = transaction.newMBeanProxy(
 138                                 transaction.lookupConfigBean(
 139                                                 this.factory.getImplementationName(), instanceName),
 140                                                 PCEPDispatcherImplModuleMXBean.class);
 141                 mxBean.setMaxUnknownMessages(10);
 142                 CommitStatus status = transaction.commit();
 143                 assertBeanCount(1, factory.getImplementationName());
 144                 assertStatus(status, 0, 1, 5);
 145         }
 146
 147         public static ObjectName createInstance(
 148                         final ConfigTransactionJMXClient transaction,
 149                         final String moduleName, final String instanceName,
 150                         final Integer maxUnknownMessages,
 151                         final String sessionFactoryImplName,
 152                         final String threadGroupFactoryImplName,
 153                         final String extensionsImplName, final String timerFactoryImplName)
 154                                         throws InstanceAlreadyExistsException {
 155                 ObjectName nameCreated = transaction.createModule(moduleName,
 156                                 instanceName);
 157                 PCEPDispatcherImplModuleMXBean mxBean = transaction.newMBeanProxy(
 158                                 nameCreated, PCEPDispatcherImplModuleMXBean.class);
 159                 mxBean.setPcepSessionProposalFactory(PCEPSessionProposalFactoryImplModuleTest
 160                                 .createInstance(transaction, sessionFactoryImplName,
 161                                                 "pcep-proposal", 0, 0, true, true, true, true));
 162                 mxBean.setMaxUnknownMessages(maxUnknownMessages);
 163                 mxBean.setBossGroup(createThreadGroupInstance(transaction,
 164                                 threadGroupFactoryImplName, "boss-group", 10));
 165                 mxBean.setWorkerGroup(createThreadGroupInstance(transaction,
 166                                 threadGroupFactoryImplName, "worker-group", 10));
 167                 mxBean.setExtensions(createExtensionsInstance(transaction,
 168                                 extensionsImplName, "extensions"));
 169                 mxBean.setTimer(createTimerInstance(transaction, timerFactoryImplName,
 170                                 "timmer1"));
 171                 return nameCreated;
 172         }
 173
 174         public static ObjectName createExtensionsInstance(
 175                         final ConfigTransactionJMXClient transaction,
 176                         final String moduleName, final String instanceName)
 177                                         throws InstanceAlreadyExistsException {
 178                 ObjectName nameCreated = transaction.createModule(moduleName,
 179                                 instanceName);
 180                 transaction.newMBeanProxy(nameCreated,
 181                                 SimplePCEPExtensionProviderContextModuleMXBean.class);
 182
 183                 return nameCreated;
 184         }
 185
 186         public static ObjectName createThreadGroupInstance(
 187                         final ConfigTransactionJMXClient transaction,
 188                         final String moduleName, final String instanceName,
 189                         final Integer threadCount) throws InstanceAlreadyExistsException {
 190                 ObjectName nameCreated = transaction.createModule(moduleName,
 191                                 instanceName);
 192                 NettyThreadgroupModuleMXBean mxBean = transaction.newMBeanProxy(
 193                                 nameCreated, NettyThreadgroupModuleMXBean.class);
 194                 mxBean.setThreadCount(threadCount);
 195                 return nameCreated;
 196         }
 197
 198         public static ObjectName createTimerInstance(
 199                         final ConfigTransactionJMXClient transaction,
 200                         final String moduleName, final String instanceName)
 201                                         throws InstanceAlreadyExistsException {
 202                 ObjectName nameCreated = transaction.createModule(moduleName,
 203                                 instanceName);
 204                 transaction.newMBeanProxy(nameCreated,
 205                                 HashedWheelTimerModuleMXBean.class);
 206                 return nameCreated;
 207         }
 208
 209 }