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