make generator testable & add more error-case tests

Author: lstreckeisen

src/main/kotlin/org/contextmapper/intellij/actions/PlantUMLAction.kt

@@ -5,6 +5,7 @@ import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.actionSystem.CommonDataKeys
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.vfs.LocalFileSystem
+import com.redhat.devtools.lsp4ij.LanguageServerManager
 import com.redhat.devtools.lsp4ij.commands.CommandExecutor
 import org.contextmapper.intellij.actions.generators.ContextMapperGenerator
 import org.contextmapper.intellij.actions.generators.HandledGeneratorException
@@ -16,7 +17,7 @@ import kotlin.io.path.Path
 private val logger = Logger.getInstance(PlantUMLAction::class.java)
 
 class PlantUMLAction : AnAction() {
-    private val generator = ContextMapperGenerator { context -> CommandExecutor.executeCommand(context) }
+    private val commandExecutor: LspCommandExecutor = { context -> CommandExecutor.executeCommand(context) }
 
     override fun actionPerformed(event: AnActionEvent) {
         val project = event.project
@@ -32,6 +33,7 @@ class PlantUMLAction : AnAction() {
         val commandArgs = listOf(file.path, outDir)
         val command = Command("Generate PlantUML Diagrams", PLANT_UML_GENERATOR_COMMAND, commandArgs)
 
+        val generator = ContextMapperGenerator(commandExecutor, LanguageServerManager.getInstance(project))
         generator.generate(project, command)
             .whenComplete { result, ex ->
                 if (ex != null || result.isFailure) {

src/main/kotlin/org/contextmapper/intellij/actions/generators/ContextMapperGenerator.kt

@@ -1,6 +1,7 @@
 package org.contextmapper.intellij.actions.generators
 
 import com.intellij.openapi.project.Project
+import com.redhat.devtools.lsp4ij.LanguageServerItem
 import com.redhat.devtools.lsp4ij.LanguageServerManager
 import com.redhat.devtools.lsp4ij.commands.CommandExecutor
 import com.redhat.devtools.lsp4ij.commands.LSPCommandContext
@@ -14,7 +15,8 @@ import org.eclipse.lsp4j.jsonrpc.ResponseErrorException
 import java.util.concurrent.CompletableFuture
 
 class ContextMapperGenerator(
-    private val commandExecutor: LspCommandExecutor
+    private val commandExecutor: LspCommandExecutor,
+    private val languageServerManager: LanguageServerManager
 ) {
     fun generate(
         project: Project,
@@ -24,23 +26,13 @@ class ContextMapperGenerator(
 
         val context = LSPCommandContext(command, project)
 
-        val languageServer =
-            try {
-                LanguageServerManager.getInstance(project).getLanguageServer(CONTEXT_MAPPER_SERVER_ID)
-                    .join()
-            } catch (ex: Exception) {
-                future.complete(
-                    Result.failure(
-                        ContextMapperGeneratorException(
-                            "Could not find language server instance.",
-                            ex,
-                        ),
-                    ),
-                )
-                return future
-            }
+        val languageServerResult = getLanguageServer()
+        if (languageServerResult.isFailure) {
+            future.complete(Result.failure(languageServerResult.exceptionOrNull()!!))
+            return future
+        }
         context.preferredLanguageServerId = CONTEXT_MAPPER_SERVER_ID
-        context.preferredLanguageServer = languageServer
+        context.preferredLanguageServer = languageServerResult.getOrNull()
 
         val response = commandExecutor(context)
         CoroutineScope(Dispatchers.IO).launch {
@@ -85,6 +77,22 @@ class ContextMapperGenerator(
         }
     }
 
+    private fun getLanguageServer(): Result<LanguageServerItem?> {
+        return try {
+            val languageServer =
+                languageServerManager.getLanguageServer(CONTEXT_MAPPER_SERVER_ID)
+                    .join()
+            Result.success(languageServer)
+        } catch (ex: Exception) {
+            Result.failure(
+                ContextMapperGeneratorException(
+                    "Could not find language server instance.",
+                    ex,
+                ),
+            )
+        }
+    }
+
     private fun extractGeneratedFiles(returnedValue: Any): Result<List<String>> {
         when (returnedValue) {
             is List<*> -> {

src/test/kotlin/org/contextmapper/intellij/actions/generators/ContextMapperGeneratorTest.kt

@@ -1,14 +1,17 @@
 package org.contextmapper.intellij.actions.generators
 
 import com.intellij.openapi.project.Project
+import com.redhat.devtools.lsp4ij.LanguageServerManager
 import com.redhat.devtools.lsp4ij.commands.CommandExecutor
 import com.redhat.devtools.lsp4ij.settings.UserDefinedLanguageServerSettings
 import io.mockk.CapturingSlot
 import io.mockk.every
 import io.mockk.mockk
 import io.mockk.slot
 import org.contextmapper.intellij.actions.LspCommandExecutor
+import org.contextmapper.intellij.utils.CONTEXT_MAPPER_SERVER_ID
 import org.eclipse.lsp4j.Command
+import org.eclipse.lsp4j.jsonrpc.ResponseErrorException
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertNotNull
 import org.junit.jupiter.api.Assertions.assertTrue
@@ -20,13 +23,21 @@ class ContextMapperGeneratorTest() {
 
     private lateinit var successMessage: CapturingSlot<String>
     private lateinit var lspCommandExecutor: LspCommandExecutor
+    private lateinit var languageServerManager: LanguageServerManager
     private lateinit var project: Project
     private lateinit var generator: ContextMapperGenerator
 
     @BeforeEach
     fun setup() {
         successMessage = slot()
         lspCommandExecutor = mockk(relaxed = true)
+        languageServerManager =
+            mockk(relaxed = true) {
+                every { getLanguageServer(any()) } returns
+                    mockk {
+                        every { join() } returns mockk(relaxed = true)
+                    }
+            }
         project =
             mockk {
                 every { basePath } returns "/tmp"
@@ -35,7 +46,7 @@ class ContextMapperGeneratorTest() {
                         relaxed = true,
                     )
             }
-        generator = ContextMapperGenerator(lspCommandExecutor)
+        generator = ContextMapperGenerator(lspCommandExecutor, languageServerManager)
     }
 
     @Test
@@ -110,4 +121,39 @@ class ContextMapperGeneratorTest() {
         assertTrue(result.isFailure)
         assertTrue { result.exceptionOrNull() is ContextMapperGeneratorException }
     }
+
+    @Test
+    fun testFailedGenerationWithHandledException() {
+        every { lspCommandExecutor.invoke(any()) } returns
+            mockk<CommandExecutor.LSPCommandResponse> {
+                every { response } returns
+                    mockk {
+                        every { join() } returns mockk<ResponseErrorException>()
+                    }
+            }
+
+        val result =
+            generator.generate(project, command)
+                .join()
+
+        assertNotNull(result)
+        assertTrue { result.isFailure }
+        assertTrue { result.exceptionOrNull() is HandledGeneratorException }
+    }
+
+    @Test
+    fun testGeneratorWithMissingLanguageServer() {
+        every { languageServerManager.getLanguageServer(eq(CONTEXT_MAPPER_SERVER_ID)) } returns
+            mockk {
+                every { join() } throws RuntimeException()
+            }
+
+        val result =
+            generator.generate(project, command)
+                .join()
+
+        assertNotNull(result)
+        assertTrue { result.isFailure }
+        assertTrue { result.exceptionOrNull() is ContextMapperGeneratorException }
+    }
 }