From 17c744900d71af042b05118a0d7abdc097c057e5 Mon Sep 17 00:00:00 2001 From: Milos Fabian Date: Fri, 8 Nov 2013 13:58:31 +0100 Subject: [PATCH] Added threadpool config tests. Change-Id: I7664c762b3c6e63085a4b73a92ba871e856e21c6 Signed-off-by: Milos Fabian --- .../config/threadpool-config-impl/pom.xml | 23 +++ .../async/AsyncEventBusConfigBeanTest.java | 100 ++++++++++ .../eventbus/SyncEventBusConfigBeanTest.java | 97 ++++++++++ .../eventbus/TestingEventBusModule.java | 28 +++ .../fixed/FixedThreadPoolConfigBeanTest.java | 129 +++++++++++++ .../fixed/TestingFixedThreadPoolModule.java | 30 +++ .../FlexibleThreadPoolConfigBeanTest.java | 173 ++++++++++++++++++ ...NamingThreadPoolFactoryConfigBeanTest.java | 136 ++++++++++++++ .../TestingNamingThreadPoolFactoryModule.java | 59 ++++++ .../ScheduledThreadPoolConfigBeanTest.java | 154 ++++++++++++++++ .../TestingScheduledThreadPoolModule.java | 77 ++++++++ 11 files changed, 1006 insertions(+) create mode 100644 opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/async/AsyncEventBusConfigBeanTest.java create mode 100644 opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/eventbus/SyncEventBusConfigBeanTest.java create mode 100644 opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/eventbus/TestingEventBusModule.java create mode 100644 opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/fixed/FixedThreadPoolConfigBeanTest.java create mode 100644 opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/fixed/TestingFixedThreadPoolModule.java create mode 100644 opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/flexible/FlexibleThreadPoolConfigBeanTest.java create mode 100644 opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/naming/NamingThreadPoolFactoryConfigBeanTest.java create mode 100644 opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/naming/TestingNamingThreadPoolFactoryModule.java create mode 100644 opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/scheduled/ScheduledThreadPoolConfigBeanTest.java create mode 100644 opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/scheduled/TestingScheduledThreadPoolModule.java diff --git a/opendaylight/config/threadpool-config-impl/pom.xml b/opendaylight/config/threadpool-config-impl/pom.xml index 12279781a2..1bad023bac 100644 --- a/opendaylight/config/threadpool-config-impl/pom.xml +++ b/opendaylight/config/threadpool-config-impl/pom.xml @@ -31,6 +31,29 @@ org.slf4j slf4j-api + + + + org.opendaylight.controller + config-manager + test + test-jar + + + org.opendaylight.controller + config-manager + test + + + org.opendaylight.controller + config-util + test + + + org.opendaylight.bgpcep + mockito-configuration + test + diff --git a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/async/AsyncEventBusConfigBeanTest.java b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/async/AsyncEventBusConfigBeanTest.java new file mode 100644 index 0000000000..b2fc75d700 --- /dev/null +++ b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/async/AsyncEventBusConfigBeanTest.java @@ -0,0 +1,100 @@ +package org.opendaylight.controller.config.threadpool.async; + +import static org.junit.Assert.assertThat; +import static org.junit.Assert.fail; +import static org.junit.matchers.JUnitMatchers.containsString; + +import javax.management.InstanceAlreadyExistsException; +import javax.management.ObjectName; + +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.config.api.ConflictingVersionException; +import org.opendaylight.controller.config.api.ValidationException; +import org.opendaylight.controller.config.api.jmx.CommitStatus; +import org.opendaylight.controller.config.manager.impl.AbstractConfigTest; +import org.opendaylight.controller.config.manager.impl.ClassBasedModuleFactory; +import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver; +import org.opendaylight.controller.config.threadpool.scheduled.TestingScheduledThreadPoolModule; +import org.opendaylight.controller.config.util.ConfigTransactionJMXClient; +import org.opendaylight.controller.config.yang.threadpool.impl.AsyncEventBusModuleFactory; +import org.opendaylight.controller.config.yang.threadpool.impl.AsyncEventBusModuleMXBean; + +public class AsyncEventBusConfigBeanTest extends AbstractConfigTest { + + private AsyncEventBusModuleFactory factory; + private final String instanceName = "async1"; + private final String poolImplName = "fixed1"; + + @Before + public void setUp() { + + ClassBasedModuleFactory scheduledThreadPoolConfigFactory = createClassBasedCBF( + TestingScheduledThreadPoolModule.class, poolImplName); + + factory = new AsyncEventBusModuleFactory(); + super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(factory, + scheduledThreadPoolConfigFactory)); + } + + @Test + public void testCreateBean() throws InstanceAlreadyExistsException, ValidationException, + ConflictingVersionException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + + createAsynced(transaction, instanceName, transaction.createModule(poolImplName, "pool-test")); + transaction.validateConfig(); + CommitStatus status = transaction.commit(); + + assertBeanCount(1, factory.getImplementationName()); + assertStatus(status, 2, 0, 0); + } + + @Test + public void testReusingOldInstance() throws InstanceAlreadyExistsException, ConflictingVersionException, + ValidationException { + + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + createAsynced(transaction, instanceName, transaction.createModule(poolImplName, "pool-test")); + + transaction.commit(); + + assertBeanCount(1, factory.getImplementationName()); + + transaction = configRegistryClient.createTransaction(); + CommitStatus status = transaction.commit(); + + assertBeanCount(1, factory.getImplementationName()); + assertStatus(status, 0, 0, 2); + + } + + @Test + public void testInstanceAlreadyExistsException() throws ConflictingVersionException, ValidationException, + InstanceAlreadyExistsException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + + ObjectName poolCB = transaction.createModule(poolImplName, "pool-test"); + createAsynced(transaction, instanceName, poolCB); + transaction.commit(); + + transaction = configRegistryClient.createTransaction(); + try { + createAsynced(transaction, instanceName, poolCB); + fail(); + } catch (InstanceAlreadyExistsException e) { + assertThat( + e.getMessage(), + containsString("There is an instance registered with name ModuleIdentifier{factoryName='async-eventbus', instanceName='async1'}")); + } + } + + private ObjectName createAsynced(ConfigTransactionJMXClient transaction, String instanceName, ObjectName threadPool) + throws InstanceAlreadyExistsException { + ObjectName nameCreated = transaction.createModule(factory.getImplementationName(), instanceName); + AsyncEventBusModuleMXBean mxBean = transaction.newMBeanProxy(nameCreated, AsyncEventBusModuleMXBean.class); + mxBean.setThreadpool(threadPool); + return nameCreated; + } + +} diff --git a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/eventbus/SyncEventBusConfigBeanTest.java b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/eventbus/SyncEventBusConfigBeanTest.java new file mode 100644 index 0000000000..4cd279f881 --- /dev/null +++ b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/eventbus/SyncEventBusConfigBeanTest.java @@ -0,0 +1,97 @@ +package org.opendaylight.controller.config.threadpool.eventbus; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.fail; +import static org.junit.matchers.JUnitMatchers.containsString; + +import javax.management.InstanceAlreadyExistsException; +import javax.management.ObjectName; + +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.config.api.ConflictingVersionException; +import org.opendaylight.controller.config.api.ValidationException; +import org.opendaylight.controller.config.api.jmx.CommitStatus; +import org.opendaylight.controller.config.manager.impl.AbstractConfigTest; +import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver; +import org.opendaylight.controller.config.util.ConfigTransactionJMXClient; +import org.opendaylight.controller.config.yang.threadpool.impl.EventBusModuleFactory; + +public class SyncEventBusConfigBeanTest extends AbstractConfigTest { + + private EventBusModuleFactory factory; + private final String instanceName = "sync1"; + + @Before + public void setUp() { + + factory = new EventBusModuleFactory(); + super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(factory)); + } + + @Test + public void testCreateBean() throws InstanceAlreadyExistsException, ValidationException, + ConflictingVersionException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + + createSynced(transaction, instanceName); + transaction.validateConfig(); + CommitStatus status = transaction.commit(); + + assertEquals(1, configRegistry.lookupConfigBeans(factory.getImplementationName()).size()); + assertEquals(1, status.getNewInstances().size()); + assertEquals(0, status.getRecreatedInstances().size()); + assertEquals(0, status.getReusedInstances().size()); + // TODO test dead event collector + } + + @Test + public void testReusingOldInstance() throws InstanceAlreadyExistsException, ConflictingVersionException, + ValidationException { + + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + createSynced(transaction, instanceName); + + transaction.commit(); + + assertEquals(1, configRegistry.lookupConfigBeans(factory.getImplementationName()).size()); + + transaction = configRegistryClient.createTransaction(); + CommitStatus status = transaction.commit(); + + assertEquals(1, configRegistry.lookupConfigBeans(factory.getImplementationName()).size()); + assertEquals(0, status.getNewInstances().size()); + assertEquals(0, status.getRecreatedInstances().size()); + assertEquals(1, status.getReusedInstances().size()); + + } + + @Test + public void testInstanceAlreadyExistsException() throws ConflictingVersionException, ValidationException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + + try { + createSynced(transaction, instanceName); + transaction.commit(); + } catch (InstanceAlreadyExistsException e1) { + fail(); + } + + transaction = configRegistryClient.createTransaction(); + try { + createSynced(transaction, instanceName); + fail(); + } catch (InstanceAlreadyExistsException e) { + assertThat( + e.getMessage(), + containsString("There is an instance registered with name ModuleIdentifier{factoryName='eventbus', instanceName='sync1'}")); + } + } + + private ObjectName createSynced(ConfigTransactionJMXClient transaction, String instanceName) + throws InstanceAlreadyExistsException { + ObjectName nameCreated = transaction.createModule(factory.getImplementationName(), instanceName); + return nameCreated; + } +} diff --git a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/eventbus/TestingEventBusModule.java b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/eventbus/TestingEventBusModule.java new file mode 100644 index 0000000000..ee6bbc51bc --- /dev/null +++ b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/eventbus/TestingEventBusModule.java @@ -0,0 +1,28 @@ +package org.opendaylight.controller.config.threadpool.eventbus; + +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.mock; + +import org.opendaylight.controller.config.api.DynamicMBeanWithInstance; +import org.opendaylight.controller.config.api.ModuleIdentifier; +import org.opendaylight.controller.config.manager.impl.AbstractMockedModule; +import org.opendaylight.controller.config.spi.Module; +import org.opendaylight.controller.config.threadpool.util.CloseableEventBus; +import org.opendaylight.controller.config.yang.threadpool.EventBusServiceInterface; +import org.opendaylight.controller.config.yang.threadpool.impl.EventBusModuleMXBean; + +public class TestingEventBusModule extends AbstractMockedModule implements Module, EventBusServiceInterface, + EventBusModuleMXBean { + + public TestingEventBusModule(DynamicMBeanWithInstance old, ModuleIdentifier id) { + super(old, id); + } + + @Override + protected AutoCloseable prepareMockedInstance() throws Exception { + CloseableEventBus bus = mock(CloseableEventBus.class); + doNothing().when(bus).close(); + return bus; + } + +} diff --git a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/fixed/FixedThreadPoolConfigBeanTest.java b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/fixed/FixedThreadPoolConfigBeanTest.java new file mode 100644 index 0000000000..4fda06bf4c --- /dev/null +++ b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/fixed/FixedThreadPoolConfigBeanTest.java @@ -0,0 +1,129 @@ +package org.opendaylight.controller.config.threadpool.fixed; + +import static org.junit.Assert.assertThat; +import static org.junit.Assert.fail; +import static org.junit.matchers.JUnitMatchers.containsString; + +import javax.management.InstanceAlreadyExistsException; +import javax.management.InstanceNotFoundException; +import javax.management.ObjectName; + +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.config.api.ConflictingVersionException; +import org.opendaylight.controller.config.api.ValidationException; +import org.opendaylight.controller.config.api.jmx.CommitStatus; +import org.opendaylight.controller.config.manager.impl.AbstractConfigTest; +import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver; +import org.opendaylight.controller.config.util.ConfigTransactionJMXClient; +import org.opendaylight.controller.config.yang.threadpool.impl.FixedThreadPoolModuleFactory; +import org.opendaylight.controller.config.yang.threadpool.impl.FixedThreadPoolModuleMXBean; +import org.opendaylight.controller.config.yang.threadpool.impl.NamingThreadFactoryModuleFactory; +import org.opendaylight.controller.config.yang.threadpool.impl.NamingThreadFactoryModuleMXBean; + +public class FixedThreadPoolConfigBeanTest extends AbstractConfigTest { + + private FixedThreadPoolModuleFactory factory; + private final String nameInstance = "fixedInstance"; + + @Before + public void setUp() { + factory = new FixedThreadPoolModuleFactory(); + super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(factory, + new NamingThreadFactoryModuleFactory())); + } + + @Test + public void testCreateBean() throws InstanceAlreadyExistsException, ValidationException, + ConflictingVersionException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + createFixed(transaction, nameInstance, 2); + + transaction.validateConfig(); + CommitStatus status = transaction.commit(); + + assertBeanCount(1, factory.getImplementationName()); + assertStatus(status, 2, 0, 0); + } + + @Test + public void testReusingOldInstance() throws InstanceAlreadyExistsException, ConflictingVersionException, + ValidationException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + createFixed(transaction, nameInstance, 4); + + transaction.validateConfig(); + transaction.commit(); + + assertBeanCount(1, factory.getImplementationName()); + + transaction = configRegistryClient.createTransaction(); + CommitStatus status = transaction.commit(); + + assertBeanCount(1, factory.getImplementationName()); + assertStatus(status, 0, 0, 2); + } + + @Test + public void testNegative() throws ConflictingVersionException, ValidationException, InstanceAlreadyExistsException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + + createFixed(transaction, nameInstance, 5); + transaction.commit(); + + transaction = configRegistryClient.createTransaction(); + try { + createFixed(transaction, nameInstance, 0); + fail(); + } catch (InstanceAlreadyExistsException e) { + assertThat( + e.getMessage(), + containsString("There is an instance registered with name ModuleIdentifier{factoryName='threadpool-fixed', instanceName='fixedInstance'}")); + } + } + + @Test + public void testDestroy() throws InstanceAlreadyExistsException, ValidationException, ConflictingVersionException, + InstanceNotFoundException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + createFixed(transaction, nameInstance, 1); + + transaction.commit(); + + transaction = configRegistryClient.createTransaction(); + transaction.destroyConfigBean(factory.getImplementationName(), nameInstance); + CommitStatus status = transaction.commit(); + + assertBeanCount(0, factory.getImplementationName()); + assertStatus(status, 0, 0, 1); + } + + @Test + public void testValidationException() throws InstanceAlreadyExistsException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + createFixed(transaction, nameInstance, -1); + try { + transaction.validateConfig(); + fail(); + } catch (ValidationException e) { + assertThat(e.getMessage(), containsString("MaxThreadCount must be greater than zero")); + } + } + + private ObjectName createFixed(ConfigTransactionJMXClient transaction, String name, int numberOfThreads) + throws InstanceAlreadyExistsException { + ObjectName nameCreated = transaction.createModule(factory.getImplementationName(), name); + FixedThreadPoolModuleMXBean mxBean = transaction.newMXBeanProxy(nameCreated, FixedThreadPoolModuleMXBean.class); + mxBean.setMaxThreadCount(numberOfThreads); + + ObjectName threadFactoryON = transaction.createModule(NamingThreadFactoryModuleFactory.NAME, "naming"); + NamingThreadFactoryModuleMXBean namingThreadFactoryModuleMXBean = transaction.newMXBeanProxy(threadFactoryON, + NamingThreadFactoryModuleMXBean.class); + namingThreadFactoryModuleMXBean.setNamePrefix("prefix"); + + mxBean.setThreadFactory(threadFactoryON); + + return nameCreated; + } + +} diff --git a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/fixed/TestingFixedThreadPoolModule.java b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/fixed/TestingFixedThreadPoolModule.java new file mode 100644 index 0000000000..00be5d8118 --- /dev/null +++ b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/fixed/TestingFixedThreadPoolModule.java @@ -0,0 +1,30 @@ +package org.opendaylight.controller.config.threadpool.fixed; + +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; + +import java.util.concurrent.ExecutorService; + +import org.opendaylight.controller.config.api.DynamicMBeanWithInstance; +import org.opendaylight.controller.config.api.ModuleIdentifier; +import org.opendaylight.controller.config.manager.impl.AbstractMockedModule; +import org.opendaylight.controller.config.spi.Module; +import org.opendaylight.controller.config.threadpool.util.FixedThreadPoolWrapper; +import org.opendaylight.controller.config.yang.threadpool.ThreadPoolServiceInterface; + +public class TestingFixedThreadPoolModule extends AbstractMockedModule implements ThreadPoolServiceInterface, Module { + + public TestingFixedThreadPoolModule(DynamicMBeanWithInstance old, ModuleIdentifier id) { + super(old, id); + } + + @Override + protected AutoCloseable prepareMockedInstance() throws Exception { + FixedThreadPoolWrapper pool = mock(FixedThreadPoolWrapper.class); + doNothing().when(pool).close(); + doReturn(mock(ExecutorService.class)).when(pool).getExecutor(); + return pool; + } + +} diff --git a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/flexible/FlexibleThreadPoolConfigBeanTest.java b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/flexible/FlexibleThreadPoolConfigBeanTest.java new file mode 100644 index 0000000000..ee1de8f8ab --- /dev/null +++ b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/flexible/FlexibleThreadPoolConfigBeanTest.java @@ -0,0 +1,173 @@ +package org.opendaylight.controller.config.threadpool.flexible; + +import static org.junit.Assert.assertThat; +import static org.junit.Assert.fail; +import static org.junit.matchers.JUnitMatchers.containsString; + +import javax.management.InstanceAlreadyExistsException; +import javax.management.InstanceNotFoundException; +import javax.management.ObjectName; + +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.config.api.ConflictingVersionException; +import org.opendaylight.controller.config.api.ValidationException; +import org.opendaylight.controller.config.api.jmx.CommitStatus; +import org.opendaylight.controller.config.manager.impl.AbstractConfigTest; +import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver; +import org.opendaylight.controller.config.util.ConfigTransactionJMXClient; +import org.opendaylight.controller.config.yang.threadpool.impl.FlexibleThreadPoolModuleFactory; +import org.opendaylight.controller.config.yang.threadpool.impl.FlexibleThreadPoolModuleMXBean; +import org.opendaylight.controller.config.yang.threadpool.impl.NamingThreadFactoryModuleFactory; +import org.opendaylight.controller.config.yang.threadpool.impl.NamingThreadFactoryModuleMXBean; + +public class FlexibleThreadPoolConfigBeanTest extends AbstractConfigTest { + + private FlexibleThreadPoolModuleFactory flexibleFactory; + private final String instanceName = "flexible1"; + private final String threadFactoryName = "threadFactoryName"; + + @Before + public void setUp() { + + flexibleFactory = new FlexibleThreadPoolModuleFactory(); + super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(flexibleFactory, + new NamingThreadFactoryModuleFactory())); + } + + @Test + public void testCreateBean() throws InstanceAlreadyExistsException, ValidationException, + ConflictingVersionException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + + createFlexible(transaction, instanceName, threadFactoryName, 1, 20, 20); + transaction.validateConfig(); + CommitStatus status = transaction.commit(); + + assertBeanCount(1, flexibleFactory.getImplementationName()); + assertStatus(status, 2, 0, 0); + } + + @Test + public void testReusingOldInstance() throws InstanceAlreadyExistsException, ConflictingVersionException, + ValidationException { + + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + createFlexible(transaction, instanceName, threadFactoryName, 1, 20, 10); + + transaction.commit(); + + assertBeanCount(1, flexibleFactory.getImplementationName()); + + transaction = configRegistryClient.createTransaction(); + CommitStatus status = transaction.commit(); + + assertBeanCount(1, flexibleFactory.getImplementationName()); + assertStatus(status, 0, 0, 2); + + } + + @Test + public void testInstanceAlreadyExistsException() throws ConflictingVersionException, ValidationException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + + try { + createFlexible(transaction, instanceName, threadFactoryName, 1, 1, 2); + transaction.commit(); + } catch (InstanceAlreadyExistsException e1) { + fail(); + } + + transaction = configRegistryClient.createTransaction(); + try { + createFlexible(transaction, instanceName, "threadFactoryName1", 2, 2, 2); + fail(); + } catch (InstanceAlreadyExistsException e) { + assertThat( + e.getMessage(), + containsString("There is an instance registered with name ModuleIdentifier{factoryName='threadpool-flexible', instanceName='flexible1'}")); + } + } + + @Test + public void testValidationException() throws InstanceAlreadyExistsException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + + createFlexible(transaction, instanceName, threadFactoryName, 0, 10, 10); + + try { + transaction.validateConfig(); + fail(); + } catch (ValidationException e) { + assertThat(e.getMessage(), containsString("MinThreadCount must be greater than zero")); + } + } + + @Test + public void testValidationException2() throws InstanceAlreadyExistsException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + + createFlexible(transaction, instanceName, threadFactoryName, 0, 0, 10); + + try { + transaction.validateConfig(); + fail(); + } catch (ValidationException e) { + assertThat(e.getMessage(), containsString("KeepAliveMillis must be greater than zero")); + } + } + + @Test + public void testValidationException3() throws InstanceAlreadyExistsException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + + createFlexible(transaction, instanceName, threadFactoryName, 10, 50, 0); + + try { + transaction.validateConfig(); + fail(); + } catch (ValidationException e) { + assertThat(e.getMessage(), containsString("MaxThreadCount must be greater than zero")); + } + } + + private ObjectName createFlexible(ConfigTransactionJMXClient transaction, String instanceName, + String threadFactoryName, int minThreadCount, long keepAliveMillis, int maxThreadCount) + throws InstanceAlreadyExistsException { + + ObjectName threadFactoryON = transaction.createModule(NamingThreadFactoryModuleFactory.NAME, threadFactoryName); + NamingThreadFactoryModuleMXBean namingThreadFactoryModuleMXBean = transaction.newMXBeanProxy(threadFactoryON, + NamingThreadFactoryModuleMXBean.class); + namingThreadFactoryModuleMXBean.setNamePrefix("prefix"); + + ObjectName flexibleON = transaction.createModule(flexibleFactory.getImplementationName(), instanceName); + FlexibleThreadPoolModuleMXBean mxBean = transaction.newMBeanProxy(flexibleON, + FlexibleThreadPoolModuleMXBean.class); + mxBean.setKeepAliveMillis(keepAliveMillis); + mxBean.setMaxThreadCount(maxThreadCount); + mxBean.setMinThreadCount(minThreadCount); + mxBean.setThreadFactory(threadFactoryON); + return flexibleON; + } + + @Test + public void testReconfigurationInstance() throws InstanceAlreadyExistsException, ValidationException, + ConflictingVersionException, InstanceNotFoundException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + createFlexible(transaction, instanceName, threadFactoryName, 2, 2, 2); + + transaction.commit(); + + transaction = configRegistryClient.createTransaction(); + ObjectName databaseNew = transaction.lookupConfigBean(flexibleFactory.getImplementationName(), instanceName); + FlexibleThreadPoolModuleMXBean proxy = transaction.newMXBeanProxy(databaseNew, + FlexibleThreadPoolModuleMXBean.class); + proxy.setMaxThreadCount(99); + + CommitStatus status = transaction.commit(); + + assertBeanCount(1, flexibleFactory.getImplementationName()); + assertStatus(status, 0, 1, 1); + } + +} diff --git a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/naming/NamingThreadPoolFactoryConfigBeanTest.java b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/naming/NamingThreadPoolFactoryConfigBeanTest.java new file mode 100644 index 0000000000..9e9565a4f9 --- /dev/null +++ b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/naming/NamingThreadPoolFactoryConfigBeanTest.java @@ -0,0 +1,136 @@ +package org.opendaylight.controller.config.threadpool.naming; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import static org.junit.matchers.JUnitMatchers.containsString; + +import javax.management.InstanceAlreadyExistsException; +import javax.management.InstanceNotFoundException; +import javax.management.ObjectName; + +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.config.api.ConflictingVersionException; +import org.opendaylight.controller.config.api.ValidationException; +import org.opendaylight.controller.config.api.jmx.CommitStatus; +import org.opendaylight.controller.config.manager.impl.AbstractConfigTest; +import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver; +import org.opendaylight.controller.config.util.ConfigTransactionJMXClient; +import org.opendaylight.controller.config.yang.threadpool.ThreadFactoryServiceInterface; +import org.opendaylight.controller.config.yang.threadpool.impl.NamingThreadFactoryModuleFactory; +import org.opendaylight.controller.config.yang.threadpool.impl.NamingThreadFactoryModuleMXBean; + +public class NamingThreadPoolFactoryConfigBeanTest extends AbstractConfigTest { + + private NamingThreadFactoryModuleFactory factory; + private final String instanceName = "named"; + + @Before + public void setUp() { + + factory = new NamingThreadFactoryModuleFactory(); + super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(factory)); + } + + @Test + public void testCreateBean() throws InstanceAlreadyExistsException, ValidationException, + ConflictingVersionException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + + createNamed(transaction, instanceName, "prefixes"); + transaction.validateConfig(); + CommitStatus status = transaction.commit(); + + assertEquals(1, configRegistry.lookupConfigBeans(factory.getImplementationName()).size()); + assertEquals(1, status.getNewInstances().size()); + assertEquals(0, status.getRecreatedInstances().size()); + assertEquals(0, status.getReusedInstances().size()); + } + + @Test + public void testReusingOldInstance() throws InstanceAlreadyExistsException, ConflictingVersionException, + ValidationException { + + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + createNamed(transaction, instanceName, "prefixes"); + + transaction.commit(); + + assertEquals(1, configRegistry.lookupConfigBeans(factory.getImplementationName()).size()); + + transaction = configRegistryClient.createTransaction(); + CommitStatus status = transaction.commit(); + + assertEquals(1, configRegistry.lookupConfigBeans(factory.getImplementationName()).size()); + assertEquals(0, status.getNewInstances().size()); + assertEquals(0, status.getRecreatedInstances().size()); + assertEquals(1, status.getReusedInstances().size()); + + } + + @Test + public void testInstanceAlreadyExistsException() throws ConflictingVersionException, ValidationException, + InstanceAlreadyExistsException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + + createNamed(transaction, instanceName, "prefixes"); + transaction.commit(); + + transaction = configRegistryClient.createTransaction(); + try { + createNamed(transaction, instanceName, "prefixes1"); + fail(); + } catch (InstanceAlreadyExistsException e) { + assertThat( + e.getMessage(), + containsString("There is an instance registered with name ModuleIdentifier{factoryName='threadfactory-naming', instanceName='named'}")); + } + } + + @Test + public void testValidationException() throws InstanceAlreadyExistsException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + + ObjectName nameCreated = transaction.createModule(factory.getImplementationName(), instanceName); + transaction.newMXBeanProxy(nameCreated, ThreadFactoryServiceInterface.class); + try { + transaction.validateConfig(); + fail(); + } catch (ValidationException e) { + assertTrue(e.getFailedValidations().containsKey(factory.getImplementationName())); + assertEquals(1, e.getFailedValidations().get(factory.getImplementationName()).keySet().size()); + } + } + + @Test + public void testReconfigurationInstance() throws InstanceAlreadyExistsException, ValidationException, + ConflictingVersionException, InstanceNotFoundException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + createNamed(transaction, instanceName, "pref"); + + transaction.commit(); + + transaction = configRegistryClient.createTransaction(); + ObjectName databaseNew = transaction.lookupConfigBean(factory.getImplementationName(), instanceName); + NamingThreadFactoryModuleMXBean proxy = transaction.newMXBeanProxy(databaseNew, + NamingThreadFactoryModuleMXBean.class); + proxy.setNamePrefix("pref1"); + + CommitStatus status = transaction.commit(); + + assertBeanCount(1, factory.getImplementationName()); + assertStatus(status, 0, 1, 0); + } + + private ObjectName createNamed(ConfigTransactionJMXClient transaction, String instanceName, String prefixes) + throws InstanceAlreadyExistsException { + ObjectName nameCreated = transaction.createModule(factory.getImplementationName(), instanceName); + NamingThreadFactoryModuleMXBean mxBean = transaction.newMBeanProxy(nameCreated, + NamingThreadFactoryModuleMXBean.class); + mxBean.setNamePrefix(prefixes); + return nameCreated; + } + +} diff --git a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/naming/TestingNamingThreadPoolFactoryModule.java b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/naming/TestingNamingThreadPoolFactoryModule.java new file mode 100644 index 0000000000..5c717ccd4c --- /dev/null +++ b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/naming/TestingNamingThreadPoolFactoryModule.java @@ -0,0 +1,59 @@ +package org.opendaylight.controller.config.threadpool.naming; + +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; + +import java.io.Closeable; +import java.io.IOException; + +import org.opendaylight.controller.config.api.DynamicMBeanWithInstance; +import org.opendaylight.controller.config.api.ModuleIdentifier; +import org.opendaylight.controller.config.spi.Module; +import org.opendaylight.controller.config.threadpool.util.NamingThreadPoolFactory; +import org.opendaylight.controller.config.yang.threadpool.ThreadFactoryServiceInterface; +import org.opendaylight.controller.config.yang.threadpool.impl.NamingThreadFactoryModuleMXBean; + +public class TestingNamingThreadPoolFactoryModule implements Module, ThreadFactoryServiceInterface, + NamingThreadFactoryModuleMXBean { + + private final NamingThreadPoolFactory fact; + + public TestingNamingThreadPoolFactoryModule() throws IOException { + fact = mock(NamingThreadPoolFactory.class); + Thread thread = mock(Thread.class); + doNothing().when(thread).start(); + doReturn(thread).when(fact).newThread(any(Runnable.class)); + doNothing().when(fact).close(); + } + + public TestingNamingThreadPoolFactoryModule(DynamicMBeanWithInstance old) { + fact = (NamingThreadPoolFactory) old.getInstance(); + } + + @Override + public ModuleIdentifier getIdentifier() { + return new ModuleIdentifier(TestingNamingThreadPoolFactoryModule.class.getCanonicalName(), "mock"); + } + + @Override + public String getNamePrefix() { + return null; + } + + @Override + public void setNamePrefix(String arg) { + throw new UnsupportedOperationException(); + } + + @Override + public void validate() { + } + + @Override + public Closeable getInstance() { + return fact; + } + +} diff --git a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/scheduled/ScheduledThreadPoolConfigBeanTest.java b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/scheduled/ScheduledThreadPoolConfigBeanTest.java new file mode 100644 index 0000000000..b4b1b60ffe --- /dev/null +++ b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/scheduled/ScheduledThreadPoolConfigBeanTest.java @@ -0,0 +1,154 @@ +package org.opendaylight.controller.config.threadpool.scheduled; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import static org.junit.matchers.JUnitMatchers.containsString; + +import javax.management.InstanceAlreadyExistsException; +import javax.management.InstanceNotFoundException; +import javax.management.ObjectName; + +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.config.api.ConflictingVersionException; +import org.opendaylight.controller.config.api.ValidationException; +import org.opendaylight.controller.config.api.jmx.CommitStatus; +import org.opendaylight.controller.config.manager.impl.AbstractConfigTest; +import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver; +import org.opendaylight.controller.config.util.ConfigTransactionJMXClient; +import org.opendaylight.controller.config.yang.threadpool.impl.NamingThreadFactoryModuleFactory; +import org.opendaylight.controller.config.yang.threadpool.impl.NamingThreadFactoryModuleMXBean; +import org.opendaylight.controller.config.yang.threadpool.impl.ScheduledThreadPoolModuleFactory; +import org.opendaylight.controller.config.yang.threadpool.impl.ScheduledThreadPoolModuleMXBean; + +public class ScheduledThreadPoolConfigBeanTest extends AbstractConfigTest { + + private ScheduledThreadPoolModuleFactory factory; + private final String instanceName = "scheduled1"; + + @Before + public void setUp() { + + factory = new ScheduledThreadPoolModuleFactory(); + super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(factory, + new NamingThreadFactoryModuleFactory())); + } + + @Test + public void testCreateBean() throws InstanceAlreadyExistsException, ValidationException, + ConflictingVersionException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + + createScheduled(transaction, instanceName, 1); + transaction.validateConfig(); + CommitStatus status = transaction.commit(); + + assertBeanCount(1, factory.getImplementationName()); + assertStatus(status, 2, 0, 0); + } + + @Test + public void testReusingOldInstance() throws InstanceAlreadyExistsException, ConflictingVersionException, + ValidationException { + + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + createScheduled(transaction, instanceName, 1); + + transaction.commit(); + + assertBeanCount(1, factory.getImplementationName()); + + transaction = configRegistryClient.createTransaction(); + CommitStatus status = transaction.commit(); + + assertBeanCount(1, factory.getImplementationName()); + assertStatus(status, 0, 0, 2); + } + + @Test + public void testReconfigurationInstance() throws InstanceAlreadyExistsException, ValidationException, + ConflictingVersionException, InstanceNotFoundException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + createScheduled(transaction, instanceName, 1); + + transaction.commit(); + + transaction = configRegistryClient.createTransaction(); + ObjectName databaseNew = transaction.lookupConfigBean(factory.getImplementationName(), instanceName); + ScheduledThreadPoolModuleMXBean proxy = transaction.newMXBeanProxy(databaseNew, + ScheduledThreadPoolModuleMXBean.class); + proxy.setMaxThreadCount(99); + + CommitStatus status = transaction.commit(); + + assertBeanCount(1, factory.getImplementationName()); + assertStatus(status, 0, 1, 1); + } + + @Test + public void testDestroy() throws InstanceAlreadyExistsException, ValidationException, ConflictingVersionException, + InstanceNotFoundException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + createScheduled(transaction, instanceName, 1); + + transaction.commit(); + + transaction = configRegistryClient.createTransaction(); + transaction.destroyConfigBean(factory.getImplementationName(), instanceName); + CommitStatus status = transaction.commit(); + + assertBeanCount(0, factory.getImplementationName()); + assertStatus(status, 0, 0, 1); + } + + @Test + public void testInstanceAlreadyExistsException() throws ConflictingVersionException, ValidationException, + InstanceAlreadyExistsException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + createScheduled(transaction, instanceName, 1); + transaction.commit(); + transaction = configRegistryClient.createTransaction(); + try { + createScheduled(transaction, instanceName, 2); + fail(); + } catch (InstanceAlreadyExistsException e) { + assertThat( + e.getMessage(), + containsString("There is an instance registered with name ModuleIdentifier{factoryName='threadpool-scheduled', instanceName='scheduled1'}")); + } + } + + @Test + public void testValidationException() throws InstanceAlreadyExistsException { + ConfigTransactionJMXClient transaction = configRegistryClient.createTransaction(); + createScheduled(transaction, instanceName, 0); + + try { + transaction.validateConfig(); + fail(); + } catch (ValidationException e) { + assertTrue(e.getFailedValidations().containsKey(factory.getImplementationName())); + assertEquals(1, e.getFailedValidations().get(factory.getImplementationName()).keySet().size()); + } + } + + private ObjectName createScheduled(ConfigTransactionJMXClient transaction, String instanceName, int maxThreadCount) + throws InstanceAlreadyExistsException { + ObjectName nameCreated = transaction.createModule(factory.getImplementationName(), instanceName); + ScheduledThreadPoolModuleMXBean mxBean = transaction.newMBeanProxy(nameCreated, + ScheduledThreadPoolModuleMXBean.class); + mxBean.setMaxThreadCount(maxThreadCount); + + ObjectName threadFactoryON = transaction.createModule(NamingThreadFactoryModuleFactory.NAME, "naming"); + NamingThreadFactoryModuleMXBean namingThreadFactoryModuleMXBean = transaction.newMXBeanProxy(threadFactoryON, + NamingThreadFactoryModuleMXBean.class); + namingThreadFactoryModuleMXBean.setNamePrefix("prefix"); + + mxBean.setThreadFactory(threadFactoryON); + + return nameCreated; + } + +} diff --git a/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/scheduled/TestingScheduledThreadPoolModule.java b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/scheduled/TestingScheduledThreadPoolModule.java new file mode 100644 index 0000000000..27e60eef5c --- /dev/null +++ b/opendaylight/config/threadpool-config-impl/src/test/java/org/opendaylight/controller/config/threadpool/scheduled/TestingScheduledThreadPoolModule.java @@ -0,0 +1,77 @@ +package org.opendaylight.controller.config.threadpool.scheduled; + +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyBoolean; +import static org.mockito.Matchers.anyLong; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; + +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ScheduledFuture; +import java.util.concurrent.TimeUnit; + +import javax.management.ObjectName; + +import org.opendaylight.controller.config.api.DynamicMBeanWithInstance; +import org.opendaylight.controller.config.api.ModuleIdentifier; +import org.opendaylight.controller.config.manager.impl.AbstractMockedModule; +import org.opendaylight.controller.config.spi.Module; +import org.opendaylight.controller.config.threadpool.util.ScheduledThreadPoolWrapper; +import org.opendaylight.controller.config.yang.threadpool.ScheduledThreadPoolServiceInterface; +import org.opendaylight.controller.config.yang.threadpool.impl.ScheduledThreadPoolModuleMXBean; + +import com.google.common.util.concurrent.ListenableFutureTask; + +public class TestingScheduledThreadPoolModule extends AbstractMockedModule implements + ScheduledThreadPoolServiceInterface, Module, ScheduledThreadPoolModuleMXBean { + + public TestingScheduledThreadPoolModule(DynamicMBeanWithInstance old, ModuleIdentifier id) { + super(old, id); + } + + @Override + protected AutoCloseable prepareMockedInstance() throws Exception { + ScheduledThreadPoolWrapper instance = mock(ScheduledThreadPoolWrapper.class); + ScheduledExecutorService ses = mock(ScheduledExecutorService.class); + {// mockFuture + ScheduledFuture future = mock(ScheduledFuture.class); + doReturn(false).when(future).cancel(anyBoolean()); + try { + doReturn(mock(Object.class)).when(future).get(); + } catch (Exception e) { + throw new RuntimeException(e); + } + doReturn(future).when(ses).schedule(any(Runnable.class), any(Long.class), any(TimeUnit.class)); + doReturn(future).when(ses).scheduleWithFixedDelay(any(Runnable.class), anyLong(), anyLong(), + any(TimeUnit.class)); + + } + doNothing().when(ses).execute(any(Runnable.class)); + doNothing().when(ses).execute(any(ListenableFutureTask.class)); + doReturn(ses).when(instance).getExecutor(); + doNothing().when(instance).close(); + + doReturn(1).when(instance).getMaxThreadCount(); + return instance; + } + + @Override + public ObjectName getThreadFactory() { + return any(ObjectName.class); + } + + @Override + public void setThreadFactory(ObjectName threadFactory) { + } + + @Override + public Integer getMaxThreadCount() { + return 1; + } + + @Override + public void setMaxThreadCount(Integer maxThreadCount) { + } + +} -- 2.36.6