Spring MVC Controllers Unit Test non chiama @ControllerAdvice

Question

Ho un set di controller nell'applicazione e una classe annotata come @ControllerAdvice che imposta determinati elementi di dati che vengono utilizzati in ciascuno di questi controller. Sto usando Spring MVC 3.2 e ho Junits per questi controller. Quando eseguo il Junit, il controllo non passa alla classe , ma funziona correttamente se distribuisco l'app in Tomcat e inoltro una richiesta tramite browser.

Qualche idea per favore ?.

Answer 1

Prima di poter aspettarsi risposte specifiche, è necessario fornire ulteriori informazioni e magari alcuni file e/o file di configurazione effettivi. Detto questo, in base al poco che hai fornito, sembra che il bean annotato non venga caricato.

Provare ad aggiungere quanto segue al test applicationContext.xml (o un file di configurazione Spring equivalente, se ne si utilizza uno).

<context:component-scan base-package="com.example.path.to.package" /> 

In alternativa, potrebbe essere necessario 'manualmente' caricare i contesti all'interno dei test includendo le seguenti annotazioni prima della classe di test:

@RunWith(SpringJUnit4ClassRunner.class) 
@ContextConfiguration("/applicationContext.xml") 

Buona fortuna!

Answer 2

Ho lottato con la stessa cosa per un po 'di tempo. Dopo molte scavo, il miglior riferimento è stata la documentazione di primavera:

http://static.springsource.org/spring/docs/3.2.x/spring-framework-reference/html/testing.html#spring-mvc-test-framework

In breve, se si sta semplicemente testando un controller e dei suoi metodi è possibile utilizzare il metodo 'standaloneSetup' che crea una semplice molla Configurazione MVC. Questo sarà non includi il gestore degli errori che annoti con @ControllerAdvice.

private MockMvc mockMvc; 

@Before 
public void setup() { 
    this.mockMvc = MockMvcBuilders.standaloneSetup(new AccountController()).build(); 
} 

// ... 

Per creare una configurazione più completa Spring MVC che fa contenere il vostro gestore degli errori è necessario utilizzare la seguente configurazione:

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

    @Autowired 
    private WebApplicationContext wac; 

    private MockMvc mockMvc; 

    @Autowired 
    private AccountService accountService; 

    // ... 

} 

Answer 3

ho avuto problema simile quando si cerca di testare ExceptionHandler annotato con @ControllerAdvice. Nel mio caso ho dovuto aggiungere il file @Configuration con annotazione @EnableWebMvc a @ContextConfiguration nella classe di test.

Quindi il mio test si presentava così:

@RunWith(SpringJUnit4ClassRunner.class) 
@WebAppConfiguration 
@ContextConfiguration(classes = { 
    RestProcessingExceptionHandler.class, 
    TestConfiguration.class, 
    RestProcessingExceptionThrowingController.class }) 
public class TestRestProcessingExceptionHandler { 


    private MockMvc mockMvc; 
    @Autowired 
    WebApplicationContext wac; 


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


    @Configuration 
    // !!! this is very important - conf with this annotation 
    //  must be included in @ContextConfiguration 
    @EnableWebMvc 
    public static class TestConfiguration { } 


    @Controller 
    @RequestMapping("/tests") 
    public static class RestProcessingExceptionThrowingController { 


    @RequestMapping(value = "/exception", method = GET) 
    public @ResponseBody String find() { 
     throw new RestProcessingException("global_error_test"); 
    } 
    } 


    @Test 
    public void testHandleException() throws Exception { 
    mockMvc.perform(get("/tests/exception")) 
     .andExpect(new ResultMatcher() { 


      @Override 
      public void match(MvcResult result) throws Exception { 
      result.getResponse().getContentAsString().contains("global_error_test"); 
      } 
     }) 
     .andExpect(status().isBadRequest()); 
    } 
} 

Con @EnableWebMvc configurazione Il test è stato superato.

Answer 4

Supponiamo di avere classe MyControllerAdvice annotata con @ControllerAdvice con metodi annotati con @ExceptionHandler. Per MockMvc puoi facilmente aggiungere questa classe come risolutore di eccezioni.

@Before 
public void beforeTest() { 
    MockMvc mockMvc = standaloneSetup(myControllers) 
     .setHandlerExceptionResolvers(createExceptionResolver()) 
     .build(); 
} 

private ExceptionHandlerExceptionResolver createExceptionResolver() { 
    ExceptionHandlerExceptionResolver exceptionResolver = new ExceptionHandlerExceptionResolver() { 
     protected ServletInvocableHandlerMethod getExceptionHandlerMethod(HandlerMethod handlerMethod, Exception exception) { 
      Method method = new ExceptionHandlerMethodResolver(MyControllerAdvice.class).resolveMethod(exception); 
      return new ServletInvocableHandlerMethod(new MyControllerAdvice(), method); 
     } 
    }; 
    exceptionResolver.afterPropertiesSet(); 
    return exceptionResolver; 
} 

Answer 5

codice di esempio @tunguski funziona, ma vale la pena di capire come funzionano le cose. Questo è solo un modo per sistemare le cose.

@EnableWebMvc equivale a seguito in un file di configurazione di primavera

<mvc:annotation-driven />

In sostanza cosa c'è da lavorare è necessario inizializzare Spring MVC e caricare tutti i controller ei riferimenti di fagioli. Quindi, a seguito potrebbe essere una configurazione valida, nonché un supplente

seguito è come si farebbe impostare la classe di test

@RunWith(SpringJUnit4ClassRunner.class) 
    @ContextConfiguration(locations = { "classpath: "classpath:test-context.xml" }) 
    @WebAppConfiguration  
    public class BaseTest { 

     @Autowired 
     WebApplicationContext wac; 

     private MockMvc mockMvc; 

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

E seguendo potrebbe essere la configurazione di primavera per il test

<mvc:annotation-driven /> 
<context:component-scan base-package="com.base.package.controllers" /> 

Answer 6

Dopo utilizzando la risposta da @ eugene-a e un'altra simile here ho trovato limitazioni e sollevato un problema in primavera: https://jira.spring.io/browse/SPR-12751

Come risultato, il test Spring ha introdotto la possibilità di registrare le classi @ControllerAdvice nel builder in 4.2. Se stai usando Spring Boot allora avrai bisogno della versione 1.3.0 o successiva.

Con questo miglioramento, se si utilizza il programma di installazione standalone quindi è possibile impostare uno o più ControllerAdvice casi in questo modo:

mockMvc = MockMvcBuilders.standaloneSetup(yourController) 
      .setControllerAdvice(new YourControllerAdvice()) 
      .build(); 

Nota: il nome setControllerAdvice() potrebbe non rendere immediatamente evidente, ma si può passare molte istanze ad esso, dal momento che ha una firma var-args.

Answer 7

Questo sta lavorando per me

public class MyGlobalExceptionHandlerTest { 

    private MockMvc mockMvc; 

    @Mock 
    HealthController healthController; 

    @BeforeTest 
    public void setUp() { 
     MockitoAnnotations.initMocks(this); 
     mockMvc = MockMvcBuilders.standaloneSetup(healthController).setControllerAdvice(new GlobalExceptionHandler()) 
      .build(); 
    } 

    @Test(groups = { "services" }) 
    public void testGlobalExceptionHandlerError() throws Exception { 

     Mockito.when(healthController.health()).thenThrow(new RuntimeException("Unexpected Exception")); 

     mockMvc.perform(get("/health")).andExpect(status().is(500)).andReturn(); 

    } 

} 

Answer 8

ho incontrato questo problema durante la scrittura di test controller con spock (Groovy). La mia classe di test è stata originariamente scritta come:

@AutoConfigureMockMvc(secure = false) 
@SpringBootTest 
@Category(RestTest) 
class FooControllerTest extends Specification { 
    def fooService = Mock(FooService) 
    def underTest = new FooController(FooService) 
    def mockMvc = MockMvcBuilders.standaloneSetup(underTest).build() 
.... 
} 

Ciò ha causato che ControllerAdvice venisse ignorato. Cambiando il codice per Autowire i mock hanno risolto il problema.

@AutoConfigureMockMvc(secure = false) 
@SpringBootTest 
@Category(RestTest) 
class FooControllerTest extends Specification { 

    @AutowiredMock 
    FooService FooService 

    @Autowired 
    MockMvc mockMvc