Mockito.mockConstruction does not return the mocked object

You can access mocks that were created during the instantiation of your objects via MockedConstruction.constructed() method. It represents a collection of mocks that are created after each constructor's execution. If your object will be instantiated 3 times MockedConstruction<T>.constructed() will return 3 different mock objects for each instantiation.
According to documentation MockedConstruction<T>

Represents a mock of any object construction of the represented type. Within the scope of the mocked construction, the invocation of any interceptor will generate a mock which will be prepared as specified when generating this scope. The mock can also be received via this instance.

Simple implementation with comments below shows how to get mocks from MockedConstruction and verify them:

public class A {
    private final String test;

    public A(String test) {
        this.test = test;
    }

    public String check() {
        return "checked " + this.test;
    }
}

public class TestService {
    public String purchaseProduct(String param) {
        A a = new A(param);
        return a.check();
    }
}

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.MockedConstruction;
import org.mockito.Mockito;

import static org.mockito.Mockito.*;

public class ConstructorMockTest {
    private MockedConstruction<A> mockAController;

    @BeforeEach
    public void beginTest() {
        //create mock controller for all constructors of the given class
        mockAController = Mockito.mockConstruction(A.class,
                (mock, context) -> {
                    //implement initializer for mock. Set return value for object A mock methods
                    when(mock.check()).thenReturn(" Constructor Mock A ");
                });
    }

    @Test
    public void test() {
        //each instantiation of class A will return new mock, which initialized by initializer from beginTest method
        //new mock will be stored to mockAController.constructed() collection of mocks
        A aObject = new A("test");
        //ensure that method check() returns mocked value
        Assertions.assertEquals(aObject.check(), " Constructor Mock A ");
        //get just created mock for class A from controller. It will be first element of mockAController.constructed() collection
        A aMock = mockAController.constructed().get(0);
        //ensure that we get correct mock from mock controller, that it is equal from new created object
        Assertions.assertEquals(aMock, aObject);
        //verify that check method was executed on Mock
        verify(aMock, times(1)).check();

        //create new A object, new mock created and stored to mockAController.constructed()
        A aObject2 = new A("test");
        //ensure that method check() returns mocked value
        Assertions.assertEquals(aObject2.check(), " Constructor Mock A ");
        //get just created mock for class A from controller, it will be second object from constructed collection
        A aMock2 = mockAController.constructed().get(1);
        //ensure that we get correct mock from mock controller, that it is equal from just created A object
        Assertions.assertEquals(aObject2, aMock2);
        //verify that check method was executed on Mock
        verify(aMock2, times(1)).check();

        //Example of testing service which creates A object
        TestService service = new TestService();
        String serviceResult = service.purchaseProduct("test");
        //ensure that service returned value  from A mock
        Assertions.assertEquals(serviceResult, " Constructor Mock A ");
        //get just created mock for class A from controller, it will be third object from constructed collection
        A aMock3 = mockAController.constructed().get(2);
        //verify that check method was executed on Mock
        verify(aMock3, times(1)).check();
    }

    @AfterEach
    public void endTest() {
        mockAController.close();
    }
}

Let's rewrite your test. I do not have the full code, but I will try to create an example with comments:

    @Test
    void shouldThrowException() throws Exception {
        //given
        UrlLinkDto urlLinkDto =
                UrlPartLinkDto.builder().callId("333").videoId("5555544").build();
        ArgumentCaptor<UrlPartLinkDto> argumentCaptor = ArgumentCaptor.forClass(UrlPartLinkDto.class);

        try (MockedConstruction<ObjectMapper> objectMapperMockedConstruction = mockConstruction(ObjectMapper.class,
                (objectMapper, context) -> {
                     //initialize ObjectMapper mock to throw exception when argumentCaptor will come to writeValueAsString method
                    doThrow(JsonProcessingException.class).when(objectMapper).writeValueAsString(argumentCaptor.capture());
                })) {

            //execute service for testing and catch exception
            Throwable throwable = catchThrowable(() -> partUnlinkService.unlink(urlLinkDto, false));

            //verify that inner service was executed
            verify(partLogCheckService, times(1)).checkForExistingVideo(urlLinkDto.getVideoId());

            //verify that ObjectMapper was instantiated
            Assertions.assertEquals(1, objectMapperMockedConstruction.constructed().size());
            //get mock of ObjectMapper which was instantiated during service execution
            ObjectMapper objectMapper = objectMapperMockedConstruction.constructed().get(0);
            //verify that writeValueAsString was executed
            verify(objectMapper, times(1)).writeValueAsString(argumentCaptor.capture());

            //check that exception is correct
            assertThat(throwable).isInstanceOf(JsonProcessingException.class);
        }
    }

I think I have the same question as you, hope someone can solve our problem.

In my case, I also want to got a return object like PowerMock.whenNew().withArguments().thenReturn(someThing), I try a lot of times but it failed. I think mockConstruction just only can mock their behavior, can't verify their result like powerMock, and I couldn't find any articles or answers. below is my post link :

Junit 5 use mockConstruction().withSetting().useConstructor() instead of PowerMock.whenNew().withArguments()