uuid-based account crawler

This commit is contained in:
Jeffrey Griffin 2019-08-26 14:11:23 -07:00
parent bb52049bf4
commit 69742839c0
17 changed files with 202 additions and 125 deletions

View File

@ -19,10 +19,11 @@ package org.whispersystems.textsecuregcm.entities;
import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.Map; import java.util.Map;
import java.util.HashMap; import java.util.HashMap;
import java.util.UUID;
public class ActiveUserTally { public class ActiveUserTally {
@JsonProperty @JsonProperty
private String fromNumber; private UUID fromUuid;
@JsonProperty @JsonProperty
private Map<String, long[]> platforms; private Map<String, long[]> platforms;
@ -32,14 +33,14 @@ public class ActiveUserTally {
public ActiveUserTally() {} public ActiveUserTally() {}
public ActiveUserTally(String fromNumber, Map<String, long[]> platforms, Map<String, long[]> countries) { public ActiveUserTally(UUID fromUuid, Map<String, long[]> platforms, Map<String, long[]> countries) {
this.fromNumber = fromNumber; this.fromUuid = fromUuid;
this.platforms = platforms; this.platforms = platforms;
this.countries = countries; this.countries = countries;
} }
public String getFromNumber() { public UUID getFromUuid() {
return this.fromNumber; return this.fromUuid;
} }
public Map<String, long[]> getPlatforms() { public Map<String, long[]> getPlatforms() {
@ -50,8 +51,8 @@ public class ActiveUserTally {
return this.countries; return this.countries;
} }
public void setFromNumber(String fromNumber) { public void setFromUuid(UUID fromUuid) {
this.fromNumber = fromNumber; this.fromUuid = fromUuid;
} }
} }

View File

@ -18,38 +18,84 @@ package org.whispersystems.textsecuregcm.entities;
import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonProperty;
import javax.validation.constraints.NotNull;
import java.util.List; import java.util.List;
import java.util.UUID;
public class DirectoryReconciliationRequest { public class DirectoryReconciliationRequest {
@JsonProperty @JsonProperty
private String fromNumber; private UUID fromUuid;
@JsonProperty @JsonProperty
private String toNumber; private UUID toUuid;
@JsonProperty @JsonProperty
private List<String> numbers; private List<User> users;
public DirectoryReconciliationRequest() { public DirectoryReconciliationRequest() {
} }
public DirectoryReconciliationRequest(String fromNumber, String toNumber, List<String> numbers) { public DirectoryReconciliationRequest(UUID fromUuid, UUID toUuid, List<User> users) {
this.fromNumber = fromNumber; this.fromUuid = fromUuid;
this.toNumber = toNumber; this.toUuid = toUuid;
this.numbers = numbers; this.users = users;
} }
public String getFromNumber() { public UUID getFromUuid() {
return fromNumber; return fromUuid;
} }
public String getToNumber() { public UUID getToUuid() {
return toNumber; return toUuid;
} }
public List<String> getNumbers() { public List<User> getUsers() {
return numbers; return users;
} }
public static class User {
@JsonProperty
private UUID uuid;
@JsonProperty
private String number;
public User() {
}
public User(UUID uuid, String number) {
this.uuid = uuid;
this.number = number;
}
public UUID getUuid() {
return uuid;
}
public String getNumber() {
return number;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
if (uuid != null ? !uuid.equals(user.uuid) : user.uuid != null) return false;
if (number != null ? !number.equals(user.number) : user.number != null) return false;
return true;
}
@Override
public int hashCode() {
int result = uuid != null ? uuid.hashCode() : 0;
result = 31 * result + (number != null ? number.hashCode() : 0);
return result;
}
}
} }

View File

@ -26,6 +26,7 @@ import org.whispersystems.textsecuregcm.util.Util;
import java.util.List; import java.util.List;
import java.util.Optional; import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import static com.codahale.metrics.MetricRegistry.name; import static com.codahale.metrics.MetricRegistry.name;
@ -51,7 +52,7 @@ public class AccountCleaner implements AccountDatabaseCrawlerListener {
} }
@Override @Override
public void onCrawlChunk(Optional<String> fromNumber, List<Account> chunkAccounts) { public void onCrawlChunk(Optional<UUID> fromUuid, List<Account> chunkAccounts) {
int accountUpdateCount = 0; int accountUpdateCount = 0;
for (Account account : chunkAccounts) { for (Account account : chunkAccounts) {
if (needsExplicitRemoval(account)) { if (needsExplicitRemoval(account)) {
@ -74,7 +75,7 @@ public class AccountCleaner implements AccountDatabaseCrawlerListener {
} }
@Override @Override
public void onCrawlEnd(Optional<String> fromNumber) { public void onCrawlEnd(Optional<UUID> fromUuid) {
} }
private boolean needsExplicitRemoval(Account account) { private boolean needsExplicitRemoval(Account account) {

View File

@ -122,26 +122,26 @@ public class AccountDatabaseCrawler implements Managed, Runnable {
} }
private void processChunk() { private void processChunk() {
Optional<String> fromNumber = cache.getLastNumber(); Optional<UUID> fromUuid = cache.getLastUuid();
if (!fromNumber.isPresent()) { if (!fromUuid.isPresent()) {
listeners.forEach(listener -> { listener.onCrawlStart(); }); listeners.forEach(AccountDatabaseCrawlerListener::onCrawlStart);
} }
List<Account> chunkAccounts = readChunk(fromNumber, chunkSize); List<Account> chunkAccounts = readChunk(fromUuid, chunkSize);
if (chunkAccounts.isEmpty()) { if (chunkAccounts.isEmpty()) {
listeners.forEach(listener -> { listener.onCrawlEnd(fromNumber); }); listeners.forEach(listener -> listener.onCrawlEnd(fromUuid));
cache.setLastNumber(Optional.empty()); cache.setLastUuid(Optional.empty());
cache.clearAccelerate(); cache.clearAccelerate();
} else { } else {
try { try {
for (AccountDatabaseCrawlerListener listener : listeners) { for (AccountDatabaseCrawlerListener listener : listeners) {
listener.onCrawlChunk(fromNumber, chunkAccounts); listener.onCrawlChunk(fromUuid, chunkAccounts);
} }
cache.setLastNumber(Optional.of(chunkAccounts.get(chunkAccounts.size() - 1).getNumber())); cache.setLastUuid(Optional.of(chunkAccounts.get(chunkAccounts.size() - 1).getUuid()));
} catch (AccountDatabaseCrawlerRestartException e) { } catch (AccountDatabaseCrawlerRestartException e) {
cache.setLastNumber(Optional.empty()); cache.setLastUuid(Optional.empty());
cache.clearAccelerate(); cache.clearAccelerate();
} }
@ -149,12 +149,12 @@ public class AccountDatabaseCrawler implements Managed, Runnable {
} }
private List<Account> readChunk(Optional<String> fromNumber, int chunkSize) { private List<Account> readChunk(Optional<UUID> fromUuid, int chunkSize) {
try (Timer.Context timer = readChunkTimer.time()) { try (Timer.Context timer = readChunkTimer.time()) {
List<Account> chunkAccounts; List<Account> chunkAccounts;
if (fromNumber.isPresent()) { if (fromUuid.isPresent()) {
chunkAccounts = accounts.getAllFrom(fromNumber.get(), chunkSize); chunkAccounts = accounts.getAllFrom(fromUuid.get(), chunkSize);
} else { } else {
chunkAccounts = accounts.getAllFrom(chunkSize); chunkAccounts = accounts.getAllFrom(chunkSize);
} }

View File

@ -23,6 +23,7 @@ import java.io.IOException;
import java.util.Arrays; import java.util.Arrays;
import java.util.List; import java.util.List;
import java.util.Optional; import java.util.Optional;
import java.util.UUID;
import redis.clients.jedis.Jedis; import redis.clients.jedis.Jedis;
@ -30,7 +31,7 @@ import redis.clients.jedis.Jedis;
public class AccountDatabaseCrawlerCache { public class AccountDatabaseCrawlerCache {
private static final String ACTIVE_WORKER_KEY = "account_database_crawler_cache_active_worker"; private static final String ACTIVE_WORKER_KEY = "account_database_crawler_cache_active_worker";
private static final String LAST_NUMBER_KEY = "account_database_crawler_cache_last_number"; private static final String LAST_UUID_KEY = "account_database_crawler_cache_last_uuid";
private static final String ACCELERATE_KEY = "account_database_crawler_cache_accelerate"; private static final String ACCELERATE_KEY = "account_database_crawler_cache_accelerate";
private static final long LAST_NUMBER_TTL_MS = 86400_000L; private static final long LAST_NUMBER_TTL_MS = 86400_000L;
@ -67,18 +68,21 @@ public class AccountDatabaseCrawlerCache {
luaScript.execute(keys, args); luaScript.execute(keys, args);
} }
public Optional<String> getLastNumber() { public Optional<UUID> getLastUuid() {
try (Jedis jedis = jedisPool.getWriteResource()) { try (Jedis jedis = jedisPool.getWriteResource()) {
return Optional.ofNullable(jedis.get(LAST_NUMBER_KEY)); String lastUuidString = jedis.get(LAST_UUID_KEY);
if (lastUuidString == null) return Optional.empty();
else return Optional.of(UUID.fromString(lastUuidString));
} }
} }
public void setLastNumber(Optional<String> lastNumber) { public void setLastUuid(Optional<UUID> lastUuid) {
try (Jedis jedis = jedisPool.getWriteResource()) { try (Jedis jedis = jedisPool.getWriteResource()) {
if (lastNumber.isPresent()) { if (lastUuid.isPresent()) {
jedis.psetex(LAST_NUMBER_KEY, LAST_NUMBER_TTL_MS, lastNumber.get()); jedis.psetex(LAST_UUID_KEY, LAST_NUMBER_TTL_MS, lastUuid.get().toString());
} else { } else {
jedis.del(LAST_NUMBER_KEY); jedis.del(LAST_UUID_KEY);
} }
} }
} }

View File

@ -18,10 +18,11 @@ package org.whispersystems.textsecuregcm.storage;
import java.util.List; import java.util.List;
import java.util.Optional; import java.util.Optional;
import java.util.UUID;
@SuppressWarnings("OptionalUsedAsFieldOrParameterType") @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
public interface AccountDatabaseCrawlerListener { public interface AccountDatabaseCrawlerListener {
void onCrawlStart(); void onCrawlStart();
void onCrawlChunk(Optional<String> fromNumber, List<Account> chunkAccounts) throws AccountDatabaseCrawlerRestartException; void onCrawlChunk(Optional<UUID> fromUuid, List<Account> chunkAccounts) throws AccountDatabaseCrawlerRestartException;
void onCrawlEnd(Optional<String> fromNumber); void onCrawlEnd(Optional<UUID> fromUuid);
} }

View File

@ -111,10 +111,10 @@ public class Accounts {
})); }));
} }
public List<Account> getAllFrom(String from, int length) { public List<Account> getAllFrom(UUID from, int length) {
return database.with(jdbi -> jdbi.withHandle(handle -> { return database.with(jdbi -> jdbi.withHandle(handle -> {
try (Timer.Context ignored = getAllFromOffsetTimer.time()) { try (Timer.Context ignored = getAllFromOffsetTimer.time()) {
return handle.createQuery("SELECT * FROM accounts WHERE " + NUMBER + " > :from ORDER BY " + NUMBER + " LIMIT :limit") return handle.createQuery("SELECT * FROM accounts WHERE " + UID + " > :from ORDER BY " + UID + " LIMIT :limit")
.bind("from", from) .bind("from", from)
.bind("limit", length) .bind("limit", length)
.mapTo(Account.class) .mapTo(Account.class)
@ -126,7 +126,7 @@ public class Accounts {
public List<Account> getAllFrom(int length) { public List<Account> getAllFrom(int length) {
return database.with(jdbi -> jdbi.withHandle(handle -> { return database.with(jdbi -> jdbi.withHandle(handle -> {
try (Timer.Context ignored = getAllFromTimer.time()) { try (Timer.Context ignored = getAllFromTimer.time()) {
return handle.createQuery("SELECT * FROM accounts ORDER BY " + NUMBER + " LIMIT :limit") return handle.createQuery("SELECT * FROM accounts ORDER BY " + UID + " LIMIT :limit")
.bind("limit", length) .bind("limit", length)
.mapTo(Account.class) .mapTo(Account.class)
.list(); .list();

View File

@ -121,8 +121,8 @@ public class AccountsManager {
return accounts.getAllFrom(length); return accounts.getAllFrom(length);
} }
public List<Account> getAllFrom(String number, int length) { public List<Account> getAllFrom(UUID uuid, int length) {
return accounts.getAllFrom(number, length); return accounts.getAllFrom(uuid, length);
} }
private void updateDirectory(Account account) { private void updateDirectory(Account account) {

View File

@ -30,6 +30,7 @@ import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Optional; import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import io.dropwizard.metrics.MetricsFactory; import io.dropwizard.metrics.MetricsFactory;
@ -43,8 +44,6 @@ public class ActiveUserCounter implements AccountDatabaseCrawlerListener {
private static final String PLATFORM_IOS = "ios"; private static final String PLATFORM_IOS = "ios";
private static final String PLATFORM_ANDROID = "android"; private static final String PLATFORM_ANDROID = "android";
private static final String FIRST_FROM_NUMBER = "+";
private static final String INTERVALS[] = {"daily", "weekly", "monthly", "quarterly", "yearly"}; private static final String INTERVALS[] = {"daily", "weekly", "monthly", "quarterly", "yearly"};
private final MetricsFactory metricsFactory; private final MetricsFactory metricsFactory;
@ -64,7 +63,7 @@ public class ActiveUserCounter implements AccountDatabaseCrawlerListener {
} }
@Override @Override
public void onCrawlChunk(Optional<String> fromNumber, List<Account> chunkAccounts) { public void onCrawlChunk(Optional<UUID> fromNumber, List<Account> chunkAccounts) {
long nowDays = TimeUnit.MILLISECONDS.toDays(System.currentTimeMillis()); long nowDays = TimeUnit.MILLISECONDS.toDays(System.currentTimeMillis());
long agoMs[] = {TimeUnit.DAYS.toMillis(nowDays - 1), long agoMs[] = {TimeUnit.DAYS.toMillis(nowDays - 1),
TimeUnit.DAYS.toMillis(nowDays - 7), TimeUnit.DAYS.toMillis(nowDays - 7),
@ -107,12 +106,11 @@ public class ActiveUserCounter implements AccountDatabaseCrawlerListener {
} }
} }
incrementTallies(fromNumber.orElse(FIRST_FROM_NUMBER), platformIncrements, countryIncrements); incrementTallies(fromNumber.orElse(UUID.randomUUID()), platformIncrements, countryIncrements);
} }
@Override @Override
public void onCrawlEnd(Optional<String> fromNumber) { public void onCrawlEnd(Optional<UUID> fromNumber) {
MetricRegistry metrics = new MetricRegistry(); MetricRegistry metrics = new MetricRegistry();
long intervalTallies[] = new long[INTERVALS.length]; long intervalTallies[] = new long[INTERVALS.length];
ActiveUserTally activeUserTally = getFinalTallies(); ActiveUserTally activeUserTally = getFinalTallies();
@ -156,17 +154,18 @@ public class ActiveUserCounter implements AccountDatabaseCrawlerListener {
return tally; return tally;
} }
private void incrementTallies(String fromNumber, Map<String, long[]> platformIncrements, Map<String, long[]> countryIncrements) { private void incrementTallies(UUID fromUuid, Map<String, long[]> platformIncrements, Map<String, long[]> countryIncrements) {
try (Jedis jedis = jedisPool.getWriteResource()) { try (Jedis jedis = jedisPool.getWriteResource()) {
String tallyValue = jedis.get(TALLY_KEY); String tallyValue = jedis.get(TALLY_KEY);
ActiveUserTally activeUserTally; ActiveUserTally activeUserTally;
if (tallyValue == null) { if (tallyValue == null) {
activeUserTally = new ActiveUserTally(fromNumber, platformIncrements, countryIncrements); activeUserTally = new ActiveUserTally(fromUuid, platformIncrements, countryIncrements);
} else { } else {
activeUserTally = mapper.readValue(tallyValue, ActiveUserTally.class); activeUserTally = mapper.readValue(tallyValue, ActiveUserTally.class);
if (activeUserTally.getFromNumber() != fromNumber) {
activeUserTally.setFromNumber(fromNumber); if (!fromUuid.equals(activeUserTally.getFromUuid())) {
activeUserTally.setFromUuid(fromUuid);
Map<String, long[]> platformTallies = activeUserTally.getPlatforms(); Map<String, long[]> platformTallies = activeUserTally.getPlatforms();
addTallyMaps(platformTallies, platformIncrements); addTallyMaps(platformTallies, platformIncrements);
Map<String, long[]> countryTallies = activeUserTally.getCountries(); Map<String, long[]> countryTallies = activeUserTally.getCountries();

View File

@ -30,9 +30,12 @@ import org.whispersystems.textsecuregcm.util.Constants;
import org.whispersystems.textsecuregcm.util.Util; import org.whispersystems.textsecuregcm.util.Util;
import javax.ws.rs.ProcessingException; import javax.ws.rs.ProcessingException;
import java.util.ArrayList;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.Optional; import java.util.Optional;
import java.util.UUID;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import static com.codahale.metrics.MetricRegistry.name; import static com.codahale.metrics.MetricRegistry.name;
@ -55,16 +58,16 @@ public class DirectoryReconciler implements AccountDatabaseCrawlerListener {
public void onCrawlStart() { } public void onCrawlStart() { }
public void onCrawlEnd(Optional<String> fromNumber) { public void onCrawlEnd(Optional<UUID> fromUuid) {
DirectoryReconciliationRequest request = new DirectoryReconciliationRequest(fromNumber.orElse(null), null, Collections.emptyList()); DirectoryReconciliationRequest request = new DirectoryReconciliationRequest(fromUuid.orElse(null), null, Collections.emptyList());
DirectoryReconciliationResponse response = sendChunk(request); DirectoryReconciliationResponse response = sendChunk(request);
} }
public void onCrawlChunk(Optional<String> fromNumber, List<Account> chunkAccounts) throws AccountDatabaseCrawlerRestartException { public void onCrawlChunk(Optional<UUID> fromUuid, List<Account> chunkAccounts) throws AccountDatabaseCrawlerRestartException {
updateDirectoryCache(chunkAccounts); updateDirectoryCache(chunkAccounts);
DirectoryReconciliationRequest request = createChunkRequest(fromNumber, chunkAccounts); DirectoryReconciliationRequest request = createChunkRequest(fromUuid, chunkAccounts);
DirectoryReconciliationResponse response = sendChunk(request); DirectoryReconciliationResponse response = sendChunk(request);
if (response.getStatus() == DirectoryReconciliationResponse.Status.MISSING) { if (response.getStatus() == DirectoryReconciliationResponse.Status.MISSING) {
throw new AccountDatabaseCrawlerRestartException("directory reconciler missing"); throw new AccountDatabaseCrawlerRestartException("directory reconciler missing");
@ -91,19 +94,21 @@ public class DirectoryReconciler implements AccountDatabaseCrawlerListener {
} }
@SuppressWarnings("OptionalUsedAsFieldOrParameterType") @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
private DirectoryReconciliationRequest createChunkRequest(Optional<String> fromNumber, List<Account> accounts) { private DirectoryReconciliationRequest createChunkRequest(Optional<UUID> fromUuid, List<Account> accounts) {
List<String> numbers = accounts.stream() List<DirectoryReconciliationRequest.User> users = new ArrayList<>(accounts.size());
.filter(Account::isEnabled) for (Account account : accounts) {
.map(Account::getNumber) if (account.isEnabled()) {
.collect(Collectors.toList()); users.add(new DirectoryReconciliationRequest.User(account.getUuid(), account.getNumber()));
}
Optional<String> toNumber = Optional.empty();
if (!accounts.isEmpty()) {
toNumber = Optional.of(accounts.get(accounts.size() - 1).getNumber());
} }
return new DirectoryReconciliationRequest(fromNumber.orElse(null), toNumber.orElse(null), numbers); Optional<UUID> toUuid = Optional.empty();
if (!accounts.isEmpty()) {
toUuid = Optional.of(accounts.get(accounts.size() - 1).getUuid());
}
return new DirectoryReconciliationRequest(fromUuid.orElse(null), toUuid.orElse(null), users);
} }
private DirectoryReconciliationResponse sendChunk(DirectoryReconciliationRequest request) { private DirectoryReconciliationResponse sendChunk(DirectoryReconciliationRequest request) {

View File

@ -51,7 +51,7 @@ public class DirectoryReconciliationClient {
public DirectoryReconciliationResponse sendChunk(DirectoryReconciliationRequest request) { public DirectoryReconciliationResponse sendChunk(DirectoryReconciliationRequest request) {
return client.target(replicationUrl) return client.target(replicationUrl)
.path("/v1/directory/reconcile") .path("/v2/directory/reconcile")
.request(MediaType.APPLICATION_JSON_TYPE) .request(MediaType.APPLICATION_JSON_TYPE)
.put(Entity.json(request), DirectoryReconciliationResponse.class); .put(Entity.json(request), DirectoryReconciliationResponse.class);
} }

View File

@ -9,6 +9,7 @@ import org.whispersystems.textsecuregcm.util.Util;
import java.util.List; import java.util.List;
import java.util.Optional; import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import static com.codahale.metrics.MetricRegistry.name; import static com.codahale.metrics.MetricRegistry.name;
@ -31,7 +32,7 @@ public class PushFeedbackProcessor implements AccountDatabaseCrawlerListener {
public void onCrawlStart() {} public void onCrawlStart() {}
@Override @Override
public void onCrawlChunk(Optional<String> fromNumber, List<Account> chunkAccounts) { public void onCrawlChunk(Optional<UUID> fromUuid, List<Account> chunkAccounts) {
for (Account account : chunkAccounts) { for (Account account : chunkAccounts) {
boolean update = false; boolean update = false;
@ -65,5 +66,5 @@ public class PushFeedbackProcessor implements AccountDatabaseCrawlerListener {
} }
@Override @Override
public void onCrawlEnd(Optional<String> fromNumber) {} public void onCrawlEnd(Optional<UUID> toUuid) {}
} }

View File

@ -29,6 +29,7 @@ import org.whispersystems.textsecuregcm.storage.AccountsManager;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collections; import java.util.Collections;
import java.util.Optional; import java.util.Optional;
import java.util.UUID;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
@ -39,8 +40,8 @@ import static org.mockito.Mockito.*;
public class AccountDatabaseCrawlerTest { public class AccountDatabaseCrawlerTest {
private static final String ACCOUNT1 = "+1"; private static final UUID ACCOUNT1 = UUID.randomUUID();
private static final String ACCOUNT2 = "+2"; private static final UUID ACCOUNT2 = UUID.randomUUID();
private static final int CHUNK_SIZE = 1000; private static final int CHUNK_SIZE = 1000;
private static final long CHUNK_INTERVAL_MS = 30_000L; private static final long CHUNK_INTERVAL_MS = 30_000L;
@ -56,8 +57,8 @@ public class AccountDatabaseCrawlerTest {
@Before @Before
public void setup() { public void setup() {
when(account1.getNumber()).thenReturn(ACCOUNT1); when(account1.getUuid()).thenReturn(ACCOUNT1);
when(account2.getNumber()).thenReturn(ACCOUNT2); when(account2.getUuid()).thenReturn(ACCOUNT2);
when(accounts.getAllFrom(anyInt())).thenReturn(Arrays.asList(account1, account2)); when(accounts.getAllFrom(anyInt())).thenReturn(Arrays.asList(account1, account2));
when(accounts.getAllFrom(eq(ACCOUNT1), anyInt())).thenReturn(Arrays.asList(account2)); when(accounts.getAllFrom(eq(ACCOUNT1), anyInt())).thenReturn(Arrays.asList(account2));
@ -69,20 +70,20 @@ public class AccountDatabaseCrawlerTest {
@Test @Test
public void testCrawlStart() throws AccountDatabaseCrawlerRestartException { public void testCrawlStart() throws AccountDatabaseCrawlerRestartException {
when(cache.getLastNumber()).thenReturn(Optional.empty()); when(cache.getLastUuid()).thenReturn(Optional.empty());
boolean accelerated = crawler.doPeriodicWork(); boolean accelerated = crawler.doPeriodicWork();
assertThat(accelerated).isFalse(); assertThat(accelerated).isFalse();
verify(cache, times(1)).claimActiveWork(any(String.class), anyLong()); verify(cache, times(1)).claimActiveWork(any(String.class), anyLong());
verify(cache, times(1)).getLastNumber(); verify(cache, times(1)).getLastUuid();
verify(listener, times(1)).onCrawlStart(); verify(listener, times(1)).onCrawlStart();
verify(accounts, times(1)).getAllFrom(eq(CHUNK_SIZE)); verify(accounts, times(1)).getAllFrom(eq(CHUNK_SIZE));
verify(accounts, times(0)).getAllFrom(any(String.class), eq(CHUNK_SIZE)); verify(accounts, times(0)).getAllFrom(any(UUID.class), eq(CHUNK_SIZE));
verify(account1, times(0)).getNumber(); verify(account1, times(0)).getUuid();
verify(account2, times(1)).getNumber(); verify(account2, times(1)).getUuid();
verify(listener, times(1)).onCrawlChunk(eq(Optional.empty()), eq(Arrays.asList(account1, account2))); verify(listener, times(1)).onCrawlChunk(eq(Optional.empty()), eq(Arrays.asList(account1, account2)));
verify(cache, times(1)).setLastNumber(eq(Optional.of(ACCOUNT2))); verify(cache, times(1)).setLastUuid(eq(Optional.of(ACCOUNT2)));
verify(cache, times(1)).isAccelerated(); verify(cache, times(1)).isAccelerated();
verify(cache, times(1)).releaseActiveWork(any(String.class)); verify(cache, times(1)).releaseActiveWork(any(String.class));
@ -95,18 +96,18 @@ public class AccountDatabaseCrawlerTest {
@Test @Test
public void testCrawlChunk() throws AccountDatabaseCrawlerRestartException { public void testCrawlChunk() throws AccountDatabaseCrawlerRestartException {
when(cache.getLastNumber()).thenReturn(Optional.of(ACCOUNT1)); when(cache.getLastUuid()).thenReturn(Optional.of(ACCOUNT1));
boolean accelerated = crawler.doPeriodicWork(); boolean accelerated = crawler.doPeriodicWork();
assertThat(accelerated).isFalse(); assertThat(accelerated).isFalse();
verify(cache, times(1)).claimActiveWork(any(String.class), anyLong()); verify(cache, times(1)).claimActiveWork(any(String.class), anyLong());
verify(cache, times(1)).getLastNumber(); verify(cache, times(1)).getLastUuid();
verify(accounts, times(0)).getAllFrom(eq(CHUNK_SIZE)); verify(accounts, times(0)).getAllFrom(eq(CHUNK_SIZE));
verify(accounts, times(1)).getAllFrom(eq(ACCOUNT1), eq(CHUNK_SIZE)); verify(accounts, times(1)).getAllFrom(eq(ACCOUNT1), eq(CHUNK_SIZE));
verify(account2, times(1)).getNumber(); verify(account2, times(1)).getUuid();
verify(listener, times(1)).onCrawlChunk(eq(Optional.of(ACCOUNT1)), eq(Arrays.asList(account2))); verify(listener, times(1)).onCrawlChunk(eq(Optional.of(ACCOUNT1)), eq(Arrays.asList(account2)));
verify(cache, times(1)).setLastNumber(eq(Optional.of(ACCOUNT2))); verify(cache, times(1)).setLastUuid(eq(Optional.of(ACCOUNT2)));
verify(cache, times(1)).isAccelerated(); verify(cache, times(1)).isAccelerated();
verify(cache, times(1)).releaseActiveWork(any(String.class)); verify(cache, times(1)).releaseActiveWork(any(String.class));
@ -121,18 +122,18 @@ public class AccountDatabaseCrawlerTest {
@Test @Test
public void testCrawlChunkAccelerated() throws AccountDatabaseCrawlerRestartException { public void testCrawlChunkAccelerated() throws AccountDatabaseCrawlerRestartException {
when(cache.isAccelerated()).thenReturn(true); when(cache.isAccelerated()).thenReturn(true);
when(cache.getLastNumber()).thenReturn(Optional.of(ACCOUNT1)); when(cache.getLastUuid()).thenReturn(Optional.of(ACCOUNT1));
boolean accelerated = crawler.doPeriodicWork(); boolean accelerated = crawler.doPeriodicWork();
assertThat(accelerated).isTrue(); assertThat(accelerated).isTrue();
verify(cache, times(1)).claimActiveWork(any(String.class), anyLong()); verify(cache, times(1)).claimActiveWork(any(String.class), anyLong());
verify(cache, times(1)).getLastNumber(); verify(cache, times(1)).getLastUuid();
verify(accounts, times(0)).getAllFrom(eq(CHUNK_SIZE)); verify(accounts, times(0)).getAllFrom(eq(CHUNK_SIZE));
verify(accounts, times(1)).getAllFrom(eq(ACCOUNT1), eq(CHUNK_SIZE)); verify(accounts, times(1)).getAllFrom(eq(ACCOUNT1), eq(CHUNK_SIZE));
verify(account2, times(1)).getNumber(); verify(account2, times(1)).getUuid();
verify(listener, times(1)).onCrawlChunk(eq(Optional.of(ACCOUNT1)), eq(Arrays.asList(account2))); verify(listener, times(1)).onCrawlChunk(eq(Optional.of(ACCOUNT1)), eq(Arrays.asList(account2)));
verify(cache, times(1)).setLastNumber(eq(Optional.of(ACCOUNT2))); verify(cache, times(1)).setLastUuid(eq(Optional.of(ACCOUNT2)));
verify(cache, times(1)).isAccelerated(); verify(cache, times(1)).isAccelerated();
verify(cache, times(1)).releaseActiveWork(any(String.class)); verify(cache, times(1)).releaseActiveWork(any(String.class));
@ -146,19 +147,19 @@ public class AccountDatabaseCrawlerTest {
@Test @Test
public void testCrawlChunkRestart() throws AccountDatabaseCrawlerRestartException { public void testCrawlChunkRestart() throws AccountDatabaseCrawlerRestartException {
when(cache.getLastNumber()).thenReturn(Optional.of(ACCOUNT1)); when(cache.getLastUuid()).thenReturn(Optional.of(ACCOUNT1));
doThrow(AccountDatabaseCrawlerRestartException.class).when(listener).onCrawlChunk(eq(Optional.of(ACCOUNT1)), eq(Arrays.asList(account2))); doThrow(AccountDatabaseCrawlerRestartException.class).when(listener).onCrawlChunk(eq(Optional.of(ACCOUNT1)), eq(Arrays.asList(account2)));
boolean accelerated = crawler.doPeriodicWork(); boolean accelerated = crawler.doPeriodicWork();
assertThat(accelerated).isFalse(); assertThat(accelerated).isFalse();
verify(cache, times(1)).claimActiveWork(any(String.class), anyLong()); verify(cache, times(1)).claimActiveWork(any(String.class), anyLong());
verify(cache, times(1)).getLastNumber(); verify(cache, times(1)).getLastUuid();
verify(accounts, times(0)).getAllFrom(eq(CHUNK_SIZE)); verify(accounts, times(0)).getAllFrom(eq(CHUNK_SIZE));
verify(accounts, times(1)).getAllFrom(eq(ACCOUNT1), eq(CHUNK_SIZE)); verify(accounts, times(1)).getAllFrom(eq(ACCOUNT1), eq(CHUNK_SIZE));
verify(account2, times(0)).getNumber(); verify(account2, times(0)).getNumber();
verify(listener, times(1)).onCrawlChunk(eq(Optional.of(ACCOUNT1)), eq(Arrays.asList(account2))); verify(listener, times(1)).onCrawlChunk(eq(Optional.of(ACCOUNT1)), eq(Arrays.asList(account2)));
verify(cache, times(1)).setLastNumber(eq(Optional.empty())); verify(cache, times(1)).setLastUuid(eq(Optional.empty()));
verify(cache, times(1)).clearAccelerate(); verify(cache, times(1)).clearAccelerate();
verify(cache, times(1)).isAccelerated(); verify(cache, times(1)).isAccelerated();
verify(cache, times(1)).releaseActiveWork(any(String.class)); verify(cache, times(1)).releaseActiveWork(any(String.class));
@ -173,19 +174,19 @@ public class AccountDatabaseCrawlerTest {
@Test @Test
public void testCrawlEnd() { public void testCrawlEnd() {
when(cache.getLastNumber()).thenReturn(Optional.of(ACCOUNT2)); when(cache.getLastUuid()).thenReturn(Optional.of(ACCOUNT2));
boolean accelerated = crawler.doPeriodicWork(); boolean accelerated = crawler.doPeriodicWork();
assertThat(accelerated).isFalse(); assertThat(accelerated).isFalse();
verify(cache, times(1)).claimActiveWork(any(String.class), anyLong()); verify(cache, times(1)).claimActiveWork(any(String.class), anyLong());
verify(cache, times(1)).getLastNumber(); verify(cache, times(1)).getLastUuid();
verify(accounts, times(0)).getAllFrom(eq(CHUNK_SIZE)); verify(accounts, times(0)).getAllFrom(eq(CHUNK_SIZE));
verify(accounts, times(1)).getAllFrom(eq(ACCOUNT2), eq(CHUNK_SIZE)); verify(accounts, times(1)).getAllFrom(eq(ACCOUNT2), eq(CHUNK_SIZE));
verify(account1, times(0)).getNumber(); verify(account1, times(0)).getNumber();
verify(account2, times(0)).getNumber(); verify(account2, times(0)).getNumber();
verify(listener, times(1)).onCrawlEnd(eq(Optional.of(ACCOUNT2))); verify(listener, times(1)).onCrawlEnd(eq(Optional.of(ACCOUNT2)));
verify(cache, times(1)).setLastNumber(eq(Optional.empty())); verify(cache, times(1)).setLastUuid(eq(Optional.empty()));
verify(cache, times(1)).clearAccelerate(); verify(cache, times(1)).clearAccelerate();
verify(cache, times(1)).isAccelerated(); verify(cache, times(1)).isAccelerated();
verify(cache, times(1)).releaseActiveWork(any(String.class)); verify(cache, times(1)).releaseActiveWork(any(String.class));

View File

@ -173,6 +173,8 @@ public class AccountsTest {
accounts.create(account); accounts.create(account);
} }
users.sort((account, t1) -> UUIDComparator.staticCompare(account.getUuid(), t1.getUuid()));
List<Account> retrieved = accounts.getAllFrom(10); List<Account> retrieved = accounts.getAllFrom(10);
assertThat(retrieved.size()).isEqualTo(10); assertThat(retrieved.size()).isEqualTo(10);
@ -181,7 +183,7 @@ public class AccountsTest {
} }
for (int j=0;j<9;j++) { for (int j=0;j<9;j++) {
retrieved = accounts.getAllFrom(retrieved.get(9).getNumber(), 10); retrieved = accounts.getAllFrom(retrieved.get(9).getUuid(), 10);
assertThat(retrieved.size()).isEqualTo(10); assertThat(retrieved.size()).isEqualTo(10);
for (int i=0;i<retrieved.size();i++) { for (int i=0;i<retrieved.size();i++) {

View File

@ -31,6 +31,7 @@ import org.junit.Test;
import redis.clients.jedis.Jedis; import redis.clients.jedis.Jedis;
import java.util.Arrays; import java.util.Arrays;
import java.util.UUID;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import java.util.Optional; import java.util.Optional;
@ -46,9 +47,13 @@ import static org.mockito.Mockito.when;
public class ActiveUserCounterTest { public class ActiveUserCounterTest {
private final String NUMBER_IOS = "+15551234567"; private final UUID UUID_IOS = UUID.randomUUID();
private final String NUMBER_ANDROID = "+5511987654321"; private final UUID UUID_ANDROID = UUID.randomUUID();
private final String NUMBER_NODEVICE = "+5215551234567"; private final UUID UUID_NODEVICE = UUID.randomUUID();
private final String ACCOUNT_NUMBER_IOS = "+15551234567";
private final String ACCOUNT_NUMBER_ANDROID = "+5511987654321";
private final String ACCOUNT_NUMBER_NODEVICE = "+5215551234567";
private final String TALLY_KEY = "active_user_tally"; private final String TALLY_KEY = "active_user_tally";
@ -79,14 +84,17 @@ public class ActiveUserCounterTest {
when(iosDevice.getGcmId()).thenReturn(null); when(iosDevice.getGcmId()).thenReturn(null);
when(iosDevice.getLastSeen()).thenReturn(halfDayAgo); when(iosDevice.getLastSeen()).thenReturn(halfDayAgo);
when(iosAccount.getNumber()).thenReturn(NUMBER_IOS); when(iosAccount.getUuid()).thenReturn(UUID_IOS);
when(iosAccount.getMasterDevice()).thenReturn(Optional.of(iosDevice)); when(iosAccount.getMasterDevice()).thenReturn(Optional.of(iosDevice));
when(iosAccount.getNumber()).thenReturn(ACCOUNT_NUMBER_IOS);
when(androidAccount.getNumber()).thenReturn(NUMBER_ANDROID); when(androidAccount.getUuid()).thenReturn(UUID_ANDROID);
when(androidAccount.getMasterDevice()).thenReturn(Optional.of(androidDevice)); when(androidAccount.getMasterDevice()).thenReturn(Optional.of(androidDevice));
when(androidAccount.getNumber()).thenReturn(ACCOUNT_NUMBER_ANDROID);
when(noDeviceAccount.getNumber()).thenReturn(NUMBER_NODEVICE); when(noDeviceAccount.getUuid()).thenReturn(UUID_NODEVICE);
when(noDeviceAccount.getMasterDevice()).thenReturn(Optional.ofNullable(null)); when(noDeviceAccount.getMasterDevice()).thenReturn(Optional.ofNullable(null));
when(noDeviceAccount.getNumber()).thenReturn(ACCOUNT_NUMBER_NODEVICE);
when(jedis.get(any(String.class))).thenReturn("{\"fromNumber\":\"+\",\"platforms\":{},\"countries\":{}}"); when(jedis.get(any(String.class))).thenReturn("{\"fromNumber\":\"+\",\"platforms\":{},\"countries\":{}}");
when(jedisPool.getWriteResource()).thenReturn(jedis); when(jedisPool.getWriteResource()).thenReturn(jedis);
@ -137,7 +145,7 @@ public class ActiveUserCounterTest {
@Test @Test
public void testCrawlChunkValidAccount() throws AccountDatabaseCrawlerRestartException { public void testCrawlChunkValidAccount() throws AccountDatabaseCrawlerRestartException {
activeUserCounter.onCrawlChunk(Optional.of(NUMBER_IOS), Arrays.asList(iosAccount)); activeUserCounter.onCrawlChunk(Optional.of(UUID_IOS), Arrays.asList(iosAccount));
verify(iosAccount, times(1)).getMasterDevice(); verify(iosAccount, times(1)).getMasterDevice();
verify(iosAccount, times(1)).getNumber(); verify(iosAccount, times(1)).getNumber();
@ -148,7 +156,7 @@ public class ActiveUserCounterTest {
verify(jedisPool, times(1)).getWriteResource(); verify(jedisPool, times(1)).getWriteResource();
verify(jedis, times(1)).get(any(String.class)); verify(jedis, times(1)).get(any(String.class));
verify(jedis, times(1)).set(any(String.class), eq("{\"fromNumber\":\""+NUMBER_IOS+"\",\"platforms\":{\"ios\":[1,1,1,1,1]},\"countries\":{\"1\":[1,1,1,1,1]}}")); verify(jedis, times(1)).set(any(String.class), eq("{\"fromUuid\":\""+UUID_IOS.toString()+"\",\"platforms\":{\"ios\":[1,1,1,1,1]},\"countries\":{\"1\":[1,1,1,1,1]}}"));
verify(jedis, times(1)).close(); verify(jedis, times(1)).close();
verify(metricsFactory, times(0)).getReporters(); verify(metricsFactory, times(0)).getReporters();
@ -166,13 +174,13 @@ public class ActiveUserCounterTest {
@Test @Test
public void testCrawlChunkNoDeviceAccount() throws AccountDatabaseCrawlerRestartException { public void testCrawlChunkNoDeviceAccount() throws AccountDatabaseCrawlerRestartException {
activeUserCounter.onCrawlChunk(Optional.of(NUMBER_NODEVICE), Arrays.asList(noDeviceAccount)); activeUserCounter.onCrawlChunk(Optional.of(UUID_NODEVICE), Arrays.asList(noDeviceAccount));
verify(noDeviceAccount, times(1)).getMasterDevice(); verify(noDeviceAccount, times(1)).getMasterDevice();
verify(jedisPool, times(1)).getWriteResource(); verify(jedisPool, times(1)).getWriteResource();
verify(jedis, times(1)).get(eq(TALLY_KEY)); verify(jedis, times(1)).get(eq(TALLY_KEY));
verify(jedis, times(1)).set(any(String.class), eq("{\"fromNumber\":\""+NUMBER_NODEVICE+"\",\"platforms\":{},\"countries\":{}}")); verify(jedis, times(1)).set(any(String.class), eq("{\"fromUuid\":\""+UUID_NODEVICE+"\",\"platforms\":{},\"countries\":{}}"));
verify(jedis, times(1)).close(); verify(jedis, times(1)).close();
verify(metricsFactory, times(0)).getReporters(); verify(metricsFactory, times(0)).getReporters();
@ -190,7 +198,7 @@ public class ActiveUserCounterTest {
@Test @Test
public void testCrawlChunkMixedAccount() throws AccountDatabaseCrawlerRestartException { public void testCrawlChunkMixedAccount() throws AccountDatabaseCrawlerRestartException {
activeUserCounter.onCrawlChunk(Optional.of(NUMBER_IOS), Arrays.asList(iosAccount, androidAccount, noDeviceAccount)); activeUserCounter.onCrawlChunk(Optional.of(UUID_IOS), Arrays.asList(iosAccount, androidAccount, noDeviceAccount));
verify(iosAccount, times(1)).getMasterDevice(); verify(iosAccount, times(1)).getMasterDevice();
verify(iosAccount, times(1)).getNumber(); verify(iosAccount, times(1)).getNumber();
@ -208,7 +216,7 @@ public class ActiveUserCounterTest {
verify(jedisPool, times(1)).getWriteResource(); verify(jedisPool, times(1)).getWriteResource();
verify(jedis, times(1)).get(eq(TALLY_KEY)); verify(jedis, times(1)).get(eq(TALLY_KEY));
verify(jedis, times(1)).set(any(String.class), eq("{\"fromNumber\":\""+NUMBER_IOS+"\",\"platforms\":{\"android\":[0,0,0,1,1],\"ios\":[1,1,1,1,1]},\"countries\":{\"55\":[0,0,0,1,1],\"1\":[1,1,1,1,1]}}")); verify(jedis, times(1)).set(any(String.class), eq("{\"fromUuid\":\""+UUID_IOS+"\",\"platforms\":{\"android\":[0,0,0,1,1],\"ios\":[1,1,1,1,1]},\"countries\":{\"55\":[0,0,0,1,1],\"1\":[1,1,1,1,1]}}"));
verify(jedis, times(1)).close(); verify(jedis, times(1)).close();
verify(metricsFactory, times(0)).getReporters(); verify(metricsFactory, times(0)).getReporters();

View File

@ -33,6 +33,7 @@ import org.whispersystems.textsecuregcm.util.Util;
import java.util.Arrays; import java.util.Arrays;
import java.util.Optional; import java.util.Optional;
import java.util.UUID;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
@ -40,8 +41,10 @@ import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.*; import static org.mockito.Mockito.*;
public class DirectoryReconcilerTest { public class DirectoryReconcilerTest {
private static final String VALID_NUMBER = "valid"; private static final UUID VALID_UUID = UUID.randomUUID();
private static final String INACTIVE_NUMBER = "inactive"; private static final String VALID_NUMBERRR = "+14152222222";
private static final UUID INACTIVE_UUID = UUID.randomUUID();
private static final String INACTIVE_NUMBERRR = "+14151111111";
private final Account activeAccount = mock(Account.class); private final Account activeAccount = mock(Account.class);
private final Account inactiveAccount = mock(Account.class); private final Account inactiveAccount = mock(Account.class);
@ -55,9 +58,11 @@ public class DirectoryReconcilerTest {
@Before @Before
public void setup() { public void setup() {
when(activeAccount.getNumber()).thenReturn(VALID_NUMBER); when(activeAccount.getUuid()).thenReturn(VALID_UUID);
when(activeAccount.isEnabled()).thenReturn(true); when(activeAccount.isEnabled()).thenReturn(true);
when(inactiveAccount.getNumber()).thenReturn(INACTIVE_NUMBER); when(activeAccount.getNumber()).thenReturn(VALID_NUMBERRR);
when(inactiveAccount.getUuid()).thenReturn(INACTIVE_UUID);
when(inactiveAccount.getNumber()).thenReturn(INACTIVE_NUMBERRR);
when(inactiveAccount.isEnabled()).thenReturn(false); when(inactiveAccount.isEnabled()).thenReturn(false);
when(directoryManager.startBatchOperation()).thenReturn(batchOperationHandle); when(directoryManager.startBatchOperation()).thenReturn(batchOperationHandle);
} }
@ -65,27 +70,29 @@ public class DirectoryReconcilerTest {
@Test @Test
public void testCrawlChunkValid() throws AccountDatabaseCrawlerRestartException { public void testCrawlChunkValid() throws AccountDatabaseCrawlerRestartException {
when(reconciliationClient.sendChunk(any())).thenReturn(successResponse); when(reconciliationClient.sendChunk(any())).thenReturn(successResponse);
directoryReconciler.onCrawlChunk(Optional.of(VALID_NUMBER), Arrays.asList(activeAccount, inactiveAccount)); directoryReconciler.onCrawlChunk(Optional.of(VALID_UUID), Arrays.asList(activeAccount, inactiveAccount));
verify(activeAccount, atLeastOnce()).getUuid();
verify(activeAccount, atLeastOnce()).getNumber(); verify(activeAccount, atLeastOnce()).getNumber();
verify(activeAccount, atLeastOnce()).isEnabled(); verify(activeAccount, atLeastOnce()).isEnabled();
verify(inactiveAccount, atLeastOnce()).getUuid();
verify(inactiveAccount, atLeastOnce()).getNumber(); verify(inactiveAccount, atLeastOnce()).getNumber();
verify(inactiveAccount, atLeastOnce()).isEnabled(); verify(inactiveAccount, atLeastOnce()).isEnabled();
ArgumentCaptor<DirectoryReconciliationRequest> request = ArgumentCaptor.forClass(DirectoryReconciliationRequest.class); ArgumentCaptor<DirectoryReconciliationRequest> request = ArgumentCaptor.forClass(DirectoryReconciliationRequest.class);
verify(reconciliationClient, times(1)).sendChunk(request.capture()); verify(reconciliationClient, times(1)).sendChunk(request.capture());
assertThat(request.getValue().getFromNumber()).isEqualTo(VALID_NUMBER); assertThat(request.getValue().getFromUuid()).isEqualTo(VALID_UUID);
assertThat(request.getValue().getToNumber()).isEqualTo(INACTIVE_NUMBER); assertThat(request.getValue().getToUuid()).isEqualTo(INACTIVE_UUID);
assertThat(request.getValue().getNumbers()).isEqualTo(Arrays.asList(VALID_NUMBER)); assertThat(request.getValue().getUsers()).isEqualTo(Arrays.asList(new DirectoryReconciliationRequest.User(VALID_UUID, VALID_NUMBERRR)));
ArgumentCaptor<ClientContact> addedContact = ArgumentCaptor.forClass(ClientContact.class); ArgumentCaptor<ClientContact> addedContact = ArgumentCaptor.forClass(ClientContact.class);
verify(directoryManager, times(1)).startBatchOperation(); verify(directoryManager, times(1)).startBatchOperation();
verify(directoryManager, times(1)).add(eq(batchOperationHandle), addedContact.capture()); verify(directoryManager, times(1)).add(eq(batchOperationHandle), addedContact.capture());
verify(directoryManager, times(1)).remove(eq(batchOperationHandle), eq(INACTIVE_NUMBER)); verify(directoryManager, times(1)).remove(eq(batchOperationHandle), eq(INACTIVE_NUMBERRR));
verify(directoryManager, times(1)).stopBatchOperation(eq(batchOperationHandle)); verify(directoryManager, times(1)).stopBatchOperation(eq(batchOperationHandle));
assertThat(addedContact.getValue().getToken()).isEqualTo(Util.getContactToken(VALID_NUMBER)); assertThat(addedContact.getValue().getToken()).isEqualTo(Util.getContactToken(VALID_NUMBERRR));
verifyNoMoreInteractions(activeAccount); verifyNoMoreInteractions(activeAccount);
verifyNoMoreInteractions(inactiveAccount); verifyNoMoreInteractions(inactiveAccount);

View File

@ -13,6 +13,7 @@ import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.Optional; import java.util.Optional;
import java.util.Set; import java.util.Set;
import java.util.UUID;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import static org.mockito.Mockito.*; import static org.mockito.Mockito.*;
@ -62,7 +63,7 @@ public class PushFeedbackProcessorTest {
@Test @Test
public void testEmpty() { public void testEmpty() {
PushFeedbackProcessor processor = new PushFeedbackProcessor(accountsManager, directoryQueue); PushFeedbackProcessor processor = new PushFeedbackProcessor(accountsManager, directoryQueue);
processor.onCrawlChunk(Optional.of("+14152222222"), Collections.emptyList()); processor.onCrawlChunk(Optional.of(UUID.randomUUID()), Collections.emptyList());
verifyZeroInteractions(accountsManager); verifyZeroInteractions(accountsManager);
verifyZeroInteractions(directoryQueue); verifyZeroInteractions(directoryQueue);
@ -71,7 +72,7 @@ public class PushFeedbackProcessorTest {
@Test @Test
public void testUpdate() { public void testUpdate() {
PushFeedbackProcessor processor = new PushFeedbackProcessor(accountsManager, directoryQueue); PushFeedbackProcessor processor = new PushFeedbackProcessor(accountsManager, directoryQueue);
processor.onCrawlChunk(Optional.of("+14153333333"), List.of(uninstalledAccount, mixedAccount, stillActiveAccount, freshAccount, cleanAccount)); processor.onCrawlChunk(Optional.of(UUID.randomUUID()), List.of(uninstalledAccount, mixedAccount, stillActiveAccount, freshAccount, cleanAccount));
verify(uninstalledDevice).setApnId(isNull()); verify(uninstalledDevice).setApnId(isNull());
verify(uninstalledDevice).setGcmId(isNull()); verify(uninstalledDevice).setGcmId(isNull());