package com.atlassian.plugin.manager;
   
   import com.atlassian.plugin.manager.StateTracker.State;
   
   import org.junit.After;
   import org.junit.Before;
   import org.junit.Test;
   import org.junit.runner.RunWith;
   import org.mockito.runners.MockitoJUnitRunner;
  
  import static com.atlassian.plugin.manager.StateTracker.State.DELAYED;
  import static com.atlassian.plugin.manager.StateTracker.State.NOT_STARTED;
  import static com.atlassian.plugin.manager.StateTracker.State.RESUMING;
  import static com.atlassian.plugin.manager.StateTracker.State.SHUTDOWN;
  import static com.atlassian.plugin.manager.StateTracker.State.SHUTTING_DOWN;
  import static com.atlassian.plugin.manager.StateTracker.State.STARTED;
  import static com.atlassian.plugin.manager.StateTracker.State.STARTING;
  import static com.atlassian.plugin.manager.StateTracker.State.WARM_RESTARTING;
  
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.core.Is.is;
  import static org.junit.Assert.fail;
  
  
  @RunWith (MockitoJUnitRunner.class)
  public class TestStateTracker
  {
      private StateTracker stateTracker;
  
      @Before
      public void setup()
      {
          stateTracker = new StateTracker();
      }
  
      @After
      public void tearDown()
      {
          stateTracker = null;
      }
  
      @Test
      public void testStandardTransitions() throws Exception
      {
          assertThat(stateTracker.get(), is(NOT_STARTED));
          // The standardTransitions is one loop of the path StateTracker usually runs through.
          // This is not just State.values() - it omits the start point NOT_STARTED, and also
          // WARM_RESTARTING which is tested independently later.
          final State[] standardTransitions = { STARTING, DELAYED, RESUMING, STARTED, SHUTTING_DOWN, SHUTDOWN, STARTING };
          for(final State state : standardTransitions)
          {
              stateTracker.setState(state);
              assertThat(stateTracker.get(), is(state));
          }
      }
  
      private void performStateSequence(final State... desiredStates)
      {
          for(final State state : desiredStates)
          {
              stateTracker.setState(state);
          }
      }
  
      @Test
      public void testIllegalNotStartedTransitions() throws Exception
      {
          performStateSequence();
          validateIllegalStates(NOT_STARTED, DELAYED, RESUMING, STARTED, WARM_RESTARTING, SHUTDOWN);
      }
  
      @Test
      public void testIllegalStartingTransitions() throws Exception
      {
          performStateSequence(STARTING);
          validateIllegalStates(NOT_STARTED, STARTING, RESUMING, STARTED, WARM_RESTARTING, SHUTTING_DOWN, SHUTDOWN);
      }
  
      @Test
      public void testIllegalDelayedTransitions() throws Exception
      {
          performStateSequence(STARTING, DELAYED);
          validateIllegalStates(NOT_STARTED, STARTING, DELAYED, STARTED, WARM_RESTARTING, SHUTTING_DOWN, SHUTDOWN);
      }
  
      @Test
      public void testIllegalResumingTransitions() throws Exception
      {
          performStateSequence(STARTING, DELAYED, RESUMING);
          validateIllegalStates(NOT_STARTED, STARTING, DELAYED, RESUMING, WARM_RESTARTING, SHUTTING_DOWN, SHUTDOWN);
      }
  
      @Test
      public void testIllegalStartedTransitions() throws Exception
      {
          performStateSequence(STARTING, DELAYED, RESUMING, STARTED);
          validateIllegalStates(NOT_STARTED, STARTING, DELAYED, RESUMING, STARTED, SHUTDOWN);
      }
  
     @Test
     public void testIllegalWarmRestartingTransitions() throws Exception
     {
         performStateSequence(STARTING, DELAYED, RESUMING, STARTED, WARM_RESTARTING);
         validateIllegalStates(NOT_STARTED, STARTING, DELAYED, RESUMING, WARM_RESTARTING, SHUTTING_DOWN, SHUTDOWN);
     }
 
     @Test
     public void testIllegalWarmRestartTransitions() throws Exception
     {
         performStateSequence(STARTING, DELAYED, RESUMING, STARTED, WARM_RESTARTING, STARTED);
         validateIllegalStates(NOT_STARTED, STARTING, DELAYED, RESUMING, STARTED, SHUTDOWN);
     }
 
     @Test
     public void testIllegalShuttingDownTransitions() throws Exception
     {
         performStateSequence(STARTING, DELAYED, RESUMING, STARTED, SHUTTING_DOWN);
         validateIllegalStates(NOT_STARTED, STARTING, DELAYED, RESUMING, STARTED, WARM_RESTARTING, SHUTTING_DOWN);
     }
 
     @Test
     public void testIllegalShutdownTransitions() throws Exception
     {
         performStateSequence(STARTING, DELAYED, RESUMING, STARTED, SHUTTING_DOWN, SHUTDOWN);
         validateIllegalStates(NOT_STARTED, DELAYED, RESUMING, STARTED, WARM_RESTARTING, SHUTTING_DOWN, SHUTDOWN);
     }
 
     private void validateIllegalStates(final State... illegalStates)
     {
         final State initialState = stateTracker.get();
         for (final State illegalState : illegalStates)
         {
             try
             {
                 stateTracker.setState(illegalState);
                 fail(initialState + " should not be allowed to transition to: " + illegalState);
             }
             catch (final IllegalStateException expected)
             {
                 assertThat(stateTracker.get(), is(initialState));
             }
         }
     }
 }