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