/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.apache.commons.configuration2;

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

import javax.sql.DataSource;
import java.sql.Clob;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.List;

import org.apache.commons.configuration2.builder.fluent.DatabaseBuilderParameters;
import org.apache.commons.configuration2.convert.DefaultListDelimiterHandler;
import org.apache.commons.configuration2.event.ConfigurationErrorEvent;
import org.apache.commons.configuration2.event.ConfigurationEvent;
import org.apache.commons.configuration2.event.ErrorListenerTestImpl;
import org.apache.commons.configuration2.event.EventType;
import org.apache.commons.configuration2.ex.ConfigurationException;
import org.easymock.EasyMock;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * Test for database stored configurations.  Note, when running this Unit
 * Test in Eclipse it sometimes takes a couple tries. Otherwise you may get
 * database is already in use by another process errors.
 *
 * @version $Id: TestDatabaseConfiguration.java 1624601 2014-09-12 18:04:36Z oheger $
 */
public class TestDatabaseConfiguration
{
    /** Constant for another configuration name. */
    private static final String CONFIG_NAME2 = "anotherTestConfig";

    /** An error listener for testing whether internal errors occurred.*/
    private ErrorListenerTestImpl listener;

    /** The test helper. */
    private DatabaseConfigurationTestHelper helper;

    @Before
    public void setUp() throws Exception
    {
        /*
         * Thread.sleep may or may not help with the database is already in
         * use exception.
         */
        //Thread.sleep(1000);

        // set up the datasource

        helper = new DatabaseConfigurationTestHelper();
        helper.setUp();
    }

    @After
    public void tearDown() throws Exception
    {
        // if an error listener is defined, we check whether an error occurred
        if(listener != null)
        {
            listener.done();
        }
        helper.tearDown();
    }

    /**
     * Creates a database configuration with default values.
     *
     * @return the configuration
     * @throws ConfigurationException if an error occurs
     */
    private PotentialErrorDatabaseConfiguration setUpConfig()
            throws ConfigurationException
    {
        return helper.setUpConfig(PotentialErrorDatabaseConfiguration.class);
    }

    /**
     * Creates an error listener and adds it to the specified configuration.
     *
     * @param config the configuration
     */
    private void setUpErrorListener(PotentialErrorDatabaseConfiguration config)
    {
        // remove log listener to avoid exception longs
        config.clearErrorListeners();
        listener = new ErrorListenerTestImpl(config);
        config.addEventListener(ConfigurationErrorEvent.ANY, listener);
        config.failOnConnect = true;
    }

    /**
     * Prepares a test for a database error. Sets up a config and registers an
     * error listener.
     *
     * @return the initialized configuration
     * @throws ConfigurationException if an error occurs
     */
    private PotentialErrorDatabaseConfiguration setUpErrorConfig()
            throws ConfigurationException
    {
        PotentialErrorDatabaseConfiguration config = setUpConfig();
        setUpErrorListener(config);
        return config;
    }

    /**
     * Checks the error listener for an expected error. The properties of the
     * error event will be compared with the expected values.
     *
     * @param type the expected type of the error event
     * @param opType the expected operation type
     * @param key the expected property key
     * @param value the expected property value
     */
    private void checkErrorListener(
            EventType<? extends ConfigurationErrorEvent> type,
            EventType<?> opType, String key, Object value)
    {
        Throwable exception = listener.checkEvent(type, opType, key, value);
        assertTrue("Wrong exception", exception instanceof SQLException);
        listener = null; // mark as checked
    }

    @Test
    public void testAddPropertyDirectSingle() throws ConfigurationException
    {
        DatabaseConfiguration config = helper.setUpConfig();
        config.addPropertyDirect("key", "value");

        assertTrue("missing property", config.containsKey("key"));
    }

    /**
     * Tests whether a commit is performed after a property was added.
     */
    @Test
    public void testAddPropertyDirectCommit() throws ConfigurationException
    {
        helper.setAutoCommit(false);
        DatabaseConfiguration config = helper.setUpConfig();
        config.addPropertyDirect("key", "value");
        assertTrue("missing property", config.containsKey("key"));
    }

    @Test
    public void testAddPropertyDirectMultiple() throws ConfigurationException
    {
        DatabaseConfiguration config = helper.setUpMultiConfig();
        config.addPropertyDirect("key", "value");

        assertTrue("missing property", config.containsKey("key"));
    }

    @Test
    public void testAddNonStringProperty() throws ConfigurationException
    {
        DatabaseConfiguration config = helper.setUpConfig();
        config.addPropertyDirect("boolean", Boolean.TRUE);

        assertTrue("missing property", config.containsKey("boolean"));
    }

    @Test
    public void testGetPropertyDirectSingle() throws ConfigurationException
    {
        Configuration config = setUpConfig();

        assertEquals("property1", "value1", config.getProperty("key1"));
        assertEquals("property2", "value2", config.getProperty("key2"));
        assertEquals("unknown property", null, config.getProperty("key3"));
    }

    @Test
    public void testGetPropertyDirectMultiple() throws ConfigurationException
    {
        Configuration config = helper.setUpMultiConfig();

        assertEquals("property1", "value1", config.getProperty("key1"));
        assertEquals("property2", "value2", config.getProperty("key2"));
        assertEquals("unknown property", null, config.getProperty("key3"));
    }

    @Test
    public void testClearPropertySingle() throws ConfigurationException
    {
        Configuration config = helper.setUpConfig();
        config.clearProperty("key1");

        assertFalse("property not cleared", config.containsKey("key1"));
    }

    @Test
    public void testClearPropertyMultiple() throws ConfigurationException
    {
        Configuration config = helper.setUpMultiConfig();
        config.clearProperty("key1");

        assertFalse("property not cleared", config.containsKey("key1"));
    }

    /**
     * Tests that another configuration is not affected when clearing
     * properties.
     */
    @Test
    public void testClearPropertyMultipleOtherConfig() throws ConfigurationException
    {
        DatabaseConfiguration config = helper.setUpMultiConfig();
        DatabaseConfiguration config2 =
                helper.setUpMultiConfig(DatabaseConfiguration.class,
                        CONFIG_NAME2);
        config2.addProperty("key1", "some test");
        config.clearProperty("key1");
        assertFalse("property not cleared", config.containsKey("key1"));
        assertTrue("Property cleared in other config", config2
                .containsKey("key1"));
    }

    /**
     * Tests whether a commit is performed after a property was cleared.
     */
    @Test
    public void testClearPropertyCommit() throws ConfigurationException
    {
        helper.setAutoCommit(false);
        Configuration config = helper.setUpConfig();
        config.clearProperty("key1");
        assertFalse("property not cleared", config.containsKey("key1"));
    }

    @Test
    public void testClearSingle() throws ConfigurationException
    {
        Configuration config = helper.setUpConfig();
        config.clear();

        assertTrue("configuration is not cleared", config.isEmpty());
    }

    @Test
    public void testClearMultiple() throws ConfigurationException
    {
        Configuration config = helper.setUpMultiConfig();
        config.clear();

        assertTrue("configuration is not cleared", config.isEmpty());
    }

    /**
     * Tests whether a commit is performed after a clear operation.
     */
    @Test
    public void testClearCommit() throws ConfigurationException
    {
        helper.setAutoCommit(false);
        Configuration config = helper.setUpConfig();
        config.clear();
        assertTrue("configuration is not cleared", config.isEmpty());
    }

    @Test
    public void testGetKeysSingle() throws ConfigurationException
    {
        Configuration config = setUpConfig();
        Iterator<String> it = config.getKeys();

        assertEquals("1st key", "key1", it.next());
        assertEquals("2nd key", "key2", it.next());
    }

    @Test
    public void testGetKeysMultiple() throws ConfigurationException
    {
        Configuration config = helper.setUpMultiConfig();
        Iterator<String> it = config.getKeys();

        assertEquals("1st key", "key1", it.next());
        assertEquals("2nd key", "key2", it.next());
    }

    @Test
    public void testContainsKeySingle() throws ConfigurationException
    {
        Configuration config = setUpConfig();
        assertTrue("missing key1", config.containsKey("key1"));
        assertTrue("missing key2", config.containsKey("key2"));
    }

    @Test
    public void testContainsKeyMultiple() throws ConfigurationException
    {
        Configuration config = helper.setUpMultiConfig();
        assertTrue("missing key1", config.containsKey("key1"));
        assertTrue("missing key2", config.containsKey("key2"));
    }

    @Test
    public void testIsEmptySingle() throws ConfigurationException
    {
        Configuration config1 = setUpConfig();
        assertFalse("The configuration is empty", config1.isEmpty());
    }

    @Test
    public void testIsEmptyMultiple() throws ConfigurationException
    {
        Configuration config1 = helper.setUpMultiConfig();
        assertFalse("The configuration named 'test' is empty", config1.isEmpty());

        Configuration config2 = helper.setUpMultiConfig(DatabaseConfiguration.class, "testIsEmpty");
        assertTrue("The configuration named 'testIsEmpty' is not empty", config2.isEmpty());
    }

    @Test
    public void testGetList() throws ConfigurationException
    {
        DatabaseBuilderParameters params = helper.setUpDefaultParameters().setTable("configurationList");
        Configuration config1 = helper.createConfig(DatabaseConfiguration.class, params);
        List<Object> list = config1.getList("key3");
        assertEquals(3,list.size());
    }

    @Test
    public void testGetKeys() throws ConfigurationException
    {
        DatabaseBuilderParameters params = helper.setUpDefaultParameters().setTable("configurationList");
        Configuration config1 = helper.createConfig(DatabaseConfiguration.class, params);
        Iterator<String> i = config1.getKeys();
        assertTrue(i.hasNext());
        Object key = i.next();
        assertEquals("key3",key.toString());
        assertFalse(i.hasNext());
    }

    @Test
    public void testClearSubset() throws ConfigurationException
    {
        Configuration config = setUpConfig();

        Configuration subset = config.subset("key1");
        subset.clear();

        assertTrue("the subset is not empty", subset.isEmpty());
        assertFalse("the parent configuration is empty", config.isEmpty());
    }

    /**
     * Tests whether the configuration has already an error listener registered
     * that is used for logging.
     */
    @Test
    public void testLogErrorListener() throws ConfigurationException
    {
        DatabaseConfiguration config = helper.setUpConfig();
        assertEquals("No error listener registered", 1, config
                .getEventListeners(ConfigurationErrorEvent.ANY).size());
    }

    /**
     * Tests handling of errors in getProperty().
     */
    @Test
    public void testGetPropertyError() throws ConfigurationException
    {
        setUpErrorConfig().getProperty("key1");
        checkErrorListener(ConfigurationErrorEvent.READ,
                ConfigurationErrorEvent.READ, "key1", null);
    }

    /**
     * Tests handling of errors in addPropertyDirect().
     */
    @Test
    public void testAddPropertyError() throws ConfigurationException
    {
        setUpErrorConfig().addProperty("key1", "value");
        checkErrorListener(ConfigurationErrorEvent.WRITE,
                ConfigurationEvent.ADD_PROPERTY, "key1", "value");
    }

    /**
     * Tests handling of errors in isEmpty().
     */
    @Test
    public void testIsEmptyError() throws ConfigurationException
    {
        assertTrue("Wrong return value for failure", setUpErrorConfig().isEmpty());
        checkErrorListener(ConfigurationErrorEvent.READ,
                ConfigurationErrorEvent.READ, null, null);
    }

    /**
     * Tests handling of errors in containsKey().
     */
    @Test
    public void testContainsKeyError() throws ConfigurationException
    {
        assertFalse("Wrong return value for failure", setUpErrorConfig().containsKey("key1"));
        checkErrorListener(ConfigurationErrorEvent.READ,
                ConfigurationErrorEvent.READ, "key1", null);
    }

    /**
     * Tests handling of errors in clearProperty().
     */
    @Test
    public void testClearPropertyError() throws ConfigurationException
    {
        setUpErrorConfig().clearProperty("key1");
        checkErrorListener(ConfigurationErrorEvent.WRITE,
                ConfigurationEvent.CLEAR_PROPERTY, "key1", null);
    }

    /**
     * Tests handling of errors in clear().
     */
    @Test
    public void testClearError() throws ConfigurationException
    {
        setUpErrorConfig().clear();
        checkErrorListener(ConfigurationErrorEvent.WRITE,
                ConfigurationEvent.CLEAR, null, null);
    }

    /**
     * Tests handling of errors in getKeys().
     */
    @Test
    public void testGetKeysError() throws ConfigurationException
    {
        Iterator<String> it = setUpErrorConfig().getKeys();
        checkErrorListener(ConfigurationErrorEvent.READ,
                ConfigurationErrorEvent.READ, null, null);
        assertFalse("Iteration is not empty", it.hasNext());
    }

    /**
     * Tests obtaining a property as list whose value contains the list
     * delimiter. Multiple values should be returned.
     */
    @Test
    public void testGetListWithDelimiter() throws ConfigurationException
    {
        DatabaseConfiguration config = setUpConfig();
        config.setListDelimiterHandler(new DefaultListDelimiterHandler(';'));
        List<Object> values = config.getList("keyMulti");
        assertEquals("Wrong number of list elements", 3, values.size());
        assertEquals("Wrong list element 0", "a", values.get(0));
        assertEquals("Wrong list element 2", "c", values.get(2));
    }

    /**
     * Tests obtaining a property whose value contains the list delimiter when
     * delimiter parsing is disabled.
     */
    @Test
    public void testGetListWithDelimiterParsingDisabled() throws ConfigurationException
    {
        DatabaseConfiguration config = setUpConfig();
        assertEquals("Wrong value of property", "a;b;c", config.getString("keyMulti"));
    }

    /**
     * Tests adding a property containing the list delimiter. When this property
     * is queried multiple values should be returned.
     */
    @Test
    public void testAddWithDelimiter() throws ConfigurationException
    {
        DatabaseConfiguration config = setUpConfig();
        config.setListDelimiterHandler(new DefaultListDelimiterHandler(';'));
        config.addProperty("keyList", "1;2;3");
        String[] values = config.getStringArray("keyList");
        assertEquals("Wrong number of property values", 3, values.length);
        assertEquals("Wrong value at index 1", "2", values[1]);
    }

    /**
     * Tests setProperty() if the property value contains the list delimiter.
     */
    @Test
    public void testSetPropertyWithDelimiter() throws ConfigurationException
    {
        DatabaseConfiguration config = helper.setUpMultiConfig();
        config.setListDelimiterHandler(new DefaultListDelimiterHandler(';'));
        config.setProperty("keyList", "1;2;3");
        String[] values = config.getStringArray("keyList");
        assertEquals("Wrong number of property values", 3, values.length);
        assertEquals("Wrong value at index 1", "2", values[1]);
    }

    /**
     * Tests whether a CLOB as a property value is handled correctly.
     */
    @Test
    public void testExtractPropertyValueCLOB() throws ConfigurationException,
            SQLException
    {
        ResultSet rs = EasyMock.createMock(ResultSet.class);
        Clob clob = EasyMock.createMock(Clob.class);
        final String content = "This is the content of the test CLOB!";
        EasyMock.expect(rs.getObject(DatabaseConfigurationTestHelper.COL_VALUE))
                .andReturn(clob);
        EasyMock.expect(clob.length())
                .andReturn(Long.valueOf(content.length()));
        EasyMock.expect(clob.getSubString(1, content.length())).andReturn(
                content);
        EasyMock.replay(rs, clob);
        DatabaseConfiguration config = helper.setUpConfig();
        assertEquals("Wrong extracted value", content,
                config.extractPropertyValue(rs));
        EasyMock.verify(rs, clob);
    }

    /**
     * Tests whether an empty CLOB is correctly handled by
     * extractPropertyValue().
     */
    @Test
    public void testExtractPropertyValueCLOBEmpty()
            throws ConfigurationException, SQLException
    {
        ResultSet rs = EasyMock.createMock(ResultSet.class);
        Clob clob = EasyMock.createMock(Clob.class);
        EasyMock.expect(rs.getObject(DatabaseConfigurationTestHelper.COL_VALUE))
                .andReturn(clob);
        EasyMock.expect(clob.length()).andReturn(0L);
        EasyMock.replay(rs, clob);
        DatabaseConfiguration config = helper.setUpConfig();
        assertEquals("Wrong extracted value", "",
                config.extractPropertyValue(rs));
        EasyMock.verify(rs, clob);
    }

    /**
     * A specialized database configuration implementation that can be
     * configured to throw an exception when obtaining a connection. This way
     * database exceptions can be simulated.
     */
    public static class PotentialErrorDatabaseConfiguration extends DatabaseConfiguration
    {
        /** A flag whether a getConnection() call should fail. */
        boolean failOnConnect;

        @Override
        public DataSource getDatasource()
        {
            if (failOnConnect)
            {
                DataSource ds = EasyMock.createMock(DataSource.class);
                try
                {
                    EasyMock.expect(ds.getConnection()).andThrow(
                            new SQLException("Simulated DB error"));
                }
                catch (SQLException e)
                {
                    // should not happen
                    throw new AssertionError("Unexpected exception!");
                }
                EasyMock.replay(ds);
                return ds;
            }
            return super.getDatasource();
        }
    }
}
