{"id":44892,"date":"2015-11-15T15:24:33","date_gmt":"2015-11-15T13:24:33","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=44892"},"modified":"2023-12-13T11:08:56","modified_gmt":"2023-12-13T09:08:56","slug":"mockito-verification","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2015\/11\/mockito-verification.html","title":{"rendered":"Mockito Verification"},"content":{"rendered":"

This article is part of our Academy Course titled Testing with Mockito<\/a>.<\/p>\n

In this course, you will dive into the magic of Mockito. You will learn about Mocks, Spies and Partial Mocks, and their corresponding Stubbing behaviour. You will also see the process of Verification with Test Doubles and Object Matchers. Finally, Test Driven Development (TDD) with Mockito is discussed in order to see how this library fits in the concept of TDD. Check it out here<\/a>!<\/em><\/p>\n

\n

Table Of Contents<\/h4>\n
\n
1. What is Verification?<\/a><\/dt>\n
2. Using verify()<\/a><\/dt>\n
\n
\n
2.1. Using the built in Verification Modes<\/a><\/dt>\n
2.2. Creating a custom Verification Mode<\/a><\/dt>\n
2.3. Verification with Parameters<\/a><\/dt>\n
2.4. Verification with Timeout<\/a><\/dt>\n<\/dl>\n<\/dd>\n
3. Verifying No Interactions and No More Interactions<\/a><\/dt>\n
4. Verification in Order<\/a><\/dt>\n
5. Argument Captors<\/a><\/dt>\n
6. Conclusion<\/a><\/dt>\n
7. Download the Source Code<\/a><\/dt>\n<\/dl>\n<\/div>\n

<\/a>1. What is Verification?<\/h2>\n

Verification is the process of confirming the behaviour of a Mock. It is useful in determining that the class we are testing has interacted in an expected way with any of its dependencies. Sometimes we aren\u2019t interested in the values which are returned from a Mock, but are instead interested in how the class under test interacted with it, what values were sent in or how often it was called. The process of confirming this behaviour is verification and there are a number of tools which Mockito provides to allow us to do it.<\/p>\n

<\/a>2. Using verify()<\/h2>\n

The main tool for performing verification in the Mockito toolbox is the org.mockito.Mockito.verify()<\/code> method. The verify method takes the Mock object as a parameter and returns an instance of the same Class as the Mock, allowing you to call the methods of the Class, which Mockito interprets as a request to verify that there was some interaction with that method.<\/p>\n

Let\u2019s look again at our printer interface from the previous tutorial.<\/p>\n

\npublic interface Printer {\n\t\n\tvoid printTestPage();\n\n}\n<\/pre>\n
We can create a simple unit test to demonstrate verify using a Mock Printer<\/p>\n
\nimport static org.mockito.Mockito.verify;\n\nimport org.junit.Test;\nimport org.junit.runner.RunWith;\nimport org.mockito.Mock;\nimport org.mockito.runners.MockitoJUnitRunner;\n\n@RunWith(MockitoJUnitRunner.class)\npublic class PrinterTest {\n\n\t@Mock\n\tprivate Printer printer;\n\n\t@Test\n\tpublic void simple_interaction_verification() {\n\t\t\/\/ Given\n\t\t\n\t\t\/\/ When\n\t\tprinter.printTestPage();\n\t\t\n\t\t\/\/ Then\n\t\tverify(printer).printTestPage();\t\t\n\t}\n}\n<\/pre>\n
We can see that our unit test firstly calls printer.printTestPage()<\/code>. This is simulating a possible interaction within a class under test, but to keep things simple we are doing it out in the unit test class. The next call is the call to verify(printer).printTestPage()<\/code>. This instructs Mockito to check if there has been a single call to the printTestPage()<\/code> method of the Mock Printer.<\/p>\n
Note carefully the syntax of the call, the parameter of verify()<\/code> is the Mock object, not the method call. If we had put verify(printer.printTestPage())<\/code> we would have generated a compile error. Contrast this to the given\/when syntax in stubbing which takes the form when(mockObject.someMethod()).thenReturn(...)<\/code>.<\/p>\n
If we hadn\u2019t called printTestPage()<\/code> above this call to verify Mockito would have generated a verification error informing us that there was no invocation of printTestPage()<\/code>, which would look like this:<\/p>\n
\nWanted but not invoked:\nprinter.printTestPage();\n-> at com.javacodegeeks.hughwphamill.mockito.stubbing.PrinterTest.simple_interaction_verification(PrinterTest.java:24)\nActually, there were zero interactions with this mock.\n<\/pre>\n
Additionally if we had made a second call to printTestPage()<\/code> Mockito would have generated a verification error informing us that there were too many invocations of printTestPage()<\/code>. This error would look like this:<\/p>\n
\norg.mockito.exceptions.verification.TooManyActualInvocations: \nprinter.printTestPage();\nWanted 1 time:\n-> at com.javacodegeeks.hughwphamill.mockito.stubbing.PrinterTest.simple_interaction_verification(PrinterTest.java:25)\nBut was 2 times. Undesired invocation:\n-> at com.javacodegeeks.hughwphamill.mockito.stubbing.PrinterTest.simple_interaction_verification(PrinterTest.java:22)\n<\/pre>\n
Usefully the error informs us which line of code contained the superfluous invocation – in this case line 22 of PrinterTest.java<\/code>.<\/p>\n
But what if we want multiple interactions with our Mock?  Does Mockito support this?  Unsurprisingly the answer is Yes!<\/p>\n
The verify()<\/code> method takes a second parameter of type org.mockito.verification.VerificationMode<\/code> which can be used to provide additional details about the desired interactions with the mock.<\/p>\n
<\/a>2.1. Using the built in Verification Modes<\/h3>\n
As usual Mockito provides a number of convenient static methods in org.mockito.Mockito for creating VerificationModes, such as:<\/p>\n
times(int)<\/code>
\nThis will verify that the method was called the input number of times.<\/p>\n
\n@Test\npublic void simple_interaction_verification_times_1() {\n\t\/\/ Given\n\t\t\n\t\/\/ When\n\tprinter.printTestPage();\n\t\t\n\t\/\/ Then\n\tverify(printer, times(1)).printTestPage();\t\t\n}\n<\/pre>\n
Note that verify(mock)<\/code> is an alias of verify(mock, times(1))<\/code>.<\/p>\n
Of course we can verify multiple interactions using times()<\/code><\/p>\n
\n@Test\npublic void simple_interaction_verification_times_3() {\n\t\/\/ Given\n\t\t\n\t\/\/ When\n\tprinter.printTestPage();\n\tprinter.printTestPage();\n\tprinter.printTestPage();\n\t\t\n\t\/\/ Then\n\tverify(printer, times(3)).printTestPage();\t\t\n}\n<\/pre>\n
This VerificationMode<\/code> will generate useful errors when the actual number of invocations doesn\u2019t match the expected number.<\/p>\n
Not enough invocations:<\/p>\n
\norg.mockito.exceptions.verification.TooLittleActualInvocations: \nprinter.printTestPage();\nWanted 3 times:\n-> at com.javacodegeeks.hughwphamill.mockito.stubbing.PrinterTest.simple_interaction_verification_times_3(PrinterTest.java:49)\nBut was 2 times:\n-> at com.javacodegeeks.hughwphamill.mockito.stubbing.PrinterTest.simple_interaction_verification_times_3(PrinterTest.java:45)\n<\/pre>\n
Too many invocations:<\/p>\n
\norg.mockito.exceptions.verification.TooManyActualInvocations: \nprinter.printTestPage();\nWanted 3 times:\n-> at com.javacodegeeks.hughwphamill.mockito.stubbing.PrinterTest.simple_interaction_verification_times_3(PrinterTest.java:50)\nBut was 4 times. Undesired invocation:\n-> at com.javacodegeeks.hughwphamill.mockito.stubbing.PrinterTest.simple_interaction_verification_times_3(PrinterTest.java:47)\n<\/pre>\n
atLeastOnce()<\/code>, atLeast(int)<\/code>
\nThis will verify that the method was called at least the given number of times.<\/p>\n
\n@Test\npublic void simple_interaction_verification_atleastonce() {\n\t\/\/ Given\n\t\t\n\t\/\/ When\n\tprinter.printTestPage();\n\tprinter.printTestPage();\n\t\t\n\t\/\/ Then\n\tverify(printer, atLeastOnce()).printTestPage();\t\t\n}\n<\/pre>\n
\n@Test\npublic void simple_interaction_verification_atleast_2() {\n\t\/\/ Given\n\t\t\n\t\/\/ When\n\tprinter.printTestPage();\n\tprinter.printTestPage();\n\tprinter.printTestPage();\n\t\t\n\t\/\/ Then\n\tverify(printer, atLeast(2)).printTestPage();\t\t\n}\n<\/pre>\n
As usual we get comprehensive error reporting:<\/p>\n
\norg.mockito.exceptions.verification.TooLittleActualInvocations: \nprinter.printTestPage();\nWanted *at least* 2 times:\n-> at com.javacodegeeks.hughwphamill.mockito.stubbing.PrinterTest.simple_interaction_verification_atleast_2(PrinterTest.java:76)\nBut was 1 time:\n-> at com.javacodegeeks.hughwphamill.mockito.stubbing.PrinterTest.simple_interaction_verification_atleast_2(PrinterTest.java:71)\n<\/pre>\n
atMost(int)<\/code>
\nThis will verify that the method was called at most the given number of times.<\/p>\n
\n@Test\npublic void simple_interaction_verification_atmost_3() {\n\t\/\/ Given\n\t\t\n\t\/\/ When\n\tprinter.printTestPage();\n\tprinter.printTestPage();\n\t\t\n\t\/\/ Then\n\tverify(printer, atMost(3)).printTestPage();\t\t\n}\n<\/pre>\n
And the error condition:<\/p>\n
\norg.mockito.exceptions.base.MockitoAssertionError: \nWanted at most 3 times but was 4\n\tat com.javacodegeeks.hughwphamill.mockito.stubbing.PrinterTest.simple_interaction_verification_atmost_3(PrinterTest.java:91)\n<\/pre>\n
never()<\/code>
\nThis will verify that the method was not called.<\/p>\n
\n@Test\npublic void simple_interaction_verification_never() {\n\t\/\/ Given\n\t\t\n\t\/\/ When\n\t\t\n\t\/\/ Then\n\tverify(printer, never()).printTestPage();\t\t\n}\n<\/pre>\n
And the error condition:<\/p>\n
\norg.mockito.exceptions.verification.NeverWantedButInvoked: \nprinter.printTestPage();\nNever wanted here:\n-> at com.javacodegeeks.hughwphamill.mockito.stubbing.PrinterTest.simple_interaction_verification_never(PrinterTest.java:102)\nBut invoked here:\n-> at com.javacodegeeks.hughwphamill.mockito.stubbing.PrinterTest.simple_interaction_verification_never(PrinterTest.java:98)\n<\/pre>\n
only()<\/code>
\nThis will verify that the method being verified was the only method of the mock called.<\/p>\n
\n@Test\npublic void simple_interaction_verification_only() {\n\t\/\/ Given\n\t\t\n\t\/\/ When\n\tprinter.printTestPage();\n\t\t\n\t\/\/ Then\n\tverify(printer, only()).printTestPage();\t\t\n}\n<\/pre>\n
We can produce an error by adding the following method to our printer interface:<\/p>\n
\nvoid turnOff();\n<\/pre>\n
And calling it in our test<\/p>\n
\n@Test\npublic void simple_interaction_verification_only_fails() {\n\t\/\/ Given\n\t\t\n\t\/\/ When\n\tprinter.printTestPage();\n\tprinter.turnOff();\n\t\t\n\t\/\/ Then\n\tverify(printer, only()).printTestPage();\t\t\n}\n<\/pre>\n
to give the following error:<\/p>\n
\norg.mockito.exceptions.verification.NoInteractionsWanted: \nNo interactions wanted here:\n-> at com.javacodegeeks.hughwphamill.mockito.stubbing.PrinterTest.simple_interaction_verification_only_fails(PrinterTest.java:124)\nBut found this interaction:\n-> at com.javacodegeeks.hughwphamill.mockito.stubbing.PrinterTest.simple_interaction_verification_only_fails(PrinterTest.java:120)\n***\nFor your reference, here is the list of all invocations ([?] - means unverified).\n1. [?]-> at com.javacodegeeks.hughwphamill.mockito.stubbing.PrinterTest.simple_interaction_verification_only_fails(PrinterTest.java:120)\n2. [?]-> at com.javacodegeeks.hughwphamill.mockito.stubbing.PrinterTest.simple_interaction_verification_only_fails(PrinterTest.java:121)\n<\/pre>\n
<\/a>2.2. Creating a custom Verification Mode<\/h3>\n
You can create your own custom verification mode by implementing the org.mockito.verification.VerificationMode<\/code> interface. Note that this is using some classes that don\u2019t form part of the public API of Mockito. There are plans to promote them to public API as of the time of writing, but this feature should be used with caution in case the implementation changes before that happens.<\/p>\n
VerificationMode<\/code> exposes a single void verify(VerificationData data)<\/code> method which is used to verify that the mock invocations we are interested in happend correctly.<\/p>\n
You can use a couple of internal Mockito classes to help you in your VerificationMode<\/code>:<\/p>\n