fix: update UTs related to agent resolution in the URI handling

Author: fioan89

src/test/kotlin/com/coder/toolbox/util/CoderProtocolHandlerTest.kt

@@ -18,6 +18,7 @@ import io.mockk.mockk
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.DisplayName
 import java.util.UUID
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -47,40 +48,34 @@ internal class CoderProtocolHandlerTest {
 
     private val agents =
         mapOf(
-            "agent_name_3" to "b0e4c54d-9ba9-4413-8512-11ca1e826a24",
-            "agent_name_2" to "fb3daea4-da6b-424d-84c7-36b90574cfef",
-            "agent_name" to "9a920eee-47fb-4571-9501-e4b3120c12f2",
+            "agent_name_bob" to "b0e4c54d-9ba9-4413-8512-11ca1e826a24",
+            "agent_name_bill" to "fb3daea4-da6b-424d-84c7-36b90574cfef",
+            "agent_name_riker" to "9a920eee-47fb-4571-9501-e4b3120c12f2",
         )
-    private val oneAgent =
+    private val agentBob =
         mapOf(
-            "agent_name_3" to "b0e4c54d-9ba9-4413-8512-11ca1e826a24",
+            "agent_name_bob" to "b0e4c54d-9ba9-4413-8512-11ca1e826a24",
         )
 
     @Test
-    fun tstgetMatchingAgent() {
+    @DisplayName("given a ws with multiple agents, expect the correct agent to be resolved if it matches the agent_name query param")
+    fun getMatchingAgent() {
         val ws = DataGen.workspace("ws", agents = agents)
 
         val tests =
             listOf(
                 Pair(
-                    mapOf("agent_id" to "9a920eee-47fb-4571-9501-e4b3120c12f2"),
+                    mapOf("agent_name" to "agent_name_riker"),
                     "9a920eee-47fb-4571-9501-e4b3120c12f2"
                 ),
                 Pair(
-                    mapOf("agent_id" to "fb3daea4-da6b-424d-84c7-36b90574cfef"),
+                    mapOf("agent_name" to "agent_name_bill"),
                     "fb3daea4-da6b-424d-84c7-36b90574cfef"
                 ),
                 Pair(
-                    mapOf("agent_id" to "b0e4c54d-9ba9-4413-8512-11ca1e826a24"),
+                    mapOf("agent_name" to "agent_name_bob"),
                     "b0e4c54d-9ba9-4413-8512-11ca1e826a24"
-                ),
-                // Prefer agent_id.
-                Pair(
-                    mapOf(
-                        "agent_id" to "b0e4c54d-9ba9-4413-8512-11ca1e826a24",
-                    ),
-                    "b0e4c54d-9ba9-4413-8512-11ca1e826a24",
-                ),
+                )
             )
         runBlocking {
             tests.forEach {
@@ -90,28 +85,20 @@ internal class CoderProtocolHandlerTest {
     }
 
     @Test
+    @DisplayName("given a ws with only multiple agents expect the agent resolution to fail if none match the agent_name query param")
     fun failsToGetMatchingAgent() {
         val ws = DataGen.workspace("ws", agents = agents)
         val tests =
             listOf(
                 Triple(emptyMap(), MissingArgumentException::class, "Unable to determine"),
-                Triple(mapOf("agent_id" to ""), MissingArgumentException::class, "Unable to determine"),
-                Triple(mapOf("agent_id" to null), MissingArgumentException::class, "Unable to determine"),
-                Triple(mapOf("agent_id" to "not-a-uuid"), IllegalArgumentException::class, "agent with ID"),
+                Triple(mapOf("agent_name" to ""), MissingArgumentException::class, "Unable to determine"),
+                Triple(mapOf("agent_name" to null), MissingArgumentException::class, "Unable to determine"),
+                Triple(mapOf("agent_name" to "not-an-agent-name"), IllegalArgumentException::class, "agent with ID"),
                 Triple(
-                    mapOf("agent_id" to "ceaa7bcf-1612-45d7-b484-2e0da9349168"),
+                    mapOf("agent_name" to "agent_name_homer"),
                     IllegalArgumentException::class,
-                    "agent with ID"
-                ),
-                // Will ignore agent if agent_id is set even if agent matches.
-                Triple(
-                    mapOf(
-                        "agent" to "agent_name",
-                        "agent_id" to "ceaa7bcf-1612-45d7-b484-2e0da9349168",
-                    ),
-                    IllegalArgumentException::class,
-                    "agent with ID",
-                ),
+                    "agent with name"
+                )
             )
         runBlocking {
             tests.forEach {
@@ -121,15 +108,14 @@ internal class CoderProtocolHandlerTest {
     }
 
     @Test
+    @DisplayName("given a ws with only one agent, the agent is selected even when agent_name query param was not provided")
     fun getsFirstAgentWhenOnlyOne() {
-        val ws = DataGen.workspace("ws", agents = oneAgent)
+        val ws = DataGen.workspace("ws", agents = agentBob)
         val tests =
             listOf(
                 emptyMap(),
-                mapOf("agent" to ""),
-                mapOf("agent_id" to ""),
-                mapOf("agent" to null),
-                mapOf("agent_id" to null),
+                mapOf("agent_name" to ""),
+                mapOf("agent_name" to null)
             )
         runBlocking {
             tests.forEach {
@@ -145,43 +131,42 @@ internal class CoderProtocolHandlerTest {
     }
 
     @Test
+    @DisplayName("given a ws with only one agent, the agent is NOT selected when agent_name query param was provided but does not match")
     fun failsToGetAgentWhenOnlyOne() {
-        val ws = DataGen.workspace("ws", agents = oneAgent)
+        val wsWithAgentBob = DataGen.workspace("ws", agents = agentBob)
         val tests =
             listOf(
                 Triple(
-                    mapOf("agent_id" to "ceaa7bcf-1612-45d7-b484-2e0da9349168"),
+                    mapOf("agent_name" to "agent_name_garfield"),
                     IllegalArgumentException::class,
-                    "agent with ID"
+                    "agent with name"
                 ),
             )
         runBlocking {
             tests.forEach {
-                assertNull(protocolHandler.getMatchingAgent(it.first, ws)?.id)
+                assertNull(protocolHandler.getMatchingAgent(it.first, wsWithAgentBob))
             }
         }
     }
 
     @Test
-    fun failsToGetAgentWithoutAgents() {
-        val ws = DataGen.workspace("ws")
+    @DisplayName("fails to resolve any agent when the workspace has no agents")
+    fun failsToGetAgentWhenWorkspaceHasNoAgents() {
+        val wsWithoutAgents = DataGen.workspace("ws")
         val tests =
             listOf(
                 Triple(emptyMap(), IllegalArgumentException::class, "has no agents"),
-                Triple(mapOf("agent" to ""), IllegalArgumentException::class, "has no agents"),
-                Triple(mapOf("agent_id" to ""), IllegalArgumentException::class, "has no agents"),
-                Triple(mapOf("agent" to null), IllegalArgumentException::class, "has no agents"),
-                Triple(mapOf("agent_id" to null), IllegalArgumentException::class, "has no agents"),
-                Triple(mapOf("agent" to "agent_name"), IllegalArgumentException::class, "has no agents"),
+                Triple(mapOf("agent_name" to ""), IllegalArgumentException::class, "has no agents"),
+                Triple(mapOf("agent_name" to null), IllegalArgumentException::class, "has no agents"),
                 Triple(
-                    mapOf("agent_id" to "9a920eee-47fb-4571-9501-e4b3120c12f2"),
+                    mapOf("agent_name" to "agent_name_riker"),
                     IllegalArgumentException::class,
                     "has no agents"
                 ),
             )
         runBlocking {
             tests.forEach {
-                assertNull(protocolHandler.getMatchingAgent(it.first, ws)?.id)
+                assertNull(protocolHandler.getMatchingAgent(it.first, wsWithoutAgents))
             }
         }
     }