JUnit：无法模拟RestTemplate对象以调用postForObject方法

Question

我是Mockito和Spring的RestTemplate的新手。我正在为某个功能进行JUnit测试，该功能可以将请求发送到Web服务并通过使用RestTemplate获得响应。我希望服务器以我想要的响应进行响应，以便我可以基于此响应测试功能。我正在使用Mockito进行嘲笑。

我不确定我要去哪里错。我不是在制作适当的模拟游戏吗？我的JSON对象映射器是否配置不正确？

定义RestTemplate bean的配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

        <bean id="restTemplate" class="org.springframework.web.client.RestTemplate">
        <property name="messageConverters">
            <list>
                <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />
                <bean class="org.springframework.http.converter.xml.SourceHttpMessageConverter"/>
                <bean class="org.springframework.http.converter.xml.MarshallingHttpMessageConverter">
                    <property name="marshaller"  ref="xsStreamMarshaller" />
                    <property name="unmarshaller" ref="xsStreamMarshaller" />
                </bean>
            </list>
        </property>
    </bean>    
    <bean id="xsStreamMarshaller" class="org.springframework.oxm.xstream.XStreamMarshaller"></bean>
</beans>

我的DTO：

import org.codehaus.jackson.annotate.JsonWriteNullProperties;

@JsonWriteNullProperties(false)
public abstract class BaseDTO {

    protected boolean error;

    public boolean isError() {
        return error;
    }

    public void setError(boolean error) {
        this.error = error;
    }

}

public class ChildDTO extends CommercialBaseDTO {   

    private String fullName;    

    public String getFullName() {
        return fullName;
    }

    public void setFullName(String fullName) {
        this.fullName = fullName;
    }
}

包含要测试的方法的类：

package com.exmpale.mypackage;  

import org.springframework.web.client.RestTemplate;

@Component
public class MyUtilClass {

    @Autowired
    private RestTemplate restTemplate;

    public RestTemplate getRestTemplate(){
        return restTemplate;
    }

    public void setRestTemplate(RestTemplate restTemplate){
        this.restTemplate = restTemplate;
    }

    // Method to test       
    public ChildDTO getChildDTO(MyUser myUser, HttpServletRequest request, HttpServletResponse response)
    {
        response.setContentType("application/json");        

        //Nothing much here, it takes the myUser and convert into childDTO  
        ChildDTO childDTO = new MyUtilClass().getDTOFromUser(request, myUser);  

        //This is the restTemplate that iam trying to mock.
        childDTO = restTemplate.postForObject("http://www.google.com", childDTO, ChildDTO.class);

        if (childDTO.isError()) {
            //Then do some stuff.........           
        }
        return childDTO;
    }
}

JUnit测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"test-config.xml"})
public class MyUtilClassTest {

    @InjectMocks
    RestTemplate restTemplate= new RestTemplate();

    private MockRestServiceServer mockServer;

    @Before
    public void setUp() throws Exception {

        MockitoAnnotations.initMocks(this);

        //Creating the mock server      

        //Add message conveters
        List<HttpMessageConverter<?>> messageConverters = new ArrayList<HttpMessageConverter<?>>();
        messageConverters.add(new FormHttpMessageConverter());
        messageConverters.add(new StringHttpMessageConverter());
        messageConverters.add(new MappingJacksonHttpMessageConverter());

        //Create Object mapper
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.configure( DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        objectMapper.configure( SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS, false);
        objectMapper.configure( SerializationConfig.Feature.AUTO_DETECT_FIELDS, true);
        objectMapper.configure( SerializationConfig.Feature.AUTO_DETECT_GETTERS,true);
        objectMapper.configure( SerializationConfig.Feature.AUTO_DETECT_IS_GETTERS,true);
        MappingJacksonHttpMessageConverter jsonMessageConverter = new MappingJacksonHttpMessageConverter();
        jsonMessageConverter.setObjectMapper(objectMapper);
        messageConverters.add(jsonMessageConverter);

        //Set the message converters 
        restTemplate.setMessageConverters(messageConverters);        
        mockServer = MockRestServiceServer.createServer(restTemplate);
    }

    @Test
    public void testGetChildDTO()throws Exception {

        MyUtilClass myUtil = new MyUtilClass();         
        MyUser myUser = new MyUser();

        HttpServletRequest request = new HttpServletRequestWrapper(new MockHttpServletRequest());
        HttpServletResponse response = new HttpServletResponseWrapper(new MockHttpServletResponse());       

        //create the mocks for ChildDTO. I want MyUtilClass().getDTOFromUser(request, myUser) to return this.
        ChildDTO childDTOMock_One =  Mockito.mock(ChildDTO);            

        //Want this to be returned when restTemplate.postForObject() is called.
        ChildDTO childDTOMock_Two =  Mockito.mock(ChildDTO.class);
        childDTOMock_Two.setError(false);

        //create the mocks for userMgntUtils
        MyUtilClass myUtilClassMock =  Mockito.mock(MyUtilClass.class);     

        //stub the method getDTOFromUser() to return the mock object. I need this mock to be passed to 'postForObject()'
        Mockito.when(myUtilClassMock.getDTOFromUser(request, myUser)).thenReturn(childDTOMock_One);

        String responseJSON="{\"error\":false}";

        //set the expectation values for mockServer
        mockServer.expect( requestTo("http://www.google.com")).andExpect(method(HttpMethod.POST)).andRespond(withSuccess(responseJSON,MediaType.APPLICATION_JSON));

        //set the expectation values for restTemplate
        Mockito.when(restTemplate.postForObject( "http://www.google.com", childDTOMock_One, ChildDTO.class)).thenReturn(childDTOMock_Two);

        TypedUserDTO result = userMgmtUtils.getUserProfileDTO(registerUser, request, response, action);
        assertNotNull(result);
    }
}

得到以下异常：

org.springframework.http.converter.HttpMessageNotWritableException：无法编写JSON：找不到针对类org.mockito.internal.stubbing.defaultanswers.GloballyConfiguredAnswer的序列化程序，也没有发现创建BeanSerializer的属性（为避免异常，请禁用SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS） ）（通过参考链：com.biogenidec.dto.TypedUserDTO $$ EnhancerByMockitoWithCGLIB $$ bee3c447 [“ callbacks”]-> org.mockito.internal.creation.MethodInterceptorFilter [“ handler”]-> org.mockito.internal.handler。 InvocationNotifierHandler [“ mockSettings”]-> org.mockito.internal.creation.settings.CreationSettings [“ defaultAnswer”]））; 嵌套的异常是org.codehaus.jackson.map.JsonMappingException：没有为org.mockito.internal.stubbing.defaultanswers类找到序列化程序。

和：

Caused by: org.codehaus.jackson.map.JsonMappingException: No serializer found for class org.mockito.internal.stubbing.defaultanswers.GloballyConfiguredAnswer and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS) ) (through reference chain: com.biogenidec.dto.TypedUserDTO$$EnhancerByMockitoWithCGLIB$$bee3c447["callbacks"]->org.mockito.internal.creation.MethodInterceptorFilter["handler"]->org.mockito.internal.handler.InvocationNotifierHandler["mockSettings"]->org.mockito.internal.creation.settings.CreationSettings["defaultAnswer"])

Answer 1

Mockito的想法是测试类，并且不测试任何依赖项。因此，如果您MyUtilClass要进行测试，则希望模拟RestTemplate该类。而且您的@InjectMocks位于错误的类中，请参见下文。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"test-config.xml"})
public class MyUtilClassTest 
{
    @Mock
    private RestTemplate restTemplate;
    @InjectMocks
    private MyUtilClass myUtilClass;

    @Before
    public void setUp() throws Exception 
    {

        MockitoAnnotations.initMocks(this);
    }

    @Test
    public void testGetChildDTO()throws Exception 
    {

         MyUser myUser = new MyUser();
         HttpServletRequest request = new HttpServletRequestWrapper(new MockHttpServletRequest());
         HttpServletResponse response = new HttpServletResponseWrapper(new MockHttpServletResponse());    

         Mockito.when(RestTemplate.postForObject(Mockito.eq("http://www.google.com", 
            Mockito.any(ChildDTO.class), Mockito.eq(ChildDTO.class)))).thenAnswer(
            new Answer<ChildDTO>()
            {
                @Override
                public ChildDTO answer(InvocationOnMock invocation) throws Throwable
                {
                     //The below statement takes the second argument passed into the method and returns it
                    return (ChildDTO) invocation.getArguments()[1];
                }
            });

         ChildDTO childDTO = myUtilClass.getDTOFromUser(request, myUser);

         //then verify that the restTemplate.postForObject mock was called with the correct parameters
         Mockito.verify(restTemplate, Mockito.times(1)).postForObject(Mockito.eq("http://www.google.com",
            Mockito.eq(childDTO), Mockito.eq(ChildDTO.class));
    }
 }

同样，我发现测试其他框架类是一种不好的做法，更多的时候不是他们已经测试了他们的类，而您只是在复制他们的工作。