Refresh accounts from storage when checking for device state changes after requests

service/src/test/java/org/whispersystems/textsecuregcm/auth/AuthEnablementRefreshRequirementProviderTest.java

@@ -11,6 +11,7 @@ import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
@@ -72,6 +73,7 @@ import org.junit.jupiter.params.provider.ValueSource;
 import org.mockito.ArgumentCaptor;
 import org.whispersystems.textsecuregcm.push.ClientPresenceManager;
 import org.whispersystems.textsecuregcm.storage.Account;
+import org.whispersystems.textsecuregcm.storage.AccountsManager;
 import org.whispersystems.textsecuregcm.storage.Device;
 import org.whispersystems.textsecuregcm.tests.util.DevicesHelper;
 import org.whispersystems.websocket.WebSocketResourceProvider;
@@ -104,14 +106,18 @@ class AuthEnablementRefreshRequirementProviderTest {
       .addResource(new TestResource())
       .build();
 
+  private AccountsManager accountsManager;
   private ClientPresenceManager clientPresenceManager;
 
   private AuthEnablementRefreshRequirementProvider provider;
 
   @BeforeEach
   void setup() {
+    accountsManager = mock(AccountsManager.class);
     clientPresenceManager = mock(ClientPresenceManager.class);
-    provider = new AuthEnablementRefreshRequirementProvider();
+
+    provider = new AuthEnablementRefreshRequirementProvider(accountsManager);
+
     final WebsocketRefreshRequestEventListener listener =
         new WebsocketRefreshRequestEventListener(clientPresenceManager, provider);
 
@@ -122,6 +128,8 @@ class AuthEnablementRefreshRequirementProviderTest {
     account.addDevice(authenticatedDevice);
     LongStream.range(2, 4).forEach(deviceId -> account.addDevice(DevicesHelper.createDevice(deviceId)));
 
+    when(accountsManager.get(uuid)).thenReturn(Optional.of(account));
+
     account.getDevices()
         .forEach(device -> when(clientPresenceManager.isPresent(uuid, device.getId())).thenReturn(true));
   }
@@ -301,6 +309,8 @@ class AuthEnablementRefreshRequirementProviderTest {
         .get();
 
     assertEquals(200, response.getStatus());
+
+    verify(accountsManager, never()).get(any(UUID.class));
   }
 
   @Nested
@@ -402,6 +412,7 @@ class AuthEnablementRefreshRequirementProviderTest {
 
     @PUT
     @Path("/account/enabled/{enabled}")
+    @ChangesDeviceEnabledState
     public String setAccountEnabled(@Auth TestPrincipal principal, @PathParam("enabled") final boolean enabled) {
 
       final Device device = principal.getAccount().getMasterDevice().orElseThrow();
@@ -415,6 +426,7 @@ class AuthEnablementRefreshRequirementProviderTest {
 
     @POST
     @Path("/account/devices/enabled")
+    @ChangesDeviceEnabledState
     public String setEnabled(@Auth TestPrincipal principal, Map<Long, Boolean> deviceIdsEnabled) {
 
       final StringBuilder response = new StringBuilder();
@@ -431,6 +443,7 @@ class AuthEnablementRefreshRequirementProviderTest {
 
     @PUT
     @Path("/account/devices")
+    @ChangesDeviceEnabledState
     public String addDevices(@Auth TestPrincipal auth, List<String> deviceNames) {
 
       deviceNames.forEach(name -> {
@@ -445,6 +458,7 @@ class AuthEnablementRefreshRequirementProviderTest {
 
     @DELETE
     @Path("/account/devices/{deviceIds}")
+    @ChangesDeviceEnabledState
     public String removeDevices(@Auth TestPrincipal auth, @PathParam("deviceIds") String deviceIds) {
 
       Arrays.stream(deviceIds.split(","))
@@ -456,6 +470,7 @@ class AuthEnablementRefreshRequirementProviderTest {
 
     @POST
     @Path("/account/disableMasterDeviceAndDeleteDevice/{deviceId}")
+    @ChangesDeviceEnabledState
     public String disableMasterDeviceAndRemoveDevice(@Auth TestPrincipal auth, @PathParam("deviceId") long deviceId) {
 
       DevicesHelper.setEnabled(auth.getAccount().getMasterDevice().orElseThrow(), false);

service/src/test/java/org/whispersystems/textsecuregcm/auth/PhoneNumberChangeRefreshRequirementProviderTest.java

@@ -6,6 +6,7 @@
 package org.whispersystems.textsecuregcm.auth;
 
 import org.glassfish.jersey.server.ContainerRequest;
+import org.glassfish.jersey.server.monitoring.RequestEvent;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.whispersystems.textsecuregcm.storage.Account;
@@ -33,6 +34,7 @@ class PhoneNumberChangeRefreshRequirementProviderTest {
   private PhoneNumberChangeRefreshRequirementProvider provider;
 
   private Account account;
+  private RequestEvent requestEvent;
   private ContainerRequest request;
 
   private static final UUID ACCOUNT_UUID = UUID.randomUUID();
@@ -62,23 +64,26 @@ class PhoneNumberChangeRefreshRequirementProviderTest {
 
     when(request.getProperty(anyString())).thenAnswer(
         invocation -> requestProperties.get(invocation.getArgument(0, String.class)));
+
+    requestEvent = mock(RequestEvent.class);
+    when(requestEvent.getContainerRequest()).thenReturn(request);
   }
 
   @Test
   void handleRequestNoChange() {
     setAuthenticatedAccount(request, account);
 
-    provider.handleRequestFiltered(request);
-    assertEquals(Collections.emptyList(), provider.handleRequestFinished(request));
+    provider.handleRequestFiltered(requestEvent);
+    assertEquals(Collections.emptyList(), provider.handleRequestFinished(requestEvent));
   }
 
   @Test
   void handleRequestNumberChange() {
     setAuthenticatedAccount(request, account);
 
-    provider.handleRequestFiltered(request);
+    provider.handleRequestFiltered(requestEvent);
     when(account.getNumber()).thenReturn(CHANGED_NUMBER);
-    assertEquals(List.of(new Pair<>(ACCOUNT_UUID, Device.MASTER_ID)), provider.handleRequestFinished(request));
+    assertEquals(List.of(new Pair<>(ACCOUNT_UUID, Device.MASTER_ID)), provider.handleRequestFinished(requestEvent));
   }
 
   @Test
@@ -86,11 +91,13 @@ class PhoneNumberChangeRefreshRequirementProviderTest {
     final ContainerRequest request = mock(ContainerRequest.class);
     setAuthenticatedAccount(request, null);
 
-    provider.handleRequestFiltered(request);
-    assertEquals(Collections.emptyList(), provider.handleRequestFinished(request));
+    when(requestEvent.getContainerRequest()).thenReturn(request);
+
+    provider.handleRequestFiltered(requestEvent);
+    assertEquals(Collections.emptyList(), provider.handleRequestFinished(requestEvent));
   }
 
-  private void setAuthenticatedAccount(final ContainerRequest mockRequest, @Nullable final Account account) {
+  private static void setAuthenticatedAccount(final ContainerRequest mockRequest, @Nullable final Account account) {
     final SecurityContext securityContext = mock(SecurityContext.class);
 
     when(mockRequest.getSecurityContext()).thenReturn(securityContext);

service/src/test/java/org/whispersystems/textsecuregcm/tests/controllers/DeviceControllerTest.java

@@ -7,6 +7,7 @@ package org.whispersystems.textsecuregcm.tests.controllers;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.clearInvocations;
 import static org.mockito.Mockito.eq;
 import static org.mockito.Mockito.mock;
@@ -23,6 +24,7 @@ import io.dropwizard.testing.junit5.ResourceExtension;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
 import java.util.stream.Stream;
 import javax.ws.rs.Path;
 import javax.ws.rs.client.Entity;
@@ -39,12 +41,14 @@ import org.junit.jupiter.params.provider.MethodSource;
 import org.whispersystems.textsecuregcm.auth.AuthenticatedAccount;
 import org.whispersystems.textsecuregcm.auth.DisabledPermittedAuthenticatedAccount;
 import org.whispersystems.textsecuregcm.auth.StoredVerificationCode;
+import org.whispersystems.textsecuregcm.auth.WebsocketRefreshApplicationEventListener;
 import org.whispersystems.textsecuregcm.controllers.DeviceController;
 import org.whispersystems.textsecuregcm.entities.AccountAttributes;
 import org.whispersystems.textsecuregcm.entities.DeviceResponse;
 import org.whispersystems.textsecuregcm.limits.RateLimiter;
 import org.whispersystems.textsecuregcm.limits.RateLimiters;
 import org.whispersystems.textsecuregcm.mappers.DeviceLimitExceededExceptionMapper;
+import org.whispersystems.textsecuregcm.push.ClientPresenceManager;
 import org.whispersystems.textsecuregcm.storage.Account;
 import org.whispersystems.textsecuregcm.storage.AccountsManager;
 import org.whispersystems.textsecuregcm.storage.Device;
@@ -85,6 +89,7 @@ class DeviceControllerTest {
   private static Account               account               = mock(Account.class               );
   private static Account               maxedAccount          = mock(Account.class);
   private static Device                masterDevice          = mock(Device.class);
+  private static ClientPresenceManager clientPresenceManager = mock(ClientPresenceManager.class);
 
   private static Map<String, Integer>  deviceConfiguration   = new HashMap<>();
 
@@ -93,6 +98,7 @@ class DeviceControllerTest {
       .addProvider(new PolymorphicAuthValueFactoryProvider.Binder<>(
           ImmutableSet.of(AuthenticatedAccount.class, DisabledPermittedAuthenticatedAccount.class)))
       .setTestContainerFactory(new GrizzlyWebTestContainerFactory())
+      .addProvider(new WebsocketRefreshApplicationEventListener(accountsManager, clientPresenceManager))
       .addProvider(new DeviceLimitExceededExceptionMapper())
       .addResource(new DumbVerificationDeviceController(pendingDevicesManager,
           accountsManager,
@@ -143,12 +149,19 @@ class DeviceControllerTest {
         rateLimiter,
         account,
         maxedAccount,
-        masterDevice
+        masterDevice,
+        clientPresenceManager
     );
   }
 
   @Test
   void validDeviceRegisterTest() {
+    when(accountsManager.get(AuthHelper.VALID_UUID)).thenReturn(Optional.of(AuthHelper.VALID_ACCOUNT));
+
+    final Device existingDevice = mock(Device.class);
+    when(existingDevice.getId()).thenReturn(Device.MASTER_ID);
+    when(AuthHelper.VALID_ACCOUNT.getDevices()).thenReturn(Set.of(existingDevice));
+
     VerificationCode deviceCode = resources.getJerseyTest()
                                            .target("/v1/devices/provisioning/code")
                                            .request()
@@ -170,6 +183,7 @@ class DeviceControllerTest {
 
     verify(pendingDevicesManager).remove(AuthHelper.VALID_NUMBER);
     verify(messagesManager).clear(eq(AuthHelper.VALID_UUID), eq(42L));
+    verify(clientPresenceManager).displacePresence(AuthHelper.VALID_UUID, Device.MASTER_ID);
   }
 
   @Test