Mockito: verify arguments passed to constructor

I'm trying to work out how to verify the parameters passed to a mocked constructor in Mockito. A simplified version of my code is:

class Mocked {
    Mocked(String first, String second, int value) {
    }
}

class Target {
    void testMe() {
        new Mocked("Hello", "World", 99);
    }
}


@Test
public void test_Target() {
    try (
        MockedConstruction<Mocked> mockedNew = mockConstruction(Mocked.class);
    ) {
        new Target().testMe();

        Mocked mocked = mockedNew.constructed().get(0);
        // TODO: verify all arguments passed to mocked
    }
}

• The class I'm trying to test is "Target"
• Target uses an instance of the "Mocked" class. In real code code I'll want to use an actual instance of Mocked, but for the purposes of testing I want to mock it out so I can test "Target" in isolation of "Mocked". I've used the mockConstruction construct to do this.

In my final version of my code the arguments passed to the Mocked constructor are not hardcoded. Instead there will be some business logic to derive them, so and I want to verify they have been derived out correctly. But how?

None of the examples I've Googled show show me how to do this, and org.mockito.Mockito.verify() doesn't appear to have a way to test a constructor.

The only solution I can see is to add mock initialiser function that copies the argument into local variables. But this involves making those variables effectively final (so final one element array) and ugly casts. Surely there has to be something better than that!

What have I missed?

You can run assertions using Junit or your testing library of choice on the context argument passed into the mockedConstructor, which will have a list of the arguments passed into the constructor. (Note that they will all be stored as Object, so you will need to cast them) e.g.

try (MockedConstruction<Mocked> mockedConstructor = mockConstruction(Mocked.class, (mock, context) -> {
             assertEquals("Hello", (String) context.arguments().get(0));
             assertEquals("World", (String) context.arguments().get(1));
             assertEquals(99, (int) context.arguments().get(2));
    }))
{
    new Target().testMe();
}

As far as I know, this is not possible using the Mockito API.

You can try a design change where a new MockedFactory class is responsible for creating Mocked objects. You can create a MockMockedFactory for your tests and inject it into Target to use. You will be able to verify the methods called on this factory by the class under test. Not the nicest, adds boilerplate code, but works.

Also, I guess the newly created object is not returned as testing would not be a problem then. It is worth considering if the method you are testing isn't too big doing too many things at once. Maybe some other refactors could help make it more testable.

Or maybe this one: https://groups.google.com/g/mockito/c/WqPlcNrvbOw?pli=1