Spring MVC - JUnit Test Examples

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultMatcher;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.DefaultMockMvcBuilder;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = MyWebConfig.class)
public class CustomerControllerTest {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup () {
        DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(this.wac);
        this.mockMvc = builder.build();
    }

    @Test
    public void testUserController () throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status()
                                                .isOk();

        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/customers");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

    }
}

import jdk.Exported;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultMatcher;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.DefaultMockMvcBuilder;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.util.NestedServletException;

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = MyWebConfig.class)
public class MyMvcControllerTest {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup () {
        DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(this.wac);
        this.mockMvc = builder.build();
    }

    @Test
    public void testUserController () throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status().isOk();

        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/employees?dept=IT");
        this.mockMvc.perform(builder)
                    .andExpect(ok);


        builder = MockMvcRequestBuilders.get("/employees?state=NC");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

         builder = MockMvcRequestBuilders.get("/employees?dept=IT&state=NC");
          this.mockMvc.perform(builder)
         .andExpect(ok);

        builder = MockMvcRequestBuilders.get("/employees/234/messages?sendBy=mgr&date=20160210");
        this.mockMvc.perform(builder)
                    .andExpect(ok);


        builder = MockMvcRequestBuilders.get("/employees/234/paystubs?months=5");
        this.mockMvc.perform(builder)
                    .andExpect(ok);


        builder = MockMvcRequestBuilders.get("/employees/234/paystubs?startDate=2000-10-31&endDate=2000-10-31");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

        builder = MockMvcRequestBuilders.get("/employees/234/report");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

        builder = MockMvcRequestBuilders.get("/employees/234/report?project=mara");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

        builder = MockMvcRequestBuilders.get("/employees/234/messages?sendBy=mgr&date=20160210");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

    }
}

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultMatcher;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.DefaultMockMvcBuilder;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = MyWebConfig.class)
public class UploadControllerTest {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup () {
        DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(this.wac);
        this.mockMvc = builder.build();
    }

    @Test
    public void testController () throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status().isOk();

        MockMultipartFile file = new MockMultipartFile("user-file", "test.txt",
                                                       null, "test data".getBytes());

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.fileUpload("/upload")
                                                  .file(file);
        this.mockMvc.perform(builder).andExpect(ok);

    }

}

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultMatcher;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.DefaultMockMvcBuilder;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = MyWebConfig.class)
public class RegistrationControllerTest {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup () {
        DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(this.wac);
        this.mockMvc = builder.build();
    }

    @Test
    public void testUserController () throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status()
                                                .isOk();
        ResultMatcher registerView = MockMvcResultMatchers.view()
                                                          .name("user-registration");
        ResultMatcher doneView = MockMvcResultMatchers.view()
                                                      .name("registration-done");

        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/register");
        this.mockMvc.perform(builder)
                    .andExpect(ok)
                    .andExpect(registerView);

        builder = MockMvcRequestBuilders.post("/register")
                                        .param("name", "KatieK")
                                        .param("emailAddress", "kat@exmaple.com")
                                        .param("password", "abcadf");
        this.mockMvc.perform(builder)
                    .andExpect(ok)
                    .andExpect(doneView);

    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = MyWebConfig.class)
public class UserControllerTest {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup () {
        DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(this.wac);
        this.mockMvc = builder.build();
    }

    @Test
    public void testUserController () throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status()
                                                .isOk();

        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get(
                            "/users");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

         builder = MockMvcRequestBuilders.get(
                            "/users/23");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

        builder = MockMvcRequestBuilders.get(
                            "/users?querier=Joe");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

        builder = MockMvcRequestBuilders.get(
                            "/users/23?querier=Joe");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = MyWebConfig.class)
public class TradeControllerTest {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup () {
        DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(this.wac);
        this.mockMvc = builder.build();
    }

    @Test
    public void testUserController () throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status()
                                                .isOk();

        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get(
                            "/trades/paramTest?buySell=buy&buyCurrency=EUR&sellCurrency=USD");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

        builder = MockMvcRequestBuilders.get(
                            "/trades?buySell=buy&buyCurrency=EUR&sellCurrency=USD");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

        builder = MockMvcRequestBuilders.get("/trades/buy/EUR/USD");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

        builder = MockMvcRequestBuilders.get("/trades/pathTest/buy/EUR/USD");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

    }
}

import jdk.Exported;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultMatcher;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.DefaultMockMvcBuilder;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.util.NestedServletException;

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = MyWebConfig.class)
public class MyMvcControllerTest {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup() {
        DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(this.wac);
        this.mockMvc = builder.build();
    }

    @Test
    public void testUserController() throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status().isOk();

        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/users/234");
        this.mockMvc.perform(builder)
               .andExpect(ok);


        builder = MockMvcRequestBuilders.get("/users/profiles/joe");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

        builder = MockMvcRequestBuilders.get("/users/234/posts/111");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

        builder = MockMvcRequestBuilders.get("/users/234/messages/453");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

    }

    /**
     * testing ambiguous method mapping
     * @throws Exception
     */
    @Test(expected = NestedServletException.class)
    public void testEmployeeControllerController() throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status().isOk();

        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/employees/234");
        this.mockMvc.perform(builder)
                    .andExpect(ok);
    }

   @Test
    public void testDeptControllerController() throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status().isOk();

        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/dept/234");
        this.mockMvc.perform(builder)
                    .andExpect(ok);


       builder = MockMvcRequestBuilders.get("/dept/account");
       this.mockMvc.perform(builder)
                   .andExpect(ok);
    }
}

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultMatcher;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.DefaultMockMvcBuilder;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = WebConfigConsume.class)
public class UserControllerTestConsume {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup () {
        DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(this.wac);
        this.mockMvc = builder.build();
    }


    @Test
    public void testMyMvcController () throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status()
                                                .isOk();

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.post("/users")
                                                  .contentType(MediaType.APPLICATION_JSON)
                                                  .content("{ \"userName\": \"Joe\"}");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

    }

    @Test
    public void testMyMvcController2 () throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status()
                                                .isOk();

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.post("/users")
                                                  .contentType(MediaType.APPLICATION_XML)
                                                  .content("<user><userName>Joe</userName></user>");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

    }
}

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultMatcher;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.DefaultMockMvcBuilder;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = WebConfigHeader.class)
public class UserControllerTestHeader {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup () {
        DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(this.wac);
        this.mockMvc = builder.build();
    }


    @Test
    public void testMyMvcController () throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status()
                                                .isOk();

        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/users");
        builder.header("id", "4");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

    }

    @Test
    public void testMyMvcController2 () throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status()
                                                .isOk();

        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/users");
        builder.header("id", "10");
        this.mockMvc.perform(builder)
                    .andExpect(ok);

    }

    @Test
    public void testMyMvcController3 () throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status()
                                                .is(404);

        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/users");
        builder.header("id", "40");
        this.mockMvc.perform(builder)
                    .andExpect(ok);
    }
}

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultMatcher;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.DefaultMockMvcBuilder;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = WebConfigHttpMethods.class)
public class UserControllerTestHttpMethod {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup() {
        DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(this.wac);
        this.mockMvc = builder.build();
    }

    @Test
    public void testMyMvcControllerGet() throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status().isOk();
        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/users/2");
        this.mockMvc.perform(builder)
                  .andExpect(ok);
    }

    @Test
    public void testMyMvcControllerDelete() throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status().isOk();
        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.delete("/users/2");
        this.mockMvc.perform(builder)
                  .andExpect(ok);
    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = WebConfigProduce.class)
public class UserControllerTestProduce {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup () {
        DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(this.wac);
        this.mockMvc = builder.build();
    }


    @Test
    public void testMyMvcController () throws Exception {
        ResultMatcher expected = MockMvcResultMatchers.jsonPath("userName")
                                                      .value("Joe");

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.get("/users")
                                                  .accept(MediaType.APPLICATION_JSON);
        this.mockMvc.perform(builder)
                    .andExpect(expected);


    }

    @Test
    public void testMyMvcController2 () throws Exception {
        ResultMatcher expected = MockMvcResultMatchers.xpath("userName")
                                                      .string("Joe");

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.post("/users")
                                                  .accept(MediaType.APPLICATION_XML);
        this.mockMvc.perform(builder)
                    .andExpect(expected);

    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = MyWebConfig.class)
public class MyMvcControllerTest {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup() {
        DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(this.wac);
        this.mockMvc = builder.build();
    }

    @Test
    public void testMyMvcController() throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status().isOk();
        ResultMatcher msg = MockMvcResultMatchers.model()
                            .attribute("msg", "Spring quick start!!");

        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/");
        this.mockMvc.perform(builder)
               .andExpect(ok)
               .andExpect(msg);
    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = MyWebConfig.class)
public class RegistrationControllerTest {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup () {
        DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(this.wac);
        this.mockMvc = builder.build();
    }

    @Test
    public void testController () throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status()
                                                .isOk();

        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/message")
                                                                      .contentType(MediaType.TEXT_PLAIN)
                                                                      .content("test message");
        this.mockMvc.perform(builder)
                    .andExpect(ok)
                    .andDo(MockMvcResultHandlers.print());

    }

    @Test
    public void testFormPostController () throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status()
                                                .isOk();

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.post("/message")
                                                  .contentType("application/x-www-form-urlencoded")
                                                  .accept(MediaType.TEXT_PLAIN)
                                                  //use param instead of content
                                                  .param("name", "joe");

        this.mockMvc.perform(builder)
                    .andExpect(ok);


    }

    @Test
    public void testPostFormPostController () throws Exception {
        ResultMatcher created = MockMvcResultMatchers.status()
                                                .isCreated();

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.put("/message")
                                                  .contentType("application/x-www-form-urlencoded")
                                                  .accept(MediaType.TEXT_PLAIN)
                                                  .content("name=mike");
        this.mockMvc.perform(builder)
                    .andExpect(created);


    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = MyWebConfig.class)
public class RegistrationControllerTest {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup () {
        DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(this.wac);
        this.mockMvc = builder.build();
    }

    @Test
    public void testUserController () throws Exception {

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.post("/users/register")
                                                  .contentType(MediaType.APPLICATION_XML)
                                                  .content(createUserInXml(
                                                                      "joe",
                                                                      "joe@example.com",
                                                                      "abc"));

        //create one moe user
        this.mockMvc.perform(builder)
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isCreated());

        builder = MockMvcRequestBuilders.post("/users/register")
                                        .contentType(MediaType.APPLICATION_XML)
                                        .content(createUserInXml("mike",
                                                                 "mike@example.com",
                                                                 "123"));

        this.mockMvc.perform(builder)
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isCreated());

        //getting all users
        builder = MockMvcRequestBuilders.get("/users")
                                        .accept(MediaType.APPLICATION_XML);
        this.mockMvc.perform(builder)
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isOk())
                    .andDo(MockMvcResultHandlers.print());

    }

    private static String createUserInXml (String name, String email, String password) {
        return "<user>" +
                            "<name>" + name + "</name>" +
                            "<emailAddress>" + email + "</emailAddress>" +
                            "<password>" + password + "</password>" +
                            "</user>";
    }
}

    @Test
    public void testUserController () throws Exception {

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.post("/users/register")
                                                  .contentType(MediaType.APPLICATION_JSON)
                                                  .content(createUserInJson("joe",
                                                                            "joe@example.com",
                                                                            "abc"));

        this.mockMvc.perform(builder)
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isCreated());

        // create one more user
        builder = MockMvcRequestBuilders.post("/users/register")
                                        .contentType(MediaType.APPLICATION_JSON)
                                        .content(createUserInJson("mike",
                                                                  "mike@example.com",
                                                                  "123"));

        this.mockMvc.perform(builder)
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isCreated());

        // get all users
        builder = MockMvcRequestBuilders.get("/users")
                                        .accept(MediaType.APPLICATION_JSON);
        this.mockMvc.perform(builder)
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isOk())
                    .andDo(MockMvcResultHandlers.print());

    }

    private static String createUserInJson (String name, String email, String password) {
        return "{ \"name\": \"" + name + "\", " +
                            "\"emailAddress\":\"" + email + "\"," +
                            "\"password\":\"" + password + "\"}";
    }

    @Test
    public void testUserController () throws Exception {

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.get("/test/5");


        this.mockMvc.perform(builder)
                    .andDo(MockMvcResultHandlers.print())
                    .andExpect(MockMvcResultMatchers.redirectedUrl(
                                        "/test2/pathValue/5?attr=attrVal"));
    }

    @Test
    public void testController () throws Exception {

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.get("/test");


        this.mockMvc.perform(builder)
                    .andDo(MockMvcResultHandlers.print())
                    .andExpect(MockMvcResultMatchers.redirectedUrl(
                                        "test2?myModelAttribute=attributeVal"));
    }

    @Test
    public void testController3 () throws Exception {

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.get("/test2/6");


        this.mockMvc.perform(builder)
                    .andDo(MockMvcResultHandlers.print())
                    .andExpect(MockMvcResultMatchers.forwardedUrl(
                                        "/testFinal2/6"));
    }

    @Test
    public void testUserController () throws Exception {

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.post("/register")
                                                  .param("name", "KatieK")
                                                  .param("emailAddress",
                                                         "kat@exmaple.com")
                                                  .param("password", "abcadf");
        this.mockMvc.perform(builder)
                    .andDo(MockMvcResultHandlers.print())
                    .andExpect(MockMvcResultMatchers.redirectedUrl(
                                        "/registration-success"));
    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = MyWebConfig.class)
public class RegistrationControllerTest {

    @Autowired
    private WebApplicationContext wac;

    @Autowired
    private UserService userService;

    private MockMvc mockMvc;

    @Before
    public void setup () {
        DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(this.wac);
        this.mockMvc = builder.build();
    }

    @Test
    public void testLogin () throws Exception {

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.post("/login")
                                                  .param("emailAddress",
                                                         "admin@exmaple.com")
                                                  .param("password", "password");
        this.mockMvc.perform(builder)
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isOk());
    }

    @Test
    public void testPostLogin() throws Exception{
        MockHttpSession session = new MockHttpSession();

        User user = new User();
        user.setEmailAddress("admin@example.com");
        user.setPassword("password");
        user = userService.loginUser(user);

        session.setAttribute("user", user);

        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/app")
                                        .session(session);
        this.mockMvc.perform(builder)
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isOk());

    }

}

    @Test
    public void testController () throws Exception {

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.get("/test");


        this.mockMvc.perform(builder)
                    .andExpect(MockMvcResultMatchers.request()
                                                    .asyncStarted())
                    .andExpect(MockMvcResultMatchers.request()
                                                    .asyncResult("async result"))
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isOk());
    }

    @Test
    public void testController () throws Exception {

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.get("/test");


        this.mockMvc.perform(builder)
                    .andExpect(MockMvcResultMatchers.request()
                                                    .asyncStarted())
                    .andExpect(MockMvcResultMatchers.request()
                                                    .asyncResult("test async result"))
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isOk());
    }

    @Test
    public void testGet () throws Exception {

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.get("/test");


        this.mockMvc.perform(builder)
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isOk())
                    .andDo(MockMvcResultHandlers.print());
    }

    @Test
    public void testHead () throws Exception {

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.head("/test");

        this.mockMvc.perform(builder)
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isOk())
                    .andDo(MockMvcResultHandlers.print());
    }

    @Test
    public void testOptions () throws Exception {

        ResultMatcher accessHeader = MockMvcResultMatchers.header()
                                                          .string("Allow", "GET,HEAD");

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.options("/test");

        this.mockMvc.perform(builder)
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isOk())
                    .andExpect(accessHeader)
                    .andDo(MockMvcResultHandlers.print());
    }

    @Test
    public void testGet () throws Exception {

        ResultMatcher viewMatcher = MockMvcResultMatchers.view()
                                                         .name("GetMapping-view");

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.get("/test");


        this.mockMvc.perform(builder)
                    .andExpect(viewMatcher)
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isOk());
    }

    @Test
    public void testPost () throws Exception {

        ResultMatcher viewMatcher = MockMvcResultMatchers.view()
                                                         .name("PostMapping-view");

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.post("/test");


        this.mockMvc.perform(builder)
                    .andExpect(viewMatcher)
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isOk());
    }

    @Test
    public void testPut () throws Exception {

        ResultMatcher viewMatcher = MockMvcResultMatchers.view()
                                                         .name("PutMapping-view");

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.put("/test");


        this.mockMvc.perform(builder)
                    .andExpect(viewMatcher)
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isOk());
    }

    @Test
    public void testDelete () throws Exception {

        ResultMatcher viewMatcher = MockMvcResultMatchers.view()
                                                         .name("DeleteMapping-view");

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.delete("/test");


        this.mockMvc.perform(builder)
                    .andExpect(viewMatcher)
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isOk());
    }

    @Test
    public void testPatch () throws Exception {

        ResultMatcher viewMatcher = MockMvcResultMatchers.view()
                                                         .name("PatchMapping-view");

        MockHttpServletRequestBuilder builder =
                            MockMvcRequestBuilders.patch("/test");


        this.mockMvc.perform(builder)
                    .andExpect(viewMatcher)
                    .andExpect(MockMvcResultMatchers.status()
                                                    .isOk());
    }

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultMatcher;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.test.web.servlet.setup.DefaultMockMvcBuilder;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = MyWebConfig.class)
public class RegistrationControllerTest {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup () {
        DefaultMockMvcBuilder builder = MockMvcBuilders.webAppContextSetup(this.wac);
        this.mockMvc = builder.build();
    }

    @Test
    public void testUserController () throws Exception {
        ResultMatcher ok = MockMvcResultMatchers.status()
                                                .isOk();
        ResultMatcher registerView = MockMvcResultMatchers.view()
                                                          .name("user-registration");
        ResultMatcher doneView = MockMvcResultMatchers.view()
                                                      .name("registration-done");

        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/register");
        this.mockMvc.perform(builder)
                    .andExpect(ok)
                    .andExpect(registerView);

        builder = MockMvcRequestBuilders.post("/register")
                                        .param("name", "KatieK")
                                        .param("emailAddress", "kat@exmaple.com")
                                        .param("password", "abcadf");
        this.mockMvc.perform(builder)
                    .andExpect(ok)
                    .andExpect(doneView);

    }
}