Różnica między MockMvc i RestTemplate w testach integracji

Question

Zarówno MockMvc, jak i RestTemplate są używane do testów integracyjnych ze sprężynami i JUnit.

Pytanie brzmi: jaka jest różnica między nimi, a kiedy powinniśmy wybierać jedną nad drugą?

Oto tylko przykłady obu opcji:

//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

Jak powiedział w this artykułu należy użyć MockMvc gdy chcesz przetestować Server-side zastosowania:

Wiosna MVC test opiera się na mock żądanie i odpowiedź od spring-test i nie wymagają uruchomiony kontener serwletu. Główną różnicą jest to, że faktyczna konfiguracja Spring MVC jest ładowana przez strukturę TestContext i że żądanie jest wykonywane przez wywołanie DispatcherServlet i całej tej samej infrastruktury Spring MVC, która jest używana w środowisku wykonawczym.

na przykład:

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

I RestTemplate należy użyć, gdy chcesz przetestować Reszta po stronie klienta aplikację:

Jeśli masz kod używając RestTemplate, ty” Prawdopodobnie będziesz chciał to przetestować i możesz celować w działający serwer lub kpić z RestTemplate. Obsługa testów REST po stronie klienta oferuje trzecią opcję, która polega na użyciu rzeczywistego RestTemplate, ale skonfiguruj ją za pomocą niestandardowego ClientHttpRequestFactory, który sprawdza oczekiwania względem rzeczywistych żądań i zwraca odpowiedzi stub.

przykład:

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

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

// use RestTemplate ... 

mockServer.verify(); 

przeczytać również this example

Answer 2

Z MockMvc, jesteś zazwyczaj utworzenie cały kontekst aplikacji internetowych i szydząc żądań i odpowiedzi HTTP. Tak więc, chociaż fałszywy DispatcherServlet jest gotowy do działania, symulując sposób działania stosu MVC, nie ma rzeczywistych połączeń sieciowych.

Z RestTemplate, musisz wdrożyć rzeczywistą instancję serwera, aby nasłuchiwać wysyłanych żądań HTTP.

Answer 3

Możliwe jest stosowanie zarówno RestTemplate i MockMvc!

Jest to przydatne, jeśli masz oddzielnego klienta, w którym już teraz wykonuje się żmudne odwzorowywanie obiektów Java na adresy URL i konwersję do iz Json, i chcesz użyć go ponownie w testach MockMVC.

Oto jak to zrobić:

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

     [...] 
    } 

}