@Override Void runTask() throws Exception { cacheManager.destroyCache("simple-cache"); return null; } });
@Test public void testDestroyCacheDestroysPersistenceContext() throws Exception { File file = new File(getStoragePath(), "testDestroy"); initCacheManager(file); persistentCacheManager.destroyCache(PERSISTENT_CACHE); assertThat(file, not(containsCacheDirectory(PERSISTENT_CACHE))); }
@Test public void testDestroyCache_UnexistingCacheDoesNothing() throws CachePersistenceException { PersistentCacheManager manager = builder.build(true); manager.destroyCache(TEST_CACHE_ALIAS); }
@Test public void reconnectDuringCacheCreation() throws Exception { expireLease(); Cache<Long, String> cache = cacheManager.createCache("clustered-cache", config); assertThat(cache, notNullValue()); cacheManager.destroyCache("clustered-cache"); }
@Test public void testDestroyNonExistentCache() throws CachePersistenceException { PersistentCacheManager persistentCacheManager = clusteredCacheManagerBuilder.build(true); String nonExistent = "this-is-not-the-cache-you-are-looking-for"; assertThat(persistentCacheManager.getCache(nonExistent, Long.class, String.class), nullValue()); persistentCacheManager.destroyCache(nonExistent); persistentCacheManager.close(); }
@Test public void testDestroyNonExistentCacheWithCacheManagerStopped() throws CachePersistenceException { PersistentCacheManager persistentCacheManager = clusteredCacheManagerBuilder.build(true); persistentCacheManager.close(); persistentCacheManager.destroyCache("this-is-not-the-cache-you-are-looking-for"); assertThat(persistentCacheManager.getStatus(), is(Status.UNINITIALIZED)); }
@Test public void testDestroyCache_CacheManagerUninitialized() throws CachePersistenceException { PersistentCacheManager manager = buildCacheManagerWithCache(false); manager.destroyCache(TEST_CACHE_ALIAS); assertThat(rootDirectory, not(isLocked())); assertThat(rootDirectory, not(containsCacheDirectory(TEST_CACHE_ALIAS))); }
@Test public void testDestroyCacheWithCacheManagerStopped() throws CachePersistenceException { PersistentCacheManager persistentCacheManager = clusteredCacheManagerBuilder.build(true); persistentCacheManager.close(); persistentCacheManager.destroyCache(CLUSTERED_CACHE); assertThat(persistentCacheManager.getStatus(), is(Status.UNINITIALIZED)); }
@Test public void reconnectDuringCacheDestroy() throws Exception { Cache<Long, String> cache = cacheManager.createCache("clustered-cache", config); assertThat(cache, notNullValue()); expireLease(); cacheManager.destroyCache("clustered-cache"); assertThat(cacheManager.getCache("clustered-cache", Long.class, String.class), nullValue()); }
@Test public void testDestroyCacheWhenSingleClientIsConnected() throws CachePersistenceException { PersistentCacheManager persistentCacheManager = clusteredCacheManagerBuilder.build(true); persistentCacheManager.destroyCache(CLUSTERED_CACHE); final Cache<Long, String> cache = persistentCacheManager.getCache(CLUSTERED_CACHE, Long.class, String.class); assertThat(cache, nullValue()); persistentCacheManager.close(); }
@Test public void testDestroyCache_NullAliasNotAllowed() throws CachePersistenceException { PersistentCacheManager manager = builder.build(true); thrown.expect(NullPointerException.class); thrown.expectMessage("Alias cannot be null"); manager.destroyCache(null); }
@Test public void testDestroyCacheWithTwoCacheManagerOnSameCache_firstRemovesSecondDestroy() throws CachePersistenceException { PersistentCacheManager persistentCacheManager1 = clusteredCacheManagerBuilder.build(true); PersistentCacheManager persistentCacheManager2 = clusteredCacheManagerBuilder.build(true); persistentCacheManager2.removeCache(CLUSTERED_CACHE); persistentCacheManager1.destroyCache(CLUSTERED_CACHE); }
@Test public void testDestroyCache_Uninitialized_DestroyExistingCache() throws CachePersistenceException { PersistentCacheManager manager = buildCacheManagerWithCache(true); manager.close(); manager.destroyCache(TEST_CACHE_ALIAS); assertThat(rootDirectory, not(isLocked())); assertThat(rootDirectory, not(containsCacheDirectory(TEST_CACHE_ALIAS))); }
@Test public void testDestroyCacheWithTwoCacheManagerOnSameCache_secondDoesntHaveTheCacheButPreventExclusiveAccessToCluster() throws CachePersistenceException { PersistentCacheManager persistentCacheManager1 = clusteredCacheManagerBuilder.build(false); PersistentCacheManager persistentCacheManager2 = clusteredCacheManagerBuilder.build(true); persistentCacheManager2.removeCache(CLUSTERED_CACHE); persistentCacheManager1.destroyCache(CLUSTERED_CACHE); } }
@Test public void testDestroyCacheOnNonExistentCacheManager() throws CachePersistenceException { PersistentCacheManager persistentCacheManager = clusteredCacheManagerBuilder.build(true); persistentCacheManager.close(); persistentCacheManager.destroy(); persistentCacheManager.destroyCache("this-is-not-the-cache-you-are-looking-for"); assertThat(persistentCacheManager.getStatus(), is(Status.UNINITIALIZED)); } @Test
@Test public void testDestroyCache_Initialized_DestroyExistingCache() throws CachePersistenceException { PersistentCacheManager manager = buildCacheManagerWithCache(true); manager.destroyCache(TEST_CACHE_ALIAS); assertThat(rootDirectory, isLocked()); assertThat(rootDirectory, not(containsCacheDirectory(TEST_CACHE_ALIAS))); }
@Test public void testDestroyCacheWithTwoCacheManagerOnSameCache_forbiddenWhenInUse() throws CachePersistenceException { PersistentCacheManager persistentCacheManager1 = clusteredCacheManagerBuilder.build(true); PersistentCacheManager persistentCacheManager2 = clusteredCacheManagerBuilder.build(true); expectedException.expect(CachePersistenceException.class); expectedException.expectMessage("Cannot destroy cluster tier 'clustered-cache': in use by other client(s)"); persistentCacheManager1.destroyCache(CLUSTERED_CACHE); }
@Test public void testDestroyCacheWithUnknownAlias() throws Exception { File file = new File(getStoragePath(), "testDestroyUnknownAlias"); initCacheManager(file); Cache<Long, String > cache = persistentCacheManager.getCache(PERSISTENT_CACHE, Long.class, String.class); cache.put(1L, "One"); persistentCacheManager.close(); PersistentCacheManager anotherPersistentCacheManager = CacheManagerBuilder.newCacheManagerBuilder() .with(new CacheManagerPersistenceConfiguration(file)).build(true); anotherPersistentCacheManager.destroyCache(PERSISTENT_CACHE); assertThat(file, not(containsCacheDirectory(PERSISTENT_CACHE))); }
@Test public void testCreateCacheWithSameAliasAfterDestroy() throws Exception { File file = new File(getStoragePath(), "testDestroy"); initCacheManager(file); persistentCacheManager.destroyCache(PERSISTENT_CACHE); persistentCacheManager.createCache(PERSISTENT_CACHE, CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class, newResourcePoolsBuilder() .heap(10, EntryUnit.ENTRIES) .disk(10L, MemoryUnit.MB, true)) .build()); assertNotNull(persistentCacheManager.getCache(PERSISTENT_CACHE, Long.class, String.class)); persistentCacheManager.close(); }
@Test public void testDestroyUnknownCacheAlias() throws Exception { clusteredCacheManagerBuilder.build(true).close(); PersistentCacheManager cacheManager = newCacheManagerBuilder().with(cluster(CLUSTER_URI).expecting()).build(true); cacheManager.destroyCache(CLUSTERED_CACHE); try { cacheManager.createCache(CLUSTERED_CACHE, newCacheConfigurationBuilder(Long.class, String.class, newResourcePoolsBuilder() .with(clustered()))); fail("Expected exception as clustered store no longer exists"); } catch (IllegalStateException e) { assertThat(e.getMessage(), containsString(CLUSTERED_CACHE)); } cacheManager.close(); }