@Test public void startDeferredResultProcessingErrorAndResumeWithDefaultResult() throws Exception { Exception e = new Exception(); DeferredResult<Throwable> deferredResult = new DeferredResult<>(null, e); this.asyncManager.startDeferredResultProcessing(deferredResult); AsyncEvent event = new AsyncEvent(new MockAsyncContext(this.servletRequest, this.servletResponse), e); this.asyncWebRequest.onError(event); assertTrue(this.asyncManager.hasConcurrentResult()); assertEquals(e, this.asyncManager.getConcurrentResult()); assertEquals("/test", ((MockAsyncContext) this.servletRequest.getAsyncContext()).getDispatchedPath()); }
private void testDeferredResultSubscriber(Object returnValue, Class<?> asyncType, ResolvableType elementType, Runnable produceTask, Object expected) throws Exception { ResponseBodyEmitter emitter = handleValue(returnValue, asyncType, elementType); assertNull(emitter); assertTrue(this.servletRequest.isAsyncStarted()); assertFalse(WebAsyncUtils.getAsyncManager(this.webRequest).hasConcurrentResult()); produceTask.run(); assertTrue(WebAsyncUtils.getAsyncManager(this.webRequest).hasConcurrentResult()); assertEquals(expected, WebAsyncUtils.getAsyncManager(this.webRequest).getConcurrentResult()); resetRequest(); }
private void testHandle(Object returnValue, Class<?> asyncType, Runnable setResultTask, Object expectedValue) throws Exception { ModelAndViewContainer mavContainer = new ModelAndViewContainer(); MethodParameter returnType = on(TestController.class).resolveReturnType(asyncType, String.class); this.handler.handleReturnValue(returnValue, returnType, mavContainer, this.webRequest); assertTrue(this.request.isAsyncStarted()); assertFalse(WebAsyncUtils.getAsyncManager(this.webRequest).hasConcurrentResult()); setResultTask.run(); assertTrue(WebAsyncUtils.getAsyncManager(this.webRequest).hasConcurrentResult()); assertEquals(expectedValue, WebAsyncUtils.getAsyncManager(this.webRequest).getConcurrentResult()); }
@Test public void startDeferredResultProcessingTimeoutAndResumeWithDefaultResult() throws Exception { DeferredResult<Integer> deferredResult = new DeferredResult<>(null, 23); this.asyncManager.startDeferredResultProcessing(deferredResult); AsyncEvent event = null; this.asyncWebRequest.onTimeout(event); assertTrue(this.asyncManager.hasConcurrentResult()); assertEquals(23, this.asyncManager.getConcurrentResult()); assertEquals("/test", ((MockAsyncContext) this.servletRequest.getAsyncContext()).getDispatchedPath()); }
@Test public void startDeferredResultProcessingPreProcessException() throws Exception { DeferredResult<Integer> deferredResult = new DeferredResult<>(); Exception exception = new Exception(); DeferredResultProcessingInterceptor interceptor = mock(DeferredResultProcessingInterceptor.class); willThrow(exception).given(interceptor).preProcess(this.asyncWebRequest, deferredResult); setupDefaultAsyncScenario(); this.asyncManager.registerDeferredResultInterceptor("interceptor", interceptor); this.asyncManager.startDeferredResultProcessing(deferredResult); deferredResult.setResult(25); assertEquals(exception, this.asyncManager.getConcurrentResult()); verifyDefaultAsyncScenario(); verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, deferredResult); }
@Test public void startDeferredResultProcessingErrorAndResumeThroughCallback() throws Exception { final DeferredResult<Throwable> deferredResult = new DeferredResult<>(); deferredResult.onError(new Consumer<Throwable>() { @Override public void accept(Throwable t) { deferredResult.setResult(t); } }); this.asyncManager.startDeferredResultProcessing(deferredResult); Exception e = new Exception(); AsyncEvent event = new AsyncEvent(new MockAsyncContext(this.servletRequest, this.servletResponse), e); this.asyncWebRequest.onError(event); assertTrue(this.asyncManager.hasConcurrentResult()); assertEquals(e, this.asyncManager.getConcurrentResult()); assertEquals("/test", ((MockAsyncContext) this.servletRequest.getAsyncContext()).getDispatchedPath()); }
@Test public void startCallableProcessingPreProcessException() throws Exception { Callable<Object> task = new StubCallable(21); Exception exception = new Exception(); CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class); willThrow(exception).given(interceptor).preProcess(this.asyncWebRequest, task); setupDefaultAsyncScenario(); this.asyncManager.registerCallableInterceptor("interceptor", interceptor); this.asyncManager.startCallableProcessing(task); assertTrue(this.asyncManager.hasConcurrentResult()); assertEquals(exception, this.asyncManager.getConcurrentResult()); verifyDefaultAsyncScenario(); verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, task); }
@Test public void startDeferredResultProcessingPostProcessException() throws Exception { DeferredResult<Integer> deferredResult = new DeferredResult<>(); Exception exception = new Exception(); DeferredResultProcessingInterceptor interceptor = mock(DeferredResultProcessingInterceptor.class); willThrow(exception).given(interceptor).postProcess(this.asyncWebRequest, deferredResult, 25); setupDefaultAsyncScenario(); this.asyncManager.registerDeferredResultInterceptor("interceptor", interceptor); this.asyncManager.startDeferredResultProcessing(deferredResult); deferredResult.setResult(25); assertEquals(exception, this.asyncManager.getConcurrentResult()); verifyDefaultAsyncScenario(); verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, deferredResult); verify(interceptor).preProcess(this.asyncWebRequest, deferredResult); }
@Test public void startCallableProcessingAfterException() throws Exception { StubCallable callable = new StubCallable(); Exception exception = new Exception(); CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class); Exception e = new Exception(); given(interceptor.handleError(this.asyncWebRequest, callable, e)).willThrow(exception); this.asyncManager.registerCallableInterceptor("errorInterceptor", interceptor); this.asyncManager.startCallableProcessing(callable); AsyncEvent event = new AsyncEvent(new MockAsyncContext(this.servletRequest, this.servletResponse), e); this.asyncWebRequest.onError(event); assertTrue(this.asyncManager.hasConcurrentResult()); assertEquals(exception, this.asyncManager.getConcurrentResult()); assertEquals("/test", ((MockAsyncContext) this.servletRequest.getAsyncContext()).getDispatchedPath()); verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, callable); }
@Test public void startDeferredResultProcessingTimeoutAndResumeThroughCallback() throws Exception { final DeferredResult<Integer> deferredResult = new DeferredResult<>(); deferredResult.onTimeout(new Runnable() { @Override public void run() { deferredResult.setResult(23); } }); this.asyncManager.startDeferredResultProcessing(deferredResult); AsyncEvent event = null; this.asyncWebRequest.onTimeout(event); assertTrue(this.asyncManager.hasConcurrentResult()); assertEquals(23, this.asyncManager.getConcurrentResult()); assertEquals("/test", ((MockAsyncContext) this.servletRequest.getAsyncContext()).getDispatchedPath()); }
@Test public void startCallableProcessingCallableException() throws Exception { Exception concurrentResult = new Exception(); Callable<Object> task = new StubCallable(concurrentResult); CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class); setupDefaultAsyncScenario(); this.asyncManager.registerCallableInterceptor("interceptor", interceptor); this.asyncManager.startCallableProcessing(task); assertTrue(this.asyncManager.hasConcurrentResult()); assertEquals(concurrentResult, this.asyncManager.getConcurrentResult()); verifyDefaultAsyncScenario(); verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, task); verify(interceptor).preProcess(this.asyncWebRequest, task); verify(interceptor).postProcess(this.asyncWebRequest, task, concurrentResult); }
@Test public void startCallableProcessingTimeoutAndComplete() throws Exception { StubCallable callable = new StubCallable(); CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class); given(interceptor.handleTimeout(this.asyncWebRequest, callable)).willReturn(RESULT_NONE); this.asyncManager.registerCallableInterceptor("interceptor", interceptor); this.asyncManager.startCallableProcessing(callable); this.asyncWebRequest.onTimeout(ASYNC_EVENT); this.asyncWebRequest.onComplete(ASYNC_EVENT); assertTrue(this.asyncManager.hasConcurrentResult()); assertEquals(AsyncRequestTimeoutException.class, this.asyncManager.getConcurrentResult().getClass()); verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, callable); verify(interceptor).afterCompletion(this.asyncWebRequest, callable); }
@Test public void startCallableProcessingAfterTimeoutException() throws Exception { StubCallable callable = new StubCallable(); Exception exception = new Exception(); CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class); given(interceptor.handleTimeout(this.asyncWebRequest, callable)).willThrow(exception); this.asyncManager.registerCallableInterceptor("timeoutInterceptor", interceptor); this.asyncManager.startCallableProcessing(callable); this.asyncWebRequest.onTimeout(ASYNC_EVENT); assertTrue(this.asyncManager.hasConcurrentResult()); assertEquals(exception, this.asyncManager.getConcurrentResult()); assertEquals("/test", ((MockAsyncContext) this.servletRequest.getAsyncContext()).getDispatchedPath()); verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, callable); }
@Test public void startCallableProcessingPostProcessException() throws Exception { Callable<Object> task = new StubCallable(21); Exception exception = new Exception(); CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class); willThrow(exception).given(interceptor).postProcess(this.asyncWebRequest, task, 21); setupDefaultAsyncScenario(); this.asyncManager.registerCallableInterceptor("interceptor", interceptor); this.asyncManager.startCallableProcessing(task); assertTrue(this.asyncManager.hasConcurrentResult()); assertEquals(exception, this.asyncManager.getConcurrentResult()); verifyDefaultAsyncScenario(); verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, task); verify(interceptor).preProcess(this.asyncWebRequest, task); }
@Test public void startDeferredResultProcessingTimeoutAndComplete() throws Exception { DeferredResult<Integer> deferredResult = new DeferredResult<>(); DeferredResultProcessingInterceptor interceptor = mock(DeferredResultProcessingInterceptor.class); given(interceptor.handleTimeout(this.asyncWebRequest, deferredResult)).willReturn(true); this.asyncManager.registerDeferredResultInterceptor("interceptor", interceptor); this.asyncManager.startDeferredResultProcessing(deferredResult); this.asyncWebRequest.onTimeout(ASYNC_EVENT); this.asyncWebRequest.onComplete(ASYNC_EVENT); assertTrue(this.asyncManager.hasConcurrentResult()); assertEquals(AsyncRequestTimeoutException.class, this.asyncManager.getConcurrentResult().getClass()); verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, deferredResult); verify(interceptor).preProcess(this.asyncWebRequest, deferredResult); verify(interceptor).afterCompletion(this.asyncWebRequest, deferredResult); }
@Test public void startCallableProcessingErrorAndResumeThroughInterceptor() throws Exception { StubCallable callable = new StubCallable(); CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class); Exception e = new Exception(); given(interceptor.handleError(this.asyncWebRequest, callable, e)).willReturn(22); this.asyncManager.registerCallableInterceptor("errorInterceptor", interceptor); this.asyncManager.startCallableProcessing(callable); AsyncEvent event = new AsyncEvent(new MockAsyncContext(this.servletRequest, this.servletResponse), e); this.asyncWebRequest.onError(event); assertTrue(this.asyncManager.hasConcurrentResult()); assertEquals(22, this.asyncManager.getConcurrentResult()); assertEquals("/test", ((MockAsyncContext) this.servletRequest.getAsyncContext()).getDispatchedPath()); verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, callable); }
@Test public void startDeferredResultProcessingErrorAndComplete() throws Exception { DeferredResult<Integer> deferredResult = new DeferredResult<>(); DeferredResultProcessingInterceptor interceptor = mock(DeferredResultProcessingInterceptor.class); Exception e = new Exception(); given(interceptor.handleError(this.asyncWebRequest, deferredResult, e)).willReturn(true); this.asyncManager.registerDeferredResultInterceptor("interceptor", interceptor); this.asyncManager.startDeferredResultProcessing(deferredResult); AsyncEvent event = new AsyncEvent(new MockAsyncContext(this.servletRequest, this.servletResponse), e); this.asyncWebRequest.onError(event); this.asyncWebRequest.onComplete(event); assertTrue(this.asyncManager.hasConcurrentResult()); assertEquals(e, this.asyncManager.getConcurrentResult()); verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, deferredResult); verify(interceptor).preProcess(this.asyncWebRequest, deferredResult); verify(interceptor).afterCompletion(this.asyncWebRequest, deferredResult); }
@Test public void startCallableProcessing() throws Exception { int concurrentResult = 21; Callable<Object> task = new StubCallable(concurrentResult); CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class); setupDefaultAsyncScenario(); this.asyncManager.registerCallableInterceptor("interceptor", interceptor); this.asyncManager.startCallableProcessing(task); assertTrue(this.asyncManager.hasConcurrentResult()); assertEquals(concurrentResult, this.asyncManager.getConcurrentResult()); verifyDefaultAsyncScenario(); verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, task); verify(interceptor).preProcess(this.asyncWebRequest, task); verify(interceptor).postProcess(this.asyncWebRequest, task, concurrentResult); }
@Test public void startCallableProcessingTimeoutAndResumeThroughInterceptor() throws Exception { StubCallable callable = new StubCallable(); CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class); given(interceptor.handleTimeout(this.asyncWebRequest, callable)).willReturn(22); this.asyncManager.registerCallableInterceptor("timeoutInterceptor", interceptor); this.asyncManager.startCallableProcessing(callable); this.asyncWebRequest.onTimeout(ASYNC_EVENT); assertTrue(this.asyncManager.hasConcurrentResult()); assertEquals(22, this.asyncManager.getConcurrentResult()); assertEquals("/test", ((MockAsyncContext) this.servletRequest.getAsyncContext()).getDispatchedPath()); verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, callable); }
@Test public void startDeferredResultProcessing() throws Exception { DeferredResult<String> deferredResult = new DeferredResult<>(1000L); String concurrentResult = "abc"; DeferredResultProcessingInterceptor interceptor = mock(DeferredResultProcessingInterceptor.class); setupDefaultAsyncScenario(); this.asyncManager.registerDeferredResultInterceptor("interceptor", interceptor); this.asyncManager.startDeferredResultProcessing(deferredResult); deferredResult.setResult(concurrentResult); assertEquals(concurrentResult, this.asyncManager.getConcurrentResult()); verifyDefaultAsyncScenario(); verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, deferredResult); verify(interceptor).preProcess(this.asyncWebRequest, deferredResult); verify(interceptor).postProcess(asyncWebRequest, deferredResult, concurrentResult); verify(this.asyncWebRequest).setTimeout(1000L); }