Grails 3.3.5: resources.groovy not evaluated in Integration Tests

[miffels]

When trying to autowire a bean in an integration test that was defined in resources.groovy, the app fails to start in the test environment. When defining the bean in a plugin's doWithSpring closure instead, it works as expected. When trying to deliberately throw a RuntimeException in resources.groovy it turns out that the application does not run into that exception before failing to inject the bean, which I assume means that resources.groovy does not even get evaluated in that environment.

Task List

• Steps to reproduce provided
• Stacktrace (if present) provided
• Example that reproduces the problem uploaded to Github
• Full description of the issue provided (see below)

Steps to Reproduce

1. Create a new Grails plugin with Grails 3.3.5: grails create-plugin bean.test.bean-test
2. Add an arbitrary class to src/main/groovy, e.g. DummyDependency
3. Add a bean definition in grails-app/conf/spring/resources.groovy
4. Add an integration test that is trying to autowire the bean
5. Run the integration test: ./gradlew integrationTest

Expected Behaviour

The bean should be injected and the test should succeed

Actual Behaviour

Before the test suite is executed, the application crashes with the following UnsatisfiedDependencyException:

org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'bean.test.DummySpecification': Unsatisfied dependency expressed through field 'dummyDependency'; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'bean.test.beans.DummyDependency' available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true), @org.spockframework.runtime.model.FieldMetadata(line=13, name=dummyDependency, ordinal=0)}
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:588)
	at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:88)
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:366)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1268)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.autowireBeanProperties(AbstractAutowireCapableBeanFactory.java:386)
	at org.springframework.test.context.support.DependencyInjectionTestExecutionListener.injectDependencies(DependencyInjectionTestExecutionListener.java:118)
	at org.springframework.test.context.support.DependencyInjectionTestExecutionListener.prepareTestInstance(DependencyInjectionTestExecutionListener.java:83)
	at org.springframework.test.context.TestContextManager.prepareTestInstance(TestContextManager.java:230)
	at org.spockframework.spring.SpringTestContextManager.prepareTestInstance(SpringTestContextManager.java:50)
	at org.spockframework.spring.SpringInterceptor.interceptSetupMethod(SpringInterceptor.java:42)
	at org.spockframework.runtime.extension.AbstractMethodInterceptor.intercept(AbstractMethodInterceptor.java:28)
	at org.spockframework.runtime.extension.MethodInvocation.proceed(MethodInvocation.java:87)
	at org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecuter.runTestClass(JUnitTestClassExecuter.java:114)
	at org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecuter.execute(JUnitTestClassExecuter.java:57)
	at org.gradle.api.internal.tasks.testing.junit.JUnitTestClassProcessor.processTestClass(JUnitTestClassProcessor.java:66)
	at org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.processTestClass(SuiteTestClassProcessor.java:51)
	at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35)
	at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)
	at org.gradle.internal.dispatch.ContextClassLoaderDispatch.dispatch(ContextClassLoaderDispatch.java:32)
	at org.gradle.internal.dispatch.ProxyDispatchAdapter$DispatchingInvocationHandler.invoke(ProxyDispatchAdapter.java:93)
	at org.gradle.api.internal.tasks.testing.worker.TestWorker.processTestClass(TestWorker.java:109)
	at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35)
	at org.gradle.internal.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)
	at org.gradle.internal.remote.internal.hub.MessageHubBackedObjectConnection$DispatchWrapper.dispatch(MessageHubBackedObjectConnection.java:147)
	at org.gradle.internal.remote.internal.hub.MessageHubBackedObjectConnection$DispatchWrapper.dispatch(MessageHubBackedObjectConnection.java:129)
	at org.gradle.internal.remote.internal.hub.MessageHub$Handler.run(MessageHub.java:404)
	at org.gradle.internal.concurrent.ExecutorPolicy$CatchAndRecordFailures.onExecute(ExecutorPolicy.java:63)
	at org.gradle.internal.concurrent.StoppableExecutorImpl$1.run(StoppableExecutorImpl.java:46)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)
Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'bean.test.beans.DummyDependency' available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true), @org.spockframework.runtime.model.FieldMetadata(line=13, name=dummyDependency, ordinal=0)}
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.raiseNoMatchingBeanFound(DefaultListableBeanFactory.java:1493)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1104)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:1066)
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:585)
	... 30 more

Environment Information

• Operating System: Windows 10
• Grails Version: 3.3.5
• JDK Version: javac 1.8.0_102
• Container Version (If Applicable): n/a

Example Application

• https://github.com/miffels/catfood/tree/master/bean-test

[benrhine]

Internal to the plugin this is expected behavior. If you review the documentation here under the sub-heading 'Notes on exluded artifacts' you will see that resources.groovy is an excluded resource in a plugin. Also take a look at 'Hooking into the Grails Spring configuration' sub-heading as it covers how to hook into the grails runtime configuration. In order to make your object available through injection inside the plugin it is correct to declare it in the doWithSpring block. This also has the added benefit that when you include the plugin in your project the bean will already be automatically defined for you.

If you do not define it in the plugins doWithSpring block then in the actual app which you are importing your plugin into in the applications resources.groovy you can declare it as you are attempting to do

[miffels]

Sorry Ben, I am not sure if I understand. In my Plugin I am providing a default bean that pretty much does nothing. Then, in my integration tests, which in essence start a Grails app that runs my plugin, in resurces.groovy I am providing a meaningful non-default bean which overrides the bean. This bean is not loaded, hence I cannot integration test the plugin. What is the proposed approach to address this?

That is, I am not trying to define default plugin beans in my resources.groovy. Plugin-internal beans are provided in doWithSpring, as you pointed out. This is just for integration tests, and when I integration test my plugin, resources.groovy is ignored. When I simply run my app instead of testing it, it will work. It does not sound like this is the way it is supposed to work.

The documentation you are pointing to also talks about packaging a plugin, not about integration testing it.

[benrhine]

There is nothing specific in our doc around integration testing in a plugin as opposed to just the standard testing doc.

As for proposed approach, integration testing would be considered Runtime Configuration as discussed here which is the documented way of providing beans in a plugin. I can successfully run the integration test in your example when declaring the following in your ...Plugin.groovy

Closure doWithSpring() { {->
            dummyDependency(DummyDependency)
        }
}

[miffels]

The bean I am referencing is not supposed to be defined in the plugin, and it is not supposed to be exported. It should be provided by the implementing Grails application, and hence it lives in my resources.groovy. If I would declare it in doWithSpring, it would be exported with the plugin, which is exactly what I do not wish to do, since it is a bean that I require for testing and testing only.

I still don't understand why I can run the plugin (i.e. launch a Grails app implementing the plugin) in dev mode and it works fine. However, it won't work if I run it as an integration test, i.e. I launch the same application in test mode.

[benrhine]

After doing more investigation, I agree with you and am going to reopen the issue for now.

Investigation notes:

I did some back testing and see the same behaviour of the integration test not picking up on beans declared in the resources.groovy in 3.3.0 as well as in 3.2.13.

In the running (working) version in DefaultRuntimeSpringConfiguration.java, registerBeansWithRegistry method which calls registerBeanConfigsWithRegistry(registry) the registry does not contain the dummyDependency but the beanConfigs does. After the method has been run the dummyDependency has been added to the registry.

In the case of the integration test neither contain the dummyDependency so it is not added. If dummyDependency is declared in the doWithSpring then it behaves just like the running version and you can see it is available in the beanConfigs and is added

It seems when beanConfigs is being built in the registerBeanConfiguration the dummyDependency is not being added / read.

Tracing the path back from registerBeanConfiguration > addSingletonBean > BeanBuilder.invokeBeanDefiningMethod > BeanBuilder.invokeMethod (line 565) beyond that at this point it is still unclear why it is not reading the bean.