PropertiesLoaderTest.java

package dbfit.util;

import static dbfit.util.PropertiesTestsSetUp.wrapEncryptedValue;

import dbfit.util.crypto.CryptoTestsConfig;
import dbfit.util.crypto.CryptoService;
import static dbfit.util.crypto.CryptoTestsConfig.getFakeCryptoService;

import org.junit.Test;
import org.junit.Before;
import org.junit.Rule;
import org.junit.rules.TemporaryFolder;
import org.junit.runner.RunWith;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.hamcrest.Matchers.*;

import org.mockito.runners.MockitoJUnitRunner;
import org.mockito.Mock;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.times;

import java.util.List;
import java.util.Map;

@RunWith(MockitoJUnitRunner.class)
public class PropertiesLoaderTest {

    public static final String DB_PASSWORD = "Test Password";
    private final String ENCRYPTED_PASSWORD = encrypt(DB_PASSWORD);

    @Mock private CryptoService mockedCryptoService;
    @Rule public TemporaryFolder tempKeyStoreFolder = new TemporaryFolder();
    private PropertiesLoader fakeLoader;

    @Before
    public void initMockedCryptoService() {
        when(mockedCryptoService.decrypt(ENCRYPTED_PASSWORD)).thenReturn(DB_PASSWORD);
        fakeLoader = new PropertiesLoader(getFakeCryptoService());
    }

    private String encrypt(String password) {
        return getFakeCryptoService().encrypt(password);
    }

    private List<String> prepareEncryptedSettings() {
        return PropertiesTestsSetUp.prepareEncryptedSettings(ENCRYPTED_PASSWORD);
    }

    //----- Whole list loading tests -----/
    @Test
    public void shouldCallDecryptWhenLoadingEncryptedValue() {
        PropertiesLoader loader = new PropertiesLoader(mockedCryptoService);

        loader.loadFromList(prepareEncryptedSettings());

        verify(mockedCryptoService, times(1)).decrypt(ENCRYPTED_PASSWORD);
    }

    @Test
    public void testNonEncryptedPropertyLoad() throws Exception {
        Map<String, String> props =
            fakeLoader.loadFromList(prepareEncryptedSettings());

        assertEquals("mydemodb", props.get("database"));
    }

    @Test
    public void testEncryptedPropertyLoad() throws Exception {
        Map<String, String> props =
            fakeLoader.loadFromList(prepareEncryptedSettings());

        assertEquals(DB_PASSWORD, props.get("password"));
    }

    @Test
    public void shouldSkipCommentedLines() throws Exception {
        List<String> lines = new java.util.ArrayList<String>();
        lines.add("#=A comment here");
        lines.add("username=myname");

        Map<String, String> props = fakeLoader.loadFromList(lines);

        assertThat(props, not(hasKey(startsWith("#"))));
    }

    // Integration test with real crypto svc
    @Test
    public void testEncryptedPropertyLoadRealCryptoSvc() throws Exception {
        java.io.File ksRoot = tempKeyStoreFolder.getRoot();
        CryptoTestsConfig.createTestKeyStore(ksRoot);
        CryptoService crypto = CryptoTestsConfig.getCryptoService(ksRoot);

        PropertiesLoader loader = new PropertiesLoader(crypto);

        Map<String, String> props = loader.loadFromList(
            PropertiesTestsSetUp.prepareEncryptedSettings(crypto.encrypt(DB_PASSWORD)));

        assertEquals(DB_PASSWORD, props.get("password"));
    }
    //----- End of whole list loading tests -/

    //----- Line-level processing tests -----/
    @Test
    public void parseEncryptedValueTest() throws Exception {
        String decPwd = fakeLoader.parseValue(wrapEncryptedValue(ENCRYPTED_PASSWORD));
        assertEquals(DB_PASSWORD, decPwd);
    }

    @Test
    public void parseNonEncryptedValueTest() throws Exception {
        String decPwd = fakeLoader.parseValue(DB_PASSWORD);
        assertEquals(DB_PASSWORD, decPwd);
    }

    //----- Start of static methods tests ------/
    @Test
    public void unwrapEncryptedValueTest() {
        String value = "XYZ";
        String wrapped = wrapEncryptedValue(value);

        assertEquals(value, PropertiesLoader.unwrapEncryptedValue(wrapped));
    }

    @Test
    public void unwrapNonEncryptedValueShouldGiveNull() {
        assertNull(PropertiesLoader.unwrapEncryptedValue("XYZ"));
    }

    @Test
    public void splitKeyValueSettingsLineTest() {
        String[] keyval = PropertiesLoader.splitKeyVal("password=crap");

        assertEquals("password", keyval[0]);
        assertEquals("crap", keyval[1]);
    }

    @Test
    public void shouldAllowEqualsSignInSettingsValue() {
        String key = "password";
        String value = "One=Two-Three==";
        String[] keyval = PropertiesLoader.splitKeyVal(
                key + "=" + value);


        assertEquals(key, keyval[0]);
        assertEquals(value, keyval[1]);
    }
    //------- End of static methods tests ------/
}