I have written some JUnit tests using JUnit 4 and spring-test libraries. When I run the tests inside Eclipse then run fine and pass. But when I run them using Maven (during the build process), they fail giving a spring related error. I am not sure what is causing the problem, JUnit, Surefire or Spring. Here is my test code, spring configuration and the exception that I get from Maven:

_PersonServiceTest.java_

    package com.xyz.person.test;

    import static com.xyz.person.util.FjUtil.toFjList;
    import static junit.framework.Assert.assertEquals;
    import static org.junit.Assert.assertNotNull;

    import java.util.List;

    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    import org.springframework.test.context.transaction.TransactionConfiguration;
    import org.springframework.transaction.annotation.Transactional;

    import com.xyz.person.bo.Person;
    import com.xyz.person.bs.PersonService;

    import fj.Effect;

    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = { &quot;classpath*:personservice-test.xml&quot; })
    @TransactionConfiguration(transactionManager = &quot;transactionManager&quot;, defaultRollback = false)
    public class PersonServiceTest {

        @Autowired
        private PersonService service;

        @Test
        @Transactional
        public void testCreatePerson() {
            Person person = new Person();
            person.setName(&quot;abhinav&quot;);
            service.createPerson(person);

            assertNotNull(person.getId());
        }

        @Test
        @Transactional
        public void testFindPersons() {
            Person person = new Person();
            person.setName(&quot;abhinav&quot;);
            service.createPerson(person);

            List&lt;Person&gt; persons = service.findPersons(&quot;abhinav&quot;);
            toFjList(persons).foreach(new Effect&lt;Person&gt;() {
                public void e(final Person p) {
                    assertEquals(&quot;abhinav&quot;, p.getName());
                }});
        }

    }

_personservice-test.xml_

    &lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;
    &lt;beans xmlns=&quot;http://www.springframework.org/schema/beans&quot;
        xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot;
        xmlns:tx=&quot;http://www.springframework.org/schema/tx&quot;
        xmlns:aop=&quot;http://www.springframework.org/schema/aop&quot;
        xmlns:context=&quot;http://www.springframework.org/schema/context&quot;
        xsi:schemaLocation=&quot;http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/tx
          http://www.springframework.org/schema/tx/spring-tx.xsd
          http://www.springframework.org/schema/aop
          http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
          http://www.springframework.org/schema/context
          http://www.springframework.org/schema/context/spring-context-2.5.xsd&quot;&gt;

        &lt;import resource=&quot;classpath:/personservice.xml&quot; /&gt;

        &lt;bean id=&quot;datasource&quot;
            class=&quot;org.springframework.jdbc.datasource.DriverManagerDataSource&quot;
            lazy-init=&quot;true&quot;&gt;
            &lt;property name=&quot;driverClassName&quot; value=&quot;org.apache.derby.jdbc.EmbeddedDriver&quot; /&gt;
            &lt;property name=&quot;url&quot; value=&quot;jdbc:derby:InMemoryDatabase;create=true&quot; /&gt;
        &lt;/bean&gt;

        &lt;bean id=&quot;entityManagerFactory&quot;
            class=&quot;org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean&quot;&gt;
            &lt;property name=&quot;dataSource&quot; ref=&quot;datasource&quot; /&gt;
            &lt;property name=&quot;persistenceUnitName&quot; value=&quot;PersonService&quot; /&gt;
            &lt;property name=&quot;jpaVendorAdapter&quot;&gt;
                &lt;bean class=&quot;org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter&quot;&gt;
                    &lt;property name=&quot;databasePlatform&quot; value=&quot;org.hibernate.dialect.DerbyDialect&quot; /&gt;
                    &lt;property name=&quot;showSql&quot; value=&quot;true&quot; /&gt;
                    &lt;property name=&quot;generateDdl&quot; value=&quot;true&quot; /&gt;
                &lt;/bean&gt;
            &lt;/property&gt;
            &lt;property name=&quot;jpaPropertyMap&quot;&gt;
                &lt;map&gt;
                    &lt;entry key=&quot;hibernate.validator.autoregister_listeners&quot; value=&quot;false&quot; /&gt;
                    &lt;entry key=&quot;javax.persistence.transactionType&quot; value=&quot;RESOURCE_LOCAL&quot; /&gt;
                &lt;/map&gt;
            &lt;/property&gt;
        &lt;/bean&gt;

        &lt;bean id=&quot;transactionManager&quot; class=&quot;org.springframework.orm.jpa.JpaTransactionManager&quot;&gt;
            &lt;property name=&quot;entityManagerFactory&quot; ref=&quot;entityManagerFactory&quot; /&gt;
            &lt;property name=&quot;dataSource&quot; ref=&quot;datasource&quot; /&gt;
        &lt;/bean&gt;

        &lt;tx:annotation-driven transaction-manager=&quot;transactionManager&quot;
            proxy-target-class=&quot;false&quot; /&gt;

        &lt;bean id=&quot;beanMapper&quot; class=&quot;org.dozer.DozerBeanMapper&quot;&gt;
            &lt;property name=&quot;mappingFiles&quot;&gt;
                &lt;list&gt;
                    &lt;value&gt;personservice-mappings.xml&lt;/value&gt;
                &lt;/list&gt;
            &lt;/property&gt;
        &lt;/bean&gt;

    &lt;/beans&gt;

_Exception in Maven_

    -------------------------------------------------------
     T E S T S
    -------------------------------------------------------
    Running com.xyz.person.test.PersonServiceTest
    23:18:51,250  WARN JDBCExceptionReporter:77 - SQL Warning: 10000, SQLState: 01J01
    23:18:51,281  WARN JDBCExceptionReporter:78 - Database &#39;InMemoryDatabase&#39; not created, connection made to existing database instead.
    23:18:52,937  WARN JDBCExceptionReporter:77 - SQL Warning: 10000, SQLState: 01J01
    23:18:52,937  WARN JDBCExceptionReporter:78 - Database &#39;InMemoryDatabase&#39; not created, connection made to existing database instead.
    23:18:52,953  WARN TestContextManager:429 - Caught exception while allowing TestExecutionListener [org.springframework.test.context.transaction.TransactionalTestExecutionListener@359a359a] to process &#39;after&#39; execution for test: method [public void com.xyz.person.test.PersonServiceTest.testCreatePerson()], instance [com.xyz.person.test.PersonServiceTest@1bc81bc8], exception [org.springframework.transaction.IllegalTransactionStateException: Pre-bound JDBC Connection found! JpaTransactionManager does not support running within DataSourceTransactionManager if told to manage the DataSource itself. It is recommended to use a single JpaTransactionManager for all transactions on a single DataSource, no matter whether JPA or JDBC access.]
    java.lang.IllegalStateException: No value for key [org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean@3f563f56] bound to thread [main]
            at org.springframework.transaction.support.TransactionSynchronizationManager.unbindResource(TransactionSynchronizationManager.java:199)
            at org.springframework.orm.jpa.JpaTransactionManager.doCleanupAfterCompletion(JpaTransactionManager.java:489)
            at org.springframework.transaction.support.AbstractPlatformTransactionManager.cleanupAfterCompletion(AbstractPlatformTransactionManager.java:1011)
            at org.springframework.transaction.support.AbstractPlatformTransactionManager.processCommit(AbstractPlatformTransactionManager.java:804)
            at org.springframework.transaction.support.AbstractPlatformTransactionManager.commit(AbstractPlatformTransactionManager.java:723)
            at org.springframework.test.context.transaction.TransactionalTestExecutionListener$TransactionContext.endTransaction(TransactionalTestExecutionListener.java:515)
            at org.springframework.test.context.transaction.TransactionalTestExecutionListener.endTransaction(TransactionalTestExecutionListener.java:290)
            at org.springframework.test.context.transaction.TransactionalTestExecutionListener.afterTestMethod(TransactionalTestExecutionListener.java:183)
            at org.springframework.test.context.TestContextManager.afterTestMethod(TestContextManager.java:426)
            at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:90)
            at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:72)
            at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:240)
            at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:50)
            at org.junit.runners.ParentRunner$3.run(ParentRunner.java:193)
            at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:52)
            at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:191)
            at org.junit.runners.ParentRunner.access$000(ParentRunner.java:42)
            at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:184)
            at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)
            at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:70)
            at org.junit.runners.ParentRunner.run(ParentRunner.java:236)
            at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:180)
            at org.apache.maven.surefire.junit4.JUnit4TestSet.execute(JUnit4TestSet.java:59)
            at org.apache.maven.surefire.suite.AbstractDirectoryTestSuite.executeTestSet(AbstractDirectoryTestSuite.java:115)
            at org.apache.maven.surefire.suite.AbstractDirectoryTestSuite.execute(AbstractDirectoryTestSuite.java:102)
            at org.apache.maven.surefire.Surefire.run(Surefire.java:180)
            at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
            at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
            at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:37)
            at java.lang.reflect.Method.invoke(Method.java:599)
            at org.apache.maven.surefire.booter.SurefireBooter.runSuitesInProcess(SurefireBooter.java:350)
            at org.apache.maven.surefire.booter.SurefireBooter.main(SurefireBooter.java:1021)
    23:18:53,078  WARN TestContextManager:377 - Caught exception while allowing TestExecutionListener [org.springframework.test.context.transaction.TransactionalTestExecutionListener@359a359a] to process &#39;before&#39; execution of test method [public void com.xyz.person.test.PersonServiceTest.testFindPersons()] for test instance [com.xyz.person.test.PersonServiceTest@79f279f2]
    org.springframework.transaction.IllegalTransactionStateException: Pre-bound JDBC Connection found! JpaTransactionManager does not support running within DataSourceTransactionManager if told to manage the DataSource itself. It is recommended to use a single JpaTransactionManager for all transactions on a single DataSource, no matter whether JPA or JDBC access.
            at org.springframework.orm.jpa.JpaTransactionManager.doBegin(JpaTransactionManager.java:304)
            at org.springframework.transaction.support.AbstractPlatformTransactionManager.getTransaction(AbstractPlatformTransactionManager.java:371)
            at org.springframework.test.context.transaction.TransactionalTestExecutionListener$TransactionContext.startTransaction(TransactionalTestExecutionListener.java:507)
            at org.springframework.test.context.transaction.TransactionalTestExecutionListener.startNewTransaction(TransactionalTestExecutionListener.java:269)
            at org.springframework.test.context.transaction.TransactionalTestExecutionListener.beforeTestMethod(TransactionalTestExecutionListener.java:162)
            at org.springframework.test.context.TestContextManager.beforeTestMethod(TestContextManager.java:374)
            at org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:73)
            at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:82)
            at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:72)
            at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:240)
            at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:50)
            at org.junit.runners.ParentRunner$3.run(ParentRunner.java:193)
            at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:52)
            at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:191)
            at org.junit.runners.ParentRunner.access$000(ParentRunner.java:42)
            at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:184)
            at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)
            at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:70)
            at org.junit.runners.ParentRunner.run(ParentRunner.java:236)
            at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:180)
            at org.apache.maven.surefire.junit4.JUnit4TestSet.execute(JUnit4TestSet.java:59)
            at org.apache.maven.surefire.suite.AbstractDirectoryTestSuite.executeTestSet(AbstractDirectoryTestSuite.java:115)
            at org.apache.maven.surefire.suite.AbstractDirectoryTestSuite.execute(AbstractDirectoryTestSuite.java:102)
            at org.apache.maven.surefire.Surefire.run(Surefire.java:180)
            at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
            at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
            at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:37)
            at java.lang.reflect.Method.invoke(Method.java:599)
            at org.apache.maven.surefire.booter.SurefireBooter.runSuitesInProcess(SurefireBooter.java:350)
            at org.apache.maven.surefire.booter.SurefireBooter.main(SurefireBooter.java:1021)
    Tests run: 3, Failures: 0, Errors: 3, Skipped: 0, Time elapsed: 15.625 sec &lt;&lt;&lt; FAILURE!

    Results :

    Tests in error:
      testCreatePerson(com.xyz.person.test.PersonServiceTest)
      testCreatePerson(com.xyz.person.test.PersonServiceTest)
      testFindPersons(com.xyz.person.test.PersonServiceTest)

    Tests run: 3, Failures: 0, Errors: 3, Skipped: 0

JUnit tests pass in Eclipse but fail in Maven Surefire

I&#39;d like to write some tests that check the XML Spring configuration of a deployed WAR. Unfortunately some beans require that some environment variables or system properties are set. How can I set an environment variable before the spring beans are initialized when using the convenient test style with @ContextConfiguration?

    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = &quot;classpath:whereever/context.xml&quot;)
    public class TestWarSpringContext { ... }

If I configure the application context with annotations, I don&#39;t see a hook where I can do something before the spring context is initialized.

How to set environment variable or system property in spring tests?

First of all, I&#39;ve found a lot of threads on StackOverflow about this, but none of them really helped me, so sorry to ask possibly duplicate question.

I&#39;m running JUnit tests using spring-test, my code looks like this

    @RunWith(SpringJUnit4ClassRunner.class)  
    @ContextConfiguration(locations = {})
    public class StudentSystemTest {
    
    	@Autowired
    	private StudentSystem studentSystem;
    
        @Before
    	public void initTest() {
        // set up the database, create basic structure for testing
        }
    
        @Test
    	public void test1() {
        }    
        ...  
    }

My problem is that I want my tests to NOT influence other tests.
So I&#39;d like to create something like rollback for each test.
I&#39;ve searched a lot for this, but I&#39;ve found nothing so far.
I&#39;m using Hibernate and MySql for this

Rollback transaction after @Test

Whenever I see a blog post related to Spring testing I see either of these classes but do not understand the real difference:
 

    @RunWith(SpringRunner.class)
    @RunWith(SpringJUnit4ClassRunner.class)



What is the difference between SpringJUnit4ClassRunner and SpringRunner

We&#39;ve a bunch of JUnit test cases (Integration tests) and they are logically grouped into different test classes.

We are able to load Spring application context once per test class and re-use it for all test cases in a JUnit test class as mentioned in http://static.springsource.org/spring/docs/current/spring-framework-reference/html/testing.html

However, we were just wondering if there is a way to load Spring application context only once for a bunch of JUnit test classes.

FWIW, we use Spring 3.0.5, JUnit 4.5 and use Maven to build the project.

Reuse spring application context across junit test classes

For my Spring-Boot app I provide a RestTemplate though a @Configuration file so I can add sensible defaults(ex Timeouts). For my integration tests I would like to mock the RestTemplate as I dont want to connect to external services - I know what responses to expect. I tried providing a different implementation in the integration-test package in the hope that the latter will override the real implementation , but checking the logs it`s the other way around : the real implementation overrides the test one. &lt;br/&gt;&lt;br/&gt;&lt;b&gt; How can I make sure the one from the TestConfig is the one used?&lt;/b&gt;

This is my config file :

    @Configuration
    public class RestTemplateProvider {

        private static final int DEFAULT_SERVICE_TIMEOUT = 5_000;

        @Bean
        public RestTemplate restTemplate(){
            return new RestTemplate(buildClientConfigurationFactory());
        }

        private ClientHttpRequestFactory buildClientConfigurationFactory() {
            HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
            factory.setReadTimeout(DEFAULT_SERVICE_TIMEOUT);
            factory.setConnectTimeout(DEFAULT_SERVICE_TIMEOUT);
            return factory;
        }
    }

Integration test:

    @RunWith(SpringJUnit4ClassRunner.class)
    @SpringApplicationConfiguration(classes = TestConfiguration.class)
    @WebAppConfiguration
    @ActiveProfiles(&quot;it&quot;)
    public abstract class IntegrationTest {}

TestConfiguration class:

    @Configuration
    @Import({Application.class, MockRestTemplateConfiguration.class})
    public class TestConfiguration {}

And finally MockRestTemplateConfiguration

    @Configuration
    public class MockRestTemplateConfiguration {
    
        @Bean
        public RestTemplate restTemplate() {
            return Mockito.mock(RestTemplate.class)
        }
    }

Overriding beans in Integration tests

My Spring-Boot-Mvc-Web application has the following database configuration in `application.properties` file:

    spring.datasource.url=jdbc:h2:tcp://localhost/~/pdk
    spring.datasource.username=sa
    spring.datasource.password=
    spring.datasource.driver-class-name=org.h2.Driver

this is the only config I made. No any other configurations made by me anywhere. Nevertheless the Spring and subsystems are automatically recreate database on each web application run. Database is recreated namely on system run while it contains data after application ends.

I was not understanding this defaults and was expecting this is suitable for tests.

But when I started to run tests I found that database is recreated only once. Since tests are executed at no predefined order, this is senseless at all.

So, the question is: &lt;s&gt;how to make any sense? I.e.&lt;/s&gt; how to make database recreate before each test as it happens at application first start?

My test class header is follows:

    @RunWith(SpringJUnit4ClassRunner.class)
    @SpringApplicationConfiguration(classes = myapp.class)
    //@WebAppConfiguration
    @WebIntegrationTest
    @DirtiesContext
    public class WebControllersTest {

As you see, I tried `@DirtiesContext` at class level and it didn&#39;t help.

**UPDATE**

I have a bean

    @Service
    public class DatabaseService implements InitializingBean {

which has a method

    @Override
        @Transactional()
        public void afterPropertiesSet() throws Exception {
            log.info(&quot;Bootstrapping data...&quot;);
            User user = createRootUser();
            if(populateDemo) {
                populateDemos();
            }
            log.info(&quot;...Bootstrapping completed&quot;);
        }

Now I made it&#39;s `populateDemos()` method to clear all data from database. Unfortunately, it does not called before each test despite `@DirtiesContext`. Why?

How to re-create database before each test in Spring?

The following code is invalid due to duplicate `@RunWith` annotation:

    @RunWith(SpringJUnit4ClassRunner.class)
    @RunWith(Parameterized.class)
    @SpringApplicationConfiguration(classes = {ApplicationConfigTest.class})
    public class ServiceTest {
    }

But how can I use these two annotations in conjunction?

How to run JUnit SpringJUnit4ClassRunner with Parametrized?

I&#39;m trying to create a simple spring boot web project with security.  I can launch the application fine and the security is working fine.  However, I have some components that I want to test without security (or test at all -- I cant get the test working at all).

I get an exception indicating that it can&#39;t find an ObjectPostProcessor and thus can&#39;t bring up the container.  

Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [org.springframework.security.config.annotation.ObjectPostProcessor] found for dependency

&lt;pre&gt;
14:01:50.937 [main] ERROR o.s.boot.SpringApplication - Application startup failed
org.springframework.beans.factory.BeanCreationException: Error creating bean with name &#39;fmpdfApplication.ApplicationSecurity&#39;: Injection of autowired dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowire method: public void org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter.setObjectPostProcessor(org.springframework.security.config.annotation.ObjectPostProcessor); nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [org.springframework.security.config.annotation.ObjectPostProcessor] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {}
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:334) ~[spring-beans-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1210) ~[spring-beans-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:537) ~[spring-beans-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:476) ~[spring-beans-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:303) ~[spring-beans-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:230) ~[spring-beans-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:299) ~[spring-beans-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:194) ~[spring-beans-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:755) ~[spring-beans-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:757) ~[spring-context-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:480) ~[spring-context-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:686) ~[spring-boot-1.2.4.RELEASE.jar:1.2.4.RELEASE]
	at org.springframework.boot.SpringApplication.run(SpringApplication.java:320) ~[spring-boot-1.2.4.RELEASE.jar:1.2.4.RELEASE]
	at org.springframework.boot.test.SpringApplicationContextLoader.loadContext(SpringApplicationContextLoader.java:103) [spring-boot-1.2.4.RELEASE.jar:1.2.4.RELEASE]
	at org.springframework.test.context.DefaultCacheAwareContextLoaderDelegate.loadContextInternal(DefaultCacheAwareContextLoaderDelegate.java:68) [spring-test-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.test.context.DefaultCacheAwareContextLoaderDelegate.loadContext(DefaultCacheAwareContextLoaderDelegate.java:86) [spring-test-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.test.context.DefaultTestContext.getApplicationContext(DefaultTestContext.java:72) [spring-test-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.test.context.support.DependencyInjectionTestExecutionListener.injectDependencies(DependencyInjectionTestExecutionListener.java:117) [spring-test-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.test.context.support.DependencyInjectionTestExecutionListener.prepareTestInstance(DependencyInjectionTestExecutionListener.java:83) [spring-test-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.test.context.TestContextManager.prepareTestInstance(TestContextManager.java:212) [spring-test-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.createTest(SpringJUnit4ClassRunner.java:200) [spring-test-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner$1.runReflectiveCall(SpringJUnit4ClassRunner.java:259) [spring-test-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12) [junit-4.12.jar:4.12]
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.methodBlock(SpringJUnit4ClassRunner.java:261) [spring-test-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:219) [spring-test-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:83) [spring-test-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290) [junit-4.12.jar:4.12]
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71) [junit-4.12.jar:4.12]
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288) [junit-4.12.jar:4.12]
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58) [junit-4.12.jar:4.12]
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268) [junit-4.12.jar:4.12]
	at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61) [spring-test-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:68) [spring-test-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.junit.runners.ParentRunner.run(ParentRunner.java:363) [junit-4.12.jar:4.12]
	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:163) [spring-test-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137) [junit-4.12.jar:4.12]
	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:78) [junit-rt.jar:na]
	at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:212) [junit-rt.jar:na]
	at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:68) [junit-rt.jar:na]
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_45]
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_45]
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_45]
	at java.lang.reflect.Method.invoke(Method.java:497) ~[na:1.8.0_45]
	at com.intellij.rt.execution.application.AppMain.main(AppMain.java:140) [idea_rt.jar:na]
Caused by: org.springframework.beans.factory.BeanCreationException: Could not autowire method: public void org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter.setObjectPostProcessor(org.springframework.security.config.annotation.ObjectPostProcessor); nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [org.springframework.security.config.annotation.ObjectPostProcessor] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {}
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredMethodElement.inject(AutowiredAnnotationBeanPostProcessor.java:649) ~[spring-beans-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:88) ~[spring-beans-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:331) ~[spring-beans-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	... 43 common frames omitted
Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [org.springframework.security.config.annotation.ObjectPostProcessor] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {}
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.raiseNoSuchBeanDefinitionException(DefaultListableBeanFactory.java:1301) ~[spring-beans-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1047) ~[spring-beans-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:942) ~[spring-beans-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredMethodElement.inject(AutowiredAnnotationBeanPostProcessor.java:606) ~[spring-beans-4.1.6.RELEASE.jar:4.1.6.RELEASE]
	... 45 common frames omitted
&lt;/pre&gt;

I&#39;m not even trying to test anything related to web or security or anything.  I&#39;m just unit testing one of my components.
My Unit test (in groovy) is like:


&lt;!-- language: java --&gt;    

    @RunWith(SpringJUnit4ClassRunner)
    @SpringApplicationConfiguration(classes = FmpdfApplication)
    @ActiveProfiles([&quot;test&quot;, &quot;mockstore&quot;])
    class PdfUpdaterTest {
    
        @Resource PdfUpdater pdfUpdater
        ...

And my (relevant) gradle dependencies are:

    compile(&quot;org.springframework.boot:spring-boot-starter-actuator&quot;)
    compile(&quot;org.springframework.boot:spring-boot-starter-security&quot;)
    compile(&quot;org.springframework.boot:spring-boot-starter-web&quot;)
    compile(&quot;org.springframework.boot:spring-boot-starter-jdbc&quot;)
    testCompile(&quot;org.springframework.boot:spring-boot-starter-test&quot;)

I have tried setting 
management.security.enabled=false
security.basic.enabled=false
But that didn&#39;t help

One other relevant bit of info: I needed to customize the security so I followed the pattern to:

&lt;!-- language: java --&gt;    

    @Configuration
    @Order(SecurityProperties.ACCESS_OVERRIDE_ORDER)
    protected static class ApplicationSecurity extends WebSecurityConfigurerAdapter {
            @Override
            public void configure(AuthenticationManagerBuilder auth) throws Exception {
        ..

Is this part of the problem?  Is there a way to make this @Lazy if that&#39;s related?

Update: If I mark the unit test as @WebIntegrationTest then everything works -- but it starts up an embedded tomcat server.  How can I disable spring security for unit testing non web things?


Disable security for unit tests with spring boot

I have following test class

    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = {&quot;/services-test-config.xml&quot;})
    public class MySericeTest {
    
      @Autowired
      MyService service;
    ...
    
    }

Is it possible to access `services-test-config.xml` programmatically in one of such methods? Like:

    ApplicationContext ctx = somehowGetContext();





How to access Spring context in jUnit tests annotated with @RunWith and @ContextConfiguration?

What am I doing wrong? I&#39;m using this little standalone App which runs and finds my `src/main/resources/config/application.yml`. The same configuration doesn&#39;t work from JUnit, see below:

    @Configuration
    @ComponentScan
    @EnableConfigurationProperties
    
    public class TestApplication {

        public static void main(String[] args) {

            SpringApplication.run(TestApplication.class);
        }
    }


    @Component
    @ConfigurationProperties

    public class Bean{
        ...
    }

The following doesn&#39;t work, the same properties in `application.yml` are not loaded and `Bean` has only `null` values:

    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(classes = TestApplication.class)

    public class SomeTestClass {
        ...
    }



Spring Boot properties in &#39;application.yml&#39; not loading from JUnit Test

I have a `Bean` defined in a class decorated with `@Configuration`:

    @Configuration
    public class MyBeanConfig {
        @Bean
        public String configPath() {
            return &quot;../production/environment/path&quot;;
        }
    }

I have a class decorated with `@TestConfiguration` that should override this `Bean`:

    @TestConfiguration
    public class MyTestConfiguration {
        @Bean
        @Primary
        public String configPath() {
            return &quot;/test/environment/path&quot;;
        }
    }

The `configPath` bean is used to set the path to an external file containing a registration code that must be read during startup. It is used in an `@Component` class:

    @Component
    public class MyParsingComponent {
        private String CONFIG_PATH;
        
        @Autowired
        public void setCONFIG_PATH(String configPath) {
            this.CONFIG_PATH = configPath;
        }
    }

While trying to debug this I set a breakpoint inside each method as well as the constructor of the test config class. The `@TestConfiguration`&#39;s constructor breakpoint is hit, so i know that my test configuration class instantiates, however the `configPath` method of that class is never hit. Instead, the `configPath` method of the normal `@Configuration` class is hit and the `@Autowired` `String` in `MyParsingComponent` is always `../production/environment/path` rather than the expected `/test/environment/path`.

Not sure why this is happening. Any thoughts would be greatly appreciated.

Spring Boot: @TestConfiguration Not Overriding Bean During Integration Test

On my spring boot application I want to override just one of my `@Configuration` classes with a test configuration (in particular my `@EnableAuthorizationServer` `@Configuration` class), on all of my tests.

So far after an overview of [spring boot testing features][1] and [spring integration testing features][2] no straightforward solution has surfaced:

- `@TestConfiguration`: It&#39;s for extending, not overriding;
- `@ContextConfiguration(classes=…​)` and `@SpringApplicationConfiguration(classes =…​)` let me override the whole config, not just the one class;
- An inner `@Configuration` class inside a `@Test` is suggested to override the default configuration, but no example is provided;

Any suggestions?


  [1]: http://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-testing.html
  [2]: http://docs.spring.io/spring/docs/current/spring-framework-reference/html/integration-testing.html

Override a single @Configuration class on every spring boot @Test

I have a very simple test case that is using Mockito and Spring Test framework. When I do 

    when(pcUserService.read(&quot;1&quot;)).thenReturn(pcUser);

I get this exception. 

    org.mockito.exceptions.misusing.MissingMethodInvocationException: 
    when() requires an argument which has to be &#39;a method call on a mock&#39;.
    For example:
        when(mock.getArticles()).thenReturn(articles);
    
    Also, this error might show up because:
    1. you stub either of: final/private/equals()/hashCode() methods.
       Those methods *cannot* be stubbed/verified.
    2. inside when() you don&#39;t call method on mock but on some other object.
    
    	at com.project.cleaner.controller.test.PcUserControllerTest.shouldGetPcUser(PcUserControllerTest.java:93)
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
    	at java.lang.reflect.Method.invoke(Unknown Source)
    	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)

I have tried with different methods but keep on getting this error message. I am using Spring 3.1.0.RELEASE with Mockito. Please share and guide me in the right direction.

Mockito Exception - when() requires an argument which has to be a method call on a mock

I am using `Spring Data JPA` and `Spring Boot`. The layout of the application is this

    main
        +-- java
            +-- com/lapots/game/monolith
                +-- repository/relational
                    +--RelationalPlayerRepository.java
                +-- web
                    +--GrandJourneyMonolithApplication.java
                    +-- config
                        +-- RelationalDBConfiguration.java
    test
        +-- java
            +-- com/lapots/game/monolith
                +-- repository/relational
                    +-- RelationalPlayerRepositoryTests.java
                +-- web
                    +-- GrandJourneyMonolithApplicationTests.java


The repository for my object looks like this

    public interface RelationalPlayerRepository extends JpaRepository&lt;Player, Long&gt; {
    }

Additionally for the repositories I provided a configuration

    @Configuration
    @EnableJpaRepositories(basePackages = &quot;com.lapots.game.monolith.repository.relational&quot;)
    @EntityScan(&quot;com.lapots.game.monolith.domain&quot;)
    public class RelationalDBConfiguration {
    }

My main application looks like this

    @SpringBootApplication
    @ComponentScan(&quot;com.lapots.game.monolith&quot;)
    public class GrandJourneyMonolithApplication {

        @Autowired
        private RelationalPlayerRepository relationalPlayerRepository;

        public static void main(String[] args) {
            SpringApplication.run(GrandJourneyMonolithApplication.class, args);
        }

        @Bean
        public CommandLineRunner initPlayers() {
            return (args) -&gt; {
                Player p = new Player();
                p.setLevel(10);
                p.setName(&quot;Master1909&quot;);
                p.setClazz(&quot;warrior&quot;);

                relationalPlayerRepository.save(p);
            };
        }
    }
    
Test for application looks like this

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class GrandJourneyMonolithApplicationTests {

        @Test
        public void contextLoads() {
        }

    }
    
The test for repository looks like this

    @RunWith(SpringRunner.class)
    @DataJpaTest
    public class RelationalPlayerRepositoryTests {

        @Autowired
        private TestEntityManager entityManager;

        @Autowired
        private RelationalPlayerRepository repository;

        @Test
        public void testBasic() {
            Player expected = createPlayer(&quot;Master12&quot;, &quot;warrior&quot;, 10);
            this.entityManager.persist(expected);
            List&lt;Player&gt; players = repository.findAll();
            assertThat(repository.findAll()).isNotEmpty();
            assertEquals(expected, players.get(0));
        }

        private Player createPlayer(String name, String clazz, int level) {
            Player p = new Player();
            p.setId(1L);
            p.setName(name);
            p.setClazz(clazz);
            p.setLevel(level);
            return p;
        }
    }

But when I try to run the tests I get the error

    Tests run: 1, Failures: 0, Errors: 1, Skipped: 0, Time elapsed: 0.041 sec &lt;&lt;&lt; FAILURE! - in com.lapots.game.monolith.repository.relational.RelationalPlayerRepositoryTests
    initializationError(com.lapots.game.monolith.repository.relational.RelationalPlayerRepositoryTests)  Time elapsed: 0.006 sec  &lt;&lt;&lt; ERROR!
    java.lang.IllegalStateException: Unable to find a @SpringBootConfiguration, you need to use @ContextConfiguration or @SpringBootTest(classes=...) with your test
    at org.springframework.util.Assert.state(Assert.java:70)
    at org.springframework.boot.test.context.SpringBootTestContextBootstrapper.getOrFindConfigurationClasses(SpringBootTestContextBootstrapper.java:202)
    at org.springframework.boot.test.context.SpringBootTestContextBootstrapper.processMergedContextConfiguration(SpringBootTestContextBootstrapper.java:137)
    at org.springframework.test.context.support.AbstractTestContextBootstrapper.buildMergedContextConfiguration(AbstractTestContextBootstrapper.java:409)
    at org.springframework.test.context.support.AbstractTestContextBootstrapper.buildDefaultMergedContextConfiguration(AbstractTestContextBootstrapper.java:323)
    at org.springframework.test.context.support.AbstractTestContextBootstrapper.buildMergedContextConfiguration(AbstractTestContextBootstrapper.java:277)
    at org.springframework.test.context.support.AbstractTestContextBootstrapper.buildTestContext(AbstractTestContextBootstrapper.java:112)
    at org.springframework.boot.test.context.SpringBootTestContextBootstrapper.buildTestContext(SpringBootTestContextBootstrapper.java:82)
    at org.springframework.test.context.TestContextManager.&lt;init&gt;(TestContextManager.java:120)
    at org.springframework.test.context.TestContextManager.&lt;init&gt;(TestContextManager.java:105)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.createTestContextManager(SpringJUnit4ClassRunner.java:152)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.&lt;init&gt;(SpringJUnit4ClassRunner.java:143)
    at org.springframework.test.context.junit4.SpringRunner.&lt;init&gt;(SpringRunner.java:49)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
    at org.junit.internal.builders.AnnotatedBuilder.buildRunner(AnnotatedBuilder.java:104)
    at org.junit.internal.builders.AnnotatedBuilder.runnerForClass(AnnotatedBuilder.java:86)
    at org.junit.runners.model.RunnerBuilder.safeRunnerForClass(RunnerBuilder.java:59)
    at org.junit.internal.builders.AllDefaultPossibilitiesBuilder.runnerForClass(AllDefaultPossibilitiesBuilder.java:26)
    at org.junit.runners.model.RunnerBuilder.safeRunnerForClass(RunnerBuilder.java:59)
    at org.junit.internal.requests.ClassRequest.getRunner(ClassRequest.java:33)
    at org.apache.maven.surefire.junit4.JUnit4Provider.execute(JUnit4Provider.java:283)
    at org.apache.maven.surefire.junit4.JUnit4Provider.executeWithRerun(JUnit4Provider.java:173)
    at org.apache.maven.surefire.junit4.JUnit4Provider.executeTestSet(JUnit4Provider.java:153)
    at org.apache.maven.surefire.junit4.JUnit4Provider.invoke(JUnit4Provider.java:128)
    at org.apache.maven.surefire.booter.ForkedBooter.invokeProviderInSameClassLoader(ForkedBooter.java:203)
    at org.apache.maven.surefire.booter.ForkedBooter.runSuitesInProcess(ForkedBooter.java:155)
    at org.apache.maven.surefire.booter.ForkedBooter.main(ForkedBooter.java:103)

What is the problem?
Domain `Player` loooks like this

    @Data
    @Entity
    @Table(schema = &quot;app&quot;, name = &quot;players&quot;)
    public class Player {
        @Id
        @GeneratedValue
        private Long id;

        @Transient
        Set&lt;Player&gt; comrades;

        @Column(unique = true)
        private String name;

        private int level;

        @Column(name = &quot;class&quot;)
        private String clazz;
    }

Unable to find a @SpringBootConfiguration, you need to use @ContextConfiguration or @SpringBootTest(classes=...) with your test

I have the following test class:

    @ActiveProfiles({ &quot;DataTC&quot;, &quot;test&quot; })
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(classes = {BaseTestConfiguration.class, DataTestConfiguration.class, JpaConfiguration.class, PropertyPlaceholderConfiguration.class })
    public class RegularDayToTimeSlotsTest {
    ...

The issue seems to come from the BaseTestConfiguration class:

    @Configuration
    @ComponentScan(basePackages = { &quot;com.bignibou&quot; }, excludeFilters = { @Filter(type = FilterType.CUSTOM, value = RooRegexFilter.class),
    		@Filter(type = FilterType.ANNOTATION, value = Controller.class), @Filter(type = FilterType.ANNOTATION, value = ControllerAdvice.class) })
    public class BaseTestConfiguration {
    
    }

I systematically get this exception:

    Caused by: java.lang.IllegalArgumentException: A ServletContext is required to configure default servlet handling
    	at org.springframework.util.Assert.notNull(Assert.java:112)
    	at org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer.&lt;init&gt;(DefaultServletHandlerConfigurer.java:54)
    	at org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport.defaultServletHandlerMapping(WebMvcConfigurationSupport.java:329)
    	at org.springframework.web.servlet.config.annotation.DelegatingWebMvcConfiguration$$EnhancerByCGLIB$$bb4ceb44.CGLIB$defaultServletHandlerMapping$22(&lt;generated&gt;)
    	at org.springframework.web.servlet.config.annotation.DelegatingWebMvcConfiguration$$EnhancerByCGLIB$$bb4ceb44$$FastClassByCGLIB$$368bb5c1.invoke(&lt;generated&gt;)
    	at org.springframework.cglib.proxy.MethodProxy.invokeSuper(MethodProxy.java:228)
    	at org.springframework.context.annotation.ConfigurationClassEnhancer$BeanMethodInterceptor.intercept(ConfigurationClassEnhancer.java:326)
    	at org.springframework.web.servlet.config.annotation.DelegatingWebMvcConfiguration$$EnhancerByCGLIB$$bb4ceb44.defaultServletHandlerMapping(&lt;generated&gt;)
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    	at java.lang.reflect.Method.invoke(Method.java:606)
    	at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:166)
    	... 43 more

I am not sure how to get around this issue. Somehow Spring is looking for a ServletContext when I run the test and I get the above exception...

java.lang.IllegalArgumentException: A ServletContext is required to configure default servlet handling

By following the official doc here:
http://docs.spring.io/spring-boot/docs/1.4.0.M2/reference/htmlsingle/#Testing

i wanted to test one of my REST API method like this:


    @RunWith(SpringRunner.class)
    @WebMvcTest(LoginController.class)
    @SpringBootTest(classes = Application.class)
    public class AuthorizationServiceTest {
    	@Autowired
    	private TestRestTemplate restTemplate;

    	@Test
    	public void test() {
    		Object returnedObject=his.restTemplate.getForObject(&quot;/login&quot;, Object.class);
    	}
    }

As stated in the doc :


&gt; The search algorithm works up from the package that contains the test
&gt; until it finds a @SpringBootApplication or @SpringBootConfiguration
&gt; annotated class. As long as you’ve structure your code in a sensible
&gt; way your main configuration is usually found.


I have structured my code properly(atleast i think ):

**AuthorizationService** : is under  package          com.xxx.yyy.zzz.authorization;  

**AuthorizationServiceTest** : is under  package          com.xxx.yyy.zzz.authorizationTest;



I am getting this exception(Full Trace):


    java.lang.IllegalStateException: Configuration error: found multiple declarations of @BootstrapWith for test class [com.orangeraid.rasberry.gateway.authorizationTest.AuthorizationServiceTest]: [@org.springframework.test.context.BootstrapWith(value=class org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTestContextBootstrapper), @org.springframework.test.context.BootstrapWith(value=class org.springframework.boot.test.context.SpringBootTestContextBootstrapper)]
    	at org.springframework.test.context.BootstrapUtils.resolveExplicitTestContextBootstrapper(BootstrapUtils.java:155)
    	at org.springframework.test.context.BootstrapUtils.resolveTestContextBootstrapper(BootstrapUtils.java:126)
    	at org.springframework.test.context.TestContextManager.&lt;init&gt;(TestContextManager.java:105)
    	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.createTestContextManager(SpringJUnit4ClassRunner.java:152)
    	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.&lt;init&gt;(SpringJUnit4ClassRunner.java:143)
    	at org.springframework.test.context.junit4.SpringRunner.&lt;init&gt;(SpringRunner.java:49)
    	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    	at java.lang.reflect.Constructor.newInstance(Constructor.java:422)
    	at org.junit.internal.builders.AnnotatedBuilder.buildRunner(AnnotatedBuilder.java:104)
    	at org.junit.internal.builders.AnnotatedBuilder.runnerForClass(AnnotatedBuilder.java:86)
    	at org.junit.runners.model.RunnerBuilder.safeRunnerForClass(RunnerBuilder.java:59)
    	at org.junit.internal.builders.AllDefaultPossibilitiesBuilder.runnerForClass(AllDefaultPossibilitiesBuilder.java:26)
    	at org.junit.runners.model.RunnerBuilder.safeRunnerForClass(RunnerBuilder.java:59)
    	at org.junit.internal.requests.ClassRequest.getRunner(ClassRequest.java:33)
    	at org.eclipse.jdt.internal.junit4.runner.JUnit4TestLoader.createUnfilteredTest(JUnit4TestLoader.java:84)
    	at org.eclipse.jdt.internal.junit4.runner.JUnit4TestLoader.createTest(JUnit4TestLoader.java:70)
    	at org.eclipse.jdt.internal.junit4.runner.JUnit4TestLoader.loadTests(JUnit4TestLoader.java:43)
    	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:444)
    	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:675)
    	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382)
    	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192)

Please help me with this, i have already spent more than 2-3 hours without any luck.


Thanks.



Spring boot 1.4 Testing : Configuration error: found multiple declarations of @BootstrapWith

We are using Spring for my application purposes, and Spring Testing framework for unit tests. We have a small problem though: the application code loads a Spring application context from a list of locations (XML files) in the classpath. But when we run our unit tests, we want some of the Spring beans to be mocks instead of full-fledged implementation classes. Moreover, for some unit tests we want some beans to become mocks, while for other unit tests we want other beans to become mocks, as we are testing different layers of the application.

All this means I want to redefine specific beans of the application context and refresh the context when desired. While doing this, I want to redefine only a small portion of the beans located in one (or several) original XML beans definition file. I cannot find an easy way to do it. It&#39;s always regarded that Spring is a unit-testing-friendly framework, so I must be missing something here.

Do you have any ideas how to do it?

Thanks!


Spring beans redefinition in unit test environment

I have a simple annotated controller similar to this one:

    @Controller
    public class MyController {
      @RequestMapping(&quot;/{id}.html&quot;)
      public String doSomething(@PathVariable String id, Model model) {
        // do something
        return &quot;view&quot;;
      }
    }

and I want to test it with an unit test like this:

    public class MyControllerTest {
      @Test
      public void test() {
        MockHttpServletRequest request = new MockHttpServletRequest();
        request.setRequestURI(&quot;/test.html&quot;);
        new AnnotationMethodHandlerAdapter()
          .handle(request, new MockHttpServletResponse(), new MyController());
        // assert something
      }
    }

The problem is that AnnotationMethodHandlerAdapter.handler() method throws an exception:

    java.lang.IllegalStateException: Could not find @PathVariable [id] in @RequestMapping
	at org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter$ServletHandlerMethodInvoker.resolvePathVariable(AnnotationMethodHandlerAdapter.java:642)
	at org.springframework.web.bind.annotation.support.HandlerMethodInvoker.resolvePathVariable(HandlerMethodInvoker.java:514)
	at org.springframework.web.bind.annotation.support.HandlerMethodInvoker.resolveHandlerArguments(HandlerMethodInvoker.java:262)
	at org.springframework.web.bind.annotation.support.HandlerMethodInvoker.invokeHandlerMethod(HandlerMethodInvoker.java:146)

How to unit test a Spring MVC controller using @PathVariable?


I am using spring boot `1.4.0.RELEASE`. I am writing tests for my controller class. I get the following exception.

    org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name &#39;com.concur.cognos.authentication.service.ServiceControllerITTest&#39;: Unsatisfied dependency expressed through field &#39;restTemplate&#39;: No qualifying bean of type [org.springframework.boot.test.web.client.TestRestTemplate] found for dependency [org.springframework.boot.test.web.client.TestRestTemplate]: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [org.springframework.boot.test.web.client.TestRestTemplate] found for dependency [org.springframework.boot.test.web.client.TestRestTemplate]: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}

Here is my test class

    public class ServiceControllerITTest extends ApplicationTests {
    
        @Autowired
        private TestRestTemplate restTemplate;
    
        @Autowired
        private MockMvc mvc;
    
        @Test
        public void exampleTest() throws Exception {
             // test
        }
    }

`ApplicationTests.java`

    @RunWith(SpringRunner.class)
    @SpringBootTest
    @WebAppConfiguration
    //@DirtiesContext
    public class ApplicationTests {
    
    	@Autowired
    	Environment env;
    
    	@Test
    	public void contextLoads() {
    		
    	}
    
    }



spring boot test unable to inject TestRestTemplate and MockMvc

I was using `@RunWith(MockitoJUnitRunner.class)` for my junit test with mockito. But now i am working with spring boot app and trying to use `@RunWith(SpringRunner.class)` . Does using `@RunWith(SpringRunner.class)` has any advantages over using `@RunWith(MockitoJUnitRunner.class)`? Can i still use feature like `@Injectmock`, `@Mock`, `@Spy` with `@RunWith(SpringRunner.class)`

@RunWith(SpringRunner.class) vs @RunWith(MockitoJUnitRunner.class)

I&#39;m pretty new to Mockito and have some trouble with clean up.

I used to use JMock2 for unit tests. As far as I know, JMock2 preserves the expectations and other mock information in a context which will be rebuilt for every test method. Therefore every test method is not interfered by the others.

I adopted the same strategy for spring tests when using JMock2, I found a potential problem with the strategies I used in my [post](http://java.dzone.com/articles/how-use-mockstub-spring): The application context is rebuilt for every test method and therefore slows the whole test procedure.

I noticed many articles recommend using Mockito in spring tests and I would like to have a try. It works well until I write two test method in a test case. Each test method passed when it ran alone, One of them failed if they ran together. I speculated that this is because the mock infomation was preserved in the mock itself(&#39;cause I don&#39;t see any context object like that in JMock) and the mock(and the application context) is shared in both test methods.

I solved it by adding reset() in @Before method. My question is what is the best practice to handle this situation (The javadoc of reset() says that the code is smell if you need reset())? Any idea is appreciate, thanks in advance.

    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = {
		&quot;file:src/main/webapp/WEB-INF/booking-servlet.xml&quot;,
		&quot;classpath:test-booking-servlet.xml&quot; })
    @WebAppConfiguration
    public class PlaceOrderControllerIntegrationTests implements IntegrationTests {

	@Autowired
	private WebApplicationContext wac;

	private MockMvc mockMvc;

	@Autowired
	private PlaceOrderService placeOrderService;

	@Before
	public void setup() {
		this.mockMvc = webAppContextSetup(this.wac).build();

		reset(placeOrderService);// reset mock
	}

	@Test
	public void fowardsToFoodSelectionViewAfterPendingOrderIsPlaced()
			throws Exception {

		final Address deliveryAddress = new AddressFixture().build();
		final String deliveryTime = twoHoursLater();
		final PendingOrder pendingOrder = new PendingOrderFixture()
				.with(deliveryAddress).at(with(deliveryTime)).build();

		when(placeOrderService.placeOrder(deliveryAddress, with(deliveryTime)))
				.thenReturn(pendingOrder);

		mockMvc.perform(...);

	}

	@Test
	public void returnsToPlaceOrderViewWhenFailsToPlaceOrder() throws Exception {

		final Address deliveryAddress = new AddressFixture().build();
		final String deliveryTime = twoHoursLater();
		final PendingOrder pendingOrder = new PendingOrderFixture()
				.with(deliveryAddress).at(with(deliveryTime)).build();

		NoAvailableRestaurantException noAvailableRestaurantException = new NoAvailableRestaurantException(
				deliveryAddress, with(deliveryTime));
		when(placeOrderService.placeOrder(deliveryAddress, with(deliveryTime)))
				.thenThrow(noAvailableRestaurantException);

				mockMvc.perform(...);

	}




How to clean up mocks in spring tests when using Mockito

I am testing my controller given below

    @Controller
    public class MasterController {

	@GetMapping(&quot;/&quot;)
	public String goLoginPage(){
		return &quot;index&quot;;
	}
    }

I am following [this][1] Spring documentation to test my controller.
  [1]: https://spring.io/guides/gs/testing-web/

Now, I want to test my controller by just instantiating the web layer and not the whole Spring context as given in the documentation. Below is my code for the same.

    @RunWith(SpringRunner.class)
    @WebMvcTest
    public class MasterControllerTestWithWebLayer {
	
	@Autowired
	MockMvc mockMvc;
	
	@Autowired
	MasterController masterController;
	

	@Before
	public void setUp() throws Exception {
	}

	@After
	public void tearDown() throws Exception {
	}
	
	@Test
	public void testLoginHome() throws Exception{
		mockMvc.perform(get(&quot;/&quot;))
		.andExpect(status().isOk())
		.andExpect(view().name(&quot;index&quot;));
	}

    }

When I run this test I get the error `Unable to find @SpringBootConfiguration,...etc`. But I am confused why it is asking for Spring configuration when we do not want it to instantiate it but want to use only the web layer. Kindly point me to the right direction what is happening here. And also how to fix this. Thanks






Error: Unable to find @SpringBootConfiguration when doing @WebMvcTest for Spring Controller

    @RunWith(SpringJUnit4ClassRunner.class)
    public void ITest {
    	@Autowired
    	private EntityRepository dao;
    
    	@BeforeClass
    	public static void init() {
    		dao.save(initialEntity); //not possible as field is not static
    	}
    }

How can I have my service injected already in the static init class?

How to autowire field in static @BeforeClass?

How do I configure my Spring Boot application so that when I run unit tests it will use in-memory database such as H2/HSQL but when I run Spring Boot application it will use production database [Postgre/MySQL] ?

All Spring Test Solutions on Gang of Coders

Total of 25 Spring Test Solutions