Examples with OutgoingMessageEntity org.whispersystems.textsecuregcm.entities.OutgoingMessageEntity used on opensource projects

Example 1 with OutgoingMessageEntity

use of org.whispersystems.textsecuregcm.entities.OutgoingMessageEntity in project Signal-Server by signalapp.

the class MessageControllerTest method testGetMessages.

@Test
void testGetMessages() {
    final long timestampOne = 313377;
    final long timestampTwo = 313388;
    final UUID messageGuidOne = UUID.randomUUID();
    final UUID sourceUuid = UUID.randomUUID();
    List<OutgoingMessageEntity> messages = new LinkedList<>() {

        {
            add(new OutgoingMessageEntity(messageGuidOne, Envelope.Type.CIPHERTEXT_VALUE, timestampOne, "+14152222222", sourceUuid, 2, AuthHelper.VALID_UUID, "hi there".getBytes(), 0));
            add(new OutgoingMessageEntity(null, Envelope.Type.SERVER_DELIVERY_RECEIPT_VALUE, timestampTwo, "+14152222222", sourceUuid, 2, AuthHelper.VALID_UUID, null, 0));
        }
    };
    OutgoingMessageEntityList messagesList = new OutgoingMessageEntityList(messages, false);
    when(messagesManager.getMessagesForDevice(eq(AuthHelper.VALID_UUID), eq(1L), anyString(), anyBoolean())).thenReturn(messagesList);
    OutgoingMessageEntityList response = resources.getJerseyTest().target("/v1/messages/").request().header("Authorization", AuthHelper.getAuthHeader(AuthHelper.VALID_UUID, AuthHelper.VALID_PASSWORD)).accept(MediaType.APPLICATION_JSON_TYPE).get(OutgoingMessageEntityList.class);
    assertEquals(response.getMessages().size(), 2);
    assertEquals(response.getMessages().get(0).getTimestamp(), timestampOne);
    assertEquals(response.getMessages().get(1).getTimestamp(), timestampTwo);
    assertEquals(response.getMessages().get(0).getGuid(), messageGuidOne);
    assertNull(response.getMessages().get(1).getGuid());
    assertEquals(response.getMessages().get(0).getSourceUuid(), sourceUuid);
    assertEquals(response.getMessages().get(1).getSourceUuid(), sourceUuid);
}

Example 2 with OutgoingMessageEntity

use of org.whispersystems.textsecuregcm.entities.OutgoingMessageEntity in project Signal-Server by signalapp.

the class MessageControllerTest method testDeleteMessages.

@Test
void testDeleteMessages() throws Exception {
    long timestamp = System.currentTimeMillis();
    UUID sourceUuid = UUID.randomUUID();
    UUID uuid1 = UUID.randomUUID();
    when(messagesManager.delete(AuthHelper.VALID_UUID, 1, uuid1)).thenReturn(Optional.of(new OutgoingMessageEntity(uuid1, Envelope.Type.CIPHERTEXT_VALUE, timestamp, "+14152222222", sourceUuid, 1, AuthHelper.VALID_UUID, "hi".getBytes(), 0)));
    UUID uuid2 = UUID.randomUUID();
    when(messagesManager.delete(AuthHelper.VALID_UUID, 1, uuid2)).thenReturn(Optional.of(new OutgoingMessageEntity(uuid2, Envelope.Type.SERVER_DELIVERY_RECEIPT_VALUE, System.currentTimeMillis(), "+14152222222", sourceUuid, 1, AuthHelper.VALID_UUID, null, 0)));
    UUID uuid3 = UUID.randomUUID();
    when(messagesManager.delete(AuthHelper.VALID_UUID, 1, uuid3)).thenReturn(Optional.empty());
    Response response = resources.getJerseyTest().target(String.format("/v1/messages/uuid/%s", uuid1)).request().header("Authorization", AuthHelper.getAuthHeader(AuthHelper.VALID_UUID, AuthHelper.VALID_PASSWORD)).delete();
    assertThat("Good Response Code", response.getStatus(), is(equalTo(204)));
    verify(receiptSender).sendReceipt(any(AuthenticatedAccount.class), eq(sourceUuid), eq(timestamp));
    response = resources.getJerseyTest().target(String.format("/v1/messages/uuid/%s", uuid2)).request().header("Authorization", AuthHelper.getAuthHeader(AuthHelper.VALID_UUID, AuthHelper.VALID_PASSWORD)).delete();
    assertThat("Good Response Code", response.getStatus(), is(equalTo(204)));
    verifyNoMoreInteractions(receiptSender);
    response = resources.getJerseyTest().target(String.format("/v1/messages/uuid/%s", uuid3)).request().header("Authorization", AuthHelper.getAuthHeader(AuthHelper.VALID_UUID, AuthHelper.VALID_PASSWORD)).delete();
    assertThat("Good Response Code", response.getStatus(), is(equalTo(204)));
    verifyNoMoreInteractions(receiptSender);
}

Example 3 with OutgoingMessageEntity

use of org.whispersystems.textsecuregcm.entities.OutgoingMessageEntity in project Signal-Server by signalapp.

the class MessageControllerTest method testGetMessagesBadAuth.

@Test
void testGetMessagesBadAuth() throws Exception {
    final long timestampOne = 313377;
    final long timestampTwo = 313388;
    List<OutgoingMessageEntity> messages = new LinkedList<OutgoingMessageEntity>() {

        {
            add(new OutgoingMessageEntity(UUID.randomUUID(), Envelope.Type.CIPHERTEXT_VALUE, timestampOne, "+14152222222", UUID.randomUUID(), 2, AuthHelper.VALID_UUID, "hi there".getBytes(), 0));
            add(new OutgoingMessageEntity(UUID.randomUUID(), Envelope.Type.SERVER_DELIVERY_RECEIPT_VALUE, timestampTwo, "+14152222222", UUID.randomUUID(), 2, AuthHelper.VALID_UUID, null, 0));
        }
    };
    OutgoingMessageEntityList messagesList = new OutgoingMessageEntityList(messages, false);
    when(messagesManager.getMessagesForDevice(eq(AuthHelper.VALID_UUID), eq(1L), anyString(), anyBoolean())).thenReturn(messagesList);
    Response response = resources.getJerseyTest().target("/v1/messages/").request().header("Authorization", AuthHelper.getAuthHeader(AuthHelper.VALID_UUID, AuthHelper.INVALID_PASSWORD)).accept(MediaType.APPLICATION_JSON_TYPE).get();
    assertThat("Unauthorized response", response.getStatus(), is(equalTo(401)));
}

Example 4 with OutgoingMessageEntity

use of org.whispersystems.textsecuregcm.entities.OutgoingMessageEntity in project Signal-Server by signalapp.

the class WebSocketConnectionTest method testOpen.

@Test
void testOpen() throws Exception {
    MessagesManager storedMessages = mock(MessagesManager.class);
    UUID accountUuid = UUID.randomUUID();
    UUID senderOneUuid = UUID.randomUUID();
    UUID senderTwoUuid = UUID.randomUUID();
    List<OutgoingMessageEntity> outgoingMessages = new LinkedList<OutgoingMessageEntity>() {

        {
            add(createMessage("sender1", senderOneUuid, UUID.randomUUID(), 1111, false, "first"));
            add(createMessage("sender1", senderOneUuid, UUID.randomUUID(), 2222, false, "second"));
            add(createMessage("sender2", senderTwoUuid, UUID.randomUUID(), 3333, false, "third"));
        }
    };
    OutgoingMessageEntityList outgoingMessagesList = new OutgoingMessageEntityList(outgoingMessages, false);
    when(device.getId()).thenReturn(2L);
    when(account.getNumber()).thenReturn("+14152222222");
    when(account.getUuid()).thenReturn(accountUuid);
    final Device sender1device = mock(Device.class);
    Set<Device> sender1devices = new HashSet<>() {

        {
            add(sender1device);
        }
    };
    Account sender1 = mock(Account.class);
    when(sender1.getDevices()).thenReturn(sender1devices);
    when(accountsManager.getByE164("sender1")).thenReturn(Optional.of(sender1));
    when(accountsManager.getByE164("sender2")).thenReturn(Optional.empty());
    String userAgent = "user-agent";
    when(storedMessages.getMessagesForDevice(account.getUuid(), device.getId(), userAgent, false)).thenReturn(outgoingMessagesList);
    final List<CompletableFuture<WebSocketResponseMessage>> futures = new LinkedList<>();
    final WebSocketClient client = mock(WebSocketClient.class);
    when(client.getUserAgent()).thenReturn(userAgent);
    when(client.sendRequest(eq("PUT"), eq("/api/v1/message"), ArgumentMatchers.nullable(List.class), ArgumentMatchers.<Optional<byte[]>>any())).thenAnswer(new Answer<CompletableFuture<WebSocketResponseMessage>>() {

        @Override
        public CompletableFuture<WebSocketResponseMessage> answer(InvocationOnMock invocationOnMock) {
            CompletableFuture<WebSocketResponseMessage> future = new CompletableFuture<>();
            futures.add(future);
            return future;
        }
    });
    WebSocketConnection connection = new WebSocketConnection(receiptSender, storedMessages, auth, device, client, retrySchedulingExecutor);
    connection.start();
    verify(client, times(3)).sendRequest(eq("PUT"), eq("/api/v1/message"), any(List.class), ArgumentMatchers.<Optional<byte[]>>any());
    assertEquals(3, futures.size());
    WebSocketResponseMessage response = mock(WebSocketResponseMessage.class);
    when(response.getStatus()).thenReturn(200);
    futures.get(1).complete(response);
    futures.get(0).completeExceptionally(new IOException());
    futures.get(2).completeExceptionally(new IOException());
    verify(storedMessages, times(1)).delete(eq(accountUuid), eq(2L), eq(outgoingMessages.get(1).getGuid()));
    verify(receiptSender, times(1)).sendReceipt(eq(auth), eq(senderOneUuid), eq(2222L));
    connection.stop();
    verify(client).close(anyInt(), anyString());
}

Example 5 with OutgoingMessageEntity

use of org.whispersystems.textsecuregcm.entities.OutgoingMessageEntity in project Signal-Server by signalapp.

the class WebSocketConnectionTest method testRequeryOnStateMismatch.

@Test
public void testRequeryOnStateMismatch() {
    final MessagesManager messagesManager = mock(MessagesManager.class);
    final WebSocketClient client = mock(WebSocketClient.class);
    final WebSocketConnection connection = new WebSocketConnection(receiptSender, messagesManager, auth, device, client, retrySchedulingExecutor);
    final UUID accountUuid = UUID.randomUUID();
    when(account.getNumber()).thenReturn("+18005551234");
    when(account.getUuid()).thenReturn(accountUuid);
    when(device.getId()).thenReturn(1L);
    when(client.getUserAgent()).thenReturn("Test-UA");
    final List<OutgoingMessageEntity> firstPageMessages = List.of(createMessage("sender1", UUID.randomUUID(), UUID.randomUUID(), 1111, false, "first"), createMessage("sender1", UUID.randomUUID(), UUID.randomUUID(), 2222, false, "second"));
    final List<OutgoingMessageEntity> secondPageMessages = List.of(createMessage("sender1", UUID.randomUUID(), UUID.randomUUID(), 3333, false, "third"));
    final OutgoingMessageEntityList firstPage = new OutgoingMessageEntityList(firstPageMessages, false);
    final OutgoingMessageEntityList secondPage = new OutgoingMessageEntityList(secondPageMessages, false);
    when(messagesManager.getMessagesForDevice(eq(accountUuid), eq(1L), eq("Test-UA"), anyBoolean())).thenReturn(firstPage).thenReturn(secondPage).thenReturn(new OutgoingMessageEntityList(Collections.emptyList(), false));
    final WebSocketResponseMessage successResponse = mock(WebSocketResponseMessage.class);
    when(successResponse.getStatus()).thenReturn(200);
    final CountDownLatch sendLatch = new CountDownLatch(firstPageMessages.size() + secondPageMessages.size());
    when(client.sendRequest(eq("PUT"), eq("/api/v1/message"), any(List.class), any(Optional.class))).thenAnswer((Answer<CompletableFuture<WebSocketResponseMessage>>) invocation -> {
        connection.handleNewMessagesAvailable();
        sendLatch.countDown();
        return CompletableFuture.completedFuture(successResponse);
    });
    assertTimeoutPreemptively(Duration.ofSeconds(5), () -> {
        connection.processStoredMessages();
        sendLatch.await();
    });
    verify(client, times(firstPageMessages.size() + secondPageMessages.size())).sendRequest(eq("PUT"), eq("/api/v1/message"), any(List.class), any(Optional.class));
    verify(client).sendRequest(eq("PUT"), eq("/api/v1/queue/empty"), any(List.class), eq(Optional.empty()));
}