Update AssertJ to 3.26.0

gradle/libs.versions.toml

@@ -1,7 +1,7 @@
 [versions]
 apache-commons-collections = "4.4"
 apache-commons-io = "2.16.0"
-assertJ = "3.20.2" # Upgrading leads to SAM errors: https://youtrack.jetbrains.com/issue/KT-17765
+assertJ = "3.26.0"
 # match with <root>/settings.gradle.kts
 awsSdk = "2.25.33"
 commonmark = "0.17.1"

plugins/core/core/tst/software/aws/toolkits/core/utils/test/AssertJAsserts.kt

@@ -3,18 +3,27 @@
 
 package software.aws.toolkits.core.utils.test
 
-import org.assertj.core.api.IterableAssert
+import org.assertj.core.api.AbstractIterableAssert
+import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.ListAssert
 import org.assertj.core.api.ObjectAssert
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.attribute.PosixFilePermissions
 
 @Suppress("UNCHECKED_CAST")
 val <T : Any> ObjectAssert<T?>.notNull: ObjectAssert<T>
     get() = this.isNotNull as ObjectAssert<T>
 
 @Suppress("UNCHECKED_CAST")
-inline fun <reified SubType : Any> IterableAssert<*>.hasOnlyElementsOfType(): IterableAssert<SubType> =
-    hasOnlyElementsOfType(SubType::class.java) as IterableAssert<SubType>
+inline fun <reified SubType : Any> AbstractIterableAssert<*, *, *, *>.hasOnlyElementsOfTypeKt() =
+    hasOnlyElementsOfType(SubType::class.java) as AbstractIterableAssert<*, Iterable<SubType>, SubType, *>
 
 @Suppress("UNCHECKED_CAST")
 inline fun <reified SubType : Any> ListAssert<*>.hasOnlyOneElementOfType(): ObjectAssert<SubType> =
     (hasOnlyElementsOfType(SubType::class.java) as ListAssert<SubType>).singleElement()
+
+fun assertPosixPermissions(path: Path, expected: String) {
+    val perms = PosixFilePermissions.toString(Files.getPosixFilePermissions(path))
+    assertThat(perms).isEqualTo(expected)
+}

plugins/core/jetbrains-community/tst/software/aws/toolkits/jetbrains/core/credentials/DefaultAwsConnectionManagerTest.kt

@@ -26,6 +26,7 @@ import software.aws.toolkits.jetbrains.core.region.getDefaultRegion
 import software.aws.toolkits.jetbrains.services.sts.StsResources
 import software.aws.toolkits.jetbrains.utils.deserializeState
 import software.aws.toolkits.jetbrains.utils.rules.HeavyJavaCodeInsightTestFixtureRule
+import software.aws.toolkits.jetbrains.utils.satisfiesKt
 import software.aws.toolkits.jetbrains.utils.serializeState
 import java.nio.file.Files
 import java.util.concurrent.CompletableFuture
@@ -89,7 +90,7 @@ class DefaultAwsConnectionManagerTest {
         manager.noStateLoaded()
         manager.waitUntilConnectionStateIsStable()
 
-        assertThat(manager.selectedCredentialIdentifier).notNull.satisfies {
+        assertThat(manager.selectedCredentialIdentifier).notNull.satisfiesKt {
             assertThat(it.id).isEqualTo(credentials.id)
         }
     }
@@ -112,7 +113,7 @@ class DefaultAwsConnectionManagerTest {
 
         manager.waitUntilConnectionStateIsStable()
 
-        assertThat(manager.selectedRegion).notNull.satisfies {
+        assertThat(manager.selectedRegion).notNull.satisfiesKt {
             assertThat(it.id).isEqualTo("us-west-2")
         }
     }

plugins/core/jetbrains-community/tst/software/aws/toolkits/jetbrains/core/credentials/DefaultConfigFilesFacadeTest.kt

@@ -4,18 +4,16 @@
 package software.aws.toolkits.jetbrains.core.credentials
 
 import org.assertj.core.api.Assertions.assertThat
-import org.assertj.core.api.IterableAssert
 import org.junit.Assume
 import org.junit.Rule
 import org.junit.Test
 import org.junit.rules.TemporaryFolder
 import software.amazon.awssdk.profiles.Profile
 import software.aws.toolkits.core.utils.createParentDirectories
+import software.aws.toolkits.core.utils.test.assertPosixPermissions
 import software.aws.toolkits.core.utils.writeText
-import java.nio.file.Files
+import software.aws.toolkits.jetbrains.utils.satisfiesKt
 import java.nio.file.Paths
-import java.nio.file.attribute.PosixFilePermission
-import java.nio.file.attribute.PosixFilePermissions
 
 class DefaultConfigFilesFacadeTest {
 
@@ -33,8 +31,8 @@ class DefaultConfigFilesFacadeTest {
         assertThat(file).exists().hasContent(DefaultConfigFilesFacade.TEMPLATE)
 
         assumeNoException<UnsupportedOperationException> {
-            assertThat(Files.getPosixFilePermissions(file)).matches("rw-------")
-            assertThat(Files.getPosixFilePermissions(file.parent)).matches("rwxr-xr-x")
+            assertPosixPermissions(file, "rw-------")
+            assertPosixPermissions(file.parent, "rwxr-xr-x")
         }
     }
 
@@ -50,8 +48,8 @@ class DefaultConfigFilesFacadeTest {
         sut.createConfigFile()
 
         assumeNoException<UnsupportedOperationException> {
-            assertThat(Files.getPosixFilePermissions(file)).matches("rw-------")
-            assertThat(Files.getPosixFilePermissions(file.parent)).matches("rwxrwxrwx")
+            assertPosixPermissions(file, "rw-------")
+            assertPosixPermissions(file.parent, "rwxrwxrwx")
         }
     }
 
@@ -106,7 +104,7 @@ class DefaultConfigFilesFacadeTest {
 
         assertThat(sut.readAllProfiles())
             .hasSize(1)
-            .satisfies {
+            .satisfiesKt {
                 val entry = it.entries.first()
                 assertThat(entry.key).isEqualTo("profileName")
                 assertThat(entry.value).isEqualTo(
@@ -596,10 +594,6 @@ class DefaultConfigFilesFacadeTest {
         )
     }
 
-    private fun IterableAssert<PosixFilePermission>.matches(permissionString: String) {
-        containsOnly(*PosixFilePermissions.fromString(permissionString).toTypedArray())
-    }
-
     private inline fun <reified T> assumeNoException(block: () -> Unit) {
         try {
             block()

plugins/core/jetbrains-community/tst/software/aws/toolkits/jetbrains/core/credentials/DefaultToolkitAuthManagerTest.kt

@@ -31,6 +31,7 @@ import software.aws.toolkits.jetbrains.core.credentials.sso.bearer.InteractiveBe
 import software.aws.toolkits.jetbrains.core.region.MockRegionProviderRule
 import software.aws.toolkits.jetbrains.utils.isInstanceOf
 import software.aws.toolkits.jetbrains.utils.isInstanceOfSatisfying
+import software.aws.toolkits.jetbrains.utils.satisfiesKt
 
 class DefaultToolkitAuthManagerTest {
     @JvmField
@@ -90,7 +91,7 @@ class DefaultToolkitAuthManagerTest {
         )
         sut.createConnection(profile)
 
-        assertThat(sut.state?.ssoProfiles).satisfies { profiles ->
+        assertThat(sut.state?.ssoProfiles).satisfiesKt { profiles ->
             assertThat(profiles).isNotNull()
             assertThat(profiles).singleElement().isEqualTo(profile)
         }
@@ -110,7 +111,7 @@ class DefaultToolkitAuthManagerTest {
             )
         )
 
-        assertThat(sut.listConnections()).singleElement().satisfies {
+        assertThat(sut.listConnections()).singleElement().satisfiesKt {
             assertThat(it).isInstanceOfSatisfying<ManagedBearerSsoConnection> { connection ->
                 assertThat(connection.sessionName).isEqualTo("")
                 assertThat(connection.region).isEqualTo(profile.ssoRegion)
@@ -138,7 +139,7 @@ class DefaultToolkitAuthManagerTest {
             )
         )
 
-        assertThat(sut.listConnections()).singleElement().satisfies {
+        assertThat(sut.listConnections()).singleElement().satisfiesKt {
             assertThat(it).isInstanceOfSatisfying<ManagedBearerSsoConnection> { connection ->
                 assertThat(connection.sessionName).isEqualTo("")
                 assertThat(connection.region).isEqualTo(profile.ssoRegion)
@@ -164,7 +165,7 @@ class DefaultToolkitAuthManagerTest {
             )
         )
 
-        assertThat(sut.listConnections()).singleElement().satisfies {
+        assertThat(sut.listConnections()).singleElement().satisfiesKt {
             assertThat(it).isInstanceOfSatisfying<ManagedBearerSsoConnection> { connection ->
                 assertThat(connection.sessionName).isEqualTo("add")
                 assertThat(connection.region).isEqualTo("us-east-1")
@@ -182,7 +183,7 @@ class DefaultToolkitAuthManagerTest {
             )
         )
 
-        assertThat(sut.listConnections()).singleElement().satisfies {
+        assertThat(sut.listConnections()).singleElement().satisfiesKt {
             assertThat(it).isInstanceOfSatisfying<ManagedBearerSsoConnection> { connection ->
                 assertThat(connection.sessionName).isEqualTo("add")
                 assertThat(connection.region).isEqualTo("us-east-1")
@@ -332,7 +333,7 @@ class DefaultToolkitAuthManagerTest {
             val newScopes = listOf("existing1", "new1")
             loginSso(projectRule.project, "foo", "us-east-1", newScopes)
 
-            assertThat(connectionManager.activeConnection() as AwsBearerTokenConnection).satisfies { connection ->
+            assertThat(connectionManager.activeConnection() as AwsBearerTokenConnection).satisfiesKt { connection ->
                 assertThat(connection.scopes.toSet()).isEqualTo(setOf("existing1", "existing2", "existing3", "new1"))
             }
             assertThat(sut.listConnections()).singleElement().isInstanceOfSatisfying<AwsBearerTokenConnection> { connection ->

plugins/core/jetbrains-community/tst/software/aws/toolkits/jetbrains/core/credentials/sso/DiskCacheTest.kt

@@ -12,6 +12,7 @@ import org.junit.jupiter.api.condition.DisabledOnOs
 import org.junit.jupiter.api.condition.OS
 import org.junit.jupiter.api.io.TempDir
 import software.aws.toolkits.core.utils.readText
+import software.aws.toolkits.core.utils.test.assertPosixPermissions
 import software.aws.toolkits.core.utils.writeText
 import java.nio.file.Files
 import java.nio.file.Path
@@ -709,9 +710,4 @@ class DiskCacheTest {
             .usingRecursiveComparison()
             .isEqualTo(sut.loadAccessToken(key2))
     }
-
-    private fun assertPosixPermissions(path: Path, expected: String) {
-        val perms = PosixFilePermissions.toString(Files.getPosixFilePermissions(path))
-        assertThat(perms).isEqualTo(expected)
-    }
 }

plugins/core/jetbrains-community/tst/software/aws/toolkits/jetbrains/core/gettingstarted/IdcRolePopupTest.kt

@@ -21,6 +21,7 @@ import software.aws.toolkits.core.utils.test.aString
 import software.aws.toolkits.jetbrains.core.MockClientManagerExtension
 import software.aws.toolkits.jetbrains.core.credentials.ConfigFilesFacade
 import software.aws.toolkits.jetbrains.core.region.MockRegionProviderExtension
+import software.aws.toolkits.jetbrains.utils.satisfiesKt
 import software.aws.toolkits.resources.message
 
 @ExtendWith(MockKExtension::class)
@@ -53,7 +54,7 @@ class IdcRolePopupTest {
                 }
             }
 
-            assertThat(validation).singleElement().satisfies {
+            assertThat(validation).singleElement().satisfiesKt {
                 assertThat(it.okEnabled).isFalse()
                 assertThat(it.message).contains(message("gettingstarted.setup.error.not_selected"))
             }

plugins/core/jetbrains-community/tst/software/aws/toolkits/jetbrains/core/gettingstarted/SetupAuthenticationDialogTest.kt

@@ -37,6 +37,7 @@ import software.aws.toolkits.jetbrains.core.credentials.sono.SONO_REGION
 import software.aws.toolkits.jetbrains.core.credentials.sono.SONO_URL
 import software.aws.toolkits.jetbrains.core.gettingstarted.editor.SourceOfEntry
 import software.aws.toolkits.jetbrains.core.region.MockRegionProviderExtension
+import software.aws.toolkits.jetbrains.utils.satisfiesKt
 import software.aws.toolkits.resources.message
 import software.aws.toolkits.telemetry.FeatureId
 
@@ -212,7 +213,7 @@ class SetupAuthenticationDialogTest {
                 }
             }
 
-            assertThat(validation).satisfies {
+            assertThat(validation).satisfiesKt {
                 assertThat(it).hasSize(2)
                 assertThat(it).allSatisfy { error ->
                     assertThat(error.message).contains("Must not be empty")
@@ -266,7 +267,7 @@ class SetupAuthenticationDialogTest {
                 }
             }
 
-            assertThat(validation).satisfies {
+            assertThat(validation).satisfiesKt {
                 assertThat(it).hasSize(3)
                 assertThat(it).allSatisfy { error ->
                     assertThat(error.message).contains("Must not be empty")

plugins/core/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/telemetry/TelemetryServiceTest.kt

@@ -37,6 +37,7 @@ import software.aws.toolkits.jetbrains.core.credentials.waitUntilConnectionState
 import software.aws.toolkits.jetbrains.core.region.MockRegionProviderRule
 import software.aws.toolkits.jetbrains.services.sts.StsResources
 import software.aws.toolkits.jetbrains.settings.AwsSettings
+import software.aws.toolkits.jetbrains.utils.isInstanceOfSatisfying
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 
@@ -267,9 +268,11 @@ class TelemetryServiceTest {
     private fun assertMetricEventsContains(events: Collection<MetricEvent>, eventName: String, awsAccount: String, awsRegion: String) {
         assertThat(events).filteredOn { event ->
             event.data.any { it.name == eventName }
-        }.anySatisfy {
-            assertThat(it.awsAccount).isEqualTo(awsAccount)
-            assertThat(it.awsRegion).isEqualTo(awsRegion)
+        }.anySatisfy { element ->
+            assertThat(element).isInstanceOfSatisfying<MetricEvent> {
+                assertThat(it.awsAccount).isEqualTo(awsAccount)
+                assertThat(it.awsRegion).isEqualTo(awsRegion)
+            }
         }
     }
 }

plugins/core/jetbrains-community/tstFixtures/software/aws/toolkits/jetbrains/utils/AssertJMatchers.kt

@@ -4,6 +4,7 @@
 package software.aws.toolkits.jetbrains.utils
 
 import org.assertj.core.api.AbstractAssert
+import org.assertj.core.api.AbstractIterableAssert
 import org.assertj.core.api.AbstractThrowableAssert
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.CompletableFutureAssert
@@ -31,10 +32,23 @@ val <T> CompletionStage<T>.value get() = toCompletableFuture().get(TIMEOUT.toMil
 
 val <T> CompletableFutureAssert<T>.hasException get() = this.wait().isCompletedExceptionally
 
+// https://github.com/assertj/assertj/issues/2357
+@Suppress("UNCHECKED_CAST")
+fun <E : Any?, I : Iterable<E>> AbstractIterableAssert<*, I, E, *>.allSatisfyKt(requirements: Consumer<E>) =
+    allSatisfy(requirements) as AbstractIterableAssert<*, I, E, *>
+
+@Suppress("UNCHECKED_CAST")
+fun <E : Any?, I : Iterable<E>> AbstractIterableAssert<*, I, E, *>.anySatisfyKt(requirements: Consumer<E>) =
+    anySatisfy(requirements) as AbstractIterableAssert<*, I, E, *>
+
+@Suppress("UNCHECKED_CAST")
+fun <T : Any?> AbstractAssert<*, T>.satisfiesKt(requirements: Consumer<T>) =
+    satisfies(requirements) as AbstractAssert<*, T>
+
 fun <SELF : AbstractThrowableAssert<SELF, ACTUAL>, ACTUAL : Throwable> AbstractThrowableAssert<SELF, ACTUAL>.hasCauseWithMessage(
     message: String
 ): AbstractThrowableAssert<SELF, ACTUAL> {
-    satisfies { parentThrowable ->
+    satisfiesKt { parentThrowable ->
         assertThat(parentThrowable.cause).isNotNull.hasMessage(message)
     }
     return this

plugins/toolkit/jetbrains-core/it/software/aws/toolkits/jetbrains/core/credentials/sso/bearer/InteractiveBearerTokenProviderIntegrationTest.kt

@@ -21,6 +21,7 @@ import software.aws.toolkits.jetbrains.core.credentials.sso.DeviceGrantAccessTok
 import software.aws.toolkits.jetbrains.core.credentials.sso.DiskCache
 import software.aws.toolkits.jetbrains.utils.extensions.SsoLogin
 import software.aws.toolkits.jetbrains.utils.extensions.SsoLoginExtension
+import software.aws.toolkits.jetbrains.utils.satisfiesKt
 import java.nio.file.Path
 import java.time.Instant
 
@@ -74,7 +75,7 @@ class InteractiveBearerTokenProviderIntegrationTest {
             id = "test"
         )
 
-        assertThat(sut.resolveToken()).satisfies {
+        assertThat(sut.resolveToken()).satisfiesKt {
             assertThat(it).isNotNull()
             assertThat(it).isNotEqualTo(initialToken)
         }

plugins/toolkit/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/credentials/ConnectionSettingsMenuBuilderTest.kt

@@ -22,6 +22,7 @@ import software.aws.toolkits.jetbrains.core.credentials.ConnectionSettingsMenuBu
 import software.aws.toolkits.jetbrains.core.credentials.MockAwsConnectionManager.ProjectAccountSettingsManagerRule
 import software.aws.toolkits.jetbrains.core.region.AwsRegionProvider
 import software.aws.toolkits.jetbrains.core.region.MockRegionProviderRule
+import software.aws.toolkits.jetbrains.utils.satisfiesKt
 import software.aws.toolkits.resources.message
 
 class ConnectionSettingsMenuBuilderTest {
@@ -87,7 +88,7 @@ class ConnectionSettingsMenuBuilderTest {
             .build()
         val actions = group.getChildren().filterIsInstance<ActionGroup>()
 
-        assertThat(actions).singleElement().satisfies {
+        assertThat(actions).singleElement().satisfiesKt {
             assertThat(it.isPopup).isTrue
             assertThat(it.templatePresentation.text).isEqualTo(message("settings.partitions"))
             assertThat(it.getChildren()).hasSize(otherPartitions.size)

plugins/toolkit/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/credentials/metadataservice/ContainerCredentialProviderFactoryTest.kt

@@ -23,6 +23,7 @@ import software.aws.toolkits.core.credentials.CredentialType
 import software.aws.toolkits.core.credentials.CredentialsChangeEvent
 import software.aws.toolkits.core.credentials.CredentialsChangeListener
 import software.aws.toolkits.core.rules.SystemPropertyHelper
+import software.aws.toolkits.jetbrains.utils.satisfiesKt
 import java.time.Duration
 import java.time.Instant
 import java.time.format.DateTimeFormatter
@@ -66,7 +67,7 @@ class ContainerCredentialProviderFactoryTest {
         sut.setUp(profileLoadCallback)
 
         assertThat(credentialChangeEvent.allValues.size).isEqualTo(1)
-        assertThat(credentialChangeEvent.firstValue).satisfies {
+        assertThat(credentialChangeEvent.firstValue).satisfiesKt {
             assertThat(it.modified).isEmpty()
             assertThat(it.removed).isEmpty()
             assertThat(it.added).hasSize(1)
@@ -80,7 +81,7 @@ class ContainerCredentialProviderFactoryTest {
         sut.setUp(profileLoadCallback)
 
         assertThat(credentialChangeEvent.allValues.size).isEqualTo(1)
-        assertThat(credentialChangeEvent.firstValue).satisfies {
+        assertThat(credentialChangeEvent.firstValue).satisfiesKt {
             assertThat(it.modified).isEmpty()
             assertThat(it.removed).isEmpty()
             assertThat(it.added).hasSize(1)

plugins/toolkit/jetbrains-core/tst/software/aws/toolkits/jetbrains/core/credentials/metadataservice/InstanceRoleCredentialProviderFactoryTest.kt

@@ -26,6 +26,7 @@ import software.aws.toolkits.core.credentials.CredentialType
 import software.aws.toolkits.core.credentials.CredentialsChangeEvent
 import software.aws.toolkits.core.credentials.CredentialsChangeListener
 import software.aws.toolkits.core.rules.SystemPropertyHelper
+import software.aws.toolkits.jetbrains.utils.satisfiesKt
 import java.time.Duration
 import java.time.Instant
 import java.time.format.DateTimeFormatter
@@ -99,7 +100,7 @@ class InstanceRoleCredentialProviderFactoryTest {
         sut.setUp(profileLoadCallback)
 
         assertThat(credentialChangeEvent.allValues.size).isEqualTo(1)
-        assertThat(credentialChangeEvent.firstValue).satisfies {
+        assertThat(credentialChangeEvent.firstValue).satisfiesKt {
             assertThat(it.modified).isEmpty()
             assertThat(it.removed).isEmpty()
             assertThat(it.added).hasSize(1)