LogicalConfigServiceTest.java

/**
 * Copyright (C) 2015 Orange
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.francetelecom.clara.cloud.logicalmodel;

import com.francetelecom.clara.cloud.commons.BusinessException;
import com.francetelecom.clara.cloud.logicalmodel.InvalidConfigServiceException.ErrorType;
import com.francetelecom.clara.cloud.logicalmodel.samplecatalog.ConfigLogicalModelCatalog;
import com.francetelecom.clara.cloud.logicalmodel.samplecatalog.SpringooLogicalModelCatalog;
import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.lang3.StringUtils;
import org.fest.assertions.Assertions;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.transaction.Transactional;
import java.util.*;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

/**
 * Tests the LogicalConfigService parsing and consistency checking.<br>
 * TODO: find a way to simulate invalid unicode characters easily. Get some inspiration in https://issues.apache.org/jira/browse/LANG-100 ?<br>
 * @author skwg9735
 */
@ContextConfiguration(locations = "application-context.xml")
@RunWith(SpringJUnit4ClassRunner.class)
@DirtiesContext
public class  LogicalConfigServiceTest {

	public static final LogicalConfigServiceUtils LOGICAL_CONFIG_SERVICE_UTILS = new LogicalConfigServiceUtils();
    @Autowired
    SpringooLogicalModelCatalog utilSpringooIntegration;
	@Autowired
	ConfigLogicalModelCatalog configLogicalModelCatalog;

    @Autowired
    LogicalDeploymentRepository logicalDeploymentRepository;

    //syntaxic sugar
    private HashSet<String> IGNORED_DUPLICATES;
    private StringBuffer IGNORE_COLLISIONS;

    public LogicalConfigServiceTest() {
    }

    @Before
    public void setUp() throws Exception {
        IGNORED_DUPLICATES = new HashSet<String>();
        IGNORE_COLLISIONS = new StringBuffer();
    }

    /**
     * Tests that the long string content properly serializes.
     * TODO: test with postgresql in addition to default hsqldb
     * @throws BusinessException
     */
    @Test
    @DirtiesContext
    @Transactional
    public void testPersistenceOfLongConfigSetContent() throws BusinessException {
        createLongConfigSetContent(LogicalConfigService.MAX_CONFIG_SET_CHARS -1, true);
    }

	@Test
	public void testConfigSetTooLargeSizeDetected() throws BusinessException {
        try {
            createLongConfigSetContent(LogicalConfigService.MAX_CONFIG_SET_CHARS + 1, false);
			Assert.assertFalse("Should have failed", true);
		} catch (InvalidConfigServiceException e) {
			Assert.assertEquals(ErrorType.TOO_LONG, e.getType());
			Assert.assertEquals(LogicalConfigService.MAX_CONFIG_SET_CHARS, e.getMaxLength());
		}
	}

    private void createLongConfigSetContent(int size, boolean testPersistence) throws BusinessException {
        String frontEndConfigSetContent = "#Comment too long ?";
        frontEndConfigSetContent = StringUtils.rightPad(frontEndConfigSetContent, size, '?');
        createConfigSetLogicalModelCatalog(frontEndConfigSetContent, testPersistence);
    }

    @Test
	public void testDuplicateKeysInSingleConfigSetDetected() throws BusinessException {
		try {
			String frontEndConfigSetContent = "Key1=value1\n" + "Key1=value2\n";
            LogicalDeployment ld = configLogicalModelCatalog.createLogicalModel("TestInvalidUnicodeCharacters");
            Set<LogicalConfigService> frontEndConfigService = ld.listLogicalServices(LogicalConfigService.class, ConfigLogicalModelCatalog.FRONT_END_CONFIG);
            assert frontEndConfigService.size() ==1;

            LogicalConfigService configService = frontEndConfigService.iterator().next();
            configService.setConfigSetContent(frontEndConfigSetContent);

            configService.checkForDuplicatesWithinService();
            Assert.fail("expected exception to be caught");
        } catch (InvalidConfigServiceException e) {
			Assert.assertEquals(ErrorType.DUPLICATE_KEYS, e.getType());
			Assert.assertEquals(1, e.getDuplicateKeys().size());
			Assert.assertEquals("Key1", e.getDuplicateKeys().iterator().next());
		}
	}

    /**
     * Checks that duplicates among configsets are detected, but that the full list of properties can still
     * be displayed to help end-users diagnose these duplicates
     * @throws BusinessException
     */
	@Test
	public void testDuplicateKeysAmongConfigSetsDetectedAndDisplayed() throws BusinessException {
        String frontEndConfigSetContent = "Key1=value1\n" + "Key2=value2\n";
        String backendConfigSetContent = "";
        String wholeAppConfigSetContent = "Key2=value1\n" + "Key3=value2\n";
        LogicalDeployment ld = configLogicalModelCatalog.createLogicalModel("TestInvalidUnicodeCharacters");

        Set<LogicalConfigService> backConfig = ld.listLogicalServices(LogicalConfigService.class, ConfigLogicalModelCatalog.BACK_END_CONFIG);
        assert backConfig.size() ==1;
        backConfig.iterator().next().setConfigSetContent(backendConfigSetContent);

        Set<LogicalConfigService> frontConfig = ld.listLogicalServices(LogicalConfigService.class, ConfigLogicalModelCatalog.FRONT_END_CONFIG);
        assert frontConfig.size() ==1;
        frontConfig.iterator().next().setConfigSetContent(frontEndConfigSetContent);

        Set<LogicalConfigService> wholeConfig = ld.listLogicalServices(LogicalConfigService.class, ConfigLogicalModelCatalog.WHOLE_APP_CONFIG);
        assert wholeConfig.size() ==1;
        wholeConfig.iterator().next().setConfigSetContent(wholeAppConfigSetContent);

        try {
			ld.checkOverallConsistency();
			Assert.assertFalse("Should have failed", true);
		} catch (LogicalModelNotConsistentException ie) {
            boolean foundMatchingConfigException = false;
            for (BusinessException businessException : ie.getErrors()) {
                if (businessException instanceof InvalidConfigServiceException) {
                    InvalidConfigServiceException e = (InvalidConfigServiceException) businessException;
                    Assert.assertEquals(ErrorType.DUPLICATE_KEYS, e.getType());
                    Assert.assertEquals(1, e.getDuplicateKeys().size());
                    Assert.assertEquals("configKey2", e.getDuplicateKeys().iterator().next());
                    foundMatchingConfigException = true;
                }
            }
            assertTrue("Did not catch an InvalidConfigServiceException", foundMatchingConfigException);
        }

        //Test how the UI can display these duplicated keys to report them
        StringBuilder sb = new StringBuilder();
        List<ProcessingNode> processingNodes = ld.listProcessingNodes();
        for (ProcessingNode processingNode : processingNodes) {
            Map<String,String> mergedProperties = new HashMap<String,String>();
            String executionNodeLabel = processingNode.getLabel();
            List<LogicalConfigService> logicalConfigServices = processingNode.listLogicalServices(LogicalConfigService.class);
            for (LogicalConfigService logicalConfigService : logicalConfigServices) {

                LogicalConfigServiceUtils.StructuredLogicalConfigServiceContent structuredLogicalConfigServiceContent = LOGICAL_CONFIG_SERVICE_UTILS.parseConfigContent(logicalConfigService.getConfigSetContent());
                for (LogicalConfigServiceUtils.ConfigEntry configEntry : structuredLogicalConfigServiceContent.getConfigEntries()) {
                    String previousValue = mergedProperties.put(configEntry.getKey(), configEntry.getValue());
                    sb.append("JEEProcess=" + executionNodeLabel + ", ConfigSet=" + logicalConfigService.getLabel() + ", key=" + logicalConfigService.getKeyPrefix() + configEntry.getKey() + ", value=" + configEntry.getValue() + ", isDuplicate=" + (previousValue != null) + ", comment=" + configEntry.getComment() + "\n");
                }
            }
        }
        String conf = sb.toString();
        Assertions.assertThat(conf).contains("JEEProcess=BackEnd, ConfigSet=WholeAppConfig, key=configKey2, value=value1, isDuplicate=false, comment=null");
        Assertions.assertThat(conf).contains("JEEProcess=BackEnd, ConfigSet=WholeAppConfig, key=configKey3, value=value2, isDuplicate=false, comment=null");
        Assertions.assertThat(conf).contains("JEEProcess=FrontEnd, ConfigSet=FrontEndConfig, key=configKey1, value=value1, isDuplicate=false, comment=null");
        Assertions.assertThat(conf).contains("JEEProcess=FrontEnd, ConfigSet=FrontEndConfig, key=configKey2, value=value2, isDuplicate=false, comment=null");
        Assertions.assertThat(conf).contains("JEEProcess=FrontEnd, ConfigSet=WholeAppConfig, key=configKey2, value=value1, isDuplicate=true, comment=null");
        Assertions.assertThat(conf).contains("JEEProcess=FrontEnd, ConfigSet=WholeAppConfig, key=configKey3, value=value2, isDuplicate=false, comment=null");
    }


	@Test
	public void testTooManyKeysConfigSetsDetected() throws BusinessException {
		try {
			StringBuffer sb = new StringBuffer();
			for (int keyIndex = 0; keyIndex < ProcessingNode.MAX_CONFIG_SET_ENTRIES_PER_EXEC_NODE + 1; keyIndex++) {
				sb.append("key" + keyIndex + "=" + "value" + keyIndex + "\n");
			}
			String frontEndConfigSetContent = sb.toString();
			createConfigSetLogicalModelCatalog(frontEndConfigSetContent, false);
			Assert.assertFalse("Should have failed", true);
		} catch (LogicalModelNotConsistentException ie) {
            boolean foundMatchingConfigException = false;
            for (BusinessException businessException : ie.getErrors()) {
                if (businessException instanceof InvalidConfigServiceException) {
                    InvalidConfigServiceException e = (InvalidConfigServiceException) businessException;
                    Assert.assertEquals(ErrorType.TOO_MANY_ENTRIES, e.getType());
                    Assert.assertEquals(ProcessingNode.MAX_CONFIG_SET_ENTRIES_PER_EXEC_NODE, e.getMaxEntryCount());
                    Assert.assertEquals(ProcessingNode.MAX_CONFIG_SET_ENTRIES_PER_EXEC_NODE + 3, e.getEntryCount());
                    foundMatchingConfigException = true;
                }
            }
            assertTrue("Did not catch an InvalidConfigServiceException", foundMatchingConfigException);

        }
	}

	@Test
    public void testEmptyKeyPrefix() throws BusinessException {
        LogicalConfigService lcs = createConfigSetLogicalModelCatalog("toto=titi", false, "");
		Properties mergedProperties = new Properties();
        lcs.mergeAndCheckForDuplicateKeys(mergedProperties, IGNORED_DUPLICATES, IGNORE_COLLISIONS);
		Assert.assertNotNull(mergedProperties.getProperty("toto"));
		Assert.assertEquals(mergedProperties.getProperty("toto"), "titi");
	}

    @Test()
	public void empty_key_name_should_be_supported() throws BusinessException {
		LogicalConfigService lcs = createConfigSetLogicalModelCatalog("#comment\n=some value", false, "prefix.");
        Properties mergedProperties = new Properties();
        lcs.mergeAndCheckForDuplicateKeys(mergedProperties, IGNORED_DUPLICATES, IGNORE_COLLISIONS);
        Assert.assertEquals("expected empty key to return specified value", "some value", mergedProperties.getProperty("prefix."));
	}

    @Test()
	public void empty_key_name_should_be_supported_without_prefix() throws BusinessException {
		LogicalConfigService lcs = createConfigSetLogicalModelCatalog("#comment\n=some value", false, "");
        Properties mergedProperties = new Properties();
        lcs.mergeAndCheckForDuplicateKeys(mergedProperties, IGNORED_DUPLICATES, IGNORE_COLLISIONS);
        Assert.assertEquals("expected empty key to return specified value", "some value", mergedProperties.getProperty(""));
	}

    @Test
    public void entries_with_empty_values_are_supported() throws BusinessException {
        LogicalConfigService lcs = createConfigSetLogicalModelCatalog("#comment\nkeyWithEmptyValue=", false, "prefix.");
        Properties mergedProperties = new Properties();
        lcs.mergeAndCheckForDuplicateKeys(mergedProperties, IGNORED_DUPLICATES, IGNORE_COLLISIONS);
        Assert.assertTrue("expected keyWithEmptyValue to be present in list of keys", mergedProperties.containsKey("prefix.keyWithEmptyValue"));
        Assert.assertEquals("expected empty value to return empty string", "", mergedProperties.getProperty("prefix.keyWithEmptyValue"));
    }

    @Test
	public void testConfigServiceUtils() throws ConfigurationException, InvalidConfigServiceException {
        //given
		String header =
                "#HeaderComment1\n" +
                "#HeaderComment2";
		String propertiesContent = header + "\n\n" + "#Comment1.1\n" + "Key1=value1\n" + "# Comment2 Line1\n" + "# Comment2 Line2\n" + "Key2=value2\n";

        //when
		LogicalConfigServiceUtils.StructuredLogicalConfigServiceContent parsedContent = LOGICAL_CONFIG_SERVICE_UTILS.parseConfigContent(propertiesContent);

        //then
		List<LogicalConfigServiceUtils.ConfigEntry> expectedEntries = new ArrayList<LogicalConfigServiceUtils.ConfigEntry>();
		expectedEntries.add(new LogicalConfigServiceUtils.ConfigEntry("Key1", "value1", "Comment1.1"));
		expectedEntries.add(new LogicalConfigServiceUtils.ConfigEntry("Key2", "value2", " Comment2 Line1\n Comment2 Line2"));
		LogicalConfigServiceUtils.StructuredLogicalConfigServiceContent expectedContent = new LogicalConfigServiceUtils.StructuredLogicalConfigServiceContent(
				header, expectedEntries);

		assertEquals(expectedContent, parsedContent);

		// Then dump back
        //when
		String dumpedProperties = LOGICAL_CONFIG_SERVICE_UTILS.dumpConfigContentToString(expectedContent);

        //Then: dumped content normalizes comments with a prefix space if missing (i.e. not strictly symetric)
        String expectedNormalizedDumpedContent =
                "#HeaderComment1\n" +
                "#HeaderComment2\n" +
                "\n" +
                "# Comment1.1\n" +
                "Key1=value1\n" +
                "#  Comment2 Line1\n" +
                "#  Comment2 Line2\n" +
                "Key2=value2\n";
		assertEquals(expectedNormalizedDumpedContent, dumpedProperties);
	}

    @Test
    public void parses_comments_received_from_apache_commons() {
        //removes pound as prefix
        assertCommentEscaped("comment", "#comment");
        assertCommentEscaped("comment1\ncomment2", "#comment1\n#comment2");
        assertCommentEscaped("comment1\n\rcomment2", "#comment1\n\r#comment2");
        assertCommentEscaped("comment1 with # embedded in between\n\rcomment2", "#comment1 with # embedded in between\n\r#comment2");
    }

    private void assertCommentEscaped(String expectedEscape, String rawComment) {
        assertEquals(expectedEscape, LOGICAL_CONFIG_SERVICE_UTILS.escapesPoundsInComments(rawComment));
    }

    @Test
	public void testConfigServiceUtils_when_no_header_comments() throws ConfigurationException, InvalidConfigServiceException {
		String propertiesContent = "#Comment1.1\n" + "Key1=value1\n";

		LogicalConfigServiceUtils.StructuredLogicalConfigServiceContent parsedContent = LOGICAL_CONFIG_SERVICE_UTILS.parseConfigContent(propertiesContent);
		List<LogicalConfigServiceUtils.ConfigEntry> expectedEntries = new ArrayList<LogicalConfigServiceUtils.ConfigEntry>();
		expectedEntries.add(new LogicalConfigServiceUtils.ConfigEntry("Key1", "value1", "Comment1.1"));
		LogicalConfigServiceUtils.StructuredLogicalConfigServiceContent expectedContent = new LogicalConfigServiceUtils.StructuredLogicalConfigServiceContent(
				null, expectedEntries);

		assertEquals(expectedContent, parsedContent);
    }

	private LogicalConfigService createConfigSetLogicalModelCatalog(String frontEndConfigSetContent, boolean testPersistence) throws InvalidConfigServiceException, LogicalModelNotConsistentException {
		return createConfigSetLogicalModelCatalog(frontEndConfigSetContent, testPersistence, "");
	}

    private LogicalConfigService createConfigSetLogicalModelCatalog(String frontEndConfigSetContent, boolean testPersistence, String keyPrefix) throws InvalidConfigServiceException, LogicalModelNotConsistentException {
        LogicalDeployment ld = configLogicalModelCatalog.createLogicalModel("TestInvalidUnicodeCharacters");

        Set<LogicalConfigService> config = ld.listLogicalServices(LogicalConfigService.class, ConfigLogicalModelCatalog.FRONT_END_CONFIG);
        assert config.size() ==1;

        LogicalConfigService lcs = config.iterator().next();
        lcs.setConfigSetContent(frontEndConfigSetContent);
        lcs.setKeyPrefix(keyPrefix);

        if (testPersistence) {
            logicalDeploymentRepository.save(ld);
            LogicalDeployment reloadedLd = logicalDeploymentRepository.findOne(ld.getId());
            assertEquals(ld, reloadedLd);
        }
		ld.checkOverallConsistency();
		return lcs;
	}
    @Test(expected=IllegalArgumentException.class)
    public void keyPrefix_cannot_be_null() throws BusinessException {
        LogicalConfigService lcs = createConfigSetLogicalModelCatalog("toto=titi", false, null);
        lcs.setKeyPrefix(null);
		
	}


}