package com.atlassian.vcache.internal.core;
   
   import com.atlassian.vcache.internal.BegunTransactionalActivityHandler;
   import com.atlassian.vcache.internal.core.metrics.NoopMetricsCollector;
   import org.junit.Before;
   import org.junit.Test;
   import org.junit.runner.RunWith;
   import org.mockito.InjectMocks;
   import org.mockito.Mock;
  import org.mockito.runners.MockitoJUnitRunner;
  
  import java.util.Set;
  
  import static org.hamcrest.Matchers.contains;
  import static org.hamcrest.Matchers.empty;
  import static org.junit.Assert.assertThat;
  import static org.mockito.Matchers.anyString;
  import static org.mockito.Matchers.eq;
  import static org.mockito.Mockito.times;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.when;
  
  @RunWith(MockitoJUnitRunner.class)
  public class DefaultTransactionControlManagerTest {
      @InjectMocks
      private DefaultTransactionControlManager transactionControlManager;
  
      @Mock
      private Instrumentor instrumentor = new NoopMetricsCollector();
  
      @Mock
      private BegunTransactionalActivityHandler activityHandler;
  
      @Mock
      private TransactionControl transactionControl;
  
      @Mock
      private TransactionControl wrappedTransactionControl;
  
      private final DefaultRequestContext requestContext = new DefaultRequestContext("pid");
  
      @Before
      public void setUp() {
          when(instrumentor.wrap(eq(transactionControl), anyString())).thenReturn(wrappedTransactionControl);
          when(wrappedTransactionControl.transactionDiscard()).thenReturn(true);
      }
  
      @Test
      public void repeatedRegistrationOfSameCacheOnlyInvokesCallbackOnce() {
          transactionControlManager.registerTransactionalExternalCache(requestContext, "mycache", transactionControl);
          transactionControlManager.registerTransactionalExternalCache(requestContext, "mycache", transactionControl);
  
          verify(activityHandler, times(1)).onRequest(requestContext);
      }
  
      @Test
      public void repeatedRegistrationOfDifferentCachesOnlyInvokesCallbackOnce() {
          transactionControlManager.registerTransactionalExternalCache(requestContext, "cache1", transactionControl);
          transactionControlManager.registerTransactionalExternalCache(requestContext, "cache2", transactionControl);
  
          verify(activityHandler, times(1)).onRequest(requestContext);
      }
  
      @Test
      public void syncAllWithNoRegistrationsDoesNothing() {
          transactionControlManager.syncAll(requestContext);
      }
  
      @Test
      public void syncAllInvokesTransactionControlOncePerCacheAndClearsCallbackFlag() {
          transactionControlManager.registerTransactionalExternalCache(requestContext, "mycache", transactionControl);
          transactionControlManager.registerTransactionalExternalCache(requestContext, "mycache", transactionControl);
  
          verify(activityHandler, times(1)).onRequest(requestContext);
  
          // sync should reset the callback flag
          transactionControlManager.syncAll(requestContext);
  
          // now re-register the same cache and make sure the callback is invoked once more
          transactionControlManager.registerTransactionalExternalCache(requestContext, "mycache", transactionControl);
  
          verify(activityHandler, times(2)).onRequest(requestContext);
      }
  
      @Test
      public void discardAllWithNoRegistrationsDoesNothing() {
          final Set<String> discardedCaches = transactionControlManager.discardAll(requestContext);
  
          assertThat(discardedCaches, empty());
      }
  
      @Test
      public void discardAllInvokesTransactionControlOncePerCacheAndClearsCallbackFlag() {
          transactionControlManager.registerTransactionalExternalCache(requestContext, "mycache", transactionControl);
          transactionControlManager.registerTransactionalExternalCache(requestContext, "mycache", transactionControl);
  
          verify(activityHandler, times(1)).onRequest(requestContext);
  
          // discard should reset the callback flag
         final Set<String> discardedCaches = transactionControlManager.discardAll(requestContext);
 
         assertThat(discardedCaches, contains("mycache"));
 
         // now re-register the same cache and make sure the callback is invoked once more
         transactionControlManager.registerTransactionalExternalCache(requestContext, "mycache", transactionControl);
 
         verify(activityHandler, times(2)).onRequest(requestContext);
     }
 
     @Test
     public void discardAllReturnsNoCachenamesIfAllCacheshaveBeenSynchronized() {
         transactionControlManager.registerTransactionalExternalCache(requestContext, "mycache", transactionControl);
 
         transactionControlManager.syncAll(requestContext);
 
         when(wrappedTransactionControl.transactionDiscard()).thenReturn(false);
 
         final Set<String> discardedCaches = transactionControlManager.discardAll(requestContext);
 
         assertThat(discardedCaches, empty());
     }
 
     @Test
     public void discardAllReturnsNoCachenamesIfAlreadyDiscarded() {
         transactionControlManager.registerTransactionalExternalCache(requestContext, "mycache", transactionControl);
 
         final Set<String> discardedCaches = transactionControlManager.discardAll(requestContext);
 
         assertThat(discardedCaches, contains("mycache"));
 
         when(wrappedTransactionControl.transactionDiscard()).thenReturn(false);
 
         final Set<String> discardedCaches2 = transactionControlManager.discardAll(requestContext);
 
         assertThat(discardedCaches2, empty());
     }
 }