package com.atlassian.sal.core.features;
   
   import com.atlassian.fugue.Option;
   import com.atlassian.sal.api.features.EnabledDarkFeatures;
   import com.atlassian.sal.api.features.InvalidFeatureKeyException;
   import com.atlassian.sal.api.features.MissingPermissionException;
   import com.atlassian.sal.api.features.SiteDarkFeaturesStorage;
   import com.atlassian.sal.api.user.UserManager;
   import com.google.common.collect.ImmutableSet;
  import org.junit.Before;
  import org.junit.Rule;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.mockito.Mock;
  import org.mockito.runners.MockitoJUnitRunner;
  
  import java.security.Principal;
  
  import static org.hamcrest.Matchers.hasItem;
  import static org.hamcrest.Matchers.is;
  import static org.junit.Assert.assertFalse;
  import static org.junit.Assert.assertNull;
  import static org.junit.Assert.assertThat;
  import static org.junit.Assert.assertTrue;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.verifyNoMoreInteractions;
  import static org.mockito.Mockito.verifyZeroInteractions;
  import static org.mockito.Mockito.when;
  
  @RunWith(MockitoJUnitRunner.class)
  public class TestDefaultDarkFeatureManager
  {
      private static final String FEATURE_FOO = "foo";
      private static final String INVALID_FEATURE_KEY = "invalid feature key";
      private static final String USER_NAME = "foobar";
  
      @Rule public final ClearSystemPropertyRule systemPropertyRule = new ClearSystemPropertyRule();
      @Mock private UserManager userManager;
      @Mock private Principal user;
      @Mock private SiteDarkFeaturesStorage siteDarkFeaturesStorage;
  
      @Before
      public void setUp()
      {
          when(siteDarkFeaturesStorage.getEnabledDarkFeatures()).thenReturn(ImmutableSet.<String>of());
      }
  
      @Test
      public void systemFeatureEnabledForAllUsers()
      {
          enableDarkFeatureViaSystemProperty(FEATURE_FOO);
          assertTrue(createFeatureManager().isFeatureEnabledForAllUsers(FEATURE_FOO));
      }
  
      @Test
      public void systemFeatureNotEnabledForAllUsers()
      {
          assertNull(System.getProperty(FEATURE_FOO));
          assertFalse(createFeatureManager().isFeatureEnabledForAllUsers(FEATURE_FOO));
      }
  
      @Test
      public void invalidFeatureKeyIsNeverEnabledForAllUsers()
      {
          assertFalse(createFeatureManager().isFeatureEnabledForAllUsers(INVALID_FEATURE_KEY));
      }
  
      @Test
      public void systemFeatureEnabledForAnonymous()
      {
          enableDarkFeatureViaSystemProperty(FEATURE_FOO);
          final Option<Boolean> featureEnabledForUser = createFeatureManager().isFeatureEnabledForUser(null, FEATURE_FOO);
          assertThat(featureEnabledForUser, is(Option.some(true)));
      }
  
      @Test
      public void systemFeatureDisabledForAnonymous()
      {
          final Option<Boolean> featureEnabledForUser = createFeatureManager().isFeatureEnabledForUser(null, FEATURE_FOO);
          assertThat(featureEnabledForUser, is(Option.some(false)));
      }
  
      @Test
      public void systemFeatureEnabledForAuthenticatedUser()
      {
          enableDarkFeatureViaSystemProperty(FEATURE_FOO);
          givenUserResolved();
          final Option<Boolean> featureEnabledForUser = createFeatureManager().isFeatureEnabledForUser(USER_NAME, FEATURE_FOO);
          assertThat(featureEnabledForUser, is(Option.some(true)));
      }
  
      @Test
      public void systemFeatureDisabledForAuthenticatedUser()
      {
          givenUserResolved();
          final Option<Boolean> featureEnabledForUser = createFeatureManager().isFeatureEnabledForUser(USER_NAME, FEATURE_FOO);
          assertThat(featureEnabledForUser, is(Option.some(false)));
      }
  
     @Test
     public void featureUndefinedForInvalidUserName()
     {
         enableDarkFeatureViaSystemProperty(FEATURE_FOO);
         givenUserNotResolved();
         final Option<Boolean> featureEnabledForUser = createFeatureManager().isFeatureEnabledForUser(USER_NAME, FEATURE_FOO);
         assertThat(featureEnabledForUser, is(Option.<Boolean>none()));
     }
 
     @Test
     public void enableFeatureForAllUsersViaSystemProperty()
     {
         enableDarkFeatureViaSystemProperty(FEATURE_FOO);
         final EnabledDarkFeatures enabledDarkFeatures = createFeatureManager().getFeaturesEnabledForAllUsers();
         assertThat(enabledDarkFeatures.getFeatureKeys(), hasItem(FEATURE_FOO));
     }
 
     @Test
     public void enableFeatureForAllUsersDuringRuntime()
     {
         enableDarkFeatureForAllUsersDuringRuntime(FEATURE_FOO);
         final EnabledDarkFeatures enabledDarkFeatures = createFeatureManager().getFeaturesEnabledForAllUsers();
         assertThat(enabledDarkFeatures.getFeatureKeys(), hasItem(FEATURE_FOO));
     }
 
     @Test
     public void enabledFeaturesForAnonymous()
     {
         enableDarkFeatureForAllUsersDuringRuntime(FEATURE_FOO);
         final Option<EnabledDarkFeatures> enabledDarkFeatures = createFeatureManager().getFeaturesEnabledForUser(null);
         assertTrue(enabledDarkFeatures.isDefined());
         assertThat(enabledDarkFeatures.get().getFeatureKeys(), hasItem(FEATURE_FOO));
     }
 
     @Test
     public void enabledFeaturesForAuthenticatedUser()
     {
         enableDarkFeatureForAllUsersDuringRuntime(FEATURE_FOO);
         givenUserResolved();
         final Option<EnabledDarkFeatures> enabledDarkFeatures = createFeatureManager().getFeaturesEnabledForUser(USER_NAME);
         assertTrue(enabledDarkFeatures.isDefined());
         assertThat(enabledDarkFeatures.get().getFeatureKeys(), hasItem(FEATURE_FOO));
     }
 
     @Test
     public void enabledFeaturesUndefinedForInvalidUserName()
     {
         givenUserNotResolved();
         final Option<EnabledDarkFeatures> enabledDarkFeatures = createFeatureManager().getFeaturesEnabledForUser(USER_NAME);
         assertThat(enabledDarkFeatures, is(Option.<EnabledDarkFeatures>none()));
     }
 
     @Test
     public void featureEnabledViaSystemFeature()
     {
         enableDarkFeatureViaSystemProperty(FEATURE_FOO);
         assertTrue(createFeatureManager().isFeatureEnabledForCurrentUser(FEATURE_FOO));
     }
 
     @Test
     public void featureNotEnabled()
     {
         assertNull(System.getProperty(FEATURE_FOO));
         assertFalse(createFeatureManager().isFeatureEnabledForCurrentUser(FEATURE_FOO));
     }
 
     @Test
     public void invalidFeatureKeyIsNeverEnabled()
     {
         assertFalse(createFeatureManager().isFeatureEnabledForCurrentUser(INVALID_FEATURE_KEY));
     }
 
     @Test
     public void sysadminCanManageFeaturesForAllUsers()
     {
         givenUserIsAuthenticated();
         givenUserIsSysadmin();
         assertTrue(createFeatureManager().canManageFeaturesForAllUsers());
     }
 
     @Test
     public void nonSysadminCannotManageFeaturesForAllUsers()
     {
         givenUserIsAuthenticated();
         givenUserIsNotSysadmin();
         assertFalse(createFeatureManager().canManageFeaturesForAllUsers());
     }
 
     @Test
     public void anonymousCannotManageFeaturesForAllUsers()
     {
         givenUserIsNotAuthenticated();
         assertFalse(createFeatureManager().canManageFeaturesForAllUsers());
     }
 
     @Test(expected = MissingPermissionException.class)
     public void enableFeatureForAllUsersRequiresManagePermission()
     {
         try
         {
             givenUserIsNotAuthenticated();
             createFeatureManager().enableFeatureForAllUsers(FEATURE_FOO);
         }
         finally
         {
             verifyZeroInteractions(siteDarkFeaturesStorage);
         }
     }
 
     @Test(expected = InvalidFeatureKeyException.class)
     public void enableFeatureForAllUsersRequiresValidFeatureKey()
     {
         try
         {
             createFeatureManager().enableFeatureForAllUsers(INVALID_FEATURE_KEY);
         }
         finally
         {
             verifyNoMoreInteractions(siteDarkFeaturesStorage);
         }
     }
 
     @Test
     public void enableFeatureForAllUsers()
     {
         givenUserCanManageFeaturesForAllUsers();
         createFeatureManager().enableFeatureForAllUsers(FEATURE_FOO);
         verify(siteDarkFeaturesStorage).enable(FEATURE_FOO);
     }
 
     @Test(expected = MissingPermissionException.class)
     public void disableFeatureForAllUsersRequiresManagePermission()
     {
         try
         {
             givenUserIsNotAuthenticated();
             createFeatureManager().disableFeatureForAllUsers(FEATURE_FOO);
         }
         finally
         {
             verifyZeroInteractions(siteDarkFeaturesStorage);
         }
     }
 
     @Test(expected = InvalidFeatureKeyException.class)
     public void disableFeatureForAllUsersRequiresValidFeatureKey()
     {
         try
         {
             createFeatureManager().disableFeatureForAllUsers(INVALID_FEATURE_KEY);
         }
         finally
         {
             verifyNoMoreInteractions(siteDarkFeaturesStorage);
         }
 
     }
 
     @Test
     public void disableFeatureForAllUsers()
     {
         givenUserCanManageFeaturesForAllUsers();
         createFeatureManager().disableFeatureForAllUsers(FEATURE_FOO);
         verify(siteDarkFeaturesStorage).disable(FEATURE_FOO);
     }
 
     private void givenUserCanManageFeaturesForAllUsers()
     {
         givenUserIsAuthenticated();
         givenUserIsSysadmin();
     }
 
     private void givenUserNotResolved()
     {
         when(userManager.resolve(USER_NAME)).thenReturn(null);
     }
 
     private void givenUserResolved()
     {
         when(userManager.resolve(USER_NAME)).thenReturn(user);
     }
 
     private void givenUserIsNotAuthenticated()
     {
         when(userManager.getRemoteUsername()).thenReturn(null);
     }
 
     private void givenUserIsAuthenticated()
     {
         when(userManager.getRemoteUsername()).thenReturn(USER_NAME);
     }
 
     private void givenUserIsSysadmin()
     {
         when(userManager.isSystemAdmin(USER_NAME)).thenReturn(Boolean.TRUE);
     }
 
     private void givenUserIsNotSysadmin()
     {
         when(userManager.isSystemAdmin(USER_NAME)).thenReturn(Boolean.FALSE);
     }
 
     private void enableDarkFeatureViaSystemProperty(final String systemPropertyKey)
     {
         systemPropertyRule.setPropertyWithDarkFeaturePrefix(systemPropertyKey, "true");
     }
 
     private void enableDarkFeatureForAllUsersDuringRuntime(final String darkFeatureKey)
     {
         when(siteDarkFeaturesStorage.getEnabledDarkFeatures()).thenReturn(ImmutableSet.of(darkFeatureKey));
     }
 
     private DefaultDarkFeatureManager createFeatureManager()
     {
         return new DefaultDarkFeatureManager(userManager, siteDarkFeaturesStorage);
     }
 }