opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/flexible/FlexibleThreadPoolConfigBeanTest.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.threadpool.flexible;
   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.threadpool.impl.NamingThreadFactoryModuleFactory;
  19 import org.opendaylight.controller.config.yang.threadpool.impl.NamingThreadFactoryModuleMXBean;
  20 import org.opendaylight.controller.config.yang.threadpool.impl.flexible.FlexibleThreadPoolModuleFactory;
  21 import org.opendaylight.controller.config.yang.threadpool.impl.flexible.FlexibleThreadPoolModuleMXBean;
  22
  23 import javax.management.InstanceAlreadyExistsException;
  24 import javax.management.InstanceNotFoundException;
  25 import javax.management.ObjectName;
  26
  27 import static org.junit.Assert.assertThat;
  28 import static org.junit.Assert.fail;
  29 import static org.junit.matchers.JUnitMatchers.containsString;
  30
  31 public class FlexibleThreadPoolConfigBeanTest extends AbstractConfigTest {
  32
  33     private FlexibleThreadPoolModuleFactory flexibleFactory;
  34     private final String instanceName = "flexible1";
  35     private final String threadFactoryName = "threadFactoryName";
  36
  37     @Before
  38     public void setUp() {
  39
  40         flexibleFactory = new FlexibleThreadPoolModuleFactory();
  41         super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(mockedContext,flexibleFactory,
  42                 new NamingThreadFactoryModuleFactory()));
  43     }
  44
  45     @Test
  46     public void testCreateBean() throws InstanceAlreadyExistsException, ValidationException,
  47             ConflictingVersionException {
  48         ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
  49
  50         createFlexible(transaction, instanceName, threadFactoryName, 1, 20, 20);
  51         transaction.validateConfig();
  52         CommitStatus status = transaction.commit();
  53
  54         assertBeanCount(1, flexibleFactory.getImplementationName());
  55         assertStatus(status, 2, 0, 0);
  56     }
  57
  58     @Test
  59     public void testReusingOldInstance() throws InstanceAlreadyExistsException, ConflictingVersionException,
  60             ValidationException {
  61
  62         ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
  63         createFlexible(transaction, instanceName, threadFactoryName, 1, 20, 10);
  64
  65         transaction.commit();
  66
  67         assertBeanCount(1, flexibleFactory.getImplementationName());
  68
  69         transaction = configRegistryClient.createTransaction();
  70         CommitStatus status = transaction.commit();
  71
  72         assertBeanCount(1, flexibleFactory.getImplementationName());
  73         assertStatus(status, 0, 0, 2);
  74
  75     }
  76
  77     @Test
  78     public void testInstanceAlreadyExistsException() throws ConflictingVersionException, ValidationException {
  79         ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
  80
  81         try {
  82             createFlexible(transaction, instanceName, threadFactoryName, 1, 1, 2);
  83             transaction.commit();
  84         } catch (InstanceAlreadyExistsException e1) {
  85             fail();
  86         }
  87
  88         transaction = configRegistryClient.createTransaction();
  89         try {
  90             createFlexible(transaction, instanceName, "threadFactoryName1", 2, 2, 2);
  91             fail();
  92         } catch (InstanceAlreadyExistsException e) {
  93             assertThat(
  94                     e.getMessage(),
  95                     containsString("There is an instance registered with name ModuleIdentifier{factoryName='threadpool-flexible', instanceName='flexible1'}"));
  96         }
  97     }
  98
  99     @Test
 100     public void testValidationException() throws InstanceAlreadyExistsException {
 101         ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
 102
 103         createFlexible(transaction, instanceName, threadFactoryName, 0, 10, 10);
 104
 105         try {
 106             transaction.validateConfig();
 107             fail();
 108         } catch (ValidationException e) {
 109             assertThat(e.getMessage(), containsString("MinThreadCount must be greater than zero"));
 110         }
 111     }
 112
 113     @Test
 114     public void testValidationException2() throws InstanceAlreadyExistsException {
 115         ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
 116
 117         createFlexible(transaction, instanceName, threadFactoryName, 0, 0, 10);
 118
 119         try {
 120             transaction.validateConfig();
 121             fail();
 122         } catch (ValidationException e) {
 123             assertThat(e.getMessage(), containsString("KeepAliveMillis must be greater than zero"));
 124         }
 125     }
 126
 127     @Test
 128     public void testValidationException3() throws InstanceAlreadyExistsException {
 129         ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
 130
 131         createFlexible(transaction, instanceName, threadFactoryName, 10, 50, 0);
 132
 133         try {
 134             transaction.validateConfig();
 135             fail();
 136         } catch (ValidationException e) {
 137             assertThat(e.getMessage(), containsString("MaxThreadCount must be greater than zero"));
 138         }
 139     }
 140
 141     private ObjectName createFlexible(ConfigTransactionJMXClient transaction, String instanceName,
 142             String threadFactoryName, int minThreadCount, long keepAliveMillis, int maxThreadCount)
 143             throws InstanceAlreadyExistsException {
 144
 145         ObjectName threadFactoryON = transaction.createModule(NamingThreadFactoryModuleFactory.NAME, threadFactoryName);
 146         NamingThreadFactoryModuleMXBean namingThreadFactoryModuleMXBean = transaction.newMXBeanProxy(threadFactoryON,
 147                 NamingThreadFactoryModuleMXBean.class);
 148         namingThreadFactoryModuleMXBean.setNamePrefix("prefix");
 149
 150         ObjectName flexibleON = transaction.createModule(flexibleFactory.getImplementationName(), instanceName);
 151         FlexibleThreadPoolModuleMXBean mxBean = transaction.newMBeanProxy(flexibleON,
 152                 FlexibleThreadPoolModuleMXBean.class);
 153         mxBean.setKeepAliveMillis(keepAliveMillis);
 154         mxBean.setMaxThreadCount(maxThreadCount);
 155         mxBean.setMinThreadCount(minThreadCount);
 156         mxBean.setThreadFactory(threadFactoryON);
 157         return flexibleON;
 158     }
 159
 160     @Test
 161     public void testReconfigurationInstance() throws InstanceAlreadyExistsException, ValidationException,
 162             ConflictingVersionException, InstanceNotFoundException {
 163         ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction();
 164         createFlexible(transaction, instanceName, threadFactoryName, 2, 2, 2);
 165
 166         transaction.commit();
 167
 168         transaction = configRegistryClient.createTransaction();
 169         ObjectName databaseNew = transaction.lookupConfigBean(flexibleFactory.getImplementationName(), instanceName);
 170         FlexibleThreadPoolModuleMXBean proxy = transaction.newMXBeanProxy(databaseNew,
 171                 FlexibleThreadPoolModuleMXBean.class);
 172         proxy.setMaxThreadCount(99);
 173
 174         CommitStatus status = transaction.commit();
 175
 176         assertBeanCount(1, flexibleFactory.getImplementationName());
 177         assertStatus(status, 0, 1, 1);
 178     }
 179
 180 }