package com.atlassian.sal.core.rdbms;
   
   import com.atlassian.sal.api.rdbms.ConnectionCallback;
   import com.atlassian.sal.spi.HostConnectionAccessor;
   import org.junit.Before;
   import org.junit.Rule;
   import org.junit.Test;
   import org.junit.rules.ExpectedException;
   import org.junit.runner.RunWith;
  import org.mockito.Mock;
  import org.mockito.invocation.InvocationOnMock;
  import org.mockito.runners.MockitoJUnitRunner;
  import org.mockito.stubbing.Answer;
  
  import java.sql.Connection;
  import java.sql.SQLException;
  
  import static org.hamcrest.Matchers.nullValue;
  import static org.hamcrest.core.Is.is;
  import static org.junit.Assert.assertThat;
  import static org.mockito.Matchers.any;
  import static org.mockito.Mockito.doThrow;
  import static org.mockito.Mockito.never;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.when;
  
  @RunWith (MockitoJUnitRunner.class)
  public class TestDefaultTransactionalExecutor
  {
      @Rule
      public ExpectedException expectedException = ExpectedException.none();
  
      private DefaultTransactionalExecutor defaultTransactionalExecutor;
  
      @Mock
      private HostConnectionAccessor hostConnectionAccessor;
      @Mock
      private Connection connection;
      @Mock
      private ConnectionCallback<Object> callback;
      @Mock
      private Object result;
  
      private WrappedConnection wrappedConnection;
  
      private boolean callbackThrows;
  
      @Before
      public void before()
      {
          defaultTransactionalExecutor = new DefaultTransactionalExecutor(hostConnectionAccessor, false, false);
  
          callbackThrows = false;
  
          // grab a hold of the wrapped connection each time
          when(callback.execute(any(WrappedConnection.class))).thenAnswer(new Answer<Object>()
          {
              @Override
              public Object answer(final InvocationOnMock invocation) throws Throwable
              {
                  wrappedConnection = (WrappedConnection) invocation.getArguments()[0];
                  if (callbackThrows)
                  {
                      throw new RuntimeException("epic fail");
                  }
                  else
                  {
                      return result;
                  }
              }
          });
      }
  
      @Test
      public void changeProperties()
      {
          defaultTransactionalExecutor.readOnly();
          assertThat(defaultTransactionalExecutor.readOnly, is(true));
  
          defaultTransactionalExecutor.readWrite();
          assertThat(defaultTransactionalExecutor.readOnly, is(false));
  
          defaultTransactionalExecutor.newTransaction();
          assertThat(defaultTransactionalExecutor.newTransaction, is(true));
  
          defaultTransactionalExecutor.existingTransaction();
          assertThat(defaultTransactionalExecutor.newTransaction, is(false));
      }
  
      @Test
      public void executeCommitSucceeds() throws SQLException
      {
          callbackThrows = false;
  
          assertThat(defaultTransactionalExecutor.executeInternal(connection, callback), is(result));
          assertThat(wrappedConnection.connection, nullValue());
  
          verify(callback).execute(any(WrappedConnection.class));
          verify(connection).commit();
         verify(connection, never()).rollback();
     }
 
     @Test
     public void executeCommitFails() throws SQLException
     {
         callbackThrows = false;
 
         doThrow(new SQLException("horrible commit exception")).when(connection).commit();
 
         expectedException.expect(RuntimeException.class);
         expectedException.expectCause(is(SQLException.class));
 
         defaultTransactionalExecutor.executeInternal(connection, callback);
         assertThat(wrappedConnection.connection, nullValue());
 
         verify(callback).execute(any(WrappedConnection.class));
         verify(connection).commit();
         verify(connection, never()).rollback();
     }
 
     @Test
     public void executeRollbackSucceeds() throws SQLException
     {
         callbackThrows = true;
 
         expectedException.expect(RuntimeException.class);
         expectedException.expectMessage("epic fail");
 
         defaultTransactionalExecutor.executeInternal(connection, callback);
         assertThat(wrappedConnection.connection, nullValue());
 
         verify(callback).execute(any(WrappedConnection.class));
         verify(connection, never()).commit();
         verify(connection).rollback();
     }
 
     @Test
     public void executeRollbackFails() throws SQLException
     {
         callbackThrows = true;
 
         doThrow(new SQLException("horrible rollback exception")).when(connection).rollback();
 
         expectedException.expect(RuntimeException.class);
         expectedException.expectMessage("epic fail");
 
         defaultTransactionalExecutor.executeInternal(connection, callback);
         assertThat(wrappedConnection.connection, nullValue());
 
         verify(callback).execute(any(WrappedConnection.class));
         verify(connection, never()).commit();
         verify(connection).rollback();
     }
 
     @Test
     public void executeFailsOnAutoCommit() throws SQLException
     {
         when(connection.getAutoCommit()).thenReturn(true);
 
         expectedException.expect(IllegalStateException.class);
 
         defaultTransactionalExecutor.executeInternal(connection, callback);
     }
 
     @Test
     public void executeFailsOnAutoCommitGetFail() throws SQLException
     {
         when(connection.getAutoCommit()).thenThrow(new SQLException("horrible getAutoCommit exception"));
 
         expectedException.expect(RuntimeException.class);
 
         defaultTransactionalExecutor.executeInternal(connection, callback);
     }
 }