Mockito WrongTypeOfReturnValue: Boolean cannot be returned by findById()-CodePudding

I am trying to test the following method with JUnit tests, using Mockito:

@Override public List<Adoption> search(String username, Integer id) {

List<Adoption> emptySearchResult = new ArrayList<>();

if(id != null && !username.equals("") ) {
    if(!this.petRepository.findById(id).isPresent()){
        return emptySearchResult;
    }
    if(!this.appUserRepository.findByUsername(username).isPresent()){
        return emptySearchResult;
    }
    Pet pet = this.petRepository.findById(id).orElseThrow( () -> new PetNotFoundException(id));
    AppUser user  = this.appUserRepository.findByUsername(username).orElseThrow( () -> new UsernameNotFoundException(username));
    return this.adoptionRepository.findAllByUserAndPet(user, pet);
}
else if(id != null && username.equals("")){
    if(!this.petRepository.findById(id).isPresent()){
        return emptySearchResult;
    }
    Pet pet = this.petRepository.findById(id).orElseThrow( () -> new PetNotFoundException(id));
    return this.adoptionRepository.findAllByPet(pet);
}
else if(id == null && !username.equals("")) {
    if(!this.appUserRepository.findByUsername(username).isPresent()){
        return emptySearchResult;
    }
    AppUser user  = this.appUserRepository.findByUsername(username).orElseThrow( () -> new UsernameNotFoundException(username));
    return this.adoptionRepository.findAllByUser(user);
}
else {
    return this.adoptionRepository.findAll();
}

}

However, I run into a problem with the following part:

if(!this.petRepository.findById(id).isPresent())

Even though I have mocked this.petRepository.findById(id), for some reason isPresent() is returning false. This is my initialization for the tests:

@Mock
private AdoptionRepository adoptionRepository;

@Mock
private PetRepository petRepository;

@Mock
private AppUserRepository appUserRepository;

private AdoptionServiceImpl service;

private Adoption adoption1;
private Adoption adoption2;
private Adoption adoption3;

private AppUser user;
private AppUser user2;
private Pet pet;
private Pet petAlteadyAdopted;

List<Adoption> allAdoptions = new ArrayList<>();
List<Adoption> userFilteredAdoptions = new ArrayList<>();
List<Adoption> petFilteredAdoptions = new ArrayList<>();

@Before
public void init() {
    MockitoAnnotations.initMocks(this);
    user = new AppUser("username","name","lastname","[email protected]","pass",ZonedDateTime.now(), Role.ROLE_USER, City.Skopje);
    user2 = new AppUser("username1","name","lastname","[email protected]","pass",ZonedDateTime.now(), Role.ROLE_USER, City.Skopje);

    Center center = new Center("a", City.Bitola,"url");
    pet = new Pet("p", Type.DOG,"b", Gender.FEMALE,"d",center, ZonedDateTime.now(),"url",null,false,ZonedDateTime.now());
    petAlteadyAdopted = new Pet("p", Type.DOG,"b", Gender.FEMALE,"d",center, ZonedDateTime.now(),"url",null,true,ZonedDateTime.now());

    pet.setId(0);
    petAlteadyAdopted.setId(1);
    adoption1 = new Adoption(ZonedDateTime.now(),ZonedDateTime.now(),Status.ACTIVE,user,pet);
    adoption2 = new Adoption(ZonedDateTime.now(),ZonedDateTime.now(),Status.CLOSED,user,pet);
    adoption3 = new Adoption(ZonedDateTime.now(),ZonedDateTime.now(),Status.CLOSED,user2,new Pet());

    allAdoptions.add(adoption1);
    allAdoptions.add(adoption2);
    allAdoptions.add(adoption3);

    petFilteredAdoptions.add(adoption2);
    petFilteredAdoptions.add(adoption1);

    userFilteredAdoptions.add(adoption2);
    userFilteredAdoptions.add(adoption1);

    Mockito.when(this.adoptionRepository.findById(0)).thenReturn(java.util.Optional.of(adoption1));
    Mockito.when(this.adoptionRepository.findById(1)).thenReturn(java.util.Optional.of(adoption2));

    Mockito.when(this.petRepository.findById(0)).thenReturn(java.util.Optional.of(pet));
    Mockito.when(this.petRepository.findById(1)).thenReturn(java.util.Optional.of(petAlteadyAdopted));
    

    Mockito.when(this.appUserRepository.findByUsername("username")).thenReturn(java.util.Optional.of(user));
    Mockito.when(this.appUserRepository.findByUsername("username1")).thenReturn(java.util.Optional.of(user2));

    Mockito.when(this.adoptionRepository.findAll()).thenReturn(allAdoptions);
    Mockito.when(this.adoptionRepository.findAllByPet(pet)).thenReturn(petFilteredAdoptions);
    Mockito.when(this.adoptionRepository.findAllByUser(user)).thenReturn(userFilteredAdoptions);
    Mockito.when(this.adoptionRepository.findAllByUserAndPet(user,pet)).thenReturn(userFilteredAdoptions);

    Mockito.when(this.adoptionRepository.save(Mockito.any(Adoption.class))).thenReturn(adoption1);

    this.service = Mockito.spy(new AdoptionServiceImpl(this.adoptionRepository, this.petRepository,this.appUserRepository));
}

As a result, the following test fails, even though it should pass:

@Test
public void searchTest2() { 
    List<Adoption> adoptionList = this.service.search("",0);
    Assert.assertEquals(petFilteredAdoptions,adoptionList);
}

In order to solve this I tried mocking the isPresent() method:

Mockito.when(this.petRepository.findById(0).isPresent()).thenReturn(true);

But I'm getting the following exception:

org.mockito.exceptions.misusing.WrongTypeOfReturnValue: Boolean cannot be returned by findById() findById() should return Optional*** If you're unsure why you're getting above error read on. Due to the nature of the syntax above problem might occur because:

This exception might occur in wrongly written multi-threaded tests. Please refer to Mockito FAQ on limitations of concurrency testing.

A spy is stubbed using when(spy.foo()).then() syntax. It is safer to stub spies -

with doReturn|Throw() family of methods. More in javadocs for Mockito.spy() method.

I also tried the following variation:

Mockito.doReturn(true).when(this.petRepository.findById(0)).isPresent();

But then I got the following exception:

org.mockito.exceptions.misusing.UnfinishedStubbingException: Unfinished stubbing detected here: -> at mk.finki.ukim.milenichinja.ServiceTests.AdoptionServiceFilterTests.init(AdoptionServiceFilterTests.java:87)

E.g. thenReturn() may be missing. Examples of correct stubbing: when(mock.isOk()).thenReturn(true); when(mock.isOk()).thenThrow(exception); doThrow(exception).when(mock).someVoidMethod(); Hints:

missing thenReturn()

you are trying to stub a final method, which is not supported

you are stubbing the behaviour of another mock inside before 'thenReturn' instruction is completed

Any ideas how to solve this problem?

CodePudding user response：

In the init method, you are stubbing findById on the mock instance this.petRepository to return a non-mock Optional, which is good. In your new test, you are trying to set a return value for isPresent, which you can't do because Optional is not a mock. If you want to override the behavior per-test, you'll need to stub findById to return an Optional of a different instance. Therefore, this is right, though it appears exactly as it does in init and consequently it can't tell you why your test is failing.

Mockito.when(this.petRepository.findById(0))
    .thenReturn(java.util.Optional.of(pet));

Mockito works by creating a mock object that subclasses a class and overrides every method. The overridden method is what interacts with a static (ThreadLocal) infrastructure, allowing you to use when syntax. The important thing here is that when ignores its argument, and instead tries to mock the last interaction that you made with a mock. You can find out more in the SO questions How does mockito when() invocation work? and How do Mockito matchers work?.

When you see this call:

Mockito.when(this.petRepository.findById(0))
    .thenReturn(java.util.Optional.of(pet));

Then it works as you've intended:

petRepository is a mock, findById is presumably an overridable method, Mockito records the fact that you've called it with the argument 0.
findById doesn't have any behavior stubbed yet, so it does its default, returning null.
when doesn't care that it just received null, because the null doesn't tell it anything about what methods were called to get the null. Instead it looks back at its most recent record (findById(0)) and returns an object with the thenVerb methods you expect.
You call thenReturn, so Mockito sets up petRepository to return the Optional instance you created and passed in.

But when you try this call:

Mockito.when(this.petRepository.findById(0).isPresent()).thenReturn(true);

Then the most recent interaction isn't isPresent, it's findById, so Mockito assumes you want findById(0) to thenReturn(true) and throws WrongTypeOfReturnValue. Optional is not a mock, so interacting with it doesn't let Mockito record its interaction or replay your behavior. For what it's worth, I also wouldn't advise mocking it: Optional is a final class, and though Mockito has recently added some support for mocking final types, Optional is simple and straightforward enough that it makes more sense to just return the Optional instance you want rather than trying to mock it.

With all that said, your code looks right; as long as PetRepository is an interface I don't see anything about the way your method looks or the way your mocks look that would cause this.petRepository.findById(0) to return an absent Optional. In fact, I don't even see where you would create an absent Optional for it to return, so I can only guess that you are using more real objects in your test than you think you are.