diff --git a/plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/textdocument/TextDocumentServiceHandler.kt b/plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/textdocument/TextDocumentServiceHandler.kt
index 80a63f3d953..49149863b67 100644
--- a/plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/textdocument/TextDocumentServiceHandler.kt
+++ b/plugins/amazonq/shared/jetbrains-community/src/software/aws/toolkits/jetbrains/services/amazonq/lsp/textdocument/TextDocumentServiceHandler.kt
@@ -52,6 +52,27 @@ class TextDocumentServiceHandler(
             FileDocumentManagerListener.TOPIC,
             this
         )
+
+        // open files on startup
+        val fileEditorManager = FileEditorManager.getInstance(project)
+        fileEditorManager.openFiles.forEach { file ->
+            handleFileOpened(file)
+        }
+    }
+
+    private fun handleFileOpened(file: VirtualFile) {
+        AmazonQLspService.executeIfRunning(project) { languageServer ->
+            toUriString(file)?.let { uri ->
+                languageServer.textDocumentService.didOpen(
+                    DidOpenTextDocumentParams().apply {
+                        textDocument = TextDocumentItem().apply {
+                            this.uri = uri
+                            text = file.inputStream.readAllBytes().decodeToString()
+                        }
+                    }
+                )
+            }
+        }
     }
 
     override fun beforeDocumentSaving(document: Document) {
@@ -99,18 +120,7 @@ class TextDocumentServiceHandler(
         source: FileEditorManager,
         file: VirtualFile,
     ) {
-        AmazonQLspService.executeIfRunning(project) { languageServer ->
-            toUriString(file)?.let { uri ->
-                languageServer.textDocumentService.didOpen(
-                    DidOpenTextDocumentParams().apply {
-                        textDocument = TextDocumentItem().apply {
-                            this.uri = uri
-                            text = file.inputStream.readAllBytes().decodeToString()
-                        }
-                    }
-                )
-            }
-        }
+        handleFileOpened(file)
     }
 
     override fun fileClosed(
diff --git a/plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/textdocument/TextDocumentServiceHandlerTest.kt b/plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/textdocument/TextDocumentServiceHandlerTest.kt
index 4e4df327f96..14ee9888473 100644
--- a/plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/textdocument/TextDocumentServiceHandlerTest.kt
+++ b/plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/textdocument/TextDocumentServiceHandlerTest.kt
@@ -9,6 +9,7 @@ import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.components.serviceIfCreated
 import com.intellij.openapi.editor.Document
 import com.intellij.openapi.fileEditor.FileDocumentManager
+import com.intellij.openapi.fileEditor.FileEditorManager
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.vfs.newvfs.events.VFileContentChangeEvent
@@ -24,13 +25,13 @@ import io.mockk.runs
 import io.mockk.slot
 import io.mockk.verify
 import kotlinx.coroutines.test.runTest
+import org.assertj.core.api.Assertions.assertThat
 import org.eclipse.lsp4j.DidChangeTextDocumentParams
 import org.eclipse.lsp4j.DidCloseTextDocumentParams
 import org.eclipse.lsp4j.DidOpenTextDocumentParams
 import org.eclipse.lsp4j.DidSaveTextDocumentParams
 import org.eclipse.lsp4j.jsonrpc.messages.ResponseMessage
 import org.eclipse.lsp4j.services.TextDocumentService
-import org.junit.Assert.assertEquals
 import org.junit.Before
 import org.junit.Test
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.AmazonQLanguageServer
@@ -43,6 +44,7 @@ import java.util.concurrent.CompletableFuture
 
 class TextDocumentServiceHandlerTest {
     private lateinit var project: Project
+    private lateinit var mockFileEditorManager: FileEditorManager
     private lateinit var mockLanguageServer: AmazonQLanguageServer
     private lateinit var mockTextDocumentService: TextDocumentService
     private lateinit var sut: TextDocumentServiceHandler
@@ -90,6 +92,11 @@ class TextDocumentServiceHandlerTest {
         every { messageBus.connect(any<Disposable>()) } returns mockConnection
         every { mockConnection.subscribe(any(), any()) } just runs
 
+        // Mock FileEditorManager
+        mockFileEditorManager = mockk<FileEditorManager>()
+        every { mockFileEditorManager.openFiles } returns emptyArray()
+        every { project.getService(FileEditorManager::class.java) } returns mockFileEditorManager
+
         sut = TextDocumentServiceHandler(project, mockk())
     }
 
@@ -120,12 +127,31 @@ class TextDocumentServiceHandlerTest {
             verify { mockTextDocumentService.didSave(capture(paramsSlot)) }
 
             with(paramsSlot.captured) {
-                assertEquals(normalizeFileUri(uri.toString()), textDocument.uri)
-                assertEquals("test content", text)
+                assertThat(textDocument.uri).isEqualTo(normalizeFileUri(uri.toString()))
+                assertThat(text).isEqualTo("test content")
             }
         }
     }
 
+    @Test
+    fun `didOpen runs on service init`() = runTest {
+        val uri = URI.create("file:///test/path/file.txt")
+        val content = "test content"
+        val file = createMockVirtualFile(uri, content)
+
+        every { mockFileEditorManager.openFiles } returns arrayOf(file)
+
+        sut = TextDocumentServiceHandler(project, mockk())
+
+        val paramsSlot = slot<DidOpenTextDocumentParams>()
+        verify { mockTextDocumentService.didOpen(capture(paramsSlot)) }
+
+        with(paramsSlot.captured.textDocument) {
+            assertThat(this.uri).isEqualTo(normalizeFileUri(uri.toString()))
+            assertThat(text).isEqualTo(content)
+        }
+    }
+
     @Test
     fun `didOpen runs on fileOpened`() = runTest {
         // Create test file
@@ -142,8 +168,8 @@ class TextDocumentServiceHandlerTest {
         verify { mockTextDocumentService.didOpen(capture(paramsSlot)) }
 
         with(paramsSlot.captured.textDocument) {
-            assertEquals(normalizeFileUri(uri.toString()), this.uri)
-            assertEquals(content, text)
+            assertThat(this.uri).isEqualTo(normalizeFileUri(uri.toString()))
+            assertThat(text).isEqualTo(content)
         }
     }
 
@@ -157,7 +183,7 @@ class TextDocumentServiceHandlerTest {
         val paramsSlot = slot<DidCloseTextDocumentParams>()
         verify { mockTextDocumentService.didClose(capture(paramsSlot)) }
 
-        assertEquals(normalizeFileUri(uri.toString()), paramsSlot.captured.textDocument.uri)
+        assertThat(paramsSlot.captured.textDocument.uri).isEqualTo(normalizeFileUri(uri.toString()))
     }
 
     @Test
@@ -191,9 +217,9 @@ class TextDocumentServiceHandlerTest {
         verify { mockTextDocumentService.didChange(capture(paramsSlot)) }
 
         with(paramsSlot.captured) {
-            assertEquals(normalizeFileUri(uri.toString()), textDocument.uri)
-            assertEquals(123, textDocument.version)
-            assertEquals("changed content", contentChanges[0].text)
+            assertThat(textDocument.uri).isEqualTo(normalizeFileUri(uri.toString()))
+            assertThat(textDocument.version).isEqualTo(123)
+            assertThat(contentChanges[0].text).isEqualTo("changed content")
         }
     }
 
diff --git a/plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/util/WorkspaceFolderUtilTest.kt b/plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/util/WorkspaceFolderUtilTest.kt
index c3e976b02f8..93dc0ae9bd6 100644
--- a/plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/util/WorkspaceFolderUtilTest.kt
+++ b/plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/util/WorkspaceFolderUtilTest.kt
@@ -8,7 +8,7 @@ import com.intellij.openapi.roots.ProjectRootManager
 import com.intellij.openapi.vfs.VirtualFile
 import io.mockk.every
 import io.mockk.mockk
-import org.junit.jupiter.api.Assertions.assertEquals
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
 import java.net.URI
 import java.nio.file.Path
@@ -22,7 +22,7 @@ class WorkspaceFolderUtilTest {
 
         val result = WorkspaceFolderUtil.createWorkspaceFolders(mockProject)
 
-        assertEquals(emptyList<VirtualFile>(), result)
+        assertThat(result).isEqualTo(emptyList<VirtualFile>())
     }
 
     @Test
@@ -44,11 +44,11 @@ class WorkspaceFolderUtilTest {
 
         val result = WorkspaceFolderUtil.createWorkspaceFolders(mockProject)
 
-        assertEquals(2, result.size)
-        assertEquals(normalizeFileUri("file:///path/to/root1"), result[0].uri)
-        assertEquals(normalizeFileUri("file:///path/to/root2"), result[1].uri)
-        assertEquals("root1", result[0].name)
-        assertEquals("root2", result[1].name)
+        assertThat(result).hasSize(2)
+        assertThat(result[0].uri).isEqualTo(normalizeFileUri("file:///path/to/root1"))
+        assertThat(result[1].uri).isEqualTo(normalizeFileUri("file:///path/to/root2"))
+        assertThat(result[0].name).isEqualTo("root1")
+        assertThat(result[1].name).isEqualTo("root2")
     }
 
     @Test
@@ -62,7 +62,7 @@ class WorkspaceFolderUtilTest {
 
         val result = WorkspaceFolderUtil.createWorkspaceFolders(mockProject)
 
-        assertEquals(emptyList<VirtualFile>(), result)
+        assertThat(result).isEqualTo(emptyList<VirtualFile>())
     }
 
     private fun createMockVirtualFile(uri: URI, name: String): VirtualFile {
diff --git a/plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/workspace/WorkspaceServiceHandlerTest.kt b/plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/workspace/WorkspaceServiceHandlerTest.kt
index 0435a5c167d..ef0adf1bf26 100644
--- a/plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/workspace/WorkspaceServiceHandlerTest.kt
+++ b/plugins/amazonq/shared/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/amazonq/lsp/workspace/WorkspaceServiceHandlerTest.kt
@@ -26,6 +26,7 @@ import io.mockk.runs
 import io.mockk.slot
 import io.mockk.verify
 import kotlinx.coroutines.test.runTest
+import org.assertj.core.api.Assertions.assertThat
 import org.eclipse.lsp4j.CreateFilesParams
 import org.eclipse.lsp4j.DeleteFilesParams
 import org.eclipse.lsp4j.DidChangeWatchedFilesParams
@@ -35,7 +36,6 @@ import org.eclipse.lsp4j.RenameFilesParams
 import org.eclipse.lsp4j.WorkspaceFolder
 import org.eclipse.lsp4j.jsonrpc.messages.ResponseMessage
 import org.eclipse.lsp4j.services.WorkspaceService
-import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import software.aws.toolkits.jetbrains.services.amazonq.lsp.AmazonQLanguageServer
@@ -108,7 +108,7 @@ class WorkspaceServiceHandlerTest {
 
         val paramsSlot = slot<CreateFilesParams>()
         verify { mockWorkspaceService.didCreateFiles(capture(paramsSlot)) }
-        assertEquals(normalizeFileUri(pyUri.toString()), paramsSlot.captured.files[0].uri)
+        assertThat(paramsSlot.captured.files[0].uri).isEqualTo(normalizeFileUri(pyUri.toString()))
     }
 
     @Test
@@ -120,7 +120,7 @@ class WorkspaceServiceHandlerTest {
 
         val paramsSlot = slot<CreateFilesParams>()
         verify { mockWorkspaceService.didCreateFiles(capture(paramsSlot)) }
-        assertEquals(normalizeFileUri(tsUri.toString()), paramsSlot.captured.files[0].uri)
+        assertThat(paramsSlot.captured.files[0].uri).isEqualTo(normalizeFileUri(tsUri.toString()))
     }
 
     @Test
@@ -132,7 +132,7 @@ class WorkspaceServiceHandlerTest {
 
         val paramsSlot = slot<CreateFilesParams>()
         verify { mockWorkspaceService.didCreateFiles(capture(paramsSlot)) }
-        assertEquals(normalizeFileUri(jsUri.toString()), paramsSlot.captured.files[0].uri)
+        assertThat(paramsSlot.captured.files[0].uri).isEqualTo(normalizeFileUri(jsUri.toString()))
     }
 
     @Test
@@ -144,7 +144,7 @@ class WorkspaceServiceHandlerTest {
 
         val paramsSlot = slot<CreateFilesParams>()
         verify { mockWorkspaceService.didCreateFiles(capture(paramsSlot)) }
-        assertEquals(normalizeFileUri(javaUri.toString()), paramsSlot.captured.files[0].uri)
+        assertThat(paramsSlot.captured.files[0].uri).isEqualTo(normalizeFileUri(javaUri.toString()))
     }
 
     @Test
@@ -156,7 +156,7 @@ class WorkspaceServiceHandlerTest {
 
         val paramsSlot = slot<CreateFilesParams>()
         verify { mockWorkspaceService.didCreateFiles(capture(paramsSlot)) }
-        assertEquals(normalizeFileUri(dirUri.toString()), paramsSlot.captured.files[0].uri)
+        assertThat(paramsSlot.captured.files[0].uri).isEqualTo(normalizeFileUri(dirUri.toString()))
     }
 
     @Test
@@ -179,7 +179,7 @@ class WorkspaceServiceHandlerTest {
 
         val paramsSlot = slot<CreateFilesParams>()
         verify { mockWorkspaceService.didCreateFiles(capture(paramsSlot)) }
-        assertEquals(normalizeFileUri(newUri.toString()), paramsSlot.captured.files[0].uri)
+        assertThat(paramsSlot.captured.files[0].uri).isEqualTo(normalizeFileUri(newUri.toString()))
     }
 
     @Test
@@ -192,7 +192,7 @@ class WorkspaceServiceHandlerTest {
 
         val paramsSlot = slot<CreateFilesParams>()
         verify { mockWorkspaceService.didCreateFiles(capture(paramsSlot)) }
-        assertEquals(normalizeFileUri(newUri.toString()), paramsSlot.captured.files[0].uri)
+        assertThat(paramsSlot.captured.files[0].uri).isEqualTo(normalizeFileUri(newUri.toString()))
     }
 
     @Test
@@ -204,7 +204,7 @@ class WorkspaceServiceHandlerTest {
 
         val paramsSlot = slot<DeleteFilesParams>()
         verify { mockWorkspaceService.didDeleteFiles(capture(paramsSlot)) }
-        assertEquals(normalizeFileUri(pyUri.toString()), paramsSlot.captured.files[0].uri)
+        assertThat(paramsSlot.captured.files[0].uri).isEqualTo(normalizeFileUri(pyUri.toString()))
     }
 
     @Test
@@ -216,7 +216,7 @@ class WorkspaceServiceHandlerTest {
 
         val paramsSlot = slot<DeleteFilesParams>()
         verify { mockWorkspaceService.didDeleteFiles(capture(paramsSlot)) }
-        assertEquals(normalizeFileUri(tsUri.toString()), paramsSlot.captured.files[0].uri)
+        assertThat(paramsSlot.captured.files[0].uri).isEqualTo(normalizeFileUri(tsUri.toString()))
     }
 
     @Test
@@ -228,7 +228,7 @@ class WorkspaceServiceHandlerTest {
 
         val paramsSlot = slot<DeleteFilesParams>()
         verify { mockWorkspaceService.didDeleteFiles(capture(paramsSlot)) }
-        assertEquals(normalizeFileUri(jsUri.toString()), paramsSlot.captured.files[0].uri)
+        assertThat(paramsSlot.captured.files[0].uri).isEqualTo(normalizeFileUri(jsUri.toString()))
     }
 
     @Test
@@ -240,7 +240,7 @@ class WorkspaceServiceHandlerTest {
 
         val paramsSlot = slot<DeleteFilesParams>()
         verify { mockWorkspaceService.didDeleteFiles(capture(paramsSlot)) }
-        assertEquals(normalizeFileUri(javaUri.toString()), paramsSlot.captured.files[0].uri)
+        assertThat(paramsSlot.captured.files[0].uri).isEqualTo(normalizeFileUri(javaUri.toString()))
     }
 
     @Test
@@ -262,7 +262,7 @@ class WorkspaceServiceHandlerTest {
 
         val paramsSlot = slot<DeleteFilesParams>()
         verify { mockWorkspaceService.didDeleteFiles(capture(paramsSlot)) }
-        assertEquals(normalizeFileUri(dirUri.toString()), paramsSlot.captured.files[0].uri)
+        assertThat(paramsSlot.captured.files[0].uri).isEqualTo(normalizeFileUri(dirUri.toString()))
     }
 
     @Test
@@ -278,9 +278,9 @@ class WorkspaceServiceHandlerTest {
 
         val deleteParamsSlot = slot<DeleteFilesParams>()
         verify { mockWorkspaceService.didDeleteFiles(capture(deleteParamsSlot)) }
-        assertEquals(2, deleteParamsSlot.captured.files.size)
-        assertEquals(normalizeFileUri(deleteUri.toString()), deleteParamsSlot.captured.files[0].uri)
-        assertEquals(normalizeFileUri(oldMoveUri.toString()), deleteParamsSlot.captured.files[1].uri)
+        assertThat(deleteParamsSlot.captured.files).hasSize(2)
+        assertThat(deleteParamsSlot.captured.files[0].uri).isEqualTo(normalizeFileUri(deleteUri.toString()))
+        assertThat(deleteParamsSlot.captured.files[1].uri).isEqualTo(normalizeFileUri(oldMoveUri.toString()))
     }
 
     @Test
@@ -304,7 +304,7 @@ class WorkspaceServiceHandlerTest {
 
         val deleteParamsSlot = slot<DeleteFilesParams>()
         verify { mockWorkspaceService.didDeleteFiles(capture(deleteParamsSlot)) }
-        assertEquals(normalizeFileUri(oldUri.toString()), deleteParamsSlot.captured.files[0].uri)
+        assertThat(deleteParamsSlot.captured.files[0].uri).isEqualTo(normalizeFileUri(oldUri.toString()))
     }
 
     @Test
@@ -324,12 +324,12 @@ class WorkspaceServiceHandlerTest {
         // Assert
         val paramsSlot = slot<DidChangeWatchedFilesParams>()
         verify { mockWorkspaceService.didChangeWatchedFiles(capture(paramsSlot)) }
-        assertEquals(normalizeFileUri(createURI.toString()), paramsSlot.captured.changes[0].uri)
-        assertEquals(FileChangeType.Created, paramsSlot.captured.changes[0].type)
-        assertEquals(normalizeFileUri(deleteURI.toString()), paramsSlot.captured.changes[1].uri)
-        assertEquals(FileChangeType.Deleted, paramsSlot.captured.changes[1].type)
-        assertEquals(normalizeFileUri(changeURI.toString()), paramsSlot.captured.changes[2].uri)
-        assertEquals(FileChangeType.Changed, paramsSlot.captured.changes[2].type)
+        assertThat(paramsSlot.captured.changes[0].uri).isEqualTo(normalizeFileUri(createURI.toString()))
+        assertThat(paramsSlot.captured.changes[0].type).isEqualTo(FileChangeType.Created)
+        assertThat(paramsSlot.captured.changes[1].uri).isEqualTo(normalizeFileUri(deleteURI.toString()))
+        assertThat(paramsSlot.captured.changes[1].type).isEqualTo(FileChangeType.Deleted)
+        assertThat(paramsSlot.captured.changes[2].uri).isEqualTo(normalizeFileUri(changeURI.toString()))
+        assertThat(paramsSlot.captured.changes[2].type).isEqualTo(FileChangeType.Changed)
     }
 
     @Test
@@ -343,11 +343,11 @@ class WorkspaceServiceHandlerTest {
         val paramsSlot = slot<DidChangeWatchedFilesParams>()
         verify { mockWorkspaceService.didChangeWatchedFiles(capture(paramsSlot)) }
 
-        assertEquals(2, paramsSlot.captured.changes.size)
-        assertEquals(normalizeFileUri(oldUri.toString()), paramsSlot.captured.changes[0].uri)
-        assertEquals(FileChangeType.Deleted, paramsSlot.captured.changes[0].type)
-        assertEquals(normalizeFileUri(newUri.toString()), paramsSlot.captured.changes[1].uri)
-        assertEquals(FileChangeType.Created, paramsSlot.captured.changes[1].type)
+        assertThat(paramsSlot.captured.changes).hasSize(2)
+        assertThat(paramsSlot.captured.changes[0].uri).isEqualTo(normalizeFileUri(oldUri.toString()))
+        assertThat(paramsSlot.captured.changes[0].type).isEqualTo(FileChangeType.Deleted)
+        assertThat(paramsSlot.captured.changes[1].uri).isEqualTo(normalizeFileUri(newUri.toString()))
+        assertThat(paramsSlot.captured.changes[1].type).isEqualTo(FileChangeType.Created)
     }
 
     @Test
@@ -360,8 +360,8 @@ class WorkspaceServiceHandlerTest {
 
         val paramsSlot = slot<DidChangeWatchedFilesParams>()
         verify { mockWorkspaceService.didChangeWatchedFiles(capture(paramsSlot)) }
-        assertEquals(normalizeFileUri(newUri.toString()), paramsSlot.captured.changes[0].uri)
-        assertEquals(FileChangeType.Created, paramsSlot.captured.changes[0].type)
+        assertThat(paramsSlot.captured.changes[0].uri).isEqualTo(normalizeFileUri(newUri.toString()))
+        assertThat(paramsSlot.captured.changes[0].type).isEqualTo(FileChangeType.Created)
     }
 
     @Test
@@ -393,8 +393,8 @@ class WorkspaceServiceHandlerTest {
         val paramsSlot = slot<RenameFilesParams>()
         verify { mockWorkspaceService.didRenameFiles(capture(paramsSlot)) }
         with(paramsSlot.captured.files[0]) {
-            assertEquals(normalizeFileUri("file:///testDir/$oldName"), oldUri)
-            assertEquals(normalizeFileUri("file:///testDir/$newName"), newUri)
+            assertThat(oldUri).isEqualTo(normalizeFileUri("file:///testDir/$oldName"))
+            assertThat(newUri).isEqualTo(normalizeFileUri("file:///testDir/$newName"))
         }
     }
 
@@ -430,8 +430,8 @@ class WorkspaceServiceHandlerTest {
         val paramsSlot = slot<RenameFilesParams>()
         verify { mockWorkspaceService.didRenameFiles(capture(paramsSlot)) }
         with(paramsSlot.captured.files[0]) {
-            assertEquals(normalizeFileUri("file:///testDir/oldDir"), oldUri)
-            assertEquals(normalizeFileUri("file:///testDir/newDir"), newUri)
+            assertThat(oldUri).isEqualTo(normalizeFileUri("file:///testDir/oldDir"))
+            assertThat(newUri).isEqualTo(normalizeFileUri("file:///testDir/newDir"))
         }
     }
 
@@ -453,7 +453,7 @@ class WorkspaceServiceHandlerTest {
         // Assert
         val paramsSlot = slot<RenameFilesParams>()
         verify { mockWorkspaceService.didRenameFiles(capture(paramsSlot)) }
-        assertEquals(2, paramsSlot.captured.files.size)
+        assertThat(paramsSlot.captured.files).hasSize(2)
     }
 
     @Test
@@ -498,8 +498,8 @@ class WorkspaceServiceHandlerTest {
         // Assert
         val paramsSlot = slot<DidChangeWorkspaceFoldersParams>()
         verify(exactly = 1) { mockWorkspaceService.didChangeWorkspaceFolders(capture(paramsSlot)) }
-        assertEquals(1, paramsSlot.captured.event.added.size)
-        assertEquals("folder1", paramsSlot.captured.event.added[0].name)
+        assertThat(paramsSlot.captured.event.added).hasSize(1)
+        assertThat(paramsSlot.captured.event.added[0].name).isEqualTo("folder1")
     }
 
     // rootsChanged handles additional files added to root
@@ -533,8 +533,8 @@ class WorkspaceServiceHandlerTest {
         // Assert
         val paramsSlot = slot<DidChangeWorkspaceFoldersParams>()
         verify(exactly = 1) { mockWorkspaceService.didChangeWorkspaceFolders(capture(paramsSlot)) }
-        assertEquals(1, paramsSlot.captured.event.added.size)
-        assertEquals("folder2", paramsSlot.captured.event.added[0].name)
+        assertThat(paramsSlot.captured.event.added).hasSize(1)
+        assertThat(paramsSlot.captured.event.added[0].name).isEqualTo("folder2")
     }
 
     // rootsChanged handles removal of files from root
@@ -568,8 +568,8 @@ class WorkspaceServiceHandlerTest {
         // Assert
         val paramsSlot = slot<DidChangeWorkspaceFoldersParams>()
         verify(exactly = 1) { mockWorkspaceService.didChangeWorkspaceFolders(capture(paramsSlot)) }
-        assertEquals(1, paramsSlot.captured.event.removed.size)
-        assertEquals("folder2", paramsSlot.captured.event.removed[0].name)
+        assertThat(paramsSlot.captured.event.removed).hasSize(1)
+        assertThat(paramsSlot.captured.event.removed[0].name).isEqualTo("folder2")
     }
 
     @Test
@@ -606,10 +606,10 @@ class WorkspaceServiceHandlerTest {
         // Assert
         val paramsSlot = slot<DidChangeWorkspaceFoldersParams>()
         verify(exactly = 1) { mockWorkspaceService.didChangeWorkspaceFolders(capture(paramsSlot)) }
-        assertEquals(1, paramsSlot.captured.event.added.size)
-        assertEquals(1, paramsSlot.captured.event.removed.size)
-        assertEquals("folder3", paramsSlot.captured.event.added[0].name)
-        assertEquals("folder2", paramsSlot.captured.event.removed[0].name)
+        assertThat(paramsSlot.captured.event.added).hasSize(1)
+        assertThat(paramsSlot.captured.event.removed).hasSize(1)
+        assertThat(paramsSlot.captured.event.added[0].name).isEqualTo("folder3")
+        assertThat(paramsSlot.captured.event.removed[0].name).isEqualTo("folder2")
     }
 
     private fun createMockVirtualFile(uri: URI, fileName: String, isDirectory: Boolean = false): VirtualFile {