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

Merge branch '3.2.x'

Browse Source 
* 3.2.x: (28 commits)
  Hide 'doc' changes from jdiff reports
  Document @Bean 'lite' mode vs @Configuration
  Final preparations for 3.2.2
  Remove Tiles 3 configuration method
  Polishing
  Extracted buildRequestAttributes template method from FrameworkServlet
  Added "beforeExistingAdvisors" flag to AbstractAdvisingBeanPostProcessor
  Minor refinements along the way of researching static CGLIB callbacks
  Compare Kind references before checking log levels
  Polish Javadoc in RequestAttributes
  Fix copy-n-paste errors in NativeWebRequest
  Fix issue with restoring included attributes
  Add additional test for daylight savings glitch
  Document context hierarchy support in the TCF
  Fix test for daylight savings glitch
  Make the methodParameter field of HandlerMethod final
  Disable AsyncTests in spring-test-mvc
  Reformat the testing chapter
  Document context hierarchy support in the TCF
  Document context hierarchy support in the TCF
  ...
This commit is contained in:
Phillip Webb
2013-03-13 14:01:46 -07:00
parent ce4be3b46b f62f697550
commit 4e1cab28df
267 changed files with 8384 additions and 6246 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
spring-web/src/main/java/org/springframework/web/context/request/NativeWebRequest.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.
@@ -56,13 +56,13 @@ public interface NativeWebRequest extends WebRequest {
<T> T getNativeRequest(Class<T> requiredType);
/**
* Return the underlying native request object, if available.
* Return the underlying native response object, if available.
* @param requiredType the desired type of response object
* @return the matching response object, or {@code null} if none
* of that type is available
* @see javax.servlet.http.HttpServletRequest
* @see javax.portlet.ActionRequest
* @see javax.portlet.RenderRequest
* @see javax.servlet.http.HttpServletResponse
* @see javax.portlet.ActionResponse
* @see javax.portlet.RenderResponse
*/
<T> T getNativeResponse(Class<T> requiredType);

6
spring-web/src/main/java/org/springframework/web/context/request/RequestAttributes.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.
@@ -135,14 +135,14 @@ public interface RequestAttributes {
/**
* Return an id for the current underlying session.
* @return the session id as String (never {@code null}
* @return the session id as String (never {@code null})
*/
String getSessionId();
/**
* Expose the best available mutex for the underlying session:
* that is, an object to synchronize on for the underlying session.
* @return the session mutex to use (never {@code null}
* @return the session mutex to use (never {@code null})
*/
Object getSessionMutex();

40
spring-web/src/main/java/org/springframework/web/method/HandlerMethod.java
View File

@@ -54,7 +54,7 @@ public class HandlerMethod {
private final BeanFactory beanFactory;
private MethodParameter[] parameters;
private final MethodParameter[] parameters;
private final Method bridgedMethod;
@@ -69,6 +69,16 @@ public class HandlerMethod {
this.beanFactory = null;
this.method = method;
this.bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
this.parameters = initMethodParameters();
}
private MethodParameter[] initMethodParameters() {
int count = this.bridgedMethod.getParameterTypes().length;
MethodParameter[] result = new MethodParameter[count];
for (int i = 0; i < count; i++) {
result[i] = new HandlerMethodParameter(i);
}
return result;
}
/**
@@ -82,6 +92,7 @@ public class HandlerMethod {
this.beanFactory = null;
this.method = bean.getClass().getMethod(methodName, parameterTypes);
this.bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
this.parameters = initMethodParameters();
}
/**
@@ -99,10 +110,11 @@ public class HandlerMethod {
this.beanFactory = beanFactory;
this.method = method;
this.bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
this.parameters = initMethodParameters();
}
/**
* Create an instance from another {@code HandlerMethod}.
* Copy constructor for use in sub-classes.
*/
protected HandlerMethod(HandlerMethod handlerMethod) {
Assert.notNull(handlerMethod, "HandlerMethod is required");
@@ -113,6 +125,19 @@ public class HandlerMethod {
this.parameters = handlerMethod.parameters;
}
/**
* Re-create HandlerMethod with the resolved handler.
*/
private HandlerMethod(HandlerMethod handlerMethod, Object handler) {
Assert.notNull(handlerMethod, "handlerMethod is required");
Assert.notNull(handler, "handler is required");
this.bean = handler;
this.beanFactory = handlerMethod.beanFactory;
this.method = handlerMethod.method;
this.bridgedMethod = handlerMethod.bridgedMethod;
this.parameters = handlerMethod.parameters;
}
/**
* Returns the bean for this handler method.
*/
@@ -150,13 +175,6 @@ public class HandlerMethod {
* Returns the method parameters for this handler method.
*/
public MethodParameter[] getMethodParameters() {
if (this.parameters == null) {
int parameterCount = this.bridgedMethod.getParameterTypes().length;
this.parameters = new MethodParameter[parameterCount];
for (int i = 0; i < parameterCount; i++) {
this.parameters[i] = new HandlerMethodParameter(i);
}
}
return this.parameters;
}
@@ -201,9 +219,7 @@ public class HandlerMethod {
String beanName = (String) this.bean;
handler = this.beanFactory.getBean(beanName);
}
HandlerMethod handlerMethod = new HandlerMethod(handler, this.method);
handlerMethod.parameters = getMethodParameters();
return handlerMethod;
return new HandlerMethod(this, handler);
}
@Override

6
spring-web/src/main/java/org/springframework/web/util/UriComponentsBuilder.java
View File

@@ -48,6 +48,7 @@ import org.springframework.web.util.HierarchicalUriComponents.PathComponent;
* @author Arjen Poutsma
* @author Rossen Stoyanchev
* @author Phillip Webb
* @author Oliver Gierke
* @since 3.1
* @see #newInstance()
* @see #fromPath(String)
@@ -204,7 +205,10 @@ public class UriComponentsBuilder {
builder.path(path);
builder.query(query);
}
builder.fragment(fragment);
if (StringUtils.hasText(fragment)) {
builder.fragment(fragment);
}
return builder;
}

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));
}
}

11
spring-web/src/test/java/org/springframework/mock/web/test/MockServletContext.java
View File

@@ -45,7 +45,6 @@ import javax.servlet.descriptor.JspConfigDescriptor;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
@@ -258,9 +257,17 @@ public class MockServletContext implements ServletContext {
return this.effectiveMinorVersion;
}
/**
* This method uses the Java Activation framework, which returns
* "application/octet-stream" when the mime type is unknown (i.e. it never returns
* {@code null}). In order to maintain the {@link ServletContext#getMimeType(String)
* contract, as of version 3.2.2, this method returns null if the mimeType is
* "application/octet-stream".
*/
@Override
public String getMimeType(String filePath) {
return MimeTypeResolver.getMimeType(filePath);
String mimeType = MimeTypeResolver.getMimeType(filePath);
return ("application/octet-stream".equals(mimeType)) ? null : mimeType;
}
@Override

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());
}
}

6
spring-web/src/test/java/org/springframework/web/accept/PathExtensionContentNegotiationStrategyTests.java
View File

@@ -74,10 +74,12 @@ public class PathExtensionContentNegotiationStrategyTests {
assertEquals(Arrays.asList(new MediaType("application", "vnd.ms-excel")), mediaTypes);
}
// SPR-10334
@Test
public void getMediaTypeFromFilenameNoJaf() {
this.servletRequest.setRequestURI("test.xls");
this.servletRequest.setRequestURI("test.json");
ServletContext servletContext = this.servletRequest.getServletContext();
PathExtensionContentNegotiationStrategy strategy =
@@ -86,7 +88,7 @@ public class PathExtensionContentNegotiationStrategyTests {
List<MediaType> mediaTypes = strategy.resolveMediaTypes(this.webRequest);
assertEquals(Arrays.asList(MediaType.APPLICATION_OCTET_STREAM), mediaTypes);
assertEquals(Collections.emptyList(), mediaTypes);
}
// SPR-8678

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();
}
}

11
spring-web/src/test/java/org/springframework/web/util/UriComponentsBuilderTests.java
View File

@@ -23,16 +23,16 @@ import java.util.HashMap;
import java.util.Map;
import org.junit.Test;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.*;
/**
* @author Arjen Poutsma
* @author Phillip Webb
* @author Oliver Gierke
*/
public class UriComponentsBuilderTests {
@@ -354,4 +354,11 @@ public class UriComponentsBuilderTests {
assertThat(UriComponentsBuilder.fromUriString("http://example.com/abc/").path("/x/").path("/y/z").build().toString(), equalTo("http://example.com/abc/x/y/z"));
assertThat(UriComponentsBuilder.fromUriString("http://example.com/abc/").pathSegment("x").path("y").build().toString(), equalTo("http://example.com/abc/x/y"));
}
@Test
public void parsesEmptyFragment() {
UriComponents components = UriComponentsBuilder.fromUriString("/example#").build();
assertThat(components.getFragment(), is(nullValue()));
assertThat(components.toString(), equalTo("/example"));
}
}