Mockito.spy object is not being recognized

I'm trying to test the following method:

@Override
  public Target apply(Source source) throws MappingException {
    try {
      Target target = targetModelObjectFactory.create(Target.class);
      mapNameToFirstName(source, target);
      mapMailToEMail(source, target);
      mapSourceSubEntityToTargetSubEntity(source, target);
      mapPrimitiveSourceColToPrimitiveTargetCol(source, target);
      mapSubEntitiesSourceColToSubEntitiesTargetCol(source, target);
      mapSourceSubEntityFieldToSubEntityFetchedField(source, target);
      produceProducedFieldValue(target);
      setConstantFieldConstantValue(target);
      return target;
    } catch (Exception e) {
      throw new MappingException(source, e);
    }
  }

here is part of my test:

public void TestApply() throws MappingException, MappingOperatorCreationException, TargetModelObjectCreationException {

        Source mockedSource = Mockito.mock(Source.class);
        Target mockedTarget = Mockito.mock(Target.class);
        TargetModelObjectFactory targetModelObjectFactory = Mockito.spy(TargetModelObjectFactory.class);

        Mockito.when(targetModelObjectFactory.create(Target.class)).thenReturn(mockedTarget);
        sourceToTargetMapper.apply(mockedSource);
}

The problem I'm having is with this part:

Target target = targetModelObjectFactory.create(Target.class);

When debbaging targetModelObjectFactory value inside the apply function I'm testing it's value is "'this' is not available" And I keep on getting NullPointerException

node that targetModelObjectFactory is an interface

I've been trying to do it like this:

 TargetModelObjectFactory targetModelObjectFactory1 = Mockito.mock(TargetModelObjectFactory.class,Mockito.RETURNS_DEEP_STUBS);

But still no luck

Any help would be appreciated

The main source of the problem is lack of injection of the mocked targetModelObjectFactory object in the test.
When you're mocking/spying on the class TargetModelObjectFactory, the object you get is in no way passed to the tested class,
thus it's reference is null, hence NullPointerException is thrown when trying to call the method create on an actually null reference.

Depending on the rest of your tested class (I can only guess) you can choose two approaches. The first one is constructor injection
(usually preferable, you can read more here):

class SourceToTargetMapper {

    private TargetModelObjectFactory targetModelObjectFactory;

    SourceToTargetMapper(TargetModelObjectFactory targetModelObjectFactory) {
        this.targetModelObjectFactory = targetModelObjectFactory;
    }
    
}

The second one is field injection and is possible thanks to annotations like @Inject, @Autowired etc., depending on the used tool:

class SourceToTargetMapper {

    @Autowired
    private TargetModelObjectFactory targetModelObjectFactory;

}

Both cases can be easily handled using Mockito:

@Test
void constructorInjectionTest() {
    TargetModelObjectFactory factory = mock(TargetModelObjectFactory.class);
    SourceToTargetMapper mapper = new SourceToTargetMapper(factory);
    Source source = mock(Source.class);
    Target target = mock(Target.class);
    when(factory.create(Target.class))
            .thenReturn(target);

    Target result = mapper.apply(source);

    assertSame(target, result);
}

<!-- -->

@Mock
TargetModelObjectFactory factory;
@InjectMocks
private SourceToTargetMapper mapper;

@BeforeEach
void setUp() {
    MockitoAnnotations.initMocks(this);
}

@Test
void fieldInjectionTest() {
    Source source = mock(Source.class);
    Target target = mock(Target.class);
    when(factory.create(Target.class))
            .thenReturn(target);

    Target result = mapper.apply(source);

    assertSame(target, result);
}

Another thing worth noting is the difference between mock and spy methods from the Mockito library.

When using mock, the whole behaviour of the class is handled by Mockito, that's why we call it with a Class parameter:

FirstClass firstObject = mock(FirstClass.class);
SecondClass secondObject = mock(SecondClass.class);

No actual instance of neither FirstClass nor SecondClass is created.

When using spy, we explicitly tell Mockito, which methods should have their behaviour changed and which methods should be actually called
as defined in the class. We can create the spy using a Class parameter or an actual object (the latter used more often).
In case of spies, actual behaviour is often not changed at all, since spies can be used to check if the method was actually called:

MyClass object = spy(new MyClass());
doStuff(object);
verify(object, times(1))
    .myMethod();

In your case, since you change the behaviour of the TargetModelObjectFactory class, probably mock will be a better choice.

I've created a repository on GitHub, where you can find all the code - all tests pass.