How to unit test with @ResponseBody return Json in Spring MVC controller

1. model

public class Dealer {
    private String id;
    private String name;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2. Controller

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;
import java.util.List;

@Controller
@RequestMapping("/dealer")
public class DealerController {
    @Resource(name = "dealerService")
    private DealerService dealerService;

    @RequestMapping("json/all")
    public @ResponseBody List<Dealer> getAllDealers() {
        return dealerService.getAllDealers();
    }
}

3. applicationContext.xml

    
        
    
    
        
           <bean class="org.springframework.web.servlet.view.xml.MarshallingView" p:marshaller-ref="unmarshaller" />
           <bean class="org.springframework.web.servlet.view.json.MappingJacksonJsonView" p:objectMapper-ref="jacksonJsonObjectMapper" />
        
    



    <oxm:class-to-be-bound name="mypackge.Dealer"/>

4. Unit test

import com.google.common.collect.Lists;
import org.apache.http.HttpHeaders;
import org.junit.Before;
import org.junit.Test;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJacksonHttpMessageConverter;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter;

import java.util.List;

import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

public class TestDealerController {
    private DealerController dealerController;

    @Before
    public void before() throws Exception {
        DealerService dealerService = mock(DealerService.class);
        when(dealerService.getAllDealers()).thenReturn(mockDealers());
        
        dealerController = new DealerController();
        ReflectionTestUtils.setField(dealerController, "dealerService", dealerService);
    }

    @Test
    public void testGetAllDealers() throws Exception {
        MockHttpServletRequest mockRequest = new MockHttpServletRequest();
        mockRequest.setContentType(MediaType.APPLICATION_JSON.toString());
        mockRequest.addHeader(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON.toString());
        mockRequest.setMethod("GET");
        mockRequest.setRequestURI("/dealer/json/all");

        AnnotationMethodHandlerAdapter handlerAdapter = new AnnotationMethodHandlerAdapter();
        HttpMessageConverter[] messageConverters = {new MappingJacksonHttpMessageConverter()};
        handlerAdapter.setMessageConverters(messageConverters);

        MockHttpServletResponse mockResponse = new MockHttpServletResponse();
        handlerAdapter.handle(mockRequest, mockResponse, dealerController);

        String expected="[{\"id\":\"01\",\"name\":\"dealer-01\"}, {\"id\":\"02\",\"name\":\"dealer-02\"}]";
        assertEquals(expected, mockResponse.getContentAsString());
    }

    private List<Dealer> mockDealers() {
        Dealer dealer01 = new Dealer();
        dealer01.setId("01");
        dealer01.setName("dealer-01");

        Dealer dealer02 = new Dealer();
        dealer02.setId("02");
        dealer02.setName("dealer-02");

        return Lists.newArrayList(dealer01, dealer02);
    }

5. reference
Spring Framework TEST RESTful Web Service (Controller) Offline i.e. No Server, No Database

Spring support multiple @Transactional datasource

1. Define tx-manager

    <tx:annotation-driven/>
    
        <property name="dataSource" ref="dataSource1"/>
    

    
        <property name="dataSource" ref="dataSource2"/>
    

2. In you service layer code

@Transactional(value = "jdbcTxManager")
public List<String> getNames() {
    return userDao.getNames();
}

@Transactional(value = "jpaTxManager")
public void persitentUser(User user) {
    return user.persist();
}

How to test email of junit

How can it test email of junit? Solution use dumbster as a fake smtp server 1. add dependency to pom.xml

    dumbster
    dumbster
    1.6
    test

2. add bean definition to spring applicationContext.xml

    <constructor-arg index="0" value="2525"/>

using javax mail session

    
        
            127.0.0.1
            2525
        
    


    <constructor-arg ref="mailSession" type="javax.mail.Session"/>

or if you using spring mail sender:

<bean class="org.springframework.mail.javamail.JavaMailSenderImpl" id="mailSender" p:host="localhost" p:port="2525"/>

3. define one util class

import com.dumbster.smtp.SimpleSmtpServer;
import com.dumbster.smtp.SmtpMessage;
import com.dumbster.smtp.SmtpResponse;
import com.dumbster.smtp.SmtpState;
import org.hamcrest.Description;
import org.hamcrest.Factory;
import org.hamcrest.Matcher;
import org.hamcrest.TypeSafeMatcher;

import java.util.Iterator;

public class BodySmtpMessage extends TypeSafeMatcher<Smtpmessage> {
    private SmtpMessage smtpMessage;

    public BodySmtpMessage(SmtpMessage smtpMessage) {
        this.smtpMessage = smtpMessage;
    }

    @Override
    public boolean matchesSafely(SmtpMessage smtpMessage) {
        return smtpMessage.getBody().equals(smtpMessage.getBody());
    }

    @Override
    public void describeTo(Description description) {
        description.appendText("not same body message");
    }

    @Factory
    public static <T> Matcher<smtpmessage> bodyEqualTo(SmtpMessage smtpMessage) {
        return new BodySmtpMessage(smtpMessage);
    }

    public static SmtpMessage getExpectedSmtpMessage(String body) {
        SmtpResponse smtpResponse = new SmtpResponse(1, "", SmtpState.DATA_BODY);
        SmtpMessage expectedMessage = new SmtpMessage();
        expectedMessage.store(smtpResponse, body);

        return expectedMessage;
    }

    public static SmtpMessage getFirstReceivedMessage(SimpleSmtpServer simpleSmtpServer) {
        Iterator<smtpmessage> receivedEmail = simpleSmtpServer.getReceivedEmail();

        while (receivedEmail.hasNext()) {
            return receivedEmail.next();
        }
        return null;
    }
}

4. Junit

import com.dumbster.smtp.SimpleSmtpServer;
import com.dumbster.smtp.SimpleSmtpServer;
import com.dumbster.smtp.SmtpMessage;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

import static au.com.hothouse.toyota.utils.email.BodySmtpMessage.*;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.*;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath*:applicationContext-test.xml")
public class TestEmailerImpl {
    @Resource(name = "saveYourCarEmailer")
    private EmailerImpl emailer;
    @Resource(name = "fakeSmtpServer")
    private SimpleSmtpServer simpleSmtpServer;

    private static String EXPECTED = "Dear Jianjun Shou,\n" +
            "\n" +
            "Here is the permanent link to the vehicle you have created:\n" +
            "\n" +
            "http://test.email.hothouse.com.au\n" +
            "\n" +
            "Thank you for vising the Toyota website.\n" +
            "\n" +
            "Regards,\n" +
            "\n" +
            "The Toyota Team";

    @Test
    public void testEmail() throws Exception {
        emailer.email("Jianjun", "Shou", "sean.shou@hothouse.com.au", "http://test.email.hothouse.com.au");
        assertTrue("test failed", simpleSmtpServer.getReceivedEmailSize() > 0);
        SmtpMessage sentMessage = getFirstReceivedMessage(simpleSmtpServer);
        SmtpMessage expectedSmtpMessage = getExpectedSmtpMessage(EXPECTED);
        assertThat(sentMessage, is(bodyEqualTo(expectedSmtpMessage)));
    }
}