src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
Pop3Folder extends Folder<Pop3Message> { @Override public synchronized void open(int mode) throws MessagingException { if (isOpen()) { return; } if (!name.equalsIgnoreCase(pop3Store.getConfig().getInboxFolderId())) { throw new MessagingException("Folder does not exist"); } connection = pop3Store.createConnection(); String response = connection.executeSimpleCommand(STAT_COMMAND); String[] parts = response.split(" "); messageCount = Integer.parseInt(parts[1]); uidToMsgMap.clear(); msgNumToMsgMap.clear(); uidToMsgNumMap.clear(); } Pop3Folder(Pop3Store pop3Store, String name); @Override String getParentId(); @Override synchronized void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getName(); @Override boolean create(FolderType type); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override Pop3Message getMessage(String uid); @Override List<Pop3Message> getMessages(int start, int end, Date earliestDate, MessageRetrievalListener<Pop3Message> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<Pop3Message> messages, FetchProfile fp,
MessageRetrievalListener<Pop3Message> listener); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override void delete(boolean recurse); @Override void delete(List<? extends Message> msgs, String trashFolderName); @Override String getUidFromMessageId(Message message); @Override void setFlags(final Set<Flag> flags, boolean value); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean isFlagSupported(Flag flag); @Override boolean supportsFetchingFlags(); @Override boolean equals(Object o); @Override int hashCode(); } | @Test(expected = MessagingException.class) public void open_withoutInboxFolder_shouldThrow() throws Exception { Pop3Folder folder = new Pop3Folder(mockStore, "TestFolder"); folder.open(Folder.OPEN_MODE_RW); }
@Test public void open_withoutInboxFolder_shouldNotTryAndCreateConnection() throws Exception { Pop3Folder folder = new Pop3Folder(mockStore, "TestFolder"); try { folder.open(Folder.OPEN_MODE_RW); } catch (Exception ignored) {} verify(mockStore, never()).createConnection(); }
@Test(expected = MessagingException.class) public void open_withInboxFolderWithExceptionCreatingConnection_shouldThrow() throws MessagingException { when(mockStore.createConnection()).thenThrow(new MessagingException("Test")); folder.open(Folder.OPEN_MODE_RW); }
@Test(expected = MessagingException.class) public void open_withInboxFolder_whenStatCommandFails_shouldThrow() throws MessagingException { when(mockConnection.executeSimpleCommand(Pop3Commands.STAT_COMMAND)) .thenThrow(new MessagingException("Test")); folder.open(Folder.OPEN_MODE_RW); } |
Pop3Folder extends Folder<Pop3Message> { @Override public void close() { try { if (isOpen()) { connection.executeSimpleCommand(QUIT_COMMAND); } } catch (Exception e) { } if (connection != null) { connection.close(); connection = null; } } Pop3Folder(Pop3Store pop3Store, String name); @Override String getParentId(); @Override synchronized void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getName(); @Override boolean create(FolderType type); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override Pop3Message getMessage(String uid); @Override List<Pop3Message> getMessages(int start, int end, Date earliestDate, MessageRetrievalListener<Pop3Message> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<Pop3Message> messages, FetchProfile fp,
MessageRetrievalListener<Pop3Message> listener); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override void delete(boolean recurse); @Override void delete(List<? extends Message> msgs, String trashFolderName); @Override String getUidFromMessageId(Message message); @Override void setFlags(final Set<Flag> flags, boolean value); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean isFlagSupported(Flag flag); @Override boolean supportsFetchingFlags(); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void close_onNonOpenedFolder_succeeds() throws MessagingException { folder.close(); } |
Pop3Connection { InputStream getInputStream() { return in; } Pop3Connection(Pop3Settings settings,
TrustedSocketFactory trustedSocketFactory); } | @Test public void withTLS_connectsToSocket() throws Exception { String response = INITIAL_RESPONSE + AUTH_HANDLE_RESPONSE + CAPA_RESPONSE + AUTH_PLAIN_AUTHENTICATED_RESPONSE; when(mockSocket.getInputStream()).thenReturn(new ByteArrayInputStream(response.getBytes())); setSettingsForMockSocket(); settings.setAuthType(AuthType.PLAIN); new Pop3Connection(settings, mockTrustedSocketFactory); assertEquals(AUTH + CAPA + AUTH_PLAIN_WITH_LOGIN, new String(outputStream.toByteArray())); } |
WebDavStore extends RemoteStore { public static String createUri(ServerSettings server) { return WebDavStoreUriCreator.create(server); } WebDavStore(StoreConfig storeConfig, QMailHttpClientFactory clientFactory); static WebDavStoreSettings decodeUri(String uri); static String createUri(ServerSettings server); @Override void checkSettings(); @Override @NonNull List<? extends Folder> getFolders(boolean forceListAll); @NonNull @Override List<? extends Folder> getSubFolders(String parentFolderId, boolean forceListAll); @Override @NonNull WebDavFolder getFolder(String name); @Override boolean isMoveCapable(); @Override boolean isCopyCapable(); CookieStore getAuthCookies(); String getAlias(); String getUrl(); QMailHttpClient getHttpClient(); String getAuthString(); @Override boolean isSendCapable(); @Override void sendMessages(List<? extends Message> messages); } | @Test public void createUri_withSetting_shouldProvideUri() { ServerSettings serverSettings = new ServerSettings(Type.WebDAV, "example.org", 123456, ConnectionSecurity.NONE, AuthType.PLAIN, "user", "password", null); String result = WebDavStore.createUri(serverSettings); assertEquals("webdav: }
@Test public void createUri_withSettingsWithTLS_shouldProvideSSLUri() { ServerSettings serverSettings = new ServerSettings(Type.WebDAV, "example.org", 123456, ConnectionSecurity.SSL_TLS_REQUIRED, AuthType.PLAIN, "user", "password", null); String result = WebDavStore.createUri(serverSettings); assertEquals("webdav+ssl+: } |
WebDavStore extends RemoteStore { @Override public void checkSettings() throws MessagingException { authenticate(); } WebDavStore(StoreConfig storeConfig, QMailHttpClientFactory clientFactory); static WebDavStoreSettings decodeUri(String uri); static String createUri(ServerSettings server); @Override void checkSettings(); @Override @NonNull List<? extends Folder> getFolders(boolean forceListAll); @NonNull @Override List<? extends Folder> getSubFolders(String parentFolderId, boolean forceListAll); @Override @NonNull WebDavFolder getFolder(String name); @Override boolean isMoveCapable(); @Override boolean isCopyCapable(); CookieStore getAuthCookies(); String getAlias(); String getUrl(); QMailHttpClient getHttpClient(); String getAuthString(); @Override boolean isSendCapable(); @Override void sendMessages(List<? extends Message> messages); } | @Test public void checkSettings_withHttpPrefixedServerName_shouldUseInsecureConnection() throws Exception { WebDavStore webDavStore = createWebDavStore("webdav: configureHttpResponses(UNAUTHORIZED_401_RESPONSE, OK_200_RESPONSE); webDavStore.checkSettings(); assertHttpClientUsesHttps(false); }
@Test public void checkSettings_withWebDavUri_shouldUseInsecureConnection() throws Exception { WebDavStore webDavStore = createWebDavStore("webdav: configureHttpResponses(UNAUTHORIZED_401_RESPONSE, OK_200_RESPONSE); webDavStore.checkSettings(); assertHttpClientUsesHttps(false); }
@Test public void checkSettings_withWebDavSslUri_shouldUseSecureConnection() throws Exception { WebDavStore webDavStore = createWebDavStore("webdav+ssl: configureHttpResponses(UNAUTHORIZED_401_RESPONSE, OK_200_RESPONSE); webDavStore.checkSettings(); assertHttpClientUsesHttps(true); }
@Test public void checkSettings_withWebDavTlsUri_shouldUseSecureConnection() throws Exception { WebDavStore webDavStore = createWebDavStore("webdav+tls: configureHttpResponses(UNAUTHORIZED_401_RESPONSE, OK_200_RESPONSE); webDavStore.checkSettings(); assertHttpClientUsesHttps(true); }
@Test public void checkSettings_withOkResponse_shouldPerformFormBasedAuthentication() throws Exception { WebDavStore webDavStore = createDefaultWebDavStore(); ArgumentCaptor<HttpGeneric> requestCaptor = ArgumentCaptor.forClass(HttpGeneric.class); when(mockHttpClient.executeOverride(requestCaptor.capture(), any(HttpContext.class))) .thenReturn(OK_200_RESPONSE) .thenReturn(createOkResponseWithForm()) .thenAnswer(createOkResponseWithCookie()) .thenReturn(OK_200_RESPONSE); webDavStore.checkSettings(); List<HttpGeneric> requests = requestCaptor.getAllValues(); assertEquals(4, requests.size()); assertEquals("GET", requests.get(0).getMethod()); assertEquals("POST", requests.get(1).getMethod()); assertEquals("http: assertEquals("POST", requests.get(2).getMethod()); assertEquals("http: assertEquals("GET", requests.get(3).getMethod()); }
@Test public void checkSettings_withInitialUnauthorizedResponse_shouldPerformBasicAuthentication() throws Exception { WebDavStore webDavStore = createDefaultWebDavStore(); configureHttpResponses(UNAUTHORIZED_401_RESPONSE, OK_200_RESPONSE); webDavStore.checkSettings(); List<HttpGeneric> requests = requestCaptor.getAllValues(); assertEquals(2, requests.size()); assertEquals("GET", requests.get(0).getMethod()); assertEquals("GET", requests.get(1).getMethod()); assertEquals("Basic " + Base64.encode("user:password"), requests.get(1).getHeaders("Authorization")[0].getValue()); }
@Test(expected = MessagingException.class) public void checkSettings_withUnauthorizedResponses_shouldThrow() throws Exception { WebDavStore webDavStore = createDefaultWebDavStore(); configureHttpResponses(UNAUTHORIZED_401_RESPONSE, UNAUTHORIZED_401_RESPONSE); webDavStore.checkSettings(); }
@Test(expected = MessagingException.class) public void checkSettings_withErrorResponse_shouldThrow() throws Exception { WebDavStore webDavStore = createDefaultWebDavStore(); configureHttpResponses(UNAUTHORIZED_401_RESPONSE, SERVER_ERROR_500_RESPONSE); webDavStore.checkSettings(); }
@Test(expected = CertificateValidationException.class) public void checkSettings_withSslException_shouldThrowCertificateValidationException() throws Exception { WebDavStore webDavStore = createDefaultWebDavStore(); ArgumentCaptor<HttpGeneric> requestCaptor = ArgumentCaptor.forClass(HttpGeneric.class); when(mockHttpClient.executeOverride(requestCaptor.capture(), any(HttpContext.class))) .thenThrow(new SSLException("Test")); webDavStore.checkSettings(); }
@Test public void checkSettings_shouldRegisterHttpsSchemeWithRegistry() throws Exception { WebDavStore webDavStore = createDefaultWebDavStore(); configureHttpResponses(UNAUTHORIZED_401_RESPONSE, OK_200_RESPONSE); webDavStore.checkSettings(); ArgumentCaptor<Scheme> schemeCaptor = ArgumentCaptor.forClass(Scheme.class); verify(mockSchemeRegistry).register(schemeCaptor.capture()); assertEquals("https", schemeCaptor.getValue().getName()); assertEquals(WebDavSocketFactory.class, schemeCaptor.getValue().getSocketFactory().getClass()); } |
WebDavStore extends RemoteStore { @Override @NonNull public WebDavFolder getFolder(String name) { WebDavFolder folder = this.folderList.get(name); if (folder == null) { folder = new WebDavFolder(this, name); folderList.put(name, folder); } return folder; } WebDavStore(StoreConfig storeConfig, QMailHttpClientFactory clientFactory); static WebDavStoreSettings decodeUri(String uri); static String createUri(ServerSettings server); @Override void checkSettings(); @Override @NonNull List<? extends Folder> getFolders(boolean forceListAll); @NonNull @Override List<? extends Folder> getSubFolders(String parentFolderId, boolean forceListAll); @Override @NonNull WebDavFolder getFolder(String name); @Override boolean isMoveCapable(); @Override boolean isCopyCapable(); CookieStore getAuthCookies(); String getAlias(); String getUrl(); QMailHttpClient getHttpClient(); String getAuthString(); @Override boolean isSendCapable(); @Override void sendMessages(List<? extends Message> messages); } | @Test public void getFolder_shouldReturnWebDavFolderInstance() throws Exception { WebDavStore webDavStore = createDefaultWebDavStore(); Folder result = webDavStore.getFolder("INBOX"); assertEquals(WebDavFolder.class, result.getClass()); }
@Test public void getFolder_calledTwice_shouldReturnFirstInstance() throws Exception { WebDavStore webDavStore = createDefaultWebDavStore(); String folderName = "Trash"; Folder webDavFolder = webDavStore.getFolder(folderName); Folder result = webDavStore.getFolder(folderName); assertSame(webDavFolder, result); } |
WebDavStore extends RemoteStore { @Override @NonNull public List<? extends Folder> getFolders(boolean forceListAll) throws MessagingException { List<Folder> folderList = new LinkedList<>(); getHttpClient(); Map<String, String> headers = new HashMap<>(); headers.put("Depth", "0"); headers.put("Brief", "t"); DataSet dataset = processRequest(this.baseUrl, "PROPFIND", getSpecialFoldersList(), headers); Map<String, String> specialFoldersMap = dataset.getSpecialFolderToUrl(); String folderId = getFolderId(specialFoldersMap.get(WebDavConstants.DAV_MAIL_INBOX_FOLDER)); if (folderId != null) { mStoreConfig.setAutoExpandFolderId(folderId); mStoreConfig.setInboxFolderId(folderId); } folderId = getFolderId(specialFoldersMap.get(WebDavConstants.DAV_MAIL_DRAFTS_FOLDER)); if (folderId != null) { mStoreConfig.setDraftsFolderId(folderId); } folderId = getFolderId(specialFoldersMap.get(WebDavConstants.DAV_MAIL_TRASH_FOLDER)); if (folderId != null) { mStoreConfig.setTrashFolderId(folderId); } folderId = getFolderId(specialFoldersMap.get(WebDavConstants.DAV_MAIL_SPAM_FOLDER)); if (folderId != null) { mStoreConfig.setSpamFolderId(folderId); } folderId = getFolderId(specialFoldersMap.get(WebDavConstants.DAV_MAIL_SENT_FOLDER)); if (folderId != null) { mStoreConfig.setSentFolderId(folderId); } headers = new HashMap<>(); headers.put("Brief", "t"); dataset = processRequest(this.baseUrl, "SEARCH", getFolderListXml(), headers); String[] folderUrls = dataset.getHrefs(); for (String tempUrl : folderUrls) { WebDavFolder folder = createFolder(tempUrl); if (folder != null) { folderList.add(folder); } } return folderList; } WebDavStore(StoreConfig storeConfig, QMailHttpClientFactory clientFactory); static WebDavStoreSettings decodeUri(String uri); static String createUri(ServerSettings server); @Override void checkSettings(); @Override @NonNull List<? extends Folder> getFolders(boolean forceListAll); @NonNull @Override List<? extends Folder> getSubFolders(String parentFolderId, boolean forceListAll); @Override @NonNull WebDavFolder getFolder(String name); @Override boolean isMoveCapable(); @Override boolean isCopyCapable(); CookieStore getAuthCookies(); String getAlias(); String getUrl(); QMailHttpClient getHttpClient(); String getAuthString(); @Override boolean isSendCapable(); @Override void sendMessages(List<? extends Message> messages); } | @Test public void getPersonalNamespaces_shouldRequestSpecialFolders() throws Exception { StoreConfig storeConfig = createStoreConfig("webdav: WebDavStore webDavStore = new WebDavStore(storeConfig, mockHttpClientFactory); configureHttpResponses(UNAUTHORIZED_401_RESPONSE, OK_200_RESPONSE, createOkPropfindResponse(), createOkSearchResponse()); webDavStore.getFolders(true); List<HttpGeneric> requests = requestCaptor.getAllValues(); assertEquals(4, requests.size()); assertEquals("PROPFIND", requests.get(2).getMethod()); }
@Test public void getPersonalNamespaces_shouldSetSpecialFolderNames() throws Exception { StoreConfig storeConfig = createStoreConfig("webdav: WebDavStore webDavStore = new WebDavStore(storeConfig, mockHttpClientFactory); configureHttpResponses(UNAUTHORIZED_401_RESPONSE, OK_200_RESPONSE, createOkPropfindResponse(), createOkSearchResponse()); webDavStore.getFolders(true); verify(storeConfig).setInboxFolderId("Inbox"); }
@Test public void getPersonalNamespaces_shouldRequestFolderList() throws Exception { StoreConfig storeConfig = createStoreConfig("webdav: WebDavStore webDavStore = new WebDavStore(storeConfig, mockHttpClientFactory); configureHttpResponses(UNAUTHORIZED_401_RESPONSE, OK_200_RESPONSE, createOkPropfindResponse(), createOkSearchResponse()); webDavStore.getFolders(true); List<HttpGeneric> requests = requestCaptor.getAllValues(); assertEquals(4, requests.size()); assertEquals("SEARCH", requests.get(3).getMethod()); }
@Test public void getPersonalNamespaces_shouldProvideListOfAllFoldersSentFromResponses() throws Exception { StoreConfig storeConfig = createStoreConfig("webdav: WebDavStore webDavStore = new WebDavStore(storeConfig, mockHttpClientFactory); configureHttpResponses(UNAUTHORIZED_401_RESPONSE, OK_200_RESPONSE, createOkPropfindResponse(), createOkSearchResponse()); List<? extends Folder> folders = webDavStore.getFolders(true); List<HttpGeneric> requests = requestCaptor.getAllValues(); assertEquals(3, folders.size()); } |
WebDavFolder extends Folder<WebDavMessage> { @Override public void fetch(List<WebDavMessage> messages, FetchProfile fp, MessageRetrievalListener<WebDavMessage> listener) throws MessagingException { if (messages == null || messages.isEmpty()) { return; } if (fp.contains(FetchProfile.Item.ENVELOPE)) { fetchEnvelope(messages, listener); } if (fp.contains(FetchProfile.Item.FLAGS)) { fetchFlags(messages, listener); } if (fp.contains(FetchProfile.Item.BODY_SANE)) { int maximumAutoDownloadSize = store.getStoreConfig().getMaximumAutoDownloadMessageSize(); if (maximumAutoDownloadSize > 0) { fetchMessages(messages, listener, (maximumAutoDownloadSize / 76)); } else { fetchMessages(messages, listener, -1); } } if (fp.contains(FetchProfile.Item.BODY)) { fetchMessages(messages, listener, -1); } } WebDavFolder(WebDavStore nStore, String id); void setUrl(String url); @Override void open(int mode); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> msgs, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override boolean isOpen(); @Override int getMode(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override void close(); @Override boolean create(FolderType type); @Override void delete(boolean recursive); @Override WebDavMessage getMessage(String uid); @Override List<WebDavMessage> getMessages(int start, int end, Date earliestDate, MessageRetrievalListener<WebDavMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<WebDavMessage> messages, FetchProfile fp, MessageRetrievalListener<WebDavMessage> listener); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override Map<String, String> appendMessages(List<? extends Message> messages); List<? extends Message> appendWebDavMessages(List<? extends Message> messages); @Override boolean equals(Object o); @Override String getUidFromMessageId(Message message); @Override void setFlags(final Set<Flag> flags, boolean value); String getUrl(); } | @Test public void folder_can_fetch_less_than_10_envelopes() throws MessagingException { when(mockStore.processRequest(anyString(), anyString(), anyString(), anyMapOf(String.class, String.class))) .thenReturn(mockDataSet); List<WebDavMessage> messages = new ArrayList<>(); for (int i = 0; i < 5; i++) { WebDavMessage mockMessage = mock(WebDavMessage.class); messages.add(mockMessage); } FetchProfile profile = new FetchProfile(); profile.add(FetchProfile.Item.ENVELOPE); folder.fetch(messages, profile, listener); }
@Test public void folder_can_fetch_more_than_10_envelopes() throws MessagingException { when(mockStore.processRequest(anyString(), anyString(), anyString(), anyMapOf(String.class, String.class))) .thenReturn(mockDataSet); List<WebDavMessage> messages = new ArrayList<>(); for (int i = 0; i < 15; i++) { WebDavMessage mockMessage = mock(WebDavMessage.class); messages.add(mockMessage); } FetchProfile profile = new FetchProfile(); profile.add(FetchProfile.Item.ENVELOPE); folder.fetch(messages, profile, listener); }
@Test public void folder_can_fetch_less_than_20_flags() throws MessagingException { when(mockStore.processRequest(anyString(), anyString(), anyString(), anyMapOf(String.class, String.class))) .thenReturn(mockDataSet); List<WebDavMessage> messages = new ArrayList<>(); for (int i = 0; i < 5; i++) { WebDavMessage mockMessage = mock(WebDavMessage.class); messages.add(mockMessage); } FetchProfile profile = new FetchProfile(); profile.add(FetchProfile.Item.FLAGS); folder.fetch(messages, profile, listener); }
@Test public void folder_can_fetch_more_than_20_flags() throws MessagingException { when(mockStore.processRequest(anyString(), anyString(), anyString(), anyMapOf(String.class, String.class))) .thenReturn(mockDataSet); List<WebDavMessage> messages = new ArrayList<>(); for (int i = 0; i < 25; i++) { WebDavMessage mockMessage = mock(WebDavMessage.class); messages.add(mockMessage); } FetchProfile profile = new FetchProfile(); profile.add(FetchProfile.Item.FLAGS); folder.fetch(messages, profile, listener); }
@Test public void folder_can_fetch_sensible_body_data_and_notifies_listener() throws MessagingException, IOException, URISyntaxException { setupStoreForMessageFetching(); List<WebDavMessage> messages = setup25MessagesToFetch(); when(mockHttpClient.executeOverride(any(HttpUriRequest.class), any(HttpContext.class))).thenAnswer( new Answer<HttpResponse>() { @Override public HttpResponse answer(InvocationOnMock invocation) throws Throwable { HttpResponse httpResponse = mock(HttpResponse.class); StatusLine statusLine = mock(StatusLine.class); when(httpResponse.getStatusLine()).thenReturn(statusLine); when(statusLine.getStatusCode()).thenReturn(200); BasicHttpEntity httpEntity = new BasicHttpEntity(); String body = ""; httpEntity.setContent(new ByteArrayInputStream(body.getBytes("UTF-8"))); when(httpResponse.getEntity()).thenReturn(httpEntity); return httpResponse; } }); FetchProfile profile = new FetchProfile(); profile.add(FetchProfile.Item.BODY_SANE); folder.fetch(messages, profile, listener); verify(listener, times(25)).messageStarted(any(String.class), anyInt(), eq(25)); verify(listener, times(25)).messageFinished(any(WebDavMessage.class), anyInt(), eq(25)); }
@Test public void folder_does_not_notify_listener_twice_when_fetching_flags_and_bodies() throws MessagingException, IOException, URISyntaxException { setupStoreForMessageFetching(); when(mockStore.processRequest(anyString(), anyString(), anyString(), anyMapOf(String.class, String.class))) .thenReturn(mockDataSet); List<WebDavMessage> messages = setup25MessagesToFetch(); when(mockHttpClient.executeOverride(any(HttpUriRequest.class), any(HttpContext.class))).thenAnswer( new Answer<HttpResponse>() { @Override public HttpResponse answer(InvocationOnMock invocation) throws Throwable { HttpResponse httpResponse = mock(HttpResponse.class); StatusLine statusLine = mock(StatusLine.class); when(httpResponse.getStatusLine()).thenReturn(statusLine); when(statusLine.getStatusCode()).thenReturn(200); BasicHttpEntity httpEntity = new BasicHttpEntity(); String body = ""; httpEntity.setContent(new ByteArrayInputStream(body.getBytes("UTF-8"))); when(httpResponse.getEntity()).thenReturn(httpEntity); return httpResponse; } }); FetchProfile profile = new FetchProfile(); profile.add(FetchProfile.Item.FLAGS); profile.add(FetchProfile.Item.BODY); folder.fetch(messages, profile, listener); verify(listener, times(25)).messageStarted(any(String.class), anyInt(), anyInt()); verify(listener, times(25)).messageFinished(any(WebDavMessage.class), anyInt(), anyInt()); }
@Test public void folder_can_handle_empty_response_to_body_request() throws MessagingException, IOException { setupStoreForMessageFetching(); List<WebDavMessage> messages = setup25MessagesToFetch(); when(mockHttpClient.executeOverride(any(HttpUriRequest.class), any(HttpContext.class))).thenAnswer( new Answer<HttpResponse>() { @Override public HttpResponse answer(InvocationOnMock invocation) throws Throwable { HttpResponse httpResponse = mock(HttpResponse.class); StatusLine statusLine = mock(StatusLine.class); when(httpResponse.getStatusLine()).thenReturn(statusLine); when(statusLine.getStatusCode()).thenReturn(200); return httpResponse; } }); FetchProfile profile = new FetchProfile(); profile.add(FetchProfile.Item.BODY_SANE); folder.fetch(messages, profile, listener); verify(listener, times(25)).messageStarted(any(String.class), anyInt(), eq(25)); verify(listener, times(25)).messageFinished(any(WebDavMessage.class), anyInt(), eq(25)); } |
WebDavFolder extends Folder<WebDavMessage> { @Override public boolean isOpen() { return this.mIsOpen; } WebDavFolder(WebDavStore nStore, String id); void setUrl(String url); @Override void open(int mode); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> msgs, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override boolean isOpen(); @Override int getMode(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override void close(); @Override boolean create(FolderType type); @Override void delete(boolean recursive); @Override WebDavMessage getMessage(String uid); @Override List<WebDavMessage> getMessages(int start, int end, Date earliestDate, MessageRetrievalListener<WebDavMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<WebDavMessage> messages, FetchProfile fp, MessageRetrievalListener<WebDavMessage> listener); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override Map<String, String> appendMessages(List<? extends Message> messages); List<? extends Message> appendWebDavMessages(List<? extends Message> messages); @Override boolean equals(Object o); @Override String getUidFromMessageId(Message message); @Override void setFlags(final Set<Flag> flags, boolean value); String getUrl(); } | @Test public void folder_does_not_start_open() throws MessagingException { assertFalse(folder.isOpen()); } |
WebDavFolder extends Folder<WebDavMessage> { @Override public boolean exists() { return true; } WebDavFolder(WebDavStore nStore, String id); void setUrl(String url); @Override void open(int mode); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> msgs, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override boolean isOpen(); @Override int getMode(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override void close(); @Override boolean create(FolderType type); @Override void delete(boolean recursive); @Override WebDavMessage getMessage(String uid); @Override List<WebDavMessage> getMessages(int start, int end, Date earliestDate, MessageRetrievalListener<WebDavMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<WebDavMessage> messages, FetchProfile fp, MessageRetrievalListener<WebDavMessage> listener); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override Map<String, String> appendMessages(List<? extends Message> messages); List<? extends Message> appendWebDavMessages(List<? extends Message> messages); @Override boolean equals(Object o); @Override String getUidFromMessageId(Message message); @Override void setFlags(final Set<Flag> flags, boolean value); String getUrl(); } | @Test public void exists_is_always_true() throws Exception { assertTrue(folder.exists()); } |
WebDavFolder extends Folder<WebDavMessage> { private int getMessageCount(boolean read) throws MessagingException { String isRead; int messageCount = 0; Map<String, String> headers = new HashMap<String, String>(); String messageBody; if (read) { isRead = "True"; } else { isRead = "False"; } messageBody = store.getMessageCountXml(isRead); headers.put("Brief", "t"); DataSet dataset = store.processRequest(this.folderUrl, "SEARCH", messageBody, headers); if (dataset != null) { messageCount = dataset.getMessageCount(); } if (K9MailLib.isDebug() && DEBUG_PROTOCOL_WEBDAV) { Timber.v("Counted messages and webdav returned: %d", messageCount); } return messageCount; } WebDavFolder(WebDavStore nStore, String id); void setUrl(String url); @Override void open(int mode); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> msgs, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override boolean isOpen(); @Override int getMode(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override void close(); @Override boolean create(FolderType type); @Override void delete(boolean recursive); @Override WebDavMessage getMessage(String uid); @Override List<WebDavMessage> getMessages(int start, int end, Date earliestDate, MessageRetrievalListener<WebDavMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<WebDavMessage> messages, FetchProfile fp, MessageRetrievalListener<WebDavMessage> listener); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override Map<String, String> appendMessages(List<? extends Message> messages); List<? extends Message> appendWebDavMessages(List<? extends Message> messages); @Override boolean equals(Object o); @Override String getUidFromMessageId(Message message); @Override void setFlags(final Set<Flag> flags, boolean value); String getUrl(); } | @Test public void can_fetch_message_count() throws Exception { int messageCount = 23; HashMap<String, String> headers = new HashMap<>(); headers.put("Brief", "t"); String messageCountXml = "<xml>MessageCountXml</xml>"; when(mockStore.getMessageCountXml("True")).thenReturn(messageCountXml); when(mockStore.processRequest("https: "SEARCH", messageCountXml, headers)).thenReturn(mockDataSet); when(mockDataSet.getMessageCount()).thenReturn(messageCount); int result = folder.getMessageCount(); assertEquals(messageCount, result); } |
WebDavFolder extends Folder<WebDavMessage> { @Override public List<WebDavMessage> getMessages(int start, int end, Date earliestDate, MessageRetrievalListener<WebDavMessage> listener) throws MessagingException { List<WebDavMessage> messages = new ArrayList<WebDavMessage>(); String[] uids; Map<String, String> headers = new HashMap<String, String>(); int uidsLength; String messageBody; int prevStart = start; start = this.messageCount - end; end = start + (end - prevStart); if (start < 0 || end < 0 || end < start) { throw new MessagingException(String.format(Locale.US, "Invalid message set %d %d", start, end)); } if (start == 0 && end < 10) { end = 10; } messageBody = store.getMessagesXml(); headers.put("Brief", "t"); headers.put("Range", "rows=" + start + "-" + end); DataSet dataset = store.processRequest(this.folderUrl, "SEARCH", messageBody, headers); uids = dataset.getUids(); Map<String, String> uidToUrl = dataset.getUidToUrl(); uidsLength = uids.length; for (int i = 0; i < uidsLength; i++) { if (listener != null) { listener.messageStarted(uids[i], i, uidsLength); } WebDavMessage message = new WebDavMessage(uids[i], this); message.setUrl(uidToUrl.get(uids[i])); messages.add(message); if (listener != null) { listener.messageFinished(message, i, uidsLength); } } return messages; } WebDavFolder(WebDavStore nStore, String id); void setUrl(String url); @Override void open(int mode); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> msgs, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override boolean isOpen(); @Override int getMode(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override void close(); @Override boolean create(FolderType type); @Override void delete(boolean recursive); @Override WebDavMessage getMessage(String uid); @Override List<WebDavMessage> getMessages(int start, int end, Date earliestDate, MessageRetrievalListener<WebDavMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<WebDavMessage> messages, FetchProfile fp, MessageRetrievalListener<WebDavMessage> listener); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override Map<String, String> appendMessages(List<? extends Message> messages); List<? extends Message> appendWebDavMessages(List<? extends Message> messages); @Override boolean equals(Object o); @Override String getUidFromMessageId(Message message); @Override void setFlags(final Set<Flag> flags, boolean value); String getUrl(); } | @Test public void getMessages_should_request_message_search() throws MessagingException { int totalMessages = 23; int messageStart = 1; int messageEnd = 11; setupFolderWithMessages(totalMessages); String messagesXml = "<xml>MessagesXml</xml>"; buildSearchResponse(mockDataSet); when(mockStore.getMessagesXml()).thenReturn(messagesXml); when(mockStore.processRequest(eq("https: eq(messagesXml), Matchers.<Map<String, String>>any())).thenReturn(mockDataSet); folder.getMessages(messageStart, messageEnd, new Date(), listener); verify(listener, times(5)).messageStarted(anyString(), anyInt(), eq(5)); verify(listener, times(5)).messageFinished(any(WebDavMessage.class), anyInt(), eq(5)); }
@Test public void getMessages_shouldProvideCorrectHeadersInRequest() throws MessagingException { int totalMessages = 23; int messageStart = 1; int messageEnd = 11; setupFolderWithMessages(totalMessages); String messagesXml = "<xml>MessagesXml</xml>"; buildSearchResponse(mockDataSet); when(mockStore.getMessagesXml()).thenReturn(messagesXml); when(mockStore.processRequest(eq("https: eq(messagesXml), Matchers.<Map<String, String>>any())).thenReturn(mockDataSet); folder.getMessages(messageStart, messageEnd, new Date(), listener); verify(mockStore, times(2)).processRequest(anyString(), anyString(), anyString(), headerCaptor.capture()); assertEquals(2, headerCaptor.getValue().size()); assertEquals("t", headerCaptor.getValue().get("Brief")); assertEquals("rows=" + (totalMessages - (messageEnd)) + "-" + (totalMessages - messageStart) , headerCaptor.getValue().get("Range")); }
@Test(expected = MessagingException.class) public void getMessages_should_throw_message_exception_if_requesting_messages_from_empty_folder() throws MessagingException { folder.getMessages(0, 10, new Date(), listener); } |
WebDavFolder extends Folder<WebDavMessage> { @Override public Map<String, String> moveMessages(List<? extends Message> messages, Folder folder) throws MessagingException { moveOrCopyMessages(messages, folder.getId(), true); return null; } WebDavFolder(WebDavStore nStore, String id); void setUrl(String url); @Override void open(int mode); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> msgs, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override boolean isOpen(); @Override int getMode(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override void close(); @Override boolean create(FolderType type); @Override void delete(boolean recursive); @Override WebDavMessage getMessage(String uid); @Override List<WebDavMessage> getMessages(int start, int end, Date earliestDate, MessageRetrievalListener<WebDavMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<WebDavMessage> messages, FetchProfile fp, MessageRetrievalListener<WebDavMessage> listener); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override Map<String, String> appendMessages(List<? extends Message> messages); List<? extends Message> appendWebDavMessages(List<? extends Message> messages); @Override boolean equals(Object o); @Override String getUidFromMessageId(Message message); @Override void setFlags(final Set<Flag> flags, boolean value); String getUrl(); } | @Test public void moveMessages_should_requestMoveXml() throws Exception { setupMoveOrCopy(); folder.moveMessages(messages, destinationFolder); verify(mockStore).getMoveOrCopyMessagesReadXml(eq(new String[]{"url1"}), eq(true)); }
@Test public void moveMessages_should_send_move_command() throws Exception { setupMoveOrCopy(); folder.moveMessages(messages, destinationFolder); verify(mockStore).processRequest("https: moveOrCopyXml, moveOrCopyHeaders, false); } |
WebDavFolder extends Folder<WebDavMessage> { @Override public Map<String, String> copyMessages(List<? extends Message> messages, Folder folder) throws MessagingException { moveOrCopyMessages(messages, folder.getId(), false); return null; } WebDavFolder(WebDavStore nStore, String id); void setUrl(String url); @Override void open(int mode); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> msgs, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override boolean isOpen(); @Override int getMode(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override void close(); @Override boolean create(FolderType type); @Override void delete(boolean recursive); @Override WebDavMessage getMessage(String uid); @Override List<WebDavMessage> getMessages(int start, int end, Date earliestDate, MessageRetrievalListener<WebDavMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<WebDavMessage> messages, FetchProfile fp, MessageRetrievalListener<WebDavMessage> listener); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override Map<String, String> appendMessages(List<? extends Message> messages); List<? extends Message> appendWebDavMessages(List<? extends Message> messages); @Override boolean equals(Object o); @Override String getUidFromMessageId(Message message); @Override void setFlags(final Set<Flag> flags, boolean value); String getUrl(); } | @Test public void copyMessages_should_requestCopyXml() throws Exception { setupMoveOrCopy(); folder.copyMessages(messages, destinationFolder); verify(mockStore).getMoveOrCopyMessagesReadXml(eq(new String[]{"url1"}), eq(false)); }
@Test public void copyMessages_should_send_copy_command() throws Exception { setupMoveOrCopy(); folder.copyMessages(messages, destinationFolder); verify(mockStore).processRequest("https: moveOrCopyXml, moveOrCopyHeaders, false); } |
WebDavFolder extends Folder<WebDavMessage> { public List<? extends Message> appendWebDavMessages(List<? extends Message> messages) throws MessagingException { List<Message> retMessages = new ArrayList<Message>(messages.size()); QMailHttpClient httpclient = store.getHttpClient(); for (Message message : messages) { HttpGeneric httpmethod; HttpResponse response; StringEntity bodyEntity; int statusCode; try { ByteArrayOutputStream out; long size = message.getSize(); if (size > Integer.MAX_VALUE) { throw new MessagingException("message size > Integer.MAX_VALUE!"); } out = new ByteArrayOutputStream((int) size); open(Folder.OPEN_MODE_RW); EOLConvertingOutputStream msgOut = new EOLConvertingOutputStream( new BufferedOutputStream(out, 1024)); message.writeTo(msgOut); msgOut.flush(); bodyEntity = new StringEntity(out.toString(), "UTF-8"); bodyEntity.setContentType("message/rfc822"); String messageURL = folderUrl; if (!messageURL.endsWith("/")) { messageURL += "/"; } messageURL += encodeUtf8(message.getUid() + ":" + System.currentTimeMillis() + ".eml"); Timber.i("Uploading message as %s", messageURL); store.sendRequest(messageURL, "PUT", bodyEntity, null, true); WebDavMessage retMessage = new WebDavMessage(message.getUid(), this); retMessage.setUrl(messageURL); retMessages.add(retMessage); } catch (Exception e) { throw new MessagingException("Unable to append", e); } } return retMessages; } WebDavFolder(WebDavStore nStore, String id); void setUrl(String url); @Override void open(int mode); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> msgs, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override boolean isOpen(); @Override int getMode(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override void close(); @Override boolean create(FolderType type); @Override void delete(boolean recursive); @Override WebDavMessage getMessage(String uid); @Override List<WebDavMessage> getMessages(int start, int end, Date earliestDate, MessageRetrievalListener<WebDavMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<WebDavMessage> messages, FetchProfile fp, MessageRetrievalListener<WebDavMessage> listener); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override Map<String, String> appendMessages(List<? extends Message> messages); List<? extends Message> appendWebDavMessages(List<? extends Message> messages); @Override boolean equals(Object o); @Override String getUidFromMessageId(Message message); @Override void setFlags(final Set<Flag> flags, boolean value); String getUrl(); } | @Test public void appendWebDavMessages_replaces_messages_with_WebDAV_versions() throws MessagingException, IOException { List<Message> existingMessages = new ArrayList<>(); Message existingMessage = mock(Message.class); existingMessages.add(existingMessage); String messageUid = "testMessageUid"; when(existingMessage.getUid()).thenReturn(messageUid); List<? extends Message> response = folder.appendWebDavMessages(existingMessages); assertEquals(1, response.size(), 1); assertEquals(WebDavMessage.class, response.get(0).getClass()); assertEquals(messageUid, response.get(0).getUid()); }
@Test public void appendWebDavMessages_sendsRequestUsingStore() throws MessagingException, IOException { List<Message> existingMessages = new ArrayList<>(); Message existingMessage = mock(Message.class); existingMessages.add(existingMessage); String messageUid = "testMessageUid"; when(existingMessage.getUid()).thenReturn(messageUid); folder.appendWebDavMessages(existingMessages); verify(mockStore).sendRequest(urlCaptor.capture(), eq("PUT"), entityCaptor.capture(), Matchers.<Map<String, String>>eq(null), eq(true)); assertTrue(urlCaptor.getValue().startsWith(storeUrl + "/" + folderName + "/" + messageUid)); assertTrue(urlCaptor.getValue().endsWith(".eml")); } |
WebDavMessage extends MimeMessage { @Override public void delete(String trashFolderName) throws MessagingException { WebDavFolder wdFolder = (WebDavFolder) getFolder(); Timber.i("Deleting message by moving to %s", trashFolderName); wdFolder.moveMessages(Collections.singletonList(this), wdFolder.getStore().getFolder(trashFolderName)); } WebDavMessage(String uid, Folder folder); void setUrl(String url); String getUrl(); void setSize(int size); void setFlagInternal(Flag flag, boolean set); void setNewHeaders(ParsedMessageEnvelope envelope); @Override void delete(String trashFolderName); @Override void setFlag(Flag flag, boolean set); } | @Test public void delete_asks_folder_to_delete_message() throws MessagingException { when(mockFolder.getStore()).thenReturn(mockStore); when(mockStore.getFolder("Trash")).thenReturn(mockTrashFolder); message.delete("Trash"); verify(mockFolder).moveMessages(Collections.singletonList(message), mockTrashFolder); } |
WebDavMessage extends MimeMessage { public void setNewHeaders(ParsedMessageEnvelope envelope) throws MessagingException { String[] headers = envelope.getHeaderList(); Map<String, String> messageHeaders = envelope.getMessageHeaders(); for (String header : headers) { String headerValue = messageHeaders.get(header); if (header.equals("Content-Length")) { int size = Integer.parseInt(headerValue); this.setSize(size); } if (headerValue != null && !headerValue.equals("")) { this.addHeader(header, headerValue); } } } WebDavMessage(String uid, Folder folder); void setUrl(String url); String getUrl(); void setSize(int size); void setFlagInternal(Flag flag, boolean set); void setNewHeaders(ParsedMessageEnvelope envelope); @Override void delete(String trashFolderName); @Override void setFlag(Flag flag, boolean set); } | @Test public void setNewHeaders_updates_size() throws MessagingException { ParsedMessageEnvelope parsedMessageEnvelope = new ParsedMessageEnvelope(); parsedMessageEnvelope.addHeader("getcontentlength", "1024"); message.setNewHeaders(parsedMessageEnvelope); assertEquals(1024, message.getSize()); } |
WebDavMessage extends MimeMessage { @Override public void setFlag(Flag flag, boolean set) throws MessagingException { super.setFlag(flag, set); mFolder.setFlags(Collections.singletonList(this), Collections.singleton(flag), set); } WebDavMessage(String uid, Folder folder); void setUrl(String url); String getUrl(); void setSize(int size); void setFlagInternal(Flag flag, boolean set); void setNewHeaders(ParsedMessageEnvelope envelope); @Override void delete(String trashFolderName); @Override void setFlag(Flag flag, boolean set); } | @Test public void setFlag_asks_folder_to_set_flag() throws MessagingException { message.setFlag(Flag.FLAGGED, true); verify(mockFolder).setFlags(Collections.singletonList(message), Collections.singleton(Flag.FLAGGED), true); } |
CopyUidResponse { public static CopyUidResponse parse(ImapResponse response) { if (!response.isTagged() || response.size() < 2 || !equalsIgnoreCase(response.get(0), Responses.OK) || !response.isList(1)) { return null; } ImapList responseTextList = response.getList(1); if (responseTextList.size() < 4 || !equalsIgnoreCase(responseTextList.get(0), Responses.COPYUID) || !responseTextList.isString(1) || !responseTextList.isString(2) || !responseTextList.isString(3)) { return null; } List<String> sourceUids = getImapSequenceValues(responseTextList.getString(2)); List<String> destinationUids = getImapSequenceValues(responseTextList.getString(3)); int size = sourceUids.size(); if (size == 0 || size != destinationUids.size()) { return null; } Map<String, String> uidMapping = new HashMap<>(size); for (int i = 0; i < size; i++) { String sourceUid = sourceUids.get(i); String destinationUid = destinationUids.get(i); uidMapping.put(sourceUid, destinationUid); } return new CopyUidResponse(uidMapping); } private CopyUidResponse(Map<String, String> uidMapping); static CopyUidResponse parse(ImapResponse response); Map<String, String> getUidMapping(); } | @Test public void parse_withUntaggedResponse_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("* OK [COPYUID 1 1,3:5 7:10] Success"); CopyUidResponse result = CopyUidResponse.parse(imapResponse); assertNull(result); }
@Test public void parse_withTooShortResponse_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x OK"); CopyUidResponse result = CopyUidResponse.parse(imapResponse); assertNull(result); }
@Test public void parse_withoutOkResponse_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x BYE Logout"); CopyUidResponse result = CopyUidResponse.parse(imapResponse); assertNull(result); }
@Test public void parse_withoutResponseTextList_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x OK Success"); CopyUidResponse result = CopyUidResponse.parse(imapResponse); assertNull(result); }
@Test public void parse_withResponseTextListTooShort_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x OK [A B C] Success"); CopyUidResponse result = CopyUidResponse.parse(imapResponse); assertNull(result); }
@Test public void parse_withoutCopyUidResponse_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x OK [A B C D] Success"); CopyUidResponse result = CopyUidResponse.parse(imapResponse); assertNull(result); }
@Test public void parse_withNonStringCopyUidArgumentOne_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x OK [COPYUID () C D] Success"); CopyUidResponse result = CopyUidResponse.parse(imapResponse); assertNull(result); }
@Test public void parse_withNonStringCopyUidArgumentTwo_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x OK [COPYUID B () D] Success"); CopyUidResponse result = CopyUidResponse.parse(imapResponse); assertNull(result); }
@Test public void parse_withNonStringCopyUidArgumentThree_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x OK [COPYUID B C ()] Success"); CopyUidResponse result = CopyUidResponse.parse(imapResponse); assertNull(result); }
@Test public void parse_withNonNumberCopyUidArguments_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x OK [COPYUID B C D] Success"); CopyUidResponse result = CopyUidResponse.parse(imapResponse); assertNull(result); }
@Test public void parse_withUnbalancedCopyUidArguments_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x OK [COPYUID B 1 1,2] Success"); CopyUidResponse result = CopyUidResponse.parse(imapResponse); assertNull(result); } |
ResponseCodeExtractor { public static String getResponseCode(ImapResponse response) { if (response.size() < 2 || !response.isList(1)) { return null; } ImapList responseTextCode = response.getList(1); return responseTextCode.size() != 1 ? null : responseTextCode.getString(0); } private ResponseCodeExtractor(); static String getResponseCode(ImapResponse response); static final String AUTHENTICATION_FAILED; } | @Test public void getResponseCode_withResponseCode() throws Exception { ImapResponse imapResponse = createImapResponse("x NO [AUTHENTICATIONFAILED] No sir"); String result = ResponseCodeExtractor.getResponseCode(imapResponse); assertEquals("AUTHENTICATIONFAILED", result); }
@Test public void getResponseCode_withoutResponseCode() throws Exception { ImapResponse imapResponse = createImapResponse("x NO Authentication failed"); String result = ResponseCodeExtractor.getResponseCode(imapResponse); assertNull(result); }
@Test public void getResponseCode_withoutSingleItemResponse() throws Exception { ImapResponse imapResponse = createImapResponse("x NO"); String result = ResponseCodeExtractor.getResponseCode(imapResponse); assertNull(result); } |
NamespaceResponse { public static NamespaceResponse parse(List<ImapResponse> responses) { for (ImapResponse response : responses) { NamespaceResponse prefix = parse(response); if (prefix != null) { return prefix; } } return null; } private NamespaceResponse(String prefix, String hierarchyDelimiter); static NamespaceResponse parse(List<ImapResponse> responses); String getPrefix(); String getHierarchyDelimiter(); } | @Test public void parse_withoutNamespaceResponse_shouldReturnNull() throws Exception { NamespaceResponse result = parse("* OK Some text here"); assertNull(result); }
@Test public void parse_withTooShortNamespaceResponse_shouldReturnNull() throws Exception { NamespaceResponse result = parse("* NAMESPACE NIL NIL"); assertNull(result); }
@Test public void parse_withPersonalNamespacesNotPresent_shouldReturnNull() throws Exception { NamespaceResponse result = parse("* NAMESPACE NIL NIL NIL"); assertNull(result); }
@Test public void parse_withEmptyListForPersonalNamespaces_shouldReturnNull() throws Exception { NamespaceResponse result = parse("* NAMESPACE () NIL NIL"); assertNull(result); }
@Test public void parse_withEmptyListForFirstPersonalNamespace_shouldReturnNull() throws Exception { NamespaceResponse result = parse("* NAMESPACE (()) NIL NIL"); assertNull(result); }
@Test public void parse_withIncompleteFirstPersonalNamespace_shouldReturnNull() throws Exception { NamespaceResponse result = parse("* NAMESPACE ((\"\")) NIL NIL"); assertNull(result); }
@Test public void parse_withEmptyResponseList() throws Exception { NamespaceResponse result = NamespaceResponse.parse(Collections.<ImapResponse>emptyList()); assertNull(result); } |
ListResponse { public static List<ListResponse> parseList(List<ImapResponse> responses) { return parse(responses, Responses.LIST); } private ListResponse(List<String> attributes, String hierarchyDelimiter, String name); static List<ListResponse> parseList(List<ImapResponse> responses); static List<ListResponse> parseLsub(List<ImapResponse> responses); List<String> getAttributes(); boolean hasAttribute(String attribute); @Nullable String getHierarchyDelimiter(); String getName(); } | @Test public void parseList_withValidResponses_shouldReturnListResponses() throws Exception { List<ImapResponse> responses = asList( createImapResponse("* LIST () \"/\" blurdybloop"), createImapResponse("* LIST (\\Noselect) \"/\" foo"), createImapResponse("* LIST () \"/\" foo/bar"), createImapResponse("* LIST (\\NoInferiors) NIL INBOX"), createImapResponse("X OK LIST completed") ); List<ListResponse> result = ListResponse.parseList(responses); assertEquals(4, result.size()); assertListResponseEquals(noAttributes(), "/", "blurdybloop", result.get(0)); assertListResponseEquals(singletonList("\\Noselect"), "/", "foo", result.get(1)); assertListResponseEquals(noAttributes(), "/", "foo/bar", result.get(2)); assertListResponseEquals(singletonList("\\NoInferiors"), null, "INBOX", result.get(3)); } |
ListResponse { public static List<ListResponse> parseLsub(List<ImapResponse> responses) { return parse(responses, Responses.LSUB); } private ListResponse(List<String> attributes, String hierarchyDelimiter, String name); static List<ListResponse> parseList(List<ImapResponse> responses); static List<ListResponse> parseLsub(List<ImapResponse> responses); List<String> getAttributes(); boolean hasAttribute(String attribute); @Nullable String getHierarchyDelimiter(); String getName(); } | @Test public void parseLsub_withValidResponse_shouldReturnListResponse() throws Exception { List<ImapResponse> responses = singletonList(createImapResponse("* LSUB () \".\" \"Folder\"")); List<ListResponse> result = ListResponse.parseLsub(responses); assertEquals(1, result.size()); assertListResponseEquals(noAttributes(), ".", "Folder", result.get(0)); } |
ImapConnection { public void open() throws IOException, MessagingException { if (open) { return; } else if (stacktraceForClose != null) { throw new IllegalStateException("open() called after close(). " + "Check wrapped exception to see where close() was called.", stacktraceForClose); } open = true; boolean authSuccess = false; nextCommandTag = 1; adjustDNSCacheTTL(); try { socket = connect(); configureSocket(); setUpStreamsAndParserFromSocket(); readInitialResponse(); requestCapabilitiesIfNecessary(); upgradeToTlsIfNecessary(); List<ImapResponse> responses = authenticate(); authSuccess = true; extractOrRequestCapabilities(responses); enableCompressionIfRequested(); retrievePathPrefixIfNecessary(); retrievePathDelimiterIfNecessary(); } catch (SSLException e) { handleSslException(e); } catch (ConnectException e) { handleConnectException(e); } catch (GeneralSecurityException e) { throw new MessagingException("Unable to open connection to IMAP server due to security error.", e); } finally { if (!authSuccess) { Timber.e("Failed to login, closing connection for %s", getLogId()); close(); } } } ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider,
int socketConnectTimeout, int socketReadTimeout); void open(); boolean isConnected(); void close(); OutputStream getOutputStream(); List<ImapResponse> executeSimpleCommand(String command); List<ImapResponse> executeSimpleCommand(String command, boolean sensitive); List<ImapResponse> readStatusResponse(String tag, String commandToLog, UntaggedHandler untaggedHandler); String sendSaslIrCommand(String command, String initialClientResponse, boolean sensitive); String sendCommand(String command, boolean sensitive); void sendContinuation(String continuation); ImapResponse readResponse(); ImapResponse readResponse(ImapResponseCallback callback); } | @Test public void open_withNoCapabilitiesInInitialResponse_shouldIssuePreAuthCapabilitiesCommand() throws Exception { settings.setAuthType(AuthType.PLAIN); MockImapServer server = new MockImapServer(); server.output("* OK example.org server"); server.expect("1 CAPABILITY"); server.output("* CAPABILITY IMAP4 IMAP4REV1 AUTH=PLAIN"); server.output("1 OK CAPABILITY Completed"); server.expect("2 AUTHENTICATE PLAIN"); server.output("+"); server.expect(ByteString.encodeUtf8("\000" + USERNAME + "\000" + PASSWORD).base64()); server.output("2 OK Success"); postAuthenticationDialogRequestingCapabilities(server); ImapConnection imapConnection = startServerAndCreateImapConnection(server); imapConnection.open(); server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); }
@Test public void open_withCapabilitiesInInitialResponse_shouldNotIssuePreAuthCapabilitiesCommand() throws Exception { settings.setAuthType(AuthType.PLAIN); MockImapServer server = new MockImapServer(); server.output("* OK [CAPABILITY IMAP4 IMAP4REV1 AUTH=PLAIN]"); server.expect("1 AUTHENTICATE PLAIN"); server.output("+"); server.expect(ByteString.encodeUtf8("\000" + USERNAME + "\000" + PASSWORD).base64()); server.output("1 OK Success"); postAuthenticationDialogRequestingCapabilities(server, 2); ImapConnection imapConnection = startServerAndCreateImapConnection(server); imapConnection.open(); server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); }
@Test public void open_authPlain() throws Exception { settings.setAuthType(AuthType.PLAIN); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server, "AUTH=PLAIN"); server.expect("2 AUTHENTICATE PLAIN"); server.output("+"); server.expect(ByteString.encodeUtf8("\000" + USERNAME + "\000" + PASSWORD).base64()); server.output("2 OK Success"); postAuthenticationDialogRequestingCapabilities(server); ImapConnection imapConnection = startServerAndCreateImapConnection(server); imapConnection.open(); server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); }
@Test public void open_authPlainWithLoginDisabled_shouldThrow() throws Exception { settings.setAuthType(AuthType.PLAIN); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server, "LOGINDISABLED"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); try { imapConnection.open(); fail("Expected exception"); } catch (MessagingException e) { assertEquals("Server doesn't support unencrypted passwords using AUTH=PLAIN and LOGIN is disabled.", e.getMessage()); } server.verifyConnectionClosed(); server.verifyInteractionCompleted(); }
@Test public void open_authPlainWithAuthenticationFailure_shouldFallbackToLogin() throws Exception { settings.setAuthType(AuthType.PLAIN); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server, "AUTH=PLAIN"); server.expect("2 AUTHENTICATE PLAIN"); server.output("+"); server.expect(ByteString.encodeUtf8("\000" + USERNAME + "\000" + PASSWORD).base64()); server.output("2 NO Login Failure"); server.expect("3 LOGIN \"" + USERNAME + "\" \"" + PASSWORD + "\""); server.output("3 OK LOGIN completed"); postAuthenticationDialogRequestingCapabilities(server, 4); ImapConnection imapConnection = startServerAndCreateImapConnection(server); imapConnection.open(); server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); }
@Test public void open_authPlainAndLoginFallbackWithAuthenticationFailure_shouldThrow() throws Exception { settings.setAuthType(AuthType.PLAIN); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server, "AUTH=PLAIN"); server.expect("2 AUTHENTICATE PLAIN"); server.output("+"); server.expect(ByteString.encodeUtf8("\000" + USERNAME + "\000" + PASSWORD).base64()); server.output("2 NO Login Failure"); server.expect("3 LOGIN \"" + USERNAME + "\" \"" + PASSWORD + "\""); server.output("3 NO Go away"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); try { imapConnection.open(); fail("Expected exception"); } catch (AuthenticationFailedException e) { assertThat(e.getMessage(), containsString("Go away")); } server.verifyConnectionClosed(); server.verifyInteractionCompleted(); }
@Test public void open_authPlainWithByeResponseAndConnectionClose_shouldThrowAuthenticationFailedException() throws Exception { settings.setAuthType(AuthType.PLAIN); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server, "AUTH=PLAIN"); server.expect("2 AUTHENTICATE PLAIN"); server.output("+"); server.expect(ByteString.encodeUtf8("\000" + USERNAME + "\000" + PASSWORD).base64()); server.output("* BYE Go away"); server.output("2 NO Login Failure"); server.closeConnection(); ImapConnection imapConnection = startServerAndCreateImapConnection(server); try { imapConnection.open(); fail("Expected exception"); } catch (AuthenticationFailedException e) { assertThat(e.getMessage(), containsString("Login Failure")); } server.verifyConnectionClosed(); server.verifyInteractionCompleted(); }
@Test public void open_authPlainWithoutAuthPlainCapability_shouldUseLoginMethod() throws Exception { settings.setAuthType(AuthType.PLAIN); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server); server.expect("2 LOGIN \"" + USERNAME + "\" \"" + PASSWORD + "\""); server.output("2 OK LOGIN completed"); postAuthenticationDialogRequestingCapabilities(server); ImapConnection imapConnection = startServerAndCreateImapConnection(server); imapConnection.open(); server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); }
@Test public void open_authCramMd5() throws Exception { settings.setAuthType(AuthType.CRAM_MD5); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server, "AUTH=CRAM-MD5"); server.expect("2 AUTHENTICATE CRAM-MD5"); server.output("+ " + ByteString.encodeUtf8("<[email protected]>").base64()); server.expect("dXNlciA2ZjdiOTcyYjk5YTI4NDk4OTRhN2YyMmE3MGRhZDg0OQ=="); server.output("2 OK Success"); postAuthenticationDialogRequestingCapabilities(server); ImapConnection imapConnection = startServerAndCreateImapConnection(server); imapConnection.open(); server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); }
@Test public void open_authCramMd5WithAuthenticationFailure_shouldThrow() throws Exception { settings.setAuthType(AuthType.CRAM_MD5); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server, "AUTH=CRAM-MD5"); server.expect("2 AUTHENTICATE CRAM-MD5"); server.output("+ " + ByteString.encodeUtf8("<[email protected]>").base64()); server.expect("dXNlciA2ZjdiOTcyYjk5YTI4NDk4OTRhN2YyMmE3MGRhZDg0OQ=="); server.output("2 NO Who are you?"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); try { imapConnection.open(); fail("Expected exception"); } catch (AuthenticationFailedException e) { assertThat(e.getMessage(), containsString("Who are you?")); } server.verifyConnectionClosed(); server.verifyInteractionCompleted(); }
@Test public void open_authCramMd5WithoutAuthCramMd5Capability_shouldThrow() throws Exception { settings.setAuthType(AuthType.CRAM_MD5); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server, "AUTH=PLAIN"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); try { imapConnection.open(); fail("Expected exception"); } catch (MessagingException e) { assertEquals("Server doesn't support encrypted passwords using CRAM-MD5.", e.getMessage()); } server.verifyConnectionClosed(); server.verifyInteractionCompleted(); }
@Test public void open_authXoauthWithSaslIr() throws Exception { settings.setAuthType(AuthType.XOAUTH2); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server, "SASL-IR AUTH=XOAUTH AUTH=XOAUTH2"); server.expect("2 AUTHENTICATE XOAUTH2 " + XOAUTH_STRING); server.output("2 OK Success"); postAuthenticationDialogRequestingCapabilities(server); ImapConnection imapConnection = startServerAndCreateImapConnection(server); imapConnection.open(); server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); }
@Test public void open_authXoauthWithSaslIrThrowsExeptionOn401Response() throws Exception { settings.setAuthType(AuthType.XOAUTH2); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server, "SASL-IR AUTH=XOAUTH AUTH=XOAUTH2"); server.expect("2 AUTHENTICATE XOAUTH2 " + XOAUTH_STRING); server.output("+ " + XOAuth2ChallengeParserTest.STATUS_401_RESPONSE); server.expect(""); server.output("2 NO SASL authentication failed"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); try { imapConnection.open(); fail(); } catch (AuthenticationFailedException e) { assertEquals("Command: AUTHENTICATE XOAUTH2; response: #2# [NO, SASL authentication failed]", e.getMessage()); } }
@Test public void open_authXoauthWithSaslIrInvalidatesAndRetriesNewTokenOn400Response() throws Exception { settings.setAuthType(AuthType.XOAUTH2); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server, "SASL-IR AUTH=XOAUTH AUTH=XOAUTH2"); server.expect("2 AUTHENTICATE XOAUTH2 " + XOAUTH_STRING); server.output("+ " + XOAuth2ChallengeParserTest.STATUS_400_RESPONSE); server.expect(""); server.output("2 NO SASL authentication failed"); server.expect("3 AUTHENTICATE XOAUTH2 " + XOAUTH_STRING_RETRY); server.output("3 OK Success"); postAuthenticationDialogRequestingCapabilities(server, 4); ImapConnection imapConnection = startServerAndCreateImapConnection(server); imapConnection.open(); server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); }
@Test public void open_authXoauthWithSaslIrWithOldTokenThrowsExceptionIfRetryFails() throws Exception { settings.setAuthType(AuthType.XOAUTH2); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server, "SASL-IR AUTH=XOAUTH AUTH=XOAUTH2"); server.expect("2 AUTHENTICATE XOAUTH2 " + XOAUTH_STRING); server.output("+ r3j3krj3irj3oir3ojo"); server.expect(""); server.output("2 NO SASL authentication failed"); server.expect("3 AUTHENTICATE XOAUTH2 " + XOAUTH_STRING_RETRY); server.output("+ 433ba3a3a"); server.expect(""); server.output("3 NO SASL authentication failed"); postAuthenticationDialogRequestingCapabilities(server); ImapConnection imapConnection = startServerAndCreateImapConnection(server); try { imapConnection.open(); fail(); } catch (AuthenticationFailedException e) { assertEquals("Command: AUTHENTICATE XOAUTH2; response: #3# [NO, SASL authentication failed]", e.getMessage()); } }
@Test public void open_authExternal() throws Exception { settings.setAuthType(AuthType.EXTERNAL); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server, "AUTH=EXTERNAL"); server.expect("2 AUTHENTICATE EXTERNAL " + ByteString.encodeUtf8(USERNAME).base64()); server.output("2 OK Success"); postAuthenticationDialogRequestingCapabilities(server); ImapConnection imapConnection = startServerAndCreateImapConnection(server); imapConnection.open(); server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); }
@Test public void open_authExternalWithAuthenticationFailure_shouldThrow() throws Exception { settings.setAuthType(AuthType.EXTERNAL); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server, "AUTH=EXTERNAL"); server.expect("2 AUTHENTICATE EXTERNAL " + ByteString.encodeUtf8(USERNAME).base64()); server.output("2 NO Bad certificate"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); try { imapConnection.open(); fail("Expected exception"); } catch (CertificateValidationException e) { assertThat(e.getMessage(), containsString("Bad certificate")); } server.verifyConnectionClosed(); server.verifyInteractionCompleted(); }
@Test public void open_authExternalWithoutAuthExternalCapability_shouldThrow() throws Exception { settings.setAuthType(AuthType.EXTERNAL); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server, "AUTH=PLAIN"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); try { imapConnection.open(); fail("Expected exception"); } catch (CertificateValidationException e) { assertEquals(Reason.MissingCapability, e.getReason()); } server.verifyConnectionClosed(); server.verifyInteractionCompleted(); }
@Test public void open_withNamespaceCapability_shouldIssueNamespaceCommand() throws Exception { MockImapServer server = new MockImapServer(); simplePreAuthAndLoginDialog(server, "NAMESPACE"); server.expect("3 NAMESPACE"); server.output("* NAMESPACE ((\"\" \"/\")) NIL NIL"); server.output("3 OK command completed"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); imapConnection.open(); server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); }
@Test public void open_withConnectionError_shouldThrow() throws Exception { settings.setHost("127.1.2.3"); settings.setPort(143); ImapConnection imapConnection = createImapConnection( settings, socketFactory, connectivityManager, oAuth2TokenProvider); try { imapConnection.open(); fail("Expected exception"); } catch (MessagingException e) { assertEquals("Cannot connect to host", e.getMessage()); assertTrue(e.getCause() instanceof IOException); } }
@Test public void open_withStartTlsButWithoutStartTlsCapability_shouldThrow() throws Exception { settings.setConnectionSecurity(ConnectionSecurity.STARTTLS_REQUIRED); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server); ImapConnection imapConnection = startServerAndCreateImapConnection(server); try { imapConnection.open(); fail("Expected exception"); } catch (CertificateValidationException e) { assertEquals("STARTTLS connection security not available", e.getMessage()); } server.verifyConnectionClosed(); server.verifyInteractionCompleted(); }
@Test public void open_withNegativeResponseToStartTlsCommand_shouldThrow() throws Exception { settings.setAuthType(AuthType.PLAIN); settings.setConnectionSecurity(ConnectionSecurity.STARTTLS_REQUIRED); MockImapServer server = new MockImapServer(); preAuthenticationDialog(server, "STARTTLS"); server.expect("2 STARTTLS"); server.output("2 NO"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); try { imapConnection.open(); fail("Expected exception"); } catch (NegativeImapResponseException e) { assertEquals(e.getMessage(), "Command: STARTTLS; response: #2# [NO]"); } server.verifyConnectionClosed(); server.verifyInteractionCompleted(); }
@Test public void open_withNegativeResponseToCompressionCommand_shouldContinue() throws Exception { settings.setAuthType(AuthType.PLAIN); settings.setUseCompression(true); MockImapServer server = new MockImapServer(); simplePreAuthAndLoginDialog(server, "COMPRESS=DEFLATE"); server.expect("3 COMPRESS DEFLATE"); server.output("3 NO"); simplePostAuthenticationDialog(server, 4); ImapConnection imapConnection = startServerAndCreateImapConnection(server); imapConnection.open(); server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); }
@Test public void open_withIoExceptionDuringCompressionCommand_shouldThrow() throws Exception { settings.setAuthType(AuthType.PLAIN); settings.setUseCompression(true); MockImapServer server = new MockImapServer(); simplePreAuthAndLoginDialog(server, "COMPRESS=DEFLATE"); server.expect("3 COMPRESS DEFLATE"); server.closeConnection(); ImapConnection imapConnection = startServerAndCreateImapConnection(server); try { imapConnection.open(); fail("Exception expected"); } catch (IOException ignored) { } server.verifyConnectionClosed(); server.verifyInteractionCompleted(); }
@Test public void open_withIoExceptionDuringListCommand_shouldThrow() throws Exception { settings.setAuthType(AuthType.PLAIN); MockImapServer server = new MockImapServer(); simplePreAuthAndLoginDialog(server, ""); server.expect("3 LIST \"\" \"\""); server.output("* Now what?"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); try { imapConnection.open(); fail("Exception expected"); } catch (IOException ignored) { } server.verifyConnectionClosed(); server.verifyInteractionCompleted(); }
@Test public void open_withNegativeResponseToListCommand() throws Exception { settings.setAuthType(AuthType.PLAIN); MockImapServer server = new MockImapServer(); simplePreAuthAndLoginDialog(server, ""); server.expect("3 LIST \"\" \"\""); server.output("3 NO"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); imapConnection.open(); server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); } |
ImapConnection { public boolean isConnected() { return inputStream != null && outputStream != null && socket != null && socket.isConnected() && !socket.isClosed(); } ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider,
int socketConnectTimeout, int socketReadTimeout); void open(); boolean isConnected(); void close(); OutputStream getOutputStream(); List<ImapResponse> executeSimpleCommand(String command); List<ImapResponse> executeSimpleCommand(String command, boolean sensitive); List<ImapResponse> readStatusResponse(String tag, String commandToLog, UntaggedHandler untaggedHandler); String sendSaslIrCommand(String command, String initialClientResponse, boolean sensitive); String sendCommand(String command, boolean sensitive); void sendContinuation(String continuation); ImapResponse readResponse(); ImapResponse readResponse(ImapResponseCallback callback); } | @Test public void isConnected_withoutPreviousOpen_shouldReturnFalse() throws Exception { ImapConnection imapConnection = createImapConnection( settings, socketFactory, connectivityManager, oAuth2TokenProvider); boolean result = imapConnection.isConnected(); assertFalse(result); }
@Test public void isConnected_afterOpen_shouldReturnTrue() throws Exception { MockImapServer server = new MockImapServer(); ImapConnection imapConnection = simpleOpen(server); boolean result = imapConnection.isConnected(); assertTrue(result); server.verifyConnectionStillOpen(); server.shutdown(); } |
ImapConnection { public void close() { open = false; stacktraceForClose = new Exception(); untagQuietly(socket); IOUtils.closeQuietly(inputStream); IOUtils.closeQuietly(outputStream); IOUtils.closeQuietly(socket); inputStream = null; outputStream = null; socket = null; } ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider,
int socketConnectTimeout, int socketReadTimeout); void open(); boolean isConnected(); void close(); OutputStream getOutputStream(); List<ImapResponse> executeSimpleCommand(String command); List<ImapResponse> executeSimpleCommand(String command, boolean sensitive); List<ImapResponse> readStatusResponse(String tag, String commandToLog, UntaggedHandler untaggedHandler); String sendSaslIrCommand(String command, String initialClientResponse, boolean sensitive); String sendCommand(String command, boolean sensitive); void sendContinuation(String continuation); ImapResponse readResponse(); ImapResponse readResponse(ImapResponseCallback callback); } | @Test public void close_withoutOpen_shouldNotThrow() throws Exception { ImapConnection imapConnection = createImapConnection( settings, socketFactory, connectivityManager, oAuth2TokenProvider); imapConnection.close(); }
@Test public void close_afterOpen_shouldCloseConnection() throws Exception { MockImapServer server = new MockImapServer(); ImapConnection imapConnection = simpleOpen(server); imapConnection.close(); server.verifyConnectionClosed(); server.shutdown(); } |
ImapConnection { protected boolean isIdleCapable() { if (K9MailLib.isDebug()) { Timber.v("Connection %s has %d capabilities", getLogId(), capabilities.size()); } return capabilities.contains(Capabilities.IDLE); } ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider,
int socketConnectTimeout, int socketReadTimeout); void open(); boolean isConnected(); void close(); OutputStream getOutputStream(); List<ImapResponse> executeSimpleCommand(String command); List<ImapResponse> executeSimpleCommand(String command, boolean sensitive); List<ImapResponse> readStatusResponse(String tag, String commandToLog, UntaggedHandler untaggedHandler); String sendSaslIrCommand(String command, String initialClientResponse, boolean sensitive); String sendCommand(String command, boolean sensitive); void sendContinuation(String continuation); ImapResponse readResponse(); ImapResponse readResponse(ImapResponseCallback callback); } | @Test public void isIdleCapable_withoutIdleCapability() throws Exception { MockImapServer server = new MockImapServer(); ImapConnection imapConnection = simpleOpen(server); boolean result = imapConnection.isIdleCapable(); assertFalse(result); server.shutdown(); }
@Test public void isIdleCapable_withIdleCapability() throws Exception { MockImapServer server = new MockImapServer(); ImapConnection imapConnection = simpleOpenWithCapabilities(server, "IDLE"); boolean result = imapConnection.isIdleCapable(); assertTrue(result); server.shutdown(); } |
ImapConnection { public void sendContinuation(String continuation) throws IOException { outputStream.write(continuation.getBytes()); outputStream.write('\r'); outputStream.write('\n'); outputStream.flush(); if (K9MailLib.isDebug() && DEBUG_PROTOCOL_IMAP) { Timber.v("%s>>> %s", getLogId(), continuation); } } ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider,
int socketConnectTimeout, int socketReadTimeout); void open(); boolean isConnected(); void close(); OutputStream getOutputStream(); List<ImapResponse> executeSimpleCommand(String command); List<ImapResponse> executeSimpleCommand(String command, boolean sensitive); List<ImapResponse> readStatusResponse(String tag, String commandToLog, UntaggedHandler untaggedHandler); String sendSaslIrCommand(String command, String initialClientResponse, boolean sensitive); String sendCommand(String command, boolean sensitive); void sendContinuation(String continuation); ImapResponse readResponse(); ImapResponse readResponse(ImapResponseCallback callback); } | @Test public void sendContinuation() throws Exception { settings.setAuthType(AuthType.PLAIN); MockImapServer server = new MockImapServer(); simpleOpenDialog(server, "IDLE"); server.expect("4 IDLE"); server.output("+ idling"); server.expect("DONE"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); imapConnection.open(); imapConnection.sendCommand("IDLE", false); imapConnection.readResponse(); imapConnection.sendContinuation("DONE"); server.waitForInteractionToComplete(); server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); } |
ImapConnection { public List<ImapResponse> executeSimpleCommand(String command) throws IOException, MessagingException { return executeSimpleCommand(command, false); } ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); ImapConnection(ImapSettings settings, TrustedSocketFactory socketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider,
int socketConnectTimeout, int socketReadTimeout); void open(); boolean isConnected(); void close(); OutputStream getOutputStream(); List<ImapResponse> executeSimpleCommand(String command); List<ImapResponse> executeSimpleCommand(String command, boolean sensitive); List<ImapResponse> readStatusResponse(String tag, String commandToLog, UntaggedHandler untaggedHandler); String sendSaslIrCommand(String command, String initialClientResponse, boolean sensitive); String sendCommand(String command, boolean sensitive); void sendContinuation(String continuation); ImapResponse readResponse(); ImapResponse readResponse(ImapResponseCallback callback); } | @Test public void executeSingleCommand_withOkResponse_shouldReturnResult() throws Exception { MockImapServer server = new MockImapServer(); simpleOpenDialog(server, ""); server.expect("4 CREATE Folder"); server.output("4 OK Folder created"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); List<ImapResponse> result = imapConnection.executeSimpleCommand("CREATE Folder"); assertEquals(result.size(), 1); server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); }
@Test public void executeSingleCommand_withNoResponse_shouldThrowNegativeImapResponseException() throws Exception { MockImapServer server = new MockImapServer(); simpleOpenDialog(server, ""); server.expect("4 CREATE Folder"); server.output("4 NO Folder exists"); ImapConnection imapConnection = startServerAndCreateImapConnection(server); try { imapConnection.executeSimpleCommand("CREATE Folder"); fail("Expected exception"); } catch (NegativeImapResponseException e) { assertEquals("Folder exists", e.getLastResponse().getString(1)); } server.verifyConnectionStillOpen(); server.verifyInteractionCompleted(); } |
FolderNameCodec { public String encode(String folderName) { ByteBuffer byteBuffer = modifiedUtf7Charset.encode(folderName); byte[] bytes = new byte[byteBuffer.limit()]; byteBuffer.get(bytes); return new String(bytes, asciiCharset); } private FolderNameCodec(); static FolderNameCodec newInstance(); String encode(String folderName); String decode(String encodedFolderName); } | @Test public void encode_withAsciiArgument_shouldReturnInput() throws Exception { String folderName = "ASCII"; String result = folderNameCode.encode(folderName); assertEquals(folderName, result); }
@Test public void encode_withNonAsciiArgument_shouldReturnEncodedString() throws Exception { String folderName = "über"; String result = folderNameCode.encode(folderName); assertEquals("&APw-ber", result); } |
FolderNameCodec { public String decode(String encodedFolderName) throws CharacterCodingException { CharsetDecoder decoder = modifiedUtf7Charset.newDecoder().onMalformedInput(CodingErrorAction.REPORT); ByteBuffer byteBuffer = ByteBuffer.wrap(encodedFolderName.getBytes(asciiCharset)); CharBuffer charBuffer = decoder.decode(byteBuffer); return charBuffer.toString(); } private FolderNameCodec(); static FolderNameCodec newInstance(); String encode(String folderName); String decode(String encodedFolderName); } | @Test public void decode_withEncodedArgument_shouldReturnDecodedString() throws Exception { String encodedFolderName = "&ANw-bergr&APYA3w-entr&AOQ-ger"; String result = folderNameCode.decode(encodedFolderName); assertEquals("Übergrößenträger", result); }
@Test public void decode_withInvalidEncodedArgument_shouldThrow() throws Exception { String encodedFolderName = "&12-foo"; try { folderNameCode.decode(encodedFolderName); fail("Expected exception"); } catch (CharacterCodingException ignored) { } } |
ImapStore extends RemoteStore { @Override @NonNull public ImapFolder getFolder(String folderId) { ImapFolder folder; synchronized (folderCache) { folder = folderCache.get(folderId); if (folder == null) { folder = new ImapFolder(this, folderId); folderCache.put(folderId, folder); } } return folder; } ImapStore(StoreConfig storeConfig, TrustedSocketFactory trustedSocketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); static ImapStoreSettings decodeUri(String uri); static String createUri(ServerSettings server); @Override @NonNull ImapFolder getFolder(String folderId); @Override @NonNull List<ImapFolder> getFolders(boolean forceListAll); @Override @NonNull List<ImapFolder> getSubFolders(final String parentFolderId, boolean forceListAll); @NonNull List<ImapFolder> getPersonalNamespaces(boolean forceListAll); @Override void checkSettings(); @Override boolean isMoveCapable(); @Override boolean isCopyCapable(); @Override boolean isPushCapable(); @Override boolean isExpungeCapable(); @Override Pusher getPusher(PushReceiver receiver); String getFolderName(String id); } | @Test public void getFolder_shouldReturnImapFolderInstance() throws Exception { Folder result = imapStore.getFolder("INBOX"); assertEquals(ImapFolder.class, result.getClass()); }
@Test public void getFolder_calledTwice_shouldReturnFirstInstance() throws Exception { String folderName = "Trash"; Folder imapFolder = imapStore.getFolder(folderName); Folder result = imapStore.getFolder(folderName); assertEquals(imapFolder, result); } |
ImapStore extends RemoteStore { @Override public void checkSettings() throws MessagingException { try { ImapConnection connection = createImapConnection(); connection.open(); autoconfigureFolders(connection); connection.close(); } catch (IOException ioe) { throw new MessagingException("Unable to connect", ioe); } } ImapStore(StoreConfig storeConfig, TrustedSocketFactory trustedSocketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); static ImapStoreSettings decodeUri(String uri); static String createUri(ServerSettings server); @Override @NonNull ImapFolder getFolder(String folderId); @Override @NonNull List<ImapFolder> getFolders(boolean forceListAll); @Override @NonNull List<ImapFolder> getSubFolders(final String parentFolderId, boolean forceListAll); @NonNull List<ImapFolder> getPersonalNamespaces(boolean forceListAll); @Override void checkSettings(); @Override boolean isMoveCapable(); @Override boolean isCopyCapable(); @Override boolean isPushCapable(); @Override boolean isExpungeCapable(); @Override Pusher getPusher(PushReceiver receiver); String getFolderName(String id); } | @Test public void checkSettings_shouldCreateImapConnectionAndCallOpen() throws Exception { ImapConnection imapConnection = mock(ImapConnection.class); imapStore.enqueueImapConnection(imapConnection); imapStore.checkSettings(); verify(imapConnection).open(); }
@Test public void checkSettings_withOpenThrowing_shouldThrowMessagingException() throws Exception { ImapConnection imapConnection = mock(ImapConnection.class); doThrow(IOException.class).when(imapConnection).open(); imapStore.enqueueImapConnection(imapConnection); try { imapStore.checkSettings(); fail("Expected exception"); } catch (MessagingException e) { assertEquals("Unable to connect", e.getMessage()); assertNotNull(e.getCause()); assertEquals(IOException.class, e.getCause().getClass()); } } |
ImapStore extends RemoteStore { void autoconfigureFolders(final ImapConnection connection) throws IOException, MessagingException { if (!connection.hasCapability(Capabilities.SPECIAL_USE)) { if (K9MailLib.isDebug()) { Timber.d("No detected folder auto-configuration methods."); } return; } if (K9MailLib.isDebug()) { Timber.d("Folder auto-configuration: Using RFC6154/SPECIAL-USE."); } String command = String.format("LIST (SPECIAL-USE) \"\" %s", ImapUtility.encodeString(getCombinedPrefix() + "*")); List<ImapResponse> responses = connection.executeSimpleCommand(command); List<ListResponse> listResponses = ListResponse.parseList(responses); for (ListResponse listResponse : listResponses) { String decodedFolderName; try { decodedFolderName = folderNameCodec.decode(listResponse.getName()); } catch (CharacterCodingException e) { Timber.w(e, "Folder name not correctly encoded with the UTF-7 variant as defined by RFC 3501: %s", listResponse.getName()); continue; } if (pathDelimiter == null) { pathDelimiter = listResponse.getHierarchyDelimiter(); combinedPrefix = null; } if (listResponse.hasAttribute("\\Archive") || listResponse.hasAttribute("\\All")) { mStoreConfig.setArchiveFolderId(decodedFolderName); if (K9MailLib.isDebug()) { Timber.d("Folder auto-configuration detected Archive folder: %s", decodedFolderName); } } else if (listResponse.hasAttribute("\\Drafts")) { mStoreConfig.setDraftsFolderId(decodedFolderName); if (K9MailLib.isDebug()) { Timber.d("Folder auto-configuration detected Drafts folder: %s", decodedFolderName); } } else if (listResponse.hasAttribute("\\Sent")) { mStoreConfig.setSentFolderId(decodedFolderName); if (K9MailLib.isDebug()) { Timber.d("Folder auto-configuration detected Sent folder: %s", decodedFolderName); } } else if (listResponse.hasAttribute("\\Junk")) { mStoreConfig.setSpamFolderId(decodedFolderName); if (K9MailLib.isDebug()) { Timber.d("Folder auto-configuration detected Spam folder: %s", decodedFolderName); } } else if (listResponse.hasAttribute("\\Trash")) { mStoreConfig.setTrashFolderId(decodedFolderName); if (K9MailLib.isDebug()) { Timber.d("Folder auto-configuration detected Trash folder: %s", decodedFolderName); } } } } ImapStore(StoreConfig storeConfig, TrustedSocketFactory trustedSocketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); static ImapStoreSettings decodeUri(String uri); static String createUri(ServerSettings server); @Override @NonNull ImapFolder getFolder(String folderId); @Override @NonNull List<ImapFolder> getFolders(boolean forceListAll); @Override @NonNull List<ImapFolder> getSubFolders(final String parentFolderId, boolean forceListAll); @NonNull List<ImapFolder> getPersonalNamespaces(boolean forceListAll); @Override void checkSettings(); @Override boolean isMoveCapable(); @Override boolean isCopyCapable(); @Override boolean isPushCapable(); @Override boolean isExpungeCapable(); @Override Pusher getPusher(PushReceiver receiver); String getFolderName(String id); } | @Test public void autoconfigureFolders_withSpecialUseCapability_shouldSetSpecialFolders() throws Exception { ImapConnection imapConnection = mock(ImapConnection.class); when(imapConnection.hasCapability(Capabilities.SPECIAL_USE)).thenReturn(true); List<ImapResponse> imapResponses = Arrays.asList( createImapResponse("* LIST (\\HasNoChildren) \"/\" \"INBOX\""), createImapResponse("* LIST (\\Noselect \\HasChildren) \"/\" \"[Gmail]\""), createImapResponse("* LIST (\\HasNoChildren \\All) \"/\" \"[Gmail]/All Mail\""), createImapResponse("* LIST (\\HasNoChildren \\Drafts) \"/\" \"[Gmail]/Drafts\""), createImapResponse("* LIST (\\HasNoChildren \\Important) \"/\" \"[Gmail]/Important\""), createImapResponse("* LIST (\\HasNoChildren \\Sent) \"/\" \"[Gmail]/Sent Mail\""), createImapResponse("* LIST (\\HasNoChildren \\Junk) \"/\" \"[Gmail]/Spam\""), createImapResponse("* LIST (\\HasNoChildren \\Flagged) \"/\" \"[Gmail]/Starred\""), createImapResponse("* LIST (\\HasNoChildren \\Trash) \"/\" \"[Gmail]/Trash\""), createImapResponse("5 OK Success") ); when(imapConnection.executeSimpleCommand("LIST (SPECIAL-USE) \"\" \"*\"")).thenReturn(imapResponses); imapStore.autoconfigureFolders(imapConnection); verify(storeConfig).setDraftsFolderId("[Gmail]/Drafts"); verify(storeConfig).setSentFolderId("[Gmail]/Sent Mail"); verify(storeConfig).setSpamFolderId("[Gmail]/Spam"); verify(storeConfig).setTrashFolderId("[Gmail]/Trash"); verify(storeConfig).setArchiveFolderId("[Gmail]/All Mail"); }
@Test public void autoconfigureFolders_withoutSpecialUseCapability_shouldNotIssueImapCommand() throws Exception { ImapConnection imapConnection = mock(ImapConnection.class); when(imapConnection.hasCapability(Capabilities.SPECIAL_USE)).thenReturn(false); imapStore.autoconfigureFolders(imapConnection); verify(imapConnection, atLeastOnce()).hasCapability(anyString()); verifyNoMoreInteractions(imapConnection); } |
ImapStore extends RemoteStore { @Override @NonNull public List<ImapFolder> getFolders(boolean forceListAll) throws MessagingException { return getPersonalNamespaces(forceListAll); } ImapStore(StoreConfig storeConfig, TrustedSocketFactory trustedSocketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); static ImapStoreSettings decodeUri(String uri); static String createUri(ServerSettings server); @Override @NonNull ImapFolder getFolder(String folderId); @Override @NonNull List<ImapFolder> getFolders(boolean forceListAll); @Override @NonNull List<ImapFolder> getSubFolders(final String parentFolderId, boolean forceListAll); @NonNull List<ImapFolder> getPersonalNamespaces(boolean forceListAll); @Override void checkSettings(); @Override boolean isMoveCapable(); @Override boolean isCopyCapable(); @Override boolean isPushCapable(); @Override boolean isExpungeCapable(); @Override Pusher getPusher(PushReceiver receiver); String getFolderName(String id); } | @Test public void getPersonalNamespaces_withForceListAll() throws Exception { when(storeConfig.subscribedFoldersOnly()).thenReturn(true); ImapConnection imapConnection = mock(ImapConnection.class); List<ImapResponse> imapResponses = Arrays.asList( createImapResponse("* LIST (\\HasNoChildren) \".\" \"INBOX\""), createImapResponse("* LIST (\\Noselect \\HasChildren) \".\" \"Folder\""), createImapResponse("* LIST (\\HasNoChildren) \".\" \"Folder.SubFolder\""), createImapResponse("6 OK Success") ); when(imapConnection.executeSimpleCommand("LIST \"\" \"*\"")).thenReturn(imapResponses); imapStore.enqueueImapConnection(imapConnection); List<? extends Folder> result = imapStore.getFolders(true); assertNotNull(result); assertEquals(Sets.newSet("INBOX", "Folder.SubFolder"), extractFolderIds(result)); }
@Test public void getPersonalNamespaces_withPathPrefix() throws Exception { when(storeConfig.getStoreUri()).thenReturn("imap: imapStore = new TestImapStore(storeConfig, trustedSocketFactory, connectivityManager, oauth2TokenProvider); ImapConnection imapConnection = mock(ImapConnection.class); List<ImapResponse> imapResponses = Arrays.asList( createImapResponse("* LIST (\\HasNoChildren) \".\" \"pathPrefix/INBOX\""), createImapResponse("* LIST (\\Noselect \\HasChildren) \".\" \"pathPrefix/.Folder\""), createImapResponse("* LIST (\\HasNoChildren) \".\" \"pathPrefix/.Folder.SubFolder\""), createImapResponse("6 OK Success") ); when(imapConnection.executeSimpleCommand("LIST \"\" \"pathPrefix/*\"")).thenReturn(imapResponses); imapStore.enqueueImapConnection(imapConnection); List<? extends Folder> result = imapStore.getFolders(true); assertNotNull(result); assertEquals(Sets.newSet("INBOX", "Folder.SubFolder"), extractFolderIds(result)); }
@Test public void getPersonalNamespaces_withoutForceListAllAndWithoutSubscribedFoldersOnly() throws Exception { when(storeConfig.subscribedFoldersOnly()).thenReturn(false); ImapConnection imapConnection = mock(ImapConnection.class); List<ImapResponse> imapResponses = Arrays.asList( createImapResponse("* LIST (\\HasNoChildren) \".\" \"INBOX\""), createImapResponse("* LIST (\\Noselect \\HasChildren) \".\" \"Folder\""), createImapResponse("* LIST (\\HasNoChildren) \".\" \"Folder.SubFolder\""), createImapResponse("6 OK Success") ); when(imapConnection.executeSimpleCommand("LIST \"\" \"*\"")).thenReturn(imapResponses); imapStore.enqueueImapConnection(imapConnection); List<? extends Folder> result = imapStore.getFolders(false); assertNotNull(result); assertEquals(Sets.newSet("INBOX", "Folder.SubFolder"), extractFolderIds(result)); }
@Test public void getPersonalNamespaces_withSubscribedFoldersOnlyAndWithoutForceListAll_shouldOnlyReturnExistingSubscribedFolders() throws Exception { when(storeConfig.subscribedFoldersOnly()).thenReturn(true); ImapConnection imapConnection = mock(ImapConnection.class); List<ImapResponse> lsubResponses = Arrays.asList( createImapResponse("* LSUB (\\HasNoChildren) \".\" \"INBOX\""), createImapResponse("* LSUB (\\Noselect \\HasChildren) \".\" \"Folder\""), createImapResponse("* LSUB (\\HasNoChildren) \".\" \"Folder.SubFolder\""), createImapResponse("* LSUB (\\HasNoChildren) \".\" \"SubscribedFolderThatHasBeenDeleted\""), createImapResponse("5 OK Success") ); when(imapConnection.executeSimpleCommand("LSUB \"\" \"*\"")).thenReturn(lsubResponses); List<ImapResponse> imapResponses = Arrays.asList( createImapResponse("* LIST (\\HasNoChildren) \".\" \"INBOX\""), createImapResponse("* LIST (\\Noselect \\HasChildren) \".\" \"Folder\""), createImapResponse("* LIST (\\HasNoChildren) \".\" \"Folder.SubFolder\""), createImapResponse("6 OK Success") ); when(imapConnection.executeSimpleCommand("LIST \"\" \"*\"")).thenReturn(imapResponses); imapStore.enqueueImapConnection(imapConnection); List<? extends Folder> result = imapStore.getFolders(false); assertNotNull(result); assertEquals(Sets.newSet("INBOX", "Folder.SubFolder"), extractFolderIds(result)); }
@Test public void getPersonalNamespaces_withoutException_shouldLeaveImapConnectionOpen() throws Exception { ImapConnection imapConnection = mock(ImapConnection.class); List<ImapResponse> imapResponses = Collections.singletonList(createImapResponse("5 OK Success")); when(imapConnection.executeSimpleCommand(anyString())).thenReturn(imapResponses); imapStore.enqueueImapConnection(imapConnection); imapStore.getFolders(true); verify(imapConnection, never()).close(); }
@Test public void getPersonalNamespaces_withIoException_shouldCloseImapConnection() throws Exception { ImapConnection imapConnection = mock(ImapConnection.class); doThrow(IOException.class).when(imapConnection).executeSimpleCommand("LIST \"\" \"*\""); imapStore.enqueueImapConnection(imapConnection); try { imapStore.getFolders(true); fail("Expected exception"); } catch (MessagingException ignored) { } verify(imapConnection).close(); } |
ImapStore extends RemoteStore { ImapConnection getConnection() throws MessagingException { ImapConnection connection; while ((connection = pollConnection()) != null) { try { connection.executeSimpleCommand(Commands.NOOP); break; } catch (IOException ioe) { connection.close(); } } if (connection == null) { connection = createImapConnection(); } return connection; } ImapStore(StoreConfig storeConfig, TrustedSocketFactory trustedSocketFactory,
ConnectivityManager connectivityManager, OAuth2TokenProvider oauthTokenProvider); static ImapStoreSettings decodeUri(String uri); static String createUri(ServerSettings server); @Override @NonNull ImapFolder getFolder(String folderId); @Override @NonNull List<ImapFolder> getFolders(boolean forceListAll); @Override @NonNull List<ImapFolder> getSubFolders(final String parentFolderId, boolean forceListAll); @NonNull List<ImapFolder> getPersonalNamespaces(boolean forceListAll); @Override void checkSettings(); @Override boolean isMoveCapable(); @Override boolean isCopyCapable(); @Override boolean isPushCapable(); @Override boolean isExpungeCapable(); @Override Pusher getPusher(PushReceiver receiver); String getFolderName(String id); } | @Test public void getConnection_shouldCreateImapConnection() throws Exception { ImapConnection imapConnection = mock(ImapConnection.class); imapStore.enqueueImapConnection(imapConnection); ImapConnection result = imapStore.getConnection(); assertSame(imapConnection, result); }
@Test public void getConnection_calledTwiceWithoutRelease_shouldCreateTwoImapConnection() throws Exception { ImapConnection imapConnectionOne = mock(ImapConnection.class); ImapConnection imapConnectionTwo = mock(ImapConnection.class); imapStore.enqueueImapConnection(imapConnectionOne); imapStore.enqueueImapConnection(imapConnectionTwo); ImapConnection resultOne = imapStore.getConnection(); ImapConnection resultTwo = imapStore.getConnection(); assertSame(imapConnectionOne, resultOne); assertSame(imapConnectionTwo, resultTwo); } |
ImapUtility { public static List<String> getImapSequenceValues(String set) { List<String> list = new ArrayList<String>(); if (set != null) { String[] setItems = set.split(","); for (String item : setItems) { if (item.indexOf(':') == -1) { if (isNumberValid(item)) { list.add(item); } } else { list.addAll(getImapRangeValues(item)); } } } return list; } static List<String> getImapSequenceValues(String set); static List<String> getImapRangeValues(String range); static String encodeString(String str); static ImapResponse getLastResponse(List<ImapResponse> responses); } | @Test public void testGetImapSequenceValues() { String[] expected; List<String> actual; expected = new String[] {"1"}; actual = ImapUtility.getImapSequenceValues("1"); assertArrayEquals(expected, actual.toArray()); expected = new String[] {"2147483648"}; actual = ImapUtility.getImapSequenceValues("2147483648"); assertArrayEquals(expected, actual.toArray()); expected = new String[] {"4294967295"}; actual = ImapUtility.getImapSequenceValues("4294967295"); assertArrayEquals(expected, actual.toArray()); expected = new String[] {"1", "3", "2"}; actual = ImapUtility.getImapSequenceValues("1,3,2"); assertArrayEquals(expected, actual.toArray()); expected = new String[] {"4", "5", "6"}; actual = ImapUtility.getImapSequenceValues("4:6"); assertArrayEquals(expected, actual.toArray()); expected = new String[] {"9", "8", "7"}; actual = ImapUtility.getImapSequenceValues("9:7"); assertArrayEquals(expected, actual.toArray()); expected = new String[] {"1", "2", "3", "4", "9", "8", "7"}; actual = ImapUtility.getImapSequenceValues("1,2:4,9:7"); assertArrayEquals(expected, actual.toArray()); expected = new String[] {"2147483646", "2147483647", "2147483648"}; actual = ImapUtility.getImapSequenceValues("2147483646:2147483648"); assertArrayEquals(expected, actual.toArray()); expected = new String[] { "1", "5" }; actual = ImapUtility.getImapSequenceValues("1,x,5"); assertArrayEquals(expected, actual.toArray()); expected = new String[] { "1", "2", "3" }; actual = ImapUtility.getImapSequenceValues("a:d,1:3"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapSequenceValues(""); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapSequenceValues(null); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapSequenceValues("a"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapSequenceValues("1:x"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapSequenceValues("4294967296:4294967297"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapSequenceValues("4294967296"); assertArrayEquals(expected, actual.toArray()); } |
ImapUtility { public static List<String> getImapRangeValues(String range) { List<String> list = new ArrayList<String>(); try { if (range != null) { int colonPos = range.indexOf(':'); if (colonPos > 0) { long first = Long.parseLong(range.substring(0, colonPos)); long second = Long.parseLong(range.substring(colonPos + 1)); if (is32bitValue(first) && is32bitValue(second)) { if (first < second) { for (long i = first; i <= second; i++) { list.add(Long.toString(i)); } } else { for (long i = first; i >= second; i--) { list.add(Long.toString(i)); } } } else { Timber.d("Invalid range: %s", range); } } } } catch (NumberFormatException e) { Timber.d(e, "Invalid range value: %s", range); } return list; } static List<String> getImapSequenceValues(String set); static List<String> getImapRangeValues(String range); static String encodeString(String str); static ImapResponse getLastResponse(List<ImapResponse> responses); } | @Test public void testGetImapRangeValues() { String[] expected; List<String> actual; expected = new String[] {"1", "2", "3"}; actual = ImapUtility.getImapRangeValues("1:3"); assertArrayEquals(expected, actual.toArray()); expected = new String[] {"16", "15", "14"}; actual = ImapUtility.getImapRangeValues("16:14"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapRangeValues(""); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapRangeValues(null); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapRangeValues("a"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapRangeValues("6"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapRangeValues("1:3,6"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapRangeValues("1:x"); assertArrayEquals(expected, actual.toArray()); expected = new String[0]; actual = ImapUtility.getImapRangeValues("1:*"); assertArrayEquals(expected, actual.toArray()); } |
ImapPushState { public static ImapPushState parse(String pushState) { if (pushState == null || !pushState.startsWith(PUSH_STATE_PREFIX)) { return createDefaultImapPushState(); } String value = pushState.substring(PUSH_STATE_PREFIX_LENGTH); try { long newUidNext = Long.parseLong(value); return new ImapPushState(newUidNext); } catch (NumberFormatException e) { Timber.e(e, "Unable to part uidNext value %s", value); } return createDefaultImapPushState(); } ImapPushState(long uidNext); static ImapPushState parse(String pushState); @Override String toString(); final long uidNext; } | @Test public void parse_withValidArgument() throws Exception { ImapPushState result = ImapPushState.parse("uidNext=42"); assertNotNull(result); assertEquals(42L, result.uidNext); }
@Test public void parse_withNullArgument_shouldReturnUidNextOfMinusOne() throws Exception { ImapPushState result = ImapPushState.parse(null); assertNotNull(result); assertEquals(-1L, result.uidNext); }
@Test public void parse_withEmptyArgument_shouldReturnUidNextOfMinusOne() throws Exception { ImapPushState result = ImapPushState.parse(""); assertNotNull(result); assertEquals(-1L, result.uidNext); }
@Test public void parse_withInvalidArgument_shouldReturnUidNextOfMinusOne() throws Exception { ImapPushState result = ImapPushState.parse("xyz"); assertNotNull(result); assertEquals(-1L, result.uidNext); }
@Test public void parse_withIncompleteArgument_shouldReturnUidNextOfMinusOne() throws Exception { ImapPushState result = ImapPushState.parse("uidNext="); assertNotNull(result); assertEquals(-1L, result.uidNext); }
@Test public void parse_withoutIntegerAsUidNext_shouldReturnUidNextOfMinusOne() throws Exception { ImapPushState result = ImapPushState.parse("uidNext=xyz"); assertNotNull(result); assertEquals(-1L, result.uidNext); } |
HtmlConverter { public static String textToHtml(String text) { if (text.length() > MAX_SMART_HTMLIFY_MESSAGE_LENGTH) { return simpleTextToHtml(text); } StringBuilder buff = new StringBuilder(text.length() + TEXT_TO_HTML_EXTRA_BUFFER_LENGTH); boolean isStartOfLine = true; int spaces = 0; int quoteDepth = 0; int quotesThisLine = 0; for (int index = 0; index < text.length(); index++) { char c = text.charAt(index); if (isStartOfLine) { switch (c) { case ' ': spaces++; break; case '>': quotesThisLine++; spaces = 0; break; case '\n': appendbq(buff, quotesThisLine, quoteDepth); quoteDepth = quotesThisLine; appendsp(buff, spaces); spaces = 0; appendchar(buff, c); isStartOfLine = true; quotesThisLine = 0; break; default: isStartOfLine = false; appendbq(buff, quotesThisLine, quoteDepth); quoteDepth = quotesThisLine; appendsp(buff, spaces); spaces = 0; appendchar(buff, c); isStartOfLine = false; break; } } else { appendchar(buff, c); if (c == '\n') { isStartOfLine = true; quotesThisLine = 0; } } } if (quoteDepth > 0) { for (int i = quoteDepth; i > 0; i--) { buff.append(HTML_BLOCKQUOTE_END); } } text = buff.toString(); text = text.replaceAll( "\\Q" + HTML_NEWLINE + "\\E((\\Q" + HTML_NEWLINE + "\\E)+?)\\Q" + HTML_BLOCKQUOTE_END + "\\E", HTML_BLOCKQUOTE_END + "$1" ); text = ASCII_PATTERN_FOR_HR.matcher(text).replaceAll("<hr>"); StringBuffer sb = new StringBuffer(text.length() + TEXT_TO_HTML_EXTRA_BUFFER_LENGTH); sb.append(htmlifyMessageHeader()); UriLinkifier.linkifyText(text, sb); sb.append(htmlifyMessageFooter()); text = sb.toString(); text = text.replaceAll("<gt>", ">"); return text; } static String htmlToText(final String html); static String textToHtml(String text); static String convertEmoji2Img(String html); static String wrapStatusMessage(CharSequence status); static String wrapMessageContent(CharSequence messageContent); static String textToHtmlFragment(final String text); static Spanned htmlToSpanned(String html); } | @Test public void testTextQuoteToHtmlBlockquote() { String message = "Panama!\r\n" + "\r\n" + "Bob Barker <[email protected]> wrote:\r\n" + "> a canal\r\n" + ">\r\n" + "> Dorothy Jo Gideon <[email protected]> espoused:\r\n" + "> >A man, a plan...\r\n" + "> Too easy!\r\n" + "\r\n" + "Nice job :)\r\n" + ">> Guess!"; String result = HtmlConverter.textToHtml(message); writeToFile(result); assertEquals("<pre class=\"k9mail\">" + "Panama!<br />" + "<br />" + "Bob Barker <[email protected]> wrote:<br />" + "<blockquote class=\"gmail_quote\" style=\"margin: 0pt 0pt 1ex 0.8ex; border-left: 1px solid #729fcf; padding-left: 1ex;\">" + " a canal<br />" + "<br />" + " Dorothy Jo Gideon <[email protected]> espoused:<br />" + "<blockquote class=\"gmail_quote\" style=\"margin: 0pt 0pt 1ex 0.8ex; border-left: 1px solid #ad7fa8; padding-left: 1ex;\">" + "A man, a plan...<br />" + "</blockquote>" + " Too easy!<br />" + "</blockquote>" + "<br />" + "Nice job :)<br />" + "<blockquote class=\"gmail_quote\" style=\"margin: 0pt 0pt 1ex 0.8ex; border-left: 1px solid #729fcf; padding-left: 1ex;\">" + "<blockquote class=\"gmail_quote\" style=\"margin: 0pt 0pt 1ex 0.8ex; border-left: 1px solid #ad7fa8; padding-left: 1ex;\">" + " Guess!" + "</blockquote>" + "</blockquote>" + "</pre>", result); }
@Test public void testTextQuoteToHtmlBlockquoteIndented() { String message = "*facepalm*\r\n" + "\r\n" + "Bob Barker <[email protected]> wrote:\r\n" + "> A wise man once said...\r\n" + ">\r\n" + "> LOL F1RST!!!!!\r\n" + ">\r\n" + "> :)"; String result = HtmlConverter.textToHtml(message); writeToFile(result); assertEquals("<pre class=\"k9mail\">" + "*facepalm*<br />" + "<br />" + "Bob Barker <[email protected]> wrote:<br />" + "<blockquote class=\"gmail_quote\" style=\"margin: 0pt 0pt 1ex 0.8ex; border-left: 1px solid #729fcf; padding-left: 1ex;\">" + " A wise man once said...<br />" + "<br />" + " LOL F1RST!!!!!<br />" + "<br />" + " :)" + "</blockquote></pre>", result); }
@Test public void testPreserveSpacesAtFirst() { String message = "foo\r\n" + " bar\r\n" + " baz\r\n"; String result = HtmlConverter.textToHtml(message); writeToFile(result); assertEquals("<pre class=\"k9mail\">" + "foo<br />" + " bar<br />" + " baz<br />" + "</pre>", result); }
@Test public void testPreserveSpacesAtFirstForSpecialCharacters() { String message = " \r\n" + " &\r\n" + " \n" + " <\r\n" + " > \r\n"; String result = HtmlConverter.textToHtml(message); writeToFile(result); assertEquals("<pre class=\"k9mail\">" + " <br />" + " &<br />" + " <br />" + " <<br />" + "<blockquote class=\"gmail_quote\" style=\"margin: 0pt 0pt 1ex 0.8ex; border-left: 1px solid #729fcf; padding-left: 1ex;\">" + " <br />" + "</blockquote>" + "</pre>", result); }
@Test public void issue2259Spec() { String text = "text\n" + "---------------------------\n" + "some other text\n" + "===========================\n" + "more text\n" + "-=-=-=-=-=-=-=-=-=-=-=-=-=-\n" + "scissors below\n" + "-- >8 --\n" + "other direction\n" + "-- 8< --\n" + "end"; String result = HtmlConverter.textToHtml(text); assertEquals("<pre class=\"k9mail\">text<hr>" + "some other text<hr>" + "more text<hr>" + "scissors below<hr>" + "other direction<hr>" + "end</pre>", result); }
@Test public void dashesContainingSpacesIgnoredAsHR() { String text = "hello\n--- --- --- --- ---\nfoo bar"; String result = HtmlConverter.textToHtml(text); assertEquals("<pre class=\"k9mail\">hello<br />--- --- --- --- ---<br />foo bar</pre>", result); }
@Test public void mergeConsecutiveBreaksIntoOne() { String text = "hello\n------------\n---------------\nfoo bar"; String result = HtmlConverter.textToHtml(text); assertEquals("<pre class=\"k9mail\">hello<hr>foo bar</pre>", result); }
@Test public void dashedHorizontalRulePrefixedWithTextIgnoredAsHR() { String text = "hello----\n\n"; String result = HtmlConverter.textToHtml(text); assertEquals("<pre class=\"k9mail\">hello----<br /><br /></pre>", result); }
@Test public void doubleMinusIgnoredAsHR() { String text = "--\n"; String result = HtmlConverter.textToHtml(text); assertEquals("<pre class=\"k9mail\">--<br /></pre>", result); }
@Test public void doubleEqualsIgnoredAsHR() { String text = "==\n"; String result = HtmlConverter.textToHtml(text); assertEquals("<pre class=\"k9mail\">==<br /></pre>", result); }
@Test public void doubleUnderscoreIgnoredAsHR() { String text = "__\n"; String result = HtmlConverter.textToHtml(text); assertEquals("<pre class=\"k9mail\">__<br /></pre>", result); }
@Test public void anyTripletIsHRuledOut() { String text = "--=\n-=-\n===\n___\n\n"; String result = HtmlConverter.textToHtml(text); assertEquals("<pre class=\"k9mail\"><hr></pre>", result); }
@Test public void replaceSpaceSeparatedDashesWithHR() { String text = "hello\n---------------------------\nfoo bar"; String result = HtmlConverter.textToHtml(text); assertEquals("<pre class=\"k9mail\">hello<hr>foo bar</pre>", result); }
@Test public void replacementWithHRAtBeginning() { String text = "---------------------------\nfoo bar"; String result = HtmlConverter.textToHtml(text); assertEquals("<pre class=\"k9mail\"><hr>foo bar</pre>", result); }
@Test public void replacementWithHRAtEnd() { String text = "hello\n__________________________________"; String result = HtmlConverter.textToHtml(text); assertEquals("<pre class=\"k9mail\">hello<hr></pre>", result); }
@Test public void replacementOfScissorsByHR() { String text = "hello\n-- %< -------------- >8 --\nworld\n"; String result = HtmlConverter.textToHtml(text); assertEquals("<pre class=\"k9mail\">hello<hr>world<br /></pre>", result); } |
ImapPushState { @Override public String toString() { return "uidNext=" + uidNext; } ImapPushState(long uidNext); static ImapPushState parse(String pushState); @Override String toString(); final long uidNext; } | @Test public void toString_shouldReturnExpectedResult() throws Exception { ImapPushState imapPushState = new ImapPushState(23L); String result = imapPushState.toString(); assertEquals("uidNext=23", result); } |
AlertResponse { public static String getAlertText(ImapResponse response) { if (response.size() < 3 || !response.isList(1)) { return null; } ImapList responseTextCode = response.getList(1); if (responseTextCode.size() != 1 || !equalsIgnoreCase(responseTextCode.get(0), ALERT_RESPONSE_CODE)) { return null; } return response.getString(2); } private AlertResponse(); static String getAlertText(ImapResponse response); } | @Test public void getAlertText_withProperAlertResponse() throws Exception { ImapResponse imapResponse = createImapResponse("x NO [ALERT] Please don't do that"); String result = AlertResponse.getAlertText(imapResponse); assertEquals("Please don't do that", result); }
@Test public void getAlertText_withoutResponseCodeText_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x NO"); String result = AlertResponse.getAlertText(imapResponse); assertNull(result); }
@Test public void getAlertText_withoutAlertText_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x NO [ALERT]"); String result = AlertResponse.getAlertText(imapResponse); assertNull(result); }
@Test public void getAlertText_withoutResponseCodeTextList_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x NO ALERT ALARM!"); String result = AlertResponse.getAlertText(imapResponse); assertNull(result); }
@Test public void getAlertText_withResponseCodeTextContainingTooManyItems_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x NO [ALERT SOMETHING] ALARM!"); String result = AlertResponse.getAlertText(imapResponse); assertNull(result); }
@Test public void getAlertText_withWrongResponseCodeText_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x NO [ALARM] ALERT!"); String result = AlertResponse.getAlertText(imapResponse); assertNull(result); } |
CapabilityResponse { public static CapabilityResponse parse(List<ImapResponse> responses) { for (ImapResponse response : responses) { CapabilityResponse result; if (!response.isEmpty() && equalsIgnoreCase(response.get(0), Responses.OK) && response.isList(1)) { ImapList capabilityList = response.getList(1); result = parse(capabilityList); } else if (response.getTag() == null) { result = parse(response); } else { result = null; } if (result != null) { return result; } } return null; } private CapabilityResponse(Set<String> capabilities); static CapabilityResponse parse(List<ImapResponse> responses); Set<String> getCapabilities(); } | @Test public void parse_withTaggedResponse_shouldReturnNull() throws Exception { CapabilityResponse result = parse("1 OK"); assertNull(result); }
@Test public void parse_withoutOkResponse_shouldReturnNull() throws Exception { CapabilityResponse result = parse("* BAD Go Away"); assertNull(result); }
@Test public void parse_withOkResponseWithoutList_shouldReturnNull() throws Exception { CapabilityResponse result = parse("* OK Welcome"); assertNull(result); }
@Test public void parse_withListInCapabilityResponse_shouldReturnNull() throws Exception { ImapList list = createImapResponse("* CAPABILITY IMAP4rev1 []"); CapabilityResponse result = CapabilityResponse.parse(list); assertNull(result); }
@Test public void parse_withoutCapabilityResponse_shouldReturnNull() throws Exception { ImapList list = createImapResponse("* EXISTS 1"); CapabilityResponse result = CapabilityResponse.parse(list); assertNull(result); }
@Test public void parse_withEmptyResponseList_shouldReturnNull() throws Exception { List<ImapResponse> responses = Collections.emptyList(); CapabilityResponse result = CapabilityResponse.parse(responses); assertNull(result); }
@Test public void parse_withoutCapabilityResponseInResponseList_shouldReturnNull() throws Exception { List<ImapResponse> responses = Collections.singletonList(createImapResponse("* EXISTS 42")); CapabilityResponse result = CapabilityResponse.parse(responses); assertNull(result); } |
PermanentFlagsResponse { public static PermanentFlagsResponse parse(ImapResponse response) { if (response.isTagged() || !equalsIgnoreCase(response.get(0), Responses.OK) || !response.isList(1)) { return null; } ImapList responseTextList = response.getList(1); if (responseTextList.size() < 2 || !equalsIgnoreCase(responseTextList.get(0), Responses.PERMANENTFLAGS) || !responseTextList.isList(1)) { return null; } ImapList permanentFlagsList = responseTextList.getList(1); int size = permanentFlagsList.size(); Set<Flag> flags = new HashSet<>(size); boolean canCreateKeywords = false; for (int i = 0; i < size; i++) { if (!permanentFlagsList.isString(i)) { return null; } String flag = permanentFlagsList.getString(i); String compareFlag = flag.toLowerCase(Locale.US); switch (compareFlag) { case "\\deleted": { flags.add(Flag.DELETED); break; } case "\\answered": { flags.add(Flag.ANSWERED); break; } case "\\seen": { flags.add(Flag.SEEN); break; } case "\\flagged": { flags.add(Flag.FLAGGED); break; } case "$forwarded": { flags.add(Flag.FORWARDED); break; } case "\\*": { canCreateKeywords = true; break; } } } return new PermanentFlagsResponse(flags, canCreateKeywords); } private PermanentFlagsResponse(Set<Flag> flags, boolean canCreateKeywords); static PermanentFlagsResponse parse(ImapResponse response); Set<Flag> getFlags(); boolean canCreateKeywords(); } | @Test public void parse_withTaggedResponse_shouldReturnNull() throws Exception { ImapResponse response = createImapResponse("1 OK [PERMANENTFLAGS (\\Deleted \\Seen)] Flags permitted."); PermanentFlagsResponse result = PermanentFlagsResponse.parse(response); assertNull(result); }
@Test public void parse_withoutOkResponse_shouldReturnNull() throws Exception { ImapResponse response = createImapResponse("* BYE See you"); PermanentFlagsResponse result = PermanentFlagsResponse.parse(response); assertNull(result); }
@Test public void parse_withoutResponseText_shouldReturnNull() throws Exception { ImapResponse response = createImapResponse("* OK Success"); PermanentFlagsResponse result = PermanentFlagsResponse.parse(response); assertNull(result); }
@Test public void parse_withTooShortResponseText_shouldReturnNull() throws Exception { ImapResponse response = createImapResponse("* OK [PERMANENTFLAGS]"); PermanentFlagsResponse result = PermanentFlagsResponse.parse(response); assertNull(result); }
@Test public void parse_withoutPermanentFlagsResponse_shouldReturnNull() throws Exception { ImapResponse response = createImapResponse("* OK [UIDNEXT 1]"); PermanentFlagsResponse result = PermanentFlagsResponse.parse(response); assertNull(result); }
@Test public void parse_withoutPermanentFlagsList_shouldReturnNull() throws Exception { ImapResponse response = createImapResponse("* OK [PERMANENTFLAGS none]"); PermanentFlagsResponse result = PermanentFlagsResponse.parse(response); assertNull(result); }
@Test public void parse_withInvalidElementInPermanentFlagsList_shouldReturnNull() throws Exception { ImapResponse response = createImapResponse("* OK [PERMANENTFLAGS (\\Seen ())]"); PermanentFlagsResponse result = PermanentFlagsResponse.parse(response); assertNull(result); } |
ImapResponseParser { public ImapResponse readResponse() throws IOException { return readResponse(null); } ImapResponseParser(PeekableInputStream in); ImapResponse readResponse(); ImapResponse readResponse(ImapResponseCallback callback); } | @Test public void testSimpleOkResponse() throws IOException { ImapResponseParser parser = createParser("* OK\r\n"); ImapResponse response = parser.readResponse(); assertNotNull(response); assertEquals(1, response.size()); assertEquals("OK", response.get(0)); }
@Test public void testOkResponseWithText() throws IOException { ImapResponseParser parser = createParser("* OK Some text here\r\n"); ImapResponse response = parser.readResponse(); assertNotNull(response); assertEquals(2, response.size()); assertEquals("OK", response.get(0)); assertEquals("Some text here", response.get(1)); }
@Test public void testOkResponseWithRespTextCode() throws IOException { ImapResponseParser parser = createParser("* OK [UIDVALIDITY 3857529045]\r\n"); ImapResponse response = parser.readResponse(); assertNotNull(response); assertEquals(2, response.size()); assertEquals("OK", response.get(0)); assertTrue(response.get(1) instanceof ImapList); ImapList respTextCode = (ImapList) response.get(1); assertEquals(2, respTextCode.size()); assertEquals("UIDVALIDITY", respTextCode.get(0)); assertEquals("3857529045", respTextCode.get(1)); }
@Test public void testOkResponseWithRespTextCodeAndText() throws IOException { ImapResponseParser parser = createParser("* OK [token1 token2] {x} test [...]\r\n"); ImapResponse response = parser.readResponse(); assertNotNull(response); assertEquals(3, response.size()); assertEquals("OK", response.get(0)); assertTrue(response.get(1) instanceof ImapList); assertEquals("{x} test [...]", response.get(2)); ImapList respTextCode = (ImapList) response.get(1); assertEquals(2, respTextCode.size()); assertEquals("token1", respTextCode.get(0)); assertEquals("token2", respTextCode.get(1)); }
@Test public void testRespTextCodeWithList() throws Exception { ImapResponseParser parser = createParser("* OK [PERMANENTFLAGS (\\Answered \\Flagged \\Deleted \\Seen " + "\\Draft NonJunk $MDNSent \\*)] Flags permitted.\r\n"); ImapResponse response = parser.readResponse(); assertEquals(3, response.size()); assertTrue(response.get(1) instanceof ImapList); assertEquals(2, response.getList(1).size()); assertEquals("PERMANENTFLAGS", response.getList(1).getString(0)); assertTrue(response.getList(1).get(1) instanceof ImapList); assertEquals("\\Answered", response.getList(1).getList(1).getString(0)); assertEquals("\\Flagged", response.getList(1).getList(1).getString(1)); assertEquals("\\Deleted", response.getList(1).getList(1).getString(2)); assertEquals("\\Seen", response.getList(1).getList(1).getString(3)); assertEquals("\\Draft", response.getList(1).getList(1).getString(4)); assertEquals("NonJunk", response.getList(1).getList(1).getString(5)); assertEquals("$MDNSent", response.getList(1).getList(1).getString(6)); assertEquals("\\*", response.getList(1).getList(1).getString(7)); }
@Test public void testExistsResponse() throws Exception { ImapResponseParser parser = createParser("* 23 EXISTS\r\n"); ImapResponse response = parser.readResponse(); assertEquals(2, response.size()); assertEquals(23, response.getNumber(0)); assertEquals("EXISTS", response.getString(1)); }
@Test(expected = IOException.class) public void testReadStringUntilEndOfStream() throws IOException { ImapResponseParser parser = createParser("* OK Some text "); parser.readResponse(); }
@Test public void testCommandContinuation() throws Exception { ImapResponseParser parser = createParser("+ Ready for additional command text\r\n"); ImapResponse response = parser.readResponse(); assertEquals(1, response.size()); assertEquals("Ready for additional command text", response.getString(0)); }
@Test public void testParseLiteralWithEmptyString() throws Exception { ImapResponseParser parser = createParser("* {0}\r\n\r\n"); ImapResponse response = parser.readResponse(); assertEquals(1, response.size()); assertEquals("", response.getString(0)); }
@Test(expected = IOException.class) public void testParseLiteralToEndOfStream() throws Exception { ImapResponseParser parser = createParser("* {4}\r\nabc"); parser.readResponse(); }
@Test public void testParseLiteralWithConsumingCallbackReturningNull() throws Exception { ImapResponseParser parser = createParser("* {4}\r\ntest\r\n"); TestImapResponseCallback callback = TestImapResponseCallback.readBytesAndReturn(4, "cheeseburger"); ImapResponse response = parser.readResponse(callback); assertEquals(1, response.size()); assertEquals("cheeseburger", response.getString(0)); }
@Test public void testParseLiteralWithNonConsumingCallbackReturningNull() throws Exception { ImapResponseParser parser = createParser("* {4}\r\ntest\r\n"); TestImapResponseCallback callback = TestImapResponseCallback.readBytesAndReturn(0, null); ImapResponse response = parser.readResponse(callback); assertEquals(1, response.size()); assertEquals("test", response.getString(0)); assertTrue(callback.foundLiteralCalled); assertAllInputConsumed(); }
@Test public void readResponse_withPartlyConsumingCallbackReturningNull_shouldThrow() throws Exception { ImapResponseParser parser = createParser("* {4}\r\ntest\r\n"); TestImapResponseCallback callback = TestImapResponseCallback.readBytesAndReturn(2, null); try { parser.readResponse(callback); fail(); } catch (AssertionError e) { assertEquals("Callback consumed some data but returned no result", e.getMessage()); } }
@Test public void readResponse_withPartlyConsumingCallbackThatThrows_shouldReadAllDataAndThrow() throws Exception { ImapResponseParser parser = createParser("* {4}\r\ntest\r\n"); TestImapResponseCallback callback = TestImapResponseCallback.readBytesAndThrow(2); try { parser.readResponse(callback); fail(); } catch (ImapResponseParserException e) { assertEquals("readResponse(): Exception in callback method", e.getMessage()); assertEquals(ImapResponseParserTestException.class, e.getCause().getClass()); } assertAllInputConsumed(); }
@Test public void readResponse_withCallbackThatThrowsRepeatedly_shouldConsumeAllInputAndThrowFirstException() throws Exception { ImapResponseParser parser = createParser("* {3}\r\none {3}\r\ntwo\r\n"); TestImapResponseCallback callback = TestImapResponseCallback.readBytesAndThrow(3); try { parser.readResponse(callback); fail(); } catch (ImapResponseParserException e) { assertEquals("readResponse(): Exception in callback method", e.getMessage()); assertEquals(ImapResponseParserTestException.class, e.getCause().getClass()); assertEquals(0, ((ImapResponseParserTestException) e.getCause()).instanceNumber); } assertAllInputConsumed(); }
@Test public void testParseLiteralWithIncompleteConsumingCallbackReturningString() throws Exception { ImapResponseParser parser = createParser("* {4}\r\ntest\r\n"); TestImapResponseCallback callback = TestImapResponseCallback.readBytesAndReturn(2, "ninja"); ImapResponse response = parser.readResponse(callback); assertEquals(1, response.size()); assertEquals("ninja", response.getString(0)); assertAllInputConsumed(); }
@Test public void testParseLiteralWithThrowingCallback() throws Exception { ImapResponseParser parser = createParser("* {4}\r\ntest\r\n"); ImapResponseCallback callback = TestImapResponseCallback.readBytesAndThrow(0); try { parser.readResponse(callback); fail(); } catch (ImapResponseParserException e) { assertEquals("readResponse(): Exception in callback method", e.getMessage()); } assertAllInputConsumed(); }
@Test(expected = IOException.class) public void testParseLiteralWithCallbackThrowingIOException() throws Exception { ImapResponseParser parser = createParser("* {4}\r\ntest\r\n"); ImapResponseCallback callback = new ImapResponseCallback() { @Override public Object foundLiteral(ImapResponse response, FixedLengthInputStream literal) throws Exception { throw new IOException(); } }; parser.readResponse(callback); }
@Test(expected = IOException.class) public void testParseQuotedToEndOfStream() throws Exception { ImapResponseParser parser = createParser("* \"abc"); parser.readResponse(); }
@Test(expected = IOException.class) public void testParseAtomToEndOfStream() throws Exception { ImapResponseParser parser = createParser("* abc"); parser.readResponse(); }
@Test(expected = IOException.class) public void testParseUntaggedResponseWithoutSpace() throws Exception { ImapResponseParser parser = createParser("*\r\n"); parser.readResponse(); }
@Test public void testListResponseContainingFolderNameWithBrackets() throws Exception { ImapResponseParser parser = createParser("* LIST (\\HasNoChildren) \".\" [FolderName]\r\n"); ImapResponse response = parser.readResponse(); assertEquals(4, response.size()); assertEquals("LIST", response.get(0)); assertEquals(1, response.getList(1).size()); assertEquals("\\HasNoChildren", response.getList(1).getString(0)); assertEquals(".", response.get(2)); assertEquals("[FolderName]", response.get(3)); }
@Test(expected = IOException.class) public void testListResponseContainingFolderNameContainingBracketsThrowsException() throws Exception { ImapResponseParser parser = createParser( "* LIST (\\NoInferiors) \"/\" Root/Folder/Subfolder()\r\n"); parser.readResponse(); }
@Test public void readResponseShouldReadWholeListResponseLine() throws Exception { ImapResponseParser parser = createParser("* LIST (\\HasNoChildren) \".\" [FolderName]\r\n" + "TAG OK [List complete]\r\n"); parser.readResponse(); ImapResponse responseTwo = parser.readResponse(); assertEquals("TAG", responseTwo.getTag()); }
@Test public void readResponse_withListResponseContainingNil() throws Exception { ImapResponseParser parser = createParser("* LIST (\\NoInferiors) NIL INBOX\r\n"); ImapResponse response = parser.readResponse(); assertEquals(4, response.size()); assertEquals("LIST", response.get(0)); assertEquals(1, response.getList(1).size()); assertEquals("\\NoInferiors", response.getList(1).getString(0)); assertEquals(null, response.get(2)); assertEquals("INBOX", response.get(3)); }
@Test public void readResponse_withListAsFirstToken_shouldThrow() throws Exception { ImapResponseParser parser = createParser("* [1 2] 3\r\n"); try { parser.readResponse(); fail("Expected exception"); } catch (IOException e) { assertEquals("Unexpected non-string token: ImapList - [1, 2]", e.getMessage()); } }
@Test public void testFetchResponse() throws Exception { ImapResponseParser parser = createParser("* 1 FETCH (" + "UID 23 " + "INTERNALDATE \"01-Jul-2015 12:34:56 +0200\" " + "RFC822.SIZE 3456 " + "BODY[HEADER.FIELDS (date subject from)] \"<headers>\" " + "FLAGS (\\Seen))\r\n"); ImapResponse response = parser.readResponse(); assertEquals(3, response.size()); assertEquals("1", response.getString(0)); assertEquals("FETCH", response.getString(1)); assertEquals("UID", response.getList(2).getString(0)); assertEquals(23, response.getList(2).getNumber(1)); assertEquals("INTERNALDATE", response.getList(2).getString(2)); assertEquals("01-Jul-2015 12:34:56 +0200", response.getList(2).getString(3)); assertEquals("RFC822.SIZE", response.getList(2).getString(4)); assertEquals(3456, response.getList(2).getNumber(5)); assertEquals("BODY", response.getList(2).getString(6)); assertEquals(2, response.getList(2).getList(7).size()); assertEquals("HEADER.FIELDS", response.getList(2).getList(7).getString(0)); assertEquals(3, response.getList(2).getList(7).getList(1).size()); assertEquals("date", response.getList(2).getList(7).getList(1).getString(0)); assertEquals("subject", response.getList(2).getList(7).getList(1).getString(1)); assertEquals("from", response.getList(2).getList(7).getList(1).getString(2)); assertEquals("<headers>", response.getList(2).getString(8)); assertEquals("FLAGS", response.getList(2).getString(9)); assertEquals(1, response.getList(2).getList(10).size()); assertEquals("\\Seen", response.getList(2).getList(10).getString(0)); } |
ImapResponseParser { List<ImapResponse> readStatusResponse(String tag, String commandToLog, String logId, UntaggedHandler untaggedHandler) throws IOException, NegativeImapResponseException { List<ImapResponse> responses = new ArrayList<ImapResponse>(); ImapResponse response; do { response = readResponse(); if (K9MailLib.isDebug() && DEBUG_PROTOCOL_IMAP) { Timber.v("%s<<<%s", logId, response); } if (response.getTag() != null && !response.getTag().equalsIgnoreCase(tag)) { Timber.w("After sending tag %s, got tag response from previous command %s for %s", tag, response, logId); Iterator<ImapResponse> responseIterator = responses.iterator(); while (responseIterator.hasNext()) { ImapResponse delResponse = responseIterator.next(); if (delResponse.getTag() != null || delResponse.size() < 2 || ( !equalsIgnoreCase(delResponse.get(1), Responses.EXISTS) && !equalsIgnoreCase(delResponse.get(1), Responses.EXPUNGE))) { responseIterator.remove(); } } response = null; continue; } if (response.getTag() == null && untaggedHandler != null) { untaggedHandler.handleAsyncUntaggedResponse(response); } responses.add(response); } while (response == null || response.getTag() == null); if (response.size() < 1 || !equalsIgnoreCase(response.get(0), Responses.OK)) { String message = "Command: " + commandToLog + "; response: " + response.toString(); throw new NegativeImapResponseException(message, responses); } return responses; } ImapResponseParser(PeekableInputStream in); ImapResponse readResponse(); ImapResponse readResponse(ImapResponseCallback callback); } | @Test public void testReadStatusResponseWithOKResponse() throws Exception { ImapResponseParser parser = createParser("* COMMAND BAR\tBAZ\r\n" + "TAG OK COMMAND completed\r\n"); List<ImapResponse> responses = parser.readStatusResponse("TAG", null, null, null); assertEquals(2, responses.size()); assertEquals(asList("COMMAND", "BAR", "BAZ"), responses.get(0)); assertEquals(asList("OK", "COMMAND completed"), responses.get(1)); }
@Test public void testReadStatusResponseUntaggedHandlerGetsUntaggedOnly() throws Exception { ImapResponseParser parser = createParser( "* UNTAGGED\r\n" + "A2 OK COMMAND completed\r\n"); TestUntaggedHandler untaggedHandler = new TestUntaggedHandler(); parser.readStatusResponse("A2", null, null, untaggedHandler); assertEquals(1, untaggedHandler.responses.size()); assertEquals(asList("UNTAGGED"), untaggedHandler.responses.get(0)); }
@Test public void testReadStatusResponseSkippingWrongTag() throws Exception { ImapResponseParser parser = createParser("* UNTAGGED\r\n" + "* 0 EXPUNGE\r\n" + "* 42 EXISTS\r\n" + "A1 COMMAND BAR BAZ\r\n" + "A2 OK COMMAND completed\r\n"); TestUntaggedHandler untaggedHandler = new TestUntaggedHandler(); List<ImapResponse> responses = parser.readStatusResponse("A2", null, null, untaggedHandler); assertEquals(3, responses.size()); assertEquals(asList("0", "EXPUNGE"), responses.get(0)); assertEquals(asList("42", "EXISTS"), responses.get(1)); assertEquals(asList("OK", "COMMAND completed"), responses.get(2)); assertEquals(asList("UNTAGGED"), untaggedHandler.responses.get(0)); assertEquals(responses.get(0), untaggedHandler.responses.get(1)); assertEquals(responses.get(1), untaggedHandler.responses.get(2)); }
@Test public void testReadStatusResponseUntaggedHandlerStillCalledOnNegativeReply() throws Exception { ImapResponseParser parser = createParser( "+ text\r\n" + "A2 NO Bad response\r\n"); TestUntaggedHandler untaggedHandler = new TestUntaggedHandler(); try { List<ImapResponse> responses = parser.readStatusResponse("A2", null, null, untaggedHandler); } catch (NegativeImapResponseException e) { } assertEquals(1, untaggedHandler.responses.size()); assertEquals(asList("text"), untaggedHandler.responses.get(0)); }
@Test(expected = NegativeImapResponseException.class) public void testReadStatusResponseWithErrorResponse() throws Exception { ImapResponseParser parser = createParser("* COMMAND BAR BAZ\r\nTAG ERROR COMMAND errored\r\n"); parser.readStatusResponse("TAG", null, null, null); }
@Test public void readStatusResponse_withNoResponse_shouldThrow() throws Exception { ImapResponseParser parser = createParser("1 NO\r\n"); try { parser.readStatusResponse("1", "COMMAND", "[logId]", null); fail("Expected exception"); } catch (NegativeImapResponseException e) { assertEquals("Command: COMMAND; response: #1# [NO]", e.getMessage()); } }
@Test public void readStatusResponse_withNoResponseAndAlertText_shouldThrowWithAlertText() throws Exception { ImapResponseParser parser = createParser("1 NO [ALERT] Access denied\r\n"); try { parser.readStatusResponse("1", "COMMAND", "[logId]", null); fail("Expected exception"); } catch (NegativeImapResponseException e) { assertEquals("Access denied", e.getAlertText()); } } |
ImapResponseParser { private Object parseLiteral() throws IOException { expect('{'); int size = Integer.parseInt(readStringUntil('}')); expect('\r'); expect('\n'); if (size == 0) { return ""; } if (response.getCallback() != null) { FixedLengthInputStream fixed = new FixedLengthInputStream(inputStream, size); Exception callbackException = null; Object result = null; try { result = response.getCallback().foundLiteral(response, fixed); } catch (IOException e) { throw e; } catch (Exception e) { callbackException = e; } boolean someDataWasRead = fixed.available() != size; if (someDataWasRead) { if (result == null && callbackException == null) { throw new AssertionError("Callback consumed some data but returned no result"); } fixed.skipRemaining(); } if (callbackException != null) { if (exception == null) { exception = callbackException; } return "EXCEPTION"; } if (result != null) { return result; } } byte[] data = new byte[size]; int read = 0; while (read != size) { int count = inputStream.read(data, read, size - read); if (count == -1) { throw new IOException("parseLiteral(): end of stream reached"); } read += count; } return new String(data, "US-ASCII"); } ImapResponseParser(PeekableInputStream in); ImapResponse readResponse(); ImapResponse readResponse(ImapResponseCallback callback); } | @Test public void testParseLiteral() throws Exception { ImapResponseParser parser = createParser("* {4}\r\ntest\r\n"); ImapResponse response = parser.readResponse(); assertEquals(1, response.size()); assertEquals("test", response.getString(0)); } |
ImapResponseParser { private String parseQuoted() throws IOException { expect('"'); StringBuilder sb = new StringBuilder(); int ch; boolean escape = false; while ((ch = inputStream.read()) != -1) { if (!escape && ch == '\\') { escape = true; } else if (!escape && ch == '"') { return sb.toString(); } else { sb.append((char) ch); escape = false; } } throw new IOException("parseQuoted(): end of stream reached"); } ImapResponseParser(PeekableInputStream in); ImapResponse readResponse(); ImapResponse readResponse(ImapResponseCallback callback); } | @Test public void testParseQuoted() throws Exception { ImapResponseParser parser = createParser("* \"qu\\\"oted\"\r\n"); ImapResponse response = parser.readResponse(); assertEquals(1, response.size()); assertEquals("qu\"oted", response.getString(0)); } |
ImapPusher implements Pusher { @Override public void start(List<String> folderNames) { synchronized (folderPushers) { stop(); setLastRefresh(currentTimeMillis()); for (String folderName : folderNames) { ImapFolderPusher pusher = createImapFolderPusher(folderName); folderPushers.add(pusher); pusher.start(); } } } ImapPusher(ImapStore store, PushReceiver pushReceiver); @Override void start(List<String> folderNames); @Override void refresh(); @Override void stop(); @Override int getRefreshInterval(); @Override long getLastRefresh(); @Override void setLastRefresh(long lastRefresh); } | @Test public void start_withSingleFolderName_shouldCreateImapFolderPusherAndCallStartOnIt() throws Exception { List<String> folderNames = Collections.singletonList("INBOX"); imapPusher.start(folderNames); List<ImapFolderPusher> imapFolderPushers = imapPusher.getImapFolderPushers(); assertEquals(1, imapFolderPushers.size()); ImapFolderPusher imapFolderPusher = imapFolderPushers.get(0); verify(imapFolderPusher).start(); }
@Test public void start_withTwoFolderNames_shouldCreateTwoImapFolderPushersAndCallStart() throws Exception { List<String> folderNames = Arrays.asList("Important", "Drafts"); imapPusher.start(folderNames); List<ImapFolderPusher> imapFolderPushers = imapPusher.getImapFolderPushers(); assertEquals(2, imapFolderPushers.size()); ImapFolderPusher imapFolderPusherOne = imapFolderPushers.get(0); ImapFolderPusher imapFolderPusherTwo = imapFolderPushers.get(1); verify(imapFolderPusherOne).start(); verify(imapFolderPusherTwo).start(); } |
ImapPusher implements Pusher { @Override public void stop() { if (K9MailLib.isDebug()) { Timber.i("Requested stop of IMAP pusher"); } synchronized (folderPushers) { for (ImapFolderPusher folderPusher : folderPushers) { try { if (K9MailLib.isDebug()) { Timber.i("Requesting stop of IMAP folderPusher %s", folderPusher.getId()); } folderPusher.stop(); } catch (Exception e) { Timber.e(e, "Got exception while stopping %s", folderPusher.getId()); } } folderPushers.clear(); } } ImapPusher(ImapStore store, PushReceiver pushReceiver); @Override void start(List<String> folderNames); @Override void refresh(); @Override void stop(); @Override int getRefreshInterval(); @Override long getLastRefresh(); @Override void setLastRefresh(long lastRefresh); } | @Test public void stop_withoutStartBeingCalled_shouldNotCreateAnyImapFolderPushers() throws Exception { imapPusher.stop(); List<ImapFolderPusher> imapFolderPushers = imapPusher.getImapFolderPushers(); assertEquals(0, imapFolderPushers.size()); } |
ImapPusher implements Pusher { @Override public int getRefreshInterval() { return (store.getStoreConfig().getIdleRefreshMinutes() * 60 * 1000); } ImapPusher(ImapStore store, PushReceiver pushReceiver); @Override void start(List<String> folderNames); @Override void refresh(); @Override void stop(); @Override int getRefreshInterval(); @Override long getLastRefresh(); @Override void setLastRefresh(long lastRefresh); } | @Test public void getRefreshInterval() throws Exception { StoreConfig storeConfig = mock(StoreConfig.class); when(storeConfig.getIdleRefreshMinutes()).thenReturn(23); when(imapStore.getStoreConfig()).thenReturn(storeConfig); int result = imapPusher.getRefreshInterval(); assertEquals(23 * 60 * 1000, result); } |
ImapPusher implements Pusher { @Override public long getLastRefresh() { return lastRefresh; } ImapPusher(ImapStore store, PushReceiver pushReceiver); @Override void start(List<String> folderNames); @Override void refresh(); @Override void stop(); @Override int getRefreshInterval(); @Override long getLastRefresh(); @Override void setLastRefresh(long lastRefresh); } | @Test public void getLastRefresh_shouldBeMinusOneInitially() throws Exception { long result = imapPusher.getLastRefresh(); assertEquals(-1L, result); } |
ImapList extends ArrayList<Object> { public boolean containsKey(String key) { if (key == null) { return false; } for (int i = 0, count = size() - 1; i < count; i++) { if (ImapResponseParser.equalsIgnoreCase(get(i), key)) { return true; } } return false; } ImapList getList(int index); boolean isList(int index); Object getObject(int index); String getString(int index); boolean isString(int index); long getLong(int index); int getNumber(int index); Date getDate(int index); Date getKeyedDate(String key); Object getKeyedValue(String key); ImapList getKeyedList(String key); String getKeyedString(String key); int getKeyedNumber(String key); boolean containsKey(String key); int getKeyIndex(String key); } | @Test public void containsKey_returnsTrueForKeys() throws IOException { ImapList list = buildSampleList(); assertTrue(list.containsKey("ONE")); assertTrue(list.containsKey("TWO")); assertFalse(list.containsKey("THREE")); assertFalse(list.containsKey("nonexistent")); }
@Test public void containsKey_returnsFalseForStringThatCantBeKey() throws IOException { ImapList list = buildSampleList(); assertFalse(list.containsKey("THREE")); }
@Test public void containsKey_returnsFalseForStringNotInList() throws IOException { ImapList list = buildSampleList(); assertFalse(list.containsKey("nonexistent")); } |
ImapList extends ArrayList<Object> { public Object getKeyedValue(String key) { for (int i = 0, count = size() - 1; i < count; i++) { if (ImapResponseParser.equalsIgnoreCase(get(i), key)) { return get(i + 1); } } return null; } ImapList getList(int index); boolean isList(int index); Object getObject(int index); String getString(int index); boolean isString(int index); long getLong(int index); int getNumber(int index); Date getDate(int index); Date getKeyedDate(String key); Object getKeyedValue(String key); ImapList getKeyedList(String key); String getKeyedString(String key); int getKeyedNumber(String key); boolean containsKey(String key); int getKeyIndex(String key); } | @Test public void getKeyedValue_providesCorrespondingValues() { ImapList list = buildSampleList(); assertEquals("TWO", list.getKeyedValue("ONE")); assertEquals("THREE", list.getKeyedValue("TWO")); assertNull(list.getKeyedValue("THREE")); assertNull(list.getKeyedValue("nonexistent")); } |
ImapList extends ArrayList<Object> { public int getKeyIndex(String key) { for (int i = 0, count = size() - 1; i < count; i++) { if (ImapResponseParser.equalsIgnoreCase(get(i), key)) { return i; } } throw new IllegalArgumentException("getKeyIndex() only works for keys that are in the collection."); } ImapList getList(int index); boolean isList(int index); Object getObject(int index); String getString(int index); boolean isString(int index); long getLong(int index); int getNumber(int index); Date getDate(int index); Date getKeyedDate(String key); Object getKeyedValue(String key); ImapList getKeyedList(String key); String getKeyedString(String key); int getKeyedNumber(String key); boolean containsKey(String key); int getKeyIndex(String key); } | @Test public void getKeyIndex_providesIndexForKeys() { ImapList list = buildSampleList(); assertEquals(0, list.getKeyIndex("ONE")); assertEquals(1, list.getKeyIndex("TWO")); }
@Test(expected = IllegalArgumentException.class) public void getKeyIndex_throwsExceptionForValue() { ImapList list = buildSampleList(); list.getKeyIndex("THREE"); }
@Test(expected = IllegalArgumentException.class) public void getKeyIndex_throwsExceptionForNonExistantKey() { ImapList list = buildSampleList(); list.getKeyIndex("nonexistent"); } |
ImapList extends ArrayList<Object> { public Date getDate(int index) throws MessagingException { return getDate(getString(index)); } ImapList getList(int index); boolean isList(int index); Object getObject(int index); String getString(int index); boolean isString(int index); long getLong(int index); int getNumber(int index); Date getDate(int index); Date getKeyedDate(String key); Object getKeyedValue(String key); ImapList getKeyedList(String key); String getKeyedString(String key); int getKeyedNumber(String key); boolean containsKey(String key); int getKeyIndex(String key); } | @Test public void getDate_returnsCorrectDateForValidString() throws MessagingException { ImapList list = new ImapList(); list.add("INTERNALDATE"); list.add("10-Mar-2000 12:02:01 GMT"); Calendar c = Calendar.getInstance(); c.setTime(list.getDate(1)); assertEquals(2000, c.get(Calendar.YEAR)); assertEquals(Calendar.MARCH, c.get(Calendar.MONTH)); assertEquals(10, c.get(Calendar.DAY_OF_MONTH)); }
@Test(expected = MessagingException.class) public void getDate_throwsExceptionForInvalidDate() throws MessagingException { ImapList list = new ImapList(); list.add("INTERNALDATE"); list.add("InvalidDate"); list.getDate(1); }
@Test public void getDate_returnsNullForNIL() throws MessagingException { ImapList list = new ImapList(); list.add("INTERNALDATE"); list.add("NIL"); assertNull(list.getDate(1)); } |
ImapList extends ArrayList<Object> { public Date getKeyedDate(String key) throws MessagingException { return getDate(getKeyedString(key)); } ImapList getList(int index); boolean isList(int index); Object getObject(int index); String getString(int index); boolean isString(int index); long getLong(int index); int getNumber(int index); Date getDate(int index); Date getKeyedDate(String key); Object getKeyedValue(String key); ImapList getKeyedList(String key); String getKeyedString(String key); int getKeyedNumber(String key); boolean containsKey(String key); int getKeyIndex(String key); } | @Test public void getKeyedDate_returnsCorrectDateForValidString() throws MessagingException { ImapList list = new ImapList(); list.add("INTERNALDATE"); list.add("10-Mar-2000 12:02:01 GMT"); Calendar c = Calendar.getInstance(); c.setTime(list.getKeyedDate("INTERNALDATE")); assertEquals(2000, c.get(Calendar.YEAR)); assertEquals(Calendar.MARCH, c.get(Calendar.MONTH)); assertEquals(10, c.get(Calendar.DAY_OF_MONTH)); }
@Test(expected = MessagingException.class) public void getKeyedDate_throwsExceptionForInvalidDate() throws MessagingException { ImapList list = new ImapList(); list.add("INTERNALDATE"); list.add("InvalidDate"); list.getKeyedDate("INTERNALDATE"); }
@Test public void getKeyedDate_returnsNullForNIL() throws MessagingException { ImapList list = new ImapList(); list.add("INTERNALDATE"); list.add("NIL"); assertNull(list.getKeyedDate("INTERNALDATE")); } |
SelectOrExamineResponse { public static SelectOrExamineResponse parse(ImapResponse response) { if (!response.isTagged() || !equalsIgnoreCase(response.get(0), Responses.OK)) { return null; } if (!response.isList(1)) { return noOpenModeInResponse(); } ImapList responseTextList = response.getList(1); if (!responseTextList.isString(0)) { return noOpenModeInResponse(); } String responseCode = responseTextList.getString(0); if ("READ-ONLY".equalsIgnoreCase(responseCode)) { return new SelectOrExamineResponse(false); } else if ("READ-WRITE".equalsIgnoreCase(responseCode)) { return new SelectOrExamineResponse(true); } return noOpenModeInResponse(); } private SelectOrExamineResponse(Boolean readWriteMode); static SelectOrExamineResponse parse(ImapResponse response); boolean hasOpenMode(); int getOpenMode(); } | @Test public void parse_withUntaggedResponse_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("* OK [READ-WRITE] Select completed."); SelectOrExamineResponse result = SelectOrExamineResponse.parse(imapResponse); assertNull(result); }
@Test public void parse_withoutOkResponse_shouldReturnNull() throws Exception { ImapResponse imapResponse = createImapResponse("x BYE"); SelectOrExamineResponse result = SelectOrExamineResponse.parse(imapResponse); assertNull(result); } |
ImapFolder extends Folder<ImapMessage> { @Override public void open(int mode) throws MessagingException { internalOpen(mode); if (messageCount == -1) { throw new MessagingException("Did not find message count during open"); } } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); } | @Test public void open_calledTwice_shouldReuseSameImapConnection() throws Exception { ImapFolder imapFolder = createFolder("Folder"); prepareImapFolderForOpen(OPEN_MODE_RW); imapFolder.open(OPEN_MODE_RW); imapFolder.open(OPEN_MODE_RW); verify(imapStore, times(1)).getConnection(); } |
ImapFolder extends Folder<ImapMessage> { private boolean exists(String escapedFolderName) throws MessagingException { try { connection.executeSimpleCommand(String.format("STATUS %s (RECENT)", escapedFolderName)); return true; } catch (IOException ioe) { throw ioExceptionHandler(connection, ioe); } catch (NegativeImapResponseException e) { return false; } } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); } | @Test public void exists_withoutNegativeImapResponse_shouldReturnTrue() throws Exception { ImapFolder imapFolder = createFolder("Folder"); when(imapStore.getConnection()).thenReturn(imapConnection); boolean folderExists = imapFolder.exists(); assertTrue(folderExists); } |
ImapFolder extends Folder<ImapMessage> { @Override public boolean create(FolderType type) throws MessagingException { ImapConnection connection; synchronized (this) { if (this.connection == null) { connection = store.getConnection(); } else { connection = this.connection; } } try { String encodedFolderName = folderNameCodec.encode(getPrefixedId()); String escapedFolderName = ImapUtility.encodeString(encodedFolderName); connection.executeSimpleCommand(String.format("CREATE %s", escapedFolderName)); return true; } catch (NegativeImapResponseException e) { return false; } catch (IOException ioe) { throw ioExceptionHandler(this.connection, ioe); } finally { if (this.connection == null) { store.releaseConnection(connection); } } } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); } | @Test public void create_withoutNegativeImapResponse_shouldReturnTrue() throws Exception { ImapFolder imapFolder = createFolder("Folder"); when(imapStore.getConnection()).thenReturn(imapConnection); boolean success = imapFolder.create(FolderType.HOLDS_MESSAGES); assertTrue(success); } |
ImapFolder extends Folder<ImapMessage> { @Override public Map<String, String> copyMessages(List<? extends Message> messages, Folder folder) throws MessagingException { if (!(folder instanceof ImapFolder)) { throw new MessagingException("ImapFolder.copyMessages passed non-ImapFolder"); } if (messages.isEmpty()) { return null; } ImapFolder imapFolder = (ImapFolder) folder; checkOpen(); String[] uids = new String[messages.size()]; for (int i = 0, count = messages.size(); i < count; i++) { uids[i] = messages.get(i).getUid(); } try { String encodedDestinationFolderName = folderNameCodec.encode(imapFolder.getPrefixedId()); String escapedDestinationFolderName = ImapUtility.encodeString(encodedDestinationFolderName); if (!exists(escapedDestinationFolderName)) { if (K9MailLib.isDebug()) { Timber.i("ImapFolder.copyMessages: attempting to create remote folder '%s' for %s", escapedDestinationFolderName, getLogId()); } imapFolder.create(FolderType.HOLDS_MESSAGES); } List<ImapResponse> responses = executeSimpleCommand(String.format("UID COPY %s %s", combine(uids, ','), escapedDestinationFolderName)); ImapResponse response = getLastResponse(responses); CopyUidResponse copyUidResponse = CopyUidResponse.parse(response); if (copyUidResponse == null) { return null; } return copyUidResponse.getUidMapping(); } catch (IOException ioe) { throw ioExceptionHandler(connection, ioe); } } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); } | @Test public void copyMessages_withEmptyMessageList_shouldReturnNull() throws Exception { ImapFolder sourceFolder = createFolder("Source"); ImapFolder destinationFolder = createFolder("Destination"); List<ImapMessage> messages = Collections.emptyList(); Map<String, String> uidMapping = sourceFolder.copyMessages(messages, destinationFolder); assertNull(uidMapping); }
@Test public void copyMessages() throws Exception { ImapFolder sourceFolder = createFolder("Folder"); prepareImapFolderForOpen(OPEN_MODE_RW); ImapFolder destinationFolder = createFolder("Destination"); List<ImapMessage> messages = singletonList(createImapMessage("1")); List<ImapResponse> copyResponses = singletonList( createImapResponse("x OK [COPYUID 23 1 101] Success") ); when(imapConnection.executeSimpleCommand("UID COPY 1 \"Destination\"")).thenReturn(copyResponses); sourceFolder.open(OPEN_MODE_RW); Map<String, String> uidMapping = sourceFolder.copyMessages(messages, destinationFolder); assertNotNull(uidMapping); assertEquals("101", uidMapping.get("1")); } |
ImapFolder extends Folder<ImapMessage> { @Override public Map<String, String> moveMessages(List<? extends Message> messages, Folder folder) throws MessagingException { if (messages.isEmpty()) { return null; } Map<String, String> uidMapping = copyMessages(messages, folder); setFlags(messages, Collections.singleton(Flag.DELETED), true); return uidMapping; } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); } | @Test public void moveMessages_withEmptyMessageList_shouldReturnNull() throws Exception { ImapFolder sourceFolder = createFolder("Source"); ImapFolder destinationFolder = createFolder("Destination"); List<ImapMessage> messages = Collections.emptyList(); Map<String, String> uidMapping = sourceFolder.moveMessages(messages, destinationFolder); assertNull(uidMapping); } |
ImapFolder extends Folder<ImapMessage> { @Override public void delete(List<? extends Message> messages, String trashFolderName) throws MessagingException { if (messages.isEmpty()) { return; } if (trashFolderName == null || getId().equalsIgnoreCase(trashFolderName)) { setFlags(messages, Collections.singleton(Flag.DELETED), true); } else { ImapFolder remoteTrashFolder = getStore().getFolder(trashFolderName); String encodedTrashFolderName = folderNameCodec.encode(remoteTrashFolder.getPrefixedId()); String escapedTrashFolderName = ImapUtility.encodeString(encodedTrashFolderName); if (!exists(escapedTrashFolderName)) { if (K9MailLib.isDebug()) { Timber.i("IMAPMessage.delete: attempting to create remote '%s' folder for %s", trashFolderName, getLogId()); } remoteTrashFolder.create(FolderType.HOLDS_MESSAGES); } if (exists(escapedTrashFolderName)) { if (K9MailLib.isDebug()) { Timber.d("IMAPMessage.delete: copying remote %d messages to '%s' for %s", messages.size(), trashFolderName, getLogId()); } moveMessages(messages, remoteTrashFolder); } else { throw new MessagingException("IMAPMessage.delete: remote Trash folder " + trashFolderName + " does not exist and could not be created for " + getLogId(), true); } } } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); } | @Test public void delete_withEmptyMessageList_shouldNotInteractWithImapConnection() throws Exception { ImapFolder folder = createFolder("Source"); List<ImapMessage> messages = Collections.emptyList(); folder.delete(messages, "Trash"); verifyNoMoreInteractions(imapConnection); }
@Test(expected = Error.class) public void delete_notImplemented() throws Exception { ImapFolder folder = createFolder("Folder"); folder.delete(false); } |
ImapFolder extends Folder<ImapMessage> { @Override public int getUnreadMessageCount() throws MessagingException { return getRemoteMessageCount("UNSEEN NOT DELETED"); } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); } | @Test public void getUnreadMessageCount_withClosedFolder_shouldThrow() throws Exception { ImapFolder folder = createFolder("Folder"); when(imapStore.getConnection()).thenReturn(imapConnection); try { folder.getUnreadMessageCount(); fail("Expected exception"); } catch (MessagingException e) { assertCheckOpenErrorMessage("Folder", e); } }
@Test public void getUnreadMessageCount() throws Exception { ImapFolder folder = createFolder("Folder"); prepareImapFolderForOpen(OPEN_MODE_RW); List<ImapResponse> imapResponses = singletonList(createImapResponse("* SEARCH 1 2 3")); when(imapConnection.executeSimpleCommand("SEARCH 1:* UNSEEN NOT DELETED")).thenReturn(imapResponses); folder.open(OPEN_MODE_RW); int unreadMessageCount = folder.getUnreadMessageCount(); assertEquals(3, unreadMessageCount); } |
ImapFolder extends Folder<ImapMessage> { @Override public int getFlaggedMessageCount() throws MessagingException { return getRemoteMessageCount("FLAGGED NOT DELETED"); } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); } | @Test public void getFlaggedMessageCount_withClosedFolder_shouldThrow() throws Exception { ImapFolder folder = createFolder("Folder"); when(imapStore.getConnection()).thenReturn(imapConnection); try { folder.getFlaggedMessageCount(); fail("Expected exception"); } catch (MessagingException e) { assertCheckOpenErrorMessage("Folder", e); } }
@Test public void getFlaggedMessageCount() throws Exception { ImapFolder folder = createFolder("Folder"); prepareImapFolderForOpen(OPEN_MODE_RW); List<ImapResponse> imapResponses = asList( createImapResponse("* SEARCH 1 2"), createImapResponse("* SEARCH 23 42") ); when(imapConnection.executeSimpleCommand("SEARCH 1:* FLAGGED NOT DELETED")).thenReturn(imapResponses); folder.open(OPEN_MODE_RW); int flaggedMessageCount = folder.getFlaggedMessageCount(); assertEquals(4, flaggedMessageCount); } |
ImapFolder extends Folder<ImapMessage> { protected long getHighestUid() throws MessagingException { try { String command = "UID SEARCH *:*"; List<ImapResponse> responses = executeSimpleCommand(command); SearchResponse searchResponse = SearchResponse.parse(responses); return extractHighestUid(searchResponse); } catch (NegativeImapResponseException e) { return -1L; } catch (IOException ioe) { throw ioExceptionHandler(connection, ioe); } } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); } | @Test public void getHighestUid() throws Exception { ImapFolder folder = createFolder("Folder"); prepareImapFolderForOpen(OPEN_MODE_RW); List<ImapResponse> imapResponses = singletonList(createImapResponse("* SEARCH 42")); when(imapConnection.executeSimpleCommand("UID SEARCH *:*")).thenReturn(imapResponses); folder.open(OPEN_MODE_RW); long highestUid = folder.getHighestUid(); assertEquals(42L, highestUid); } |
ImapFolder extends Folder<ImapMessage> { @Override public List<ImapMessage> getMessages(int start, int end, Date earliestDate, MessageRetrievalListener<ImapMessage> listener) throws MessagingException { return getMessages(start, end, earliestDate, false, listener); } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); } | @Test public void getMessages_withClosedFolder_shouldThrow() throws Exception { ImapFolder folder = createFolder("Folder"); when(imapStore.getConnection()).thenReturn(imapConnection); try { folder.getMessages(1, 5, null, null); fail("Expected exception"); } catch (MessagingException e) { assertCheckOpenErrorMessage("Folder", e); } }
@Test public void getMessages_sequenceNumbers_withClosedFolder_shouldThrow() throws Exception { ImapFolder folder = createFolder("Folder"); when(imapStore.getConnection()).thenReturn(imapConnection); try { folder.getMessages(asList(1L, 2L, 5L), false, null); fail("Expected exception"); } catch (MessagingException e) { assertCheckOpenErrorMessage("Folder", e); } } |
ImapFolder extends Folder<ImapMessage> { protected List<ImapMessage> getMessagesFromUids(final List<String> mesgUids) throws MessagingException { ImapSearcher searcher = new ImapSearcher() { @Override public List<ImapResponse> search() throws IOException, MessagingException { String command = String.format("UID SEARCH UID %s", combine(mesgUids.toArray(), ',')); return executeSimpleCommand(command); } }; return search(searcher, null); } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); } | @Test public void getMessagesFromUids_withClosedFolder_shouldThrow() throws Exception { ImapFolder folder = createFolder("Folder"); when(imapStore.getConnection()).thenReturn(imapConnection); try { folder.getMessagesFromUids(asList("11", "22", "25")); fail("Expected exception"); } catch (MessagingException e) { assertCheckOpenErrorMessage("Folder", e); } }
@Test public void getMessagesFromUids() throws Exception { ImapFolder folder = createFolder("Folder"); prepareImapFolderForOpen(OPEN_MODE_RW); List<ImapResponse> imapResponses = asList( createImapResponse("* SEARCH 11"), createImapResponse("* SEARCH 22"), createImapResponse("* SEARCH 25") ); when(imapConnection.executeSimpleCommand("UID SEARCH UID 11,22,25")).thenReturn(imapResponses); folder.open(OPEN_MODE_RW); List<ImapMessage> messages = folder.getMessagesFromUids(asList("11", "22", "25")); assertNotNull(messages); assertEquals(newSet("11", "22", "25"), extractMessageUids(messages)); } |
ImapFolder extends Folder<ImapMessage> { @Override public boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate) throws IOException, MessagingException { checkOpen(); if (indexOfOldestMessage == 1) { return false; } String dateSearchString = getDateSearchString(earliestDate); int endIndex = indexOfOldestMessage - 1; while (endIndex > 0) { int startIndex = Math.max(0, endIndex - MORE_MESSAGES_WINDOW_SIZE) + 1; if (existsNonDeletedMessageInRange(startIndex, endIndex, dateSearchString)) { return true; } endIndex = endIndex - MORE_MESSAGES_WINDOW_SIZE; } return false; } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); } | @Test public void areMoreMessagesAvailable_withClosedFolder_shouldThrow() throws Exception { ImapFolder folder = createFolder("Folder"); when(imapStore.getConnection()).thenReturn(imapConnection); try { folder.areMoreMessagesAvailable(10, new Date()); fail("Expected exception"); } catch (MessagingException e) { assertCheckOpenErrorMessage("Folder", e); } } |
ImapFolder extends Folder<ImapMessage> { @Override public void fetch(List<ImapMessage> messages, FetchProfile fetchProfile, MessageRetrievalListener<ImapMessage> listener) throws MessagingException { if (messages == null || messages.isEmpty()) { return; } checkOpen(); List<String> uids = new ArrayList<>(messages.size()); HashMap<String, Message> messageMap = new HashMap<>(); for (Message message : messages) { String uid = message.getUid(); uids.add(uid); messageMap.put(uid, message); } Set<String> fetchFields = new LinkedHashSet<>(); fetchFields.add("UID"); if (fetchProfile.contains(FetchProfile.Item.FLAGS)) { fetchFields.add("FLAGS"); } if (fetchProfile.contains(FetchProfile.Item.ENVELOPE)) { fetchFields.add("INTERNALDATE"); fetchFields.add("RFC822.SIZE"); fetchFields.add("BODY.PEEK[HEADER.FIELDS (date subject from content-type to cc " + "reply-to message-id references in-reply-to " + K9MailLib.IDENTITY_HEADER + ")]"); } if (fetchProfile.contains(FetchProfile.Item.STRUCTURE)) { fetchFields.add("BODYSTRUCTURE"); } if (fetchProfile.contains(FetchProfile.Item.BODY_SANE)) { int maximumAutoDownloadMessageSize = store.getStoreConfig().getMaximumAutoDownloadMessageSize(); if (maximumAutoDownloadMessageSize > 0) { fetchFields.add(String.format(Locale.US, "BODY.PEEK[]<0.%d>", maximumAutoDownloadMessageSize)); } else { fetchFields.add("BODY.PEEK[]"); } } if (fetchProfile.contains(FetchProfile.Item.BODY)) { fetchFields.add("BODY.PEEK[]"); } String spaceSeparatedFetchFields = combine(fetchFields.toArray(new String[fetchFields.size()]), ' '); for (int windowStart = 0; windowStart < messages.size(); windowStart += (FETCH_WINDOW_SIZE)) { int windowEnd = Math.min(windowStart + FETCH_WINDOW_SIZE, messages.size()); List<String> uidWindow = uids.subList(windowStart, windowEnd); try { String commaSeparatedUids = combine(uidWindow.toArray(new String[uidWindow.size()]), ','); String command = String.format("UID FETCH %s (%s)", commaSeparatedUids, spaceSeparatedFetchFields); connection.sendCommand(command, false); ImapResponse response; int messageNumber = 0; ImapResponseCallback callback = null; if (fetchProfile.contains(FetchProfile.Item.BODY) || fetchProfile.contains(FetchProfile.Item.BODY_SANE)) { callback = new FetchBodyCallback(messageMap); } do { response = connection.readResponse(callback); if (response.getTag() == null && ImapResponseParser.equalsIgnoreCase(response.get(1), "FETCH")) { ImapList fetchList = (ImapList) response.getKeyedValue("FETCH"); String uid = fetchList.getKeyedString("UID"); long msgSeq = response.getLong(0); if (uid != null) { try { msgSeqUidMap.put(msgSeq, uid); if (K9MailLib.isDebug()) { Timber.v("Stored uid '%s' for msgSeq %d into map", uid, msgSeq); } } catch (Exception e) { Timber.e("Unable to store uid '%s' for msgSeq %d", uid, msgSeq); } } Message message = messageMap.get(uid); if (message == null) { if (K9MailLib.isDebug()) { Timber.d("Do not have message in messageMap for UID %s for %s", uid, getLogId()); } handleUntaggedResponse(response); continue; } if (listener != null) { listener.messageStarted(uid, messageNumber++, messageMap.size()); } ImapMessage imapMessage = (ImapMessage) message; Object literal = handleFetchResponse(imapMessage, fetchList); if (literal != null) { if (literal instanceof String) { String bodyString = (String) literal; InputStream bodyStream = new ByteArrayInputStream(bodyString.getBytes()); imapMessage.parse(bodyStream); } else if (literal instanceof Integer) { } else { throw new MessagingException("Got FETCH response with bogus parameters"); } } if (listener != null) { listener.messageFinished(imapMessage, messageNumber, messageMap.size()); } } else { handleUntaggedResponse(response); } } while (response.getTag() == null); } catch (IOException ioe) { throw ioExceptionHandler(connection, ioe); } } } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); } | @Test public void fetch_withNullMessageListArgument_shouldDoNothing() throws Exception { ImapFolder folder = createFolder("Folder"); FetchProfile fetchProfile = createFetchProfile(); folder.fetch(null, fetchProfile, null); verifyNoMoreInteractions(imapConnection); }
@Test public void fetch_withEmptyMessageListArgument_shouldDoNothing() throws Exception { ImapFolder folder = createFolder("Folder"); FetchProfile fetchProfile = createFetchProfile(); folder.fetch(Collections.<ImapMessage>emptyList(), fetchProfile, null); verifyNoMoreInteractions(imapConnection); } |
ImapFolder extends Folder<ImapMessage> { @Override public String getUidFromMessageId(Message message) throws MessagingException { try { String[] messageIdHeader = message.getHeader("Message-ID"); if (messageIdHeader.length == 0) { if (K9MailLib.isDebug()) { Timber.d("Did not get a message-id in order to search for UID for %s", getLogId()); } return null; } String messageId = messageIdHeader[0]; if (K9MailLib.isDebug()) { Timber.d("Looking for UID for message with message-id %s for %s", messageId, getLogId()); } String command = String.format("UID SEARCH HEADER MESSAGE-ID %s", ImapUtility.encodeString(messageId)); List<ImapResponse> responses = executeSimpleCommand(command); for (ImapResponse response : responses) { if (response.getTag() == null && ImapResponseParser.equalsIgnoreCase(response.get(0), "SEARCH") && response.size() > 1) { return response.getString(1); } } return null; } catch (IOException ioe) { throw new MessagingException("Could not find UID for message based on Message-ID", ioe); } } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); } | @Test public void getUidFromMessageId_withoutMessageIdHeader_shouldReturnNull() throws Exception { ImapFolder folder = createFolder("Folder"); ImapMessage message = createImapMessage("2"); when(message.getHeader("Message-ID")).thenReturn(new String[0]); String uid = folder.getUidFromMessageId(message); assertNull(uid); }
@Test public void getUidFromMessageId() throws Exception { ImapFolder folder = createFolder("Folder"); prepareImapFolderForOpen(OPEN_MODE_RW); folder.open(OPEN_MODE_RW); ImapMessage message = createImapMessage("2"); when(message.getHeader("Message-ID")).thenReturn(new String[] { "<[email protected]>" }); when(imapConnection.executeSimpleCommand("UID SEARCH HEADER MESSAGE-ID \"<[email protected]>\"")) .thenReturn(singletonList(createImapResponse("* SEARCH 23"))); String uid = folder.getUidFromMessageId(message); assertEquals("23", uid); } |
ImapFolder extends Folder<ImapMessage> { @Override public String getNewPushState(String oldSerializedPushState, Message message) { try { String uid = message.getUid(); long messageUid = Long.parseLong(uid); ImapPushState oldPushState = ImapPushState.parse(oldSerializedPushState); if (messageUid >= oldPushState.uidNext) { long uidNext = messageUid + 1; ImapPushState newPushState = new ImapPushState(uidNext); return newPushState.toString(); } else { return null; } } catch (Exception e) { Timber.e(e, "Exception while updated push state for %s", getLogId()); return null; } } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); } | @Test public void getNewPushState_withNewerUid_shouldReturnNewPushState() throws Exception { ImapFolder folder = createFolder("Folder"); prepareImapFolderForOpen(OPEN_MODE_RW); ImapMessage message = createImapMessage("2"); String newPushState = folder.getNewPushState("uidNext=2", message); assertEquals("uidNext=3", newPushState); }
@Test public void getNewPushState_withoutNewerUid_shouldReturnNull() throws Exception { ImapFolder folder = createFolder("Folder"); prepareImapFolderForOpen(OPEN_MODE_RW); ImapMessage message = createImapMessage("1"); String newPushState = folder.getNewPushState("uidNext=2", message); assertNull(newPushState); } |
ImapFolder extends Folder<ImapMessage> { @Override public ImapMessage getMessage(String uid) throws MessagingException { return new ImapMessage(uid, this); } ImapFolder(ImapStore store, String id); ImapFolder(ImapStore store, String id, FolderNameCodec folderNameCodec); @Override void open(int mode); @Override boolean isOpen(); @Override int getMode(); @Override void close(); @Override String getId(); @Override String getParentId(); @Override String getName(); @Override boolean exists(); @Override boolean canHaveSubFolders(); @Override boolean create(FolderType type); @Override Map<String, String> copyMessages(List<? extends Message> messages, Folder folder); @Override Map<String, String> moveMessages(List<? extends Message> messages, Folder folder); @Override void delete(List<? extends Message> messages, String trashFolderName); @Override int getMessageCount(); @Override int getUnreadMessageCount(); @Override int getFlaggedMessageCount(); @Override void delete(boolean recurse); @Override ImapMessage getMessage(String uid); @Override List<ImapMessage> getMessages(int start, int end, Date earliestDate,
MessageRetrievalListener<ImapMessage> listener); @Override boolean areMoreMessagesAvailable(int indexOfOldestMessage, Date earliestDate); @Override void fetch(List<ImapMessage> messages, FetchProfile fetchProfile,
MessageRetrievalListener<ImapMessage> listener); @Override void fetchPart(Message message, Part part, MessageRetrievalListener<Message> listener,
BodyFactory bodyFactory); @Override Map<String, String> appendMessages(List<? extends Message> messages); @Override String getUidFromMessageId(Message message); @Override void expunge(); @Override void setFlags(Set<Flag> flags, boolean value); @Override String getNewPushState(String oldSerializedPushState, Message message); @Override void setFlags(List<? extends Message> messages, final Set<Flag> flags, boolean value); @Override boolean equals(Object other); @Override int hashCode(); @Override List<ImapMessage> search(final String queryString, final Set<Flag> requiredFlags,
final Set<Flag> forbiddenFlags); } | @Test public void getMessageByUid_returnsNewImapMessageWithUidInFolder() throws Exception { ImapFolder folder = createFolder("Folder"); ImapMessage message = folder.getMessage("uid"); assertEquals("uid", message.getUid()); assertEquals(folder, message.getFolder()); } |
BoundaryGenerator { public String generateBoundary() { StringBuilder builder = new StringBuilder(4 + BOUNDARY_CHARACTER_COUNT); builder.append("----"); for (int i = 0; i < BOUNDARY_CHARACTER_COUNT; i++) { builder.append(BASE36_MAP[random.nextInt(36)]); } return builder.toString(); } @VisibleForTesting BoundaryGenerator(Random random); static BoundaryGenerator getInstance(); String generateBoundary(); } | @Test public void generateBoundary_allZeros() throws Exception { Random random = createRandom(0); BoundaryGenerator boundaryGenerator = new BoundaryGenerator(random); String result = boundaryGenerator.generateBoundary(); assertEquals("----000000000000000000000000000000", result); }
@Test public void generateBoundary() throws Exception { Random random = createRandom(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 35); BoundaryGenerator boundaryGenerator = new BoundaryGenerator(random); String result = boundaryGenerator.generateBoundary(); assertEquals("----0123456789ABCDEFGHIJKLMNOPQRSZ", result); } |
Message implements Part, Body { @Override public boolean equals(Object o) { if (o == null || !(o instanceof Message)) { return false; } Message other = (Message)o; return (getUid().equals(other.getUid()) && getFolder().getId().equals(other.getFolder().getId())); } boolean olderThan(Date earliestDate); @Override boolean equals(Object o); @Override int hashCode(); String getUid(); void setUid(String uid); Folder getFolder(); abstract String getSubject(); abstract void setSubject(String subject); Date getInternalDate(); void setInternalDate(Date internalDate); abstract Date getSentDate(); abstract void setSentDate(Date sentDate, boolean hideTimeZone); abstract Address[] getRecipients(RecipientType type); abstract void setRecipients(RecipientType type, Address[] addresses); void setRecipient(RecipientType type, Address address); abstract Address[] getFrom(); abstract void setFrom(Address from); abstract Address[] getSender(); abstract void setSender(Address sender); abstract Address[] getReplyTo(); abstract void setReplyTo(Address[] from); abstract String getMessageId(); abstract void setInReplyTo(String inReplyTo); abstract String[] getReferences(); abstract void setReferences(String references); @Override abstract Body getBody(); @Override abstract void addHeader(String name, String value); @Override abstract void addRawHeader(String name, String raw); @Override abstract void setHeader(String name, String value); @NonNull @Override abstract String[] getHeader(String name); abstract Set<String> getHeaderNames(); @Override abstract void removeHeader(String name); @Override abstract void setBody(Body body); abstract boolean hasAttachments(); abstract long getSize(); void delete(String trashFolderName); Set<Flag> getFlags(); void setFlag(Flag flag, boolean set); void setFlags(final Set<Flag> flags, boolean set); boolean isSet(Flag flag); void destroy(); @Override abstract void setEncoding(String encoding); abstract void setCharset(String charset); long calculateSize(); @Override abstract Message clone(); } | @Test public void equals_whenFolderIdDifferent_isFalse() { SimpleFolder folder1 = new SimpleFolder(); folder1.id = "1"; SimpleFolder folder2 = new SimpleFolder(); folder2.id = "2"; String uid = "uid"; Message m1 = new StoredMimeMessage(folder1, uid); Message m2 = new StoredMimeMessage(folder2, uid); boolean result = m1.equals(m2); assertFalse(result); }
@Test public void equals_whenUidDifferent_isFalse() { SimpleFolder folder = new SimpleFolder(); folder.id = "1"; String uid1 = "uid1"; String uid2 = "uid2"; Message m1 = new StoredMimeMessage(folder, uid1); Message m2 = new StoredMimeMessage(folder, uid2); boolean result = m1.equals(m2); assertFalse(result); }
@Test public void equals_whenUidAndFolderSame_isTrue() { SimpleFolder folder1 = new SimpleFolder(); folder1.id = "1"; SimpleFolder folder2 = new SimpleFolder(); folder2.id = "1"; String uid = "uid"; Message m1 = new StoredMimeMessage(folder1, uid); Message m2 = new StoredMimeMessage(folder2, uid); boolean result = m1.equals(m2); assertTrue(result); } |
HttpUriParser implements UriParser { @Override public int linkifyUri(String text, int startPos, StringBuffer outputBuffer) { int currentPos = startPos; String shortScheme = text.substring(currentPos, Math.min(currentPos + 7, text.length())); String longScheme = text.substring(currentPos, Math.min(currentPos + 8, text.length())); if (longScheme.equalsIgnoreCase("https: currentPos += "https: } else if (shortScheme.equalsIgnoreCase("http: currentPos += "http: } else if (shortScheme.equalsIgnoreCase("rtsp: currentPos += "rtsp: } else { return startPos; } int matchedAuthorityEnd = tryMatchAuthority(text, currentPos); if (matchedAuthorityEnd == currentPos) { return startPos; } currentPos = matchedAuthorityEnd; if (currentPos < text.length() && text.charAt(currentPos) == '/') { currentPos = matchUnreservedPCTEncodedSubDelimClassesGreedy(text, currentPos + 1, "/:@"); } if (currentPos < text.length() && text.charAt(currentPos) == '?') { currentPos = matchUnreservedPCTEncodedSubDelimClassesGreedy(text, currentPos + 1, ":@/?"); } if (currentPos < text.length() && text.charAt(currentPos) == '#') { currentPos = matchUnreservedPCTEncodedSubDelimClassesGreedy(text, currentPos + 1, ":@/?"); } String httpUri = text.substring(startPos, currentPos); outputBuffer.append("<a href=\"") .append(httpUri) .append("\">") .append(httpUri) .append("</a>"); return currentPos; } @Override int linkifyUri(String text, int startPos, StringBuffer outputBuffer); } | @Test public void domainWithTrailingSpace() { String text = "http: int endPos = parser.linkifyUri(text, 0, outputBuffer); assertLinkOnly("http: assertEquals(text.length() - 1, endPos); }
@Test public void domainWithTrailingNewline() { String text = "http: int endPos = parser.linkifyUri(text, 0, outputBuffer); assertLinkOnly("http: assertEquals(text.length() - 1, endPos); }
@Test public void domainWithTrailingAngleBracket() { String text = "<http: int endPos = parser.linkifyUri(text, 1, outputBuffer); assertLinkOnly("http: assertEquals(text.length() - 1, endPos); }
@Test public void uriInMiddleAfterInput() { String prefix = "prefix "; String uri = "http: String text = prefix + uri; parser.linkifyUri(text, prefix.length(), outputBuffer); assertLinkOnly(uri, outputBuffer); }
@Test public void uriInMiddleOfInput() { String prefix = "prefix "; String uri = "http: String postfix = " postfix"; String text = prefix + uri + postfix; parser.linkifyUri(text, prefix.length(), outputBuffer); assertLinkOnly(uri, outputBuffer); } |
StringCalculator { public int add(String input) { if ("".equals(input)) { return 0; } String numbers = extractNumbers(input); String delimiter = extractDelimiter(input); return stringSum(numbers, delimiter); } int add(String input); } | @Test public void TestEmptyStringReturnZero() { Assert.assertEquals(0, stringCalculator.add("")); }
@Test public void TestNumberStringReturnValue() { Assert.assertEquals(1, stringCalculator.add("1")); Assert.assertEquals(2, stringCalculator.add("2")); }
@Test public void TestTwoNumbersStringReturnSum() { Assert.assertEquals(3, stringCalculator.add("1,2")); Assert.assertEquals(5, stringCalculator.add("2,3")); }
@Test public void TestAnyNumbersStringReturnSum() { Assert.assertEquals(10, stringCalculator.add("1,2,3,4")); }
@Test public void TestAnyNumbersComaOrReturnLineDelimiterStringReturnSum() { Assert.assertEquals(6, stringCalculator.add("1,2\n3")); }
@Test public void TestAnyNumbersCustomDelimiterStringReturnSum() { Assert.assertEquals(3, stringCalculator.add(" } |
StringCalculator { public int add(String input) { if ("".equals(input)) return 0; String delimiter = extractDelimiter(input); String[] numberArray = extractNumbers(input, delimiter); return sumNumberArray(numberArray); } int add(String input); } | @Test public void comma_or_return_line_separated_numbers_return_sum() { Assert.assertEquals(6, this.calculator.add("1\n2,3")); }
@Test public void any_delimited_numbers_return_sum() { Assert.assertEquals(3, this.calculator.add(" }
@Test public void negative_number_throw_exception() { this.exception.expect(RuntimeException.class); this.exception.expectMessage("negativos no soportados: -1"); this.calculator.add("-1"); }
@Test public void multiple_negative_number_throw_exception() { this.exception.expect(RuntimeException.class); this.exception.expectMessage("negativos no soportados: -1,-2"); this.calculator.add("-1,-2"); }
@Test public void numbers_greater_than_thousand_not_sum() { Assert.assertEquals(3, this.calculator.add("1,2,1001")); }
@Test public void any_length_delimiter() { Assert.assertEquals(6, this.calculator.add(" }
@Test public void any_multiple_length_delimiter() { Assert.assertEquals(6, this.calculator.add(" }
@Test public void empty_string_return_zero() { Assert.assertEquals(0, this.calculator.add("")); }
@Test public void one_number_return_number() { Assert.assertEquals(1, this.calculator.add("1")); Assert.assertEquals(2, this.calculator.add("2")); }
@Test public void two_comma_separated_number_return_sum() { Assert.assertEquals(3, this.calculator.add("1,2")); }
@Test public void comma_separated_numbers_return_sum() { Assert.assertEquals(6, this.calculator.add("1,2,3")); } |
StringCalculator { public int add(String input) { if (input.isEmpty()) return 0; String delimiter = getDelimiter(input); String numbers = getNumbers(input); return calculateSum(numbers.split(delimiter)); } int add(String input); } | @Test public void emptyStringReturnsZero() { assertEquals(0, this.stringCalculator.add("")); }
@Test public void numberStringReturnsNumber() { assertEquals(1, this.stringCalculator.add("1")); }
@Test public void stringNumbersCommaDelimitedReturnsSum() { assertEquals(3, this.stringCalculator.add("1,2")); }
@Test public void multipleStringNumbersCommaDelimitedReturnsSum() { assertEquals(6, this.stringCalculator.add("1,2,3")); }
@Test public void multipleStringNumbersCommaOrReturnLineDelimitedReturnsSum() { assertEquals(6, this.stringCalculator.add("1\n2,3")); assertEquals(6, this.stringCalculator.add("1,2\n3")); }
@Test public void multipleStringNumbersCustomDelimitedReturnsSum() { assertEquals("Should return 3", 3, this.stringCalculator.add(" } |
RockPaper { public final int play(final String playerOne, final String playerTwo) { int response = DRAW; if (isDraw(playerOne, playerTwo)) { response = DRAW; } else if (PAPER.equals(playerOne)) { return checkPaperRulesPlayerOne(playerTwo); } else if (ROCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SCISSORS.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERONE; } else if (ROCK.equals(playerOne) && LIZZARD.equals(playerTwo)) { response = WINPLAYERONE; } else if (LIZZARD.equals(playerOne) && ROCK.equals(playerTwo)) { response = WINPLAYERTWO; } else if (SPOCK.equals(playerOne) && PAPER.equals(playerTwo)) { response = WINPLAYERTWO; } return response; } final int play(final String playerOne, final String playerTwo); static final int DRAW; static final int WINPLAYERONE; static final int WINPLAYERTWO; static final String SPOCK; static final String LIZZARD; static final String ROCK; static final String PAPER; static final String SCISSORS; } | @Test public final void sameMovesReturnDraw() { Assert.assertEquals(RockPaper.DRAW, this.GAME.play(RockPaper.SCISSORS, RockPaper.SCISSORS)); Assert.assertEquals(RockPaper.DRAW, this.GAME.play(RockPaper.PAPER, RockPaper.PAPER)); Assert.assertEquals(RockPaper.DRAW, this.GAME.play(RockPaper.ROCK, RockPaper.ROCK)); Assert.assertEquals(RockPaper.DRAW, this.GAME.play(RockPaper.LIZZARD, RockPaper.LIZZARD)); Assert.assertEquals(RockPaper.DRAW, this.GAME.play(RockPaper.SPOCK, RockPaper.SPOCK)); }
@Test public final void scissorsCutPaper() { Assert.assertEquals(RockPaper.WINPLAYERONE, this.GAME.play(RockPaper.SCISSORS, RockPaper.PAPER)); Assert.assertEquals(RockPaper.WINPLAYERTWO, this.GAME.play(RockPaper.PAPER, RockPaper.SCISSORS)); }
@Test public final void paperCoversRock() { Assert.assertEquals(RockPaper.WINPLAYERONE, this.GAME.play(RockPaper.PAPER, RockPaper.ROCK)); Assert.assertEquals(RockPaper.WINPLAYERTWO, this.GAME.play(RockPaper.ROCK, RockPaper.PAPER)); }
@Test public final void rockCrushersLizard() { Assert.assertEquals(RockPaper.WINPLAYERONE, this.GAME.play(RockPaper.ROCK, RockPaper.LIZZARD)); Assert.assertEquals(RockPaper.WINPLAYERTWO, this.GAME.play(RockPaper.LIZZARD, RockPaper.ROCK)); }
@Test public final void paperDisprovesSpock() { Assert.assertEquals(RockPaper.WINPLAYERONE, this.GAME.play(RockPaper.PAPER, RockPaper.SPOCK)); Assert.assertEquals(RockPaper.WINPLAYERTWO, this.GAME.play(RockPaper.SPOCK, RockPaper.PAPER)); } |
PageAnalyzer { public static HtmlAnalysisResult analyze(Map<String, String> config, String url) { try { String userAgent = config.getOrDefault(CONFIG_USER_AGENT, DEFAULT_USER_AGENT); HttpResponse<String> response = Unirest.get(url) .header("User-Agent", userAgent) .asString(); return analyze(config, url, response.getBody(), response.getStatus(), response.getHeaders()); } catch (UnirestException e) { throw new RuntimeException(e); } } static HtmlAnalysisResult analyze(Map<String, String> config, String url); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html); static HtmlAnalysisResult analyze(Map<String, String> config, String url, String html, Integer status, Map<String, List<String>> headers); static void parseRobotsTxt(String userAgent, String robotsUrl, String robotsTxt, HtmlAnalysisResult result); static final String CONFIG_USER_AGENT; static final String CONFIG_ANALYZE_ROBOTS_TXT; } | @Test public void headersAndStatus() { Map<String, List<String>> headers = Maps.newHashMap(); headers.put("Etag", Lists.newArrayList("c1dc8d7be85325149", "ed5fc4d62b84752")); headers.put("Date", Lists.newArrayList("Wed, 11 Jan 2017 13:00:18 GMT")); HashMap<String, String> config = Maps.newHashMap(); HtmlAnalysisResult result = PageAnalyzer.analyze(config, "http: assertEquals(new Integer(200), result.getHttpStatus()); assertEquals(2, result.getHeaders().size()); assertEquals("c1dc8d7be85325149\ned5fc4d62b84752", result.getHeaders().get("Etag")); assertEquals("Wed, 11 Jan 2017 13:00:18 GMT", result.getHeaders().get("Date")); }
@Test public void htmlParsing() { HashMap<String, String> config = Maps.newHashMap(); HtmlAnalysisResult result = PageAnalyzer.analyze(config, "https: assertEquals("Bloomberg.com", result.getTitle()); assertEquals(33, result.getMetaValues().size()); assertTrue(result.getMetaValues().contains("<meta property=\"og:url\" content=\"https: assertEquals(361, result.getLinks().size()); assertTrue(result.getLinks().contains("https: }
@Test @Ignore public void fetchAndParse() { HashMap<String, String> config = Maps.newHashMap(); config.put(PageAnalyzer.CONFIG_ANALYZE_ROBOTS_TXT, "true"); HtmlAnalysisResult result = PageAnalyzer.analyze(config, "http: assertEquals("TokenMill - Natural Language Processing", result.getTitle()); assertEquals(10, result.getMetaValues().size()); assertEquals(42, result.getLinks().size()); assertTrue(result.getLinks().contains("http: assertTrue(result.getRobotsAllowedAll()); assertFalse(result.getRobotsAllowedNone()); assertTrue(result.getRobotsAllowedHome()); assertEquals(Lists.newArrayList(), result.getRobotsSitemaps()); assertEquals(Long.MIN_VALUE, (long) result.getRobotsCrawlDelay()); }
@Test @Ignore public void fetchAndParseRobotsTxt() { HashMap<String, String> config = Maps.newHashMap(); config.put(PageAnalyzer.CONFIG_ANALYZE_ROBOTS_TXT, "true"); HtmlAnalysisResult result = PageAnalyzer.analyze(config, "https: assertFalse(result.getRobotsAllowedAll()); assertFalse(result.getRobotsAllowedNone()); assertTrue(result.getRobotsAllowedHome()); assertTrue(result.getRobotsSitemaps().contains("http: assertEquals(Long.MIN_VALUE, (long) result.getRobotsCrawlDelay()); } |
DateParser { public static MatchedDate parse(MatchedDate matchedText, HttpSource source) { String value = Strings.nullToEmpty(matchedText.getValue()).trim(); for (String regexp : source.getDateRegexps()) { Pattern pattern = Pattern.compile(regexp); Matcher matcher = pattern.matcher(value); if (matcher.matches() && matcher.groupCount() > 0) { value = matcher.group(1); } } matchedText.setValue(value.replace("ET", "EST")); List<SimpleDateFormat> customFormatters = formatsToFormatters(source.getDateFormats()); MatchedDate md = Stream.concat(customFormatters.stream(), FORMATTERS.stream()) .map(dateFormat -> parse(matchedText, dateFormat)) .filter(matchedDate -> matchedDate.getDate() != null) .findFirst().orElse(matchedText); if (md.getDate() == null && md.getValue() != null) { md = parseWithTimewords(md, source); } return md; } static MatchedDate parse(MatchedDate matchedText, HttpSource source); static List<MatchedDate> extractFromMeta(Document document); static List<MatchedDate> extractFromProperties(Document document); } | @Test public void formats() { MatchedDate matchedDate = new MatchedDate("2017-01-16 01:45:05 -0500", null); MatchedDate parse = DateParser.parse(matchedDate, new HttpSource()); assertEquals("2017-01-16T06:45:05", DataUtils.formatInUTC(parse.getDate())); matchedDate = new MatchedDate("Jan 17, 2017 06:08AM ET", null); parse = DateParser.parse(matchedDate, new HttpSource()); assertEquals("2017-01-17T11:08:00", DataUtils.formatInUTC(parse.getDate())); matchedDate = new MatchedDate("January 18, 2017", null); parse = DateParser.parse(matchedDate, new HttpSource()); assertEquals("2017-01-18T00:00:00", DataUtils.formatInUTC(parse.getDate())); assertEquals("2017-01-18T13:45:00", parse("Wed Jan 18 13:45:00 GMT 2017")); assertEquals("2017-02-14T00:00:00", parse("02142017")); assertEquals("2017-02-27T00:00:00", parse("Monday, February 27, 2017 @ 05:02 PM gHale")); assertEquals("2017-03-09T00:00:00", parse("March 9, 2017 8:43 AM")); assertEquals("2017-03-13T15:49:00", parse("13 Mar, 2017 15:49")); assertEquals("2017-03-13T03:14:28", parse("2017-03-13 03:14:28")); assertEquals("2017-03-10T00:00:00", parse("10 March 2017")); assertEquals("2017-03-09T16:47:21", parse("2017-03-09 16:47:21")); assertEquals("2017-03-09T01:00:00", parse("2017-03-09T01:00:00")); assertEquals("2017-03-10T08:24:19", parse("Fri, 10 Mar 2017 13:54:19 +0530")); assertEquals("2016-08-24T06:42:00", parse("Wed Aug 24, 2016 2:42am EDT")); assertEquals("2017-03-10T12:51:00", parse("March 10, 2017, 14:51 IST")); assertEquals("2016-08-22T18:14:26", parse("Mon, 22 Aug 2016 18:14:26 +0000")); assertEquals("2017-04-13T00:00:00", parse("2017/04/13")); }
@Test public void testHttpSourceDateRegexpPattern000() throws ParseException { String dateRegexp = "By.*on (.*) Tweet"; String dateString = "By Scott Simkin on February 14, 2017 Tweet"; String expectedDateString = "2017-02-14T00:00:00"; MatchedDate matchedDate = new MatchedDate(dateString, null); HttpSource httpSource = new HttpSource(); httpSource.setDateRegexps(Arrays.asList(dateRegexp)); MatchedDate parse = DateParser.parse(matchedDate, httpSource); assertNotNull(parse.getDate()); assertEquals(expectedDateString, DataUtils.formatInUTC(matchedDate.getDate())); } |
DateParser { private static MatchedDate parseWithTimewords(MatchedDate matchedText, HttpSource source) { Timewords timewords = new Timewords(); try { Date parse = timewords.parse(matchedText.getValue(), new Date(), source.getLanguage()); if (parse != null) { matchedText.setDate(new DateTime(parse)); matchedText.setPattern("TIMEWORDS"); } return matchedText; } catch (Exception e) { return matchedText; } } static MatchedDate parse(MatchedDate matchedText, HttpSource source); static List<MatchedDate> extractFromMeta(Document document); static List<MatchedDate> extractFromProperties(Document document); } | @Test public void parseWithTimewords() { MatchedDate matchedDate = new MatchedDate("Wed Feb 24 2016 00:01 UTC+1201", null); MatchedDate parse = DateParser.parse(matchedDate, new HttpSource()); assertEquals("2016-02-24T00:01:00", DataUtils.formatInUTC(parse.getDate())); assertEquals("TIMEWORDS", parse.getPattern()); assertEquals("Wed Feb 24 2016 00:01 UTC+1201", parse.getValue()); } |
DataUtils implements Serializable { public static List<String> parseStringList(Object object) { if (object == null) { return null; } return Splitter.onPattern("(?:\r?\n)+") .splitToList(object.toString()) .stream() .map(String::trim) .filter(s -> !s.isEmpty()) .collect(Collectors.toList()); } static Integer tryParseInteger(Object object); static Long tryParseLong(Object object); static List<String> parseStringList(Object object); static String formatInUTC(DateTime date); static DateTime parseFromUTC(String date); } | @Test public void normalizerSplitter() { assertEquals(Lists.newArrayList("\\?.*$-->>", "a-->>b"), DataUtils.parseStringList("\\?.*$-->>\na-->>b\r\r\n\n")); } |
DataUtils implements Serializable { public static String formatInUTC(DateTime date) { return date != null ? FORMATTER.print(date.toDateTime(DateTimeZone.UTC)) : null; } static Integer tryParseInteger(Object object); static Long tryParseLong(Object object); static List<String> parseStringList(Object object); static String formatInUTC(DateTime date); static DateTime parseFromUTC(String date); } | @Test public void dateFormatInUTC() { Long DATE_2017_01_04_12_26_00 = 1483532760805L; assertEquals("2017-01-04T12:26:00", DataUtils.formatInUTC(new DateTime(DATE_2017_01_04_12_26_00))); } |
EsHttpSourceOperations extends BaseElasticOps { public PageableList<HttpSource> filter(String text) { return filter(text, 0); } protected EsHttpSourceOperations(ElasticConnection connection, String index, String type); static EsHttpSourceOperations getInstance(ElasticConnection connection, String index, String type); List<HttpSource> findEnabledSources(); HttpSource get(String url); PageableList<HttpSource> filter(String text); PageableList<HttpSource> filter(String text, int offset); List<HttpSource> all(); void save(HttpSource source); void delete(String url); void deleteAll(); } | @Test @Ignore public void test() { ElasticConnection connection = ElasticConnection.getConnection("localhost", 9200, "http"); EsHttpSourceOperations esHttpSourceOperations = new EsHttpSourceOperations(connection, "demo-http_sources", "http_source"); PageableList<HttpSource> data = esHttpSourceOperations.filter(null); for (HttpSource source : data.getItems()) { System.out.println(">>" + source); } } |
ElasticConnection { public static Builder builder() { return new Builder(); } private ElasticConnection(BulkProcessor processor, RestHighLevelClient restHighLevelClient, RestClientBuilder restClient); static Builder builder(); RestHighLevelClient getRestHighLevelClient(); BulkProcessor getProcessor(); static ElasticConnection getConnection(String hostname); static ElasticConnection getConnection(String hostname, int restPort, String restScheme); void close(); } | @Test public void testBuilder() { BulkProcessor.Listener listener = new BulkProcessor.Listener() { @Override public void afterBulk(long executionId, BulkRequest request, BulkResponse response) { for (BulkItemResponse item : response.getItems()) { if (item.isFailed()) { LOG.error("Bulk item failure: '{}' for request '{}'", item.getFailure(), request.requests().get(item.getItemId())); } } } @Override public void afterBulk(long executionId, BulkRequest request, Throwable response) { LOG.error("Bulk failed:" + response); } @Override public void beforeBulk(long executionId, BulkRequest request) { for (DocWriteRequest r :request.requests()) { try { if (r instanceof IndexRequest) { IndexRequest indexRequest = (IndexRequest) r; indexRequest.id(URLDecoder.decode(indexRequest.id(), "utf-8")); } else if (r instanceof UpdateRequest) { UpdateRequest updateRequest = (UpdateRequest) r; updateRequest.id(URLDecoder.decode(updateRequest.id(), "utf-8")); } } catch (UnsupportedEncodingException e) { e.printStackTrace(); } } } }; ElasticConnection connection = ElasticConnection.builder() .hostname("0.0.0.0") .restPort(443) .restScheme("https") .bulkActions(1) .flushIntervalString("1s") .listener(listener) .build(); assertNotNull(connection); } |
TextProfileSignature { public TextProfileSignature() { this.quantRate = 0.01f; this.minTokenLen = 2; try { this.digester = MessageDigest.getInstance("MD5"); } catch (Exception e) { LOG.error("Failed to initialize Media digest algorithm"); throw new RuntimeException("Failed to initialize Media digest algorithm", e); } } TextProfileSignature(); String getSignature(String text); void add(String content); } | @Test public void testTextProfileSignature() { TextProfileSignature textProfileSignature = new TextProfileSignature(); String text1 = "This is a test"; String text2 = "This is e test"; String text3 = "This is a very test"; assertEquals(text1, text1); assertTrue(textProfileSignature.getSignature(text1) .equalsIgnoreCase(textProfileSignature.getSignature(text1))); assertNotEquals(text1, text2); assertTrue(textProfileSignature.getSignature(text1) .equalsIgnoreCase(textProfileSignature.getSignature(text2))); assertNotEquals(text1, text3); assertFalse(textProfileSignature.getSignature(text1) .equalsIgnoreCase(textProfileSignature.getSignature(text3))); assertTrue(textProfileSignature.getSignature("very very text") .equalsIgnoreCase(textProfileSignature.getSignature("very very very text"))); String a = "Updated: 2.4 million hit by Carphone Warehouse breach On Saturday Carphone Warehouse (CW) announced that the names, addresses, dates of birth and bank details of up to 2.4 million customers may have been accessed in a cyber-attack discovered on Wednesday, believed to have occurred during the two weeks prior. Encrypted credit card details of up to 90,000 people may have been accessed. Check Point's technical director, Thierry Karsenti, emailed SC to warn that the stolen data is likely to be used as bait for targeted phishing attacks against customers, especially in emails claiming to be from Carphone Warehouse or one of its subsidiaries. Karsenti said: “Armed with the data they already have, attackers are likely to try and trick those affected by the breach into revealing further details, such as account numbers and passwords. “For the attackers, it's just a numbers game, but it could have serious consequences for customers. Phishing emails continue to be the most common source for social engineering attacks, so customers should be suspicious of any emails, or even phone calls, that relate to the breach, and should not give away more information.” Carphone Warehouse is clearly aware of the danger and on Saturday sent an email to customers telling them to notify their bank and credit card company, so they can monitor account activity, as well as advising them to change the password for their online accounts. They also advised checking credit rating on Experian, Equifax or Noddle to ensure they have not been made a victim of fraud. Some commentators suggest the details where obtained, will already have been sold on. Staff at Haymarket were among those affected. After receiving warning emails from Carphone Warehouse, at 3pm and 9pm on Saturday, one member told SC how they rang their bank, and were immediately asked whether their password for the bank was the same as for the phone contract – as the password would have needed to be changed had that been the case. Plus they were advised to keep an eye out for any unusual transactions on their account, clearly concerned that identity theft may be attempted. They were also advised to contact Action Fraud, the UK's national fraud and internet crime reporting centre, if they were concerned they might be a victim of fraud. However, both the Information Commissioner's Office (ICO) and The Metropolitan Police Cyber Crime Unit have reported being aware of the attack and the ICO is investigating the issue while the Met says no reports of related fraud have yet been made. Sebastian James, chief executive of Dixons Carphone, was reported by the Guardian newspaper as saying: “We take the security of customer data extremely seriously, and we are very sorry people have been affected by this attack. We are, of course, informing anyone that may have been affected, and have put in place additional security measures.” In an email to SCMagazineUK.com data security expert Jason du Preez, CEO of Privitar said: “This data breach is yet another high-profile reminder that it is impossible for companies to protect their customer's data with traditional perimeter security. “Companies need to embrace the irrefutable fact that the way they manage and process data will have a direct impact on brand and customer loyalty. Embracing a data-centric approach to security and a process that ensures no sensitive data is visible in any given process – privacy-by-default – will enable organisations to confidently use consumer's precious data safely.” “Most organisations have entirely valid reasons for wanting customer data. It allows them to provide the personalised, relevant product and services consumers demand. But there's no reason, from a technical point of view, even financial data can't be anonymised to protect both the individual and the organisation itself.” Carphone Warehouse says the hack was stopped \"straight away\" after it was discovered on Wednesday afternoon, and that the company has launched a forensic investigation with a ‘leading cyber security firm'. Carphone Warehouse is responsible for the websites of OneStopPhoneShop.com, e2save.com and Mobiles.co.uk, as well as services for its own recently launched iD Mobile network, as well as TalkTalk Mobile, and Talk Mobile. About 1.9 million of those affected are reportedly directly signed up to Carphone Warehouse, while about 480,000 are customers of TalkTalk Mobile, whose registration process is handled by Carphone Warehouse. Phil Barnett, EMEA VP and GM of Good Technology, noted in an email that: “Many companies are still flying blind when it comes to security, because 60 per cent think it doesn't affect them. The truth is that it's not just a conversation for banks or governments anymore - anyone and everyone is a potential victim of hacks and data leaks. Data is a company's biggest asset, but many organisations haven't yet got to grips with how to protect it in the new world order of mobile devices and cloud-based access. The security challenge won't go away and companies need to change their mindset in order to solve it.”"; String b = "Updated: 2.4 million hit by Carphone Warehouse breach On Saturday Carphone Warehouse (CW) announced that the names, addresses, dates of birth and bank details of up to 2.4 million customers may have been accessed in a cyber-attack discovered on Wednesday, believed to have occurred during the two weeks prior. Encrypted credit card details of up to 90,000 people may have been accessed. Check Point's technical director, Thierry Karsenti, emailed SC to warn that the stolen data is likely to be used as bait for targeted phishing attacks against customers, especially in emails claiming to be from Carphone Warehouse or one of its subsidiaries. Karsenti said: “Armed with the data they already have, attackers are likely to try and trick those affected by the breach into revealing further details, such as account numbers and passwords. “For the attackers, it's just a numbers game, but it could have serious consequences for customers. Phishing emails continue to be the most common source for social engineering attacks, so customers should be suspicious of any emails, or even phone calls, that relate to the breach, and should not give away more information.” Carphone Warehouse is clearly aware of the danger and on Saturday sent an email to customers telling them to notify their bank and credit card company, so they can monitor account activity, as well as advising them to change the password for their online accounts. They also advised checking credit rating on Experian, Equifax or Noddle to ensure they have not been made a victim of fraud. Some commentators suggest the details where obtained, will already have been sold on. Staff at Haymarket were among those affected. After receiving warning emails from Carphone Warehouse, at 3pm and 9pm on Saturday, one member told SC how they rang their bank, and were immediately asked whether their password for the bank was the same as for the phone contract – as the password would have needed to be changed had that been the case. Plus they were advised to keep an eye out for any unusual transactions on their account, clearly concerned that identity theft may be attempted. They were also advised to contact Action Fraud, the UK's national fraud and internet crime reporting centre, if they were concerned they might be a victim of fraud. However, both the Information Commissioner's Office (ICO) and The Metropolitan Police Cyber Crime Unit have reported being aware of the attack and the ICO is investigating the issue while the Met says no reports of related fraud have yet been made. Sebastian James, chief executive of Dixons Carphone, was reported by the Guardian newspaper as saying: “We take the security of customer data extremely seriously, and we are very sorry people have been affected by this attack. We are, of course, informing anyone that may have been affected, and have put in place additional security measures.” In an email to SCMagazineUK.com data security expert Jason du Preez, CEO of Privitar said: “This data breach is yet another high-profile reminder that it is impossible for companies to protect their customer's data with traditional perimeter security. “Companies need to embrace the irrefutable fact that the way they manage and process data will have a direct impact on brand and customer loyalty. Embracing a data-centric approach to security and a process that ensures no sensitive data is visible in any given process – privacy-by-default – will enable organisations to confidently use consumer's precious data safely.” “Most organisations have entirely valid reasons for wanting customer data. It allows them to provide the personalised, relevant product and services consumers demand. But there's no reason, from a technical point of view, even financial data can't be anonymised to protect both the individual and the organisation itself.” Carphone Warehouse says the hack was stopped \"straight away\" after it was discovered on Wednesday afternoon, and that the company has launched a forensic investigation with a ‘leading cyber security firm'. Carphone Warehouse is responsible for the websites of OneStopPhoneShop.com, e2save.com and Mobiles.co.uk, as well as services for its own recently launched iD Mobile network, as well as TalkTalk Mobile, and Talk Mobile. About 1.9 million of those affected are reportedly directly signed up to Carphone Warehouse, while about 480,000 are customers of TalkTalk Mobile, whose registration process is handled by Carphone Warehouse. Phil Barnett, EMEA VP and GM of Good Technology, noted in an email that: “Many companies are still flying blind when it comes to security, because 60 per cent think it doesn't affect them. The truth is that it's not just a conversation for banks or governments anymore - anyone and everyone is a potential victim of hacks and data leaks. Data is a company's biggest asset, but many organisations haven't yet got to grips with how to protect it in the new world order of mobile devices and cloud-based access. The security challenge won't go away and companies need to change their mindset in order to solve its.”"; assertNotEquals(a, b); assertTrue(textProfileSignature.getSignature(a) .equalsIgnoreCase(textProfileSignature.getSignature(b))); } |
QueryParser { public static List<String> parseQuery(String query) { List<String> result = Lists.newArrayList(); if (!Strings.isNullOrEmpty(query)) { query = query.replaceAll("(\\s*[+-]\\s*)", "#SPLIT#$1"); return Arrays.stream(query.split("(#SPLIT#| )")) .map(String::trim) .filter(s -> !s.isEmpty()) .collect(Collectors.toList()); } return result; } static List<String> parseQuery(String query); } | @Test public void parseQuery() { List<String> parts = QueryParser.parseQuery("+Turkey-Inflation"); assertEquals(Lists.newArrayList("+Turkey", "-Inflation"), parts); parts = QueryParser.parseQuery("+Turkey -Inflation"); assertEquals(Lists.newArrayList("+Turkey", "-Inflation"), parts); parts = QueryParser.parseQuery("Turkey -Inflation"); assertEquals(Lists.newArrayList("Turkey", "-Inflation"), parts); parts = QueryParser.parseQuery("+Turkey attack"); assertEquals(Lists.newArrayList("+Turkey", "attack"), parts); } |
UrlExtractor { private static Set<String> extract(Document document) { Set<String> canonicalUrls = new HashSet<>(); if (document == null) { return canonicalUrls; } Elements elements = document.select("meta[property=og:url]"); elements.forEach(element -> { String attr = element.attr("content"); if (attr != null) { canonicalUrls.add(attr); } }); elements = document.select("link[rel=canonical]"); elements.forEach(element -> { String attr = element.attr("href"); if (attr != null) { canonicalUrls.add(attr); } }); return canonicalUrls.stream() .filter(UrlExtractor::isAbsolute) .collect(Collectors.toSet()); } static String extract(String url, Document document); } | @Test public void testExtraction00() throws Exception { String html = loadArticle("aljazeera1"); String url = "https: Document document = Jsoup.parse(html); assertEquals(url, UrlExtractor.extract(url, document)); assertEquals("https: }
@Test public void testExtraction01() throws Exception { String html = loadArticle("kedainietis"); String url = "url"; Document document = Jsoup.parse(html); assertEquals(url, UrlExtractor.extract(url, document)); } |
JsonUtil { public static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root) { Map<String, String> paths = new HashMap<>(); searchJsonForTemplate(root, paths, "$"); return paths; } private JsonUtil(/* empty */); static boolean updateField(JsonElement json, String field, JsonElement value); static boolean updateField(JsonElement json, String field, String value); static Map<String, String> getJsonPathsForTemplating(Set<Map.Entry<String, JsonElement>> root); static Map<String, String> getJsonPathsForTemplating(JsonObject json); } | @Test public void simple_shallow() { String template = "{ \"a\" : \"{{value}}\", \"b\": \"b\"}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(1, paths.size()); Object value = paths.get("$.a"); assertNotNull(value); assertEquals("{{value}}", value.toString()); }
@Test public void double_shallow() { String template = "{ \"a\" : \"{{value}}\", \"b\": \"{{value}}\"}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(2, paths.size()); Object a = paths.get("$.a"); assertNotNull(a); assertEquals("{{value}}", a.toString()); Object b = paths.get("$.b"); assertNotNull(b); assertEquals("{{value}}", a.toString()); }
@Test public void simple_deep() { String template = "{ \"a\" : { \"b\": \"{{value}}\"}}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(1, paths.size()); Object value = paths.get("$.a.b"); assertNotNull(value); assertEquals("{{value}}", value.toString()); }
@Test public void double_deep() { String template = "{ \"a\" : { \"b\": \"{{value}}\"}, \"c\": { \"b\": \"{{value}}\"}}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(2, paths.size()); Object a = paths.get("$.a.b"); assertNotNull(a); assertEquals("{{value}}", a.toString()); Object b = paths.get("$.c.b"); assertNotNull(b); assertEquals("{{value}}", a.toString()); }
@Test public void double_nested_deep() { String template = "{ \"a\" : { \"b\": \"{{value}}\", \"c\": { \"b\": \"{{value}}\"}}, \"c\": { \"b\": \"{{value}}\"}}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(3, paths.size()); Object a = paths.get("$.a.b"); assertNotNull(a); assertEquals("{{value}}", a.toString()); Object b = paths.get("$.a.c.b"); assertNotNull(b); assertEquals("{{value}}", b.toString()); Object c = paths.get("$.c.b"); assertNotNull(c); assertEquals("{{value}}", c.toString()); }
@Test public void mixed_data_types() { String template = "{ \"a\" : { \"b\": \"{{value}}\", \"c\": { \"b\": \"{{value}}\"}}, \"c\": { \"b\": \"{{value}}\"}, \"num\": 343, \"bool\": true}"; JsonObject document = (JsonObject) new JsonParser().parse(template); Map<String, String> paths = JsonUtil.getJsonPathsForTemplating(document); assertEquals(3, paths.size()); Object a = paths.get("$.a.b"); assertNotNull(a); assertEquals("{{value}}", a.toString()); Object b = paths.get("$.a.c.b"); assertNotNull(b); assertEquals("{{value}}", b.toString()); Object c = paths.get("$.c.b"); assertNotNull(c); assertEquals("{{value}}", c.toString()); } |
HazelcastMapMetricsReporter extends AbstractReportingTask { boolean isValid(ObjectName name, Set<String> mapNames, String clusterName) { if (!"com.hazelcast".equals(name.getDomain())) { return false; } String propertyName = name.getKeyProperty("name"); if (!mapNames.isEmpty() && !mapNames.contains(propertyName)) { return false; } String typeProperty = name.getKeyProperty("type"); if (StringUtils.isBlank(typeProperty) || !"IMap".equals(name.getKeyProperty("type"))) { return false; } String instanceProperty = name.getKeyProperty("instance"); if (StringUtils.isBlank(instanceProperty) || !instanceProperty.contains(clusterName)) { return false; } return true; } @OnScheduled void startup(ConfigurationContext context); @Override void onTrigger(ReportingContext context); @Override final List<PropertyDescriptor> getSupportedPropertyDescriptors(); } | @Test public void testIsValid() throws MalformedObjectNameException { ObjectName o = new ObjectName("domain", "key", "value"); Set<String> mapNames = ImmutableSet.of("foo"); HazelcastMapMetricsReporter hazelcastMapMetricsReporter = new HazelcastMapMetricsReporter(); boolean isValid = hazelcastMapMetricsReporter.isValid(o, mapNames, "cluster"); assertFalse(isValid); String c = "foo"; o = new ObjectName("com.hazelcast", "key", "value"); isValid = hazelcastMapMetricsReporter.isValid(o, mapNames, c); assertFalse(isValid); o = new ObjectName("com.hazelcast", "name", "foo"); isValid = hazelcastMapMetricsReporter.isValid(o, mapNames, c); assertFalse(isValid); Hashtable<String, String> keys = new Hashtable<>(); keys.put("name", "foo"); keys.put("type", "IMap"); o = new ObjectName("com.hazelcast", keys); isValid = hazelcastMapMetricsReporter.isValid(o, mapNames, c); assertFalse(isValid); keys = new Hashtable<>(); keys.put("name", "foo"); keys.put("type", "IMap"); keys.put("instance", "foo"); o = new ObjectName("com.hazelcast", keys); isValid = hazelcastMapMetricsReporter.isValid(o, mapNames, c); assertTrue(isValid); } |
InfluxNiFiClusterMetricsReporter extends AbstractNiFiClusterMetricsReporter { void collectMeasurements(long now, SystemMetricsSnapshot snapshot, BatchPoints points) { collectMemoryMetrics(now, snapshot, points); collectJvmMetrics(now, snapshot, points); collectDiskUsageMetrics(now, snapshot, points); collectProcessGroupMetrics(now, Collections.singletonList(snapshot.getRootProcessGroupSnapshot()), points); collectProcessGroupMetrics(now, snapshot.getProcessGroupSnapshots(), points); collectRemoteProcessGroupMetrics(now, snapshot.getRemoteProcessGroupSnapshots(), points); collectProcessorMetrics(now, snapshot.getProcessorSnapshots(), points); collectConnectionMetrics(now, snapshot.getConnectionSnapshots(), points); collectInputPortMetrics(now, snapshot.getInputPortSnapshots(), points); collectOutputPortMetrics(now, snapshot.getOutputPortSnapshots(), points); } @OnScheduled void startup(ConfigurationContext context); @Override final List<PropertyDescriptor> getSupportedPropertyDescriptors(); } | @Test public void testCollectMeasurements() throws InitializationException { InfluxNiFiClusterMetricsReporter metricsInfluxDbReporter = new InfluxNiFiClusterMetricsReporter(); ProcessGroupStatusMetric processGroupStatusMetric = new ProcessGroupStatusMetric() .setId("id") .setProcessGroupName("root") .setActiveThreadCount(15.0) .setBytesRead(1.4) .setBytesReceived(4.) .setBytesSent(45.) .setBytesWritten(2387.) .setFlowFilesReceived(3425.) .setFlowFilesSent(3425.) .setFlowFilesTransferred(4243.) .setQueued(34521.) .setQueuedContentSize(487652.); Map<String, Object> memory = new HashMap<>(); memory.put("mem", 1.2); Map<String, Object> jvm = new HashMap<>(); jvm.put("free", 1.2); SystemMetricsSnapshot metrics = new SystemMetricsSnapshot() .setClusterNodeIdentifier("clusterId") .setMachineMemory(memory) .setJvmMetrics(jvm) .setRootProcessGroupSnapshot(processGroupStatusMetric) .setProcessGroupSnapshots(Arrays.asList(processGroupStatusMetric)); BatchPoints batchPoints = BatchPoints .database("mock_database") .build(); metricsInfluxDbReporter.collectMeasurements(System.currentTimeMillis(), metrics, batchPoints); List<Point> points = batchPoints.getPoints(); assertEquals(4, points.size()); } |
CloudwatchNiFiClusterMetricsReporter extends AbstractNiFiClusterMetricsReporter { List<MetricDatum> collectMeasurements(Date now, SystemMetricsSnapshot snapshot, List<Dimension> dimensions) { List<MetricDatum> toCloudwatch = new ArrayList<>(); if (collectsMemory) { getMetrics("System Memory", snapshot.getMachineMemory(), now, dimensions, toCloudwatch); } if (collectsJVMMetrics) { getMetrics("System JVM", snapshot.getJvmMetrics(), now, dimensions, toCloudwatch); } snapshot.getProcessGroupSnapshots().forEach((groupData) -> getMetrics(groupData.getProcessGroupName(), groupData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getRemoteProcessGroupSnapshots().forEach((groupData) -> getMetrics(groupData.getRemoteProcessGroupName(), groupData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getProcessorSnapshots().forEach((processorData) -> getMetrics(processorData.getProcessorName(), processorData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getConnectionSnapshots().forEach((connectionData) -> getMetrics(connectionData.getConnectionName(), connectionData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getInputPortSnapshots().forEach((portData) -> getMetrics(portData.getInputPortName(), portData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getOutputPortSnapshots().forEach((portData) -> getMetrics(portData.getInputPortName(), portData.valuesAsMap(), now, dimensions, toCloudwatch) ); snapshot.getDiskMetrics().entrySet().forEach((fileData) -> getMetrics(fileData.getKey().getAbsolutePath(), fileData.getValue(), now, dimensions, toCloudwatch) ); return toCloudwatch; } @Override final List<PropertyDescriptor> getSupportedPropertyDescriptors(); @OnScheduled void startup(ConfigurationContext context); static final PropertyDescriptor CREDENTIALS_FILE; static final PropertyDescriptor ACCESS_KEY; static final PropertyDescriptor SECRET_KEY; } | @Test public void testCollectMeasurements() throws InitializationException { CloudwatchNiFiClusterMetricsReporter metricsCloudwatchReporter = new CloudwatchNiFiClusterMetricsReporter(); ProcessGroupStatusMetric processGroupStatusMetric = new ProcessGroupStatusMetric() .setId("id") .setProcessGroupName("root") .setActiveThreadCount(15.0) .setBytesRead(1.4) .setBytesReceived(4.) .setBytesSent(45.) .setBytesWritten(2387.) .setFlowFilesReceived(3425.) .setFlowFilesSent(3425.) .setFlowFilesTransferred(4243.) .setQueued(34521.) .setQueuedContentSize(487652.); Map<String, Object> memory = new HashMap<>(); memory.put("mem", 1.2); Map<String, Object> jvm = new HashMap<>(); jvm.put("free", 1.2); SystemMetricsSnapshot metrics = new SystemMetricsSnapshot() .setClusterNodeIdentifier("clusterId") .setMachineMemory(memory) .setJvmMetrics(jvm) .setRootProcessGroupSnapshot(processGroupStatusMetric) .setProcessGroupSnapshots(Arrays.asList(processGroupStatusMetric)); List<Dimension> dimensions = new ArrayList<>(); List<MetricDatum> cloudwatchMetrics = metricsCloudwatchReporter.collectMeasurements(new Date(), metrics, dimensions); assertEquals(10, cloudwatchMetrics.size()); metricsCloudwatchReporter.collectsJVMMetrics = true; metricsCloudwatchReporter.collectsMemory = true; cloudwatchMetrics = metricsCloudwatchReporter.collectMeasurements(new Date(), metrics, dimensions); assertEquals(12, cloudwatchMetrics.size()); } |
ByteCode { public static void printOpCode(InstructionHandle insHandle, ConstantPoolGen cpg) { System.out.print("[" + String.format("%02d", insHandle.getPosition()) + "] "); printOpCode(insHandle.getInstruction(),cpg); } static void printOpCode(InstructionHandle insHandle, ConstantPoolGen cpg); static void printOpCode(Instruction ins, ConstantPoolGen cpg); static T getConstantLDC(InstructionHandle h, ConstantPoolGen cpg, Class<T> clazz); static Integer getConstantInt(InstructionHandle h); static Number getPushNumber(InstructionHandle h); static T getPrevInstruction(InstructionHandle startHandle, Class<T> clazz); } | @Test public void probeByteCodeDebug() { PrintStream sysOut = mock(PrintStream.class); System.out.println("Sysout hijack!"); PrintStream oldPrintStream = System.out; try { System.setOut(sysOut); InvokeInstruction ins = mock(InvokeInstruction.class); ConstantPoolGen cpg = mock(ConstantPoolGen.class); when(ins.getClassName(Matchers.<ConstantPoolGen>any())).thenReturn("ClassTest"); when(ins.getMethodName(Matchers.<ConstantPoolGen>any())).thenReturn("method"); when(ins.getSignature(Matchers.<ConstantPoolGen>any())).thenReturn("(Lsignature)Lblah"); ByteCode.printOpCode(ins, cpg); verify(sysOut, atLeastOnce()).println(contains("ClassTest.method")); } finally { System.setOut(oldPrintStream); System.out.println("Sysout is back!"); } } |
DoubleLinkedCountingSet { public void increment(int key) { int index = sparse[key]; if (index < elementsCount && dense[index] == key) { counts[index]++; } else { index = elementsCount++; sparse[key] = index; dense[index] = key; counts[index] = 1; } } DoubleLinkedCountingSet(int maxValue, int maxValues); void increment(int key); void clear(); final int[] sparse; final int[] dense; final int[] counts; public int elementsCount; } | @Test public void testSimple() { DoubleLinkedCountingSet s = new DoubleLinkedCountingSet(10, 5); assertEquals(0, s.elementsCount); s.increment(3); assertEquals(1, s.elementsCount); assertEquals(1, s.counts[0]); assertEquals(3, s.dense[0]); s.increment(10); assertEquals(2, s.elementsCount); assertEquals(1, s.counts[1]); assertEquals(10, s.dense[1]); s.increment(3); assertEquals(2, s.elementsCount); assertEquals(2, s.counts[0]); }
@Test @Repeat(iterations = 20) public void testRandomized() { int maxValue = randomIntBetween(0, 1000); int maxValues = randomIntBetween(0, maxValue); int [] values = new int [maxValues]; for (int i = 0; i < values.length; i++) { values[i] = randomIntBetween(0, maxValue); } DoubleLinkedCountingSet s = new DoubleLinkedCountingSet(maxValue, maxValues); IntIntOpenHashMap ref = IntIntOpenHashMap.newInstance(); for (int i = 0; i < maxValues * 10; i++) { int r = values[randomIntBetween(0, values.length - 1)]; ref.addTo(r, 1); s.increment(r); } IntIntOpenHashMap result = IntIntOpenHashMap.newInstance(); for (int i = 0; i < s.elementsCount; i++) { int k = s.dense[i]; int v = s.counts[i]; assertTrue(!result.containsKey(k)); result.put(k, v); } assertEquals(ref, result); } |
LangIdV3 implements ILangIdClassifier { @Override public DetectedLanguage classify(CharSequence str, boolean normalizeConfidence) { reset(); append(str); return classify(normalizeConfidence); } LangIdV3(); LangIdV3(Model model); @Override DetectedLanguage classify(CharSequence str, boolean normalizeConfidence); @Override void reset(); @Override void append(CharSequence str); @Override void append(ByteBuffer buffer); @Override void append(byte [] array, int start, int length); @Override DetectedLanguage classify(boolean normalizeConfidence); @Override List<DetectedLanguage> rank(boolean normalizeConfidence); } | @Test public void testSanity() { LangIdV3 langid = new LangIdV3(); for (String [] langString : new String [][] { {"en", "Mike McCandless rocks the boat."}, {"pl", "W Szczebrzeszynie chrząszcz brzmi w trzcinie"}, {"it", "Piano italiano per la crescita: negoziato in Europa sugli investimenti «virtuosi»"} }) { DetectedLanguage result = langid.classify(langString[1], true); assertEquals(langString[0], result.langCode); } } |
Model { public static Model detectOnly(Set<String> langCodes) { final Model source = defaultModel(); Set<String> newClasses = new LinkedHashSet<String>(Arrays.asList(source.langClasses)); newClasses.retainAll(langCodes); if (newClasses.size() < 2) { throw new IllegalArgumentException("A model must contain at least two languages."); } String [] trimmed_nb_classes = newClasses.toArray(new String[newClasses.size()]); float[] trimmed_nb_pc = new float [newClasses.size()]; float[] trimmed_nb_ptc = new float [newClasses.size() * source.numFeatures]; for (int i = 0, j = 0; i < source.numClasses; i++) { if (newClasses.contains(source.langClasses[i])) { trimmed_nb_pc[j] = source.nb_pc[i]; for (int f = 0; f < source.numFeatures; f++) { int iFrom = source.numFeatures * i + f; int iTo = source.numFeatures * j + f; trimmed_nb_ptc[iTo] = source.nb_ptc[iFrom]; } j++; } } return new Model( trimmed_nb_classes, trimmed_nb_ptc, trimmed_nb_pc, source.dsa, source.dsaOutput); } Model(String [] langClasses, float [] ptc, float [] pc, short [] dsa, int[][] dsaOutput); static Model readExternal(ObjectInput in); static Model detectOnly(Set<String> langCodes); Set<String> getDetectedLanguages(); static synchronized Model defaultModel(); } | @Test @Seeds(value = { @Seed, @Seed("deadbeef") }) public void testSameResultWithTrimmedLanguages() { final Set<String> allowed = Sets.newHashSet("en", "de", "es", "fr", "it", "pl"); LangIdV3 v1 = new LangIdV3(); LangIdV3 v2 = new LangIdV3(Model.detectOnly(allowed)); for (int i = 0; i < 10000; i++) { String in = randomRealisticUnicodeOfCodepointLengthBetween(1, 300); DetectedLanguage c1 = v1.classify(in, true); DetectedLanguage c2 = v2.classify(in, true); if (allowed.contains(c1.langCode)) { assertEquals(c1.langCode, c2.langCode); } } } |
UserService { public User create(String name, String currency) { final User user = new User(name, currency); return userRepository.save(user); } @Autowired UserService(UserRepository userRepository, UserManagementProperties userManagementProperties); List<User> list(); User create(String name, String currency); User get(long id); String getTestProperty(); } | @Test public void shouldCreateUser() throws Exception { when(userRepositoryMock.save(isA(User.class))).thenAnswer(invocation -> invocation.getArgument(0)); final User user = testSubject.create("Clark", "$"); assertThat(user.getName()).isEqualTo("Clark"); assertThat(user.getCurrency()).isEqualTo("$"); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.