Question Différence entre MockMvc et RestTemplate dans les tests d'intégration


Tous les deux MockMvc et RestTemplate sont utilisés pour les tests d'intégration avec Spring et JUnit.

La question est: quelle est la différence entre eux et quand on devrait en choisir un sur un autre?

Voici quelques exemples des deux options:

//MockMVC example
mockMvc.perform(get("/api/users"))
            .andExpect(status().isOk())
            (...)

//RestTemplate example
ResponseEntity<User> entity = restTemplate.exchange("/api/users",
            HttpMethod.GET,
            new HttpEntity<String>(...),
            User.class);
assertEquals(HttpStatus.OK, entity.getStatusCode());

30
2017-09-17 23:34


origine


Réponses:


Comme dit dans ce  article que vous devriez utiliser MockMvc quand vous voulez tester Du côté serveur d'application:

Spring MVC Test se base sur la requête simulée et la réponse de spring-test et ne nécessite pas de conteneur de servlet en cours d'exécution. La principale différence est que la configuration actuelle de Spring MVC est chargée via le framework TestContext et que la requête est exécutée en invoquant le DispatcherServlet et toutes les mêmes infrastructures Spring MVC utilisées lors de l'exécution.

par exemple:

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration("servlet-context.xml")
public class SampleTests {

  @Autowired
  private WebApplicationContext wac;

  private MockMvc mockMvc;

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

  @Test
  public void getFoo() throws Exception {
    this.mockMvc.perform(get("/foo").accept("application/json"))
        .andExpect(status().isOk())
        .andExpect(content().mimeType("application/json"))
        .andExpect(jsonPath("$.name").value("Lee"));
  }}

Et RestTemplate vous devriez utiliser quand vous voulez tester Reste côté client application:

Si vous avez du code en utilisant le RestTemplate, vous voudrez probablement le tester et que vous pouvez cibler un serveur en cours d'exécution ou simuler le RestTemplate. Le support de test REST côté client offre une troisième alternative, qui consiste à utiliser le RestTemplate mais configurez-le avec une coutume ClientHttpRequestFactory qui vérifie les attentes par rapport aux demandes réelles et renvoie les réponses stub.

Exemple:

RestTemplate restTemplate = new RestTemplate();
MockRestServiceServer mockServer = MockRestServiceServer.createServer(restTemplate);

mockServer.expect(requestTo("/greeting"))
  .andRespond(withSuccess("Hello world", "text/plain"));

// use RestTemplate ...

mockServer.verify();

aussi lire cet exemple


20
2018-02-24 13:24



Avec MockMvcEn règle générale, vous configurez un contexte d'application Web complet et vous vous moquez des requêtes et des réponses HTTP. Donc, bien qu'un faux DispatcherServlet est en marche, simulant le fonctionnement de votre pile MVC, il n'y a pas de connexions réseau réelles faites.

Avec RestTemplate, vous devez déployer une instance de serveur réelle pour écouter les requêtes HTTP que vous envoyez.


26
2017-09-17 23:44



Il est possible d'utiliser à la fois RestTemplate et MockMvc!

Ceci est utile si vous avez un client distinct où vous faites déjà le mappage fastidieux des objets Java vers les URL et la conversion vers et depuis Json, et que vous souhaitez les réutiliser pour vos tests MockMVC.

Voici comment faire:

@RunWith(SpringRunner.class)
@ActiveProfiles("integration")
@WebMvcTest(ControllerUnderTest.class)
public class MyTestShould {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void verify_some_condition() throws Exception {

        MockMvcClientHttpRequestFactory requestFactory = new MockMvcClientHttpRequestFactory(mockMvc);
        RestTemplate restTemplate = new RestTemplate(requestFactory);

        ResponseEntity<SomeClass> result = restTemplate.getForEntity("/my/url", SomeClass.class);

        [...]
    }

}

9
2018-02-21 16:34