1. Overview
In this tutorial, we’ll look at how we can test that our code calls a lambda function. There are two approaches to achieving this goal to consider. We’ll first check that the lambda is invoked with the correct arguments. Then, we’ll look at testing the behavior instead and checking if the lambda code has executed and produced the expected result.
2. Example Class Under Test
To start, let’s create a class LambdaExample that has an ArrayList we’ll call bricksList:
class LambdaExample {
ArrayList<String> bricksList = new ArrayList<>();
}
Now, let’s add an inner class called BrickLayer, which will be able to add bricks for us:
class LambdaExample {
BrickLayer brickLayer = new BrickLayer();
class BrickLayer {
void layBricks(String bricks) {
bricksList.add(bricks);
}
}
}
BrickLayer doesn’t do much. It has a single method, layBricks() that will add a brick to our List for us. This could have been an external class, but to keep the concepts together and simple an inner class works here.
Finally, we can add a method to LambdaExample to call layBricks() via a lambda:
void createWall(String bricks) {
Runnable build = () -> brickLayer.layBricks(bricks);
build.run();
}
Again, we’ve kept things simple. Our real-world applications are more complex but this streamlined example will help explain the test methods.
In the upcoming sections, we’ll test whether calling createWall() results in the expected execution of layBricks() within our lambda.
3. Testing Correct Invocation
The first testing method we’ll look at is based on confirming that the lambda is called when we expect it. Furthermore, we’ll need to confirm that it received the correct arguments. To start we’ll need to create Mocks of both BrickLayer and LambdaExample:
@Mock
BrickLayer brickLayer;
@InjectMocks
LambdaExample lambdaExample;
We’ve applied the @InjectMocks annotation to LambdaExample so that it uses the mocked BrickLayer object. We’ll be able to confirm the call to the layBricks() method because of this.
We can now write our test:
@Test
void whenCallingALambda_thenTheInvocationCanBeConfirmedWithCorrectArguments() {
String bricks = "red bricks";
lambdaExample.createWall(bricks);
verify(brickLayer).layBricks(bricks);
}
In this test, we’ve defined the String we want to add to bricksList and passed it as an argument to createWall(). Let’s keep in mind that we’re using the Mock we created earlier as the instance of LambdaExample.
We’ve then used Mockitos verify() function. Verify() is hugely helpful for this kind of test. It confirms the function layBricks() was called and that the argument was what we expected.
There’s much more we can do with verify(). For example, confirming how many times a method is called. For our purposes, however, it’s sufficient to confirm that our lambda invoked the method as expected.
4. Testing Correct Behaviour
The second route we can go down for testing is to not worry about what gets called and when. Instead, we’ll confirm that the expected behavior of the lambda function occurs. There will almost always be a good reason we’re calling a function. Perhaps to perform a calculation or to get or set a variable.
In our example, the lambda adds a given String to an ArrayList. In this section, let’s verify that the lambda successfully executes that task:
@Test
void whenCallingALambda_thenCorrectBehaviourIsPerformed() {
LambdaExample lambdaExample = new LambdaExample();
String bricks = "red bricks";
lambdaExample.createWall(bricks);
ArrayList<String> bricksList = lambdaExample.getBricksList();
assertEquals(bricks, bricksList.get(0));
}
Here, we’ve created an instance of the LambdaExample class. Next, we’ve called createWall() to add a brick to the ArrayList.
We should now see that bricksList contains the String we just added. Assuming the code correctly executes the lambda. We confirmed that by retrieving bricksList from lambdaExample and checking the contents.
We can conclude that the lambda is executing as expected, as that’s the only way our String could have ended up in the ArrayList.
5. Conclusion
In this article, we’ve looked at two methods for testing lambda calls. The first is useful when we can mock the class containing the function and inject it into the class which calls it as a lambda. In that case, we can use Mockito to verify the call to the function and the correct arguments. This offers no confidence that the lambda went on to do what we expected, however.
The alternative is to test that the lambda produces the expected results when called. This offers more test coverage and is often preferable if it’s simple to access and confirm the correct behavior of the function call.
As always, the full code for the examples is available over on GitHub.
