From ef498c60e4aa37e7f2ddd2637a4d80713d595b38 Mon Sep 17 00:00:00 2001 From: cketti Date: Tue, 16 May 2023 17:01:40 +0200 Subject: [PATCH] Update assertk to version 0.26 --- .../fsck/k9/ServerSettingsSerializerTest.kt | 7 +- .../com/fsck/k9/helper/MessageHelperTest.kt | 2 +- .../fsck/k9/mailstore/K9BackendFolderTest.kt | 12 +- .../k9/mailstore/MimePartStreamParserTest.kt | 8 +- .../k9/message/html/GenericUriParserTest.kt | 12 +- .../fsck/k9/message/html/HttpUriParserTest.kt | 12 +- .../BaseNotificationDataCreatorTest.kt | 2 +- .../NewMailNotificationManagerTest.kt | 10 +- .../notification/NotificationDataStoreTest.kt | 2 +- .../SummaryNotificationDataCreatorTest.kt | 2 +- .../k9/preferences/StoragePersisterTest.kt | 7 +- .../messages/RetrieveFolderOperationsTest.kt | 7 +- .../fsck/k9/message/PgpMessageBuilderTest.kt | 10 +- .../MessageDetailsParticipantFormatterTest.kt | 2 +- .../MessageViewRecipientFormatterTest.kt | 2 +- .../jmap/CommandRefreshFolderListTest.kt | 12 +- .../fsck/k9/backend/jmap/CommandSyncTest.kt | 2 +- .../database/CursorExtensionsKtAccessTest.kt | 6 +- .../core/common/mail/EmailAddressTest.kt | 7 +- .../assertions/ListExtensionsKtTest.kt | 10 +- .../autoconfig/AutoconfigParserTest.kt | 107 ++++++--------- gradle/libs.versions.toml | 2 +- .../java/com/fsck/k9/mail/MimeTypeTest.kt | 7 +- .../mail/internet/AddressHeaderBuilderTest.kt | 7 +- .../k9/mail/internet/MimeHeaderCheckerTest.kt | 13 +- .../mail/store/imap/ImapResponseParserTest.kt | 122 ++++++++---------- .../mail/store/imap/RealImapConnectionTest.kt | 92 ++++++------- .../store/imap/RealImapFolderIdlerTest.kt | 17 +-- .../k9/mail/store/imap/RealImapFolderTest.kt | 100 ++++++-------- .../k9/mail/store/imap/RealImapStoreTest.kt | 18 +-- .../k9/mail/store/pop3/Pop3ConnectionTest.kt | 33 ++--- .../transport/smtp/SmtpResponseParserTest.kt | 69 +++++----- .../mail/transport/smtp/SmtpTransportTest.kt | 122 ++++++++---------- 33 files changed, 356 insertions(+), 487 deletions(-) diff --git a/app/core/src/test/java/com/fsck/k9/ServerSettingsSerializerTest.kt b/app/core/src/test/java/com/fsck/k9/ServerSettingsSerializerTest.kt index 21666945b40..d2e97ea3c72 100644 --- a/app/core/src/test/java/com/fsck/k9/ServerSettingsSerializerTest.kt +++ b/app/core/src/test/java/com/fsck/k9/ServerSettingsSerializerTest.kt @@ -1,9 +1,9 @@ package com.fsck.k9 +import assertk.assertFailure import assertk.assertThat import assertk.assertions.hasMessage import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import com.fsck.k9.mail.AuthType import com.fsck.k9.mail.ConnectionSecurity @@ -67,10 +67,9 @@ class ServerSettingsSerializerTest { } """.trimIndent() - assertThat { + assertFailure { serverSettingsSerializer.deserialize(json) - }.isFailure() - .isInstanceOf(IllegalArgumentException::class) + }.isInstanceOf() .hasMessage("'type' must not be missing") } } diff --git a/app/core/src/test/java/com/fsck/k9/helper/MessageHelperTest.kt b/app/core/src/test/java/com/fsck/k9/helper/MessageHelperTest.kt index 2f31e774fbd..4f509f0402c 100644 --- a/app/core/src/test/java/com/fsck/k9/helper/MessageHelperTest.kt +++ b/app/core/src/test/java/com/fsck/k9/helper/MessageHelperTest.kt @@ -60,7 +60,7 @@ class MessageHelperTest : RobolectricTest() { changeContactNameColor = true, contactNameColor = Color.RED, ) - assertThat(friendly).isInstanceOf(SpannableString::class.java) + assertThat(friendly).isInstanceOf() assertThat(friendly.toString()).isEqualTo("Tim Testor") } diff --git a/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendFolderTest.kt b/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendFolderTest.kt index f629bdba949..b4d03d9529a 100644 --- a/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendFolderTest.kt +++ b/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendFolderTest.kt @@ -2,11 +2,11 @@ package com.fsck.k9.mailstore import android.database.sqlite.SQLiteDatabase import androidx.core.content.contentValuesOf +import assertk.assertFailure import assertk.assertThat import assertk.assertions.contains import assertk.assertions.hasMessage import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import assertk.assertions.isTrue import com.fsck.k9.Account @@ -77,10 +77,9 @@ class K9BackendFolderTest : K9RobolectricTest() { fun saveCompleteMessage_withoutServerId_shouldThrow() { val message = createMessage(messageServerId = null) - assertThat { + assertFailure { backendFolder.saveMessage(message, MessageDownloadState.FULL) - }.isFailure() - .isInstanceOf(IllegalStateException::class) + }.isInstanceOf() .hasMessage("Message requires a server ID to be set") } @@ -88,10 +87,9 @@ class K9BackendFolderTest : K9RobolectricTest() { fun savePartialMessage_withoutServerId_shouldThrow() { val message = createMessage(messageServerId = null) - assertThat { + assertFailure { backendFolder.saveMessage(message, MessageDownloadState.PARTIAL) - }.isFailure() - .isInstanceOf(IllegalStateException::class) + }.isInstanceOf() .hasMessage("Message requires a server ID to be set") } diff --git a/app/core/src/test/java/com/fsck/k9/mailstore/MimePartStreamParserTest.kt b/app/core/src/test/java/com/fsck/k9/mailstore/MimePartStreamParserTest.kt index e129e8b9e8d..bfaae6b7e1f 100644 --- a/app/core/src/test/java/com/fsck/k9/mailstore/MimePartStreamParserTest.kt +++ b/app/core/src/test/java/com/fsck/k9/mailstore/MimePartStreamParserTest.kt @@ -43,11 +43,11 @@ class MimePartStreamParserTest { val bodyPart = MimePartStreamParser.parse(null, ByteArrayInputStream(messageContent.toByteArray())) - assertThat(bodyPart.body).isInstanceOf(MimeMultipart::class).all { + assertThat(bodyPart.body).isInstanceOf().all { bodyParts().hasSize(2) bodyPart(1).all { mimeType().isEqualTo("message/rfc822") - body().isInstanceOf(MimeMessage::class) + body().isInstanceOf() } } } @@ -80,11 +80,11 @@ class MimePartStreamParserTest { val bodyPart = MimePartStreamParser.parse(null, ByteArrayInputStream(messageContent.toByteArray())) - assertThat(bodyPart.body).isInstanceOf(MimeMultipart::class).all { + assertThat(bodyPart.body).isInstanceOf().all { bodyParts().hasSize(2) bodyPart(1).all { mimeType().isEqualTo("message/rfc822") - body().isInstanceOf(DeferredFileBody::class) + body().isInstanceOf() } } } diff --git a/app/core/src/test/java/com/fsck/k9/message/html/GenericUriParserTest.kt b/app/core/src/test/java/com/fsck/k9/message/html/GenericUriParserTest.kt index 455b95013f3..9787809c5fe 100644 --- a/app/core/src/test/java/com/fsck/k9/message/html/GenericUriParserTest.kt +++ b/app/core/src/test/java/com/fsck/k9/message/html/GenericUriParserTest.kt @@ -1,9 +1,9 @@ package com.fsck.k9.message.html +import assertk.assertFailure import assertk.assertThat import assertk.assertions.hasMessage import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import assertk.assertions.isNotNull import assertk.assertions.prop @@ -68,19 +68,17 @@ class GenericUriParserTest { @Test fun `negative 'startPos' value`() { - assertThat { + assertFailure { parser.parseUri("test", -1) - }.isFailure() - .isInstanceOf(IllegalArgumentException::class) + }.isInstanceOf() .hasMessage("Invalid 'startPos' value") } @Test fun `out of bounds 'startPos' value`() { - assertThat { + assertFailure { parser.parseUri("test", 4) - }.isFailure() - .isInstanceOf(IllegalArgumentException::class) + }.isInstanceOf() .hasMessage("Invalid 'startPos' value") } diff --git a/app/core/src/test/java/com/fsck/k9/message/html/HttpUriParserTest.kt b/app/core/src/test/java/com/fsck/k9/message/html/HttpUriParserTest.kt index 235b6c24f59..3c8a61842a7 100644 --- a/app/core/src/test/java/com/fsck/k9/message/html/HttpUriParserTest.kt +++ b/app/core/src/test/java/com/fsck/k9/message/html/HttpUriParserTest.kt @@ -1,9 +1,9 @@ package com.fsck.k9.message.html +import assertk.assertFailure import assertk.assertThat import assertk.assertions.hasMessage import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import assertk.assertions.isNotNull import assertk.assertions.isNull @@ -287,19 +287,17 @@ class HttpUriParserTest { @Test fun `negative 'startPos' value`() { - assertThat { + assertFailure { parser.parseUri("test", -1) - }.isFailure() - .isInstanceOf(IllegalArgumentException::class) + }.isInstanceOf() .hasMessage("Invalid 'startPos' value") } @Test fun `out of bounds 'startPos' value`() { - assertThat { + assertFailure { parser.parseUri("test", 4) - }.isFailure() - .isInstanceOf(IllegalArgumentException::class) + }.isInstanceOf() .hasMessage("Invalid 'startPos' value") } diff --git a/app/core/src/test/java/com/fsck/k9/notification/BaseNotificationDataCreatorTest.kt b/app/core/src/test/java/com/fsck/k9/notification/BaseNotificationDataCreatorTest.kt index 43e56a824da..1483f698640 100644 --- a/app/core/src/test/java/com/fsck/k9/notification/BaseNotificationDataCreatorTest.kt +++ b/app/core/src/test/java/com/fsck/k9/notification/BaseNotificationDataCreatorTest.kt @@ -127,7 +127,7 @@ class BaseNotificationDataCreatorTest { val result = notificationDataCreator.createBaseNotificationData(notificationData) - assertThat(result.lockScreenNotificationData).isInstanceOf(LockScreenNotificationData.SenderNames::class.java) + assertThat(result.lockScreenNotificationData).isInstanceOf() val senderNamesData = result.lockScreenNotificationData as LockScreenNotificationData.SenderNames assertThat(senderNamesData.senderNames).isEqualTo("Sender One, Sender Two, Sender Three") } diff --git a/app/core/src/test/java/com/fsck/k9/notification/NewMailNotificationManagerTest.kt b/app/core/src/test/java/com/fsck/k9/notification/NewMailNotificationManagerTest.kt index aec8dcfbb15..b7c4ee1151e 100644 --- a/app/core/src/test/java/com/fsck/k9/notification/NewMailNotificationManagerTest.kt +++ b/app/core/src/test/java/com/fsck/k9/notification/NewMailNotificationManagerTest.kt @@ -70,7 +70,7 @@ class NewMailNotificationManagerTest { summary = "summary", ), ) - assertThat(result.summaryNotificationData).isNotNull().isInstanceOf(SummarySingleNotificationData::class.java) + assertThat(result.summaryNotificationData).isNotNull().isInstanceOf() val summaryNotificationData = result.summaryNotificationData as SummarySingleNotificationData assertThat(summaryNotificationData.singleNotificationData.isSilent).isFalse() } @@ -108,7 +108,7 @@ class NewMailNotificationManagerTest { ), ) assertThat(result.baseNotificationData.newMessagesCount).isEqualTo(2) - assertThat(result.summaryNotificationData).isNotNull().isInstanceOf(SummaryInboxNotificationData::class.java) + assertThat(result.summaryNotificationData).isNotNull().isInstanceOf() val summaryNotificationData = result.summaryNotificationData as SummaryInboxNotificationData assertThat(summaryNotificationData.content).isEqualTo(listOf("Zoe Meeting", "Alice Hi Bob")) assertThat(summaryNotificationData.messageReferences).isEqualTo( @@ -229,7 +229,7 @@ class NewMailNotificationManagerTest { assertThat(data.cancelNotificationIds).isEqualTo(listOf(notificationIdTwo)) assertThat(data.singleNotificationData).isEmpty() assertThat(data.baseNotificationData.newMessagesCount).isEqualTo(2) - assertThat(data.summaryNotificationData).isNotNull().isInstanceOf(SummaryInboxNotificationData::class.java) + assertThat(data.summaryNotificationData).isNotNull().isInstanceOf() val summaryNotificationData = data.summaryNotificationData as SummaryInboxNotificationData assertThat(summaryNotificationData.content).isEqualTo(listOf("Alice Three", "Alice One")) assertThat(summaryNotificationData.messageReferences).isEqualTo( @@ -317,7 +317,7 @@ class NewMailNotificationManagerTest { ), ) - assertThat(data.summaryNotificationData).isNotNull().isInstanceOf(SummarySingleNotificationData::class.java) + assertThat(data.summaryNotificationData).isNotNull().isInstanceOf() val summaryNotificationData = data.summaryNotificationData as SummarySingleNotificationData assertThat(summaryNotificationData.singleNotificationData.isSilent).isTrue() assertThat(summaryNotificationData.singleNotificationData.content).isEqualTo( @@ -354,7 +354,7 @@ class NewMailNotificationManagerTest { assertThat(data.singleNotificationData).hasSize(MAX_NUMBER_OF_NEW_MESSAGE_NOTIFICATIONS) assertThat(data.singleNotificationData.map { it.content.sender }).doesNotContain("inactive") - assertThat(data.summaryNotificationData).isNotNull().isInstanceOf(SummaryInboxNotificationData::class.java) + assertThat(data.summaryNotificationData).isNotNull().isInstanceOf() val summaryNotificationData = data.summaryNotificationData as SummaryInboxNotificationData assertThat(summaryNotificationData.isSilent).isTrue() } diff --git a/app/core/src/test/java/com/fsck/k9/notification/NotificationDataStoreTest.kt b/app/core/src/test/java/com/fsck/k9/notification/NotificationDataStoreTest.kt index 781acaf6554..ec310362047 100644 --- a/app/core/src/test/java/com/fsck/k9/notification/NotificationDataStoreTest.kt +++ b/app/core/src/test/java/com/fsck/k9/notification/NotificationDataStoreTest.kt @@ -131,7 +131,7 @@ class NotificationDataStoreTest : RobolectricTest() { assertThat(removeResult.notificationHolders).hasSize(0) assertThat(removeResult.notificationStoreOperations).hasSize(MAX_NUMBER_OF_NEW_MESSAGE_NOTIFICATIONS + 1) for (notificationStoreOperation in removeResult.notificationStoreOperations) { - assertThat(notificationStoreOperation).isInstanceOf(NotificationStoreOperation.Remove::class.java) + assertThat(notificationStoreOperation).isInstanceOf() } } } diff --git a/app/core/src/test/java/com/fsck/k9/notification/SummaryNotificationDataCreatorTest.kt b/app/core/src/test/java/com/fsck/k9/notification/SummaryNotificationDataCreatorTest.kt index ed50ac4f3f6..48db6d7d97f 100644 --- a/app/core/src/test/java/com/fsck/k9/notification/SummaryNotificationDataCreatorTest.kt +++ b/app/core/src/test/java/com/fsck/k9/notification/SummaryNotificationDataCreatorTest.kt @@ -51,7 +51,7 @@ class SummaryNotificationDataCreatorTest { silent = false, ) - assertThat(result).isInstanceOf(SummarySingleNotificationData::class.java) + assertThat(result).isInstanceOf() } @Test diff --git a/app/storage/src/test/java/com/fsck/k9/preferences/StoragePersisterTest.kt b/app/storage/src/test/java/com/fsck/k9/preferences/StoragePersisterTest.kt index 005dd556bec..02417aecc63 100644 --- a/app/storage/src/test/java/com/fsck/k9/preferences/StoragePersisterTest.kt +++ b/app/storage/src/test/java/com/fsck/k9/preferences/StoragePersisterTest.kt @@ -1,11 +1,11 @@ package com.fsck.k9.preferences import android.content.Context +import assertk.assertFailure import assertk.assertThat import assertk.assertions.contains import assertk.assertions.containsOnly import assertk.assertions.isEmpty -import assertk.assertions.isFailure import assertk.assertions.isSameAs import assertk.assertions.isTrue import com.fsck.k9.preferences.K9StoragePersister.StoragePersistOperationCallback @@ -63,10 +63,9 @@ class StoragePersisterTest : K9RobolectricTest() { }, ) - assertThat { + assertFailure { storagePersister.doInTransaction(operationCallback) - }.isFailure() - .isSameAs(exception) + }.isSameAs(exception) val values = storagePersister.loadValues() diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveFolderOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveFolderOperationsTest.kt index ea6c03913dc..1dba4a96a21 100644 --- a/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveFolderOperationsTest.kt +++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveFolderOperationsTest.kt @@ -1,10 +1,10 @@ package com.fsck.k9.storage.messages +import assertk.assertFailure import assertk.assertThat import assertk.assertions.hasSize import assertk.assertions.isEmpty import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import assertk.assertions.isNotNull import assertk.assertions.isNull @@ -482,10 +482,9 @@ class RetrieveFolderOperationsTest : RobolectricTest() { @Test fun `get 'more messages' value from non-existent folder`() { - assertThat { + assertFailure { retrieveFolderOperations.hasMoreMessages(23) - }.isFailure() - .isInstanceOf(FolderNotFoundException::class) + }.isInstanceOf() .transform { it.folderId }.isEqualTo(23) } diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/message/PgpMessageBuilderTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/message/PgpMessageBuilderTest.kt index a162a2c18a3..f74368b3337 100644 --- a/app/ui/legacy/src/test/java/com/fsck/k9/message/PgpMessageBuilderTest.kt +++ b/app/ui/legacy/src/test/java/com/fsck/k9/message/PgpMessageBuilderTest.kt @@ -226,11 +226,11 @@ class PgpMessageBuilderTest : K9RobolectricTest() { val message = captor.value assertThat(message.mimeType).isEqualTo("multipart/signed") - assertThat(message.body).isInstanceOf(MimeMultipart::class).all { + assertThat(message.body).isInstanceOf().all { bodyParts().hasSize(2) bodyPart(0).all { contentType().value().isEqualTo("text/plain") - body().isInstanceOf(TextBody::class).all { + body().isInstanceOf().all { contentTransferEncoding().isEqualTo(MimeUtil.ENC_QUOTED_PRINTABLE) asText().isEqualTo(TEST_MESSAGE_TEXT) } @@ -559,7 +559,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() { assertThat(message).all { mimeType().isEqualTo("multipart/encrypted") - body().isInstanceOf(MimeMultipart::class).all { + body().isInstanceOf().all { bodyParts().hasSize(2) bodyPart(0).all { contentType().value().isEqualTo("application/pgp-encrypted") @@ -570,7 +570,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() { value().isEqualTo("application/octet-stream") parameter("name").isEqualTo("encrypted.asc") } - body().isInstanceOf(BinaryTempFileBody::class) + body().isInstanceOf() .contentTransferEncoding().isEqualTo(MimeUtil.ENC_7BIT) } } @@ -619,7 +619,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() { val message = captor.value assertThat(message).all { mimeType().isEqualTo("text/plain") - body().isInstanceOf(BinaryTempFileBody::class) + body().isInstanceOf() .contentTransferEncoding().isEqualTo(MimeUtil.ENC_7BIT) } diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagedetails/MessageDetailsParticipantFormatterTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagedetails/MessageDetailsParticipantFormatterTest.kt index 6bba916c647..b90a318d35c 100644 --- a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagedetails/MessageDetailsParticipantFormatterTest.kt +++ b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagedetails/MessageDetailsParticipantFormatterTest.kt @@ -124,7 +124,7 @@ class MessageDetailsParticipantFormatterTest : RobolectricTest() { val displayName = participantFormatter.getDisplayName(Address("user1@domain.example"), account) assertThat(displayName.toString()).isEqualTo("Contact One") - assertThat(displayName).isNotNull().isInstanceOf(Spannable::class.java) + assertThat(displayName).isNotNull().isInstanceOf() val spans = (displayName as Spannable).getSpans(0, displayName.length) assertThat(spans.map { it.foregroundColor }).containsExactly(Color.RED) } diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/MessageViewRecipientFormatterTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/MessageViewRecipientFormatterTest.kt index c75099ded65..77e3242187a 100644 --- a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/MessageViewRecipientFormatterTest.kt +++ b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/MessageViewRecipientFormatterTest.kt @@ -133,7 +133,7 @@ class MessageViewRecipientFormatterTest : RobolectricTest() { val displayName = recipientFormatter.getDisplayName(Address("user1@domain.example"), account) assertThat(displayName.toString()).isEqualTo("Contact One") - assertThat(displayName).isInstanceOf(Spannable::class.java) + assertThat(displayName).isInstanceOf() val spans = (displayName as Spannable).getSpans(0, displayName.length) assertThat(spans.map { it.foregroundColor }).containsExactly(Color.RED) } diff --git a/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandRefreshFolderListTest.kt b/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandRefreshFolderListTest.kt index 1173a048984..018a020e639 100644 --- a/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandRefreshFolderListTest.kt +++ b/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandRefreshFolderListTest.kt @@ -1,10 +1,10 @@ package com.fsck.k9.backend.jmap import app.k9mail.backend.testing.InMemoryBackendStorage +import assertk.assertFailure import assertk.assertThat import assertk.assertions.containsExactlyInAnyOrder import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import assertk.assertions.isTrue import assertk.fail @@ -28,10 +28,9 @@ class CommandRefreshFolderListTest { MockResponse().setResponseCode(401), ) - assertThat { + assertFailure { command.refreshFolderList() - }.isFailure() - .isInstanceOf(AuthenticationFailedException::class) + }.isInstanceOf() } @Test @@ -40,10 +39,9 @@ class CommandRefreshFolderListTest { MockResponse().setBody("invalid"), ) - assertThat { + assertFailure { command.refreshFolderList() - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .transform { it.isPermanentFailure }.isTrue() } diff --git a/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandSyncTest.kt b/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandSyncTest.kt index 5d1156388ee..d2a0d16cc8a 100644 --- a/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandSyncTest.kt +++ b/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandSyncTest.kt @@ -56,7 +56,7 @@ class CommandSyncTest { assertThat(syncListener.getNextEvent()).isEqualTo(SyncListenerEvent.SyncStarted(FOLDER_SERVER_ID)) val failedEvent = syncListener.getNextEvent() as SyncListenerEvent.SyncFailed - assertThat(failedEvent.exception).isNotNull().isInstanceOf(AuthenticationFailedException::class) + assertThat(failedEvent.exception).isNotNull().isInstanceOf() } @Test diff --git a/core/android/common/src/test/kotlin/app/k9mail/core/android/common/database/CursorExtensionsKtAccessTest.kt b/core/android/common/src/test/kotlin/app/k9mail/core/android/common/database/CursorExtensionsKtAccessTest.kt index d228ae48c97..1eaa52f71c9 100644 --- a/core/android/common/src/test/kotlin/app/k9mail/core/android/common/database/CursorExtensionsKtAccessTest.kt +++ b/core/android/common/src/test/kotlin/app/k9mail/core/android/common/database/CursorExtensionsKtAccessTest.kt @@ -2,10 +2,10 @@ package app.k9mail.core.android.common.database import android.database.Cursor import android.database.MatrixCursor +import assertk.assertFailure import assertk.assertThat import assertk.assertions.hasMessage import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isNull import org.junit.Test import org.junit.runner.RunWith @@ -55,9 +55,9 @@ class CursorExtensionsKtAccessTest(data: CursorExtensionsAccessTestData) { addRow(arrayOf(null)) } - assertThat { + assertFailure { cursor.map { testThrowingAction(it, "column") } - }.isFailure().hasMessage("Column column must not be null") + }.hasMessage("Column column must not be null") } @Test diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressTest.kt index 4f55a4b21be..7d2382efe24 100644 --- a/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressTest.kt +++ b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressTest.kt @@ -1,9 +1,9 @@ package app.k9mail.core.common.mail +import assertk.assertFailure import assertk.assertThat import assertk.assertions.hasMessage import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import kotlin.test.Test @@ -11,10 +11,9 @@ internal class EmailAddressTest { @Test fun `should reject blank email address`() { - assertThat { + assertFailure { EmailAddress("") - }.isFailure() - .isInstanceOf(IllegalArgumentException::class) + }.isInstanceOf() .hasMessage("Email address must not be blank") } diff --git a/core/testing/src/test/kotlin/assertk/assertions/ListExtensionsKtTest.kt b/core/testing/src/test/kotlin/assertk/assertions/ListExtensionsKtTest.kt index 6978dae9111..e3626132406 100644 --- a/core/testing/src/test/kotlin/assertk/assertions/ListExtensionsKtTest.kt +++ b/core/testing/src/test/kotlin/assertk/assertions/ListExtensionsKtTest.kt @@ -1,5 +1,6 @@ package assertk.assertions +import assertk.assertFailure import assertk.assertThat import kotlin.test.Test @@ -16,13 +17,8 @@ class ListExtensionsKtTest { fun `containsNoDuplicates() should fail with duplicates`() { val list = listOf("a", "b", "c", "a", "a") - assertThat { + assertFailure { assertThat(list).containsNoDuplicates() - }.isFailure() - .hasMessage( - """ - expected to contain no duplicates but found: <["a", "a"]> - """.trimIndent(), - ) + }.hasMessage("""expected to contain no duplicates but found: <["a", "a"]>""") } } diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParserTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParserTest.kt index eac22b09a3e..0b8e3df1953 100644 --- a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParserTest.kt +++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParserTest.kt @@ -3,10 +3,10 @@ package app.k9mail.autodiscovery.autoconfig import app.k9mail.autodiscovery.api.DiscoveredServerSettings import app.k9mail.autodiscovery.api.DiscoveryResults import assertk.all +import assertk.assertFailure import assertk.assertThat import assertk.assertions.containsExactly import assertk.assertions.hasMessage -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import assertk.assertions.isNotNull import assertk.assertions.prop @@ -194,10 +194,9 @@ class AutoconfigParserTest { element("emailProvider").removeAttr("id") } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Missing 'emailProvider.id' attribute") } @@ -207,10 +206,9 @@ class AutoconfigParserTest { element("emailProvider").attr("id", "-23") } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Invalid 'emailProvider.id' attribute") } @@ -220,10 +218,9 @@ class AutoconfigParserTest { element("emailProvider > domain").remove() } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Valid 'domain' element required") } @@ -233,10 +230,9 @@ class AutoconfigParserTest { element("emailProvider > domain").text("-invalid") } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Valid 'domain' element required") } @@ -246,10 +242,9 @@ class AutoconfigParserTest { element("incomingServer").remove() } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Missing 'incomingServer' element") } @@ -259,10 +254,9 @@ class AutoconfigParserTest { element("outgoingServer").remove() } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Missing 'outgoingServer' element") } @@ -272,10 +266,9 @@ class AutoconfigParserTest { element("incomingServer > hostname").remove() } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Missing 'hostname' element") } @@ -285,10 +278,9 @@ class AutoconfigParserTest { element("incomingServer > hostname").text("in valid") } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Invalid 'hostname' value: 'in valid'") } @@ -298,10 +290,9 @@ class AutoconfigParserTest { element("incomingServer > port").remove() } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Missing 'port' element") } @@ -311,10 +302,9 @@ class AutoconfigParserTest { element("incomingServer > socketType").remove() } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Missing 'socketType' element") } @@ -324,10 +314,9 @@ class AutoconfigParserTest { element("incomingServer > authentication").remove() } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("No usable 'authentication' element found") } @@ -337,10 +326,9 @@ class AutoconfigParserTest { element("incomingServer > username").remove() } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Missing 'username' element") } @@ -350,10 +338,9 @@ class AutoconfigParserTest { element("incomingServer > port").text("invalid") } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Invalid 'port' value: 'invalid'") } @@ -363,10 +350,9 @@ class AutoconfigParserTest { element("incomingServer > port").text("100000") } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Invalid 'port' value: '100000'") } @@ -376,10 +362,9 @@ class AutoconfigParserTest { element("incomingServer > socketType").text("TLS") } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Unknown 'socketType' value: 'TLS'") } @@ -389,10 +374,9 @@ class AutoconfigParserTest { element("incomingServer > hostname").html("imap.domain.example") } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Expected text, but got START_TAG") } @@ -402,10 +386,9 @@ class AutoconfigParserTest { element("emailProvider").tagName("madeUpTag") } - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "user@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Missing 'emailProvider' element") } @@ -413,10 +396,9 @@ class AutoconfigParserTest { fun `non XML data should throw`() { val inputStream = "invalid".byteInputStream() - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "irrelevant@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Error parsing Autoconfig XML") } @@ -429,10 +411,9 @@ class AutoconfigParserTest { """.trimIndent().byteInputStream() - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "irrelevant@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Missing 'clientConfig' element") } @@ -462,10 +443,9 @@ class AutoconfigParserTest { """.trimIndent().byteInputStream() - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "irrelevant@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("Error parsing Autoconfig XML") } @@ -479,10 +459,9 @@ class AutoconfigParserTest { """.trimIndent().byteInputStream() - assertThat { + assertFailure { parser.parseSettings(inputStream, email = "irrelevant@domain.example") - }.isFailure() - .isInstanceOf(AutoconfigParserException::class) + }.isInstanceOf() .hasMessage("End of document reached while reading element 'emailProvider'") } diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 59d7f59bcfa..c3784859451 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -142,7 +142,7 @@ mockito-kotlin = "org.mockito.kotlin:mockito-kotlin:4.1.0" turbine = "app.cash.turbine:turbine:0.12.3" jdom2 = "org.jdom:jdom2:2.0.6.1" icu4j-charset = "com.ibm.icu:icu4j-charset:72.1" -assertk = "com.willowtreeapps.assertk:assertk-jvm:0.25" +assertk = "com.willowtreeapps.assertk:assertk-jvm:0.26" leakcanary-android = "com.squareup.leakcanary:leakcanary-android:2.9.1" diff --git a/mail/common/src/test/java/com/fsck/k9/mail/MimeTypeTest.kt b/mail/common/src/test/java/com/fsck/k9/mail/MimeTypeTest.kt index 611592ccfde..961ac403e53 100644 --- a/mail/common/src/test/java/com/fsck/k9/mail/MimeTypeTest.kt +++ b/mail/common/src/test/java/com/fsck/k9/mail/MimeTypeTest.kt @@ -1,8 +1,8 @@ package com.fsck.k9.mail +import assertk.assertFailure import assertk.assertThat import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import assertk.assertions.isNotNull import assertk.assertions.isNull @@ -69,10 +69,9 @@ class MimeTypeTest { } private fun assertInvalidMimeType(input: String) { - assertThat { + assertFailure { input.toMimeType() - }.isFailure() - .isInstanceOf(IllegalArgumentException::class) + }.isInstanceOf() .message().isNotNull().startsWith("Invalid MIME type: ") } diff --git a/mail/common/src/test/java/com/fsck/k9/mail/internet/AddressHeaderBuilderTest.kt b/mail/common/src/test/java/com/fsck/k9/mail/internet/AddressHeaderBuilderTest.kt index 85839201e84..f710ba6d9f4 100644 --- a/mail/common/src/test/java/com/fsck/k9/mail/internet/AddressHeaderBuilderTest.kt +++ b/mail/common/src/test/java/com/fsck/k9/mail/internet/AddressHeaderBuilderTest.kt @@ -1,9 +1,9 @@ package com.fsck.k9.mail.internet +import assertk.assertFailure import assertk.assertThat import assertk.assertions.hasMessage import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import com.fsck.k9.mail.Address import com.fsck.k9.mail.crlf @@ -56,10 +56,9 @@ class AddressHeaderBuilderTest { @Test fun createHeaderValue_withoutAddresses_shouldThrow() { - assertThat { + assertFailure { AddressHeaderBuilder.createHeaderValue(emptyArray()) - }.isFailure() - .isInstanceOf(IllegalArgumentException::class) + }.isInstanceOf() .hasMessage("addresses must not be empty") } } diff --git a/mail/common/src/test/java/com/fsck/k9/mail/internet/MimeHeaderCheckerTest.kt b/mail/common/src/test/java/com/fsck/k9/mail/internet/MimeHeaderCheckerTest.kt index 898ffbf5061..9c5ed4543be 100644 --- a/mail/common/src/test/java/com/fsck/k9/mail/internet/MimeHeaderCheckerTest.kt +++ b/mail/common/src/test/java/com/fsck/k9/mail/internet/MimeHeaderCheckerTest.kt @@ -1,9 +1,7 @@ package com.fsck.k9.mail.internet -import assertk.assertThat -import assertk.assertions.isFailure +import assertk.assertFailure import assertk.assertions.isInstanceOf -import assertk.assertions.isSuccess import org.junit.Test class MimeHeaderCheckerTest { @@ -200,17 +198,14 @@ class MimeHeaderCheckerTest { private fun assertValidHeader(header: String) { val (name, value) = header.split(": ", limit = 2) - assertThat { - MimeHeaderChecker.checkHeader(name, value) - }.isSuccess() + MimeHeaderChecker.checkHeader(name, value) } private fun assertInvalidHeader(header: String) { val (name, value) = header.split(": ", limit = 2) - assertThat { + assertFailure { MimeHeaderChecker.checkHeader(name, value) - }.isFailure() - .isInstanceOf(MimeHeaderParserException::class) + }.isInstanceOf() } } diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/ImapResponseParserTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/ImapResponseParserTest.kt index a79e9d8783b..18f7a90dc06 100644 --- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/ImapResponseParserTest.kt +++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/ImapResponseParserTest.kt @@ -1,6 +1,7 @@ package com.fsck.k9.mail.store.imap import assertk.all +import assertk.assertFailure import assertk.assertThat import assertk.assertions.cause import assertk.assertions.containsExactly @@ -8,10 +9,10 @@ import assertk.assertions.hasMessage import assertk.assertions.hasSize import assertk.assertions.index import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import assertk.assertions.isNotNull import assertk.assertions.isNull +import assertk.assertions.isSameAs import assertk.assertions.isTrue import assertk.assertions.prop import com.fsck.k9.mail.filter.FixedLengthInputStream @@ -51,7 +52,7 @@ class ImapResponseParserTest { assertThat(response).hasSize(2) assertThat(response).index(0).isEqualTo("OK") - assertThat(response).index(1).isInstanceOf(ImapList::class).containsExactly("UIDVALIDITY", "3857529045") + assertThat(response).index(1).isInstanceOf().containsExactly("UIDVALIDITY", "3857529045") assertThatAllInputWasConsumed() } @@ -63,7 +64,7 @@ class ImapResponseParserTest { assertThat(response).hasSize(3) assertThat(response).index(0).isEqualTo("OK") - assertThat(response).index(1).isInstanceOf(ImapList::class).containsExactly("token1", "token2") + assertThat(response).index(1).isInstanceOf().containsExactly("token1", "token2") assertThat(response).index(2).isEqualTo("{x} test [...]") assertThatAllInputWasConsumed() } @@ -148,10 +149,9 @@ class ImapResponseParserTest { "TAG ERROR COMMAND errored", ) - assertThat { + assertFailure { parser.readStatusResponse("TAG", null, null, null) - }.isFailure() - .isInstanceOf(NegativeImapResponseException::class) + }.isInstanceOf() } @Test @@ -165,9 +165,9 @@ class ImapResponseParserTest { assertThat(response).hasSize(3) assertThat(response).index(0).isEqualTo("OK") - assertThat(response).index(1).isInstanceOf(ImapList::class).all { + assertThat(response).index(1).isInstanceOf().all { index(0).isEqualTo("PERMANENTFLAGS") - index(1).isInstanceOf(ImapList::class).containsExactly( + index(1).isInstanceOf().containsExactly( """\Answered""", """\Flagged""", """\Deleted""", @@ -199,10 +199,9 @@ class ImapResponseParserTest { fun `readResponse() should throw if stream ends before end of line is found`() { val parser = createParserWithData("* OK Some text ") - assertThat { + assertFailure { parser.readResponse() - }.isFailure() - .isInstanceOf(IOException::class) + }.isInstanceOf() } @Test @@ -240,10 +239,9 @@ class ImapResponseParserTest { fun `readResponse() with literal containing negative size`() { val parser = createParserWithResponses("* {-1}") - assertThat { + assertFailure { parser.readResponse() - }.isFailure() - .isInstanceOf(ImapResponseParserException::class) + }.isInstanceOf() .hasMessage("Invalid value for size of literal string") } @@ -251,10 +249,9 @@ class ImapResponseParserTest { fun `readResponse() with literal size exceeding Int`() { val parser = createParserWithResponses("* {2147483648}") - assertThat { + assertFailure { parser.readResponse() - }.isFailure() - .isInstanceOf(ImapResponseParserException::class) + }.isInstanceOf() .hasMessage("Invalid value for size of literal string") } @@ -262,10 +259,9 @@ class ImapResponseParserTest { fun `readResponse() with invalid characters for literal size`() { val parser = createParserWithResponses("* {invalid}") - assertThat { + assertFailure { parser.readResponse() - }.isFailure() - .isInstanceOf(ImapResponseParserException::class) + }.isInstanceOf() .hasMessage("Invalid value for size of literal string") } @@ -273,10 +269,9 @@ class ImapResponseParserTest { fun `readResponse() should throw when end of stream is reached while reading literal`() { val parser = createParserWithData("* {4}\r\nabc") - assertThat { + assertFailure { parser.readResponse() - }.isFailure() - .isInstanceOf(IOException::class) + }.isInstanceOf() } @Test @@ -307,10 +302,9 @@ class ImapResponseParserTest { val parser = createParserWithResponses("* {4}\r\ntest") val callback = TestImapResponseCallback.readBytesAndReturn(2, null) - assertThat { + assertFailure { parser.readResponse(callback) - }.isFailure() - .isInstanceOf(AssertionError::class) + }.isInstanceOf() .hasMessage("Callback consumed some data but returned no result") } @@ -319,13 +313,12 @@ class ImapResponseParserTest { val parser = createParserWithResponses("* {4}\r\ntest") val callback = TestImapResponseCallback.readBytesAndThrow(2) - assertThat { + assertFailure { parser.readResponse(callback) - }.isFailure() - .isInstanceOf(ImapResponseParserException::class) + }.isInstanceOf() .all { hasMessage("readResponse(): Exception in callback method") - cause().isNotNull().isInstanceOf(ImapResponseParserTestException::class) + cause().isNotNull().isInstanceOf() } assertThatAllInputWasConsumed() } @@ -335,13 +328,12 @@ class ImapResponseParserTest { val parser = createParserWithResponses("* {3}\r\none {3}\r\ntwo") val callback = TestImapResponseCallback.readBytesAndThrow(3) - assertThat { + assertFailure { parser.readResponse(callback) - }.isFailure() - .isInstanceOf(ImapResponseParserException::class) + }.isInstanceOf() .all { hasMessage("readResponse(): Exception in callback method") - cause().isNotNull().isInstanceOf(ImapResponseParserTestException::class) + cause().isNotNull().isInstanceOf() .prop(ImapResponseParserTestException::instanceNumber).isEqualTo(0) } assertThatAllInputWasConsumed() @@ -363,10 +355,9 @@ class ImapResponseParserTest { val parser = createParserWithResponses("* {4}\r\ntest") val callback = TestImapResponseCallback.readBytesAndThrow(0) - assertThat { + assertFailure { parser.readResponse(callback) - }.isFailure() - .isInstanceOf(ImapResponseParserException::class) + }.isInstanceOf() .hasMessage("readResponse(): Exception in callback method") assertThatAllInputWasConsumed() } @@ -377,10 +368,9 @@ class ImapResponseParserTest { val exception = IOException() val callback = ImapResponseCallback { _, _ -> throw exception } - assertThat { + assertFailure { parser.readResponse(callback) - }.isFailure() - .isEqualTo(exception) + }.isSameAs(exception) } @Test @@ -407,30 +397,27 @@ class ImapResponseParserTest { fun `readResponse() should throw when end of stream is reached before end of quoted string`() { val parser = createParserWithResponses("* \"abc") - assertThat { + assertFailure { parser.readResponse() - }.isFailure() - .isInstanceOf(IOException::class) + }.isInstanceOf() } @Test fun `readResponse() should throw if end of stream is reached before end of atom`() { val parser = createParserWithData("* abc") - assertThat { + assertFailure { parser.readResponse() - }.isFailure() - .isInstanceOf(IOException::class) + }.isInstanceOf() } @Test fun `readResponse() should throw if untagged response indicator is not followed by a space`() { val parser = createParserWithResponses("*") - assertThat { + assertFailure { parser.readResponse() - }.isFailure() - .isInstanceOf(IOException::class) + }.isInstanceOf() } @Test @@ -441,7 +428,7 @@ class ImapResponseParserTest { assertThat(response).hasSize(4) assertThat(response).index(0).isEqualTo("LIST") - assertThat(response).index(1).isInstanceOf(ImapList::class).containsExactly("""\HasNoChildren""") + assertThat(response).index(1).isInstanceOf().containsExactly("""\HasNoChildren""") assertThat(response).index(2).isEqualTo(".") assertThat(response).index(3).isEqualTo("[FolderName]") assertThatAllInputWasConsumed() @@ -451,10 +438,9 @@ class ImapResponseParserTest { fun `readResponse() with LIST response containing folder name with parentheses should throw`() { val parser = createParserWithResponses("""* LIST (\NoInferiors) "/" Root/Folder/Subfolder()""") - assertThat { + assertFailure { parser.readResponse() - }.isFailure() - .isInstanceOf(IOException::class) + }.isInstanceOf() } @Test @@ -479,7 +465,7 @@ class ImapResponseParserTest { assertThat(response).hasSize(4) assertThat(response).index(0).isEqualTo("LIST") - assertThat(response).index(1).isInstanceOf(ImapList::class).containsExactly("""\NoInferiors""") + assertThat(response).index(1).isInstanceOf().containsExactly("""\NoInferiors""") assertThat(response).index(2).isNull() assertThat(response).index(3).isEqualTo("INBOX") assertThatAllInputWasConsumed() @@ -489,10 +475,9 @@ class ImapResponseParserTest { fun `readResponse() with tagged response missing completion code should throw`() { val parser = createParserWithResponses("tag ") - assertThat { + assertFailure { parser.readResponse() - }.isFailure() - .isInstanceOf(ImapResponseParserException::class) + }.isInstanceOf() .hasMessage("Unexpected non-string token") } @@ -500,10 +485,9 @@ class ImapResponseParserTest { fun `readResponse() with list as first token should throw`() { val parser = createParserWithResponses("* [1 2] 3") - assertThat { + assertFailure { parser.readResponse() - }.isFailure() - .isInstanceOf(ImapResponseParserException::class) + }.isInstanceOf() .hasMessage("Unexpected non-string token") } @@ -524,7 +508,7 @@ class ImapResponseParserTest { assertThat(response).hasSize(3) assertThat(response).index(0).isEqualTo("1") assertThat(response).index(1).isEqualTo("FETCH") - assertThat(response).index(2).isInstanceOf(ImapList::class).all { + assertThat(response).index(2).isInstanceOf().all { hasSize(11) index(0).isEqualTo("UID") index(1).isEqualTo("23") @@ -533,14 +517,14 @@ class ImapResponseParserTest { index(4).isEqualTo("RFC822.SIZE") index(5).isEqualTo("3456") index(6).isEqualTo("BODY") - index(7).isInstanceOf(ImapList::class).all { + index(7).isInstanceOf().all { hasSize(2) index(0).isEqualTo("HEADER.FIELDS") - index(1).isInstanceOf(ImapList::class).containsExactly("date", "subject", "from") + index(1).isInstanceOf().containsExactly("date", "subject", "from") } index(8).isEqualTo("") index(9).isEqualTo("FLAGS") - index(10).isInstanceOf(ImapList::class).containsExactly("""\Seen""") + index(10).isInstanceOf().containsExactly("""\Seen""") } assertThatAllInputWasConsumed() } @@ -549,10 +533,9 @@ class ImapResponseParserTest { fun `readStatusResponse() with NO response should throw`() { val parser = createParserWithResponses("1 NO") - assertThat { + assertFailure { parser.readStatusResponse("1", "COMMAND", "[logId]", null) - }.isFailure() - .isInstanceOf(NegativeImapResponseException::class) + }.isInstanceOf() .hasMessage("Command: COMMAND; response: #1# [NO]") } @@ -560,10 +543,9 @@ class ImapResponseParserTest { fun `readStatusResponse() with NO response and alert text should throw with alert text`() { val parser = createParserWithResponses("1 NO [ALERT] Access denied\r\n") - assertThat { + assertFailure { parser.readStatusResponse("1", "COMMAND", "[logId]", null) - }.isFailure() - .isInstanceOf(NegativeImapResponseException::class) + }.isInstanceOf() .prop(NegativeImapResponseException::getAlertText).isEqualTo("Access denied") } diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapConnectionTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapConnectionTest.kt index b56a1ca1f5d..c5b3c3fd1fa 100644 --- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapConnectionTest.kt +++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapConnectionTest.kt @@ -1,12 +1,12 @@ package com.fsck.k9.mail.store.imap +import assertk.assertFailure import assertk.assertThat import assertk.assertions.contains import assertk.assertions.containsExactly import assertk.assertions.hasMessage import assertk.assertions.hasSize import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isFalse import assertk.assertions.isInstanceOf import assertk.assertions.isNotNull @@ -128,10 +128,9 @@ class RealImapConnectionTest { imapConnection.open() imapConnection.close() - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(IllegalStateException::class) + }.isInstanceOf() .hasMessage("open() called after close(). Check wrapped exception to see where close() was called.") } @@ -142,10 +141,9 @@ class RealImapConnectionTest { } val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.PLAIN) - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Server doesn't support unencrypted passwords using AUTH=PLAIN and LOGIN is disabled.") server.verifyConnectionClosed() @@ -185,10 +183,9 @@ class RealImapConnectionTest { } val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.PLAIN) - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(AuthenticationFailedException::class) + }.isInstanceOf() .prop(AuthenticationFailedException::messageFromServer) .isEqualTo("Go away") @@ -208,10 +205,9 @@ class RealImapConnectionTest { } val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.PLAIN) - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(NegativeImapResponseException::class) + }.isInstanceOf() .message().isNotNull().contains("Maximum number of connections from user+IP exceeded") assertThat(imapConnection.isConnected).isFalse() @@ -232,10 +228,9 @@ class RealImapConnectionTest { } val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.PLAIN) - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(AuthenticationFailedException::class) + }.isInstanceOf() .prop(AuthenticationFailedException::messageFromServer) .isEqualTo("Login Failure") @@ -288,10 +283,9 @@ class RealImapConnectionTest { } val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.CRAM_MD5) - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(AuthenticationFailedException::class) + }.isInstanceOf() .prop(AuthenticationFailedException::messageFromServer) .isEqualTo("Who are you?") @@ -306,10 +300,9 @@ class RealImapConnectionTest { } val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.CRAM_MD5) - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Server doesn't support encrypted passwords using CRAM-MD5.") server.verifyConnectionClosed() @@ -393,10 +386,9 @@ class RealImapConnectionTest { } val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.XOAUTH2) - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(AuthenticationFailedException::class) + }.isInstanceOf() .prop(AuthenticationFailedException::messageFromServer) .isEqualTo("SASL authentication failed") } @@ -479,10 +471,9 @@ class RealImapConnectionTest { } val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.XOAUTH2) - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(AuthenticationFailedException::class) + }.isInstanceOf() .prop(AuthenticationFailedException::messageFromServer) .isEqualTo("SASL authentication failed") } @@ -530,10 +521,9 @@ class RealImapConnectionTest { val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.EXTERNAL) // FIXME: improve exception message - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(CertificateValidationException::class) + }.isInstanceOf() .message().isNotNull().contains("Bad certificate") server.verifyConnectionClosed() @@ -547,10 +537,9 @@ class RealImapConnectionTest { } val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.EXTERNAL) - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(CertificateValidationException::class) + }.isInstanceOf() .prop(CertificateValidationException::getReason) .isEqualTo(CertificateValidationException.Reason.MissingCapability) @@ -652,10 +641,9 @@ class RealImapConnectionTest { val settings = createImapSettings(host = "host name") val imapConnection = createImapConnection(settings, socketFactory, oAuth2TokenProvider) - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(UnknownHostException::class) + }.isInstanceOf() assertThat(imapConnection.isConnected).isFalse() } @@ -699,10 +687,9 @@ class RealImapConnectionTest { ) // FIXME: CertificateValidationException seems wrong - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(CertificateValidationException::class) + }.isInstanceOf() .hasMessage("STARTTLS connection security not available") server.verifyConnectionClosed() @@ -749,10 +736,9 @@ class RealImapConnectionTest { authType = AuthType.PLAIN, ) - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(NegativeImapResponseException::class) + }.isInstanceOf() .hasMessage("Command: STARTTLS; response: #2# [NO]") server.verifyConnectionClosed() @@ -801,10 +787,9 @@ class RealImapConnectionTest { } val imapConnection = startServerAndCreateImapConnection(server, useCompression = true) - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(IOException::class) + }.isInstanceOf() server.verifyConnectionClosed() server.verifyInteractionCompleted() @@ -819,10 +804,9 @@ class RealImapConnectionTest { } val imapConnection = startServerAndCreateImapConnection(server) - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(IOException::class) + }.isInstanceOf() server.verifyConnectionClosed() server.verifyInteractionCompleted() @@ -1058,10 +1042,9 @@ class RealImapConnectionTest { } val imapConnection = startServerAndCreateImapConnection(server) - assertThat { + assertFailure { imapConnection.executeSimpleCommand("CREATE Folder") - }.isFailure() - .isInstanceOf(NegativeImapResponseException::class) + }.isInstanceOf() .prop(NegativeImapResponseException::getLastResponse) .containsExactly("NO", "Folder exists") @@ -1100,10 +1083,9 @@ class RealImapConnectionTest { } val imapConnection = startServerAndCreateImapConnection(server) - assertThat { + assertFailure { imapConnection.open() - }.isFailure() - .isInstanceOf(AuthenticationFailedException::class) + }.isInstanceOf() .prop(AuthenticationFailedException::messageFromServer) .isEqualTo("AUTHENTICATE failed") diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderIdlerTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderIdlerTest.kt index 3e9862379a1..45f21aa4104 100644 --- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderIdlerTest.kt +++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderIdlerTest.kt @@ -1,9 +1,9 @@ package com.fsck.k9.mail.store.imap +import assertk.assertFailure import assertk.assertThat import assertk.assertions.hasMessage import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isFalse import assertk.assertions.isGreaterThan import assertk.assertions.isInstanceOf @@ -224,10 +224,9 @@ class RealImapFolderIdlerTest { imapFolder.throwOnOpen { throw AuthenticationFailedException("Authentication failure for test") } thread { - assertThat { + assertFailure { idler.idle() - }.isFailure() - .isInstanceOf(AuthenticationFailedException::class) + }.isInstanceOf() .hasMessage("Authentication failure for test") latch.countDown() @@ -243,10 +242,9 @@ class RealImapFolderIdlerTest { imapFolder.throwOnOpen { throw IOException("I/O error for test") } thread { - assertThat { + assertFailure { idler.idle() - }.isFailure() - .isInstanceOf(IOException::class) + }.isInstanceOf() .hasMessage("I/O error for test") latch.countDown() @@ -261,10 +259,9 @@ class RealImapFolderIdlerTest { val latch = CountDownLatch(1) thread { - assertThat { + assertFailure { idler.idle() - }.isFailure() - .isInstanceOf(IOException::class) + }.isInstanceOf() .hasMessage("Socket closed during IDLE") latch.countDown() diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderTest.kt index 9d914b9f868..27225051ea0 100644 --- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderTest.kt +++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderTest.kt @@ -1,6 +1,7 @@ package com.fsck.k9.mail.store.imap import assertk.all +import assertk.assertFailure import assertk.assertThat import assertk.assertions.cause import assertk.assertions.containsExactly @@ -8,7 +9,6 @@ import assertk.assertions.containsOnly import assertk.assertions.extracting import assertk.assertions.hasMessage import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isFalse import assertk.assertions.isInstanceOf import assertk.assertions.isNotNull @@ -161,10 +161,10 @@ class RealImapFolderTest { val imapFolder = createFolder("Folder") doThrow(IOException::class).whenever(imapConnection).executeSimpleCommand("SELECT \"Folder\"") - assertThat { + assertFailure { imapFolder.open(OpenMode.READ_WRITE) - }.isFailure() - .isInstanceOf(MessagingException::class).cause().isNotNull().isInstanceOf(IOException::class) + }.isInstanceOf() + .cause().isNotNull().isInstanceOf() } @Test @@ -172,10 +172,9 @@ class RealImapFolderTest { val imapFolder = createFolder("Folder") doThrow(MessagingException::class).whenever(imapConnection).executeSimpleCommand("SELECT \"Folder\"") - assertThat { + assertFailure { imapFolder.open(OpenMode.READ_WRITE) - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() } @Test @@ -187,10 +186,9 @@ class RealImapFolderTest { ) whenever(imapConnection.executeSimpleCommand("SELECT \"Folder\"")).thenReturn(selectResponses) - assertThat { + assertFailure { imapFolder.open(OpenMode.READ_WRITE) - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Did not find message count during open") } @@ -279,10 +277,9 @@ class RealImapFolderTest { val destinationFolder = createFolder("Destination") val messages = listOf(mock()) - assertThat { + assertFailure { sourceFolder.copyMessages(messages, destinationFolder) - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Folder Source is not open.") } @@ -342,10 +339,9 @@ class RealImapFolderTest { fun getUnreadMessageCount_withClosedFolder_shouldThrow() { val folder = createFolder("FolderName") - assertThat { + assertFailure { folder.unreadMessageCount - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Folder FolderName is not open.") } @@ -356,10 +352,9 @@ class RealImapFolderTest { whenever(imapConnection.executeSimpleCommand("SEARCH 1:* UNSEEN NOT DELETED")).thenThrow(IOException()) folder.open(OpenMode.READ_WRITE) - assertThat { + assertFailure { folder.unreadMessageCount - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("IO Error") } @@ -380,10 +375,9 @@ class RealImapFolderTest { fun getFlaggedMessageCount_withClosedFolder_shouldThrow() { val folder = createFolder("FolderName") - assertThat { + assertFailure { folder.flaggedMessageCount - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Folder FolderName is not open.") } @@ -434,10 +428,9 @@ class RealImapFolderTest { doThrow(IOException::class).whenever(imapConnection).executeSimpleCommand("UID SEARCH *:*") folder.open(OpenMode.READ_WRITE) - assertThat { + assertFailure { folder.highestUid - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("IO Error") } @@ -486,10 +479,9 @@ class RealImapFolderTest { fun getMessages_withInvalidStartArgument_shouldThrow() { val folder = createFolder("Folder") - assertThat { + assertFailure { folder.getMessages(0, 10, null, null) - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Invalid message set 0 10") } @@ -497,10 +489,9 @@ class RealImapFolderTest { fun getMessages_withInvalidEndArgument_shouldThrow() { val folder = createFolder("Folder") - assertThat { + assertFailure { folder.getMessages(10, 0, null, null) - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Invalid message set 10 0") } @@ -508,10 +499,9 @@ class RealImapFolderTest { fun getMessages_withEndArgumentSmallerThanStartArgument_shouldThrow() { val folder = createFolder("Folder") - assertThat { + assertFailure { folder.getMessages(10, 5, null, null) - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Invalid message set 10 5") } @@ -519,10 +509,9 @@ class RealImapFolderTest { fun getMessages_withClosedFolder_shouldThrow() { val folder = createFolder("FolderName") - assertThat { + assertFailure { folder.getMessages(1, 5, null, null) - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Folder FolderName is not open.") } @@ -530,10 +519,9 @@ class RealImapFolderTest { fun getMessages_sequenceNumbers_withClosedFolder_shouldThrow() { val folder = createFolder("FolderName") - assertThat { + assertFailure { folder.getMessages(setOf(1L, 2L, 5L), false, null) - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Folder FolderName is not open.") } @@ -568,10 +556,9 @@ class RealImapFolderTest { fun getMessagesFromUids_withClosedFolder_shouldThrow() { val folder = createFolder("FolderName") - assertThat { + assertFailure { folder.getMessagesFromUids(listOf("11", "22", "25")) - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Folder FolderName is not open.") } @@ -592,10 +579,9 @@ class RealImapFolderTest { fun areMoreMessagesAvailable_withClosedFolder_shouldThrow() { val folder = createFolder("FolderName") - assertThat { + assertFailure { folder.areMoreMessagesAvailable(10, Date()) - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Folder FolderName is not open.") } @@ -944,13 +930,12 @@ class RealImapFolderTest { val messages = listOf(createImapMessage("1")) whenever(imapConnection.readResponse()).thenReturn(createImapResponse("x NO Can't append to this folder")) - assertThat { + assertFailure { folder.appendMessages(messages) - }.isFailure() - .isInstanceOf(NegativeImapResponseException::class.java).all { - hasMessage("APPEND failed") - transform { it.lastResponse[0] }.isEqualTo("NO") - } + }.isInstanceOf().all { + hasMessage("APPEND failed") + transform { it.lastResponse[0] }.isEqualTo("NO") + } } @Test @@ -961,13 +946,12 @@ class RealImapFolderTest { val messages = listOf(createImapMessage("1")) whenever(imapConnection.readResponse()).thenReturn(createImapResponse("x BAD [TOOBIG] Message too large.")) - assertThat { + assertFailure { folder.appendMessages(messages) - }.isFailure() - .isInstanceOf(NegativeImapResponseException::class.java).all { - hasMessage("APPEND failed") - transform { it.lastResponse[0] }.isEqualTo("BAD") - } + }.isInstanceOf().all { + hasMessage("APPEND failed") + transform { it.lastResponse[0] }.isEqualTo("BAD") + } } @Test diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapStoreTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapStoreTest.kt index 04c9af4f9a4..54e236bdbb4 100644 --- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapStoreTest.kt +++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapStoreTest.kt @@ -1,11 +1,11 @@ package com.fsck.k9.mail.store.imap import assertk.all +import assertk.assertFailure import assertk.assertThat import assertk.assertions.cause import assertk.assertions.containsExactly import assertk.assertions.hasMessage -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import assertk.assertions.isNotNull import assertk.assertions.isSameAs @@ -50,11 +50,12 @@ class RealImapStoreTest { } imapStore.enqueueImapConnection(imapConnection) - assertThat { imapStore.checkSettings() }.isFailure() - .isInstanceOf(MessagingException::class).all { - hasMessage("Unable to connect") - cause().isNotNull().isInstanceOf(IOException::class) - } + assertFailure { + imapStore.checkSettings() + }.isInstanceOf().all { + hasMessage("Unable to connect") + cause().isNotNull().isInstanceOf() + } } @Test @@ -249,8 +250,9 @@ class RealImapStoreTest { } imapStore.enqueueImapConnection(imapConnection) - assertThat { imapStore.getFolders() }.isFailure() - .isInstanceOf(MessagingException::class) + assertFailure { + imapStore.getFolders() + }.isInstanceOf() verify(imapConnection).close() } diff --git a/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3ConnectionTest.kt b/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3ConnectionTest.kt index 397745e3cc4..db1f483500e 100644 --- a/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3ConnectionTest.kt +++ b/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3ConnectionTest.kt @@ -1,9 +1,8 @@ package com.fsck.k9.mail.store.pop3 -import assertk.assertThat +import assertk.assertFailure import assertk.assertions.hasMessage import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import assertk.assertions.prop import com.fsck.k9.mail.AuthType @@ -162,10 +161,9 @@ class Pop3ConnectionTest { } val settings = server.createSettings(authType = PLAIN) - assertThat { + assertFailure { createAndOpenPop3Connection(settings) - }.isFailure() - .isInstanceOf(AuthenticationFailedException::class) + }.isInstanceOf() server.verifyInteractionCompleted() } @@ -197,10 +195,9 @@ class Pop3ConnectionTest { } val settings = server.createSettings(authType = PLAIN) - assertThat { + assertFailure { createAndOpenPop3Connection(settings) - }.isFailure() - .isInstanceOf(AuthenticationFailedException::class) + }.isInstanceOf() server.verifyInteractionCompleted() } @@ -233,10 +230,9 @@ class Pop3ConnectionTest { } val settings = server.createSettings(authType = CRAM_MD5) - assertThat { + assertFailure { createAndOpenPop3Connection(settings) - }.isFailure() - .isInstanceOf(AuthenticationFailedException::class) + }.isInstanceOf() server.verifyInteractionCompleted() } @@ -273,10 +269,9 @@ class Pop3ConnectionTest { } val settings = server.createSettings(authType = CRAM_MD5) - assertThat { + assertFailure { createAndOpenPop3Connection(settings) - }.isFailure() - .isInstanceOf(AuthenticationFailedException::class) + }.isInstanceOf() server.verifyInteractionCompleted() } @@ -303,10 +298,9 @@ class Pop3ConnectionTest { } val settings = server.createSettings(authType = EXTERNAL) - assertThat { + assertFailure { createAndOpenPop3Connection(settings) - }.isFailure() - .isInstanceOf(CertificateValidationException::class.java) + }.isInstanceOf() .prop(CertificateValidationException::getReason) .isEqualTo(CertificateValidationException.Reason.MissingCapability) @@ -323,10 +317,9 @@ class Pop3ConnectionTest { } val settings = server.createSettings(authType = EXTERNAL) - assertThat { + assertFailure { createAndOpenPop3Connection(settings) - }.isFailure() - .isInstanceOf(CertificateValidationException::class.java) + }.isInstanceOf() .hasMessage("POP3 client certificate authentication failed: -ERR Invalid certificate") server.verifyInteractionCompleted() diff --git a/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpResponseParserTest.kt b/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpResponseParserTest.kt index 91c82341f6a..b81d8172ee8 100644 --- a/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpResponseParserTest.kt +++ b/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpResponseParserTest.kt @@ -1,6 +1,7 @@ package com.fsck.k9.mail.transport.smtp import assertk.all +import assertk.assertFailure import assertk.assertThat import assertk.assertions.containsExactly import assertk.assertions.containsExactlyInAnyOrder @@ -8,7 +9,6 @@ import assertk.assertions.hasMessage import assertk.assertions.hasSize import assertk.assertions.isEmpty import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isFalse import assertk.assertions.isInstanceOf import assertk.assertions.isNotNull @@ -69,7 +69,7 @@ class SmtpResponseParserTest { val response = parser.readHelloResponse() - assertThat(response).isInstanceOf(SmtpHelloResponse.Hello::class).all { + assertThat(response).isInstanceOf().all { prop(SmtpHelloResponse.Hello::response) .transform { it.toLogString(false, "") }.isEqualTo(input) prop(SmtpHelloResponse.Hello::keywords).all { @@ -98,7 +98,7 @@ class SmtpResponseParserTest { val response = parser.readHelloResponse() - assertThat(response).isInstanceOf(SmtpHelloResponse.Hello::class).all { + assertThat(response).isInstanceOf().all { prop(SmtpHelloResponse.Hello::response).all { prop(SmtpResponse::replyCode).isEqualTo(250) prop(SmtpResponse::texts).containsExactly("smtp.domain.example") @@ -114,7 +114,7 @@ class SmtpResponseParserTest { val response = parser.readHelloResponse() - assertThat(response).isInstanceOf(SmtpHelloResponse.Error::class) + assertThat(response).isInstanceOf() .prop(SmtpHelloResponse.Error::response).all { prop(SmtpResponse::replyCode).isEqualTo(421) prop(SmtpResponse::texts).containsExactly("Service not available") @@ -126,10 +126,9 @@ class SmtpResponseParserTest { val input = "250".toPeekableInputStream() val parser = SmtpResponseParser(logger, input) - assertThat { + assertFailure { parser.readHelloResponse() - }.isFailure() - .isInstanceOf(SmtpResponseParserException::class) + }.isInstanceOf() .hasMessage("Unexpected character: (13)") assertThat(logger.logEntries).containsExactly( @@ -151,10 +150,9 @@ class SmtpResponseParserTest { """.toPeekableInputStream() val parser = SmtpResponseParser(logger, input) - assertThat { + assertFailure { parser.readHelloResponse() - }.isFailure() - .isInstanceOf(SmtpResponseParserException::class) + }.isInstanceOf() .hasMessage("Multi-line response with reply codes not matching: 250 != 220") assertThat(logger.logEntries).containsExactly( @@ -185,7 +183,7 @@ class SmtpResponseParserTest { val response = parser.readHelloResponse() - assertThat(response).isInstanceOf(SmtpHelloResponse.Hello::class) + assertThat(response).isInstanceOf() .prop(SmtpHelloResponse.Hello::keywords).transform { it.keys }.containsExactlyInAnyOrder( "SIZE", "8BITMIME", @@ -215,7 +213,7 @@ class SmtpResponseParserTest { val response = parser.readHelloResponse() - assertThat(response).isInstanceOf(SmtpHelloResponse.Hello::class) + assertThat(response).isInstanceOf() .transform { it.keywords.keys }.isEmpty() assertThat(logger.logEntries).isNotNull().hasSize(1) @@ -234,7 +232,7 @@ class SmtpResponseParserTest { val response = parser.readHelloResponse() - assertThat(response).isInstanceOf(SmtpHelloResponse.Hello::class) + assertThat(response).isInstanceOf() .transform { it.keywords.keys }.containsExactlyInAnyOrder("8BITMIME") assertThat(logger.logEntries).hasSize(1) @@ -253,10 +251,9 @@ class SmtpResponseParserTest { val parser = SmtpResponseParser(logger, input) parser.readGreeting() - assertThat { + assertFailure { parser.readHelloResponse() - }.isFailure() - .isInstanceOf(SmtpResponseParserException::class) + }.isInstanceOf() .hasMessage("Unexpected character: I (73)") assertThat(logger.logEntries).containsExactly( @@ -441,10 +438,9 @@ class SmtpResponseParserTest { """.toPeekableInputStream() val parser = SmtpResponseParser(logger, input) - assertThat { + assertFailure { parser.readResponse(enhancedStatusCodes = false) - }.isFailure() - .isInstanceOf(SmtpResponseParserException::class) + }.isInstanceOf() .hasMessage("Multi-line response with reply codes not matching: 200 != 500") assertThat(logger.logEntries).containsExactly( @@ -468,10 +464,9 @@ class SmtpResponseParserTest { val logger = TestSmtpLogger(isRawProtocolLoggingEnabled = false) val parser = SmtpResponseParser(logger, input) - assertThat { + assertFailure { parser.readResponse(enhancedStatusCodes = false) - }.isFailure() - .isInstanceOf(SmtpResponseParserException::class) + }.isInstanceOf() .hasMessage("Multi-line response with reply codes not matching: 200 != 500") assertThat(logger.logEntries).isEmpty() } @@ -481,10 +476,9 @@ class SmtpResponseParserTest { val input = "611".toPeekableInputStream() val parser = SmtpResponseParser(logger, input) - assertThat { + assertFailure { parser.readResponse(enhancedStatusCodes = false) - }.isFailure() - .isInstanceOf(SmtpResponseParserException::class) + }.isInstanceOf() .hasMessage("Unsupported 1st reply code digit: 6") } @@ -508,10 +502,9 @@ class SmtpResponseParserTest { val input = "20x".toPeekableInputStream() val parser = SmtpResponseParser(logger, input) - assertThat { + assertFailure { parser.readResponse(enhancedStatusCodes = false) - }.isFailure() - .isInstanceOf(SmtpResponseParserException::class) + }.isInstanceOf() .hasMessage("Unexpected character: x (120)") assertThat(logger.logEntries).containsExactly( @@ -530,10 +523,9 @@ class SmtpResponseParserTest { val input = PeekableInputStream("200".byteInputStream()) val parser = SmtpResponseParser(logger, input) - assertThat { + assertFailure { parser.readResponse(enhancedStatusCodes = false) - }.isFailure() - .isInstanceOf(SmtpResponseParserException::class) + }.isInstanceOf() .hasMessage("Unexpected end of stream") assertThat(logger.logEntries).containsExactly( @@ -552,10 +544,9 @@ class SmtpResponseParserTest { val input = PeekableInputStream("200\r".byteInputStream()) val parser = SmtpResponseParser(logger, input) - assertThat { + assertFailure { parser.readResponse(enhancedStatusCodes = false) - }.isFailure() - .isInstanceOf(SmtpResponseParserException::class) + }.isInstanceOf() .hasMessage("Unexpected end of stream") } @@ -564,10 +555,9 @@ class SmtpResponseParserTest { val input = PeekableInputStream("200\n".byteInputStream()) val parser = SmtpResponseParser(logger, input) - assertThat { + assertFailure { parser.readResponse(enhancedStatusCodes = false) - }.isFailure() - .isInstanceOf(SmtpResponseParserException::class) + }.isInstanceOf() .hasMessage("Unexpected character: (10)") assertThat(logger.logEntries).containsExactly( @@ -694,10 +684,9 @@ class SmtpResponseParserTest { """.toPeekableInputStream() val parser = SmtpResponseParser(logger, input) - assertThat { + assertFailure { parser.readResponse(enhancedStatusCodes = true) - }.isFailure() - .isInstanceOf(SmtpResponseParserException::class) + }.isInstanceOf() .hasMessage( "Multi-line response with enhanced status codes not matching: " + "EnhancedStatusCode(statusClass=PERMANENT_FAILURE, subject=2, detail=1) != null", diff --git a/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpTransportTest.kt b/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpTransportTest.kt index 5d35e5bdb5c..29d199c649d 100644 --- a/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpTransportTest.kt +++ b/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpTransportTest.kt @@ -1,10 +1,9 @@ package com.fsck.k9.mail.transport.smtp import assertk.all -import assertk.assertThat +import assertk.assertFailure import assertk.assertions.hasMessage import assertk.assertions.isEqualTo -import assertk.assertions.isFailure import assertk.assertions.isInstanceOf import assertk.assertions.isTrue import assertk.assertions.prop @@ -122,10 +121,9 @@ class SmtpTransportTest { } val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.PLAIN) - assertThat { + assertFailure { transport.open() - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Authentication methods SASL PLAIN and LOGIN are unavailable.") server.verifyConnectionClosed() @@ -164,10 +162,9 @@ class SmtpTransportTest { } val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.CRAM_MD5) - assertThat { + assertFailure { transport.open() - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Authentication method CRAM-MD5 is unavailable.") server.verifyConnectionClosed() @@ -245,10 +242,9 @@ class SmtpTransportTest { } val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.XOAUTH2) - assertThat { + assertFailure { transport.open() - }.isFailure() - .isInstanceOf(AuthenticationFailedException::class) + }.isInstanceOf() .hasMessage( "5.7.1 Username and Password not accepted. Learn more at " + "5.7.1 http://support.google.com/mail/bin/answer.py?answer=14257 hx9sm5317360pbc.68", @@ -369,10 +365,9 @@ class SmtpTransportTest { val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.XOAUTH2) - assertThat { + assertFailure { transport.open() - }.isFailure() - .isInstanceOf(AuthenticationFailedException::class) + }.isInstanceOf() .hasMessage( "5.7.1 Username and Password not accepted. Learn more at " + "5.7.1 http://support.google.com/mail/bin/answer.py?answer=14257 hx9sm5317360pbc.68", @@ -397,10 +392,9 @@ class SmtpTransportTest { } val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.XOAUTH2) - assertThat { + assertFailure { transport.open() - }.isFailure() - .isInstanceOf(AuthenticationFailedException::class) + }.isInstanceOf() .hasMessage("Failed to fetch token") server.verifyConnectionClosed() @@ -419,10 +413,9 @@ class SmtpTransportTest { } val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.XOAUTH2) - assertThat { + assertFailure { transport.open() - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Server doesn't support SASL OAUTHBEARER or XOAUTH2.") server.verifyConnectionClosed() @@ -459,10 +452,9 @@ class SmtpTransportTest { } val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.EXTERNAL) - assertThat { + assertFailure { transport.open() - }.isFailure() - .isInstanceOf(CertificateValidationException::class) + }.isInstanceOf() .prop(CertificateValidationException::getReason) .isEqualTo(CertificateValidationException.Reason.MissingCapability) @@ -509,10 +501,9 @@ class SmtpTransportTest { connectionSecurity = ConnectionSecurity.NONE, ) - assertThat { + assertFailure { transport.open() - }.isFailure() - .isInstanceOf(MessagingException::class) + }.isInstanceOf() .hasMessage("Update your outgoing server authentication setting. AUTOMATIC authentication is unavailable.") server.verifyConnectionClosed() @@ -553,10 +544,9 @@ class SmtpTransportTest { server.output("221 BYE") val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.XOAUTH2) - assertThat { + assertFailure { transport.open() - }.isFailure() - .isInstanceOf(AuthenticationFailedException::class) + }.isInstanceOf() .hasMessage( "Username and Password not accepted. " + "Learn more at http://support.google.com/mail/bin/answer.py?answer=14257 hx9sm5317360pbc.68", @@ -718,13 +708,12 @@ class SmtpTransportTest { val server = createServerAndSetupForPlainAuthentication("SIZE 1000") val transport = startServerAndCreateSmtpTransport(server) - assertThat { + assertFailure { transport.sendMessage(message) - }.isFailure() - .isInstanceOf(MessagingException::class).all { - hasMessage("Message too large for server") - transform { it.isPermanentFailure }.isTrue() - } + }.isInstanceOf().all { + hasMessage("Message too large for server") + transform { it.isPermanentFailure }.isTrue() + } // FIXME: Make sure connection was closed // server.verifyConnectionClosed(); @@ -749,13 +738,12 @@ class SmtpTransportTest { } val transport = startServerAndCreateSmtpTransport(server) - assertThat { + assertFailure { transport.sendMessage(message) - }.isFailure() - .isInstanceOf(NegativeSmtpReplyException::class).all { - prop(NegativeSmtpReplyException::replyCode).isEqualTo(421) - prop(NegativeSmtpReplyException::replyText).isEqualTo("4.7.0 Temporary system problem") - } + }.isInstanceOf().all { + prop(NegativeSmtpReplyException::replyCode).isEqualTo(421) + prop(NegativeSmtpReplyException::replyText).isEqualTo("4.7.0 Temporary system problem") + } server.verifyConnectionClosed() server.verifyInteractionCompleted() @@ -825,14 +813,13 @@ class SmtpTransportTest { } val transport = startServerAndCreateSmtpTransport(server) - assertThat { + assertFailure { transport.sendMessage(message) - }.isFailure() - .isInstanceOf(NegativeSmtpReplyException::class).all { - prop(NegativeSmtpReplyException::replyCode).isEqualTo(550) - prop(NegativeSmtpReplyException::replyText) - .isEqualTo("remote mail to not allowed") - } + }.isInstanceOf().all { + prop(NegativeSmtpReplyException::replyCode).isEqualTo(550) + prop(NegativeSmtpReplyException::replyText) + .isEqualTo("remote mail to not allowed") + } server.verifyConnectionClosed() server.verifyInteractionCompleted() @@ -851,14 +838,13 @@ class SmtpTransportTest { server.closeConnection() val transport = startServerAndCreateSmtpTransport(server) - assertThat { + assertFailure { transport.sendMessage(message) - }.isFailure() - .isInstanceOf(NegativeSmtpReplyException::class).all { - prop(NegativeSmtpReplyException::replyCode).isEqualTo(550) - prop(NegativeSmtpReplyException::replyText) - .isEqualTo("remote mail to not allowed") - } + }.isInstanceOf().all { + prop(NegativeSmtpReplyException::replyCode).isEqualTo(550) + prop(NegativeSmtpReplyException::replyText) + .isEqualTo("remote mail to not allowed") + } server.verifyConnectionClosed() server.verifyInteractionCompleted() @@ -880,14 +866,13 @@ class SmtpTransportTest { } val transport = startServerAndCreateSmtpTransport(server) - assertThat { + assertFailure { transport.sendMessage(message) - }.isFailure() - .isInstanceOf(NegativeSmtpReplyException::class).all { - prop(NegativeSmtpReplyException::replyCode).isEqualTo(550) - prop(NegativeSmtpReplyException::replyText) - .isEqualTo("remote mail to not allowed") - } + }.isInstanceOf().all { + prop(NegativeSmtpReplyException::replyCode).isEqualTo(550) + prop(NegativeSmtpReplyException::replyText) + .isEqualTo("remote mail to not allowed") + } server.verifyConnectionClosed() server.verifyInteractionCompleted() @@ -909,14 +894,13 @@ class SmtpTransportTest { } val transport = startServerAndCreateSmtpTransport(server) - assertThat { + assertFailure { transport.sendMessage(message) - }.isFailure() - .isInstanceOf(NegativeSmtpReplyException::class).all { - prop(NegativeSmtpReplyException::replyCode).isEqualTo(550) - prop(NegativeSmtpReplyException::replyText) - .isEqualTo("remote mail to not allowed") - } + }.isInstanceOf().all { + prop(NegativeSmtpReplyException::replyCode).isEqualTo(550) + prop(NegativeSmtpReplyException::replyText) + .isEqualTo("remote mail to not allowed") + } server.verifyConnectionClosed() server.verifyInteractionCompleted()