@Test public void searchRemoteMessagesSynchronous_shouldNotFetchExistingMessages() throws Exception { setupRemoteSearch(); controller.searchRemoteMessagesSynchronous(ACCOUNT_UUID, FOLDER_NAME, "query", reqFlags, forbiddenFlags, listener); verify(backend, never()).fetchMessage(eq(FOLDER_NAME), eq("newMessageUid1"), fetchProfileCaptor.capture()); }
@Test public void refreshRemoteSynchronous_shouldCallBackend() throws MessagingException { controller.refreshRemoteSynchronous(account, listener); verify(backend).refreshFolderList(); }
public void sendMessageBlocking(Account account, Message message) throws MessagingException { Backend backend = getBackend(account); backend.sendMessage(message); }
remoteUidMap = backend.copyMessages(srcFolder, destFolder, uids); } else { remoteUidMap = backend.moveMessages(srcFolder, destFolder, uids); if (!isCopy && backend.getSupportsExpunge() && account.getExpungePolicy() == Expunge.EXPUNGE_IMMEDIATELY) { Timber.i("processingPendingMoveOrCopy expunging folder %s:%s", account.getDescription(), srcFolder); backend.expungeMessages(srcFolder, uids);
when(backend.search(eq(FOLDER_NAME), anyString(), nullable(Set.class), nullable(Set.class))) .thenReturn(remoteMessages); when(localFolder.extractNewMessages(ArgumentMatchers.<String>anyList())).thenReturn(newRemoteMessages); return null; }).when(backend).fetchMessage( eq(FOLDER_NAME), eq("newMessageUid2"),
@Test public void searchRemoteMessagesSynchronous_shouldQueryRemoteFolder() throws Exception { setupRemoteSearch(); controller.searchRemoteMessagesSynchronous(ACCOUNT_UUID, FOLDER_NAME, "query", reqFlags, forbiddenFlags, listener); verify(backend).search(FOLDER_NAME, "query", reqFlags, forbiddenFlags); }
backend.downloadMessage(syncConfig, folder, uid); } else { FetchProfile fp = new FetchProfile(); fp.add(FetchProfile.Item.BODY); fp.add(FetchProfile.Item.FLAGS); Message remoteMessage = backend.fetchMessage(folder, uid, fp); localFolder.appendMessages(Collections.singletonList(remoteMessage));
void processPendingEmptyTrash(Account account) throws MessagingException { if (!account.hasTrashFolder()) { return; } Backend backend = getBackend(account); String trashFolderServerId = account.getTrashFolder(); backend.deleteAllMessages(trashFolderServerId); if (account.getExpungePolicy() == Expunge.EXPUNGE_IMMEDIATELY) { backend.expunge(trashFolderServerId); } // When we empty trash, we need to actually synchronize the folder // or local deletes will never get cleaned up LocalStore localStore = localStoreProvider.getInstance(account); LocalFolder folder = localStore.getFolder(trashFolderServerId); folder.open(Folder.OPEN_MODE_RW); synchronizeFolder(account, folder, true, 0, null); compact(account, null); }
if (!backend.isPushCapable()) { Timber.i("Account %s is not push capable, skipping", account.getDescription()); Pusher pusher = backend.createPusher(receiver); Pusher oldPusher = pushers.putIfAbsent(account, pusher); if (oldPusher == null) {
public void checkIncomingServerSettings(Account account) throws MessagingException { getBackend(account).checkIncomingServerSettings(); }
public void checkOutgoingServerSettings(Account account) throws MessagingException { getBackend(account).checkOutgoingServerSettings(); }
@Test public void searchRemoteMessagesSynchronous_shouldNotifyOnFailure() throws Exception { setupRemoteSearch(); when(backend.search(anyString(), anyString(), nullable(Set.class), nullable(Set.class))) .thenThrow(new MessagingException("Test")); controller.searchRemoteMessagesSynchronous(ACCOUNT_UUID, FOLDER_NAME, "query", reqFlags, forbiddenFlags, listener); verify(listener).remoteSearchFailed(null, "Test"); }
@Test public void sendPendingMessagesSynchronous_shouldSetAndRemoveSendInProgressFlag() throws MessagingException { setupAccountWithMessageToSend(); controller.sendPendingMessagesSynchronous(account); InOrder ordering = inOrder(localMessageToSend1, backend); ordering.verify(localMessageToSend1).setFlag(Flag.X_SEND_IN_PROGRESS, true); ordering.verify(backend).sendMessage(localMessageToSend1); ordering.verify(localMessageToSend1).setFlag(Flag.X_SEND_IN_PROGRESS, false); }
@Test public void searchRemoteMessagesSynchronous_shouldNotifyOnFinish() throws Exception { setupRemoteSearch(); when(backend.search(anyString(), nullable(String.class), nullable(Set.class), nullable(Set.class))) .thenThrow(new MessagingException("Test")); controller.searchRemoteMessagesSynchronous(ACCOUNT_UUID, FOLDER_NAME, "query", reqFlags, forbiddenFlags, listener); verify(listener).remoteSearchFinished(FOLDER_NAME, 0, 50, Collections.<String>emptyList()); }
@Test public void searchRemoteMessagesSynchronous_shouldFetchNewMessages() throws Exception { setupRemoteSearch(); controller.searchRemoteMessagesSynchronous(ACCOUNT_UUID, FOLDER_NAME, "query", reqFlags, forbiddenFlags, listener); verify(backend).fetchMessage(eq(FOLDER_NAME), eq("newMessageUid2"), fetchProfileCaptor.capture()); }
@VisibleForTesting void refreshRemoteSynchronous(final Account account, final MessagingListener listener) { List<LocalFolder> localFolders = null; try { Backend backend = getBackend(account); backend.refreshFolderList(); LocalStore localStore = localStoreProvider.getInstance(account); localFolders = localStore.getPersonalNamespaces(false); for (MessagingListener l : getListeners(listener)) { l.listFolders(account, localFolders); } for (MessagingListener l : getListeners(listener)) { l.listFoldersFinished(account); } } catch (Exception e) { Timber.e(e); for (MessagingListener l : getListeners(listener)) { l.listFoldersFailed(account, ""); } } finally { if (localFolders != null) { for (Folder localFolder : localFolders) { closeFolder(localFolder); } } } }
@Test public void sendPendingMessagesSynchronous_shouldSendMessageUsingTransport() throws MessagingException { setupAccountWithMessageToSend(); controller.sendPendingMessagesSynchronous(account); verify(backend).sendMessage(localMessageToSend1); }
List<String> messageServerIds = backend.search(folderServerId, query, requiredFlags, forbiddenFlags);
private void loadSearchResultsSynchronous(Account account, List<String> messageServerIds, LocalFolder localFolder) throws MessagingException { FetchProfile fetchProfile = new FetchProfile(); fetchProfile.add(FetchProfile.Item.FLAGS); fetchProfile.add(FetchProfile.Item.ENVELOPE); fetchProfile.add(FetchProfile.Item.STRUCTURE); Backend backend = getBackend(account); String folderServerId = localFolder.getServerId(); for (String messageServerId : messageServerIds) { LocalMessage localMessage = localFolder.getMessage(messageServerId); if (localMessage == null) { Message message = backend.fetchMessage(folderServerId, messageServerId, fetchProfile); localFolder.appendMessages(Collections.singletonList(message)); } } }
@Test public void sendPendingMessagesSynchronous_withAuthenticationFailure_shouldNotify() throws MessagingException { setupAccountWithMessageToSend(); doThrow(new AuthenticationFailedException("Test")).when(backend).sendMessage(localMessageToSend1); controller.sendPendingMessagesSynchronous(account); verify(notificationController).showAuthenticationErrorNotification(account, false); }