@Mock Object is null when called in another class

Question

I have the following

public class SenderHeaders {
    public Map<String, Object> getHeaders(String subject) {
        Map<String, Object> headers = new HashMap<>();
        ...
        return headers;
    }
}

public class Sender {
  private SenderHeaders senderHeaders;

  public Sender(SenderHeaders senderHeaders) {
    this.senderHeaders = senderHeaders;
  }

  public void sendFirstAndSecondDocuments(ATask aTask, Optional<ATask> secondTask, String subject) {
    Map<String, Object> headers = senderHeaders.getHeaders(subject);
    sendDocument(new Document(aTask, headers));
    if (secondTask.isPresent()) {
        sendDocument(new Document(secondTask.get(), senderHeaders.getHeaders(subject)));
    }
  }


  public void sendDocument(Document<ATask> Document) {
        ...
  }
  ....
}


public class BSending {
    ...
    private final String subject;
    ...
    @Autowired
    public BSending(Sender sender, AMapper aMapper, String subject) {
        ...
        this.subject = subject;
    }

    public void sendTask(CTask cTask) {
        final var aTask = getATask(cTask);
        final var secondTask = getSecondTask(cTask);

        aSender.sendFirstAndSecondDocuments(aTask, secondTask, subject);
    }


}

public class BSendingTest {
    @Mock private Sender aSender;
    @Mock ATask aTask;
    @Mock ATask secondTask;
    @Mock Map<String, Object> headers;
    static final String subject = "subject";
    @Mock private SenderHeaders senderHeaders;
    @InjectMocks private BSending bSending;
    ...


    @Test
    void test() {
        ...
        when(senderHeaders.getHeaders(subject)).thenReturn(headers);

        doCallRealMethod().when(aSender).sendFirstAndSecondDocuments(aTask, Optional.empty(), subject);

        ArgumentCaptor<Document<ATask>> documentCaptor = ArgumentCaptor.forClass(Document.class);
        bSending.sendTask(cTask);

        verify(aSender, times(1)).sendFirstAndSecondDocuments(aEvent, Optional.empty(), subject);

        verify(aSender, times(1)).sendDocument(documentCaptor.capture());
        final var actual = documentCaptor.getValue();
        assertEquals(aTask, actual.get(0).getBody());
        ..
    }
}

I got this error

strict stubbing argument mismatch
this invocation of 'sendFirstAndSecondDocuments' method:
aSender.sendFirstAndSecondDocuments(
aEvent,
Optional.empty,
null)

has following stubbing(s) with different arguments:
aSender.sendFirstAndSecondDocuments(
aEvent,
Optional.empty,
"subject")

why is it being null when I passed in subject?

I also noticed when I was debugging and hit Map<String, Object> headers = senderHeaders.getHeaders(subject); inside of sendFirstAndSecondDocuments I noticed it said senderHeaders = 'this' is not available

when I replace subject with null for the doCallRealMethod and verify for sendFirstAndSecondDocuments I then get

nullPointerException: cannot invoke getHeaders(String) because <local5>.senderHeaders is null

I don't understand this because I already mocked senderHeaders and have when(senderHeaders.getHeaders(subject)).thenReturn(headers);

Can I get help with this?

EDIT: Modified getHeaders() so its public but I still get the same errors

EDIT2: I created another code that is hopefully easier to understand but gives similar error:

public class SenderPrint {
    public void printTask(ATask aTask) {
        System.out.println("printLetters: " + aTask.getLetters());
    }

    public void confirmTask(ATask aTask) {
        System.out.println("confirmLetters: " + aTask.getLetters());
    }
}

public class Sender {
    private SenderPrint senderPrint;

    public Sender(SenderPrint senderPrint) {
        this.senderPrint = senderPrint;
    }

    public void printSenderLetters(ATask aTask) {
        senderPrint.printTask(aTask);
        senderPrint.confirmTask(aTask);
        if (aTask.getLetters() == "subject") {
            senderPrint.printTask(aTask);
        }
    }
}

public class ATask {
    private String letters;
    public String getLetters() {
        return this.letters;
    }
    public void setLetters(String letters) {
        this.letters = letters;
    }
}


public class BSending {
    protected final Sender sender;

    public BSending(Sender sender) {
        this.sender = sender;
    }

    public void sendTask(ATask aTask) {
        sender.printSenderLetters(aTask);
    }

}

public class BSendingTest {
    @Mock private Sender sender;
    @Mock ATask aTask;
    @Mock private senderPrint senderPrint;


    @Test
    void test() {
        BSending bSending = new BSending(sender);
        doCallRealMethod().when(senderPrint).printTask(aTask);
        doCallRealMethod().when(senderPrint).confirmTask(aTask);
        bSending.sendTask(aTask);
        verify(sender, times(1)).printSenderLetters(aTask);
        verify(senderPrint, times(1)).printTask(aTask);
        verify(senderPrint, times(1)).confirmTask(aTask);
        ArgumentCaptor<ATask> captor = ArgumentCaptor.forClass(ATask.class);
        final var actual = captor.getValue();
    }
}

Gives

wanted but not invoked
senderPrint.printTask(aTask)
actually there were zero interactions with this mock