} else { successes.putAll(result); throw new BulkCacheLoadingException(failures, successes);
@SuppressWarnings({ "unchecked" }) private void collectSuccessesAndFailures(BulkCacheLoadingException bcle, Map<K, V> successes, Map<K, Exception> failures) { successes.putAll((Map<K, V>)bcle.getSuccesses()); failures.putAll((Map<K, Exception>)bcle.getFailures()); }
fail("expected BulkCacheLoadingException"); } catch (BulkCacheLoadingException ex) { assertThat(ex.getFailures().size(), is(1)); assertThat(ex.getFailures().get(2), is(notNullValue())); assertThat(ex.getSuccesses().size(), is(lessThan(4))); assertThat(ex.getSuccesses().containsKey(2), is(false));
@Override public Map<String, String> loadAll(final Iterable<? extends String> keys) throws Exception { if (isBulkCacheLoadingExceptionEnabled) { Map<String, Exception> failures = new HashMap<>(); Map<String, String> loadedKeys = new HashMap<>(); Exception loadingException = new RuntimeException("Exception loading keys"); for (String key : keys) { if (failingKeys.contains(key)) { failures.put(key, loadingException); } else { loadedKeys.put(key, this.entries.get(key)); } } throw new BulkCacheLoadingException(failures, loadedKeys); } final Map<String, String> resultMap = new HashMap<>(); for (final String key : keys) { if (this.failingKeys.contains(key)) { throw new FailedKeyException(key); } resultMap.put(key, this.entries.get(key)); } return resultMap; }
@Test public void testGetAll_cache_loader_throws_exception() throws Exception { CacheConfigurationBuilder cacheConfigurationBuilder = CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class, String.class, heap(100)); CacheLoaderWriterProvider cacheLoaderWriterProvider = mock(CacheLoaderWriterProvider.class); CacheLoaderWriter cacheLoaderWriter = mock(CacheLoaderWriter.class); when(cacheLoaderWriter.load(ArgumentMatchers.any())).thenThrow(new RuntimeException("We should not have called .load() but .loadAll()")); when(cacheLoaderWriter.loadAll(ArgumentMatchers.any(Iterable.class))).thenThrow(new Exception("Simulating an exception from the cache loader")); when(cacheLoaderWriterProvider.createCacheLoaderWriter(anyString(), ArgumentMatchers.any(CacheConfiguration.class))).thenReturn(cacheLoaderWriter); CacheManagerBuilder<CacheManager> managerBuilder = CacheManagerBuilder.newCacheManagerBuilder().using(cacheLoaderWriterProvider); CacheConfiguration<String, String> cacheConfiguration = cacheConfigurationBuilder.withLoaderWriter(cacheLoaderWriter).build(); CacheManager cacheManager = managerBuilder.withCache("myCache", cacheConfiguration).build(true); Cache<String, String> myCache = cacheManager.getCache("myCache", String.class, String.class); Set<String> fewKeysSet = new HashSet<String>() { { add("key0"); add("key2"); } }; // the call to getAll try { myCache.getAll(fewKeysSet); fail(); } catch (BulkCacheLoadingException bcwe) { // since onHeapStore.bulkComputeIfAbsent sends batches of 1 element, assertThat(bcwe.getFailures().size(), is(2)); assertThat(bcwe.getSuccesses().size(), is(0)); } }
} else { successes.putAll(result); throw new BulkCacheLoadingException(failures, successes);
@SuppressWarnings({ "unchecked" }) private void collectSuccessesAndFailures(BulkCacheLoadingException bcle, Map<K, V> successes, Map<K, Exception> failures) { successes.putAll((Map<K, V>)bcle.getSuccesses()); failures.putAll((Map<K, Exception>)bcle.getFailures()); }