How to Create Dependency Injections in JUnit
The purpose of a unit test is to identify the errors in an application as soon as it’s possible to. Though several channels might lead you to the same objective, you should aim to use the most efficient route.
A JUnit test suite might have several test classes that need the same data, but you can’t reuse test data. In previous versions of JUnit, a good approach was to create a utility method, then call that method each time a test class needed its data.
JUnit 5 provides a more efficient approach to this problem: dependency injection (DI).
What Is Dependency Injection?
DI is a design pattern where an object supplies the dependencies of another object. When you are building a Java application, you might have a class that depends on an object that another class creates to perform its function.
Before dependency injection, to use an object from a different class you would have to create a new instance of that object within the class that depends on it. So, if you had several classes that depend on the same object, you’d have to create several instances of it within the dependent classes.
DI allows you to use an object in a dependent class, without creating a new instance of it in that class.
Dependency Injection in JUnit 5
JUnit 5 allows you to inject dependencies in both test methods and constructors. This is significant as the previous versions of the framework did not allow test methods or constructors to have parameters.
JUnit 5 allows you to inject as many parameters as you like. The only catch is that the ParameterResolver API must be able to resolve each parameter at run time. JUnit currently has three built-in parameter resolvers that it uses automatically. To use any other resolver, you would need to register it explicitly by using the @ExtendWith annotation.
Injecting Dependencies in JUnit
This sample program uses one of JUnit’s built-in parameters (the TestInfoParameterResolver), to demonstrate how you can inject a dependency into aJUnit 5 test. The TestInfoParameterResolver resolves objects that belong to the TestInfo interface. So, JUnit 5 will supply an instance of the TestInfo interface to any method or constructor that uses it.
The JUnit test above demonstrates how to inject an object into a constructor and two methods. TheJUnit TestInfointerface has four methods that you’re able to use with its object.
The getDisplayName() method is the most useful. It returns the display name of the current test method or constructor. By default, this name is based on the class. But if you usethe @DisplayName annotation, the getDisplayName() method will return that text instead.
The test class above generates the following test report:
Use DI in @Before and @After Methods
There are four other types of JUnit annotated methods that support dependencies. These are the @BeforeAll, @BeforeEach, @AfterAll, and @AfterEach annotations. Like the @Test method, all you need to do is pass an object to any of the before or after methods as a parameter, and you’re good to go.
The @Before and @After annotations are important, as they also help you to develop more efficient test code. Having the ability to also inject dependencies into these methods will further improve your test code.
Unit tests should isolate functionality as much as possible, but it can be tricky to eliminate all dependant code. These annotations will help out.
Turn these settings on, and your iPhone will be so much better than before.
These plugins will make you wonder why you used Photoshop in the first place.
OneDrive is one of the best, but it has a catch.
It’s not super flashy, but it can help to keep your computer up and running.
Make sure you don’t miss these movies and shows before Netflix removes them.
