Spying method calls the actual Method

Question

I am writing a JUnit with Mockito. But on the line

when(encryptDecryptUtil.getKeyFromKeyStore(any(String.class))).thenReturn(keyMock);

It calls the actual method, which is causing the test failure. Interesting point is that it directly makes the actual call at start of the test case when when()...thenReturn() statemnts gets executed. Can you please tell me how I can fix this? My test is as per below

@Test
public void testDecryptData_Success() throws NoSuchPaddingException, NoSuchAlgorithmException, BadPaddingException, IllegalBlockSizeException {
    encryptDecryptUtil = spy(new EncryptDecryptUtil());
    Key keyMock = Mockito.mock(Key.class);
    when(encryptDecryptUtil.getKeyFromKeyStore(any(String.class))).thenReturn(keyMock);
    String inputData = "TestMessage";
    String version = GetPropValues.getPropValue(PublisherConstants.KEYSTORE_VERSION);
    byte[] enCryptedValue= new byte[] {9,2,5,8,9};
    Cipher cipherMock = Mockito.mock(Cipher.class);
    when(Cipher.getInstance(any(String.class))).thenReturn(cipherMock);
    when(cipherMock.doFinal(any(byte[].class))).thenReturn(enCryptedValue);
    String encryptedMessage = encryptDecryptUtil.encryptData(inputData);
    assert(encryptedMessage.contains(version));
    assertTrue(!encryptedMessage.contains(inputData));
}

On the third line it self, it calls the actual method. Main code is as per below.

public class EncryptDecryptUtil {
private String publicKeyStoreFileName = 

GetPropValues.getPropValue(PublisherConstants.KEYSTORE_PATH);
    private String pubKeyStorePwd = "changeit";
    private static final String SHA1PRNG = "SHA1PRNG";
    private static final String pubKeyAlias="jceksaes";
    private static final String JCEKS = "JCEKS";
    private static final String AES_PADDING = "AES/CBC/PKCS5Padding";
    private static final String AES = "AES";
    private static final int CONST_16 = 16;
    private static final int CONST_0 = 0;
    private static final String KEY_STORE = "aes-keystore";
    private static final String KEY_STORE_TYPE = "jck";
    private static final Logger logger = Logger.getLogger(KafkaPublisher.class);

    public Key getKeyFromKeyStore( String keystoreVersion) {

        KeyStore keyStore = null;
        Key key = null;
        try {
            keyStore = KeyStore.getInstance(JCEKS);
            FileInputStream stream = null;
            stream = new FileInputStream(publicKeyStoreFileName+KEY_STORE+PublisherConstants.UNDERSCORE+keystoreVersion+PublisherConstants.DOT+KEY_STORE_TYPE);
            keyStore.load(stream, pubKeyStorePwd.toCharArray());
            stream.close();
            key = keyStore.getKey(pubKeyAlias, pubKeyStorePwd.toCharArray());
        } catch (KeyStoreException e) {
            e.printStackTrace();
        }
        catch (FileNotFoundException e) {
            logger.error("Error Inside getKeyFromKeyStore, Exception = " + e);
            e.printStackTrace();
        } catch (CertificateException e) {
            logger.error("Error Inside getKeyFromKeyStore, Exception = " + e);
            e.printStackTrace();
        } catch (UnrecoverableKeyException e) {
            logger.error("Error Inside getKeyFromKeyStore, Exception = " + e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            logger.error("Error Inside getKeyFromKeyStore, Exception = " + e);
            e.printStackTrace();
        } catch (IOException e) {
            logger.error("Error Inside getKeyFromKeyStore, Exception = " + e);
            e.printStackTrace();
        }
        return key;
    }

    public String encryptData(String data) {
        String keystoreVersion = GetPropValues.getPropValue(PublisherConstants.KEYSTORE_VERSION);
        SecretKey secKey = new SecretKeySpec(getKeyFromKeyStore(keystoreVersion).getEncoded(), AES);
        String base64EncodedEncryptedMsg = null;
        Cipher cipher = null;

        try { ------- Logic -------------------}
catch() { }
}
}

Answer 1

Have a look at the "Important gotcha on spying real objects" section of the Spy documentation.

Essentially, you cannot use the when(...).thenReturn(...) pattern with Spies, because as you have discovered, it calls the real method!

Instead, you use a different pattern which does exactly the same thing:

doReturn(...).when(spy).someMethod();

So, for your example:

doReturn(keyMock).when(encryptDecryptUtil).getKeyFromKeyStore(any(String.class));

Some advice which is unrelated to your question: If I read your code correctly, then EncryptDecryptUtil is the class that you are testing. As a general rule, you should not mock, stub, or spy on the object that you are actually testing, because then you are not testing the true object. You are actually testing a version of the object creating by the Mockito library. Furthermore, it's an uncommon pattern which will make your tests hard to read and maintain. If you find yourself having to do this, then the best thing would be to refactor your code so that the methods you are mocking (or spying on) and the methods you are testing are in different classes.