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

Update recently-deleted accounts table transactionally as part of account mutations

Browse Source
This commit is contained in:
Jon Chambers
2023-09-12 23:00:54 -04:00
committed by Jon Chambers
parent 1b9bf01ab1
commit f0544fab89
4 changed files with 86 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
service/src/test/java/org/whispersystems/textsecuregcm/storage/AccountsManagerTest.java
View File

@@ -148,7 +148,7 @@ class AccountsManagerTest {
account.setNumber(number, phoneNumberIdentifier);
return null;
}).when(accounts).changeNumber(any(), anyString(), any());
}).when(accounts).changeNumber(any(), anyString(), any(), any());
final SecureStorageClient storageClient = mock(SecureStorageClient.class);
when(storageClient.deleteStoredData(any())).thenReturn(CompletableFuture.completedFuture(null));
@@ -1031,7 +1031,6 @@ class AccountsManagerTest {
account = accountsManager.changeNumber(account, number, null, null, null, null);
assertEquals(number, account.getNumber());
verify(accounts, never()).putRecentlyDeletedAccount(any(), any());
verify(keysManager, never()).delete(any());
}

108
service/src/test/java/org/whispersystems/textsecuregcm/storage/AccountsTest.java
View File

@@ -39,12 +39,15 @@ import java.util.concurrent.CompletionException;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.BiConsumer;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.apache.commons.lang3.RandomUtils;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.junit.jupiter.api.extension.RegisterExtension;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;
import org.whispersystems.textsecuregcm.configuration.dynamic.DynamicConfiguration;
import org.whispersystems.textsecuregcm.experiment.ExperimentEnrollmentManager;
@@ -228,6 +231,34 @@ class AccountsTest {
assertPhoneNumberIdentifierConstraintExists(account.getPhoneNumberIdentifier(), account.getUuid());
}
@Test
void testStoreRecentlyDeleted() {
final UUID originalUuid = UUID.randomUUID();
Device device = generateDevice(1);
Account account = generateAccount("+14151112222", originalUuid, UUID.randomUUID(), List.of(device));
boolean freshUser = accounts.create(account);
assertThat(freshUser).isTrue();
verifyStoredState("+14151112222", account.getUuid(), account.getPhoneNumberIdentifier(), null, account, true);
assertPhoneNumberConstraintExists("+14151112222", account.getUuid());
assertPhoneNumberIdentifierConstraintExists(account.getPhoneNumberIdentifier(), account.getUuid());
accounts.delete(originalUuid);
assertThat(accounts.findRecentlyDeletedAccountIdentifier(account.getNumber())).hasValue(originalUuid);
freshUser = accounts.create(account);
assertThat(freshUser).isTrue();
verifyStoredState("+14151112222", account.getUuid(), account.getPhoneNumberIdentifier(), null, account, true);
assertPhoneNumberConstraintExists("+14151112222", account.getUuid());
assertPhoneNumberIdentifierConstraintExists(account.getPhoneNumberIdentifier(), account.getUuid());
assertThat(accounts.findRecentlyDeletedAccountIdentifier(account.getNumber())).isEmpty();
}
@Test
void testStoreMulti() {
final List<Device> devices = List.of(generateDevice(1), generateDevice(2));
@@ -536,6 +567,8 @@ class AccountsTest {
accounts.create(deletedAccount);
accounts.create(retainedAccount);
assertThat(accounts.findRecentlyDeletedAccountIdentifier(deletedAccount.getNumber())).isEmpty();
assertPhoneNumberConstraintExists("+14151112222", deletedAccount.getUuid());
assertPhoneNumberIdentifierConstraintExists(deletedAccount.getPhoneNumberIdentifier(), deletedAccount.getUuid());
assertPhoneNumberConstraintExists("+14151112345", retainedAccount.getUuid());
@@ -547,6 +580,7 @@ class AccountsTest {
accounts.delete(deletedAccount.getUuid());
assertThat(accounts.getByAccountIdentifier(deletedAccount.getUuid())).isNotPresent();
assertThat(accounts.findRecentlyDeletedAccountIdentifier(deletedAccount.getNumber())).hasValue(deletedAccount.getUuid());
assertPhoneNumberConstraintDoesNotExist(deletedAccount.getNumber());
assertPhoneNumberIdentifierConstraintDoesNotExist(deletedAccount.getPhoneNumberIdentifier());
@@ -637,8 +671,10 @@ class AccountsTest {
verifyStoredState("+14151112222", account.getUuid(), account.getPhoneNumberIdentifier(), null, account, false);
}
@Test
public void testChangeNumber() {
@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
@ParameterizedTest
@MethodSource
public void testChangeNumber(final Optional<UUID> maybeDisplacedAccountIdentifier) {
final String originalNumber = "+14151112222";
final String targetNumber = "+14151113333";
@@ -662,7 +698,7 @@ class AccountsTest {
verifyStoredState(originalNumber, account.getUuid(), account.getPhoneNumberIdentifier(), null, retrieved.get(), account);
}
accounts.changeNumber(account, targetNumber, targetPni);
accounts.changeNumber(account, targetNumber, targetPni, maybeDisplacedAccountIdentifier);
assertThat(accounts.getByE164(originalNumber)).isEmpty();
assertThat(accounts.getByAccountIdentifier(originalPni)).isEmpty();
@@ -681,6 +717,15 @@ class AccountsTest {
assertThat(retrieved.get().getPhoneNumberIdentifier()).isEqualTo(targetPni);
assertThat(accounts.getByPhoneNumberIdentifier(targetPni)).isPresent();
}
assertThat(accounts.findRecentlyDeletedAccountIdentifier(originalNumber)).isEqualTo(maybeDisplacedAccountIdentifier);
}
private static Stream<Arguments> testChangeNumber() {
return Stream.of(
Arguments.of(Optional.empty()),
Arguments.of(Optional.of(UUID.randomUUID()))
);
}
@Test
@@ -700,7 +745,7 @@ class AccountsTest {
accounts.create(account);
accounts.create(existingAccount);
assertThrows(TransactionCanceledException.class, () -> accounts.changeNumber(account, targetNumber, targetPni));
assertThrows(TransactionCanceledException.class, () -> accounts.changeNumber(account, targetNumber, targetPni, Optional.of(existingAccount.getUuid())));
assertPhoneNumberConstraintExists(originalNumber, account.getUuid());
assertPhoneNumberIdentifierConstraintExists(originalPni, account.getUuid());
@@ -736,7 +781,7 @@ class AccountsTest {
Map.of(":uuid", AttributeValues.fromUUID(existingAccountIdentifier)))
.build());
assertThrows(TransactionCanceledException.class, () -> accounts.changeNumber(account, targetNumber, existingPhoneNumberIdentifier));
assertThrows(TransactionCanceledException.class, () -> accounts.changeNumber(account, targetNumber, existingPhoneNumberIdentifier, Optional.empty()));
}
@Test
@@ -992,59 +1037,6 @@ class AccountsTest {
assertThat(account.getUsernameHash()).isEmpty();
}
@Test
void testPutFindRecentlyDeletedAccount() {
final UUID uuid = UUID.randomUUID();
final String e164 = "+18005551234";
assertEquals(Optional.empty(), accounts.findRecentlyDeletedAccountIdentifier(e164));
accounts.putRecentlyDeletedAccount(uuid, e164);
assertEquals(Optional.of(uuid), accounts.findRecentlyDeletedAccountIdentifier(e164));
}
@Test
void testRemoveRecentlyDeletedAccount() {
final UUID uuid = UUID.randomUUID();
final String e164 = "+18005551234";
assertEquals(Optional.empty(), accounts.findRecentlyDeletedAccountIdentifier(e164));
accounts.putRecentlyDeletedAccount(uuid, e164);
assertEquals(Optional.of(uuid), accounts.findRecentlyDeletedAccountIdentifier(e164));
accounts.removeRecentlyDeletedAccount(e164);
assertEquals(Optional.empty(), accounts.findRecentlyDeletedAccountIdentifier(e164));
}
@Test
void testFindRecentlyDeletedE164() {
assertEquals(Optional.empty(), accounts.findRecentlyDeletedE164(UUID.randomUUID()));
final UUID uuid = UUID.randomUUID();
final String e164 = "+18005551234";
accounts.putRecentlyDeletedAccount(uuid, e164);
assertEquals(Optional.of(e164), accounts.findRecentlyDeletedE164(uuid));
}
@Test
void testFindRecentlyDeletedUUID() {
final String e164 = "+18005551234";
assertEquals(Optional.empty(), accounts.findRecentlyDeletedAccountIdentifier(e164));
final UUID uuid = UUID.randomUUID();
accounts.putRecentlyDeletedAccount(uuid, e164);
assertEquals(Optional.of(uuid), accounts.findRecentlyDeletedAccountIdentifier(e164));
}
@Test
public void testIgnoredFieldsNotAddedToDataAttribute() throws Exception {
final Account account = generateAccount("+18005551234", UUID.randomUUID(), UUID.randomUUID());