Mockito，方法验证的任务

Question

Could you please explain a mission of mockito method verify? Documentation says, that this method checks, whether the method was called. But can you give an example when it is really useful? Usually in test method we invoke a method and then... check, that we have invoked it right now? Sounds weird.

Answer 1

It goes like this:

public class UnderTest {
  private Foo foo;

  public UnderTest(Foo foo) { this.foo = foo };

  public void bar() { foo.foo(); }
}

Now assume that you provide a mocked foo instance to UnderTest. And you want to be sure that foo.foo() is invoked when bar() is called.

Then you use verify() to ensure that the expected call took place.

In other words: tests need to verify method behavior. Ideally they do that by asserting on values returned by the method under test. But not all methods return something. Then you might verify your code by at least checking that certain expected calls on objects owned/passed to the class under test did occur. And then you need verify() !

Answer 2

This type of check is often performed just to make sure that specific object was used using specified parameters. Let's assume You are testing business service that performs some action and also some kind of audit trail is being stored in DB during this process.

Storing that kind of info in DB was already tested somewhere else (separate unit-tests or some kind of external library is used), so You do not need checking whether audit data was stored properly. For the sake of Your test-case the information that this method was called is sufficient. And that's the use case for 'verify' method.

Answer 3

Usually in test method we invoke a method and then... check, that we have invoked it right now? Sounds weird.

You don't verify that you invoked a test method. You verify that as a result of whatever that test did, some dependency (that you have replaced with a mock) was called.

So for example, when testing a password checker method, you want to assert that in addition to rejecting the incorrect password it also calls some auditing backend system to register the failed login attempt. Your mock object would stand in for that backend system, and you can use it to verify that it ended up being called (and also with the proper parameters).

Answer 4

To simplify... Let's say you are testing method A with certain parameters. What method A does is calls methods B , C and D .

With Mockito.verify you can test that methods B, C, D really are called. It even let's you specify more complex testing such as:

• atLeast(1)
• atMost(10)

It can really be useful when the method you are testing behaves differently based on parameters you call it with.

Answer 5

Let's imagine that you have some DAO class which interacts with the database by plain JDBC. You have some method to write data in the database and want to unit test it. To do so, you probably mock Connection class. When you're writing in the database you will probably call commit method on this mock, but the return type of it is void , so you can't guarantee that that method invoked during your test. To solve such problems you can use verify . Hope it helps!

Answer 6

Methods return either something or void .
In unit test, as a method returns something, generally you want to mock its result with a specific value and check that the flow of the tested method goes on as it should.
It makes sense as if a method to mock returns something, generally you need its results : either in the next statement of the tested method or in the result returned by the tested method.

As a method returns nothing ( void ), things are different : you cannot mock its result.
But you can assert that this method is invoked and with expected parameters.

For example imagine a PrinterService class to print documents

public class PrintService{
 ...
  public void printMessage(String message){
    os.print(message);
  }
}

And suppose you need to isolate it during an unit test of another class.
Here the method to test :

public class PrintClient{
 ...
  PrintService printService;

  public void print(String message, PrinterParameters printerParameters...){
     ... // do some tasks
     ...
     printService.print(message);
    ...          
  }
}

PrintService.print() returns nothing.
So in the unit test of PrintClient , you don't want to mock the result of PrintService.print() as it doesn't have.
You want just to check that it was invoked with the message argument passed to to the PrintClient tested method.

@RunWith(MockitoJUnitRunner.class) 
public class PrintClientTest{

    @Mock 
    PrintService printServiceMock;
    ...
    @Test
    pubic void print(){
      ... 
      String message = "my message";  
      PrintClient printClient = new PrintClient(printServiceMock);
      printClient.print(message, ...);
      //
      Mockito.verify(printServiceMock).print(message);
      ...
    }
}