src/test/java/com/googlesource/gerrit/plugins/ratelimiter/ConfigurationTest.java - plugins/rate-limiter - Git at Google

 // Copyright (C) 2017 The Android Open Source Project
 //
 // 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 com.googlesource.gerrit.plugins.ratelimiter;

 import static com.google.common.truth.Truth.assertThat;
 import static com.google.gerrit.testing.GerritJUnit.assertThrows;
 import static org.mockito.Mockito.when;

 import com.google.common.collect.ImmutableMap;
 import com.google.gerrit.entities.AccountGroup;
 import com.google.gerrit.entities.CachedProjectConfig;
 import com.google.gerrit.entities.GroupDescription;
 import com.google.gerrit.entities.Project;
 import com.google.gerrit.server.config.AllProjectsName;
 import com.google.gerrit.server.config.PluginConfigFactory;
 import com.google.gerrit.server.group.GroupResolver;
 import com.google.gerrit.server.project.NoSuchProjectException;
 import com.google.gerrit.server.project.ProjectConfig;
 import com.google.inject.ProvisionException;
 import java.util.Map;
 import org.eclipse.jgit.errors.ConfigInvalidException;
 import org.eclipse.jgit.lib.Config;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;

 @RunWith(MockitoJUnitRunner.class)
 public class ConfigurationTest {
   private static final String PLUGIN_NAME = "rate-limiter";
   private static final String PROJECT_NAME = "All-Projects";

   @Mock private PluginConfigFactory pluginConfigFactoryMock;
   @Mock private GroupResolver groupsCollectionMock;
   @Mock private GroupDescription.Basic administratorsGroupDescMock;
   @Mock private GroupDescription.Basic someGroupDescMock;
   @Mock private ProjectConfig newProjectConfig;
   @Mock private ProjectConfig oldProjectConfig;
   @Mock private CachedProjectConfig cachedProjectConfig;
   @Mock private CachedProjectConfig oldCachedProjectConfig;
   private AllProjectsName allProjectsName;
   private Config globalPluginConfig;
   private ImmutableMap<String, String> cacheableConfig;
   private ImmutableMap<String, String> oldCacheableConfig;
   private final int validRate = 123;
   private final int validWarningRate = 50;
   private final int newValidRate = 100;
   private final int newValidWarningRate = 60;
   private final int validTimeLapse = 10;
   private final int newValidTimeLapse = 20;
   private final String groupTagName = "group";
   private final String newRateLimiterConfigInAllProject =
       String.format(
           "[%s \"someGroup\"]\n "
               + "uploadpackperhour = %s\n "
               + "uploadpackperhourwarn = %s\n "
               + "timelapseinminutes = %s",
           groupTagName, newValidRate, newValidWarningRate, newValidTimeLapse);
   private final String oldRateLimiterConfigInAllProject =
       String.format(
           "[%s \"someGroup\"]\n "
               + "uploadpackperhour = %s\n "
               + "uploadpackperhourwarn = %s\n "
               + "timelapseinminutes = %s",
           groupTagName, validRate, validWarningRate, validTimeLapse);
   private final String badConfiguration =
       String.format(
           "[%s \"someGroup\"\n "
               + "uploadpackperhour = %s\n "
               + "uploadpackperhourwarn = %s\n "
               + "timelapseinminutes = %s",
           groupTagName, newValidRate, newValidWarningRate, newValidTimeLapse);

   @Before
   public void setUp() {
     globalPluginConfig = new Config();
     allProjectsName = new AllProjectsName(PROJECT_NAME);

     when(pluginConfigFactoryMock.getGlobalPluginConfig(PLUGIN_NAME)).thenReturn(globalPluginConfig);

     when(administratorsGroupDescMock.getGroupUUID()).thenReturn(AccountGroup.uuid("admin_uuid"));
     when(groupsCollectionMock.parseId("Administrators")).thenReturn(administratorsGroupDescMock);

     when(someGroupDescMock.getName()).thenReturn("someGroup");
     when(someGroupDescMock.getGroupUUID()).thenReturn(AccountGroup.uuid("some_uuid"));
     when(groupsCollectionMock.parseId("someGroup")).thenReturn(someGroupDescMock);

     when(newProjectConfig.getCacheable()).thenReturn(cachedProjectConfig);
     when(oldProjectConfig.getCacheable()).thenReturn(oldCachedProjectConfig);
   }

   @Test
   public void testConfigInNonReplca() throws NoSuchProjectException {
     assertThat(
             getUploadPackLimits(false)
                 .getRateLimits(RateLimitType.UPLOAD_PACK_PER_HOUR)
                 .get(AccountGroup.uuid("some_uuid"))
                 .getRatePerHour())
         .isEqualTo(newValidRate);
   }

   @Test
   public void testConfigInReplca() throws NoSuchProjectException {
     assertThat(
             getUploadPackLimits(true)
                 .getRateLimits(RateLimitType.UPLOAD_PACK_PER_HOUR)
                 .get(AccountGroup.uuid("some_uuid"))
                 .getRatePerHour())
         .isEqualTo(validRate);
   }

   @Test
   public void testEmptyConfig() {
     assertThat(getConfiguration(false).getRateLimits(RateLimitType.UPLOAD_PACK_PER_HOUR)).isEmpty();
   }

   @Test
   public void testConfigtFromAllProjectConfig() {
     // Config in table
     globalPluginConfig.setInt(
         groupTagName,
         someGroupDescMock.getName(),
         RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
         validRate);
     globalPluginConfig.setInt(
         groupTagName,
         someGroupDescMock.getName(),
         RateLimitType.UPLOAD_PACK_PER_HOUR_WARN.toString(),
         validWarningRate);
     globalPluginConfig.setInt(
         groupTagName,
         someGroupDescMock.getName(),
         RateLimitType.TIME_LAPSE_IN_MINUTES.toString(),
         validTimeLapse);

     oldCacheableConfig =
         ImmutableMap.<String, String>builder()
             .put("rate-limiter.config", oldRateLimiterConfigInAllProject)
             .build();
     ;
     cacheableConfig =
         ImmutableMap.<String, String>builder()
             .put("rate-limiter.config", newRateLimiterConfigInAllProject)
             .build();

     when(oldCachedProjectConfig.getProjectLevelConfigs()).thenReturn(oldCacheableConfig);
     when(cachedProjectConfig.getProjectLevelConfigs()).thenReturn(cacheableConfig);

     Configuration configuration = getConfiguration(false);

     verifyConfiginTable(configuration, validRate, validWarningRate, validTimeLapse);
     configuration.refreshTable(
         newProjectConfig,
         oldProjectConfig); // Change config in table base in config in all-projects
     verifyConfiginTable(configuration, newValidRate, newValidWarningRate, newValidTimeLapse);
   }

   @Test
   public void testInvalidConfigInAllProjects() {
     globalPluginConfig.setInt(
         groupTagName,
         someGroupDescMock.getName(),
         RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
         validRate);
     globalPluginConfig.setInt(
         groupTagName,
         someGroupDescMock.getName(),
         RateLimitType.UPLOAD_PACK_PER_HOUR_WARN.toString(),
         validWarningRate);
     globalPluginConfig.setInt(
         groupTagName,
         someGroupDescMock.getName(),
         RateLimitType.TIME_LAPSE_IN_MINUTES.toString(),
         validTimeLapse);

     oldCacheableConfig =
         ImmutableMap.<String, String>builder()
             .put("rate-limiter.config", oldRateLimiterConfigInAllProject)
             .build();
     cacheableConfig =
         ImmutableMap.<String, String>builder().put("rate-limiter.config", badConfiguration).build();

     when(oldCachedProjectConfig.getProjectLevelConfigs()).thenReturn(oldCacheableConfig);
     when(cachedProjectConfig.getProjectLevelConfigs()).thenReturn(cacheableConfig);

     Configuration configuration = getConfiguration(false);

     verifyConfiginTable(configuration, validRate, validWarningRate, validTimeLapse);
     configuration.refreshTable(newProjectConfig, oldProjectConfig);
     verifyConfiginTable(configuration, validRate, validWarningRate, validTimeLapse);
   }

   @Test
   public void testNoConfiginAllProjects() {
     globalPluginConfig.setInt(
         groupTagName,
         someGroupDescMock.getName(),
         RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
         validRate);
     globalPluginConfig.setInt(
         groupTagName,
         someGroupDescMock.getName(),
         RateLimitType.UPLOAD_PACK_PER_HOUR_WARN.toString(),
         validWarningRate);
     globalPluginConfig.setInt(
         groupTagName,
         someGroupDescMock.getName(),
         RateLimitType.TIME_LAPSE_IN_MINUTES.toString(),
         validTimeLapse);

     oldCacheableConfig =
         ImmutableMap.<String, String>builder()
             .put("rate-limiter.config", oldRateLimiterConfigInAllProject)
             .build();
     cacheableConfig = ImmutableMap.<String, String>builder().build();

     when(cachedProjectConfig.getProjectLevelConfigs()).thenReturn(cacheableConfig);
     when(oldCachedProjectConfig.getProjectLevelConfigs()).thenReturn(oldCacheableConfig);

     Configuration configuration = getConfiguration(false);

     verifyConfiginTable(configuration, validRate, validWarningRate, validTimeLapse);
     configuration.refreshTable(newProjectConfig, oldProjectConfig);
     verifyConfiginTable(configuration, validRate, validWarningRate, validTimeLapse);
   }

   @Test
   public void testUploadPackPerHourRateLimit() {
     globalPluginConfig.setInt(
         groupTagName,
         someGroupDescMock.getName(),
         RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
         validRate);

     Map<AccountGroup.UUID, RateLimit> rateLimit =
         getConfiguration(false).getRateLimits(RateLimitType.UPLOAD_PACK_PER_HOUR);
     assertThat(rateLimit).hasSize(1);
     assertThat(rateLimit.get(someGroupDescMock.getGroupUUID()).getRatePerHour())
         .isEqualTo(validRate);
   }

   @Test
   public void testInvalidRateLimitType() {
     globalPluginConfig.setInt(
         groupTagName, someGroupDescMock.getName(), "invalidTypePerHour", validRate);

     ProvisionException thrown =
         assertThrows(ProvisionException.class, () -> getConfiguration(false));
     assertThat(thrown)
         .hasMessageThat()
         .contains("Invalid configuration, unsupported rate limit type: invalidTypePerHour");
   }

   @Test
   public void testInvalidRateLimitValue() {
     String invalidType = "dummyType";

     globalPluginConfig.setString(
         groupTagName,
         someGroupDescMock.getName(),
         RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
         invalidType);

     String expectedMessage =
         String.format(
             "Invalid configuration, 'rate limit value '%s' for 'group.someGroup.uploadpackperhour' is not a valid number",
             invalidType);
     ProvisionException thrown =
         assertThrows(ProvisionException.class, () -> getConfiguration(false));
     assertThat(thrown).hasMessageThat().contains(expectedMessage);
   }

   @Test
   public void testInvalidGroup() {
     // Set a good group and a bad and ensure the good is still parsed

     globalPluginConfig.setInt(
         groupTagName,
         someGroupDescMock.getName(),
         RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
         validRate);

     globalPluginConfig.setString(
         groupTagName,
         "nonexistingGroup",
         RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
         "badGroup");

     Map<AccountGroup.UUID, RateLimit> rateLimit =
         getConfiguration(false).getRateLimits(RateLimitType.UPLOAD_PACK_PER_HOUR);
     assertThat(rateLimit).hasSize(1);
     assertThat(rateLimit.get(someGroupDescMock.getGroupUUID()).getRatePerHour())
         .isEqualTo(validRate);
   }

   @Test
   public void testNoUploadPackPerHourRateLimitForAGroup() throws ConfigInvalidException {
     globalPluginConfig.fromText("[group \"Administrators\"]");

     Map<AccountGroup.UUID, RateLimit> rateLimit =
         getConfiguration(false).getRateLimits(RateLimitType.UPLOAD_PACK_PER_HOUR);
     assertThat(rateLimit).hasSize(1);
     assertThat(rateLimit.get(administratorsGroupDescMock.getGroupUUID())).isNull();
   }

   @Test
   public void testDefaultRateLimitExceededMsg() {
     assertThat(getConfiguration(false).getRateLimitExceededMsg())
         .isEqualTo("Exceeded rate limit of ${rateLimit} fetch requests/hour");
   }

   @Test
   public void testRateLimitExceededMsg() {
     String msg = "Some error message.";
     globalPluginConfig.setString("configuration", null, "uploadpackLimitExceededMsg", msg);
     assertThat(getConfiguration(false).getRateLimitExceededMsg()).isEqualTo(msg);
   }

   private Configuration getConfiguration(Boolean isReplica) {
     return new Configuration(
         allProjectsName, pluginConfigFactoryMock, PLUGIN_NAME, isReplica, groupsCollectionMock);
   }

   private void verifyConfiginTable(
       Configuration configuration, int rateToCheck, int warningToCheck, int timeLapseToCheck) {
     Map<AccountGroup.UUID, RateLimit> rateLimit =
         configuration.getRateLimits(RateLimitType.UPLOAD_PACK_PER_HOUR);
     assertThat(rateLimit).hasSize(1);
     assertThat(rateLimit.get(someGroupDescMock.getGroupUUID()).getRatePerHour())
         .isEqualTo(rateToCheck);
     Map<AccountGroup.UUID, RateLimit> warningRate =
         configuration.getRateLimits(RateLimitType.UPLOAD_PACK_PER_HOUR_WARN);
     assertThat(warningRate).hasSize(1);
     assertThat(warningRate.get(someGroupDescMock.getGroupUUID()).getRatePerHour())
         .isEqualTo(warningToCheck);
     Map<AccountGroup.UUID, RateLimit> timeLapse =
         configuration.getRateLimits(RateLimitType.TIME_LAPSE_IN_MINUTES);
     assertThat(timeLapse).hasSize(1);
     assertThat(timeLapse.get(someGroupDescMock.getGroupUUID()).getRatePerHour())
         .isEqualTo(timeLapseToCheck);
   }

   public Configuration getUploadPackLimits(Boolean isReplica) throws NoSuchProjectException {
     Config configInAllProjects = new Config();
     // Config in All-Project
     configInAllProjects.setInt(
         groupTagName,
         someGroupDescMock.getName(),
         RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
         newValidRate);
     // Config in etc/rate-limiter
     globalPluginConfig.setInt(
         groupTagName,
         someGroupDescMock.getName(),
         RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
         validRate);

     when(pluginConfigFactoryMock.getProjectPluginConfigWithInheritance(
             Project.NameKey.parse(PROJECT_NAME), PLUGIN_NAME))
         .thenReturn(configInAllProjects);

     return getConfiguration(isReplica);
   }
 }
	// Copyright (C) 2017 The Android Open Source Project
	//
	// 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 com.googlesource.gerrit.plugins.ratelimiter;

	import static com.google.common.truth.Truth.assertThat;
	import static com.google.gerrit.testing.GerritJUnit.assertThrows;
	import static org.mockito.Mockito.when;

	import com.google.common.collect.ImmutableMap;
	import com.google.gerrit.entities.AccountGroup;
	import com.google.gerrit.entities.CachedProjectConfig;
	import com.google.gerrit.entities.GroupDescription;
	import com.google.gerrit.entities.Project;
	import com.google.gerrit.server.config.AllProjectsName;
	import com.google.gerrit.server.config.PluginConfigFactory;
	import com.google.gerrit.server.group.GroupResolver;
	import com.google.gerrit.server.project.NoSuchProjectException;
	import com.google.gerrit.server.project.ProjectConfig;
	import com.google.inject.ProvisionException;
	import java.util.Map;
	import org.eclipse.jgit.errors.ConfigInvalidException;
	import org.eclipse.jgit.lib.Config;
	import org.junit.Before;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.mockito.Mock;
	import org.mockito.junit.MockitoJUnitRunner;

	@RunWith(MockitoJUnitRunner.class)
	public class ConfigurationTest {
	private static final String PLUGIN_NAME = "rate-limiter";
	private static final String PROJECT_NAME = "All-Projects";

	@Mock private PluginConfigFactory pluginConfigFactoryMock;
	@Mock private GroupResolver groupsCollectionMock;
	@Mock private GroupDescription.Basic administratorsGroupDescMock;
	@Mock private GroupDescription.Basic someGroupDescMock;
	@Mock private ProjectConfig newProjectConfig;
	@Mock private ProjectConfig oldProjectConfig;
	@Mock private CachedProjectConfig cachedProjectConfig;
	@Mock private CachedProjectConfig oldCachedProjectConfig;
	private AllProjectsName allProjectsName;
	private Config globalPluginConfig;
	private ImmutableMap<String, String> cacheableConfig;
	private ImmutableMap<String, String> oldCacheableConfig;
	private final int validRate = 123;
	private final int validWarningRate = 50;
	private final int newValidRate = 100;
	private final int newValidWarningRate = 60;
	private final int validTimeLapse = 10;
	private final int newValidTimeLapse = 20;
	private final String groupTagName = "group";
	private final String newRateLimiterConfigInAllProject =
	String.format(
	"[%s \"someGroup\"]\n "
	+ "uploadpackperhour = %s\n "
	+ "uploadpackperhourwarn = %s\n "
	+ "timelapseinminutes = %s",
	groupTagName, newValidRate, newValidWarningRate, newValidTimeLapse);
	private final String oldRateLimiterConfigInAllProject =
	String.format(
	"[%s \"someGroup\"]\n "
	+ "uploadpackperhour = %s\n "
	+ "uploadpackperhourwarn = %s\n "
	+ "timelapseinminutes = %s",
	groupTagName, validRate, validWarningRate, validTimeLapse);
	private final String badConfiguration =
	String.format(
	"[%s \"someGroup\"\n "
	+ "uploadpackperhour = %s\n "
	+ "uploadpackperhourwarn = %s\n "
	+ "timelapseinminutes = %s",
	groupTagName, newValidRate, newValidWarningRate, newValidTimeLapse);

	@Before
	public void setUp() {
	globalPluginConfig = new Config();
	allProjectsName = new AllProjectsName(PROJECT_NAME);

	when(pluginConfigFactoryMock.getGlobalPluginConfig(PLUGIN_NAME)).thenReturn(globalPluginConfig);

	when(administratorsGroupDescMock.getGroupUUID()).thenReturn(AccountGroup.uuid("admin_uuid"));
	when(groupsCollectionMock.parseId("Administrators")).thenReturn(administratorsGroupDescMock);

	when(someGroupDescMock.getName()).thenReturn("someGroup");
	when(someGroupDescMock.getGroupUUID()).thenReturn(AccountGroup.uuid("some_uuid"));
	when(groupsCollectionMock.parseId("someGroup")).thenReturn(someGroupDescMock);

	when(newProjectConfig.getCacheable()).thenReturn(cachedProjectConfig);
	when(oldProjectConfig.getCacheable()).thenReturn(oldCachedProjectConfig);
	}

	@Test
	public void testConfigInNonReplca() throws NoSuchProjectException {
	assertThat(
	getUploadPackLimits(false)
	.getRateLimits(RateLimitType.UPLOAD_PACK_PER_HOUR)
	.get(AccountGroup.uuid("some_uuid"))
	.getRatePerHour())
	.isEqualTo(newValidRate);
	}

	@Test
	public void testConfigInReplca() throws NoSuchProjectException {
	assertThat(
	getUploadPackLimits(true)
	.getRateLimits(RateLimitType.UPLOAD_PACK_PER_HOUR)
	.get(AccountGroup.uuid("some_uuid"))
	.getRatePerHour())
	.isEqualTo(validRate);
	}

	@Test
	public void testEmptyConfig() {
	assertThat(getConfiguration(false).getRateLimits(RateLimitType.UPLOAD_PACK_PER_HOUR)).isEmpty();
	}

	@Test
	public void testConfigtFromAllProjectConfig() {
	// Config in table
	globalPluginConfig.setInt(
	groupTagName,
	someGroupDescMock.getName(),
	RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
	validRate);
	globalPluginConfig.setInt(
	groupTagName,
	someGroupDescMock.getName(),
	RateLimitType.UPLOAD_PACK_PER_HOUR_WARN.toString(),
	validWarningRate);
	globalPluginConfig.setInt(
	groupTagName,
	someGroupDescMock.getName(),
	RateLimitType.TIME_LAPSE_IN_MINUTES.toString(),
	validTimeLapse);

	oldCacheableConfig =
	ImmutableMap.<String, String>builder()
	.put("rate-limiter.config", oldRateLimiterConfigInAllProject)
	.build();
	;
	cacheableConfig =
	ImmutableMap.<String, String>builder()
	.put("rate-limiter.config", newRateLimiterConfigInAllProject)
	.build();

	when(oldCachedProjectConfig.getProjectLevelConfigs()).thenReturn(oldCacheableConfig);
	when(cachedProjectConfig.getProjectLevelConfigs()).thenReturn(cacheableConfig);

	Configuration configuration = getConfiguration(false);

	verifyConfiginTable(configuration, validRate, validWarningRate, validTimeLapse);
	configuration.refreshTable(
	newProjectConfig,
	oldProjectConfig); // Change config in table base in config in all-projects
	verifyConfiginTable(configuration, newValidRate, newValidWarningRate, newValidTimeLapse);
	}

	@Test
	public void testInvalidConfigInAllProjects() {
	globalPluginConfig.setInt(
	groupTagName,
	someGroupDescMock.getName(),
	RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
	validRate);
	globalPluginConfig.setInt(
	groupTagName,
	someGroupDescMock.getName(),
	RateLimitType.UPLOAD_PACK_PER_HOUR_WARN.toString(),
	validWarningRate);
	globalPluginConfig.setInt(
	groupTagName,
	someGroupDescMock.getName(),
	RateLimitType.TIME_LAPSE_IN_MINUTES.toString(),
	validTimeLapse);

	oldCacheableConfig =
	ImmutableMap.<String, String>builder()
	.put("rate-limiter.config", oldRateLimiterConfigInAllProject)
	.build();
	cacheableConfig =
	ImmutableMap.<String, String>builder().put("rate-limiter.config", badConfiguration).build();

	when(oldCachedProjectConfig.getProjectLevelConfigs()).thenReturn(oldCacheableConfig);
	when(cachedProjectConfig.getProjectLevelConfigs()).thenReturn(cacheableConfig);

	Configuration configuration = getConfiguration(false);

	verifyConfiginTable(configuration, validRate, validWarningRate, validTimeLapse);
	configuration.refreshTable(newProjectConfig, oldProjectConfig);
	verifyConfiginTable(configuration, validRate, validWarningRate, validTimeLapse);
	}

	@Test
	public void testNoConfiginAllProjects() {
	globalPluginConfig.setInt(
	groupTagName,
	someGroupDescMock.getName(),
	RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
	validRate);
	globalPluginConfig.setInt(
	groupTagName,
	someGroupDescMock.getName(),
	RateLimitType.UPLOAD_PACK_PER_HOUR_WARN.toString(),
	validWarningRate);
	globalPluginConfig.setInt(
	groupTagName,
	someGroupDescMock.getName(),
	RateLimitType.TIME_LAPSE_IN_MINUTES.toString(),
	validTimeLapse);

	oldCacheableConfig =
	ImmutableMap.<String, String>builder()
	.put("rate-limiter.config", oldRateLimiterConfigInAllProject)
	.build();
	cacheableConfig = ImmutableMap.<String, String>builder().build();

	when(cachedProjectConfig.getProjectLevelConfigs()).thenReturn(cacheableConfig);
	when(oldCachedProjectConfig.getProjectLevelConfigs()).thenReturn(oldCacheableConfig);

	Configuration configuration = getConfiguration(false);

	verifyConfiginTable(configuration, validRate, validWarningRate, validTimeLapse);
	configuration.refreshTable(newProjectConfig, oldProjectConfig);
	verifyConfiginTable(configuration, validRate, validWarningRate, validTimeLapse);
	}

	@Test
	public void testUploadPackPerHourRateLimit() {
	globalPluginConfig.setInt(
	groupTagName,
	someGroupDescMock.getName(),
	RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
	validRate);

	Map<AccountGroup.UUID, RateLimit> rateLimit =
	getConfiguration(false).getRateLimits(RateLimitType.UPLOAD_PACK_PER_HOUR);
	assertThat(rateLimit).hasSize(1);
	assertThat(rateLimit.get(someGroupDescMock.getGroupUUID()).getRatePerHour())
	.isEqualTo(validRate);
	}

	@Test
	public void testInvalidRateLimitType() {
	globalPluginConfig.setInt(
	groupTagName, someGroupDescMock.getName(), "invalidTypePerHour", validRate);

	ProvisionException thrown =
	assertThrows(ProvisionException.class, () -> getConfiguration(false));
	assertThat(thrown)
	.hasMessageThat()
	.contains("Invalid configuration, unsupported rate limit type: invalidTypePerHour");
	}

	@Test
	public void testInvalidRateLimitValue() {
	String invalidType = "dummyType";

	globalPluginConfig.setString(
	groupTagName,
	someGroupDescMock.getName(),
	RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
	invalidType);

	String expectedMessage =
	String.format(
	"Invalid configuration, 'rate limit value '%s' for 'group.someGroup.uploadpackperhour' is not a valid number",
	invalidType);
	ProvisionException thrown =
	assertThrows(ProvisionException.class, () -> getConfiguration(false));
	assertThat(thrown).hasMessageThat().contains(expectedMessage);
	}

	@Test
	public void testInvalidGroup() {
	// Set a good group and a bad and ensure the good is still parsed

	globalPluginConfig.setInt(
	groupTagName,
	someGroupDescMock.getName(),
	RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
	validRate);

	globalPluginConfig.setString(
	groupTagName,
	"nonexistingGroup",
	RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
	"badGroup");

	Map<AccountGroup.UUID, RateLimit> rateLimit =
	getConfiguration(false).getRateLimits(RateLimitType.UPLOAD_PACK_PER_HOUR);
	assertThat(rateLimit).hasSize(1);
	assertThat(rateLimit.get(someGroupDescMock.getGroupUUID()).getRatePerHour())
	.isEqualTo(validRate);
	}

	@Test
	public void testNoUploadPackPerHourRateLimitForAGroup() throws ConfigInvalidException {
	globalPluginConfig.fromText("[group \"Administrators\"]");

	Map<AccountGroup.UUID, RateLimit> rateLimit =
	getConfiguration(false).getRateLimits(RateLimitType.UPLOAD_PACK_PER_HOUR);
	assertThat(rateLimit).hasSize(1);
	assertThat(rateLimit.get(administratorsGroupDescMock.getGroupUUID())).isNull();
	}

	@Test
	public void testDefaultRateLimitExceededMsg() {
	assertThat(getConfiguration(false).getRateLimitExceededMsg())
	.isEqualTo("Exceeded rate limit of ${rateLimit} fetch requests/hour");
	}

	@Test
	public void testRateLimitExceededMsg() {
	String msg = "Some error message.";
	globalPluginConfig.setString("configuration", null, "uploadpackLimitExceededMsg", msg);
	assertThat(getConfiguration(false).getRateLimitExceededMsg()).isEqualTo(msg);
	}

	private Configuration getConfiguration(Boolean isReplica) {
	return new Configuration(
	allProjectsName, pluginConfigFactoryMock, PLUGIN_NAME, isReplica, groupsCollectionMock);
	}

	private void verifyConfiginTable(
	Configuration configuration, int rateToCheck, int warningToCheck, int timeLapseToCheck) {
	Map<AccountGroup.UUID, RateLimit> rateLimit =
	configuration.getRateLimits(RateLimitType.UPLOAD_PACK_PER_HOUR);
	assertThat(rateLimit).hasSize(1);
	assertThat(rateLimit.get(someGroupDescMock.getGroupUUID()).getRatePerHour())
	.isEqualTo(rateToCheck);
	Map<AccountGroup.UUID, RateLimit> warningRate =
	configuration.getRateLimits(RateLimitType.UPLOAD_PACK_PER_HOUR_WARN);
	assertThat(warningRate).hasSize(1);
	assertThat(warningRate.get(someGroupDescMock.getGroupUUID()).getRatePerHour())
	.isEqualTo(warningToCheck);
	Map<AccountGroup.UUID, RateLimit> timeLapse =
	configuration.getRateLimits(RateLimitType.TIME_LAPSE_IN_MINUTES);
	assertThat(timeLapse).hasSize(1);
	assertThat(timeLapse.get(someGroupDescMock.getGroupUUID()).getRatePerHour())
	.isEqualTo(timeLapseToCheck);
	}

	public Configuration getUploadPackLimits(Boolean isReplica) throws NoSuchProjectException {
	Config configInAllProjects = new Config();
	// Config in All-Project
	configInAllProjects.setInt(
	groupTagName,
	someGroupDescMock.getName(),
	RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
	newValidRate);
	// Config in etc/rate-limiter
	globalPluginConfig.setInt(
	groupTagName,
	someGroupDescMock.getName(),
	RateLimitType.UPLOAD_PACK_PER_HOUR.toString(),
	validRate);

	when(pluginConfigFactoryMock.getProjectPluginConfigWithInheritance(
	Project.NameKey.parse(PROJECT_NAME), PLUGIN_NAME))
	.thenReturn(configInAllProjects);

	return getConfiguration(isReplica);
	}
	}