Response r = new Response();
  when(mock.method()).thenReturn(r);
  assertEquals(r, testObj.call()); // call() { return mock.method();}

package com.meawallet.secured.service;

@Service
public class ClientInfoService implements MessageListener {
    @Autowired
    private JmsTemplate jmsTemplate;
    @Autowired
    private Queue clientInfoResponseQueue;

    @Autowired
    private CardDetailsService cardDetailsService;

    @Override
    public void onMessage(Message message) {
        if (message instanceof ObjectMessage) {
            try {
                InfoRequest infoRequest = (InfoRequest) ((ObjectMessage) message).getObject();
                final String correlationId = message.getJMSCorrelationID();
                final InfoResponse infoResponse = process(infoRequest);
                jmsTemplate.send(clientInfoResponseQueue, session -> {
                    ObjectMessage objectMessage = session.createObjectMessage(infoResponse);
                    objectMessage.setJMSCorrelationID(correlationId);
                    return objectMessage;
                });
            } catch (JMSException ex) {
                throw new RuntimeException(ex);
            }
        } else {
            throw new IllegalArgumentException("Message must be of type ObjectMessage");
        }
    }

    InfoResponse process(InfoRequest infoRequest) {
        InfoResponse result = new InfoResponse();
        Info resultInfo = new Info();
        List<CardDetails> resultCardDetails = infoRequest.getInfo().getCardDetails().stream()
                .map(cardDetails -> {
                    Optional<CardDetails> optionalClientInfo = cardDetailsService.getClientInfo(cardDetails.getCardNumber());
                    return optionalClientInfo.orElseGet(() -> {
                        CardDetails clientInfo = new CardDetails();
                        clientInfo.setSuccess(false);
                        clientInfo.setCardNumber(cardDetails.getCardNumber());
                        return clientInfo;
                    });
                })
                .collect(Collectors.toList());

        resultInfo.setCardDetails(resultCardDetails);
        result.setInfo(resultInfo);
        return result;
    }
}

package com.meawallet.secured.service;

public class ClientInfoServiceTest {

    @InjectMocks
    private ClientInfoService clientInfoService;

    @Mock
    private CardDetailsService cardDetailsService;

    @Before
    public void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);
    }

    @Test
    public void testEmptyRequestProcess() {
        InfoRequest request = prepareEmptyInfoRequest();
        InfoResponse response = clientInfoService.process(request);
        assertNotNull(response);
        assertEquals(0, response.getInfo().getCardDetails().size());
    }

    @SuppressWarnings("unused")
    @Test
    public void testAllInfoFound() {
        InfoRequest request = prepareEmptyInfoRequest();

        CardDetails cardDetails1 = prepareCardDetails(request, "1", "Name 1", "Surname 1");
        CardDetails cardDetails2 = prepareCardDetails(request, "2", "Name 2", "Surname 2");
        CardDetails cardDetails3 = prepareCardDetails(request, "3", "Name 3", "Surname 3");

        InfoResponse response = clientInfoService.process(request);
        List<CardDetails> responseCardDetails = response.getInfo().getCardDetails();

        assertNotNull(response);
        assertEquals(3, responseCardDetails.size());

        List<CardDetails> responseCardDetails2 = responseCardDetails.stream()
                .filter(cardDetails -> cardDetails2.getCardNumber().equals(cardDetails.getCardNumber()))
                .collect(Collectors.toList());

        assertEquals(1, responseCardDetails2.size());
        assertEquals(true, responseCardDetails2.get(0).getSuccess());
        assertEquals("Name 2", responseCardDetails2.get(0).getInfo().getName());
    }
    
    @SuppressWarnings("unused")
    @Test
    public void testAllInfoNotFound() {
        InfoRequest request = prepareEmptyInfoRequest();

        CardDetails cardDetails1 = prepareNotFoundCardDetails(request, "1");
        CardDetails cardDetails2 = prepareNotFoundCardDetails(request, "2");
        CardDetails cardDetails3 = prepareNotFoundCardDetails(request, "3");

        InfoResponse response = clientInfoService.process(request);
        List<CardDetails> responseCardDetails = response.getInfo().getCardDetails();

        assertNotNull(response);
        assertEquals(3, responseCardDetails.size());

        List<CardDetails> responseCardDetails2 = responseCardDetails.stream()
                .filter(cardDetails -> cardDetails2.getCardNumber().equals(cardDetails.getCardNumber()))
                .collect(Collectors.toList());

        assertEquals(1, responseCardDetails2.size());
        assertEquals(false, responseCardDetails2.get(0).getSuccess());

    }

    @Test
    public void testMixedFound() {
        InfoRequest request = prepareEmptyInfoRequest();

        CardDetails cardDetails1 = prepareCardDetails(request, "1", "Name 1", "Surname 1");
        CardDetails cardDetails2 = prepareNotFoundCardDetails(request, "2");
        CardDetails cardDetails3 = prepareNotFoundCardDetails(request, "3");
        CardDetails cardDetails4 = prepareCardDetails(request, "4", "Name 4", "Surname 4");

        InfoResponse response = clientInfoService.process(request);

        List<CardDetails> responseCardDetails = response.getInfo().getCardDetails();

        assertNotNull(response);
        assertEquals(4, responseCardDetails.size());

        List<CardDetails> responseCardDetails2 = responseCardDetails.stream()
                .filter(cardDetails -> cardDetails2.getCardNumber().equals(cardDetails.getCardNumber()))
                .collect(Collectors.toList());

        assertEquals(1, responseCardDetails2.size());
        assertEquals(false, responseCardDetails2.get(0).getSuccess());

        List<CardDetails> responseCardDetails4 = responseCardDetails.stream()
                .filter(cardDetails -> cardDetails4.getCardNumber().equals(cardDetails.getCardNumber()))
                .collect(Collectors.toList());

        assertEquals(1, responseCardDetails4.size());
        assertEquals(true, responseCardDetails4.get(0).getSuccess());
        assertEquals("Name 4", responseCardDetails4.get(0).getInfo().getName());
    }

    private CardDetails prepareNotFoundCardDetails(InfoRequest request, String cardNumber) {
        CardDetails result = new CardDetails();
        result.setCardNumber(cardNumber);
        result.setSuccess(false);

        request.getInfo().getCardDetails().add(result);
        when(cardDetailsService.getClientInfo(cardNumber)).thenReturn(Optional.empty());

        return result;
    }

    private CardDetails prepareCardDetails(InfoRequest request, String cardNumber, String name, String surname) {
        CardDetails result = new CardDetails();
        result.setCardNumber(cardNumber);
        PersonInfo personInfo = new PersonInfo(name, surname);
        result.setInfo(personInfo);
        result.setSuccess(true);

        request.getInfo().getCardDetails().add(result);
        when(cardDetailsService.getClientInfo(cardNumber)).thenReturn(Optional.of(result));

        return result;
    }

    private InfoRequest prepareEmptyInfoRequest() {
        InfoRequest request  = new InfoRequest();
        Info info = new Info();
        List<CardDetails> requestCardDetails = new ArrayList<>();
        info.setCardDetails(requestCardDetails);
        request.setInfo(info);
        return request;
    }
}

D> package com.meawallet.secured.service;

D> @Service
D> public class ClientInfoService implements MessageListener {
D>     @Autowired
D>     private JmsTemplate jmsTemplate;
D>     @Autowired
D>     private Queue clientInfoResponseQueue;

D>     @Autowired
D>     private CardDetailsService cardDetailsService;

D>     @Override
D>     public void onMessage(Message message) {
D>         if (message instanceof ObjectMessage) {
D>             try {
D>                 InfoRequest infoRequest = (InfoRequest) ((ObjectMessage) message).getObject();
D>                 final String correlationId = message.getJMSCorrelationID();
D>                 final InfoResponse infoResponse = process(infoRequest);
D>                 jmsTemplate.send(clientInfoResponseQueue, session -> {
D>                     ObjectMessage objectMessage = session.createObjectMessage(infoResponse);
D>                     objectMessage.setJMSCorrelationID(correlationId);
D>                     return objectMessage;
D>                 });
D>             } catch (JMSException ex) {
D>                 throw new RuntimeException(ex);
D>             }
D>         } else {
D>             throw new IllegalArgumentException("Message must be of type ObjectMessage");
D>         }
D>     }

D>     InfoResponse process(InfoRequest infoRequest) {
D>         InfoResponse result = new InfoResponse();
D>         Info resultInfo = new Info();
D>         List<CardDetails> resultCardDetails = infoRequest.getInfo().getCardDetails().stream()
D>                 .map(cardDetails -> {
D>                     Optional<CardDetails> optionalClientInfo = cardDetailsService.getClientInfo(cardDetails.getCardNumber());
D>                     return optionalClientInfo.orElseGet(() -> {
D>                         CardDetails clientInfo = new CardDetails();
D>                         clientInfo.setSuccess(false);
D>                         clientInfo.setCardNumber(cardDetails.getCardNumber());
D>                         return clientInfo;
D>                     });
D>                 })
D>                 .collect(Collectors.toList());

D>         resultInfo.setCardDetails(resultCardDetails);
D>         result.setInfo(resultInfo);
D>         return result;
D>     }
D> }
D>

D> process уже имеет некоторую логику и его вполне можно поюниттестировать

D> Всё. У меня больше нет никаких идей и фантазии что можно тестировать юнит тестами в этом приложении

 public class ClientInfoServiceTest {
 
     @InjectMocks
     private ClientInfoService testSubject;
 
     @Mock
     private CardDetailsService cardDetailsService;
 
     @Mock
     private JmsOperations jmsOperations;
     @Mock
     private Queue clientInfoResponseQueue;
     @Captor
     private ArgumentCaptor<MessageCreator> creatorCaptor;
 
     @Before
     public void setUp() throws Exception {
         MockitoAnnotations.initMocks(this);
        doNothing().when(jmsOperations.send(clientInfoResponseQueue, creatorCaptor.capture());
     }

     @Test public shouldReturnExistingDetails()
     {
        //given
        Message msg = new ObjectMessage();
        msg.setObject(new InfoRequest()....withClinetInfo);
        msg.setJMSCorrelationID("12345");
        when(cardDetailsService.getClientInfo("cardNo1")).willReturn(...);
        //when
        testSubject.onMessage(msg);
        MessageCreator creator = creatorCaptor.getValue();
        ObjectMessage actual = creator.createMessage(session);
        //then
        assertEquals("12345", message.getCorrelationID());
        assertEquals(..., message.getObject().getInfo...);
     }