À l'aide de Printemps mockMvc de test en option variables de chemin d'accès

J'ai une méthode de Spring MVC avec l'option variable de chemin d'accès. Je suis en train de le tester pour un scénario facultatif variable de chemin d'accès n'est pas fourni.

Extrait de Contrôleur de ressource URI appeler-

@RequestMapping(value = "/some/uri/{foo}/{bar}", method = RequestMethod.PUT)
public <T> ResponseEntity<T> someMethod(@PathVariable("foo") String foo, @PathVariable(value = "bar", required = false) String bar) {

    LOGGER.info("foo: {}, bar: {}", foo, bar);
}

Extrait de mon test à l'aide de MockMvc-

//inject context
@Autowired
private WebApplicationContext webApplicationContext;

protected MockMvc mockMvc;

@Before
public void setup() {
    //build mockMvc
    mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
}

@Test
public void someMethodTest() throws Exception {
    //works as expected
    mockMvc.perform(put("/some/uri/{foo}/{bar}", "foo", "bar"))
            .andExpect(status().isOk()); //works

    //following doesn't work

    //pass null for optional
    mockMvc.perform(put("/some/uri/{foo}/{bar}", "foo", null))
            .andExpect(status().isOk()); //throws 404

    //pass empty for optional
    mockMvc.perform(put("/some/uri/{foo}/{bar}", "foo", ""))
            .andExpect(status().isOk()); //throws 404

    //remove optional from URI
    mockMvc.perform(put("/some/uri/{foo}", "foo"))
            .andExpect(status().isOk()); //throws 404
}
Double Possible de stackoverflow.com/questions/17821731/.... En bref, vous devez utiliser les tableau de l'Uri de la demande de cartographie (@RequestMapping(valeur = {"/certains/uri/{foo}/{bar}", "/certains/uri/{foo}"})
Je ne pense pas que c'est un doublon de cette question PathVariable peut être en option et je l'utilise comme option dans le code affiché ci-dessus.

OriginalL'auteur Pankaj Kohli | 2017-08-22

  1. 11

    L'aide d'un tableau de @RequestMapping des valeurs de ce type ...

    @RequestMapping(value = {"/some/uri/{foo}", "/some/uri/{foo}/{bar}"}, method = RequestMethod.PUT)
public ResponseEntity<String> someMethod(@PathVariable("foo") String foo, @PathVariable(value = "bar", required = false) String bar) {
    return new ResponseEntity<>(foo + " and " + (bar == null ? "<null>" : bar), HttpStatus.OK);
}

    ... permettre à ce test à passer:

    @Test
public void someMethodTest() throws Exception {
    MvcResult mvcResult = mockMvc.perform(put("/some/uri/{foo}/{bar}", "foo", "bar"))
            .andExpect(status().isOk()).andReturn();
    Assert.assertEquals("foo and bar", mvcResult.getResponse().getContentAsString());

    mvcResult = mockMvc.perform(put("/some/uri/{foo}/{bar}", "foo", null))
            .andExpect(status().isOk()).andReturn();
    Assert.assertEquals("foo and <null>", mvcResult.getResponse().getContentAsString());

    mvcResult = mockMvc.perform(put("/some/uri/{foo}/{bar}", "foo", ""))
            .andExpect(status().isOk()).andReturn();
    Assert.assertEquals("foo and <null>", mvcResult.getResponse().getContentAsString());

    mvcResult = mockMvc.perform(put("/some/uri/{foo}", "foo"))
            .andExpect(status().isOk()).andReturn();
    Assert.assertEquals("foo and <null>", mvcResult.getResponse().getContentAsString());
}

    Qui semble être la solution la plus simple et elle est susceptible d'être plus facile à des outils tels que Swagger car il les mappages explicite.

    Cependant, vous pouvez aussi déclarer un mappage de caractères génériques, et ensuite utiliser un chemin d'accès matcher au sein de votre contrôleur de méthode pour interpréter l'URI de la demande. Par exemple, cette méthode ...

    private final AntPathMatcher antPathMatcher = new AntPathMatcher();

@RequestMapping(value = "/some/uri/with/wildcards/**", method = RequestMethod.PUT)
public ResponseEntity<String> someMethod(HttpServletRequest request) {
    String matched = antPathMatcher.extractPathWithinPattern(
            (String) request.getAttribute(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE), request.getPathInfo());
    //ugly parsing code to read the path variables, allowing for the optionality of the second one
    String foo = matched;
    String bar = null;
    String[] pathVariables = matched.split("/");
    if (pathVariables.length > 1) {
        foo = pathVariables[0];
        bar = pathVariables[1];
    }
    return new ResponseEntity<>(foo + " and " + (bar == null ? "<null>" : bar), HttpStatus.OK);
}

    ... permettre à ce test à passer:

    @Test
public void someMethodTestWithWildcards() throws Exception {
    MvcResult mvcResult = mockMvc.perform(put("/some/uri/with/wildcards/{foo}/{bar}", "foo", "bar"))
            .andExpect(status().isOk()).andReturn();
    Assert.assertEquals("foo and bar", mvcResult.getResponse().getContentAsString());

    mvcResult = mockMvc.perform(put("/some/uri/with/wildcards/{foo}/{bar}", "foo", null))
            .andExpect(status().isOk()).andReturn();
    Assert.assertEquals("foo and <null>", mvcResult.getResponse().getContentAsString());

    mvcResult = mockMvc.perform(put("/some/uri/with/wildcards/{foo}/{bar}", "foo", ""))
            .andExpect(status().isOk()).andReturn();
    Assert.assertEquals("foo and <null>", mvcResult.getResponse().getContentAsString());

    mvcResult = mockMvc.perform(put("/some/uri/with/wildcards/{foo}", "foo"))
            .andExpect(status().isOk()).andReturn();
    Assert.assertEquals("foo and <null>", mvcResult.getResponse().getContentAsString());
}

    OriginalL'auteur glytching