From ef9735d778a9e687f272b8db324c7760ccf655a6 Mon Sep 17 00:00:00 2001 From: Dan Berindei Date: Wed, 6 Jun 2018 15:16:28 +0300 Subject: [PATCH] ISPN-9067 Fix test node names * Only set the node name once * Fail the test if a node doesn't have a proper name set * Don't start the cache manager in the configuration parsing tests --- .../StringPropertyReplacementTest.java | 48 ++-- .../configuration/XmlFileParsingTest.java | 114 ++++----- .../health/ClusterHealthImplTest.java | 20 +- .../statetransfer/ConcurrentStartTest.java | 5 +- .../test/AbstractInfinispanTest.java | 10 +- .../test/MultipleCacheManagersTest.java | 9 + .../test/fwk/TestCacheManagerFactory.java | 86 ++++--- .../test/fwk/TestResourceTracker.java | 36 +-- .../infinispan/util/PersistenceMockUtil.java | 21 +- .../resources/configs/named-cache-test.xml | 8 +- .../configs/string-property-replaced.xml | 8 +- .../tools/ConfigurationConverterTest.java | 233 +++++++++--------- 12 files changed, 306 insertions(+), 292 deletions(-) diff --git a/core/src/test/java/org/infinispan/configuration/StringPropertyReplacementTest.java b/core/src/test/java/org/infinispan/configuration/StringPropertyReplacementTest.java index 5c578f6ce4b2..6624c395c630 100644 --- a/core/src/test/java/org/infinispan/configuration/StringPropertyReplacementTest.java +++ b/core/src/test/java/org/infinispan/configuration/StringPropertyReplacementTest.java @@ -5,9 +5,11 @@ import java.util.Properties; import org.infinispan.commons.executors.BlockingThreadPoolExecutorFactory; -import org.infinispan.manager.EmbeddedCacheManager; -import org.infinispan.test.SingleCacheManagerTest; -import org.infinispan.test.fwk.TestCacheManagerFactory; +import org.infinispan.configuration.cache.Configuration; +import org.infinispan.configuration.global.GlobalConfiguration; +import org.infinispan.configuration.parsing.ConfigurationBuilderHolder; +import org.infinispan.configuration.parsing.ParserRegistry; +import org.infinispan.test.AbstractInfinispanTest; import org.infinispan.util.concurrent.IsolationLevel; import org.testng.annotations.Test; @@ -19,35 +21,33 @@ * @author Mircea.Markus@jboss.com */ @Test (groups = "functional", testName = "config.StringPropertyReplacementTest") -public class StringPropertyReplacementTest extends SingleCacheManagerTest { - - - @Override - protected EmbeddedCacheManager createCacheManager() throws Exception { - System.setProperty("test.property.asyncListenerMaxThreads","2"); - System.setProperty("test.property.persistenceMaxThreads","4"); - System.setProperty("test.property.IsolationLevel","READ_COMMITTED"); - System.setProperty("test.property.writeSkewCheck","true"); - System.setProperty("test.property.SyncCommitPhase","true"); - return TestCacheManagerFactory.fromXml("configs/string-property-replaced.xml"); +public class StringPropertyReplacementTest extends AbstractInfinispanTest { + + protected ConfigurationBuilderHolder parse() throws Exception { + System.setProperty("StringPropertyReplacementTest.asyncListenerMaxThreads","2"); + System.setProperty("StringPropertyReplacementTest.persistenceMaxThreads","4"); + System.setProperty("StringPropertyReplacementTest.IsolationLevel","READ_COMMITTED"); + System.setProperty("StringPropertyReplacementTest.writeSkewCheck","true"); + System.setProperty("StringPropertyReplacementTest.SyncCommitPhase","true"); + ParserRegistry parserRegistry = new ParserRegistry(Thread.currentThread().getContextClassLoader(), true); + return parserRegistry.parseFile("configs/string-property-replaced.xml"); } - public void testGlobalConfig() { + public void testGlobalConfig() throws Exception { + ConfigurationBuilderHolder holder = parse(); + GlobalConfiguration gc = holder.getGlobalConfigurationBuilder().build(); BlockingThreadPoolExecutorFactory listenerThreadPool = - cacheManager.getCacheManagerConfiguration().listenerThreadPool().threadPoolFactory(); + gc.listenerThreadPool().threadPoolFactory(); assertEquals(2, listenerThreadPool.maxThreads()); BlockingThreadPoolExecutorFactory persistenceThreadPool = - cacheManager.getCacheManagerConfiguration().persistenceThreadPool().threadPoolFactory(); + gc.persistenceThreadPool().threadPoolFactory(); assertEquals(4, persistenceThreadPool.maxThreads()); - Properties transportProps = cacheManager.getCacheManagerConfiguration().transport().properties(); - // Should be "jgroups-tcp.xml", but gets overriden by test cache manager factory - assert transportProps.get("configurationFile") == null; - } + Properties transportProps = gc.transport().properties(); + assertEquals("jgroups-tcp.xml", transportProps.get("configurationFile")); - public void testDefaultCache() { - org.infinispan.configuration.cache.Configuration configuration = cacheManager.getCache().getCacheConfiguration(); - assert configuration.locking().isolationLevel().equals(IsolationLevel.READ_COMMITTED); + Configuration configuration = holder.getDefaultConfigurationBuilder().build(); + assertEquals(IsolationLevel.READ_COMMITTED, configuration.locking().isolationLevel()); } } diff --git a/core/src/test/java/org/infinispan/configuration/XmlFileParsingTest.java b/core/src/test/java/org/infinispan/configuration/XmlFileParsingTest.java index 038e6b116291..0e91754144f4 100644 --- a/core/src/test/java/org/infinispan/configuration/XmlFileParsingTest.java +++ b/core/src/test/java/org/infinispan/configuration/XmlFileParsingTest.java @@ -31,12 +31,13 @@ import org.infinispan.configuration.cache.StoreConfiguration; import org.infinispan.configuration.global.GlobalConfiguration; import org.infinispan.configuration.global.ShutdownHookBehavior; +import org.infinispan.configuration.parsing.ConfigurationBuilderHolder; +import org.infinispan.configuration.parsing.ParserRegistry; import org.infinispan.eviction.EvictionStrategy; import org.infinispan.eviction.EvictionType; import org.infinispan.factories.threads.DefaultThreadFactory; import org.infinispan.interceptors.FooInterceptor; import org.infinispan.commons.jmx.PerThreadMBeanServerLookup; -import org.infinispan.manager.EmbeddedCacheManager; import org.infinispan.marshall.AdvancedExternalizerTest; import org.infinispan.marshall.TestObjectStreamMarshaller; import org.infinispan.marshall.core.MarshalledEntry; @@ -65,12 +66,9 @@ public void testFailOnUnexpectedConfigurationFile() throws IOException { } public void testNamedCacheFile() throws IOException { - withCacheManager(new CacheManagerCallable(TestCacheManagerFactory.fromXml("configs/named-cache-test.xml", true)) { - @Override - public void call() { - assertNamedCacheFile(cm, false); - } - }); + ParserRegistry parserRegistry = new ParserRegistry(Thread.currentThread().getContextClassLoader(), true); + ConfigurationBuilderHolder holder = parserRegistry.parseFile("configs/named-cache-test.xml"); + assertNamedCacheFile(holder, false); } public void testNoNamedCaches() throws Exception { @@ -461,57 +459,61 @@ public void call() { } - private void assertNamedCacheFile(EmbeddedCacheManager cm, boolean deprecated) { - final GlobalConfiguration gc = cm.getCacheManagerConfiguration(); + private void assertNamedCacheFile(ConfigurationBuilderHolder holder, boolean deprecated) { + GlobalConfiguration gc = holder.getGlobalConfigurationBuilder().build(); BlockingThreadPoolExecutorFactory listenerThreadPool = - cm.getCacheManagerConfiguration().listenerThreadPool().threadPoolFactory(); + gc.listenerThreadPool().threadPoolFactory(); assertEquals(5, listenerThreadPool.maxThreads()); assertEquals(10000, listenerThreadPool.queueLength()); DefaultThreadFactory listenerThreadFactory = - cm.getCacheManagerConfiguration().listenerThreadPool().threadFactory(); + gc.listenerThreadPool().threadFactory(); assertEquals("AsyncListenerThread", listenerThreadFactory.threadNamePattern()); BlockingThreadPoolExecutorFactory persistenceThreadPool = - cm.getCacheManagerConfiguration().persistenceThreadPool().threadPoolFactory(); + gc.persistenceThreadPool().threadPoolFactory(); assertEquals(6, persistenceThreadPool.maxThreads()); assertEquals(10001, persistenceThreadPool.queueLength()); DefaultThreadFactory persistenceThreadFactory = - cm.getCacheManagerConfiguration().persistenceThreadPool().threadFactory(); + gc.persistenceThreadPool().threadFactory(); assertEquals("PersistenceThread", persistenceThreadFactory.threadNamePattern()); BlockingThreadPoolExecutorFactory asyncThreadPool = - cm.getCacheManagerConfiguration().asyncThreadPool().threadPoolFactory(); - assertEquals(TestCacheManagerFactory.ASYNC_EXEC_MAX_THREADS, asyncThreadPool.maxThreads()); - assertEquals(TestCacheManagerFactory.ASYNC_EXEC_QUEUE_SIZE, asyncThreadPool.queueLength()); - assertEquals(TestCacheManagerFactory.KEEP_ALIVE, asyncThreadPool.keepAlive()); + gc.asyncThreadPool().threadPoolFactory(); + assertEquals(5, asyncThreadPool.coreThreads()); + assertEquals(5, asyncThreadPool.maxThreads()); + assertEquals(10000, asyncThreadPool.queueLength()); + assertEquals(0, asyncThreadPool.keepAlive()); + DefaultThreadFactory asyncThreadFactory = gc.asyncThreadPool().threadFactory(); + assertEquals("AsyncOperationsThread", asyncThreadFactory.threadNamePattern()); BlockingThreadPoolExecutorFactory transportThreadPool = - cm.getCacheManagerConfiguration().transport().transportThreadPool().threadPoolFactory(); - assertEquals(TestCacheManagerFactory.TRANSPORT_EXEC_MAX_THREADS, transportThreadPool.maxThreads()); - assertEquals(TestCacheManagerFactory.TRANSPORT_EXEC_QUEUE_SIZE, transportThreadPool.queueLength()); - assertEquals(TestCacheManagerFactory.KEEP_ALIVE, transportThreadPool.keepAlive()); + gc.transport().transportThreadPool().threadPoolFactory(); + assertEquals(25, transportThreadPool.maxThreads()); + assertEquals(10000, transportThreadPool.queueLength()); + assertEquals(0, transportThreadPool.keepAlive()); BlockingThreadPoolExecutorFactory remoteCommandThreadPool = - cm.getCacheManagerConfiguration().transport().remoteCommandThreadPool().threadPoolFactory(); - assertEquals(TestCacheManagerFactory.REMOTE_EXEC_MAX_THREADS, remoteCommandThreadPool.maxThreads()); - assertEquals(TestCacheManagerFactory.REMOTE_EXEC_QUEUE_SIZE, remoteCommandThreadPool.queueLength()); - assertEquals(TestCacheManagerFactory.KEEP_ALIVE, remoteCommandThreadPool.keepAlive()); + gc.transport().remoteCommandThreadPool().threadPoolFactory(); + assertEquals(30, remoteCommandThreadPool.maxThreads()); + assertEquals(2, remoteCommandThreadPool.coreThreads()); + assertEquals(10000, remoteCommandThreadPool.queueLength()); + assertEquals(10000, remoteCommandThreadPool.keepAlive()); BlockingThreadPoolExecutorFactory stateTransferThreadPool = - cm.getCacheManagerConfiguration().stateTransferThreadPool().threadPoolFactory(); - assertEquals(TestCacheManagerFactory.STATE_TRANSFER_EXEC_MAX_THREADS, stateTransferThreadPool.maxThreads()); - assertEquals(TestCacheManagerFactory.STATE_TRANSFER_EXEC_QUEUE_SIZE, stateTransferThreadPool.queueLength()); - assertEquals(TestCacheManagerFactory.KEEP_ALIVE, stateTransferThreadPool.keepAlive()); + gc.stateTransferThreadPool().threadPoolFactory(); + assertEquals(20, stateTransferThreadPool.maxThreads()); + assertEquals(2, remoteCommandThreadPool.coreThreads()); + assertEquals(5, stateTransferThreadPool.queueLength()); + assertEquals(60000, stateTransferThreadPool.keepAlive()); DefaultThreadFactory evictionThreadFactory = - cm.getCacheManagerConfiguration().expirationThreadPool().threadFactory(); + gc.expirationThreadPool().threadFactory(); assertEquals("ExpirationThread", evictionThreadFactory.threadNamePattern()); assertTrue(gc.transport().transport() instanceof JGroupsTransport); assertEquals("infinispan-cluster", gc.transport().clusterName()); - // Should be "Jalapeno" but it's overriden by the test cache manager factory - assertTrue(gc.transport().nodeName().contains("Node")); + assertEquals("Jalapeno", gc.transport().nodeName()); assertEquals(50000, gc.transport().distributedSyncTimeout()); assertEquals(ShutdownHookBehavior.REGISTER, gc.shutdown().hookBehavior()); @@ -524,7 +526,7 @@ private void assertNamedCacheFile(EmbeddedCacheManager cm, boolean deprecated) { assertTrue(externalizers.get(5678) instanceof AdvancedExternalizerTest.IdViaAnnotationObj.Externalizer); assertTrue(externalizers.get(3456) instanceof AdvancedExternalizerTest.IdViaBothObj.Externalizer); - Configuration defaultCfg = cm.getDefaultCacheConfiguration(); + Configuration defaultCfg = holder.getDefaultConfigurationBuilder().build(); assertEquals(1000, defaultCfg.locking().lockAcquisitionTimeout()); assertEquals(100, defaultCfg.locking().concurrencyLevel()); @@ -534,50 +536,50 @@ private void assertNamedCacheFile(EmbeddedCacheManager cm, boolean deprecated) { } - Configuration c = cm.getCacheConfiguration("transactional"); + Configuration c = holder.getNamedConfigurationBuilders().get("transactional").build(); assertTrue(!c.clustering().cacheMode().isClustered()); assertTrue(c.transaction().transactionManagerLookup() instanceof GenericTransactionManagerLookup); if (!deprecated) { assertReaperAndTimeoutInfo(defaultCfg); } - c = cm.getCacheConfiguration("transactional2"); + c = holder.getNamedConfigurationBuilders().get("transactional2").build(); assertTrue(c.transaction().transactionManagerLookup() instanceof TestLookup); assertEquals(10000, c.transaction().cacheStopTimeout()); assertEquals(LockingMode.PESSIMISTIC, c.transaction().lockingMode()); assertTrue(!c.transaction().autoCommit()); - c = cm.getCacheConfiguration("transactional3"); + c = holder.getNamedConfigurationBuilders().get("transactional3").build(); if (!deprecated) { assertEquals(TransactionProtocol.TOTAL_ORDER, c.transaction().transactionProtocol()); } - c = cm.getCacheConfiguration("syncInval"); + c = holder.getNamedConfigurationBuilders().get("syncInval").build(); assertEquals(CacheMode.INVALIDATION_SYNC, c.clustering().cacheMode()); assertTrue(c.clustering().stateTransfer().awaitInitialTransfer()); assertEquals(15000, c.clustering().remoteTimeout()); - c = cm.getCacheConfiguration("asyncInval"); + c = holder.getNamedConfigurationBuilders().get("asyncInval").build(); assertEquals(CacheMode.INVALIDATION_ASYNC, c.clustering().cacheMode()); assertEquals(15000, c.clustering().remoteTimeout()); - c = cm.getCacheConfiguration("syncRepl"); + c = holder.getNamedConfigurationBuilders().get("syncRepl").build(); assertEquals(CacheMode.REPL_SYNC, c.clustering().cacheMode()); assertTrue(!c.clustering().stateTransfer().fetchInMemoryState()); assertTrue(c.clustering().stateTransfer().awaitInitialTransfer()); assertEquals(15000, c.clustering().remoteTimeout()); - c = cm.getCacheConfiguration("asyncRepl"); + c = holder.getNamedConfigurationBuilders().get("asyncRepl").build(); assertEquals(CacheMode.REPL_ASYNC, c.clustering().cacheMode()); assertTrue(!c.clustering().stateTransfer().fetchInMemoryState()); assertTrue(c.clustering().stateTransfer().awaitInitialTransfer()); - c = cm.getCacheConfiguration("txSyncRepl"); + c = holder.getNamedConfigurationBuilders().get("txSyncRepl").build(); assertTrue(c.transaction().transactionManagerLookup() instanceof GenericTransactionManagerLookup); assertEquals(CacheMode.REPL_SYNC, c.clustering().cacheMode()); @@ -585,7 +587,7 @@ private void assertNamedCacheFile(EmbeddedCacheManager cm, boolean deprecated) { assertTrue(c.clustering().stateTransfer().awaitInitialTransfer()); assertEquals(15000, c.clustering().remoteTimeout()); - c = cm.getCacheConfiguration("overriding"); + c = holder.getNamedConfigurationBuilders().get("overriding").build(); assertEquals(CacheMode.LOCAL, c.clustering().cacheMode()); assertEquals(20000, c.locking().lockAcquisitionTimeout()); @@ -593,10 +595,10 @@ private void assertNamedCacheFile(EmbeddedCacheManager cm, boolean deprecated) { assertEquals(IsolationLevel.REPEATABLE_READ, c.locking().isolationLevel()); assertEquals(StorageType.OBJECT, c.memory().storageType()); - c = cm.getCacheConfiguration("storeAsBinary"); + c = holder.getNamedConfigurationBuilders().get("storeAsBinary").build(); assertEquals(StorageType.BINARY, c.memory().storageType()); - c = cm.getCacheConfiguration("withFileStore"); + c = holder.getNamedConfigurationBuilders().get("withFileStore").build(); assertTrue(c.persistence().preload()); assertTrue(!c.persistence().passivation()); assertEquals(1, c.persistence().stores().size()); @@ -611,23 +613,23 @@ private void assertNamedCacheFile(EmbeddedCacheManager cm, boolean deprecated) { assertTrue(loaderCfg.async().enabled()); assertEquals(700, loaderCfg.async().modificationQueueSize()); - c = cm.getCacheConfiguration("withClusterLoader"); + c = holder.getNamedConfigurationBuilders().get("withClusterLoader").build(); assertEquals(1, c.persistence().stores().size()); ClusterLoaderConfiguration clusterLoaderCfg = (ClusterLoaderConfiguration) c.persistence().stores().get(0); assertEquals(15000, clusterLoaderCfg.remoteCallTimeout()); - c = cm.getCacheConfiguration("withLoaderDefaults"); + c = holder.getNamedConfigurationBuilders().get("withLoaderDefaults").build(); loaderCfg = (SingleFileStoreConfiguration) c.persistence().stores().get(0); assertEquals("/tmp/Another-FileCacheStore-Location", loaderCfg.location()); - c = cm.getCacheConfiguration("withouthJmxEnabled"); + c = holder.getNamedConfigurationBuilders().get("withouthJmxEnabled").build(); assertTrue(!c.jmxStatistics().enabled()); assertTrue(gc.globalJmxStatistics().enabled()); assertTrue(gc.globalJmxStatistics().allowDuplicateDomains()); assertEquals("funky_domain", gc.globalJmxStatistics().domain()); assertTrue(gc.globalJmxStatistics().mbeanServerLookup() instanceof PerThreadMBeanServerLookup); - c = cm.getCacheConfiguration("dist"); + c = holder.getNamedConfigurationBuilders().get("dist").build(); assertEquals(CacheMode.DIST_SYNC, c.clustering().cacheMode()); assertEquals(600000, c.clustering().l1().lifespan()); if (deprecated) assertEquals(120000, c.clustering().hash().rehashRpcTimeout()); @@ -637,7 +639,7 @@ private void assertNamedCacheFile(EmbeddedCacheManager cm, boolean deprecated) { assertEquals(3, c.clustering().hash().numOwners()); assertTrue(c.clustering().l1().enabled()); - c = cm.getCacheConfiguration("dist_with_capacity_factors"); + c = holder.getNamedConfigurationBuilders().get("dist_with_capacity_factors").build(); assertEquals(CacheMode.DIST_SYNC, c.clustering().cacheMode()); assertEquals(600000, c.clustering().l1().lifespan()); if (deprecated) assertEquals(120000, c.clustering().hash().rehashRpcTimeout()); @@ -648,17 +650,17 @@ private void assertNamedCacheFile(EmbeddedCacheManager cm, boolean deprecated) { assertEquals(0.0f, c.clustering().hash().capacityFactor()); if (!deprecated) assertEquals(1000, c.clustering().hash().numSegments()); - c = cm.getCacheConfiguration("groups"); + c = holder.getNamedConfigurationBuilders().get("groups").build(); assertTrue(c.clustering().hash().groups().enabled()); assertEquals(1, c.clustering().hash().groups().groupers().size()); assertEquals(String.class, c.clustering().hash().groups().groupers().get(0).getKeyType()); - c = cm.getCacheConfiguration("chunkSize"); + c = holder.getNamedConfigurationBuilders().get("chunkSize").build(); assertTrue(c.clustering().stateTransfer().fetchInMemoryState()); assertEquals(120000, c.clustering().stateTransfer().timeout()); assertEquals(1000, c.clustering().stateTransfer().chunkSize()); - c = cm.getCacheConfiguration("cacheWithCustomInterceptors"); + c = holder.getNamedConfigurationBuilders().get("cacheWithCustomInterceptors").build(); assertTrue(!c.customInterceptors().interceptors().isEmpty()); assertEquals(6, c.customInterceptors().interceptors().size()); for(InterceptorConfiguration i : c.customInterceptors().interceptors()) { @@ -667,7 +669,7 @@ private void assertNamedCacheFile(EmbeddedCacheManager cm, boolean deprecated) { } } - c = cm.getCacheConfiguration("evictionCache"); + c = holder.getNamedConfigurationBuilders().get("evictionCache").build(); assertEquals(5000, c.memory().size()); assertEquals(EvictionStrategy.REMOVE, c.memory().evictionStrategy()); assertEquals(EvictionType.COUNT, c.memory().evictionType()); @@ -676,18 +678,18 @@ private void assertNamedCacheFile(EmbeddedCacheManager cm, boolean deprecated) { assertEquals(1000, c.expiration().maxIdle()); assertEquals(500, c.expiration().wakeUpInterval()); - c = cm.getCacheConfiguration("evictionMemoryExceptionCache"); + c = holder.getNamedConfigurationBuilders().get("evictionMemoryExceptionCache").build(); assertEquals(5000, c.memory().size()); assertEquals(EvictionStrategy.EXCEPTION, c.memory().evictionStrategy()); assertEquals(EvictionType.MEMORY, c.memory().evictionType()); assertEquals(StorageType.BINARY, c.memory().storageType()); - c = cm.getCacheConfiguration("withDeadlockDetection"); + c = holder.getNamedConfigurationBuilders().get("withDeadlockDetection").build(); assertFalse(c.deadlockDetection().enabled()); assertEquals(-1, c.deadlockDetection().spinDuration()); assertEquals(CacheMode.DIST_SYNC, c.clustering().cacheMode()); - c = cm.getCacheConfiguration("storeKeyValueBinary"); + c = holder.getNamedConfigurationBuilders().get("storeKeyValueBinary").build(); assertEquals(StorageType.BINARY, c.memory().storageType()); } diff --git a/core/src/test/java/org/infinispan/health/ClusterHealthImplTest.java b/core/src/test/java/org/infinispan/health/ClusterHealthImplTest.java index 9a3d69f9f23a..ad786d10d5fe 100644 --- a/core/src/test/java/org/infinispan/health/ClusterHealthImplTest.java +++ b/core/src/test/java/org/infinispan/health/ClusterHealthImplTest.java @@ -14,12 +14,13 @@ import org.infinispan.Cache; import org.infinispan.configuration.cache.CacheMode; import org.infinispan.configuration.cache.ConfigurationBuilder; -import org.infinispan.configuration.global.GlobalConfigurationBuilder; import org.infinispan.distribution.DistributionManager; import org.infinispan.health.impl.ClusterHealthImpl; import org.infinispan.manager.DefaultCacheManager; import org.infinispan.manager.EmbeddedCacheManager; import org.infinispan.registry.InternalCacheRegistry; +import org.infinispan.test.AbstractInfinispanTest; +import org.infinispan.test.fwk.TestCacheManagerFactory; import org.testng.annotations.AfterClass; import org.testng.annotations.AfterMethod; import org.testng.annotations.BeforeClass; @@ -27,12 +28,10 @@ import org.testng.annotations.Test; @Test(testName = "health.ClusterHealthImplTest", groups = "functional") -public class ClusterHealthImplTest { +public class ClusterHealthImplTest extends AbstractInfinispanTest { private static final String INTERNAL_CACHE_NAME = "internal_cache"; private static final String CACHE_NAME = "test_cache"; - private static final String CLUSTER_NAME = "testCluster"; - private static final String NODE_NAME = "testNode"; private EmbeddedCacheManager cacheManager; private DefaultCacheManager mockedCacheManager; private ClusterHealth clusterHealth; @@ -40,10 +39,7 @@ public class ClusterHealthImplTest { @BeforeClass private void init() { - GlobalConfigurationBuilder globalConfigurationBuilder = new GlobalConfigurationBuilder().clusteredDefault(); - globalConfigurationBuilder.transport().clusterName(CLUSTER_NAME).nodeName(NODE_NAME); - - cacheManager = new DefaultCacheManager(globalConfigurationBuilder.build()); + cacheManager = TestCacheManagerFactory.createClusteredCacheManager(); internalCacheRegistry = cacheManager.getGlobalComponentRegistry().getComponent(InternalCacheRegistry.class); clusterHealth = new ClusterHealthImpl(cacheManager); } @@ -61,7 +57,7 @@ private void configureBeforeMethod() { cacheManager.defineConfiguration(CACHE_NAME, new ConfigurationBuilder().build()); } - @AfterMethod + @AfterMethod(alwaysRun = true) private void cleanAfterMethod() { cacheManager.administration().removeCache(CACHE_NAME); cacheManager.undefineConfiguration(CACHE_NAME); @@ -70,7 +66,7 @@ private void cleanAfterMethod() { internalCacheRegistry.unregisterInternalCache(INTERNAL_CACHE_NAME); } - @AfterClass + @AfterClass(alwaysRun = true) private void cleanUp() { if (cacheManager != null) { cacheManager.stop(); @@ -79,7 +75,7 @@ private void cleanUp() { } public void testGetClusterName() throws Exception { - assertEquals(CLUSTER_NAME, clusterHealth.getClusterName()); + assertEquals(cacheManager.getClusterName(), clusterHealth.getClusterName()); } public void testCallingGetHealthStatusDoesNotCreateAnyCache() throws Exception { @@ -150,7 +146,7 @@ public void testRebalancingStatusWhenInternalCacheIsRebalancing() throws Excepti } public void testGetNodeNames() throws Exception { - assertTrue(clusterHealth.getNodeNames().get(0).contains(NODE_NAME)); + assertEquals(cacheManager.getAddress().toString(), clusterHealth.getNodeNames().get(0)); } public void testGetNumberOfNodes() throws Exception { diff --git a/core/src/test/java/org/infinispan/statetransfer/ConcurrentStartTest.java b/core/src/test/java/org/infinispan/statetransfer/ConcurrentStartTest.java index 32f647a98154..97a3eaf9de18 100644 --- a/core/src/test/java/org/infinispan/statetransfer/ConcurrentStartTest.java +++ b/core/src/test/java/org/infinispan/statetransfer/ConcurrentStartTest.java @@ -18,7 +18,6 @@ import org.infinispan.configuration.cache.ConfigurationBuilder; import org.infinispan.configuration.global.GlobalConfigurationBuilder; import org.infinispan.lifecycle.ComponentStatus; -import org.infinispan.manager.DefaultCacheManager; import org.infinispan.manager.EmbeddedCacheManager; import org.infinispan.remoting.inboundhandler.DeliverOrder; import org.infinispan.remoting.inboundhandler.InboundInvocationHandler; @@ -117,8 +116,10 @@ private EmbeddedCacheManager createCacheManager(int index) { GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder(); gcb.transport().defaultTransport(); TestCacheManagerFactory.amendGlobalConfiguration(gcb, new TransportFlags().withPortRange(index)); - EmbeddedCacheManager cm = new DefaultCacheManager(gcb.build(), false); + ConfigurationBuilder defaultCacheConfig = new ConfigurationBuilder(); + EmbeddedCacheManager cm = TestCacheManagerFactory.newDefaultCacheManager(false, gcb, defaultCacheConfig, false); registerCacheManager(cm); + Configuration replCfg = new ConfigurationBuilder().clustering().cacheMode(CacheMode.REPL_SYNC).build(); cm.defineConfiguration(REPL_CACHE_NAME, replCfg); Configuration distCfg = new ConfigurationBuilder().clustering().cacheMode(CacheMode.DIST_SYNC).build(); diff --git a/core/src/test/java/org/infinispan/test/AbstractInfinispanTest.java b/core/src/test/java/org/infinispan/test/AbstractInfinispanTest.java index d6d1f13b8616..72adc47a0b04 100644 --- a/core/src/test/java/org/infinispan/test/AbstractInfinispanTest.java +++ b/core/src/test/java/org/infinispan/test/AbstractInfinispanTest.java @@ -137,15 +137,7 @@ protected final void testClassFinished(ITestContext context) { } public String getTestName() { - // will qualified test name and parameters, thread names can be quite long when debugging - boolean shortTestName = Boolean.getBoolean("test.infinispan.shortTestName"); - String className; - if (shortTestName) { - className = "Test"; - } else { - className = getClass().getName(); - } - + String className = getClass().getName(); String parameters = parameters(); return parameters == null ? className : className + parameters; } diff --git a/core/src/test/java/org/infinispan/test/MultipleCacheManagersTest.java b/core/src/test/java/org/infinispan/test/MultipleCacheManagersTest.java index ea898d6dc85c..79dbf419c6bf 100644 --- a/core/src/test/java/org/infinispan/test/MultipleCacheManagersTest.java +++ b/core/src/test/java/org/infinispan/test/MultipleCacheManagersTest.java @@ -1,6 +1,8 @@ package org.infinispan.test; import static java.util.Arrays.asList; +import static org.infinispan.test.fwk.TestResourceTracker.getCurrentTestShortName; +import static org.testng.AssertJUnit.assertTrue; import java.lang.annotation.Annotation; import java.lang.reflect.Constructor; @@ -135,6 +137,13 @@ protected void destroy() { TestingUtil.clearContent(cacheManagers); TestingUtil.killCacheManagers(cacheManagers); } + + for (EmbeddedCacheManager cm : cacheManagers) { + String nodeName = cm.getCacheManagerConfiguration().transport().nodeName(); + assertTrue("Invalid node name for test " + getCurrentTestShortName() + ": " + nodeName, + nodeName != null && nodeName.contains(getCurrentTestShortName())); + } + cacheManagers.clear(); listeners.clear(); } diff --git a/core/src/test/java/org/infinispan/test/fwk/TestCacheManagerFactory.java b/core/src/test/java/org/infinispan/test/fwk/TestCacheManagerFactory.java index 281cb058c0dc..4b1a5bef90b3 100644 --- a/core/src/test/java/org/infinispan/test/fwk/TestCacheManagerFactory.java +++ b/core/src/test/java/org/infinispan/test/fwk/TestCacheManagerFactory.java @@ -6,7 +6,6 @@ import java.io.IOException; import java.io.InputStream; import java.util.UUID; - import javax.xml.stream.FactoryConfigurationError; import javax.xml.stream.XMLStreamException; @@ -20,9 +19,11 @@ import org.infinispan.configuration.cache.Index; import org.infinispan.configuration.global.GlobalConfiguration; import org.infinispan.configuration.global.GlobalConfigurationBuilder; +import org.infinispan.configuration.global.ThreadPoolConfiguration; import org.infinispan.configuration.internal.PrivateGlobalConfigurationBuilder; import org.infinispan.configuration.parsing.ConfigurationBuilderHolder; import org.infinispan.configuration.parsing.ParserRegistry; +import org.infinispan.factories.threads.DefaultThreadFactory; import org.infinispan.commons.jmx.MBeanServerLookup; import org.infinispan.commons.jmx.PerThreadMBeanServerLookup; import org.infinispan.manager.DefaultCacheManager; @@ -40,18 +41,13 @@ * @author Galder Zamarreño */ public class TestCacheManagerFactory { + private static final int NAMED_EXECUTORS_THREADS_NO_QUEUE = 6; + private static final int NAMED_EXECUTORS_THREADS_WITH_QUEUE = 4; + private static final int NAMED_EXECUTORS_QUEUE_SIZE = 10; + private static final int NAMED_EXECUTORS_KEEP_ALIVE = 30000; - public static final int ASYNC_EXEC_MAX_THREADS = 4; - public static final int ASYNC_EXEC_QUEUE_SIZE = 10000; - public static final int REMOTE_EXEC_MAX_THREADS = 6; - public static final int REMOTE_EXEC_QUEUE_SIZE = 0; - public static final int STATE_TRANSFER_EXEC_MAX_THREADS = 4; - public static final int STATE_TRANSFER_EXEC_QUEUE_SIZE = 0; - public static final int TRANSPORT_EXEC_MAX_THREADS = 6; - public static final int TRANSPORT_EXEC_QUEUE_SIZE = 10000; - public static final int KEEP_ALIVE = 30000; - - public static final String MARSHALLER = LegacyKeySupportSystemProperties.getProperty("infinispan.test.marshaller.class", "infinispan.marshaller.class"); + private static final String MARSHALLER = LegacyKeySupportSystemProperties.getProperty( + "infinispan.test.marshaller.class", "infinispan.marshaller.class"); private static final Log log = LogFactory.getLog(TestCacheManagerFactory.class); /** @@ -117,9 +113,26 @@ public static EmbeddedCacheManager fromStream(InputStream is, boolean keepJmxDom public static EmbeddedCacheManager fromStream(InputStream is, boolean keepJmxDomainName, boolean defaultParsersOnly, boolean start) throws IOException { ParserRegistry parserRegistry = new ParserRegistry(Thread.currentThread().getContextClassLoader(), defaultParsersOnly); ConfigurationBuilderHolder holder = parserRegistry.parse(is); + + // The node name is set in each DefaultThreadFactory individually, override it here + String testShortName = TestResourceTracker.getCurrentTestShortName(); + GlobalConfiguration gc = holder.getGlobalConfigurationBuilder().build(); + updateNodeName(testShortName, gc.listenerThreadPool()); + updateNodeName(testShortName, gc.expirationThreadPool()); + updateNodeName(testShortName, gc.persistenceThreadPool()); + updateNodeName(testShortName, gc.stateTransferThreadPool()); + updateNodeName(testShortName, gc.asyncThreadPool()); + updateNodeName(testShortName, gc.transport().transportThreadPool()); + return createClusteredCacheManager(start, holder, keepJmxDomainName); } + private static void updateNodeName(String nodeName, ThreadPoolConfiguration threadPoolConfiguration) { + if (threadPoolConfiguration.threadFactory() instanceof DefaultThreadFactory) { + ((DefaultThreadFactory) threadPoolConfiguration.threadFactory()).setNode(nodeName); + } + } + public static EmbeddedCacheManager fromString(String config) throws IOException { return fromStream(new ByteArrayInputStream(config.getBytes())); } @@ -247,6 +260,7 @@ public static EmbeddedCacheManager createCacheManager(GlobalConfigurationBuilder if (globalBuilder.transport().build().transport().transport() != null) { throw new IllegalArgumentException("Use TestCacheManagerFactory.createClusteredCacheManager(...) for clustered cache managers"); } + amendTransport(globalBuilder); return newDefaultCacheManager(true, globalBuilder, builder, false); } @@ -360,40 +374,39 @@ public static void amendTransport(GlobalConfigurationBuilder cfg) { } private static void amendTransport(GlobalConfigurationBuilder builder, TransportFlags flags) { - org.infinispan.configuration.global.GlobalConfiguration gc = builder.build(); - if (gc.transport().transport() != null) { //this is local - String testName = TestResourceTracker.getCurrentTestName(); - String nextNodeName = TestResourceTracker.getNextNodeName(); + String testName = TestResourceTracker.getCurrentTestName(); + GlobalConfiguration gc = builder.build(); + if (gc.transport().transport() != null) { // Remove any configuration file that might have been set. builder.transport().removeProperty(JGroupsTransport.CONFIGURATION_FILE); - builder - .transport() - .addProperty(JGroupsTransport.CONFIGURATION_STRING, getJGroupsConfig(testName, flags)) - .nodeName(nextNodeName); + builder.transport().addProperty(JGroupsTransport.CONFIGURATION_STRING, getJGroupsConfig(testName, flags)); } } - public static void minimizeThreads(GlobalConfigurationBuilder builder) { - BlockingThreadPoolExecutorFactory executorFactory; - - executorFactory = new BlockingThreadPoolExecutorFactory(ASYNC_EXEC_MAX_THREADS, - ASYNC_EXEC_MAX_THREADS, ASYNC_EXEC_QUEUE_SIZE, KEEP_ALIVE); - builder.asyncThreadPool().threadPoolFactory(executorFactory); + public static void setNodeName(GlobalConfigurationBuilder builder) { + String nextNodeName = TestResourceTracker.getNextNodeName(); - executorFactory = new BlockingThreadPoolExecutorFactory(STATE_TRANSFER_EXEC_MAX_THREADS, - STATE_TRANSFER_EXEC_MAX_THREADS, STATE_TRANSFER_EXEC_QUEUE_SIZE, KEEP_ALIVE); - builder.stateTransferThreadPool().threadPoolFactory(executorFactory); + // Set the node name even for local managers in order to set the name of the worker threads + builder.transport().nodeName(nextNodeName); + } - executorFactory = new BlockingThreadPoolExecutorFactory(REMOTE_EXEC_MAX_THREADS, - REMOTE_EXEC_MAX_THREADS, REMOTE_EXEC_QUEUE_SIZE, KEEP_ALIVE); - builder.transport().remoteCommandThreadPool().threadPoolFactory(executorFactory); + public static void minimizeThreads(GlobalConfigurationBuilder builder) { + BlockingThreadPoolExecutorFactory executorFactoryNoQueue = + new BlockingThreadPoolExecutorFactory(NAMED_EXECUTORS_THREADS_NO_QUEUE, 0, 0, NAMED_EXECUTORS_KEEP_ALIVE); + BlockingThreadPoolExecutorFactory executorFactoryWithQueue = + new BlockingThreadPoolExecutorFactory(NAMED_EXECUTORS_THREADS_WITH_QUEUE, NAMED_EXECUTORS_THREADS_WITH_QUEUE, + NAMED_EXECUTORS_QUEUE_SIZE, NAMED_EXECUTORS_KEEP_ALIVE); - executorFactory = new BlockingThreadPoolExecutorFactory( - TRANSPORT_EXEC_MAX_THREADS, TRANSPORT_EXEC_MAX_THREADS, TRANSPORT_EXEC_QUEUE_SIZE, KEEP_ALIVE); - builder.transport().transportThreadPool().threadPoolFactory(executorFactory); + builder.transport().remoteCommandThreadPool().threadPoolFactory(executorFactoryNoQueue); + builder.stateTransferThreadPool().threadPoolFactory(executorFactoryNoQueue); + builder.asyncThreadPool().threadPoolFactory(executorFactoryWithQueue); + builder.listenerThreadPool().threadPoolFactory(executorFactoryWithQueue); + builder.transport().transportThreadPool().threadPoolFactory(executorFactoryWithQueue); + // TODO Scheduled thread pools don't have a threads limit + // Timeout thread pool is not configurable at all } public static void amendMarshaller(GlobalConfigurationBuilder builder) { @@ -408,7 +421,7 @@ public static void amendMarshaller(GlobalConfigurationBuilder builder) { } private static DefaultCacheManager newDefaultCacheManager(boolean start, GlobalConfigurationBuilder gc, ConfigurationBuilder c) { - gc.transport().nodeName(TestResourceTracker.getNextNodeName()); + setNodeName(gc); GlobalConfiguration globalConfiguration = gc.build(); DefaultCacheManager defaultCacheManager = new DefaultCacheManager(globalConfiguration, c.build(globalConfiguration), start); TestResourceTracker.addResource(new TestResourceTracker.CacheManagerCleaner(defaultCacheManager)); @@ -416,6 +429,7 @@ private static DefaultCacheManager newDefaultCacheManager(boolean start, GlobalC } private static DefaultCacheManager newDefaultCacheManager(boolean start, ConfigurationBuilderHolder holder) { + setNodeName(holder.getGlobalConfigurationBuilder()); DefaultCacheManager defaultCacheManager = new DefaultCacheManager(holder, start); TestResourceTracker.addResource(new TestResourceTracker.CacheManagerCleaner(defaultCacheManager)); return defaultCacheManager; diff --git a/core/src/test/java/org/infinispan/test/fwk/TestResourceTracker.java b/core/src/test/java/org/infinispan/test/fwk/TestResourceTracker.java index d0f2aab78a31..a6a4c037de68 100644 --- a/core/src/test/java/org/infinispan/test/fwk/TestResourceTracker.java +++ b/core/src/test/java/org/infinispan/test/fwk/TestResourceTracker.java @@ -60,8 +60,7 @@ public static void cleanUpResources(String testName) { public static String getCurrentTestShortName() { String currentTestName = TestResourceTracker.getCurrentTestName(); - int endIndex = currentTestName.contains("[") ? currentTestName.lastIndexOf("[") : currentTestName.length(); - return currentTestName.substring(currentTestName.lastIndexOf(".") + 1, endIndex); + return getTestResources(currentTestName).getShortName(); } public static String getCurrentTestName() { @@ -132,17 +131,17 @@ public static void setThreadTestNameIfMissing(String testName) { public static String getNextNodeName() { String testName = getCurrentTestName(); TestResources resources = getTestResources(testName); - String simpleName = resources.getSimpleName(); + String shortName = resources.getShortName(); int nextNodeIndex = resources.addNode(); - return simpleName + "-" + "Node" + getNameForIndex(nextNodeIndex); + return shortName + "-" + "Node" + getNameForIndex(nextNodeIndex); } public static String getNextTestThreadName() { String testName = getCurrentTestName(); TestResources resources = getTestResources(testName); - String simpleName = resources.getSimpleName(); + String shortName = resources.getShortName(); int nextThreadIndex = resources.addThread(); - return "testng-" + simpleName + (nextThreadIndex != 0 ? "-" + nextThreadIndex : ""); + return "testng-" + shortName + (nextThreadIndex != 0 ? "-" + nextThreadIndex : ""); } public static String getNameForIndex(int i) { @@ -153,25 +152,30 @@ public static String getNameForIndex(int i) { } private static TestResources getTestResources(final String testName) { - return testResources.computeIfAbsent(testName, k -> new TestResources(getSimpleName(k))); - } - - private static String getSimpleName(String fullTestName) { - return fullTestName.substring(fullTestName.lastIndexOf(".") + 1); + return testResources.computeIfAbsent(testName, TestResources::new); } private static class TestResources { - private final String simpleName; + private static final boolean shortenTestName = Boolean.getBoolean("infinispan.test.shortTestName"); + + private final String shortName; private final AtomicInteger nodeCount = new AtomicInteger(0); private final AtomicInteger threadCount = new AtomicInteger(0); private final List> resourceCleaners = Collections.synchronizedList(new ArrayList>()); - private TestResources(String simpleName) { - this.simpleName = simpleName; + private TestResources(String testName) { + if (shortenTestName) { + this.shortName = "Test"; + } else { + int simpleNameStart = testName.lastIndexOf("."); + int parametersStart = testName.indexOf('['); + this.shortName = testName.substring(simpleNameStart + 1, + parametersStart > 0 ? parametersStart : testName.length()); + } } - public String getSimpleName() { - return simpleName; + public String getShortName() { + return shortName; } public int addNode() { diff --git a/core/src/test/java/org/infinispan/util/PersistenceMockUtil.java b/core/src/test/java/org/infinispan/util/PersistenceMockUtil.java index b0ca7315ec2e..527435b92837 100644 --- a/core/src/test/java/org/infinispan/util/PersistenceMockUtil.java +++ b/core/src/test/java/org/infinispan/util/PersistenceMockUtil.java @@ -35,30 +35,29 @@ */ public class PersistenceMockUtil { - public static InitializationContext createContext(String cacheName, Configuration configuration, StreamingMarshaller marshaller) { - return createContext(cacheName, configuration, marshaller, AbstractInfinispanTest.TIME_SERVICE); + public static InitializationContext createContext(String nodeName, Configuration configuration, StreamingMarshaller marshaller) { + return createContext(nodeName, configuration, marshaller, AbstractInfinispanTest.TIME_SERVICE); } - public static InitializationContext createContext(String cacheName, Configuration configuration, StreamingMarshaller marshaller, TimeService timeService) { - Cache mockCache = mockCache(cacheName, configuration, timeService); + public static InitializationContext createContext(String nodeName, Configuration configuration, StreamingMarshaller marshaller, TimeService timeService) { + Cache mockCache = mockCache(nodeName, configuration, timeService); return new InitializationContextImpl(configuration.persistence().stores().get(0), mockCache, SingleSegmentKeyPartitioner.getInstance(), marshaller, timeService, new ByteBufferFactoryImpl(), new MarshalledEntryFactoryImpl(marshaller), new WithinThreadExecutor()); } - public static Cache mockCache(String name, Configuration configuration) { - return mockCache(name, configuration, AbstractInfinispanTest.TIME_SERVICE); - } - - public static Cache mockCache(String name, Configuration configuration, TimeService timeService) { - String cacheName = "mock-cache-" + name; + private static Cache mockCache(String nodeName, Configuration configuration, TimeService timeService) { + String cacheName = "mock-cache"; AdvancedCache cache = mock(AdvancedCache.class, RETURNS_DEEP_STUBS); - GlobalConfiguration gc = new GlobalConfigurationBuilder().build(); + GlobalConfiguration gc = new GlobalConfigurationBuilder() + .transport().nodeName(nodeName) + .build(); Set cachesSet = new HashSet<>(); EmbeddedCacheManager cm = mock(EmbeddedCacheManager.class); + when(cm.getCacheManagerConfiguration()).thenReturn(gc); GlobalComponentRegistry gcr = new GlobalComponentRegistry(gc, cm, cachesSet); gcr.registerComponent(timeService, TimeService.class); ComponentRegistry registry = new ComponentRegistry(cacheName, configuration, cache, gcr, diff --git a/core/src/test/resources/configs/named-cache-test.xml b/core/src/test/resources/configs/named-cache-test.xml index 240cf6dd0294..d602c8ba1c75 100644 --- a/core/src/test/resources/configs/named-cache-test.xml +++ b/core/src/test/resources/configs/named-cache-test.xml @@ -11,7 +11,8 @@ - + + @@ -19,13 +20,16 @@ + + listener-executor="listener" persistence-executor="persistence" + state-transfer-executor="state-transfer" expiration-executor="expiration" + async-executor="async"> diff --git a/core/src/test/resources/configs/string-property-replaced.xml b/core/src/test/resources/configs/string-property-replaced.xml index 87822efdebd4..52d8069a1b85 100644 --- a/core/src/test/resources/configs/string-property-replaced.xml +++ b/core/src/test/resources/configs/string-property-replaced.xml @@ -11,8 +11,8 @@ - - + + @@ -23,8 +23,8 @@ keyEquivalence() instanceof AnyEquivalence); } - private void assertDefaultConfigApplied(EmbeddedCacheManager cm) { - for (String cacheName : cm.getCacheNames()) { - Configuration config = cm.getCacheConfiguration(cacheName); - if (!cacheName.startsWith("transaction") && !cacheName.startsWith("tx")) { - assertFalse("Assertion failed for cache: " + cacheName, config.transaction().transactionMode().isTransactional()); + private void assertDefaultConfigApplied(ConfigurationBuilderHolder holder) { + for (Map.Entry e : holder.getNamedConfigurationBuilders().entrySet()) { + Configuration config = e.getValue().build(); + String name = e.getKey(); + if (!name.startsWith("transaction") && !name.startsWith("tx")) { + assertFalse("Assertion failed for cache: " + e, config.transaction().transactionMode().isTransactional()); assertEquals(123, config.transaction().reaperWakeUpInterval()); assertEquals(3123, config.transaction().completedTxTimeout()); } - if (!cacheName.startsWith("locking")) { + if (!name.startsWith("locking")) { assertEquals(1000, config.locking().lockAcquisitionTimeout()); assertEquals(100, config.locking().concurrencyLevel()); } - if (!cacheName.equals("jmxEnabled")) - assertFalse(config.jmxStatistics().enabled()); - else - assertTrue(config.jmxStatistics().enabled()); + boolean jmxEnabled = "jmxEnabled".equals(name); + assertEquals(jmxEnabled, config.jmxStatistics().enabled()); } } - private void assertIndexingConverted(EmbeddedCacheManager cm) { - Configuration config = cm.getCacheConfiguration("withIndexingNotLocal"); + private void assertIndexingConverted(ConfigurationBuilderHolder holder) { + Configuration config = holder.getNamedConfigurationBuilders().get("withIndexingNotLocal").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertEquals("ALL", config.indexing().index().name()); assertEquals("test1", config.indexing().properties().get("test")); - config = cm.getCacheConfiguration("withIndexingLocalOnly"); + config = holder.getNamedConfigurationBuilders().get("withIndexingLocalOnly").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertEquals("LOCAL", config.indexing().index().name()); assertEquals("test1", config.indexing().properties().get("test")); - config = cm.getCacheConfiguration("withDisabledIndexing"); + config = holder.getNamedConfigurationBuilders().get("withDisabledIndexing").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertEquals("NONE", config.indexing().index().name()); } - private void assertTransactionConverted(EmbeddedCacheManager cm) { - Configuration config = cm.getCacheConfiguration("transactionalWithInvocationBatching"); + private void assertTransactionConverted(ConfigurationBuilderHolder holder) { + Configuration config = holder.getNamedConfigurationBuilders().get("transactionalWithInvocationBatching").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertTrue(config.transaction().transactionMode().isTransactional()); assertEquals("TRANSACTIONAL", config.transaction().transactionMode().name()); @@ -256,7 +249,7 @@ private void assertTransactionConverted(EmbeddedCacheManager cm) { assertTrue(config.transaction().autoCommit()); assertTrue(config.invocationBatching().enabled()); - config = cm.getCacheConfiguration("transactionalWithDisabledInvocationBatching"); + config = holder.getNamedConfigurationBuilders().get("transactionalWithDisabledInvocationBatching").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertTrue(config.transaction().transactionMode().isTransactional()); assertEquals("TRANSACTIONAL", config.transaction().transactionMode().name()); @@ -265,7 +258,7 @@ private void assertTransactionConverted(EmbeddedCacheManager cm) { assertTrue(config.transaction().autoCommit()); assertFalse(config.invocationBatching().enabled()); - config = cm.getCacheConfiguration("transactional"); + config = holder.getNamedConfigurationBuilders().get("transactional").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertTrue(config.transaction().transactionMode().isTransactional()); assertEquals("TRANSACTIONAL", config.transaction().transactionMode().name()); @@ -275,7 +268,7 @@ private void assertTransactionConverted(EmbeddedCacheManager cm) { assertTrue(config.transaction().recovery().enabled()); assertEquals("transactional2", config.transaction().recovery().recoveryInfoCacheName()); - config = cm.getCacheConfiguration("transactional2"); + config = holder.getNamedConfigurationBuilders().get("transactional2").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertTrue(config.transaction().transactionMode().isTransactional()); assertEquals("TRANSACTIONAL", config.transaction().transactionMode().name()); @@ -287,7 +280,7 @@ private void assertTransactionConverted(EmbeddedCacheManager cm) { assertEquals(10000, config.transaction().cacheStopTimeout()); assertTrue(config.transaction().transactionManagerLookup() instanceof org.infinispan.test.tx.TestLookup); - config = cm.getCacheConfiguration("transactional3"); + config = holder.getNamedConfigurationBuilders().get("transactional3").build(); assertTrue(config.clustering().cacheMode().isReplicated()); assertTrue(config.transaction().transactionMode().isTransactional()); assertEquals("TRANSACTIONAL", config.transaction().transactionMode().name()); @@ -298,7 +291,7 @@ private void assertTransactionConverted(EmbeddedCacheManager cm) { assertEquals("TOTAL_ORDER", config.transaction().transactionProtocol().name()); assertFalse(config.transaction().recovery().enabled()); - config = cm.getCacheConfiguration("txSyncRepl"); + config = holder.getNamedConfigurationBuilders().get("txSyncRepl").build(); assertTrue(config.clustering().cacheMode().isReplicated()); assertTrue(config.transaction().transactionMode().isTransactional()); assertEquals("TRANSACTIONAL", config.transaction().transactionMode().name()); @@ -310,19 +303,19 @@ private void assertTransactionConverted(EmbeddedCacheManager cm) { assertTrue(config.transaction().transactionManagerLookup() instanceof org.infinispan.transaction.lookup.GenericTransactionManagerLookup); } - private void assertCompatibilityConverted(EmbeddedCacheManager cm) { - Configuration config = cm.getCacheConfiguration("withCompatibilityEnabled"); + private void assertCompatibilityConverted(ConfigurationBuilderHolder holder) { + Configuration config = holder.getNamedConfigurationBuilders().get("withCompatibilityEnabled").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertTrue(config.compatibility().enabled()); assertTrue(config.compatibility().marshaller() instanceof GenericJBossMarshaller); - config = cm.getCacheConfiguration("withoutCompatibility"); + config = holder.getNamedConfigurationBuilders().get("withoutCompatibility").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertFalse(config.compatibility().enabled()); } - private void assertBackupsConverted(EmbeddedCacheManager cm) { - Configuration config = cm.getCacheConfiguration("withSitesEnabled"); + private void assertBackupsConverted(ConfigurationBuilderHolder holder) { + Configuration config = holder.getNamedConfigurationBuilders().get("withSitesEnabled").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertTrue(config.sites().backupFor().isBackupFor("test1", "test")); assertTrue(config.sites().hasInUseBackup("backupTest")); @@ -354,7 +347,7 @@ private void assertBackupsConverted(EmbeddedCacheManager cm) { assertEquals(BackupFailurePolicy.IGNORE, config.sites().getFailurePolicy("backupTest")); assertEquals(BackupFailurePolicy.CUSTOM, config.sites().getFailurePolicy("backupTest1")); - config = cm.getCacheConfiguration("withEmptyBackups"); + config = holder.getNamedConfigurationBuilders().get("withEmptyBackups").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertTrue(config.sites().backupFor().isBackupFor("test1", "test")); assertFalse(config.sites().hasEnabledBackups()); @@ -362,27 +355,27 @@ private void assertBackupsConverted(EmbeddedCacheManager cm) { assertEquals(0, config.sites().allBackups().size()); } - private void assertLockingConverted(EmbeddedCacheManager cm) { - Configuration config = cm.getCacheConfiguration("lockingOverriding"); + private void assertLockingConverted(ConfigurationBuilderHolder holder) { + Configuration config = holder.getNamedConfigurationBuilders().get("lockingOverriding").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertEquals("REPEATABLE_READ", config.locking().isolationLevel().name()); assertEquals(1000, config.locking().concurrencyLevel()); assertEquals(20000, config.locking().lockAcquisitionTimeout()); assertTrue(config.locking().useLockStriping()); - config = cm.getCacheConfiguration("lockingWithJDBCLoader"); + config = holder.getNamedConfigurationBuilders().get("lockingWithJDBCLoader").build(); assertEquals(1000, config.locking().lockAcquisitionTimeout()); assertEquals(100, config.locking().concurrencyLevel()); assertTrue(config.locking().supportsConcurrentUpdates()); - config = cm.getCacheConfiguration("lockingWithStoreAsBinary"); + config = holder.getNamedConfigurationBuilders().get("lockingWithStoreAsBinary").build(); assertEquals("REPEATABLE_READ", config.locking().isolationLevel().name()); assertEquals(20000, config.locking().lockAcquisitionTimeout()); assertEquals(1000, config.locking().concurrencyLevel()); } - private void assertExpirationEvictionConverted(EmbeddedCacheManager cm) { - Configuration config = cm.getCacheConfiguration("evictionCache"); + private void assertExpirationEvictionConverted(ConfigurationBuilderHolder holder) { + Configuration config = holder.getNamedConfigurationBuilders().get("evictionCache").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertEquals(500, config.expiration().wakeUpInterval()); assertEquals(1000, config.expiration().maxIdle()); @@ -392,7 +385,7 @@ private void assertExpirationEvictionConverted(EmbeddedCacheManager cm) { assertEquals(EvictionType.COUNT, config.memory().evictionType()); assertEquals(StorageType.OBJECT, config.memory().storageType()); - config = cm.getCacheConfiguration("expirationCacheWithEnabledReaper"); + config = holder.getNamedConfigurationBuilders().get("expirationCacheWithEnabledReaper").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertEquals(500, config.expiration().wakeUpInterval()); assertEquals(1000, config.expiration().maxIdle()); @@ -400,8 +393,8 @@ private void assertExpirationEvictionConverted(EmbeddedCacheManager cm) { assertTrue(config.expiration().reaperEnabled()); } - private void assertCustomInterceptorsConverted(EmbeddedCacheManager cm) { - Configuration config = cm.getCacheConfiguration("cacheWithCustomInterceptors"); + private void assertCustomInterceptorsConverted(ConfigurationBuilderHolder holder) { + Configuration config = holder.getNamedConfigurationBuilders().get("cacheWithCustomInterceptors").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertEquals(6, config.customInterceptors().interceptors().size()); @@ -427,8 +420,8 @@ private void assertCustomInterceptorsConverted(EmbeddedCacheManager cm) { assertTrue(config.customInterceptors().interceptors().get(0).interceptor() instanceof FooInterceptor); } - private void assertDeadlockDetectionConverted(EmbeddedCacheManager cm) { - Configuration config = cm.getCacheConfiguration("withDeadlockDetection"); + private void assertDeadlockDetectionConverted(ConfigurationBuilderHolder holder) { + Configuration config = holder.getNamedConfigurationBuilders().get("withDeadlockDetection").build(); assertFalse(config.jmxStatistics().enabled()); assertTrue(config.clustering().cacheMode().isDistributed()); assertTrue(config.clustering().cacheMode().isSynchronous()); @@ -436,11 +429,11 @@ private void assertDeadlockDetectionConverted(EmbeddedCacheManager cm) { assertFalse(config.deadlockDetection().enabled()); assertEquals(-1, config.deadlockDetection().spinDuration()); - config = cm.getCacheConfiguration("lockingWithJDBCLoader"); + config = holder.getNamedConfigurationBuilders().get("lockingWithJDBCLoader").build(); assertFalse(config.deadlockDetection().enabled()); assertEquals(-1, config.deadlockDetection().spinDuration()); - config = cm.getCacheConfiguration("withDeadlockDetectionDisabled"); + config = holder.getNamedConfigurationBuilders().get("withDeadlockDetectionDisabled").build(); assertFalse(config.jmxStatistics().enabled()); assertTrue(config.clustering().cacheMode().isDistributed()); assertTrue(config.clustering().cacheMode().isSynchronous()); @@ -448,50 +441,50 @@ private void assertDeadlockDetectionConverted(EmbeddedCacheManager cm) { assertFalse(config.deadlockDetection().enabled()); } - private void assertJmxStatisticsConverted(EmbeddedCacheManager cm) { - Configuration config = cm.getCacheConfiguration("jmxEnabled"); + private void assertJmxStatisticsConverted(ConfigurationBuilderHolder holder) { + Configuration config = holder.getNamedConfigurationBuilders().get("jmxEnabled").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertTrue(config.jmxStatistics().enabled()); } - private void assertStoreAsBinaryConverted(EmbeddedCacheManager cm) { - Configuration config = cm.getCacheConfiguration("lockingWithStoreAsBinary"); + private void assertStoreAsBinaryConverted(ConfigurationBuilderHolder holder) { + Configuration config = holder.getNamedConfigurationBuilders().get("lockingWithStoreAsBinary").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertEquals(StorageType.BINARY, config.memory().storageType()); - config = cm.getCacheConfiguration("lockingWithStoreAsBinaryDisabled"); + config = holder.getNamedConfigurationBuilders().get("lockingWithStoreAsBinaryDisabled").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertEquals(StorageType.OBJECT, config.memory().storageType()); - config = cm.getCacheConfiguration("withoutStoreAsBinary"); + config = holder.getNamedConfigurationBuilders().get("withoutStoreAsBinary").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertEquals(StorageType.OBJECT, config.memory().storageType()); - config = cm.getCacheConfiguration("storeKeyValueBinary"); + config = holder.getNamedConfigurationBuilders().get("storeKeyValueBinary").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertEquals(StorageType.BINARY, config.memory().storageType()); - config = cm.getCacheConfiguration("lazyDeserializationCache"); + config = holder.getNamedConfigurationBuilders().get("lazyDeserializationCache").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertEquals(StorageType.BINARY, config.memory().storageType()); } - private void assertClusteringConverted(EmbeddedCacheManager cm) { - Configuration config = cm.getCacheConfiguration("transactional3"); + private void assertClusteringConverted(ConfigurationBuilderHolder holder) { + Configuration config = holder.getNamedConfigurationBuilders().get("transactional3").build(); assertTrue(config.clustering().cacheMode().isReplicated()); assertTrue(config.clustering().cacheMode().isSynchronous()); - config = cm.getCacheConfiguration("lockingSyncInval"); + config = holder.getNamedConfigurationBuilders().get("lockingSyncInval").build(); assertTrue(config.clustering().cacheMode().isInvalidation()); assertTrue(config.clustering().cacheMode().isSynchronous()); - config = cm.getCacheConfiguration("lockingAsyncInval"); + config = holder.getNamedConfigurationBuilders().get("lockingAsyncInval").build(); assertTrue(config.clustering().cacheMode().isInvalidation()); assertFalse(config.clustering().cacheMode().isSynchronous()); assertTrue(config.clustering().stateTransfer().fetchInMemoryState()); assertTrue(config.clustering().stateTransfer().awaitInitialTransfer()); - config = cm.getCacheConfiguration("syncRepl"); + config = holder.getNamedConfigurationBuilders().get("syncRepl").build(); assertTrue(config.clustering().cacheMode().isReplicated()); assertTrue(config.clustering().cacheMode().isSynchronous()); assertEquals(15000, config.clustering().sync().replTimeout()); @@ -499,26 +492,26 @@ private void assertClusteringConverted(EmbeddedCacheManager cm) { assertFalse(config.clustering().stateTransfer().fetchInMemoryState()); assertTrue(config.clustering().stateTransfer().awaitInitialTransfer()); - config = cm.getCacheConfiguration("asyncRepl"); + config = holder.getNamedConfigurationBuilders().get("asyncRepl").build(); assertTrue(config.clustering().cacheMode().isReplicated()); assertFalse(config.clustering().cacheMode().isSynchronous()); assertFalse(config.clustering().stateTransfer().fetchInMemoryState()); assertTrue(config.clustering().stateTransfer().awaitInitialTransfer()); - config = cm.getCacheConfiguration("asyncReplQueue"); + config = holder.getNamedConfigurationBuilders().get("asyncReplQueue").build(); assertTrue(config.clustering().cacheMode().isReplicated()); assertFalse(config.clustering().cacheMode().isSynchronous()); assertFalse(config.clustering().stateTransfer().fetchInMemoryState()); assertTrue(config.clustering().stateTransfer().awaitInitialTransfer()); - config = cm.getCacheConfiguration("txSyncRepl"); + config = holder.getNamedConfigurationBuilders().get("txSyncRepl").build(); assertTrue(config.clustering().cacheMode().isReplicated()); assertTrue(config.clustering().cacheMode().isSynchronous()); assertEquals(15000, config.clustering().remoteTimeout()); assertFalse(config.clustering().stateTransfer().fetchInMemoryState()); assertTrue(config.clustering().stateTransfer().awaitInitialTransfer()); - config = cm.getCacheConfiguration("dist"); + config = holder.getNamedConfigurationBuilders().get("dist").build(); assertTrue(config.clustering().cacheMode().isDistributed()); assertTrue(config.clustering().cacheMode().isSynchronous()); assertEquals(120000, config.clustering().stateTransfer().timeout()); @@ -529,7 +522,7 @@ private void assertClusteringConverted(EmbeddedCacheManager cm) { assertEquals(600000, config.clustering().l1().lifespan()); assertEquals(1200, config.clustering().l1().cleanupTaskFrequency()); - config = cm.getCacheConfiguration("dist_with_capacity_factors"); + config = holder.getNamedConfigurationBuilders().get("dist_with_capacity_factors").build(); assertTrue(config.clustering().cacheMode().isDistributed()); assertTrue(config.clustering().cacheMode().isSynchronous()); assertEquals(120000, config.clustering().stateTransfer().timeout()); @@ -540,7 +533,7 @@ private void assertClusteringConverted(EmbeddedCacheManager cm) { assertTrue(config.clustering().l1().enabled()); assertEquals(610000, config.clustering().l1().lifespan()); - config = cm.getCacheConfiguration("groups"); + config = holder.getNamedConfigurationBuilders().get("groups").build(); assertTrue(config.clustering().cacheMode().isDistributed()); assertTrue(config.clustering().cacheMode().isSynchronous()); assertTrue(config.clustering().stateTransfer().fetchInMemoryState()); @@ -549,14 +542,14 @@ private void assertClusteringConverted(EmbeddedCacheManager cm) { assertEquals(1, config.clustering().hash().groups().groupers().size()); assertTrue(config.clustering().hash().groups().groupers().get(0) instanceof org.infinispan.distribution.groups.KXGrouper); - config = cm.getCacheConfiguration("groupsDisabled"); + config = holder.getNamedConfigurationBuilders().get("groupsDisabled").build(); assertTrue(config.clustering().cacheMode().isDistributed()); assertTrue(config.clustering().cacheMode().isSynchronous()); assertTrue(config.clustering().stateTransfer().fetchInMemoryState()); assertTrue(config.clustering().stateTransfer().awaitInitialTransfer()); assertFalse(config.clustering().hash().groups().enabled()); - config = cm.getCacheConfiguration("chunkSize"); + config = holder.getNamedConfigurationBuilders().get("chunkSize").build(); assertTrue(config.clustering().cacheMode().isDistributed()); assertFalse(config.clustering().cacheMode().isSynchronous()); assertTrue(config.clustering().stateTransfer().fetchInMemoryState()); @@ -568,7 +561,7 @@ private void assertClusteringConverted(EmbeddedCacheManager cm) { assertEquals(600000, config.clustering().l1().lifespan()); assertEquals(1200, config.clustering().l1().cleanupTaskFrequency()); - config = cm.getCacheConfiguration("distAsync"); + config = holder.getNamedConfigurationBuilders().get("distAsync").build(); assertTrue(config.clustering().cacheMode().isDistributed()); assertFalse(config.clustering().cacheMode().isSynchronous()); assertEquals(120000, config.clustering().stateTransfer().timeout()); @@ -579,19 +572,19 @@ private void assertClusteringConverted(EmbeddedCacheManager cm) { assertEquals(600000, config.clustering().l1().lifespan()); assertEquals(1200, config.clustering().l1().cleanupTaskFrequency()); - config = cm.getCacheConfiguration("localCache"); + config = holder.getNamedConfigurationBuilders().get("localCache").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertTrue(config.clustering().cacheMode().isSynchronous()); - config = cm.getCacheConfiguration("hashWithFactory"); + config = holder.getNamedConfigurationBuilders().get("hashWithFactory").build(); assertTrue(config.clustering().cacheMode().isDistributed()); assertTrue(config.clustering().cacheMode().isSynchronous()); assertTrue(config.clustering().hash().consistentHashFactory() instanceof org.infinispan.distribution.ch.impl.ReplicatedConsistentHashFactory); assertFalse(config.clustering().l1().enabled()); } - private void assertPersistenceConverted(EmbeddedCacheManager cm) { - Configuration config = cm.getCacheConfiguration("withClusterLoader"); + private void assertPersistenceConverted(ConfigurationBuilderHolder holder) { + Configuration config = holder.getNamedConfigurationBuilders().get("withClusterLoader").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertFalse(config.persistence().usingAsyncStore()); assertTrue(config.persistence().usingStores()); @@ -608,7 +601,7 @@ private void assertPersistenceConverted(EmbeddedCacheManager cm) { //----------------------------------------------------------------------------------------- - config = cm.getCacheConfiguration("withFileStore"); + config = holder.getNamedConfigurationBuilders().get("withFileStore").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertTrue(config.persistence().usingAsyncStore()); assertFalse(config.persistence().passivation()); @@ -630,7 +623,7 @@ private void assertPersistenceConverted(EmbeddedCacheManager cm) { //----------------------------------------------------------------------------------------- - config = cm.getCacheConfiguration("withFileStoreDisabledAsync"); + config = holder.getNamedConfigurationBuilders().get("withFileStoreDisabledAsync").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertFalse(config.persistence().usingAsyncStore()); assertFalse(config.persistence().passivation()); @@ -650,7 +643,7 @@ private void assertPersistenceConverted(EmbeddedCacheManager cm) { //-------------------------------------------------------------------------------------------- - config = cm.getCacheConfiguration("withLoaderDefaults"); + config = holder.getNamedConfigurationBuilders().get("withLoaderDefaults").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertFalse(config.persistence().usingAsyncStore()); assertFalse(config.persistence().passivation()); @@ -668,7 +661,7 @@ private void assertPersistenceConverted(EmbeddedCacheManager cm) { //-------------------------------------------------------------------------------------------- - config = cm.getCacheConfiguration("withClusterLoader1"); + config = holder.getNamedConfigurationBuilders().get("withClusterLoader1").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertFalse(config.persistence().usingAsyncStore()); assertFalse(config.persistence().passivation()); @@ -685,7 +678,7 @@ private void assertPersistenceConverted(EmbeddedCacheManager cm) { assertTrue(clusterLoaderConfiguration.shared()); //-------------------------------------------------------------------------------------------- - config = cm.getCacheConfiguration("lockingWithJDBCLoader"); + config = holder.getNamedConfigurationBuilders().get("lockingWithJDBCLoader").build(); assertTrue(config.clustering().cacheMode().isClustered()); assertTrue(config.clustering().cacheMode().isSynchronous()); assertEquals(20000, config.clustering().sync().replTimeout()); @@ -706,7 +699,7 @@ private void assertPersistenceConverted(EmbeddedCacheManager cm) { assertEquals("${java.io.tmpdir}", singleFileStoreConfiguration.location()); //-------------------------------------------------------------------------------------------- - config = cm.getCacheConfiguration("jdbcStringBasedWithConnectionPool"); + config = holder.getNamedConfigurationBuilders().get("jdbcStringBasedWithConnectionPool").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertFalse(config.persistence().usingAsyncStore()); assertFalse(config.persistence().passivation()); @@ -736,7 +729,7 @@ private void assertPersistenceConverted(EmbeddedCacheManager cm) { assertEquals("org.h2.Driver", connectionPool.driverClass()); //---------------------------------------------------------------------------------------------- - config = cm.getCacheConfiguration("jdbcStringBasedWithDataSource"); + config = holder.getNamedConfigurationBuilders().get("jdbcStringBasedWithDataSource").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertFalse(config.persistence().usingAsyncStore()); assertFalse(config.persistence().passivation()); @@ -765,7 +758,7 @@ private void assertPersistenceConverted(EmbeddedCacheManager cm) { assertEquals("url", managedConnectionFactoryConfiguration.jndiUrl()); //---------------------------------------------------------------------------------------------- - config = cm.getCacheConfiguration("jdbcStringBasedWithSimpleConnection"); + config = holder.getNamedConfigurationBuilders().get("jdbcStringBasedWithSimpleConnection").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertFalse(config.persistence().usingAsyncStore()); assertFalse(config.persistence().passivation()); @@ -797,7 +790,7 @@ private void assertPersistenceConverted(EmbeddedCacheManager cm) { assertEquals("testValue", jdbcStringBasedStoreConfiguration.properties().getProperty("testName")); //---------------------------------------------------------------------------------------------- - config = cm.getCacheConfiguration("withRemoteStore"); + config = holder.getNamedConfigurationBuilders().get("withRemoteStore").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertFalse(config.persistence().usingAsyncStore()); assertFalse(config.persistence().passivation()); @@ -844,7 +837,7 @@ private void assertPersistenceConverted(EmbeddedCacheManager cm) { assertFalse(remoteConnectionPoolConfiguration.testWhileIdle()); //------------------------------------------------------------------------------------------- - config = cm.getCacheConfiguration("withRestStore"); + config = holder.getNamedConfigurationBuilders().get("withRestStore").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertFalse(config.persistence().usingAsyncStore()); assertFalse(config.persistence().passivation()); @@ -873,7 +866,7 @@ private void assertPersistenceConverted(EmbeddedCacheManager cm) { assertTrue(restConnectionPool.tcpNoDelay()); //------------------------------------------------------------------------------------------- - config = cm.getCacheConfiguration("withLevelDBStore"); + config = holder.getNamedConfigurationBuilders().get("withLevelDBStore").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertFalse(config.persistence().usingAsyncStore()); assertTrue(config.persistence().passivation()); @@ -893,7 +886,7 @@ private void assertPersistenceConverted(EmbeddedCacheManager cm) { assertEquals("SNAPPY", rocksDBStoreConfiguration.compressionType().name()); //------------------------------------------------------------------------------------------- - config = cm.getCacheConfiguration("withJpaStore"); + config = holder.getNamedConfigurationBuilders().get("withJpaStore").build(); assertFalse(config.clustering().cacheMode().isClustered()); assertFalse(config.persistence().usingAsyncStore()); assertTrue(config.persistence().passivation()); @@ -908,11 +901,11 @@ private void assertPersistenceConverted(EmbeddedCacheManager cm) { assertFalse(jpaStoreConfiguration.storeMetadata()); } - private void assertUnsafeConverted(EmbeddedCacheManager cm) { - Configuration config = cm.getCacheConfiguration("withUnsafe"); + private void assertUnsafeConverted(ConfigurationBuilderHolder holder) { + Configuration config = holder.getNamedConfigurationBuilders().get("withUnsafe").build(); assertTrue(config.unsafe().unreliableReturnValues()); - config = cm.getCacheConfiguration("withUnsafeDisabled"); + config = holder.getNamedConfigurationBuilders().get("withUnsafeDisabled").build(); assertFalse(config.unsafe().unreliableReturnValues()); } }