Spring MVC Controller Unit Tests: "Normal" Controllers (2023)

The first part of this tutorial covered how to set up unit tests using the Spring MVC testing framework. Now it's time to get your hands dirty and learn how to write unit tests for "normal" controllers.

The next obvious question is:

What is a normal driver?

Well, a regular controller (in the context of this blog post) is a controller that renders a view or handles a form submission.

Let us begin.

Use: It is recommended that you read the first part of this tutorial before reading this blog post (if you have already read it, you can continue reading)

Use Maven to get the required dependencies

We can get the required test dependencies by adding the following dependency declarations to the sample application's POM file:

• Jackson 2.2.1 (base and data link modules). We use Jackson to turn the object into an encoded URLlineObject.
• Hamcrest 1.3. When we write assertions for answers we use hamcrest matchers.
• JUnit 4.11 (without the Hacrest kernel dependency).
• Mockito 1.9.5
• Spring Test 3.2.3 released

The relevant part of the pom.xmlFile looks like this:

<dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-core</artifactId><Version>2.2.1</Version><scope>test</scope></dependency><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>Jackson-bind de data</artifactId><Version>2.2.1</Version><scope>test</scope></dependency><dependency><groupId>org.hamcrest</groupId><artifactId>hamcrest-todo</artifactId><Version>1.3</Version><scope>test</scope></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><Version>4.11</Version><scope>test</scope><Exclusions><exclusion><artifactId>hamcrest-core</artifactId><groupId>org.hamcrest</groupId></disclaimer></Exclusions></dependency><dependency><groupId>org.mockito</groupId><artifactId>Mockito-Core</artifactId><Version>1.9.5</Version><scope>test</scope></dependency><dependency><groupId>org.springframework</groupId><artifactId>Spring test</artifactId><Version>3.2.3.RELEASE</Version><scope>test</scope></dependency>

Let's jump ahead and see how to write unit tests for Spring MVC controllers using the Spring MVC testing framework.

Write unit tests for controller methods

Each unit test we write to test the behavior of a controller method consists of the following steps:

1. We send a request to the tested controller method.
2. We confirm that we received the expected response.

The Spring MVC testing framework has a few "core" classes that we can use to implement these steps in our tests. These classes are described below:

• We can use the static methods of theMockMvcRequestBuildersClass for generating requests. More specifically, we can create a request generator and then pass it as a method parameter to the method making the actual request.
• El MockMvcThe class is the main entry point for testing. We can make a request by calling youRealizar (RequestBuilder-RequestBuilder)Method.
• We can write statements about the received response using the static methods ofClase MockMvcResultMathers.

Next, let's look at some examples that show how these classes are used in unit tests. We will write unit tests for the following controller methods:

• The first controller method displays a page that displays a task list.
• The second controller method returns a page showing information about a single pending task.
• The third controller method handles the form submission used to add a new task to the database.

Render the todo list page

First, let's look at the implementation of the controller method used to render the task list page.

expected behavior

Implementing the controller method to display all to-do information involves the following steps:

1. Gets the outstanding items by callingfind all()method ofAllServiceinterface . This method returns a list ofatobjects.
2. Adds the received list to the model.
3. Returns the name of the rendered view.

The relevant part of the TodoControllerthe class looks like this:

importar org.springframework.stereotype.Controller;import org.springframework.ui.Model;importar org.springframework.web.bind.annotation.*;import java.util.List;@Rulespublic class TodoController {private final TodoService service; @RequestMapping(valor = "/", Methode = RequestMethod. GET)public String findAll(Modell model) {List <All> Models = Service. find all();model.addAttribute("all", Models);return "all/list";}}

Now we're ready to write unit tests for this method. Let's see how we can do that.

Quiz: find tasks

We can write a unit test for this controller method using the following steps:

1. Create the test data that will be returned when our service method is called. When creating test data for testing, we use a concept called test data generator.
2. Configure the mock object used to return the test data created when yourThe findAll() method is called.
3. perform aTO GETRequest to send URL '/'.
4. Be sure to return HTTP status code 200.
5. Ensure that the returned view is named "all/list".
6. Make sure the request is redirected to the URL "/WEB-INF/jsp/todo/list.jsp".
7. Make sure the model property namedatcontains two elements.
8. Make sure that the called model propertyatcontains the correct elements.
9. Make sure the simulated objectfind all()The method is only called once.
10. Ensure that no other methods of the mock object are called during the test.

The source code of our unit tests looks like this:

import org.junit.Before;import org.junit.Test;importar org.junit.runner.RunWith;import org.mockito.Mockito;importar org.springframework.beans.factory.annotation.Autowired;importar org.springframework.test.context.ContextConfiguration;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;importar org.springframework.test.context.web.WebAppConfiguration;importar org.springframework.test.web.servlet.MockMvc;importar org.springframework.test.web.servlet.setup.MockMvcBuilders;importar org.springframework.web.context.WebApplicationContext;import java.util.Arrays;import static org.hamcrest.Matchers.*;import static org.hamcrest.Matchers.is;import org.mockito.Mockito.* static;importar org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get estático;Import estático org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;importar org.springframework.test.web.servlet.result.MockMvcResultMatchers.model estático;@RunWith(SpringJUnit4ClassRunner. Class)@ContextConfiguration(Classes = {TestContext. Class, WebAppContext. Class})@WebAppSettingspublic class TodoControllerTest {private MockMvc mockMvc;@autoverdrahtetprivate TodoService todoServiceMock;//Add the WebApplicationContext field here//The setUp() method is skipped.@Testpublic void findAll_ShouldAddTodoEntriesToModelAndRenderTodoListView() throws exception {All first = new TodoBuilder().id(1L).description("Learn by yourself").title("Foo").to build();All second = new TodoBuilder().id(2L).description("Learn by yourself").Titelleiste").to build();when(todoServiceMock.findAll()).thenReturn(Arrays.asList(first, second));mockMvc.perform(obtener("/")).andExpect(status().isOk()).andExpect(view().name("alle/liste")).andExpect(URL forwarded ("/WEB-INF/jsp/todo/list.jsp")).andExpect(model().attribute("all", hasSize(2))).andExpect(modelo().attribute("todos", hasItem(at(hasProperty("id", es(1L)),hasProperty("Description", is("The property itself")),hasProperty("Title", is("Foo")))))).andExpect(modelo().attribute("todos", hasItem(at(hasProperty("id", es(2L)),hasProperty("Description", is("The property itself")),hasProperty("Title", is("Bar"))))));check(allServiceMock, times(1)).findAll();checkNoMoreInteractions(todoServiceMock);}}

Render start page Show all

Before we can write actual unit tests for a controller method, we need to take a closer look at the method's implementation. Let's go ahead and see how the controller is implemented.

expected behavior

Implement the Controller method to display information about each task by doing the following:

1. Gets the requested pending task by callingfindById() method ofAllServiceinterface and passes the ID of the requested task as a method parameter. This method returns the pending item found.This method throws TodoNotEntryNotFoundExceptionif no task entry is found.
2. Adds the pending items found to the model.
3. Returns the name of the rendered view.

The source code of our controller method looks like this:

importar org.springframework.stereotype.Controller;import org.springframework.ui.Model;importar org.springframework.web.bind.annotation.*;@Rulespublic class TodoController {private final TodoService service;@RequestMapping(value = "/all/{id}", method = RequestMethod.GET)public String findById(@PathVariable("id") Long id, Model model) throws TodoNotFoundException {All found = service.findById(id);model.addAttribute("all", found);return "do/see";}}

Our next question is:

What happens when the TodoEntryNotFoundException exception is thrown?

In the previous part of this tutorial, we created an exception resolver bean to handle exceptions thrown by controller classes. The bean configuration looks like this:

@Beanpublic SimpleMappingExceptionResolverExceptionResolver() {SimpleMappingExceptionResolverExceptionResolver = new SimpleMappingExceptionResolver();PropertiesExceptionMappings = new properties();ExceptionMappings.put("net.petrikainulainen.spring.testmvc.todo.exception.TodoNotFoundException", "error/404");exception assignments. put("java.lang.Exception", "error/error");exception assignments. put("java.lang.RuntimeException", "error/error");ExceptionResolver.setExceptionMappings (ExceptionMappings);Property status codes = newproperties();status codes. put("Error/404", "404");status codes. put("Error/Error", "500");excepciónResolver.setStatusCodes(statusCodes);returns the exception handler;}

As we can see when aTodoEntryNotFoundExceptionis launched, our application displays the "Error/404" view and returns HTTP status code 404.

Obviously we need to write two tests for this controller method:

1. We need to write a test to ensure our app behaves correctly when no to do items are found.
2. Once we've found our backlog, we need to write a test to verify that our application is working properly.

Let's see how to write these tests.

Test 1: All items not found

First we need to make sure our app works if the requested task item is not found. We can write tests to ensure this as follows:

1. Configure the mockup to start aTodoNotFoundExceptionWhen isThe findById() method isI calland the ID of the requested pending item is 1L .
2. run aTO GETRequest to send URL '/todo/1'.
3. Check if HTTP status code 404 was returned.
4. Ensure that the returned view is named "error/404".
5. Be sure to redirect the request to the URL "/WEB-INF/jsp/error/404.jsp".
6. Make sure that the findById() method of theAllServicethe interface is only called once with the correct method parameters (1L) .
7. Make sure that no other methods of the mock object are called during this test.

The source code of our unit tests looks like this:

import org.junit.Before;import org.junit.Test;importar org.junit.runner.RunWith;import org.mockito.Mockito;importar org.springframework.beans.factory.annotation.Autowired;importar org.springframework.test.context.ContextConfiguration;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;importar org.springframework.test.context.web.WebAppConfiguration;importar org.springframework.test.web.servlet.MockMvc;importar org.springframework.test.web.servlet.setup.MockMvcBuilders;importar org.springframework.web.context.WebApplicationContext;import org.mockito.Mockito.* static;importar org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get estático;Import estático org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;@RunWith(SpringJUnit4ClassRunner. Class)@ContextConfiguration(Classes = {TestContext. Class, WebAppContext. Class})@WebAppSettingspublic class TodoControllerTest {private MockMvc mockMvc;@autoverdrahtetprivate TodoService todoServiceMock;//Add the WebApplicationContext field here//The setUp() method is skipped.@Testpublic void findById_TodoEntryNotFound_ShouldRender404View() throws exception {when(todoServiceMock.findById(1L)).thenThrow(new TodoNotFoundException(""));mockMvc.perform(get("/todo/{id}", 1L)).andExpect(status().isNotFound()).andExpect(view().name("error/404")).andExpect(forwardedUrl("/WEB-INF/jsp/error/404.jsp"));check(allServiceMock, times(1)).findById(1L);verificarZeroInteractions(todoServiceMock);}}

Test 2: Find the All entry

Second, we need to write a test to make sure the controller works when the task is found. We can do this by following these steps:

1. create theat-Object returned when our service method is called. Again, we use the test data generator to create the returned onesatObject.
2. Set our mock object to return the created oneatobject if it isThe findById() method is called with the method parameter 1L.
3. run aTO GETRequest to send URL '/todo/1'.
4. Verify that HTTP status code 200 is returned.
5. Make sure the returned view name is "todo/view".
6. Be sure to redirect the request to the URL "/WEB-INF/jsp/todo/view.jsp".
7. Check the identificationof the named model objectatis 1L.
8. Check the descriptionof the named model objectatit is "the law itself."
9. Check if thetitleof the named model objectatis "foo".
10. Make sure that only the dummy object's findById() is calledMethod with the correct method arguments (1L) .
11. Ensure that no other methods of the mock object are called during the test.

The source code of our unit tests looks like this:

import org.junit.Before;import org.junit.Test;importar org.junit.runner.RunWith;import org.mockito.Mockito;importar org.springframework.beans.factory.annotation.Autowired;importar org.springframework.test.context.ContextConfiguration;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;importar org.springframework.test.context.web.WebAppConfiguration;importar org.springframework.test.web.servlet.MockMvc;importar org.springframework.test.web.servlet.setup.MockMvcBuilders;importar org.springframework.web.context.WebApplicationContext;Import static org.hamcrest.Matchers.hasProperty;import static org.hamcrest.Matchers.is;import org.mockito.Mockito.* static;importar org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get estático;Import estático org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;@RunWith(SpringJUnit4ClassRunner. Class)@ContextConfiguration(Classes = {TestContext. Class, WebAppContext. Class})@WebAppSettingspublic class TodoControllerTest {private MockMvc mockMvc;@autoverdrahtetprivate TodoService todoServiceMock;//Add the WebApplicationContext field here//The setUp() method is skipped.@Testpublic void findById_TodoEntryFound_ShouldAddTodoEntryToModelAndRenderViewTodoEntryView() throws exception {Todo found = new TodoBuilder().id(1L).description("Learn by yourself").title("Foo").to build();when(todoServiceMock.findById(1L)).thenReturn(encontrado);mockMvc.perform(get("/todo/{id}", 1L)).andExpect(status().isOk()).andExpect(view().name("do/view")).andExpect(URL forwarded ("/WEB-INF/jsp/todo/view.jsp")).andExpect(modelo().attribute("todo", hasProperty("id", is(1L)))).andExpect(model().attribute("everything", hasProperty("description", is("The property itself")))).andExpect(model().attribute("todo", hasProperty("title", is("Foo"))));check(allServiceMock, times(1)).findById(1L);checkNoMoreInteractions(todoServiceMock);}}

Edit form submissions for the Add All input form

Again, let's look at the expected behavior of controller methods before writing unit tests for them.

expected behavior

Implement the controller method that handles the submission of the Add Task input form by doing the following:

1. Check the BindingResultThe object specified as a method parameter is healthy. If an error is found, the form view name is returned.
2. Add a new All entry by callingadd() method ofAllServiceinterface , with the form object being passed to the method as a parameter. This method creates and returns a new pending item.
3. Create a feedback message about the added to-do item and add this message to theRedirect AttributesObject specified as method parameter.
4. Adds the ID of the added pending item to theRedirect AttributesObject.
5. Returns the name of the redirection view that redirects the request to the task view input page.

The relevant part of the TodoControllerthe class looks like this:

importar org.springframework.context.MessageSource;importar org.springframework.context.i18n.LocaleContextHolder;importar org.springframework.stereotype.Controller;importar org.springframework.validation.BindingResult;importar org.springframework.web.bind.annotation.*;importar org.springframework.web.servlet.mvc.support.RedirectAttributes;javax.validation.Valid importieren;import java.util.Locale;@Rules@SessionAttributes("todo")public class TodoController {private final TodoService service;news source end private news source;@RequestMapping(value = "/all/add", method = RequestMethod. POST)public String add(@Valid @ModelAttribute("todo") TodoDTO dto, result of BindingResult, attributes of RedirectAttributes) {if (result. has error()) {returns "all/add";}Everything added = service. add (discount);addFeedbackMessage(Attributes, "Feedback. Message. Pending. Added", Added. getTitle());Attributes addAttribute("id", added. getId());return createRedirectViewPath("todo/ver");}private void addFeedbackMessage(Attribute de RedirectAttributes, String messageCode, Object... messageParameters) {String localizadoFeedbackMessage = getMessage (messageCode, messageParameters);atributos.addFlashAttribute("feedbackMessage", localizadoFeedbackMessage);}private String getMessage(string message code, object... message parameters) {Current locale = LocaleContextHolder. getLocal();return messageSource.getMessage (messageCode, messageParameters, aktuell);}Cadena privada createRedirectViewPath(String requestMapping) {StringBuilder RedirectViewPath = new StringBuilder();RedirectViewPath.append("Redirect:");forwardViewPath.append (requestMapping);devuelve RedirectViewPath.toString();}}

As we can see, the controller method uses theTodoDTOobject as a form object.All DTOclass is a simple DTO class whose source code is as follows:

importar org.hibernate.validator.constraints.Length;import org.hibernate.validator.constraints.NotEmpty;public class TodoDTO {private lange ID;@Length (max = 500)private string description;@not empty@Long (max = 100)private string title;//Constructor and other methods are ignored.}

All DTOThe class declares some validation constraints, which are described below:

• The task title cannot be empty.
• The maximum length of the description is 500 characters.
• The maximum length of the title is 100 characters.

Looking at the tests written for this controller method, it is clear that we need to ensure this

1. If validation fails, the controller method is a job property.
2. The controller method is owned by the job when the task item is added to the database.

Let's see how to write these tests.

Test 1: Validation failed

First we need to write a test to make sure our controller method works correctly when validation fails. We can write this test as follows:

1. A... createtitlewith 101 characters.
2. Create a 501 characterdesignation.
3. Create a new TodoDTOObject with our test data generator. set objecttitlejdesignation.
4. do oneTO POSTRequest to send "all/add" url. Set the request content type to "application/x-www-form-urlencoded". Make sure the content of our form object is sent in the request body. Set the form object to session.
5. Verify that HTTP status code 200 is returned.
6. Confirm that the view name returned is "all/add".
7. Make sure the request is redirected to the URL "/WEB-INF/jsp/todo/add.jsp".
8. Validate the properties of our model for field errors in thetitlejdescription fields.
9. Pay attention to the identificationof our property model is null.
10. Pay attention to the descriptionof the properties of our model is correct.
11. Pay attention to the titleof the model property is correct.
12. Ensure that the mock object's methods are not called during the test.

The source code of our unit tests looks like this:

import org.junit.Before;import org.junit.Test;importar org.junit.runner.RunWith;import org.mockito.Mockito;importar org.springframework.beans.factory.annotation.Autowired;importar org.springframework.http.MediaType;importar org.springframework.test.context.ContextConfiguration;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;importar org.springframework.test.context.web.WebAppConfiguration;importar org.springframework.test.web.servlet.MockMvc;importar org.springframework.test.web.servlet.setup.MockMvcBuilders;importar org.springframework.web.context.WebApplicationContext;Import static org.hamcrest.Matchers.hasProperty;import static org.hamcrest.Matchers.is;import org.hamcrest.Matchers.nullValue static;import org.mockito.Mockito.* static;import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.static post;Import estático org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;@RunWith(SpringJUnit4ClassRunner. Class)@ContextConfiguration(Classes = {TestContext. Class, WebAppContext. Class})@WebAppSettingspublic class TodoControllerTest {private MockMvc mockMvc;@autoverdrahtetprivate TodoService todoServiceMock;//Add the WebApplicationContext field here//The setUp() method is skipped.@Testpublic void add_DescriptionAndTitleAreTooLong_ShouldRenderFormViewAndReturnValidationErrorsForTitleAndDescription() arroja una excepción {String Title = TestUtil.createStringWithLength(101);String Description = TestUtil. createStringWithLength(501);TodoDTO formObject = neuer TodoDTOBuilder().description(description).title(Titel).to build();mockMvc.perform(post("/do/add").contentType(Medientyp.APPLICATION_FORM_URLENCODED).content(TestUtil.convertObjectToFormUrlEncodedBytes(formObject)).sessionAttr("alle", formObject)).andExpect(status().isOk()).andExpect(view().name("all/add")).andExpect(URL forwarded ("/WEB-INF/jsp/todo/add.jsp")).andExpect(pattern().attributeHasFieldErrors("all", "title")).andExpect(model().attributeHasFieldErrors("do", "description")).andExpect(modelo().attribute("todo", hasProperty("id", nullValue()))).andExpect(model().attribute("alles", hasProperty("description", is(description)))).andExpect(pattern().attribute("alles", hasProperty("title", is(title))));verificarZeroInteractions(todoServiceMock);}}

Our test cases call some static methods of theTestUtil Class.These methods are described below:

• The createStringWithLength(int length) method creates a new onelineObject with the given length and returns the created object.
• convertObjectToFormUrlEncodedBytes(object object)The method converts an object into a URL-encoded form.lineobject and returns the content of thelineobject like aByteFormation.

The TestUtil source codeClass is as follows:

importar com.fasterxml.jackson.annotation.JsonInclude;importar com.fasterxml.jackson.databind.ObjectMapper;import java.util.Iterator;import java.util.Map;import java.util.Set;public class TestUtil {public static byte[] convertObjectToFormUrlEncodedBytes(Objekt Objekt) {Mappeador de ObjectMapper = new ObjectMapper();asignador.setSerializationInclusion(JsonInclude.Include.NON_NULL);Map<String, Objekt> propertyValues ​​= mapper.convertValue(object, Map.class);Set<String> propertyNames = propertyValues. keyset();Iterator<String> nameIter = propertyNames. iterador();StringBuilder formUrlEncoded = new StringBuilder();for (int index=0; index < propertyNames. size(); index++) {chain currentKey = nameIter. next();Object current value = property values. get(current key);formUrlEncoded.append (claveActual);formUrlEncoded.append("=");formUrlEncoded.append(current value);if (nombreIter. hasNext()) {formUrlEncoded.append("&");}}devuelve formUrlEncoded.toString().getBytes();}public static string createStringWithLength(int length) {Konstruktor StringBuilder = new StringBuilder();for (int index = 0; index < length; index++) {Konstruktor.append("a");}volver constructor.toString();}}

Test 2: Todo entry added to database

Second, we need to write a test to make sure the controller works properly when a new task is added to the database. We can write this test as follows:

1. Create a form object using the test data generator class. Set the value to "legal".titlejdesignationFields of the created object.
2. A... createatObject returned when theAdd()method ofAllServiceis called interface.
3. Set our mock object to return what was createdAny object if it isAdd()The method is called and the generated form object is passed as a method parameter.
4. do oneTO POSTRequest to send "all/add" url. Set the request content type to "application/x-www-form-urlencoded". Make sure the content of our form object is sent in the request body. Set the form object to session.
5. Check if HTTP status code 302 was returned.
6. Ensure that the returned view is named "redirect:todo/{id}".
7. Be sure to redirect the request to the URL "/todo/1".
8. Verify that the named model attributeI WOULDis "1".
9. Make sure feedback is configured.
10. Check if our mock objectAdd()The method is called only once, and the form object is provided as a parameter to the method.
11. Make sure that no other methods of the mock object were called during the test.

The source code of our unit tests looks like this:

import org.junit.Before;import org.junit.Test;importar org.junit.runner.RunWith;import org.mockito.Mockito;importar org.springframework.beans.factory.annotation.Autowired;importar org.springframework.http.MediaType;importar org.springframework.test.context.ContextConfiguration;import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;importar org.springframework.test.context.web.WebAppConfiguration;importar org.springframework.test.web.servlet.MockMvc;importar org.springframework.test.web.servlet.setup.MockMvcBuilders;importar org.springframework.web.context.WebApplicationContext;import static org.hamcrest.Matchers.is;import org.mockito.Mockito.* static;import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.static post;Import estático org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;@RunWith(SpringJUnit4ClassRunner. Class)@ContextConfiguration(Classes = {TestContext. Class, WebAppContext. Class})@WebAppSettingspublic class TodoControllerTest {private MockMvc mockMvc;@autoverdrahtetprivate TodoService todoServiceMock;//Add the WebApplicationContext field here//The setUp() method is skipped.@Testpublic void add_NewTodoEntry_ShouldAddTodoEntryAndRenderViewTodoEntryView() throws exception {TodoDTO formObject = neuer TodoDTOBuilder().description("description").title("Titel").to build();Added todo = new TodoBuilder().id(1L).description(formObject.getDescription()).title(formObject.getTitle()).to build();when(todoServiceMock.add(formObject)).thenReturn(agregado);mockMvc.perform(post("/do/add").contentType(Medientyp.APPLICATION_FORM_URLENCODED).content(TestUtil.convertObjectToFormUrlEncodedBytes(formObject)).sessionAttr("alle", formObject)).andExpect(status().isMovedTemporally()).andExpect(view().name("redirect:todo/{id}")).andExpect(redirectedUrl("/todo/1")).andExpect(model().attribute("id", is("1"))).andExpect(flash().attribute("feedbackMessage", is("Feedback from All: added title.")));verificar(todoServiceMock, times(1)).add(formObject);checkNoMoreInteractions(todoServiceMock);}}

Continue

We've now written some unit tests for "normal" controller methods using the Spring MVC testing framework. This tutorial teaches four things:

• We learned to create requests that are processed by controller best practices.
• We learned how to write assertions for the responses returned from the tested controller methods.
• We learned how to write unit tests for controller methods that render views.
• We learned how to write unit tests for controller methods that handle form submissions.

The next part of this tutorial describes how to write unit tests for REST APIs.

PS The sample app for this blog post is available on Github. I suggest you check it out as it contains some unit tests that are not covered in this blog post.

Relation:Unit Testing Spring MVC Controllers – “Normal” Controllers by our JCG partner Petri Kainulainen on Petri Kainulainen's blog.

Translated from: https://www.javacodegeeks.com/2013/07/unit-testing-of-spring-mvc-controllers-normal-controllers.html