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

Replace EasyMock with Mockito

Browse Source 
Issue: SPR-10126
This commit is contained in:
Phillip Webb
2013-03-04 19:46:15 -08:00
parent a399b13354
commit 05765d7520
180 changed files with 2329 additions and 4272 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
spring-web/src/test/java/org/springframework/http/MockHttpOutputMessage.java
View File

@@ -16,13 +16,13 @@
package org.springframework.http;
import static org.mockito.Mockito.spy;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.Charset;
import static org.mockito.BDDMockito.*;
/**
* @author Arjen Poutsma
*/

5
spring-web/src/test/java/org/springframework/http/converter/FormHttpMessageConverterTests.java
View File

@@ -22,6 +22,7 @@ import java.io.InputStream;
import java.io.StringReader;
import java.nio.charset.Charset;
import java.util.List;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
@@ -32,7 +33,6 @@ import org.apache.commons.fileupload.RequestContext;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.junit.Before;
import org.junit.Test;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.http.HttpEntity;
@@ -45,8 +45,7 @@ import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import static org.junit.Assert.*;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.BDDMockito.*;
/**
* @author Arjen Poutsma

26
spring-web/src/test/java/org/springframework/http/converter/xml/MarshallingHttpMessageConverterTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2009 the original author or authors.
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -19,18 +19,20 @@ package org.springframework.http.converter.xml;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import static org.easymock.EasyMock.*;
import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;
import org.springframework.http.MediaType;
import org.springframework.http.MockHttpInputMessage;
import org.springframework.http.MockHttpOutputMessage;
import org.springframework.oxm.Marshaller;
import org.springframework.oxm.Unmarshaller;
/** @author Arjen Poutsma */
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
/**
* @author Arjen Poutsma
*/
public class MarshallingHttpMessageConverterTests {
private MarshallingHttpMessageConverter converter;
@@ -41,9 +43,8 @@ public class MarshallingHttpMessageConverterTests {
@Before
public void setUp() {
marshaller = createMock(Marshaller.class);
unmarshaller = createMock(Unmarshaller.class);
marshaller = mock(Marshaller.class);
unmarshaller = mock(Unmarshaller.class);
converter = new MarshallingHttpMessageConverter(marshaller, unmarshaller);
}
@@ -52,12 +53,10 @@ public class MarshallingHttpMessageConverterTests {
String body = "<root>Hello World</root>";
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
expect(unmarshaller.unmarshal(isA(StreamSource.class))).andReturn(body);
given(unmarshaller.unmarshal(isA(StreamSource.class))).willReturn(body);
replay(marshaller, unmarshaller);
String result = (String) converter.read(Object.class, inputMessage);
assertEquals("Invalid result", body, result);
verify(marshaller, unmarshaller);
}
@Test
@@ -65,12 +64,9 @@ public class MarshallingHttpMessageConverterTests {
String body = "<root>Hello World</root>";
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
marshaller.marshal(eq(body), isA(StreamResult.class));
replay(marshaller, unmarshaller);
converter.write(body, null, outputMessage);
assertEquals("Invalid content-type", new MediaType("application", "xml"),
outputMessage.getHeaders().getContentType());
verify(marshaller, unmarshaller);
verify(marshaller).marshal(eq(body), isA(StreamResult.class));
}
}

127
spring-web/src/test/java/org/springframework/remoting/jaxrpc/JaxRpcSupportTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -20,7 +20,6 @@ import java.net.MalformedURLException;
import java.net.URL;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
@@ -34,12 +33,11 @@ import javax.xml.rpc.ServiceFactory;
import javax.xml.rpc.Stub;
import junit.framework.TestCase;
import org.easymock.ArgumentsMatcher;
import org.easymock.MockControl;
import org.springframework.remoting.RemoteAccessException;
import org.springframework.remoting.RemoteLookupFailureException;
import org.springframework.util.ObjectUtils;
import static org.mockito.BDDMockito.*;
/**
* @author Juergen Hoeller
@@ -117,7 +115,6 @@ public class JaxRpcSupportTests extends TestCase {
IRemoteBean proxy = (IRemoteBean) factory.getObject();
proxy.setName("myName");
assertEquals("myName", RemoteBean.name);
MockServiceFactory.service1Control.verify();
}
public void testJaxRpcPortProxyFactoryBeanWithProperties() throws Exception {
@@ -145,7 +142,6 @@ public class JaxRpcSupportTests extends TestCase {
IRemoteBean proxy = (IRemoteBean) factory.getObject();
proxy.setName("myName");
assertEquals("myName", RemoteBean.name);
MockServiceFactory.service1Control.verify();
}
public void testJaxRpcPortProxyFactoryBeanWithCustomProperties() throws Exception {
@@ -173,7 +169,6 @@ public class JaxRpcSupportTests extends TestCase {
IRemoteBean proxy = (IRemoteBean) factory.getObject();
proxy.setName("myName");
assertEquals("myName", RemoteBean.name);
MockServiceFactory.service1Control.verify();
}
public void testJaxRpcPortProxyFactoryBeanWithCustomPropertyMap() throws Exception {
@@ -203,7 +198,6 @@ public class JaxRpcSupportTests extends TestCase {
IRemoteBean proxy = (IRemoteBean) factory.getObject();
proxy.setName("myName");
assertEquals("myName", RemoteBean.name);
MockServiceFactory.service1Control.verify();
}
public void testJaxRpcPortProxyFactoryBeanWithDynamicCalls() throws Exception {
@@ -219,13 +213,11 @@ public class JaxRpcSupportTests extends TestCase {
assertTrue(factory.getObject() instanceof IBusinessBean);
IBusinessBean proxy = (IBusinessBean) factory.getObject();
proxy.setName("myName");
MockServiceFactory.service1Control.verify();
CallMockServiceFactory.call1Control.verify();
}
public void testJaxRpcPortProxyFactoryBeanWithDynamicCallsAndProperties() throws Exception {
JaxRpcPortProxyFactoryBean factory = new JaxRpcPortProxyFactoryBean();
factory.setServiceFactoryClass(CallWithPropertiesMockServiceFactory.class);
factory.setServiceFactoryClass(CallMockServiceFactory.class);
factory.setNamespaceUri("myNamespace");
factory.setServiceName("myService1");
factory.setPortName("myPort");
@@ -240,8 +232,11 @@ public class JaxRpcSupportTests extends TestCase {
assertTrue(factory.getObject() instanceof IBusinessBean);
IBusinessBean proxy = (IBusinessBean) factory.getObject();
proxy.setName("myName");
MockServiceFactory.service1Control.verify();
CallMockServiceFactory.call1Control.verify();
verify(CallMockServiceFactory.call1).setProperty(Call.USERNAME_PROPERTY, "user");
verify(CallMockServiceFactory.call1).setProperty(Call.PASSWORD_PROPERTY, "pw");
verify(CallMockServiceFactory.call1).setTargetEndpointAddress("ea");
verify(CallMockServiceFactory.call1).setProperty(Call.SESSION_MAINTAIN_PROPERTY, Boolean.TRUE);
}
public void testJaxRpcPortProxyFactoryBeanWithDynamicCallsAndServiceException() throws Exception {
@@ -310,9 +305,6 @@ public class JaxRpcSupportTests extends TestCase {
assertEquals("myName", RemoteBean.name);
assertEquals(1, serviceFactory.serviceCount);
MockServiceFactory.service1Control.verify();
CallMockServiceFactory.call1Control.verify();
ExceptionCallMockServiceFactory.call2Control.verify();
}
public void testJaxRpcPortProxyFactoryBeanWithDynamicCallsAndRemoteExceptionAndRefresh() throws Exception {
@@ -344,9 +336,6 @@ public class JaxRpcSupportTests extends TestCase {
assertEquals("myName", RemoteBean.name);
assertEquals(2, serviceFactory.serviceCount);
MockServiceFactory.service1Control.verify();
CallMockServiceFactory.call1Control.verify();
ExceptionCallMockServiceFactory.call2Control.verify();
}
public void testJaxRpcPortProxyFactoryBeanWithPortInterface() throws Exception {
@@ -363,7 +352,6 @@ public class JaxRpcSupportTests extends TestCase {
IBusinessBean proxy = (IBusinessBean) factory.getObject();
proxy.setName("myName");
assertEquals("myName", RemoteBean.name);
MockServiceFactory.service1Control.verify();
}
public void testJaxRpcPortProxyFactoryBeanWithPortInterfaceAndServiceException() throws Exception {
@@ -436,7 +424,6 @@ public class JaxRpcSupportTests extends TestCase {
assertEquals("myName", RemoteBean.name);
assertEquals(1, serviceFactory.serviceCount);
MockServiceFactory.service1Control.verify();
}
public void testJaxRpcPortProxyFactoryBeanWithPortInterfaceAndRemoteExceptionAndRefresh() throws Exception {
@@ -470,30 +457,25 @@ public class JaxRpcSupportTests extends TestCase {
assertEquals("myName", RemoteBean.name);
assertEquals(2, serviceFactory.serviceCount);
MockServiceFactory.service1Control.verify();
}
public static class MockServiceFactory extends ServiceFactory {
protected static MockControl service1Control;
protected static Service service1;
protected static MockControl service2Control;
protected static Service service2;
protected int serviceCount = 0;
public MockServiceFactory() throws Exception {
service1Control = MockControl.createControl(Service.class);
service1 = (Service) service1Control.getMock();
service2Control = MockControl.createControl(Service.class);
service2 = (Service) service2Control.getMock();
service1 = mock(Service.class);
service2 = mock(Service.class);
initMocks();
service1Control.replay();
}
protected void initMocks() throws Exception {
service1.getPort(new QName("myNamespace", "myPort"), IRemoteBean.class);
service1Control.setReturnValue(new RemoteBean());
RemoteBean remoteBean = new RemoteBean();
given(service1.getPort(new QName("myNamespace", "myPort"),
IRemoteBean.class)).willReturn(remoteBean);
}
@Override
@@ -572,15 +554,14 @@ public class JaxRpcSupportTests extends TestCase {
@Override
protected void initMocks() throws Exception {
super.initMocks();
service1.getPort(new QName("myNamespace", "myPort"), IRemoteBean.class);
service1Control.setReturnValue(new RemoteBean());
given(service1.getPort(new QName("myNamespace", "myPort"),
IRemoteBean.class)).willReturn(new RemoteBean());
}
}
public static class CallMockServiceFactory extends MockServiceFactory {
protected static MockControl call1Control;
protected static Call call1;
public CallMockServiceFactory() throws Exception {
@@ -589,38 +570,15 @@ public class JaxRpcSupportTests extends TestCase {
@Override
protected void initMocks() throws Exception {
initStandardCall(1);
}
protected void initStandardCall(int count) throws Exception {
call1Control = MockControl.createControl(Call.class);
call1 = (Call) call1Control.getMock();
service1.createCall(new QName("myNamespace", "myPort"), "setName");
service1Control.setReturnValue(call1, count);
call1.invoke(new Object[] {"myName"});
call1Control.setMatcher(new ArgumentsMatcher() {
@Override
public boolean matches(Object[] objects, Object[] objects1) {
return Arrays.equals((Object[]) objects[0], (Object[]) objects1[0]);
}
@Override
public String toString(Object[] objects) {
return ObjectUtils.nullSafeToString(objects[0]);
}
});
call1Control.setReturnValue(null, count);
extendStandardCall();
call1Control.replay();
}
protected void extendStandardCall() {
call1 = mock(Call.class);
given(service1.createCall(new QName("myNamespace", "myPort"), "setName")).willReturn(call1);
}
}
public static class ExceptionCallMockServiceFactory extends CallMockServiceFactory {
public static class ExceptionCallMockServiceFactory extends MockServiceFactory {
protected static MockControl call2Control;
protected static Call call1;
protected static Call call2;
public ExceptionCallMockServiceFactory() throws Exception {
@@ -628,47 +586,10 @@ public class JaxRpcSupportTests extends TestCase {
@Override
protected void initMocks() throws Exception {
initExceptionCall();
initStandardCall(2);
}
protected void initExceptionCall() throws Exception {
call2Control = MockControl.createControl(Call.class);
call2 = (Call) call2Control.getMock();
service1.createCall(new QName("myNamespace", "myPort"), "setName");
service1Control.setReturnValue(call2);
call2.invoke(new Object[] {"exception"});
call2Control.setMatcher(new ArgumentsMatcher() {
@Override
public boolean matches(Object[] objects, Object[] objects1) {
return Arrays.equals((Object[]) objects[0], (Object[]) objects1[0]);
}
@Override
public String toString(Object[] objects) {
return ObjectUtils.nullSafeToString(objects[0]);
}
});
call2Control.setThrowable(new RemoteException());
call2Control.replay();
}
}
public static class CallWithPropertiesMockServiceFactory extends CallMockServiceFactory {
public CallWithPropertiesMockServiceFactory() throws Exception {
}
@Override
protected void extendStandardCall() {
call1.setProperty(Call.USERNAME_PROPERTY, "user");
call1Control.setVoidCallable();
call1.setProperty(Call.PASSWORD_PROPERTY, "pw");
call1Control.setVoidCallable();
call1.setTargetEndpointAddress("ea");
call1Control.setVoidCallable();
call1.setProperty(Call.SESSION_MAINTAIN_PROPERTY, Boolean.TRUE);
call1Control.setVoidCallable();
call1 = mock(Call.class);
call2 = mock(Call.class);
given(service1.createCall(new QName("myNamespace", "myPort"), "setName")).willReturn(call2, call1);
given(call2.invoke(new Object[] { "exception" })).willThrow(new RemoteException());
}
}

66
spring-web/src/test/java/org/springframework/web/client/DefaultResponseErrorHandlerTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -21,15 +21,13 @@ import java.io.IOException;
import org.junit.Before;
import org.junit.Test;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.client.ClientHttpResponse;
import static org.easymock.EasyMock.*;
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
/**
* Unit tests for {@link DefaultResponseErrorHandler}.
@@ -45,27 +43,19 @@ public class DefaultResponseErrorHandlerTests {
@Before
public void setUp() throws Exception {
handler = new DefaultResponseErrorHandler();
response = createMock(ClientHttpResponse.class);
response = mock(ClientHttpResponse.class);
}
@Test
public void hasErrorTrue() throws Exception {
expect(response.getStatusCode()).andReturn(HttpStatus.NOT_FOUND);
replay(response);
given(response.getStatusCode()).willReturn(HttpStatus.NOT_FOUND);
assertTrue(handler.hasError(response));
verify(response);
}
@Test
public void hasErrorFalse() throws Exception {
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
replay(response);
given(response.getStatusCode()).willReturn(HttpStatus.OK);
assertFalse(handler.hasError(response));
verify(response);
}
@Test
@@ -73,12 +63,10 @@ public class DefaultResponseErrorHandlerTests {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.TEXT_PLAIN);
expect(response.getStatusCode()).andReturn(HttpStatus.NOT_FOUND);
expect(response.getStatusText()).andReturn("Not Found");
expect(response.getHeaders()).andReturn(headers).atLeastOnce();
expect(response.getBody()).andReturn(new ByteArrayInputStream("Hello World".getBytes("UTF-8")));
replay(response);
given(response.getStatusCode()).willReturn(HttpStatus.NOT_FOUND);
given(response.getStatusText()).willReturn("Not Found");
given(response.getHeaders()).willReturn(headers);
given(response.getBody()).willReturn(new ByteArrayInputStream("Hello World".getBytes("UTF-8")));
try {
handler.handleError(response);
@@ -87,8 +75,6 @@ public class DefaultResponseErrorHandlerTests {
catch (HttpClientErrorException e) {
assertSame(headers, e.getResponseHeaders());
}
verify(response);
}
@Test(expected = HttpClientErrorException.class)
@@ -96,16 +82,12 @@ public class DefaultResponseErrorHandlerTests {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.TEXT_PLAIN);
expect(response.getStatusCode()).andReturn(HttpStatus.NOT_FOUND);
expect(response.getStatusText()).andReturn("Not Found");
expect(response.getHeaders()).andReturn(headers).atLeastOnce();
expect(response.getBody()).andThrow(new IOException());
replay(response);
given(response.getStatusCode()).willReturn(HttpStatus.NOT_FOUND);
given(response.getStatusText()).willReturn("Not Found");
given(response.getHeaders()).willReturn(headers);
given(response.getBody()).willThrow(new IOException());
handler.handleError(response);
verify(response);
}
@Test(expected = HttpClientErrorException.class)
@@ -113,16 +95,11 @@ public class DefaultResponseErrorHandlerTests {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.TEXT_PLAIN);
expect(response.getStatusCode()).andReturn(HttpStatus.NOT_FOUND);
expect(response.getStatusText()).andReturn("Not Found");
expect(response.getHeaders()).andReturn(headers).atLeastOnce();
expect(response.getBody()).andReturn(null);
replay(response);
given(response.getStatusCode()).willReturn(HttpStatus.NOT_FOUND);
given(response.getStatusText()).willReturn("Not Found");
given(response.getHeaders()).willReturn(headers);
handler.handleError(response);
verify(response);
}
// SPR-9406
@@ -132,13 +109,10 @@ public class DefaultResponseErrorHandlerTests {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.TEXT_PLAIN);
expect(response.getStatusCode()).andThrow(new IllegalArgumentException("No matching constant for 999"));
expect(response.getRawStatusCode()).andReturn(999);
expect(response.getStatusText()).andReturn("Custom status code");
expect(response.getHeaders()).andReturn(headers).atLeastOnce();
expect(response.getBody()).andReturn(null);
replay(response);
given(response.getStatusCode()).willThrow(new IllegalArgumentException("No matching constant for 999"));
given(response.getRawStatusCode()).willReturn(999);
given(response.getStatusText()).willReturn("Custom status code");
given(response.getHeaders()).willReturn(headers);
handler.handleError(response);
}

86
spring-web/src/test/java/org/springframework/web/client/HttpMessageConverterExtractorTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,14 +16,6 @@
package org.springframework.web.client;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;
import java.io.IOException;
import java.lang.reflect.Type;
import java.util.ArrayList;
@@ -39,6 +31,9 @@ import org.springframework.http.client.ClientHttpResponse;
import org.springframework.http.converter.GenericHttpMessageConverter;
import org.springframework.http.converter.HttpMessageConverter;
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
/**
* Test fixture for {@link HttpMessageConverter}.
*
@@ -52,101 +47,80 @@ public class HttpMessageConverterExtractorTests {
@Before
public void createMocks() {
response = createMock(ClientHttpResponse.class);
response = mock(ClientHttpResponse.class);
}
@Test
public void noContent() throws IOException {
HttpMessageConverter<?> converter = createMock(HttpMessageConverter.class);
HttpMessageConverter<?> converter = mock(HttpMessageConverter.class);
extractor = new HttpMessageConverterExtractor<String>(String.class, createConverterList(converter));
given(response.getStatusCode()).willReturn(HttpStatus.NO_CONTENT);
expect(response.getStatusCode()).andReturn(HttpStatus.NO_CONTENT);
replay(response, converter);
Object result = extractor.extractData(response);
assertNull(result);
verify(response, converter);
}
@Test
public void notModified() throws IOException {
HttpMessageConverter<?> converter = createMock(HttpMessageConverter.class);
HttpMessageConverter<?> converter = mock(HttpMessageConverter.class);
extractor = new HttpMessageConverterExtractor<String>(String.class, createConverterList(converter));
given(response.getStatusCode()).willReturn(HttpStatus.NOT_MODIFIED);
expect(response.getStatusCode()).andReturn(HttpStatus.NOT_MODIFIED);
replay(response, converter);
Object result = extractor.extractData(response);
assertNull(result);
verify(response, converter);
}
@Test
public void zeroContentLength() throws IOException {
HttpMessageConverter<?> converter = createMock(HttpMessageConverter.class);
HttpMessageConverter<?> converter = mock(HttpMessageConverter.class);
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentLength(0);
extractor = new HttpMessageConverterExtractor<String>(String.class, createConverterList(converter));
given(response.getStatusCode()).willReturn(HttpStatus.OK);
given(response.getHeaders()).willReturn(responseHeaders);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
expect(response.getHeaders()).andReturn(responseHeaders);
replay(response, converter);
Object result = extractor.extractData(response);
assertNull(result);
verify(response, converter);
}
@Test
@SuppressWarnings("unchecked")
public void normal() throws IOException {
HttpMessageConverter<String> converter = createMock(HttpMessageConverter.class);
HttpMessageConverter<String> converter = mock(HttpMessageConverter.class);
List<HttpMessageConverter<?>> converters = new ArrayList<HttpMessageConverter<?>>();
converters.add(converter);
HttpHeaders responseHeaders = new HttpHeaders();
MediaType contentType = MediaType.TEXT_PLAIN;
responseHeaders.setContentType(contentType);
String expected = "Foo";
extractor = new HttpMessageConverterExtractor<String>(String.class, converters);
given(response.getStatusCode()).willReturn(HttpStatus.OK);
given(response.getHeaders()).willReturn(responseHeaders);
given(converter.canRead(String.class, contentType)).willReturn(true);
given(converter.read(String.class, response)).willReturn(expected);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
expect(response.getHeaders()).andReturn(responseHeaders).times(2);
expect(converter.canRead(String.class, contentType)).andReturn(true);
expect(converter.read(String.class, response)).andReturn(expected);
replay(response, converter);
Object result = extractor.extractData(response);
assertEquals(expected, result);
verify(response, converter);
}
@Test
@SuppressWarnings("unchecked")
public void cannotRead() throws IOException {
HttpMessageConverter<String> converter = createMock(HttpMessageConverter.class);
HttpMessageConverter<String> converter = mock(HttpMessageConverter.class);
List<HttpMessageConverter<?>> converters = new ArrayList<HttpMessageConverter<?>>();
converters.add(converter);
HttpHeaders responseHeaders = new HttpHeaders();
MediaType contentType = MediaType.TEXT_PLAIN;
responseHeaders.setContentType(contentType);
extractor = new HttpMessageConverterExtractor<String>(String.class, converters);
given(response.getStatusCode()).willReturn(HttpStatus.OK);
given(response.getHeaders()).willReturn(responseHeaders);
given(converter.canRead(String.class, contentType)).willReturn(false);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
expect(response.getHeaders()).andReturn(responseHeaders).times(2);
expect(converter.canRead(String.class, contentType)).andReturn(false);
replay(response, converter);
try {
extractor.extractData(response);
fail("RestClientException expected");
@@ -154,36 +128,28 @@ public class HttpMessageConverterExtractorTests {
catch (RestClientException expected) {
// expected
}
verify(response, converter);
}
@Test
@SuppressWarnings("unchecked")
public void generics() throws IOException {
GenericHttpMessageConverter<String> converter = createMock(GenericHttpMessageConverter.class);
GenericHttpMessageConverter<String> converter = mock(GenericHttpMessageConverter.class);
List<HttpMessageConverter<?>> converters = createConverterList(converter);
HttpHeaders responseHeaders = new HttpHeaders();
MediaType contentType = MediaType.TEXT_PLAIN;
responseHeaders.setContentType(contentType);
String expected = "Foo";
ParameterizedTypeReference<List<String>> reference = new ParameterizedTypeReference<List<String>>() {};
Type type = reference.getType();
extractor = new HttpMessageConverterExtractor<List<String>>(type, converters);
given(response.getStatusCode()).willReturn(HttpStatus.OK);
given(response.getHeaders()).willReturn(responseHeaders);
given(converter.canRead(type, null, contentType)).willReturn(true);
given(converter.read(type, null, response)).willReturn(expected);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
expect(response.getHeaders()).andReturn(responseHeaders).times(2);
expect(converter.canRead(type, null, contentType)).andReturn(true);
expect(converter.read(type, null, response)).andReturn(expected);
replay(response, converter);
Object result = extractor.extractData(response);
assertEquals(expected, result);
verify(response, converter);
}
private List<HttpMessageConverter<?>> createConverterList(HttpMessageConverter converter) {

596
spring-web/src/test/java/org/springframework/web/client/RestTemplateTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -25,11 +25,8 @@ import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.easymock.EasyMock.*;
import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
@@ -43,7 +40,12 @@ import org.springframework.http.client.ClientHttpResponse;
import org.springframework.http.converter.GenericHttpMessageConverter;
import org.springframework.http.converter.HttpMessageConverter;
/** @author Arjen Poutsma */
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
/**
* @author Arjen Poutsma
*/
@SuppressWarnings("unchecked")
public class RestTemplateTests {
@@ -61,11 +63,11 @@ public class RestTemplateTests {
@Before
public void setUp() {
requestFactory = createMock(ClientHttpRequestFactory.class);
request = createMock(ClientHttpRequest.class);
response = createMock(ClientHttpResponse.class);
errorHandler = createMock(ResponseErrorHandler.class);
converter = createMock(HttpMessageConverter.class);
requestFactory = mock(ClientHttpRequestFactory.class);
request = mock(ClientHttpRequest.class);
response = mock(ClientHttpResponse.class);
errorHandler = mock(ResponseErrorHandler.class);
converter = mock(HttpMessageConverter.class);
template = new RestTemplate(requestFactory);
template.setErrorHandler(errorHandler);
template.setMessageConverters(Collections.<HttpMessageConverter<?>>singletonList(converter));
@@ -73,85 +75,77 @@ public class RestTemplateTests {
@Test
public void varArgsTemplateVariables() throws Exception {
expect(requestFactory.createRequest(new URI("http://example.com/hotels/42/bookings/21"), HttpMethod.GET))
.andReturn(request);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(requestFactory.createRequest(new URI("http://example.com/hotels/42/bookings/21"), HttpMethod.GET))
.willReturn(request);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
template.execute("http://example.com/hotels/{hotel}/bookings/{booking}", HttpMethod.GET, null, null, "42",
"21");
verifyMocks();
verify(response).close();
}
@Test
public void varArgsNullTemplateVariable() throws Exception {
expect(requestFactory.createRequest(new URI("http://example.com/-foo"), HttpMethod.GET))
.andReturn(request);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(requestFactory.createRequest(new URI("http://example.com/-foo"), HttpMethod.GET))
.willReturn(request);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
template.execute("http://example.com/{first}-{last}", HttpMethod.GET, null, null, null, "foo");
verifyMocks();
verify(response).close();
}
@Test
public void mapTemplateVariables() throws Exception {
expect(requestFactory.createRequest(new URI("http://example.com/hotels/42/bookings/42"), HttpMethod.GET))
.andReturn(request);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(requestFactory.createRequest(new URI("http://example.com/hotels/42/bookings/42"), HttpMethod.GET))
.willReturn(request);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
Map<String, String> vars = Collections.singletonMap("hotel", "42");
template.execute("http://example.com/hotels/{hotel}/bookings/{hotel}", HttpMethod.GET, null, null, vars);
verifyMocks();
verify(response).close();
}
@Test
public void mapNullTemplateVariable() throws Exception {
expect(requestFactory.createRequest(new URI("http://example.com/-foo"), HttpMethod.GET))
.andReturn(request);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(requestFactory.createRequest(new URI("http://example.com/-foo"), HttpMethod.GET))
.willReturn(request);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
Map<String, String> vars = new HashMap<String, String>(2);
vars.put("first", null);
vars.put("last", "foo");
template.execute("http://example.com/{first}-{last}", HttpMethod.GET, null, null, vars);
verifyMocks();
verify(response).close();
}
@Test
public void errorHandling() throws Exception {
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.GET)).andReturn(request);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(true);
expect(response.getStatusCode()).andReturn(HttpStatus.INTERNAL_SERVER_ERROR);
expect(response.getStatusText()).andReturn("Internal Server Error");
errorHandler.handleError(response);
expectLastCall().andThrow(new HttpServerErrorException(HttpStatus.INTERNAL_SERVER_ERROR));
response.close();
replayMocks();
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.GET)).willReturn(request);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(true);
given(response.getStatusCode()).willReturn(HttpStatus.INTERNAL_SERVER_ERROR);
given(response.getStatusText()).willReturn("Internal Server Error");
willThrow(new HttpServerErrorException(HttpStatus.INTERNAL_SERVER_ERROR)).given(errorHandler).handleError(response);
try {
template.execute("http://example.com", HttpMethod.GET, null, null);
@@ -160,60 +154,59 @@ public class RestTemplateTests {
catch (HttpServerErrorException ex) {
// expected
}
verifyMocks();
verify(response).close();
}
@Test
public void getForObject() throws Exception {
expect(converter.canRead(String.class, null)).andReturn(true);
given(converter.canRead(String.class, null)).willReturn(true);
MediaType textPlain = new MediaType("text", "plain");
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(textPlain));
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.GET)).andReturn(request);
given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(textPlain));
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.GET)).willReturn(request);
HttpHeaders requestHeaders = new HttpHeaders();
expect(request.getHeaders()).andReturn(requestHeaders);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
given(request.getHeaders()).willReturn(requestHeaders);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentType(textPlain);
responseHeaders.setContentLength(10);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
expect(response.getHeaders()).andReturn(responseHeaders).times(2);
expect(converter.canRead(String.class, textPlain)).andReturn(true);
given(response.getStatusCode()).willReturn(HttpStatus.OK);
given(response.getHeaders()).willReturn(responseHeaders);
given(converter.canRead(String.class, textPlain)).willReturn(true);
String expected = "Hello World";
expect(converter.read(String.class, response)).andReturn(expected);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(converter.read(String.class, response)).willReturn(expected);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
String result = template.getForObject("http://example.com", String.class);
assertEquals("Invalid GET result", expected, result);
assertEquals("Invalid Accept header", textPlain.toString(), requestHeaders.getFirst("Accept"));
verifyMocks();
verify(response).close();
}
@Test
public void getUnsupportedMediaType() throws Exception {
expect(converter.canRead(String.class, null)).andReturn(true);
given(converter.canRead(String.class, null)).willReturn(true);
MediaType supportedMediaType = new MediaType("foo", "bar");
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(supportedMediaType));
expect(requestFactory.createRequest(new URI("http://example.com/resource"), HttpMethod.GET)).andReturn(request);
given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(supportedMediaType));
given(requestFactory.createRequest(new URI("http://example.com/resource"), HttpMethod.GET)).willReturn(request);
HttpHeaders requestHeaders = new HttpHeaders();
expect(request.getHeaders()).andReturn(requestHeaders);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
given(request.getHeaders()).willReturn(requestHeaders);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
MediaType contentType = new MediaType("bar", "baz");
responseHeaders.setContentType(contentType);
responseHeaders.setContentLength(10);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
expect(response.getHeaders()).andReturn(responseHeaders).times(2);
expect(converter.canRead(String.class, contentType)).andReturn(false);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(response.getStatusCode()).willReturn(HttpStatus.OK);
given(response.getHeaders()).willReturn(responseHeaders);
given(converter.canRead(String.class, contentType)).willReturn(false);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
try {
template.getForObject("http://example.com/{p}", String.class, "resource");
@@ -222,33 +215,33 @@ public class RestTemplateTests {
catch (RestClientException ex) {
// expected
}
verifyMocks();
verify(response).close();
}
@Test
public void getForEntity() throws Exception {
expect(converter.canRead(String.class, null)).andReturn(true);
given(converter.canRead(String.class, null)).willReturn(true);
MediaType textPlain = new MediaType("text", "plain");
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(textPlain));
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.GET)).andReturn(request);
given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(textPlain));
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.GET)).willReturn(request);
HttpHeaders requestHeaders = new HttpHeaders();
expect(request.getHeaders()).andReturn(requestHeaders);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
given(request.getHeaders()).willReturn(requestHeaders);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentType(textPlain);
responseHeaders.setContentLength(10);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
expect(response.getHeaders()).andReturn(responseHeaders).times(3);
expect(converter.canRead(String.class, textPlain)).andReturn(true);
given(response.getStatusCode()).willReturn(HttpStatus.OK);
given(response.getHeaders()).willReturn(responseHeaders);
given(converter.canRead(String.class, textPlain)).willReturn(true);
String expected = "Hello World";
expect(converter.read(String.class, response)).andReturn(expected);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(converter.read(String.class, response)).willReturn(expected);
given(response.getStatusCode()).willReturn(HttpStatus.OK);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
ResponseEntity<String> result = template.getForEntity("http://example.com", String.class);
assertEquals("Invalid GET result", expected, result.getBody());
@@ -256,70 +249,68 @@ public class RestTemplateTests {
assertEquals("Invalid Content-Type header", textPlain, result.getHeaders().getContentType());
assertEquals("Invalid status code", HttpStatus.OK, result.getStatusCode());
verifyMocks();
verify(response).close();
}
@Test
public void headForHeaders() throws Exception {
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.HEAD)).andReturn(request);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.HEAD)).willReturn(request);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
expect(response.getHeaders()).andReturn(responseHeaders);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
given(response.getHeaders()).willReturn(responseHeaders);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
replayMocks();
HttpHeaders result = template.headForHeaders("http://example.com");
assertSame("Invalid headers returned", responseHeaders, result);
verifyMocks();
verify(response).close();
}
@Test
public void postForLocation() throws Exception {
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).andReturn(request);
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(request);
String helloWorld = "Hello World";
expect(converter.canWrite(String.class, null)).andReturn(true);
given(converter.canWrite(String.class, null)).willReturn(true);
converter.write(helloWorld, null, request);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
URI expected = new URI("http://example.com/hotels");
responseHeaders.setLocation(expected);
expect(response.getHeaders()).andReturn(responseHeaders);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(response.getHeaders()).willReturn(responseHeaders);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
URI result = template.postForLocation("http://example.com", helloWorld);
assertEquals("Invalid POST result", expected, result);
verifyMocks();
verify(response).close();
}
@Test
public void postForLocationEntityContentType() throws Exception {
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).andReturn(request);
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(request);
String helloWorld = "Hello World";
MediaType contentType = MediaType.TEXT_PLAIN;
expect(converter.canWrite(String.class, contentType)).andReturn(true);
given(converter.canWrite(String.class, contentType)).willReturn(true);
HttpHeaders requestHeaders = new HttpHeaders();
expect(request.getHeaders()).andReturn(requestHeaders);
given(request.getHeaders()).willReturn(requestHeaders);
converter.write(helloWorld, contentType, request);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
URI expected = new URI("http://example.com/hotels");
responseHeaders.setLocation(expected);
expect(response.getHeaders()).andReturn(responseHeaders);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(response.getHeaders()).willReturn(responseHeaders);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
HttpHeaders entityHeaders = new HttpHeaders();
entityHeaders.setContentType(contentType);
@@ -328,27 +319,26 @@ public class RestTemplateTests {
URI result = template.postForLocation("http://example.com", entity);
assertEquals("Invalid POST result", expected, result);
verifyMocks();
verify(response).close();
}
@Test
public void postForLocationEntityCustomHeader() throws Exception {
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).andReturn(request);
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(request);
String helloWorld = "Hello World";
expect(converter.canWrite(String.class, null)).andReturn(true);
given(converter.canWrite(String.class, null)).willReturn(true);
HttpHeaders requestHeaders = new HttpHeaders();
expect(request.getHeaders()).andReturn(requestHeaders);
given(request.getHeaders()).willReturn(requestHeaders);
converter.write(helloWorld, null, request);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
URI expected = new URI("http://example.com/hotels");
responseHeaders.setLocation(expected);
expect(response.getHeaders()).andReturn(responseHeaders);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(response.getHeaders()).willReturn(responseHeaders);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
HttpHeaders entityHeaders = new HttpHeaders();
entityHeaders.set("MyHeader", "MyValue");
@@ -358,108 +348,105 @@ public class RestTemplateTests {
assertEquals("Invalid POST result", expected, result);
assertEquals("No custom header set", "MyValue", requestHeaders.getFirst("MyHeader"));
verifyMocks();
verify(response).close();
}
@Test
public void postForLocationNoLocation() throws Exception {
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).andReturn(request);
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(request);
String helloWorld = "Hello World";
expect(converter.canWrite(String.class, null)).andReturn(true);
given(converter.canWrite(String.class, null)).willReturn(true);
converter.write(helloWorld, null, request);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
expect(response.getHeaders()).andReturn(responseHeaders);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(response.getHeaders()).willReturn(responseHeaders);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
URI result = template.postForLocation("http://example.com", helloWorld);
assertNull("Invalid POST result", result);
verifyMocks();
verify(response).close();
}
@Test
public void postForLocationNull() throws Exception {
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).andReturn(request);
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(request);
HttpHeaders requestHeaders = new HttpHeaders();
expect(request.getHeaders()).andReturn(requestHeaders);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
given(request.getHeaders()).willReturn(requestHeaders);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
expect(response.getHeaders()).andReturn(responseHeaders);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
given(response.getHeaders()).willReturn(responseHeaders);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
replayMocks();
template.postForLocation("http://example.com", null);
assertEquals("Invalid content length", 0, requestHeaders.getContentLength());
verifyMocks();
verify(response).close();
}
@Test
public void postForObject() throws Exception {
MediaType textPlain = new MediaType("text", "plain");
expect(converter.canRead(Integer.class, null)).andReturn(true);
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(textPlain));
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).andReturn(this.request);
given(converter.canRead(Integer.class, null)).willReturn(true);
given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(textPlain));
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(this.request);
HttpHeaders requestHeaders = new HttpHeaders();
expect(this.request.getHeaders()).andReturn(requestHeaders);
given(this.request.getHeaders()).willReturn(requestHeaders);
String request = "Hello World";
expect(converter.canWrite(String.class, null)).andReturn(true);
given(converter.canWrite(String.class, null)).willReturn(true);
converter.write(request, null, this.request);
expect(this.request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
given(this.request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentType(textPlain);
responseHeaders.setContentLength(10);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
expect(response.getHeaders()).andReturn(responseHeaders).times(2);
given(response.getStatusCode()).willReturn(HttpStatus.OK);
given(response.getHeaders()).willReturn(responseHeaders);
Integer expected = 42;
expect(converter.canRead(Integer.class, textPlain)).andReturn(true);
expect(converter.read(Integer.class, response)).andReturn(expected);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(converter.canRead(Integer.class, textPlain)).willReturn(true);
given(converter.read(Integer.class, response)).willReturn(expected);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
Integer result = template.postForObject("http://example.com", request, Integer.class);
assertEquals("Invalid POST result", expected, result);
assertEquals("Invalid Accept header", textPlain.toString(), requestHeaders.getFirst("Accept"));
verifyMocks();
verify(response).close();
}
@Test
public void postForEntity() throws Exception {
MediaType textPlain = new MediaType("text", "plain");
expect(converter.canRead(Integer.class, null)).andReturn(true);
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(textPlain));
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).andReturn(this.request);
given(converter.canRead(Integer.class, null)).willReturn(true);
given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(textPlain));
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(this.request);
HttpHeaders requestHeaders = new HttpHeaders();
expect(this.request.getHeaders()).andReturn(requestHeaders);
given(this.request.getHeaders()).willReturn(requestHeaders);
String request = "Hello World";
expect(converter.canWrite(String.class, null)).andReturn(true);
given(converter.canWrite(String.class, null)).willReturn(true);
converter.write(request, null, this.request);
expect(this.request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
given(this.request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentType(textPlain);
responseHeaders.setContentLength(10);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
expect(response.getHeaders()).andReturn(responseHeaders).times(3);
given(response.getStatusCode()).willReturn(HttpStatus.OK);
given(response.getHeaders()).willReturn(responseHeaders);
Integer expected = 42;
expect(converter.canRead(Integer.class, textPlain)).andReturn(true);
expect(converter.read(Integer.class, response)).andReturn(expected);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(converter.canRead(Integer.class, textPlain)).willReturn(true);
given(converter.read(Integer.class, response)).willReturn(expected);
given(response.getStatusCode()).willReturn(HttpStatus.OK);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
ResponseEntity<Integer> result = template.postForEntity("http://example.com", request, Integer.class);
assertEquals("Invalid POST result", expected, result.getBody());
@@ -467,148 +454,143 @@ public class RestTemplateTests {
assertEquals("Invalid Accept header", textPlain.toString(), requestHeaders.getFirst("Accept"));
assertEquals("Invalid status code", HttpStatus.OK, result.getStatusCode());
verifyMocks();
verify(response).close();
}
@Test
public void postForObjectNull() throws Exception {
MediaType textPlain = new MediaType("text", "plain");
expect(converter.canRead(Integer.class, null)).andReturn(true);
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(textPlain));
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).andReturn(request);
given(converter.canRead(Integer.class, null)).willReturn(true);
given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(textPlain));
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(request);
HttpHeaders requestHeaders = new HttpHeaders();
expect(request.getHeaders()).andReturn(requestHeaders).times(2);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
given(request.getHeaders()).willReturn(requestHeaders);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentType(textPlain);
responseHeaders.setContentLength(10);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
expect(response.getHeaders()).andReturn(responseHeaders).times(2);
expect(converter.canRead(Integer.class, textPlain)).andReturn(true);
expect(converter.read(Integer.class, response)).andReturn(null);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
given(response.getStatusCode()).willReturn(HttpStatus.OK);
given(response.getHeaders()).willReturn(responseHeaders);
given(converter.canRead(Integer.class, textPlain)).willReturn(true);
given(converter.read(Integer.class, response)).willReturn(null);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
replayMocks();
Integer result = template.postForObject("http://example.com", null, Integer.class);
assertNull("Invalid POST result", result);
assertEquals("Invalid content length", 0, requestHeaders.getContentLength());
verifyMocks();
verify(response).close();
}
@Test
public void postForEntityNull() throws Exception {
MediaType textPlain = new MediaType("text", "plain");
expect(converter.canRead(Integer.class, null)).andReturn(true);
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(textPlain));
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).andReturn(request);
given(converter.canRead(Integer.class, null)).willReturn(true);
given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(textPlain));
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(request);
HttpHeaders requestHeaders = new HttpHeaders();
expect(request.getHeaders()).andReturn(requestHeaders).times(2);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
given(request.getHeaders()).willReturn(requestHeaders);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentType(textPlain);
responseHeaders.setContentLength(10);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
expect(response.getHeaders()).andReturn(responseHeaders).times(3);
expect(converter.canRead(Integer.class, textPlain)).andReturn(true);
expect(converter.read(Integer.class, response)).andReturn(null);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
given(response.getStatusCode()).willReturn(HttpStatus.OK);
given(response.getHeaders()).willReturn(responseHeaders);
given(converter.canRead(Integer.class, textPlain)).willReturn(true);
given(converter.read(Integer.class, response)).willReturn(null);
given(response.getStatusCode()).willReturn(HttpStatus.OK);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
replayMocks();
ResponseEntity<Integer> result = template.postForEntity("http://example.com", null, Integer.class);
assertFalse("Invalid POST result", result.hasBody());
assertEquals("Invalid Content-Type", textPlain, result.getHeaders().getContentType());
assertEquals("Invalid content length", 0, requestHeaders.getContentLength());
assertEquals("Invalid status code", HttpStatus.OK, result.getStatusCode());
verifyMocks();
verify(response).close();
}
@Test
public void put() throws Exception {
expect(converter.canWrite(String.class, null)).andReturn(true);
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.PUT)).andReturn(request);
given(converter.canWrite(String.class, null)).willReturn(true);
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.PUT)).willReturn(request);
String helloWorld = "Hello World";
converter.write(helloWorld, null, request);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
template.put("http://example.com", helloWorld);
verifyMocks();
verify(response).close();
}
@Test
public void putNull() throws Exception {
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.PUT)).andReturn(request);
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.PUT)).willReturn(request);
HttpHeaders requestHeaders = new HttpHeaders();
expect(request.getHeaders()).andReturn(requestHeaders);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
given(request.getHeaders()).willReturn(requestHeaders);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
replayMocks();
template.put("http://example.com", null);
assertEquals("Invalid content length", 0, requestHeaders.getContentLength());
verifyMocks();
verify(response).close();
}
@Test
public void delete() throws Exception {
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.DELETE)).andReturn(request);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.DELETE)).willReturn(request);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
template.delete("http://example.com");
verifyMocks();
verify(response).close();
}
@Test
public void optionsForAllow() throws Exception {
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.OPTIONS)).andReturn(request);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.OPTIONS)).willReturn(request);
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
EnumSet<HttpMethod> expected = EnumSet.of(HttpMethod.GET, HttpMethod.POST);
responseHeaders.setAllow(expected);
expect(response.getHeaders()).andReturn(responseHeaders);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(response.getHeaders()).willReturn(responseHeaders);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
Set<HttpMethod> result = template.optionsForAllow("http://example.com");
assertEquals("Invalid OPTIONS result", expected, result);
verifyMocks();
verify(response).close();
}
@Test
public void ioException() throws Exception {
expect(converter.canRead(String.class, null)).andReturn(true);
given(converter.canRead(String.class, null)).willReturn(true);
MediaType mediaType = new MediaType("foo", "bar");
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(mediaType));
expect(requestFactory.createRequest(new URI("http://example.com/resource"), HttpMethod.GET)).andReturn(request);
expect(request.getHeaders()).andReturn(new HttpHeaders());
expect(request.execute()).andThrow(new IOException());
replayMocks();
given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(mediaType));
given(requestFactory.createRequest(new URI("http://example.com/resource"), HttpMethod.GET)).willReturn(request);
given(request.getHeaders()).willReturn(new HttpHeaders());
given(request.execute()).willThrow(new IOException());
try {
template.getForObject("http://example.com/resource", String.class);
@@ -617,35 +599,32 @@ public class RestTemplateTests {
catch (ResourceAccessException ex) {
// expected
}
verifyMocks();
}
@Test
public void exchange() throws Exception {
expect(converter.canRead(Integer.class, null)).andReturn(true);
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).andReturn(this.request);
given(converter.canRead(Integer.class, null)).willReturn(true);
given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(this.request);
HttpHeaders requestHeaders = new HttpHeaders();
expect(this.request.getHeaders()).andReturn(requestHeaders).times(2);
expect(converter.canWrite(String.class, null)).andReturn(true);
given(this.request.getHeaders()).willReturn(requestHeaders);
given(converter.canWrite(String.class, null)).willReturn(true);
String body = "Hello World";
converter.write(body, null, this.request);
expect(this.request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
given(this.request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentType(MediaType.TEXT_PLAIN);
responseHeaders.setContentLength(10);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
expect(response.getHeaders()).andReturn(responseHeaders).times(3);
given(response.getStatusCode()).willReturn(HttpStatus.OK);
given(response.getHeaders()).willReturn(responseHeaders);
Integer expected = 42;
expect(converter.canRead(Integer.class, MediaType.TEXT_PLAIN)).andReturn(true);
expect(converter.read(Integer.class, response)).andReturn(expected);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replayMocks();
given(converter.canRead(Integer.class, MediaType.TEXT_PLAIN)).willReturn(true);
given(converter.read(Integer.class, response)).willReturn(expected);
given(response.getStatusCode()).willReturn(HttpStatus.OK);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
HttpHeaders entityHeaders = new HttpHeaders();
entityHeaders.set("MyHeader", "MyValue");
@@ -657,38 +636,37 @@ public class RestTemplateTests {
assertEquals("Invalid custom header", "MyValue", requestHeaders.getFirst("MyHeader"));
assertEquals("Invalid status code", HttpStatus.OK, result.getStatusCode());
verifyMocks();
verify(response).close();
}
@Test
public void exchangeParameterizedType() throws Exception {
GenericHttpMessageConverter converter = createMock(GenericHttpMessageConverter.class);
GenericHttpMessageConverter converter = mock(GenericHttpMessageConverter.class);
template.setMessageConverters(Collections.<HttpMessageConverter<?>>singletonList(converter));
ParameterizedTypeReference<List<Integer>> intList = new ParameterizedTypeReference<List<Integer>>() {};
expect(converter.canRead(intList.getType(), null, null)).andReturn(true);
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).andReturn(this.request);
given(converter.canRead(intList.getType(), null, null)).willReturn(true);
given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
given(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).willReturn(this.request);
HttpHeaders requestHeaders = new HttpHeaders();
expect(this.request.getHeaders()).andReturn(requestHeaders).times(2);
expect(converter.canWrite(String.class, null)).andReturn(true);
given(this.request.getHeaders()).willReturn(requestHeaders);
given(converter.canWrite(String.class, null)).willReturn(true);
String requestBody = "Hello World";
converter.write(requestBody, null, this.request);
expect(this.request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
given(this.request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentType(MediaType.TEXT_PLAIN);
responseHeaders.setContentLength(10);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
expect(response.getHeaders()).andReturn(responseHeaders).times(3);
given(response.getStatusCode()).willReturn(HttpStatus.OK);
given(response.getHeaders()).willReturn(responseHeaders);
List<Integer> expected = Collections.singletonList(42);
expect(converter.canRead(intList.getType(), null, MediaType.TEXT_PLAIN)).andReturn(true);
expect(converter.read(intList.getType(), null, response)).andReturn(expected);
expect(response.getStatusCode()).andReturn(HttpStatus.OK);
addLogResponseStatusExpectations(HttpStatus.OK);
response.close();
replay(requestFactory, request, response, errorHandler, converter);
given(converter.canRead(intList.getType(), null, MediaType.TEXT_PLAIN)).willReturn(true);
given(converter.read(intList.getType(), null, response)).willReturn(expected);
given(response.getStatusCode()).willReturn(HttpStatus.OK);
HttpStatus status = HttpStatus.OK;
given(response.getStatusCode()).willReturn(status);
given(response.getStatusText()).willReturn(status.getReasonPhrase());
HttpHeaders entityHeaders = new HttpHeaders();
entityHeaders.set("MyHeader", "MyValue");
@@ -700,22 +678,6 @@ public class RestTemplateTests {
assertEquals("Invalid custom header", "MyValue", requestHeaders.getFirst("MyHeader"));
assertEquals("Invalid status code", HttpStatus.OK, result.getStatusCode());
verify(requestFactory, request, response, errorHandler, converter);
verify(response).close();
}
private void addLogResponseStatusExpectations(HttpStatus status) throws IOException {
expect(response.getStatusCode()).andReturn(status).times(0, 1);
expect(response.getStatusText()).andReturn(status.getReasonPhrase()).times(0, 1);
}
private void replayMocks() {
replay(requestFactory, request, response, errorHandler, converter);
}
private void verifyMocks() {
verify(requestFactory, request, response, errorHandler, converter);
}
}

27
spring-web/src/test/java/org/springframework/web/context/request/ServletRequestAttributesTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -17,15 +17,16 @@
package org.springframework.web.context.request;
import java.io.Serializable;
import javax.servlet.http.HttpServletRequest;
import org.easymock.MockControl;
import static org.junit.Assert.*;
import org.junit.Test;
import org.springframework.mock.web.test.MockHttpServletRequest;
import org.springframework.mock.web.test.MockHttpSession;
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
/**
* @author Rick Evans
* @author Juergen Hoeller
@@ -132,17 +133,12 @@ public class ServletRequestAttributesTests {
@Test
public void getSessionScopedAttributeDoesNotForceCreationOfSession() throws Exception {
MockControl mockRequest = MockControl.createControl(HttpServletRequest.class);
HttpServletRequest request = (HttpServletRequest) mockRequest.getMock();
request.getSession(false);
mockRequest.setReturnValue(null, 1);
mockRequest.replay();
HttpServletRequest request = mock(HttpServletRequest.class);
ServletRequestAttributes attrs = new ServletRequestAttributes(request);
Object value = attrs.getAttribute(KEY, RequestAttributes.SCOPE_SESSION);
assertNull(value);
mockRequest.verify();
verify(request).getSession(false);
}
@Test
@@ -159,16 +155,11 @@ public class ServletRequestAttributesTests {
@Test
public void removeSessionScopedAttributeDoesNotForceCreationOfSession() throws Exception {
MockControl mockRequest = MockControl.createControl(HttpServletRequest.class);
HttpServletRequest request = (HttpServletRequest) mockRequest.getMock();
request.getSession(false);
mockRequest.setReturnValue(null, 1);
mockRequest.replay();
HttpServletRequest request = mock(HttpServletRequest.class);
ServletRequestAttributes attrs = new ServletRequestAttributes(request);
attrs.removeAttribute(KEY, RequestAttributes.SCOPE_SESSION);
mockRequest.verify();
verify(request).getSession(false);
}
}

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

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,16 +16,12 @@
package org.springframework.web.context.request.async;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
import org.springframework.web.context.request.async.DeferredResult.DeferredResultHandler;
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
/**
* DeferredResult tests.
*
@@ -35,23 +31,18 @@ public class DeferredResultTests {
@Test
public void setResult() {
DeferredResultHandler handler = createMock(DeferredResultHandler.class);
handler.handleResult("hello");
replay(handler);
DeferredResultHandler handler = mock(DeferredResultHandler.class);
DeferredResult<String> result = new DeferredResult<String>();
result.setResultHandler(handler);
assertTrue(result.setResult("hello"));
verify(handler);
verify(handler).handleResult("hello");
}
@Test
public void setResultTwice() {
DeferredResultHandler handler = createMock(DeferredResultHandler.class);
handler.handleResult("hello");
replay(handler);
DeferredResultHandler handler = mock(DeferredResultHandler.class);
DeferredResult<String> result = new DeferredResult<String>();
result.setResultHandler(handler);
@@ -59,14 +50,12 @@ public class DeferredResultTests {
assertTrue(result.setResult("hello"));
assertFalse(result.setResult("hi"));
verify(handler);
verify(handler).handleResult("hello");
}
@Test
public void isSetOrExpired() {
DeferredResultHandler handler = createMock(DeferredResultHandler.class);
handler.handleResult("hello");
replay(handler);
DeferredResultHandler handler = mock(DeferredResultHandler.class);
DeferredResult<String> result = new DeferredResult<String>();
result.setResultHandler(handler);
@@ -77,7 +66,7 @@ public class DeferredResultTests {
assertTrue(result.isSetOrExpired());
verify(handler);
verify(handler).handleResult("hello");
}
@Test
@@ -102,9 +91,7 @@ public class DeferredResultTests {
public void onTimeout() throws Exception {
final StringBuilder sb = new StringBuilder();
DeferredResultHandler handler = createMock(DeferredResultHandler.class);
handler.handleResult("timeout result");
replay(handler);
DeferredResultHandler handler = mock(DeferredResultHandler.class);
DeferredResult<String> result = new DeferredResult<String>(null, "timeout result");
result.setResultHandler(handler);
@@ -119,7 +106,7 @@ public class DeferredResultTests {
assertEquals("timeout event", sb.toString());
assertFalse("Should not be able to set result a second time", result.setResult("hello"));
verify(handler);
verify(handler).handleResult("timeout result");
}
}

24
spring-web/src/test/java/org/springframework/web/context/request/async/StandardServletAsyncWebRequestTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -17,26 +17,18 @@
package org.springframework.web.context.request.async;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.hamcrest.Matchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import javax.servlet.AsyncEvent;
import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;
import org.springframework.mock.web.test.MockAsyncContext;
import org.springframework.mock.web.test.MockHttpServletRequest;
import org.springframework.mock.web.test.MockHttpServletResponse;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
/**
* A test fixture with a {@link StandardServletAsyncWebRequest}.
*
@@ -124,14 +116,12 @@ public class StandardServletAsyncWebRequestTests {
@Test
public void onTimeoutTimeoutHandler() throws Exception {
Runnable timeoutHandler = EasyMock.createMock(Runnable.class);
timeoutHandler.run();
replay(timeoutHandler);
Runnable timeoutHandler = mock(Runnable.class);
this.asyncRequest.addTimeoutHandler(timeoutHandler);
this.asyncRequest.onTimeout(new AsyncEvent(null));
verify(timeoutHandler);
verify(timeoutHandler).run();
}
@Test(expected=IllegalStateException.class)

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

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,30 +16,19 @@
package org.springframework.web.context.request.async;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.createStrictMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.notNull;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.reset;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.util.concurrent.Callable;
import javax.servlet.http.HttpServletRequest;
import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;
import org.springframework.core.task.AsyncTaskExecutor;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.mock.web.test.MockHttpServletRequest;
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
/**
* Test fixture with an {@link WebAsyncManager} with a mock AsyncWebRequest.
*
@@ -59,14 +48,9 @@ public class WebAsyncManagerTests {
this.servletRequest = new MockHttpServletRequest();
this.asyncManager = WebAsyncUtils.getAsyncManager(servletRequest);
this.asyncManager.setTaskExecutor(new SyncTaskExecutor());
this.asyncWebRequest = createStrictMock(AsyncWebRequest.class);
this.asyncWebRequest.addCompletionHandler((Runnable) notNull());
replay(this.asyncWebRequest);
this.asyncWebRequest = mock(AsyncWebRequest.class);
this.asyncManager.setAsyncWebRequest(this.asyncWebRequest);
verify(this.asyncWebRequest);
verify(this.asyncWebRequest).addCompletionHandler((Runnable) notNull());
reset(this.asyncWebRequest);
}
@@ -93,21 +77,14 @@ public class WebAsyncManagerTests {
@Test
public void isConcurrentHandlingStarted() {
expect(this.asyncWebRequest.isAsyncStarted()).andReturn(false);
replay(this.asyncWebRequest);
given(this.asyncWebRequest.isAsyncStarted()).willReturn(false);
assertFalse(this.asyncManager.isConcurrentHandlingStarted());
verify(this.asyncWebRequest);
reset(this.asyncWebRequest);
expect(this.asyncWebRequest.isAsyncStarted()).andReturn(true);
replay(this.asyncWebRequest);
given(this.asyncWebRequest.isAsyncStarted()).willReturn(true);
assertTrue(this.asyncManager.isConcurrentHandlingStarted());
verify(this.asyncWebRequest);
}
@Test(expected=IllegalArgumentException.class)
@@ -122,11 +99,7 @@ public class WebAsyncManagerTests {
int concurrentResult = 21;
Callable<Object> task = new StubCallable(concurrentResult);
CallableProcessingInterceptor interceptor = createStrictMock(CallableProcessingInterceptor.class);
interceptor.beforeConcurrentHandling(this.asyncWebRequest, task);
interceptor.preProcess(this.asyncWebRequest, task);
interceptor.postProcess(this.asyncWebRequest, task, new Integer(concurrentResult));
replay(interceptor);
CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class);
setupDefaultAsyncScenario();
@@ -136,7 +109,10 @@ public class WebAsyncManagerTests {
assertTrue(this.asyncManager.hasConcurrentResult());
assertEquals(concurrentResult, this.asyncManager.getConcurrentResult());
verify(interceptor, this.asyncWebRequest);
verifyDefaultAsyncScenario();
verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, task);
verify(interceptor).preProcess(this.asyncWebRequest, task);
verify(interceptor).postProcess(this.asyncWebRequest, task, new Integer(concurrentResult));
}
@Test
@@ -145,11 +121,7 @@ public class WebAsyncManagerTests {
Exception concurrentResult = new Exception();
Callable<Object> task = new StubCallable(concurrentResult);
CallableProcessingInterceptor interceptor = createStrictMock(CallableProcessingInterceptor.class);
interceptor.beforeConcurrentHandling(this.asyncWebRequest, task);
interceptor.preProcess(this.asyncWebRequest, task);
interceptor.postProcess(this.asyncWebRequest, task, concurrentResult);
replay(interceptor);
CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class);
setupDefaultAsyncScenario();
@@ -159,7 +131,10 @@ public class WebAsyncManagerTests {
assertTrue(this.asyncManager.hasConcurrentResult());
assertEquals(concurrentResult, this.asyncManager.getConcurrentResult());
verify(interceptor, this.asyncWebRequest);
verifyDefaultAsyncScenario();
verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, task);
verify(interceptor).preProcess(this.asyncWebRequest, task);
verify(interceptor).postProcess(this.asyncWebRequest, task, concurrentResult);
}
@Test
@@ -167,14 +142,8 @@ public class WebAsyncManagerTests {
Callable<Object> task = new StubCallable(21);
Exception exception = new Exception();
CallableProcessingInterceptor interceptor = createStrictMock(CallableProcessingInterceptor.class);
interceptor.beforeConcurrentHandling(this.asyncWebRequest, task);
expectLastCall().andThrow(exception);
replay(interceptor);
this.asyncWebRequest.addTimeoutHandler((Runnable) notNull());
this.asyncWebRequest.addCompletionHandler((Runnable) notNull());
replay(this.asyncWebRequest);
CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class);
willThrow(exception).given(interceptor).beforeConcurrentHandling(this.asyncWebRequest, task);
this.asyncManager.registerCallableInterceptor("interceptor", interceptor);
@@ -187,7 +156,8 @@ public class WebAsyncManagerTests {
assertFalse(this.asyncManager.hasConcurrentResult());
verify(this.asyncWebRequest, interceptor);
verify(this.asyncWebRequest).addTimeoutHandler((Runnable) notNull());
verify(this.asyncWebRequest).addCompletionHandler((Runnable) notNull());
}
@Test
@@ -196,11 +166,8 @@ public class WebAsyncManagerTests {
Callable<Object> task = new StubCallable(21);
Exception exception = new Exception();
CallableProcessingInterceptor interceptor = createStrictMock(CallableProcessingInterceptor.class);
interceptor.beforeConcurrentHandling(this.asyncWebRequest, task);
interceptor.preProcess(this.asyncWebRequest, task);
expectLastCall().andThrow(exception);
replay(interceptor);
CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class);
willThrow(exception).given(interceptor).preProcess(this.asyncWebRequest, task);
setupDefaultAsyncScenario();
@@ -210,7 +177,8 @@ public class WebAsyncManagerTests {
assertTrue(this.asyncManager.hasConcurrentResult());
assertEquals(exception, this.asyncManager.getConcurrentResult());
verify(interceptor, this.asyncWebRequest);
verifyDefaultAsyncScenario();
verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, task);
}
@Test
@@ -219,12 +187,8 @@ public class WebAsyncManagerTests {
Callable<Object> task = new StubCallable(21);
Exception exception = new Exception();
CallableProcessingInterceptor interceptor = createStrictMock(CallableProcessingInterceptor.class);
interceptor.beforeConcurrentHandling(this.asyncWebRequest, task);
interceptor.preProcess(this.asyncWebRequest, task);
interceptor.postProcess(this.asyncWebRequest, task, 21);
expectLastCall().andThrow(exception);
replay(interceptor);
CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class);
willThrow(exception).given(interceptor).postProcess(this.asyncWebRequest, task, 21);
setupDefaultAsyncScenario();
@@ -234,7 +198,9 @@ public class WebAsyncManagerTests {
assertTrue(this.asyncManager.hasConcurrentResult());
assertEquals(exception, this.asyncManager.getConcurrentResult());
verify(interceptor, this.asyncWebRequest);
verifyDefaultAsyncScenario();
verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, task);
verify(interceptor).preProcess(this.asyncWebRequest, task);
}
@Test
@@ -243,18 +209,9 @@ public class WebAsyncManagerTests {
Callable<Object> task = new StubCallable(21);
Exception exception = new Exception();
CallableProcessingInterceptor interceptor1 = createMock(CallableProcessingInterceptor.class);
interceptor1.beforeConcurrentHandling(this.asyncWebRequest, task);
interceptor1.preProcess(this.asyncWebRequest, task);
interceptor1.postProcess(this.asyncWebRequest, task, 21);
replay(interceptor1);
CallableProcessingInterceptor interceptor2 = createMock(CallableProcessingInterceptor.class);
interceptor2.beforeConcurrentHandling(this.asyncWebRequest, task);
interceptor2.preProcess(this.asyncWebRequest, task);
interceptor2.postProcess(this.asyncWebRequest, task, 21);
expectLastCall().andThrow(exception);
replay(interceptor2);
CallableProcessingInterceptor interceptor1 = mock(CallableProcessingInterceptor.class);
CallableProcessingInterceptor interceptor2 = mock(CallableProcessingInterceptor.class);
willThrow(exception).given(interceptor2).postProcess(this.asyncWebRequest, task, 21);
setupDefaultAsyncScenario();
@@ -264,30 +221,29 @@ public class WebAsyncManagerTests {
assertTrue(this.asyncManager.hasConcurrentResult());
assertEquals(exception, this.asyncManager.getConcurrentResult());
verify(interceptor1);
verify(interceptor2);
verify(this.asyncWebRequest);
verifyDefaultAsyncScenario();
verify(interceptor1).beforeConcurrentHandling(this.asyncWebRequest, task);
verify(interceptor1).preProcess(this.asyncWebRequest, task);
verify(interceptor1).postProcess(this.asyncWebRequest, task, 21);
verify(interceptor2).beforeConcurrentHandling(this.asyncWebRequest, task);
verify(interceptor2).preProcess(this.asyncWebRequest, task);
}
@Test
public void startCallableProcessingWithAsyncTask() throws Exception {
AsyncTaskExecutor executor = createMock(AsyncTaskExecutor.class);
expect(executor.submit((Runnable) notNull())).andReturn(null);
replay(executor);
this.asyncWebRequest.setTimeout(1000L);
this.asyncWebRequest.addTimeoutHandler(EasyMock.<Runnable>anyObject());
this.asyncWebRequest.addCompletionHandler(EasyMock.<Runnable>anyObject());
this.asyncWebRequest.startAsync();
expect(this.asyncWebRequest.getNativeRequest(HttpServletRequest.class)).andReturn(this.servletRequest).times(0, 1);
replay(this.asyncWebRequest);
AsyncTaskExecutor executor = mock(AsyncTaskExecutor.class);
given(this.asyncWebRequest.getNativeRequest(HttpServletRequest.class)).willReturn(this.servletRequest);
@SuppressWarnings("unchecked")
WebAsyncTask<Object> asyncTask = new WebAsyncTask<Object>(1000L, executor, createMock(Callable.class));
WebAsyncTask<Object> asyncTask = new WebAsyncTask<Object>(1000L, executor, mock(Callable.class));
this.asyncManager.startCallableProcessing(asyncTask);
verify(executor, this.asyncWebRequest);
verify(executor).submit((Runnable) notNull());
verify(this.asyncWebRequest).setTimeout(1000L);
verify(this.asyncWebRequest).addTimeoutHandler(any(Runnable.class));
verify(this.asyncWebRequest).addCompletionHandler(any(Runnable.class));
verify(this.asyncWebRequest).startAsync();
}
@Test
@@ -307,13 +263,8 @@ public class WebAsyncManagerTests {
DeferredResult<String> deferredResult = new DeferredResult<String>(1000L);
String concurrentResult = "abc";
DeferredResultProcessingInterceptor interceptor = createStrictMock(DeferredResultProcessingInterceptor.class);
interceptor.beforeConcurrentHandling(this.asyncWebRequest, deferredResult);
interceptor.preProcess(this.asyncWebRequest, deferredResult);
interceptor.postProcess(asyncWebRequest, deferredResult, concurrentResult);
replay(interceptor);
DeferredResultProcessingInterceptor interceptor = mock(DeferredResultProcessingInterceptor.class);
this.asyncWebRequest.setTimeout(1000L);
setupDefaultAsyncScenario();
this.asyncManager.registerDeferredResultInterceptor("interceptor", interceptor);
@@ -322,7 +273,11 @@ public class WebAsyncManagerTests {
deferredResult.setResult(concurrentResult);
assertEquals(concurrentResult, this.asyncManager.getConcurrentResult());
verify(this.asyncWebRequest, interceptor);
verifyDefaultAsyncScenario();
verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, deferredResult);
verify(interceptor).preProcess(this.asyncWebRequest, deferredResult);
verify(interceptor).postProcess(asyncWebRequest, deferredResult, concurrentResult);
verify(this.asyncWebRequest).setTimeout(1000L);
}
@Test
@@ -331,14 +286,8 @@ public class WebAsyncManagerTests {
DeferredResult<Integer> deferredResult = new DeferredResult<Integer>();
Exception exception = new Exception();
DeferredResultProcessingInterceptor interceptor = createStrictMock(DeferredResultProcessingInterceptor.class);
interceptor.beforeConcurrentHandling(this.asyncWebRequest, deferredResult);
expectLastCall().andThrow(exception);
replay(interceptor);
this.asyncWebRequest.addTimeoutHandler((Runnable) notNull());
this.asyncWebRequest.addCompletionHandler((Runnable) notNull());
replay(this.asyncWebRequest);
DeferredResultProcessingInterceptor interceptor = mock(DeferredResultProcessingInterceptor.class);
willThrow(exception).given(interceptor).beforeConcurrentHandling(this.asyncWebRequest, deferredResult);
this.asyncManager.registerDeferredResultInterceptor("interceptor", interceptor);
@@ -352,7 +301,8 @@ public class WebAsyncManagerTests {
assertFalse(this.asyncManager.hasConcurrentResult());
verify(this.asyncWebRequest, interceptor);
verify(this.asyncWebRequest).addTimeoutHandler((Runnable) notNull());
verify(this.asyncWebRequest).addCompletionHandler((Runnable) notNull());
}
@Test
@@ -361,11 +311,8 @@ public class WebAsyncManagerTests {
DeferredResult<Integer> deferredResult = new DeferredResult<Integer>();
Exception exception = new Exception();
DeferredResultProcessingInterceptor interceptor = createStrictMock(DeferredResultProcessingInterceptor.class);
interceptor.beforeConcurrentHandling(this.asyncWebRequest, deferredResult);
interceptor.preProcess(this.asyncWebRequest, deferredResult);
expectLastCall().andThrow(exception);
replay(interceptor);
DeferredResultProcessingInterceptor interceptor = mock(DeferredResultProcessingInterceptor.class);
willThrow(exception).given(interceptor).preProcess(this.asyncWebRequest, deferredResult);
setupDefaultAsyncScenario();
@@ -375,7 +322,8 @@ public class WebAsyncManagerTests {
deferredResult.setResult(25);
assertEquals(exception, this.asyncManager.getConcurrentResult());
verify(this.asyncWebRequest, interceptor);
verifyDefaultAsyncScenario();
verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, deferredResult);
}
@Test
@@ -384,12 +332,8 @@ public class WebAsyncManagerTests {
DeferredResult<Integer> deferredResult = new DeferredResult<Integer>();
Exception exception = new Exception();
DeferredResultProcessingInterceptor interceptor = createStrictMock(DeferredResultProcessingInterceptor.class);
interceptor.beforeConcurrentHandling(this.asyncWebRequest, deferredResult);
interceptor.preProcess(this.asyncWebRequest, deferredResult);
interceptor.postProcess(this.asyncWebRequest, deferredResult, 25);
expectLastCall().andThrow(exception);
replay(interceptor);
DeferredResultProcessingInterceptor interceptor = mock(DeferredResultProcessingInterceptor.class);
willThrow(exception).given(interceptor).postProcess(this.asyncWebRequest, deferredResult, 25);;
setupDefaultAsyncScenario();
@@ -399,7 +343,9 @@ public class WebAsyncManagerTests {
deferredResult.setResult(25);
assertEquals(exception, this.asyncManager.getConcurrentResult());
verify(this.asyncWebRequest, interceptor);
verifyDefaultAsyncScenario();
verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, deferredResult);
verify(interceptor).preProcess(this.asyncWebRequest, deferredResult);
}
@Test
@@ -414,15 +360,16 @@ public class WebAsyncManagerTests {
}
private void setupDefaultAsyncScenario() {
this.asyncWebRequest.addTimeoutHandler((Runnable) notNull());
this.asyncWebRequest.addCompletionHandler((Runnable) notNull());
this.asyncWebRequest.startAsync();
expect(this.asyncWebRequest.getNativeRequest(HttpServletRequest.class)).andReturn(this.servletRequest).times(0, 1);
expect(this.asyncWebRequest.isAsyncComplete()).andReturn(false);
this.asyncWebRequest.dispatch();
replay(this.asyncWebRequest);
given(this.asyncWebRequest.getNativeRequest(HttpServletRequest.class)).willReturn(this.servletRequest);
given(this.asyncWebRequest.isAsyncComplete()).willReturn(false);
}
private void verifyDefaultAsyncScenario() {
verify(this.asyncWebRequest).addTimeoutHandler((Runnable) notNull());
verify(this.asyncWebRequest).addCompletionHandler((Runnable) notNull());
verify(this.asyncWebRequest).startAsync();
verify(this.asyncWebRequest).dispatch();
}
private final class StubCallable implements Callable<Object> {

59
spring-web/src/test/java/org/springframework/web/context/request/async/WebAsyncManagerTimeoutTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,17 +16,6 @@
package org.springframework.web.context.request.async;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.createStrictMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.notNull;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.springframework.web.context.request.async.CallableProcessingInterceptor.RESULT_NONE;
import java.util.concurrent.Callable;
import javax.servlet.AsyncEvent;
@@ -40,6 +29,10 @@ import org.springframework.mock.web.test.MockHttpServletRequest;
import org.springframework.mock.web.test.MockHttpServletResponse;
import org.springframework.web.context.request.NativeWebRequest;
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
import static org.springframework.web.context.request.async.CallableProcessingInterceptor.*;
/**
* {@link WebAsyncManager} tests where container-triggered timeout/completion
* events are simulated.
@@ -65,9 +58,7 @@ public class WebAsyncManagerTimeoutTests {
this.servletResponse = new MockHttpServletResponse();
this.asyncWebRequest = new StandardServletAsyncWebRequest(servletRequest, servletResponse);
AsyncTaskExecutor executor = createMock(AsyncTaskExecutor.class);
expect(executor.submit((Runnable) notNull())).andReturn(null);
replay(executor);
AsyncTaskExecutor executor = mock(AsyncTaskExecutor.class);
this.asyncManager = WebAsyncUtils.getAsyncManager(servletRequest);
this.asyncManager.setTaskExecutor(executor);
@@ -79,11 +70,8 @@ public class WebAsyncManagerTimeoutTests {
StubCallable callable = new StubCallable();
CallableProcessingInterceptor interceptor = createStrictMock(CallableProcessingInterceptor.class);
interceptor.beforeConcurrentHandling(this.asyncWebRequest, callable);
expect(interceptor.handleTimeout(this.asyncWebRequest, callable)).andReturn(RESULT_NONE);
interceptor.afterCompletion(this.asyncWebRequest, callable);
replay(interceptor);
CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class);
given(interceptor.handleTimeout(this.asyncWebRequest, callable)).willReturn(RESULT_NONE);
this.asyncManager.registerCallableInterceptor("interceptor", interceptor);
this.asyncManager.startCallableProcessing(callable);
@@ -95,7 +83,8 @@ public class WebAsyncManagerTimeoutTests {
assertEquals(DispatcherType.REQUEST, this.servletRequest.getDispatcherType());
assertEquals(503, this.servletResponse.getStatus());
verify(interceptor);
verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, callable);
verify(interceptor).afterCompletion(this.asyncWebRequest, callable);
}
@Test
@@ -124,10 +113,8 @@ public class WebAsyncManagerTimeoutTests {
StubCallable callable = new StubCallable();
CallableProcessingInterceptor interceptor = createStrictMock(CallableProcessingInterceptor.class);
interceptor.beforeConcurrentHandling(this.asyncWebRequest, callable);
expect(interceptor.handleTimeout(this.asyncWebRequest, callable)).andReturn(22);
replay(interceptor);
CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class);
given(interceptor.handleTimeout(this.asyncWebRequest, callable)).willReturn(22);
this.asyncManager.registerCallableInterceptor("timeoutInterceptor", interceptor);
this.asyncManager.startCallableProcessing(callable);
@@ -138,7 +125,7 @@ public class WebAsyncManagerTimeoutTests {
assertEquals(22, this.asyncManager.getConcurrentResult());
assertEquals("/test", ((MockAsyncContext) this.servletRequest.getAsyncContext()).getDispatchedPath());
verify(interceptor);
verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, callable);
}
@Test
@@ -147,10 +134,8 @@ public class WebAsyncManagerTimeoutTests {
StubCallable callable = new StubCallable();
Exception exception = new Exception();
CallableProcessingInterceptor interceptor = createStrictMock(CallableProcessingInterceptor.class);
interceptor.beforeConcurrentHandling(this.asyncWebRequest, callable);
expect(interceptor.handleTimeout(this.asyncWebRequest, callable)).andThrow(exception);
replay(interceptor);
CallableProcessingInterceptor interceptor = mock(CallableProcessingInterceptor.class);
given(interceptor.handleTimeout(this.asyncWebRequest, callable)).willThrow(exception);
this.asyncManager.registerCallableInterceptor("timeoutInterceptor", interceptor);
this.asyncManager.startCallableProcessing(callable);
@@ -161,7 +146,7 @@ public class WebAsyncManagerTimeoutTests {
assertEquals(exception, this.asyncManager.getConcurrentResult());
assertEquals("/test", ((MockAsyncContext) this.servletRequest.getAsyncContext()).getDispatchedPath());
verify(interceptor);
verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, callable);
}
@Test
@@ -169,12 +154,8 @@ public class WebAsyncManagerTimeoutTests {
DeferredResult<Integer> deferredResult = new DeferredResult<Integer>();
DeferredResultProcessingInterceptor interceptor = createStrictMock(DeferredResultProcessingInterceptor.class);
interceptor.beforeConcurrentHandling(this.asyncWebRequest, deferredResult);
interceptor.preProcess(this.asyncWebRequest, deferredResult);
expect(interceptor.handleTimeout(this.asyncWebRequest, deferredResult)).andReturn(true);
interceptor.afterCompletion(this.asyncWebRequest, deferredResult);
replay(interceptor);
DeferredResultProcessingInterceptor interceptor = mock(DeferredResultProcessingInterceptor.class);
given(interceptor.handleTimeout(this.asyncWebRequest, deferredResult)).willReturn(true);
this.asyncManager.registerDeferredResultInterceptor("interceptor", interceptor);
this.asyncManager.startDeferredResultProcessing(deferredResult);
@@ -186,7 +167,9 @@ public class WebAsyncManagerTimeoutTests {
assertEquals(DispatcherType.REQUEST, this.servletRequest.getDispatcherType());
assertEquals(503, this.servletResponse.getStatus());
verify(interceptor);
verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, deferredResult);
verify(interceptor).preProcess(this.asyncWebRequest, deferredResult);
verify(interceptor).afterCompletion(this.asyncWebRequest, deferredResult);
}
@Test

137
spring-web/src/test/java/org/springframework/web/filter/CharacterEncodingFilterTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,14 +16,6 @@
package org.springframework.web.filter;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.notNull;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.same;
import static org.easymock.EasyMock.verify;
import javax.servlet.FilterChain;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@@ -33,9 +25,10 @@ import junit.framework.TestCase;
import org.springframework.mock.web.test.MockFilterConfig;
import org.springframework.mock.web.test.MockHttpServletResponse;
import org.springframework.mock.web.test.MockServletContext;
import org.springframework.web.context.request.async.WebAsyncUtils;
import org.springframework.web.util.WebUtils;
import static org.mockito.BDDMockito.*;
/**
* @author Rick Evans
* @author Juergen Hoeller
@@ -48,22 +41,13 @@ public class CharacterEncodingFilterTests extends TestCase {
public void testForceAlwaysSetsEncoding() throws Exception {
HttpServletRequest request = createMock(HttpServletRequest.class);
addAsyncManagerExpectations(request);
HttpServletRequest request = mock(HttpServletRequest.class);
request.setCharacterEncoding(ENCODING);
expect(request.getAttribute(WebUtils.ERROR_REQUEST_URI_ATTRIBUTE)).andReturn(null);
expect(request.getAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX)).andReturn(null);
request.setAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX, Boolean.TRUE);
request.removeAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX);
replay(request);
given(request.getAttribute(WebUtils.ERROR_REQUEST_URI_ATTRIBUTE)).willReturn(null);
given(request.getAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX)).willReturn(null);
HttpServletResponse response = createMock(HttpServletResponse.class);
response.setCharacterEncoding(ENCODING);
replay(response);
FilterChain filterChain = createMock(FilterChain.class);
filterChain.doFilter(request, response);
replay(filterChain);
HttpServletResponse response = mock(HttpServletResponse.class);
FilterChain filterChain = mock(FilterChain.class);
CharacterEncodingFilter filter = new CharacterEncodingFilter();
filter.setForceEncoding(true);
@@ -71,27 +55,21 @@ public class CharacterEncodingFilterTests extends TestCase {
filter.init(new MockFilterConfig(FILTER_NAME));
filter.doFilter(request, response, filterChain);
verify(request);
verify(response);
verify(filterChain);
verify(request).setAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX, Boolean.TRUE);
verify(request).removeAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX);
verify(response).setCharacterEncoding(ENCODING);
verify(filterChain).doFilter(request, response);
}
public void testEncodingIfEmptyAndNotForced() throws Exception {
HttpServletRequest request = createMock(HttpServletRequest.class);
addAsyncManagerExpectations(request);
expect(request.getCharacterEncoding()).andReturn(null);
request.setCharacterEncoding(ENCODING);
expect(request.getAttribute(WebUtils.ERROR_REQUEST_URI_ATTRIBUTE)).andReturn(null);
expect(request.getAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX)).andReturn(null);
request.setAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX, Boolean.TRUE);
request.removeAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX);
replay(request);
HttpServletRequest request = mock(HttpServletRequest.class);
given(request.getCharacterEncoding()).willReturn(null);
given(request.getAttribute(WebUtils.ERROR_REQUEST_URI_ATTRIBUTE)).willReturn(null);
given(request.getAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX)).willReturn(null);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = createMock(FilterChain.class);
filterChain.doFilter(request, response);
replay(filterChain);
FilterChain filterChain = mock(FilterChain.class);
CharacterEncodingFilter filter = new CharacterEncodingFilter();
filter.setForceEncoding(false);
@@ -99,51 +77,41 @@ public class CharacterEncodingFilterTests extends TestCase {
filter.init(new MockFilterConfig(FILTER_NAME));
filter.doFilter(request, response, filterChain);
verify(request);
verify(filterChain);
verify(request).setCharacterEncoding(ENCODING);
verify(request).setAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX, Boolean.TRUE);
verify(request).removeAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX);
verify(filterChain).doFilter(request, response);
}
public void testDoesNowtIfEncodingIsNotEmptyAndNotForced() throws Exception {
HttpServletRequest request = createMock(HttpServletRequest.class);
addAsyncManagerExpectations(request);
expect(request.getCharacterEncoding()).andReturn(ENCODING);
expect(request.getAttribute(WebUtils.ERROR_REQUEST_URI_ATTRIBUTE)).andReturn(null);
expect(request.getAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX)).andReturn(null);
request.setAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX, Boolean.TRUE);
request.removeAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX);
replay(request);
HttpServletRequest request = mock(HttpServletRequest.class);
given(request.getCharacterEncoding()).willReturn(ENCODING);
given(request.getAttribute(WebUtils.ERROR_REQUEST_URI_ATTRIBUTE)).willReturn(null);
given(request.getAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX)).willReturn(null);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = createMock(FilterChain.class);
filterChain.doFilter(request, response);
replay(filterChain);
FilterChain filterChain = mock(FilterChain.class);
CharacterEncodingFilter filter = new CharacterEncodingFilter();
filter.setEncoding(ENCODING);
filter.init(new MockFilterConfig(FILTER_NAME));
filter.doFilter(request, response, filterChain);
verify(request);
verify(filterChain);
verify(request).setAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX, Boolean.TRUE);
verify(request).removeAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX);
verify(filterChain).doFilter(request, response);
}
public void testWithBeanInitialization() throws Exception {
HttpServletRequest request = createMock(HttpServletRequest.class);
addAsyncManagerExpectations(request);
expect(request.getCharacterEncoding()).andReturn(null);
request.setCharacterEncoding(ENCODING);
expect(request.getAttribute(WebUtils.ERROR_REQUEST_URI_ATTRIBUTE)).andReturn(null);
expect(request.getAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX)).andReturn(null);
request.setAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX, Boolean.TRUE);
request.removeAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX);
replay(request);
HttpServletRequest request = mock(HttpServletRequest.class);
given(request.getCharacterEncoding()).willReturn(null);
given(request.getAttribute(WebUtils.ERROR_REQUEST_URI_ATTRIBUTE)).willReturn(null);
given(request.getAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX)).willReturn(null);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = createMock(FilterChain.class);
filterChain.doFilter(request, response);
replay(filterChain);
FilterChain filterChain = mock(FilterChain.class);
CharacterEncodingFilter filter = new CharacterEncodingFilter();
filter.setEncoding(ENCODING);
@@ -151,40 +119,29 @@ public class CharacterEncodingFilterTests extends TestCase {
filter.setServletContext(new MockServletContext());
filter.doFilter(request, response, filterChain);
verify(request);
verify(filterChain);
verify(request).setCharacterEncoding(ENCODING);
verify(request).setAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX, Boolean.TRUE);
verify(request).removeAttribute(FILTER_NAME + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX);
verify(filterChain).doFilter(request, response);
}
public void testWithIncompleteInitialization() throws Exception {
HttpServletRequest request = createMock(HttpServletRequest.class);
addAsyncManagerExpectations(request);
expect(request.getCharacterEncoding()).andReturn(null);
request.setCharacterEncoding(ENCODING);
expect(request.getAttribute(WebUtils.ERROR_REQUEST_URI_ATTRIBUTE)).andReturn(null);
expect(request.getAttribute(CharacterEncodingFilter.class.getName() + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX)).andReturn(null);
request.setAttribute(CharacterEncodingFilter.class.getName() + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX, Boolean.TRUE);
request.removeAttribute(CharacterEncodingFilter.class.getName() + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX);
replay(request);
HttpServletRequest request = mock(HttpServletRequest.class);
given(request.getCharacterEncoding()).willReturn(null);
given(request.getAttribute(WebUtils.ERROR_REQUEST_URI_ATTRIBUTE)).willReturn(null);
given(request.getAttribute(CharacterEncodingFilter.class.getName() + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX)).willReturn(null);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = createMock(FilterChain.class);
filterChain.doFilter(request, response);
replay(filterChain);
FilterChain filterChain = mock(FilterChain.class);
CharacterEncodingFilter filter = new CharacterEncodingFilter();
filter.setEncoding(ENCODING);
filter.doFilter(request, response, filterChain);
verify(request);
verify(filterChain);
}
private void addAsyncManagerExpectations(HttpServletRequest request) {
expect(request.getAttribute(WebAsyncUtils.WEB_ASYNC_MANAGER_ATTRIBUTE)).andReturn(null);
expectLastCall().anyTimes();
request.setAttribute(same(WebAsyncUtils.WEB_ASYNC_MANAGER_ATTRIBUTE), notNull());
expectLastCall().anyTimes();
verify(request).setCharacterEncoding(ENCODING);
verify(request).setAttribute(CharacterEncodingFilter.class.getName() + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX, Boolean.TRUE);
verify(request).removeAttribute(CharacterEncodingFilter.class.getName() + OncePerRequestFilter.ALREADY_FILTERED_SUFFIX);
verify(filterChain).doFilter(request, response);
}
}

39
spring-web/src/test/java/org/springframework/web/method/annotation/ModelAttributeMethodProcessorTests.java
View File

@@ -22,10 +22,9 @@ import java.lang.reflect.Method;
import org.junit.Before;
import org.junit.Test;
import org.springframework.tests.sample.beans.TestBean;
import org.springframework.core.MethodParameter;
import org.springframework.mock.web.test.MockHttpServletRequest;
import org.springframework.tests.sample.beans.TestBean;
import org.springframework.validation.BindException;
import org.springframework.validation.BindingResult;
import org.springframework.validation.Errors;
@@ -37,13 +36,14 @@ import org.springframework.web.bind.support.WebRequestDataBinder;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.method.annotation.ModelAttributeMethodProcessor;
import org.springframework.web.method.support.ModelAndViewContainer;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import static org.easymock.EasyMock.*;
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
import static org.mockito.Matchers.*;
import static org.mockito.Mockito.*;
/**
* Test fixture with {@link ModelAttributeMethodProcessor}.
@@ -153,26 +153,23 @@ public class ModelAttributeMethodProcessorTests {
mavContainer.addAttribute(expectedAttributeName, target);
WebDataBinder dataBinder = new WebRequestDataBinder(target);
WebDataBinderFactory factory = createMock(WebDataBinderFactory.class);
expect(factory.createBinder(webRequest, target, expectedAttributeName)).andReturn(dataBinder);
replay(factory);
WebDataBinderFactory factory = mock(WebDataBinderFactory.class);
given(factory.createBinder(webRequest, target, expectedAttributeName)).willReturn(dataBinder);
processor.resolveArgument(param, mavContainer, webRequest, factory);
verify(factory);
verify(factory).createBinder(webRequest, target, expectedAttributeName);
}
@Test
public void resovleArgumentViaDefaultConstructor() throws Exception {
WebDataBinder dataBinder = new WebRequestDataBinder(null);
WebDataBinderFactory factory = createMock(WebDataBinderFactory.class);
expect(factory.createBinder((NativeWebRequest) anyObject(), notNull(), eq("attrName"))).andReturn(dataBinder);
replay(factory);
WebDataBinderFactory factory = mock(WebDataBinderFactory.class);
given(factory.createBinder((NativeWebRequest) anyObject(), notNull(), eq("attrName"))).willReturn(dataBinder);
processor.resolveArgument(paramNamedValidModelAttr, mavContainer, webRequest, factory);
verify(factory);
verify(factory).createBinder((NativeWebRequest) anyObject(), notNull(), eq("attrName"));
}
@Test
@@ -182,9 +179,8 @@ public class ModelAttributeMethodProcessorTests {
mavContainer.addAttribute(name, target);
StubRequestDataBinder dataBinder = new StubRequestDataBinder(target, name);
WebDataBinderFactory binderFactory = createMock(WebDataBinderFactory.class);
expect(binderFactory.createBinder(webRequest, target, name)).andReturn(dataBinder);
replay(binderFactory);
WebDataBinderFactory binderFactory = mock(WebDataBinderFactory.class);
given(binderFactory.createBinder(webRequest, target, name)).willReturn(dataBinder);
processor.resolveArgument(paramNamedValidModelAttr, mavContainer, webRequest, binderFactory);
@@ -201,11 +197,11 @@ public class ModelAttributeMethodProcessorTests {
StubRequestDataBinder dataBinder = new StubRequestDataBinder(target, name);
dataBinder.getBindingResult().reject("error");
WebDataBinderFactory binderFactory = createMock(WebDataBinderFactory.class);
expect(binderFactory.createBinder(webRequest, target, name)).andReturn(dataBinder);
replay(binderFactory);
WebDataBinderFactory binderFactory = mock(WebDataBinderFactory.class);
given(binderFactory.createBinder(webRequest, target, name)).willReturn(dataBinder);
processor.resolveArgument(paramNonSimpleType, mavContainer, webRequest, binderFactory);
verify(binderFactory).createBinder(webRequest, target, name);
}
// SPR-9378
@@ -221,9 +217,8 @@ public class ModelAttributeMethodProcessorTests {
mavContainer.addAttribute("anotherTestBean", anotherTestBean);
StubRequestDataBinder dataBinder = new StubRequestDataBinder(testBean, name);
WebDataBinderFactory binderFactory = createMock(WebDataBinderFactory.class);
expect(binderFactory.createBinder(webRequest, testBean, name)).andReturn(dataBinder);
replay(binderFactory);
WebDataBinderFactory binderFactory = mock(WebDataBinderFactory.class);
given(binderFactory.createBinder(webRequest, testBean, name)).willReturn(dataBinder);
processor.resolveArgument(paramModelAttr, mavContainer, webRequest, binderFactory);

29
spring-web/src/test/java/org/springframework/web/method/annotation/ModelFactoryTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,16 +16,6 @@
package org.springframework.web.method.annotation;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.lang.reflect.Method;
import java.util.Arrays;
@@ -48,6 +38,9 @@ import org.springframework.web.method.support.HandlerMethodArgumentResolverCompo
import org.springframework.web.method.support.InvocableHandlerMethod;
import org.springframework.web.method.support.ModelAndViewContainer;
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
/**
* Text fixture for {@link ModelFactory} tests.
*
@@ -153,9 +146,8 @@ public class ModelFactoryTests {
mavContainer.addAttribute(attrName, attrValue);
WebDataBinder dataBinder = new WebDataBinder(attrValue, attrName);
WebDataBinderFactory binderFactory = createMock(WebDataBinderFactory.class);
expect(binderFactory.createBinder(webRequest, attrValue, attrName)).andReturn(dataBinder);
replay(binderFactory);
WebDataBinderFactory binderFactory = mock(WebDataBinderFactory.class);
given(binderFactory.createBinder(webRequest, attrValue, attrName)).willReturn(dataBinder);
ModelFactory modelFactory = new ModelFactory(null, binderFactory, sessionAttrsHandler);
modelFactory.updateModel(webRequest, mavContainer);
@@ -163,8 +155,6 @@ public class ModelFactoryTests {
assertEquals(attrValue, mavContainer.getModel().remove(attrName));
assertSame(dataBinder.getBindingResult(), mavContainer.getModel().remove(bindingResultKey(attrName)));
assertEquals(0, mavContainer.getModel().size());
verify(binderFactory);
}
@Test
@@ -181,17 +171,14 @@ public class ModelFactoryTests {
assertTrue(sessionAttrsHandler.isHandlerSessionAttribute(attrName, null));
WebDataBinder dataBinder = new WebDataBinder(attrValue, attrName);
WebDataBinderFactory binderFactory = createMock(WebDataBinderFactory.class);
expect(binderFactory.createBinder(webRequest, attrValue, attrName)).andReturn(dataBinder);
replay(binderFactory);
WebDataBinderFactory binderFactory = mock(WebDataBinderFactory.class);
given(binderFactory.createBinder(webRequest, attrValue, attrName)).willReturn(dataBinder);
ModelFactory modelFactory = new ModelFactory(null, binderFactory, sessionAttrsHandler);
modelFactory.updateModel(webRequest, mavContainer);
assertEquals(attrValue, mavContainer.getModel().get(attrName));
assertNull(sessionAttributeStore.retrieveAttribute(webRequest, attrName));
verify(binderFactory);
}
private String bindingResultKey(String key) {

58
spring-web/src/test/java/org/springframework/web/method/annotation/WebArgumentResolverAdapterTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,14 +16,6 @@
package org.springframework.web.method.annotation;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -34,6 +26,9 @@ import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletWebRequest;
import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*;
/**
* Test fixture with {@link WebArgumentResolverAdapterTests}.
*
@@ -52,7 +47,7 @@ public class WebArgumentResolverAdapterTests {
@Before
public void setUp() throws Exception {
adaptee = createMock(WebArgumentResolver.class);
adaptee = mock(WebArgumentResolver.class);
adapter = new TestWebArgumentResolverAdapter(adaptee);
parameter = new MethodParameter(getClass().getMethod("handle", Integer.TYPE), 0);
webRequest = new ServletWebRequest(new MockHttpServletRequest());
@@ -68,85 +63,68 @@ public class WebArgumentResolverAdapterTests {
@Test
public void supportsParameter() throws Exception {
expect(adaptee.resolveArgument(parameter, webRequest)).andReturn(42);
replay(adaptee);
given(adaptee.resolveArgument(parameter, webRequest)).willReturn(42);
assertTrue("Parameter not supported", adapter.supportsParameter(parameter));
verify(adaptee);
verify(adaptee).resolveArgument(parameter, webRequest);
}
@Test
public void supportsParameterUnresolved() throws Exception {
expect(adaptee.resolveArgument(parameter, webRequest)).andReturn(WebArgumentResolver.UNRESOLVED);
replay(adaptee);
given(adaptee.resolveArgument(parameter, webRequest)).willReturn(WebArgumentResolver.UNRESOLVED);
assertFalse("Parameter supported", adapter.supportsParameter(parameter));
verify(adaptee);
verify(adaptee).resolveArgument(parameter, webRequest);
}
@Test
public void supportsParameterWrongType() throws Exception {
expect(adaptee.resolveArgument(parameter, webRequest)).andReturn("Foo");
replay(adaptee);
given(adaptee.resolveArgument(parameter, webRequest)).willReturn("Foo");
assertFalse("Parameter supported", adapter.supportsParameter(parameter));
verify(adaptee);
verify(adaptee).resolveArgument(parameter, webRequest);
}
@Test
public void supportsParameterThrowsException() throws Exception {
expect(adaptee.resolveArgument(parameter, webRequest)).andThrow(new Exception());
replay(adaptee);
given(adaptee.resolveArgument(parameter, webRequest)).willThrow(new Exception());
assertFalse("Parameter supported", adapter.supportsParameter(parameter));
verify(adaptee);
verify(adaptee).resolveArgument(parameter, webRequest);
}
@Test
public void resolveArgument() throws Exception {
int expected = 42;
expect(adaptee.resolveArgument(parameter, webRequest)).andReturn(expected);
replay(adaptee);
given(adaptee.resolveArgument(parameter, webRequest)).willReturn(expected);
Object result = adapter.resolveArgument(parameter, null, webRequest, null);
assertEquals("Invalid result", expected, result);
verify(adaptee);
}
@Test(expected = IllegalStateException.class)
public void resolveArgumentUnresolved() throws Exception {
expect(adaptee.resolveArgument(parameter, webRequest)).andReturn(WebArgumentResolver.UNRESOLVED);
replay(adaptee);
given(adaptee.resolveArgument(parameter, webRequest)).willReturn(WebArgumentResolver.UNRESOLVED);
adapter.resolveArgument(parameter, null, webRequest, null);
verify(adaptee);
}
@Test(expected = IllegalStateException.class)
public void resolveArgumentWrongType() throws Exception {
expect(adaptee.resolveArgument(parameter, webRequest)).andReturn("Foo");
replay(adaptee);
given(adaptee.resolveArgument(parameter, webRequest)).willReturn("Foo");
adapter.resolveArgument(parameter, null, webRequest, null);
verify(adaptee);
}
@Test(expected = Exception.class)
public void resolveArgumentThrowsException() throws Exception {
expect(adaptee.resolveArgument(parameter, webRequest)).andThrow(new Exception());
replay(adaptee);
given(adaptee.resolveArgument(parameter, webRequest)).willThrow(new Exception());
adapter.resolveArgument(parameter, null, webRequest, null);
verify(adaptee);
}
public void handle(int param) {
@@ -164,4 +142,4 @@ public class WebArgumentResolverAdapterTests {
}
}
}
}

21
spring-web/src/test/java/org/springframework/web/multipart/support/ByteArrayMultipartFileEditorTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2006 the original author or authors.
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -19,10 +19,11 @@ package org.springframework.web.multipart.support;
import java.io.IOException;
import junit.framework.TestCase;
import org.easymock.MockControl;
import org.springframework.web.multipart.MultipartFile;
import static org.mockito.BDDMockito.*;
/**
* @author Rick Evans
*/
@@ -63,30 +64,22 @@ public final class ByteArrayMultipartFileEditorTests extends TestCase {
public void testSetValueAsMultipartFile() throws Exception {
String expectedValue = "That is comforting to know";
ByteArrayMultipartFileEditor editor = new ByteArrayMultipartFileEditor();
MockControl mock = MockControl.createControl(MultipartFile.class);
MultipartFile file = (MultipartFile) mock.getMock();
file.getBytes();
mock.setReturnValue(expectedValue.getBytes());
mock.replay();
MultipartFile file = mock(MultipartFile.class);
given(file.getBytes()).willReturn(expectedValue.getBytes());
editor.setValue(file);
assertEquals(expectedValue, editor.getAsText());
mock.verify();
}
public void testSetValueAsMultipartFileWithBadBytes() throws Exception {
ByteArrayMultipartFileEditor editor = new ByteArrayMultipartFileEditor();
MockControl mock = MockControl.createControl(MultipartFile.class);
MultipartFile file = (MultipartFile) mock.getMock();
file.getBytes();
mock.setThrowable(new IOException());
mock.replay();
MultipartFile file = mock(MultipartFile.class);
given(file.getBytes()).willThrow(new IOException());
try {
editor.setValue(file);
fail("Must have thrown an IllegalArgumentException: IOException thrown when reading MultipartFile bytes");
}
catch (IllegalArgumentException expected) {
}
mock.verify();
}
}