PropertyUtilTest.java

/**
 * Copyright (C) 2006 - 2016 52°North Initiative for Geospatial Open Source
 * Software GmbH
 *
 * 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 org.n52.wps.commons;

import com.google.common.base.Joiner;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import org.jmock.Expectations;
import static org.jmock.Expectations.returnValue;
import org.jmock.integration.junit4.JUnitRuleMockery;
import org.joda.time.Period;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.n52.wps.PropertyDocument.Property;

/**
 *
 * @author tkunicki
 */
public class PropertyUtilTest {
    
    static final String KEY_TEST_ROOT = "my.test.root";
    
    static final String KEY_TEST_BOOLEAN = "sample.boolean";
    static final String KEY_TEST_LONG = "sample.long";
    static final String KEY_TEST_DOUBLE = "sample.double";
    static final String KEY_TEST_STRING = "sample.string";
    static final String KEY_TEST_PERIOD = "sample.period";
    
    static final boolean DEFAULT_BOOLEAN = false;
    static final long    DEFAULT_LONG = 1l;
    static final double  DEFAULT_DOUBLE = 1d;
    static final String  DEFAULT_STRING = "default";
    static final String  DEFAULT_PERIOD = "P1D";
    static final long    DEFAULT_PERIOD_MS = Period.days(1).toStandardDuration().getMillis();
    
    static final boolean CONFIG_BOOLEAN = true;
    static final long    CONFIG_LONG = 2l;
    static final double  CONFIG_DOUBLE = 2d;
    static final String  CONFIG_STRING = "config";
    static final String  CONFIG_PERIOD = "P2D";
    static final long    CONFIG_PERIOD_MS = Period.days(2).toStandardDuration().getMillis();
    
    static final boolean SYSTEM_BOOLEAN = true;
    static final long    SYSTEM_LONG = 3l;
    static final double  SYSTEM_DOUBLE = 3d;
    static final String  SYSTEM_STRING = "system";
    static final String  SYSTEM_PERIOD = "P3D";
    static final long    SYSTEM_PERIOD_MS = Period.days(3).toStandardDuration().getMillis();
    
    @Rule public JUnitRuleMockery context = new JUnitRuleMockery();
    
    Property[] properties;
    
    public PropertyUtilTest() {

    }
    
    @Before
    public void setUp() {
        properties = new Property[5];
        properties[0] = context.mock(Property.class, "p1");
        properties[1] = context.mock(Property.class, "p2");
        properties[2] = context.mock(Property.class, "p3");
        properties[3] = context.mock(Property.class, "p4");
        properties[4] = context.mock(Property.class, "p5");
    }
    
    @Test
    public void testExtractDefaults_NoSystemProperties_NoConfigProperties() {
        PropertyUtil cu = new PropertyUtil(new Property[0]);
        
        System.out.println("Verify default values are passed through in absense of system or config properties");
        assertThat("extractBoolean", cu.extractBoolean(KEY_TEST_BOOLEAN, DEFAULT_BOOLEAN), equalTo(DEFAULT_BOOLEAN));
        assertThat("extractLong", cu.extractLong(KEY_TEST_LONG, DEFAULT_LONG), equalTo(DEFAULT_LONG));
        assertThat("extractDouble", cu.extractDouble(KEY_TEST_DOUBLE, DEFAULT_DOUBLE), equalTo(DEFAULT_DOUBLE));
        assertThat("extractString", cu.extractString(KEY_TEST_STRING, DEFAULT_STRING), equalTo(DEFAULT_STRING));
        assertThat("extractPeriodAsMillis", cu.extractPeriodAsMillis(KEY_TEST_PERIOD, DEFAULT_PERIOD_MS), equalTo(DEFAULT_PERIOD_MS));
        
    }
    
    @Test
    public void testExtractDefaults_NoSystemProperties_NoConfigProperties_SystemPropertyRootSet() {
        PropertyUtil cu = new PropertyUtil(new Property[0], KEY_TEST_ROOT);
        
        System.out.println("Verify default values are passed through in absense of system or config properties even with system properties root set");
        assertThat("extractBoolean", cu.extractBoolean(KEY_TEST_BOOLEAN, DEFAULT_BOOLEAN), equalTo(DEFAULT_BOOLEAN));
        assertThat("extractLong", cu.extractLong(KEY_TEST_LONG, DEFAULT_LONG), equalTo(DEFAULT_LONG));
        assertThat("extractDouble", cu.extractDouble(KEY_TEST_DOUBLE, DEFAULT_DOUBLE), equalTo(DEFAULT_DOUBLE));
        assertThat("extractString", cu.extractString(KEY_TEST_STRING, DEFAULT_STRING), equalTo(DEFAULT_STRING));
        assertThat("extractPeriodAsMillis", cu.extractPeriodAsMillis(KEY_TEST_PERIOD, DEFAULT_PERIOD_MS), equalTo(DEFAULT_PERIOD_MS));
    }
    
    @Test
    public void testExtractValid_SystemProperties() {
        PropertyUtil cu = new PropertyUtil(new Property[0], KEY_TEST_ROOT);
        
        setValidSystemProperties();
        try {
            System.out.println("Verify system property values are used if present");
            assertThat("extractBoolean", cu.extractBoolean(KEY_TEST_BOOLEAN, DEFAULT_BOOLEAN), equalTo(SYSTEM_BOOLEAN));
            assertThat("extractLong", cu.extractLong(KEY_TEST_LONG, DEFAULT_LONG), equalTo(SYSTEM_LONG));
            assertThat("extractDouble", cu.extractDouble(KEY_TEST_DOUBLE, DEFAULT_DOUBLE), equalTo(SYSTEM_DOUBLE));
            assertThat("extractString", cu.extractString(KEY_TEST_STRING, DEFAULT_STRING), equalTo(SYSTEM_STRING));
            assertThat("extractPeriodAsMillis", cu.extractPeriodAsMillis(KEY_TEST_PERIOD, DEFAULT_PERIOD_MS), equalTo(SYSTEM_PERIOD_MS));
        } finally {
            clearSystemProperties();
        }
    }
    
    @Test
    public void testExtractValid_SystemProperties_ConfigProperties_SystemPreferredOverConfig() {
        PropertyUtil cu = new PropertyUtil(getValidMockProperties(true), KEY_TEST_ROOT);
        
        setValidSystemProperties();
        try {
            System.out.println("Verify system property values preferred over config property values");
            assertThat("extractBoolean", cu.extractBoolean(KEY_TEST_BOOLEAN, DEFAULT_BOOLEAN), equalTo(SYSTEM_BOOLEAN));
            assertThat("extractLong", cu.extractLong(KEY_TEST_LONG, DEFAULT_LONG), equalTo(SYSTEM_LONG));
            assertThat("extractDouble", cu.extractDouble(KEY_TEST_DOUBLE, DEFAULT_DOUBLE), equalTo(SYSTEM_DOUBLE));
            assertThat("extractString", cu.extractString(KEY_TEST_STRING, DEFAULT_STRING), equalTo(SYSTEM_STRING));
            assertThat("extractPeriodAsMillis", cu.extractPeriodAsMillis(KEY_TEST_PERIOD, DEFAULT_PERIOD_MS), equalTo(SYSTEM_PERIOD_MS));
        } finally {
            clearSystemProperties();
        }
    }
    
    @Test
    public void testExtractValid_ConfigProperties_NoSystemProperties() {
        
        PropertyUtil cu = new PropertyUtil(getValidMockProperties(true));
        
        System.out.println("Verify config property values are used if system aren't present");
        assertThat("extractBoolean", cu.extractBoolean(KEY_TEST_BOOLEAN, DEFAULT_BOOLEAN), equalTo(CONFIG_BOOLEAN));
        assertThat("extractLong", cu.extractLong(KEY_TEST_LONG, DEFAULT_LONG), equalTo(CONFIG_LONG));
        assertThat("extractDouble", cu.extractDouble(KEY_TEST_DOUBLE, DEFAULT_DOUBLE), equalTo(CONFIG_DOUBLE));
        assertThat("extractString", cu.extractString(KEY_TEST_STRING, DEFAULT_STRING), equalTo(CONFIG_STRING));
        assertThat("extractPeriodAsMillis", cu.extractPeriodAsMillis(KEY_TEST_PERIOD, DEFAULT_PERIOD_MS), equalTo(CONFIG_PERIOD_MS));
        
    }
    
    @Test
    public void testExtractValid_ConfigPropertiesInactive_NoSystemProperties() {
        
        PropertyUtil cu = new PropertyUtil(getValidMockProperties(false));
        
        System.out.println("Verify config property values ignored when inactive (defaults are used in absense of system properties)");
        assertThat("extractBoolean", cu.extractBoolean(KEY_TEST_BOOLEAN, DEFAULT_BOOLEAN), equalTo(DEFAULT_BOOLEAN));
        assertThat("extractLong", cu.extractLong(KEY_TEST_LONG, DEFAULT_LONG), equalTo(DEFAULT_LONG));
        assertThat("extractDouble", cu.extractDouble(KEY_TEST_DOUBLE, DEFAULT_DOUBLE), equalTo(DEFAULT_DOUBLE));
        assertThat("extractString", cu.extractString(KEY_TEST_STRING, DEFAULT_STRING), equalTo(DEFAULT_STRING));
        assertThat("extractPeriodAsMillis", cu.extractPeriodAsMillis(KEY_TEST_PERIOD, DEFAULT_PERIOD_MS), equalTo(DEFAULT_PERIOD_MS));
        
    }
    
    private Property[] getValidMockProperties(final boolean active) {
        
        context.checking(new Expectations() {{
            allowing (properties[0]).getName(); will(returnValue(KEY_TEST_BOOLEAN));
            allowing (properties[0]).getActive(); will(returnValue(active));
            allowing (properties[0]).getStringValue(); will(returnValue(Boolean.toString(CONFIG_BOOLEAN)));
            
            allowing (properties[1]).getName(); will(returnValue(KEY_TEST_LONG));
            allowing (properties[1]).getActive(); will(returnValue(active));
            allowing (properties[1]).getStringValue(); will(returnValue(Long.toString(CONFIG_LONG)));
            
            allowing (properties[2]).getName(); will(returnValue(KEY_TEST_DOUBLE));
            allowing (properties[2]).getActive(); will(returnValue(active));
            allowing (properties[2]).getStringValue(); will(returnValue(Double.toString(CONFIG_DOUBLE)));
            
            allowing (properties[3]).getName(); will(returnValue(KEY_TEST_STRING));
            allowing (properties[3]).getActive(); will(returnValue(active));
            allowing (properties[3]).getStringValue(); will(returnValue(CONFIG_STRING));
            
            allowing (properties[4]).getName(); will(returnValue(KEY_TEST_PERIOD));
            allowing (properties[4]).getActive(); will(returnValue(active));
            allowing (properties[4]).getStringValue(); will(returnValue(CONFIG_PERIOD));
        }});
        
        return properties;
    }
    
    private void setValidSystemProperties() {
        Joiner dot = Joiner.on('.');
        System.setProperty(dot.join(KEY_TEST_ROOT, KEY_TEST_BOOLEAN), Boolean.toString(SYSTEM_BOOLEAN));
        System.setProperty(dot.join(KEY_TEST_ROOT, KEY_TEST_LONG), Long.toString(SYSTEM_LONG));
        System.setProperty(dot.join(KEY_TEST_ROOT, KEY_TEST_DOUBLE), Double.toString(SYSTEM_DOUBLE));
        System.setProperty(dot.join(KEY_TEST_ROOT, KEY_TEST_STRING), SYSTEM_STRING);
        System.setProperty(dot.join(KEY_TEST_ROOT, KEY_TEST_PERIOD), SYSTEM_PERIOD);
    }
    
    private void clearSystemProperties() {
        Joiner dot = Joiner.on('.');
        System.clearProperty(dot.join(KEY_TEST_ROOT, KEY_TEST_BOOLEAN));
        System.clearProperty(dot.join(KEY_TEST_ROOT, KEY_TEST_LONG));
        System.clearProperty(dot.join(KEY_TEST_ROOT, KEY_TEST_DOUBLE));
        System.clearProperty(dot.join(KEY_TEST_ROOT, KEY_TEST_STRING));
        System.clearProperty(dot.join(KEY_TEST_ROOT, KEY_TEST_PERIOD));
    }
    
}