Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Make DeferredResult more usable and testable

Browse Source 
DeferredResult now has a setErrorResult method that can be set to an
Exception or an error object, error view, etc.

The new isSetOrExpired() method can be used to check pro-actively if
the DeferredResult is still usable or not.

The setDeferredResultHandler method is now public so tests may use it.

Issue: SPR-9690, SPR-9689
This commit is contained in:
Rossen Stoyanchev
2012-08-16 00:12:23 -04:00
parent 3b9833c538
commit 4407f6a4c0
9 changed files with 190 additions and 218 deletions
Download Patch File Download Diff File Expand all files Collapse all files

118
spring-web/src/test/java/org/springframework/web/context/request/async/DeferredResultTests.java
View File

@@ -17,16 +17,13 @@
package org.springframework.web.context.request.async;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.reset;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
import org.springframework.web.context.request.async.DeferredResult;
import org.springframework.web.context.request.async.StaleAsyncWebRequestException;
import org.springframework.web.context.request.async.DeferredResult.DeferredResultHandler;
/**
@@ -37,79 +34,96 @@ import org.springframework.web.context.request.async.DeferredResult.DeferredResu
public class DeferredResultTests {
@Test
public void set() {
DeferredResultHandler resultHandler = createMock(DeferredResultHandler.class);
DeferredResult<String> deferredResult = new DeferredResult<String>();
deferredResult.init(resultHandler);
public void setResult() {
DeferredResultHandler handler = createMock(DeferredResultHandler.class);
handler.handleResult("hello");
replay(handler);
resultHandler.handle("foo");
replay(resultHandler);
DeferredResult<String> result = new DeferredResult<String>();
result.setResultHandler(handler);
deferredResult.set("foo");
assertTrue(result.setResult("hello"));
verify(resultHandler);
verify(handler);
}
@Test
public void getTimeoutHandler() {
assertNull(new DeferredResult<String>().getTimeoutHandler());
assertNotNull(new DeferredResult<String>("foo").getTimeoutHandler());
public void setResultTwice() {
DeferredResultHandler handler = createMock(DeferredResultHandler.class);
handler.handleResult("hello");
replay(handler);
DeferredResult<String> result = new DeferredResult<String>();
result.setResultHandler(handler);
assertTrue(result.setResult("hello"));
assertFalse(result.setResult("hi"));
verify(handler);
}
@Test
public void handleTimeout() {
DeferredResultHandler resultHandler = createMock(DeferredResultHandler.class);
resultHandler.handle("foo");
replay(resultHandler);
public void setResultWithException() {
DeferredResultHandler handler = createMock(DeferredResultHandler.class);
handler.handleResult("hello");
expectLastCall().andThrow(new IllegalStateException());
replay(handler);
DeferredResult<String> deferredResult = new DeferredResult<String>("foo");
deferredResult.init(resultHandler);
DeferredResult<String> result = new DeferredResult<String>();
result.setResultHandler(handler);
deferredResult.getTimeoutHandler().run();
assertFalse(result.setResult("hello"));
verify(resultHandler);
verify(handler);
}
@Test
public void setAfterTimeoutValueUsed() {
DeferredResultHandler resultHandler = createMock(DeferredResultHandler.class);
resultHandler.handle("foo");
replay(resultHandler);
public void isSetOrExpired() {
DeferredResultHandler handler = createMock(DeferredResultHandler.class);
handler.handleResult("hello");
replay(handler);
DeferredResult<String> deferredResult = new DeferredResult<String>("foo");
deferredResult.init(resultHandler);
DeferredResult<String> result = new DeferredResult<String>();
result.setResultHandler(handler);
deferredResult.getTimeoutHandler().run();
assertFalse(result.isSetOrExpired());
verify(resultHandler);
result.setResult("hello");
try {
deferredResult.set("foo");
fail("Expected exception");
}
catch (StaleAsyncWebRequestException ex) {
// expected
}
assertTrue(result.isSetOrExpired());
verify(handler);
}
@Test
public void setBeforeTimeoutValueUsed() {
DeferredResultHandler resultHandler = createMock(DeferredResultHandler.class);
resultHandler.handle("foo");
replay(resultHandler);
public void setExpired() {
DeferredResult<String> result = new DeferredResult<String>();
assertFalse(result.isSetOrExpired());
DeferredResult<String> deferredResult = new DeferredResult<String>("foo");
deferredResult.init(resultHandler);
deferredResult.set("foo");
result.setExpired();
assertTrue(result.isSetOrExpired());
assertFalse(result.setResult("hello"));
}
verify(resultHandler);
@Test
public void hasTimeout() {
assertFalse(new DeferredResult<String>().hasTimeoutResult());
assertTrue(new DeferredResult<String>("timed out").hasTimeoutResult());
}
reset(resultHandler);
replay(resultHandler);
@Test
public void applyTimeoutResult() {
DeferredResultHandler handler = createMock(DeferredResultHandler.class);
handler.handleResult("timed out");
replay(handler);
deferredResult.getTimeoutHandler().run();
DeferredResult<String> result = new DeferredResult<String>("timed out");
result.setResultHandler(handler);
verify(resultHandler);
assertTrue(result.applyTimeoutResult());
assertFalse("Shouldn't be able to set result after timeout", result.setResult("hello"));
verify(handler);
}
}

8
spring-web/src/test/java/org/springframework/web/context/request/async/WebAsyncManagerTests.java
View File

@@ -141,17 +141,17 @@ public class WebAsyncManagerTests {
assertTrue(this.asyncManager.isConcurrentHandlingStarted());
deferredResult.set(25);
deferredResult.setResult(25);
assertEquals(25, this.asyncManager.getConcurrentResult());
}
@Test(expected=StaleAsyncWebRequestException.class)
public void startDeferredResultProcessing_staleRequest() throws Exception {
@Test
public void startDeferredResultProcessingStaleRequest() throws Exception {
DeferredResult<Integer> deferredResult = new DeferredResult<Integer>();
this.asyncManager.startDeferredResultProcessing(deferredResult);
this.stubAsyncWebRequest.setAsyncComplete(true);
deferredResult.set(1);
assertFalse(deferredResult.setResult(1));
}
@Test