style: ban org.junit.Assert and org.junit.jupiter.api.Assertions

detekt-rules/src/software/aws/toolkits/gradle/detekt/rules/BannedImportsRule.kt

@@ -17,7 +17,7 @@ class BannedImportsRule : Rule() {
     override fun visitImportList(importList: KtImportList) {
         super.visitImportList(importList)
         importList.imports.forEach { element ->
-            val importedFqName = element.importedFqName?.asString()
+            val importedFqName = element.importedFqName?.asString() ?: return
             if (importedFqName == "org.assertj.core.api.Assertions") {
                 report(
                     CodeSmell(
@@ -28,7 +28,7 @@ class BannedImportsRule : Rule() {
                 )
             }
 
-            if (importedFqName?.startsWith("org.hamcrest") == true) {
+            if (importedFqName.startsWith("org.hamcrest")) {
                 report(
                     CodeSmell(
                         issue,
@@ -38,9 +38,7 @@ class BannedImportsRule : Rule() {
                 )
             }
 
-            if (importedFqName?.startsWith("kotlin.test.assert") == true &&
-                importedFqName.startsWith("kotlin.test.assertNotNull") == false
-            ) {
+            if (importedFqName.startsWith("kotlin.test.assert") && !importedFqName.startsWith("kotlin.test.assertNotNull")) {
                 report(
                     CodeSmell(
                         issue,
@@ -50,7 +48,17 @@ class BannedImportsRule : Rule() {
                 )
             }
 
-            if (importedFqName?.startsWith("org.gradle.internal.impldep") == true) {
+            if (importedFqName.startsWith("org.junit.jupiter.api.Assertions") || importedFqName.startsWith("org.junit.Assert")) {
+                report(
+                    CodeSmell(
+                        issue,
+                        Entity.from(element),
+                        message = "Use AssertJ instead of JUnit assertions"
+                    )
+                )
+            }
+
+            if (importedFqName.startsWith("org.gradle.internal.impldep")) {
                 report(
                     CodeSmell(
                         issue,
@@ -60,7 +68,7 @@ class BannedImportsRule : Rule() {
                 )
             }
 
-            if (importedFqName?.contains("kotlinx.coroutines.Dispatchers") == true) {
+            if (importedFqName.contains("kotlinx.coroutines.Dispatchers")) {
                 report(
                     CodeSmell(
                         issue,

plugins/amazonq/chat/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonqFeatureDev/FeatureDevSessionContextTest.kt

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import com.intellij.testFramework.RuleChain
-import org.junit.Assert.assertEquals
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
@@ -85,7 +85,11 @@ class FeatureDevSessionContextTest : FeatureDevTestBase(HeavyJavaCodeInsightTest
         fun addressablePathOf(path: String) = path.removePrefix(base).removePrefix("/")
 
         fileCases.forEach {
-            assertEquals(it.shouldInclude, zippedFiles.contains(addressablePathOf(it.path)))
+            if (it.shouldInclude) {
+                assertThat(zippedFiles).contains(addressablePathOf(it.path))
+            } else {
+                assertThat(zippedFiles).doesNotContain(addressablePathOf(it.path))
+            }
         }
     }
 

plugins/amazonq/chat/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonqFeatureDev/storage/ChatSessionStorageTest.kt

@@ -3,14 +3,13 @@
 
 package software.aws.toolkits.jetbrains.services.amazonqFeatureDev.storage
 
-import org.junit.Assert.assertEquals
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.Before
 import org.junit.Test
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.whenever
 import software.aws.toolkits.jetbrains.services.amazonqFeatureDev.FeatureDevTestBase
 import software.aws.toolkits.jetbrains.services.amazonqFeatureDev.session.Session
-import kotlin.test.assertNotNull
 
 class ChatSessionStorageTest : FeatureDevTestBase() {
 
@@ -27,9 +26,9 @@ class ChatSessionStorageTest : FeatureDevTestBase() {
     @Test
     fun `check getSession for NewSession`() {
         val testSession = chatSessionStorage.getSession("tabId", project)
-        assertNotNull(testSession)
-        assertEquals(testSession.tabID, "tabId")
-        assertEquals(testSession.project, project)
+        assertThat(testSession).isNotNull()
+        assertThat(testSession.tabID).isEqualTo("tabId")
+        assertThat(testSession.project).isEqualTo(project)
     }
 
     @Test
@@ -39,7 +38,7 @@ class ChatSessionStorageTest : FeatureDevTestBase() {
 
         val expectedSession = chatSessionStorage.getSession(mockSession.tabID, mockSession.project)
         val actualSession = chatSessionStorage.getSession("tab1", project)
-        assertNotNull(actualSession)
-        assertEquals(expectedSession, actualSession)
+        assertThat(actualSession).isNotNull()
+        assertThat(actualSession).isEqualTo(expectedSession)
     }
 }

plugins/amazonq/codetransform/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/codemodernizer/CodeTransformChatTest.kt

@@ -3,15 +3,13 @@
 
 package software.aws.toolkits.jetbrains.services.codemodernizer
 
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertNull
-import org.junit.Assert.fail
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.Test
 import software.aws.toolkits.jetbrains.services.codemodernizer.constants.buildTransformResultChatContent
 import software.aws.toolkits.jetbrains.services.codemodernizer.messages.CodeTransformButtonId
 import software.aws.toolkits.jetbrains.services.codemodernizer.model.CodeModernizerJobCompletedResult
 import software.aws.toolkits.jetbrains.services.codemodernizer.model.JobId
+import software.aws.toolkits.jetbrains.utils.satisfiesKt
 import software.aws.toolkits.resources.message
 
 class CodeTransformChatTest {
@@ -20,41 +18,49 @@ class CodeTransformChatTest {
     fun `test that transform result chat item includes view build log button and message when pre-build fails`() {
         val result = CodeModernizerJobCompletedResult.JobFailedInitialBuild(JobId("dummy-job-id-123"), "Build failed in Java 8 sandbox", true)
         val chatItem = buildTransformResultChatContent(result)
-        assertEquals(chatItem.message, message("codemodernizer.chat.message.result.fail_initial_build"))
-        assertNotNull(chatItem.buttons)
-        assertEquals(chatItem.buttons?.size ?: fail("buttons is null"), 1)
-        assertEquals(chatItem.buttons?.get(0)?.id ?: fail("buttons is null"), CodeTransformButtonId.ViewBuildLog.id)
+        assertThat(chatItem.message).isEqualTo(message("codemodernizer.chat.message.result.fail_initial_build"))
+        assertThat(chatItem.buttons)
+            .singleElement()
+            .satisfiesKt {
+                assertThat(it.id).isEqualTo(CodeTransformButtonId.ViewBuildLog.id)
+            }
     }
 
     @Test
     fun `test that transform result chat item includes view summary button and view diff button with correct label when job fully succeeded with 5 patch files`() {
         val result = CodeModernizerJobCompletedResult.JobCompletedSuccessfully(JobId("dummy-job-id-123"))
         val chatItem = buildTransformResultChatContent(result, 5)
-        assertEquals(chatItem.message, message("codemodernizer.chat.message.result.success.multiple_diffs"))
-        assertNotNull(chatItem.buttons)
-        assertEquals(chatItem.buttons?.size ?: fail("buttons is null"), 2)
-        assertEquals(chatItem.buttons?.get(0)?.id ?: fail("buttons is null"), CodeTransformButtonId.ViewDiff.id)
-        assertEquals(chatItem.buttons?.get(0)?.text ?: fail("buttons is null"), "View diff 1/5")
-        assertEquals(chatItem.buttons?.get(1)?.id ?: fail("buttons is null"), CodeTransformButtonId.ViewSummary.id)
+        assertThat(chatItem.message).isEqualTo(message("codemodernizer.chat.message.result.success.multiple_diffs"))
+        assertThat(chatItem.buttons)
+            .hasSize(2)
+            .satisfiesKt { buttons ->
+                assertThat(buttons[0].id).isEqualTo(CodeTransformButtonId.ViewDiff.id)
+                assertThat(buttons[0].text).isEqualTo("View diff 1/5")
+                assertThat(buttons[1].id).isEqualTo(CodeTransformButtonId.ViewSummary.id)
+            }
     }
 
     @Test
     fun `test that transform result chat item includes view summary button and view diff button with correct label when job partially succeeded with 1 patch file`() {
         val result = CodeModernizerJobCompletedResult.JobPartiallySucceeded(JobId("dummy-job-id-123"))
         val chatItem = buildTransformResultChatContent(result, 1)
-        assertEquals(chatItem.message, message("codemodernizer.chat.message.result.partially_success"))
-        assertNotNull(chatItem.buttons)
-        assertEquals(chatItem.buttons?.size ?: fail("buttons is null"), 2)
-        assertEquals(chatItem.buttons?.get(0)?.id ?: fail("buttons is null"), CodeTransformButtonId.ViewDiff.id)
-        assertEquals(chatItem.buttons?.get(0)?.text ?: fail("buttons is null"), "View diff")
-        assertEquals(chatItem.buttons?.get(1)?.id ?: fail("buttons is null"), CodeTransformButtonId.ViewSummary.id)
+        assertThat(chatItem.message).isEqualTo(message("codemodernizer.chat.message.result.partially_success"))
+
+        assertThat(chatItem.buttons)
+            .hasSize(2)
+            .satisfiesKt { buttons ->
+                assertThat(buttons[0].id).isEqualTo(CodeTransformButtonId.ViewDiff.id)
+                assertThat(buttons[0].text).isEqualTo("View diff")
+                assertThat(buttons[1].id).isEqualTo(CodeTransformButtonId.ViewSummary.id)
+            }
     }
 
     @Test
     fun `test that transform result chat item does not include any buttons when job failed with known reason`() {
         val result = CodeModernizerJobCompletedResult.JobFailed(JobId("dummy-job-id-123"), message("codemodernizer.file.invalid_pom_version"))
         val chatItem = buildTransformResultChatContent(result)
-        assertEquals(chatItem.message, message("codemodernizer.chat.message.result.fail_with_known_reason", result.failureReason))
-        assertNull(chatItem.buttons)
+
+        assertThat(chatItem.message).isEqualTo(message("codemodernizer.chat.message.result.fail_with_known_reason", result.failureReason))
+        assertThat(chatItem.buttons).isNull()
     }
 }

plugins/amazonq/codetransform/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/codemodernizer/CodeTransformHilDownloadArtifactTest.kt

@@ -5,11 +5,12 @@ package software.aws.toolkits.jetbrains.services.codemodernizer
 
 import com.intellij.testFramework.assertEqualsToFile
 import com.intellij.util.io.delete
-import org.junit.Assert.assertEquals
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.Before
 import org.junit.Test
 import software.aws.toolkits.jetbrains.services.codemodernizer.model.CodeTransformHilDownloadArtifact
 import software.aws.toolkits.jetbrains.utils.rules.HeavyJavaCodeInsightTestFixtureRule
+import software.aws.toolkits.jetbrains.utils.satisfiesKt
 import kotlin.io.path.createTempDirectory
 
 class CodeTransformHilDownloadArtifactTest : CodeWhispererCodeModernizerTestBase(HeavyJavaCodeInsightTestFixtureRule()) {
@@ -25,10 +26,12 @@ class CodeTransformHilDownloadArtifactTest : CodeWhispererCodeModernizerTestBase
         val hilDownloadArtifact = CodeTransformHilDownloadArtifact.create(testZipFilePath, outputFolder)
 
         // verify manifest file values
-        assertEquals(hilDownloadArtifact.manifest.pomArtifactId, "lombok")
-        assertEquals(hilDownloadArtifact.manifest.pomGroupId, "org.projectlombok")
-        assertEquals(hilDownloadArtifact.manifest.sourcePomVersion, "0.11.4")
-        assertEquals(hilDownloadArtifact.manifest.pomArtifactId, "lombok")
+        assertThat(hilDownloadArtifact.manifest).satisfiesKt {
+            assertThat(it.pomArtifactId).isEqualTo("lombok")
+            assertThat(it.pomGroupId).isEqualTo("org.projectlombok")
+            assertThat(it.sourcePomVersion).isEqualTo("0.11.4")
+            assertThat(it.pomArtifactId).isEqualTo("lombok")
+        }
 
         // verify pom file
         val testDownloadPomFile = "humanInTheLoop/pom.xml".toResourceFile().toPath()

plugins/amazonq/codetransform/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/codemodernizer/CodeTransformTelemetryTest.kt

@@ -4,8 +4,7 @@
 package software.aws.toolkits.jetbrains.services.codemodernizer
 
 import com.intellij.testFramework.LightVirtualFile
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNotEquals
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.Before
 import org.junit.Test
 import org.mockito.kotlin.doReturn
@@ -25,14 +24,16 @@ class CodeTransformTelemetryTest : CodeWhispererCodeModernizerTestBase(HeavyJava
     fun `SessionId updated on prepareForNewJobSubmission invoked`() {
         val originalSessionId = CodeTransformTelemetryState.instance.getSessionId()
         telemetryManagerSpy.prepareForNewJobSubmission()
-        assertNotEquals(originalSessionId, CodeTransformTelemetryState.instance.getSessionId())
+
+        assertThat(originalSessionId).isNotEqualTo(CodeTransformTelemetryState.instance.getSessionId())
     }
 
     @Test
     fun `ProjectId is reproducible`() {
         val projectId1 = telemetryManagerSpy.getProjectHash(validJDK8CustomerSelection)
         val projectId2 = telemetryManagerSpy.getProjectHash(validJDK8CustomerSelection)
-        assertEquals(projectId1, projectId2)
+
+        assertThat(projectId1).isEqualTo(projectId2)
     }
 
     @Test
@@ -42,6 +43,7 @@ class CodeTransformTelemetryTest : CodeWhispererCodeModernizerTestBase(HeavyJava
         doReturn(Path("/anotherpath/pom.xml")).whenever(emptyPomFileSpy2).toNioPath()
         val newCustomerSelection = validJDK8CustomerSelection.copy(configurationFile = emptyPomFileSpy2)
         val projectId2 = telemetryManagerSpy.getProjectHash(newCustomerSelection)
-        assertNotEquals(projectId1, projectId2)
+
+        assertThat(projectId1).isNotEqualTo(projectId2)
     }
 }