Test d'intégration de l'Affichage d'un objet entier de contrôleur Spring MVC

L'un des principaux objectifs des tests d'intégration avec MockMvc est de vérifier que les objets de modèle sont correctement renseignés avec les données de formulaire.

Pour ce faire, vous devez passer les données d'un formulaire qu'ils sont passés de la forme (à l'aide de .param()). Si vous utilisez une conversion automatique de NewObject à partir des données, le test ne traite pas de classe particulière de problèmes éventuels (modifications de NewObject incompatible avec la forme réelle).

Je crois que j'ai le plus simple encore de réponse à l'aide de Spring Boot 1.4, inclus dans les importations de la classe de test.:

public class SomeClass {  ///this goes in it's own file
////fields go here
}

import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
import org.springframework.http.MediaType
import org.springframework.test.context.junit4.SpringRunner
import org.springframework.test.web.servlet.MockMvc

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status

@RunWith(SpringRunner.class)
@WebMvcTest(SomeController.class)
public class ControllerTest {

  @Autowired private MockMvc mvc;
  @Autowired private ObjectMapper mapper;

  private SomeClass someClass;  //this could be Autowired
                                //, initialized in the test method
                                //, or created in setup block
  @Before
  public void setup() {
    someClass = new SomeClass(); 
  }

  @Test
  public void postTest() {
    String json = mapper.writeValueAsString(someClass);
    mvc.perform(post("/someControllerUrl")
       .contentType(MediaType.APPLICATION_JSON)
       .content(json)
       .accept(MediaType.APPLICATION_JSON))
       .andExpect(status().isOk());
  }

}

Une autre façon de résoudre la Réflexion, mais sans ordonnancement:

J'ai ce abstraite de la classe helper:

public abstract class MvcIntegrationTestUtils {

       public static MockHttpServletRequestBuilder postForm(String url,
                 Object modelAttribute, String... propertyPaths) {

              try {
                     MockHttpServletRequestBuilder form = post(url).characterEncoding(
                           "UTF-8").contentType(MediaType.APPLICATION_FORM_URLENCODED);

                     for (String path : propertyPaths) {
                            form.param(path, BeanUtils.getProperty(modelAttribute, path));
                     }

                     return form;

              } catch (Exception e) {
                     throw new RuntimeException(e);
              }
     }
}

Vous l'utiliser comme ceci:

//static import (optional)
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

//in your test method, populate your model attribute object (yes, works with nested properties)
BlogSetup bgs = new BlogSetup();
      bgs.getBlog().setBlogTitle("Test Blog");
      bgs.getUser().setEmail("[email protected]");
    bgs.getUser().setFirstName("Administrator");
      bgs.getUser().setLastName("Localhost");
      bgs.getUser().setPassword("password");

//finally put it together
mockMvc.perform(
            postForm("/blogs/create", bgs, "blog.blogTitle", "user.email",
                    "user.firstName", "user.lastName", "user.password"))
            .andExpect(status().isOk())

J'ai déduit qu'il est préférable d'être en mesure de parler de la propriété des chemins lors de la construction de la forme, car j'ai besoin de faire varier que dans mes tests. Par exemple, je pourrais être amené à vérifier si j'obtiens une erreur de validation sur une entrée manquante et je vais quitter le chemin de la propriété pour simuler les conditions. Je trouve aussi qu'il est plus facile de construire mon modèle d'attributs dans un @Avant méthode.

La BeanUtils est de commons-beanutils:

    <dependency>
        <groupId>commons-beanutils</groupId>
        <artifactId>commons-beanutils</artifactId>
        <version>1.8.3</version>
        <scope>test</scope>
    </dependency>

Voici la méthode que j'ai faite pour transformer de manière récursive les champs d'un objet dans une carte prête à être utilisée avec un MockHttpServletRequestBuilder

public static void objectToPostParams(final String key, final Object value, final Map<String, String> map) throws IllegalAccessException {
if ((value instanceof Number) || (value instanceof Enum) || (value instanceof String)) {
map.put(key, value.toString());
} else if (value instanceof Date) {
map.put(key, new SimpleDateFormat("yyyy-MM-dd HH:mm").format((Date) value));
} else if (value instanceof GenericDTO) {
final Map<String, Object> fieldsMap = ReflectionUtils.getFieldsMap((GenericDTO) value);
for (final Entry<String, Object> entry : fieldsMap.entrySet()) {
final StringBuilder sb = new StringBuilder();
if (!GenericValidator.isEmpty(key)) {
sb.append(key).append('.');
}
sb.append(entry.getKey());
objectToPostParams(sb.toString(), entry.getValue(), map);
}
} else if (value instanceof List) {
for (int i = 0; i < ((List) value).size(); i++) {
objectToPostParams(key + '[' + i + ']', ((List) value).get(i), map);
}
}
}

GenericDTO est une simple classe étendant Serializable

public interface GenericDTO extends Serializable {}

et voici le ReflectionUtils classe

public final class ReflectionUtils {
public static List<Field> getAllFields(final List<Field> fields, final Class<?> type) {
if (type.getSuperclass() != null) {
getAllFields(fields, type.getSuperclass());
}
//if a field is overwritten in the child class, the one in the parent is removed
fields.addAll(Arrays.asList(type.getDeclaredFields()).stream().map(field -> {
final Iterator<Field> iterator = fields.iterator();
while(iterator.hasNext()){
final Field fieldTmp = iterator.next();
if (fieldTmp.getName().equals(field.getName())) {
iterator.remove();
break;
}
}
return field;
}).collect(Collectors.toList()));
return fields;
}
public static Map<String, Object> getFieldsMap(final GenericDTO genericDTO) throws IllegalAccessException {
final Map<String, Object> map = new HashMap<>();
final List<Field> fields = new ArrayList<>();
getAllFields(fields, genericDTO.getClass());
for (final Field field : fields) {
final boolean isFieldAccessible = field.isAccessible();
field.setAccessible(true);
map.put(field.getName(), field.get(genericDTO));
field.setAccessible(isFieldAccessible);
}
return map;
}
}

Vous pouvez l'utiliser comme

final MockHttpServletRequestBuilder post = post("/");
final Map<String, String> map = new TreeMap<>();
objectToPostParams("", genericDTO, map);
for (final Entry<String, String> entry : map.entrySet()) {
post.param(entry.getKey(), entry.getValue());
}

Je n'ai pas testé beaucoup, mais il semble fonctionner.