/*
    * Copyright 2012-2013 smartics, Kronseder & Reiner 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 test.de.smartics.properties.spi.config.ds;
  
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.equalTo;
  import static org.hamcrest.Matchers.is;
  import static org.mockito.Mockito.atLeast;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.when;
  
  import java.sql.Connection;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.util.Iterator;
  import java.util.NoSuchElementException;
  
  import org.junit.After;
  import org.junit.Before;
  import org.junit.Test;
  import org.junit.experimental.categories.Category;
  
  import de.smartics.properties.api.config.domain.Property;
  import de.smartics.properties.api.config.domain.PropertyLocation;
  import de.smartics.properties.spi.config.ds.DsPropertyCollection;
  import de.smartics.testdoc.annotations.Uut;
  import de.smartics.testdoc.categories.Technical;
  
  /**
   * Tests {@link DsPropertyCollection}.
   */
  @Uut(type = DsPropertyCollection.class)
  public class DsPropertyCollectionTest
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    private static final String DATA_SOURCE_ID = "test-ds";
  
    private static final PropertyLocation TEST_SOURCE = new PropertyLocation(
        DATA_SOURCE_ID);
  
    // --- members --------------------------------------------------------------
  
    private Connection connection;
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- prepare --------------------------------------------------------------
  
    @Before
    public void setUp()
    {
      connection = mock(Connection.class);
    }
  
    @After
    public void tearDown() throws Exception
    {
      verify(connection, atLeast(1)).close();
    }
  
    // --- helper ---------------------------------------------------------------
  
    // --- tests ----------------------------------------------------------------
  
    @Test(expected = NoSuchElementException.class)
    public void signalsEmptyIterationIfResultSetProvidesNoHits()
      throws SQLException
    {
      final ResultSet resultSet = mock(ResultSet.class);
      when(resultSet.next()).thenReturn(false);
  
      final DsPropertyCollection uut =
          new DsPropertyCollection(DATA_SOURCE_ID, connection, resultSet);
      final Iterator<Property> i = uut.iterator();
      assertThat(i.hasNext(), is(false));
      i.next();
    }
  
    @Category(Technical.class)
    @Test
   public void allowsToCheckForMoreElementsAnyNumberOfTimes()
     throws SQLException
   {
     final Property expectedProperty = new Property(TEST_SOURCE, "key", "value"); // NOPMD
 
     final ResultSet resultSet = mock(ResultSet.class);
     when(resultSet.next()).thenReturn(true, false);
     when(resultSet.getString(1)).thenReturn(expectedProperty.getName());
     when(resultSet.getString(2)).thenReturn(expectedProperty.getValue());
 
     final DsPropertyCollection uut =
         new DsPropertyCollection(DATA_SOURCE_ID, connection, resultSet);
     final Iterator<Property> i = uut.iterator();
     assertThat(i.hasNext(), is(true));
     assertThat(i.hasNext(), is(true));
 
     uut.close();
   }
 
   @Category(Technical.class)
   @Test(expected = NoSuchElementException.class)
   public void allowsToIterateOverOneProperty() throws SQLException
   {
     final Property expectedProperty = new Property(TEST_SOURCE, "key", "value");
 
     final ResultSet resultSet = mock(ResultSet.class);
     when(resultSet.next()).thenReturn(true, false);
     when(resultSet.getString(1)).thenReturn(expectedProperty.getName());
     when(resultSet.getString(2)).thenReturn(expectedProperty.getValue());
 
     final DsPropertyCollection uut =
         new DsPropertyCollection(DATA_SOURCE_ID, connection, resultSet);
     final Iterator<Property> i = uut.iterator();
     assertThat(i.hasNext(), is(true));
     final Property property = i.next();
     assertThat(property, is(equalTo(expectedProperty)));
 
     assertThat(i.hasNext(), is(false));
     i.next();
   }
 
   @Test(expected = NoSuchElementException.class)
   public void allowsToIterateOverProperties() throws SQLException
   {
     final Property expectedProperty1 =
         new Property(TEST_SOURCE, "key1", "value1");
     final Property expectedProperty2 =
         new Property(TEST_SOURCE, "key2", "value2");
     final Property expectedProperty3 =
         new Property(TEST_SOURCE, "key3", "value3");
 
     final ResultSet resultSet = mock(ResultSet.class);
     when(resultSet.next()).thenReturn(true, true, true, false);
     when(resultSet.getString(1)).thenReturn(expectedProperty1.getName(),
         expectedProperty2.getName(), expectedProperty3.getName());
     when(resultSet.getString(2)).thenReturn(expectedProperty1.getValue(),
         expectedProperty2.getValue(), expectedProperty3.getValue());
 
     final DsPropertyCollection uut =
         new DsPropertyCollection(DATA_SOURCE_ID, connection, resultSet);
     final Iterator<Property> i = uut.iterator();
     assertThat(i.hasNext(), is(true));
     assertThat(i.next(), is(equalTo(expectedProperty1)));
     assertThat(i.hasNext(), is(true));
     assertThat(i.next(), is(equalTo(expectedProperty2)));
     assertThat(i.hasNext(), is(true));
     assertThat(i.next(), is(equalTo(expectedProperty3)));
 
     assertThat(i.hasNext(), is(false));
     i.next();
   }
 
   @Test(expected = UnsupportedOperationException.class)
   public void removingFromTheIteratorIsNotSupported() throws SQLException
   {
     final Property expectedProperty = new Property(TEST_SOURCE, "key", "value");
 
     final ResultSet resultSet = mock(ResultSet.class);
     when(resultSet.next()).thenReturn(true, false);
     when(resultSet.getString(1)).thenReturn(expectedProperty.getName());
     when(resultSet.getString(2)).thenReturn(expectedProperty.getValue());
 
     final DsPropertyCollection uut =
         new DsPropertyCollection(DATA_SOURCE_ID, connection, resultSet);
     try
     {
       final Iterator<Property> i = uut.iterator();
       i.remove();
     }
     finally
     {
       uut.close();
     }
   }
 
   @Category(Technical.class)
   @Test(expected = IllegalStateException.class)
   public void signalsUnderlyingProblemsWithAnIllegalStateException()
     throws SQLException
   {
     final Property expectedProperty = new Property(TEST_SOURCE, "key", "value");
 
     final ResultSet resultSet = mock(ResultSet.class);
     when(resultSet.next()).thenReturn(true, false);
     when(resultSet.getString(1)).thenThrow(new SQLException("Saboteur!"));
     when(resultSet.getString(2)).thenReturn(expectedProperty.getValue());
 
     final DsPropertyCollection uut =
         new DsPropertyCollection(DATA_SOURCE_ID, connection, resultSet);
     final Iterator<Property> i = uut.iterator();
     i.hasNext();
   }
 }