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＆＃39>：

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 [＆＃34;回调＆＃34;] - ＆GT; org.mockito.internal.creation.MethodInterceptorFilter [＆＃34;处理＆＃34;] - ＆GT;有机mockito.internal.handler.InvocationNotifierHandler [＆＃34; mockSettings＆＃34;] - ＆GT; org.mockito.internal.creation.settings.CreationSettings [＆＃34; defaultAnswer＆＃34;]）; 嵌套异常是org.codehaus.jackson.map.JsonMappingException：否为类找到序列化器 org.mockito.internal.stubbing.defaultanswers.GloballyConfiguredAnswer 并且没有发现创建BeanSerializer的属性（以避免异常，禁用SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS））（通过参考链： com.biogenidec.dto.TypedUserDTO $$ EnhancerByMockitoWithCGLIB $$ bee3c447 [＆＃34;回调＆＃34;] - ＆GT; org.mockito.internal.creation.MethodInterceptorFilter [＆＃34;处理＆＃34;] - ＆GT;有机mockito.internal.handler.InvocationNotifierHandler [＆＃34; mockSettings＆＃34;] - ＆GT; org.mockito.internal.creation.settings.CreationSettings [＆＃34; defaultAnswer＆＃34;]）

并

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

此外，我发现测试其他框架类是不好的做法，更常见的是他们已经测试过他们的课程并且只是重复他们的工作。

Answer 2

如上所述，要使用mockito测试您的方法，不必初始化restTemplate。验证输入的参数是否正确（如果需要）并从restTemplate返回正确的模拟对象就足够了。

我们不在这里测试restTemplate，我们只测试我们的代码。这是单元测试的目的。

你可以做这样的事情，或者更简单的事情：

@RunWith(value = MockitoJUnitRunner.class)
public class Test {

@InjectMocks
private MyUtilClass testObj;

@Mock
private RestTemplate restTemplate;
@Mock
MyUser myUser;
@Mock
HttpServletRequest request;
@Mock
HttpServletResponse response;

@Test
public void test() throws Exception {
        //Configure sample to comparison and verification the result of the method:
        ChildDTO sample = getSample();

        //configure mocks:
        ChildDTO myObject = new ChildDTO();
        //configure myObject properties
        ResponseEntity<ChildDTO> respEntity = new ResponseEntity<>(
                myObject, HttpStatus.ACCEPTED);

        when(restTemplate.postForObject(anyString(), Matchers.<HttpEntity<?>>any(),
                Matchers.any(Class.class))).thenReturn(respEntity);
        //other stuff to configure correct behaviour of mocks request, response e.t.c.

        //act:
        ChildDTO result = testObj.getChildDTO(myUser, request, response);

        //verify that correct parameters were passed into restTemplate method "postForObject":
        verify(restTemplate).postForObject(eq("http://www.google.com"), Matchers.<HttpEntity<?>>any(),
                eq(ChildDTO.class)).thenReturn(respEntity);
        //assert to verify that we got correct result:
        assertEquals(sample, result);
    }    
}

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

2 个答案: