Mockito verify constructor calls method

Question

I'm trying to test when the Game class is instantiated, that the start method is called. However I get the following error:

Wanted but not invoked:
game.start();
Actually, there were zero interactions with this mock.

I have the following class called Game

public class Game {
    private Hand player_hand;
    private Hand dealer_hand;
    public static Boolean isInPlay;

    public Game() {
        player_hand = new Hand();
        dealer_hand = new Hand();
        start();
    }

    public void start() {
        isInPlay = true;
        player_hand.hit();
        player_hand.hit();
        System.out.println("Player hand: ");
        player_hand.printHands();
        instantWinLose();
        dealer_hand.hit();
        dealer_hand.hit();
    }
}

I have a test class called GameTest

@RunWith(MockitoJUnitRunner.StrictStubs.class)

public class GameTest {

@InjectMocks
Game game;

@Mock
Hand hand;

    @Test
    public void testGameConstruction() {
        Game mockedGame = mock(Game.class);
        verify(mockedGame, times(1)).start();
    }
}

I'm new to Mockito. I've tried following examples in Difference between @Mock and @InjectMocks but I still get the same error

score 2 · Answer 1 · answered Sep 28 '18 at 15:41

2

Actually, You need to call the start method then only your mocking will be validated with times.

something like :: mockedGames.start()

Then only it call will be verified

answered Sep 28 '18 at 15:41

anup

19
1

Doe Johnson · Accepted Answer · 2018-09-28T16:36:35.297

When you call Mockito.mock(SomeType.class), Mockito will dynamically create a subclass for that type but for instantiation it uses certain techniques to avoid calling the super constructor (read more).

Try this:

public class Foobar {

    public Foobar () {
        throw new RuntimeException();
    }

}

// Somewhere else ...
Mockito.mock(Foobar.class); // No exception will be thrown because constructor is never called

That makes sense, when you think about it: A fresh mock object should not be doing anything unless it is absolutely required (stubbing). Calling any real logic could have undesired side effects.

And that is why you never mock the class under test itself!

When you mock the class under test itself, your tests have absolutely no meaning at all!

Only mock dependencies.

Your Game class has no dependencies, so you won't be needing any mocks:

    @Test
    public void testGameConstruction() {
        Game game = new Game();
        assertTrue(game.isInGame());
    }

If Game had dependencies, for instance Hand, you could add constructor parameters:

public Game (Hand hand1, Hand hand2) { .... }

and then:

    @Test
    public void testGameConstruction() {

        Hand handMock1 = Mockito.mock(Hand.class);
        Hand handMock2 = Mockito.mock(Hand.class);
        Game game = new Game(handMock1, handMock2);

        verify(handMock1, times(1)).hit();
        verify(handMock2, times(1)).hit();

    }

Doesn't my `Game` class _currently_ have a dependency on `Hand` anyway? [dependencies](http://tutorials.jenkov.com/ood/understanding-dependencies.html). — randhm, Sep 30 '18 at 18:19
I'm sorry. I was looking for a simple term and didn't want to confuse you. You are right. From an OO-perspective `Game`depends on `Hand` but in order to _test_ `Game` you don't need to know anything about `Hand` since `Game` handles everything internally and provides a no-arg constructor. From a testing perspective, you most of the time want to ignore _how_ something works. You want to make sure it works! — Doe Johnson, Oct 01 '18 at 13:37

score 0 · Answer 3 · answered Sep 28 '18 at 15:02

0

How I understand, by mocking Game class you also mocking constructor. That's mean that no code from actual class constructer was run. Try to create an instance of Game class without mocking.

answered Sep 28 '18 at 15:02

Alexey Usharovski

1,404
13
31

Mockito verify constructor calls method

3 Answers3