GitHub-Spring
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Consistent early eviction tests in regular and transactional scenarios 

See gh-23192
pull/23329/head
Juergen Hoeller 7 years ago
parent
be65bef91b
commit
8aa0b07768
11 changed files with 288 additions and 241 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      spring-aspects/src/test/java/org/springframework/cache/aspectj/AspectJCacheAnnotationTests.java
  2. 52
      spring-aspects/src/test/java/org/springframework/cache/config/AnnotatedClassCacheableService.java
  3. 15
      spring-aspects/src/test/java/org/springframework/cache/config/CacheableService.java
  4. 63
      spring-aspects/src/test/java/org/springframework/cache/config/DefaultCacheableService.java
  5. 31
      spring-context-support/src/test/java/org/springframework/cache/jcache/JCacheEhCacheAnnotationTests.java
  6. 309
      spring-context/src/test/java/org/springframework/cache/config/AbstractCacheAnnotationTests.java
  7. 21
      spring-context/src/test/java/org/springframework/cache/config/AnnotatedClassCacheableService.java
  8. 2
      spring-context/src/test/java/org/springframework/cache/config/CacheAdviceNamespaceTests.java
  9. 12
      spring-context/src/test/java/org/springframework/cache/config/CacheableService.java
  10. 19
      spring-context/src/test/java/org/springframework/cache/config/DefaultCacheableService.java
  11. 3
      spring-context/src/test/resources/org/springframework/cache/config/cache-advice.xml

2
spring-aspects/src/test/java/org/springframework/cache/aspectj/AspectJCacheAnnotationTests.java vendored
Unescape View File

@ -38,7 +38,7 @@ public class AspectJCacheAnnotationTests extends AbstractCacheAnnotationTests {
} }
@Test @Test
public void testKeyStrategy() throws Exception { public void testKeyStrategy() {
AnnotationCacheAspect aspect = ctx.getBean( AnnotationCacheAspect aspect = ctx.getBean(
"org.springframework.cache.config.internalCacheAspect", AnnotationCacheAspect.class); "org.springframework.cache.config.internalCacheAspect", AnnotationCacheAspect.class);
assertThat(aspect.getKeyGenerator()).isSameAs(ctx.getBean("keyGenerator")); assertThat(aspect.getKeyGenerator()).isSameAs(ctx.getBean("keyGenerator"));

52
spring-aspects/src/test/java/org/springframework/cache/config/AnnotatedClassCacheableService.java vendored
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2016 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -33,11 +33,13 @@ import org.springframework.cache.annotation.Caching;
public class AnnotatedClassCacheableService implements CacheableService<Object> { public class AnnotatedClassCacheableService implements CacheableService<Object> {
private final AtomicLong counter = new AtomicLong(); private final AtomicLong counter = new AtomicLong();
public static final AtomicLong nullInvocations = new AtomicLong(); public static final AtomicLong nullInvocations = new AtomicLong();
@Override @Override
public Object cache(Object arg1) { public Object cache(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@ -48,7 +50,7 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
@Override @Override
@Cacheable(cacheNames = "testCache", sync = true) @Cacheable(cacheNames = "testCache", sync = true)
public Object cacheSync(Object arg1) { public Object cacheSync(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@ -68,13 +70,14 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
} }
@Override @Override
@Cacheable(cacheNames = "testCache", unless = "#result > 10")
public Object unless(int arg) { public Object unless(int arg) {
return arg; return arg;
} }
@Override @Override
@CacheEvict("testCache") @CacheEvict(cacheNames = "testCache", key = "#p0")
public void invalidate(Object arg1) { public void evict(Object arg1, Object arg2) {
} }
@Override @Override
@ -83,11 +86,6 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
throw new RuntimeException("exception thrown - evict should NOT occur"); throw new RuntimeException("exception thrown - evict should NOT occur");
} }
@Override
@CacheEvict(cacheNames = "testCache", allEntries = true)
public void evictAll(Object arg1) {
}
@Override @Override
@CacheEvict(cacheNames = "testCache", beforeInvocation = true) @CacheEvict(cacheNames = "testCache", beforeInvocation = true)
public void evictEarly(Object arg1) { public void evictEarly(Object arg1) {
@ -95,68 +93,68 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
} }
@Override @Override
@CacheEvict(cacheNames = "testCache", key = "#p0") @CacheEvict(cacheNames = "testCache", allEntries = true)
public void evict(Object arg1, Object arg2) { public void evictAll(Object arg1) {
} }
@Override @Override
@CacheEvict(cacheNames = "testCache", key = "#p0", beforeInvocation = true) @CacheEvict(cacheNames = "testCache", allEntries = true, beforeInvocation = true)
public void invalidateEarly(Object arg1, Object arg2) { public void evictAllEarly(Object arg1) {
throw new RuntimeException("exception thrown - evict should still occur"); throw new RuntimeException("exception thrown - evict should still occur");
} }
@Override @Override
@Cacheable(cacheNames = "testCache", key = "#p0") @Cacheable(cacheNames = "testCache", key = "#p0")
public Object key(Object arg1, Object arg2) { public Object key(Object arg1, Object arg2) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Cacheable("testCache") @Cacheable("testCache")
public Object varArgsKey(Object... args) { public Object varArgsKey(Object... args) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Cacheable(cacheNames = "testCache", key = "#root.methodName + #root.caches[0].name") @Cacheable(cacheNames = "testCache", key = "#root.methodName + #root.caches[0].name")
public Object name(Object arg1) { public Object name(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Cacheable(cacheNames = "testCache", key = "#root.methodName + #root.method.name + #root.targetClass + #root.target") @Cacheable(cacheNames = "testCache", key = "#root.methodName + #root.method.name + #root.targetClass + #root.target")
public Object rootVars(Object arg1) { public Object rootVars(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Cacheable(cacheNames = "testCache", keyGenerator = "customKyeGenerator") @Cacheable(cacheNames = "testCache", keyGenerator = "customKyeGenerator")
public Object customKeyGenerator(Object arg1) { public Object customKeyGenerator(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Cacheable(cacheNames = "testCache", keyGenerator = "unknownBeanName") @Cacheable(cacheNames = "testCache", keyGenerator = "unknownBeanName")
public Object unknownCustomKeyGenerator(Object arg1) { public Object unknownCustomKeyGenerator(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Cacheable(cacheNames = "testCache", cacheManager = "customCacheManager") @Cacheable(cacheNames = "testCache", cacheManager = "customCacheManager")
public Object customCacheManager(Object arg1) { public Object customCacheManager(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Cacheable(cacheNames = "testCache", cacheManager = "unknownBeanName") @Cacheable(cacheNames = "testCache", cacheManager = "unknownBeanName")
public Object unknownCustomCacheManager(Object arg1) { public Object unknownCustomCacheManager(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@CachePut("testCache") @CachePut("testCache")
public Object update(Object arg1) { public Object update(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@ -203,25 +201,25 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
@Override @Override
@Caching(cacheable = { @Cacheable("primary"), @Cacheable("secondary") }) @Caching(cacheable = { @Cacheable("primary"), @Cacheable("secondary") })
public Object multiCache(Object arg1) { public Object multiCache(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames = "secondary", key = "#a0"), @CacheEvict(cacheNames = "primary", key = "#p0 + 'A'") }) @Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames = "secondary", key = "#a0"), @CacheEvict(cacheNames = "primary", key = "#p0 + 'A'") })
public Object multiEvict(Object arg1) { public Object multiEvict(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Caching(cacheable = { @Cacheable(cacheNames = "primary", key = "#root.methodName") }, evict = { @CacheEvict("secondary") }) @Caching(cacheable = { @Cacheable(cacheNames = "primary", key = "#root.methodName") }, evict = { @CacheEvict("secondary") })
public Object multiCacheAndEvict(Object arg1) { public Object multiCacheAndEvict(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Caching(cacheable = { @Cacheable(cacheNames = "primary", condition = "#a0 == 3") }, evict = { @CacheEvict("secondary") }) @Caching(cacheable = { @Cacheable(cacheNames = "primary", condition = "#a0 == 3") }, evict = { @CacheEvict("secondary") })
public Object multiConditionalCacheAndEvict(Object arg1) { public Object multiConditionalCacheAndEvict(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override

15
spring-aspects/src/test/java/org/springframework/cache/config/CacheableService.java vendored
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2015 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -17,7 +17,7 @@
package org.springframework.cache.config; package org.springframework.cache.config;
/** /**
* Basic service interface. * Basic service interface for caching tests.
* *
* @author Costin Leau * @author Costin Leau
* @author Phillip Webb * @author Phillip Webb
@ -33,17 +33,15 @@ public interface CacheableService<T> {
T cacheSyncNull(Object arg1); T cacheSyncNull(Object arg1);
void invalidate(Object arg1); void evict(Object arg1, Object arg2);
void evictWithException(Object arg1);
void evictEarly(Object arg1); void evictEarly(Object arg1);
void evictAll(Object arg1); void evictAll(Object arg1);
void evictWithException(Object arg1); void evictAllEarly(Object arg1);
void evict(Object arg1, Object arg2);
void invalidateEarly(Object arg1, Object arg2);
T conditional(int field); T conditional(int field);
@ -83,7 +81,6 @@ public interface CacheableService<T> {
T throwUncheckedSync(Object arg1); T throwUncheckedSync(Object arg1);
// multi annotations
T multiCache(Object arg1); T multiCache(Object arg1);
T multiEvict(Object arg1); T multiEvict(Object arg1);

63
spring-aspects/src/test/java/org/springframework/cache/config/DefaultCacheableService.java vendored
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2016 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -25,7 +25,7 @@ import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.Caching; import org.springframework.cache.annotation.Caching;
/** /**
* Simple cacheable service * Simple cacheable service.
* *
* @author Costin Leau * @author Costin Leau
* @author Phillip Webb * @author Phillip Webb
@ -34,12 +34,14 @@ import org.springframework.cache.annotation.Caching;
public class DefaultCacheableService implements CacheableService<Long> { public class DefaultCacheableService implements CacheableService<Long> {
private final AtomicLong counter = new AtomicLong(); private final AtomicLong counter = new AtomicLong();
private final AtomicLong nullInvocations = new AtomicLong(); private final AtomicLong nullInvocations = new AtomicLong();
@Override @Override
@Cacheable("testCache") @Cacheable("testCache")
public Long cache(Object arg1) { public Long cache(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@ -51,7 +53,7 @@ public class DefaultCacheableService implements CacheableService<Long> {
@Override @Override
@Cacheable(cacheNames = "testCache", sync = true) @Cacheable(cacheNames = "testCache", sync = true)
public Long cacheSync(Object arg1) { public Long cacheSync(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@ -61,8 +63,8 @@ public class DefaultCacheableService implements CacheableService<Long> {
} }
@Override @Override
@CacheEvict("testCache") @CacheEvict(cacheNames = "testCache", key = "#p0")
public void invalidate(Object arg1) { public void evict(Object arg1, Object arg2) {
} }
@Override @Override
@ -71,11 +73,6 @@ public class DefaultCacheableService implements CacheableService<Long> {
throw new RuntimeException("exception thrown - evict should NOT occur"); throw new RuntimeException("exception thrown - evict should NOT occur");
} }
@Override
@CacheEvict(cacheNames = "testCache", allEntries = true)
public void evictAll(Object arg1) {
}
@Override @Override
@CacheEvict(cacheNames = "testCache", beforeInvocation = true) @CacheEvict(cacheNames = "testCache", beforeInvocation = true)
public void evictEarly(Object arg1) { public void evictEarly(Object arg1) {
@ -83,26 +80,26 @@ public class DefaultCacheableService implements CacheableService<Long> {
} }
@Override @Override
@CacheEvict(cacheNames = "testCache", key = "#p0") @CacheEvict(cacheNames = "testCache", allEntries = true)
public void evict(Object arg1, Object arg2) { public void evictAll(Object arg1) {
} }
@Override @Override
@CacheEvict(cacheNames = "testCache", key = "#p0", beforeInvocation = true) @CacheEvict(cacheNames = "testCache", allEntries = true, beforeInvocation = true)
public void invalidateEarly(Object arg1, Object arg2) { public void evictAllEarly(Object arg1) {
throw new RuntimeException("exception thrown - evict should still occur"); throw new RuntimeException("exception thrown - evict should still occur");
} }
@Override @Override
@Cacheable(cacheNames = "testCache", condition = "#p0 == 3") @Cacheable(cacheNames = "testCache", condition = "#p0 == 3")
public Long conditional(int classField) { public Long conditional(int classField) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Cacheable(cacheNames = "testCache", sync = true, condition = "#p0 == 3") @Cacheable(cacheNames = "testCache", sync = true, condition = "#p0 == 3")
public Long conditionalSync(int field) { public Long conditionalSync(int classField) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@ -114,55 +111,55 @@ public class DefaultCacheableService implements CacheableService<Long> {
@Override @Override
@Cacheable(cacheNames = "testCache", key = "#p0") @Cacheable(cacheNames = "testCache", key = "#p0")
public Long key(Object arg1, Object arg2) { public Long key(Object arg1, Object arg2) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Cacheable(cacheNames = "testCache") @Cacheable(cacheNames = "testCache")
public Long varArgsKey(Object... args) { public Long varArgsKey(Object... args) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Cacheable(cacheNames = "testCache", key = "#root.methodName") @Cacheable(cacheNames = "testCache", key = "#root.methodName")
public Long name(Object arg1) { public Long name(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Cacheable(cacheNames = "testCache", key = "#root.methodName + #root.method.name + #root.targetClass + #root.target") @Cacheable(cacheNames = "testCache", key = "#root.methodName + #root.method.name + #root.targetClass + #root.target")
public Long rootVars(Object arg1) { public Long rootVars(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Cacheable(cacheNames = "testCache", keyGenerator = "customKeyGenerator") @Cacheable(cacheNames = "testCache", keyGenerator = "customKeyGenerator")
public Long customKeyGenerator(Object arg1) { public Long customKeyGenerator(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Cacheable(cacheNames = "testCache", keyGenerator = "unknownBeanName") @Cacheable(cacheNames = "testCache", keyGenerator = "unknownBeanName")
public Long unknownCustomKeyGenerator(Object arg1) { public Long unknownCustomKeyGenerator(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Cacheable(cacheNames = "testCache", cacheManager = "customCacheManager") @Cacheable(cacheNames = "testCache", cacheManager = "customCacheManager")
public Long customCacheManager(Object arg1) { public Long customCacheManager(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Cacheable(cacheNames = "testCache", cacheManager = "unknownBeanName") @Cacheable(cacheNames = "testCache", cacheManager = "unknownBeanName")
public Long unknownCustomCacheManager(Object arg1) { public Long unknownCustomCacheManager(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@CachePut("testCache") @CachePut("testCache")
public Long update(Object arg1) { public Long update(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@ -174,13 +171,13 @@ public class DefaultCacheableService implements CacheableService<Long> {
@Override @Override
@Cacheable("testCache") @Cacheable("testCache")
public Long nullValue(Object arg1) { public Long nullValue(Object arg1) {
nullInvocations.incrementAndGet(); this.nullInvocations.incrementAndGet();
return null; return null;
} }
@Override @Override
public Number nullInvocations() { public Number nullInvocations() {
return nullInvocations.get(); return this.nullInvocations.get();
} }
@Override @Override
@ -212,25 +209,25 @@ public class DefaultCacheableService implements CacheableService<Long> {
@Override @Override
@Caching(cacheable = { @Cacheable("primary"), @Cacheable("secondary") }) @Caching(cacheable = { @Cacheable("primary"), @Cacheable("secondary") })
public Long multiCache(Object arg1) { public Long multiCache(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames = "secondary", key = "#p0"), @CacheEvict(cacheNames = "primary", key = "#p0 + 'A'") }) @Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames = "secondary", key = "#p0"), @CacheEvict(cacheNames = "primary", key = "#p0 + 'A'") })
public Long multiEvict(Object arg1) { public Long multiEvict(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Caching(cacheable = { @Cacheable(cacheNames = "primary", key = "#root.methodName") }, evict = { @CacheEvict("secondary") }) @Caching(cacheable = { @Cacheable(cacheNames = "primary", key = "#root.methodName") }, evict = { @CacheEvict("secondary") })
public Long multiCacheAndEvict(Object arg1) { public Long multiCacheAndEvict(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override
@Caching(cacheable = { @Cacheable(cacheNames = "primary", condition = "#p0 == 3") }, evict = { @CacheEvict("secondary") }) @Caching(cacheable = { @Cacheable(cacheNames = "primary", condition = "#p0 == 3") }, evict = { @CacheEvict("secondary") })
public Long multiConditionalCacheAndEvict(Object arg1) { public Long multiConditionalCacheAndEvict(Object arg1) {
return counter.getAndIncrement(); return this.counter.getAndIncrement();
} }
@Override @Override

31
spring-context-support/src/test/java/org/springframework/cache/jcache/JCacheEhCacheAnnotationTests.java vendored
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2017 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -39,12 +39,17 @@ import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import org.springframework.tests.transaction.CallCountingTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;
/** /**
* @author Stephane Nicoll * @author Stephane Nicoll
* @author Juergen Hoeller
*/ */
public class JCacheEhCacheAnnotationTests extends AbstractCacheAnnotationTests { public class JCacheEhCacheAnnotationTests extends AbstractCacheAnnotationTests {
private final TransactionTemplate txTemplate = new TransactionTemplate(new CallCountingTransactionManager());
private CacheManager jCacheManager; private CacheManager jCacheManager;
@ -76,6 +81,26 @@ public class JCacheEhCacheAnnotationTests extends AbstractCacheAnnotationTests {
public void testCustomCacheManager() { public void testCustomCacheManager() {
} }
@Test
public void testEvictWithTransaction() {
txTemplate.execute(() -> testEvict(this.cs, false));
}
@Test
public void testEvictEarlyWithTransaction() {
txTemplate.execute(() -> testEvictEarly(this.cs));
}
@Test
public void testEvictAllWithTransaction() {
txTemplate.execute(() -> testEvictAll(this.cs, false));
}
@Test
public void testEvictAllEarlyWithTransaction() {
txTemplate.execute(() -> testEvictAllEarly(this.cs));
}
@Configuration @Configuration
@EnableCaching @EnableCaching
@ -87,7 +112,9 @@ public class JCacheEhCacheAnnotationTests extends AbstractCacheAnnotationTests {
@Override @Override
@Bean @Bean
public org.springframework.cache.CacheManager cacheManager() { public org.springframework.cache.CacheManager cacheManager() {
return new JCacheCacheManager(jCacheManager()); JCacheCacheManager cm = new JCacheCacheManager(jCacheManager());
cm.setTransactionAware(true);
return cm;
} }
@Bean @Bean

309
spring-context/src/test/java/org/springframework/cache/config/AbstractCacheAnnotationTests.java vendored
Unescape View File

@ -79,7 +79,7 @@ public abstract class AbstractCacheAnnotationTests {
} }
public void testCacheable(CacheableService<?> service) throws Exception { public void testCacheable(CacheableService<?> service) {
Object o1 = new Object(); Object o1 = new Object();
Object r1 = service.cache(o1); Object r1 = service.cache(o1);
@ -90,9 +90,9 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(r3).isSameAs(r1); assertThat(r3).isSameAs(r1);
} }
public void testCacheableNull(CacheableService<?> service) throws Exception { public void testCacheableNull(CacheableService<?> service) {
Object o1 = new Object(); Object o1 = new Object();
assertThat((Object) this.cm.getCache("testCache").get(o1)).isNull(); assertThat(this.cm.getCache("testCache").get(o1)).isNull();
Object r1 = service.cacheNull(o1); Object r1 = service.cacheNull(o1);
Object r2 = service.cacheNull(o1); Object r2 = service.cacheNull(o1);
@ -105,7 +105,7 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(r3).as("Cached value should be null").isNull(); assertThat(r3).as("Cached value should be null").isNull();
} }
public void testCacheableSync(CacheableService<?> service) throws Exception { public void testCacheableSync(CacheableService<?> service) {
Object o1 = new Object(); Object o1 = new Object();
Object r1 = service.cacheSync(o1); Object r1 = service.cacheSync(o1);
@ -116,9 +116,9 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(r3).isSameAs(r1); assertThat(r3).isSameAs(r1);
} }
public void testCacheableSyncNull(CacheableService<?> service) throws Exception { public void testCacheableSyncNull(CacheableService<?> service) {
Object o1 = new Object(); Object o1 = new Object();
assertThat((Object) this.cm.getCache("testCache").get(o1)).isNull(); assertThat(this.cm.getCache("testCache").get(o1)).isNull();
Object r1 = service.cacheSyncNull(o1); Object r1 = service.cacheSyncNull(o1);
Object r2 = service.cacheSyncNull(o1); Object r2 = service.cacheSyncNull(o1);
@ -131,47 +131,53 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(r3).as("Cached value should be null").isNull(); assertThat(r3).as("Cached value should be null").isNull();
} }
public void testEvict(CacheableService<?> service) throws Exception { public void testEvict(CacheableService<?> service, boolean successExpected) {
Object o1 = new Object(); Cache cache = this.cm.getCache("testCache");
Object o1 = new Object();
cache.putIfAbsent(o1, -1L);
Object r1 = service.cache(o1); Object r1 = service.cache(o1);
Object r2 = service.cache(o1);
assertThat(r2).isSameAs(r1); service.evict(o1, null);
service.invalidate(o1); if (successExpected) {
Object r3 = service.cache(o1); assertThat(cache.get(o1)).isNull();
Object r4 = service.cache(o1); }
assertThat(r3).isNotSameAs(r1); else {
assertThat(r4).isSameAs(r3); assertThat(cache.get(o1)).isNotNull();
}
Object r2 = service.cache(o1);
if (successExpected) {
assertThat(r2).isNotSameAs(r1);
}
else {
assertThat(r2).isSameAs(r1);
}
} }
public void testEvictEarly(CacheableService<?> service) throws Exception { public void testEvictEarly(CacheableService<?> service) {
Object o1 = new Object(); Cache cache = this.cm.getCache("testCache");
Object o1 = new Object();
cache.putIfAbsent(o1, -1L);
Object r1 = service.cache(o1); Object r1 = service.cache(o1);
Object r2 = service.cache(o1);
assertThat(r2).isSameAs(r1);
try { try {
service.evictEarly(o1); service.evictEarly(o1);
} }
catch (RuntimeException ex) { catch (RuntimeException ex) {
// expected // expected
} }
assertThat(cache.get(o1)).isNull();
Object r3 = service.cache(o1); Object r2 = service.cache(o1);
Object r4 = service.cache(o1); assertThat(r2).isNotSameAs(r1);
assertThat(r3).isNotSameAs(r1);
assertThat(r4).isSameAs(r3);
} }
public void testEvictException(CacheableService<?> service) throws Exception { public void testEvictException(CacheableService<?> service) {
Object o1 = new Object(); Object o1 = new Object();
Object r1 = service.cache(o1); Object r1 = service.cache(o1);
Object r2 = service.cache(o1);
assertThat(r2).isSameAs(r1);
try { try {
service.evictWithException(o1); service.evictWithException(o1);
} }
@ -179,67 +185,95 @@ public abstract class AbstractCacheAnnotationTests {
// expected // expected
} }
// exception occurred, eviction skipped, data should still be in the cache // exception occurred, eviction skipped, data should still be in the cache
Object r3 = service.cache(o1); Object r2 = service.cache(o1);
assertThat(r3).isSameAs(r1); assertThat(r2).isSameAs(r1);
} }
public void testEvictWKey(CacheableService<?> service) throws Exception { public void testEvictWithKey(CacheableService<?> service) {
Object o1 = new Object(); Object o1 = new Object();
Object r1 = service.cache(o1); Object r1 = service.cache(o1);
Object r2 = service.cache(o1);
assertThat(r2).isSameAs(r1);
service.evict(o1, null); service.evict(o1, null);
Object r3 = service.cache(o1); Object r2 = service.cache(o1);
Object r4 = service.cache(o1); assertThat(r2).isNotSameAs(r1);
assertThat(r3).isNotSameAs(r1);
assertThat(r4).isSameAs(r3);
} }
public void testEvictWKeyEarly(CacheableService<?> service) throws Exception { public void testEvictWithKeyEarly(CacheableService<?> service) {
Object o1 = new Object(); Object o1 = new Object();
Object r1 = service.cache(o1); Object r1 = service.cache(o1);
Object r2 = service.cache(o1);
assertThat(r2).isSameAs(r1);
try { try {
service.invalidateEarly(o1, null); service.evictEarly(o1);
} }
catch (Exception ex) { catch (Exception ex) {
// expected // expected
} }
Object r3 = service.cache(o1); Object r2 = service.cache(o1);
Object r4 = service.cache(o1); assertThat(r2).isNotSameAs(r1);
assertThat(r3).isNotSameAs(r1);
assertThat(r4).isSameAs(r3);
} }
public void testEvictAll(CacheableService<?> service) throws Exception { public void testEvictAll(CacheableService<?> service, boolean successExpected) {
Cache cache = this.cm.getCache("testCache");
Object o1 = new Object(); Object o1 = new Object();
Object o2 = new Object();
cache.putIfAbsent(o1, -1L);
cache.putIfAbsent(o2, -2L);
Object r1 = service.cache(o1); Object r1 = service.cache(o1);
Object r2 = service.cache(o1); Object r2 = service.cache(o2);
assertThat(r2).isNotSameAs(r1);
Object o2 = new Object();
Object r10 = service.cache(o2);
assertThat(r2).isSameAs(r1);
assertThat(r10).isNotSameAs(r1);
service.evictAll(new Object()); service.evictAll(new Object());
if (successExpected) {
assertThat(cache.get(o1)).isNull();
assertThat(cache.get(o2)).isNull();
}
else {
assertThat(cache.get(o1)).isNotNull();
assertThat(cache.get(o2)).isNotNull();
}
Object r3 = service.cache(o1);
Object r4 = service.cache(o2);
if (successExpected) {
assertThat(r3).isNotSameAs(r1);
assertThat(r4).isNotSameAs(r2);
}
else {
assertThat(r3).isSameAs(r1);
assertThat(r4).isSameAs(r2);
}
}
public void testEvictAllEarly(CacheableService<?> service) {
Cache cache = this.cm.getCache("testCache"); Cache cache = this.cm.getCache("testCache");
assertThat((Object) cache.get(o1)).isNull();
assertThat((Object) cache.get(o2)).isNull(); Object o1 = new Object();
Object o2 = new Object();
cache.putIfAbsent(o1, -1L);
cache.putIfAbsent(o2, -2L);
Object r1 = service.cache(o1);
Object r2 = service.cache(o2);
assertThat(r2).isNotSameAs(r1);
try {
service.evictAllEarly(new Object());
}
catch (Exception ex) {
// expected
}
assertThat(cache.get(o1)).isNull();
assertThat(cache.get(o2)).isNull();
Object r3 = service.cache(o1); Object r3 = service.cache(o1);
Object r4 = service.cache(o1); Object r4 = service.cache(o2);
assertThat(r3).isNotSameAs(r1); assertThat(r3).isNotSameAs(r1);
assertThat(r4).isSameAs(r3); assertThat(r4).isNotSameAs(r2);
} }
public void testConditionalExpression(CacheableService<?> service) throws Exception { public void testConditionalExpression(CacheableService<?> service) {
Object r1 = service.conditional(4); Object r1 = service.conditional(4);
Object r2 = service.conditional(4); Object r2 = service.conditional(4);
@ -251,7 +285,7 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(r4).isSameAs(r3); assertThat(r4).isSameAs(r3);
} }
public void testConditionalExpressionSync(CacheableService<?> service) throws Exception { public void testConditionalExpressionSync(CacheableService<?> service) {
Object r1 = service.conditionalSync(4); Object r1 = service.conditionalSync(4);
Object r2 = service.conditionalSync(4); Object r2 = service.conditionalSync(4);
@ -263,7 +297,7 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(r4).isSameAs(r3); assertThat(r4).isSameAs(r3);
} }
public void testUnlessExpression(CacheableService<?> service) throws Exception { public void testUnlessExpression(CacheableService<?> service) {
Cache cache = this.cm.getCache("testCache"); Cache cache = this.cm.getCache("testCache");
cache.clear(); cache.clear();
service.unless(10); service.unless(10);
@ -272,7 +306,7 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(cache.get(11)).isNull(); assertThat(cache.get(11)).isNull();
} }
public void testKeyExpression(CacheableService<?> service) throws Exception { public void testKeyExpression(CacheableService<?> service) {
Object r1 = service.key(5, 1); Object r1 = service.key(5, 1);
Object r2 = service.key(5, 2); Object r2 = service.key(5, 2);
@ -284,7 +318,7 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(r4).isNotSameAs(r3); assertThat(r4).isNotSameAs(r3);
} }
public void testVarArgsKey(CacheableService<?> service) throws Exception { public void testVarArgsKey(CacheableService<?> service) {
Object r1 = service.varArgsKey(1, 2, 3); Object r1 = service.varArgsKey(1, 2, 3);
Object r2 = service.varArgsKey(1, 2, 3); Object r2 = service.varArgsKey(1, 2, 3);
@ -297,7 +331,7 @@ public abstract class AbstractCacheAnnotationTests {
} }
public void testNullValue(CacheableService<?> service) throws Exception { public void testNullValue(CacheableService<?> service) {
Object key = new Object(); Object key = new Object();
assertThat(service.nullValue(key)).isNull(); assertThat(service.nullValue(key)).isNull();
int nr = service.nullInvocations().intValue(); int nr = service.nullInvocations().intValue();
@ -307,7 +341,7 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(service.nullInvocations().intValue()).isEqualTo(nr + 1); assertThat(service.nullInvocations().intValue()).isEqualTo(nr + 1);
} }
public void testMethodName(CacheableService<?> service, String keyName) throws Exception { public void testMethodName(CacheableService<?> service, String keyName) {
Object key = new Object(); Object key = new Object();
Object r1 = service.name(key); Object r1 = service.name(key);
assertThat(service.name(key)).isSameAs(r1); assertThat(service.name(key)).isSameAs(r1);
@ -326,27 +360,27 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(cache.get(expectedKey)).isNotNull(); assertThat(cache.get(expectedKey)).isNotNull();
} }
public void testCheckedThrowable(CacheableService<?> service) throws Exception { public void testCheckedThrowable(CacheableService<?> service) {
String arg = UUID.randomUUID().toString(); String arg = UUID.randomUUID().toString();
assertThatIOException().isThrownBy(() -> assertThatIOException().isThrownBy(() ->
service.throwChecked(arg)) service.throwChecked(arg))
.withMessage(arg); .withMessage(arg);
} }
public void testUncheckedThrowable(CacheableService<?> service) throws Exception { public void testUncheckedThrowable(CacheableService<?> service) {
assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() -> assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() ->
service.throwUnchecked(1L)) service.throwUnchecked(1L))
.withMessage("1"); .withMessage("1");
} }
public void testCheckedThrowableSync(CacheableService<?> service) throws Exception { public void testCheckedThrowableSync(CacheableService<?> service) {
String arg = UUID.randomUUID().toString(); String arg = UUID.randomUUID().toString();
assertThatIOException().isThrownBy(() -> assertThatIOException().isThrownBy(() ->
service.throwCheckedSync(arg)) service.throwCheckedSync(arg))
.withMessage(arg); .withMessage(arg);
} }
public void testUncheckedThrowableSync(CacheableService<?> service) throws Exception { public void testUncheckedThrowableSync(CacheableService<?> service) {
assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() -> assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() ->
service.throwUncheckedSync(1L)) service.throwUncheckedSync(1L))
.withMessage("1"); .withMessage("1");
@ -360,12 +394,12 @@ public abstract class AbstractCacheAnnotationTests {
public void testCacheUpdate(CacheableService<?> service) { public void testCacheUpdate(CacheableService<?> service) {
Object o = new Object(); Object o = new Object();
Cache cache = this.cm.getCache("testCache"); Cache cache = this.cm.getCache("testCache");
assertThat((Object) cache.get(o)).isNull(); assertThat(cache.get(o)).isNull();
Object r1 = service.update(o); Object r1 = service.update(o);
assertThat(cache.get(o).get()).isSameAs(r1); assertThat(cache.get(o).get()).isSameAs(r1);
o = new Object(); o = new Object();
assertThat((Object) cache.get(o)).isNull(); assertThat(cache.get(o)).isNull();
Object r2 = service.update(o); Object r2 = service.update(o);
assertThat(cache.get(o).get()).isSameAs(r2); assertThat(cache.get(o).get()).isSameAs(r2);
} }
@ -389,8 +423,8 @@ public abstract class AbstractCacheAnnotationTests {
Cache primary = this.cm.getCache("primary"); Cache primary = this.cm.getCache("primary");
Cache secondary = this.cm.getCache("secondary"); Cache secondary = this.cm.getCache("secondary");
assertThat((Object) primary.get(o1)).isNull(); assertThat(primary.get(o1)).isNull();
assertThat((Object) secondary.get(o1)).isNull(); assertThat(secondary.get(o1)).isNull();
Object r1 = service.multiCache(o1); Object r1 = service.multiCache(o1);
assertThat(primary.get(o1).get()).isSameAs(r1); assertThat(primary.get(o1).get()).isSameAs(r1);
assertThat(secondary.get(o1).get()).isSameAs(r1); assertThat(secondary.get(o1).get()).isSameAs(r1);
@ -401,8 +435,8 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(r2).isSameAs(r1); assertThat(r2).isSameAs(r1);
assertThat(r3).isSameAs(r1); assertThat(r3).isSameAs(r1);
assertThat((Object) primary.get(o2)).isNull(); assertThat(primary.get(o2)).isNull();
assertThat((Object) secondary.get(o2)).isNull(); assertThat(secondary.get(o2)).isNull();
Object r4 = service.multiCache(o2); Object r4 = service.multiCache(o2);
assertThat(primary.get(o2).get()).isSameAs(r4); assertThat(primary.get(o2).get()).isSameAs(r4);
assertThat(secondary.get(o2).get()).isSameAs(r4); assertThat(secondary.get(o2).get()).isSameAs(r4);
@ -425,9 +459,9 @@ public abstract class AbstractCacheAnnotationTests {
assertThat(secondary.get(o1).get()).isSameAs(r1); assertThat(secondary.get(o1).get()).isSameAs(r1);
service.multiEvict(o1); service.multiEvict(o1);
assertThat((Object) primary.get(o1)).isNull(); assertThat(primary.get(o1)).isNull();
assertThat((Object) secondary.get(o1)).isNull(); assertThat(secondary.get(o1)).isNull();
assertThat((Object) primary.get(o2)).isNull(); assertThat(primary.get(o2)).isNull();
Object r3 = service.multiCache(o1); Object r3 = service.multiCache(o1);
Object r4 = service.multiCache(o1); Object r4 = service.multiCache(o1);
@ -444,26 +478,26 @@ public abstract class AbstractCacheAnnotationTests {
Cache primary = this.cm.getCache("primary"); Cache primary = this.cm.getCache("primary");
Cache secondary = this.cm.getCache("secondary"); Cache secondary = this.cm.getCache("secondary");
assertThat((Object) primary.get(o)).isNull(); assertThat(primary.get(o)).isNull();
assertThat((Object) secondary.get(o)).isNull(); assertThat(secondary.get(o)).isNull();
Object r1 = service.multiUpdate(o); Object r1 = service.multiUpdate(o);
assertThat(primary.get(o).get()).isSameAs(r1); assertThat(primary.get(o).get()).isSameAs(r1);
assertThat(secondary.get(o).get()).isSameAs(r1); assertThat(secondary.get(o).get()).isSameAs(r1);
o = 2; o = 2;
assertThat((Object) primary.get(o)).isNull(); assertThat(primary.get(o)).isNull();
assertThat((Object) secondary.get(o)).isNull(); assertThat(secondary.get(o)).isNull();
Object r2 = service.multiUpdate(o); Object r2 = service.multiUpdate(o);
assertThat(primary.get(o).get()).isSameAs(r2); assertThat(primary.get(o).get()).isSameAs(r2);
assertThat(secondary.get(o).get()).isSameAs(r2); assertThat(secondary.get(o).get()).isSameAs(r2);
} }
public void testPutRefersToResult(CacheableService<?> service) throws Exception { public void testPutRefersToResult(CacheableService<?> service) {
Long id = Long.MIN_VALUE; Long id = Long.MIN_VALUE;
TestEntity entity = new TestEntity(); TestEntity entity = new TestEntity();
Cache primary = this.cm.getCache("primary"); Cache primary = this.cm.getCache("primary");
assertThat((Object) primary.get(id)).isNull(); assertThat(primary.get(id)).isNull();
assertThat((Object) entity.getId()).isNull(); assertThat(entity.getId()).isNull();
service.putRefersToResult(entity); service.putRefersToResult(entity);
assertThat(primary.get(id).get()).isSameAs(entity); assertThat(primary.get(id).get()).isSameAs(entity);
} }
@ -503,7 +537,7 @@ public abstract class AbstractCacheAnnotationTests {
Object r3 = service.multiConditionalCacheAndEvict(key); Object r3 = service.multiConditionalCacheAndEvict(key);
assertThat(!r1.equals(r3)).isTrue(); assertThat(!r1.equals(r3)).isTrue();
assertThat((Object) primary.get(key)).isNull(); assertThat(primary.get(key)).isNull();
Object key2 = 3; Object key2 = 3;
Object r2 = service.multiConditionalCacheAndEvict(key2); Object r2 = service.multiConditionalCacheAndEvict(key2);
@ -515,127 +549,132 @@ public abstract class AbstractCacheAnnotationTests {
} }
@Test @Test
public void testCacheable() throws Exception { public void testCacheable() {
testCacheable(this.cs); testCacheable(this.cs);
} }
@Test @Test
public void testCacheableNull() throws Exception { public void testCacheableNull() {
testCacheableNull(this.cs); testCacheableNull(this.cs);
} }
@Test @Test
public void testCacheableSync() throws Exception { public void testCacheableSync() {
testCacheableSync(this.cs); testCacheableSync(this.cs);
} }
@Test @Test
public void testCacheableSyncNull() throws Exception { public void testCacheableSyncNull() {
testCacheableSyncNull(this.cs); testCacheableSyncNull(this.cs);
} }
@Test @Test
public void testInvalidate() throws Exception { public void testEvict() {
testEvict(this.cs); testEvict(this.cs, true);
} }
@Test @Test
public void testEarlyInvalidate() throws Exception { public void testEvictEarly() {
testEvictEarly(this.cs); testEvictEarly(this.cs);
} }
@Test @Test
public void testEvictWithException() throws Exception { public void testEvictWithException() {
testEvictException(this.cs); testEvictException(this.cs);
} }
@Test @Test
public void testEvictAll() throws Exception { public void testEvictAll() {
testEvictAll(this.cs); testEvictAll(this.cs, true);
}
@Test
public void testEvictAllEarly() {
testEvictAllEarly(this.cs);
} }
@Test @Test
public void testInvalidateWithKey() throws Exception { public void testEvictWithKey() {
testEvictWKey(this.cs); testEvictWithKey(this.cs);
} }
@Test @Test
public void testEarlyInvalidateWithKey() throws Exception { public void testEvictWithKeyEarly() {
testEvictWKeyEarly(this.cs); testEvictWithKeyEarly(this.cs);
} }
@Test @Test
public void testConditionalExpression() throws Exception { public void testConditionalExpression() {
testConditionalExpression(this.cs); testConditionalExpression(this.cs);
} }
@Test @Test
public void testConditionalExpressionSync() throws Exception { public void testConditionalExpressionSync() {
testConditionalExpressionSync(this.cs); testConditionalExpressionSync(this.cs);
} }
@Test @Test
public void testUnlessExpression() throws Exception { public void testUnlessExpression() {
testUnlessExpression(this.cs); testUnlessExpression(this.cs);
} }
@Test @Test
public void testClassCacheUnlessExpression() throws Exception { public void testClassCacheUnlessExpression() {
testUnlessExpression(this.cs); testUnlessExpression(this.cs);
} }
@Test @Test
public void testKeyExpression() throws Exception { public void testKeyExpression() {
testKeyExpression(this.cs); testKeyExpression(this.cs);
} }
@Test @Test
public void testVarArgsKey() throws Exception { public void testVarArgsKey() {
testVarArgsKey(this.cs); testVarArgsKey(this.cs);
} }
@Test @Test
public void testClassCacheCacheable() throws Exception { public void testClassCacheCacheable() {
testCacheable(this.ccs); testCacheable(this.ccs);
} }
@Test @Test
public void testClassCacheInvalidate() throws Exception { public void testClassCacheEvict() {
testEvict(this.ccs); testEvict(this.ccs, true);
} }
@Test @Test
public void testClassEarlyInvalidate() throws Exception { public void testClassEvictEarly() {
testEvictEarly(this.ccs); testEvictEarly(this.ccs);
} }
@Test @Test
public void testClassEvictAll() throws Exception { public void testClassEvictAll() {
testEvictAll(this.ccs); testEvictAll(this.ccs, true);
} }
@Test @Test
public void testClassEvictWithException() throws Exception { public void testClassEvictWithException() {
testEvictException(this.ccs); testEvictException(this.ccs);
} }
@Test @Test
public void testClassCacheInvalidateWKey() throws Exception { public void testClassCacheEvictWithWKey() {
testEvictWKey(this.ccs); testEvictWithKey(this.ccs);
} }
@Test @Test
public void testClassEarlyInvalidateWithKey() throws Exception { public void testClassEvictWithKeyEarly() {
testEvictWKeyEarly(this.ccs); testEvictWithKeyEarly(this.ccs);
} }
@Test @Test
public void testNullValue() throws Exception { public void testNullValue() {
testNullValue(this.cs); testNullValue(this.cs);
} }
@Test @Test
public void testClassNullValue() throws Exception { public void testClassNullValue() {
Object key = new Object(); Object key = new Object();
assertThat(this.ccs.nullValue(key)).isNull(); assertThat(this.ccs.nullValue(key)).isNull();
int nr = this.ccs.nullInvocations().intValue(); int nr = this.ccs.nullInvocations().intValue();
@ -648,22 +687,22 @@ public abstract class AbstractCacheAnnotationTests {
} }
@Test @Test
public void testMethodName() throws Exception { public void testMethodName() {
testMethodName(this.cs, "name"); testMethodName(this.cs, "name");
} }
@Test @Test
public void testClassMethodName() throws Exception { public void testClassMethodName() {
testMethodName(this.ccs, "nametestCache"); testMethodName(this.ccs, "nametestCache");
} }
@Test @Test
public void testRootVars() throws Exception { public void testRootVars() {
testRootVars(this.cs); testRootVars(this.cs);
} }
@Test @Test
public void testClassRootVars() throws Exception { public void testClassRootVars() {
testRootVars(this.ccs); testRootVars(this.ccs);
} }
@ -704,52 +743,52 @@ public abstract class AbstractCacheAnnotationTests {
} }
@Test @Test
public void testNullArg() throws Exception { public void testNullArg() {
testNullArg(this.cs); testNullArg(this.cs);
} }
@Test @Test
public void testClassNullArg() throws Exception { public void testClassNullArg() {
testNullArg(this.ccs); testNullArg(this.ccs);
} }
@Test @Test
public void testCheckedException() throws Exception { public void testCheckedException() {
testCheckedThrowable(this.cs); testCheckedThrowable(this.cs);
} }
@Test @Test
public void testClassCheckedException() throws Exception { public void testClassCheckedException() {
testCheckedThrowable(this.ccs); testCheckedThrowable(this.ccs);
} }
@Test @Test
public void testCheckedExceptionSync() throws Exception { public void testCheckedExceptionSync() {
testCheckedThrowableSync(this.cs); testCheckedThrowableSync(this.cs);
} }
@Test @Test
public void testClassCheckedExceptionSync() throws Exception { public void testClassCheckedExceptionSync() {
testCheckedThrowableSync(this.ccs); testCheckedThrowableSync(this.ccs);
} }
@Test @Test
public void testUncheckedException() throws Exception { public void testUncheckedException() {
testUncheckedThrowable(this.cs); testUncheckedThrowable(this.cs);
} }
@Test @Test
public void testClassUncheckedException() throws Exception { public void testClassUncheckedException() {
testUncheckedThrowable(this.ccs); testUncheckedThrowable(this.ccs);
} }
@Test @Test
public void testUncheckedExceptionSync() throws Exception { public void testUncheckedExceptionSync() {
testUncheckedThrowableSync(this.cs); testUncheckedThrowableSync(this.cs);
} }
@Test @Test
public void testClassUncheckedExceptionSync() throws Exception { public void testClassUncheckedExceptionSync() {
testUncheckedThrowableSync(this.ccs); testUncheckedThrowableSync(this.ccs);
} }
@ -804,12 +843,12 @@ public abstract class AbstractCacheAnnotationTests {
} }
@Test @Test
public void testPutRefersToResult() throws Exception { public void testPutRefersToResult() {
testPutRefersToResult(this.cs); testPutRefersToResult(this.cs);
} }
@Test @Test
public void testClassPutRefersToResult() throws Exception { public void testClassPutRefersToResult() {
testPutRefersToResult(this.ccs); testPutRefersToResult(this.ccs);
} }

21
spring-context/src/test/java/org/springframework/cache/config/AnnotatedClassCacheableService.java vendored
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2016 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -36,6 +36,7 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
public static final AtomicLong nullInvocations = new AtomicLong(); public static final AtomicLong nullInvocations = new AtomicLong();
@Override @Override
public Object cache(Object arg1) { public Object cache(Object arg1) {
return this.counter.getAndIncrement(); return this.counter.getAndIncrement();
@ -75,8 +76,8 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
} }
@Override @Override
@CacheEvict("testCache") @CacheEvict(cacheNames = "testCache", key = "#p0")
public void invalidate(Object arg1) { public void evict(Object arg1, Object arg2) {
} }
@Override @Override
@ -85,11 +86,6 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
throw new RuntimeException("exception thrown - evict should NOT occur"); throw new RuntimeException("exception thrown - evict should NOT occur");
} }
@Override
@CacheEvict(cacheNames = "testCache", allEntries = true)
public void evictAll(Object arg1) {
}
@Override @Override
@CacheEvict(cacheNames = "testCache", beforeInvocation = true) @CacheEvict(cacheNames = "testCache", beforeInvocation = true)
public void evictEarly(Object arg1) { public void evictEarly(Object arg1) {
@ -97,13 +93,13 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
} }
@Override @Override
@CacheEvict(cacheNames = "testCache", key = "#p0") @CacheEvict(cacheNames = "testCache", allEntries = true)
public void evict(Object arg1, Object arg2) { public void evictAll(Object arg1) {
} }
@Override @Override
@CacheEvict(cacheNames = "testCache", key = "#p0", beforeInvocation = true) @CacheEvict(cacheNames = "testCache", allEntries = true, beforeInvocation = true)
public void invalidateEarly(Object arg1, Object arg2) { public void evictAllEarly(Object arg1) {
throw new RuntimeException("exception thrown - evict should still occur"); throw new RuntimeException("exception thrown - evict should still occur");
} }
@ -238,4 +234,5 @@ public class AnnotatedClassCacheableService implements CacheableService<Object>
arg1.setId(Long.MIN_VALUE); arg1.setId(Long.MIN_VALUE);
return arg1; return arg1;
} }
} }

2
spring-context/src/test/java/org/springframework/cache/config/CacheAdviceNamespaceTests.java vendored
Unescape View File

@ -37,7 +37,7 @@ public class CacheAdviceNamespaceTests extends AbstractCacheAnnotationTests {
} }
@Test @Test
public void testKeyStrategy() throws Exception { public void testKeyStrategy() {
CacheInterceptor bean = this.ctx.getBean("cacheAdviceClass", CacheInterceptor.class); CacheInterceptor bean = this.ctx.getBean("cacheAdviceClass", CacheInterceptor.class);
assertThat(bean.getKeyGenerator()).isSameAs(this.ctx.getBean("keyGenerator")); assertThat(bean.getKeyGenerator()).isSameAs(this.ctx.getBean("keyGenerator"));
} }

12
spring-context/src/test/java/org/springframework/cache/config/CacheableService.java vendored
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2017 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -33,17 +33,15 @@ public interface CacheableService<T> {
T cacheSyncNull(Object arg1); T cacheSyncNull(Object arg1);
void invalidate(Object arg1); void evict(Object arg1, Object arg2);
void evictWithException(Object arg1);
void evictEarly(Object arg1); void evictEarly(Object arg1);
void evictAll(Object arg1); void evictAll(Object arg1);
void evictWithException(Object arg1); void evictAllEarly(Object arg1);
void evict(Object arg1, Object arg2);
void invalidateEarly(Object arg1, Object arg2);
T conditional(int field); T conditional(int field);

19
spring-context/src/test/java/org/springframework/cache/config/DefaultCacheableService.java vendored
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2017 the original author or authors. * Copyright 2002-2019 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -63,8 +63,8 @@ public class DefaultCacheableService implements CacheableService<Long> {
} }
@Override @Override
@CacheEvict("testCache") @CacheEvict(cacheNames = "testCache", key = "#p0")
public void invalidate(Object arg1) { public void evict(Object arg1, Object arg2) {
} }
@Override @Override
@ -73,11 +73,6 @@ public class DefaultCacheableService implements CacheableService<Long> {
throw new RuntimeException("exception thrown - evict should NOT occur"); throw new RuntimeException("exception thrown - evict should NOT occur");
} }
@Override
@CacheEvict(cacheNames = "testCache", allEntries = true)
public void evictAll(Object arg1) {
}
@Override @Override
@CacheEvict(cacheNames = "testCache", beforeInvocation = true) @CacheEvict(cacheNames = "testCache", beforeInvocation = true)
public void evictEarly(Object arg1) { public void evictEarly(Object arg1) {
@ -85,13 +80,13 @@ public class DefaultCacheableService implements CacheableService<Long> {
} }
@Override @Override
@CacheEvict(cacheNames = "testCache", key = "#p0") @CacheEvict(cacheNames = "testCache", allEntries = true)
public void evict(Object arg1, Object arg2) { public void evictAll(Object arg1) {
} }
@Override @Override
@CacheEvict(cacheNames = "testCache", key = "#p0", beforeInvocation = true) @CacheEvict(cacheNames = "testCache", allEntries = true, beforeInvocation = true)
public void invalidateEarly(Object arg1, Object arg2) { public void evictAllEarly(Object arg1) {
throw new RuntimeException("exception thrown - evict should still occur"); throw new RuntimeException("exception thrown - evict should still occur");
} }

3
spring-context/src/test/resources/org/springframework/cache/config/cache-advice.xml vendored
Unescape View File

@ -27,12 +27,11 @@
<cache:cacheable method="nullValue" cache="testCache"/> <cache:cacheable method="nullValue" cache="testCache"/>
</cache:caching> </cache:caching>
<cache:caching> <cache:caching>
<cache:cache-evict method="invalidate" cache="testCache"/>
<cache:cache-evict method="evict" key="#p0" cache="testCache"/> <cache:cache-evict method="evict" key="#p0" cache="testCache"/>
<cache:cache-evict method="evictWithException" cache="testCache"/> <cache:cache-evict method="evictWithException" cache="testCache"/>
<cache:cache-evict method="evictEarly" cache="testCache" before-invocation="true"/> <cache:cache-evict method="evictEarly" cache="testCache" before-invocation="true"/>
<cache:cache-evict method="invalidateEarly" key="#p0" cache="testCache" before-invocation="true"/>
<cache:cache-evict method="evictAll" cache="testCache" all-entries="true"/> <cache:cache-evict method="evictAll" cache="testCache" all-entries="true"/>
<cache:cache-evict method="evictAllEarly" cache="testCache" all-entries="true" before-invocation="true"/>
</cache:caching> </cache:caching>
<cache:caching cache="testCache"> <cache:caching cache="testCache">
<cache:cache-put method="update"/> <cache:cache-put method="update"/>

Write Preview
Loading…
Cancel
Save