Differenza tra MockMvc e RestTemplate nei test di integrazione

Question

Entrambe MockMvc e RestTemplate vengono utilizzate per i test di integrazione con Spring e JUnit.

La domanda è: qual è la differenza tra loro e quando dovremmo scegliere l'uno rispetto all'altro?

Qui ci sono solo esempi di entrambe le opzioni:

//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()); 

Answer 1

Come detto in this articolo si dovrebbe utilizzare MockMvc quando si desidera verificare lato server di applicazione:

Spring MVC test si basa sulla richiesta di finto e risposta da spring-test e non richiede una contenitore di servlet in esecuzione. La differenza principale è che la configurazione MVC Spring effettiva viene caricata tramite il framework TestContext e che la richiesta viene eseguita richiamando effettivamente lo DispatcherServlet e tutta la stessa infrastruttura MVC Spring utilizzata in fase di runtime.

ad esempio:

@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")); 
    }} 

E RestTemplate si dovrebbe utilizzare quando si desidera verificare Resto lato client applicazione:

Se si dispone di codice utilizzando la RestTemplate, è' Probabilmente vorrete testarlo e per farlo potrete scegliere come target un server in esecuzione o prendere in giro il RestTemplate. Il supporto per il test REST lato client offre una terza alternativa, che è quella di utilizzare l'effettivo RestTemplate ma configurarlo con un ClientHttpRequestFactory personalizzato che verifica le aspettative rispetto alle richieste effettive e restituisce le risposte di stub.

esempio:

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

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

// use RestTemplate ... 

mockServer.verify(); 

anche leggere this example

Answer 2

Con MockMvc, il gioco è in genere la creazione di un contesto intera applicazione web e beffardo le richieste HTTP e le risposte. Quindi, anche se un falso DispatcherServlet è attivo e funzionante, simulando il funzionamento dello stack MVC, non sono state effettuate connessioni di rete reali.

Con RestTemplate, è necessario distribuire un'istanza del server effettiva per ascoltare le richieste HTTP inviate.

Answer 3

E 'possibile utilizzare sia RestTemplate e MockMvc!

Questo è utile se si dispone di un client separato in cui si esegue già la noiosa mappatura degli oggetti Java agli URL e la conversione da e verso Json, e si desidera riutilizzarla per i test MockMVC.

Ecco come fare:

@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); 

     [...] 
    } 

}