Using Spring's ResourceLoader in tests

Question

I'm @Autowireing a org.springframework.core.io.ResourceLoader into one of my @Service classes.

During the tests, I'd like to get access to an instance of a ResourceLoader, so that it can be injected into the service being tested. What's the best way to get a fully functional instance of ResourceLoader during your tests?

If that's not possible, is there an alternative to ResourceLoader? Essentially, I need to have my service read some static files from the project.

Update:

Started using @RunWith(SpringJUnit4ClassRunner.class) + @ContextConfiguration on my test; however, the ResourceLoader that is now being injected via @Autowire into my service behaves differently than usual (ie. when it's not in the test context). In the test, ResourceLoader#getResource returns a Resource pointing to bad relative path, rather than the proper absolute path which appears during a regular execution.

Some more information discovered while debugging:

• During tests, the @Autowired resourceLoader is an instanceof org.springframework.context.support.GenericApplicationContext
• During regular execution, resourceLoader is an instance of org.springframework.web.context.support.XmlWebApplicationContext

Answer 1

You can use a DefaultResourceLoader. It handles URL and classpath resources which should be enough for simple tests.

DefaultResourceLoader doesn't need any special setup. Just create a new instance and pass it into your test.

Answer 2

What kind of test do you want to write?

If it's a unit test, you should probably mock ResourceLoader and inject that mock into the service instance. (Use mockito for example)

If it's an integration test, you would be better off using the Spring TestContext framework. Create a spring context that contains all components needed for the test, then annotate your test class with @RunWith(SpringJUnit4ClassRunner.class) + @ContextConfiguration, which will make it possible to autowire fully configured beans (e.g. the service instance to be tested) in the test class.

Answer 3

I suppose you have your service defined as something like this:

public class ResourceService {
    @Autowired
    ResourceLoader loader;
}

Now, when you write your test for ResourceService :

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({ "classpath:test-config.xml" })
public class ResourceServiceTest {
    @Autowired
    ResourceService resourceService;
    @Test
    public void test() {
    ...
    }
}

The Spring TestContext Framework configures instances of your test classes via Dependency Injection. So, when you autowire ResourceService in your test class, Spring will inject the autowired ResourceLoader property into ResourceService.

Answer 4

ENVIRONMENT:

Java: 17
Springboot: 2.6.2
Junit-jupiter:5.8.2

Generally integration tests will need to start up a container to execute the test cases. This can be achieved using the following code:

import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.core.io.ResourceLoader;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringRunner;

import static org.junit.jupiter.api.Assertions.assertTrue;

@RunWith(SpringRunner.class)
@SpringBootTest
@TestPropertySource(locations = "classpath:application-integration-test.properties")
class TemplateKeyValidatorIT {

    @Autowired
    ResourceLoader resourceLoader;

    @Autowired
    private ResourceLoaderService resourceLoaderService;

    @Test
    void testResourceLoading() {

        // Given
        String fileName = "myTestFile.txt";

        // When
        File file = resourceLoaderService.load(fileName);

        // Then
        assertTrue(file.exists());
    }

}

@RunWith(SpringRunner.class): SpringRunner is the base Spring framework Runner. It extends SpringJUnit4ClassRunner, but it’s just an alias to that class.

@SpringBootTest: Annotation is needed to bootstrap the entire container; it creates an ApplicationContext that will be used by the integration tests.

@TestPropertySource(locations = "classpath:application-integration-test.properties"): Loads integration specific application properties.

Note: this will boot strap the real application context but you can separate test configuration class using:

@TestConfiguration
public class MyTestContextConfiguration {
    
    @Bean
    public ResourceLoaderService resourceLoaderService() {
        return new ResourceLoaderService() { 
            // implement methods 
        };
    }
 }

And this can then be impoerted by your test class using:

@Import(MyTestContextConfiguration.class)