ADFA-4484 Add comprehensive unit test suite across five modules

Add 93 new tests across 7 files covering git models, URL parsing,
LLM tool-call parsing, chat transcript writing, debounce coalescing,
diagnostics formatting, background indexing, and the index query DSL.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: yaturner

agent/src/test/java/com/itsaky/androidide/agent/repository/UtilParseToolCallTest.kt

@@ -0,0 +1,187 @@
+package com.itsaky.androidide.agent.repository
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@RunWith(JUnit4::class)
+class UtilParseToolCallTest {
+
+    private val allToolKeys = setOf(
+        "list_files", "read_file", "search_project",
+        "create_file", "update_file", "add_dependency", "get_current_datetime"
+    )
+
+    // --- Happy path: clean JSON inside <tool_call> tags ---
+
+    @Test
+    fun `parses tool call with name and empty args from tool_call tags`() {
+        val input = """<tool_call>{"name": "get_current_datetime", "args": {}}</tool_call>"""
+        val result = Util.parseToolCall(input, allToolKeys)
+        assertNotNull(result)
+        assertEquals("get_current_datetime", result!!.name)
+        assertEquals(emptyMap<String, String>(), result.args)
+    }
+
+    @Test
+    fun `parses tool call with args from tool_call tags`() {
+        val input = """<tool_call>{"name": "read_file", "args": {"file_path": "/src/main/Foo.kt"}}</tool_call>"""
+        val result = Util.parseToolCall(input, allToolKeys)
+        assertNotNull(result)
+        assertEquals("read_file", result!!.name)
+        assertEquals("/src/main/Foo.kt", result.args["file_path"])
+    }
+
+    @Test
+    fun `parses tool call for list_files with path arg`() {
+        val input = """<tool_call>{"name": "list_files", "args": {"path": "/src"}}</tool_call>"""
+        val result = Util.parseToolCall(input, allToolKeys)
+        assertNotNull(result)
+        assertEquals("list_files", result!!.name)
+        assertEquals("/src", result.args["path"])
+    }
+
+    @Test
+    fun `parses tool call for search_project`() {
+        val input = """<tool_call>{"name": "search_project", "args": {"query": "MainActivity"}}</tool_call>"""
+        val result = Util.parseToolCall(input, allToolKeys)
+        assertNotNull(result)
+        assertEquals("search_project", result!!.name)
+        assertEquals("MainActivity", result.args["query"])
+    }
+
+    // --- Happy path: JSON without tool_call wrapper ---
+
+    @Test
+    fun `parses bare JSON object with name field`() {
+        val input = """{"name": "list_files", "args": {"path": "."}}"""
+        val result = Util.parseToolCall(input, allToolKeys)
+        assertNotNull(result)
+        assertEquals("list_files", result!!.name)
+    }
+
+    @Test
+    fun `parses JSON wrapped in markdown code fence`() {
+        val input = "```json\n{\"name\": \"read_file\", \"args\": {\"file_path\": \"/README.md\"}}\n```"
+        val result = Util.parseToolCall(input, allToolKeys)
+        assertNotNull(result)
+        assertEquals("read_file", result!!.name)
+        assertEquals("/README.md", result.args["file_path"])
+    }
+
+    @Test
+    fun `parses JSON wrapped in markdown code fence without json label`() {
+        val input = "```\n{\"name\": \"list_files\", \"args\": {\"path\": \"/\"}}\n```"
+        val result = Util.parseToolCall(input, allToolKeys)
+        assertNotNull(result)
+        assertEquals("list_files", result!!.name)
+    }
+
+    // --- Name aliases ---
+
+    @Test
+    fun `list_dir is resolved to list_files`() {
+        val input = """<tool_call>{"name": "list_dir", "args": {"path": "/"}}</tool_call>"""
+        val result = Util.parseToolCall(input, allToolKeys)
+        assertNotNull(result)
+        assertEquals("list_files", result!!.name)
+    }
+
+    // --- tool_name alternative field ---
+
+    @Test
+    fun `accepts tool_name field as alternative to name`() {
+        val input = """{"tool_name": "list_files", "args": {"path": "."}}"""
+        val result = Util.parseToolCall(input, allToolKeys)
+        assertNotNull(result)
+        assertEquals("list_files", result!!.name)
+    }
+
+    // --- Tool-only tag (model emits just the name inside tags) ---
+
+    @Test
+    fun `parses tool-only tag with no args`() {
+        val input = "<tool_call>get_current_datetime</tool_call>"
+        val result = Util.parseToolCall(input, allToolKeys)
+        assertNotNull(result)
+        assertEquals("get_current_datetime", result!!.name)
+    }
+
+    // --- Failure cases: unknown tool ---
+
+    @Test
+    fun `returns null when tool name is not in available tools`() {
+        val input = """{"name": "unknown_tool", "args": {}}"""
+        val result = Util.parseToolCall(input, allToolKeys)
+        assertNull(result)
+    }
+
+    @Test
+    fun `returns null when name field is missing`() {
+        val input = """{"args": {"path": "/"}}"""
+        val result = Util.parseToolCall(input, allToolKeys)
+        assertNull(result)
+    }
+
+    @Test
+    fun `returns null when name field is blank`() {
+        val input = """{"name": "", "args": {}}"""
+        val result = Util.parseToolCall(input, allToolKeys)
+        assertNull(result)
+    }
+
+    // --- Failure cases: empty or unrecognizable input ---
+
+    @Test
+    fun `returns null for empty string`() {
+        val result = Util.parseToolCall("", allToolKeys)
+        assertNull(result)
+    }
+
+    @Test
+    fun `returns null for plain prose`() {
+        val result = Util.parseToolCall("Sure! I will list the files for you.", allToolKeys)
+        assertNull(result)
+    }
+
+    @Test
+    fun `returns null when no tools are provided and response has a tool call`() {
+        val input = """{"name": "list_files", "args": {}}"""
+        val result = Util.parseToolCall(input, emptySet())
+        assertNull(result)
+    }
+
+    // --- JSON with trailing prose (model hallucinates follow-on text) ---
+
+    @Test
+    fun `extracts first JSON object and ignores trailing text`() {
+        val input = """{"name": "read_file", "args": {"file_path": "/Foo.kt"}} Let me read that file now."""
+        val result = Util.parseToolCall(input, allToolKeys)
+        assertNotNull(result)
+        assertEquals("read_file", result!!.name)
+    }
+
+    // --- Args with multiple values ---
+
+    @Test
+    fun `parses multiple args correctly`() {
+        val input = """<tool_call>{"name": "create_file", "args": {"path": "/new.kt", "content": "class Foo {}"}}</tool_call>"""
+        val result = Util.parseToolCall(input, allToolKeys)
+        assertNotNull(result)
+        assertEquals("create_file", result!!.name)
+        assertEquals("/new.kt", result.args["path"])
+        assertEquals("class Foo {}", result.args["content"])
+    }
+
+    // --- Empty tool set ---
+
+    @Test
+    fun `returns null when tool set is empty and input has JSON`() {
+        val input = """{"name": "list_files", "args": {}}"""
+        val result = Util.parseToolCall(input, emptySet())
+        assertNull(result)
+    }
+}

agent/src/test/java/com/itsaky/androidide/agent/utils/ChatTranscriptUtilsTest.kt

@@ -0,0 +1,105 @@
+package com.itsaky.androidide.agent.utils
+
+import android.content.Context
+import io.mockk.every
+import io.mockk.mockk
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import java.io.File
+import java.io.IOException
+import java.nio.file.Files
+
+@RunWith(RobolectricTestRunner::class)
+class ChatTranscriptUtilsTest {
+
+    private lateinit var cacheDir: File
+    private lateinit var context: Context
+
+    @Before
+    fun setUp() {
+        cacheDir = Files.createTempDirectory("transcript-test").toFile()
+        context = mockk<Context> {
+            every { this@mockk.cacheDir } returns cacheDir
+        }
+    }
+
+    // --- writeTranscriptToCache ---
+
+    @Test
+    fun `writeTranscriptToCache creates file in chat_exports subdirectory`() {
+        val file = ChatTranscriptUtils.writeTranscriptToCache(context, "hello")
+        assertTrue(file.exists())
+        assertEquals("chat_exports", file.parentFile!!.name)
+    }
+
+    @Test
+    fun `writeTranscriptToCache writes content verbatim`() {
+        val content = "User: hi\nAgent: hello!"
+        val file = ChatTranscriptUtils.writeTranscriptToCache(context, content)
+        assertEquals(content, file.readText(Charsets.UTF_8))
+    }
+
+    @Test
+    fun `writeTranscriptToCache filename starts with chat-transcript`() {
+        val file = ChatTranscriptUtils.writeTranscriptToCache(context, "test")
+        assertTrue(file.name.startsWith("chat-transcript-"))
+    }
+
+    @Test
+    fun `writeTranscriptToCache filename ends with txt`() {
+        val file = ChatTranscriptUtils.writeTranscriptToCache(context, "test")
+        assertTrue(file.name.endsWith(".txt"))
+    }
+
+    @Test
+    fun `writeTranscriptToCache two calls produce distinct filenames`() {
+        val f1 = ChatTranscriptUtils.writeTranscriptToCache(context, "a")
+        Thread.sleep(5)
+        val f2 = ChatTranscriptUtils.writeTranscriptToCache(context, "b")
+        assertTrue("Expected distinct filenames but got: ${f1.name} and ${f2.name}", f1.name != f2.name)
+    }
+
+    @Test
+    fun `writeTranscriptToCache handles empty transcript`() {
+        val file = ChatTranscriptUtils.writeTranscriptToCache(context, "")
+        assertTrue(file.exists())
+        assertEquals("", file.readText())
+    }
+
+    @Test
+    fun `writeTranscriptToCache handles multiline unicode content`() {
+        val content = "日本語\nكلام عربي\n中文"
+        val file = ChatTranscriptUtils.writeTranscriptToCache(context, content)
+        assertEquals(content, file.readText(Charsets.UTF_8))
+    }
+
+    @Test
+    fun `writeTranscriptToCache throws when exports path is a file not a directory`() {
+        val exportFile = File(cacheDir, "chat_exports")
+        exportFile.createNewFile()
+
+        try {
+            ChatTranscriptUtils.writeTranscriptToCache(context, "data")
+            fail("Expected IOException")
+        } catch (e: IOException) {
+            assertTrue(
+                "Message should mention 'not a directory', was: ${e.message}",
+                e.message?.contains("not a directory") == true
+            )
+        }
+    }
+
+    @Test
+    fun `writeTranscriptToCache re-uses existing exports directory`() {
+        val exportsDir = File(cacheDir, "chat_exports")
+        exportsDir.mkdirs()
+
+        val file = ChatTranscriptUtils.writeTranscriptToCache(context, "second write")
+        assertEquals(exportsDir.canonicalPath, file.parentFile!!.canonicalPath)
+    }
+}