Signal/Signal-Server
1
0
Fork 0
mirror of https://github.com/signalapp/Signal-Server synced 2026-04-21 19:58:03 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add support for server-side feature flags

Browse Source
This commit is contained in:
Jon Chambers
2020-08-26 20:27:33 -04:00
committed by GitHub
parent b9df028bfb
commit 1ef3546822
12 changed files with 511 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
service/src/test/java/org/whispersystems/textsecuregcm/controllers/FeatureFlagsControllerTest.java Normal file
View File

@@ -0,0 +1,116 @@
package org.whispersystems.textsecuregcm.controllers;
import com.google.common.collect.ImmutableSet;
import io.dropwizard.auth.PolymorphicAuthValueFactoryProvider;
import io.dropwizard.testing.junit.ResourceTestRule;
import junitparams.JUnitParamsRunner;
import junitparams.Parameters;
import org.glassfish.jersey.test.grizzly.GrizzlyWebTestContainerFactory;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.whispersystems.textsecuregcm.auth.DisabledPermittedAccount;
import org.whispersystems.textsecuregcm.mappers.DeviceLimitExceededExceptionMapper;
import org.whispersystems.textsecuregcm.storage.Account;
import org.whispersystems.textsecuregcm.storage.FeatureFlagsManager;
import org.whispersystems.textsecuregcm.tests.util.AuthHelper;
import javax.ws.rs.client.Entity;
import javax.ws.rs.core.Form;
import javax.ws.rs.core.Response;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
@RunWith(JUnitParamsRunner.class)
public class FeatureFlagsControllerTest {
private static final FeatureFlagsManager FEATURE_FLAG_MANAGER = mock(FeatureFlagsManager.class);
private static final FeatureFlagsController FEATURE_FLAG_CONTROLLER = new FeatureFlagsController(FEATURE_FLAG_MANAGER, List.of("first", "second"));
@Rule
public final ResourceTestRule resources = ResourceTestRule.builder()
.addProvider(AuthHelper.getAuthFilter())
.addProvider(new PolymorphicAuthValueFactoryProvider.Binder<>(ImmutableSet.of(Account.class, DisabledPermittedAccount.class)))
.setTestContainerFactory(new GrizzlyWebTestContainerFactory())
.addProvider(new DeviceLimitExceededExceptionMapper())
.addResource(FEATURE_FLAG_CONTROLLER)
.build();
@Before
public void setUp() {
reset(FEATURE_FLAG_MANAGER);
}
@Test
public void testSet() {
{
final Response response = resources.getJerseyTest()
.target("/v1/featureflag/testFlag")
.request()
.header("Token", "first")
.put(Entity.form(new Form().param("active", "true")));
assertEquals(204, response.getStatus());
verify(FEATURE_FLAG_MANAGER).setFeatureFlag("testFlag", true);
}
{
final Response response = resources.getJerseyTest()
.target("/v1/featureflag/testFlag")
.request()
.header("Token", "bogus-token")
.put(Entity.form(new Form().param("active", "true")));
assertEquals(401, response.getStatus());
verifyNoMoreInteractions(FEATURE_FLAG_MANAGER);
}
}
@Test
public void testDelete() {
{
final Response response = resources.getJerseyTest()
.target("/v1/featureflag/testFlag")
.request()
.header("Token", "first")
.delete();
assertEquals(204, response.getStatus());
verify(FEATURE_FLAG_MANAGER).deleteFeatureFlag("testFlag");
}
{
final Response response = resources.getJerseyTest()
.target("/v1/featureflag/testFlag")
.request()
.header("Token", "bogus-token")
.delete();
assertEquals(401, response.getStatus());
verifyNoMoreInteractions(FEATURE_FLAG_MANAGER);
}
}
@Test
@Parameters(method = "argumentsForTestIsAuthorized")
public void testIsAuthorized(final String token, final boolean expectAuthorized) {
assertEquals(expectAuthorized, FEATURE_FLAG_CONTROLLER.isAuthorized(token));
}
@SuppressWarnings("unused")
private Object argumentsForTestIsAuthorized() {
return new Object[] {
new Object[] { "first", true },
new Object[] { "second", true },
new Object[] { "third", false },
new Object[] { "firstfirstfirst", false },
new Object[] { null, false }
};
}
}

44
service/src/test/java/org/whispersystems/textsecuregcm/storage/FeatureFlagsManagerTest.java Normal file
View File

@@ -0,0 +1,44 @@
package org.whispersystems.textsecuregcm.storage;
import org.junit.Before;
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ScheduledExecutorService;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class FeatureFlagsManagerTest {
private FeatureFlags featureFlagDatabase;
private FeatureFlagsManager featureFlagsManager;
@Before
public void setUp() {
featureFlagDatabase = mock(FeatureFlags.class);
featureFlagsManager = new FeatureFlagsManager(featureFlagDatabase, mock(ScheduledExecutorService.class));
}
@Test
public void testIsFeatureFlagActive() {
final Map<String, Boolean> featureFlags = new HashMap<>();
featureFlags.put("testFlag", true);
when(featureFlagDatabase.getFeatureFlags()).thenReturn(featureFlags);
assertFalse(featureFlagsManager.isFeatureFlagActive("testFlag"));
featureFlagsManager.refreshFeatureFlags();
assertTrue(featureFlagsManager.isFeatureFlagActive("testFlag"));
featureFlags.put("testFlag", false);
featureFlagsManager.refreshFeatureFlags();
assertFalse(featureFlagsManager.isFeatureFlagActive("testFlag"));
}
}

63
service/src/test/java/org/whispersystems/textsecuregcm/storage/FeatureFlagsTest.java Normal file
View File

@@ -0,0 +1,63 @@
package org.whispersystems.textsecuregcm.storage;
import com.opentable.db.postgres.embedded.LiquibasePreparer;
import com.opentable.db.postgres.junit.EmbeddedPostgresRules;
import com.opentable.db.postgres.junit.PreparedDbRule;
import org.jdbi.v3.core.Jdbi;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.whispersystems.textsecuregcm.configuration.CircuitBreakerConfiguration;
import java.util.Map;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
public class FeatureFlagsTest {
@Rule
public PreparedDbRule db = EmbeddedPostgresRules.preparedDatabase(LiquibasePreparer.forClasspathLocation("accountsdb.xml"));
private FeatureFlags featureFlags;
@Before
public void setUp() {
final FaultTolerantDatabase database = new FaultTolerantDatabase("featureFlagsTest",
Jdbi.create(db.getTestDatabase()),
new CircuitBreakerConfiguration());
this.featureFlags = new FeatureFlags(database);
}
@Test
public void testSetFlagIsFlagActive() {
assertTrue(featureFlags.getFeatureFlags().isEmpty());
featureFlags.setFlag("testFlag", true);
assertEquals(Map.of("testFlag", true), featureFlags.getFeatureFlags());
featureFlags.setFlag("testFlag", false);
assertEquals(Map.of("testFlag", false), featureFlags.getFeatureFlags());
}
@Test
public void testDeleteFlag() {
assertTrue(featureFlags.getFeatureFlags().isEmpty());
featureFlags.setFlag("testFlag", true);
assertEquals(Map.of("testFlag", true), featureFlags.getFeatureFlags());
featureFlags.deleteFlag("testFlag");
assertTrue(featureFlags.getFeatureFlags().isEmpty());
}
@Test
public void testVacuum() {
featureFlags.setFlag("testFlag", true);
assertEquals(Map.of("testFlag", true), featureFlags.getFeatureFlags());
featureFlags.vacuum();
assertEquals(Map.of("testFlag", true), featureFlags.getFeatureFlags());
}
}