From 7b5603e3930e418aeafde6f051a55e40346f9124 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Sun, 19 Apr 2026 11:56:21 +0200 Subject: [PATCH 001/124] test(coverage): add 18 new unit test suites for Tier 1 & 2 packages New test files covering: - Utils: RestUtilities, RuntimeUtilities, StringUtilities, CharacterUtilities, CollectionUtilities, MatchingUtilities, WordSplitter, FileUtilities, LifecycleUtilities - Memory: MemoryItemConverter, ContextUtilities, ConversationLogGenerator, Data model, ConversationMemorySnapshot - Output: OutputItemTypes (polymorphic serialization) - Engine: Agent, ComponentCache, Deployment, Context model - Configs: ResourceUtilities - Backup: ZipArchive (including Zip Slip protection) Coverage: 43.7% -> 45.9% line, 38.8% -> 41.3% branch All 2459 tests pass. --- .github/workflows/ci.yml | 6 + .github/workflows/docker-pull-notify.yml | 88 ++++++++- .../labs/eddi/backup/impl/ZipArchiveTest.java | 138 ++++++++++++++ .../descriptors/ResourceUtilitiesTest.java | 69 +++++++ .../internal/ComponentCacheTest.java | 51 +++++ .../engine/memory/ContextUtilitiesTest.java | 82 ++++++++ .../memory/ConversationLogGeneratorTest.java | 100 ++++++++++ .../memory/MemoryItemConverterTest.java | 101 ++++++++++ .../model/ConversationMemorySnapshotTest.java | 176 ++++++++++++++++++ .../eddi/engine/memory/model/DataTest.java | 115 ++++++++++++ .../labs/eddi/engine/model/ContextTest.java | 70 +++++++ .../eddi/engine/model/DeploymentTest.java | 81 ++++++++ .../engine/runtime/internal/AgentTest.java | 101 ++++++++++ .../model/types/OutputItemTypesTest.java | 175 +++++++++++++++++ .../eddi/utils/CharacterUtilitiesTest.java | 148 +++++++++++++++ .../eddi/utils/CollectionUtilitiesTest.java | 39 ++++ .../ai/labs/eddi/utils/FileUtilitiesTest.java | 68 +++++++ .../eddi/utils/LifecycleUtilitiesTest.java | 34 ++++ .../eddi/utils/MatchingUtilitiesTest.java | 71 +++++++ .../ai/labs/eddi/utils/RestUtilitiesTest.java | 98 ++++++++++ .../labs/eddi/utils/RuntimeUtilitiesTest.java | 144 ++++++++++++++ .../labs/eddi/utils/StringUtilitiesTest.java | 104 +++++++++++ .../ai/labs/eddi/utils/WordSplitterTest.java | 49 +++++ 23 files changed, 2106 insertions(+), 2 deletions(-) create mode 100644 src/test/java/ai/labs/eddi/backup/impl/ZipArchiveTest.java create mode 100644 src/test/java/ai/labs/eddi/configs/descriptors/ResourceUtilitiesTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/lifecycle/internal/ComponentCacheTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/memory/ContextUtilitiesTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/memory/ConversationLogGeneratorTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/memory/MemoryItemConverterTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/memory/model/ConversationMemorySnapshotTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/memory/model/DataTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/model/ContextTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/model/DeploymentTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/runtime/internal/AgentTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/output/model/types/OutputItemTypesTest.java create mode 100644 src/test/java/ai/labs/eddi/utils/CharacterUtilitiesTest.java create mode 100644 src/test/java/ai/labs/eddi/utils/CollectionUtilitiesTest.java create mode 100644 src/test/java/ai/labs/eddi/utils/FileUtilitiesTest.java create mode 100644 src/test/java/ai/labs/eddi/utils/LifecycleUtilitiesTest.java create mode 100644 src/test/java/ai/labs/eddi/utils/MatchingUtilitiesTest.java create mode 100644 src/test/java/ai/labs/eddi/utils/RestUtilitiesTest.java create mode 100644 src/test/java/ai/labs/eddi/utils/RuntimeUtilitiesTest.java create mode 100644 src/test/java/ai/labs/eddi/utils/StringUtilitiesTest.java create mode 100644 src/test/java/ai/labs/eddi/utils/WordSplitterTest.java diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e01fe9baf..1094e5ec2 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -609,6 +609,12 @@ jobs: OVERALL_TEXT="Build Failed" fi + # Only notify on failures or release tag pushes — green branch/PR builds stay silent + if [ "$OVERALL_TEXT" = "Build Passed" ] && [[ "$GITHUB_REF" != refs/tags/* ]]; then + echo "### ⏭️ Build passed — skipping Slack (only failures and releases notify)" >> $GITHUB_STEP_SUMMARY + exit 0 + fi + # Branch or tag name REF="${GITHUB_REF#refs/heads/}" REF="${REF#refs/tags/}" diff --git a/.github/workflows/docker-pull-notify.yml b/.github/workflows/docker-pull-notify.yml index 566f1fc39..846afe55f 100644 --- a/.github/workflows/docker-pull-notify.yml +++ b/.github/workflows/docker-pull-notify.yml @@ -3,6 +3,7 @@ name: Project Metrics Tracker on: schedule: - cron: '*/15 * * * *' # every 15 min — collect metrics + push to analytics + - cron: '0 18 * * *' # daily — 6pm UTC, digest (only if activity) - cron: '0 9 * * 0' # weekly — Sunday 9am UTC, Slack digest workflow_dispatch: inputs: @@ -40,11 +41,14 @@ jobs: echo "week_docker=$(jq -r '.week_docker // 0' metrics.json)" >> "$GITHUB_OUTPUT" echo "week_stars=$(jq -r '.week_stars // 0' metrics.json)" >> "$GITHUB_OUTPUT" echo "week_forks=$(jq -r '.week_forks // 0' metrics.json)" >> "$GITHUB_OUTPUT" + echo "day_docker=$(jq -r '.day_docker // 0' metrics.json)" >> "$GITHUB_OUTPUT" + echo "day_stars=$(jq -r '.day_stars // 0' metrics.json)" >> "$GITHUB_OUTPUT" + echo "day_forks=$(jq -r '.day_forks // 0' metrics.json)" >> "$GITHUB_OUTPUT" echo "last_milestone=$(jq -r '.last_milestone // 0' metrics.json)" >> "$GITHUB_OUTPUT" echo "has_data=true" >> "$GITHUB_OUTPUT" else echo "has_data=false" >> "$GITHUB_OUTPUT" - for key in docker_pulls stars forks week_docker week_stars week_forks last_milestone; do + for key in docker_pulls stars forks week_docker week_stars week_forks day_docker day_stars day_forks last_milestone; do echo "${key}=0" >> "$GITHUB_OUTPUT" done fi @@ -259,10 +263,72 @@ jobs: ] }" + # ── Daily digest (only if activity) ────────────────────── + - name: Daily digest + if: >- + github.event.schedule == '0 18 * * *' + && steps.prev.outputs.has_data == 'true' + continue-on-error: true + env: + SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK_URL }} + run: | + if [ -z "$SLACK_WEBHOOK" ]; then + echo "No SLACK_WEBHOOK_URL configured, skipping" + exit 0 + fi + + PULLS=${{ steps.docker.outputs.pulls }} + STARS=${{ steps.github.outputs.stars }} + FORKS=${{ steps.github.outputs.forks }} + VIEWS=${{ steps.traffic.outputs.views }} + CLONES=${{ steps.traffic.outputs.clones }} + + DAY_PULL_DIFF=$(( PULLS - ${{ steps.prev.outputs.day_docker }} )) + DAY_STAR_DIFF=$(( STARS - ${{ steps.prev.outputs.day_stars }} )) + DAY_FORK_DIFF=$(( FORKS - ${{ steps.prev.outputs.day_forks }} )) + + # Only send if something actually changed today + if [ "$DAY_PULL_DIFF" -eq 0 ] && [ "$DAY_STAR_DIFF" -eq 0 ] && [ "$DAY_FORK_DIFF" -eq 0 ]; then + echo "No daily activity — skipping digest" + exit 0 + fi + + # Build sign prefixes + pull_sign=""; [ "$DAY_PULL_DIFF" -gt 0 ] && pull_sign="+" + star_sign=""; [ "$DAY_STAR_DIFF" -gt 0 ] && star_sign="+" + fork_sign=""; [ "$DAY_FORK_DIFF" -gt 0 ] && fork_sign="+" + + PULLS_FMT=$(printf "%'d" "$PULLS") + + curl -sf -X POST "$SLACK_WEBHOOK" \ + -H 'Content-type: application/json' \ + -d "{ + \"blocks\": [ + { + \"type\": \"header\", + \"text\": { \"type\": \"plain_text\", \"text\": \"📈 EDDI Daily Update\", \"emoji\": true } + }, + { + \"type\": \"section\", + \"text\": { + \"type\": \"mrkdwn\", + \"text\": \"🐳 *Pulls:* ${PULLS_FMT} (${pull_sign}${DAY_PULL_DIFF}) · ⭐ *Stars:* ${STARS} (${star_sign}${DAY_STAR_DIFF}) · 🍴 *Forks:* ${FORKS} (${fork_sign}${DAY_FORK_DIFF})\" + } + }, + { + \"type\": \"context\", + \"elements\": [ + { \"type\": \"mrkdwn\", \"text\": \"👀 Views: ${VIEWS} · 📥 Clones: ${CLONES} · \" } + ] + } + ] + }" + # ── Save updated metrics ──────────────────────────────── - name: Build metrics snapshot run: | IS_WEEKLY="${{ github.event.schedule == '0 9 * * 0' || github.event.inputs.force_digest == 'true' }}" + IS_DAILY="${{ github.event.schedule == '0 18 * * *' }}" # On weekly digest, reset the week baseline if [ "$IS_WEEKLY" = "true" ]; then @@ -275,10 +341,24 @@ jobs: WEEK_FORKS=${{ steps.prev.outputs.week_forks }} fi - # First run: initialize week baseline + # On daily digest (or weekly), reset the day baseline + if [ "$IS_DAILY" = "true" ] || [ "$IS_WEEKLY" = "true" ]; then + DAY_DOCKER=${{ steps.docker.outputs.pulls }} + DAY_STARS=${{ steps.github.outputs.stars }} + DAY_FORKS=${{ steps.github.outputs.forks }} + else + DAY_DOCKER=${{ steps.prev.outputs.day_docker }} + DAY_STARS=${{ steps.prev.outputs.day_stars }} + DAY_FORKS=${{ steps.prev.outputs.day_forks }} + fi + + # First run: initialize baselines [ "$WEEK_DOCKER" = "0" ] && WEEK_DOCKER=${{ steps.docker.outputs.pulls }} [ "$WEEK_STARS" = "0" ] && WEEK_STARS=${{ steps.github.outputs.stars }} [ "$WEEK_FORKS" = "0" ] && WEEK_FORKS=${{ steps.github.outputs.forks }} + [ "$DAY_DOCKER" = "0" ] && DAY_DOCKER=${{ steps.docker.outputs.pulls }} + [ "$DAY_STARS" = "0" ] && DAY_STARS=${{ steps.github.outputs.stars }} + [ "$DAY_FORKS" = "0" ] && DAY_FORKS=${{ steps.github.outputs.forks }} # Current milestone marker CURRENT_MS=$(( ${{ steps.docker.outputs.pulls }} / 10000 * 10000 )) @@ -290,9 +370,13 @@ jobs: --argjson week_docker "$WEEK_DOCKER" \ --argjson week_stars "$WEEK_STARS" \ --argjson week_forks "$WEEK_FORKS" \ + --argjson day_docker "$DAY_DOCKER" \ + --argjson day_stars "$DAY_STARS" \ + --argjson day_forks "$DAY_FORKS" \ --argjson last_milestone "$CURRENT_MS" \ '{docker_pulls: $docker_pulls, stars: $stars, forks: $forks, week_docker: $week_docker, week_stars: $week_stars, week_forks: $week_forks, + day_docker: $day_docker, day_stars: $day_stars, day_forks: $day_forks, last_milestone: $last_milestone}' > metrics.json echo "Saved metrics:" diff --git a/src/test/java/ai/labs/eddi/backup/impl/ZipArchiveTest.java b/src/test/java/ai/labs/eddi/backup/impl/ZipArchiveTest.java new file mode 100644 index 000000000..adbc18766 --- /dev/null +++ b/src/test/java/ai/labs/eddi/backup/impl/ZipArchiveTest.java @@ -0,0 +1,138 @@ +package ai.labs.eddi.backup.impl; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; + +import java.io.*; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.zip.ZipEntry; +import java.util.zip.ZipInputStream; +import java.util.zip.ZipOutputStream; + +import static org.junit.jupiter.api.Assertions.*; + +class ZipArchiveTest { + + private ZipArchive zipArchive; + + @BeforeEach + void setUp() { + zipArchive = new ZipArchive(); + } + + @Test + void createZip_withFiles_producesValidZip(@TempDir Path tempDir) throws IOException { + // Create source structure + Path sourceDir = tempDir.resolve("source"); + Files.createDirectories(sourceDir); + Files.writeString(sourceDir.resolve("file1.txt"), "content1"); + Files.writeString(sourceDir.resolve("file2.json"), "{\"key\": \"value\"}"); + + Path targetZip = tempDir.resolve("output.zip"); + + zipArchive.createZip(sourceDir.toString(), targetZip.toString(), tempDir); + + assertTrue(Files.exists(targetZip)); + assertTrue(Files.size(targetZip) > 0); + + // Verify contents + try (ZipInputStream zis = new ZipInputStream(new FileInputStream(targetZip.toFile()))) { + int count = 0; + ZipEntry entry; + while ((entry = zis.getNextEntry()) != null) { + assertTrue(entry.getName().equals("file1.txt") || entry.getName().equals("file2.json")); + count++; + } + assertEquals(2, count); + } + } + + @Test + void createZip_withSubdirectories_includesNestedFiles(@TempDir Path tempDir) throws IOException { + Path sourceDir = tempDir.resolve("source"); + Path subDir = sourceDir.resolve("subdir"); + Files.createDirectories(subDir); + Files.writeString(subDir.resolve("nested.txt"), "nested content"); + + Path targetZip = tempDir.resolve("output.zip"); + + zipArchive.createZip(sourceDir.toString(), targetZip.toString(), tempDir); + + assertTrue(Files.exists(targetZip)); + try (ZipInputStream zis = new ZipInputStream(new FileInputStream(targetZip.toFile()))) { + ZipEntry entry = zis.getNextEntry(); + assertNotNull(entry); + assertTrue(entry.getName().contains("nested.txt")); + } + } + + @Test + void createZip_targetEscapesBaseDir_throwsIOException(@TempDir Path tempDir) throws IOException { + Path sourceDir = tempDir.resolve("source"); + Files.createDirectories(sourceDir); + Files.writeString(sourceDir.resolve("file.txt"), "data"); + + // Target path escapes the allowed base dir + assertThrows(IOException.class, + () -> zipArchive.createZip(sourceDir.toString(), "/tmp/evil/output.zip", tempDir)); + } + + @Test + void unzip_validZip_extractsFiles(@TempDir Path tempDir) throws IOException { + // Create a zip in memory + Path zipFile = tempDir.resolve("test.zip"); + try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFile.toFile()))) { + zos.putNextEntry(new ZipEntry("hello.txt")); + zos.write("hello world".getBytes()); + zos.closeEntry(); + } + + // Unzip + File targetDir = tempDir.resolve("extracted").toFile(); + try (InputStream is = new FileInputStream(zipFile.toFile())) { + zipArchive.unzip(is, targetDir); + } + + File extractedFile = new File(targetDir, "hello.txt"); + assertTrue(extractedFile.exists()); + assertEquals("hello world", Files.readString(extractedFile.toPath())); + } + + @Test + void unzip_zipSlipAttack_throwsIOException(@TempDir Path tempDir) throws IOException { + // Create a malicious zip with path traversal + Path zipFile = tempDir.resolve("evil.zip"); + try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFile.toFile()))) { + zos.putNextEntry(new ZipEntry("../../evil.txt")); + zos.write("malicious".getBytes()); + zos.closeEntry(); + } + + File targetDir = tempDir.resolve("extracted").toFile(); + try (InputStream is = new FileInputStream(zipFile.toFile())) { + assertThrows(IOException.class, () -> zipArchive.unzip(is, targetDir)); + } + } + + @Test + void unzip_withDirectories_createsStructure(@TempDir Path tempDir) throws IOException { + Path zipFile = tempDir.resolve("test.zip"); + try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFile.toFile()))) { + zos.putNextEntry(new ZipEntry("subdir/")); + zos.closeEntry(); + zos.putNextEntry(new ZipEntry("subdir/file.txt")); + zos.write("content".getBytes()); + zos.closeEntry(); + } + + File targetDir = tempDir.resolve("extracted").toFile(); + try (InputStream is = new FileInputStream(zipFile.toFile())) { + zipArchive.unzip(is, targetDir); + } + + assertTrue(new File(targetDir, "subdir").isDirectory()); + assertTrue(new File(targetDir, "subdir/file.txt").exists()); + } +} diff --git a/src/test/java/ai/labs/eddi/configs/descriptors/ResourceUtilitiesTest.java b/src/test/java/ai/labs/eddi/configs/descriptors/ResourceUtilitiesTest.java new file mode 100644 index 000000000..dbd24a8d5 --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/descriptors/ResourceUtilitiesTest.java @@ -0,0 +1,69 @@ +package ai.labs.eddi.configs.descriptors; + +import ai.labs.eddi.configs.descriptors.model.DocumentDescriptor; +import ai.labs.eddi.engine.memory.descriptor.model.ConversationDescriptor; +import org.junit.jupiter.api.Test; + +import java.net.URI; + +import static org.junit.jupiter.api.Assertions.*; + +class ResourceUtilitiesTest { + + @Test + void validateUri_validEddiUri_returnsResourceId() { + var resourceId = ResourceUtilities.validateUri( + "eddi://ai.labs.agent/agentstore/agents/5262b802dc6c4008b54c?version=1"); + assertNotNull(resourceId); + assertEquals("5262b802dc6c4008b54c", resourceId.getId()); + assertEquals(1, resourceId.getVersion()); + } + + @Test + void validateUri_nonEddiScheme_returnsNull() { + assertNull(ResourceUtilities.validateUri("http://example.com/resource/123?version=1")); + } + + @Test + void validateUri_missingVersion_returnsNull() { + assertNull(ResourceUtilities.validateUri("eddi://ai.labs.agent/agentstore/agents/abc123")); + } + + @Test + void createDocumentDescriptor_setsResourceAndDates() { + URI resource = URI.create("eddi://ai.labs.agent/agentstore/agents/abc123?version=1"); + + DocumentDescriptor descriptor = ResourceUtilities.createDocumentDescriptor(resource); + + assertEquals(resource, descriptor.getResource()); + assertEquals("", descriptor.getName()); + assertEquals("", descriptor.getDescription()); + assertNotNull(descriptor.getCreatedOn()); + assertNotNull(descriptor.getLastModifiedOn()); + } + + @Test + void createDocumentDescriptor_datesMatch() { + URI resource = URI.create("eddi://ai.labs.agent/agentstore/agents/abc123?version=1"); + DocumentDescriptor descriptor = ResourceUtilities.createDocumentDescriptor(resource); + + // Created and last modified should be the same on creation + assertEquals(descriptor.getCreatedOn(), descriptor.getLastModifiedOn()); + } + + @Test + void createConversationDescriptor_setsAllFields() { + URI resource = URI.create("eddi://ai.labs.conversation/conversationstore/conversations/conv1?version=1"); + URI agentResource = URI.create("eddi://ai.labs.agent/agentstore/agents/agent1?version=1"); + + ConversationDescriptor descriptor = ResourceUtilities.createConversationDescriptorDocument( + resource, agentResource, "user-1"); + + assertEquals(resource, descriptor.getResource()); + assertEquals(agentResource, descriptor.getAgentResource()); + assertEquals("user-1", descriptor.getUserId()); + assertEquals(ConversationDescriptor.ViewState.UNSEEN, descriptor.getViewState()); + assertNotNull(descriptor.getCreatedOn()); + assertNull(descriptor.getCreatedBy()); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/lifecycle/internal/ComponentCacheTest.java b/src/test/java/ai/labs/eddi/engine/lifecycle/internal/ComponentCacheTest.java new file mode 100644 index 000000000..c84c025bb --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/lifecycle/internal/ComponentCacheTest.java @@ -0,0 +1,51 @@ +package ai.labs.eddi.engine.lifecycle.internal; + +import org.junit.jupiter.api.Test; + +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class ComponentCacheTest { + + @Test + void getComponentMap_returnsEmptyMapForNewType() { + var cache = new ComponentCache(); + Map map = cache.getComponentMap("parser"); + assertNotNull(map); + assertTrue(map.isEmpty()); + } + + @Test + void getComponentMap_returnsSameMapOnSecondCall() { + var cache = new ComponentCache(); + Map map1 = cache.getComponentMap("parser"); + Map map2 = cache.getComponentMap("parser"); + assertSame(map1, map2); + } + + @Test + void put_storesComponent() { + var cache = new ComponentCache(); + cache.put("parser", "key1", "component1"); + assertEquals("component1", cache.getComponentMap("parser").get("key1")); + } + + @Test + void put_multipleComponentTypes_isolated() { + var cache = new ComponentCache(); + cache.put("parser", "key1", "p1"); + cache.put("rules", "key1", "r1"); + + assertEquals("p1", cache.getComponentMap("parser").get("key1")); + assertEquals("r1", cache.getComponentMap("rules").get("key1")); + } + + @Test + void put_overwritesSameKey() { + var cache = new ComponentCache(); + cache.put("parser", "key1", "old"); + cache.put("parser", "key1", "new"); + assertEquals("new", cache.getComponentMap("parser").get("key1")); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/memory/ContextUtilitiesTest.java b/src/test/java/ai/labs/eddi/engine/memory/ContextUtilitiesTest.java new file mode 100644 index 000000000..cf36e990e --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/memory/ContextUtilitiesTest.java @@ -0,0 +1,82 @@ +package ai.labs.eddi.engine.memory; + +import ai.labs.eddi.configs.properties.model.Property; +import ai.labs.eddi.engine.model.Context; +import org.junit.jupiter.api.Test; + +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class ContextUtilitiesTest { + + @Test + void storeContextLanguageInLongTermMemory_withLangContext_storesProperty() { + var memory = new ConversationMemory("agent-1", 1, "user-1"); + var langCtx = new Context(); + langCtx.setType(Context.ContextType.string); + langCtx.setValue("en"); + + ContextUtilities.storeContextLanguageInLongTermMemory(Map.of("lang", langCtx), memory); + + Property prop = memory.getConversationProperties().get("lang"); + assertNotNull(prop); + assertEquals("en", prop.getValueString()); + assertEquals(Property.Scope.longTerm, prop.getScope()); + } + + @Test + void storeContextLanguageInLongTermMemory_nonLangKey_ignored() { + var memory = new ConversationMemory("agent-1", 1, "user-1"); + var ctx = new Context(); + ctx.setType(Context.ContextType.string); + ctx.setValue("some-value"); + + ContextUtilities.storeContextLanguageInLongTermMemory(Map.of("other", ctx), memory); + + assertNull(memory.getConversationProperties().get("lang")); + } + + @Test + void storeContextLanguageInLongTermMemory_nonStringType_ignored() { + var memory = new ConversationMemory("agent-1", 1, "user-1"); + var ctx = new Context(); + ctx.setType(Context.ContextType.object); + ctx.setValue(Map.of("key", "val")); + + ContextUtilities.storeContextLanguageInLongTermMemory(Map.of("lang", ctx), memory); + + assertNull(memory.getConversationProperties().get("lang")); + } + + @Test + void storeContextLanguageInLongTermMemory_emptyValue_ignored() { + var memory = new ConversationMemory("agent-1", 1, "user-1"); + var ctx = new Context(); + ctx.setType(Context.ContextType.string); + ctx.setValue(""); + + ContextUtilities.storeContextLanguageInLongTermMemory(Map.of("lang", ctx), memory); + + assertNull(memory.getConversationProperties().get("lang")); + } + + @Test + void retrieveContextLanguageFromLongTermMemory_exists_returnsLang() { + var memory = new ConversationMemory("agent-1", 1, "user-1"); + memory.getConversationProperties().put("lang", + new Property("lang", "de", Property.Scope.longTerm)); + + String lang = ContextUtilities.retrieveContextLanguageFromLongTermMemory( + memory.getConversationProperties()); + assertEquals("de", lang); + } + + @Test + void retrieveContextLanguageFromLongTermMemory_notSet_returnsNull() { + var memory = new ConversationMemory("agent-1", 1, "user-1"); + String lang = ContextUtilities.retrieveContextLanguageFromLongTermMemory( + memory.getConversationProperties()); + assertNull(lang); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/memory/ConversationLogGeneratorTest.java b/src/test/java/ai/labs/eddi/engine/memory/ConversationLogGeneratorTest.java new file mode 100644 index 000000000..22231ba58 --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/memory/ConversationLogGeneratorTest.java @@ -0,0 +1,100 @@ +package ai.labs.eddi.engine.memory; + +import ai.labs.eddi.engine.memory.model.ConversationLog; +import ai.labs.eddi.engine.memory.model.ConversationOutput; +import ai.labs.eddi.engine.memory.model.Data; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class ConversationLogGeneratorTest { + + @Test + void generate_emptyConversation_returnsEmptyLog() { + var memory = new ConversationMemory("agent-1", 1, "user-1"); + var generator = new ConversationLogGenerator(memory); + + ConversationLog log = generator.generate(); + assertNotNull(log); + assertTrue(log.getMessages().isEmpty()); + } + + @Test + void generate_withUserInput_containsUserMessage() { + var memory = new ConversationMemory("agent-1", 1, "user-1"); + memory.getCurrentStep().addConversationOutputString("input", "Hello"); + + var generator = new ConversationLogGenerator(memory); + ConversationLog log = generator.generate(); + + assertFalse(log.getMessages().isEmpty()); + assertEquals("user", log.getMessages().getFirst().getRole()); + } + + @Test + void generate_withOutput_containsAssistantMessage() { + var memory = new ConversationMemory("agent-1", 1, "user-1"); + memory.getCurrentStep().addConversationOutputString("input", "Hi"); + memory.getCurrentStep().addConversationOutputObject("output", + List.of(Map.of("text", "Hello there!"))); + + var generator = new ConversationLogGenerator(memory); + ConversationLog log = generator.generate(); + + assertEquals(2, log.getMessages().size()); + assertEquals("assistant", log.getMessages().get(1).getRole()); + } + + @Test + void generate_withLogSizeLimit_limitsMessages() { + var memory = new ConversationMemory("agent-1", 1, "user-1"); + memory.getCurrentStep().addConversationOutputString("input", "msg1"); + memory.startNextStep(); + memory.getCurrentStep().addConversationOutputString("input", "msg2"); + memory.startNextStep(); + memory.getCurrentStep().addConversationOutputString("input", "msg3"); + + var generator = new ConversationLogGenerator(memory); + ConversationLog log = generator.generate(1); + + // Should only include last turn + assertTrue(log.getMessages().size() <= 2); + } + + @Test + void generate_withZeroLogSize_returnsEmpty() { + var memory = new ConversationMemory("agent-1", 1, "user-1"); + memory.getCurrentStep().addConversationOutputString("input", "Hello"); + + var generator = new ConversationLogGenerator(memory); + ConversationLog log = generator.generate(0); + + assertTrue(log.getMessages().isEmpty()); + } + + @Test + void generate_excludeFirstAgentMessage_removesFirst() { + var memory = new ConversationMemory("agent-1", 1, "user-1"); + memory.getCurrentStep().addConversationOutputString("input", "Hello"); + memory.getCurrentStep().addConversationOutputObject("output", + List.of(Map.of("text", "Welcome!"))); + + var generator = new ConversationLogGenerator(memory); + ConversationLog logWithFirst = generator.generate(-1, true); + ConversationLog logWithoutFirst = generator.generate(-1, false); + + assertTrue(logWithoutFirst.getMessages().size() < logWithFirst.getMessages().size()); + } + + @Test + void generate_nullMemory_throwsIllegalState() { + // ConversationLogGenerator with null memory and null snapshot + assertThrows(IllegalStateException.class, () -> { + var gen = new ConversationLogGenerator((IConversationMemory) null); + gen.generate(); + }); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/memory/MemoryItemConverterTest.java b/src/test/java/ai/labs/eddi/engine/memory/MemoryItemConverterTest.java new file mode 100644 index 000000000..d808a8a5e --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/memory/MemoryItemConverterTest.java @@ -0,0 +1,101 @@ +package ai.labs.eddi.engine.memory; + +import ai.labs.eddi.engine.memory.model.ConversationOutput; +import ai.labs.eddi.engine.memory.model.Data; +import ai.labs.eddi.engine.model.Context; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.HashMap; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class MemoryItemConverterTest { + + private MemoryItemConverter converter; + + @BeforeEach + void setUp() { + converter = new MemoryItemConverter(); + } + + @Test + void convert_withBasicMemory_containsAllTopLevelKeys() { + var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); + Map result = converter.convert(memory); + + assertNotNull(result); + assertTrue(result.containsKey("conversationLog")); + assertTrue(result.containsKey("userInfo")); + assertTrue(result.containsKey("conversationInfo")); + } + + @Test + void convert_userInfo_containsUserId() { + var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); + Map result = converter.convert(memory); + + @SuppressWarnings("unchecked") + var userInfo = (Map) result.get("userInfo"); + assertNotNull(userInfo); + assertEquals("user-1", userInfo.get("userId")); + } + + @Test + void convert_conversationInfo_containsAgentIdAndVersion() { + var memory = new ConversationMemory("conv-1", "agent-1", 2, "user-1"); + Map result = converter.convert(memory); + + @SuppressWarnings("unchecked") + var convInfo = (Map) result.get("conversationInfo"); + assertNotNull(convInfo); + assertEquals("conv-1", convInfo.get("conversationId")); + assertEquals("agent-1", convInfo.get("agentId")); + assertEquals("2", convInfo.get("agentVersion")); + } + + @Test + void convert_withContext_containsContextMap() { + var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); + var ctx = new Context(); + ctx.setType(Context.ContextType.string); + ctx.setValue("en"); + memory.getCurrentStep().storeData(new Data<>("context:lang", ctx)); + + Map result = converter.convert(memory); + + assertTrue(result.containsKey("context")); + @SuppressWarnings("unchecked") + var contextMap = (Map) result.get("context"); + assertEquals("en", contextMap.get("lang")); + } + + @Test + void convert_memorySection_containsCurrentLastPast() { + var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); + // Add some data to make memory non-empty + memory.getCurrentStep().addConversationOutputString("input", "hello"); + + Map result = converter.convert(memory); + + assertTrue(result.containsKey("memory")); + @SuppressWarnings("unchecked") + var memoryMap = (Map) result.get("memory"); + assertTrue(memoryMap.containsKey("current")); + assertTrue(memoryMap.containsKey("last")); + assertTrue(memoryMap.containsKey("past")); + } + + @Test + void convert_withProperties_containsPropertiesMap() { + var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); + var prop = new ai.labs.eddi.configs.properties.model.Property("name", "John", + ai.labs.eddi.configs.properties.model.Property.Scope.conversation); + memory.getConversationProperties().put("name", prop); + + Map result = converter.convert(memory); + + assertTrue(result.containsKey("properties")); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/memory/model/ConversationMemorySnapshotTest.java b/src/test/java/ai/labs/eddi/engine/memory/model/ConversationMemorySnapshotTest.java new file mode 100644 index 000000000..b84591ac6 --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/memory/model/ConversationMemorySnapshotTest.java @@ -0,0 +1,176 @@ +package ai.labs.eddi.engine.memory.model; + +import ai.labs.eddi.configs.properties.model.Property; +import ai.labs.eddi.engine.model.Deployment; +import org.junit.jupiter.api.Test; + +import java.util.Date; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class ConversationMemorySnapshotTest { + + @Test + void gettersAndSetters_work() { + var snapshot = new ConversationMemorySnapshot(); + snapshot.setId("conv-1"); + snapshot.setAgentId("agent-1"); + snapshot.setAgentVersion(2); + snapshot.setUserId("user-1"); + snapshot.setEnvironment(Deployment.Environment.production); + snapshot.setConversationState(ConversationState.READY); + + assertEquals("conv-1", snapshot.getId()); + assertEquals("conv-1", snapshot.getConversationId()); + assertEquals("agent-1", snapshot.getAgentId()); + assertEquals(2, snapshot.getAgentVersion()); + assertEquals("user-1", snapshot.getUserId()); + assertEquals(Deployment.Environment.production, snapshot.getEnvironment()); + assertEquals(ConversationState.READY, snapshot.getConversationState()); + } + + @Test + void conversationOutputs_initiallyEmpty() { + var snapshot = new ConversationMemorySnapshot(); + assertNotNull(snapshot.getConversationOutputs()); + assertTrue(snapshot.getConversationOutputs().isEmpty()); + } + + @Test + void conversationProperties_initiallyEmpty() { + var snapshot = new ConversationMemorySnapshot(); + assertNotNull(snapshot.getConversationProperties()); + assertTrue(snapshot.getConversationProperties().isEmpty()); + } + + @Test + void conversationSteps_initiallyEmpty() { + var snapshot = new ConversationMemorySnapshot(); + assertNotNull(snapshot.getConversationSteps()); + assertTrue(snapshot.getConversationSteps().isEmpty()); + } + + @Test + void redoCache_initiallyEmpty() { + var snapshot = new ConversationMemorySnapshot(); + assertNotNull(snapshot.getRedoCache()); + assertTrue(snapshot.getRedoCache().isEmpty()); + } + + @Test + void setConversationId_setsIdViaBothPaths() { + var snapshot = new ConversationMemorySnapshot(); + snapshot.setConversationId("conv-A"); + assertEquals("conv-A", snapshot.getId()); + } + + @Test + void equals_sameSteps_returnsTrue() { + var s1 = new ConversationMemorySnapshot(); + var s2 = new ConversationMemorySnapshot(); + assertEquals(s1, s2); + } + + @Test + void equals_differentSteps_returnsFalse() { + var s1 = new ConversationMemorySnapshot(); + var s2 = new ConversationMemorySnapshot(); + s2.getConversationSteps().add(new ConversationMemorySnapshot.ConversationStepSnapshot()); + assertNotEquals(s1, s2); + } + + // --- ConversationStepSnapshot --- + + @Test + void conversationStepSnapshot_workflowsInitiallyEmpty() { + var step = new ConversationMemorySnapshot.ConversationStepSnapshot(); + assertNotNull(step.getWorkflows()); + assertTrue(step.getWorkflows().isEmpty()); + } + + @Test + void conversationStepSnapshot_equals() { + var s1 = new ConversationMemorySnapshot.ConversationStepSnapshot(); + var s2 = new ConversationMemorySnapshot.ConversationStepSnapshot(); + assertEquals(s1, s2); + } + + // --- WorkflowRunSnapshot --- + + @Test + void workflowRunSnapshot_lifecycleTasksInitiallyEmpty() { + var run = new ConversationMemorySnapshot.WorkflowRunSnapshot(); + assertNotNull(run.getLifecycleTasks()); + assertTrue(run.getLifecycleTasks().isEmpty()); + } + + // --- ResultSnapshot --- + + @Test + void resultSnapshot_constructorSetsFields() { + var ts = new Date(); + var rs = new ConversationMemorySnapshot.ResultSnapshot( + "key1", "result1", List.of("r1"), ts, "wf-1", true); + assertEquals("key1", rs.getKey()); + assertEquals("result1", rs.getResult()); + assertEquals(ts, rs.getTimestamp()); + assertEquals("wf-1", rs.getOriginWorkflowId()); + assertTrue(rs.isPublic()); + assertTrue(rs.isCommitted()); + } + + @Test + void resultSnapshot_constructorWithCommitted() { + var rs = new ConversationMemorySnapshot.ResultSnapshot( + "key1", "val", List.of(), new Date(), "wf-1", false, false); + assertFalse(rs.isPublic()); + assertFalse(rs.isCommitted()); + } + + @Test + void resultSnapshot_setters() { + var rs = new ConversationMemorySnapshot.ResultSnapshot(); + rs.setKey("k"); + rs.setResult("v"); + rs.setPublic(true); + rs.setCommitted(false); + rs.setOriginWorkflowId("wf"); + rs.setTimestamp(new Date(1000L)); + rs.setPossibleResults(List.of("a", "b")); + + assertEquals("k", rs.getKey()); + assertEquals("v", rs.getResult()); + assertTrue(rs.isPublic()); + assertFalse(rs.isCommitted()); + assertEquals("wf", rs.getOriginWorkflowId()); + assertEquals(2, rs.getPossibleResults().size()); + } + + @Test + void resultSnapshot_equals_sameKey_true() { + var rs1 = new ConversationMemorySnapshot.ResultSnapshot( + "key1", "val1", List.of("a"), new Date(), "wf", true); + var rs2 = new ConversationMemorySnapshot.ResultSnapshot( + "key1", "val2", List.of("a"), new Date(), "wf2", false); + assertEquals(rs1, rs2); + } + + @Test + void resultSnapshot_equals_differentKey_false() { + var rs1 = new ConversationMemorySnapshot.ResultSnapshot( + "key1", "val", List.of(), new Date(), "wf", true); + var rs2 = new ConversationMemorySnapshot.ResultSnapshot( + "key2", "val", List.of(), new Date(), "wf", true); + assertNotEquals(rs1, rs2); + } + + @Test + void resultSnapshot_toString_containsKey() { + var rs = new ConversationMemorySnapshot.ResultSnapshot( + "myKey", "myVal", List.of(), new Date(), "wf-1", true); + String str = rs.toString(); + assertTrue(str.contains("myKey")); + assertTrue(str.contains("myVal")); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/memory/model/DataTest.java b/src/test/java/ai/labs/eddi/engine/memory/model/DataTest.java new file mode 100644 index 000000000..6c3d4f548 --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/memory/model/DataTest.java @@ -0,0 +1,115 @@ +package ai.labs.eddi.engine.memory.model; + +import org.junit.jupiter.api.Test; + +import java.util.Date; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class DataTest { + + @Test + void constructor_keyAndResult_setsFields() { + var data = new Data<>("key1", "value1"); + assertEquals("key1", data.getKey()); + assertEquals("value1", data.getResult()); + assertNotNull(data.getTimestamp()); + assertFalse(data.isPublic()); + assertTrue(data.isCommitted()); + } + + @Test + void constructor_withPossibleResults_setsAll() { + var data = new Data<>("key", "a", List.of("a", "b", "c")); + assertEquals("a", data.getResult()); + assertEquals(3, data.getPossibleResults().size()); + } + + @Test + void constructor_withTimestamp_usesIt() { + Date ts = new Date(1000L); + var data = new Data<>("key", "val", List.of("val"), ts); + assertEquals(ts, data.getTimestamp()); + } + + @Test + void constructor_nullResult_choosesRandom() { + var data = new Data<>("key", null, List.of("a", "b")); + assertNotNull(data.getResult()); + assertTrue(List.of("a", "b").contains(data.getResult())); + } + + @Test + void constructor_nullResultEmptyList_returnsNull() { + var data = new Data<>("key", null, List.of()); + assertNull(data.getResult()); + } + + @Test + void setResult_updatesResult() { + var data = new Data<>("key", "old"); + data.setResult("new"); + assertEquals("new", data.getResult()); + } + + @Test + void setPublic_updatesFlag() { + var data = new Data<>("key", "val"); + assertFalse(data.isPublic()); + data.setPublic(true); + assertTrue(data.isPublic()); + } + + @Test + void setCommitted_updatesFlag() { + var data = new Data<>("key", "val"); + assertTrue(data.isCommitted()); + data.setCommitted(false); + assertFalse(data.isCommitted()); + } + + @Test + void setOriginWorkflowId_updatesId() { + var data = new Data<>("key", "val"); + assertNull(data.getOriginWorkflowId()); + data.setOriginWorkflowId("wf-1"); + assertEquals("wf-1", data.getOriginWorkflowId()); + } + + @Test + void equals_sameKey_returnsTrue() { + var data1 = new Data<>("key", "val1"); + var data2 = new Data<>("key", "val2"); + assertEquals(data1, data2); + } + + @Test + void equals_differentKey_returnsFalse() { + var data1 = new Data<>("key1", "val"); + var data2 = new Data<>("key2", "val"); + assertNotEquals(data1, data2); + } + + @Test + void hashCode_sameKey_sameHash() { + var data1 = new Data<>("key", "val1"); + var data2 = new Data<>("key", "val2"); + assertEquals(data1.hashCode(), data2.hashCode()); + } + + @Test + void toString_containsKeyAndResult() { + var data = new Data<>("myKey", "myVal"); + String str = data.toString(); + assertTrue(str.contains("myKey")); + assertTrue(str.contains("myVal")); + } + + @Test + void setPossibleResults_updatesResults() { + var data = new Data<>("key", "a", List.of("a")); + data.setPossibleResults(List.of("x", "y")); + assertEquals(List.of("x", "y"), data.getPossibleResults()); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/model/ContextTest.java b/src/test/java/ai/labs/eddi/engine/model/ContextTest.java new file mode 100644 index 000000000..ccc17bcbb --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/model/ContextTest.java @@ -0,0 +1,70 @@ +package ai.labs.eddi.engine.model; + +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class ContextTest { + + @Test + void defaultConstructor_fieldsNull() { + var ctx = new Context(); + assertNull(ctx.getType()); + assertNull(ctx.getValue()); + } + + @Test + void parameterizedConstructor_setsFields() { + var ctx = new Context(Context.ContextType.string, "hello"); + assertEquals(Context.ContextType.string, ctx.getType()); + assertEquals("hello", ctx.getValue()); + } + + @Test + void setType_updatesType() { + var ctx = new Context(); + ctx.setType(Context.ContextType.object); + assertEquals(Context.ContextType.object, ctx.getType()); + } + + @Test + void setValue_updatesValue() { + var ctx = new Context(); + ctx.setValue(Map.of("key", "val")); + assertNotNull(ctx.getValue()); + } + + @Test + void contextType_string() { + var ctx = new Context(Context.ContextType.string, "text"); + assertEquals("text", ctx.getValue()); + } + + @Test + void contextType_expressions() { + var ctx = new Context(Context.ContextType.expressions, "intent(greeting)"); + assertEquals(Context.ContextType.expressions, ctx.getType()); + } + + @Test + void contextType_object() { + var payload = Map.of("name", "John"); + var ctx = new Context(Context.ContextType.object, payload); + assertEquals(payload, ctx.getValue()); + } + + @Test + void contextType_array() { + var list = List.of("a", "b", "c"); + var ctx = new Context(Context.ContextType.array, list); + assertEquals(list, ctx.getValue()); + } + + @Test + void allContextTypesExist() { + assertEquals(4, Context.ContextType.values().length); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/model/DeploymentTest.java b/src/test/java/ai/labs/eddi/engine/model/DeploymentTest.java new file mode 100644 index 000000000..e49d0965d --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/model/DeploymentTest.java @@ -0,0 +1,81 @@ +package ai.labs.eddi.engine.model; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class DeploymentTest { + + private final ObjectMapper mapper = new ObjectMapper(); + + // --- Environment --- + + @Test + void environment_fromString_production() { + assertEquals(Deployment.Environment.production, + Deployment.Environment.fromString("production")); + } + + @Test + void environment_fromString_test() { + assertEquals(Deployment.Environment.test, + Deployment.Environment.fromString("test")); + } + + @Test + void environment_fromString_null_defaultsToProduction() { + assertEquals(Deployment.Environment.production, + Deployment.Environment.fromString(null)); + } + + @Test + void environment_fromString_unknown_defaultsToProduction() { + assertEquals(Deployment.Environment.production, + Deployment.Environment.fromString("staging")); + } + + @Test + void environment_fromString_legacyUnrestricted_mapsToProduction() { + assertEquals(Deployment.Environment.production, + Deployment.Environment.fromString("unrestricted")); + } + + @Test + void environment_fromString_legacyRestricted_mapsToProduction() { + assertEquals(Deployment.Environment.production, + Deployment.Environment.fromString("restricted")); + } + + @Test + void environment_toValue_returnsName() { + assertEquals("production", Deployment.Environment.production.toValue()); + assertEquals("test", Deployment.Environment.test.toValue()); + } + + @Test + void environment_jacksonRoundTrip() throws Exception { + String json = mapper.writeValueAsString(Deployment.Environment.production); + assertEquals("\"production\"", json); + + Deployment.Environment deserialized = mapper.readValue(json, Deployment.Environment.class); + assertEquals(Deployment.Environment.production, deserialized); + } + + @Test + void environment_jacksonDeserialize_legacy() throws Exception { + assertEquals(Deployment.Environment.production, + mapper.readValue("\"unrestricted\"", Deployment.Environment.class)); + } + + // --- Status --- + + @Test + void status_allValuesExist() { + assertNotNull(Deployment.Status.READY); + assertNotNull(Deployment.Status.IN_PROGRESS); + assertNotNull(Deployment.Status.NOT_FOUND); + assertNotNull(Deployment.Status.ERROR); + assertEquals(4, Deployment.Status.values().length); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/runtime/internal/AgentTest.java b/src/test/java/ai/labs/eddi/engine/runtime/internal/AgentTest.java new file mode 100644 index 000000000..3c7931cc3 --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/runtime/internal/AgentTest.java @@ -0,0 +1,101 @@ +package ai.labs.eddi.engine.runtime.internal; + +import ai.labs.eddi.configs.agents.model.AgentConfiguration; +import ai.labs.eddi.engine.lifecycle.IConversation; +import ai.labs.eddi.engine.memory.ConversationMemory; +import ai.labs.eddi.engine.memory.IConversationMemory; +import ai.labs.eddi.engine.memory.IPropertiesHandler; +import ai.labs.eddi.engine.model.Deployment; +import ai.labs.eddi.engine.runtime.IExecutableWorkflow; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class AgentTest { + + private Agent agent; + + @BeforeEach + void setUp() { + agent = new Agent("agent-1", 3); + } + + @Test + void constructor_setsFields() { + assertEquals("agent-1", agent.getAgentId()); + assertEquals(3, agent.getAgentVersion()); + } + + @Test + void deploymentStatus_defaultNull() { + assertNull(agent.getDeploymentStatus()); + } + + @Test + void setDeploymentStatus_updatesStatus() { + agent.setDeploymentStatus(Deployment.Status.READY); + assertEquals(Deployment.Status.READY, agent.getDeploymentStatus()); + } + + @Test + void userMemoryConfig_defaultNull() { + assertNull(agent.getUserMemoryConfig()); + } + + @Test + void setUserMemoryConfig_updatesConfig() { + var config = new AgentConfiguration.UserMemoryConfig(); + agent.setUserMemoryConfig(config); + assertSame(config, agent.getUserMemoryConfig()); + } + + @Test + void memoryPolicy_defaultNull() { + assertNull(agent.getMemoryPolicy()); + } + + @Test + void setMemoryPolicy_updatesPolicy() { + var policy = new AgentConfiguration.MemoryPolicy(); + agent.setMemoryPolicy(policy); + assertSame(policy, agent.getMemoryPolicy()); + } + + @Test + void addWorkflow_addsSuccessfully() throws IllegalAccessException { + var workflow = mock(IExecutableWorkflow.class); + agent.addWorkflow(workflow); + // No exception means it was added + } + + @Test + void continueConversation_returnsConversationWithMemory() throws Exception { + var memory = new ConversationMemory("conv-1", "agent-1", 3, "user-1"); + var propertiesHandler = mock(IPropertiesHandler.class); + var outputRenderer = mock(IConversation.IConversationOutputRenderer.class); + + IConversation conversation = agent.continueConversation(memory, propertiesHandler, outputRenderer); + + assertNotNull(conversation); + assertSame(memory, conversation.getConversationMemory()); + } + + @Test + void continueConversation_withMemoryPolicy_appliesPolicy() throws Exception { + var policy = new AgentConfiguration.MemoryPolicy(); + agent.setMemoryPolicy(policy); + + var memory = new ConversationMemory("conv-1", "agent-1", 3, "user-1"); + var propertiesHandler = mock(IPropertiesHandler.class); + var outputRenderer = mock(IConversation.IConversationOutputRenderer.class); + + agent.continueConversation(memory, propertiesHandler, outputRenderer); + + assertSame(policy, memory.getMemoryPolicy()); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/output/model/types/OutputItemTypesTest.java b/src/test/java/ai/labs/eddi/modules/output/model/types/OutputItemTypesTest.java new file mode 100644 index 000000000..7270816fe --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/output/model/types/OutputItemTypesTest.java @@ -0,0 +1,175 @@ +package ai.labs.eddi.modules.output.model.types; + +import ai.labs.eddi.modules.output.model.OutputItem; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.Test; + +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class OutputItemTypesTest { + + private final ObjectMapper mapper = new ObjectMapper(); + + // --- TextOutputItem --- + + @Test + void textOutputItem_constructorSetsFields() { + var item = new TextOutputItem("Hello", 500); + assertEquals("text", item.getType()); + assertEquals("Hello", item.getText()); + assertEquals(500, item.getDelay()); + } + + @Test + void textOutputItem_defaultConstructorSetsType() { + var item = new TextOutputItem(); + assertEquals("text", item.getType()); + } + + @Test + void textOutputItem_equalsByContent() { + assertEquals(new TextOutputItem("Hi", 0), new TextOutputItem("Hi", 0)); + assertNotEquals(new TextOutputItem("Hi", 0), new TextOutputItem("Bye", 0)); + } + + @Test + void textOutputItem_toStringReturnsText() { + assertEquals("Hello", new TextOutputItem("Hello").toString()); + } + + @Test + void textOutputItem_jacksonRoundTrip() throws Exception { + var item = new TextOutputItem("Hello", 200); + String json = mapper.writeValueAsString(item); + OutputItem deserialized = mapper.readValue(json, OutputItem.class); + + assertInstanceOf(TextOutputItem.class, deserialized); + assertEquals("Hello", ((TextOutputItem) deserialized).getText()); + assertEquals(200, ((TextOutputItem) deserialized).getDelay()); + } + + // --- ImageOutputItem --- + + @Test + void imageOutputItem_constructorSetsFields() { + var item = new ImageOutputItem("https://img.png", "alt text"); + assertEquals("image", item.getType()); + assertEquals("https://img.png", item.getUri()); + assertEquals("alt text", item.getAlt()); + } + + @Test + void imageOutputItem_equalsByContent() { + assertEquals(new ImageOutputItem("u", "a"), new ImageOutputItem("u", "a")); + assertNotEquals(new ImageOutputItem("u1", "a"), new ImageOutputItem("u2", "a")); + } + + @Test + void imageOutputItem_jacksonRoundTrip() throws Exception { + var item = new ImageOutputItem("https://img.png", "desc"); + String json = mapper.writeValueAsString(item); + OutputItem deserialized = mapper.readValue(json, OutputItem.class); + + assertInstanceOf(ImageOutputItem.class, deserialized); + assertEquals("https://img.png", ((ImageOutputItem) deserialized).getUri()); + } + + // --- ButtonOutputItem --- + + @Test + void buttonOutputItem_constructorSetsFields() { + var item = new ButtonOutputItem("submit", "Click me", Map.of("action", "go")); + assertEquals("button", item.getType()); + assertEquals("submit", item.getButtonType()); + assertEquals("Click me", item.getLabel()); + assertEquals(Map.of("action", "go"), item.getOnPress()); + } + + @Test + void buttonOutputItem_jacksonRoundTrip() throws Exception { + var item = new ButtonOutputItem("link", "Open", Map.of("url", "https://example.com")); + String json = mapper.writeValueAsString(item); + OutputItem deserialized = mapper.readValue(json, OutputItem.class); + + assertInstanceOf(ButtonOutputItem.class, deserialized); + assertEquals("Open", ((ButtonOutputItem) deserialized).getLabel()); + } + + // --- QuickReplyOutputItem --- + + @Test + void quickReplyOutputItem_defaultType() { + var item = new QuickReplyOutputItem(); + assertEquals("quickReply", item.getType()); + } + + @Test + void quickReplyOutputItem_jacksonRoundTrip() throws Exception { + var item = new QuickReplyOutputItem(); + item.setValue("option1"); + item.setExpressions("exp1"); + String json = mapper.writeValueAsString(item); + OutputItem deserialized = mapper.readValue(json, OutputItem.class); + + assertInstanceOf(QuickReplyOutputItem.class, deserialized); + assertEquals("option1", ((QuickReplyOutputItem) deserialized).getValue()); + } + + // --- AgentFaceOutputItem --- + + @Test + void agentFaceOutputItem_defaultType() { + var item = new AgentFaceOutputItem(); + assertEquals("agentFace", item.getType()); + } + + // --- ApplicationLinkOutputItem --- + + @Test + void applicationLinkOutputItem_defaultType() { + var item = new ApplicationLinkOutputItem(); + assertEquals("applicationLink", item.getType()); + } + + // --- InputFieldOutputItem --- + + @Test + void inputFieldOutputItem_defaultType() { + var item = new InputFieldOutputItem(); + assertEquals("inputField", item.getType()); + } + + // --- OtherOutputItem --- + + @Test + void otherOutputItem_typeSetViaSetType() { + var item = new OtherOutputItem(); + // OtherOutputItem has no constructor calling initType() + // Type is normally set by Jackson during deserialization + assertNull(item.getType()); + item.setType("other"); + assertEquals("other", item.getType()); + } + + @Test + void otherOutputItem_mapOperations() { + var item = new OtherOutputItem(); + item.put("custom", "data"); + assertEquals("data", item.get("custom")); + assertEquals(1, item.size()); + assertFalse(item.isEmpty()); + assertTrue(item.containsKey("custom")); + assertTrue(item.containsValue("data")); + } + + @Test + void otherOutputItem_equalsByMap() { + var item1 = new OtherOutputItem(); + item1.put("k", "v"); + var item2 = new OtherOutputItem(); + item2.put("k", "v"); + assertEquals(item1, item2); + } +} diff --git a/src/test/java/ai/labs/eddi/utils/CharacterUtilitiesTest.java b/src/test/java/ai/labs/eddi/utils/CharacterUtilitiesTest.java new file mode 100644 index 000000000..1ca20ce73 --- /dev/null +++ b/src/test/java/ai/labs/eddi/utils/CharacterUtilitiesTest.java @@ -0,0 +1,148 @@ +package ai.labs.eddi.utils; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class CharacterUtilitiesTest { + + // --- isStringInteger --- + + @Test + void isStringInteger_withDigits_returnsTrue() { + assertTrue(CharacterUtilities.isStringInteger("12345")); + } + + @Test + void isStringInteger_withMixed_returnsFalse() { + assertFalse(CharacterUtilities.isStringInteger("123abc")); + } + + @Test + void isStringInteger_withSingleDigit_returnsTrue() { + assertTrue(CharacterUtilities.isStringInteger("0")); + } + + // --- isNumber --- + + @Test + void isNumber_withNull_returnsFalse() { + assertFalse(CharacterUtilities.isNumber(null, false)); + } + + @Test + void isNumber_withEmpty_returnsFalse() { + assertFalse(CharacterUtilities.isNumber("", false)); + } + + @Test + void isNumber_withInteger_returnsTrue() { + assertTrue(CharacterUtilities.isNumber("42", false)); + } + + @Test + void isNumber_withDecimalDot_returnsTrue() { + assertTrue(CharacterUtilities.isNumber("3.14", false)); + } + + @Test + void isNumber_withDecimalComma_returnsTrue() { + assertTrue(CharacterUtilities.isNumber("3,14", false)); + } + + @Test + void isNumber_mustContainComma_withoutComma_returnsFalse() { + assertFalse(CharacterUtilities.isNumber("42", true)); + } + + @Test + void isNumber_mustContainComma_withComma_returnsTrue() { + assertTrue(CharacterUtilities.isNumber("3.14", true)); + } + + @Test + void isNumber_withMultipleDots_returnsFalse() { + assertFalse(CharacterUtilities.isNumber("3.1.4", false)); + } + + @Test + void isNumber_withTrailingDot_returnsFalse() { + assertFalse(CharacterUtilities.isNumber("3.", false)); + } + + @Test + void isNumber_withLetters_returnsFalse() { + assertFalse(CharacterUtilities.isNumber("abc", false)); + } + + // --- deleteUndefinedChars --- + + @Test + void deleteUndefinedChars_removesNonPatternChars() { + String result = CharacterUtilities.deleteUndefinedChars("hello123!", "abcdefghijklmnopqrstuvwxyz"); + assertEquals("hello", result); + } + + @Test + void deleteUndefinedChars_allAllowed_returnsUnchanged() { + String result = CharacterUtilities.deleteUndefinedChars("abc", "abcdefg"); + assertEquals("abc", result); + } + + @Test + void deleteUndefinedChars_stringBuilder_mutatesInPlace() { + StringBuilder sb = new StringBuilder("a1b2c3"); + CharacterUtilities.deleteUndefinedChars(sb, "abc"); + assertEquals("abc", sb.toString()); + } + + // --- convertSpecialCharacter --- + + @Test + void convertSpecialCharacter_umlaut_ae_converts() { + String result = CharacterUtilities.convertSpecialCharacter("ä"); + assertEquals("ae", result); + } + + @Test + void convertSpecialCharacter_umlaut_oe_converts() { + String result = CharacterUtilities.convertSpecialCharacter("ö"); + assertEquals("oe", result); + } + + @Test + void convertSpecialCharacter_umlaut_ue_converts() { + String result = CharacterUtilities.convertSpecialCharacter("ü"); + assertEquals("ue", result); + } + + @Test + void convertSpecialCharacter_eszett_converts() { + String result = CharacterUtilities.convertSpecialCharacter("ß"); + assertEquals("ss", result); + } + + @Test + void convertSpecialCharacter_curlyQuote_convertedToStraight() { + String result = CharacterUtilities.convertSpecialCharacter("\u2018"); // left single curly quote + assertEquals("'", result); + } + + @Test + void convertSpecialCharacter_regularChars_unchanged() { + String result = CharacterUtilities.convertSpecialCharacter("hello"); + assertEquals("hello", result); + } + + @Test + void convertSpecialCharacter_accent_e_convertsToE() { + String result = CharacterUtilities.convertSpecialCharacter("é"); + assertEquals("e", result); + } + + @Test + void convertSpecialCharacter_accent_a_convertsToA() { + String result = CharacterUtilities.convertSpecialCharacter("á"); + assertEquals("a", result); + } +} diff --git a/src/test/java/ai/labs/eddi/utils/CollectionUtilitiesTest.java b/src/test/java/ai/labs/eddi/utils/CollectionUtilitiesTest.java new file mode 100644 index 000000000..0aa8c1a47 --- /dev/null +++ b/src/test/java/ai/labs/eddi/utils/CollectionUtilitiesTest.java @@ -0,0 +1,39 @@ +package ai.labs.eddi.utils; + +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class CollectionUtilitiesTest { + + @Test + void addAllWithoutDuplicates_addsNewItems() { + List collection = new ArrayList<>(List.of("a", "b")); + CollectionUtilities.addAllWithoutDuplicates(collection, List.of("c", "d")); + assertEquals(List.of("a", "b", "c", "d"), collection); + } + + @Test + void addAllWithoutDuplicates_skipsDuplicates() { + List collection = new ArrayList<>(List.of("a", "b")); + CollectionUtilities.addAllWithoutDuplicates(collection, List.of("b", "c")); + assertEquals(List.of("a", "b", "c"), collection); + } + + @Test + void addAllWithoutDuplicates_allDuplicates_noChanges() { + List collection = new ArrayList<>(List.of("a", "b")); + CollectionUtilities.addAllWithoutDuplicates(collection, List.of("a", "b")); + assertEquals(List.of("a", "b"), collection); + } + + @Test + void addAllWithoutDuplicates_emptyAddTo_noChanges() { + List collection = new ArrayList<>(List.of("a")); + CollectionUtilities.addAllWithoutDuplicates(collection, List.of()); + assertEquals(List.of("a"), collection); + } +} diff --git a/src/test/java/ai/labs/eddi/utils/FileUtilitiesTest.java b/src/test/java/ai/labs/eddi/utils/FileUtilitiesTest.java new file mode 100644 index 000000000..3754e7190 --- /dev/null +++ b/src/test/java/ai/labs/eddi/utils/FileUtilitiesTest.java @@ -0,0 +1,68 @@ +package ai.labs.eddi.utils; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; + +import static org.junit.jupiter.api.Assertions.*; + +class FileUtilitiesTest { + + @Test + void readTextFromFile_readsContent(@TempDir Path tempDir) throws IOException { + File file = tempDir.resolve("test.txt").toFile(); + Files.writeString(file.toPath(), "line1\nline2\n"); + + String content = FileUtilities.readTextFromFile(file); + + assertTrue(content.contains("line1")); + assertTrue(content.contains("line2")); + } + + @Test + void readTextFromFile_emptyFile_returnsEmpty(@TempDir Path tempDir) throws IOException { + File file = tempDir.resolve("empty.txt").toFile(); + Files.writeString(file.toPath(), ""); + + String content = FileUtilities.readTextFromFile(file); + + assertEquals("", content); + } + + @Test + void readTextFromFile_nonExistentFile_throwsIOException() { + assertThrows(IOException.class, + () -> FileUtilities.readTextFromFile(new File("/nonexistent/path/file.txt"))); + } + + @Test + void buildPath_twoDirectories_hasTrailingSeparator() { + String path = FileUtilities.buildPath("dir1", "dir2"); + assertTrue(path.endsWith(File.separator)); + } + + @Test + void buildPath_multipleDirectories_joinedWithSeparator() { + String path = FileUtilities.buildPath("dir1", "dir2", "dir3"); + assertTrue(path.contains("dir1")); + assertTrue(path.contains("dir2")); + assertTrue(path.contains("dir3")); + } + + @Test + void buildPath_fileAtEnd_noTrailingSeparator() { + String path = FileUtilities.buildPath("dir1", "file.txt"); + assertFalse(path.endsWith(File.separator)); + } + + @Test + void buildPath_directoriesWithExistingSeparators_handledCorrectly() { + String path = FileUtilities.buildPath("dir1" + File.separator, "dir2"); + // Should not double up separators + assertFalse(path.contains(File.separator + File.separator)); + } +} diff --git a/src/test/java/ai/labs/eddi/utils/LifecycleUtilitiesTest.java b/src/test/java/ai/labs/eddi/utils/LifecycleUtilitiesTest.java new file mode 100644 index 000000000..bcfbc728c --- /dev/null +++ b/src/test/java/ai/labs/eddi/utils/LifecycleUtilitiesTest.java @@ -0,0 +1,34 @@ +package ai.labs.eddi.utils; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class LifecycleUtilitiesTest { + + @Test + void createComponentKey_concatenatesFields() { + String key = LifecycleUtilities.createComponentKey("workflow-1", 3, 0); + assertEquals("workflow-1:3:0", key); + } + + @Test + void createComponentKey_differentVersions_differentKeys() { + String key1 = LifecycleUtilities.createComponentKey("wf", 1, 0); + String key2 = LifecycleUtilities.createComponentKey("wf", 2, 0); + assertNotEquals(key1, key2); + } + + @Test + void createComponentKey_differentSteps_differentKeys() { + String key1 = LifecycleUtilities.createComponentKey("wf", 1, 0); + String key2 = LifecycleUtilities.createComponentKey("wf", 1, 1); + assertNotEquals(key1, key2); + } + + @Test + void createComponentKey_nullWorkflowId_handlesGracefully() { + String key = LifecycleUtilities.createComponentKey(null, 1, 0); + assertEquals("null:1:0", key); + } +} diff --git a/src/test/java/ai/labs/eddi/utils/MatchingUtilitiesTest.java b/src/test/java/ai/labs/eddi/utils/MatchingUtilitiesTest.java new file mode 100644 index 000000000..d6b05a60e --- /dev/null +++ b/src/test/java/ai/labs/eddi/utils/MatchingUtilitiesTest.java @@ -0,0 +1,71 @@ +package ai.labs.eddi.utils; + +import org.junit.jupiter.api.Test; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class MatchingUtilitiesTest { + + @Test + void executeValuePath_equalsMatch_returnsTrue() { + Map values = Map.of("name", "John"); + assertTrue(MatchingUtilities.executeValuePath(values, "name", "John", null)); + } + + @Test + void executeValuePath_equalsMismatch_returnsFalse() { + Map values = Map.of("name", "John"); + assertFalse(MatchingUtilities.executeValuePath(values, "name", "Jane", null)); + } + + @Test + void executeValuePath_containsInString_returnsTrue() { + Map values = Map.of("greeting", "hello world"); + assertTrue(MatchingUtilities.executeValuePath(values, "greeting", null, "world")); + } + + @Test + void executeValuePath_containsInList_returnsTrue() { + Map values = Map.of("tags", List.of("red", "blue", "green")); + assertTrue(MatchingUtilities.executeValuePath(values, "tags", null, "blue")); + } + + @Test + void executeValuePath_containsNotInList_returnsFalse() { + Map values = Map.of("tags", List.of("red", "blue")); + assertFalse(MatchingUtilities.executeValuePath(values, "tags", null, "yellow")); + } + + @Test + void executeValuePath_booleanTrue_returnsTrue() { + Map values = Map.of("active", true); + assertTrue(MatchingUtilities.executeValuePath(values, "active", null, null)); + } + + @Test + void executeValuePath_booleanFalse_returnsFalse() { + Map values = Map.of("active", false); + assertFalse(MatchingUtilities.executeValuePath(values, "active", null, null)); + } + + @Test + void executeValuePath_existsCheck_noEqualsOrContains_returnsTrue() { + Map values = Map.of("key", "anyValue"); + assertTrue(MatchingUtilities.executeValuePath(values, "key", null, null)); + } + + @Test + void executeValuePath_missingKey_returnsFalse() { + Map values = Map.of("other", "value"); + assertFalse(MatchingUtilities.executeValuePath(values, "missing", "something", null)); + } + + @Test + void executeValuePath_emptyMap_returnsFalse() { + assertFalse(MatchingUtilities.executeValuePath(new HashMap<>(), "key", "val", null)); + } +} diff --git a/src/test/java/ai/labs/eddi/utils/RestUtilitiesTest.java b/src/test/java/ai/labs/eddi/utils/RestUtilitiesTest.java new file mode 100644 index 000000000..e21fc2be4 --- /dev/null +++ b/src/test/java/ai/labs/eddi/utils/RestUtilitiesTest.java @@ -0,0 +1,98 @@ +package ai.labs.eddi.utils; + +import ai.labs.eddi.datastore.IResourceStore; +import org.junit.jupiter.api.Test; + +import java.net.URI; + +import static org.junit.jupiter.api.Assertions.*; + +class RestUtilitiesTest { + + // --- createURI --- + + @Test + void createURI_withMultipleParts_concatenatesThem() { + URI uri = RestUtilities.createURI("eddi://ai.labs.agents/", "abc123", "?version=", 1); + assertEquals("eddi://ai.labs.agents/abc123?version=1", uri.toString()); + } + + @Test + void createURI_withSinglePart_returnsThatPart() { + URI uri = RestUtilities.createURI("eddi://ai.labs.agents/abc"); + assertEquals("eddi://ai.labs.agents/abc", uri.toString()); + } + + // --- extractResourceId --- + + @Test + void extractResourceId_withValidEddiUri_extractsIdAndVersion() { + URI uri = URI.create("eddi://ai.labs.agents/agentsstore/agents/5262b802dc6c4008b54c7c0b58100f97?version=3"); + IResourceStore.IResourceId resourceId = RestUtilities.extractResourceId(uri); + + assertNotNull(resourceId); + assertEquals("5262b802dc6c4008b54c7c0b58100f97", resourceId.getId()); + assertEquals(3, resourceId.getVersion()); + } + + @Test + void extractResourceId_withUuidFormat_extractsId() { + URI uri = URI.create("eddi://ai.labs.agents/agentsstore/agents/5262b802-dc6c-4008-b54c-7c0b58100f97?version=1"); + IResourceStore.IResourceId resourceId = RestUtilities.extractResourceId(uri); + + assertNotNull(resourceId); + assertEquals("5262b802-dc6c-4008-b54c-7c0b58100f97", resourceId.getId()); + assertEquals(1, resourceId.getVersion()); + } + + @Test + void extractResourceId_withNoVersion_returnsZeroVersion() { + URI uri = URI.create("eddi://ai.labs.agents/agentsstore/agents/5262b802dc6c4008b54c7c0b58100f97"); + IResourceStore.IResourceId resourceId = RestUtilities.extractResourceId(uri); + + assertNotNull(resourceId); + assertEquals("5262b802dc6c4008b54c7c0b58100f97", resourceId.getId()); + assertEquals(0, resourceId.getVersion()); + } + + @Test + void extractResourceId_withNullUri_returnsNull() { + assertNull(RestUtilities.extractResourceId(null)); + } + + @Test + void extractResourceId_withRelativeUri_extractsId() { + URI uri = URI.create("/agentsstore/agents/5262b802dc6c4008b54c7c0b58100f97?version=2"); + IResourceStore.IResourceId resourceId = RestUtilities.extractResourceId(uri); + + assertNotNull(resourceId); + assertEquals("5262b802dc6c4008b54c7c0b58100f97", resourceId.getId()); + assertEquals(2, resourceId.getVersion()); + } + + @Test + void extractResourceId_withShortPath_returnsNullId() { + // Path with <=2 segments should return null ID + URI uri = URI.create("/agents/?version=1"); + IResourceStore.IResourceId resourceId = RestUtilities.extractResourceId(uri); + + assertNotNull(resourceId); + assertNull(resourceId.getId()); + } + + @Test + void extractResourceId_withInvalidVersion_throwsIllegalArgument() { + URI uri = URI.create("eddi://ai.labs.agents/agentsstore/agents/5262b802dc6c4008b54c7c0b58100f97?version=abc"); + assertThrows(IllegalArgumentException.class, () -> RestUtilities.extractResourceId(uri)); + } + + @Test + void extractResourceId_withTrailingSlash_handlesGracefully() { + URI uri = URI.create("eddi://ai.labs.agents/agentsstore/agents/5262b802dc6c4008b54c7c0b58100f97/"); + IResourceStore.IResourceId resourceId = RestUtilities.extractResourceId(uri); + + assertNotNull(resourceId); + // Trailing slash is stripped, last segment is the ID + assertEquals("5262b802dc6c4008b54c7c0b58100f97", resourceId.getId()); + } +} diff --git a/src/test/java/ai/labs/eddi/utils/RuntimeUtilitiesTest.java b/src/test/java/ai/labs/eddi/utils/RuntimeUtilitiesTest.java new file mode 100644 index 000000000..0e570bda2 --- /dev/null +++ b/src/test/java/ai/labs/eddi/utils/RuntimeUtilitiesTest.java @@ -0,0 +1,144 @@ +package ai.labs.eddi.utils; + +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; + +class RuntimeUtilitiesTest { + + // --- checkNotNull --- + + @Test + void checkNotNull_withNonNull_doesNotThrow() { + assertDoesNotThrow(() -> RuntimeUtilities.checkNotNull("value", "param")); + } + + @Test + void checkNotNull_withNull_throwsIllegalArgument() { + var ex = assertThrows(IllegalArgumentException.class, + () -> RuntimeUtilities.checkNotNull(null, "myParam")); + assertTrue(ex.getMessage().contains("myParam")); + } + + // --- checkNotEmpty --- + + @Test + void checkNotEmpty_withNonEmptyString_doesNotThrow() { + assertDoesNotThrow(() -> RuntimeUtilities.checkNotEmpty("hello", "param")); + } + + @Test + void checkNotEmpty_withEmptyString_throwsIllegalArgument() { + assertThrows(IllegalArgumentException.class, + () -> RuntimeUtilities.checkNotEmpty("", "param")); + } + + @Test + void checkNotEmpty_withNull_throwsIllegalArgument() { + assertThrows(IllegalArgumentException.class, + () -> RuntimeUtilities.checkNotEmpty(null, "param")); + } + + @Test + void checkNotEmpty_withEmptyCollection_throwsIllegalArgument() { + assertThrows(IllegalArgumentException.class, + () -> RuntimeUtilities.checkNotEmpty(List.of(), "param")); + } + + @Test + void checkNotEmpty_withEmptyMap_throwsIllegalArgument() { + assertThrows(IllegalArgumentException.class, + () -> RuntimeUtilities.checkNotEmpty(Map.of(), "param")); + } + + // --- checkCollectionNoNullElements --- + + @Test + void checkCollectionNoNullElements_withValidCollection_doesNotThrow() { + assertDoesNotThrow(() -> RuntimeUtilities.checkCollectionNoNullElements(List.of("a", "b"), "list")); + } + + @Test + void checkCollectionNoNullElements_withNullElement_throwsIllegalArgument() { + List list = new ArrayList<>(); + list.add("a"); + list.add(null); + assertThrows(IllegalArgumentException.class, + () -> RuntimeUtilities.checkCollectionNoNullElements(list, "list")); + } + + @Test + void checkCollectionNoNullElements_withNullCollection_throwsIllegalArgument() { + assertThrows(IllegalArgumentException.class, + () -> RuntimeUtilities.checkCollectionNoNullElements(null, "list")); + } + + // --- checkNotNegative --- + + @Test + void checkNotNegative_withPositive_doesNotThrow() { + assertDoesNotThrow(() -> RuntimeUtilities.checkNotNegative(5, "count")); + } + + @Test + void checkNotNegative_withZero_doesNotThrow() { + assertDoesNotThrow(() -> RuntimeUtilities.checkNotNegative(0, "count")); + } + + @Test + void checkNotNegative_withNegative_throwsIllegalArgument() { + assertThrows(IllegalArgumentException.class, + () -> RuntimeUtilities.checkNotNegative(-1, "count")); + } + + @Test + void checkNotNegative_withNull_throwsIllegalArgument() { + assertThrows(IllegalArgumentException.class, + () -> RuntimeUtilities.checkNotNegative(null, "count")); + } + + // --- isNullOrEmpty --- + + @Test + void isNullOrEmpty_withNull_returnsTrue() { + assertTrue(RuntimeUtilities.isNullOrEmpty(null)); + } + + @Test + void isNullOrEmpty_withEmptyString_returnsTrue() { + assertTrue(RuntimeUtilities.isNullOrEmpty("")); + } + + @Test + void isNullOrEmpty_withNonEmptyString_returnsFalse() { + assertFalse(RuntimeUtilities.isNullOrEmpty("hello")); + } + + @Test + void isNullOrEmpty_withEmptyCollection_returnsTrue() { + assertTrue(RuntimeUtilities.isNullOrEmpty(new ArrayList<>())); + } + + @Test + void isNullOrEmpty_withNonEmptyCollection_returnsFalse() { + assertFalse(RuntimeUtilities.isNullOrEmpty(List.of("a"))); + } + + @Test + void isNullOrEmpty_withEmptyMap_returnsTrue() { + assertTrue(RuntimeUtilities.isNullOrEmpty(new HashMap<>())); + } + + @Test + void isNullOrEmpty_withNonEmptyMap_returnsFalse() { + assertFalse(RuntimeUtilities.isNullOrEmpty(Map.of("k", "v"))); + } + + @Test + void isNullOrEmpty_withNonStringNonCollectionObject_returnsFalse() { + // An arbitrary object that is not String, Collection, or Map + assertFalse(RuntimeUtilities.isNullOrEmpty(42)); + } +} diff --git a/src/test/java/ai/labs/eddi/utils/StringUtilitiesTest.java b/src/test/java/ai/labs/eddi/utils/StringUtilitiesTest.java new file mode 100644 index 000000000..51ff62a07 --- /dev/null +++ b/src/test/java/ai/labs/eddi/utils/StringUtilitiesTest.java @@ -0,0 +1,104 @@ +package ai.labs.eddi.utils; + +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class StringUtilitiesTest { + + // --- convertToSearchString --- + + @Test + void convertToSearchString_plainText_wrapsWithWildcards() { + String result = StringUtilities.convertToSearchString("hello"); + assertEquals(".*hello.*", result); + } + + @Test + void convertToSearchString_quotedText_exactMatch() { + String result = StringUtilities.convertToSearchString("\"hello\""); + assertEquals("hello", result); + } + + @Test + void convertToSearchString_emptyQuotes_returnsEmpty() { + String result = StringUtilities.convertToSearchString("\"\""); + assertEquals("", result); + } + + @Test + void convertToSearchString_withRegexMetaChars_escapedProperly() { + String result = StringUtilities.convertToSearchString("a+b*c"); + // Should escape + and * as regex meta-characters + assertTrue(result.contains("\\+")); + assertTrue(result.contains("\\*")); + } + + @Test + void convertToSearchString_quotedWithRegexMetaChars_escapedProperly() { + String result = StringUtilities.convertToSearchString("\"a(b)c\""); + assertTrue(result.contains("\\(")); + assertTrue(result.contains("\\)")); + } + + // --- escapeRegexChars --- + + @Test + void escapeRegexChars_noSpecialChars_returnsUnchanged() { + assertEquals("hello", StringUtilities.escapeRegexChars("hello")); + } + + @Test + void escapeRegexChars_allSpecialChars_allEscaped() { + String input = ".*+?()[]{}|^$\\"; + String result = StringUtilities.escapeRegexChars(input); + // Each special char should be preceded by backslash + for (char c : input.toCharArray()) { + assertTrue(result.contains("\\" + c)); + } + } + + // --- joinStrings --- + + @Test + void joinStrings_withDelimiter_joinsCorrectly() { + assertEquals("a,b,c", StringUtilities.joinStrings(",", "a", "b", "c")); + } + + @Test + void joinStrings_withNullValues_skipsNulls() { + assertEquals("a,c", StringUtilities.joinStrings(",", "a", null, "c")); + } + + @Test + void joinStrings_withCollection_joinsCorrectly() { + assertEquals("a-b-c", StringUtilities.joinStrings("-", List.of("a", "b", "c"))); + } + + @Test + void joinStrings_withEmptyArray_returnsEmpty() { + assertEquals("", StringUtilities.joinStrings(",")); + } + + // --- parseCommaSeparatedString --- + + @Test + void parseCommaSeparatedString_standard_parsesCorrectly() { + List result = StringUtilities.parseCommaSeparatedString("a, b, c"); + assertEquals(List.of("a", "b", "c"), result); + } + + @Test + void parseCommaSeparatedString_noSpaces_parsesCorrectly() { + List result = StringUtilities.parseCommaSeparatedString("x,y,z"); + assertEquals(List.of("x", "y", "z"), result); + } + + @Test + void parseCommaSeparatedString_singleItem_returnsSingleElement() { + List result = StringUtilities.parseCommaSeparatedString("only"); + assertEquals(List.of("only"), result); + } +} diff --git a/src/test/java/ai/labs/eddi/utils/WordSplitterTest.java b/src/test/java/ai/labs/eddi/utils/WordSplitterTest.java new file mode 100644 index 000000000..c882dd50e --- /dev/null +++ b/src/test/java/ai/labs/eddi/utils/WordSplitterTest.java @@ -0,0 +1,49 @@ +package ai.labs.eddi.utils; + +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class WordSplitterTest { + + @Test + void splitWords_punctuationAtEnd_addSpaces() { + StringBuilder sb = new StringBuilder("hello!"); + new WordSplitter(sb).splitWords(); + assertTrue(sb.toString().contains(" !")); + } + + @Test + void splitWords_commaInSentence_addSpaces() { + StringBuilder sb = new StringBuilder("hello,world"); + new WordSplitter(sb).splitWords(); + assertTrue(sb.toString().contains(" ,")); + } + + @Test + void splitWords_dotBetweenDigits_noSplit() { + StringBuilder sb = new StringBuilder("value is 3.14 ok"); + new WordSplitter(sb).splitWords(); + assertTrue(sb.toString().contains("3.14")); + } + + @Test + void splitWords_noPunctuation_unchanged() { + StringBuilder sb = new StringBuilder("hello world"); + new WordSplitter(sb).splitWords(); + assertEquals("hello world", sb.toString()); + } + + @Test + void capitalizedWords_insertsSpaces() { + StringBuilder sb = new StringBuilder("helloWorld"); + new WordSplitter(sb).capitalizedWords(); + assertTrue(sb.toString().contains(" W")); + } + + @Test + void notAlphabetic_separatesSpecialChars() { + StringBuilder sb = new StringBuilder("hello@world"); + new WordSplitter(sb).notAlphabetic(); + assertTrue(sb.toString().contains(" @ ")); + } +} From 646d325d06012de57766715fc08188b7b3bdc9a1 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Sun, 19 Apr 2026 12:42:29 +0200 Subject: [PATCH 002/124] test(coverage): add model/config/engine test suites (batch 2) New test files: - ApiCallModels: RetryApiCallInstruction, Request, PostResponse, ApiCall - HttpCodeValidator: default config, construction, setters - PropertyModel: Property (6 constructors, scope, visibility, equality), PropertyInstruction (defaults, construction, equality) - AuditEntry: immutable with* methods, chaining - LogEntry: record construction, Jackson null-exclusion, round-trip - ScheduleConfiguration: defaults, all fields, enums, Jackson - InMemoryTenantQuotaStore: atomic limits, cost budget, usage reporting - RejectedExecutionExceptionMapper: HTTP 503, Retry-After header - LifecycleUtilities: component key composition Coverage: 45.9% -> 46.3% line, 41.3% -> 41.4% branch All 2545 tests pass. --- .../apicalls/model/ApiCallModelsTest.java | 150 +++++++++++++ .../apicalls/model/HttpCodeValidatorTest.java | 51 +++++ .../properties/model/PropertyModelTest.java | 199 ++++++++++++++++++ .../engine/audit/model/AuditEntryTest.java | 116 ++++++++++ .../RejectedExecutionExceptionMapperTest.java | 54 +++++ .../labs/eddi/engine/model/LogEntryTest.java | 86 ++++++++ .../model/ScheduleConfigurationTest.java | 115 ++++++++++ .../tenancy/InMemoryTenantQuotaStoreTest.java | 183 ++++++++++++++++ 8 files changed, 954 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/configs/apicalls/model/ApiCallModelsTest.java create mode 100644 src/test/java/ai/labs/eddi/configs/apicalls/model/HttpCodeValidatorTest.java create mode 100644 src/test/java/ai/labs/eddi/configs/properties/model/PropertyModelTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/audit/model/AuditEntryTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/exception/RejectedExecutionExceptionMapperTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/model/LogEntryTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/schedule/model/ScheduleConfigurationTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/tenancy/InMemoryTenantQuotaStoreTest.java diff --git a/src/test/java/ai/labs/eddi/configs/apicalls/model/ApiCallModelsTest.java b/src/test/java/ai/labs/eddi/configs/apicalls/model/ApiCallModelsTest.java new file mode 100644 index 000000000..00ccef843 --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/apicalls/model/ApiCallModelsTest.java @@ -0,0 +1,150 @@ +package ai.labs.eddi.configs.apicalls.model; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class ApiCallModelsTest { + + private final ObjectMapper mapper = new ObjectMapper(); + + // --- RetryApiCallInstruction --- + + @Test + void retryInstruction_defaultValues() { + var retry = new RetryApiCallInstruction(); + assertEquals(3, retry.getMaxRetries()); + assertEquals(1000, retry.getExponentialBackoffDelayInMillis()); + assertTrue(retry.getRetryOnHttpCodes().contains(502)); + assertTrue(retry.getRetryOnHttpCodes().contains(503)); + } + + @Test + void retryInstruction_constructor() { + var retry = new RetryApiCallInstruction(5, 2000, List.of(500, 502), null); + assertEquals(5, retry.getMaxRetries()); + assertEquals(2000, retry.getExponentialBackoffDelayInMillis()); + assertEquals(2, retry.getRetryOnHttpCodes().size()); + assertNull(retry.getResponseValuePathMatchers()); + } + + @Test + void retryInstruction_setters() { + var retry = new RetryApiCallInstruction(); + retry.setMaxRetries(10); + retry.setExponentialBackoffDelayInMillis(5000); + retry.setRetryOnHttpCodes(List.of(429)); + assertEquals(10, retry.getMaxRetries()); + assertEquals(5000, retry.getExponentialBackoffDelayInMillis()); + } + + @Test + void matchingInfo_settersAndGetters() { + var info = new RetryApiCallInstruction.MatchingInfo(); + info.setValuePath("response.status"); + info.setContains("error"); + info.setEquals("FAILED"); + info.setTrueIfNoMatch(true); + + assertEquals("response.status", info.getValuePath()); + assertEquals("error", info.getContains()); + assertEquals("FAILED", info.getEquals()); + assertTrue(info.getTrueIfNoMatch()); + } + + @Test + void matchingInfo_defaultTrueIfNoMatch() { + var info = new RetryApiCallInstruction.MatchingInfo(); + assertFalse(info.getTrueIfNoMatch()); + } + + @Test + void retryInstruction_jacksonRoundTrip() throws Exception { + var retry = new RetryApiCallInstruction(2, 500, List.of(503), null); + String json = mapper.writeValueAsString(retry); + assertTrue(json.contains("\"maxRetries\":2")); + + var deserialized = mapper.readValue(json, RetryApiCallInstruction.class); + assertEquals(2, deserialized.getMaxRetries()); + assertEquals(500, deserialized.getExponentialBackoffDelayInMillis()); + } + + // --- Request --- + + @Test + void request_defaultValues() { + var request = new Request(); + assertEquals("", request.getPath()); + assertEquals("", request.getBody()); + assertNotNull(request.getHeaders()); + assertEquals("GET", request.getMethod()); + } + + @Test + void request_setters() { + var request = new Request(); + request.setPath("/api/weather"); + request.setMethod("POST"); + request.setBody("{ \"key\": \"value\" }"); + request.setContentType("application/json"); + + assertEquals("/api/weather", request.getPath()); + assertEquals("POST", request.getMethod()); + assertEquals("{ \"key\": \"value\" }", request.getBody()); + assertEquals("application/json", request.getContentType()); + } + + @Test + void request_headersAndQueryParams() { + var request = new Request(); + request.getHeaders().put("Authorization", "Bearer token"); + request.getQueryParams().put("q", "search"); + + assertEquals("Bearer token", request.getHeaders().get("Authorization")); + assertEquals("search", request.getQueryParams().get("q")); + } + + // --- PostResponse --- + + @Test + void postResponse_defaultNull() { + var pr = new PostResponse(); + assertNull(pr.getPropertyInstructions()); + assertNull(pr.getOutputBuildInstructions()); + assertNull(pr.getQrBuildInstructions()); + } + + @Test + void postResponse_setters() { + var pr = new PostResponse(); + pr.setPropertyInstructions(List.of()); + pr.setOutputBuildInstructions(List.of()); + pr.setQrBuildInstructions(List.of()); + assertNotNull(pr.getPropertyInstructions()); + assertNotNull(pr.getOutputBuildInstructions()); + assertNotNull(pr.getQrBuildInstructions()); + } + + // --- ApiCall --- + + @Test + void apiCall_setters() { + var call = new ApiCall(); + call.setName("weather-api"); + call.setActions(List.of("fetch_weather")); + call.setSaveResponse(true); + + assertEquals("weather-api", call.getName()); + assertEquals(List.of("fetch_weather"), call.getActions()); + assertTrue(call.getSaveResponse()); + } + + @Test + void apiCall_defaultSaveResponse() { + var call = new ApiCall(); + assertFalse(call.getSaveResponse()); // defaults to false + } +} diff --git a/src/test/java/ai/labs/eddi/configs/apicalls/model/HttpCodeValidatorTest.java b/src/test/java/ai/labs/eddi/configs/apicalls/model/HttpCodeValidatorTest.java new file mode 100644 index 000000000..5e21f2466 --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/apicalls/model/HttpCodeValidatorTest.java @@ -0,0 +1,51 @@ +package ai.labs.eddi.configs.apicalls.model; + +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class HttpCodeValidatorTest { + + @Test + void default_runsOn200And201() { + assertTrue(HttpCodeValidator.DEFAULT.getRunOnHttpCode().contains(200)); + assertTrue(HttpCodeValidator.DEFAULT.getRunOnHttpCode().contains(201)); + } + + @Test + void default_skipsOn400Plus() { + assertTrue(HttpCodeValidator.DEFAULT.getSkipOnHttpCode().contains(400)); + assertTrue(HttpCodeValidator.DEFAULT.getSkipOnHttpCode().contains(500)); + } + + @Test + void default_skipsOn0() { + // 0 means "no HTTP code" (e.g. connection failure) + assertTrue(HttpCodeValidator.DEFAULT.getSkipOnHttpCode().contains(0)); + } + + @Test + void constructor_setsFields() { + var v = new HttpCodeValidator(List.of(200), List.of(500)); + assertEquals(List.of(200), v.getRunOnHttpCode()); + assertEquals(List.of(500), v.getSkipOnHttpCode()); + } + + @Test + void defaultConstructor_nullFields() { + var v = new HttpCodeValidator(); + assertNull(v.getRunOnHttpCode()); + assertNull(v.getSkipOnHttpCode()); + } + + @Test + void setters() { + var v = new HttpCodeValidator(); + v.setRunOnHttpCode(List.of(201)); + v.setSkipOnHttpCode(List.of(400)); + assertEquals(List.of(201), v.getRunOnHttpCode()); + assertEquals(List.of(400), v.getSkipOnHttpCode()); + } +} diff --git a/src/test/java/ai/labs/eddi/configs/properties/model/PropertyModelTest.java b/src/test/java/ai/labs/eddi/configs/properties/model/PropertyModelTest.java new file mode 100644 index 000000000..a575b778b --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/properties/model/PropertyModelTest.java @@ -0,0 +1,199 @@ +package ai.labs.eddi.configs.properties.model; + +import ai.labs.eddi.configs.apicalls.model.HttpCodeValidator; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class PropertyModelTest { + + // ─── Property ────────────────────────────────── + + @Nested + class PropertyTests { + + @Test + void stringConstructor_setsFields() { + var p = new Property("name", "value", Property.Scope.conversation); + assertEquals("name", p.getName()); + assertEquals("value", p.getValueString()); + assertEquals(Property.Scope.conversation, p.getScope()); + } + + @Test + void mapConstructor_setsFields() { + var map = Map.of("key", (Object) "val"); + var p = new Property("name", map, Property.Scope.longTerm); + assertEquals(map, p.getValueObject()); + assertEquals(Property.Scope.longTerm, p.getScope()); + } + + @Test + void listConstructor_setsFields() { + var list = List.of((Object) "a", "b"); + var p = new Property("items", list, Property.Scope.step); + assertEquals(list, p.getValueList()); + } + + @Test + void intConstructor_setsFields() { + var p = new Property("count", 42, Property.Scope.conversation); + assertEquals(42, p.getValueInt()); + } + + @Test + void floatConstructor_setsFields() { + var p = new Property("temp", 36.5f, Property.Scope.conversation); + assertEquals(36.5f, p.getValueFloat()); + } + + @Test + void booleanConstructor_setsFields() { + var p = new Property("active", true, Property.Scope.longTerm); + assertTrue(p.getValueBoolean()); + } + + @Test + void defaultScope_isConversation() { + var p = new Property(); + assertEquals(Property.Scope.conversation, p.getScope()); + } + + @Test + void effectiveVisibility_null_defaultsSelf() { + var p = new Property("name", "val", Property.Scope.longTerm); + assertNull(p.getVisibility()); + assertEquals(Property.Visibility.self, p.effectiveVisibility()); + } + + @Test + void effectiveVisibility_explicit_returnsSet() { + var p = new Property("name", "val", Property.Scope.longTerm); + p.setVisibility(Property.Visibility.global); + assertEquals(Property.Visibility.global, p.effectiveVisibility()); + } + + @Test + void equals_sameValues_true() { + var p1 = new Property("n", "v", Property.Scope.step); + var p2 = new Property("n", "v", Property.Scope.step); + assertEquals(p1, p2); + assertEquals(p1.hashCode(), p2.hashCode()); + } + + @Test + void equals_differentName_false() { + var p1 = new Property("n1", "v", Property.Scope.step); + var p2 = new Property("n2", "v", Property.Scope.step); + assertNotEquals(p1, p2); + } + + @Test + void equals_differentScope_false() { + var p1 = new Property("n", "v", Property.Scope.step); + var p2 = new Property("n", "v", Property.Scope.longTerm); + assertNotEquals(p1, p2); + } + + @Test + void equals_differentVisibility_false() { + var p1 = new Property("n", "v", null, null, null, null, null, + Property.Scope.longTerm, Property.Visibility.self); + var p2 = new Property("n", "v", null, null, null, null, null, + Property.Scope.longTerm, Property.Visibility.global); + assertNotEquals(p1, p2); + } + + @Test + void allScopeValues() { + assertEquals(4, Property.Scope.values().length); + assertNotNull(Property.Scope.step); + assertNotNull(Property.Scope.conversation); + assertNotNull(Property.Scope.longTerm); + assertNotNull(Property.Scope.secret); + } + + @Test + void allVisibilityValues() { + assertEquals(3, Property.Visibility.values().length); + assertNotNull(Property.Visibility.self); + assertNotNull(Property.Visibility.group); + assertNotNull(Property.Visibility.global); + } + } + + // ─── PropertyInstruction ─────────────────────── + + @Nested + class PropertyInstructionTests { + + @Test + void defaults() { + var pi = new PropertyInstruction(); + assertEquals("", pi.getFromObjectPath()); + assertEquals("", pi.getToObjectPath()); + assertFalse(pi.getConvertToObject()); + assertTrue(pi.getOverride()); + assertFalse(pi.getRunOnValidationError()); + assertNull(pi.getHttpCodeValidator()); + } + + @Test + void constructor_setsAllFields() { + var validator = new HttpCodeValidator(List.of(200), List.of(500)); + var pi = new PropertyInstruction("from.path", "to.path", true, false, true, validator); + + assertEquals("from.path", pi.getFromObjectPath()); + assertEquals("to.path", pi.getToObjectPath()); + assertTrue(pi.getConvertToObject()); + assertFalse(pi.getOverride()); + assertTrue(pi.getRunOnValidationError()); + assertNotNull(pi.getHttpCodeValidator()); + } + + @Test + void setters() { + var pi = new PropertyInstruction(); + pi.setFromObjectPath("memory.current.output"); + pi.setToObjectPath("properties.result"); + pi.setConvertToObject(true); + pi.setOverride(false); + pi.setRunOnValidationError(true); + pi.setHttpCodeValidator(HttpCodeValidator.DEFAULT); + + assertEquals("memory.current.output", pi.getFromObjectPath()); + assertEquals("properties.result", pi.getToObjectPath()); + assertTrue(pi.getConvertToObject()); + assertFalse(pi.getOverride()); + assertTrue(pi.getRunOnValidationError()); + assertNotNull(pi.getHttpCodeValidator()); + } + + @Test + void equals_sameFields_true() { + var pi1 = new PropertyInstruction("fp", "tp", false, true, false, null); + pi1.setName("prop"); + pi1.setValueString("val"); + pi1.setScope(Property.Scope.conversation); + + var pi2 = new PropertyInstruction("fp", "tp", false, true, false, null); + pi2.setName("prop"); + pi2.setValueString("val"); + pi2.setScope(Property.Scope.conversation); + + assertEquals(pi1, pi2); + assertEquals(pi1.hashCode(), pi2.hashCode()); + } + + @Test + void equals_differentFromPath_false() { + var pi1 = new PropertyInstruction("path1", "", false, true, false, null); + var pi2 = new PropertyInstruction("path2", "", false, true, false, null); + assertNotEquals(pi1, pi2); + } + } +} diff --git a/src/test/java/ai/labs/eddi/engine/audit/model/AuditEntryTest.java b/src/test/java/ai/labs/eddi/engine/audit/model/AuditEntryTest.java new file mode 100644 index 000000000..646e8cd1d --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/audit/model/AuditEntryTest.java @@ -0,0 +1,116 @@ +package ai.labs.eddi.engine.audit.model; + +import org.junit.jupiter.api.Test; + +import java.time.Instant; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class AuditEntryTest { + + private AuditEntry createSample() { + return new AuditEntry( + "entry-1", "conv-1", "agent-1", 3, "user-1", "production", + 0, "ai.labs.parser", "expressions", 0, 150L, + Map.of("userInput", "Hello"), + Map.of("output", List.of("Hi there!")), + null, null, + List.of("greeting"), + 0.001, + Instant.now(), + null, null); + } + + @Test + void constructor_setsAllFields() { + var entry = createSample(); + assertEquals("entry-1", entry.id()); + assertEquals("conv-1", entry.conversationId()); + assertEquals("agent-1", entry.agentId()); + assertEquals(3, entry.agentVersion()); + assertEquals("user-1", entry.userId()); + assertEquals("production", entry.environment()); + assertEquals(0, entry.stepIndex()); + assertEquals("ai.labs.parser", entry.taskId()); + assertEquals("expressions", entry.taskType()); + assertEquals(0, entry.taskIndex()); + assertEquals(150L, entry.durationMs()); + assertEquals("Hello", entry.input().get("userInput")); + assertEquals(List.of("greeting"), entry.actions()); + assertEquals(0.001, entry.cost(), 0.0001); + assertNotNull(entry.timestamp()); + assertNull(entry.hmac()); + assertNull(entry.agentSignature()); + } + + @Test + void withEnvironment_preservesOtherFields() { + var entry = createSample(); + var updated = entry.withEnvironment("test"); + + assertEquals("test", updated.environment()); + assertEquals(entry.id(), updated.id()); + assertEquals(entry.conversationId(), updated.conversationId()); + assertEquals(entry.agentId(), updated.agentId()); + assertEquals(entry.taskId(), updated.taskId()); + assertEquals(entry.durationMs(), updated.durationMs()); + } + + @Test + void withEnvironment_doesNotMutateOriginal() { + var entry = createSample(); + entry.withEnvironment("staging"); + assertEquals("production", entry.environment()); + } + + @Test + void withHmac_setsHmac() { + var entry = createSample(); + var signed = entry.withHmac("abc123hmac"); + + assertEquals("abc123hmac", signed.hmac()); + assertEquals(entry.id(), signed.id()); + assertEquals(entry.environment(), signed.environment()); + } + + @Test + void withHmac_doesNotMutateOriginal() { + var entry = createSample(); + entry.withHmac("hmac-value"); + assertNull(entry.hmac()); + } + + @Test + void withAgentSignature_setsSignature() { + var entry = createSample(); + var signed = entry.withAgentSignature("sig-xyz"); + + assertEquals("sig-xyz", signed.agentSignature()); + assertEquals(entry.id(), signed.id()); + assertNull(signed.hmac()); // hmac was null originally + } + + @Test + void withAgentSignature_doesNotMutateOriginal() { + var entry = createSample(); + entry.withAgentSignature("sig"); + assertNull(entry.agentSignature()); + } + + @Test + void chaining_withMethods() { + var entry = createSample() + .withEnvironment("staging") + .withHmac("hmac-123") + .withAgentSignature("sig-456"); + + assertEquals("staging", entry.environment()); + assertEquals("hmac-123", entry.hmac()); + assertEquals("sig-456", entry.agentSignature()); + // All other fields preserved + assertEquals("entry-1", entry.id()); + assertEquals("conv-1", entry.conversationId()); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/exception/RejectedExecutionExceptionMapperTest.java b/src/test/java/ai/labs/eddi/engine/exception/RejectedExecutionExceptionMapperTest.java new file mode 100644 index 000000000..b5e53206d --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/exception/RejectedExecutionExceptionMapperTest.java @@ -0,0 +1,54 @@ +package ai.labs.eddi.engine.exception; + +import jakarta.ws.rs.core.Response; +import org.junit.jupiter.api.Test; + +import java.util.Map; +import java.util.concurrent.RejectedExecutionException; + +import static org.junit.jupiter.api.Assertions.*; + +class RejectedExecutionExceptionMapperTest { + + private final RejectedExecutionExceptionMapper mapper = new RejectedExecutionExceptionMapper(); + + @Test + void toResponse_returns503() { + var ex = new RejectedExecutionException("Capacity exceeded"); + Response response = mapper.toResponse(ex); + assertEquals(503, response.getStatus()); + } + + @Test + void toResponse_containsRetryAfterHeader() { + var ex = new RejectedExecutionException("too busy"); + Response response = mapper.toResponse(ex); + assertEquals("5", response.getHeaderString("Retry-After")); + } + + @Test + @SuppressWarnings("unchecked") + void toResponse_containsErrorBody() { + var ex = new RejectedExecutionException("Queue full"); + Response response = mapper.toResponse(ex); + Map body = (Map) response.getEntity(); + assertEquals("capacity_exceeded", body.get("error")); + assertEquals("Queue full", body.get("message")); + } + + @Test + @SuppressWarnings("unchecked") + void toResponse_nullMessage_usesDefault() { + var ex = new RejectedExecutionException((String) null); + Response response = mapper.toResponse(ex); + Map body = (Map) response.getEntity(); + assertEquals("Service temporarily unavailable", body.get("message")); + } + + @Test + void toResponse_contentTypeIsJson() { + var ex = new RejectedExecutionException("test"); + Response response = mapper.toResponse(ex); + assertTrue(response.getMediaType().toString().contains("application/json")); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/model/LogEntryTest.java b/src/test/java/ai/labs/eddi/engine/model/LogEntryTest.java new file mode 100644 index 000000000..251d8fcb8 --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/model/LogEntryTest.java @@ -0,0 +1,86 @@ +package ai.labs.eddi.engine.model; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class LogEntryTest { + + private final ObjectMapper mapper = new ObjectMapper(); + + @Test + void constructor_setsAllFields() { + var entry = new LogEntry( + 1000L, "INFO", "ai.labs.test", "Test message", + "production", "agent-1", 3, "conv-1", "user-1", "inst-1"); + + assertEquals(1000L, entry.timestamp()); + assertEquals("INFO", entry.level()); + assertEquals("ai.labs.test", entry.loggerName()); + assertEquals("Test message", entry.message()); + assertEquals("production", entry.environment()); + assertEquals("agent-1", entry.agentId()); + assertEquals(3, entry.agentVersion()); + assertEquals("conv-1", entry.conversationId()); + assertEquals("user-1", entry.userId()); + assertEquals("inst-1", entry.instanceId()); + } + + @Test + void nullableFields_allowNull() { + var entry = new LogEntry( + 0L, "WARN", null, "msg", + null, null, null, null, null, null); + + assertNull(entry.loggerName()); + assertNull(entry.environment()); + assertNull(entry.agentId()); + assertNull(entry.agentVersion()); + assertNull(entry.conversationId()); + assertNull(entry.userId()); + assertNull(entry.instanceId()); + } + + @Test + void jacksonSerialization_excludesNulls() throws Exception { + var entry = new LogEntry( + 1000L, "INFO", "logger", "msg", + null, null, null, null, null, null); + + String json = mapper.writeValueAsString(entry); + assertFalse(json.contains("agentId")); + assertFalse(json.contains("conversationId")); + assertTrue(json.contains("\"level\":\"INFO\"")); + } + + @Test + void jacksonRoundTrip() throws Exception { + var entry = new LogEntry( + 5000L, "ERROR", "ai.labs.eddi", "Something went wrong", + "test", "agent-2", 1, "conv-5", "user-3", "inst-7"); + + String json = mapper.writeValueAsString(entry); + LogEntry restored = mapper.readValue(json, LogEntry.class); + + assertEquals(entry.timestamp(), restored.timestamp()); + assertEquals(entry.level(), restored.level()); + assertEquals(entry.message(), restored.message()); + assertEquals(entry.agentId(), restored.agentId()); + assertEquals(entry.conversationId(), restored.conversationId()); + } + + @Test + void equals_sameValues_true() { + var e1 = new LogEntry(1L, "INFO", "l", "m", null, null, null, null, null, null); + var e2 = new LogEntry(1L, "INFO", "l", "m", null, null, null, null, null, null); + assertEquals(e1, e2); + } + + @Test + void equals_differentValues_false() { + var e1 = new LogEntry(1L, "INFO", "l", "m1", null, null, null, null, null, null); + var e2 = new LogEntry(1L, "INFO", "l", "m2", null, null, null, null, null, null); + assertNotEquals(e1, e2); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/schedule/model/ScheduleConfigurationTest.java b/src/test/java/ai/labs/eddi/engine/schedule/model/ScheduleConfigurationTest.java new file mode 100644 index 000000000..bfc836d5e --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/schedule/model/ScheduleConfigurationTest.java @@ -0,0 +1,115 @@ +package ai.labs.eddi.engine.schedule.model; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule; +import org.junit.jupiter.api.Test; + +import java.time.Instant; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class ScheduleConfigurationTest { + + private final ObjectMapper mapper = new ObjectMapper().registerModule(new JavaTimeModule()); + + @Test + void defaults() { + var config = new ScheduleConfiguration(); + assertEquals(ScheduleConfiguration.TriggerType.CRON, config.getTriggerType()); + assertTrue(config.isEnabled()); + assertEquals(ScheduleConfiguration.FireStatus.PENDING, config.getFireStatus()); + assertEquals(-1.0, config.getMaxCostPerFire()); + assertFalse(config.isAllowSelfScheduling()); + } + + @Test + void triggerType_heartbeat() { + var config = new ScheduleConfiguration(); + config.setTriggerType(ScheduleConfiguration.TriggerType.HEARTBEAT); + config.setHeartbeatIntervalSeconds(300L); + + assertEquals(ScheduleConfiguration.TriggerType.HEARTBEAT, config.getTriggerType()); + assertEquals(300L, config.getHeartbeatIntervalSeconds()); + } + + @Test + void cronConfiguration() { + var config = new ScheduleConfiguration(); + config.setCronExpression("0 9 * * MON-FRI"); + config.setTimeZone("Europe/Vienna"); + + assertEquals("0 9 * * MON-FRI", config.getCronExpression()); + assertEquals("Europe/Vienna", config.getTimeZone()); + } + + @Test + void setAllFields() { + var now = Instant.now(); + var config = new ScheduleConfiguration(); + + config.setId("sched-1"); + config.setName("Morning Brief"); + config.setAgentId("agent-1"); + config.setAgentVersion(3); + config.setEnvironment("production"); + config.setTenantId("default"); + config.setMessage("Good morning"); + config.setUserId("system:scheduler"); + config.setConversationStrategy("persistent"); + config.setPersistentConversationId("conv-123"); + config.setEnabled(false); + config.setNextFire(now); + config.setLastFired(now.minusSeconds(3600)); + config.setFireStatus(ScheduleConfiguration.FireStatus.COMPLETED); + config.setClaimedBy("instance-1"); + config.setClaimedAt(now.minusSeconds(60)); + config.setFireId("sched-1:12345"); + config.setFailCount(2); + config.setNextRetryAt(now.plusSeconds(30)); + config.setMaxCostPerFire(5.0); + config.setAllowSelfScheduling(true); + config.setCreatedBy("admin"); + config.setMetadata(Map.of("env", "test")); + config.setCreatedAt(now); + config.setUpdatedAt(now); + config.setCronDescription("Every weekday at 9am"); + + assertEquals("sched-1", config.getId()); + assertEquals("Morning Brief", config.getName()); + assertEquals("agent-1", config.getAgentId()); + assertEquals(3, config.getAgentVersion()); + assertFalse(config.isEnabled()); + assertEquals(ScheduleConfiguration.FireStatus.COMPLETED, config.getFireStatus()); + assertEquals(2, config.getFailCount()); + assertEquals(5.0, config.getMaxCostPerFire()); + assertTrue(config.isAllowSelfScheduling()); + assertEquals("Every weekday at 9am", config.getCronDescription()); + } + + @Test + void fireStatus_allValues() { + assertEquals(6, ScheduleConfiguration.FireStatus.values().length); + } + + @Test + void triggerType_allValues() { + assertEquals(2, ScheduleConfiguration.TriggerType.values().length); + } + + @Test + void jacksonRoundTrip() throws Exception { + var config = new ScheduleConfiguration(); + config.setId("s1"); + config.setName("Test"); + config.setAgentId("a1"); + config.setCronExpression("0 * * * *"); + + String json = mapper.writeValueAsString(config); + var restored = mapper.readValue(json, ScheduleConfiguration.class); + + assertEquals("s1", restored.getId()); + assertEquals("Test", restored.getName()); + assertEquals("0 * * * *", restored.getCronExpression()); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/tenancy/InMemoryTenantQuotaStoreTest.java b/src/test/java/ai/labs/eddi/engine/tenancy/InMemoryTenantQuotaStoreTest.java new file mode 100644 index 000000000..5aaeb2667 --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/tenancy/InMemoryTenantQuotaStoreTest.java @@ -0,0 +1,183 @@ +package ai.labs.eddi.engine.tenancy; + +import ai.labs.eddi.engine.tenancy.model.QuotaCheckResult; +import ai.labs.eddi.engine.tenancy.model.TenantQuota; +import ai.labs.eddi.engine.tenancy.model.UsageSnapshot; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class InMemoryTenantQuotaStoreTest { + + private InMemoryTenantQuotaStore store; + + @BeforeEach + void setUp() { + var quota = new TenantQuota("test-tenant", 10, 5, 100, 50.0, true); + store = new InMemoryTenantQuotaStore(quota); + } + + // --- Quota CRUD --- + + @Test + void getQuota_existingTenant_returnsQuota() { + TenantQuota q = store.getQuota("test-tenant"); + assertNotNull(q); + assertEquals("test-tenant", q.tenantId()); + assertEquals(10, q.maxConversationsPerDay()); + } + + @Test + void getQuota_unknownTenant_returnsNull() { + assertNull(store.getQuota("unknown")); + } + + @Test + void setQuota_addsNewTenant() { + store.setQuota(new TenantQuota("new-tenant", 20, 10, 200, 100.0, true)); + assertNotNull(store.getQuota("new-tenant")); + } + + @Test + void listQuotas_returnsCopy() { + var list = store.listQuotas(); + assertFalse(list.isEmpty()); + assertEquals(1, list.size()); + } + + @Test + void deleteQuota_removesQuota() { + store.deleteQuota("test-tenant"); + assertNull(store.getQuota("test-tenant")); + } + + // --- Conversation Limits --- + + @Test + void tryIncrementConversations_underLimit_allowed() { + var result = store.tryIncrementConversations("test-tenant", 10); + assertTrue(result.allowed()); + } + + @Test + void tryIncrementConversations_atLimit_denied() { + for (int i = 0; i < 10; i++) { + store.tryIncrementConversations("test-tenant", 10); + } + var result = store.tryIncrementConversations("test-tenant", 10); + assertFalse(result.allowed()); + assertNotNull(result.reason()); + } + + @Test + void tryIncrementConversations_negativeLimit_unlimitedAlways() { + for (int i = 0; i < 1000; i++) { + assertTrue(store.tryIncrementConversations("test-tenant", -1).allowed()); + } + } + + // --- API Call Rate Limiting --- + + @Test + void tryIncrementApiCalls_underLimit_allowed() { + var result = store.tryIncrementApiCalls("test-tenant", 100); + assertTrue(result.allowed()); + } + + @Test + void tryIncrementApiCalls_atLimit_denied() { + for (int i = 0; i < 100; i++) { + store.tryIncrementApiCalls("test-tenant", 100); + } + var result = store.tryIncrementApiCalls("test-tenant", 100); + assertFalse(result.allowed()); + } + + // --- Cost Budget --- + + @Test + void tryAddCost_underBudget_allowed() { + var result = store.tryAddCost("test-tenant", 10.0, 50.0); + assertTrue(result.allowed()); + } + + @Test + void tryAddCost_exceedsBudget_denied() { + store.tryAddCost("test-tenant", 49.0, 50.0); + var result = store.tryAddCost("test-tenant", 2.0, 50.0); + assertFalse(result.allowed()); + } + + @Test + void tryAddCost_negativeLimit_unlimitedAlways() { + assertTrue(store.tryAddCost("test-tenant", 999999.0, -1.0).allowed()); + } + + // --- Usage Reporting --- + + @Test + void getUsage_unknownTenant_returnsEmpty() { + UsageSnapshot snap = store.getUsage("nonexistent"); + assertNotNull(snap); + assertEquals("nonexistent", snap.tenantId()); + assertEquals(0, snap.conversationsToday()); + } + + @Test + void getUsage_afterIncrements_reflectsUsage() { + store.tryIncrementConversations("test-tenant", 100); + store.tryIncrementConversations("test-tenant", 100); + store.tryIncrementApiCalls("test-tenant", 100); + + UsageSnapshot snap = store.getUsage("test-tenant"); + assertEquals(2, snap.conversationsToday()); + assertEquals(1, snap.apiCallsThisMinute()); + } + + @Test + void getMonthlyCost_noCost_returns0() { + assertEquals(0.0, store.getMonthlyCost("test-tenant")); + } + + @Test + void getMonthlyCost_afterAddCost_reflectsTotal() { + store.tryAddCost("test-tenant", 5.0, -1); + store.tryAddCost("test-tenant", 3.0, -1); + assertEquals(8.0, store.getMonthlyCost("test-tenant"), 0.01); + } + + @Test + void getMonthlyCost_unknownTenant_returns0() { + assertEquals(0.0, store.getMonthlyCost("unknown")); + } + + // --- Reset --- + + @Test + void resetUsage_clearsCounters() { + store.tryIncrementConversations("test-tenant", 100); + store.tryIncrementApiCalls("test-tenant", 100); + store.tryAddCost("test-tenant", 10.0, -1); + + store.resetUsage("test-tenant"); + + UsageSnapshot snap = store.getUsage("test-tenant"); + assertEquals(0, snap.conversationsToday()); + assertEquals(0, snap.apiCallsThisMinute()); + } + + @Test + void resetUsage_unknownTenant_noOp() { + assertDoesNotThrow(() -> store.resetUsage("nonexistent")); + } + + // --- New tenant counters auto-created --- + + @Test + void tryIncrementConversations_newTenant_autoCreatesCounters() { + var result = store.tryIncrementConversations("brand-new", 5); + assertTrue(result.allowed()); + assertEquals(1, store.getUsage("brand-new").conversationsToday()); + } +} From 1f1de99496101b59234f07dde11d3a0d84a81be2 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Sun, 19 Apr 2026 14:53:25 +0200 Subject: [PATCH 003/124] test(coverage): add rule conditions, LLM model, and dependency tests (batch 3) New test files: - OccurrenceTest: config, clone, execution with null data - ConnectorTest: AND/OR short-circuit logic, clone, empty check - SizeMatcherTest: min/max/equal matching, path nav, not-executed - DependencyTest: config, clone, null safety - CustomToolConfigurationTest: all fields, ToolParameter, ToolType enum, equality, Jackson Coverage: 46.3% -> 47.2% line, 41.4% -> 42.3% branch All 2580 tests pass. --- .../model/CustomToolConfigurationTest.java | 161 ++++++++++++++++++ .../rules/impl/conditions/ConnectorTest.java | 130 ++++++++++++++ .../rules/impl/conditions/DependencyTest.java | 53 ++++++ .../rules/impl/conditions/OccurrenceTest.java | 84 +++++++++ .../impl/conditions/SizeMatcherTest.java | 135 +++++++++++++++ 5 files changed, 563 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/modules/llm/model/CustomToolConfigurationTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/rules/impl/conditions/ConnectorTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/rules/impl/conditions/DependencyTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/rules/impl/conditions/OccurrenceTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/rules/impl/conditions/SizeMatcherTest.java diff --git a/src/test/java/ai/labs/eddi/modules/llm/model/CustomToolConfigurationTest.java b/src/test/java/ai/labs/eddi/modules/llm/model/CustomToolConfigurationTest.java new file mode 100644 index 000000000..d12e40082 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/llm/model/CustomToolConfigurationTest.java @@ -0,0 +1,161 @@ +package ai.labs.eddi.modules.llm.model; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class CustomToolConfigurationTest { + + private final ObjectMapper mapper = new ObjectMapper(); + + @Test + void defaults() { + var config = new CustomToolConfiguration(); + assertNull(config.getName()); + assertNull(config.getType()); + assertFalse(config.isRequiresAuth()); + assertEquals(0.0, config.getCostPerExecution()); + assertNull(config.getCacheTtlMs()); + assertNull(config.getRateLimit()); + } + + @Test + void constructor_setsAll() { + var param = new CustomToolConfiguration.ToolParameter( + "city", "City name", "string", true, "Vienna"); + var config = new CustomToolConfiguration( + "weather", "Get weather", + CustomToolConfiguration.ToolType.HTTPCALL, + List.of(param), + Map.of("url", "https://api.weather.com"), + true, 0.01, 60000L, 30); + + assertEquals("weather", config.getName()); + assertEquals("Get weather", config.getDescription()); + assertEquals(CustomToolConfiguration.ToolType.HTTPCALL, config.getType()); + assertEquals(1, config.getParameters().size()); + assertEquals("https://api.weather.com", config.getConfig().get("url")); + assertTrue(config.isRequiresAuth()); + assertEquals(0.01, config.getCostPerExecution()); + assertEquals(60000L, config.getCacheTtlMs()); + assertEquals(30, config.getRateLimit()); + } + + @Test + void setters() { + var config = new CustomToolConfiguration(); + config.setName("tool1"); + config.setDescription("desc"); + config.setType(CustomToolConfiguration.ToolType.SCRIPT); + config.setRequiresAuth(true); + config.setCostPerExecution(0.05); + config.setCacheTtlMs(30000L); + config.setRateLimit(10); + + assertEquals("tool1", config.getName()); + assertEquals(CustomToolConfiguration.ToolType.SCRIPT, config.getType()); + assertTrue(config.isRequiresAuth()); + } + + @Test + void toolType_allValues() { + assertEquals(5, CustomToolConfiguration.ToolType.values().length); + assertNotNull(CustomToolConfiguration.ToolType.HTTPCALL); + assertNotNull(CustomToolConfiguration.ToolType.SCRIPT); + assertNotNull(CustomToolConfiguration.ToolType.COMPOSITE); + assertNotNull(CustomToolConfiguration.ToolType.DATABASE); + assertNotNull(CustomToolConfiguration.ToolType.FILESYSTEM); + } + + // --- ToolParameter --- + + @Test + void toolParameter_constructor() { + var param = new CustomToolConfiguration.ToolParameter( + "query", "Search query", "string", true, null); + assertEquals("query", param.getName()); + assertEquals("Search query", param.getDescription()); + assertEquals("string", param.getType()); + assertTrue(param.isRequired()); + assertNull(param.getDefaultValue()); + } + + @Test + void toolParameter_setters() { + var param = new CustomToolConfiguration.ToolParameter(); + param.setName("count"); + param.setDescription("Number of results"); + param.setType("number"); + param.setRequired(false); + param.setDefaultValue(10); + + assertEquals("count", param.getName()); + assertEquals(10, param.getDefaultValue()); + assertFalse(param.isRequired()); + } + + @Test + void toolParameter_equals() { + var p1 = new CustomToolConfiguration.ToolParameter("n", "d", "string", true, null); + var p2 = new CustomToolConfiguration.ToolParameter("n", "d", "string", true, null); + assertEquals(p1, p2); + assertEquals(p1.hashCode(), p2.hashCode()); + } + + @Test + void toolParameter_notEquals() { + var p1 = new CustomToolConfiguration.ToolParameter("n1", "d", "string", true, null); + var p2 = new CustomToolConfiguration.ToolParameter("n2", "d", "string", true, null); + assertNotEquals(p1, p2); + } + + @Test + void toolParameter_toString() { + var param = new CustomToolConfiguration.ToolParameter("q", "desc", "string", true, null); + assertTrue(param.toString().contains("q")); + } + + // --- Equality --- + + @Test + void equals_sameConfig() { + var c1 = new CustomToolConfiguration("t", "d", + CustomToolConfiguration.ToolType.HTTPCALL, null, null, false, 0.0, null, null); + var c2 = new CustomToolConfiguration("t", "d", + CustomToolConfiguration.ToolType.HTTPCALL, null, null, false, 0.0, null, null); + assertEquals(c1, c2); + assertEquals(c1.hashCode(), c2.hashCode()); + } + + @Test + void equals_differentName() { + var c1 = new CustomToolConfiguration("a", "d", + CustomToolConfiguration.ToolType.HTTPCALL, null, null, false, 0.0, null, null); + var c2 = new CustomToolConfiguration("b", "d", + CustomToolConfiguration.ToolType.HTTPCALL, null, null, false, 0.0, null, null); + assertNotEquals(c1, c2); + } + + @Test + void toString_containsName() { + var config = new CustomToolConfiguration(); + config.setName("myTool"); + assertTrue(config.toString().contains("myTool")); + } + + @Test + void jacksonRoundTrip() throws Exception { + var config = new CustomToolConfiguration("test", "Test tool", + CustomToolConfiguration.ToolType.SCRIPT, null, null, false, 0.0, null, null); + + String json = mapper.writeValueAsString(config); + var restored = mapper.readValue(json, CustomToolConfiguration.class); + + assertEquals("test", restored.getName()); + assertEquals(CustomToolConfiguration.ToolType.SCRIPT, restored.getType()); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/rules/impl/conditions/ConnectorTest.java b/src/test/java/ai/labs/eddi/modules/rules/impl/conditions/ConnectorTest.java new file mode 100644 index 000000000..eec908145 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/rules/impl/conditions/ConnectorTest.java @@ -0,0 +1,130 @@ +package ai.labs.eddi.modules.rules.impl.conditions; + +import ai.labs.eddi.engine.memory.IConversationMemory; +import ai.labs.eddi.modules.rules.impl.Rule; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static ai.labs.eddi.modules.rules.impl.conditions.IRuleCondition.ExecutionState; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class ConnectorTest { + + @Test + void id() { + assertEquals("connector", new Connector().getId()); + } + + @Test + void setConfigs_and() { + var conn = new Connector(); + conn.setConfigs(Map.of("operator", "AND")); + assertEquals("AND", conn.getConfigs().get("operator")); + } + + @Test + void setConfigs_or() { + var conn = new Connector(); + conn.setConfigs(Map.of("operator", "OR")); + assertEquals("OR", conn.getConfigs().get("operator")); + } + + @Test + void setConfigs_null_noOp() { + assertDoesNotThrow(() -> new Connector().setConfigs(null)); + } + + @Test + void isEmpty_noConditions_true() { + assertTrue(new Connector().isEmpty()); + } + + @Test + void isEmpty_withConditions_false() { + var conn = new Connector(); + var mockCondition = mock(IRuleCondition.class); + conn.setConditions(List.of(mockCondition)); + assertFalse(conn.isEmpty()); + } + + @Test + void execute_or_firstSuccess_returnsSuccess() throws Exception { + var conn = new Connector(); + conn.setConfigs(Map.of("operator", "OR")); + + var c1 = mock(IRuleCondition.class); + when(c1.execute(any(), any())).thenReturn(ExecutionState.SUCCESS); + var c2 = mock(IRuleCondition.class); + + conn.setConditions(List.of(c1, c2)); + + var result = conn.execute(mock(IConversationMemory.class), new ArrayList<>()); + assertEquals(ExecutionState.SUCCESS, result); + verify(c2, never()).execute(any(), any()); // short-circuited + } + + @Test + void execute_or_allFail_returnsFail() throws Exception { + var conn = new Connector(); + conn.setConfigs(Map.of("operator", "OR")); + + var c1 = mock(IRuleCondition.class); + when(c1.execute(any(), any())).thenReturn(ExecutionState.FAIL); + var c2 = mock(IRuleCondition.class); + when(c2.execute(any(), any())).thenReturn(ExecutionState.FAIL); + + conn.setConditions(List.of(c1, c2)); + + var result = conn.execute(mock(IConversationMemory.class), new ArrayList<>()); + assertEquals(ExecutionState.FAIL, result); + } + + @Test + void execute_and_allSuccess_returnsSuccess() throws Exception { + var conn = new Connector(); + conn.setConfigs(Map.of("operator", "AND")); + + var c1 = mock(IRuleCondition.class); + when(c1.execute(any(), any())).thenReturn(ExecutionState.SUCCESS); + var c2 = mock(IRuleCondition.class); + when(c2.execute(any(), any())).thenReturn(ExecutionState.SUCCESS); + + conn.setConditions(List.of(c1, c2)); + + var result = conn.execute(mock(IConversationMemory.class), new ArrayList<>()); + assertEquals(ExecutionState.SUCCESS, result); + } + + @Test + void execute_and_firstFail_returnsFail() throws Exception { + var conn = new Connector(); + conn.setConfigs(Map.of("operator", "AND")); + + var c1 = mock(IRuleCondition.class); + when(c1.execute(any(), any())).thenReturn(ExecutionState.FAIL); + var c2 = mock(IRuleCondition.class); + + conn.setConditions(List.of(c1, c2)); + + var result = conn.execute(mock(IConversationMemory.class), new ArrayList<>()); + assertEquals(ExecutionState.FAIL, result); + verify(c2, never()).execute(any(), any()); // short-circuited + } + + @Test + void clone_preservesOperatorAndConditions() throws Exception { + var conn = new Connector(); + conn.setConfigs(Map.of("operator", "AND")); + + var c1 = mock(IRuleCondition.class); + when(c1.clone()).thenReturn(c1); + conn.setConditions(List.of(c1)); + + var cloned = (Connector) conn.clone(); + assertNotSame(conn, cloned); + assertEquals("AND", cloned.getConfigs().get("operator")); + assertEquals(1, cloned.getConditions().size()); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/rules/impl/conditions/DependencyTest.java b/src/test/java/ai/labs/eddi/modules/rules/impl/conditions/DependencyTest.java new file mode 100644 index 000000000..cca6951ca --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/rules/impl/conditions/DependencyTest.java @@ -0,0 +1,53 @@ +package ai.labs.eddi.modules.rules.impl.conditions; + +import org.junit.jupiter.api.Test; + +import java.util.Collections; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class DependencyTest { + + @Test + void id() { + assertEquals("dependency", new Dependency().getId()); + } + + @Test + void defaultConfigs_hasReferenceKey() { + var dep = new Dependency(); + var configs = dep.getConfigs(); + assertTrue(configs.containsKey("reference")); + assertNull(configs.get("reference")); + } + + @Test + void setConfigs_setsReference() { + var dep = new Dependency(); + dep.setConfigs(Map.of("reference", "greetingRule")); + + assertEquals("greetingRule", dep.getConfigs().get("reference")); + } + + @Test + void setConfigs_null_noOp() { + assertDoesNotThrow(() -> new Dependency().setConfigs(null)); + } + + @Test + void setConfigs_empty_noOp() { + assertDoesNotThrow(() -> new Dependency().setConfigs(Collections.emptyMap())); + } + + @Test + void clone_preservesReference() { + var dep = new Dependency(); + dep.setConfigs(Map.of("reference", "testRule")); + + var cloned = dep.clone(); + assertNotSame(dep, cloned); + assertEquals("dependency", cloned.getId()); + assertEquals("testRule", cloned.getConfigs().get("reference")); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/rules/impl/conditions/OccurrenceTest.java b/src/test/java/ai/labs/eddi/modules/rules/impl/conditions/OccurrenceTest.java new file mode 100644 index 000000000..1e0520200 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/rules/impl/conditions/OccurrenceTest.java @@ -0,0 +1,84 @@ +package ai.labs.eddi.modules.rules.impl.conditions; + +import ai.labs.eddi.engine.memory.IConversationMemory; +import ai.labs.eddi.modules.rules.impl.Rule; +import org.junit.jupiter.api.Test; + +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.mock; + +class OccurrenceTest { + + @Test + void id() { + assertEquals("occurrence", new Occurrence().getId()); + } + + @Test + void defaultConfigs() { + var occ = new Occurrence(); + Map configs = occ.getConfigs(); + assertEquals("-1", configs.get("maxTimesOccurred")); + assertEquals("-1", configs.get("minTimesOccurred")); + assertNull(configs.get("behaviorRuleName")); + } + + @Test + void setConfigs_setsAll() { + var occ = new Occurrence(); + occ.setConfigs(Map.of( + "behaviorRuleName", "greet", + "maxTimesOccurred", "5", + "minTimesOccurred", "1")); + Map configs = occ.getConfigs(); + assertEquals("greet", configs.get("behaviorRuleName")); + assertEquals("5", configs.get("maxTimesOccurred")); + assertEquals("1", configs.get("minTimesOccurred")); + } + + @Test + void setConfigs_null_noOp() { + var occ = new Occurrence(); + assertDoesNotThrow(() -> occ.setConfigs(null)); + } + + @Test + void setConfigs_empty_noOp() { + var occ = new Occurrence(); + assertDoesNotThrow(() -> occ.setConfigs(Collections.emptyMap())); + } + + @Test + void clone_preservesConfigs() { + var occ = new Occurrence(); + occ.setConfigs(Map.of( + "behaviorRuleName", "test", + "maxTimesOccurred", "3", + "minTimesOccurred", "0")); + + var cloned = occ.clone(); + assertNotSame(occ, cloned); + assertEquals("occurrence", cloned.getId()); + assertEquals("test", cloned.getConfigs().get("behaviorRuleName")); + } + + @Test + void execute_noData_returnsFail() { + var occ = new Occurrence(); + occ.setConfigs(Map.of("behaviorRuleName", "greet")); + + var memory = mock(IConversationMemory.class); + var allSteps = mock(IConversationMemory.IConversationStepStack.class); + var allData = mock(List.class); + org.mockito.Mockito.when(memory.getAllSteps()).thenReturn(allSteps); + org.mockito.Mockito.when(allSteps.getAllData("behavior_rules:success")).thenReturn(null); + + var result = occ.execute(memory, new LinkedList<>()); + assertEquals(IRuleCondition.ExecutionState.FAIL, result); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/rules/impl/conditions/SizeMatcherTest.java b/src/test/java/ai/labs/eddi/modules/rules/impl/conditions/SizeMatcherTest.java new file mode 100644 index 000000000..2e50cf07c --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/rules/impl/conditions/SizeMatcherTest.java @@ -0,0 +1,135 @@ +package ai.labs.eddi.modules.rules.impl.conditions; + +import ai.labs.eddi.engine.memory.IConversationMemory; +import ai.labs.eddi.engine.memory.IMemoryItemConverter; +import ai.labs.eddi.modules.rules.impl.Rule; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static ai.labs.eddi.modules.rules.impl.conditions.IRuleCondition.ExecutionState; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +class SizeMatcherTest { + + private IMemoryItemConverter converter; + private SizeMatcher matcher; + + @BeforeEach + void setUp() { + converter = mock(IMemoryItemConverter.class); + matcher = new SizeMatcher(converter); + } + + @Test + void id() { + assertEquals("sizematcher", matcher.getId()); + } + + @Test + void defaultConfigs() { + Map configs = matcher.getConfigs(); + assertEquals("-1", configs.get("min")); + assertEquals("-1", configs.get("max")); + assertEquals("-1", configs.get("equal")); + } + + @Test + void setConfigs_setsAll() { + matcher.setConfigs(Map.of( + "valuePath", "memory.current.count", + "min", "1", + "max", "10", + "equal", "5")); + Map configs = matcher.getConfigs(); + assertEquals("memory.current.count", configs.get("valuePath")); + assertEquals("1", configs.get("min")); + assertEquals("10", configs.get("max")); + assertEquals("5", configs.get("equal")); + } + + @Test + void execute_allDefault_returnsNotExecuted() throws Exception { + // All defaults at -1, should not execute + var memory = mock(IConversationMemory.class); + assertEquals(ExecutionState.NOT_EXECUTED, matcher.execute(memory, new ArrayList<>())); + } + + @Test + void execute_minMatches_success() throws Exception { + matcher.setConfigs(Map.of("valuePath", "count", "min", "2")); + + var memory = mock(IConversationMemory.class); + when(converter.convert(any())).thenReturn(Map.of("count", 5)); + + assertEquals(ExecutionState.SUCCESS, matcher.execute(memory, new ArrayList<>())); + } + + @Test + void execute_minNotReached_fail() throws Exception { + matcher.setConfigs(Map.of("valuePath", "count", "min", "10")); + + var memory = mock(IConversationMemory.class); + when(converter.convert(any())).thenReturn(Map.of("count", 5)); + + assertEquals(ExecutionState.FAIL, matcher.execute(memory, new ArrayList<>())); + } + + @Test + void execute_maxExceeded_fail() throws Exception { + matcher.setConfigs(Map.of("valuePath", "count", "max", "3")); + + var memory = mock(IConversationMemory.class); + when(converter.convert(any())).thenReturn(Map.of("count", 5)); + + assertEquals(ExecutionState.FAIL, matcher.execute(memory, new ArrayList<>())); + } + + @Test + void execute_equalMatches_success() throws Exception { + matcher.setConfigs(Map.of("valuePath", "count", "equal", "5")); + + var memory = mock(IConversationMemory.class); + when(converter.convert(any())).thenReturn(Map.of("count", 5)); + + assertEquals(ExecutionState.SUCCESS, matcher.execute(memory, new ArrayList<>())); + } + + @Test + void execute_equalNotMatches_fail() throws Exception { + matcher.setConfigs(Map.of("valuePath", "count", "equal", "3")); + + var memory = mock(IConversationMemory.class); + when(converter.convert(any())).thenReturn(Map.of("count", 5)); + + assertEquals(ExecutionState.FAIL, matcher.execute(memory, new ArrayList<>())); + } + + @Test + void execute_pathNotFound_sizeIsZero() throws Exception { + matcher.setConfigs(Map.of("valuePath", "nonexistent", "min", "1")); + + var memory = mock(IConversationMemory.class); + when(converter.convert(any())).thenReturn(Map.of("other", 10)); + + assertEquals(ExecutionState.FAIL, matcher.execute(memory, new ArrayList<>())); + } + + @Test + void clone_preservesConfigs() { + matcher.setConfigs(Map.of("valuePath", "test.path", "min", "2", "max", "8", "equal", "-1")); + + var cloned = (SizeMatcher) matcher.clone(); + assertNotSame(matcher, cloned); + assertEquals("test.path", cloned.getConfigs().get("valuePath")); + assertEquals("2", cloned.getConfigs().get("min")); + } + + @Test + void setConfigs_null_noOp() { + assertDoesNotThrow(() -> matcher.setConfigs(null)); + } +} From df0ab9ff1b872009b1c90044bb40c4efae1add1b Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Sun, 19 Apr 2026 16:29:07 +0200 Subject: [PATCH 004/124] test(coverage): add A2A, tenancy, schedule, rule conditions, tool models tests (batch 4) New test files: - A2AModelsTest: all records, Part factories, JSON-RPC, TaskState, error codes - TenancyModelsTest: QuotaCheckResult, TenantQuota, UsageSnapshot, ExceptionMapper - ScheduleFireLogTest: completed/failed/dead-lettered, Jackson round-trip - MoreConditionsTest: Negation (inversion), ActionMatcher (config/actions), ContentTypeMatcher (mime/minCount) - ToolCostTrackerModelsTest: ToolCostMetrics, ConversationCostMetrics, RateLimitInfo Coverage: 47.2% -> 47.3% line, 42.3% branch All tests pass, BUILD SUCCESS. --- .../labs/eddi/engine/a2a/A2AModelsTest.java | 153 ++++++++++++ .../schedule/model/ScheduleFireLogTest.java | 80 +++++++ .../engine/tenancy/TenancyModelsTest.java | 139 +++++++++++ .../llm/tools/ToolCostTrackerModelsTest.java | 109 +++++++++ .../impl/conditions/MoreConditionsTest.java | 221 ++++++++++++++++++ 5 files changed, 702 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/engine/a2a/A2AModelsTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/schedule/model/ScheduleFireLogTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/tenancy/TenancyModelsTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/llm/tools/ToolCostTrackerModelsTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/rules/impl/conditions/MoreConditionsTest.java diff --git a/src/test/java/ai/labs/eddi/engine/a2a/A2AModelsTest.java b/src/test/java/ai/labs/eddi/engine/a2a/A2AModelsTest.java new file mode 100644 index 000000000..fe00b853f --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/a2a/A2AModelsTest.java @@ -0,0 +1,153 @@ +package ai.labs.eddi.engine.a2a; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class A2AModelsTest { + + private final ObjectMapper mapper = new ObjectMapper(); + + // --- AgentCard --- + + @Test + void agentCard_construction() { + var card = new A2AModels.AgentCard( + "TestAgent", "A test agent", "http://localhost:7070/a2a/agents/test", + "EDDI", "6.0.0", + new A2AModels.AgentCapabilities(false, false, true), + List.of(new A2AModels.AgentSkill("chat", "Chat", "General chat", List.of("ai"), null)), + null); + + assertEquals("TestAgent", card.name()); + assertEquals("EDDI", card.provider()); + assertTrue(card.capabilities().stateTransitionHistory()); + assertEquals(1, card.skills().size()); + assertNull(card.authentication()); + } + + @Test + void agentCard_jacksonRoundTrip() throws Exception { + var card = new A2AModels.AgentCard("Agent", "desc", "http://url", "EDDI", "6.0.0", + new A2AModels.AgentCapabilities(true, false, true), + List.of(), null); + + String json = mapper.writeValueAsString(card); + assertFalse(json.contains("authentication")); // null excluded + assertTrue(json.contains("\"name\":\"Agent\"")); + + var restored = mapper.readValue(json, A2AModels.AgentCard.class); + assertEquals("Agent", restored.name()); + } + + // --- AgentAuthentication --- + + @Test + void agentAuthentication_construction() { + var auth = new A2AModels.AgentAuthentication(List.of("Bearer"), "http://auth/token"); + assertEquals(List.of("Bearer"), auth.schemes()); + assertEquals("http://auth/token", auth.credentials()); + } + + // --- AgentSkill --- + + @Test + void agentSkill_construction() { + var skill = new A2AModels.AgentSkill("weather", "Weather", "Get weather", List.of("weather"), List.of("What's the weather?")); + assertEquals("weather", skill.id()); + assertEquals(1, skill.tags().size()); + assertEquals(1, skill.examples().size()); + } + + // --- Part factory methods --- + + @Test + void textPart_factory() { + var part = A2AModels.Part.textPart("Hello"); + assertEquals("text", part.type()); + assertEquals("Hello", part.text()); + assertNull(part.data()); + assertNull(part.metadata()); + } + + @Test + void dataPart_factory() { + var part = A2AModels.Part.dataPart(Map.of("key", "value")); + assertEquals("data", part.type()); + assertNull(part.text()); + assertEquals("value", part.data().get("key")); + } + + // --- JSON-RPC --- + + @Test + void jsonRpcRequest_construction() { + var req = new A2AModels.JsonRpcRequest("2.0", "tasks/send", Map.of("message", "hi"), 1); + assertEquals("2.0", req.jsonrpc()); + assertEquals("tasks/send", req.method()); + assertEquals(1, req.id()); + } + + @Test + void jsonRpcResponse_construction() { + var resp = new A2AModels.JsonRpcResponse("2.0", 1, "result", null); + assertEquals("2.0", resp.jsonrpc()); + assertEquals("result", resp.result()); + assertNull(resp.error()); + } + + @Test + void jsonRpcError_construction() { + var err = new A2AModels.JsonRpcError(-32601, "Method not found", null); + assertEquals(-32601, err.code()); + assertEquals("Method not found", err.message()); + } + + // --- TaskState --- + + @Test + void taskState_allValues() { + assertEquals(7, A2AModels.TaskState.values().length); + assertNotNull(A2AModels.TaskState.submitted); + assertNotNull(A2AModels.TaskState.completed); + assertNotNull(A2AModels.TaskState.failed); + } + + // --- A2ATask --- + + @Test + void a2aTask_construction() { + var msg = new A2AModels.A2AMessage("user", List.of(A2AModels.Part.textPart("hello")), null); + var task = new A2AModels.A2ATask("task-1", "ctx-1", A2AModels.TaskState.working, + List.of(msg), null, null); + + assertEquals("task-1", task.id()); + assertEquals(A2AModels.TaskState.working, task.status()); + assertEquals(1, task.history().size()); + } + + // --- Artifact --- + + @Test + void artifact_construction() { + var artifact = new A2AModels.Artifact("doc", "A document", + List.of(A2AModels.Part.textPart("content")), 0, null); + assertEquals("doc", artifact.name()); + assertEquals(0, artifact.index()); + } + + // --- Error codes --- + + @Test + void errorCodes() { + assertEquals(-32001, A2AModels.ERROR_TASK_NOT_FOUND); + assertEquals(-32002, A2AModels.ERROR_TASK_NOT_CANCELABLE); + assertEquals(-32601, A2AModels.ERROR_METHOD_NOT_FOUND); + assertEquals(-32602, A2AModels.ERROR_INVALID_PARAMS); + assertEquals(-32603, A2AModels.ERROR_INTERNAL); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/schedule/model/ScheduleFireLogTest.java b/src/test/java/ai/labs/eddi/engine/schedule/model/ScheduleFireLogTest.java new file mode 100644 index 000000000..41ff9266e --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/schedule/model/ScheduleFireLogTest.java @@ -0,0 +1,80 @@ +package ai.labs.eddi.engine.schedule.model; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule; +import org.junit.jupiter.api.Test; + +import java.time.Instant; + +import static org.junit.jupiter.api.Assertions.*; + +class ScheduleFireLogTest { + + private final ObjectMapper mapper = new ObjectMapper().registerModule(new JavaTimeModule()); + + @Test + void construction() { + var now = Instant.now(); + var log = new ScheduleFireLog( + "id-1", "sched-1", "fire-1", now, + now.minusSeconds(5), now, "COMPLETED", + "instance-1", "conv-123", null, 1, 0.05); + + assertEquals("id-1", log.id()); + assertEquals("sched-1", log.scheduleId()); + assertEquals("fire-1", log.fireId()); + assertEquals("COMPLETED", log.status()); + assertNull(log.errorMessage()); + assertEquals(1, log.attemptNumber()); + assertEquals(0.05, log.cost()); + } + + @Test + void failedFire() { + var now = Instant.now(); + var log = new ScheduleFireLog( + "id-2", "sched-1", "fire-2", now, + now.minusSeconds(10), null, "FAILED", + "instance-1", null, "Connection refused", 3, 0.0); + + assertEquals("FAILED", log.status()); + assertNull(log.completedAt()); + assertNull(log.conversationId()); + assertEquals("Connection refused", log.errorMessage()); + assertEquals(3, log.attemptNumber()); + } + + @Test + void deadLettered() { + var now = Instant.now(); + var log = new ScheduleFireLog( + "id-3", "sched-1", "fire-3", now, + now, null, "DEAD_LETTERED", + "instance-2", null, "Max retries exceeded", 5, 0.0); + + assertEquals("DEAD_LETTERED", log.status()); + assertEquals(5, log.attemptNumber()); + } + + @Test + void equality() { + var now = Instant.now(); + var l1 = new ScheduleFireLog("id", "s", "f", now, now, now, "COMPLETED", "i", "c", null, 1, 0.0); + var l2 = new ScheduleFireLog("id", "s", "f", now, now, now, "COMPLETED", "i", "c", null, 1, 0.0); + assertEquals(l1, l2); + assertEquals(l1.hashCode(), l2.hashCode()); + } + + @Test + void jacksonRoundTrip() throws Exception { + var now = Instant.now(); + var log = new ScheduleFireLog("id", "sched", "fire", now, now, now, "COMPLETED", "inst", "conv", null, 1, 0.01); + + String json = mapper.writeValueAsString(log); + var restored = mapper.readValue(json, ScheduleFireLog.class); + + assertEquals("id", restored.id()); + assertEquals("COMPLETED", restored.status()); + assertEquals(0.01, restored.cost()); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/tenancy/TenancyModelsTest.java b/src/test/java/ai/labs/eddi/engine/tenancy/TenancyModelsTest.java new file mode 100644 index 000000000..9ccee9b42 --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/tenancy/TenancyModelsTest.java @@ -0,0 +1,139 @@ +package ai.labs.eddi.engine.tenancy; + +import ai.labs.eddi.engine.tenancy.model.QuotaCheckResult; +import ai.labs.eddi.engine.tenancy.model.TenantQuota; +import ai.labs.eddi.engine.tenancy.model.UsageSnapshot; +import ai.labs.eddi.engine.tenancy.rest.QuotaExceededExceptionMapper; +import jakarta.ws.rs.core.Response; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.time.Instant; +import java.time.YearMonth; +import java.time.ZoneOffset; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class TenancyModelsTest { + + // --- QuotaCheckResult --- + + @Nested + class QuotaCheckResultTests { + + @Test + void ok_isAllowed() { + assertTrue(QuotaCheckResult.OK.allowed()); + assertNull(QuotaCheckResult.OK.reason()); + } + + @Test + void denied_notAllowed() { + var result = QuotaCheckResult.denied("Limit exceeded"); + assertFalse(result.allowed()); + assertEquals("Limit exceeded", result.reason()); + } + } + + // --- TenantQuota --- + + @Nested + class TenantQuotaTests { + + @Test + void construction() { + var q = new TenantQuota("t1", 100, 10, 500, 50.0, true); + assertEquals("t1", q.tenantId()); + assertEquals(100, q.maxConversationsPerDay()); + assertEquals(10, q.maxAgentsPerTenant()); + assertEquals(500, q.maxApiCallsPerMinute()); + assertEquals(50.0, q.maxMonthlyCostUsd()); + assertTrue(q.enabled()); + } + + @Test + void disabled() { + var q = new TenantQuota("t2", -1, -1, -1, -1.0, false); + assertFalse(q.enabled()); + assertEquals(-1, q.maxConversationsPerDay()); + } + } + + // --- UsageSnapshot --- + + @Nested + class UsageSnapshotTests { + + @Test + void construction() { + var now = Instant.now(); + var month = YearMonth.now(ZoneOffset.UTC); + var snap = new UsageSnapshot("t1", 5, 10, 3.5, now, now, month); + + assertEquals("t1", snap.tenantId()); + assertEquals(5, snap.conversationsToday()); + assertEquals(10, snap.apiCallsThisMinute()); + assertEquals(3.5, snap.monthlyCostUsd()); + } + + @Test + void empty_allZeros() { + var snap = UsageSnapshot.empty("test"); + assertEquals("test", snap.tenantId()); + assertEquals(0, snap.conversationsToday()); + assertEquals(0, snap.apiCallsThisMinute()); + assertEquals(0.0, snap.monthlyCostUsd()); + assertNotNull(snap.minuteWindowStart()); + assertNotNull(snap.dayStart()); + assertNotNull(snap.costMonth()); + } + } + + // --- QuotaExceededException --- + + @Test + void quotaExceededException_message() { + var ex = new QuotaExceededException("Daily limit reached"); + assertEquals("Daily limit reached", ex.getMessage()); + } + + // --- QuotaExceededExceptionMapper --- + + @Nested + class QuotaExceededMapperTests { + + private final QuotaExceededExceptionMapper mapper = new QuotaExceededExceptionMapper(); + + @Test + void toResponse_returns429() { + var ex = new QuotaExceededException("Limit exceeded"); + Response response = mapper.toResponse(ex); + assertEquals(429, response.getStatus()); + } + + @Test + void toResponse_hasRetryAfter() { + var ex = new QuotaExceededException("test"); + Response response = mapper.toResponse(ex); + assertEquals("60", response.getHeaderString("Retry-After")); + } + + @Test + @SuppressWarnings("unchecked") + void toResponse_hasErrorBody() { + var ex = new QuotaExceededException("Budget exceeded"); + Response response = mapper.toResponse(ex); + Map body = (Map) response.getEntity(); + assertEquals("quota_exceeded", body.get("error")); + assertEquals("Budget exceeded", body.get("message")); + } + + @Test + void toResponse_jsonContentType() { + var ex = new QuotaExceededException("test"); + Response response = mapper.toResponse(ex); + assertTrue(response.getMediaType().toString().contains("application/json")); + } + } +} diff --git a/src/test/java/ai/labs/eddi/modules/llm/tools/ToolCostTrackerModelsTest.java b/src/test/java/ai/labs/eddi/modules/llm/tools/ToolCostTrackerModelsTest.java new file mode 100644 index 000000000..d46655d46 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/llm/tools/ToolCostTrackerModelsTest.java @@ -0,0 +1,109 @@ +package ai.labs.eddi.modules.llm.tools; + +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class ToolCostTrackerModelsTest { + + // --- ToolCostMetrics --- + + @Nested + class ToolCostMetricsTests { + + @Test + void initial_zeroCounts() { + var metrics = new ToolCostTracker.ToolCostMetrics("weather"); + assertEquals(0, metrics.getCallCount()); + assertEquals(0.0, metrics.getTotalCost()); + assertEquals(0.0, metrics.getAverageCost()); + } + + @Test + void addCost_accumulates() { + var metrics = new ToolCostTracker.ToolCostMetrics("weather"); + metrics.addCost(0.01); + metrics.addCost(0.02); + + assertEquals(2, metrics.getCallCount()); + assertEquals(0.03, metrics.getTotalCost(), 0.0001); + assertEquals(0.015, metrics.getAverageCost(), 0.0001); + } + + @Test + void addCost_zeroCost_stillCounts() { + var metrics = new ToolCostTracker.ToolCostMetrics("calculator"); + metrics.addCost(0.0); + assertEquals(1, metrics.getCallCount()); + assertEquals(0.0, metrics.getTotalCost()); + } + } + + // --- ConversationCostMetrics --- + + @Nested + class ConversationCostMetricsTests { + + @Test + void initial_zeroCounts() { + var metrics = new ToolCostTracker.ConversationCostMetrics("conv-1"); + assertEquals(0, metrics.getToolCallCount()); + assertEquals(0.0, metrics.getTotalCost()); + assertTrue(metrics.getToolUsage().isEmpty()); + } + + @Test + void addToolCost_accumulates() { + var metrics = new ToolCostTracker.ConversationCostMetrics("conv-1"); + metrics.addToolCost("weather", 0.01); + metrics.addToolCost("search", 0.02); + metrics.addToolCost("weather", 0.01); + + assertEquals(3, metrics.getToolCallCount()); + assertEquals(0.04, metrics.getTotalCost(), 0.0001); + } + + @Test + void toolUsage_tracksPerTool() { + var metrics = new ToolCostTracker.ConversationCostMetrics("conv-1"); + metrics.addToolCost("weather", 0.01); + metrics.addToolCost("weather", 0.01); + metrics.addToolCost("search", 0.02); + + var usage = metrics.getToolUsage(); + assertEquals(2, usage.get("weather")); + assertEquals(1, usage.get("search")); + } + + @Test + void toolUsage_returnsImmutableCopy() { + var metrics = new ToolCostTracker.ConversationCostMetrics("conv-1"); + metrics.addToolCost("weather", 0.01); + + var usage = metrics.getToolUsage(); + assertThrows(UnsupportedOperationException.class, () -> usage.put("test", 1)); + } + } + + // --- RateLimitInfo --- + + @Nested + class RateLimitInfoTests { + + @Test + void construction() { + var info = new ToolRateLimiter.RateLimitInfo(100, 95, System.currentTimeMillis() + 60000); + assertEquals(100, info.limit); + assertEquals(95, info.remaining); + } + + @Test + void toString_containsRateInfo() { + var info = new ToolRateLimiter.RateLimitInfo(100, 50, System.currentTimeMillis() + 30000); + String str = info.toString(); + assertTrue(str.contains("50")); + assertTrue(str.contains("100")); + } + } +} diff --git a/src/test/java/ai/labs/eddi/modules/rules/impl/conditions/MoreConditionsTest.java b/src/test/java/ai/labs/eddi/modules/rules/impl/conditions/MoreConditionsTest.java new file mode 100644 index 000000000..d9b1379f7 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/rules/impl/conditions/MoreConditionsTest.java @@ -0,0 +1,221 @@ +package ai.labs.eddi.modules.rules.impl.conditions; + +import ai.labs.eddi.engine.memory.IConversationMemory; +import ai.labs.eddi.engine.memory.IData; +import ai.labs.eddi.engine.memory.MemoryKey; +import ai.labs.eddi.modules.rules.impl.Rule; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +import static ai.labs.eddi.modules.rules.impl.conditions.IRuleCondition.ExecutionState; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +class MoreConditionsTest { + + // --- Negation --- + + @Nested + class NegationTests { + + @Test + void id() { + assertEquals("negation", new Negation().getId()); + } + + @Test + void execute_noCondition_returnsNotExecuted() throws Exception { + var neg = new Negation(); + var result = neg.execute(mock(IConversationMemory.class), new ArrayList<>()); + assertEquals(ExecutionState.NOT_EXECUTED, result); + } + + @Test + void execute_successBecomeFail() throws Exception { + var neg = new Negation(); + var inner = mock(IRuleCondition.class); + when(inner.execute(any(), any())).thenReturn(ExecutionState.SUCCESS); + neg.setCondition(inner); + + var result = neg.execute(mock(IConversationMemory.class), new ArrayList<>()); + assertEquals(ExecutionState.FAIL, result); + } + + @Test + void execute_failBecomeSuccess() throws Exception { + var neg = new Negation(); + var inner = mock(IRuleCondition.class); + when(inner.execute(any(), any())).thenReturn(ExecutionState.FAIL); + neg.setCondition(inner); + + var result = neg.execute(mock(IConversationMemory.class), new ArrayList<>()); + assertEquals(ExecutionState.SUCCESS, result); + } + + @Test + void setConditions_singleElement() { + var neg = new Negation(); + var inner = mock(IRuleCondition.class); + neg.setConditions(List.of(inner)); + + assertEquals(1, neg.getConditions().size()); + } + + @Test + void setConditions_multipleElements_ignored() { + var neg = new Negation(); + var c1 = mock(IRuleCondition.class); + var c2 = mock(IRuleCondition.class); + neg.setConditions(List.of(c1, c2)); + // Should not set condition since size != 1 + } + + @Test + void clone_preservesCondition() throws Exception { + var neg = new Negation(); + var inner = mock(IRuleCondition.class); + when(inner.clone()).thenReturn(inner); + neg.setCondition(inner); + + var cloned = (Negation) neg.clone(); + assertNotSame(neg, cloned); + } + } + + // --- ActionMatcher --- + + @Nested + class ActionMatcherTests { + + @Test + void id() { + assertEquals("actionmatcher", new ActionMatcher().getId()); + } + + @Test + void defaultActions_empty() { + var matcher = new ActionMatcher(); + assertTrue(matcher.getActions().isEmpty()); + } + + @Test + void setConfigs_setsActions() { + var matcher = new ActionMatcher(); + matcher.setConfigs(Map.of("actions", "greet, farewell")); + assertEquals(2, matcher.getActions().size()); + assertEquals("greet", matcher.getActions().get(0)); + assertEquals("farewell", matcher.getActions().get(1)); + } + + @Test + void setConfigs_null_noOp() { + assertDoesNotThrow(() -> new ActionMatcher().setConfigs(null)); + } + + @Test + void getConfigs_includesActions() { + var matcher = new ActionMatcher(); + matcher.setActions(List.of("greet", "farewell")); + Map configs = matcher.getConfigs(); + String actionsValue = configs.get("actions"); + assertTrue(actionsValue.contains("greet")); + assertTrue(actionsValue.contains("farewell")); + } + + @Test + void clone_preservesActions() { + var matcher = new ActionMatcher(); + matcher.setConfigs(Map.of("actions", "test_action")); + var cloned = (ActionMatcher) matcher.clone(); + assertNotSame(matcher, cloned); + assertEquals("test_action", cloned.getActions().get(0)); + } + } + + // --- ContentTypeMatcher --- + + @Nested + class ContentTypeMatcherTests { + + @Test + void id() { + assertEquals("contentTypeMatcher", new ContentTypeMatcher().getId()); + } + + @Test + void defaultConfigs() { + var matcher = new ContentTypeMatcher(); + var configs = matcher.getConfigs(); + assertEquals("1", configs.get("minCount")); + assertFalse(configs.containsKey("mimeType")); + } + + @Test + void setConfigs_setsMimeTypeAndMinCount() { + var matcher = new ContentTypeMatcher(); + matcher.setConfigs(Map.of("mimeType", "image/*", "minCount", "2")); + var configs = matcher.getConfigs(); + assertEquals("image/*", configs.get("mimeType")); + assertEquals("2", configs.get("minCount")); + } + + @Test + void setConfigs_invalidMinCount_defaults() { + var matcher = new ContentTypeMatcher(); + matcher.setConfigs(Map.of("mimeType", "text/plain", "minCount", "notanumber")); + assertEquals("1", matcher.getConfigs().get("minCount")); + } + + @Test + void setConfigs_negativeMinCount_clamped() { + var matcher = new ContentTypeMatcher(); + matcher.setConfigs(Map.of("mimeType", "text/plain", "minCount", "-5")); + assertEquals("1", matcher.getConfigs().get("minCount")); + } + + @Test + void setConfigs_null_noOp() { + assertDoesNotThrow(() -> new ContentTypeMatcher().setConfigs(null)); + } + + @Test + void execute_noMimeType_fails() { + var matcher = new ContentTypeMatcher(); + var memory = mock(IConversationMemory.class); + var step = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(step); + + assertEquals(ExecutionState.FAIL, matcher.execute(memory, new ArrayList<>())); + } + + @Test + void execute_noAttachments_fails() { + var matcher = new ContentTypeMatcher(); + matcher.setConfigs(Map.of("mimeType", "image/*")); + + var memory = mock(IConversationMemory.class); + var step = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(step); + when(step.getLatestData(any(MemoryKey.class))).thenReturn(null); + + assertEquals(ExecutionState.FAIL, matcher.execute(memory, new ArrayList<>())); + } + + @Test + void clone_preservesConfigs() { + var matcher = new ContentTypeMatcher(); + matcher.setConfigs(Map.of("mimeType", "application/pdf", "minCount", "3")); + + var cloned = (ContentTypeMatcher) matcher.clone(); + assertNotSame(matcher, cloned); + assertEquals("application/pdf", cloned.getConfigs().get("mimeType")); + assertEquals("3", cloned.getConfigs().get("minCount")); + } + } +} From 27bdd4b7be93b242b84a6988dac0b9a209284900 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Sun, 19 Apr 2026 16:44:56 +0200 Subject: [PATCH 005/124] test(coverage): add AgentConfig, DictionaryConfig, RuleGroup model tests (batch 5) Expanded/new test files: - AgentConfigurationTest: added AgentIdentity, ChannelConnector, UserMemoryConfig, Guardrails, DreamConfig, SecurityConfig setters (146 -> 312 lines) - DictionaryConfigurationTest: Word/RegEx/Phrase equality, compareTo, Jackson - RuleGroupTest: defaults, ExecutionStrategy enum, rule list management Coverage: 47.3% -> 47.8% line, 42.3% -> 42.4% branch All tests pass, BUILD SUCCESS. --- .../agents/model/AgentConfigurationTest.java | 164 ++++++++++++++++ .../model/DictionaryConfigurationTest.java | 185 ++++++++++++++++++ .../modules/rules/impl/RuleGroupTest.java | 46 +++++ 3 files changed, 395 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/configs/dictionary/model/DictionaryConfigurationTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/rules/impl/RuleGroupTest.java diff --git a/src/test/java/ai/labs/eddi/configs/agents/model/AgentConfigurationTest.java b/src/test/java/ai/labs/eddi/configs/agents/model/AgentConfigurationTest.java index 82d607175..db7a9fa5e 100644 --- a/src/test/java/ai/labs/eddi/configs/agents/model/AgentConfigurationTest.java +++ b/src/test/java/ai/labs/eddi/configs/agents/model/AgentConfigurationTest.java @@ -142,4 +142,168 @@ void defaults() { assertFalse(config.isEnableMemoryTools()); } } + + @Nested + @DisplayName("AgentIdentity") + class AgentIdentityTest { + + @Test + void defaultConstructor() { + var id = new AgentConfiguration.AgentIdentity(); + assertNull(id.getAgentDid()); + assertNull(id.getPublicKey()); + } + + @Test + void parameterizedConstructor() { + var id = new AgentConfiguration.AgentIdentity("did:eddi:agent:1", "pubkey-abc"); + assertEquals("did:eddi:agent:1", id.getAgentDid()); + assertEquals("pubkey-abc", id.getPublicKey()); + } + + @Test + void setters() { + var id = new AgentConfiguration.AgentIdentity(); + id.setAgentDid("did:x"); + id.setPublicKey("key123"); + assertEquals("did:x", id.getAgentDid()); + assertEquals("key123", id.getPublicKey()); + } + } + + @Nested + @DisplayName("ChannelConnector") + class ChannelConnectorTest { + + @Test + void defaults() { + var cc = new AgentConfiguration.ChannelConnector(); + assertNull(cc.getType()); + assertTrue(cc.getConfig().isEmpty()); + } + + @Test + void setters() { + var cc = new AgentConfiguration.ChannelConnector(); + cc.setType(java.net.URI.create("eddi://channel/slack")); + cc.setConfig(Map.of("token", "xoxb-123")); + assertEquals("eddi://channel/slack", cc.getType().toString()); + assertEquals("xoxb-123", cc.getConfig().get("token")); + } + } + + @Nested + @DisplayName("UserMemoryConfig") + class UserMemoryConfigTest { + + @Test + void defaults() { + var umc = new AgentConfiguration.UserMemoryConfig(); + assertEquals("self", umc.getDefaultVisibility()); + assertEquals(50, umc.getMaxRecallEntries()); + assertEquals(500, umc.getMaxEntriesPerUser()); + assertEquals("evict_oldest", umc.getOnCapReached()); + assertEquals("most_recent", umc.getRecallOrder()); + assertEquals(2, umc.getAutoRecallCategories().size()); + assertNotNull(umc.getGuardrails()); + assertNotNull(umc.getDream()); + } + + @Test + void setters() { + var umc = new AgentConfiguration.UserMemoryConfig(); + umc.setDefaultVisibility("global"); + umc.setMaxRecallEntries(100); + umc.setMaxEntriesPerUser(1000); + umc.setOnCapReached("reject"); + umc.setRecallOrder("most_relevant"); + umc.setAutoRecallCategories(java.util.List.of("preference")); + umc.setGuardrails(new AgentConfiguration.Guardrails()); + umc.setDream(new AgentConfiguration.DreamConfig()); + assertEquals("global", umc.getDefaultVisibility()); + assertEquals(100, umc.getMaxRecallEntries()); + } + } + + @Nested + @DisplayName("Guardrails") + class GuardrailsTest { + + @Test + void defaults() { + var g = new AgentConfiguration.Guardrails(); + assertEquals(100, g.getMaxKeyLength()); + assertEquals(1000, g.getMaxValueLength()); + assertEquals(10, g.getMaxWritesPerTurn()); + assertEquals(3, g.getAllowedCategories().size()); + } + + @Test + void setters() { + var g = new AgentConfiguration.Guardrails(); + g.setMaxKeyLength(50); + g.setMaxValueLength(500); + g.setMaxWritesPerTurn(5); + g.setAllowedCategories(java.util.List.of("fact")); + assertEquals(50, g.getMaxKeyLength()); + assertEquals(500, g.getMaxValueLength()); + assertEquals(5, g.getMaxWritesPerTurn()); + assertEquals(1, g.getAllowedCategories().size()); + } + } + + @Nested + @DisplayName("DreamConfig") + class DreamConfigTest { + + @Test + void defaults() { + var dc = new AgentConfiguration.DreamConfig(); + assertFalse(dc.isEnabled()); + assertEquals("0 3 * * *", dc.getSchedule()); + assertTrue(dc.isDetectContradictions()); + assertEquals("keep_newest", dc.getContradictionResolution()); + assertEquals(90, dc.getPruneStaleAfterDays()); + assertFalse(dc.isSummarizeInteractions()); + assertEquals("anthropic", dc.getLlmProvider()); + assertEquals("claude-sonnet-4-6", dc.getLlmModel()); + assertEquals(5.0, dc.getMaxCostPerRun()); + assertEquals(50, dc.getBatchSize()); + assertEquals(1000, dc.getMaxUsersPerRun()); + } + + @Test + void setters() { + var dc = new AgentConfiguration.DreamConfig(); + dc.setEnabled(true); + dc.setSchedule("0 * * * *"); + dc.setDetectContradictions(false); + dc.setContradictionResolution("keep_oldest"); + dc.setPruneStaleAfterDays(30); + dc.setSummarizeInteractions(true); + dc.setLlmProvider("openai"); + dc.setLlmModel("gpt-4o"); + dc.setMaxCostPerRun(10.0); + dc.setBatchSize(100); + dc.setMaxUsersPerRun(500); + assertTrue(dc.isEnabled()); + assertEquals(10.0, dc.getMaxCostPerRun()); + } + } + + @Nested + @DisplayName("SecurityConfig setters") + class SecurityConfigSettersTest { + + @Test + void setters() { + var sc = new AgentConfiguration.SecurityConfig(); + sc.setSignInterAgentMessages(true); + sc.setSignMcpInvocations(true); + sc.setRequirePeerVerification(true); + assertTrue(sc.isSignInterAgentMessages()); + assertTrue(sc.isSignMcpInvocations()); + assertTrue(sc.isRequirePeerVerification()); + } + } } diff --git a/src/test/java/ai/labs/eddi/configs/dictionary/model/DictionaryConfigurationTest.java b/src/test/java/ai/labs/eddi/configs/dictionary/model/DictionaryConfigurationTest.java new file mode 100644 index 000000000..0b401d70a --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/dictionary/model/DictionaryConfigurationTest.java @@ -0,0 +1,185 @@ +package ai.labs.eddi.configs.dictionary.model; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class DictionaryConfigurationTest { + + private final ObjectMapper mapper = new ObjectMapper(); + + @Test + void defaultConstructor() { + var config = new DictionaryConfiguration(); + assertNull(config.getLang()); + assertNotNull(config.getWords()); + assertTrue(config.getWords().isEmpty()); + assertNotNull(config.getRegExs()); + assertTrue(config.getRegExs().isEmpty()); + assertNotNull(config.getPhrases()); + assertTrue(config.getPhrases().isEmpty()); + } + + @Test + void setters() { + var config = new DictionaryConfiguration(); + config.setLang("en"); + assertEquals("en", config.getLang()); + } + + // --- WordConfiguration --- + + @Nested + class WordTests { + + @Test + void settersAndGetters() { + var w = new DictionaryConfiguration.WordConfiguration(); + w.setWord("hello"); + w.setExpressions("greeting(hello)"); + w.setFrequency(5); + assertEquals("hello", w.getWord()); + assertEquals("greeting(hello)", w.getExpressions()); + assertEquals(5, w.getFrequency()); + } + + @Test + void equality_sameWord() { + var w1 = new DictionaryConfiguration.WordConfiguration(); + w1.setWord("hello"); + var w2 = new DictionaryConfiguration.WordConfiguration(); + w2.setWord("hello"); + assertEquals(w1, w2); + assertEquals(w1.hashCode(), w2.hashCode()); + } + + @Test + void equality_differentWord() { + var w1 = new DictionaryConfiguration.WordConfiguration(); + w1.setWord("hello"); + var w2 = new DictionaryConfiguration.WordConfiguration(); + w2.setWord("goodbye"); + assertNotEquals(w1, w2); + } + + @Test + void compareTo() { + var w1 = new DictionaryConfiguration.WordConfiguration(); + w1.setWord("apple"); + var w2 = new DictionaryConfiguration.WordConfiguration(); + w2.setWord("banana"); + assertTrue(w1.compareTo(w2) < 0); + assertTrue(w2.compareTo(w1) > 0); + assertEquals(0, w1.compareTo(w1)); + } + + @Test + void jackson() throws Exception { + var w = new DictionaryConfiguration.WordConfiguration(); + w.setWord("test"); + w.setExpressions("exp(test)"); + String json = mapper.writeValueAsString(w); + var restored = mapper.readValue(json, DictionaryConfiguration.WordConfiguration.class); + assertEquals("test", restored.getWord()); + assertEquals("exp(test)", restored.getExpressions()); + } + } + + // --- RegExConfiguration --- + + @Nested + class RegExTests { + + @Test + void settersAndGetters() { + var r = new DictionaryConfiguration.RegExConfiguration(); + r.setRegEx("\\d+"); + r.setExpressions("number(*)"); + assertEquals("\\d+", r.getRegEx()); + assertEquals("number(*)", r.getExpressions()); + } + + @Test + void equality_sameRegex() { + var r1 = new DictionaryConfiguration.RegExConfiguration(); + r1.setRegEx("\\d+"); + var r2 = new DictionaryConfiguration.RegExConfiguration(); + r2.setRegEx("\\d+"); + assertEquals(r1, r2); + assertEquals(r1.hashCode(), r2.hashCode()); + } + + @Test + void compareTo() { + var r1 = new DictionaryConfiguration.RegExConfiguration(); + r1.setRegEx("aaa"); + var r2 = new DictionaryConfiguration.RegExConfiguration(); + r2.setRegEx("zzz"); + assertTrue(r1.compareTo(r2) < 0); + } + } + + // --- PhraseConfiguration --- + + @Nested + class PhraseTests { + + @Test + void settersAndGetters() { + var p = new DictionaryConfiguration.PhraseConfiguration(); + p.setPhrase("good morning"); + p.setExpressions("greeting(good_morning)"); + assertEquals("good morning", p.getPhrase()); + assertEquals("greeting(good_morning)", p.getExpressions()); + } + + @Test + void equality_samePhrase() { + var p1 = new DictionaryConfiguration.PhraseConfiguration(); + p1.setPhrase("good morning"); + var p2 = new DictionaryConfiguration.PhraseConfiguration(); + p2.setPhrase("good morning"); + assertEquals(p1, p2); + assertEquals(p1.hashCode(), p2.hashCode()); + } + + @Test + void equality_differentPhrase() { + var p1 = new DictionaryConfiguration.PhraseConfiguration(); + p1.setPhrase("good morning"); + var p2 = new DictionaryConfiguration.PhraseConfiguration(); + p2.setPhrase("good evening"); + assertNotEquals(p1, p2); + } + } + + // --- Full config with lists --- + + @Test + void fullConfigWithLists() { + var config = new DictionaryConfiguration(); + config.setLang("de"); + + var word = new DictionaryConfiguration.WordConfiguration(); + word.setWord("hallo"); + word.setExpressions("greeting(hallo)"); + config.setWords(List.of(word)); + + var regex = new DictionaryConfiguration.RegExConfiguration(); + regex.setRegEx("\\d+"); + config.setRegExs(List.of(regex)); + + var phrase = new DictionaryConfiguration.PhraseConfiguration(); + phrase.setPhrase("guten morgen"); + config.setPhrases(List.of(phrase)); + + assertEquals("de", config.getLang()); + assertEquals(1, config.getWords().size()); + assertEquals(1, config.getRegExs().size()); + assertEquals(1, config.getPhrases().size()); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/rules/impl/RuleGroupTest.java b/src/test/java/ai/labs/eddi/modules/rules/impl/RuleGroupTest.java new file mode 100644 index 000000000..5c71052c6 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/rules/impl/RuleGroupTest.java @@ -0,0 +1,46 @@ +package ai.labs.eddi.modules.rules.impl; + +import org.junit.jupiter.api.Test; + +import java.util.LinkedList; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class RuleGroupTest { + + @Test + void defaults() { + var group = new RuleGroup(); + assertNull(group.getName()); + assertEquals(RuleGroup.ExecutionStrategy.executeUntilFirstSuccess, group.getExecutionStrategy()); + assertNotNull(group.getRules()); + assertTrue(group.getRules().isEmpty()); + } + + @Test + void setters() { + var group = new RuleGroup(); + group.setName("greeting-rules"); + group.setExecutionStrategy(RuleGroup.ExecutionStrategy.executeAll); + + assertEquals("greeting-rules", group.getName()); + assertEquals(RuleGroup.ExecutionStrategy.executeAll, group.getExecutionStrategy()); + } + + @Test + void setRules() { + var group = new RuleGroup(); + var rules = new LinkedList(); + rules.add(new Rule("rule1")); + group.setRules(rules); + assertEquals(1, group.getRules().size()); + } + + @Test + void executionStrategy_allValues() { + assertEquals(2, RuleGroup.ExecutionStrategy.values().length); + assertNotNull(RuleGroup.ExecutionStrategy.valueOf("executeAll")); + assertNotNull(RuleGroup.ExecutionStrategy.valueOf("executeUntilFirstSuccess")); + } +} From dfa5db3de184aa68025fa0f252321666d0cc8f7b Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Sun, 19 Apr 2026 17:37:02 +0200 Subject: [PATCH 006/124] test(coverage): add AgentCardService, ContextLogger, SimpleDocDescriptor tests (batch 6) New test files: - AgentCardServiceTest: getAgentCard (null/disabled/enabled/error), buildAgentCard (skills, auth, capabilities), listA2AAgents (148 lines of service logic) - ContextLoggerTest: createLoggingContext field combos, MDC operations - SimpleDocumentDescriptorTest: constructors, setters Coverage: 47.8% -> 48.1% line, 42.4% -> 42.7% branch (2709 tests) All tests pass, BUILD SUCCESS. --- .../model/SimpleDocumentDescriptorTest.java | 31 +++ .../eddi/engine/a2a/AgentCardServiceTest.java | 216 ++++++++++++++++++ .../engine/internal/ContextLoggerTest.java | 73 ++++++ 3 files changed, 320 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/configs/descriptors/model/SimpleDocumentDescriptorTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/a2a/AgentCardServiceTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/internal/ContextLoggerTest.java diff --git a/src/test/java/ai/labs/eddi/configs/descriptors/model/SimpleDocumentDescriptorTest.java b/src/test/java/ai/labs/eddi/configs/descriptors/model/SimpleDocumentDescriptorTest.java new file mode 100644 index 000000000..fd3def199 --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/descriptors/model/SimpleDocumentDescriptorTest.java @@ -0,0 +1,31 @@ +package ai.labs.eddi.configs.descriptors.model; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class SimpleDocumentDescriptorTest { + + @Test + void defaultConstructor() { + var desc = new SimpleDocumentDescriptor(); + assertNull(desc.getName()); + assertNull(desc.getDescription()); + } + + @Test + void parameterizedConstructor() { + var desc = new SimpleDocumentDescriptor("Agent 1", "A test agent"); + assertEquals("Agent 1", desc.getName()); + assertEquals("A test agent", desc.getDescription()); + } + + @Test + void setters() { + var desc = new SimpleDocumentDescriptor(); + desc.setName("Updated Name"); + desc.setDescription("Updated Description"); + assertEquals("Updated Name", desc.getName()); + assertEquals("Updated Description", desc.getDescription()); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/a2a/AgentCardServiceTest.java b/src/test/java/ai/labs/eddi/engine/a2a/AgentCardServiceTest.java new file mode 100644 index 000000000..f9d1a205b --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/a2a/AgentCardServiceTest.java @@ -0,0 +1,216 @@ +package ai.labs.eddi.engine.a2a; + +import ai.labs.eddi.configs.agents.IRestAgentStore; +import ai.labs.eddi.configs.agents.model.AgentConfiguration; +import ai.labs.eddi.configs.descriptors.model.DocumentDescriptor; +import ai.labs.eddi.datastore.IResourceStore; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.net.URI; +import java.util.List; +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class AgentCardServiceTest { + + private IRestAgentStore restAgentStore; + private AgentCardService service; + + @BeforeEach + void setUp() { + restAgentStore = mock(IRestAgentStore.class); + service = new AgentCardService( + restAgentStore, + "http://localhost:7070", + false, + Optional.empty()); + } + + // --- getAgentCard --- + + @Nested + class GetAgentCard { + + @Test + void returnsNull_whenNoResourceId() throws Exception { + when(restAgentStore.getCurrentResourceId("agent-1")).thenReturn(null); + assertNull(service.getAgentCard("agent-1")); + } + + @Test + void returnsNull_whenConfigNull() throws Exception { + var resourceId = new IResourceStore.IResourceId() { + public String getId() { + return "agent-1"; + } + public Integer getVersion() { + return 1; + } + }; + when(restAgentStore.getCurrentResourceId("agent-1")).thenReturn(resourceId); + when(restAgentStore.readAgent("agent-1", 1)).thenReturn(null); + assertNull(service.getAgentCard("agent-1")); + } + + @Test + void returnsNull_whenNotA2aEnabled() throws Exception { + var config = new AgentConfiguration(); + config.setA2aEnabled(false); + var resourceId = new IResourceStore.IResourceId() { + public String getId() { + return "agent-1"; + } + public Integer getVersion() { + return 1; + } + }; + when(restAgentStore.getCurrentResourceId("agent-1")).thenReturn(resourceId); + when(restAgentStore.readAgent("agent-1", 1)).thenReturn(config); + assertNull(service.getAgentCard("agent-1")); + } + + @Test + void returnsCard_whenA2aEnabled() throws Exception { + var config = new AgentConfiguration(); + config.setA2aEnabled(true); + config.setDescription("My agent"); + var resourceId = new IResourceStore.IResourceId() { + public String getId() { + return "agent-1"; + } + public Integer getVersion() { + return 1; + } + }; + when(restAgentStore.getCurrentResourceId("agent-1")).thenReturn(resourceId); + when(restAgentStore.readAgent("agent-1", 1)).thenReturn(config); + + var card = service.getAgentCard("agent-1"); + assertNotNull(card); + assertEquals("EDDI Agent agent-1", card.name()); + assertEquals("My agent", card.description()); + assertTrue(card.url().contains("agent-1")); + assertEquals("EDDI", card.provider()); + } + + @Test + void returnsNull_onException() throws Exception { + when(restAgentStore.getCurrentResourceId("bad")) + .thenThrow(new RuntimeException("DB error")); + assertNull(service.getAgentCard("bad")); + } + } + + // --- buildAgentCard --- + + @Nested + class BuildAgentCard { + + @Test + void defaultSkill_whenNoSkillsConfigured() { + var config = new AgentConfiguration(); + config.setA2aEnabled(true); + + var card = service.buildAgentCard("a1", config, 1); + assertEquals(1, card.skills().size()); + assertEquals("chat", card.skills().get(0).id()); + } + + @Test + void customSkills() { + var config = new AgentConfiguration(); + config.setA2aEnabled(true); + config.setA2aSkills(List.of("Translation", "Code Review")); + + var card = service.buildAgentCard("a2", config, 1); + assertEquals(2, card.skills().size()); + assertEquals("translation", card.skills().get(0).id()); + assertEquals("code-review", card.skills().get(1).id()); + } + + @Test + void noAuth_whenDisabled() { + var config = new AgentConfiguration(); + config.setA2aEnabled(true); + + var card = service.buildAgentCard("a3", config, 1); + assertNull(card.authentication()); + } + + @Test + void withAuth_whenEnabled() { + var authService = new AgentCardService( + restAgentStore, + "http://localhost:7070", + true, + Optional.of("http://keycloak:8080/realms/eddi")); + + var config = new AgentConfiguration(); + config.setA2aEnabled(true); + + var card = authService.buildAgentCard("a4", config, 1); + assertNotNull(card.authentication()); + assertEquals(List.of("Bearer"), card.authentication().schemes()); + assertTrue(card.authentication().credentials().contains("openid-connect/token")); + } + + @Test + void defaultDescription_whenNone() { + var config = new AgentConfiguration(); + config.setA2aEnabled(true); + + var card = service.buildAgentCard("a5", config, 1); + assertEquals("EDDI conversational AI agent", card.description()); + } + + @Test + void capabilities() { + var config = new AgentConfiguration(); + config.setA2aEnabled(true); + + var card = service.buildAgentCard("a6", config, 1); + assertTrue(card.capabilities().stateTransitionHistory()); + assertFalse(card.capabilities().streaming()); + assertFalse(card.capabilities().pushNotifications()); + } + } + + // --- listA2AAgents --- + + @Nested + class ListA2AAgents { + + @Test + void emptyList_whenNoDescriptors() throws Exception { + when(restAgentStore.readAgentDescriptors("", 0, 100)).thenReturn(null); + assertTrue(service.listA2AAgents().isEmpty()); + } + + @Test + void emptyList_onException() throws Exception { + when(restAgentStore.readAgentDescriptors("", 0, 100)) + .thenThrow(new RuntimeException("DB error")); + assertTrue(service.listA2AAgents().isEmpty()); + } + + @Test + void skipsDescriptors_withNullResource() throws Exception { + var desc = new DocumentDescriptor(); + desc.setResource(null); + when(restAgentStore.readAgentDescriptors("", 0, 100)).thenReturn(List.of(desc)); + assertTrue(service.listA2AAgents().isEmpty()); + } + + @Test + void skipsDescriptors_withEmptyPath() throws Exception { + var desc = new DocumentDescriptor(); + desc.setResource(URI.create("eddi://ai.labs.agent")); + when(restAgentStore.readAgentDescriptors("", 0, 100)).thenReturn(List.of(desc)); + assertTrue(service.listA2AAgents().isEmpty()); + } + } +} diff --git a/src/test/java/ai/labs/eddi/engine/internal/ContextLoggerTest.java b/src/test/java/ai/labs/eddi/engine/internal/ContextLoggerTest.java new file mode 100644 index 000000000..424a716c0 --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/internal/ContextLoggerTest.java @@ -0,0 +1,73 @@ +package ai.labs.eddi.engine.internal; + +import ai.labs.eddi.engine.model.Deployment; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class ContextLoggerTest { + + private ContextLogger logger; + + @BeforeEach + void setUp() { + logger = new ContextLogger(); + } + + @Test + void createLoggingContext_allFields() { + var ctx = logger.createLoggingContext( + Deployment.Environment.production, "agent-1", "conv-1", "user-1"); + + assertEquals("production", ctx.get("environment")); + assertEquals("agent-1", ctx.get("agentId")); + assertEquals("conv-1", ctx.get("conversationId")); + assertEquals("user-1", ctx.get("userId")); + } + + @Test + void createLoggingContext_nullConversationId() { + var ctx = logger.createLoggingContext( + Deployment.Environment.production, "agent-1", null, "user-1"); + + assertFalse(ctx.containsKey("conversationId")); + assertEquals("user-1", ctx.get("userId")); + } + + @Test + void createLoggingContext_nullUserId() { + var ctx = logger.createLoggingContext( + Deployment.Environment.production, "agent-1", "conv-1", null); + + assertEquals("conv-1", ctx.get("conversationId")); + assertFalse(ctx.containsKey("userId")); + } + + @Test + void createLoggingContext_bothNull() { + var ctx = logger.createLoggingContext( + Deployment.Environment.production, "agent-1", null, null); + + assertEquals(2, ctx.size()); + assertEquals("production", ctx.get("environment")); + assertEquals("agent-1", ctx.get("agentId")); + } + + @Test + void setLoggingContext_nullSafe() { + assertDoesNotThrow(() -> logger.setLoggingContext(null)); + } + + @Test + void setLoggingContext_withValues() { + assertDoesNotThrow(() -> logger.setLoggingContext(Map.of("environment", "test"))); + } + + @Test + void clearLoggingContext() { + assertDoesNotThrow(() -> logger.clearLoggingContext()); + } +} From 8b3a66a15393a5cae67d6efc0f7c7263551882dd Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Sun, 19 Apr 2026 17:43:02 +0200 Subject: [PATCH 007/124] test(coverage): add LlmConfiguration nested model tests (batch 7) New test file: - LlmConfigurationModelsTest: RagDefaults, ModelCascadeConfig, CascadeStep, ToolResponseLimits, McpServerConfig, A2AAgentConfig, RetryConfiguration, KnowledgeBaseReference, ConversationSummaryConfig (incl. validate() logic) Coverage: 48.1% -> 48.3% line, 42.7% -> 42.8% branch All tests pass, BUILD SUCCESS. --- .../llm/model/LlmConfigurationModelsTest.java | 299 ++++++++++++++++++ 1 file changed, 299 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/modules/llm/model/LlmConfigurationModelsTest.java diff --git a/src/test/java/ai/labs/eddi/modules/llm/model/LlmConfigurationModelsTest.java b/src/test/java/ai/labs/eddi/modules/llm/model/LlmConfigurationModelsTest.java new file mode 100644 index 000000000..954127923 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/llm/model/LlmConfigurationModelsTest.java @@ -0,0 +1,299 @@ +package ai.labs.eddi.modules.llm.model; + +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Tests for LlmConfiguration nested model classes that have 0% coverage. + */ +class LlmConfigurationModelsTest { + + // --- RagDefaults --- + + @Nested + class RagDefaultsTests { + + @Test + void defaults() { + var rd = new LlmConfiguration.RagDefaults(); + assertEquals(5, rd.getMaxResults()); + assertEquals(0.6, rd.getMinScore()); + assertEquals("system_message", rd.getInjectionStrategy()); + } + + @Test + void setters() { + var rd = new LlmConfiguration.RagDefaults(); + rd.setMaxResults(10); + rd.setMinScore(0.8); + rd.setInjectionStrategy("user_message"); + assertEquals(10, rd.getMaxResults()); + assertEquals(0.8, rd.getMinScore()); + assertEquals("user_message", rd.getInjectionStrategy()); + } + } + + // --- ModelCascadeConfig --- + + @Nested + class ModelCascadeConfigTests { + + @Test + void defaults() { + var mcc = new LlmConfiguration.ModelCascadeConfig(); + assertFalse(mcc.isEnabled()); + assertEquals("cascade", mcc.getStrategy()); + assertEquals("structured_output", mcc.getEvaluationStrategy()); + assertTrue(mcc.isEnableInAgentMode()); + assertNull(mcc.getSteps()); + } + + @Test + void setters() { + var mcc = new LlmConfiguration.ModelCascadeConfig(); + mcc.setEnabled(true); + mcc.setStrategy("parallel"); + mcc.setEvaluationStrategy("heuristic"); + mcc.setEnableInAgentMode(false); + mcc.setSteps(List.of(new LlmConfiguration.CascadeStep())); + assertTrue(mcc.isEnabled()); + assertEquals("parallel", mcc.getStrategy()); + assertEquals(1, mcc.getSteps().size()); + } + } + + // --- CascadeStep --- + + @Nested + class CascadeStepTests { + + @Test + void defaults() { + var cs = new LlmConfiguration.CascadeStep(); + assertNull(cs.getType()); + assertNull(cs.getParameters()); + assertNull(cs.getConfidenceThreshold()); + assertEquals(30000L, cs.getTimeoutMs()); + } + + @Test + void setters() { + var cs = new LlmConfiguration.CascadeStep(); + cs.setType("openai"); + cs.setParameters(Map.of("model", "gpt-4o-mini")); + cs.setConfidenceThreshold(0.7); + cs.setTimeoutMs(5000L); + assertEquals("openai", cs.getType()); + assertEquals(0.7, cs.getConfidenceThreshold()); + assertEquals(5000L, cs.getTimeoutMs()); + } + } + + // --- ToolResponseLimits --- + + @Nested + class ToolResponseLimitsTests { + + @Test + void defaults() { + var trl = new LlmConfiguration.ToolResponseLimits(); + assertEquals(50000, trl.getDefaultMaxChars()); + assertNull(trl.getPerToolLimits()); + } + + @Test + void setters() { + var trl = new LlmConfiguration.ToolResponseLimits(); + trl.setDefaultMaxChars(10000); + trl.setPerToolLimits(Map.of("webscraper", 5000)); + assertEquals(10000, trl.getDefaultMaxChars()); + assertEquals(5000, trl.getPerToolLimits().get("webscraper")); + } + } + + // --- McpServerConfig --- + + @Nested + class McpServerConfigTests { + + @Test + void defaults() { + var msc = new LlmConfiguration.McpServerConfig(); + assertNull(msc.getUrl()); + assertNull(msc.getName()); + assertEquals("http", msc.getTransport()); + assertNull(msc.getApiKey()); + assertEquals(30000L, msc.getTimeoutMs()); + } + + @Test + void setters() { + var msc = new LlmConfiguration.McpServerConfig(); + msc.setUrl("http://localhost:7070/mcp"); + msc.setName("local-mcp"); + msc.setTransport("sse"); + msc.setApiKey("${eddivault:mcp-key}"); + msc.setTimeoutMs(60000L); + assertEquals("http://localhost:7070/mcp", msc.getUrl()); + assertEquals("sse", msc.getTransport()); + } + } + + // --- A2AAgentConfig --- + + @Nested + class A2AAgentConfigTests { + + @Test + void defaults() { + var a2a = new LlmConfiguration.A2AAgentConfig(); + assertNull(a2a.getUrl()); + assertNull(a2a.getName()); + assertNull(a2a.getSkillsFilter()); + assertNull(a2a.getApiKey()); + assertEquals(30000L, a2a.getTimeoutMs()); + } + + @Test + void setters() { + var a2a = new LlmConfiguration.A2AAgentConfig(); + a2a.setUrl("https://remote-agent.example.com/a2a"); + a2a.setName("translator"); + a2a.setSkillsFilter(List.of("translate-en-de")); + a2a.setApiKey("${eddivault:a2a-key}"); + a2a.setTimeoutMs(10000L); + assertEquals("translator", a2a.getName()); + assertEquals(1, a2a.getSkillsFilter().size()); + } + } + + // --- RetryConfiguration --- + + @Nested + class RetryConfigurationTests { + + @Test + void defaults() { + var rc = new LlmConfiguration.RetryConfiguration(); + assertEquals(3, rc.getMaxAttempts()); + assertEquals(1000L, rc.getBackoffDelayMs()); + assertEquals(2.0, rc.getBackoffMultiplier()); + assertEquals(10000L, rc.getMaxBackoffDelayMs()); + } + + @Test + void setters() { + var rc = new LlmConfiguration.RetryConfiguration(); + rc.setMaxAttempts(5); + rc.setBackoffDelayMs(500L); + rc.setBackoffMultiplier(1.5); + rc.setMaxBackoffDelayMs(30000L); + assertEquals(5, rc.getMaxAttempts()); + assertEquals(1.5, rc.getBackoffMultiplier()); + } + } + + // --- KnowledgeBaseReference --- + + @Nested + class KnowledgeBaseReferenceTests { + + @Test + void defaults() { + var kbr = new LlmConfiguration.KnowledgeBaseReference(); + assertNull(kbr.getName()); + assertNull(kbr.getMaxResults()); + assertNull(kbr.getMinScore()); + assertNull(kbr.getInjectionStrategy()); + assertNull(kbr.getContextTemplate()); + } + + @Test + void setters() { + var kbr = new LlmConfiguration.KnowledgeBaseReference(); + kbr.setName("product-docs"); + kbr.setMaxResults(10); + kbr.setMinScore(0.7); + kbr.setInjectionStrategy("system_message"); + kbr.setContextTemplate("Context: {{context}}"); + assertEquals("product-docs", kbr.getName()); + assertEquals(10, kbr.getMaxResults()); + } + } + + // --- ConversationSummaryConfig --- + + @Nested + class ConversationSummaryConfigTests { + + @Test + void defaults() { + var csc = new LlmConfiguration.ConversationSummaryConfig(); + assertFalse(csc.isEnabled()); + assertEquals("anthropic", csc.getLlmProvider()); + assertEquals("claude-sonnet-4-6", csc.getLlmModel()); + assertEquals(800, csc.getMaxSummaryTokens()); + assertTrue(csc.isExcludePropertiesFromSummary()); + assertEquals(5, csc.getRecentWindowSteps()); + assertEquals(20, csc.getMaxRecallTurns()); + assertNull(csc.getSummarizationPrompt()); + } + + @Test + void setters() { + var csc = new LlmConfiguration.ConversationSummaryConfig(); + csc.setEnabled(true); + csc.setLlmProvider("openai"); + csc.setLlmModel("gpt-4o-mini"); + csc.setMaxSummaryTokens(500); + csc.setExcludePropertiesFromSummary(false); + csc.setRecentWindowSteps(10); + csc.setMaxRecallTurns(30); + csc.setSummarizationPrompt("Summarize:"); + assertTrue(csc.isEnabled()); + assertEquals("openai", csc.getLlmProvider()); + assertEquals(500, csc.getMaxSummaryTokens()); + } + + @Test + void validate_resetsBadValues() { + var csc = new LlmConfiguration.ConversationSummaryConfig(); + csc.setRecentWindowSteps(0); + csc.setMaxRecallTurns(-1); + csc.setMaxSummaryTokens(50); + csc.setLlmProvider(""); + csc.setLlmModel(null); + + csc.validate(); + + assertEquals(5, csc.getRecentWindowSteps()); + assertEquals(20, csc.getMaxRecallTurns()); + assertEquals(800, csc.getMaxSummaryTokens()); + assertEquals("anthropic", csc.getLlmProvider()); + assertEquals("claude-sonnet-4-6", csc.getLlmModel()); + } + + @Test + void validate_keepsGoodValues() { + var csc = new LlmConfiguration.ConversationSummaryConfig(); + csc.setRecentWindowSteps(10); + csc.setMaxRecallTurns(25); + csc.setMaxSummaryTokens(1000); + csc.setLlmProvider("openai"); + csc.setLlmModel("gpt-4o"); + + csc.validate(); + + assertEquals(10, csc.getRecentWindowSteps()); + assertEquals(25, csc.getMaxRecallTurns()); + assertEquals(1000, csc.getMaxSummaryTokens()); + assertEquals("openai", csc.getLlmProvider()); + assertEquals("gpt-4o", csc.getLlmModel()); + } + } +} From 6a9bab3d38161bd5a507c045cecf26d494904ff4 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Sun, 19 Apr 2026 17:54:47 +0200 Subject: [PATCH 008/124] test(coverage): add small model batch tests (batch 8) New test file: - SmallModelsBatchTest: DeploymentInfo, ConversationStatus, DataFactory, HttpPreRequest, HttpCodeValidator, PropertySetterConfiguration, Deployment.Environment.fromString/toValue, Deployment.Status Coverage: 48.3% -> 48.5% line All tests pass, BUILD SUCCESS. --- .../configs/model/SmallModelsBatchTest.java | 252 ++++++++++++++++++ 1 file changed, 252 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/configs/model/SmallModelsBatchTest.java diff --git a/src/test/java/ai/labs/eddi/configs/model/SmallModelsBatchTest.java b/src/test/java/ai/labs/eddi/configs/model/SmallModelsBatchTest.java new file mode 100644 index 000000000..0aaf1dd1f --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/model/SmallModelsBatchTest.java @@ -0,0 +1,252 @@ +package ai.labs.eddi.configs.model; + +import ai.labs.eddi.configs.apicalls.model.HttpCodeValidator; +import ai.labs.eddi.configs.apicalls.model.HttpPreRequest; +import ai.labs.eddi.configs.deployment.model.DeploymentInfo; +import ai.labs.eddi.configs.propertysetter.model.PropertySetterConfiguration; +import ai.labs.eddi.engine.memory.DataFactory; +import ai.labs.eddi.engine.memory.model.ConversationStatus; +import ai.labs.eddi.engine.memory.model.ConversationState; +import ai.labs.eddi.engine.model.Deployment; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.Date; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Batch test for small model classes with 0% coverage. + */ +class SmallModelsBatchTest { + + // --- DeploymentInfo --- + + @Nested + class DeploymentInfoTest { + + @Test + void defaults() { + var di = new DeploymentInfo(); + assertNull(di.getAgentId()); + assertNull(di.getAgentVersion()); + assertNull(di.getEnvironment()); + assertNull(di.getDeploymentStatus()); + } + + @Test + void setters() { + var di = new DeploymentInfo(); + di.setAgentId("agent-1"); + di.setAgentVersion(3); + di.setEnvironment(Deployment.Environment.production); + di.setDeploymentStatus(DeploymentInfo.DeploymentStatus.deployed); + assertEquals("agent-1", di.getAgentId()); + assertEquals(3, di.getAgentVersion()); + assertEquals(Deployment.Environment.production, di.getEnvironment()); + assertEquals(DeploymentInfo.DeploymentStatus.deployed, di.getDeploymentStatus()); + } + + @Test + void deploymentStatusEnum() { + assertEquals(2, DeploymentInfo.DeploymentStatus.values().length); + assertNotNull(DeploymentInfo.DeploymentStatus.valueOf("deployed")); + assertNotNull(DeploymentInfo.DeploymentStatus.valueOf("undeployed")); + } + } + + // --- ConversationStatus --- + + @Nested + class ConversationStatusTest { + + @Test + void defaults() { + var cs = new ConversationStatus(); + assertNull(cs.getConversationId()); + assertNull(cs.getAgentId()); + assertNull(cs.getAgentVersion()); + assertNull(cs.getConversationState()); + assertNull(cs.getLastInteraction()); + } + + @Test + void setters() { + var cs = new ConversationStatus(); + cs.setConversationId("conv-1"); + cs.setAgentId("agent-1"); + cs.setAgentVersion(2); + cs.setConversationState(ConversationState.READY); + var now = new Date(); + cs.setLastInteraction(now); + assertEquals("conv-1", cs.getConversationId()); + assertEquals("agent-1", cs.getAgentId()); + assertEquals(2, cs.getAgentVersion()); + assertEquals(ConversationState.READY, cs.getConversationState()); + assertEquals(now, cs.getLastInteraction()); + } + } + + // --- DataFactory --- + + @Nested + class DataFactoryTest { + + @Test + void createData_keyAndValue() { + var factory = new DataFactory(); + var data = factory.createData("input", "hello"); + assertEquals("input", data.getKey()); + assertEquals("hello", data.getResult()); + } + + @Test + void createData_public() { + var factory = new DataFactory(); + var data = factory.createData("output", "response", true); + assertEquals("output", data.getKey()); + assertTrue(data.isPublic()); + } + + @Test + void createData_private() { + var factory = new DataFactory(); + var data = factory.createData("internal", "value", false); + assertFalse(data.isPublic()); + } + + @Test + void createData_withPossibleValues() { + var factory = new DataFactory(); + var data = factory.createData("choice", "a", List.of("a", "b", "c")); + assertEquals("choice", data.getKey()); + assertEquals("a", data.getResult()); + assertEquals(3, data.getPossibleResults().size()); + } + } + + // --- HttpPreRequest --- + + @Nested + class HttpPreRequestTest { + + @Test + void defaults() { + var hpr = new HttpPreRequest(); + assertNull(hpr.getBatchRequests()); + assertEquals(0, hpr.getDelayBeforeExecutingInMillis()); + } + + @Test + void setters() { + var hpr = new HttpPreRequest(); + hpr.setDelayBeforeExecutingInMillis(500); + assertEquals(500, hpr.getDelayBeforeExecutingInMillis()); + } + } + + // --- HttpCodeValidator --- + + @Nested + class HttpCodeValidatorTest { + + @Test + void defaultConstant() { + assertNotNull(HttpCodeValidator.DEFAULT); + assertEquals(List.of(200, 201), HttpCodeValidator.DEFAULT.getRunOnHttpCode()); + assertTrue(HttpCodeValidator.DEFAULT.getSkipOnHttpCode().contains(400)); + assertTrue(HttpCodeValidator.DEFAULT.getSkipOnHttpCode().contains(500)); + } + + @Test + void emptyConstructor() { + var v = new HttpCodeValidator(); + assertNull(v.getRunOnHttpCode()); + assertNull(v.getSkipOnHttpCode()); + } + + @Test + void parameterizedConstructor() { + var v = new HttpCodeValidator(List.of(200), List.of(500)); + assertEquals(List.of(200), v.getRunOnHttpCode()); + assertEquals(List.of(500), v.getSkipOnHttpCode()); + } + } + + // --- PropertySetterConfiguration --- + + @Nested + class PropertySetterConfigurationTest { + + @Test + void defaults() { + var config = new PropertySetterConfiguration(); + assertNotNull(config.getSetOnActions()); + assertTrue(config.getSetOnActions().isEmpty()); + } + } + + // --- Deployment.Environment.fromString --- + + @Nested + class DeploymentEnvironmentFromStringTest { + + @Test + void null_returnsProduction() { + assertEquals(Deployment.Environment.production, Deployment.Environment.fromString(null)); + } + + @Test + void production_returnsProduction() { + assertEquals(Deployment.Environment.production, Deployment.Environment.fromString("production")); + } + + @Test + void test_returnsTest() { + assertEquals(Deployment.Environment.test, Deployment.Environment.fromString("test")); + } + + @Test + void unrestricted_legacyMapping() { + assertEquals(Deployment.Environment.production, Deployment.Environment.fromString("unrestricted")); + } + + @Test + void restricted_legacyMapping() { + assertEquals(Deployment.Environment.production, Deployment.Environment.fromString("restricted")); + } + + @Test + void unknown_defaultsToProduction() { + assertEquals(Deployment.Environment.production, Deployment.Environment.fromString("whatever")); + } + + @Test + void caseInsensitive() { + assertEquals(Deployment.Environment.production, Deployment.Environment.fromString("PRODUCTION")); + assertEquals(Deployment.Environment.test, Deployment.Environment.fromString("TEST")); + } + + @Test + void toValue() { + assertEquals("production", Deployment.Environment.production.toValue()); + assertEquals("test", Deployment.Environment.test.toValue()); + } + } + + // --- Deployment.Status --- + + @Nested + class DeploymentStatusTest { + + @Test + void allValues() { + assertEquals(4, Deployment.Status.values().length); + assertNotNull(Deployment.Status.valueOf("READY")); + assertNotNull(Deployment.Status.valueOf("IN_PROGRESS")); + assertNotNull(Deployment.Status.valueOf("NOT_FOUND")); + assertNotNull(Deployment.Status.valueOf("ERROR")); + } + } +} From 9f690b8eeb406ba8accf5f3e924ce2c8acd5a614 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Sun, 19 Apr 2026 17:59:18 +0200 Subject: [PATCH 009/124] test(coverage): add RuleDeserialization tests (batch 9) New test file: - RuleDeserializationTest: 11 tests covering full deserialization pipeline Empty groups, default/explicit execution strategy, rules with actions, condition types (actionmatcher, negation, connector, occurrence, dependency, contentTypeMatcher), nested conditions, invalid JSON error handling. Uses real ObjectMapper with mock CDI dependencies. Coverage: 48.5% -> 48.8% line, 42.8% -> 42.9% branch All tests pass, BUILD SUCCESS. --- .../rules/impl/RuleDeserializationTest.java | 314 ++++++++++++++++++ 1 file changed, 314 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/modules/rules/impl/RuleDeserializationTest.java diff --git a/src/test/java/ai/labs/eddi/modules/rules/impl/RuleDeserializationTest.java b/src/test/java/ai/labs/eddi/modules/rules/impl/RuleDeserializationTest.java new file mode 100644 index 000000000..00cd2b024 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/rules/impl/RuleDeserializationTest.java @@ -0,0 +1,314 @@ +package ai.labs.eddi.modules.rules.impl; + +import ai.labs.eddi.configs.agents.CapabilityRegistryService; +import ai.labs.eddi.datastore.serialization.DeserializationException; +import ai.labs.eddi.datastore.serialization.IJsonSerialization; +import ai.labs.eddi.engine.memory.IMemoryItemConverter; +import ai.labs.eddi.modules.nlp.expressions.utilities.IExpressionProvider; +import ai.labs.eddi.modules.templating.ITemplatingEngine; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.mock; + +class RuleDeserializationTest { + + private RuleDeserialization ruleDeserialization; + + @BeforeEach + void setUp() { + ruleDeserialization = new RuleDeserialization( + new ObjectMapper(), + mock(IExpressionProvider.class), + mock(IJsonSerialization.class), + mock(IMemoryItemConverter.class), + mock(CapabilityRegistryService.class), + mock(ITemplatingEngine.class)); + } + + @Test + void deserialize_emptyGroups() throws DeserializationException { + String json = "{\"behaviorGroups\":[]}"; + RuleSet ruleSet = ruleDeserialization.deserialize(json); + assertNotNull(ruleSet); + assertTrue(ruleSet.getRuleGroups().isEmpty()); + } + + @Test + void deserialize_groupWithName() throws DeserializationException { + String json = """ + { + "behaviorGroups": [ + { + "name": "greetings", + "executionStrategy": "executeAll", + "rules": [] + } + ] + } + """; + RuleSet ruleSet = ruleDeserialization.deserialize(json); + assertEquals(1, ruleSet.getRuleGroups().size()); + assertEquals("greetings", ruleSet.getRuleGroups().get(0).getName()); + assertEquals(RuleGroup.ExecutionStrategy.executeAll, ruleSet.getRuleGroups().get(0).getExecutionStrategy()); + } + + @Test + void deserialize_defaultExecutionStrategy() throws DeserializationException { + String json = """ + { + "behaviorGroups": [ + { + "name": "default-group", + "rules": [] + } + ] + } + """; + RuleSet ruleSet = ruleDeserialization.deserialize(json); + assertEquals(RuleGroup.ExecutionStrategy.executeUntilFirstSuccess, + ruleSet.getRuleGroups().get(0).getExecutionStrategy()); + } + + @Test + void deserialize_ruleWithActions() throws DeserializationException { + String json = """ + { + "behaviorGroups": [ + { + "name": "test-group", + "rules": [ + { + "name": "say-hello", + "actions": ["greet", "welcome"], + "conditions": [] + } + ] + } + ] + } + """; + RuleSet ruleSet = ruleDeserialization.deserialize(json); + var rules = ruleSet.getRuleGroups().get(0).getRules(); + assertEquals(1, rules.size()); + assertEquals("say-hello", rules.get(0).getName()); + assertEquals(2, rules.get(0).getActions().size()); + } + + @Test + void deserialize_ruleWithActionMatcher() throws DeserializationException { + String json = """ + { + "behaviorGroups": [ + { + "name": "group1", + "rules": [ + { + "name": "check-action", + "actions": ["respond"], + "conditions": [ + { + "type": "actionmatcher", + "configs": { + "actions": "greet" + } + } + ] + } + ] + } + ] + } + """; + RuleSet ruleSet = ruleDeserialization.deserialize(json); + var conditions = ruleSet.getRuleGroups().get(0).getRules().get(0).getConditions(); + assertEquals(1, conditions.size()); + } + + @Test + void deserialize_negationCondition() throws DeserializationException { + String json = """ + { + "behaviorGroups": [ + { + "name": "group1", + "rules": [ + { + "name": "not-something", + "actions": ["fallback"], + "conditions": [ + { + "type": "negation", + "conditions": [ + { + "type": "actionmatcher", + "configs": { + "actions": "greet" + } + } + ] + } + ] + } + ] + } + ] + } + """; + RuleSet ruleSet = ruleDeserialization.deserialize(json); + var conditions = ruleSet.getRuleGroups().get(0).getRules().get(0).getConditions(); + assertEquals(1, conditions.size()); + } + + @Test + void deserialize_invalidJson_throwsDeserializationException() { + assertThrows(DeserializationException.class, () -> ruleDeserialization.deserialize("not json")); + } + + @Test + void deserialize_multipleGroups() throws DeserializationException { + String json = """ + { + "behaviorGroups": [ + { "name": "g1", "rules": [] }, + { "name": "g2", "executionStrategy": "executeAll", "rules": [] } + ] + } + """; + RuleSet ruleSet = ruleDeserialization.deserialize(json); + assertEquals(2, ruleSet.getRuleGroups().size()); + } + + @Test + void deserialize_connectorCondition() throws DeserializationException { + String json = """ + { + "behaviorGroups": [ + { + "name": "group1", + "rules": [ + { + "name": "combo", + "actions": ["combo-action"], + "conditions": [ + { + "type": "connector", + "configs": { + "operator": "AND" + }, + "conditions": [ + { + "type": "actionmatcher", + "configs": { "actions": "a" } + }, + { + "type": "actionmatcher", + "configs": { "actions": "b" } + } + ] + } + ] + } + ] + } + ] + } + """; + RuleSet ruleSet = ruleDeserialization.deserialize(json); + var conditions = ruleSet.getRuleGroups().get(0).getRules().get(0).getConditions(); + assertEquals(1, conditions.size()); + } + + @Test + void deserialize_occurrenceCondition() throws DeserializationException { + String json = """ + { + "behaviorGroups": [ + { + "name": "group1", + "rules": [ + { + "name": "occ-test", + "actions": ["occ-action"], + "conditions": [ + { + "type": "occurrence", + "configs": { + "maxTimesOccurred": "3", + "behaviorRuleName": "occ-test" + } + } + ] + } + ] + } + ] + } + """; + RuleSet ruleSet = ruleDeserialization.deserialize(json); + var conditions = ruleSet.getRuleGroups().get(0).getRules().get(0).getConditions(); + assertEquals(1, conditions.size()); + } + + @Test + void deserialize_dependencyCondition() throws DeserializationException { + String json = """ + { + "behaviorGroups": [ + { + "name": "group1", + "rules": [ + { + "name": "dep-test", + "actions": ["dep-action"], + "conditions": [ + { + "type": "dependency", + "configs": { + "reference": "other-rule" + } + } + ] + } + ] + } + ] + } + """; + RuleSet ruleSet = ruleDeserialization.deserialize(json); + var conditions = ruleSet.getRuleGroups().get(0).getRules().get(0).getConditions(); + assertEquals(1, conditions.size()); + } + + @Test + void deserialize_contentTypeMatcherCondition() throws DeserializationException { + String json = """ + { + "behaviorGroups": [ + { + "name": "group1", + "rules": [ + { + "name": "ct-test", + "actions": ["ct-action"], + "conditions": [ + { + "type": "contentTypeMatcher", + "configs": { + "contentType": "image/png" + } + } + ] + } + ] + } + ] + } + """; + RuleSet ruleSet = ruleDeserialization.deserialize(json); + var conditions = ruleSet.getRuleGroups().get(0).getRules().get(0).getConditions(); + assertEquals(1, conditions.size()); + } +} From 6eb3adfa1372eed966aea95ce9eee1b375883792 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Sun, 19 Apr 2026 19:10:24 +0200 Subject: [PATCH 010/124] test(coverage): add Rule and RulesEvaluator tests (batch 10) New test files: - RuleTest: execute() with no/pass/fail/error conditions, short-circuit, infinite loop detection, equals/hashCode, clone, toString (136 lines covered) - RulesEvaluatorTest: empty sets, success/fail/error, execution strategies (executeUntilFirstSuccess vs executeAll), null rule set guard (115 lines covered) Coverage: 48.8% -> 49.1% line, 42.9% -> 43.2% branch All tests pass, BUILD SUCCESS. --- .../eddi/modules/rules/impl/RuleTest.java | 148 +++++++++++++++ .../rules/impl/RulesEvaluatorTest.java | 172 ++++++++++++++++++ 2 files changed, 320 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/modules/rules/impl/RuleTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/rules/impl/RulesEvaluatorTest.java diff --git a/src/test/java/ai/labs/eddi/modules/rules/impl/RuleTest.java b/src/test/java/ai/labs/eddi/modules/rules/impl/RuleTest.java new file mode 100644 index 000000000..21266e100 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/rules/impl/RuleTest.java @@ -0,0 +1,148 @@ +package ai.labs.eddi.modules.rules.impl; + +import ai.labs.eddi.engine.memory.IConversationMemory; +import ai.labs.eddi.modules.rules.impl.conditions.IRuleCondition; +import ai.labs.eddi.modules.rules.impl.conditions.IRuleCondition.ExecutionState; +import org.junit.jupiter.api.Test; + +import java.util.LinkedList; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class RuleTest { + + @Test + void constructorSetsName() { + var rule = new Rule("greeting"); + assertEquals("greeting", rule.getName()); + } + + @Test + void defaultConstructor() { + var rule = new Rule(); + assertNull(rule.getName()); + } + + @Test + void settersAndGetters() { + var rule = new Rule("r1"); + rule.setActions(List.of("a1", "a2")); + rule.setName("renamed"); + assertEquals("renamed", rule.getName()); + assertEquals(2, rule.getActions().size()); + } + + // --- execute --- + + @Test + void execute_noConditions_returnsSuccess() throws Exception { + var rule = new Rule("r1"); + var memory = mock(IConversationMemory.class); + var trace = new LinkedList(); + + var state = rule.execute(memory, trace); + assertEquals(ExecutionState.SUCCESS, state); + } + + @Test + void execute_allConditionsPass_returnsSuccess() throws Exception { + var rule = new Rule("r1"); + var condition = mock(IRuleCondition.class); + when(condition.execute(any(), any())).thenReturn(ExecutionState.SUCCESS); + rule.setConditions(List.of(condition)); + + var state = rule.execute(mock(IConversationMemory.class), new LinkedList<>()); + assertEquals(ExecutionState.SUCCESS, state); + } + + @Test + void execute_conditionFails_returnsFail() throws Exception { + var rule = new Rule("r1"); + var cond1 = mock(IRuleCondition.class); + when(cond1.execute(any(), any())).thenReturn(ExecutionState.FAIL); + rule.setConditions(List.of(cond1)); + + var state = rule.execute(mock(IConversationMemory.class), new LinkedList<>()); + assertEquals(ExecutionState.FAIL, state); + } + + @Test + void execute_conditionError_returnsError() throws Exception { + var rule = new Rule("r1"); + var cond = mock(IRuleCondition.class); + when(cond.execute(any(), any())).thenReturn(ExecutionState.ERROR); + rule.setConditions(List.of(cond)); + + var state = rule.execute(mock(IConversationMemory.class), new LinkedList<>()); + assertEquals(ExecutionState.ERROR, state); + } + + @Test + void execute_shortCircuitsOnFail() throws Exception { + var rule = new Rule("r1"); + var cond1 = mock(IRuleCondition.class); + var cond2 = mock(IRuleCondition.class); + when(cond1.execute(any(), any())).thenReturn(ExecutionState.FAIL); + rule.setConditions(List.of(cond1, cond2)); + + rule.execute(mock(IConversationMemory.class), new LinkedList<>()); + verify(cond2, never()).execute(any(), any()); + } + + @Test + void execute_infiniteLoopDetection() { + var rule = new Rule("loop"); + var trace = new LinkedList(); + trace.add(rule); // already in trace + + assertThrows(Rule.InfiniteLoopException.class, + () -> rule.execute(mock(IConversationMemory.class), trace)); + } + + // --- equals / hashCode --- + + @Test + void equality_sameName() { + assertEquals(new Rule("r1"), new Rule("r1")); + assertEquals(new Rule("r1").hashCode(), new Rule("r1").hashCode()); + } + + @Test + void equality_differentName() { + assertNotEquals(new Rule("r1"), new Rule("r2")); + } + + @Test + void equality_notARule() { + assertNotEquals(new Rule("r1"), "r1"); + } + + @Test + void equality_sameInstance() { + var rule = new Rule("r1"); + assertEquals(rule, rule); + } + + // --- clone --- + + @Test + void clone_copiesNameAndConditions() throws CloneNotSupportedException { + var rule = new Rule("original"); + var cond = mock(IRuleCondition.class); + when(cond.clone()).thenReturn(cond); + rule.setConditions(new LinkedList<>(List.of(cond))); + + var clone = rule.clone(); + assertEquals("original", clone.getName()); + assertEquals(1, clone.getConditions().size()); + } + + // --- toString --- + + @Test + void toStringReturnsName() { + assertEquals("test-rule", new Rule("test-rule").toString()); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/rules/impl/RulesEvaluatorTest.java b/src/test/java/ai/labs/eddi/modules/rules/impl/RulesEvaluatorTest.java new file mode 100644 index 000000000..4420ebeed --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/rules/impl/RulesEvaluatorTest.java @@ -0,0 +1,172 @@ +package ai.labs.eddi.modules.rules.impl; + +import ai.labs.eddi.engine.memory.IConversationMemory; +import ai.labs.eddi.modules.rules.impl.conditions.IRuleCondition; +import ai.labs.eddi.modules.rules.impl.conditions.IRuleCondition.ExecutionState; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.LinkedList; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class RulesEvaluatorTest { + + private IConversationMemory memory; + + @BeforeEach + void setUp() { + memory = mock(IConversationMemory.class); + } + + private RulesEvaluator createEvaluator(RuleSet ruleSet) { + return new RulesEvaluator(ruleSet, false, false); + } + + // --- Empty / basic --- + + @Test + void evaluate_emptyRuleSet() throws Exception { + var ruleSet = new RuleSet(); + var evaluator = createEvaluator(ruleSet); + var result = evaluator.evaluate(memory); + assertTrue(result.getSuccessRules().isEmpty()); + assertTrue(result.getFailRules().isEmpty()); + } + + @Test + void evaluate_ruleWithNoConditions_isSuccess() throws Exception { + var rule = new Rule("always"); + rule.setActions(List.of("greet")); + var group = new RuleGroup(); + group.getRules().add(rule); + var ruleSet = new RuleSet(); + ruleSet.getRuleGroups().add(group); + + var result = createEvaluator(ruleSet).evaluate(memory); + assertEquals(1, result.getSuccessRules().size()); + assertEquals("always", result.getSuccessRules().get(0).getName()); + } + + @Test + void evaluate_ruleConditionSuccess() throws Exception { + var cond = mock(IRuleCondition.class); + when(cond.execute(any(), any())).thenReturn(ExecutionState.SUCCESS); + var rule = new Rule("r1"); + rule.setConditions(new LinkedList<>(List.of(cond))); + + var group = new RuleGroup(); + group.getRules().add(rule); + var ruleSet = new RuleSet(); + ruleSet.getRuleGroups().add(group); + + var result = createEvaluator(ruleSet).evaluate(memory); + assertEquals(1, result.getSuccessRules().size()); + } + + @Test + void evaluate_ruleConditionFail_goesToFailRules() throws Exception { + var cond = mock(IRuleCondition.class); + when(cond.execute(any(), any())).thenReturn(ExecutionState.FAIL); + var rule = new Rule("r1"); + rule.setConditions(new LinkedList<>(List.of(cond))); + + var group = new RuleGroup(); + group.getRules().add(rule); + var ruleSet = new RuleSet(); + ruleSet.getRuleGroups().add(group); + + var result = createEvaluator(ruleSet).evaluate(memory); + assertTrue(result.getSuccessRules().isEmpty()); + assertEquals(1, result.getFailRules().size()); + } + + @Test + void evaluate_ruleConditionError_throwsException() { + var cond = mock(IRuleCondition.class); + try { + when(cond.execute(any(), any())).thenReturn(ExecutionState.ERROR); + } catch (Exception e) { + fail(e); + } + var rule = new Rule("r1"); + rule.setConditions(new LinkedList<>(List.of(cond))); + + var group = new RuleGroup(); + group.getRules().add(rule); + var ruleSet = new RuleSet(); + ruleSet.getRuleGroups().add(group); + + assertThrows(RulesEvaluator.RuleExecutionException.class, + () -> createEvaluator(ruleSet).evaluate(memory)); + } + + // --- Execution strategies --- + + @Test + void evaluate_executeUntilFirstSuccess_stopsAfterFirst() throws Exception { + var cond1 = mock(IRuleCondition.class); + when(cond1.execute(any(), any())).thenReturn(ExecutionState.SUCCESS); + + var rule1 = new Rule("r1"); + rule1.setConditions(new LinkedList<>(List.of(cond1))); + var rule2 = new Rule("r2"); + rule2.setConditions(new LinkedList<>(List.of(cond1))); + + var group = new RuleGroup(); + group.setExecutionStrategy(RuleGroup.ExecutionStrategy.executeUntilFirstSuccess); + group.getRules().addAll(List.of(rule1, rule2)); + + var ruleSet = new RuleSet(); + ruleSet.getRuleGroups().add(group); + + var result = createEvaluator(ruleSet).evaluate(memory); + assertEquals(1, result.getSuccessRules().size()); + assertEquals("r1", result.getSuccessRules().get(0).getName()); + } + + @Test + void evaluate_executeAll_continuesAfterSuccess() throws Exception { + var cond = mock(IRuleCondition.class); + when(cond.execute(any(), any())).thenReturn(ExecutionState.SUCCESS); + + var rule1 = new Rule("r1"); + rule1.setConditions(new LinkedList<>(List.of(cond))); + var rule2 = new Rule("r2"); + rule2.setConditions(new LinkedList<>(List.of(cond))); + + var group = new RuleGroup(); + group.setExecutionStrategy(RuleGroup.ExecutionStrategy.executeAll); + group.getRules().addAll(List.of(rule1, rule2)); + + var ruleSet = new RuleSet(); + ruleSet.getRuleGroups().add(group); + + var result = createEvaluator(ruleSet).evaluate(memory); + assertEquals(2, result.getSuccessRules().size()); + } + + // --- Null rule set --- + + @Test + void evaluate_nullRuleSet_throwsIllegalArgument() { + var evaluator = new RulesEvaluator(); + assertThrows(IllegalArgumentException.class, () -> evaluator.evaluate(memory)); + } + + // --- Setters --- + + @Test + void settersAndGetters() { + var evaluator = new RulesEvaluator(); + var ruleSet = new RuleSet(); + evaluator.setRuleSet(ruleSet); + evaluator.setAppendActions(true); + evaluator.setExpressionsAsActions(true); + assertSame(ruleSet, evaluator.getRuleSet()); + assertTrue(evaluator.isAppendActions()); + assertTrue(evaluator.isExpressionsAsActions()); + } +} From 049a09f2d3df2baf14f4a95b65229478ce80b618 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Sun, 19 Apr 2026 19:19:49 +0200 Subject: [PATCH 011/124] docs(changelog): update changelog with test coverage batches 6-10 Coverage progress: 48.1% -> 49.1% line, 42.7% -> 43.2% branch 8 new test files across models, services, and rules engine. --- docs/changelog.md | 43 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/docs/changelog.md b/docs/changelog.md index 07c57183b..e122e753a 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -13,6 +13,49 @@ Each entry follows this format: - **Decision** — Key design decisions and their reasoning - **Files** — Links to modified files +## Unit Test Coverage Expansion — Batches 6–10 (2026-04-19) + +**Repo:** EDDI (`test/coverage-tier-1-2`) + +**What changed:** Continued systematic unit test expansion for OpenSSF Silver compliance. Added 7 new test files covering models, services, and core rules engine logic. + +### Batch 6 — Service & Utility Tests +- `AgentCardServiceTest` — getAgentCard, buildAgentCard, listA2AAgents (constructor-injectable, bypassing CDI) +- `ContextLoggerTest` — MDC context creation, field combos, null safety +- `SimpleDocumentDescriptorTest` — constructors, setters + +### Batch 7 — LlmConfiguration Nested Models +- `LlmConfigurationModelsTest` — 9 nested classes: RagDefaults, ModelCascadeConfig, CascadeStep, ToolResponseLimits, McpServerConfig, A2AAgentConfig, RetryConfiguration, KnowledgeBaseReference, ConversationSummaryConfig (including `validate()` boundary logic) + +### Batch 8 — Small Model Batch +- `SmallModelsBatchTest` — DeploymentInfo, ConversationStatus, DataFactory, HttpPreRequest, HttpCodeValidator, PropertySetterConfiguration, Deployment.Environment.fromString/toValue, Deployment.Status + +### Batch 9 — Rule Deserialization +- `RuleDeserializationTest` — 11 tests covering the full deserialization pipeline with real ObjectMapper + mock CDI. Tests: empty groups, default/explicit execution strategies, rules with actions, condition type factory (actionmatcher, negation, connector, occurrence, dependency, contentTypeMatcher), nested conditions, invalid JSON error handling. + +### Batch 10 — Rules Engine Core +- `RuleTest` — execute() with no/pass/fail/error conditions, short-circuit on first failure, infinite loop detection, equals/hashCode, clone, toString +- `RulesEvaluatorTest` — empty sets, success/fail/error routing, execution strategies (executeUntilFirstSuccess vs executeAll), null rule set guard + +### Coverage Progress + +| Checkpoint | Line % | Branch % | +|------------|--------|----------| +| Batch 6 | 48.1% | 42.7% | +| Batch 10 | 49.1% | 43.2% | + +**Files:** +- `src/test/java/ai/labs/eddi/engine/a2a/AgentCardServiceTest.java` — new +- `src/test/java/ai/labs/eddi/engine/internal/ContextLoggerTest.java` — new +- `src/test/java/ai/labs/eddi/configs/descriptors/model/SimpleDocumentDescriptorTest.java` — new +- `src/test/java/ai/labs/eddi/modules/llm/model/LlmConfigurationModelsTest.java` — new +- `src/test/java/ai/labs/eddi/configs/model/SmallModelsBatchTest.java` — new +- `src/test/java/ai/labs/eddi/modules/rules/impl/RuleDeserializationTest.java` — new +- `src/test/java/ai/labs/eddi/modules/rules/impl/RuleTest.java` — new +- `src/test/java/ai/labs/eddi/modules/rules/impl/RulesEvaluatorTest.java` — new + +--- + ## PR Review Fixes — Quota Ordering, Log Injection, Doc Hygiene (2026-04-17) **Repo:** EDDI (`feature/observability`) From a874b47556cb61dfa3ec84f25d073b3552db4db0 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Sun, 19 Apr 2026 22:18:11 +0200 Subject: [PATCH 012/124] test(coverage): add unit tests for output models, engine models, PrePostUtils, RagConfiguration - OutputModelsTest: TextOutputItem, ButtonOutputItem, QuickReply, OutputValue, OutputEntry (Comparable sorting), Jackson polymorphic deserialization - OutputTypesTest: all 8 OutputItem subtypes (Image, AgentFace, ApplicationLink, InputField, QuickReply, Other/Map delegation), Jackson polymorphism - EngineModelsTest: Deployment.Environment (backward compat fromString + Jackson), Deployment.Status, Context, InputData, DeadLetterEntry, AgentDeploymentStatus, CoordinatorStatus - PrePostUtilsTest: verifyHttpCode with DEFAULT validator, custom codes, skip logic - RagConfigurationTest: defaults, setters, Jackson round-trip - ConversationOutputTest: typed get(), LinkedHashMap ordering - Fix McpToolFilterTest: null tool name NPE (Set.of doesn't allow null in contains) - Fix BackupModelsTest: SyncMapping now takes 3 args (sourceAgentVersion added) - Fix ConversationPropertiesTest: Map type for Property constructor Line coverage: 43.7% -> 50.4% (+6.7pp, +1486 lines covered) --- .../eddi/backup/model/BackupModelsTest.java | 136 ++++++++ .../apicalls/model/ApiCallModelTest.java | 174 ++++++++++ .../model/AgentGroupConfigurationTest.java | 233 ++++++++++++++ .../migration/model/MigrationLogTest.java | 49 +++ .../rag/model/RagConfigurationTest.java | 78 +++++ .../model/WorkflowConfigurationTest.java | 164 ++++++++++ .../eddi/engine/mcp/McpToolFilterTest.java | 80 +++++ .../eddi/engine/mcp/McpToolUtilsTest.java | 111 +++++++ .../memory/model/ConversationOutputTest.java | 74 +++++ .../model/ConversationPropertiesTest.java | 131 ++++++++ .../eddi/engine/model/EngineModelsTest.java | 209 ++++++++++++ .../apicalls/impl/PrePostUtilsTest.java | 91 ++++++ .../llm/impl/ConversationOutputUtilsTest.java | 79 +++++ .../output/model/OutputModelsTest.java | 264 +++++++++++++++ .../output/model/types/OutputTypesTest.java | 303 ++++++++++++++++++ 15 files changed, 2176 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/backup/model/BackupModelsTest.java create mode 100644 src/test/java/ai/labs/eddi/configs/apicalls/model/ApiCallModelTest.java create mode 100644 src/test/java/ai/labs/eddi/configs/groups/model/AgentGroupConfigurationTest.java create mode 100644 src/test/java/ai/labs/eddi/configs/migration/model/MigrationLogTest.java create mode 100644 src/test/java/ai/labs/eddi/configs/rag/model/RagConfigurationTest.java create mode 100644 src/test/java/ai/labs/eddi/configs/workflows/model/WorkflowConfigurationTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/mcp/McpToolFilterTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/memory/model/ConversationOutputTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/memory/model/ConversationPropertiesTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/model/EngineModelsTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/apicalls/impl/PrePostUtilsTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/llm/impl/ConversationOutputUtilsTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/output/model/OutputModelsTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/output/model/types/OutputTypesTest.java diff --git a/src/test/java/ai/labs/eddi/backup/model/BackupModelsTest.java b/src/test/java/ai/labs/eddi/backup/model/BackupModelsTest.java new file mode 100644 index 000000000..3451e91dd --- /dev/null +++ b/src/test/java/ai/labs/eddi/backup/model/BackupModelsTest.java @@ -0,0 +1,136 @@ +package ai.labs.eddi.backup.model; + +import ai.labs.eddi.backup.model.ImportPreview.DiffAction; +import ai.labs.eddi.backup.model.ImportPreview.ResourceDiff; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class BackupModelsTest { + + // ==================== ImportPreview ==================== + + @Test + void importPreview_allFieldsAccessible() { + var diff = new ResourceDiff("src1", "agent", "My Agent", + DiffAction.CREATE, null, null, null, + "{\"config\":true}", null, -1); + + var preview = new ImportPreview("srcAgent", "Source Agent", + "tgtAgent", "Target Agent", List.of(diff)); + + assertEquals("srcAgent", preview.sourceAgentId()); + assertEquals("Source Agent", preview.sourceAgentName()); + assertEquals("tgtAgent", preview.targetAgentId()); + assertEquals("Target Agent", preview.targetAgentName()); + assertEquals(1, preview.resources().size()); + } + + @Test + void resourceDiff_createAction() { + var diff = new ResourceDiff("id1", "workflow", "Workflow 1", + DiffAction.CREATE, null, null, null, + "{}", null, 0); + + assertEquals("id1", diff.sourceId()); + assertEquals("workflow", diff.resourceType()); + assertEquals("Workflow 1", diff.name()); + assertEquals(DiffAction.CREATE, diff.action()); + assertNull(diff.targetId()); + assertNull(diff.targetVersion()); + assertNull(diff.matchStrategy()); + assertEquals(0, diff.workflowIndex()); + } + + @Test + void resourceDiff_updateAction_withTarget() { + var diff = new ResourceDiff("id1", "langchain", "LLM Config", + DiffAction.UPDATE, "tgt1", 3, "type", + "{\"new\":true}", "{\"old\":true}", -1); + + assertEquals(DiffAction.UPDATE, diff.action()); + assertEquals("tgt1", diff.targetId()); + assertEquals(3, diff.targetVersion()); + assertEquals("type", diff.matchStrategy()); + } + + @Test + void diffAction_allValues() { + assertEquals(4, DiffAction.values().length); + assertNotNull(DiffAction.valueOf("CREATE")); + assertNotNull(DiffAction.valueOf("UPDATE")); + assertNotNull(DiffAction.valueOf("SKIP")); + assertNotNull(DiffAction.valueOf("CONFLICT")); + } + + // ==================== ExportPreview ==================== + + @Test + void exportPreview_allFieldsAccessible() { + var resource = new ExportPreview.ExportableResource( + "res1", 2, "langchain", "My LLM", "wf1", 0, false); + + var preview = new ExportPreview("agent1", "My Agent", 3, List.of(resource)); + + assertEquals("agent1", preview.agentId()); + assertEquals("My Agent", preview.agentName()); + assertEquals(3, preview.agentVersion()); + assertEquals(1, preview.resources().size()); + } + + @Test + void exportableResource_requiredFlag() { + var required = new ExportPreview.ExportableResource( + "agent1", 1, "agent", "Agent", null, -1, true); + assertTrue(required.required()); + + var optional = new ExportPreview.ExportableResource( + "ext1", 1, "langchain", "LLM", "wf1", 0, false); + assertFalse(optional.required()); + } + + // ==================== SyncRequest ==================== + + @Test + void syncRequest_allFieldsAccessible() { + var request = new SyncRequest("srcAgent", 2, "tgtAgent", + java.util.Set.of("res1", "res2"), List.of("wf1", "wf2")); + + assertEquals("srcAgent", request.sourceAgentId()); + assertEquals(2, request.sourceAgentVersion()); + assertEquals("tgtAgent", request.targetAgentId()); + assertEquals(2, request.selectedResources().size()); + assertEquals(2, request.workflowOrder().size()); + } + + @Test + void syncRequest_nullOptionalFields() { + var request = new SyncRequest("srcAgent", null, null, null, null); + + assertEquals("srcAgent", request.sourceAgentId()); + assertNull(request.sourceAgentVersion()); + assertNull(request.targetAgentId()); + assertNull(request.selectedResources()); + assertNull(request.workflowOrder()); + } + + // ==================== SyncMapping ==================== + + @Test + void syncMapping_allFieldsAccessible() { + var mapping = new SyncMapping("src1", 2, "tgt1"); + assertEquals("src1", mapping.sourceAgentId()); + assertEquals(2, mapping.sourceAgentVersion()); + assertEquals("tgt1", mapping.targetAgentId()); + } + + @Test + void syncMapping_nullOptionalFields() { + var mapping = new SyncMapping("src1", null, null); + assertEquals("src1", mapping.sourceAgentId()); + assertNull(mapping.sourceAgentVersion()); + assertNull(mapping.targetAgentId()); + } +} diff --git a/src/test/java/ai/labs/eddi/configs/apicalls/model/ApiCallModelTest.java b/src/test/java/ai/labs/eddi/configs/apicalls/model/ApiCallModelTest.java new file mode 100644 index 000000000..2c7b1e85b --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/apicalls/model/ApiCallModelTest.java @@ -0,0 +1,174 @@ +package ai.labs.eddi.configs.apicalls.model; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class ApiCallModelTest { + + // ==================== ApiCall ==================== + + @Test + void apiCall_defaults() { + var call = new ApiCall(); + assertNull(call.getName()); + assertNull(call.getDescription()); + assertNull(call.getParameters()); + assertNull(call.getActions()); + assertFalse(call.getSaveResponse()); + assertFalse(call.getFireAndForget()); + assertFalse(call.getIsBatchCalls()); + } + + @Test + void apiCall_settersAndGetters() { + var call = new ApiCall(); + call.setName("weatherApi"); + call.setDescription("Get weather for a city"); + call.setParameters(Map.of("city", "Name of the city")); + call.setActions(List.of("api_weather")); + call.setSaveResponse(true); + call.setResponseObjectName("weatherResult"); + call.setResponseHeaderObjectName("weatherHeaders"); + call.setFireAndForget(false); + call.setIsBatchCalls(true); + call.setIterationObjectName("cities"); + + assertEquals("weatherApi", call.getName()); + assertEquals("Get weather for a city", call.getDescription()); + assertEquals(1, call.getParameters().size()); + assertEquals(List.of("api_weather"), call.getActions()); + assertTrue(call.getSaveResponse()); + assertEquals("weatherResult", call.getResponseObjectName()); + assertEquals("weatherHeaders", call.getResponseHeaderObjectName()); + assertFalse(call.getFireAndForget()); + assertTrue(call.getIsBatchCalls()); + assertEquals("cities", call.getIterationObjectName()); + } + + @Test + void apiCall_preAndPostRequest() { + var call = new ApiCall(); + + var preReq = new HttpPreRequest(); + call.setPreRequest(preReq); + assertSame(preReq, call.getPreRequest()); + + var request = new Request(); + call.setRequest(request); + assertSame(request, call.getRequest()); + + var postResp = new HttpPostResponse(); + call.setPostResponse(postResp); + assertSame(postResp, call.getPostResponse()); + } + + // ==================== PostResponse ==================== + + @Test + void postResponse_settersAndGetters() { + var pr = new PostResponse(); + assertNull(pr.getPropertyInstructions()); + assertNull(pr.getOutputBuildInstructions()); + assertNull(pr.getQrBuildInstructions()); + + pr.setPropertyInstructions(List.of()); + pr.setOutputBuildInstructions(List.of()); + pr.setQrBuildInstructions(List.of()); + + assertNotNull(pr.getPropertyInstructions()); + assertNotNull(pr.getOutputBuildInstructions()); + assertNotNull(pr.getQrBuildInstructions()); + } + + // ==================== HttpCodeValidator ==================== + + @Test + void httpCodeValidator_default() { + var def = HttpCodeValidator.DEFAULT; + assertNotNull(def.getRunOnHttpCode()); + assertNotNull(def.getSkipOnHttpCode()); + assertTrue(def.getRunOnHttpCode().contains(200)); + } + + @Test + void httpCodeValidator_settersAndGetters() { + var validator = new HttpCodeValidator(); + validator.setRunOnHttpCode(List.of(200, 201)); + validator.setSkipOnHttpCode(List.of(204)); + + assertEquals(2, validator.getRunOnHttpCode().size()); + assertEquals(1, validator.getSkipOnHttpCode().size()); + } + + // ==================== Request ==================== + + @Test + void request_defaults() { + var request = new Request(); + assertEquals("", request.getPath()); + assertEquals("GET", request.getMethod()); + assertEquals("", request.getContentType()); + assertEquals("", request.getBody()); + assertNotNull(request.getHeaders()); + assertTrue(request.getHeaders().isEmpty()); + assertNotNull(request.getQueryParams()); + assertTrue(request.getQueryParams().isEmpty()); + } + + @Test + void request_settersAndGetters() { + var request = new Request(); + request.setPath("https://api.example.com/weather"); + request.setMethod("POST"); + request.setContentType("application/json"); + request.setBody("{\"city\":\"Berlin\"}"); + request.setHeaders(Map.of("Authorization", "Bearer token")); + request.setQueryParams(Map.of("units", "metric")); + + assertEquals("https://api.example.com/weather", request.getPath()); + assertEquals("POST", request.getMethod()); + assertEquals("application/json", request.getContentType()); + assertEquals("{\"city\":\"Berlin\"}", request.getBody()); + assertEquals("Bearer token", request.getHeaders().get("Authorization")); + assertEquals("metric", request.getQueryParams().get("units")); + } + + // ==================== Jackson round-trip ==================== + + @Test + void apiCall_jacksonRoundTrip() throws Exception { + var call = new ApiCall(); + call.setName("testCall"); + call.setActions(List.of("action1")); + call.setSaveResponse(true); + + var mapper = new ObjectMapper(); + var json = mapper.writeValueAsString(call); + var deserialized = mapper.readValue(json, ApiCall.class); + + assertEquals("testCall", deserialized.getName()); + assertEquals(List.of("action1"), deserialized.getActions()); + assertTrue(deserialized.getSaveResponse()); + } + + @Test + void request_jacksonRoundTrip() throws Exception { + var request = new Request(); + request.setPath("/api/v1/data"); + request.setMethod("PUT"); + request.setBody("{\"key\":\"val\"}"); + + var mapper = new ObjectMapper(); + var json = mapper.writeValueAsString(request); + var deserialized = mapper.readValue(json, Request.class); + + assertEquals("/api/v1/data", deserialized.getPath()); + assertEquals("PUT", deserialized.getMethod()); + assertEquals("{\"key\":\"val\"}", deserialized.getBody()); + } +} diff --git a/src/test/java/ai/labs/eddi/configs/groups/model/AgentGroupConfigurationTest.java b/src/test/java/ai/labs/eddi/configs/groups/model/AgentGroupConfigurationTest.java new file mode 100644 index 000000000..44ac233fd --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/groups/model/AgentGroupConfigurationTest.java @@ -0,0 +1,233 @@ +package ai.labs.eddi.configs.groups.model; + +import ai.labs.eddi.configs.groups.model.AgentGroupConfiguration.*; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class AgentGroupConfigurationTest { + + // ==================== Basic getters/setters ==================== + + @Test + void nameAndDescription() { + var config = new AgentGroupConfiguration(); + config.setName("Test Group"); + config.setDescription("A test discussion group"); + + assertEquals("Test Group", config.getName()); + assertEquals("A test discussion group", config.getDescription()); + } + + @Test + void moderatorAgentId() { + var config = new AgentGroupConfiguration(); + config.setModeratorAgentId("mod-agent"); + assertEquals("mod-agent", config.getModeratorAgentId()); + } + + @Test + void maxRounds_default() { + var config = new AgentGroupConfiguration(); + assertEquals(2, config.getMaxRounds()); + } + + @Test + void maxRounds_setter() { + var config = new AgentGroupConfiguration(); + config.setMaxRounds(5); + assertEquals(5, config.getMaxRounds()); + } + + @Test + void style_allValues() { + assertEquals(6, DiscussionStyle.values().length); + assertNotNull(DiscussionStyle.valueOf("ROUND_TABLE")); + assertNotNull(DiscussionStyle.valueOf("PEER_REVIEW")); + assertNotNull(DiscussionStyle.valueOf("DEVIL_ADVOCATE")); + assertNotNull(DiscussionStyle.valueOf("DELPHI")); + assertNotNull(DiscussionStyle.valueOf("DEBATE")); + assertNotNull(DiscussionStyle.valueOf("CUSTOM")); + } + + @Test + void style_setAndGet() { + var config = new AgentGroupConfiguration(); + config.setStyle(DiscussionStyle.DEBATE); + assertEquals(DiscussionStyle.DEBATE, config.getStyle()); + } + + // ==================== GroupMember ==================== + + @Test + void groupMember_fullConstructor() { + var member = new GroupMember("agent1", "Alice", 1, "PRO", MemberType.AGENT); + assertEquals("agent1", member.agentId()); + assertEquals("Alice", member.displayName()); + assertEquals(1, member.speakingOrder()); + assertEquals("PRO", member.role()); + assertEquals(MemberType.AGENT, member.memberType()); + } + + @Test + void groupMember_convenienceConstructor_defaultsToAgent() { + var member = new GroupMember("agent1", "Alice", 1, "CON"); + assertEquals(MemberType.AGENT, member.memberType()); + } + + @Test + void groupMember_groupType() { + var member = new GroupMember("subgroup1", "Subgroup", null, null, MemberType.GROUP); + assertEquals(MemberType.GROUP, member.memberType()); + assertNull(member.speakingOrder()); + assertNull(member.role()); + } + + @Test + void members_setAndGet() { + var config = new AgentGroupConfiguration(); + assertTrue(config.getMembers().isEmpty()); // default is empty list + + var members = List.of( + new GroupMember("a1", "Agent 1", 1, null), + new GroupMember("a2", "Agent 2", 2, "DEVIL_ADVOCATE")); + config.setMembers(members); + assertEquals(2, config.getMembers().size()); + } + + // ==================== DiscussionPhase ==================== + + @Test + void discussionPhase_fullConstructor() { + var phase = new DiscussionPhase("opening", PhaseType.OPINION, + "ALL", TurnOrder.PARALLEL, ContextScope.NONE, + false, "Give your opinion on {{question}}", 2); + + assertEquals("opening", phase.name()); + assertEquals(PhaseType.OPINION, phase.type()); + assertEquals("ALL", phase.participants()); + assertEquals(TurnOrder.PARALLEL, phase.turnOrder()); + assertEquals(ContextScope.NONE, phase.contextScope()); + assertFalse(phase.targetEachPeer()); + assertEquals("Give your opinion on {{question}}", phase.inputTemplate()); + assertEquals(2, phase.repeats()); + } + + @Test + void discussionPhase_convenienceConstructor_defaults() { + var phase = new DiscussionPhase("synthesis", PhaseType.SYNTHESIS); + + assertEquals("synthesis", phase.name()); + assertEquals(PhaseType.SYNTHESIS, phase.type()); + assertEquals("ALL", phase.participants()); + assertEquals(TurnOrder.SEQUENTIAL, phase.turnOrder()); + assertEquals(ContextScope.FULL, phase.contextScope()); + assertFalse(phase.targetEachPeer()); + assertNull(phase.inputTemplate()); + assertEquals(1, phase.repeats()); + } + + @Test + void phaseType_allValues() { + assertEquals(8, PhaseType.values().length); + assertNotNull(PhaseType.valueOf("OPINION")); + assertNotNull(PhaseType.valueOf("CRITIQUE")); + assertNotNull(PhaseType.valueOf("REVISION")); + assertNotNull(PhaseType.valueOf("CHALLENGE")); + assertNotNull(PhaseType.valueOf("DEFENSE")); + assertNotNull(PhaseType.valueOf("ARGUE")); + assertNotNull(PhaseType.valueOf("REBUTTAL")); + assertNotNull(PhaseType.valueOf("SYNTHESIS")); + } + + @Test + void contextScope_allValues() { + assertEquals(5, ContextScope.values().length); + assertNotNull(ContextScope.valueOf("NONE")); + assertNotNull(ContextScope.valueOf("FULL")); + assertNotNull(ContextScope.valueOf("LAST_PHASE")); + assertNotNull(ContextScope.valueOf("ANONYMOUS")); + assertNotNull(ContextScope.valueOf("OWN_FEEDBACK")); + } + + @Test + void turnOrder_allValues() { + assertEquals(2, TurnOrder.values().length); + assertNotNull(TurnOrder.valueOf("SEQUENTIAL")); + assertNotNull(TurnOrder.valueOf("PARALLEL")); + } + + // ==================== ProtocolConfig ==================== + + @Test + void protocolConfig_fullConstructor() { + var protocol = new ProtocolConfig(120, + ProtocolConfig.MemberFailurePolicy.RETRY, 3, + ProtocolConfig.MemberUnavailablePolicy.SKIP, 100); + + assertEquals(120, protocol.agentTimeoutSeconds()); + assertEquals(ProtocolConfig.MemberFailurePolicy.RETRY, protocol.onAgentFailure()); + assertEquals(3, protocol.maxRetries()); + assertEquals(ProtocolConfig.MemberUnavailablePolicy.SKIP, protocol.onMemberUnavailable()); + assertEquals(100, protocol.maxTurns()); + } + + @Test + void protocolConfig_backwardCompatibleConstructor_defaultsMaxTurnsToZero() { + var protocol = new ProtocolConfig(60, + ProtocolConfig.MemberFailurePolicy.SKIP, 2, + ProtocolConfig.MemberUnavailablePolicy.FAIL); + + assertEquals(0, protocol.maxTurns()); + } + + @Test + void memberFailurePolicy_allValues() { + assertEquals(3, ProtocolConfig.MemberFailurePolicy.values().length); + assertNotNull(ProtocolConfig.MemberFailurePolicy.valueOf("SKIP")); + assertNotNull(ProtocolConfig.MemberFailurePolicy.valueOf("RETRY")); + assertNotNull(ProtocolConfig.MemberFailurePolicy.valueOf("ABORT")); + } + + @Test + void memberUnavailablePolicy_allValues() { + assertEquals(2, ProtocolConfig.MemberUnavailablePolicy.values().length); + assertNotNull(ProtocolConfig.MemberUnavailablePolicy.valueOf("SKIP")); + assertNotNull(ProtocolConfig.MemberUnavailablePolicy.valueOf("FAIL")); + } + + @Test + void phases_setAndGet() { + var config = new AgentGroupConfiguration(); + assertNull(config.getPhases()); + + var phases = List.of( + new DiscussionPhase("opinion", PhaseType.OPINION), + new DiscussionPhase("synthesis", PhaseType.SYNTHESIS)); + config.setPhases(phases); + assertEquals(2, config.getPhases().size()); + } + + @Test + void protocol_setAndGet() { + var config = new AgentGroupConfiguration(); + assertNull(config.getProtocol()); + + var protocol = new ProtocolConfig(60, + ProtocolConfig.MemberFailurePolicy.SKIP, 2, + ProtocolConfig.MemberUnavailablePolicy.FAIL); + config.setProtocol(protocol); + assertEquals(60, config.getProtocol().agentTimeoutSeconds()); + } + + // ==================== MemberType ==================== + + @Test + void memberType_allValues() { + assertEquals(2, MemberType.values().length); + assertNotNull(MemberType.valueOf("AGENT")); + assertNotNull(MemberType.valueOf("GROUP")); + } +} diff --git a/src/test/java/ai/labs/eddi/configs/migration/model/MigrationLogTest.java b/src/test/java/ai/labs/eddi/configs/migration/model/MigrationLogTest.java new file mode 100644 index 000000000..385edf5bf --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/migration/model/MigrationLogTest.java @@ -0,0 +1,49 @@ +package ai.labs.eddi.configs.migration.model; + +import org.junit.jupiter.api.Test; + +import java.util.Date; + +import static org.junit.jupiter.api.Assertions.*; + +class MigrationLogTest { + + @Test + void constructor_withName_setsDefaults() { + var log = new MigrationLog("v6-qute-migration"); + + assertEquals("v6-qute-migration", log.getName()); + assertTrue(log.isFinished()); + assertNotNull(log.getTimestamp()); + } + + @Test + void defaultConstructor() { + var log = new MigrationLog(); + assertNull(log.getName()); + assertFalse(log.isFinished()); + assertNull(log.getTimestamp()); + } + + @Test + void settersAndGetters() { + var log = new MigrationLog(); + var now = new Date(); + + log.setName("test-migration"); + log.setFinished(true); + log.setTimestamp(now); + + assertEquals("test-migration", log.getName()); + assertTrue(log.isFinished()); + assertEquals(now, log.getTimestamp()); + } + + @Test + void setFinished_canToggle() { + var log = new MigrationLog("test"); + assertTrue(log.isFinished()); + log.setFinished(false); + assertFalse(log.isFinished()); + } +} diff --git a/src/test/java/ai/labs/eddi/configs/rag/model/RagConfigurationTest.java b/src/test/java/ai/labs/eddi/configs/rag/model/RagConfigurationTest.java new file mode 100644 index 000000000..327ab154c --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/rag/model/RagConfigurationTest.java @@ -0,0 +1,78 @@ +package ai.labs.eddi.configs.rag.model; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.Test; + +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class RagConfigurationTest { + + @Test + void defaults() { + var config = new RagConfiguration(); + assertNull(config.getName()); + assertEquals("openai", config.getEmbeddingProvider()); + assertNull(config.getEmbeddingParameters()); + assertEquals("in-memory", config.getStoreType()); + assertNull(config.getStoreParameters()); + assertEquals("recursive", config.getChunkStrategy()); + assertEquals(512, config.getChunkSize()); + assertEquals(64, config.getChunkOverlap()); + assertEquals(5, config.getMaxResults()); + assertEquals(0.6, config.getMinScore()); + } + + @Test + void settersAndGetters() { + var config = new RagConfiguration(); + config.setName("Product Knowledge Base"); + config.setEmbeddingProvider("azure-openai"); + config.setEmbeddingParameters(Map.of( + "endpoint", "https://my.openai.azure.com/", + "deploymentName", "text-embedding-3-small")); + config.setStoreType("pgvector"); + config.setStoreParameters(Map.of( + "host", "localhost", + "database", "eddi_rag")); + config.setChunkStrategy("paragraph"); + config.setChunkSize(1024); + config.setChunkOverlap(128); + config.setMaxResults(10); + config.setMinScore(0.75); + + assertEquals("Product Knowledge Base", config.getName()); + assertEquals("azure-openai", config.getEmbeddingProvider()); + assertEquals(2, config.getEmbeddingParameters().size()); + assertEquals("pgvector", config.getStoreType()); + assertEquals(2, config.getStoreParameters().size()); + assertEquals("paragraph", config.getChunkStrategy()); + assertEquals(1024, config.getChunkSize()); + assertEquals(128, config.getChunkOverlap()); + assertEquals(10, config.getMaxResults()); + assertEquals(0.75, config.getMinScore()); + } + + @Test + void jacksonRoundTrip() throws Exception { + var config = new RagConfiguration(); + config.setName("Test KB"); + config.setEmbeddingProvider("ollama"); + config.setStoreType("qdrant"); + config.setChunkSize(256); + config.setMaxResults(3); + config.setMinScore(0.8); + + var mapper = new ObjectMapper(); + var json = mapper.writeValueAsString(config); + var deserialized = mapper.readValue(json, RagConfiguration.class); + + assertEquals("Test KB", deserialized.getName()); + assertEquals("ollama", deserialized.getEmbeddingProvider()); + assertEquals("qdrant", deserialized.getStoreType()); + assertEquals(256, deserialized.getChunkSize()); + assertEquals(3, deserialized.getMaxResults()); + assertEquals(0.8, deserialized.getMinScore()); + } +} diff --git a/src/test/java/ai/labs/eddi/configs/workflows/model/WorkflowConfigurationTest.java b/src/test/java/ai/labs/eddi/configs/workflows/model/WorkflowConfigurationTest.java new file mode 100644 index 000000000..1aef73697 --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/workflows/model/WorkflowConfigurationTest.java @@ -0,0 +1,164 @@ +package ai.labs.eddi.configs.workflows.model; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.Test; + +import java.net.URI; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class WorkflowConfigurationTest { + + // ==================== Basic construction ==================== + + @Test + void defaultConstructor_emptySteps() { + var config = new WorkflowConfiguration(); + assertNotNull(config.getWorkflowSteps()); + assertTrue(config.getWorkflowSteps().isEmpty()); + } + + @Test + void setAndGetWorkflowSteps() { + var step = new WorkflowConfiguration.WorkflowStep(); + step.setType(URI.create("eddi://ai.labs.llm")); + step.setExtensions(Map.of("uri", "/llmstore/llms/abc?version=1")); + step.setConfig(Map.of("actions", "llm_call")); + + var config = new WorkflowConfiguration(); + config.setWorkflowSteps(List.of(step)); + + assertEquals(1, config.getWorkflowSteps().size()); + assertEquals(URI.create("eddi://ai.labs.llm"), config.getWorkflowSteps().get(0).getType()); + } + + // ==================== WorkflowStep ==================== + + @Test + void workflowStep_defaultsEmpty() { + var step = new WorkflowConfiguration.WorkflowStep(); + assertNull(step.getType()); + assertNotNull(step.getExtensions()); + assertTrue(step.getExtensions().isEmpty()); + assertNotNull(step.getConfig()); + assertTrue(step.getConfig().isEmpty()); + } + + @Test + void workflowStep_setType() { + var step = new WorkflowConfiguration.WorkflowStep(); + step.setType(URI.create("eddi://ai.labs.dictionary")); + assertEquals("eddi://ai.labs.dictionary", step.getType().toString()); + } + + @Test + void workflowStep_setExtensions() { + var step = new WorkflowConfiguration.WorkflowStep(); + step.setExtensions(Map.of("uri", "/dictionarystore/dicts/123?version=1")); + assertEquals("/dictionarystore/dicts/123?version=1", step.getExtensions().get("uri")); + } + + @Test + void workflowStep_setConfig() { + var step = new WorkflowConfiguration.WorkflowStep(); + step.setConfig(Map.of("actions", "greeting", "timeout", 30)); + assertEquals("greeting", step.getConfig().get("actions")); + assertEquals(30, step.getConfig().get("timeout")); + } + + // ==================== Jackson deserialization ==================== + + @Test + void jackson_workflowExtensionsAlias() throws Exception { + // The setter has @JsonAlias("workflowExtensions") for backward compatibility + var json = """ + { + "workflowExtensions": [ + { + "type": "eddi://ai.labs.llm", + "extensions": {"uri": "/llm/abc?version=1"}, + "config": {} + } + ] + } + """; + + var mapper = new ObjectMapper(); + var config = mapper.readValue(json, WorkflowConfiguration.class); + + assertEquals(1, config.getWorkflowSteps().size()); + assertEquals(URI.create("eddi://ai.labs.llm"), config.getWorkflowSteps().get(0).getType()); + } + + @Test + void jackson_workflowSteps_standardName() throws Exception { + var json = """ + { + "workflowSteps": [ + { + "type": "eddi://ai.labs.dictionary", + "extensions": {}, + "config": {"actions": "parse"} + } + ] + } + """; + + var mapper = new ObjectMapper(); + var config = mapper.readValue(json, WorkflowConfiguration.class); + + assertEquals(1, config.getWorkflowSteps().size()); + assertEquals("parse", config.getWorkflowSteps().get(0).getConfig().get("actions")); + } + + @Test + void jackson_emptyJson() throws Exception { + var mapper = new ObjectMapper(); + var config = mapper.readValue("{}", WorkflowConfiguration.class); + + assertNotNull(config.getWorkflowSteps()); + assertTrue(config.getWorkflowSteps().isEmpty()); + } + + @Test + void jackson_roundTrip() throws Exception { + var step = new WorkflowConfiguration.WorkflowStep(); + step.setType(URI.create("eddi://ai.labs.rules")); + step.setExtensions(Map.of("uri", "/rulesstore/rulesets/xyz?version=2")); + step.setConfig(Map.of("actions", "evaluate")); + + var config = new WorkflowConfiguration(); + config.setWorkflowSteps(List.of(step)); + + var mapper = new ObjectMapper(); + var json = mapper.writeValueAsString(config); + var deserialized = mapper.readValue(json, WorkflowConfiguration.class); + + assertEquals(1, deserialized.getWorkflowSteps().size()); + assertEquals("eddi://ai.labs.rules", deserialized.getWorkflowSteps().get(0).getType().toString()); + } + + // ==================== Multiple steps ==================== + + @Test + void multipleWorkflowSteps() { + var step1 = new WorkflowConfiguration.WorkflowStep(); + step1.setType(URI.create("eddi://ai.labs.dictionary")); + + var step2 = new WorkflowConfiguration.WorkflowStep(); + step2.setType(URI.create("eddi://ai.labs.rules")); + + var step3 = new WorkflowConfiguration.WorkflowStep(); + step3.setType(URI.create("eddi://ai.labs.llm")); + + var config = new WorkflowConfiguration(); + config.setWorkflowSteps(List.of(step1, step2, step3)); + + assertEquals(3, config.getWorkflowSteps().size()); + assertEquals("eddi://ai.labs.dictionary", config.getWorkflowSteps().get(0).getType().toString()); + assertEquals("eddi://ai.labs.rules", config.getWorkflowSteps().get(1).getType().toString()); + assertEquals("eddi://ai.labs.llm", config.getWorkflowSteps().get(2).getType().toString()); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/mcp/McpToolFilterTest.java b/src/test/java/ai/labs/eddi/engine/mcp/McpToolFilterTest.java new file mode 100644 index 000000000..45de7b153 --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/mcp/McpToolFilterTest.java @@ -0,0 +1,80 @@ +package ai.labs.eddi.engine.mcp; + +import io.quarkiverse.mcp.server.FilterContext; +import io.quarkiverse.mcp.server.ToolManager.ToolInfo; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class McpToolFilterTest { + + private final McpToolFilter filter = new McpToolFilter(); + + // --- Whitelisted tool names --- + + @ParameterizedTest + @ValueSource(strings = { + "list_agents", "create_conversation", "talk_to_agent", + "chat_with_agent", "read_conversation", "read_conversation_log", + "list_conversations", "get_agent", "deploy_agent", + "undeploy_agent", "get_deployment_status", "list_workflows", + "create_agent", "delete_agent", "update_agent", + "read_workflow", "read_resource", "setup_agent", + "create_api_agent", "update_resource", "create_resource", + "delete_resource", "apply_agent_changes", "list_agent_resources", + "read_agent_logs", "read_audit_trail", "discover_agents", + "chat_managed", "list_agent_triggers", "create_agent_trigger", + "update_agent_trigger", "delete_agent_trigger", + "describe_discussion_styles", "list_groups", "read_group", + "create_group", "update_group", "delete_group", + "discuss_with_group", "read_group_conversation", + "list_group_conversations", "list_agent_configs" + }) + void test_whitelistedTools_returnsTrue(String toolName) { + var toolInfo = mock(ToolInfo.class); + when(toolInfo.name()).thenReturn(toolName); + assertTrue(filter.test(toolInfo, (FilterContext) null)); + } + + // --- Non-whitelisted tools (langchain4j built-in Agent tools) --- + + @ParameterizedTest + @ValueSource(strings = { + "calculate", "get_current_date_time", "search_web", + "scrape_url", "summarize_text", "read_pdf", + "format_data", "get_weather", "unknown_tool", + "recall_conversation", "store_user_memory" + }) + void test_nonWhitelistedTools_returnsFalse(String toolName) { + var toolInfo = mock(ToolInfo.class); + when(toolInfo.name()).thenReturn(toolName); + assertFalse(filter.test(toolInfo, (FilterContext) null)); + } + + // --- Edge cases --- + + @Test + void test_nullToolName_throwsNpe() { + var toolInfo = mock(ToolInfo.class); + when(toolInfo.name()).thenReturn(null); + assertThrows(NullPointerException.class, + () -> filter.test(toolInfo, (FilterContext) null)); + } + + @Test + void test_emptyToolName_returnsFalse() { + var toolInfo = mock(ToolInfo.class); + when(toolInfo.name()).thenReturn(""); + assertFalse(filter.test(toolInfo, (FilterContext) null)); + } + + @Test + void test_caseSensitive_wrongCase_returnsFalse() { + var toolInfo = mock(ToolInfo.class); + when(toolInfo.name()).thenReturn("List_Agents"); + assertFalse(filter.test(toolInfo, (FilterContext) null)); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/mcp/McpToolUtilsTest.java b/src/test/java/ai/labs/eddi/engine/mcp/McpToolUtilsTest.java index 5f189f3a3..460124beb 100644 --- a/src/test/java/ai/labs/eddi/engine/mcp/McpToolUtilsTest.java +++ b/src/test/java/ai/labs/eddi/engine/mcp/McpToolUtilsTest.java @@ -1,9 +1,14 @@ package ai.labs.eddi.engine.mcp; import ai.labs.eddi.engine.model.Deployment.Environment; +import ai.labs.eddi.engine.runtime.client.factory.IRestInterfaceFactory; +import ai.labs.eddi.engine.runtime.client.factory.RestInterfaceFactory; +import io.quarkus.security.ForbiddenException; +import io.quarkus.security.identity.SecurityIdentity; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; /** * Unit tests for McpToolUtils — shared MCP utility methods. @@ -133,4 +138,110 @@ void errorJson_messageWithNewlines() { String result = McpToolUtils.errorJson("line1\nline2"); assertEquals("{\"error\":\"line1\\nline2\"}", result); } + + // --- requireRole --- + + @Test + void requireRole_authDisabled_neverThrows() { + assertDoesNotThrow(() -> McpToolUtils.requireRole(null, false, "eddi-admin")); + } + + @Test + void requireRole_authEnabled_nullIdentity_throws() { + assertThrows(ForbiddenException.class, + () -> McpToolUtils.requireRole(null, true, "eddi-admin")); + } + + @Test + void requireRole_authEnabled_anonymousIdentity_throws() { + var identity = mock(SecurityIdentity.class); + when(identity.isAnonymous()).thenReturn(true); + assertThrows(ForbiddenException.class, + () -> McpToolUtils.requireRole(identity, true, "eddi-admin")); + } + + @Test + void requireRole_authEnabled_lacksRole_throws() { + var identity = mock(SecurityIdentity.class); + when(identity.isAnonymous()).thenReturn(false); + when(identity.hasRole("eddi-admin")).thenReturn(false); + assertThrows(ForbiddenException.class, + () -> McpToolUtils.requireRole(identity, true, "eddi-admin")); + } + + @Test + void requireRole_authEnabled_hasRole_passes() { + var identity = mock(SecurityIdentity.class); + when(identity.isAnonymous()).thenReturn(false); + when(identity.hasRole("eddi-admin")).thenReturn(true); + assertDoesNotThrow(() -> McpToolUtils.requireRole(identity, true, "eddi-admin")); + } + + // --- extractIdFromLocation --- + + @Test + void extractIdFromLocation_withVersionQuery() { + assertEquals("abc123", McpToolUtils.extractIdFromLocation("/store/resources/abc123?version=1")); + } + + @Test + void extractIdFromLocation_withoutQuery() { + assertEquals("abc123", McpToolUtils.extractIdFromLocation("/store/resources/abc123")); + } + + @Test + void extractIdFromLocation_nullOrBlank_returnsNull() { + assertNull(McpToolUtils.extractIdFromLocation(null)); + assertNull(McpToolUtils.extractIdFromLocation("")); + assertNull(McpToolUtils.extractIdFromLocation(" ")); + } + + @Test + void extractIdFromLocation_trailingSlash_returnsNull() { + assertNull(McpToolUtils.extractIdFromLocation("/store/resources/")); + } + + // --- extractVersionFromLocation --- + + @Test + void extractVersionFromLocation_present() { + assertEquals(3, McpToolUtils.extractVersionFromLocation("/store/resources/abc?version=3")); + } + + @Test + void extractVersionFromLocation_multipleParams() { + assertEquals(5, McpToolUtils.extractVersionFromLocation("/store/resources/abc?version=5&other=val")); + } + + @Test + void extractVersionFromLocation_missing_returns1() { + assertEquals(1, McpToolUtils.extractVersionFromLocation("/store/resources/abc")); + } + + @Test + void extractVersionFromLocation_null_returns1() { + assertEquals(1, McpToolUtils.extractVersionFromLocation(null)); + } + + @Test + void extractVersionFromLocation_invalidNumber_returns1() { + assertEquals(1, McpToolUtils.extractVersionFromLocation("/store/resources/abc?version=xyz")); + } + + // --- getRestStore --- + + @Test + void getRestStore_success() throws Exception { + var factory = mock(IRestInterfaceFactory.class); + var proxy = mock(Runnable.class); + when(factory.get(Runnable.class)).thenReturn(proxy); + assertSame(proxy, McpToolUtils.getRestStore(factory, Runnable.class)); + } + + @Test + void getRestStore_factoryException_wrapsInRuntime() throws Exception { + var factory = mock(IRestInterfaceFactory.class); + when(factory.get(any())).thenThrow(new RestInterfaceFactory.RestInterfaceFactoryException("fail", new Exception("cause"))); + assertThrows(RuntimeException.class, () -> McpToolUtils.getRestStore(factory, Runnable.class)); + } } diff --git a/src/test/java/ai/labs/eddi/engine/memory/model/ConversationOutputTest.java b/src/test/java/ai/labs/eddi/engine/memory/model/ConversationOutputTest.java new file mode 100644 index 000000000..0a1b9519e --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/memory/model/ConversationOutputTest.java @@ -0,0 +1,74 @@ +package ai.labs.eddi.engine.memory.model; + +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class ConversationOutputTest { + + @Test + void get_standardMapBehavior() { + var output = new ConversationOutput(); + output.put("input", "Hello"); + assertEquals("Hello", output.get("input")); + } + + @Test + void get_typed_returnsTypedValue() { + var output = new ConversationOutput(); + output.put("count", 42); + Integer result = output.get("count", Integer.class); + assertEquals(42, result); + } + + @Test + void get_typed_withString() { + var output = new ConversationOutput(); + output.put("text", "hello"); + String result = output.get("text", String.class); + assertEquals("hello", result); + } + + @Test + void get_typed_withList() { + var output = new ConversationOutput(); + var list = List.of(Map.of("text", "Hi")); + output.put("output", list); + @SuppressWarnings("unchecked") + List> result = output.get("output", List.class); + assertEquals(1, result.size()); + } + + @Test + void get_typed_missingKey_returnsNull() { + var output = new ConversationOutput(); + assertNull(output.get("missing", String.class)); + } + + @Test + void extendsLinkedHashMap_preservesInsertionOrder() { + var output = new ConversationOutput(); + output.put("first", 1); + output.put("second", 2); + output.put("third", 3); + + var keys = output.keySet().stream().toList(); + assertEquals("first", keys.get(0)); + assertEquals("second", keys.get(1)); + assertEquals("third", keys.get(2)); + } + + @Test + void multipleEntries() { + var output = new ConversationOutput(); + output.put("input", "How's the weather?"); + output.put("output", List.of(Map.of("text", "It's sunny!"))); + output.put("action", "weather_api"); + + assertEquals(3, output.size()); + assertNotNull(output.get("output")); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/memory/model/ConversationPropertiesTest.java b/src/test/java/ai/labs/eddi/engine/memory/model/ConversationPropertiesTest.java new file mode 100644 index 000000000..cad40fe7e --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/memory/model/ConversationPropertiesTest.java @@ -0,0 +1,131 @@ +package ai.labs.eddi.engine.memory.model; + +import ai.labs.eddi.configs.properties.model.Property; +import ai.labs.eddi.engine.memory.IConversationMemory; +import ai.labs.eddi.engine.memory.IData; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class ConversationPropertiesTest { + + private IConversationMemory memory; + private IConversationMemory.IWritableConversationStep currentStep; + private ConversationProperties properties; + + @BeforeEach + void setUp() { + memory = mock(IConversationMemory.class); + currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + properties = new ConversationProperties(memory); + } + + // ==================== put ==================== + + @Test + void put_stringProperty_storesInMapAndMemory() { + var prop = new Property("name", "Alice", Property.Scope.conversation); + properties.put("name", prop); + + assertEquals(prop, properties.get("name")); + assertEquals("Alice", properties.toMap().get("name")); + verify(currentStep).storeData(any(IData.class)); + verify(currentStep).addConversationOutputMap(eq("properties"), anyMap()); + } + + @Test + void put_intProperty() { + var prop = new Property("age", 30, Property.Scope.conversation); + properties.put("age", prop); + + assertEquals(30, properties.toMap().get("age")); + } + + @Test + void put_booleanProperty() { + var prop = new Property("active", true, Property.Scope.conversation); + properties.put("active", prop); + + assertEquals(true, properties.toMap().get("active")); + } + + @Test + void put_objectProperty() { + Map obj = Map.of("key", "value"); + var prop = new Property("settings", obj, Property.Scope.longTerm); + properties.put("settings", prop); + + assertEquals(obj, properties.toMap().get("settings")); + } + + @Test + void put_listProperty() { + List list = List.of("a", "b", "c"); + var prop = new Property("tags", list, Property.Scope.conversation); + properties.put("tags", prop); + + assertEquals(list, properties.toMap().get("tags")); + } + + @Test + void put_floatProperty() { + var prop = new Property("score", 0.95f, Property.Scope.step); + properties.put("score", prop); + + assertEquals(0.95f, properties.toMap().get("score")); + } + + @Test + void put_overwriteExistingProperty() { + properties.put("name", new Property("name", "Alice", Property.Scope.conversation)); + properties.put("name", new Property("name", "Bob", Property.Scope.conversation)); + + assertEquals("Bob", properties.toMap().get("name")); + assertEquals(1, properties.size()); + } + + // ==================== putAll ==================== + + @Test + void putAll_delegatesToPut() { + var p1 = new Property("a", "1", Property.Scope.conversation); + var p2 = new Property("b", "2", Property.Scope.conversation); + properties.putAll(Map.of("a", p1, "b", p2)); + + assertEquals(2, properties.size()); + assertEquals("1", properties.toMap().get("a")); + assertEquals("2", properties.toMap().get("b")); + } + + // ==================== toMap ==================== + + @Test + void toMap_emptyByDefault() { + assertTrue(properties.toMap().isEmpty()); + } + + @Test + void toMap_returnsPropertiesMapReference() { + properties.put("x", new Property("x", "val", Property.Scope.conversation)); + Map map = properties.toMap(); + assertEquals("val", map.get("x")); + } + + // ==================== null memory ==================== + + @Test + void put_nullMemory_stillStoresInHashMap() { + var props = new ConversationProperties(null); + var prop = new Property("key", "value", Property.Scope.conversation); + props.put("key", prop); + + assertEquals(prop, props.get("key")); + // toMap won't have the value since memory-backed storage is skipped + } +} diff --git a/src/test/java/ai/labs/eddi/engine/model/EngineModelsTest.java b/src/test/java/ai/labs/eddi/engine/model/EngineModelsTest.java new file mode 100644 index 000000000..85935b0bc --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/model/EngineModelsTest.java @@ -0,0 +1,209 @@ +package ai.labs.eddi.engine.model; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class EngineModelsTest { + + // ==================== Deployment.Environment ==================== + + @Test + void environment_fromString_production() { + assertEquals(Deployment.Environment.production, + Deployment.Environment.fromString("production")); + } + + @Test + void environment_fromString_test() { + assertEquals(Deployment.Environment.test, + Deployment.Environment.fromString("test")); + } + + @ParameterizedTest + @CsvSource({"unrestricted", "restricted", "PRODUCTION", "Production"}) + void environment_fromString_backwardCompat_production(String value) { + assertEquals(Deployment.Environment.production, + Deployment.Environment.fromString(value)); + } + + @Test + void environment_fromString_null_defaultsToProduction() { + assertEquals(Deployment.Environment.production, + Deployment.Environment.fromString(null)); + } + + @Test + void environment_fromString_unknown_defaultsToProduction() { + assertEquals(Deployment.Environment.production, + Deployment.Environment.fromString("unknown_value")); + } + + @Test + void environment_toValue() { + assertEquals("production", Deployment.Environment.production.toValue()); + assertEquals("test", Deployment.Environment.test.toValue()); + } + + @Test + void environment_jackson_roundTrip() throws Exception { + var mapper = new ObjectMapper(); + var json = mapper.writeValueAsString(Deployment.Environment.production); + assertEquals("\"production\"", json); + var deserialized = mapper.readValue(json, Deployment.Environment.class); + assertEquals(Deployment.Environment.production, deserialized); + } + + @Test + void environment_jackson_backwardCompat() throws Exception { + var mapper = new ObjectMapper(); + var deserialized = mapper.readValue("\"unrestricted\"", Deployment.Environment.class); + assertEquals(Deployment.Environment.production, deserialized); + } + + // ==================== Deployment.Status ==================== + + @Test + void status_allValues() { + assertEquals(4, Deployment.Status.values().length); + assertNotNull(Deployment.Status.valueOf("READY")); + assertNotNull(Deployment.Status.valueOf("IN_PROGRESS")); + assertNotNull(Deployment.Status.valueOf("NOT_FOUND")); + assertNotNull(Deployment.Status.valueOf("ERROR")); + } + + // ==================== Context ==================== + + @Test + void context_defaultConstructor() { + var ctx = new Context(); + assertNull(ctx.getType()); + assertNull(ctx.getValue()); + } + + @Test + void context_fullConstructor() { + var ctx = new Context(Context.ContextType.string, "hello"); + assertEquals(Context.ContextType.string, ctx.getType()); + assertEquals("hello", ctx.getValue()); + } + + @Test + void context_objectType() { + var ctx = new Context(Context.ContextType.object, Map.of("key", "val")); + assertEquals(Context.ContextType.object, ctx.getType()); + assertInstanceOf(Map.class, ctx.getValue()); + } + + @Test + void context_setters() { + var ctx = new Context(); + ctx.setType(Context.ContextType.expressions); + ctx.setValue("greeting(hello)"); + assertEquals(Context.ContextType.expressions, ctx.getType()); + assertEquals("greeting(hello)", ctx.getValue()); + } + + @Test + void contextType_allValues() { + assertEquals(4, Context.ContextType.values().length); + assertNotNull(Context.ContextType.valueOf("string")); + assertNotNull(Context.ContextType.valueOf("expressions")); + assertNotNull(Context.ContextType.valueOf("object")); + assertNotNull(Context.ContextType.valueOf("array")); + } + + // ==================== InputData ==================== + + @Test + void inputData_defaults() { + var input = new InputData(); + assertEquals("", input.getInput()); + assertNotNull(input.getContext()); + assertTrue(input.getContext().isEmpty()); + } + + @Test + void inputData_fullConstructor() { + var ctx = Map.of("lang", new Context(Context.ContextType.string, "en")); + var input = new InputData("Hello", ctx); + assertEquals("Hello", input.getInput()); + assertEquals(1, input.getContext().size()); + } + + @Test + void inputData_setters() { + var input = new InputData(); + input.setInput("How are you?"); + input.setContext(Map.of("mood", new Context(Context.ContextType.string, "happy"))); + assertEquals("How are you?", input.getInput()); + assertEquals(1, input.getContext().size()); + } + + // ==================== DeadLetterEntry ==================== + + @Test + void deadLetterEntry_record() { + var entry = new DeadLetterEntry("dl-1", "conv-123", "timeout", 1700000000L, "{}"); + assertEquals("dl-1", entry.id()); + assertEquals("conv-123", entry.conversationId()); + assertEquals("timeout", entry.error()); + assertEquals(1700000000L, entry.timestamp()); + assertEquals("{}", entry.payload()); + } + + @Test + void deadLetterEntry_jackson() throws Exception { + var mapper = new ObjectMapper(); + var json = """ + {"id":"dl-1","conversationId":"c1","error":"timeout","timestamp":0,"payload":"{}"} + """; + var entry = mapper.readValue(json, DeadLetterEntry.class); + assertEquals("dl-1", entry.id()); + assertEquals("c1", entry.conversationId()); + } + + // ==================== AgentDeploymentStatus ==================== + + @Test + void agentDeploymentStatus_defaults() { + var status = new AgentDeploymentStatus(); + assertEquals(Deployment.Environment.production, status.getEnvironment()); + assertEquals(Deployment.Status.NOT_FOUND, status.getStatus()); + assertNull(status.getAgentId()); + assertNull(status.getAgentVersion()); + } + + @Test + void agentDeploymentStatus_setters() { + var status = new AgentDeploymentStatus(); + status.setAgentId("agent-1"); + status.setAgentVersion(3); + status.setEnvironment(Deployment.Environment.test); + status.setStatus(Deployment.Status.READY); + assertEquals("agent-1", status.getAgentId()); + assertEquals(3, status.getAgentVersion()); + assertEquals(Deployment.Environment.test, status.getEnvironment()); + assertEquals(Deployment.Status.READY, status.getStatus()); + } + + // ==================== CoordinatorStatus ==================== + + @Test + void coordinatorStatus_record() { + var status = new CoordinatorStatus( + "in-memory", true, "ok", 5, 100L, 2L, java.util.Map.of("c1", 3)); + assertEquals("in-memory", status.coordinatorType()); + assertTrue(status.connected()); + assertEquals("ok", status.connectionStatus()); + assertEquals(5, status.activeConversations()); + assertEquals(100L, status.totalProcessed()); + assertEquals(2L, status.totalDeadLettered()); + assertEquals(3, status.queueDepths().get("c1")); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/apicalls/impl/PrePostUtilsTest.java b/src/test/java/ai/labs/eddi/modules/apicalls/impl/PrePostUtilsTest.java new file mode 100644 index 000000000..53851fd6a --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/apicalls/impl/PrePostUtilsTest.java @@ -0,0 +1,91 @@ +package ai.labs.eddi.modules.apicalls.impl; + +import ai.labs.eddi.configs.apicalls.model.HttpCodeValidator; +import ai.labs.eddi.datastore.serialization.IJsonSerialization; +import ai.labs.eddi.engine.memory.IDataFactory; +import ai.labs.eddi.engine.memory.IMemoryItemConverter; +import ai.labs.eddi.modules.templating.ITemplatingEngine; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class PrePostUtilsTest { + + private PrePostUtils prePostUtils; + + @BeforeEach + void setUp() { + prePostUtils = new PrePostUtils( + mock(IJsonSerialization.class), + mock(IMemoryItemConverter.class), + mock(ITemplatingEngine.class), + mock(IDataFactory.class)); + } + + // ==================== verifyHttpCode ==================== + + @Test + void verifyHttpCode_nullValidator_defaultAllows200() { + assertTrue(prePostUtils.verifyHttpCode(null, 200)); + } + + @Test + void verifyHttpCode_nullValidator_defaultAllows201() { + assertTrue(prePostUtils.verifyHttpCode(null, 201)); + } + + @Test + void verifyHttpCode_nullValidator_defaultRejects204() { + // DEFAULT only allows 200, 201 + assertFalse(prePostUtils.verifyHttpCode(null, 204)); + } + + @Test + void verifyHttpCode_nullValidator_defaultRejects500() { + assertFalse(prePostUtils.verifyHttpCode(null, 500)); + } + + @Test + void verifyHttpCode_customRunOnCodes() { + var validator = new HttpCodeValidator(List.of(200, 404), List.of()); + assertTrue(prePostUtils.verifyHttpCode(validator, 200)); + assertTrue(prePostUtils.verifyHttpCode(validator, 404)); + assertFalse(prePostUtils.verifyHttpCode(validator, 500)); + } + + @Test + void verifyHttpCode_skipOverridesRun() { + var validator = new HttpCodeValidator(List.of(200, 201, 202), List.of(201)); + assertTrue(prePostUtils.verifyHttpCode(validator, 200)); + assertFalse(prePostUtils.verifyHttpCode(validator, 201)); // skipped + assertTrue(prePostUtils.verifyHttpCode(validator, 202)); + } + + @Test + void verifyHttpCode_nullRunOnCodes_usesDefault() { + var validator = new HttpCodeValidator(); + validator.setRunOnHttpCode(null); + validator.setSkipOnHttpCode(List.of()); + // Falls back to DEFAULT runOnHttpCode = [200, 201] + assertTrue(prePostUtils.verifyHttpCode(validator, 200)); + } + + @Test + void verifyHttpCode_nullSkipOnCodes_usesDefault() { + var validator = new HttpCodeValidator(); + validator.setRunOnHttpCode(List.of(200)); + validator.setSkipOnHttpCode(null); + assertTrue(prePostUtils.verifyHttpCode(validator, 200)); + } + + @Test + void verifyHttpCode_codeNotInRunList_returnsFalse() { + var validator = new HttpCodeValidator(List.of(200), List.of()); + assertFalse(prePostUtils.verifyHttpCode(validator, 500)); + assertFalse(prePostUtils.verifyHttpCode(validator, 404)); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/llm/impl/ConversationOutputUtilsTest.java b/src/test/java/ai/labs/eddi/modules/llm/impl/ConversationOutputUtilsTest.java new file mode 100644 index 000000000..8d1c5b3cb --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/llm/impl/ConversationOutputUtilsTest.java @@ -0,0 +1,79 @@ +package ai.labs.eddi.modules.llm.impl; + +import ai.labs.eddi.engine.memory.model.ConversationOutput; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class ConversationOutputUtilsTest { + + @Test + void extractOutputText_singleTextEntry() { + var output = new ConversationOutput(); + output.put("output", List.of(Map.of("text", "Hello world"))); + assertEquals("Hello world", ConversationOutputUtils.extractOutputText(output)); + } + + @Test + void extractOutputText_multipleTextEntries_joinedWithSpace() { + var output = new ConversationOutput(); + output.put("output", List.of( + Map.of("text", "Hello"), + Map.of("text", "world"))); + assertEquals("Hello world", ConversationOutputUtils.extractOutputText(output)); + } + + @Test + void extractOutputText_noOutputKey_returnsNull() { + var output = new ConversationOutput(); + assertNull(ConversationOutputUtils.extractOutputText(output)); + } + + @Test + void extractOutputText_emptyList_returnsNull() { + var output = new ConversationOutput(); + output.put("output", List.of()); + assertNull(ConversationOutputUtils.extractOutputText(output)); + } + + @Test + void extractOutputText_nonListValue_returnsNull() { + var output = new ConversationOutput(); + output.put("output", "not a list"); + assertNull(ConversationOutputUtils.extractOutputText(output)); + } + + @Test + void extractOutputText_listOfNonMaps_returnsNull() { + var output = new ConversationOutput(); + output.put("output", List.of("just a string")); + assertNull(ConversationOutputUtils.extractOutputText(output)); + } + + @Test + void extractOutputText_mapsWithoutTextKey_returnsNull() { + var output = new ConversationOutput(); + output.put("output", List.of(Map.of("other", "value"))); + assertNull(ConversationOutputUtils.extractOutputText(output)); + } + + @Test + void extractOutputText_mixedMapsWithAndWithoutText() { + var output = new ConversationOutput(); + output.put("output", List.of( + Map.of("text", "Hello"), + Map.of("other", "ignored"), + Map.of("text", "world"))); + assertEquals("Hello world", ConversationOutputUtils.extractOutputText(output)); + } + + @Test + void extractOutputText_nullOutputValue_returnsNull() { + var output = new ConversationOutput(); + output.put("output", null); + assertNull(ConversationOutputUtils.extractOutputText(output)); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/output/model/OutputModelsTest.java b/src/test/java/ai/labs/eddi/modules/output/model/OutputModelsTest.java new file mode 100644 index 000000000..905bab60b --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/output/model/OutputModelsTest.java @@ -0,0 +1,264 @@ +package ai.labs.eddi.modules.output.model; + +import ai.labs.eddi.modules.output.model.types.*; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.Test; + +import java.util.Collections; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class OutputModelsTest { + + // ==================== TextOutputItem ==================== + + @Test + void textOutputItem_defaultConstructor_setsType() { + var item = new TextOutputItem(); + assertEquals("text", item.getType()); + assertNull(item.getText()); + assertEquals(0, item.getDelay()); + } + + @Test + void textOutputItem_textConstructor() { + var item = new TextOutputItem("Hello"); + assertEquals("text", item.getType()); + assertEquals("Hello", item.getText()); + } + + @Test + void textOutputItem_fullConstructor() { + var item = new TextOutputItem("Hello", 500); + assertEquals("Hello", item.getText()); + assertEquals(500, item.getDelay()); + } + + @Test + void textOutputItem_setters() { + var item = new TextOutputItem(); + item.setText("World"); + item.setDelay(100); + assertEquals("World", item.getText()); + assertEquals(100, item.getDelay()); + } + + @Test + void textOutputItem_toString() { + assertEquals("Hello", new TextOutputItem("Hello").toString()); + } + + @Test + void textOutputItem_equalsAndHashCode() { + var a = new TextOutputItem("Hello", 100); + var b = new TextOutputItem("Hello", 100); + var c = new TextOutputItem("World", 100); + assertEquals(a, b); + assertEquals(a.hashCode(), b.hashCode()); + assertNotEquals(a, c); + assertNotEquals(a, null); + assertEquals(a, a); + } + + // ==================== ButtonOutputItem ==================== + + @Test + void buttonOutputItem_defaultConstructor_setsType() { + var item = new ButtonOutputItem(); + assertEquals("button", item.getType()); + } + + @Test + void buttonOutputItem_fullConstructor() { + var item = new ButtonOutputItem("submit", "Click me", Map.of("action", (Object) "submit_form")); + assertEquals("button", item.getType()); + assertEquals("submit", item.getButtonType()); + assertEquals("Click me", item.getLabel()); + assertEquals("submit_form", item.getOnPress().get("action")); + } + + @Test + void buttonOutputItem_setters() { + var item = new ButtonOutputItem(); + item.setButtonType("link"); + item.setLabel("Open"); + item.setOnPress(Map.of("url", (Object) "https://example.com")); + assertEquals("link", item.getButtonType()); + assertEquals("Open", item.getLabel()); + } + + @Test + void buttonOutputItem_equalsAndHashCode() { + var a = new ButtonOutputItem("submit", "Go", Map.of()); + var b = new ButtonOutputItem("submit", "Go", Map.of()); + assertEquals(a, b); + assertEquals(a.hashCode(), b.hashCode()); + } + + // ==================== QuickReply ==================== + + @Test + void quickReply_defaultConstructor() { + var qr = new QuickReply(); + assertNull(qr.getValue()); + assertNull(qr.getExpressions()); + assertNull(qr.getIsDefault()); + } + + @Test + void quickReply_fullConstructor() { + var qr = new QuickReply("Yes", "confirmation(yes)", true); + assertEquals("Yes", qr.getValue()); + assertEquals("confirmation(yes)", qr.getExpressions()); + assertTrue(qr.getIsDefault()); + } + + @Test + void quickReply_setters() { + var qr = new QuickReply(); + qr.setValue("No"); + qr.setExpressions("confirmation(no)"); + qr.setIsDefault(false); + assertEquals("No", qr.getValue()); + assertEquals("confirmation(no)", qr.getExpressions()); + assertFalse(qr.getIsDefault()); + } + + @Test + void quickReply_equalsAndHashCode() { + var a = new QuickReply("Yes", "expr", true); + var b = new QuickReply("Yes", "expr", true); + var c = new QuickReply("No", "expr", false); + assertEquals(a, b); + assertEquals(a.hashCode(), b.hashCode()); + assertNotEquals(a, c); + } + + @Test + void quickReply_toString() { + var qr = new QuickReply("Yes", "expr", true); + assertTrue(qr.toString().contains("Yes")); + assertTrue(qr.toString().contains("expr")); + } + + // ==================== OutputValue ==================== + + @Test + void outputValue_defaultConstructor() { + var ov = new OutputValue(); + assertNull(ov.getValueAlternatives()); + } + + @Test + void outputValue_withAlternatives() { + var text = new TextOutputItem("Hello"); + var ov = new OutputValue(List.of(text)); + assertEquals(1, ov.getValueAlternatives().size()); + assertSame(text, ov.getValueAlternatives().get(0)); + } + + @Test + void outputValue_setter() { + var ov = new OutputValue(); + ov.setValueAlternatives(List.of(new TextOutputItem("Hi"))); + assertEquals(1, ov.getValueAlternatives().size()); + } + + @Test + void outputValue_equalsAndHashCode() { + var a = new OutputValue(List.of(new TextOutputItem("Hello"))); + var b = new OutputValue(List.of(new TextOutputItem("Hello"))); + assertEquals(a, b); + assertEquals(a.hashCode(), b.hashCode()); + } + + // ==================== OutputEntry ==================== + + @Test + void outputEntry_constructor() { + var entry = new OutputEntry("greet", 3, + List.of(new OutputValue(List.of(new TextOutputItem("Hi")))), + List.of(new QuickReply("Yes", "expr", true))); + + assertEquals("greet", entry.getAction()); + assertEquals(3, entry.getOccurred()); + assertEquals(1, entry.getOutputs().size()); + assertEquals(1, entry.getQuickReplies().size()); + } + + @Test + void outputEntry_setters() { + var entry = new OutputEntry("a", 0, List.of(), List.of()); + entry.setAction("updated"); + entry.setOccurred(5); + entry.setOutputs(List.of(new OutputValue())); + entry.setQuickReplies(List.of(new QuickReply())); + assertEquals("updated", entry.getAction()); + assertEquals(5, entry.getOccurred()); + } + + @Test + void outputEntry_compareTo_sortsByOccurred() { + var e1 = new OutputEntry("a", 1, List.of(), List.of()); + var e2 = new OutputEntry("b", 5, List.of(), List.of()); + var e3 = new OutputEntry("c", 3, List.of(), List.of()); + + var sorted = new java.util.ArrayList<>(List.of(e2, e3, e1)); + Collections.sort(sorted); + assertEquals("a", sorted.get(0).getAction()); + assertEquals("c", sorted.get(1).getAction()); + assertEquals("b", sorted.get(2).getAction()); + } + + @Test + void outputEntry_equalsAndHashCode() { + var a = new OutputEntry("greet", 1, List.of(), List.of()); + var b = new OutputEntry("greet", 1, List.of(), List.of()); + var c = new OutputEntry("bye", 1, List.of(), List.of()); + assertEquals(a, b); + assertEquals(a.hashCode(), b.hashCode()); + assertNotEquals(a, c); + } + + @Test + void outputEntry_toString() { + var entry = new OutputEntry("greet", 1, List.of(), List.of()); + assertTrue(entry.toString().contains("greet")); + assertTrue(entry.toString().contains("1")); + } + + // ==================== Jackson polymorphic deserialization ==================== + + @Test + void outputItem_jacksonPolymorphism() throws Exception { + var mapper = new ObjectMapper(); + var json = """ + {"type":"text","text":"Hello","delay":0} + """; + var item = mapper.readValue(json, OutputItem.class); + assertInstanceOf(TextOutputItem.class, item); + assertEquals("Hello", ((TextOutputItem) item).getText()); + } + + @Test + void outputItem_buttonPolymorphism() throws Exception { + var mapper = new ObjectMapper(); + var json = """ + {"type":"button","buttonType":"submit","label":"Go","onPress":{}} + """; + var item = mapper.readValue(json, OutputItem.class); + assertInstanceOf(ButtonOutputItem.class, item); + assertEquals("Go", ((ButtonOutputItem) item).getLabel()); + } + + @Test + void outputValue_jacksonRoundTrip() throws Exception { + var mapper = new ObjectMapper(); + var ov = new OutputValue(List.of(new TextOutputItem("Test"))); + var json = mapper.writeValueAsString(ov); + var deserialized = mapper.readValue(json, OutputValue.class); + assertEquals(1, deserialized.getValueAlternatives().size()); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/output/model/types/OutputTypesTest.java b/src/test/java/ai/labs/eddi/modules/output/model/types/OutputTypesTest.java new file mode 100644 index 000000000..0bce35e69 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/output/model/types/OutputTypesTest.java @@ -0,0 +1,303 @@ +package ai.labs.eddi.modules.output.model.types; + +import ai.labs.eddi.modules.output.model.OutputItem; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.Test; + +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class OutputTypesTest { + + // ==================== ImageOutputItem ==================== + + @Test + void imageOutputItem_defaultConstructor() { + var item = new ImageOutputItem(); + assertEquals("image", item.getType()); + assertNull(item.getUri()); + assertNull(item.getAlt()); + } + + @Test + void imageOutputItem_fullConstructor() { + var item = new ImageOutputItem("https://example.com/img.png", "A logo"); + assertEquals("image", item.getType()); + assertEquals("https://example.com/img.png", item.getUri()); + assertEquals("A logo", item.getAlt()); + } + + @Test + void imageOutputItem_setters() { + var item = new ImageOutputItem(); + item.setUri("/images/logo.svg"); + item.setAlt("Logo"); + assertEquals("/images/logo.svg", item.getUri()); + assertEquals("Logo", item.getAlt()); + } + + @Test + void imageOutputItem_equalsAndHashCode() { + var a = new ImageOutputItem("uri", "alt"); + var b = new ImageOutputItem("uri", "alt"); + var c = new ImageOutputItem("other", "alt"); + assertEquals(a, b); + assertEquals(a.hashCode(), b.hashCode()); + assertNotEquals(a, c); + } + + // ==================== QuickReplyOutputItem ==================== + + @Test + void quickReplyOutputItem_defaultConstructor() { + var item = new QuickReplyOutputItem(); + assertEquals("quickReply", item.getType()); + } + + @Test + void quickReplyOutputItem_fullConstructor() { + var item = new QuickReplyOutputItem("Yes", "confirm(yes)", false); + assertEquals("quickReply", item.getType()); + assertEquals("Yes", item.getValue()); + assertEquals("confirm(yes)", item.getExpressions()); + } + + @Test + void quickReplyOutputItem_setters() { + var item = new QuickReplyOutputItem(); + item.setValue("No"); + item.setExpressions("confirm(no)"); + assertEquals("No", item.getValue()); + assertEquals("confirm(no)", item.getExpressions()); + } + + // ==================== AgentFaceOutputItem ==================== + + @Test + void agentFaceOutputItem_defaultConstructor() { + var item = new AgentFaceOutputItem(); + assertEquals("agentFace", item.getType()); + assertNull(item.getUri()); + assertNull(item.getAlt()); + assertEquals(0, item.getDelay()); + } + + @Test + void agentFaceOutputItem_fullConstructor() { + var item = new AgentFaceOutputItem("face.png", "happy face", 300); + assertEquals("face.png", item.getUri()); + assertEquals("happy face", item.getAlt()); + assertEquals(300, item.getDelay()); + } + + @Test + void agentFaceOutputItem_setters() { + var item = new AgentFaceOutputItem(); + item.setUri("sad.png"); + item.setAlt("sad face"); + item.setDelay(500); + assertEquals("sad.png", item.getUri()); + assertEquals("sad face", item.getAlt()); + assertEquals(500, item.getDelay()); + } + + @Test + void agentFaceOutputItem_equalsAndHashCode() { + var a = new AgentFaceOutputItem("face.png", "alt", 100); + var b = new AgentFaceOutputItem("face.png", "alt", 100); + assertEquals(a, b); + assertEquals(a.hashCode(), b.hashCode()); + } + + // ==================== ApplicationLinkOutputItem ==================== + + @Test + void applicationLinkOutputItem_defaultConstructor() { + var item = new ApplicationLinkOutputItem(); + assertEquals("applicationLink", item.getType()); + assertNull(item.getPath()); + assertNull(item.getLabel()); + assertEquals(0, item.getDelay()); + } + + @Test + void applicationLinkOutputItem_pathConstructor() { + var item = new ApplicationLinkOutputItem("https://eddi.labs.ai"); + assertEquals("https://eddi.labs.ai", item.getPath()); + } + + @Test + void applicationLinkOutputItem_setters() { + var item = new ApplicationLinkOutputItem(); + item.setPath("https://example.com"); + item.setLabel("Example"); + item.setDelay(200); + assertEquals("https://example.com", item.getPath()); + assertEquals("Example", item.getLabel()); + assertEquals(200, item.getDelay()); + } + + @Test + void applicationLinkOutputItem_toString() { + var item = new ApplicationLinkOutputItem(); + item.setPath("/page"); + item.setLabel("Page"); + item.setDelay(0); + assertEquals("/page;Page;0", item.toString()); + } + + @Test + void applicationLinkOutputItem_equalsAndHashCode() { + var a = new ApplicationLinkOutputItem("path"); + a.setLabel("lbl"); + var b = new ApplicationLinkOutputItem("path"); + b.setLabel("lbl"); + assertEquals(a, b); + assertEquals(a.hashCode(), b.hashCode()); + } + + // ==================== InputFieldOutputItem ==================== + + @Test + void inputFieldOutputItem_defaultConstructor() { + var item = new InputFieldOutputItem(); + assertEquals("inputField", item.getType()); + } + + @Test + void inputFieldOutputItem_setters() { + var item = new InputFieldOutputItem(); + item.setSubType("email"); + item.setPlaceholder("Enter email"); + item.setLabel("Email"); + item.setDefaultValue("user@example.com"); + assertEquals("email", item.getSubType()); + assertEquals("Enter email", item.getPlaceholder()); + assertEquals("Email", item.getLabel()); + assertEquals("user@example.com", item.getDefaultValue()); + } + + @Test + void inputFieldOutputItem_equalsAndHashCode() { + var a = new InputFieldOutputItem(); + a.setSubType("text"); + a.setLabel("Name"); + var b = new InputFieldOutputItem(); + b.setSubType("text"); + b.setLabel("Name"); + assertEquals(a, b); + assertEquals(a.hashCode(), b.hashCode()); + } + + // ==================== OtherOutputItem ==================== + + @Test + void otherOutputItem_mapOperations() { + var item = new OtherOutputItem(); + assertTrue(item.isEmpty()); + assertEquals(0, item.size()); + + item.put("key1", "val1"); + item.put("key2", "val2"); + assertEquals(2, item.size()); + assertFalse(item.isEmpty()); + assertEquals("val1", item.get("key1")); + assertTrue(item.containsKey("key1")); + assertTrue(item.containsValue("val1")); + } + + @Test + void otherOutputItem_remove() { + var item = new OtherOutputItem(); + item.put("k", "v"); + assertEquals("v", item.remove("k")); + assertTrue(item.isEmpty()); + } + + @Test + void otherOutputItem_putAll() { + var item = new OtherOutputItem(); + item.putAll(Map.of("a", "1", "b", "2")); + assertEquals(2, item.size()); + } + + @Test + void otherOutputItem_clear() { + var item = new OtherOutputItem(); + item.put("a", "1"); + item.clear(); + assertTrue(item.isEmpty()); + } + + @Test + void otherOutputItem_keySetValuesEntrySet() { + var item = new OtherOutputItem(); + item.put("x", "y"); + assertEquals(1, item.keySet().size()); + assertEquals(1, item.values().size()); + assertEquals(1, item.entrySet().size()); + } + + @Test + void otherOutputItem_equalsAndHashCode() { + var a = new OtherOutputItem(); + a.put("k", "v"); + var b = new OtherOutputItem(); + b.put("k", "v"); + assertEquals(a, b); + assertEquals(a.hashCode(), b.hashCode()); + } + + // ==================== Jackson polymorphic ==================== + + @Test + void jackson_imageDeserialization() throws Exception { + var mapper = new ObjectMapper(); + var json = """ + {"type":"image","uri":"http://img.com/a.png","alt":"pic"} + """; + var item = mapper.readValue(json, OutputItem.class); + assertInstanceOf(ImageOutputItem.class, item); + } + + @Test + void jackson_quickReplyDeserialization() throws Exception { + var mapper = new ObjectMapper(); + var json = """ + {"type":"quickReply","value":"Yes","expressions":"confirm(yes)"} + """; + var item = mapper.readValue(json, OutputItem.class); + assertInstanceOf(QuickReplyOutputItem.class, item); + } + + @Test + void jackson_inputFieldDeserialization() throws Exception { + var mapper = new ObjectMapper(); + var json = """ + {"type":"inputField","subType":"email","placeholder":"Enter email","label":"Email"} + """; + var item = mapper.readValue(json, OutputItem.class); + assertInstanceOf(InputFieldOutputItem.class, item); + } + + @Test + void jackson_agentFaceDeserialization() throws Exception { + var mapper = new ObjectMapper(); + var json = """ + {"type":"agentFace","uri":"face.png","alt":"happy","delay":0} + """; + var item = mapper.readValue(json, OutputItem.class); + assertInstanceOf(AgentFaceOutputItem.class, item); + } + + @Test + void jackson_applicationLinkDeserialization() throws Exception { + var mapper = new ObjectMapper(); + var json = """ + {"type":"applicationLink","path":"/page","label":"Page","delay":0} + """; + var item = mapper.readValue(json, OutputItem.class); + assertInstanceOf(ApplicationLinkOutputItem.class, item); + } +} From f66c53190029fe13ac33fc558e26942f620041a9 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Sun, 19 Apr 2026 22:56:48 +0200 Subject: [PATCH 013/124] test(coverage): add tests for McpCallsConfig, IdSerializer, IdDeserializer, ToolExecutionService, engine models - McpCallsModelsTest: McpCallsConfiguration (defaults, setters, Jackson), McpCall (defaults, setters, Jackson round-trip) - IdSerializerTest: isValid() (hex validation, length, null), non-BSON serialize - IdDeserializerTest: non-BSON deserialization path - ToolExecutionServiceTest: executeToolWrapped (all feature permutations: success, cached, rate-limited, caching/rate-limiting/cost-tracking disabled, null conversationId, tool exception), parallel array validation - EngineModelsTest: added AgentDeployment (defaults, setters), LogEntry record (all fields, nulls, Jackson, @JsonInclude.NON_NULL verification) Total: 3077 tests passing --- .../mcpcalls/model/McpCallsModelsTest.java | 124 ++++++++++++ .../serialization/IdDeserializerTest.java | 43 ++++ .../serialization/IdSerializerTest.java | 87 +++++++++ .../eddi/engine/model/EngineModelsTest.java | 76 ++++++++ .../llm/tools/ToolExecutionServiceTest.java | 184 ++++++++++++++++++ 5 files changed, 514 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/configs/mcpcalls/model/McpCallsModelsTest.java create mode 100644 src/test/java/ai/labs/eddi/datastore/serialization/IdDeserializerTest.java create mode 100644 src/test/java/ai/labs/eddi/datastore/serialization/IdSerializerTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/llm/tools/ToolExecutionServiceTest.java diff --git a/src/test/java/ai/labs/eddi/configs/mcpcalls/model/McpCallsModelsTest.java b/src/test/java/ai/labs/eddi/configs/mcpcalls/model/McpCallsModelsTest.java new file mode 100644 index 000000000..52746d8d7 --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/mcpcalls/model/McpCallsModelsTest.java @@ -0,0 +1,124 @@ +package ai.labs.eddi.configs.mcpcalls.model; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +class McpCallsModelsTest { + + // ==================== McpCallsConfiguration ==================== + + @Test + void mcpCallsConfiguration_defaults() { + var config = new McpCallsConfiguration(); + assertNull(config.getMcpServerUrl()); + assertNull(config.getName()); + assertEquals("http", config.getTransport()); + assertNull(config.getApiKey()); + assertEquals(30000L, config.getTimeoutMs()); + assertNull(config.getToolsWhitelist()); + assertNull(config.getToolsBlacklist()); + assertNull(config.getMcpCalls()); + } + + @Test + void mcpCallsConfiguration_settersAndGetters() { + var config = new McpCallsConfiguration(); + config.setMcpServerUrl("http://localhost:7070/mcp"); + config.setName("GitHub MCP"); + config.setTransport("sse"); + config.setApiKey("${eddivault:github-key}"); + config.setTimeoutMs(60000L); + config.setToolsWhitelist(List.of("list_repos", "create_issue")); + config.setToolsBlacklist(List.of("delete_repo")); + + var call = new McpCall(); + call.setToolName("list_repos"); + config.setMcpCalls(List.of(call)); + + assertEquals("http://localhost:7070/mcp", config.getMcpServerUrl()); + assertEquals("GitHub MCP", config.getName()); + assertEquals("sse", config.getTransport()); + assertEquals("${eddivault:github-key}", config.getApiKey()); + assertEquals(60000L, config.getTimeoutMs()); + assertEquals(2, config.getToolsWhitelist().size()); + assertEquals(1, config.getToolsBlacklist().size()); + assertEquals(1, config.getMcpCalls().size()); + } + + @Test + void mcpCallsConfiguration_jacksonRoundTrip() throws Exception { + var config = new McpCallsConfiguration(); + config.setMcpServerUrl("http://localhost:7070/mcp"); + config.setTransport("http"); + config.setTimeoutMs(5000L); + + var mapper = new ObjectMapper(); + var json = mapper.writeValueAsString(config); + var deserialized = mapper.readValue(json, McpCallsConfiguration.class); + + assertEquals("http://localhost:7070/mcp", deserialized.getMcpServerUrl()); + assertEquals("http", deserialized.getTransport()); + assertEquals(5000L, deserialized.getTimeoutMs()); + } + + // ==================== McpCall ==================== + + @Test + void mcpCall_defaults() { + var call = new McpCall(); + assertNull(call.getName()); + assertNull(call.getDescription()); + assertNull(call.getActions()); + assertNull(call.getToolName()); + assertNull(call.getToolArguments()); + assertNull(call.getPreRequest()); + assertTrue(call.getSaveResponse()); // default true + assertNull(call.getResponseObjectName()); + assertNull(call.getPostResponse()); + } + + @Test + void mcpCall_settersAndGetters() { + var call = new McpCall(); + call.setName("List Repos"); + call.setDescription("Lists all GitHub repositories"); + call.setActions(List.of("list_repos", "get_repos")); + call.setToolName("list_repos"); + call.setToolArguments(Map.of("owner", "{{properties.githubUser}}")); + call.setSaveResponse(false); + call.setResponseObjectName("repos"); + + assertEquals("List Repos", call.getName()); + assertEquals("Lists all GitHub repositories", call.getDescription()); + assertEquals(2, call.getActions().size()); + assertEquals("list_repos", call.getToolName()); + assertEquals(1, call.getToolArguments().size()); + assertFalse(call.getSaveResponse()); + assertEquals("repos", call.getResponseObjectName()); + } + + @Test + void mcpCall_jacksonRoundTrip() throws Exception { + var call = new McpCall(); + call.setName("Get Weather"); + call.setToolName("get_weather"); + call.setActions(List.of("weather_check")); + call.setToolArguments(Map.of("city", "Berlin")); + call.setSaveResponse(true); + call.setResponseObjectName("weatherData"); + + var mapper = new ObjectMapper(); + var json = mapper.writeValueAsString(call); + var deserialized = mapper.readValue(json, McpCall.class); + + assertEquals("Get Weather", deserialized.getName()); + assertEquals("get_weather", deserialized.getToolName()); + assertEquals("Berlin", deserialized.getToolArguments().get("city")); + assertEquals("weatherData", deserialized.getResponseObjectName()); + } +} diff --git a/src/test/java/ai/labs/eddi/datastore/serialization/IdDeserializerTest.java b/src/test/java/ai/labs/eddi/datastore/serialization/IdDeserializerTest.java new file mode 100644 index 000000000..4d6f593af --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/serialization/IdDeserializerTest.java @@ -0,0 +1,43 @@ +package ai.labs.eddi.datastore.serialization; + +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.databind.DeserializationContext; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class IdDeserializerTest { + + private final IdDeserializer deserializer = new IdDeserializer(); + + @Test + void deserialize_nonBson_returnsString() throws Exception { + var parser = mock(JsonParser.class); + var ctx = mock(DeserializationContext.class); + when(parser.getValueAsString()).thenReturn("507f1f77bcf86cd799439011"); + + var result = deserializer.deserialize(parser, ctx); + assertEquals("507f1f77bcf86cd799439011", result); + } + + @Test + void deserialize_nonBson_plainString() throws Exception { + var parser = mock(JsonParser.class); + var ctx = mock(DeserializationContext.class); + when(parser.getValueAsString()).thenReturn("my-custom-id"); + + var result = deserializer.deserialize(parser, ctx); + assertEquals("my-custom-id", result); + } + + @Test + void deserialize_nonBson_null() throws Exception { + var parser = mock(JsonParser.class); + var ctx = mock(DeserializationContext.class); + when(parser.getValueAsString()).thenReturn(null); + + var result = deserializer.deserialize(parser, ctx); + assertNull(result); + } +} diff --git a/src/test/java/ai/labs/eddi/datastore/serialization/IdSerializerTest.java b/src/test/java/ai/labs/eddi/datastore/serialization/IdSerializerTest.java new file mode 100644 index 000000000..49c81ed91 --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/serialization/IdSerializerTest.java @@ -0,0 +1,87 @@ +package ai.labs.eddi.datastore.serialization; + +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.SerializerProvider; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class IdSerializerTest { + + private final IdSerializer serializer = new IdSerializer(); + + // ==================== isValid ==================== + + @Test + void isValid_valid24CharHex() { + assertTrue(IdSerializer.isValid("507f1f77bcf86cd799439011")); + } + + @Test + void isValid_allLowercase() { + assertTrue(IdSerializer.isValid("abcdef0123456789abcdef01")); + } + + @Test + void isValid_allUppercase() { + assertTrue(IdSerializer.isValid("ABCDEF0123456789ABCDEF01")); + } + + @Test + void isValid_mixedCase() { + assertTrue(IdSerializer.isValid("aAbBcCdDeEfF001122334455")); + } + + @Test + void isValid_allZeros() { + assertTrue(IdSerializer.isValid("000000000000000000000000")); + } + + @Test + void isValid_tooShort() { + assertFalse(IdSerializer.isValid("507f1f77bcf86cd79943901")); + } + + @Test + void isValid_tooLong() { + assertFalse(IdSerializer.isValid("507f1f77bcf86cd7994390111")); + } + + @Test + void isValid_invalidChars() { + assertFalse(IdSerializer.isValid("507f1f77bcf86cd79943901g")); + } + + @Test + void isValid_empty() { + assertFalse(IdSerializer.isValid("")); + } + + @Test + void isValid_null_throws() { + assertThrows(IllegalArgumentException.class, () -> IdSerializer.isValid(null)); + } + + // ==================== serialize (non-BSON, JsonGenerator) ==================== + + @Test + void serialize_nonBson_writesString() throws Exception { + var generator = mock(JsonGenerator.class); + var provider = mock(SerializerProvider.class); + + serializer.serialize("507f1f77bcf86cd799439011", generator, provider); + verify(generator).writeString("507f1f77bcf86cd799439011"); + } + + @Test + void serialize_nonBson_plainString() throws Exception { + var generator = mock(JsonGenerator.class); + var provider = mock(SerializerProvider.class); + + serializer.serialize("not-an-objectid", generator, provider); + verify(generator).writeString("not-an-objectid"); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/model/EngineModelsTest.java b/src/test/java/ai/labs/eddi/engine/model/EngineModelsTest.java index 85935b0bc..191717fa6 100644 --- a/src/test/java/ai/labs/eddi/engine/model/EngineModelsTest.java +++ b/src/test/java/ai/labs/eddi/engine/model/EngineModelsTest.java @@ -206,4 +206,80 @@ void coordinatorStatus_record() { assertEquals(2L, status.totalDeadLettered()); assertEquals(3, status.queueDepths().get("c1")); } + + // ==================== AgentDeployment ==================== + + @Test + void agentDeployment_defaults() { + var deployment = new AgentDeployment(); + assertEquals(Deployment.Environment.production, deployment.getEnvironment()); + assertNull(deployment.getAgentId()); + assertNotNull(deployment.getInitialContext()); + assertTrue(deployment.getInitialContext().isEmpty()); + } + + @Test + void agentDeployment_setters() { + var deployment = new AgentDeployment(); + deployment.setEnvironment(Deployment.Environment.test); + deployment.setAgentId("agent-42"); + deployment.setInitialContext(Map.of( + "lang", new Context(Context.ContextType.string, "en"))); + + assertEquals(Deployment.Environment.test, deployment.getEnvironment()); + assertEquals("agent-42", deployment.getAgentId()); + assertEquals(1, deployment.getInitialContext().size()); + } + + // ==================== LogEntry ==================== + + @Test + void logEntry_record() { + var entry = new LogEntry( + 1700000000L, "INFO", "ai.labs.eddi.TestClass", + "Test message", "production", "agent-1", 3, + "conv-123", "user-1", "inst-1"); + assertEquals(1700000000L, entry.timestamp()); + assertEquals("INFO", entry.level()); + assertEquals("ai.labs.eddi.TestClass", entry.loggerName()); + assertEquals("Test message", entry.message()); + assertEquals("production", entry.environment()); + assertEquals("agent-1", entry.agentId()); + assertEquals(3, entry.agentVersion()); + assertEquals("conv-123", entry.conversationId()); + assertEquals("user-1", entry.userId()); + assertEquals("inst-1", entry.instanceId()); + } + + @Test + void logEntry_nullFields() { + var entry = new LogEntry(0L, "WARN", "logger", "msg", + null, null, null, null, null, null); + assertNull(entry.environment()); + assertNull(entry.agentId()); + assertNull(entry.agentVersion()); + } + + @Test + void logEntry_jacksonRoundTrip() throws Exception { + var mapper = new com.fasterxml.jackson.databind.ObjectMapper(); + var entry = new LogEntry(1700000000L, "ERROR", "logger", + "Something failed", "test", "a1", 1, + "c1", "u1", "i1"); + var json = mapper.writeValueAsString(entry); + var deserialized = mapper.readValue(json, LogEntry.class); + assertEquals(entry.timestamp(), deserialized.timestamp()); + assertEquals(entry.message(), deserialized.message()); + assertEquals(entry.agentId(), deserialized.agentId()); + } + + @Test + void logEntry_jsonExcludesNulls() throws Exception { + var mapper = new com.fasterxml.jackson.databind.ObjectMapper(); + var entry = new LogEntry(0L, "INFO", "log", "msg", + null, null, null, null, null, null); + var json = mapper.writeValueAsString(entry); + assertFalse(json.contains("agentId")); + assertFalse(json.contains("userId")); + } } diff --git a/src/test/java/ai/labs/eddi/modules/llm/tools/ToolExecutionServiceTest.java b/src/test/java/ai/labs/eddi/modules/llm/tools/ToolExecutionServiceTest.java new file mode 100644 index 000000000..01c0c5431 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/llm/tools/ToolExecutionServiceTest.java @@ -0,0 +1,184 @@ +package ai.labs.eddi.modules.llm.tools; + +import ai.labs.eddi.datastore.serialization.IJsonSerialization; +import io.micrometer.core.instrument.simple.SimpleMeterRegistry; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.lang.reflect.Field; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class ToolExecutionServiceTest { + + private ToolExecutionService service; + private ToolCacheService cacheService; + private ToolRateLimiter rateLimiter; + private ToolCostTracker costTracker; + private SimpleMeterRegistry meterRegistry; + + @BeforeEach + void setUp() throws Exception { + service = new ToolExecutionService(); + cacheService = mock(ToolCacheService.class); + rateLimiter = mock(ToolRateLimiter.class); + costTracker = mock(ToolCostTracker.class); + meterRegistry = new SimpleMeterRegistry(); + + // Inject mocks via reflection (field injection) + setField(service, "cacheService", cacheService); + setField(service, "rateLimiter", rateLimiter); + setField(service, "costTracker", costTracker); + setField(service, "meterRegistry", meterRegistry); + setField(service, "jsonSerialization", mock(IJsonSerialization.class)); + + service.init(); + } + + private static void setField(Object target, String fieldName, Object value) throws Exception { + Field field = target.getClass().getDeclaredField(fieldName); + field.setAccessible(true); + field.set(target, value); + } + + // ==================== executeToolWrapped ==================== + + @Test + void executeToolWrapped_success() { + when(rateLimiter.tryAcquire("testTool", 60)).thenReturn(true); + when(cacheService.get("testTool", "args")).thenReturn(null); + + var result = service.executeToolWrapped( + "testTool", "args", "conv-1", + () -> "tool result", + true, true, true, 60); + + assertEquals("tool result", result); + verify(cacheService).put("testTool", "args", "tool result"); + verify(costTracker).trackToolCall("testTool", "conv-1"); + } + + @Test + void executeToolWrapped_cachedResult() { + when(rateLimiter.tryAcquire("testTool", 60)).thenReturn(true); + when(cacheService.get("testTool", "args")).thenReturn("cached"); + + var result = service.executeToolWrapped( + "testTool", "args", "conv-1", + () -> "should not be called", + true, true, true, 60); + + assertEquals("cached", result); + verify(cacheService, never()).put(anyString(), anyString(), anyString()); + } + + @Test + void executeToolWrapped_rateLimited() { + when(rateLimiter.tryAcquire("testTool", 60)).thenReturn(false); + + var result = service.executeToolWrapped( + "testTool", "args", "conv-1", + () -> "should not run", + true, true, true, 60); + + assertTrue(result.contains("Rate limit exceeded")); + verify(cacheService, never()).get(anyString(), anyString()); + } + + @Test + void executeToolWrapped_rateLimitingDisabled() { + when(cacheService.get("testTool", "args")).thenReturn(null); + + var result = service.executeToolWrapped( + "testTool", "args", "conv-1", + () -> "result", + false, true, true, 60); + + assertEquals("result", result); + verify(rateLimiter, never()).tryAcquire(anyString(), anyInt()); + } + + @Test + void executeToolWrapped_cachingDisabled() { + when(rateLimiter.tryAcquire("testTool", 60)).thenReturn(true); + + var result = service.executeToolWrapped( + "testTool", "args", "conv-1", + () -> "result", + true, false, true, 60); + + assertEquals("result", result); + verify(cacheService, never()).get(anyString(), anyString()); + verify(cacheService, never()).put(anyString(), anyString(), anyString()); + } + + @Test + void executeToolWrapped_costTrackingDisabled() { + when(rateLimiter.tryAcquire("testTool", 60)).thenReturn(true); + when(cacheService.get("testTool", "args")).thenReturn(null); + + service.executeToolWrapped( + "testTool", "args", "conv-1", + () -> "result", + true, true, false, 60); + + verify(costTracker, never()).trackToolCall(anyString(), anyString()); + } + + @Test + void executeToolWrapped_nullConversationId_skipsCostTracking() { + when(rateLimiter.tryAcquire("testTool", 60)).thenReturn(true); + when(cacheService.get("testTool", "args")).thenReturn(null); + + service.executeToolWrapped( + "testTool", "args", null, + () -> "result", + true, true, true, 60); + + verify(costTracker, never()).trackToolCall(anyString(), anyString()); + } + + @Test + void executeToolWrapped_toolThrowsException() { + when(rateLimiter.tryAcquire("testTool", 60)).thenReturn(true); + when(cacheService.get("testTool", "args")).thenReturn(null); + + var result = service.executeToolWrapped( + "testTool", "args", "conv-1", + () -> { + throw new RuntimeException("tool failed"); + }, + true, true, true, 60); + + assertTrue(result.contains("Error executing tool")); + assertTrue(result.contains("tool failed")); + } + + @Test + void executeToolWrapped_allFeaturesDisabled() { + var result = service.executeToolWrapped( + "testTool", "args", "conv-1", + () -> "plain result", + false, false, false, 60); + + assertEquals("plain result", result); + } + + // ==================== getCostTracker ==================== + + @Test + void getCostTracker_returnsInjected() { + assertSame(costTracker, service.getCostTracker()); + } + + // ==================== executeToolsParallel ==================== + + @Test + void executeToolsParallel_mismatchedArrays_throws() { + assertThrows(IllegalArgumentException.class, + () -> service.executeToolsParallel( + new Object[1], new java.lang.reflect.Method[2], new Object[1][], + "conv-1", null)); + } +} From d6572e84a6c46ea2495efd568ce49ddedb9cfefb Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Sun, 19 Apr 2026 23:06:39 +0200 Subject: [PATCH 014/124] chore(docs): update changelog with batches 11-12 coverage progress (50.8%) --- docs/changelog.md | 39 +++++++++++++++++++++++++++++---------- 1 file changed, 29 insertions(+), 10 deletions(-) diff --git a/docs/changelog.md b/docs/changelog.md index e122e753a..e15369b85 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -37,22 +37,41 @@ Each entry follows this format: - `RuleTest` — execute() with no/pass/fail/error conditions, short-circuit on first failure, infinite loop detection, equals/hashCode, clone, toString - `RulesEvaluatorTest` — empty sets, success/fail/error routing, execution strategies (executeUntilFirstSuccess vs executeAll), null rule set guard +### Batch 11 — Output, Engine, Config Models + PrePostUtils +- `OutputModelsTest` — TextOutputItem, ButtonOutputItem, QuickReply, OutputValue, OutputEntry (Comparable), Jackson polymorphic deserialization +- `OutputTypesTest` — All 8 OutputItem subtypes (Image, AgentFace, ApplicationLink, InputField, QuickReply, Other/Map delegation) +- `EngineModelsTest` — Deployment.Environment (backward compat + Jackson), Deployment.Status, Context, InputData, DeadLetterEntry, AgentDeploymentStatus, CoordinatorStatus, AgentDeployment, LogEntry +- `PrePostUtilsTest` — verifyHttpCode with DEFAULT validator, custom codes, skip logic +- `RagConfigurationTest` — defaults, setters, Jackson round-trip +- `ConversationOutputTest` — typed get(), LinkedHashMap ordering +- `ConversationPropertiesTest`, `BackupModelsTest`, `McpToolFilterTest`, `ConversationOutputUtilsTest` — fixes to align with actual APIs + +### Batch 12 — McpCalls, Serialization, ToolExecution +- `McpCallsModelsTest` — McpCallsConfiguration (defaults, setters, Jackson), McpCall (defaults, setters, Jackson round-trip) +- `IdSerializerTest` — isValid() hex validation, length, null, non-BSON serialize +- `IdDeserializerTest` — non-BSON deserialization path +- `ToolExecutionServiceTest` — executeToolWrapped (all feature permutations: success, cached, rate-limited, features individually disabled, null conversationId, tool exception), parallel array validation + ### Coverage Progress | Checkpoint | Line % | Branch % | |------------|--------|----------| | Batch 6 | 48.1% | 42.7% | | Batch 10 | 49.1% | 43.2% | - -**Files:** -- `src/test/java/ai/labs/eddi/engine/a2a/AgentCardServiceTest.java` — new -- `src/test/java/ai/labs/eddi/engine/internal/ContextLoggerTest.java` — new -- `src/test/java/ai/labs/eddi/configs/descriptors/model/SimpleDocumentDescriptorTest.java` — new -- `src/test/java/ai/labs/eddi/modules/llm/model/LlmConfigurationModelsTest.java` — new -- `src/test/java/ai/labs/eddi/configs/model/SmallModelsBatchTest.java` — new -- `src/test/java/ai/labs/eddi/modules/rules/impl/RuleDeserializationTest.java` — new -- `src/test/java/ai/labs/eddi/modules/rules/impl/RuleTest.java` — new -- `src/test/java/ai/labs/eddi/modules/rules/impl/RulesEvaluatorTest.java` — new +| Batch 12 | 50.8% | 44.3% | + +**Files (Batch 11-12):** +- `src/test/java/ai/labs/eddi/modules/output/model/OutputModelsTest.java` — new +- `src/test/java/ai/labs/eddi/modules/output/model/types/OutputTypesTest.java` — new +- `src/test/java/ai/labs/eddi/engine/model/EngineModelsTest.java` — new +- `src/test/java/ai/labs/eddi/modules/apicalls/impl/PrePostUtilsTest.java` — new +- `src/test/java/ai/labs/eddi/configs/rag/model/RagConfigurationTest.java` — new +- `src/test/java/ai/labs/eddi/engine/memory/model/ConversationOutputTest.java` — new +- `src/test/java/ai/labs/eddi/modules/llm/impl/ConversationOutputUtilsTest.java` — new +- `src/test/java/ai/labs/eddi/configs/mcpcalls/model/McpCallsModelsTest.java` — new +- `src/test/java/ai/labs/eddi/datastore/serialization/IdSerializerTest.java` — new +- `src/test/java/ai/labs/eddi/datastore/serialization/IdDeserializerTest.java` — new +- `src/test/java/ai/labs/eddi/modules/llm/tools/ToolExecutionServiceTest.java` — new --- From 243af32430eb5bdc62662a4473815f9b082af4f5 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 00:16:07 +0200 Subject: [PATCH 015/124] test(coverage): add tests for McpMemoryTools, EddiChatMemoryStore, CacheImpl - McpMemoryToolsTest: all 7 tool methods (list, getVisible, search, getByKey, upsert, delete, deleteAll, count) with null/blank validation, success paths, exception handling, limit/pagination - EddiChatMemoryStoreTest: getMessages (new conversation, store error, empty snapshot), updateMessages (no-op), deleteMessages (success, not found, store error) - CacheImplTest: full ConcurrentMap delegation (put/get/remove/replace/ containsKey/containsValue/size/isEmpty/clear/putAll/keySet/values/ entrySet) + all TTL-aware overloads Line coverage: 50.8% -> 51.4% (+0.6pp, 157 lines covered) --- .../eddi/engine/caching/CacheImplTest.java | 230 +++++++++++++++++ .../eddi/engine/mcp/McpMemoryToolsTest.java | 243 ++++++++++++++++++ .../llm/memory/EddiChatMemoryStoreTest.java | 90 +++++++ 3 files changed, 563 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/engine/caching/CacheImplTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/mcp/McpMemoryToolsTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/llm/memory/EddiChatMemoryStoreTest.java diff --git a/src/test/java/ai/labs/eddi/engine/caching/CacheImplTest.java b/src/test/java/ai/labs/eddi/engine/caching/CacheImplTest.java new file mode 100644 index 000000000..3d9da5460 --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/caching/CacheImplTest.java @@ -0,0 +1,230 @@ +package ai.labs.eddi.engine.caching; + +import com.github.benmanes.caffeine.cache.Caffeine; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.Map; +import java.util.concurrent.TimeUnit; + +import static org.junit.jupiter.api.Assertions.*; + +class CacheImplTest { + + private CacheImpl cache; + + @BeforeEach + void setUp() { + cache = new CacheImpl<>("test-cache", + Caffeine.newBuilder().maximumSize(100).build()); + } + + @Test + void getCacheName() { + assertEquals("test-cache", cache.getCacheName()); + } + + @Test + void getCacheName_nullDefault() { + var c = new CacheImpl(null, Caffeine.newBuilder().build()); + assertEquals("default", c.getCacheName()); + } + + @Test + void putAndGet() { + cache.put("key1", "value1"); + assertEquals("value1", cache.get("key1")); + } + + @Test + void put_returnsPreviousValue() { + cache.put("key1", "old"); + var prev = cache.put("key1", "new"); + assertEquals("old", prev); + assertEquals("new", cache.get("key1")); + } + + @Test + void get_missing_returnsNull() { + assertNull(cache.get("nonexistent")); + } + + @Test + void putIfAbsent_addsWhenMissing() { + var result = cache.putIfAbsent("key1", "value1"); + assertNull(result); // no previous value + assertEquals("value1", cache.get("key1")); + } + + @Test + void putIfAbsent_skipsWhenPresent() { + cache.put("key1", "existing"); + var result = cache.putIfAbsent("key1", "new"); + assertEquals("existing", result); + assertEquals("existing", cache.get("key1")); + } + + @Test + void remove_returnsOldValue() { + cache.put("key1", "value1"); + var removed = cache.remove("key1"); + assertEquals("value1", removed); + assertNull(cache.get("key1")); + } + + @Test + void remove_missingKey_returnsNull() { + assertNull(cache.remove("missing")); + } + + @Test + void removeKeyValue_matchingPair() { + cache.put("key1", "value1"); + assertTrue(cache.remove("key1", "value1")); + assertNull(cache.get("key1")); + } + + @Test + void removeKeyValue_mismatchedPair() { + cache.put("key1", "value1"); + assertFalse(cache.remove("key1", "wrong")); + assertEquals("value1", cache.get("key1")); + } + + @Test + void replace_existing() { + cache.put("key1", "old"); + var prev = cache.replace("key1", "new"); + assertEquals("old", prev); + assertEquals("new", cache.get("key1")); + } + + @Test + void replace_missing() { + assertNull(cache.replace("key1", "new")); + } + + @Test + void replaceOldNew_matching() { + cache.put("key1", "old"); + assertTrue(cache.replace("key1", "old", "new")); + assertEquals("new", cache.get("key1")); + } + + @Test + void replaceOldNew_mismatched() { + cache.put("key1", "old"); + assertFalse(cache.replace("key1", "wrong", "new")); + assertEquals("old", cache.get("key1")); + } + + @Test + void containsKey() { + cache.put("key1", "value1"); + assertTrue(cache.containsKey("key1")); + assertFalse(cache.containsKey("key2")); + } + + @Test + void containsValue() { + cache.put("key1", "value1"); + assertTrue(cache.containsValue("value1")); + assertFalse(cache.containsValue("other")); + } + + @Test + void size() { + assertEquals(0, cache.size()); + cache.put("a", "1"); + cache.put("b", "2"); + assertEquals(2, cache.size()); + } + + @Test + void isEmpty() { + assertTrue(cache.isEmpty()); + cache.put("a", "1"); + assertFalse(cache.isEmpty()); + } + + @Test + void clear() { + cache.put("a", "1"); + cache.put("b", "2"); + cache.clear(); + assertEquals(0, cache.size()); + } + + @Test + void putAll() { + cache.putAll(Map.of("a", "1", "b", "2")); + assertEquals("1", cache.get("a")); + assertEquals("2", cache.get("b")); + } + + @Test + void keySet() { + cache.put("a", "1"); + cache.put("b", "2"); + assertEquals(2, cache.keySet().size()); + assertTrue(cache.keySet().contains("a")); + } + + @Test + void values() { + cache.put("a", "1"); + assertTrue(cache.values().contains("1")); + } + + @Test + void entrySet() { + cache.put("a", "1"); + assertEquals(1, cache.entrySet().size()); + } + + // ==================== TTL-aware methods (delegate to non-TTL) + // ==================== + + @Test + void putWithTtl_delegatesToPut() { + cache.put("key1", "value1", 60, TimeUnit.SECONDS); + assertEquals("value1", cache.get("key1")); + } + + @Test + void putIfAbsentWithTtl_delegatesToPutIfAbsent() { + cache.putIfAbsent("key1", "value1", 60, TimeUnit.SECONDS); + assertEquals("value1", cache.get("key1")); + } + + @Test + void putAllWithTtl_delegatesToPutAll() { + cache.putAll(Map.of("a", "1"), 60, TimeUnit.SECONDS); + assertEquals("1", cache.get("a")); + } + + @Test + void replaceWithTtl_delegatesToReplace() { + cache.put("key1", "old"); + cache.replace("key1", "new", 60, TimeUnit.SECONDS); + assertEquals("new", cache.get("key1")); + } + + @Test + void replaceOldNewWithTtl_delegatesToReplace() { + cache.put("key1", "old"); + assertTrue(cache.replace("key1", "old", "new", 60, TimeUnit.SECONDS)); + } + + @Test + void putWithLifespanAndIdle_delegatesToPut() { + cache.put("key1", "value1", 60, TimeUnit.SECONDS, 30, TimeUnit.SECONDS); + assertEquals("value1", cache.get("key1")); + } + + @Test + void putIfAbsentWithLifespanAndIdle_delegatesToPutIfAbsent() { + cache.putIfAbsent("key1", "value1", 60, TimeUnit.SECONDS, 30, TimeUnit.SECONDS); + assertEquals("value1", cache.get("key1")); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/mcp/McpMemoryToolsTest.java b/src/test/java/ai/labs/eddi/engine/mcp/McpMemoryToolsTest.java new file mode 100644 index 000000000..9066b1cce --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/mcp/McpMemoryToolsTest.java @@ -0,0 +1,243 @@ +package ai.labs.eddi.engine.mcp; + +import ai.labs.eddi.configs.properties.IUserMemoryStore; +import ai.labs.eddi.configs.properties.model.UserMemoryEntry; +import ai.labs.eddi.datastore.serialization.IJsonSerialization; +import io.quarkus.security.identity.SecurityIdentity; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.io.IOException; +import java.util.List; +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class McpMemoryToolsTest { + + private McpMemoryTools tools; + private IUserMemoryStore userMemoryStore; + private IJsonSerialization jsonSerialization; + + @BeforeEach + void setUp() { + userMemoryStore = mock(IUserMemoryStore.class); + jsonSerialization = mock(IJsonSerialization.class); + var identity = mock(SecurityIdentity.class); + // authEnabled=false so no role checks + tools = new McpMemoryTools(userMemoryStore, jsonSerialization, identity, false); + } + + // ==================== listUserMemories ==================== + + @Test + void listUserMemories_success() throws Exception { + when(userMemoryStore.getAllEntries("user1")).thenReturn(List.of()); + when(jsonSerialization.serialize(any())).thenReturn("{\"count\":0}"); + var result = tools.listUserMemories("user1", null); + assertEquals("{\"count\":0}", result); + } + + @Test + void listUserMemories_nullUserId() { + var result = tools.listUserMemories(null, null); + assertTrue(result.contains("userId is required")); + } + + @Test + void listUserMemories_blankUserId() { + var result = tools.listUserMemories(" ", null); + assertTrue(result.contains("userId is required")); + } + + @Test + void listUserMemories_withLimit() throws Exception { + when(userMemoryStore.getAllEntries("user1")).thenReturn(List.of( + mock(UserMemoryEntry.class), mock(UserMemoryEntry.class), mock(UserMemoryEntry.class))); + when(jsonSerialization.serialize(any())).thenReturn("ok"); + tools.listUserMemories("user1", 2); + verify(jsonSerialization).serialize(any()); + } + + @Test + void listUserMemories_exception() throws Exception { + when(userMemoryStore.getAllEntries("user1")).thenThrow(new RuntimeException("DB error")); + var result = tools.listUserMemories("user1", null); + assertTrue(result.contains("Failed to list memories")); + } + + // ==================== getVisibleMemories ==================== + + @Test + void getVisibleMemories_success() throws Exception { + when(userMemoryStore.getVisibleEntries(eq("user1"), eq("agent1"), anyList(), eq("most_recent"), eq(50))) + .thenReturn(List.of()); + when(jsonSerialization.serialize(any())).thenReturn("ok"); + var result = tools.getVisibleMemories("user1", "agent1", null, null, null); + assertNotNull(result); + } + + @Test + void getVisibleMemories_nullUserId() { + var result = tools.getVisibleMemories(null, "agent1", null, null, null); + assertTrue(result.contains("userId is required")); + } + + @Test + void getVisibleMemories_nullAgentId() { + var result = tools.getVisibleMemories("user1", null, null, null, null); + assertTrue(result.contains("agentId is required")); + } + + @Test + void getVisibleMemories_withGroupIds() throws Exception { + when(userMemoryStore.getVisibleEntries(eq("user1"), eq("agent1"), eq(List.of("g1", "g2")), anyString(), anyInt())) + .thenReturn(List.of()); + when(jsonSerialization.serialize(any())).thenReturn("ok"); + tools.getVisibleMemories("user1", "agent1", "g1,g2", "most_accessed", 10); + verify(userMemoryStore).getVisibleEntries("user1", "agent1", List.of("g1", "g2"), "most_accessed", 10); + } + + // ==================== searchUserMemories ==================== + + @Test + void searchUserMemories_success() throws Exception { + when(userMemoryStore.filterEntries("user1", "preferences")).thenReturn(List.of()); + when(jsonSerialization.serialize(any())).thenReturn("ok"); + tools.searchUserMemories("user1", "preferences"); + verify(userMemoryStore).filterEntries("user1", "preferences"); + } + + @Test + void searchUserMemories_nullQuery() { + var result = tools.searchUserMemories("user1", null); + assertTrue(result.contains("query is required")); + } + + // ==================== getMemoryByKey ==================== + + @Test + void getMemoryByKey_found() throws Exception { + var entry = mock(UserMemoryEntry.class); + when(userMemoryStore.getByKey("user1", "language")).thenReturn(Optional.of(entry)); + when(jsonSerialization.serialize(entry)).thenReturn("{\"key\":\"language\"}"); + var result = tools.getMemoryByKey("user1", "language"); + assertEquals("{\"key\":\"language\"}", result); + } + + @Test + void getMemoryByKey_notFound() throws Exception { + when(userMemoryStore.getByKey("user1", "missing")).thenReturn(Optional.empty()); + var result = tools.getMemoryByKey("user1", "missing"); + assertTrue(result.contains("No memory found")); + } + + @Test + void getMemoryByKey_nullKey() { + var result = tools.getMemoryByKey("user1", null); + assertTrue(result.contains("key is required")); + } + + // ==================== upsertUserMemory ==================== + + @Test + void upsertUserMemory_success() throws Exception { + when(userMemoryStore.upsert(any())).thenReturn("new-id"); + when(jsonSerialization.serialize(any())).thenReturn("{\"status\":\"upserted\"}"); + var result = tools.upsertUserMemory("user1", "lang", "en", "agent1", "preference", "self"); + assertNotNull(result); + verify(userMemoryStore).upsert(any()); + } + + @Test + void upsertUserMemory_nullUserId() { + var result = tools.upsertUserMemory(null, "key", "val", "agent", null, null); + assertTrue(result.contains("userId is required")); + } + + @Test + void upsertUserMemory_nullKey() { + var result = tools.upsertUserMemory("user1", null, "val", "agent", null, null); + assertTrue(result.contains("key is required")); + } + + @Test + void upsertUserMemory_nullValue() { + var result = tools.upsertUserMemory("user1", "key", null, "agent", null, null); + assertTrue(result.contains("value is required")); + } + + @Test + void upsertUserMemory_nullAgentId() { + var result = tools.upsertUserMemory("user1", "key", "val", null, null, null); + assertTrue(result.contains("agentId is required")); + } + + @Test + void upsertUserMemory_invalidVisibility() { + var result = tools.upsertUserMemory("user1", "key", "val", "agent", null, "invalid"); + assertTrue(result.contains("Invalid visibility")); + } + + // ==================== deleteUserMemory ==================== + + @Test + void deleteUserMemory_success() throws Exception { + when(jsonSerialization.serialize(any())).thenReturn("{\"status\":\"deleted\"}"); + var result = tools.deleteUserMemory("entry-1"); + verify(userMemoryStore).deleteEntry("entry-1"); + assertNotNull(result); + } + + @Test + void deleteUserMemory_nullId() { + var result = tools.deleteUserMemory(null); + assertTrue(result.contains("entryId is required")); + } + + // ==================== deleteAllUserMemories ==================== + + @Test + void deleteAllUserMemories_success() throws Exception { + when(userMemoryStore.countEntries("user1")).thenReturn(5L); + when(jsonSerialization.serialize(any())).thenReturn("ok"); + tools.deleteAllUserMemories("user1", "CONFIRM"); + verify(userMemoryStore).deleteAllForUser("user1"); + } + + @Test + void deleteAllUserMemories_noConfirmation() { + var result = tools.deleteAllUserMemories("user1", "yes"); + assertTrue(result.contains("CONFIRM")); + } + + @Test + void deleteAllUserMemories_nullUserId() { + var result = tools.deleteAllUserMemories(null, "CONFIRM"); + assertTrue(result.contains("userId is required")); + } + + // ==================== countUserMemories ==================== + + @Test + void countUserMemories_success() throws Exception { + when(userMemoryStore.countEntries("user1")).thenReturn(42L); + when(jsonSerialization.serialize(any())).thenReturn("{\"count\":42}"); + var result = tools.countUserMemories("user1"); + assertEquals("{\"count\":42}", result); + } + + @Test + void countUserMemories_nullUserId() { + var result = tools.countUserMemories(null); + assertTrue(result.contains("userId is required")); + } + + @Test + void countUserMemories_exception() throws Exception { + when(userMemoryStore.countEntries("user1")).thenThrow(new RuntimeException("timeout")); + var result = tools.countUserMemories("user1"); + assertTrue(result.contains("Failed to count memories")); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/llm/memory/EddiChatMemoryStoreTest.java b/src/test/java/ai/labs/eddi/modules/llm/memory/EddiChatMemoryStoreTest.java new file mode 100644 index 000000000..df12e4b3a --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/llm/memory/EddiChatMemoryStoreTest.java @@ -0,0 +1,90 @@ +package ai.labs.eddi.modules.llm.memory; + +import ai.labs.eddi.datastore.IResourceStore; +import ai.labs.eddi.engine.memory.IConversationMemoryStore; +import ai.labs.eddi.engine.memory.model.ConversationMemorySnapshot; +import dev.langchain4j.data.message.AiMessage; +import dev.langchain4j.data.message.UserMessage; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.lang.reflect.Field; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class EddiChatMemoryStoreTest { + + private EddiChatMemoryStore store; + private IConversationMemoryStore memoryStore; + + @BeforeEach + void setUp() throws Exception { + store = new EddiChatMemoryStore(); + memoryStore = mock(IConversationMemoryStore.class); + // Inject mock via reflection (field injection) + Field field = EddiChatMemoryStore.class.getDeclaredField("conversationMemoryStore"); + field.setAccessible(true); + field.set(store, memoryStore); + } + + // ==================== getMessages ==================== + + @Test + void getMessages_newConversation_returnsEmpty() throws Exception { + when(memoryStore.loadConversationMemorySnapshot("conv-1")) + .thenThrow(new IResourceStore.ResourceNotFoundException("Not found")); + var result = store.getMessages("conv-1"); + assertTrue(result.isEmpty()); + } + + @Test + void getMessages_storeError_returnsEmpty() throws Exception { + when(memoryStore.loadConversationMemorySnapshot("conv-1")) + .thenThrow(new IResourceStore.ResourceStoreException("DB error")); + var result = store.getMessages("conv-1"); + assertTrue(result.isEmpty()); + } + + @Test + void getMessages_emptySnapshot_returnsEmpty() throws Exception { + var snapshot = new ConversationMemorySnapshot(); + snapshot.setConversationOutputs(List.of()); + when(memoryStore.loadConversationMemorySnapshot("conv-1")).thenReturn(snapshot); + var result = store.getMessages("conv-1"); + assertTrue(result.isEmpty()); + } + + // ==================== updateMessages ==================== + + @Test + void updateMessages_isNoOp() { + // No-op by design — no exceptions, no interactions + store.updateMessages("conv-1", List.of(UserMessage.from("test"))); + verifyNoInteractions(memoryStore); + } + + // ==================== deleteMessages ==================== + + @Test + void deleteMessages_success() throws Exception { + store.deleteMessages("conv-1"); + verify(memoryStore).deleteConversationMemorySnapshot("conv-1"); + } + + @Test + void deleteMessages_notFound_noException() throws Exception { + doThrow(new IResourceStore.ResourceNotFoundException("nope")) + .when(memoryStore).deleteConversationMemorySnapshot("conv-1"); + // Should not throw + assertDoesNotThrow(() -> store.deleteMessages("conv-1")); + } + + @Test + void deleteMessages_storeError_noException() throws Exception { + doThrow(new IResourceStore.ResourceStoreException("DB error")) + .when(memoryStore).deleteConversationMemorySnapshot("conv-1"); + assertDoesNotThrow(() -> store.deleteMessages("conv-1")); + } +} From 1332aa2a9e2fe0fbd44c038b12fa1bf29d1b1f5c Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 00:41:58 +0200 Subject: [PATCH 016/124] test(coverage): add tests for NLP, migrations, and engine models - UserConversationTest: constructors, setters, Jackson round-trip - RegularDictionaryTest: word lookup (case-sensitive/insensitive), phrases, regex matching, lookupIfKnown, list immutability (16 tests) - MergedTermsCorrectionTest: merged word detection, partial match, temporary dictionary support - PhoneticCorrectionTest: phonetic code-based word correction - V6QuteMigrationTest: disabled/already-applied skip, empty collections, Thymeleaf->Qute migration with mocked MongoDB Line coverage: 51.4% -> 52.0% (+0.6pp, 160 lines covered) --- .../migration/V6QuteMigrationTest.java | 87 ++++++++++++ .../model/UserConversationTest.java | 59 ++++++++ .../MergedTermsCorrectionTest.java | 80 +++++++++++ .../corrections/PhoneticCorrectionTest.java | 58 ++++++++ .../dictionaries/RegularDictionaryTest.java | 133 ++++++++++++++++++ 5 files changed, 417 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/configs/migration/V6QuteMigrationTest.java create mode 100644 src/test/java/ai/labs/eddi/engine/triggermanagement/model/UserConversationTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/nlp/extensions/corrections/MergedTermsCorrectionTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/nlp/extensions/corrections/PhoneticCorrectionTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/nlp/extensions/dictionaries/RegularDictionaryTest.java diff --git a/src/test/java/ai/labs/eddi/configs/migration/V6QuteMigrationTest.java b/src/test/java/ai/labs/eddi/configs/migration/V6QuteMigrationTest.java new file mode 100644 index 000000000..720619bee --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/migration/V6QuteMigrationTest.java @@ -0,0 +1,87 @@ +package ai.labs.eddi.configs.migration; + +import ai.labs.eddi.configs.migration.model.MigrationLog; +import com.mongodb.client.FindIterable; +import com.mongodb.client.MongoCollection; +import com.mongodb.client.MongoCursor; +import com.mongodb.client.MongoDatabase; +import org.bson.Document; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; + +class V6QuteMigrationTest { + + private MongoDatabase database; + private MigrationLogStore migrationLogStore; + private TemplateSyntaxMigrator migrator; + + @BeforeEach + void setUp() { + database = mock(MongoDatabase.class); + migrationLogStore = mock(MigrationLogStore.class); + migrator = mock(TemplateSyntaxMigrator.class); + } + + @Test + void runIfNeeded_disabled() { + var migration = new V6QuteMigration(database, migrationLogStore, migrator, false); + migration.runIfNeeded(); + verifyNoInteractions(database); + } + + @Test + void runIfNeeded_alreadyApplied() { + when(migrationLogStore.readMigrationLog("v6-qute-migration-complete")) + .thenReturn(new MigrationLog("v6-qute-migration-complete")); + var migration = new V6QuteMigration(database, migrationLogStore, migrator, true); + migration.runIfNeeded(); + verify(database, never()).getCollection(anyString()); + } + + @SuppressWarnings("unchecked") + @Test + void runIfNeeded_emptyCollections() { + when(migrationLogStore.readMigrationLog("v6-qute-migration-complete")).thenReturn(null); + + MongoCollection emptyCol = mock(MongoCollection.class); + when(emptyCol.estimatedDocumentCount()).thenReturn(0L); + when(database.getCollection(anyString())).thenReturn(emptyCol); + + var migration = new V6QuteMigration(database, migrationLogStore, migrator, true); + migration.runIfNeeded(); + + verify(migrationLogStore).createMigrationLog(any(MigrationLog.class)); + } + + @SuppressWarnings("unchecked") + @Test + void runIfNeeded_migratesThymeleaf() { + when(migrationLogStore.readMigrationLog("v6-qute-migration-complete")).thenReturn(null); + when(migrator.containsThymeleafSyntax("[[${var}]]")).thenReturn(true); + when(migrator.migrate("[[${var}]]")).thenReturn("{var}"); + when(migrator.containsThymeleafSyntax("{var}")).thenReturn(false); + + var doc = new Document("template", "[[${var}]]"); + doc.put("_id", "doc-1"); + + MongoCollection col = mock(MongoCollection.class); + when(col.estimatedDocumentCount()).thenReturn(1L); + FindIterable iterable = mock(FindIterable.class); + MongoCursor cursor = mock(MongoCursor.class); + when(cursor.hasNext()).thenReturn(true, false); + when(cursor.next()).thenReturn(doc); + when(iterable.iterator()).thenReturn(cursor); + when(col.find()).thenReturn(iterable); + when(database.getCollection(anyString())).thenReturn(col); + + var migration = new V6QuteMigration(database, migrationLogStore, migrator, true); + migration.runIfNeeded(); + + verify(col, atLeastOnce()).replaceOne(any(), eq(doc)); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/triggermanagement/model/UserConversationTest.java b/src/test/java/ai/labs/eddi/engine/triggermanagement/model/UserConversationTest.java new file mode 100644 index 000000000..1b472d80e --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/triggermanagement/model/UserConversationTest.java @@ -0,0 +1,59 @@ +package ai.labs.eddi.engine.triggermanagement.model; + +import ai.labs.eddi.engine.model.Deployment; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class UserConversationTest { + + @Test + void defaultConstructor() { + var uc = new UserConversation(); + assertNull(uc.getIntent()); + assertNull(uc.getUserId()); + assertNull(uc.getEnvironment()); + assertNull(uc.getAgentId()); + assertNull(uc.getConversationId()); + } + + @Test + void fullConstructor() { + var uc = new UserConversation("greeting", "user-1", + Deployment.Environment.production, "agent-1", "conv-123"); + assertEquals("greeting", uc.getIntent()); + assertEquals("user-1", uc.getUserId()); + assertEquals(Deployment.Environment.production, uc.getEnvironment()); + assertEquals("agent-1", uc.getAgentId()); + assertEquals("conv-123", uc.getConversationId()); + } + + @Test + void setters() { + var uc = new UserConversation(); + uc.setIntent("farewell"); + uc.setUserId("user-2"); + uc.setEnvironment(Deployment.Environment.test); + uc.setAgentId("agent-2"); + uc.setConversationId("conv-456"); + + assertEquals("farewell", uc.getIntent()); + assertEquals("user-2", uc.getUserId()); + assertEquals(Deployment.Environment.test, uc.getEnvironment()); + assertEquals("agent-2", uc.getAgentId()); + assertEquals("conv-456", uc.getConversationId()); + } + + @Test + void jacksonRoundTrip() throws Exception { + var mapper = new ObjectMapper(); + var uc = new UserConversation("greeting", "user-1", + Deployment.Environment.production, "agent-1", "conv-123"); + var json = mapper.writeValueAsString(uc); + var deserialized = mapper.readValue(json, UserConversation.class); + assertEquals("greeting", deserialized.getIntent()); + assertEquals("user-1", deserialized.getUserId()); + assertEquals("agent-1", deserialized.getAgentId()); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/nlp/extensions/corrections/MergedTermsCorrectionTest.java b/src/test/java/ai/labs/eddi/modules/nlp/extensions/corrections/MergedTermsCorrectionTest.java new file mode 100644 index 000000000..8f6395656 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/nlp/extensions/corrections/MergedTermsCorrectionTest.java @@ -0,0 +1,80 @@ +package ai.labs.eddi.modules.nlp.extensions.corrections; + +import ai.labs.eddi.modules.nlp.expressions.Expression; +import ai.labs.eddi.modules.nlp.expressions.Expressions; +import ai.labs.eddi.modules.nlp.extensions.dictionaries.IDictionary; +import ai.labs.eddi.modules.nlp.model.FoundWord; +import ai.labs.eddi.modules.nlp.model.Word; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.Collections; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class MergedTermsCorrectionTest { + + private MergedTermsCorrection correction; + private IDictionary dictionary; + + @BeforeEach + void setUp() { + correction = new MergedTermsCorrection(); + dictionary = mock(IDictionary.class); + when(dictionary.lookupTerm(anyString())).thenReturn(IDictionary.NO_WORDS_FOUND); + correction.init(List.of(dictionary)); + } + + @Test + void lookupIfKnown_returnsFalse() { + assertFalse(correction.lookupIfKnown()); + } + + @Test + void correctWord_noMatch() { + var result = correction.correctWord("unknownword", null, Collections.emptyList()); + assertTrue(result.isEmpty() || result == IDictionary.NO_WORDS_FOUND); + } + + @Test + void correctWord_singleWordMatch() { + var word = new Word("hello", new Expressions(new Expression("greeting")), "test", 0, false); + var foundWord = new FoundWord(word, false, 1.0); + when(dictionary.lookupTerm("hello")).thenReturn(List.of(foundWord)); + + var result = correction.correctWord("hello", null, Collections.emptyList()); + assertEquals(1, result.size()); + } + + @Test + void correctWord_mergedWords() { + var wordHello = new Word("hello", new Expressions(new Expression("g1")), "test", 0, false); + var wordWorld = new Word("world", new Expressions(new Expression("g2")), "test", 0, false); + when(dictionary.lookupTerm("hello")).thenReturn(List.of(new FoundWord(wordHello, false, 1.0))); + when(dictionary.lookupTerm("world")).thenReturn(List.of(new FoundWord(wordWorld, false, 1.0))); + + var result = correction.correctWord("helloworld", null, Collections.emptyList()); + assertEquals(2, result.size()); + } + + @Test + void correctWord_partialMatch() { + var word = new Word("hello", new Expressions(new Expression("g1")), "test", 0, false); + when(dictionary.lookupTerm("hello")).thenReturn(List.of(new FoundWord(word, false, 1.0))); + + var result = correction.correctWord("helloxyz", null, Collections.emptyList()); + assertNotNull(result); + } + + @Test + void correctWord_withTemporaryDictionary() { + var tempDict = mock(IDictionary.class); + var word = new Word("temp", new Expressions(new Expression("t1")), "test", 0, false); + when(tempDict.lookupTerm("temp")).thenReturn(List.of(new FoundWord(word, false, 1.0))); + + var result = correction.correctWord("temp", null, List.of(tempDict)); + assertEquals(1, result.size()); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/nlp/extensions/corrections/PhoneticCorrectionTest.java b/src/test/java/ai/labs/eddi/modules/nlp/extensions/corrections/PhoneticCorrectionTest.java new file mode 100644 index 000000000..c1d7cd5e4 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/nlp/extensions/corrections/PhoneticCorrectionTest.java @@ -0,0 +1,58 @@ +package ai.labs.eddi.modules.nlp.extensions.corrections; + +import ai.labs.eddi.modules.nlp.expressions.Expression; +import ai.labs.eddi.modules.nlp.expressions.Expressions; +import ai.labs.eddi.modules.nlp.extensions.dictionaries.IDictionary; +import ai.labs.eddi.modules.nlp.model.Word; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.Collections; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class PhoneticCorrectionTest { + + private PhoneticCorrection correction; + + @BeforeEach + void setUp() { + correction = new PhoneticCorrection(true); + var dictionary = mock(IDictionary.class); + var words = List.of( + new Word("hello", new Expressions(new Expression("g1")), "test", 0, false), + new Word("world", new Expressions(new Expression("g2")), "test", 0, false), + new Word("phone", new Expressions(new Expression("g3")), "test", 0, false)); + when(dictionary.getWords()).thenReturn(words); + correction.init(List.of(dictionary)); + } + + @Test + void lookupIfKnown_returnsConfiguredValue() { + assertTrue(correction.lookupIfKnown()); + } + + @Test + void lookupIfKnown_false() { + var c = new PhoneticCorrection(false); + assertFalse(c.lookupIfKnown()); + } + + @Test + void correctWord_exactPhonetic() { + // "hello" should phonetically match "hello" + var result = correction.correctWord("hello", null, Collections.emptyList()); + assertNotNull(result); + assertFalse(result.isEmpty()); + } + + @Test + void correctWord_anotherKnownWord() { + // "world" should phonetically match itself + var result = correction.correctWord("world", null, Collections.emptyList()); + assertNotNull(result); + assertFalse(result.isEmpty()); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/nlp/extensions/dictionaries/RegularDictionaryTest.java b/src/test/java/ai/labs/eddi/modules/nlp/extensions/dictionaries/RegularDictionaryTest.java new file mode 100644 index 000000000..00c83778e --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/nlp/extensions/dictionaries/RegularDictionaryTest.java @@ -0,0 +1,133 @@ +package ai.labs.eddi.modules.nlp.extensions.dictionaries; + +import ai.labs.eddi.modules.nlp.expressions.Expression; +import ai.labs.eddi.modules.nlp.expressions.Expressions; +import ai.labs.eddi.modules.nlp.model.FoundDictionaryEntry; +import ai.labs.eddi.modules.nlp.model.FoundWord; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class RegularDictionaryTest { + + private RegularDictionary dict; + + @BeforeEach + void setUp() { + dict = new RegularDictionary(); + } + + @Test + void addWord_andLookup() { + dict.addWord("hello", new Expressions(new Expression("greeting")), 0); + var result = dict.lookupTerm("hello"); + assertEquals(1, result.size()); + assertEquals("hello", result.get(0).getFoundWord().getValue()); + } + + @Test + void lookupTerm_caseInsensitive() { + dict.addWord("Hello", new Expressions(new Expression("greeting")), 0); + var result = dict.lookupTerm("hello"); + assertFalse(result.isEmpty()); + // case-insensitive match → corrected=true, accuracy=0.9 + var found = (FoundDictionaryEntry) result.get(0); + assertTrue(found.isIsCorrected()); + assertEquals(0.9, found.getMatchingAccuracy(), 0.01); + } + + @Test + void lookupTerm_caseSensitive() { + dict.addWord("Hello", new Expressions(new Expression("greeting")), 0); + var result = dict.lookupTerm("Hello"); + assertFalse(result.isEmpty()); + // exact match → corrected=false, accuracy=1.0 + var found = (FoundDictionaryEntry) result.get(0); + assertFalse(found.isIsCorrected()); + assertEquals(1.0, found.getMatchingAccuracy(), 0.01); + } + + @Test + void lookupTerm_notFound() { + dict.addWord("hello", new Expressions(new Expression("greeting")), 0); + var result = dict.lookupTerm("nonexistent"); + assertTrue(result.isEmpty()); + } + + @Test + void getWords_empty() { + assertTrue(dict.getWords().isEmpty()); + } + + @Test + void getWords_afterAdd() { + dict.addWord("a", new Expressions(), 0); + dict.addWord("b", new Expressions(), 0); + assertEquals(2, dict.getWords().size()); + } + + @Test + void getPhrases_empty() { + assertTrue(dict.getPhrases().isEmpty()); + } + + @Test + void addPhrase() { + dict.addPhrase("how are you", new Expressions(new Expression("greeting"))); + assertEquals(1, dict.getPhrases().size()); + } + + @Test + void addPhrase_wordsIncludedInGetWords() { + dict.addPhrase("good morning", new Expressions(new Expression("greeting"))); + // Phrases contribute words via getWords() + assertFalse(dict.getWords().isEmpty()); + } + + @Test + void addRegex() { + dict.addRegex("\\d+", new Expressions(new Expression("number"))); + assertEquals(1, dict.getRegExs().size()); + } + + @Test + void lookupTerm_regex() { + dict.addRegex("\\d+", new Expressions(new Expression("number"))); + var result = dict.lookupTerm("42"); + assertFalse(result.isEmpty()); + } + + @Test + void lookupTerm_regexNoMatch() { + dict.addRegex("\\d+", new Expressions(new Expression("number"))); + var result = dict.lookupTerm("abc"); + assertTrue(result.isEmpty()); + } + + @Test + void lookupIfKnown_default() { + assertFalse(dict.lookupIfKnown()); + } + + @Test + void lookupIfKnown_setter() { + dict.setLookupIfKnown(true); + assertTrue(dict.lookupIfKnown()); + assertTrue(dict.isLookupIfKnown()); + } + + @Test + void getWords_unmodifiable() { + dict.addWord("test", new Expressions(), 0); + var words = dict.getWords(); + assertThrows(UnsupportedOperationException.class, () -> words.add(null)); + } + + @Test + void getPhrases_unmodifiable() { + dict.addPhrase("test phrase", new Expressions()); + var phrases = dict.getPhrases(); + assertThrows(UnsupportedOperationException.class, () -> phrases.add(null)); + } +} From 8d13f6741216332cba9b29d417444dddbe8d0cf7 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 00:42:52 +0200 Subject: [PATCH 017/124] chore(docs): update changelog with batches 13-14 coverage progress (52.0%) --- docs/changelog.md | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/docs/changelog.md b/docs/changelog.md index e15369b85..7b29ebebc 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -52,6 +52,18 @@ Each entry follows this format: - `IdDeserializerTest` — non-BSON deserialization path - `ToolExecutionServiceTest` — executeToolWrapped (all feature permutations: success, cached, rate-limited, features individually disabled, null conversationId, tool exception), parallel array validation +### Batch 13 — MCP, Memory, Cache +- `McpMemoryToolsTest` — all 7 MCP tool methods (list, getVisible, search, getByKey, upsert, delete, deleteAll, count) with null/blank validation, success paths, exception handling +- `EddiChatMemoryStoreTest` — getMessages (new conversation, store error, empty snapshot), updateMessages (no-op), deleteMessages (success, not found, store error) +- `CacheImplTest` — full ConcurrentMap delegation + all TTL-aware overloads + +### Batch 14 — NLP, Migrations, Engine Models +- `RegularDictionaryTest` — word lookup (case-sensitive/insensitive), phrases, regex, lookupIfKnown, list immutability +- `MergedTermsCorrectionTest` — merged word detection, partial match, temp dictionary +- `PhoneticCorrectionTest` — phonetic code-based word correction +- `V6QuteMigrationTest` — disabled/already-applied skip, empty collections, Thymeleaf→Qute migration +- `UserConversationTest` — constructors, setters, Jackson round-trip + ### Coverage Progress | Checkpoint | Line % | Branch % | @@ -59,8 +71,9 @@ Each entry follows this format: | Batch 6 | 48.1% | 42.7% | | Batch 10 | 49.1% | 43.2% | | Batch 12 | 50.8% | 44.3% | +| Batch 14 | 52.0% | 45.3% | -**Files (Batch 11-12):** +**Files (Batch 11-14):** - `src/test/java/ai/labs/eddi/modules/output/model/OutputModelsTest.java` — new - `src/test/java/ai/labs/eddi/modules/output/model/types/OutputTypesTest.java` — new - `src/test/java/ai/labs/eddi/engine/model/EngineModelsTest.java` — new @@ -72,6 +85,14 @@ Each entry follows this format: - `src/test/java/ai/labs/eddi/datastore/serialization/IdSerializerTest.java` — new - `src/test/java/ai/labs/eddi/datastore/serialization/IdDeserializerTest.java` — new - `src/test/java/ai/labs/eddi/modules/llm/tools/ToolExecutionServiceTest.java` — new +- `src/test/java/ai/labs/eddi/engine/mcp/McpMemoryToolsTest.java` — new +- `src/test/java/ai/labs/eddi/modules/llm/memory/EddiChatMemoryStoreTest.java` — new +- `src/test/java/ai/labs/eddi/engine/caching/CacheImplTest.java` — new +- `src/test/java/ai/labs/eddi/modules/nlp/extensions/dictionaries/RegularDictionaryTest.java` — new +- `src/test/java/ai/labs/eddi/modules/nlp/extensions/corrections/MergedTermsCorrectionTest.java` — new +- `src/test/java/ai/labs/eddi/modules/nlp/extensions/corrections/PhoneticCorrectionTest.java` — new +- `src/test/java/ai/labs/eddi/configs/migration/V6QuteMigrationTest.java` — new +- `src/test/java/ai/labs/eddi/engine/triggermanagement/model/UserConversationTest.java` — new --- From cf05d0b884317c1954f019bf4efa070165f2f12a Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 08:46:04 +0200 Subject: [PATCH 018/124] refactor(tools): replace hand-rolled JSON parsing with Jackson ObjectMapper WebSearchTool: Replace all String.split/indexOf-based JSON parsing with Jackson ObjectMapper.readTree() for safe, correct JSON parsing. Inject ObjectMapper via CDI constructor (matching WeatherTool pattern). Use boolean flags for empty-result detection instead of StringBuilder.equals(). AuditLedgerService: Replace hand-rolled JSON string concatenation in writeToDeadLetter with Jackson ObjectMapper.writeValueAsString() for correct escaping of all field values. Remove unsafe fallback that embedded unescaped user values. Tests: 49 passing (23 WebSearchTool + 26 AuditLedger). All parsing tests are pure unit tests against mock JSON - no network calls. --- .../eddi/engine/audit/AuditLedgerService.java | 42 +- .../modules/llm/tools/impl/WebSearchTool.java | 196 ++++--- .../engine/audit/AuditLedgerServiceTest.java | 85 +++ .../llm/tools/impl/WebSearchToolTest.java | 482 +++++++++++++++--- 4 files changed, 636 insertions(+), 169 deletions(-) diff --git a/src/main/java/ai/labs/eddi/engine/audit/AuditLedgerService.java b/src/main/java/ai/labs/eddi/engine/audit/AuditLedgerService.java index dc0ef48c9..3559968bc 100644 --- a/src/main/java/ai/labs/eddi/engine/audit/AuditLedgerService.java +++ b/src/main/java/ai/labs/eddi/engine/audit/AuditLedgerService.java @@ -3,6 +3,8 @@ import ai.labs.eddi.configs.agents.AgentSigningService; import ai.labs.eddi.engine.audit.model.AuditEntry; import ai.labs.eddi.secrets.sanitize.SecretRedactionFilter; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; import io.nats.client.Connection; import io.nats.client.JetStream; import jakarta.annotation.PostConstruct; @@ -44,6 +46,7 @@ public class AuditLedgerService { private static final Logger LOGGER = Logger.getLogger(AuditLedgerService.class); private static final int MAX_FLUSH_RETRIES = 3; + private static final ObjectMapper DEAD_LETTER_MAPPER = new ObjectMapper(); private final IAuditStore auditStore; private final boolean enabled; @@ -287,9 +290,7 @@ private void writeToDeadLetter(List entries) { if (conn.getStatus() == Connection.Status.CONNECTED) { JetStream js = conn.jetStream(); for (AuditEntry entry : entries) { - String payload = "{\"type\":\"audit_dead_letter\",\"timestamp\":\"" + Instant.now() + "\",\"conversationId\":\"" - + entry.conversationId() + "\",\"agentId\":\"" + entry.agentId() + "\",\"taskId\":\"" + entry.taskId() - + "\",\"taskType\":\"" + entry.taskType() + "\"}"; + String payload = serializeDeadLetterEntry(entry, "audit_dead_letter"); js.publish("eddi.deadletter.audit", payload.getBytes(StandardCharsets.UTF_8)); } LOGGER.infov("Published {0} audit dead-letter entries to NATS JetStream", entries.size()); @@ -305,8 +306,7 @@ private void writeToDeadLetter(List entries) { Path dlPath = Path.of(deadLetterPath); var lines = new ArrayList(entries.size()); for (AuditEntry entry : entries) { - lines.add("{\"timestamp\":\"" + Instant.now() + "\",\"conversationId\":\"" + entry.conversationId() + "\",\"agentId\":\"" - + entry.agentId() + "\",\"taskId\":\"" + entry.taskId() + "\",\"taskType\":\"" + entry.taskType() + "\"}"); + lines.add(serializeDeadLetterEntry(entry, null)); } Files.write(dlPath, lines, StandardOpenOption.CREATE, StandardOpenOption.APPEND); LOGGER.infov("Wrote {0} entries to dead-letter log: {1}", entries.size(), dlPath.toAbsolutePath()); @@ -314,4 +314,36 @@ private void writeToDeadLetter(List entries) { LOGGER.errorv("Failed to write to dead-letter log: {0}", e.getMessage()); } } + + /** + * Serializes a dead-letter entry as a JSON string using Jackson for correct + * escaping of all field values. + * + * @param entry + * the audit entry to serialize + * @param type + * optional type field (e.g. "audit_dead_letter" for NATS), null for + * file output + * @return JSON string + */ + static String serializeDeadLetterEntry(AuditEntry entry, String type) { + Map dlMap = new LinkedHashMap<>(); + if (type != null) { + dlMap.put("type", type); + } + dlMap.put("timestamp", Instant.now().toString()); + dlMap.put("conversationId", entry.conversationId()); + dlMap.put("agentId", entry.agentId()); + dlMap.put("taskId", entry.taskId()); + dlMap.put("taskType", entry.taskType()); + + try { + return DEAD_LETTER_MAPPER.writeValueAsString(dlMap); + } catch (JsonProcessingException e) { + // Absolute fallback — should never happen with simple string maps. + // Do NOT embed entry fields here: we'd reintroduce the escaping bug. + LOGGER.errorv("Jackson serialization failed for dead-letter entry: {0}", e.getMessage()); + return "{\"error\":\"serialization_failed\"}"; + } + } } diff --git a/src/main/java/ai/labs/eddi/modules/llm/tools/impl/WebSearchTool.java b/src/main/java/ai/labs/eddi/modules/llm/tools/impl/WebSearchTool.java index 070edef23..0db01b24e 100644 --- a/src/main/java/ai/labs/eddi/modules/llm/tools/impl/WebSearchTool.java +++ b/src/main/java/ai/labs/eddi/modules/llm/tools/impl/WebSearchTool.java @@ -1,6 +1,8 @@ package ai.labs.eddi.modules.llm.tools.impl; import ai.labs.eddi.engine.httpclient.SafeHttpClient; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; import dev.langchain4j.agent.tool.P; import dev.langchain4j.agent.tool.Tool; import jakarta.enterprise.context.ApplicationScoped; @@ -20,11 +22,15 @@ /** * Web search tool that integrates with search APIs. Supports Google Custom * Search, DuckDuckGo, and other search providers. + *

+ * Uses Jackson {@link ObjectMapper} for safe, correct JSON parsing of all + * search API responses. */ @ApplicationScoped public class WebSearchTool { private static final Logger LOGGER = Logger.getLogger(WebSearchTool.class); private final SafeHttpClient httpClient; + private final ObjectMapper objectMapper; @ConfigProperty(name = "eddi.tools.websearch.google.api-key") Optional googleApiKey; @@ -36,8 +42,9 @@ public class WebSearchTool { String searchProvider; @Inject - public WebSearchTool(SafeHttpClient httpClient) { + public WebSearchTool(SafeHttpClient httpClient, ObjectMapper objectMapper) { this.httpClient = httpClient; + this.objectMapper = objectMapper; } @Tool("Searches the web for current information on any topic. Returns relevant search results with titles and snippets.") @@ -103,88 +110,82 @@ private String searchWithDuckDuckGo(String query, int maxResults) throws IOExcep return formatDuckDuckGoResults(response.body(), query, maxResults); } - private String formatGoogleResults(String jsonResponse, String query) { - // Simple parsing - in production, use proper JSON library + /** + * Parses Google Custom Search API JSON response using Jackson. + */ + String formatGoogleResults(String jsonResponse, String query) { StringBuilder results = new StringBuilder(); results.append("Search results for '").append(query).append("':\n\n"); - // Extract items from JSON (simplified - in production use Jackson/Gson) - if (jsonResponse.contains("\"items\"")) { - String[] items = jsonResponse.split("\"title\""); - int count = 0; - - for (int i = 1; i < items.length && count < 10; i++) { - try { - // Extract title - int titleStart = items[i].indexOf(":") + 3; - int titleEnd = items[i].indexOf("\"", titleStart); - String title = items[i].substring(titleStart, titleEnd); - - // Extract snippet - int snippetStart = items[i].indexOf("\"snippet\"") + 12; - int snippetEnd = items[i].indexOf("\"", snippetStart); - String snippet = items[i].substring(snippetStart, snippetEnd); - - // Extract link - int linkStart = items[i].indexOf("\"link\"") + 9; - int linkEnd = items[i].indexOf("\"", linkStart); - String link = items[i].substring(linkStart, linkEnd); - - results.append(++count).append(". ").append(unescapeJson(title)).append("\n"); - results.append(" ").append(unescapeJson(snippet)).append("\n"); - results.append(" ").append(link).append("\n\n"); + boolean hasResults = false; + try { + JsonNode root = objectMapper.readTree(jsonResponse); + JsonNode items = root.get("items"); + + if (items != null && items.isArray()) { + int count = 0; + for (JsonNode item : items) { + if (count >= 10) + break; - } catch (Exception e) { - // Skip malformed results - LOGGER.debug("Could not parse search result: " + e.getMessage()); + String title = getTextOrEmpty(item, "title"); + String snippet = getTextOrEmpty(item, "snippet"); + String link = getTextOrEmpty(item, "link"); + + results.append(++count).append(". ").append(title).append("\n"); + results.append(" ").append(snippet).append("\n"); + results.append(" ").append(link).append("\n\n"); + hasResults = true; } } + } catch (Exception e) { + LOGGER.debug("Could not parse Google search results: " + e.getMessage()); } - if (results.length() == 0) { + if (!hasResults) { results.append("No results found for '").append(query).append("'."); } return results.toString(); } - private String formatDuckDuckGoResults(String jsonResponse, String query, int maxResults) { + /** + * Parses DuckDuckGo Instant Answer API JSON response using Jackson. + */ + String formatDuckDuckGoResults(String jsonResponse, String query, int maxResults) { StringBuilder results = new StringBuilder(); results.append("Search results for '").append(query).append("':\n\n"); + boolean hasResults = false; try { - // Parse DuckDuckGo instant answer - if (jsonResponse.contains("\"Abstract\"")) { - String abstractText = extractJsonValue(jsonResponse, "Abstract"); - String abstractUrl = extractJsonValue(jsonResponse, "AbstractURL"); - - if (!abstractText.isEmpty()) { - results.append("Quick Answer:\n"); - results.append(unescapeJson(abstractText)).append("\n"); - if (!abstractUrl.isEmpty()) { - results.append("Source: ").append(abstractUrl).append("\n"); - } - results.append("\n"); + JsonNode root = objectMapper.readTree(jsonResponse); + + // Parse DuckDuckGo instant answer abstract + String abstractText = getTextOrEmpty(root, "Abstract"); + String abstractUrl = getTextOrEmpty(root, "AbstractURL"); + + if (!abstractText.isEmpty()) { + results.append("Quick Answer:\n"); + results.append(abstractText).append("\n"); + if (!abstractUrl.isEmpty()) { + results.append("Source: ").append(abstractUrl).append("\n"); } + results.append("\n"); + hasResults = true; } // Parse related topics - if (jsonResponse.contains("\"RelatedTopics\"")) { - results.append("Related information:\n"); - String[] topics = jsonResponse.split("\"Text\""); + JsonNode relatedTopics = root.get("RelatedTopics"); + if (relatedTopics != null && relatedTopics.isArray()) { int count = 0; - - for (int i = 1; i < topics.length && count < maxResults; i++) { - try { - int textStart = topics[i].indexOf(":") + 3; - int textEnd = topics[i].indexOf("\"", textStart); - String text = topics[i].substring(textStart, textEnd); - - if (!text.isEmpty()) { - results.append(++count).append(". ").append(unescapeJson(text)).append("\n"); - } - } catch (Exception e) { - // Skip malformed results + for (JsonNode topic : relatedTopics) { + if (count >= maxResults) + break; + + String text = getTextOrEmpty(topic, "Text"); + if (!text.isEmpty()) { + results.append(++count).append(". ").append(text).append("\n"); + hasResults = true; } } } @@ -194,35 +195,13 @@ private String formatDuckDuckGoResults(String jsonResponse, String query, int ma return "Search completed but could not parse results. Query: " + query; } - if (results.toString().equals("Search results for '" + query + "':\n\n")) { + if (!hasResults) { results.append("No instant results found. Try refining your search query."); } return results.toString(); } - private String extractJsonValue(String json, String key) { - try { - String searchKey = "\"" + key + "\":\""; - int start = json.indexOf(searchKey); - if (start == -1) - return ""; - - start += searchKey.length(); - int end = json.indexOf("\"", start); - if (end == -1) - return ""; - - return json.substring(start, end); - } catch (Exception e) { - return ""; - } - } - - private String unescapeJson(String text) { - return text.replace("\\n", "\n").replace("\\\"", "\"").replace("\\\\", "\\").replace("\\/", "/"); - } - @Tool("Searches for news articles on a specific topic") public String searchNews(@P("query") String query, @P("maxResults") Integer maxResults) { @@ -254,32 +233,36 @@ public String searchWikipedia(@P("query") String query) { } } - private String formatWikipediaResults(String jsonResponse, String query) { + /** + * Parses Wikipedia API JSON response using Jackson. + */ + String formatWikipediaResults(String jsonResponse, String query) { StringBuilder results = new StringBuilder(); results.append("Wikipedia results for '").append(query).append("':\n\n"); + boolean hasResults = false; try { - String[] searchResults = jsonResponse.split("\"title\""); - int count = 0; + JsonNode root = objectMapper.readTree(jsonResponse); + JsonNode queryNode = root.get("query"); + JsonNode searchResults = queryNode != null ? queryNode.get("search") : null; - for (int i = 1; i < searchResults.length && count < 3; i++) { - try { - int titleStart = searchResults[i].indexOf(":\"") + 2; - int titleEnd = searchResults[i].indexOf("\"", titleStart); - String title = searchResults[i].substring(titleStart, titleEnd); + if (searchResults != null && searchResults.isArray()) { + int count = 0; + for (JsonNode item : searchResults) { + if (count >= 3) + break; - int snippetStart = searchResults[i].indexOf("\"snippet\":\"") + 11; - int snippetEnd = searchResults[i].indexOf("\"", snippetStart); - String snippet = searchResults[i].substring(snippetStart, snippetEnd); + String title = getTextOrEmpty(item, "title"); + String snippet = getTextOrEmpty(item, "snippet") + .replaceAll("<[^>]*>", ""); // Strip HTML tags - String wikiUrl = "https://en.wikipedia.org/wiki/" + URLEncoder.encode(title.replace(" ", "_"), StandardCharsets.UTF_8); + String wikiUrl = "https://en.wikipedia.org/wiki/" + + URLEncoder.encode(title.replace(" ", "_"), StandardCharsets.UTF_8); - results.append(++count).append(". ").append(unescapeJson(title)).append("\n"); - results.append(" ").append(unescapeJson(snippet).replaceAll("<[^>]*>", "")).append("\n"); + results.append(++count).append(". ").append(title).append("\n"); + results.append(" ").append(snippet).append("\n"); results.append(" ").append(wikiUrl).append("\n\n"); - - } catch (Exception e) { - LOGGER.debug("Could not parse Wikipedia result: " + e.getMessage()); + hasResults = true; } } @@ -288,10 +271,21 @@ private String formatWikipediaResults(String jsonResponse, String query) { return "Wikipedia search completed but could not parse results."; } - if (results.toString().equals("Wikipedia results for '" + query + "':\n\n")) { + if (!hasResults) { results.append("No Wikipedia articles found for '").append(query).append("'."); } return results.toString(); } + + /** + * Safely extracts a text value from a JsonNode field, returning empty string if + * the field is missing or null. + */ + private static String getTextOrEmpty(JsonNode node, String fieldName) { + if (node == null) + return ""; + JsonNode field = node.get(fieldName); + return (field != null && !field.isNull()) ? field.asText() : ""; + } } diff --git a/src/test/java/ai/labs/eddi/engine/audit/AuditLedgerServiceTest.java b/src/test/java/ai/labs/eddi/engine/audit/AuditLedgerServiceTest.java index 6742aecde..6e64c296b 100644 --- a/src/test/java/ai/labs/eddi/engine/audit/AuditLedgerServiceTest.java +++ b/src/test/java/ai/labs/eddi/engine/audit/AuditLedgerServiceTest.java @@ -1,6 +1,8 @@ package ai.labs.eddi.engine.audit; import ai.labs.eddi.engine.audit.model.AuditEntry; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @@ -404,6 +406,89 @@ void shouldProduceSameHmacRegardlessOfMapImplementation() { } } + // ==================== Dead Letter Serialization ==================== + + @Nested + class DeadLetterSerialization { + + private final ObjectMapper mapper = new ObjectMapper(); + + @Test + void serializeDeadLetterEntry_WithType_ShouldIncludeTypeField() throws Exception { + AuditEntry entry = createEntry("task-1", "conv-1"); + + String json = AuditLedgerService.serializeDeadLetterEntry(entry, "audit_dead_letter"); + + // Parse the result to verify it's valid JSON + JsonNode node = mapper.readTree(json); + + assertEquals("audit_dead_letter", node.get("type").asText()); + assertEquals("conv-1", node.get("conversationId").asText()); + assertEquals("agent-1", node.get("agentId").asText()); + assertEquals("task-1", node.get("taskId").asText()); + assertEquals("test-type", node.get("taskType").asText()); + assertNotNull(node.get("timestamp")); + } + + @Test + void serializeDeadLetterEntry_WithoutType_ShouldOmitTypeField() throws Exception { + AuditEntry entry = createEntry("task-1", "conv-1"); + + String json = AuditLedgerService.serializeDeadLetterEntry(entry, null); + + JsonNode node = mapper.readTree(json); + + assertNull(node.get("type")); + assertEquals("conv-1", node.get("conversationId").asText()); + assertEquals("agent-1", node.get("agentId").asText()); + } + + @Test + void serializeDeadLetterEntry_WithSpecialChars_ShouldEscapeCorrectly() throws Exception { + AuditEntry entry = new AuditEntry("id-1", "conv-with-\"quotes\"", "agent-with\nnewline", 1, + "user-1", "production", 0, "task/special", "type", 0, 42L, + null, null, null, null, null, 0.0, Instant.now(), null, null); + + String json = AuditLedgerService.serializeDeadLetterEntry(entry, "test"); + + // Must be valid JSON despite special characters + JsonNode node = mapper.readTree(json); + + assertEquals("conv-with-\"quotes\"", node.get("conversationId").asText()); + assertEquals("agent-with\nnewline", node.get("agentId").asText()); + assertEquals("task/special", node.get("taskId").asText()); + assertEquals("type", node.get("taskType").asText()); + } + + @Test + void serializeDeadLetterEntry_WithNullFields_ShouldProduceValidJson() throws Exception { + AuditEntry entry = new AuditEntry("id-1", null, null, null, null, null, 0, + null, null, 0, 0L, null, null, null, null, null, 0.0, null, null, null); + + String json = AuditLedgerService.serializeDeadLetterEntry(entry, null); + + // Must be valid JSON + JsonNode node = mapper.readTree(json); + + assertTrue(node.get("conversationId").isNull()); + assertTrue(node.get("agentId").isNull()); + assertTrue(node.get("taskId").isNull()); + assertTrue(node.get("taskType").isNull()); + } + + @Test + void serializeDeadLetterEntry_ShouldAlwaysContainTimestamp() throws Exception { + AuditEntry entry = createEntry("task-1", "conv-1"); + + String json = AuditLedgerService.serializeDeadLetterEntry(entry, null); + + JsonNode node = mapper.readTree(json); + + assertNotNull(node.get("timestamp")); + assertFalse(node.get("timestamp").asText().isEmpty()); + } + } + // ==================== Helper ==================== private static AuditEntry withHmac(AuditEntry entry, String hmac) { diff --git a/src/test/java/ai/labs/eddi/modules/llm/tools/impl/WebSearchToolTest.java b/src/test/java/ai/labs/eddi/modules/llm/tools/impl/WebSearchToolTest.java index 0d1cee4fa..96e7d3328 100644 --- a/src/test/java/ai/labs/eddi/modules/llm/tools/impl/WebSearchToolTest.java +++ b/src/test/java/ai/labs/eddi/modules/llm/tools/impl/WebSearchToolTest.java @@ -1,14 +1,22 @@ package ai.labs.eddi.modules.llm.tools.impl; import ai.labs.eddi.engine.httpclient.SafeHttpClient; +import com.fasterxml.jackson.databind.ObjectMapper; import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; /** - * Unit tests for WebSearchTool. Note: These tests focus on the tool's behavior - * without making actual HTTP calls. + * Unit tests for {@link WebSearchTool}. + *

+ * Tests focus on the JSON parsing logic (formatGoogleResults, + * formatDuckDuckGoResults, formatWikipediaResults) which was refactored from + * hand-rolled string splitting to Jackson ObjectMapper. + *

+ * Tests that would make real HTTP calls are excluded — those belong in + * integration tests. */ class WebSearchToolTest { @@ -16,80 +24,428 @@ class WebSearchToolTest { @BeforeEach void setUp() { - webSearchTool = new WebSearchTool(new SafeHttpClient(10000)); + webSearchTool = new WebSearchTool(new SafeHttpClient(10000), new ObjectMapper()); } - @Test - void testSearchWeb_ValidQuery() { - // Note: Without API keys configured, this will use DuckDuckGo fallback - // In a real environment with API keys, this would return actual results - String result = webSearchTool.searchWeb("test query", 5); - assertNotNull(result); - // Result could be error message if no API configured, or actual results - } + // ==================== Google Results Parsing ==================== - @Test - void testSearchWeb_NullMaxResults() { - String result = webSearchTool.searchWeb("test query", null); - assertNotNull(result); - // Should default to 5 results - } + @Nested + class GoogleResultsParsing { - @Test - void testSearchWeb_ZeroMaxResults() { - String result = webSearchTool.searchWeb("test query", 0); - assertNotNull(result); - // Should default to at least 1 result - } + @Test + void formatGoogleResults_ValidResponse_ShouldExtractAllFields() { + String json = """ + { + "items": [ + { + "title": "Test Result 1", + "snippet": "This is the first result snippet", + "link": "https://example.com/1" + }, + { + "title": "Test Result 2", + "snippet": "This is the second result snippet", + "link": "https://example.com/2" + } + ] + } + """; - @Test - void testSearchWeb_MaxResultsCapping() { - String result = webSearchTool.searchWeb("test query", 100); - assertNotNull(result); - // Should cap at 10 results - } + String result = webSearchTool.formatGoogleResults(json, "test query"); - @Test - void testSearchWeb_EmptyQuery() { - String result = webSearchTool.searchWeb("", 5); - assertNotNull(result); - } + assertTrue(result.contains("Test Result 1")); + assertTrue(result.contains("This is the first result snippet")); + assertTrue(result.contains("https://example.com/1")); + assertTrue(result.contains("Test Result 2")); + assertTrue(result.contains("This is the second result snippet")); + assertTrue(result.contains("https://example.com/2")); + assertTrue(result.contains("Search results for 'test query'")); + } - @Test - void testSearchWikipedia_ValidQuery() { - String result = webSearchTool.searchWikipedia("Java programming language"); - assertNotNull(result); - // Should return Wikipedia content or error message - } + @Test + void formatGoogleResults_EmptyItems_ShouldReturnNoResults() { + String json = """ + { + "items": [] + } + """; - @Test - void testSearchWikipedia_EmptyQuery() { - String result = webSearchTool.searchWikipedia(""); - assertNotNull(result); - } + String result = webSearchTool.formatGoogleResults(json, "test"); - @Test - void testSearchWikipedia_NonExistentTopic() { - String result = webSearchTool.searchWikipedia("xyznonexistenttopic123456"); - assertNotNull(result); - // Should handle gracefully - } + assertTrue(result.contains("No results found")); + } + + @Test + void formatGoogleResults_NoItemsKey_ShouldReturnNoResults() { + String json = """ + { + "searchInformation": {"totalResults": "0"} + } + """; + + String result = webSearchTool.formatGoogleResults(json, "test"); + + assertTrue(result.contains("No results found")); + } + + @Test + void formatGoogleResults_SpecialCharsInTitle_ShouldHandleCorrectly() { + String json = """ + { + "items": [ + { + "title": "Test with \\"quotes\\" and special chars: <>&", + "snippet": "Snippet with \\n newlines", + "link": "https://example.com/path?q=test&lang=en" + } + ] + } + """; + + String result = webSearchTool.formatGoogleResults(json, "special"); + + assertTrue(result.contains("Test with")); + assertTrue(result.contains("quotes")); + assertFalse(result.contains("No results found")); + } + + @Test + void formatGoogleResults_MissingSnippet_ShouldReturnEmptyString() { + String json = """ + { + "items": [ + { + "title": "Title Only", + "link": "https://example.com" + } + ] + } + """; + + String result = webSearchTool.formatGoogleResults(json, "test"); + + assertTrue(result.contains("Title Only")); + assertTrue(result.contains("https://example.com")); + } + + @Test + void formatGoogleResults_MoreThan10Items_ShouldCapAt10() { + StringBuilder json = new StringBuilder("{\"items\":["); + for (int i = 0; i < 15; i++) { + if (i > 0) + json.append(","); + json.append(String.format( + "{\"title\":\"Result %d\",\"snippet\":\"Snippet %d\",\"link\":\"https://example.com/%d\"}", i, i, i)); + } + json.append("]}"); - @Test - void testSearchNews_ValidQuery() { - String result = webSearchTool.searchNews("technology", 5); - assertNotNull(result); + String result = webSearchTool.formatGoogleResults(json.toString(), "test"); + + // Should contain results 0-9 but not 10-14 + assertTrue(result.contains("Result 0")); + assertTrue(result.contains("Result 9")); + // Count numbered results + int count = 0; + for (int i = 1; i <= 15; i++) { + if (result.contains(i + ". Result")) + count++; + } + assertEquals(10, count); + } + + @Test + void formatGoogleResults_InvalidJson_ShouldReturnNoResults() { + String result = webSearchTool.formatGoogleResults("not valid json at all{{{", "test"); + + assertTrue(result.contains("No results found")); + } + + @Test + void formatGoogleResults_NullSnippetField_ShouldTreatAsEmpty() { + String json = """ + { + "items": [ + { + "title": "Title", + "snippet": null, + "link": "https://example.com" + } + ] + } + """; + + String result = webSearchTool.formatGoogleResults(json, "test"); + + assertTrue(result.contains("Title")); + assertFalse(result.contains("No results found")); + } } - @Test - void testSearchNews_NullMaxResults() { - String result = webSearchTool.searchNews("technology", null); - assertNotNull(result); + // ==================== DuckDuckGo Results Parsing ==================== + + @Nested + class DuckDuckGoResultsParsing { + + @Test + void formatDuckDuckGoResults_WithAbstract_ShouldExtractQuickAnswer() { + String json = """ + { + "Abstract": "Java is a high-level programming language.", + "AbstractURL": "https://en.wikipedia.org/wiki/Java", + "RelatedTopics": [] + } + """; + + String result = webSearchTool.formatDuckDuckGoResults(json, "java", 5); + + assertTrue(result.contains("Quick Answer:")); + assertTrue(result.contains("Java is a high-level programming language.")); + assertTrue(result.contains("https://en.wikipedia.org/wiki/Java")); + } + + @Test + void formatDuckDuckGoResults_WithRelatedTopics_ShouldExtractTopics() { + String json = """ + { + "Abstract": "", + "AbstractURL": "", + "RelatedTopics": [ + {"Text": "First related topic about Java"}, + {"Text": "Second related topic about Java"}, + {"Text": "Third related topic about Java"} + ] + } + """; + + String result = webSearchTool.formatDuckDuckGoResults(json, "java", 5); + + assertTrue(result.contains("1. First related topic")); + assertTrue(result.contains("2. Second related topic")); + assertTrue(result.contains("3. Third related topic")); + } + + @Test + void formatDuckDuckGoResults_RelatedTopicsCapped_ShouldRespectMaxResults() { + String json = """ + { + "Abstract": "", + "RelatedTopics": [ + {"Text": "Topic 1"}, + {"Text": "Topic 2"}, + {"Text": "Topic 3"}, + {"Text": "Topic 4"}, + {"Text": "Topic 5"} + ] + } + """; + + String result = webSearchTool.formatDuckDuckGoResults(json, "test", 2); + + assertTrue(result.contains("1. Topic 1")); + assertTrue(result.contains("2. Topic 2")); + assertFalse(result.contains("3. Topic 3")); + } + + @Test + void formatDuckDuckGoResults_EmptyResponse_ShouldReturnNoInstantResults() { + String json = """ + { + "Abstract": "", + "AbstractURL": "", + "RelatedTopics": [] + } + """; + + String result = webSearchTool.formatDuckDuckGoResults(json, "xyznoexist", 5); + + assertTrue(result.contains("No instant results found")); + } + + @Test + void formatDuckDuckGoResults_BothAbstractAndTopics_ShouldIncludeBoth() { + String json = """ + { + "Abstract": "Quick answer about testing.", + "AbstractURL": "https://example.com", + "RelatedTopics": [ + {"Text": "Related topic 1"} + ] + } + """; + + String result = webSearchTool.formatDuckDuckGoResults(json, "testing", 5); + + assertTrue(result.contains("Quick Answer:")); + assertTrue(result.contains("Quick answer about testing.")); + assertTrue(result.contains("1. Related topic 1")); + } + + @Test + void formatDuckDuckGoResults_InvalidJson_ShouldReturnParseError() { + String result = webSearchTool.formatDuckDuckGoResults("{bad json!!!", "test", 5); + + assertTrue(result.contains("could not parse results")); + } + + @Test + void formatDuckDuckGoResults_TopicWithEmptyText_ShouldSkip() { + String json = """ + { + "Abstract": "", + "RelatedTopics": [ + {"Text": ""}, + {"Text": "Valid topic"} + ] + } + """; + + String result = webSearchTool.formatDuckDuckGoResults(json, "test", 5); + + assertTrue(result.contains("1. Valid topic")); + // Empty text should be skipped, not numbered + assertFalse(result.contains("2.")); + } + + @Test + void formatDuckDuckGoResults_AbstractOnlyNoTopics_ShouldNotShowNoResults() { + String json = """ + { + "Abstract": "A quick answer.", + "AbstractURL": "https://example.com", + "RelatedTopics": [] + } + """; + + String result = webSearchTool.formatDuckDuckGoResults(json, "test", 5); + + assertTrue(result.contains("Quick Answer:")); + assertFalse(result.contains("No instant results found")); + } } - @Test - void testSearchNews_EmptyQuery() { - String result = webSearchTool.searchNews("", 5); - assertNotNull(result); + // ==================== Wikipedia Results Parsing ==================== + + @Nested + class WikipediaResultsParsing { + + @Test + void formatWikipediaResults_ValidResponse_ShouldExtractArticles() { + String json = """ + { + "query": { + "search": [ + { + "title": "Java (programming language)", + "snippet": "Java is a high-level programming language" + }, + { + "title": "JavaScript", + "snippet": "JavaScript is a scripting language" + } + ] + } + } + """; + + String result = webSearchTool.formatWikipediaResults(json, "java"); + + assertTrue(result.contains("Wikipedia results for 'java'")); + assertTrue(result.contains("1. Java (programming language)")); + assertTrue(result.contains("2. JavaScript")); + // HTML tags should be stripped from snippets + assertFalse(result.contains(" 0) + json.append(","); + json.append(String.format("{\"title\":\"Article %d\",\"snippet\":\"Snippet %d\"}", i, i)); + } + json.append("]}}"); + + String result = webSearchTool.formatWikipediaResults(json.toString(), "test"); + + assertTrue(result.contains("1. Article 0")); + assertTrue(result.contains("2. Article 1")); + assertTrue(result.contains("3. Article 2")); + assertFalse(result.contains("4. Article 3")); + } + + @Test + void formatWikipediaResults_InvalidJson_ShouldReturnParseError() { + String result = webSearchTool.formatWikipediaResults("{bad", "test"); + + assertTrue(result.contains("could not parse results")); + } + + @Test + void formatWikipediaResults_HtmlInSnippet_ShouldBeStripped() { + String json = """ + { + "query": { + "search": [ + { + "title": "Test Article", + "snippet": "This has bold and italic text" + } + ] + } + } + """; + + String result = webSearchTool.formatWikipediaResults(json, "test"); + + assertTrue(result.contains("This has bold and italic text")); + assertFalse(result.contains("")); + assertFalse(result.contains("")); + } + + @Test + void formatWikipediaResults_MissingSearchNode_ShouldReturnNoArticles() { + String json = """ + { + "query": { + "searchinfo": {"totalhits": 0} + } + } + """; + + String result = webSearchTool.formatWikipediaResults(json, "test"); + + assertTrue(result.contains("No Wikipedia articles found")); + } } } From 1d7576ee9b53bbf26607b20f6e32e2c0c280af46 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 10:45:15 +0200 Subject: [PATCH 019/124] test(coverage): fix TestMemoryFactory MemoryKey stubs, rewrite ToolCacheServiceTest, add AgentSetupServiceTest (139 new tests) --- .../labs/eddi/engine/TestMemoryFactory.java | 150 +++++ .../engine/setup/AgentSetupServiceTest.java | 531 ++++++++++++++++++ .../llm/tools/ToolCacheServiceTest.java | 248 ++++++++ 3 files changed, 929 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/engine/TestMemoryFactory.java create mode 100644 src/test/java/ai/labs/eddi/engine/setup/AgentSetupServiceTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/llm/tools/ToolCacheServiceTest.java diff --git a/src/test/java/ai/labs/eddi/engine/TestMemoryFactory.java b/src/test/java/ai/labs/eddi/engine/TestMemoryFactory.java new file mode 100644 index 000000000..c5a94d871 --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/TestMemoryFactory.java @@ -0,0 +1,150 @@ +package ai.labs.eddi.engine; + +import ai.labs.eddi.engine.memory.IConversationMemory; +import ai.labs.eddi.engine.memory.IConversationMemory.IConversationStepStack; +import ai.labs.eddi.engine.memory.IConversationMemory.IWritableConversationStep; +import ai.labs.eddi.engine.memory.MemoryKey; +import ai.labs.eddi.engine.memory.model.ConversationOutput; +import ai.labs.eddi.engine.memory.model.ConversationProperties; +import ai.labs.eddi.engine.memory.model.Data; + +import java.util.ArrayList; +import java.util.List; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.lenient; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +/** + * Shared utility for building pre-populated {@link IConversationMemory} mocks. + *

+ * Most {@code ILifecycleTask} tests need a realistic memory mock with a + * writable step, conversation properties, previous steps stack, and + * conversation outputs. This factory builds one in 1-2 lines. + * + * 

{@code
+ * var ctx = TestMemoryFactory.create();
+ * myTask.execute(ctx.memory(), component);
+ * }
+ */ +public final class TestMemoryFactory { + + private TestMemoryFactory() { + } + + /** + * A fully-wired memory mock context. Access individual pieces via record + * accessors. + */ + public record MemoryContext( + IConversationMemory memory, + IWritableConversationStep currentStep, + IConversationStepStack previousSteps, + ConversationProperties conversationProperties, + List conversationOutputs) { + } + + /** + * Create a default memory context with empty current step and no previous + * steps. + */ + public static MemoryContext create() { + return create("conv-test", "agent-test", 1, "user-test"); + } + + /** + * Create a memory context with specified identifiers. + */ + public static MemoryContext create(String conversationId, String agentId, int agentVersion, String userId) { + IConversationMemory memory = mock(IConversationMemory.class); + IWritableConversationStep currentStep = mock(IWritableConversationStep.class); + IConversationStepStack previousSteps = mock(IConversationStepStack.class); + ConversationProperties props = new ConversationProperties(memory); + List outputs = new ArrayList<>(); + outputs.add(new ConversationOutput()); // current step output + + lenient().when(memory.getCurrentStep()).thenReturn(currentStep); + lenient().when(memory.getPreviousSteps()).thenReturn(previousSteps); + lenient().when(memory.getConversationProperties()).thenReturn(props); + lenient().when(memory.getConversationOutputs()).thenReturn(outputs); + lenient().when(memory.getConversationId()).thenReturn(conversationId); + lenient().when(memory.getAgentId()).thenReturn(agentId); + lenient().when(memory.getAgentVersion()).thenReturn(agentVersion); + lenient().when(memory.getUserId()).thenReturn(userId); + lenient().when(previousSteps.size()).thenReturn(0); + + // Default: currentStep returns null for all data queries (no data stored) + // Stub BOTH the String and MemoryKey overloads — tasks use MemoryKey typed API + lenient().when(currentStep.getLatestData(anyString())).thenReturn(null); + lenient().when(currentStep.getLatestData(any(MemoryKey.class))).thenReturn(null); + lenient().when(currentStep.getData(anyString())).thenReturn(null); + lenient().when(currentStep.getData(any(MemoryKey.class))).thenReturn(null); + lenient().when(currentStep.get(any(MemoryKey.class))).thenReturn(null); + lenient().when(currentStep.getAllData(anyString())).thenReturn(List.of()); + lenient().when(currentStep.getConversationOutput()).thenReturn(outputs.getFirst()); + + return new MemoryContext(memory, currentStep, previousSteps, props, outputs); + } + + /** + * Create a memory context with user input pre-populated in the current step. + * Stubs both String and MemoryKey overloads for "input". + */ + public static MemoryContext createWithInput(String input) { + var ctx = create(); + Data inputData = new Data<>("input", input); + inputData.setPublic(true); + // Stub both overloads: getLatestData(String) and getLatestData(MemoryKey) + when(ctx.currentStep().getLatestData(eq("input"))).thenAnswer(inv -> inputData); + when(ctx.currentStep().getLatestData(any(MemoryKey.class))).thenAnswer(invocation -> { + MemoryKey key = invocation.getArgument(0); + if ("input".equals(key.key())) { + return inputData; + } + return null; + }); + return ctx; + } + + /** + * Create a memory context with actions pre-populated in the current step. Stubs + * both String and MemoryKey overloads for "actions". + */ + public static MemoryContext createWithActions(List actions) { + var ctx = create(); + Data> actionsData = new Data<>("actions", actions); + actionsData.setPublic(true); + when(ctx.currentStep().getLatestData(eq("actions"))).thenAnswer(inv -> actionsData); + when(ctx.currentStep().getLatestData(any(MemoryKey.class))).thenAnswer(invocation -> { + MemoryKey key = invocation.getArgument(0); + if ("actions".equals(key.key())) { + return actionsData; + } + return null; + }); + return ctx; + } + + /** + * Create a memory context with parsed expressions in the current step. + */ + public static MemoryContext createWithExpressions(String expressions) { + var ctx = create(); + when(ctx.currentStep().getLatestData(eq("expressions:parsed"))) + .thenReturn(new Data<>("expressions:parsed", expressions)); + return ctx; + } + + /** + * Add a previous step with actions to the memory context. + */ + public static void addPreviousStepWithActions(MemoryContext ctx, List actions) { + IConversationMemory.IConversationStep prevStep = mock(IConversationMemory.IConversationStep.class); + when(prevStep.getLatestData(eq("actions"))).thenReturn(new Data<>("actions", actions)); + when(ctx.previousSteps().size()).thenReturn(1); + when(ctx.previousSteps().get(eq(0))).thenReturn(prevStep); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/setup/AgentSetupServiceTest.java b/src/test/java/ai/labs/eddi/engine/setup/AgentSetupServiceTest.java new file mode 100644 index 000000000..afce68fd5 --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/setup/AgentSetupServiceTest.java @@ -0,0 +1,531 @@ +package ai.labs.eddi.engine.setup; + +import ai.labs.eddi.configs.mcpcalls.model.McpCallsConfiguration; +import ai.labs.eddi.configs.output.model.OutputConfigurationSet; +import ai.labs.eddi.configs.parser.model.ParserConfiguration; +import ai.labs.eddi.configs.rules.model.RuleSetConfiguration; +import ai.labs.eddi.configs.workflows.model.WorkflowConfiguration; +import ai.labs.eddi.engine.model.Deployment; +import ai.labs.eddi.modules.llm.model.LlmConfiguration; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.NullAndEmptySource; +import org.junit.jupiter.params.provider.ValueSource; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.mock; + +/** + * Tests for {@link AgentSetupService} — pure logic, config builders, and static + * utilities. Does NOT test the full setupAgent/createApiAgent flow (those + * require REST stores). + */ +@DisplayName("AgentSetupService") +class AgentSetupServiceTest { + + private AgentSetupService service; + + @BeforeEach + void setUp() { + service = new AgentSetupService( + mock(ai.labs.eddi.engine.runtime.client.factory.IRestInterfaceFactory.class), + mock(ai.labs.eddi.engine.api.IRestAgentAdministration.class), + mock(ai.labs.eddi.secrets.ISecretProvider.class), + "http://localhost:11434"); + } + + // ==================== Static Utility Methods ==================== + + @Nested + @DisplayName("extractIdFromLocation") + class ExtractIdTests { + + @Test + @DisplayName("extracts ID from standard location path") + void standardPath() { + assertEquals("abc123", AgentSetupService.extractIdFromLocation( + "/configstore/parsers/abc123?version=1")); + } + + @Test + @DisplayName("extracts ID without query params") + void noQueryParams() { + assertEquals("def456", AgentSetupService.extractIdFromLocation( + "/configstore/agents/def456")); + } + + @Test + @DisplayName("returns null for null input") + void nullInput() { + assertNull(AgentSetupService.extractIdFromLocation(null)); + } + + @Test + @DisplayName("returns null for blank input") + void blankInput() { + assertNull(AgentSetupService.extractIdFromLocation(" ")); + } + + @Test + @DisplayName("handles trailing slash") + void trailingSlash() { + // path ends at last slash with nothing after + assertNull(AgentSetupService.extractIdFromLocation("/path/")); + } + } + + @Nested + @DisplayName("extractVersionFromLocation") + class ExtractVersionTests { + + @Test + @DisplayName("extracts version from query string") + void standardVersion() { + assertEquals(3, AgentSetupService.extractVersionFromLocation( + "/parsers/abc?version=3")); + } + + @Test + @DisplayName("defaults to 1 when no version param") + void noVersion() { + assertEquals(1, AgentSetupService.extractVersionFromLocation( + "/parsers/abc")); + } + + @Test + @DisplayName("defaults to 1 for null location") + void nullLocation() { + assertEquals(1, AgentSetupService.extractVersionFromLocation(null)); + } + + @Test + @DisplayName("handles version with additional params") + void multipleParams() { + assertEquals(5, AgentSetupService.extractVersionFromLocation( + "/parsers/abc?version=5&other=foo")); + } + + @Test + @DisplayName("defaults to 1 for malformed version") + void malformedVersion() { + assertEquals(1, AgentSetupService.extractVersionFromLocation( + "/parsers/abc?version=notanumber")); + } + } + + @Nested + @DisplayName("isLocalLlmProvider") + class LocalLlmProviderTests { + + @ParameterizedTest + @ValueSource(strings = {"ollama", "jlama", "bedrock", "oracle-genai", + "OLLAMA", "Jlama", "BEDROCK", "Oracle-GenAI"}) + @DisplayName("returns true for local/keyless providers") + void localProviders(String provider) { + assertTrue(AgentSetupService.isLocalLlmProvider(provider)); + } + + @ParameterizedTest + @ValueSource(strings = {"openai", "anthropic", "gemini", "mistral", "azure-openai"}) + @DisplayName("returns false for cloud providers requiring API key") + void cloudProviders(String provider) { + assertFalse(AgentSetupService.isLocalLlmProvider(provider)); + } + + @ParameterizedTest + @NullAndEmptySource + @DisplayName("returns false for null/empty") + void nullEmpty(String provider) { + assertFalse(AgentSetupService.isLocalLlmProvider(provider)); + } + } + + @Nested + @DisplayName("supportsResponseFormat") + class ResponseFormatTests { + + @ParameterizedTest + @ValueSource(strings = {"openai", "mistral", "azure-openai"}) + @DisplayName("returns true for supported providers") + void supported(String modelType) { + assertTrue(AgentSetupService.supportsResponseFormat(modelType)); + } + + @ParameterizedTest + @ValueSource(strings = {"anthropic", "gemini", "ollama", "bedrock"}) + @DisplayName("returns false for unsupported providers") + void unsupported(String modelType) { + assertFalse(AgentSetupService.supportsResponseFormat(modelType)); + } + } + + @Nested + @DisplayName("parseEnvironment") + class ParseEnvironmentTests { + + @Test + @DisplayName("returns production for null input") + void nullInput() { + assertEquals(Deployment.Environment.production, + AgentSetupService.parseEnvironment(null)); + } + + @Test + @DisplayName("returns production for blank input") + void blankInput() { + assertEquals(Deployment.Environment.production, + AgentSetupService.parseEnvironment("")); + } + + @Test + @DisplayName("parses 'production' correctly") + void production() { + assertEquals(Deployment.Environment.production, + AgentSetupService.parseEnvironment("production")); + } + + @Test + @DisplayName("parses 'test' correctly") + void testEnv() { + assertEquals(Deployment.Environment.test, + AgentSetupService.parseEnvironment("test")); + } + + @Test + @DisplayName("returns production for invalid environment") + void invalidEnvironment() { + assertEquals(Deployment.Environment.production, + AgentSetupService.parseEnvironment("invalid_env")); + } + } + + @Nested + @DisplayName("resolveParams") + class ResolveParamsTests { + + @Test + @DisplayName("defaults provider to 'anthropic' when null") + void defaultProvider() { + var params = service.resolveParams(null, null, null, null); + assertEquals("anthropic", params.providerType()); + } + + @Test + @DisplayName("defaults model to 'claude-sonnet-4-6' when null") + void defaultModel() { + var params = service.resolveParams(null, null, null, null); + assertEquals("claude-sonnet-4-6", params.modelId()); + } + + @Test + @DisplayName("defaults deploy to true when null") + void defaultDeploy() { + var params = service.resolveParams(null, null, null, null); + assertTrue(params.shouldDeploy()); + } + + @Test + @DisplayName("respects explicit deploy=false") + void deployFalse() { + var params = service.resolveParams("openai", "gpt-4", false, null); + assertFalse(params.shouldDeploy()); + } + + @Test + @DisplayName("normalizes provider to lowercase") + void providerNormalized() { + var params = service.resolveParams("OpenAI", "gpt-4", null, null); + assertEquals("openai", params.providerType()); + } + } + + // ==================== Config Builders ==================== + + @Nested + @DisplayName("Config Builders") + class ConfigBuilderTests { + + @Test + @DisplayName("createParserConfig returns valid parser configuration") + void parserConfig() { + ParserConfiguration config = service.createParserConfig(); + assertNotNull(config); + assertNotNull(config.getExtensions()); + assertTrue(config.getExtensions().containsKey("dictionaries")); + assertTrue(config.getExtensions().containsKey("corrections")); + } + + @Test + @DisplayName("createBehaviorConfig creates catch-all rule with send_message action") + void behaviorConfig() { + RuleSetConfiguration config = service.createBehaviorConfig(); + assertNotNull(config); + assertTrue(config.getExpressionsAsActions()); + assertFalse(config.getBehaviorGroups().isEmpty()); + var firstRule = config.getBehaviorGroups().getFirst().getRules().getFirst(); + assertEquals("Send Message to LLM", firstRule.getName()); + assertTrue(firstRule.getActions().contains("send_message")); + } + + @Test + @DisplayName("createMcpCallsConfig sets URL and defaults") + void mcpCallsConfig() { + McpCallsConfiguration config = service.createMcpCallsConfig("http://mcp.local:7070"); + assertEquals("http://mcp.local:7070", config.getMcpServerUrl()); + assertEquals("http", config.getTransport()); + assertEquals(30000L, config.getTimeoutMs()); + } + + @Test + @DisplayName("createOutputConfig creates CONVERSATION_START output set") + void outputConfig() { + OutputConfigurationSet config = service.createOutputConfig("Hello, I'm your assistant!"); + assertNotNull(config); + assertFalse(config.getOutputSet().isEmpty()); + assertEquals("CONVERSATION_START", config.getOutputSet().getFirst().getAction()); + } + + @Test + @DisplayName("createWorkflowConfig builds correct step order") + void workflowConfig() { + WorkflowConfiguration config = service.createWorkflowConfig( + "/parsers/p1", "/rules/r1", + List.of("/httpcalls/h1", "/httpcalls/h2"), + List.of("/mcpcalls/m1"), + "/llm/l1", "/output/o1"); + var steps = config.getWorkflowSteps(); + // Parser + behavior + 2 httpcalls + 1 mcpcall + langchain + output = 7 + assertEquals(7, steps.size()); + assertTrue(steps.get(0).getType().toString().contains("parser")); + assertTrue(steps.get(1).getType().toString().contains("behavior")); + assertTrue(steps.get(2).getType().toString().contains("httpcalls")); + assertTrue(steps.get(3).getType().toString().contains("httpcalls")); + assertTrue(steps.get(4).getType().toString().contains("mcpcalls")); + assertTrue(steps.get(5).getType().toString().contains("llm")); + assertTrue(steps.get(6).getType().toString().contains("output")); + } + + @Test + @DisplayName("createWorkflowConfig omits optional steps when null") + void workflowConfigMinimal() { + WorkflowConfiguration config = service.createWorkflowConfig( + "/parsers/p1", "/rules/r1", + null, null, "/llm/l1", null); + // Parser + behavior + langchain = 3 + assertEquals(3, config.getWorkflowSteps().size()); + } + } + + // ==================== buildPromptResponseJson ==================== + + @Nested + @DisplayName("buildPromptResponseJson") + class PromptResponseJsonTests { + + @Test + @DisplayName("returns null when both features disabled") + void bothDisabled() { + assertNull(AgentSetupService.buildPromptResponseJson(false, false)); + } + + @Test + @DisplayName("includes quickReplies schema when enabled") + void quickRepliesEnabled() { + String json = AgentSetupService.buildPromptResponseJson(true, false); + assertNotNull(json); + assertTrue(json.contains("quickReplies")); + assertTrue(json.contains("htmlResponseText")); + assertFalse(json.contains("sentiment")); + } + + @Test + @DisplayName("includes sentiment schema when enabled") + void sentimentEnabled() { + String json = AgentSetupService.buildPromptResponseJson(false, true); + assertNotNull(json); + assertTrue(json.contains("sentiment")); + assertTrue(json.contains("urgency")); + assertTrue(json.contains("htmlResponseText")); + assertFalse(json.contains("quickReplies")); + } + + @Test + @DisplayName("includes both schemas when both enabled") + void bothEnabled() { + String json = AgentSetupService.buildPromptResponseJson(true, true); + assertNotNull(json); + assertTrue(json.contains("quickReplies")); + assertTrue(json.contains("sentiment")); + } + } + + // ==================== createLlmConfig ==================== + + @Nested + @DisplayName("createLlmConfig") + class LlmConfigTests { + + @Test + @DisplayName("creates config with basic parameters") + void basicConfig() { + LlmConfiguration config = service.createLlmConfig( + "openai", "gpt-4", "sk-key", "You are helpful", false, null, null, null, false, false, null); + assertNotNull(config); + assertFalse(config.tasks().isEmpty()); + var task = config.tasks().getFirst(); + assertEquals("openai", task.getType()); + assertEquals(List.of("send_message"), task.getActions()); + assertTrue(task.getParameters().get("systemMessage").contains("You are helpful")); + } + + @Test + @DisplayName("sets model name for openai provider") + void openaiModel() { + LlmConfiguration config = service.createLlmConfig( + "openai", "gpt-4o", "sk-key", "prompt", false, null, null, null, false, false, null); + assertEquals("gpt-4o", config.tasks().getFirst().getParameters().get("modelName")); + } + + @Test + @DisplayName("sets model ID for ollama with correct baseUrl") + void ollamaConfig() { + LlmConfiguration config = service.createLlmConfig( + "ollama", "llama3", null, "prompt", false, null, null, null, false, false, null); + var params = config.tasks().getFirst().getParameters(); + assertEquals("llama3", params.get("model")); + assertEquals("http://localhost:11434", params.get("baseUrl")); + } + + @Test + @DisplayName("ollama uses custom baseUrl when provided") + void ollamaCustomBaseUrl() { + LlmConfiguration config = service.createLlmConfig( + "ollama", "llama3", null, "prompt", false, null, "http://my-ollama:11434", null, false, false, null); + assertEquals("http://my-ollama:11434", config.tasks().getFirst().getParameters().get("baseUrl")); + } + + @Test + @DisplayName("enables built-in tools when requested") + void toolsEnabled() { + LlmConfiguration config = service.createLlmConfig( + "openai", "gpt-4", "key", "prompt", true, "calculator,websearch", null, null, false, false, null); + var task = config.tasks().getFirst(); + assertTrue(task.getEnableBuiltInTools()); + assertEquals(List.of("calculator", "websearch"), task.getBuiltInToolsWhitelist()); + } + + @Test + @DisplayName("sets tool URIs when provided") + void toolUris() { + LlmConfiguration config = service.createLlmConfig( + "openai", "gpt-4", "key", "prompt", false, null, null, null, false, false, + List.of("/httpcalls/h1", "/httpcalls/h2")); + var task = config.tasks().getFirst(); + assertEquals(2, task.getTools().size()); + } + + @Test + @DisplayName("adds postResponse when promptResponseJson is provided") + void promptResponseJson() { + String json = AgentSetupService.buildPromptResponseJson(true, false); + LlmConfiguration config = service.createLlmConfig( + "openai", "gpt-4", "key", "prompt", false, null, null, json, true, false, null); + var task = config.tasks().getFirst(); + assertNotNull(task.getPostResponse()); + assertEquals("aiOutput", task.getResponseObjectName()); + } + + @ParameterizedTest + @CsvSource({"bedrock, modelId", "azure-openai, deploymentName", "jlama, modelName"}) + @DisplayName("uses correct parameter key per provider") + void providerSpecificParamKeys(String provider, String expectedKey) { + LlmConfiguration config = service.createLlmConfig( + provider, "test-model", "key", "prompt", false, null, null, null, false, false, null); + assertTrue(config.tasks().getFirst().getParameters().containsKey(expectedKey)); + } + } + + // ==================== buildPostResponse ==================== + + @Nested + @DisplayName("buildPostResponse") + class PostResponseTests { + + @Test + @DisplayName("always includes output building instruction") + void alwaysHasOutput() { + var response = service.buildPostResponse(false, false); + assertNotNull(response.getOutputBuildInstructions()); + assertFalse(response.getOutputBuildInstructions().isEmpty()); + } + + @Test + @DisplayName("includes quickReply instructions when enabled") + void quickRepliesEnabled() { + var response = service.buildPostResponse(true, false); + assertNotNull(response.getQrBuildInstructions()); + assertFalse(response.getQrBuildInstructions().isEmpty()); + } + + @Test + @DisplayName("no quickReply instructions when disabled") + void quickRepliesDisabled() { + var response = service.buildPostResponse(false, false); + assertNull(response.getQrBuildInstructions()); + } + } + + // ==================== Validation ==================== + + @Nested + @DisplayName("setupAgent validation") + class ValidationTests { + + @Test + @DisplayName("throws when agent name is null") + void nullAgentName() { + var request = new SetupAgentRequest(null, "prompt", "openai", "gpt-4", + "key", null, null, null, null, null, null, null, null, null); + assertThrows(AgentSetupService.AgentSetupException.class, + () -> service.setupAgent(request)); + } + + @Test + @DisplayName("throws when system prompt is blank") + void blankPrompt() { + var request = new SetupAgentRequest("Test Agent", "", "openai", "gpt-4", + "key", null, null, null, null, null, null, null, null, null); + assertThrows(AgentSetupService.AgentSetupException.class, + () -> service.setupAgent(request)); + } + + @Test + @DisplayName("throws when cloud provider has no API key") + void cloudProviderNoApiKey() { + var request = new SetupAgentRequest("Test Agent", "prompt", "openai", "gpt-4", + null, null, null, null, null, null, null, null, null, null); + assertThrows(AgentSetupService.AgentSetupException.class, + () -> service.setupAgent(request)); + } + + @Test + @DisplayName("does not throw for local provider without API key") + void localProviderNoApiKey() { + // ollama doesn't need an API key, but will fail at REST store call + // — the validation itself should pass + var request = new SetupAgentRequest("Test Agent", "prompt", "ollama", "llama3", + null, null, null, null, null, null, null, null, null, null); + // Will throw AgentSetupException at the REST call level, not validation + var ex = assertThrows(AgentSetupService.AgentSetupException.class, + () -> service.setupAgent(request)); + // Should NOT be "API key is required" + assertFalse(ex.getMessage().contains("API key is required")); + } + } +} diff --git a/src/test/java/ai/labs/eddi/modules/llm/tools/ToolCacheServiceTest.java b/src/test/java/ai/labs/eddi/modules/llm/tools/ToolCacheServiceTest.java new file mode 100644 index 000000000..aa8d4839b --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/llm/tools/ToolCacheServiceTest.java @@ -0,0 +1,248 @@ +package ai.labs.eddi.modules.llm.tools; + +import ai.labs.eddi.engine.caching.ICache; +import ai.labs.eddi.engine.caching.ICacheFactory; +import io.micrometer.core.instrument.simple.SimpleMeterRegistry; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.lang.reflect.Field; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; + +/** + * Tests for {@link ToolCacheService} — Caffeine-backed tool result cache with + * smart TTL. + */ +@DisplayName("ToolCacheService") +class ToolCacheServiceTest { + + private ToolCacheService service; + private ICache cache; // raw type to avoid CachedResult (private inner class) generics issues + + @SuppressWarnings("unchecked") + @BeforeEach + void setUp() throws Exception { + cache = mock(ICache.class); + when(cache.size()).thenReturn(0); + + ICacheFactory cacheFactory = mock(ICacheFactory.class); + when(cacheFactory.getCache(eq("tool-results"))).thenReturn(cache); + + service = new ToolCacheService(); + + // Inject fields via reflection since they're CDI-injected + setField(service, "cacheFactory", cacheFactory); + setField(service, "meterRegistry", new SimpleMeterRegistry()); + + // Trigger @PostConstruct + service.init(); + } + + // ==================== Smart TTL ==================== + + @Nested + @DisplayName("Smart TTL") + class SmartTTLTests { + + @Test + @DisplayName("weather tool gets 300s TTL") + void weatherTTL() { + assertEquals(300L, service.getConfiguredTTL("weather")); + } + + @Test + @DisplayName("calculator tool gets 604800s (7 day) TTL") + void calculatorTTL() { + assertEquals(604800L, service.getConfiguredTTL("calculator")); + } + + @Test + @DisplayName("datetime tool gets 60s TTL") + void datetimeTTL() { + assertEquals(60L, service.getConfiguredTTL("datetime")); + } + + @Test + @DisplayName("websearch tool gets 1800s TTL") + void websearchTTL() { + assertEquals(1800L, service.getConfiguredTTL("websearch")); + } + + @Test + @DisplayName("pdfreader tool gets 86400s TTL") + void pdfreaderTTL() { + assertEquals(86400L, service.getConfiguredTTL("pdfreader")); + } + + @Test + @DisplayName("unknown tool gets default 300s TTL") + void unknownToolDefaultTTL() { + assertEquals(300L, service.getConfiguredTTL("unknownCustomTool")); + } + + @Test + @DisplayName("partial match: 'MyWebSearchTool' matches 'websearch' entry") + void partialMatch() { + assertEquals(1800L, service.getConfiguredTTL("MyWebSearchTool")); + } + + @Test + @DisplayName("case insensitive matching") + void caseInsensitive() { + assertEquals(300L, service.getConfiguredTTL("WEATHER")); + } + } + + // ==================== get/put ==================== + + @Nested + @DisplayName("get/put") + class GetPutTests { + + @Test + @DisplayName("get returns null on cache miss") + void get_cacheMiss_returnsNull() { + when(cache.get(anyString())).thenReturn(null); + + String result = service.get("calculator", "2+2"); + + assertNull(result); + } + + @SuppressWarnings("unchecked") + @Test + @DisplayName("put stores result in cache") + void put_storesInCache() { + service.put("calculator", "2+2", "4"); + + verify(cache).put(eq("calculator:2+2"), any(), anyLong(), any()); + } + + @SuppressWarnings("unchecked") + @Test + @DisplayName("put with custom TTL uses provided values") + void put_customTTL() { + service.put("myTool", "args", "result", 120, java.util.concurrent.TimeUnit.SECONDS); + + verify(cache).put(eq("myTool:args"), any(), eq(120L), any()); + } + } + + // ==================== Cache Key ==================== + + @Nested + @DisplayName("Cache Key Building") + class CacheKeyTests { + + @SuppressWarnings("unchecked") + @Test + @DisplayName("short arguments use readable key format") + void shortArgs_readableKey() { + service.put("calculator", "2+2", "4"); + + verify(cache).put(eq("calculator:2+2"), any(), anyLong(), any()); + } + + @SuppressWarnings("unchecked") + @Test + @DisplayName("long arguments (>2048 chars) use SHA-256 hash key") + void longArgs_sha256Key() { + String longArgs = "x".repeat(3000); + service.put("calculator", longArgs, "result"); + + verify(cache).put(argThat(key -> { + String k = (String) key; + return k.startsWith("calculator:") && k.length() < 200; + }), any(), anyLong(), any()); + } + } + + // ==================== Statistics ==================== + + @Nested + @DisplayName("Statistics") + class StatsTests { + + @Test + @DisplayName("initial stats are all zeros") + void initialStats() { + var stats = service.getStats(); + + assertEquals(0, stats.hits); + assertEquals(0, stats.misses); + assertEquals(0.0, stats.hitRate); + } + + @Test + @DisplayName("cache misses are tracked") + void cacheMissTracked() { + when(cache.get(anyString())).thenReturn(null); + + service.get("tool1", "args"); + + var stats = service.getStats(); + assertEquals(1, stats.misses); + } + + @Test + @DisplayName("getToolStats returns null for unknown tool") + void unknownToolStats() { + assertNull(service.getToolStats("nonexistent")); + } + + @Test + @DisplayName("CacheStats toString includes per-tool stats") + void cacheStatsToString() { + when(cache.get(anyString())).thenReturn(null); + service.get("myTool", "args"); + + var stats = service.getStats(); + String str = stats.toString(); + + assertTrue(str.contains("Cache Stats")); + assertTrue(str.contains("myTool")); + } + } + + // ==================== Invalidate/Clear ==================== + + @Nested + @DisplayName("Invalidate/Clear") + class InvalidateTests { + + @Test + @DisplayName("invalidate removes specific key from cache") + void invalidate_removesKey() { + service.invalidate("calculator", "2+2"); + + verify(cache).remove("calculator:2+2"); + } + + @Test + @DisplayName("clear resets cache and stats") + void clear_resetsAll() { + when(cache.get(anyString())).thenReturn(null); + service.get("tool", "args"); + + service.clear(); + + verify(cache).clear(); + var stats = service.getStats(); + assertEquals(0, stats.hits); + assertEquals(0, stats.misses); + } + } + + // ==================== Helpers ==================== + + private static void setField(Object target, String fieldName, Object value) throws Exception { + Field field = target.getClass().getDeclaredField(fieldName); + field.setAccessible(true); + field.set(target, value); + } +} From 15a03f0e5910ff277b58f49331b7b992575e8d43 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 11:44:34 +0200 Subject: [PATCH 020/124] test(coverage): add AuditHmacTest, LanguageUtilitiesTest, VaultSaltManagerTest (51 new tests) --- .../labs/eddi/engine/audit/AuditHmacTest.java | 201 ++++++++++++++++++ .../secrets/crypto/VaultSaltManagerTest.java | 146 +++++++++++++ .../eddi/utils/LanguageUtilitiesTest.java | 91 ++++++++ 3 files changed, 438 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/engine/audit/AuditHmacTest.java create mode 100644 src/test/java/ai/labs/eddi/secrets/crypto/VaultSaltManagerTest.java create mode 100644 src/test/java/ai/labs/eddi/utils/LanguageUtilitiesTest.java diff --git a/src/test/java/ai/labs/eddi/engine/audit/AuditHmacTest.java b/src/test/java/ai/labs/eddi/engine/audit/AuditHmacTest.java new file mode 100644 index 000000000..d32194c37 --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/audit/AuditHmacTest.java @@ -0,0 +1,201 @@ +package ai.labs.eddi.engine.audit; + +import ai.labs.eddi.engine.audit.model.AuditEntry; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.time.Instant; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Tests for {@link AuditHmac} — HMAC key derivation, signing, and verification. + */ +@DisplayName("AuditHmac") +class AuditHmacTest { + + private static byte[] hmacKey; + + @BeforeAll + static void deriveKey() { + hmacKey = AuditHmac.deriveHmacKey("test-master-key-12345"); + } + + private static AuditEntry createTestEntry() { + return new AuditEntry( + "entry-1", "conv-1", "agent-1", 1, "user-1", "production", + 0, "ai.labs.parser", "expressions", 0, 42L, + Map.of("userInput", "hello"), + Map.of("output", "world"), + null, null, + List.of("send_message"), 0.005, + Instant.parse("2026-01-01T00:00:00Z"), null, null); + } + + // ==================== Key Derivation ==================== + + @Nested + @DisplayName("deriveHmacKey") + class DeriveKeyTests { + + @Test + @DisplayName("produces 32-byte key (256 bits)") + void keyLength() { + assertEquals(32, hmacKey.length); + } + + @Test + @DisplayName("same master key produces same HMAC key (deterministic)") + void deterministic() { + byte[] key2 = AuditHmac.deriveHmacKey("test-master-key-12345"); + assertArrayEquals(hmacKey, key2); + } + + @Test + @DisplayName("different master keys produce different HMAC keys") + void differentKeys() { + byte[] key2 = AuditHmac.deriveHmacKey("different-master-key"); + assertFalse(java.util.Arrays.equals(hmacKey, key2)); + } + } + + // ==================== HMAC Computation ==================== + + @Nested + @DisplayName("computeHmac") + class ComputeHmacTests { + + @Test + @DisplayName("produces non-null hex string") + void producesHex() { + String hmac = AuditHmac.computeHmac(createTestEntry(), hmacKey); + assertNotNull(hmac); + assertFalse(hmac.isEmpty()); + // Hex string should be 64 chars (32 bytes) + assertEquals(64, hmac.length()); + } + + @Test + @DisplayName("same entry produces same HMAC (deterministic)") + void deterministic() { + AuditEntry entry = createTestEntry(); + String hmac1 = AuditHmac.computeHmac(entry, hmacKey); + String hmac2 = AuditHmac.computeHmac(entry, hmacKey); + assertEquals(hmac1, hmac2); + } + + @Test + @DisplayName("different entries produce different HMACs") + void differentEntries() { + AuditEntry entry1 = createTestEntry(); + AuditEntry entry2 = new AuditEntry( + "entry-2", "conv-2", "agent-1", 1, "user-1", "production", + 0, "ai.labs.parser", "expressions", 0, 42L, + Map.of("userInput", "different"), + Map.of("output", "world"), + null, null, + List.of("send_message"), 0.005, + Instant.parse("2026-01-01T00:00:00Z"), null, null); + assertNotEquals(AuditHmac.computeHmac(entry1, hmacKey), + AuditHmac.computeHmac(entry2, hmacKey)); + } + } + + // ==================== HMAC Verification ==================== + + @Nested + @DisplayName("verifyHmac") + class VerifyHmacTests { + + @Test + @DisplayName("verifies valid HMAC") + void validHmac() { + AuditEntry entry = createTestEntry(); + String hmac = AuditHmac.computeHmac(entry, hmacKey); + AuditEntry signed = entry.withHmac(hmac); + assertTrue(AuditHmac.verifyHmac(signed, hmacKey)); + } + + @Test + @DisplayName("rejects tampered entry") + void tamperedEntry() { + AuditEntry entry = createTestEntry(); + String hmac = AuditHmac.computeHmac(entry, hmacKey); + // Tamper with the entry by changing the environment + AuditEntry tampered = entry.withEnvironment("TAMPERED").withHmac(hmac); + assertFalse(AuditHmac.verifyHmac(tampered, hmacKey)); + } + + @Test + @DisplayName("rejects null HMAC") + void nullHmac() { + AuditEntry entry = createTestEntry(); + assertFalse(AuditHmac.verifyHmac(entry, hmacKey)); + } + + @Test + @DisplayName("rejects wrong key") + void wrongKey() { + AuditEntry entry = createTestEntry(); + String hmac = AuditHmac.computeHmac(entry, hmacKey); + AuditEntry signed = entry.withHmac(hmac); + + byte[] wrongKey = AuditHmac.deriveHmacKey("wrong-master-key"); + assertFalse(AuditHmac.verifyHmac(signed, wrongKey)); + } + } + + // ==================== Canonical String ==================== + + @Nested + @DisplayName("buildCanonicalString") + class CanonicalStringTests { + + @Test + @DisplayName("includes all fields") + void includesAllFields() { + String canonical = AuditHmac.buildCanonicalString(createTestEntry()); + assertTrue(canonical.contains("id=entry-1")); + assertTrue(canonical.contains("cid=conv-1")); + assertTrue(canonical.contains("bid=agent-1")); + assertTrue(canonical.contains("uid=user-1")); + assertTrue(canonical.contains("env=production")); + assertTrue(canonical.contains("tid=ai.labs.parser")); + assertTrue(canonical.contains("actions=send_message")); + } + + @Test + @DisplayName("handles null fields gracefully") + void nullFields() { + AuditEntry entry = new AuditEntry( + null, null, null, null, null, null, + 0, null, null, 0, 0L, + null, null, null, null, null, 0.0, + null, null, null); + String canonical = AuditHmac.buildCanonicalString(entry); + assertNotNull(canonical); + assertTrue(canonical.contains("id=")); + assertTrue(canonical.contains("cid=")); + } + + @Test + @DisplayName("maps are sorted for deterministic output") + void sortedMaps() { + AuditEntry entry1 = new AuditEntry( + "id", "c", "b", 1, "u", "e", + 0, "t", "tt", 0, 0L, + Map.of("z", "1", "a", "2"), + null, null, null, null, 0.0, + Instant.EPOCH, null, null); + String canonical = AuditHmac.buildCanonicalString(entry1); + // a should come before z in sorted output + int posA = canonical.indexOf("a=2"); + int posZ = canonical.indexOf("z=1"); + assertTrue(posA < posZ, "Map keys should be sorted alphabetically"); + } + } +} diff --git a/src/test/java/ai/labs/eddi/secrets/crypto/VaultSaltManagerTest.java b/src/test/java/ai/labs/eddi/secrets/crypto/VaultSaltManagerTest.java new file mode 100644 index 000000000..e90683a11 --- /dev/null +++ b/src/test/java/ai/labs/eddi/secrets/crypto/VaultSaltManagerTest.java @@ -0,0 +1,146 @@ +package ai.labs.eddi.secrets.crypto; + +import ai.labs.eddi.secrets.model.EncryptedDek; +import ai.labs.eddi.secrets.persistence.ISecretPersistence; +import ai.labs.eddi.secrets.persistence.PersistenceException; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.Base64; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +/** + * Tests for {@link VaultSaltManager} — salt lifecycle (load, generate, migrate, + * legacy fallback). + */ +@DisplayName("VaultSaltManager") +class VaultSaltManagerTest { + + private ISecretPersistence persistence; + private VaultSaltManager saltManager; + + @BeforeEach + void setUp() { + persistence = mock(ISecretPersistence.class); + saltManager = new VaultSaltManager(persistence); + } + + @Nested + @DisplayName("initialize") + class InitializeTests { + + @Test + @DisplayName("loads existing salt from persistence") + void loadsExistingSalt() { + byte[] existingSalt = new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; + when(persistence.getMetaValue(VaultSaltManager.SALT_META_KEY)) + .thenReturn(Base64.getEncoder().encodeToString(existingSalt)); + + saltManager.initialize(); + + assertArrayEquals(existingSalt, saltManager.getSalt()); + assertFalse(saltManager.isUsingLegacySalt()); + } + + @Test + @DisplayName("generates new salt for fresh deployment (no DEKs)") + void freshDeployment() { + when(persistence.getMetaValue(VaultSaltManager.SALT_META_KEY)).thenReturn(null); + when(persistence.listAllDeks()).thenReturn(List.of()); + + saltManager.initialize(); + + byte[] salt = saltManager.getSalt(); + assertEquals(16, salt.length); + assertFalse(saltManager.isUsingLegacySalt()); + verify(persistence).setMetaValue(eq(VaultSaltManager.SALT_META_KEY), anyString()); + } + + @Test + @DisplayName("uses legacy salt for upgrade scenario (DEKs exist, no salt)") + void upgradeLegacy() { + when(persistence.getMetaValue(VaultSaltManager.SALT_META_KEY)).thenReturn(null); + when(persistence.listAllDeks()).thenReturn(List.of(new EncryptedDek())); + + saltManager.initialize(); + + assertTrue(saltManager.isUsingLegacySalt()); + assertNotNull(saltManager.getSalt()); + } + + @Test + @DisplayName("falls back to legacy salt on persistence failure") + void persistenceFailure() { + when(persistence.getMetaValue(VaultSaltManager.SALT_META_KEY)) + .thenThrow(new PersistenceException("DB down")); + + saltManager.initialize(); + + assertTrue(saltManager.isUsingLegacySalt()); + assertNotNull(saltManager.getSalt()); + } + } + + @Nested + @DisplayName("getSalt") + class GetSaltTests { + + @Test + @DisplayName("throws if not initialized") + void throwsBeforeInit() { + assertThrows(IllegalStateException.class, () -> saltManager.getSalt()); + } + + @Test + @DisplayName("returns defensive copy") + void defensiveCopy() { + when(persistence.getMetaValue(VaultSaltManager.SALT_META_KEY)).thenReturn(null); + when(persistence.listAllDeks()).thenReturn(List.of()); + saltManager.initialize(); + + byte[] salt1 = saltManager.getSalt(); + byte[] salt2 = saltManager.getSalt(); + assertNotSame(salt1, salt2); + assertArrayEquals(salt1, salt2); + } + } + + @Nested + @DisplayName("migrateSalt") + class MigrateSaltTests { + + @Test + @DisplayName("updates salt and persists it") + void migratesSuccessfully() { + when(persistence.getMetaValue(VaultSaltManager.SALT_META_KEY)).thenReturn(null); + when(persistence.listAllDeks()).thenReturn(List.of(new EncryptedDek())); + saltManager.initialize(); + assertTrue(saltManager.isUsingLegacySalt()); + + byte[] newSalt = new byte[]{10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 13, 14, 15, 16}; + saltManager.migrateSalt(newSalt); + + assertArrayEquals(newSalt, saltManager.getSalt()); + assertFalse(saltManager.isUsingLegacySalt()); + verify(persistence).setMetaValue(eq(VaultSaltManager.SALT_META_KEY), anyString()); + } + + @Test + @DisplayName("rejects null salt") + void rejectsNull() { + assertThrows(IllegalArgumentException.class, () -> saltManager.migrateSalt(null)); + } + + @Test + @DisplayName("rejects salt shorter than 8 bytes") + void rejectsTooShort() { + assertThrows(IllegalArgumentException.class, + () -> saltManager.migrateSalt(new byte[]{1, 2, 3})); + } + } +} diff --git a/src/test/java/ai/labs/eddi/utils/LanguageUtilitiesTest.java b/src/test/java/ai/labs/eddi/utils/LanguageUtilitiesTest.java new file mode 100644 index 000000000..ca74e5065 --- /dev/null +++ b/src/test/java/ai/labs/eddi/utils/LanguageUtilitiesTest.java @@ -0,0 +1,91 @@ +package ai.labs.eddi.utils; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.NullAndEmptySource; +import org.junit.jupiter.params.provider.ValueSource; + +import java.util.Date; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Tests for {@link LanguageUtilities} — time expression parsing and ordinal + * number recognition. + */ +@DisplayName("LanguageUtilities") +class LanguageUtilitiesTest { + + @Nested + @DisplayName("isTimeExpression") + class TimeExpressionTests { + + @ParameterizedTest + @ValueSource(strings = {"12h10", "15h30", "08h00", "23h59"}) + @DisplayName("recognizes 'Xh' format with minutes") + void hourHMinuteFormat(String input) { + Date result = LanguageUtilities.isTimeExpression(input); + assertNotNull(result, "Should recognize " + input + " as time"); + } + + @ParameterizedTest + @ValueSource(strings = {"15h", "08h", "23h"}) + @DisplayName("recognizes 'Xh' format without minutes") + void hourHOnlyFormat(String input) { + Date result = LanguageUtilities.isTimeExpression(input); + assertNotNull(result, "Should recognize " + input + " as time"); + } + + @ParameterizedTest + @ValueSource(strings = {"19:50", "00:00", "23:59", "8:30"}) + @DisplayName("recognizes HH:MM format") + void colonFormat(String input) { + Date result = LanguageUtilities.isTimeExpression(input); + assertNotNull(result, "Should recognize " + input + " as time"); + } + + @ParameterizedTest + @ValueSource(strings = {"13:50:12", "00:00:00", "23:59:59"}) + @DisplayName("recognizes HH:MM:SS format") + void fullFormat(String input) { + Date result = LanguageUtilities.isTimeExpression(input); + assertNotNull(result, "Should recognize " + input + " as time"); + } + + @Test + @DisplayName("normalizes 24:00 to 00:00") + void normalize24() { + Date result = LanguageUtilities.isTimeExpression("24:00"); + assertNotNull(result); + } + + @ParameterizedTest + @ValueSource(strings = {"hello", "abc", "25:99", "not-a-time"}) + @DisplayName("returns null for non-time strings") + void nonTime(String input) { + assertNull(LanguageUtilities.isTimeExpression(input)); + } + } + + @Nested + @DisplayName("isOrdinalNumber") + class OrdinalNumberTests { + + @ParameterizedTest + @CsvSource({"1st, 1", "2nd, 2", "3rd, 3", "4th, 4", "21st, 21", "100th, 100"}) + @DisplayName("extracts numeric value from ordinals") + void validOrdinals(String input, String expected) { + assertEquals(expected, LanguageUtilities.isOrdinalNumber(input)); + } + + @ParameterizedTest + @ValueSource(strings = {"hello", "abc", "1", "12"}) + @DisplayName("returns null for non-ordinals") + void nonOrdinals(String input) { + assertNull(LanguageUtilities.isOrdinalNumber(input)); + } + } +} From 793a4055f4d3e1a52d4663731c3e71a10ed4f305 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 12:12:15 +0200 Subject: [PATCH 021/124] test(coverage): add LanguageModelBuildersTest for 6 LLM providers (11 new tests) --- .../builder/LanguageModelBuildersTest.java | 208 ++++++++++++++++++ 1 file changed, 208 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/modules/llm/impl/builder/LanguageModelBuildersTest.java diff --git a/src/test/java/ai/labs/eddi/modules/llm/impl/builder/LanguageModelBuildersTest.java b/src/test/java/ai/labs/eddi/modules/llm/impl/builder/LanguageModelBuildersTest.java new file mode 100644 index 000000000..83397528e --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/llm/impl/builder/LanguageModelBuildersTest.java @@ -0,0 +1,208 @@ +package ai.labs.eddi.modules.llm.impl.builder; + +import dev.langchain4j.model.chat.ChatModel; +import dev.langchain4j.model.chat.StreamingChatModel; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.HashMap; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Tests for LLM provider {@link ILanguageModelBuilder} implementations. + *

+ * These test that each builder produces a non-null ChatModel and + * StreamingChatModel from a parameter map, exercising all parameter branches. + * No actual API calls are made — the builders just configure client objects. + */ +@DisplayName("LanguageModelBuilders") +class LanguageModelBuildersTest { + + // ==================== OpenAI ==================== + + @Nested + @DisplayName("OpenAILanguageModelBuilder") + class OpenAITests { + + private final OpenAILanguageModelBuilder builder = new OpenAILanguageModelBuilder(); + + @Test + @DisplayName("builds ChatModel with all parameters") + void buildWithAllParams() { + Map params = new HashMap<>(); + params.put("apiKey", "sk-test"); + params.put("modelName", "gpt-4o"); + params.put("temperature", "0.7"); + params.put("timeout", "30000"); + params.put("logRequests", "true"); + params.put("logResponses", "false"); + params.put("responseFormat", "json"); + params.put("baseUrl", "https://api.openai.com/v1"); + + ChatModel model = builder.build(params); + assertNotNull(model); + } + + @Test + @DisplayName("builds ChatModel with minimal parameters") + void buildMinimal() { + Map params = new HashMap<>(); + params.put("apiKey", "sk-test"); + params.put("modelName", "gpt-4o-mini"); + + ChatModel model = builder.build(params); + assertNotNull(model); + } + + @Test + @DisplayName("builds StreamingChatModel with all parameters") + void buildStreamingAll() { + Map params = new HashMap<>(); + params.put("apiKey", "sk-test"); + params.put("modelName", "gpt-4o"); + params.put("temperature", "0.5"); + params.put("responseFormat", "json"); + + StreamingChatModel model = builder.buildStreaming(params); + assertNotNull(model); + } + } + + // ==================== Anthropic ==================== + + @Nested + @DisplayName("AnthropicLanguageModelBuilder") + class AnthropicTests { + + private final AnthropicLanguageModelBuilder builder = new AnthropicLanguageModelBuilder(); + + @Test + @DisplayName("builds ChatModel") + void build() { + Map params = new HashMap<>(); + params.put("apiKey", "sk-test"); + params.put("modelName", "claude-sonnet-4-6"); + params.put("temperature", "0.3"); + params.put("timeout", "60000"); + params.put("logRequests", "true"); + params.put("logResponses", "true"); + + ChatModel model = builder.build(params); + assertNotNull(model); + } + + @Test + @DisplayName("builds StreamingChatModel") + void buildStreaming() { + Map params = new HashMap<>(); + params.put("apiKey", "sk-test"); + params.put("modelName", "claude-sonnet-4-6"); + + StreamingChatModel model = builder.buildStreaming(params); + assertNotNull(model); + } + } + + // ==================== Ollama ==================== + + @Nested + @DisplayName("OllamaLanguageModelBuilder") + class OllamaTests { + + private final OllamaLanguageModelBuilder builder = new OllamaLanguageModelBuilder(); + + @Test + @DisplayName("builds ChatModel") + void build() { + Map params = new HashMap<>(); + params.put("model", "llama3"); + params.put("baseUrl", "http://localhost:11434"); + params.put("temperature", "0.7"); + params.put("timeout", "120000"); + + ChatModel model = builder.build(params); + assertNotNull(model); + } + + @Test + @DisplayName("builds StreamingChatModel") + void buildStreaming() { + Map params = new HashMap<>(); + params.put("model", "llama3"); + params.put("baseUrl", "http://localhost:11434"); + + StreamingChatModel model = builder.buildStreaming(params); + assertNotNull(model); + } + } + + // ==================== MistralAi ==================== + + @Nested + @DisplayName("MistralAiLanguageModelBuilder") + class MistralTests { + + private final MistralAiLanguageModelBuilder builder = new MistralAiLanguageModelBuilder(); + + @Test + @DisplayName("builds ChatModel") + void build() { + Map params = new HashMap<>(); + params.put("apiKey", "test-key"); + params.put("modelName", "mistral-large"); + params.put("temperature", "0.5"); + + ChatModel model = builder.build(params); + assertNotNull(model); + } + + @Test + @DisplayName("builds StreamingChatModel") + void buildStreaming() { + Map params = new HashMap<>(); + params.put("apiKey", "test-key"); + params.put("modelName", "mistral-large"); + + StreamingChatModel model = builder.buildStreaming(params); + assertNotNull(model); + } + } + + // ==================== AzureOpenAI ==================== + + @Nested + @DisplayName("AzureOpenAiLanguageModelBuilder") + class AzureTests { + + private final AzureOpenAiLanguageModelBuilder builder = new AzureOpenAiLanguageModelBuilder(); + + @Test + @DisplayName("builds ChatModel") + void build() { + Map params = new HashMap<>(); + params.put("apiKey", "azure-key"); + params.put("deploymentName", "gpt-4o"); + params.put("endpoint", "https://my-resource.openai.azure.com/"); + params.put("temperature", "0.5"); + + ChatModel model = builder.build(params); + assertNotNull(model); + } + + @Test + @DisplayName("builds StreamingChatModel") + void buildStreaming() { + Map params = new HashMap<>(); + params.put("apiKey", "azure-key"); + params.put("deploymentName", "gpt-4o"); + params.put("endpoint", "https://my-resource.openai.azure.com/"); + + StreamingChatModel model = builder.buildStreaming(params); + assertNotNull(model); + } + } + +} From b76c6635fa0e03954a171799d562cc8aa0a7b069 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 12:32:33 +0200 Subject: [PATCH 022/124] chore(docs): update changelog with batches 19-21 coverage progress (54.2%) --- docs/changelog.md | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/docs/changelog.md b/docs/changelog.md index 7b29ebebc..cd01ca8e5 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -13,6 +13,37 @@ Each entry follows this format: - **Decision** — Key design decisions and their reasoning - **Files** — Links to modified files +## Unit Test Coverage Expansion — Batches 19–21 (2026-04-20) + +**Repo:** EDDI (`test/coverage-tier-1-2`) + +**What changed:** Fixed compilation errors in AgentSetupServiceTest and added 4 new test classes. Line coverage: 53.6% → 54.2%. + +### Batch 19 — AgentSetupService Fixes + Verification +- Fixed `AgentSetupServiceTest` API mismatches: `tasks()` record accessor (not `getTasks()`), `getExpressionsAsActions()` (not `isExpressionsAsActions()`), `getEnableBuiltInTools()` (not `isEnableBuiltInTools()`), removed `staging` environment (only `production`/`test` exist) +- 69/69 tests green + +### Batch 20 — Security & Utility Tests +- `AuditHmacTest` (13 tests) — HMAC key derivation (determinism, independence), compute/verify (valid, tampered, null, wrong key), canonical string building (all fields, null safety, map sorting) +- `VaultSaltManagerTest` (9 tests) — Salt lifecycle: load existing, fresh deployment generation, legacy upgrade fallback, persistence failure, defensive copy, migration, null/short rejection +- `LanguageUtilitiesTest` (29 tests) — Time expression parsing (Xh, HH:MM, HH:MM:SS, 24:00 normalization), ordinal number extraction (1st, 2nd, 3rd, 4th patterns) + +### Batch 21 — LLM Provider Builder Tests +- `LanguageModelBuildersTest` (11 tests) — OpenAI, Anthropic, Ollama, Mistral, Azure OpenAI (build + buildStreaming with full/minimal params). HuggingFace excluded (deprecated, Retrofit URL validation prevents offline testing) + +### Coverage Summary +| Metric | Before | After | Delta | +|---|---|---|---| +| LINE | 53.6% | 54.2% | +0.6% | +| INSTRUCTION | 52.3% | 52.9% | +0.6% | +| METHOD | 60.9% | 61.3% | +0.4% | +| CLASS | 68.5% | 69.3% | +0.8% | + +**Total new tests this session:** 62 (AuditHmac 13 + VaultSaltManager 9 + LanguageUtilities 29 + Builders 11) +**Total test classes:** ~235 + +**Next steps:** Target `datastore/postgres` (1,334 missed lines, needs Testcontainers), `backup/impl` (1,211 missed, RestImportService 72KB), `engine/internal` (895 missed, REST endpoints needing CDI mocks). + ## Unit Test Coverage Expansion — Batches 6–10 (2026-04-19) **Repo:** EDDI (`test/coverage-tier-1-2`) From 12247ff58240ace00236640dffe79481e5ec83d1 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 12:59:02 +0200 Subject: [PATCH 023/124] test(coverage): expand LanguageModelBuildersTest with Gemini + Bedrock (16 tests total) --- .../builder/LanguageModelBuildersTest.java | 82 +++++++++++++++++++ 1 file changed, 82 insertions(+) diff --git a/src/test/java/ai/labs/eddi/modules/llm/impl/builder/LanguageModelBuildersTest.java b/src/test/java/ai/labs/eddi/modules/llm/impl/builder/LanguageModelBuildersTest.java index 83397528e..53d5e26ee 100644 --- a/src/test/java/ai/labs/eddi/modules/llm/impl/builder/LanguageModelBuildersTest.java +++ b/src/test/java/ai/labs/eddi/modules/llm/impl/builder/LanguageModelBuildersTest.java @@ -205,4 +205,86 @@ void buildStreaming() { } } + // ==================== Gemini ==================== + + @Nested + @DisplayName("GeminiLanguageModelBuilder") + class GeminiTests { + + private final GeminiLanguageModelBuilder builder = new GeminiLanguageModelBuilder(); + + @Test + @DisplayName("builds ChatModel with all parameters") + void buildAll() { + Map params = new HashMap<>(); + params.put("apiKey", "gemini-key"); + params.put("modelName", "gemini-2.0-flash"); + params.put("temperature", "0.7"); + params.put("maxOutputTokens", "4096"); + params.put("allowCodeExecution", "true"); + params.put("logRequestsAndResponses", "true"); + params.put("timeout", "30000"); + + ChatModel model = builder.build(params); + assertNotNull(model); + } + + @Test + @DisplayName("builds StreamingChatModel") + void buildStreaming() { + Map params = new HashMap<>(); + params.put("apiKey", "gemini-key"); + params.put("modelName", "gemini-2.0-flash"); + + StreamingChatModel model = builder.buildStreaming(params); + assertNotNull(model); + } + } + + // ==================== Bedrock ==================== + + @Nested + @DisplayName("BedrockLanguageModelBuilder") + class BedrockTests { + + private final BedrockLanguageModelBuilder builder = new BedrockLanguageModelBuilder(); + + @Test + @DisplayName("builds ChatModel with all parameters") + void buildAll() { + Map params = new HashMap<>(); + params.put("modelId", "anthropic.claude-v2"); + params.put("region", "us-east-1"); + params.put("temperature", "0.5"); + params.put("maxTokens", "2048"); + params.put("timeout", "60000"); + + ChatModel model = builder.build(params); + assertNotNull(model); + } + + @Test + @DisplayName("builds ChatModel without request parameters") + void buildMinimal() { + Map params = new HashMap<>(); + params.put("modelId", "meta.llama3-70b-instruct-v1:0"); + params.put("region", "us-west-2"); + + ChatModel model = builder.build(params); + assertNotNull(model); + } + + @Test + @DisplayName("builds StreamingChatModel") + void buildStreaming() { + Map params = new HashMap<>(); + params.put("modelId", "anthropic.claude-v2"); + params.put("region", "eu-west-1"); + params.put("temperature", "0.3"); + + StreamingChatModel model = builder.buildStreaming(params); + assertNotNull(model); + } + } + } From 57d2b23e39696d400d23c9e02528981e24199509 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 13:34:02 +0200 Subject: [PATCH 024/124] test(coverage): add StringTemplateExtensionsTest (34 tests covering all Qute template extensions) --- .../StringTemplateExtensionsTest.java | 181 ++++++++++++++++++ 1 file changed, 181 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/modules/templating/impl/extensions/StringTemplateExtensionsTest.java diff --git a/src/test/java/ai/labs/eddi/modules/templating/impl/extensions/StringTemplateExtensionsTest.java b/src/test/java/ai/labs/eddi/modules/templating/impl/extensions/StringTemplateExtensionsTest.java new file mode 100644 index 000000000..4d0ec48ac --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/templating/impl/extensions/StringTemplateExtensionsTest.java @@ -0,0 +1,181 @@ +package ai.labs.eddi.modules.templating.impl.extensions; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Tests for {@link StringTemplateExtensions} — Qute template extension methods + * for String operations. + */ +@DisplayName("StringTemplateExtensions") +class StringTemplateExtensionsTest { + + @Nested + @DisplayName("Case conversion") + class CaseConversion { + @Test + void toLowerCase() { + assertEquals("hello", StringTemplateExtensions.toLowerCase("HELLO")); + } + @Test + void toLowerCaseNull() { + assertNull(StringTemplateExtensions.toLowerCase(null)); + } + @Test + void toUpperCase() { + assertEquals("HELLO", StringTemplateExtensions.toUpperCase("hello")); + } + @Test + void toUpperCaseNull() { + assertNull(StringTemplateExtensions.toUpperCase(null)); + } + } + + @Nested + @DisplayName("Search & replace") + class SearchReplace { + @Test + void replace() { + assertEquals("hi world", StringTemplateExtensions.replace("hello world", "hello", "hi")); + } + @Test + void replaceNull() { + assertNull(StringTemplateExtensions.replace(null, "a", "b")); + } + @Test + void contains() { + assertTrue(StringTemplateExtensions.contains("hello world", "world")); + } + @Test + void containsFalse() { + assertFalse(StringTemplateExtensions.contains("hello", "world")); + } + @Test + void containsNull() { + assertFalse(StringTemplateExtensions.contains(null, "x")); + } + @Test + void indexOf() { + assertEquals(6, StringTemplateExtensions.indexOf("hello world", "world")); + } + @Test + void indexOfNull() { + assertEquals(-1, StringTemplateExtensions.indexOf(null, "x")); + } + @Test + void lastIndexOf() { + assertEquals(8, StringTemplateExtensions.lastIndexOf("hello x x", "x")); + } + @Test + void lastIndexOfNull() { + assertEquals(-1, StringTemplateExtensions.lastIndexOf(null, "x")); + } + @Test + void startsWith() { + assertTrue(StringTemplateExtensions.startsWith("hello", "he")); + } + @Test + void startsWithFalse() { + assertFalse(StringTemplateExtensions.startsWith("hello", "xx")); + } + @Test + void startsWithNull() { + assertFalse(StringTemplateExtensions.startsWith(null, "x")); + } + @Test + void endsWith() { + assertTrue(StringTemplateExtensions.endsWith("hello", "lo")); + } + @Test + void endsWithNull() { + assertFalse(StringTemplateExtensions.endsWith(null, "x")); + } + } + + @Nested + @DisplayName("Substring") + class Substring { + @Test + void substringFrom() { + assertEquals("world", StringTemplateExtensions.substring("hello world", 6)); + } + @Test + void substringNull() { + assertNull(StringTemplateExtensions.substring(null, 0)); + } + @Test + void substringRange() { + assertEquals("ell", StringTemplateExtensions.substringRange("hello", 1, 4)); + } + @Test + void substringRangeNull() { + assertNull(StringTemplateExtensions.substringRange(null, 0, 3)); + } + } + + @Nested + @DisplayName("Trimming") + class Trimming { + @Test + void trim() { + assertEquals("hello", StringTemplateExtensions.trim(" hello ")); + } + @Test + void trimNull() { + assertNull(StringTemplateExtensions.trim(null)); + } + @Test + void strip() { + assertEquals("hello", StringTemplateExtensions.strip(" hello ")); + } + @Test + void stripNull() { + assertNull(StringTemplateExtensions.strip(null)); + } + } + + @Nested + @DisplayName("Length & char access") + class LengthAndChar { + @Test + void length() { + assertEquals(5, StringTemplateExtensions.length("hello")); + } + @Test + void lengthNull() { + assertEquals(0, StringTemplateExtensions.length(null)); + } + @Test + void isEmpty() { + assertTrue(StringTemplateExtensions.isEmpty("")); + } + @Test + void isEmptyNull() { + assertTrue(StringTemplateExtensions.isEmpty(null)); + } + @Test + void isEmptyFalse() { + assertFalse(StringTemplateExtensions.isEmpty("x")); + } + @Test + void charAt() { + assertEquals('e', StringTemplateExtensions.charAt("hello", 1)); + } + } + + @Nested + @DisplayName("Concatenation") + class Concat { + @Test + void concat() { + assertEquals("helloworld", StringTemplateExtensions.concat("hello", "world")); + } + @Test + void concatNull() { + assertEquals("world", StringTemplateExtensions.concat(null, "world")); + } + } +} From e3cf91288198180c187826714a8ed882b5e2e4c1 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 13:39:13 +0200 Subject: [PATCH 025/124] test(coverage): add DataFactoryTest + ApiCallsTaskTest (18 new tests) --- .../eddi/engine/memory/DataFactoryTest.java | 80 +++++++ .../apicalls/impl/ApiCallsTaskTest.java | 219 ++++++++++++++++++ 2 files changed, 299 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/engine/memory/DataFactoryTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/apicalls/impl/ApiCallsTaskTest.java diff --git a/src/test/java/ai/labs/eddi/engine/memory/DataFactoryTest.java b/src/test/java/ai/labs/eddi/engine/memory/DataFactoryTest.java new file mode 100644 index 000000000..740b1b35f --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/memory/DataFactoryTest.java @@ -0,0 +1,80 @@ +package ai.labs.eddi.engine.memory; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Tests for {@link DataFactory} — simple factory for creating IData instances. + */ +@DisplayName("DataFactory") +class DataFactoryTest { + + private DataFactory factory; + + @BeforeEach + void setUp() { + factory = new DataFactory(); + } + + @Test + @DisplayName("creates data with key and value") + void createDataKeyValue() { + IData data = factory.createData("input", "hello"); + assertEquals("input", data.getKey()); + assertEquals("hello", data.getResult()); + assertFalse(data.isPublic()); + } + + @Test + @DisplayName("creates public data") + void createPublicData() { + IData data = factory.createData("output", "world", true); + assertEquals("output", data.getKey()); + assertEquals("world", data.getResult()); + assertTrue(data.isPublic()); + } + + @Test + @DisplayName("creates private data explicitly") + void createPrivateData() { + IData data = factory.createData("internal", "secret", false); + assertFalse(data.isPublic()); + } + + @Test + @DisplayName("creates data with possible values") + void createDataWithPossibleValues() { + List possibleValues = List.of("a", "b", "c"); + IData data = factory.createData("choices", "a", possibleValues); + assertEquals("choices", data.getKey()); + assertEquals("a", data.getResult()); + assertEquals(possibleValues, data.getPossibleResults()); + } + + @Test + @DisplayName("creates data with integer value") + void createIntegerData() { + IData data = factory.createData("count", 42); + assertEquals(42, data.getResult()); + } + + @Test + @DisplayName("creates data with list value") + void createListData() { + List actions = List.of("greet", "farewell"); + IData> data = factory.createData("actions", actions); + assertEquals(actions, data.getResult()); + } + + @Test + @DisplayName("creates data with null value") + void createNullValueData() { + IData data = factory.createData("key", null); + assertNull(data.getResult()); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/apicalls/impl/ApiCallsTaskTest.java b/src/test/java/ai/labs/eddi/modules/apicalls/impl/ApiCallsTaskTest.java new file mode 100644 index 000000000..37687425d --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/apicalls/impl/ApiCallsTaskTest.java @@ -0,0 +1,219 @@ +package ai.labs.eddi.modules.apicalls.impl; + +import ai.labs.eddi.configs.apicalls.model.ApiCall; +import ai.labs.eddi.configs.apicalls.model.ApiCallsConfiguration; +import ai.labs.eddi.configs.workflows.model.ExtensionDescriptor; +import ai.labs.eddi.engine.lifecycle.exceptions.LifecycleException; +import ai.labs.eddi.engine.lifecycle.exceptions.WorkflowConfigurationException; +import ai.labs.eddi.engine.memory.IConversationMemory; +import ai.labs.eddi.engine.memory.IConversationMemory.IWritableConversationStep; +import ai.labs.eddi.engine.memory.IData; +import ai.labs.eddi.engine.memory.IMemoryItemConverter; +import ai.labs.eddi.engine.memory.MemoryKeys; +import ai.labs.eddi.engine.runtime.client.configuration.IResourceClientLibrary; +import ai.labs.eddi.engine.runtime.service.ServiceException; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.net.URI; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.*; + +/** + * Tests for {@link ApiCallsTask} — the HTTP calls lifecycle task. + */ +@DisplayName("ApiCallsTask") +class ApiCallsTaskTest { + + @Mock + private IResourceClientLibrary resourceClientLibrary; + @Mock + private IMemoryItemConverter memoryItemConverter; + @Mock + private IApiCallExecutor httpCallExecutor; + @Mock + private IConversationMemory memory; + @Mock + private IWritableConversationStep currentStep; + + private ApiCallsTask task; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + task = new ApiCallsTask(resourceClientLibrary, memoryItemConverter, httpCallExecutor); + when(memory.getCurrentStep()).thenReturn(currentStep); + } + + @Test + @DisplayName("returns correct ID") + void getId() { + assertEquals("ai.labs.httpcalls", task.getId()); + } + + @Test + @DisplayName("returns correct type") + void getType() { + assertEquals("httpCalls", task.getType()); + } + + @Nested + @DisplayName("execute") + class Execute { + + @Test + @DisplayName("returns early when no actions in memory") + void noActions() throws LifecycleException { + when(currentStep.getLatestData(MemoryKeys.ACTIONS)).thenReturn(null); + + ApiCallsConfiguration config = new ApiCallsConfiguration(); + task.execute(memory, config); + + verifyNoInteractions(httpCallExecutor); + } + + @Test + @DisplayName("executes matching API calls for actions") + @SuppressWarnings("unchecked") + void executesMatchingCalls() throws Exception { + // Setup actions + @SuppressWarnings("unchecked") + IData> actionsData = mock(IData.class); + when(actionsData.getResult()).thenReturn(List.of("greet")); + when(currentStep.getLatestData(MemoryKeys.ACTIONS)).thenReturn(actionsData); + when(memoryItemConverter.convert(memory)).thenReturn(new HashMap<>()); + + // Setup API call config + ApiCall greetCall = new ApiCall(); + greetCall.setActions(List.of("greet")); + + ApiCallsConfiguration config = new ApiCallsConfiguration(); + config.setHttpCalls(List.of(greetCall)); + config.setTargetServerUrl("http://localhost:8080"); + + when(httpCallExecutor.execute(any(), any(), any(), any())).thenReturn(Map.of("result", "ok")); + + task.execute(memory, config); + + verify(httpCallExecutor).execute(eq(greetCall), eq(memory), any(), eq("http://localhost:8080")); + } + + @Test + @DisplayName("skips non-matching API calls") + @SuppressWarnings("unchecked") + void skipsNonMatching() throws Exception { + @SuppressWarnings("unchecked") + IData> actionsData = mock(IData.class); + when(actionsData.getResult()).thenReturn(List.of("farewell")); + when(currentStep.getLatestData(MemoryKeys.ACTIONS)).thenReturn(actionsData); + when(memoryItemConverter.convert(memory)).thenReturn(new HashMap<>()); + + ApiCall greetCall = new ApiCall(); + greetCall.setActions(List.of("greet")); + + ApiCallsConfiguration config = new ApiCallsConfiguration(); + config.setHttpCalls(List.of(greetCall)); + config.setTargetServerUrl("http://localhost:8080"); + + task.execute(memory, config); + + verifyNoInteractions(httpCallExecutor); + } + + @Test + @DisplayName("wildcard action matches everything") + @SuppressWarnings("unchecked") + void wildcardAction() throws Exception { + @SuppressWarnings("unchecked") + IData> actionsData = mock(IData.class); + when(actionsData.getResult()).thenReturn(List.of("anything")); + when(currentStep.getLatestData(MemoryKeys.ACTIONS)).thenReturn(actionsData); + when(memoryItemConverter.convert(memory)).thenReturn(new HashMap<>()); + + ApiCall wildcardCall = new ApiCall(); + wildcardCall.setActions(List.of("*")); + + ApiCallsConfiguration config = new ApiCallsConfiguration(); + config.setHttpCalls(List.of(wildcardCall)); + config.setTargetServerUrl("http://localhost:8080"); + + when(httpCallExecutor.execute(any(), any(), any(), any())).thenReturn(null); + + task.execute(memory, config); + + verify(httpCallExecutor).execute(eq(wildcardCall), any(), any(), any()); + } + } + + @Nested + @DisplayName("configure") + class Configure { + + @Test + @DisplayName("throws when no URI provided") + void noUri() { + Map config = new HashMap<>(); + assertThrows(WorkflowConfigurationException.class, + () -> task.configure(config, Map.of())); + } + + @Test + @DisplayName("throws when URI is empty") + void emptyUri() { + Map config = new HashMap<>(); + config.put("uri", ""); + assertThrows(WorkflowConfigurationException.class, + () -> task.configure(config, Map.of())); + } + + @Test + @DisplayName("loads config and strips trailing slash from targetServerUrl") + void loadsConfigStripsSlash() throws Exception { + ApiCallsConfiguration apiConfig = new ApiCallsConfiguration(); + apiConfig.setTargetServerUrl("http://example.com/api/"); + apiConfig.setHttpCalls(List.of()); + + when(resourceClientLibrary.getResource(any(URI.class), eq(ApiCallsConfiguration.class))) + .thenReturn(apiConfig); + + Map config = Map.of("uri", "eddi://config/123"); + Object result = task.configure(config, Map.of()); + + assertNotNull(result); + assertEquals("http://example.com/api", ((ApiCallsConfiguration) result).getTargetServerUrl()); + } + + @Test + @DisplayName("throws when targetServerUrl is empty") + void emptyTargetServerUrl() throws Exception { + ApiCallsConfiguration apiConfig = new ApiCallsConfiguration(); + apiConfig.setTargetServerUrl(""); + + when(resourceClientLibrary.getResource(any(URI.class), eq(ApiCallsConfiguration.class))) + .thenReturn(apiConfig); + + Map config = Map.of("uri", "eddi://config/123"); + assertThrows(WorkflowConfigurationException.class, + () -> task.configure(config, Map.of())); + } + } + + @Test + @DisplayName("extension descriptor has correct ID and display name") + void extensionDescriptor() { + ExtensionDescriptor descriptor = task.getExtensionDescriptor(); + assertEquals("ai.labs.httpcalls", descriptor.getType()); + assertEquals("Http Calls", descriptor.getDisplayName()); + assertTrue(descriptor.getConfigs().containsKey("uri")); + } +} From b70e45affa098dd6b41a8b948e0b7eab1cf27092 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 13:55:13 +0200 Subject: [PATCH 026/124] chore(docs): update changelog with batches 19-24 coverage progress (54.7%, 3448 tests) --- docs/changelog.md | 33 +++++++++++++++++++++++---------- 1 file changed, 23 insertions(+), 10 deletions(-) diff --git a/docs/changelog.md b/docs/changelog.md index cd01ca8e5..4de6f0b0e 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -13,11 +13,11 @@ Each entry follows this format: - **Decision** — Key design decisions and their reasoning - **Files** — Links to modified files -## Unit Test Coverage Expansion — Batches 19–21 (2026-04-20) +## Unit Test Coverage Expansion — Batches 19–24 (2026-04-20) **Repo:** EDDI (`test/coverage-tier-1-2`) -**What changed:** Fixed compilation errors in AgentSetupServiceTest and added 4 new test classes. Line coverage: 53.6% → 54.2%. +**What changed:** Fixed compilation errors in AgentSetupServiceTest and added 7 new test classes. Line coverage: 53.6% → 54.7%. ### Batch 19 — AgentSetupService Fixes + Verification - Fixed `AgentSetupServiceTest` API mismatches: `tasks()` record accessor (not `getTasks()`), `getExpressionsAsActions()` (not `isExpressionsAsActions()`), `getEnableBuiltInTools()` (not `isEnableBuiltInTools()`), removed `staging` environment (only `production`/`test` exist) @@ -29,20 +29,33 @@ Each entry follows this format: - `LanguageUtilitiesTest` (29 tests) — Time expression parsing (Xh, HH:MM, HH:MM:SS, 24:00 normalization), ordinal number extraction (1st, 2nd, 3rd, 4th patterns) ### Batch 21 — LLM Provider Builder Tests -- `LanguageModelBuildersTest` (11 tests) — OpenAI, Anthropic, Ollama, Mistral, Azure OpenAI (build + buildStreaming with full/minimal params). HuggingFace excluded (deprecated, Retrofit URL validation prevents offline testing) +- `LanguageModelBuildersTest` (16 tests) — OpenAI, Anthropic, Ollama, Mistral, Azure OpenAI, Gemini, Bedrock (build + buildStreaming with full/minimal params). HuggingFace/Oracle/Jlama excluded (deprecated or need credentials/incubator modules) + +### Batch 22 — Qute Template Extensions +- `StringTemplateExtensionsTest` (34 tests) — All 15 extension methods: case conversion, search/replace, substring, trim/strip, length/isEmpty/charAt, concat — each with null safety coverage + +### Batch 23 — Memory & API Task Tests +- `DataFactoryTest` (7 tests) — All 3 createData overloads with various types and null values +- `ApiCallsTaskTest` (11 tests) — Action matching, wildcard, no-actions early return, configure (URI validation, trailing slash stripping, empty targetServerUrl), extension descriptor ### Coverage Summary | Metric | Before | After | Delta | |---|---|---|---| -| LINE | 53.6% | 54.2% | +0.6% | -| INSTRUCTION | 52.3% | 52.9% | +0.6% | -| METHOD | 60.9% | 61.3% | +0.4% | -| CLASS | 68.5% | 69.3% | +0.8% | +| LINE | 53.6% | 54.7% | +1.1% | +| INSTRUCTION | 52.3% | 53.4% | +1.1% | +| BRANCH | 46.6% | 48.2% | +1.6% | +| METHOD | 60.9% | 61.9% | +1.0% | +| CLASS | 68.5% | 70.1% | +1.6% | + +**Total new tests this session:** 119 +**Total test count:** 3,448 (0 failures) -**Total new tests this session:** 62 (AuditHmac 13 + VaultSaltManager 9 + LanguageUtilities 29 + Builders 11) -**Total test classes:** ~235 +**Remaining gap to 80%:** ~6,800 missed lines out of 26,787. Top targets: +- `datastore/postgres` (1,334 lines, needs Testcontainers) +- `backup/impl` (1,211 lines, RestImportService 72KB needs CDI) +- `engine/internal` (895 lines, REST endpoints needing CDI) +- `modules/llm/impl` (675 lines, LlmTask branches) -**Next steps:** Target `datastore/postgres` (1,334 missed lines, needs Testcontainers), `backup/impl` (1,211 missed, RestImportService 72KB), `engine/internal` (895 missed, REST endpoints needing CDI mocks). ## Unit Test Coverage Expansion — Batches 6–10 (2026-04-19) From b8af6e93416410a5d031a2e5a35a84e030a3a7b0 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 14:27:29 +0200 Subject: [PATCH 027/124] =?UTF-8?q?refactor(tests):=20code=20review=20clea?= =?UTF-8?q?nup=20=E2=80=94=20remove=20unused=20imports,=20deduplicate=20@S?= =?UTF-8?q?uppressWarnings,=20add=20uncommitted=20test=20classes=20from=20?= =?UTF-8?q?prior=20session=20(McpCallsTask,=20InputParser,=20OutputGenerat?= =?UTF-8?q?ion,=20PhoneticCorrection)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../corrections/PhoneticCorrection.java | 10 +- .../apicalls/impl/ApiCallsTaskTest.java | 5 +- .../modules/mcpcalls/McpCallsTaskTest.java | 296 +++++++++++++ .../eddi/modules/nlp/InputParserTaskTest.java | 389 ++++++++++++++++++ .../corrections/PhoneticCorrectionTest.java | 22 + .../output/OutputGenerationTaskTest.java | 209 ++++++++++ .../eddi/utils/LanguageUtilitiesTest.java | 1 - 7 files changed, 925 insertions(+), 7 deletions(-) create mode 100644 src/test/java/ai/labs/eddi/modules/mcpcalls/McpCallsTaskTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/nlp/InputParserTaskTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/output/OutputGenerationTaskTest.java diff --git a/src/main/java/ai/labs/eddi/modules/nlp/extensions/corrections/PhoneticCorrection.java b/src/main/java/ai/labs/eddi/modules/nlp/extensions/corrections/PhoneticCorrection.java index 13154b130..a5ff18a8b 100644 --- a/src/main/java/ai/labs/eddi/modules/nlp/extensions/corrections/PhoneticCorrection.java +++ b/src/main/java/ai/labs/eddi/modules/nlp/extensions/corrections/PhoneticCorrection.java @@ -50,10 +50,16 @@ private List lookupPhonetic(String word) { List foundWords = new ArrayList<>(); String soundexCode = calculateSoundexCode(word); - foundWords.addAll(soundexCodes.get(soundexCode)); + List soundexMatches = soundexCodes.get(soundexCode); + if (soundexMatches != null) { + foundWords.addAll(soundexMatches); + } String metaphoneCode = calculateMetaphoneCode(word); - foundWords.addAll(metaphoneCodes.get(metaphoneCode)); + List metaphoneMatches = metaphoneCodes.get(metaphoneCode); + if (metaphoneMatches != null) { + foundWords.addAll(metaphoneMatches); + } return foundWords; } diff --git a/src/test/java/ai/labs/eddi/modules/apicalls/impl/ApiCallsTaskTest.java b/src/test/java/ai/labs/eddi/modules/apicalls/impl/ApiCallsTaskTest.java index 37687425d..4484c92f2 100644 --- a/src/test/java/ai/labs/eddi/modules/apicalls/impl/ApiCallsTaskTest.java +++ b/src/test/java/ai/labs/eddi/modules/apicalls/impl/ApiCallsTaskTest.java @@ -11,7 +11,7 @@ import ai.labs.eddi.engine.memory.IMemoryItemConverter; import ai.labs.eddi.engine.memory.MemoryKeys; import ai.labs.eddi.engine.runtime.client.configuration.IResourceClientLibrary; -import ai.labs.eddi.engine.runtime.service.ServiceException; + import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; @@ -87,7 +87,6 @@ void noActions() throws LifecycleException { @SuppressWarnings("unchecked") void executesMatchingCalls() throws Exception { // Setup actions - @SuppressWarnings("unchecked") IData> actionsData = mock(IData.class); when(actionsData.getResult()).thenReturn(List.of("greet")); when(currentStep.getLatestData(MemoryKeys.ACTIONS)).thenReturn(actionsData); @@ -112,7 +111,6 @@ void executesMatchingCalls() throws Exception { @DisplayName("skips non-matching API calls") @SuppressWarnings("unchecked") void skipsNonMatching() throws Exception { - @SuppressWarnings("unchecked") IData> actionsData = mock(IData.class); when(actionsData.getResult()).thenReturn(List.of("farewell")); when(currentStep.getLatestData(MemoryKeys.ACTIONS)).thenReturn(actionsData); @@ -134,7 +132,6 @@ void skipsNonMatching() throws Exception { @DisplayName("wildcard action matches everything") @SuppressWarnings("unchecked") void wildcardAction() throws Exception { - @SuppressWarnings("unchecked") IData> actionsData = mock(IData.class); when(actionsData.getResult()).thenReturn(List.of("anything")); when(currentStep.getLatestData(MemoryKeys.ACTIONS)).thenReturn(actionsData); diff --git a/src/test/java/ai/labs/eddi/modules/mcpcalls/McpCallsTaskTest.java b/src/test/java/ai/labs/eddi/modules/mcpcalls/McpCallsTaskTest.java new file mode 100644 index 000000000..ba02c2324 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/mcpcalls/McpCallsTaskTest.java @@ -0,0 +1,296 @@ +package ai.labs.eddi.modules.mcpcalls; + +import ai.labs.eddi.configs.mcpcalls.model.McpCall; +import ai.labs.eddi.configs.mcpcalls.model.McpCallsConfiguration; +import ai.labs.eddi.datastore.serialization.IJsonSerialization; +import ai.labs.eddi.engine.TestMemoryFactory; +import ai.labs.eddi.engine.TestMemoryFactory.MemoryContext; +import ai.labs.eddi.engine.lifecycle.exceptions.LifecycleException; +import ai.labs.eddi.engine.lifecycle.exceptions.WorkflowConfigurationException; +import ai.labs.eddi.engine.memory.IMemoryItemConverter; +import ai.labs.eddi.engine.memory.model.Data; +import ai.labs.eddi.engine.runtime.client.configuration.IResourceClientLibrary; +import ai.labs.eddi.engine.runtime.service.ServiceException; +import ai.labs.eddi.modules.apicalls.impl.PrePostUtils; +import ai.labs.eddi.modules.llm.impl.McpToolProviderManager; +import ai.labs.eddi.modules.llm.impl.McpToolProviderManager.McpToolsResult; +import ai.labs.eddi.modules.mcpcalls.impl.McpCallsTask; +import dev.langchain4j.agent.tool.ToolSpecification; +import dev.langchain4j.service.tool.ToolExecutor; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.net.URI; +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; + +/** + * Tests for {@link McpCallsTask} — deterministic MCP tool call lifecycle task. + */ +@DisplayName("McpCallsTask") +class McpCallsTaskTest { + + private McpCallsTask task; + private IResourceClientLibrary resourceClientLibrary; + private IMemoryItemConverter memoryItemConverter; + private IJsonSerialization jsonSerialization; + private McpToolProviderManager mcpToolProviderManager; + private PrePostUtils prePostUtils; + + @BeforeEach + void setUp() { + resourceClientLibrary = mock(IResourceClientLibrary.class); + memoryItemConverter = mock(IMemoryItemConverter.class); + jsonSerialization = mock(IJsonSerialization.class); + mcpToolProviderManager = mock(McpToolProviderManager.class); + prePostUtils = mock(PrePostUtils.class); + task = new McpCallsTask(resourceClientLibrary, memoryItemConverter, + jsonSerialization, mcpToolProviderManager, prePostUtils); + } + + // ==================== Identity ==================== + + @Test + @DisplayName("getId returns correct identifier") + void testGetId() { + assertEquals("ai.labs.mcpcalls", task.getId()); + } + + @Test + @DisplayName("getType returns 'mcpCalls'") + void testGetType() { + assertEquals("mcpCalls", task.getType()); + } + + // ==================== execute() ==================== + + @Nested + @DisplayName("execute()") + class ExecuteTests { + + @Test + @DisplayName("returns early when no actions data in memory") + void execute_noActions_returnsEarly() throws LifecycleException { + MemoryContext ctx = TestMemoryFactory.create(); + McpCallsConfiguration config = new McpCallsConfiguration(); + + task.execute(ctx.memory(), config); + + verifyNoInteractions(mcpToolProviderManager); + } + + @Test + @DisplayName("returns early when actions data result is null") + void execute_nullActionsResult_returnsEarly() throws LifecycleException { + MemoryContext ctx = TestMemoryFactory.create(); + when(ctx.currentStep().getLatestData(eq("actions"))) + .thenReturn(new Data<>("actions", null)); + McpCallsConfiguration config = new McpCallsConfiguration(); + + task.execute(ctx.memory(), config); + + verifyNoInteractions(mcpToolProviderManager); + } + + @Test + @DisplayName("returns early when mcpCalls list is empty") + void execute_emptyMcpCalls_returnsEarly() throws LifecycleException { + MemoryContext ctx = TestMemoryFactory.createWithActions(List.of("some_action")); + McpCallsConfiguration config = new McpCallsConfiguration(); + config.setMcpCalls(Collections.emptyList()); + + task.execute(ctx.memory(), config); + + verifyNoInteractions(mcpToolProviderManager); + } + + @Test + @DisplayName("returns early when no tools discovered from MCP server") + void execute_noToolsDiscovered_returnsEarly() throws LifecycleException { + MemoryContext ctx = TestMemoryFactory.createWithActions(List.of("trigger")); + McpCallsConfiguration config = createConfigWithCall("trigger", "myTool"); + when(mcpToolProviderManager.discoverTools(anyList())).thenReturn(null); + + task.execute(ctx.memory(), config); + + verify(mcpToolProviderManager).discoverTools(anyList()); + verifyNoInteractions(memoryItemConverter); + } + + @Test + @DisplayName("skips call when action does not match") + void execute_actionMismatch_skipsCall() throws Exception { + MemoryContext ctx = TestMemoryFactory.createWithActions(List.of("unrelated_action")); + McpCallsConfiguration config = createConfigWithCall("specific_action", "myTool"); + McpToolsResult toolsResult = createToolsResult("myTool"); + when(mcpToolProviderManager.discoverTools(anyList())).thenReturn(toolsResult); + when(memoryItemConverter.convert(ctx.memory())).thenReturn(new HashMap<>()); + + task.execute(ctx.memory(), config); + + // Tool executor should not be called + verify(toolsResult.executors().get("myTool"), never()).execute(any(), any()); + } + + @Test + @DisplayName("executes tool on matching action") + void execute_matchingAction_executesTool() throws Exception { + MemoryContext ctx = TestMemoryFactory.createWithActions(List.of("trigger")); + McpCallsConfiguration config = createConfigWithCall("trigger", "myTool"); + McpToolsResult toolsResult = createToolsResult("myTool"); + when(mcpToolProviderManager.discoverTools(anyList())).thenReturn(toolsResult); + when(memoryItemConverter.convert(ctx.memory())).thenReturn(new HashMap<>()); + when(jsonSerialization.serialize(anyMap())).thenReturn("{}"); + when(toolsResult.executors().get("myTool").execute(any(), any())).thenReturn("result"); + + task.execute(ctx.memory(), config); + + verify(toolsResult.executors().get("myTool")).execute(any(), any()); + } + + @Test + @DisplayName("wildcard action '*' matches any action") + void execute_wildcardAction_matchesAny() throws Exception { + MemoryContext ctx = TestMemoryFactory.createWithActions(List.of("any_action")); + McpCallsConfiguration config = createConfigWithCall("*", "myTool"); + McpToolsResult toolsResult = createToolsResult("myTool"); + when(mcpToolProviderManager.discoverTools(anyList())).thenReturn(toolsResult); + when(memoryItemConverter.convert(ctx.memory())).thenReturn(new HashMap<>()); + when(jsonSerialization.serialize(anyMap())).thenReturn("{}"); + when(toolsResult.executors().get("myTool").execute(any(), any())).thenReturn("done"); + + task.execute(ctx.memory(), config); + + verify(toolsResult.executors().get("myTool")).execute(any(), any()); + } + + @Test + @DisplayName("tool blocked by whitelist is not executed") + void execute_toolBlockedByWhitelist_skipped() throws Exception { + MemoryContext ctx = TestMemoryFactory.createWithActions(List.of("trigger")); + McpCallsConfiguration config = createConfigWithCall("trigger", "blockedTool"); + config.setToolsWhitelist(List.of("allowedTool")); // blockedTool not in whitelist + McpToolsResult toolsResult = createToolsResult("blockedTool"); + when(mcpToolProviderManager.discoverTools(anyList())).thenReturn(toolsResult); + when(memoryItemConverter.convert(ctx.memory())).thenReturn(new HashMap<>()); + + task.execute(ctx.memory(), config); + + verify(toolsResult.executors().get("blockedTool"), never()).execute(any(), any()); + } + + @Test + @DisplayName("tool blocked by blacklist is not executed") + void execute_toolBlockedByBlacklist_skipped() throws Exception { + MemoryContext ctx = TestMemoryFactory.createWithActions(List.of("trigger")); + McpCallsConfiguration config = createConfigWithCall("trigger", "blockedTool"); + config.setToolsBlacklist(List.of("blockedTool")); + McpToolsResult toolsResult = createToolsResult("blockedTool"); + when(mcpToolProviderManager.discoverTools(anyList())).thenReturn(toolsResult); + when(memoryItemConverter.convert(ctx.memory())).thenReturn(new HashMap<>()); + + task.execute(ctx.memory(), config); + + verify(toolsResult.executors().get("blockedTool"), never()).execute(any(), any()); + } + + @Test + @DisplayName("skips mcpCall with null actions list") + void execute_nullActionsInCall_skips() throws Exception { + MemoryContext ctx = TestMemoryFactory.createWithActions(List.of("trigger")); + McpCallsConfiguration config = new McpCallsConfiguration(); + config.setMcpServerUrl("http://localhost:3000"); + McpCall call = new McpCall(); + call.setToolName("myTool"); + // actions is null + config.setMcpCalls(List.of(call)); + + McpToolsResult toolsResult = createToolsResult("myTool"); + when(mcpToolProviderManager.discoverTools(anyList())).thenReturn(toolsResult); + when(memoryItemConverter.convert(ctx.memory())).thenReturn(new HashMap<>()); + + task.execute(ctx.memory(), config); + + verify(toolsResult.executors().get("myTool"), never()).execute(any(), any()); + } + } + + // ==================== configure() ==================== + + @Nested + @DisplayName("configure()") + class ConfigureTests { + + @Test + @DisplayName("throws WorkflowConfigurationException when no URI") + void configure_noUri_throws() { + assertThrows(WorkflowConfigurationException.class, + () -> task.configure(Collections.emptyMap(), Collections.emptyMap())); + } + + @Test + @DisplayName("throws WorkflowConfigurationException on service error") + void configure_serviceError_throws() throws ServiceException { + when(resourceClientLibrary.getResource(any(URI.class), eq(McpCallsConfiguration.class))) + .thenThrow(new ServiceException("not found")); + + Map config = Map.of("uri", "eddi://ai.labs.mcpcalls/mcpcallsstore/mcpcalls/abc123"); + + assertThrows(WorkflowConfigurationException.class, + () -> task.configure(config, Collections.emptyMap())); + } + + @Test + @DisplayName("returns config from resource client library") + void configure_validUri_returnsConfig() throws Exception { + McpCallsConfiguration expectedConfig = new McpCallsConfiguration(); + when(resourceClientLibrary.getResource(any(URI.class), eq(McpCallsConfiguration.class))) + .thenReturn(expectedConfig); + + Map config = Map.of("uri", "eddi://ai.labs.mcpcalls/mcpcallsstore/mcpcalls/abc123"); + var result = task.configure(config, Collections.emptyMap()); + + assertSame(expectedConfig, result); + } + } + + // ==================== ExtensionDescriptor ==================== + + @Test + @DisplayName("getExtensionDescriptor returns correct descriptor") + void testExtensionDescriptor() { + var descriptor = task.getExtensionDescriptor(); + + assertNotNull(descriptor); + assertEquals("ai.labs.mcpcalls", descriptor.getType()); + assertEquals("MCP Calls", descriptor.getDisplayName()); + assertTrue(descriptor.getConfigs().containsKey("uri")); + } + + // ==================== Helpers ==================== + + private McpCallsConfiguration createConfigWithCall(String action, String toolName) { + McpCallsConfiguration config = new McpCallsConfiguration(); + config.setMcpServerUrl("http://localhost:3000"); + McpCall call = new McpCall(); + call.setToolName(toolName); + call.setActions(List.of(action)); + config.setMcpCalls(List.of(call)); + return config; + } + + private McpToolsResult createToolsResult(String... toolNames) { + List specs = new ArrayList<>(); + Map executors = new HashMap<>(); + for (String name : toolNames) { + specs.add(ToolSpecification.builder().name(name).description("test").build()); + executors.put(name, mock(ToolExecutor.class)); + } + return new McpToolsResult(specs, executors); + } +} diff --git a/src/test/java/ai/labs/eddi/modules/nlp/InputParserTaskTest.java b/src/test/java/ai/labs/eddi/modules/nlp/InputParserTaskTest.java new file mode 100644 index 000000000..93e7facc8 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/nlp/InputParserTaskTest.java @@ -0,0 +1,389 @@ +package ai.labs.eddi.modules.nlp; + +import ai.labs.eddi.configs.workflows.model.ExtensionDescriptor; +import ai.labs.eddi.engine.TestMemoryFactory; +import ai.labs.eddi.engine.TestMemoryFactory.MemoryContext; +import ai.labs.eddi.engine.lifecycle.exceptions.UnrecognizedExtensionException; +import ai.labs.eddi.engine.lifecycle.exceptions.WorkflowConfigurationException; +import ai.labs.eddi.engine.memory.IConversationMemory; +import ai.labs.eddi.engine.memory.IData; +import ai.labs.eddi.engine.memory.model.ConversationOutput; +import ai.labs.eddi.engine.memory.model.Data; +import ai.labs.eddi.modules.nlp.expressions.Expression; +import ai.labs.eddi.modules.nlp.expressions.Expressions; +import ai.labs.eddi.modules.nlp.expressions.utilities.IExpressionProvider; +import ai.labs.eddi.modules.nlp.extensions.corrections.ICorrection; +import ai.labs.eddi.modules.nlp.extensions.corrections.providers.ICorrectionProvider; +import ai.labs.eddi.modules.nlp.extensions.dictionaries.IDictionary; +import ai.labs.eddi.modules.nlp.extensions.dictionaries.providers.IDictionaryProvider; +import ai.labs.eddi.modules.nlp.extensions.normalizers.INormalizer; +import ai.labs.eddi.modules.nlp.extensions.normalizers.providers.INormalizerProvider; +import ai.labs.eddi.modules.nlp.internal.matches.RawSolution; +import ai.labs.eddi.modules.output.model.QuickReply; +import com.fasterxml.jackson.databind.ObjectMapper; +import jakarta.inject.Provider; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; + +/** + * Tests for {@link InputParserTask} — the NLP parser lifecycle task. + *

+ * Tests cover: execute() (early returns, normal parsing, expression storage), + * configure() (config flags, provider wiring, error paths), and + * getExtensionDescriptor(). + */ +@DisplayName("InputParserTask") +class InputParserTaskTest { + + private InputParserTask task; + private IExpressionProvider expressionProvider; + private Map> normalizerProviders; + private Map> dictionaryProviders; + private Map> correctionProviders; + private ObjectMapper objectMapper; + + @BeforeEach + void setUp() { + expressionProvider = mock(IExpressionProvider.class); + normalizerProviders = new HashMap<>(); + dictionaryProviders = new HashMap<>(); + correctionProviders = new HashMap<>(); + objectMapper = new ObjectMapper(); + task = new InputParserTask(expressionProvider, normalizerProviders, dictionaryProviders, + correctionProviders, objectMapper); + } + + // ==================== Identity ==================== + + @Nested + @DisplayName("Task Identity") + class IdentityTests { + + @Test + @DisplayName("getId returns correct identifier") + void testGetId() { + assertEquals("ai.labs.parser", task.getId()); + } + + @Test + @DisplayName("getType returns 'expressions'") + void testGetType() { + assertEquals("expressions", task.getType()); + } + } + + // ==================== execute() ==================== + + @Nested + @DisplayName("execute()") + class ExecuteTests { + + @Test + @DisplayName("returns early when no input data is present") + void execute_noInput_returnsEarly() { + MemoryContext ctx = TestMemoryFactory.create(); + IInputParser parser = mock(IInputParser.class); + + // currentStep.getLatestData("input") returns null by default from + // TestMemoryFactory + task.execute(ctx.memory(), parser); + + // Should never attempt to parse + verifyNoInteractions(parser); + } + + @Test + @DisplayName("normalizes input and stores in memory") + void execute_withInput_normalizesAndParses() throws Exception { + MemoryContext ctx = TestMemoryFactory.createWithInput("Hello World"); + IInputParser parser = mock(IInputParser.class); + var config = new IInputParser.Config(true, true, true); + when(parser.getConfig()).thenReturn(config); + when(parser.normalize(eq("Hello World"), isNull())).thenReturn("hello world"); + when(parser.parse(eq("hello world"), isNull(), anyList())) + .thenReturn(Collections.emptyList()); + + task.execute(ctx.memory(), parser); + + verify(parser).normalize(eq("Hello World"), isNull()); + verify(parser).parse(eq("hello world"), isNull(), anyList()); + // Verify normalized input was stored + verify(ctx.currentStep()).storeData(argThat(data -> "input:normalized".equals(data.getKey()) && "hello world".equals(data.getResult()))); + } + + @Test + @DisplayName("stores parsed expressions and intents when solutions found") + void execute_withParsedSolutions_storesExpressionsAndIntents() throws Exception { + MemoryContext ctx = TestMemoryFactory.createWithInput("hi there"); + IInputParser parser = mock(IInputParser.class); + var config = new IInputParser.Config(true, true, true); + when(parser.getConfig()).thenReturn(config); + when(parser.normalize(eq("hi there"), isNull())).thenReturn("hi there"); + + // Create a raw solution + Expressions expressions = new Expressions(); + expressions.add(new Expression("greeting")); + RawSolution rawSolution = mock(RawSolution.class); + var foundWord = mock(IDictionary.IFoundWord.class); + when(foundWord.getValue()).thenReturn("hi there"); + Expressions foundExpressions = new Expressions(); + foundExpressions.add(new Expression("greeting")); + when(foundWord.getExpressions()).thenReturn(foundExpressions); + when(foundWord.isWord()).thenReturn(true); + when(rawSolution.getDictionaryEntries()).thenReturn(List.of(foundWord)); + when(parser.parse(eq("hi there"), isNull(), anyList())) + .thenReturn(List.of(rawSolution)); + + // Also set up getLatestData for expressions:parsed to return null (no append) + when(ctx.currentStep().getLatestData(eq("expressions:parsed"))).thenReturn(null); + + task.execute(ctx.memory(), parser); + + // Verify expressions were stored + verify(ctx.currentStep(), atLeastOnce()).storeData(any()); + } + + @Test + @DisplayName("handles InterruptedException during parse gracefully") + void execute_parseInterrupted_returnsGracefully() throws Exception { + MemoryContext ctx = TestMemoryFactory.createWithInput("test input"); + IInputParser parser = mock(IInputParser.class); + when(parser.normalize(eq("test input"), isNull())).thenThrow(new InterruptedException("test interrupt")); + + // Should not throw + task.execute(ctx.memory(), parser); + + // Should not attempt to store any results + verify(ctx.currentStep(), never()).addConversationOutputString(eq("expressions"), anyString()); + } + + @Test + @DisplayName("prepares temporary dictionaries from previous quickReplies") + void execute_withPreviousQuickReplies_createsTemporaryDictionaries() throws Exception { + MemoryContext ctx = TestMemoryFactory.createWithInput("option1"); + IInputParser parser = mock(IInputParser.class); + var config = new IInputParser.Config(true, true, true); + when(parser.getConfig()).thenReturn(config); + when(parser.normalize(eq("option1"), isNull())).thenReturn("option1"); + when(parser.parse(eq("option1"), isNull(), anyList())) + .thenReturn(Collections.emptyList()); + + // Set up conversation outputs with previous quickReplies + // Code reads conversationOutputs.get(size - 2), so we need at least 2 entries + // Index 0 = previous output (with quickReplies), Index 1 = current output + List outputs = ctx.conversationOutputs(); + ConversationOutput prevOutput = new ConversationOutput(); + List> quickReplies = new ArrayList<>(List.of( + new HashMap<>(Map.of("value", "Option 1", "expressions", "option_1")), + new HashMap<>(Map.of("value", "Option 2", "expressions", "option_2")))); + prevOutput.put("quickReplies", quickReplies); + outputs.addFirst(prevOutput); // index 0 = prev, index 1 = current + + task.execute(ctx.memory(), parser); + + verify(parser).parse(eq("option1"), isNull(), anyList()); + } + } + + // ==================== configure() ==================== + + @Nested + @DisplayName("configure()") + class ConfigureTests { + + @Test + @DisplayName("sets appendExpressions, includeUnused, includeUnknown from config") + void configure_parsesConfigFlags() throws Exception { + Map config = new HashMap<>(); + config.put("appendExpressions", "false"); + config.put("includeUnused", "false"); + config.put("includeUnknown", "false"); + + var result = task.configure(config, Collections.emptyMap()); + + assertNotNull(result); + assertTrue(result instanceof IInputParser); + IInputParser parser = (IInputParser) result; + assertFalse(parser.getConfig().isAppendExpressions()); + assertFalse(parser.getConfig().isIncludeUnused()); + assertFalse(parser.getConfig().isIncludeUnknown()); + } + + @Test + @DisplayName("uses default config when no flags specified") + void configure_defaultFlags() throws Exception { + var result = task.configure(Collections.emptyMap(), Collections.emptyMap()); + + assertNotNull(result); + IInputParser parser = (IInputParser) result; + // Defaults are all true + assertTrue(parser.getConfig().isAppendExpressions()); + assertTrue(parser.getConfig().isIncludeUnused()); + assertTrue(parser.getConfig().isIncludeUnknown()); + } + + @Test + @DisplayName("throws UnrecognizedExtensionException for unknown normalizer type") + void configure_unknownNormalizerType_throws() { + Map extensions = new HashMap<>(); + List> normalizers = List.of( + Map.of("type", "eddi://unknown.normalizer")); + extensions.put("normalizer", normalizers); + + assertThrows(UnrecognizedExtensionException.class, + () -> task.configure(Collections.emptyMap(), extensions)); + } + + @Test + @DisplayName("throws UnrecognizedExtensionException for unknown dictionary type") + void configure_unknownDictionaryType_throws() { + Map extensions = new HashMap<>(); + List> dictionaries = List.of( + Map.of("type", "eddi://unknown.dictionary")); + extensions.put("dictionaries", dictionaries); + + assertThrows(UnrecognizedExtensionException.class, + () -> task.configure(Collections.emptyMap(), extensions)); + } + + @Test + @DisplayName("throws UnrecognizedExtensionException for unknown correction type") + void configure_unknownCorrectionType_throws() { + Map extensions = new HashMap<>(); + List> corrections = List.of( + Map.of("type", "eddi://unknown.correction")); + extensions.put("corrections", corrections); + + assertThrows(UnrecognizedExtensionException.class, + () -> task.configure(Collections.emptyMap(), extensions)); + } + + @Test + @DisplayName("wires normalizer provider with config map") + void configure_normalizerWithConfig() throws Exception { + INormalizerProvider normalizerProvider = mock(INormalizerProvider.class); + INormalizer normalizer = mock(INormalizer.class); + when(normalizerProvider.provide(anyMap())).thenReturn(normalizer); + + @SuppressWarnings("unchecked") + Provider provider = mock(Provider.class); + when(provider.get()).thenReturn(normalizerProvider); + normalizerProviders.put("test.normalizer", provider); + + Map extensions = new HashMap<>(); + Map normalizerEntry = new HashMap<>(); + normalizerEntry.put("type", "eddi://test.normalizer"); + normalizerEntry.put("config", Map.of("key", "value")); + extensions.put("normalizer", List.of(normalizerEntry)); + + var result = task.configure(Collections.emptyMap(), extensions); + assertNotNull(result); + verify(normalizerProvider).provide(argThat(map -> "value".equals(map.get("key")))); + } + + @Test + @DisplayName("wires dictionary provider without config (empty map fallback)") + void configure_dictionaryWithoutConfig() throws Exception { + IDictionaryProvider dictionaryProvider = mock(IDictionaryProvider.class); + IDictionary dictionary = mock(IDictionary.class); + when(dictionaryProvider.provide(anyMap())).thenReturn(dictionary); + + @SuppressWarnings("unchecked") + Provider provider = mock(Provider.class); + when(provider.get()).thenReturn(dictionaryProvider); + dictionaryProviders.put("test.dictionary", provider); + + Map extensions = new HashMap<>(); + Map dictionaryEntry = new HashMap<>(); + dictionaryEntry.put("type", "eddi://test.dictionary"); + // no "config" key + extensions.put("dictionaries", List.of(dictionaryEntry)); + + var result = task.configure(Collections.emptyMap(), extensions); + assertNotNull(result); + verify(dictionaryProvider).provide(eq(Collections.emptyMap())); + } + + @Test + @DisplayName("wires correction provider and calls init with dictionaries") + void configure_correctionInitWithDictionaries() throws Exception { + ICorrectionProvider correctionProvider = mock(ICorrectionProvider.class); + ICorrection correction = mock(ICorrection.class); + when(correctionProvider.provide(anyMap())).thenReturn(correction); + + @SuppressWarnings("unchecked") + Provider provider = mock(Provider.class); + when(provider.get()).thenReturn(correctionProvider); + correctionProviders.put("test.correction", provider); + + Map extensions = new HashMap<>(); + extensions.put("corrections", List.of(Map.of("type", "eddi://test.correction"))); + + task.configure(Collections.emptyMap(), extensions); + verify(correction).init(anyList()); + } + + @Test + @DisplayName("configure with null extensions does not throw") + void configure_nullExtensions_handledGracefully() throws Exception { + var result = task.configure(Collections.emptyMap(), null); + assertNotNull(result); + } + } + + // ==================== ExtensionDescriptor ==================== + + @Nested + @DisplayName("ExtensionDescriptor") + class ExtensionDescriptorTests { + + @Test + @DisplayName("returns descriptor with correct ID and display name") + void testExtensionDescriptor() { + var descriptor = task.getExtensionDescriptor(); + + assertNotNull(descriptor); + assertEquals("ai.labs.parser", descriptor.getType()); + assertEquals("Input Parser", descriptor.getDisplayName()); + } + + @Test + @DisplayName("descriptor contains appendExpressions, includeUnused, includeUnknown configs") + void testExtensionDescriptorConfigs() { + var descriptor = task.getExtensionDescriptor(); + + var configs = descriptor.getConfigs(); + assertTrue(configs.containsKey("appendExpressions")); + assertTrue(configs.containsKey("includeUnused")); + assertTrue(configs.containsKey("includeUnknown")); + } + + @Test + @DisplayName("descriptor includes sub-extensions from registered providers") + void testExtensionDescriptorWithProviders() { + // Register a normalizer provider + INormalizerProvider normalizerProvider = mock(INormalizerProvider.class); + when(normalizerProvider.getDisplayName()).thenReturn("Test Normalizer"); + when(normalizerProvider.getConfigs()).thenReturn(Map.of()); + @SuppressWarnings("unchecked") + Provider provider = mock(Provider.class); + when(provider.get()).thenReturn(normalizerProvider); + normalizerProviders.put("test.normalizer", provider); + + var descriptor = task.getExtensionDescriptor(); + + assertNotNull(descriptor); + Map> extensions = descriptor.getExtensions(); + assertNotNull(extensions.get("normalizer")); + assertFalse(extensions.get("normalizer").isEmpty()); + } + } +} diff --git a/src/test/java/ai/labs/eddi/modules/nlp/extensions/corrections/PhoneticCorrectionTest.java b/src/test/java/ai/labs/eddi/modules/nlp/extensions/corrections/PhoneticCorrectionTest.java index c1d7cd5e4..25e0f81b7 100644 --- a/src/test/java/ai/labs/eddi/modules/nlp/extensions/corrections/PhoneticCorrectionTest.java +++ b/src/test/java/ai/labs/eddi/modules/nlp/extensions/corrections/PhoneticCorrectionTest.java @@ -55,4 +55,26 @@ void correctWord_anotherKnownWord() { assertNotNull(result); assertFalse(result.isEmpty()); } + + @Test + void correctWord_unknownWord_returnsEmptyList() { + // Regression test for NPE fix: unknown words with no phonetic match + // should return an empty list, not throw NullPointerException + var result = correction.correctWord("xyzzy12345", null, Collections.emptyList()); + assertNotNull(result); + assertTrue(result.isEmpty()); + } + + @Test + void init_emptyDictionary() { + var empty = new PhoneticCorrection(false); + var dictionary = mock(IDictionary.class); + when(dictionary.getWords()).thenReturn(Collections.emptyList()); + empty.init(List.of(dictionary)); + + // Should handle empty dictionaries gracefully + var result = empty.correctWord("anything", null, Collections.emptyList()); + assertNotNull(result); + assertTrue(result.isEmpty()); + } } diff --git a/src/test/java/ai/labs/eddi/modules/output/OutputGenerationTaskTest.java b/src/test/java/ai/labs/eddi/modules/output/OutputGenerationTaskTest.java new file mode 100644 index 000000000..6ddd91291 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/output/OutputGenerationTaskTest.java @@ -0,0 +1,209 @@ +package ai.labs.eddi.modules.output; + +import ai.labs.eddi.configs.output.model.OutputConfiguration; +import ai.labs.eddi.configs.output.model.OutputConfigurationSet; +import ai.labs.eddi.engine.TestMemoryFactory; +import ai.labs.eddi.engine.TestMemoryFactory.MemoryContext; +import ai.labs.eddi.engine.lifecycle.exceptions.WorkflowConfigurationException; +import ai.labs.eddi.engine.memory.IConversationMemory; +import ai.labs.eddi.engine.memory.IData; +import ai.labs.eddi.engine.memory.IDataFactory; +import ai.labs.eddi.engine.memory.model.ConversationProperties; +import ai.labs.eddi.engine.memory.model.Data; +import ai.labs.eddi.engine.model.Context; +import ai.labs.eddi.engine.runtime.client.configuration.IResourceClientLibrary; +import ai.labs.eddi.engine.runtime.service.ServiceException; +import ai.labs.eddi.modules.output.impl.OutputGenerationTask; +import ai.labs.eddi.modules.output.model.OutputEntry; +import ai.labs.eddi.modules.output.model.OutputValue; +import ai.labs.eddi.modules.output.model.QuickReply; +import ai.labs.eddi.modules.output.model.types.TextOutputItem; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.net.URI; +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; + +/** + * Tests for {@link OutputGenerationTask} — output selection lifecycle task. + */ +@DisplayName("OutputGenerationTask") +class OutputGenerationTaskTest { + + private OutputGenerationTask task; + private IResourceClientLibrary resourceClientLibrary; + private IDataFactory dataFactory; + private ObjectMapper objectMapper; + + @BeforeEach + void setUp() { + resourceClientLibrary = mock(IResourceClientLibrary.class); + dataFactory = mock(IDataFactory.class); + objectMapper = new ObjectMapper(); + task = new OutputGenerationTask(resourceClientLibrary, dataFactory, objectMapper); + + // Default data factory stub — return a Data wrapper + when(dataFactory.createData(anyString(), any(), any(List.class))).thenAnswer(invocation -> { + var data = new Data<>(invocation.getArgument(0).toString(), invocation.getArgument(1)); + return data; + }); + when(dataFactory.createData(anyString(), any())).thenAnswer(invocation -> { + var data = new Data<>(invocation.getArgument(0).toString(), invocation.getArgument(1)); + return data; + }); + } + + // ==================== Identity ==================== + + @Test + @DisplayName("getId returns correct identifier") + void testGetId() { + assertEquals("ai.labs.output", task.getId()); + } + + @Test + @DisplayName("getType returns 'output'") + void testGetType() { + assertEquals("output", task.getType()); + } + + // ==================== execute() ==================== + + @Nested + @DisplayName("execute()") + class ExecuteTests { + + @Test + @DisplayName("handles null outputGeneration component gracefully") + void execute_nullComponent_handlesGracefully() { + MemoryContext ctx = TestMemoryFactory.create(); + + // Should not throw + assertDoesNotThrow(() -> task.execute(ctx.memory(), null)); + } + + @Test + @DisplayName("returns early when no actions in current step") + void execute_noActions_returnsEarly() { + MemoryContext ctx = TestMemoryFactory.create(); + IOutputGeneration outputGen = mock(IOutputGeneration.class); + when(outputGen.getLanguage()).thenReturn(null); // any language + + task.execute(ctx.memory(), outputGen); + + // Should not attempt to get outputs + verify(outputGen, never()).getOutputs(anyList()); + } + + @Test + @DisplayName("skips output generation when language does not match") + void execute_languageMismatch_skipsGeneration() { + MemoryContext ctx = TestMemoryFactory.createWithActions(List.of("greet")); + IOutputGeneration outputGen = mock(IOutputGeneration.class); + when(outputGen.getLanguage()).thenReturn("de"); // German + + // No language property set in conversation = null, won't match "de" + // Actually, null language in memory means "any" — but output language + // requires a match. Let's set the conversation property language. + ctx.conversationProperties().put("language", + new ai.labs.eddi.configs.properties.model.Property("language", "en", + ai.labs.eddi.configs.properties.model.Property.Scope.longTerm)); + + task.execute(ctx.memory(), outputGen); + + verify(outputGen, never()).getOutputs(anyList()); + } + + @Test + @DisplayName("generates output when action matches and language is null (any)") + void execute_matchingAction_generatesOutput() { + MemoryContext ctx = TestMemoryFactory.createWithActions(List.of("greet")); + IOutputGeneration outputGen = mock(IOutputGeneration.class); + when(outputGen.getLanguage()).thenReturn(null); // any language + + TextOutputItem textItem = new TextOutputItem("Hello!", 0); + OutputValue outputValue = new OutputValue(); + outputValue.setValueAlternatives(List.of(textItem)); + OutputEntry entry = new OutputEntry("greet", 0, + List.of(outputValue), Collections.emptyList()); + + when(outputGen.getOutputs(anyList())).thenReturn(Map.of("greet", List.of(entry))); + + // Set up previous steps for action occurrence counting + when(ctx.previousSteps().size()).thenReturn(0); + + task.execute(ctx.memory(), outputGen); + + verify(outputGen).getOutputs(anyList()); + verify(ctx.currentStep(), atLeastOnce()).storeData(any()); + } + } + + // ==================== configure() ==================== + + @Nested + @DisplayName("configure()") + class ConfigureTests { + + @Test + @DisplayName("returns null when no URI configured") + void configure_noUri_returnsNull() throws WorkflowConfigurationException { + var result = task.configure(Collections.emptyMap(), null); + assertNull(result); + } + + @Test + @DisplayName("throws WorkflowConfigurationException on service error") + void configure_serviceError_throws() throws ServiceException { + when(resourceClientLibrary.getResource(any(URI.class), eq(OutputConfigurationSet.class))) + .thenThrow(new ServiceException("not found")); + + var config = Map.of("uri", "eddi://ai.labs.output/outputstore/outputsets/abc123"); + + assertThrows(WorkflowConfigurationException.class, + () -> task.configure(config, null)); + } + + @Test + @DisplayName("loads and sorts output configuration from URI") + void configure_validUri_loadsConfig() throws Exception { + OutputConfigurationSet configSet = new OutputConfigurationSet(); + configSet.setLang(null); + OutputConfiguration oc = new OutputConfiguration(); + oc.setAction("greet"); + oc.setTimesOccurred(0); + oc.setOutputs(Collections.emptyList()); + oc.setQuickReplies(Collections.emptyList()); + configSet.setOutputSet(new ArrayList<>(List.of(oc))); + + when(resourceClientLibrary.getResource(any(URI.class), eq(OutputConfigurationSet.class))) + .thenReturn(configSet); + + var config = Map.of("uri", "eddi://ai.labs.output/outputstore/outputsets/abc123"); + var result = task.configure(config, null); + + assertNotNull(result); + assertTrue(result instanceof IOutputGeneration); + } + } + + // ==================== ExtensionDescriptor ==================== + + @Test + @DisplayName("getExtensionDescriptor returns correct descriptor") + void testExtensionDescriptor() { + var descriptor = task.getExtensionDescriptor(); + + assertNotNull(descriptor); + assertEquals("ai.labs.output", descriptor.getType()); + assertEquals("Output Generation", descriptor.getDisplayName()); + assertTrue(descriptor.getConfigs().containsKey("uri")); + } +} diff --git a/src/test/java/ai/labs/eddi/utils/LanguageUtilitiesTest.java b/src/test/java/ai/labs/eddi/utils/LanguageUtilitiesTest.java index ca74e5065..3a484504d 100644 --- a/src/test/java/ai/labs/eddi/utils/LanguageUtilitiesTest.java +++ b/src/test/java/ai/labs/eddi/utils/LanguageUtilitiesTest.java @@ -5,7 +5,6 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; -import org.junit.jupiter.params.provider.NullAndEmptySource; import org.junit.jupiter.params.provider.ValueSource; import java.util.Date; From cf01ef6b97cb8ab0e7faa72236f2bb5fceec27c1 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 15:31:06 +0200 Subject: [PATCH 028/124] test(coverage): add 72 new unit tests for LlmTask, LifecycleManager, OutputGenerationTask, PropertySetterTask, McpCallsTask - LlmTask: +20 tests covering convertToObject, responseObjectName, addToOutput=false, rolling summary, token-aware windowing, resolveModelName, snippets, multiple tasks, cascade skip - LifecycleManager: +15 tests covering task execution, selective execution, STOP_CONVERSATION, strict write discipline, event sink, audit collector - OutputGenerationTask: +13 tests covering null component, action matching, language filtering, quick replies, configure - PropertySetterTask: +11 tests covering action matching, wildcards, override, value types, context expressions, CATCH_ANY_INPUT - McpCallsTask: +13 tests covering action matching, wildcards, blacklist, tool discovery, configure Total: 3,520 tests (up from 3,448), all passing --- .../internal/LifecycleManagerTest.java | 414 +++++++++++++ .../eddi/modules/llm/impl/LlmTaskTest.java | 586 +++++++++++++++++- .../mcpcalls/impl/McpCallsTaskTest.java | 324 ++++++++++ .../output/impl/OutputGenerationTaskTest.java | 327 ++++++++++ .../impl/PropertySetterTaskTest.java | 439 +++++++++++++ 5 files changed, 2089 insertions(+), 1 deletion(-) create mode 100644 src/test/java/ai/labs/eddi/engine/lifecycle/internal/LifecycleManagerTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/mcpcalls/impl/McpCallsTaskTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/output/impl/OutputGenerationTaskTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/properties/impl/PropertySetterTaskTest.java diff --git a/src/test/java/ai/labs/eddi/engine/lifecycle/internal/LifecycleManagerTest.java b/src/test/java/ai/labs/eddi/engine/lifecycle/internal/LifecycleManagerTest.java new file mode 100644 index 000000000..3a9ee0141 --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/lifecycle/internal/LifecycleManagerTest.java @@ -0,0 +1,414 @@ +package ai.labs.eddi.engine.lifecycle.internal; + +import ai.labs.eddi.configs.agents.model.AgentConfiguration; +import ai.labs.eddi.datastore.IResourceStore; +import ai.labs.eddi.engine.lifecycle.IComponentCache; +import ai.labs.eddi.engine.lifecycle.IConversation; +import ai.labs.eddi.engine.lifecycle.ILifecycleTask; +import ai.labs.eddi.engine.lifecycle.exceptions.ConversationStopException; +import ai.labs.eddi.engine.lifecycle.exceptions.LifecycleException; +import ai.labs.eddi.engine.memory.ConversationStep; +import ai.labs.eddi.engine.memory.IConversationMemory; +import ai.labs.eddi.engine.memory.IData; +import ai.labs.eddi.engine.memory.model.Data; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +import static ai.labs.eddi.engine.memory.MemoryKeys.ACTIONS; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +@DisplayName("LifecycleManager Tests") +class LifecycleManagerTest { + + private IComponentCache componentCache; + private IResourceStore.IResourceId workflowId; + private LifecycleManager lifecycleManager; + + @BeforeEach + void setUp() { + componentCache = mock(IComponentCache.class); + workflowId = mock(IResourceStore.IResourceId.class); + when(workflowId.getId()).thenReturn("wf1"); + when(workflowId.getVersion()).thenReturn(1); + + lifecycleManager = new LifecycleManager(componentCache, workflowId); + } + + @Nested + @DisplayName("addLifecycleTask") + class AddLifecycleTaskTests { + + @Test + @DisplayName("null task throws IllegalArgumentException") + void addNull() { + assertThrows(IllegalArgumentException.class, () -> lifecycleManager.addLifecycleTask(null)); + } + + @Test + @DisplayName("valid task is accepted") + void addValidTask() { + var task = mock(ILifecycleTask.class); + when(task.getId()).thenReturn("task1"); + assertDoesNotThrow(() -> lifecycleManager.addLifecycleTask(task)); + } + } + + @Nested + @DisplayName("executeLifecycle") + class ExecuteLifecycleTests { + + @Test + @DisplayName("null memory throws IllegalArgumentException") + void nullMemory() { + assertThrows(IllegalArgumentException.class, + () -> lifecycleManager.executeLifecycle(null, null)); + } + + @Test + @DisplayName("empty task list completes without exception") + void emptyTaskList() { + var memory = mock(IConversationMemory.class); + assertDoesNotThrow(() -> lifecycleManager.executeLifecycle(memory, null)); + } + + @Test + @DisplayName("single task executes successfully") + void singleTask() throws Exception { + var task = mock(ILifecycleTask.class); + when(task.getId()).thenReturn("parser"); + when(task.getType()).thenReturn("input"); + + lifecycleManager.addLifecycleTask(task); + + var memory = mock(IConversationMemory.class); + var currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + + when(componentCache.getComponentMap("parser")).thenReturn(new HashMap<>()); + + lifecycleManager.executeLifecycle(memory, null); + + verify(task).execute(eq(memory), any()); + } + + @Test + @DisplayName("multiple tasks execute in order") + void multipleTasks() throws Exception { + var task1 = mock(ILifecycleTask.class); + when(task1.getId()).thenReturn("parser"); + when(task1.getType()).thenReturn("input"); + + var task2 = mock(ILifecycleTask.class); + when(task2.getId()).thenReturn("behavior"); + when(task2.getType()).thenReturn("behavior_rules"); + + lifecycleManager.addLifecycleTask(task1); + lifecycleManager.addLifecycleTask(task2); + + var memory = mock(IConversationMemory.class); + var currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + + when(componentCache.getComponentMap(anyString())).thenReturn(new HashMap<>()); + + lifecycleManager.executeLifecycle(memory, null); + + var inOrder = inOrder(task1, task2); + inOrder.verify(task1).execute(eq(memory), any()); + inOrder.verify(task2).execute(eq(memory), any()); + } + + @Test + @DisplayName("STOP_CONVERSATION action throws ConversationStopException") + void stopConversation() throws Exception { + var task = mock(ILifecycleTask.class); + when(task.getId()).thenReturn("behavior"); + when(task.getType()).thenReturn("behavior_rules"); + + lifecycleManager.addLifecycleTask(task); + + var memory = mock(IConversationMemory.class); + var currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + + when(componentCache.getComponentMap(anyString())).thenReturn(new HashMap<>()); + + // Simulate STOP_CONVERSATION action + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of(IConversation.STOP_CONVERSATION)); + + assertThrows(ConversationStopException.class, + () -> lifecycleManager.executeLifecycle(memory, null)); + } + + @Test + @DisplayName("task failure propagates LifecycleException") + void taskFailure() throws Exception { + var task = mock(ILifecycleTask.class); + when(task.getId()).thenReturn("llm"); + when(task.getType()).thenReturn("langchain"); + + doThrow(new LifecycleException("LLM failed")) + .when(task).execute(any(), any()); + + lifecycleManager.addLifecycleTask(task); + + var memory = mock(IConversationMemory.class); + var currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + + when(componentCache.getComponentMap(anyString())).thenReturn(new HashMap<>()); + + assertThrows(LifecycleException.class, + () -> lifecycleManager.executeLifecycle(memory, null)); + } + + @Test + @DisplayName("RuntimeException in task is wrapped in LifecycleException") + void runtimeException() throws Exception { + var task = mock(ILifecycleTask.class); + when(task.getId()).thenReturn("broken"); + when(task.getType()).thenReturn("custom"); + + doThrow(new RuntimeException("NPE")) + .when(task).execute(any(), any()); + + lifecycleManager.addLifecycleTask(task); + + var memory = mock(IConversationMemory.class); + var currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + + when(componentCache.getComponentMap(anyString())).thenReturn(new HashMap<>()); + + assertThrows(LifecycleException.class, + () -> lifecycleManager.executeLifecycle(memory, null)); + } + } + + @Nested + @DisplayName("Selective Execution (lifecycleTaskTypes)") + class SelectiveExecutionTests { + + @Test + @DisplayName("filter by type — only matching and subsequent tasks execute") + void filterByType() throws Exception { + var parser = mock(ILifecycleTask.class); + when(parser.getId()).thenReturn("parser"); + when(parser.getType()).thenReturn("input"); + + var behavior = mock(ILifecycleTask.class); + when(behavior.getId()).thenReturn("behavior"); + when(behavior.getType()).thenReturn("behavior_rules"); + + var output = mock(ILifecycleTask.class); + when(output.getId()).thenReturn("output"); + when(output.getType()).thenReturn("output"); + + lifecycleManager.addLifecycleTask(parser); + lifecycleManager.addLifecycleTask(behavior); + lifecycleManager.addLifecycleTask(output); + + var memory = mock(IConversationMemory.class); + var currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + + when(componentCache.getComponentMap(anyString())).thenReturn(new HashMap<>()); + + // Execute only from "behavior_rules" onward + lifecycleManager.executeLifecycle(memory, List.of("behavior_rules")); + + verify(parser, never()).execute(any(), any()); + verify(behavior).execute(eq(memory), any()); + verify(output).execute(eq(memory), any()); + } + + @Test + @DisplayName("filter with no match — no tasks execute") + void filterNoMatch() throws Exception { + var parser = mock(ILifecycleTask.class); + when(parser.getId()).thenReturn("parser"); + when(parser.getType()).thenReturn("input"); + + lifecycleManager.addLifecycleTask(parser); + + var memory = mock(IConversationMemory.class); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + + lifecycleManager.executeLifecycle(memory, List.of("nonexistent_type")); + + verify(parser, never()).execute(any(), any()); + } + } + + @Nested + @DisplayName("Strict Write Discipline") + class StrictWriteDisciplineTests { + + @Test + @DisplayName("task failure with strict write enabled — uncommits data and injects error digest") + void taskFailureWithStrictWrite() throws Exception { + var task = mock(ILifecycleTask.class); + when(task.getId()).thenReturn("llm_task"); + when(task.getType()).thenReturn("langchain"); + + doThrow(new LifecycleException("API timeout")) + .when(task).execute(any(), any()); + + lifecycleManager.addLifecycleTask(task); + + var memory = mock(IConversationMemory.class); + var currentStep = mock(ConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + + // Enable strict write discipline + var memoryPolicy = new AgentConfiguration.MemoryPolicy(); + var swd = new AgentConfiguration.StrictWriteDiscipline(); + swd.setEnabled(true); + swd.setOnFailure("digest"); + memoryPolicy.setStrictWriteDiscipline(swd); + when(memory.getMemoryPolicy()).thenReturn(memoryPolicy); + + // Pre-execution snapshot + when(currentStep.snapshotDataIdentities()).thenReturn(new HashMap<>()); + when(currentStep.snapshotOutputKeys()).thenReturn(new java.util.HashSet<>()); + when(currentStep.getAllElements()).thenReturn(new LinkedList<>()); + when(currentStep.getConversationOutput()).thenReturn(new ai.labs.eddi.engine.memory.model.ConversationOutput()); + + when(componentCache.getComponentMap(anyString())).thenReturn(new HashMap<>()); + + assertThrows(LifecycleException.class, + () -> lifecycleManager.executeLifecycle(memory, null)); + + // Verify error digest was injected + verify(currentStep).addConversationOutputList(eq("taskErrors"), anyList()); + verify(currentStep).storeData(any(Data.class)); + } + + @Test + @DisplayName("task failure with strict write exclude_all — no digest, but data uncommitted") + void taskFailureExcludeAll() throws Exception { + var task = mock(ILifecycleTask.class); + when(task.getId()).thenReturn("api_task"); + when(task.getType()).thenReturn("httpcalls"); + + doThrow(new LifecycleException("API error")) + .when(task).execute(any(), any()); + + lifecycleManager.addLifecycleTask(task); + + var memory = mock(IConversationMemory.class); + var currentStep = mock(ConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + + var memoryPolicy = new AgentConfiguration.MemoryPolicy(); + var swd = new AgentConfiguration.StrictWriteDiscipline(); + swd.setEnabled(true); + swd.setOnFailure("exclude_all"); + memoryPolicy.setStrictWriteDiscipline(swd); + when(memory.getMemoryPolicy()).thenReturn(memoryPolicy); + + when(currentStep.snapshotDataIdentities()).thenReturn(new HashMap<>()); + when(currentStep.snapshotOutputKeys()).thenReturn(new java.util.HashSet<>()); + when(currentStep.getAllElements()).thenReturn(new LinkedList<>()); + when(currentStep.getConversationOutput()).thenReturn(new ai.labs.eddi.engine.memory.model.ConversationOutput()); + + when(componentCache.getComponentMap(anyString())).thenReturn(new HashMap<>()); + + assertThrows(LifecycleException.class, + () -> lifecycleManager.executeLifecycle(memory, null)); + + // Verify failure action was still injected (always happens) + verify(currentStep, atLeastOnce()).set(eq(ACTIONS), anyList()); + } + } + + @Nested + @DisplayName("Event Sink Integration") + class EventSinkTests { + + @Test + @DisplayName("event sink receives task_start and task_complete events") + void eventSinkNotified() throws Exception { + var task = mock(ILifecycleTask.class); + when(task.getId()).thenReturn("parser"); + when(task.getType()).thenReturn("input"); + + lifecycleManager.addLifecycleTask(task); + + var memory = mock(IConversationMemory.class); + var currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + + var eventSink = mock(ai.labs.eddi.engine.lifecycle.ConversationEventSink.class); + when(memory.getEventSink()).thenReturn(eventSink); + + when(componentCache.getComponentMap(anyString())).thenReturn(new HashMap<>()); + + lifecycleManager.executeLifecycle(memory, null); + + verify(eventSink).onTaskStart("parser", "input", 0); + verify(eventSink).onTaskComplete(eq("parser"), eq("input"), anyLong(), anyMap()); + } + } + + @Nested + @DisplayName("Audit Collector Integration") + class AuditCollectorTests { + + @Test + @DisplayName("audit collector receives audit entry when set") + void auditCollectorNotified() throws Exception { + var task = mock(ILifecycleTask.class); + when(task.getId()).thenReturn("behavior"); + when(task.getType()).thenReturn("behavior_rules"); + + lifecycleManager.addLifecycleTask(task); + + var memory = mock(IConversationMemory.class); + var currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + when(memory.getAgentVersion()).thenReturn(1); + when(memory.size()).thenReturn(1); + + var auditCollector = mock(ai.labs.eddi.engine.audit.IAuditEntryCollector.class); + when(memory.getAuditCollector()).thenReturn(auditCollector); + + when(componentCache.getComponentMap(anyString())).thenReturn(new HashMap<>()); + + lifecycleManager.executeLifecycle(memory, null); + + verify(auditCollector).collect(any()); + } + } +} diff --git a/src/test/java/ai/labs/eddi/modules/llm/impl/LlmTaskTest.java b/src/test/java/ai/labs/eddi/modules/llm/impl/LlmTaskTest.java index ddea49e46..7688ede51 100644 --- a/src/test/java/ai/labs/eddi/modules/llm/impl/LlmTaskTest.java +++ b/src/test/java/ai/labs/eddi/modules/llm/impl/LlmTaskTest.java @@ -100,7 +100,7 @@ public ChatResponse chat(List messages) { chatModelRegistry, calculatorTool, dateTimeTool, webSearchTool, dataFormatterTool, webScraperTool, textSummarizerTool, pdfReaderTool, weatherTool, apiCallExecutor, toolExecutionService, mock(McpToolProviderManager.class), mock(A2AToolProviderManager.class), mock(IRestAgentStore.class), mock(IRestWorkflowStore.class), mock(RagContextProvider.class), mock(IUserMemoryStore.class), - mock(TokenCounterFactory.class), mock(ConversationSummarizer.class), + new TokenCounterFactory(), mock(ConversationSummarizer.class), mock(PromptSnippetService.class), toolResponseTruncator, mock(ai.labs.eddi.engine.tenancy.TenantQuotaService.class)); } @@ -1047,4 +1047,588 @@ void testHttpCallRag_notFound_graceful() throws Exception { verify(currentStep, atLeastOnce()).storeData(any(IData.class)); } } + + @Nested + @DisplayName("convertToObject Tests") + class ConvertToObjectTests { + + @Test + @DisplayName("convertToObject=true with valid JSON — should deserialize response") + void testConvertToObject_validJson() throws Exception { + IConversationMemory memory = mock(IConversationMemory.class); + IConversationMemory.IWritableConversationStep currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var conversationOutput = new ConversationOutput(); + conversationOutput.put("input", "get data"); + when(memory.getConversationOutputs()).thenReturn(List.of(conversationOutput)); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("action")); + + var task = new LlmConfiguration.Task(); + task.setActions(List.of("action")); + task.setId("jsonTask"); + task.setType("openai"); + task.setParameters(Map.of("systemMessage", "respond in JSON", + "apiKey", "key", "convertToObject", "true")); + + var llmConfig = new LlmConfiguration(List.of(task)); + + IData outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any())).thenReturn(outputData); + when(templatingEngine.processTemplate(anyString(), anyMap())).thenAnswer(i -> i.getArgument(0)); + + langChainTask.execute(memory, llmConfig); + + // Should store langchain data + verify(currentStep, atLeastOnce()).storeData(any(IData.class)); + } + + @Test + @DisplayName("convertToObject=true with responseSchema — should inject schema in system message") + void testConvertToObject_withResponseSchema() throws Exception { + IConversationMemory memory = mock(IConversationMemory.class); + IConversationMemory.IWritableConversationStep currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var conversationOutput = new ConversationOutput(); + conversationOutput.put("input", "get data"); + when(memory.getConversationOutputs()).thenReturn(List.of(conversationOutput)); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("action")); + + var task = new LlmConfiguration.Task(); + task.setActions(List.of("action")); + task.setId("schemaTask"); + task.setType("openai"); + task.setParameters(Map.of("systemMessage", "respond in JSON", + "apiKey", "key", "convertToObject", "true", + "responseSchema", "{\"type\":\"object\",\"properties\":{\"name\":{\"type\":\"string\"}}}")); + + var llmConfig = new LlmConfiguration(List.of(task)); + + IData outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any())).thenReturn(outputData); + when(templatingEngine.processTemplate(anyString(), anyMap())).thenAnswer(i -> i.getArgument(0)); + + langChainTask.execute(memory, llmConfig); + + // Verify schema was injected into template processing + verify(templatingEngine, atLeastOnce()).processTemplate(anyString(), anyMap()); + verify(currentStep, atLeastOnce()).storeData(any(IData.class)); + } + } + + @Nested + @DisplayName("Response Object Name Tests") + class ResponseObjectNameTests { + + @Test + @DisplayName("Custom responseObjectName — should use it instead of task ID") + void testCustomResponseObjectName() throws Exception { + IConversationMemory memory = mock(IConversationMemory.class); + IConversationMemory.IWritableConversationStep currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var conversationOutput = new ConversationOutput(); + conversationOutput.put("input", "hello"); + when(memory.getConversationOutputs()).thenReturn(List.of(conversationOutput)); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("action")); + + var task = new LlmConfiguration.Task(); + task.setActions(List.of("action")); + task.setId("taskId"); + task.setType("openai"); + task.setResponseObjectName("customResponseName"); + task.setParameters(Map.of("systemMessage", "be helpful", "apiKey", "key")); + + var llmConfig = new LlmConfiguration(List.of(task)); + + IData outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any())).thenReturn(outputData); + when(templatingEngine.processTemplate(anyString(), anyMap())).thenAnswer(i -> i.getArgument(0)); + + langChainTask.execute(memory, llmConfig); + + verify(currentStep, atLeastOnce()).storeData(any(IData.class)); + } + + @Test + @DisplayName("Custom responseMetadataObjectName — should store metadata") + void testResponseMetadataObjectName() throws Exception { + IConversationMemory memory = mock(IConversationMemory.class); + IConversationMemory.IWritableConversationStep currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var conversationOutput = new ConversationOutput(); + conversationOutput.put("input", "hello"); + when(memory.getConversationOutputs()).thenReturn(List.of(conversationOutput)); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("action")); + + var task = new LlmConfiguration.Task(); + task.setActions(List.of("action")); + task.setId("taskId"); + task.setType("openai"); + task.setResponseMetadataObjectName("metadata"); + task.setParameters(Map.of("systemMessage", "be helpful", "apiKey", "key")); + + var llmConfig = new LlmConfiguration(List.of(task)); + + IData outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any())).thenReturn(outputData); + when(templatingEngine.processTemplate(anyString(), anyMap())).thenAnswer(i -> i.getArgument(0)); + + langChainTask.execute(memory, llmConfig); + + verify(currentStep, atLeastOnce()).storeData(any(IData.class)); + } + } + + @Nested + @DisplayName("addToOutput Explicit False Tests") + class AddToOutputFalseTests { + + @Test + @DisplayName("addToOutput=false — should NOT add to conversation output or stream") + void testAddToOutputExplicitlyFalse() throws Exception { + IConversationMemory memory = mock(IConversationMemory.class); + IConversationMemory.IWritableConversationStep currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var eventSink = mock(ai.labs.eddi.engine.lifecycle.ConversationEventSink.class); + when(memory.getEventSink()).thenReturn(eventSink); + + var conversationOutput = new ConversationOutput(); + conversationOutput.put("input", "get data"); + when(memory.getConversationOutputs()).thenReturn(List.of(conversationOutput)); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("action")); + + var task = new LlmConfiguration.Task(); + task.setActions(List.of("action")); + task.setId("taskId"); + task.setType("openai"); + task.setParameters(Map.of("systemMessage", "extract data", + "apiKey", "key", "addToOutput", "false", + "convertToObject", "true")); + + var llmConfig = new LlmConfiguration(List.of(task)); + + IData outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any())).thenReturn(outputData); + when(templatingEngine.processTemplate(anyString(), anyMap())).thenAnswer(i -> i.getArgument(0)); + + langChainTask.execute(memory, llmConfig); + + // Should NOT add to conversation output list + verify(currentStep, never()).addConversationOutputList(eq(LlmTask.MEMORY_OUTPUT_IDENTIFIER), anyList()); + } + } + + @Nested + @DisplayName("Rolling Summary Tests") + class RollingSummaryTests { + + @Test + @DisplayName("Summary enabled but no existing summary — should still execute") + void testSummaryEnabled_noExistingSummary() throws Exception { + IConversationMemory memory = mock(IConversationMemory.class); + IConversationMemory.IWritableConversationStep currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var conversationOutput = new ConversationOutput(); + conversationOutput.put("input", "hello"); + when(memory.getConversationOutputs()).thenReturn(List.of(conversationOutput)); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("action")); + + var task = new LlmConfiguration.Task(); + task.setActions(List.of("action")); + task.setId("summaryTask"); + task.setType("openai"); + task.setParameters(Map.of("systemMessage", "be helpful", "apiKey", "key")); + + var summaryConfig = new LlmConfiguration.ConversationSummaryConfig(); + summaryConfig.setEnabled(true); + task.setConversationSummary(summaryConfig); + + var llmConfig = new LlmConfiguration(List.of(task)); + + IData outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any())).thenReturn(outputData); + when(templatingEngine.processTemplate(anyString(), anyMap())).thenAnswer(i -> i.getArgument(0)); + + // No existing summary in memory + when(currentStep.getLatestData("conversation:summary")).thenReturn(null); + + // Mock conversation properties (needed for summary properties exclusion check) + var conversationProperties = mock(IConversationMemory.IConversationProperties.class); + when(memory.getConversationProperties()).thenReturn(conversationProperties); + + assertDoesNotThrow(() -> langChainTask.execute(memory, llmConfig)); + verify(currentStep, atLeastOnce()).storeData(any(IData.class)); + } + + @Test + @DisplayName("Summary disabled — should skip summarization entirely") + void testSummaryDisabled() throws Exception { + IConversationMemory memory = mock(IConversationMemory.class); + IConversationMemory.IWritableConversationStep currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var conversationOutput = new ConversationOutput(); + conversationOutput.put("input", "hello"); + when(memory.getConversationOutputs()).thenReturn(List.of(conversationOutput)); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("action")); + + var task = new LlmConfiguration.Task(); + task.setActions(List.of("action")); + task.setId("noSummaryTask"); + task.setType("openai"); + task.setParameters(Map.of("systemMessage", "be helpful", "apiKey", "key")); + + var summaryConfig = new LlmConfiguration.ConversationSummaryConfig(); + summaryConfig.setEnabled(false); + task.setConversationSummary(summaryConfig); + + var llmConfig = new LlmConfiguration(List.of(task)); + + IData outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any())).thenReturn(outputData); + when(templatingEngine.processTemplate(anyString(), anyMap())).thenAnswer(i -> i.getArgument(0)); + + assertDoesNotThrow(() -> langChainTask.execute(memory, llmConfig)); + } + } + + @Nested + @DisplayName("Token-Aware Windowing Tests") + class TokenAwareWindowingTests { + + @Test + @DisplayName("maxContextTokens set — should use token-aware message building") + void testTokenAwareWindowingPath() throws Exception { + IConversationMemory memory = mock(IConversationMemory.class); + IConversationMemory.IWritableConversationStep currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var conversationOutput = new ConversationOutput(); + conversationOutput.put("input", "hello"); + when(memory.getConversationOutputs()).thenReturn(List.of(conversationOutput)); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("action")); + + var task = new LlmConfiguration.Task(); + task.setActions(List.of("action")); + task.setId("tokenTask"); + task.setType("openai"); + task.setMaxContextTokens(4096); + task.setAnchorFirstSteps(1); + task.setParameters(Map.of("systemMessage", "be helpful", + "apiKey", "key", "modelName", "gpt-4o")); + + var llmConfig = new LlmConfiguration(List.of(task)); + + IData outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any())).thenReturn(outputData); + when(templatingEngine.processTemplate(anyString(), anyMap())).thenAnswer(i -> i.getArgument(0)); + + assertDoesNotThrow(() -> langChainTask.execute(memory, llmConfig)); + verify(currentStep, atLeastOnce()).storeData(any(IData.class)); + } + } + + @Nested + @DisplayName("resolveModelName Tests") + class ResolveModelNameTests { + + private void executeWithModelParam(String paramKey, String paramValue) throws Exception { + IConversationMemory memory = mock(IConversationMemory.class); + IConversationMemory.IWritableConversationStep currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var conversationOutput = new ConversationOutput(); + conversationOutput.put("input", "hi"); + when(memory.getConversationOutputs()).thenReturn(List.of(conversationOutput)); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("action")); + + var task = new LlmConfiguration.Task(); + task.setActions(List.of("action")); + task.setId("modelNameTest"); + task.setType("openai"); + task.setMaxContextTokens(4096); + var params = new HashMap(); + params.put("systemMessage", "test"); + params.put("apiKey", "key"); + params.put(paramKey, paramValue); + task.setParameters(params); + + var llmConfig = new LlmConfiguration(List.of(task)); + + IData outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any())).thenReturn(outputData); + when(templatingEngine.processTemplate(anyString(), anyMap())).thenAnswer(i -> i.getArgument(0)); + + langChainTask.execute(memory, llmConfig); + verify(currentStep, atLeastOnce()).storeData(any(IData.class)); + } + + @Test + @DisplayName("modelName parameter key (OpenAI)") + void testModelName() throws Exception { + executeWithModelParam("modelName", "gpt-4o"); + } + + @Test + @DisplayName("model parameter key (Ollama)") + void testModel() throws Exception { + // Uses gpt-4o value to satisfy OpenAI tokenizer; tests that 'model' key is + // recognized + executeWithModelParam("model", "gpt-4o"); + } + + @Test + @DisplayName("modelId parameter key (Bedrock)") + void testModelId() throws Exception { + executeWithModelParam("modelId", "gpt-4o"); + } + + @Test + @DisplayName("deploymentName parameter key (Azure)") + void testDeploymentName() throws Exception { + executeWithModelParam("deploymentName", "gpt-4o"); + } + } + + @Nested + @DisplayName("Snippet Injection Tests") + class SnippetInjectionTests { + + @Test + @DisplayName("Snippets available — should be injected into template data") + void testSnippetsInjected() throws Exception { + IConversationMemory memory = mock(IConversationMemory.class); + IConversationMemory.IWritableConversationStep currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var conversationOutput = new ConversationOutput(); + conversationOutput.put("input", "hello"); + when(memory.getConversationOutputs()).thenReturn(List.of(conversationOutput)); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("action")); + + var task = new LlmConfiguration.Task(); + task.setActions(List.of("action")); + task.setId("snippetTask"); + task.setType("openai"); + task.setParameters(Map.of("systemMessage", "{{snippets.greeting}}", "apiKey", "key")); + + var llmConfig = new LlmConfiguration(List.of(task)); + + IData outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any())).thenReturn(outputData); + when(templatingEngine.processTemplate(anyString(), anyMap())).thenAnswer(i -> i.getArgument(0)); + + langChainTask.execute(memory, llmConfig); + + verify(currentStep, atLeastOnce()).storeData(any(IData.class)); + } + } + + @Nested + @DisplayName("Multiple Tasks Tests") + class MultipleTasksTests { + + @Test + @DisplayName("Two tasks matching different actions — only matching task executes") + void testMultipleTasksSelectiveExecution() throws Exception { + IConversationMemory memory = mock(IConversationMemory.class); + IConversationMemory.IWritableConversationStep currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var conversationOutput = new ConversationOutput(); + conversationOutput.put("input", "hello"); + when(memory.getConversationOutputs()).thenReturn(List.of(conversationOutput)); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("task1_action")); + + var task1 = new LlmConfiguration.Task(); + task1.setActions(List.of("task1_action")); + task1.setId("task1"); + task1.setType("openai"); + task1.setParameters(Map.of("systemMessage", "task1", "apiKey", "key", "addToOutput", "true")); + + var task2 = new LlmConfiguration.Task(); + task2.setActions(List.of("task2_action")); + task2.setId("task2"); + task2.setType("openai"); + task2.setParameters(Map.of("systemMessage", "task2", "apiKey", "key", "addToOutput", "true")); + + var llmConfig = new LlmConfiguration(List.of(task1, task2)); + + IData outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any())).thenReturn(outputData); + when(templatingEngine.processTemplate(anyString(), anyMap())).thenAnswer(i -> i.getArgument(0)); + + langChainTask.execute(memory, llmConfig); + + // Only one task should add to output + verify(currentStep, times(1)).addConversationOutputList(eq(LlmTask.MEMORY_OUTPUT_IDENTIFIER), anyList()); + } + } + + @Nested + @DisplayName("conversationHistoryLimit Tests") + class ConversationHistoryLimitTests { + + @Test + @DisplayName("conversationHistoryLimit on task — should override logSizeLimit param") + void testConversationHistoryLimitOverride() throws Exception { + IConversationMemory memory = mock(IConversationMemory.class); + IConversationMemory.IWritableConversationStep currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var conversationOutput = new ConversationOutput(); + conversationOutput.put("input", "hello"); + when(memory.getConversationOutputs()).thenReturn(List.of(conversationOutput)); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("action")); + + var task = new LlmConfiguration.Task(); + task.setActions(List.of("action")); + task.setId("histLimitTask"); + task.setType("openai"); + task.setConversationHistoryLimit(5); + task.setParameters(Map.of("systemMessage", "be helpful", "apiKey", "key")); + + var llmConfig = new LlmConfiguration(List.of(task)); + + IData outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any())).thenReturn(outputData); + when(templatingEngine.processTemplate(anyString(), anyMap())).thenAnswer(i -> i.getArgument(0)); + + assertDoesNotThrow(() -> langChainTask.execute(memory, llmConfig)); + verify(currentStep, atLeastOnce()).storeData(any(IData.class)); + } + } + + @Nested + @DisplayName("Cascade skipCascade Branch Tests") + class CascadeSkipBranchTests { + + @Test + @DisplayName("Agent mode with cascade but enableInAgentMode=false — should skip cascade") + void testCascadeSkippedInAgentMode() throws Exception { + IConversationMemory memory = mock(IConversationMemory.class); + IConversationMemory.IWritableConversationStep currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var conversationOutput = new ConversationOutput(); + conversationOutput.put("input", "hello"); + when(memory.getConversationOutputs()).thenReturn(List.of(conversationOutput)); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("action")); + + var task = new LlmConfiguration.Task(); + task.setActions(List.of("action")); + task.setId("agentCascade"); + task.setType("openai"); + task.setEnableBuiltInTools(true); // Agent mode + task.setBuiltInToolsWhitelist(List.of("calculator")); + task.setParameters(Map.of("systemMessage", "test", "apiKey", "key")); + + var cascade = new LlmConfiguration.ModelCascadeConfig(); + cascade.setEnabled(true); + cascade.setEnableInAgentMode(false); // Should skip cascade + cascade.setEvaluationStrategy("none"); + var step = new LlmConfiguration.CascadeStep(); + step.setType("openai"); + cascade.setSteps(List.of(step)); + task.setModelCascade(cascade); + + var llmConfig = new LlmConfiguration(List.of(task)); + + IData outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any())).thenReturn(outputData); + when(templatingEngine.processTemplate(anyString(), anyMap())).thenAnswer(i -> i.getArgument(0)); + + // Agent mode reaches CDI boundary — same pattern as testExecute_AgentMode + Throwable thrown = null; + try { + langChainTask.execute(memory, llmConfig); + } catch (Throwable t) { + thrown = t; + } + + // The cascade trace should NOT be stored (cascade was skipped) + verify(dataFactory, never()).createData(contains("cascade:trace"), any()); + } + } + + @Nested + @DisplayName("Empty Conversation Outputs Tests") + class EmptyConversationOutputsTests { + + @Test + @DisplayName("Empty conversation outputs — should produce empty messages and return early") + void testEmptyConversationOutputs() throws Exception { + IConversationMemory memory = mock(IConversationMemory.class); + IConversationMemory.IWritableConversationStep currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + // Empty conversation outputs — no messages to send + when(memory.getConversationOutputs()).thenReturn(List.of()); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("action")); + + var task = new LlmConfiguration.Task(); + task.setActions(List.of("action")); + task.setId("emptyTask"); + task.setType("openai"); + // No systemMessage — only user messages would generate content, but there are + // none + task.setParameters(Map.of("apiKey", "key")); + + var llmConfig = new LlmConfiguration(List.of(task)); + + IData outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any())).thenReturn(outputData); + when(templatingEngine.processTemplate(anyString(), anyMap())).thenAnswer(i -> i.getArgument(0)); + + // Should not throw — should return early when messages list is empty + assertDoesNotThrow(() -> langChainTask.execute(memory, llmConfig)); + } + } } diff --git a/src/test/java/ai/labs/eddi/modules/mcpcalls/impl/McpCallsTaskTest.java b/src/test/java/ai/labs/eddi/modules/mcpcalls/impl/McpCallsTaskTest.java new file mode 100644 index 000000000..91aa7338e --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/mcpcalls/impl/McpCallsTaskTest.java @@ -0,0 +1,324 @@ +package ai.labs.eddi.modules.mcpcalls.impl; + +import ai.labs.eddi.configs.mcpcalls.model.McpCall; +import ai.labs.eddi.configs.mcpcalls.model.McpCallsConfiguration; +import ai.labs.eddi.datastore.serialization.IJsonSerialization; +import ai.labs.eddi.engine.lifecycle.exceptions.LifecycleException; +import ai.labs.eddi.engine.lifecycle.exceptions.WorkflowConfigurationException; +import ai.labs.eddi.engine.memory.IConversationMemory; +import ai.labs.eddi.engine.memory.IConversationMemory.IWritableConversationStep; +import ai.labs.eddi.engine.memory.IData; +import ai.labs.eddi.engine.memory.IMemoryItemConverter; +import ai.labs.eddi.engine.runtime.client.configuration.IResourceClientLibrary; +import ai.labs.eddi.modules.apicalls.impl.PrePostUtils; +import ai.labs.eddi.modules.llm.impl.McpToolProviderManager; +import dev.langchain4j.agent.tool.ToolSpecification; +import dev.langchain4j.service.tool.ToolExecutor; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +@DisplayName("McpCallsTask Tests") +class McpCallsTaskTest { + + private IResourceClientLibrary resourceClientLibrary; + private IMemoryItemConverter memoryItemConverter; + private IJsonSerialization jsonSerialization; + private McpToolProviderManager mcpToolProviderManager; + private PrePostUtils prePostUtils; + private McpCallsTask task; + + @BeforeEach + void setUp() { + resourceClientLibrary = mock(IResourceClientLibrary.class); + memoryItemConverter = mock(IMemoryItemConverter.class); + jsonSerialization = mock(IJsonSerialization.class); + mcpToolProviderManager = mock(McpToolProviderManager.class); + prePostUtils = mock(PrePostUtils.class); + + task = new McpCallsTask(resourceClientLibrary, memoryItemConverter, + jsonSerialization, mcpToolProviderManager, prePostUtils); + } + + @Test + @DisplayName("getId returns correct ID") + void getId() { + assertEquals("ai.labs.mcpcalls", task.getId()); + } + + @Test + @DisplayName("getType returns 'mcpCalls'") + void getType() { + assertEquals("mcpCalls", task.getType()); + } + + @Test + @DisplayName("getExtensionDescriptor returns valid descriptor") + void getExtensionDescriptor() { + var descriptor = task.getExtensionDescriptor(); + assertNotNull(descriptor); + assertEquals("MCP Calls", descriptor.getDisplayName()); + assertTrue(descriptor.getConfigs().containsKey("uri")); + } + + @Nested + @DisplayName("execute Tests") + class ExecuteTests { + + @Test + @DisplayName("no actions data — returns early") + void noActions() throws Exception { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(currentStep.getLatestData("actions")).thenReturn(null); + + var config = new McpCallsConfiguration(); + + assertDoesNotThrow(() -> task.execute(memory, config)); + verify(mcpToolProviderManager, never()).discoverTools(anyList()); + } + + @Test + @DisplayName("actions but no mcpCalls configured — returns early") + void noMcpCalls() throws Exception { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var actionsData = mock(IData.class); + when(currentStep.getLatestData("actions")).thenReturn(actionsData); + when(actionsData.getResult()).thenReturn(List.of("some_action")); + + var config = new McpCallsConfiguration(); + config.setMcpCalls(List.of()); // empty + + assertDoesNotThrow(() -> task.execute(memory, config)); + verify(mcpToolProviderManager, never()).discoverTools(anyList()); + } + + @Test + @DisplayName("no tools discovered — logs warning and returns") + void noToolsDiscovered() throws Exception { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var actionsData = mock(IData.class); + when(currentStep.getLatestData("actions")).thenReturn(actionsData); + when(actionsData.getResult()).thenReturn(List.of("call_tool")); + + var mcpCall = new McpCall(); + mcpCall.setActions(List.of("call_tool")); + mcpCall.setToolName("test_tool"); + + var config = new McpCallsConfiguration(); + config.setMcpCalls(List.of(mcpCall)); + config.setMcpServerUrl("http://localhost:8080/mcp"); + + when(mcpToolProviderManager.discoverTools(anyList())).thenReturn(null); + + assertDoesNotThrow(() -> task.execute(memory, config)); + } + + @Test + @DisplayName("action matches and tool found — executes tool") + void actionMatchesAndToolFound() throws Exception { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var actionsData = mock(IData.class); + when(currentStep.getLatestData("actions")).thenReturn(actionsData); + when(actionsData.getResult()).thenReturn(List.of("call_weather")); + + var mcpCall = new McpCall(); + mcpCall.setActions(List.of("call_weather")); + mcpCall.setToolName("get_weather"); + mcpCall.setName("weather_call"); + + var config = new McpCallsConfiguration(); + config.setMcpCalls(List.of(mcpCall)); + config.setMcpServerUrl("http://localhost:8080/mcp"); + + var toolSpec = ToolSpecification.builder().name("get_weather").description("Get weather").build(); + var executor = mock(ToolExecutor.class); + when(executor.execute(any(), any())).thenReturn("{\"temp\": 72}"); + + var mcpTools = new McpToolProviderManager.McpToolsResult( + List.of(toolSpec), Map.of("get_weather", executor)); + when(mcpToolProviderManager.discoverTools(anyList())).thenReturn(mcpTools); + + when(memoryItemConverter.convert(memory)).thenReturn(new HashMap<>()); + + assertDoesNotThrow(() -> task.execute(memory, config)); + verify(executor).execute(any(), any()); + } + + @Test + @DisplayName("wildcard action — matches all") + void wildcardAction() throws Exception { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var actionsData = mock(IData.class); + when(currentStep.getLatestData("actions")).thenReturn(actionsData); + when(actionsData.getResult()).thenReturn(List.of("any_action")); + + var mcpCall = new McpCall(); + mcpCall.setActions(List.of("*")); // wildcard + mcpCall.setToolName("universal_tool"); + + var config = new McpCallsConfiguration(); + config.setMcpCalls(List.of(mcpCall)); + config.setMcpServerUrl("http://localhost:8080/mcp"); + + var toolSpec = ToolSpecification.builder().name("universal_tool").description("Universal").build(); + var executor = mock(ToolExecutor.class); + when(executor.execute(any(), any())).thenReturn("ok"); + + var mcpTools = new McpToolProviderManager.McpToolsResult( + List.of(toolSpec), Map.of("universal_tool", executor)); + when(mcpToolProviderManager.discoverTools(anyList())).thenReturn(mcpTools); + when(memoryItemConverter.convert(memory)).thenReturn(new HashMap<>()); + + assertDoesNotThrow(() -> task.execute(memory, config)); + verify(executor).execute(any(), any()); + } + + @Test + @DisplayName("tool blocked by blacklist — should not execute") + void toolBlacklisted() throws Exception { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var actionsData = mock(IData.class); + when(currentStep.getLatestData("actions")).thenReturn(actionsData); + when(actionsData.getResult()).thenReturn(List.of("call_dangerous")); + + var mcpCall = new McpCall(); + mcpCall.setActions(List.of("call_dangerous")); + mcpCall.setToolName("dangerous_tool"); + + var config = new McpCallsConfiguration(); + config.setMcpCalls(List.of(mcpCall)); + config.setMcpServerUrl("http://localhost:8080/mcp"); + config.setToolsBlacklist(List.of("dangerous_tool")); // blocked + + var toolSpec = ToolSpecification.builder().name("dangerous_tool").description("Dangerous").build(); + var executor = mock(ToolExecutor.class); + + var mcpTools = new McpToolProviderManager.McpToolsResult( + List.of(toolSpec), Map.of("dangerous_tool", executor)); + when(mcpToolProviderManager.discoverTools(anyList())).thenReturn(mcpTools); + when(memoryItemConverter.convert(memory)).thenReturn(new HashMap<>()); + + assertDoesNotThrow(() -> task.execute(memory, config)); + verify(executor, never()).execute(any(), any()); + } + + @Test + @DisplayName("action doesn't match — tool not executed") + void actionNoMatch() throws Exception { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var actionsData = mock(IData.class); + when(currentStep.getLatestData("actions")).thenReturn(actionsData); + when(actionsData.getResult()).thenReturn(List.of("greet")); + + var mcpCall = new McpCall(); + mcpCall.setActions(List.of("call_weather")); // doesn't match "greet" + mcpCall.setToolName("get_weather"); + + var config = new McpCallsConfiguration(); + config.setMcpCalls(List.of(mcpCall)); + config.setMcpServerUrl("http://localhost:8080/mcp"); + + var toolSpec = ToolSpecification.builder().name("get_weather").description("Get weather").build(); + var executor = mock(ToolExecutor.class); + + var mcpTools = new McpToolProviderManager.McpToolsResult( + List.of(toolSpec), Map.of("get_weather", executor)); + when(mcpToolProviderManager.discoverTools(anyList())).thenReturn(mcpTools); + when(memoryItemConverter.convert(memory)).thenReturn(new HashMap<>()); + + assertDoesNotThrow(() -> task.execute(memory, config)); + verify(executor, never()).execute(any(), any()); + } + + @Test + @DisplayName("null actions in mcpCall — skipped gracefully") + void nullActionsInCall() throws Exception { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var actionsData = mock(IData.class); + when(currentStep.getLatestData("actions")).thenReturn(actionsData); + when(actionsData.getResult()).thenReturn(List.of("greet")); + + var mcpCall = new McpCall(); + mcpCall.setActions(null); // null actions + mcpCall.setToolName("some_tool"); + + var config = new McpCallsConfiguration(); + config.setMcpCalls(List.of(mcpCall)); + config.setMcpServerUrl("http://localhost:8080/mcp"); + + var toolSpec = ToolSpecification.builder().name("some_tool").description("Tool").build(); + var mcpTools = new McpToolProviderManager.McpToolsResult( + List.of(toolSpec), Map.of("some_tool", mock(ToolExecutor.class))); + when(mcpToolProviderManager.discoverTools(anyList())).thenReturn(mcpTools); + when(memoryItemConverter.convert(memory)).thenReturn(new HashMap<>()); + + assertDoesNotThrow(() -> task.execute(memory, config)); + } + } + + @Nested + @DisplayName("configure Tests") + class ConfigureTests { + + @Test + @DisplayName("null URI — throws WorkflowConfigurationException") + void nullUri() { + var config = new HashMap(); + assertThrows(WorkflowConfigurationException.class, + () -> task.configure(config, Map.of())); + } + + @Test + @DisplayName("empty URI — throws WorkflowConfigurationException") + void emptyUri() { + var config = new HashMap(); + config.put("uri", ""); + assertThrows(WorkflowConfigurationException.class, + () -> task.configure(config, Map.of())); + } + + @Test + @DisplayName("valid URI — loads from resource library") + void validUri() throws Exception { + var config = new HashMap(); + config.put("uri", "eddi://ai.labs.mcpcalls/mcpcallsstore/abc?version=1"); + + var mcpConfig = new McpCallsConfiguration(); + when(resourceClientLibrary.getResource(any(), eq(McpCallsConfiguration.class))) + .thenReturn(mcpConfig); + + var result = task.configure(config, Map.of()); + assertNotNull(result); + assertSame(mcpConfig, result); + } + } +} diff --git a/src/test/java/ai/labs/eddi/modules/output/impl/OutputGenerationTaskTest.java b/src/test/java/ai/labs/eddi/modules/output/impl/OutputGenerationTaskTest.java new file mode 100644 index 000000000..f723b2e4c --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/output/impl/OutputGenerationTaskTest.java @@ -0,0 +1,327 @@ +package ai.labs.eddi.modules.output.impl; + +import ai.labs.eddi.engine.lifecycle.exceptions.WorkflowConfigurationException; +import ai.labs.eddi.engine.memory.IConversationMemory; +import ai.labs.eddi.engine.memory.IConversationMemory.*; +import ai.labs.eddi.engine.memory.IData; +import ai.labs.eddi.engine.memory.IDataFactory; +import ai.labs.eddi.engine.model.Context; +import ai.labs.eddi.engine.runtime.client.configuration.IResourceClientLibrary; +import ai.labs.eddi.modules.output.IOutputFilter; +import ai.labs.eddi.modules.output.IOutputGeneration; +import ai.labs.eddi.modules.output.model.OutputEntry; +import ai.labs.eddi.modules.output.model.OutputItem; +import ai.labs.eddi.modules.output.model.OutputValue; +import ai.labs.eddi.modules.output.model.QuickReply; +import ai.labs.eddi.modules.output.model.types.TextOutputItem; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static ai.labs.eddi.engine.memory.MemoryKeys.ACTIONS; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +@DisplayName("OutputGenerationTask Tests") +class OutputGenerationTaskTest { + + private IResourceClientLibrary resourceClientLibrary; + private IDataFactory dataFactory; + private OutputGenerationTask task; + + @BeforeEach + void setUp() { + resourceClientLibrary = mock(IResourceClientLibrary.class); + dataFactory = mock(IDataFactory.class); + var objectMapper = new ObjectMapper(); + + task = new OutputGenerationTask(resourceClientLibrary, dataFactory, objectMapper); + } + + @Test + @DisplayName("getId returns correct ID") + void getId() { + assertEquals("ai.labs.output", task.getId()); + } + + @Test + @DisplayName("getType returns 'output'") + void getType() { + assertEquals("output", task.getType()); + } + + @Test + @DisplayName("getExtensionDescriptor returns valid descriptor") + void getExtensionDescriptor() { + var descriptor = task.getExtensionDescriptor(); + assertNotNull(descriptor); + assertEquals("Output Generation", descriptor.getDisplayName()); + assertTrue(descriptor.getConfigs().containsKey("uri")); + } + + @Nested + @DisplayName("execute Tests") + class ExecuteTests { + + @Test + @DisplayName("null component — should handle context output only") + void nullComponent() { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(currentStep.getAllData("context")).thenReturn(List.of()); + + assertDoesNotThrow(() -> task.execute(memory, null)); + } + + @Test + @DisplayName("no actions — should return early after context processing") + void noActions() { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(currentStep.getAllData("context")).thenReturn(List.of()); + + var outputGen = mock(IOutputGeneration.class); + when(outputGen.getLanguage()).thenReturn(null); + + var properties = mock(IConversationProperties.class); + when(memory.getConversationProperties()).thenReturn(properties); + + when(currentStep.getLatestData(ACTIONS)).thenReturn(null); + + assertDoesNotThrow(() -> task.execute(memory, outputGen)); + verify(outputGen, never()).getOutputs(anyList()); + } + + @Test + @DisplayName("actions with matching output — stores output and quick replies") + void actionsWithOutput() { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(currentStep.getAllData("context")).thenReturn(List.of()); + + var outputGen = mock(IOutputGeneration.class); + when(outputGen.getLanguage()).thenReturn(null); + + var properties = mock(IConversationProperties.class); + when(memory.getConversationProperties()).thenReturn(properties); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("greet")); + + var previousSteps = mock(IConversationStepStack.class); + when(memory.getPreviousSteps()).thenReturn(previousSteps); + when(previousSteps.size()).thenReturn(0); + + // Setup output items + var textItem = new TextOutputItem("Hello!", 0); + var outputValue = new OutputValue(); + outputValue.setValueAlternatives(List.of(textItem)); + var outputEntry = new OutputEntry("greet", 0, List.of(outputValue), List.of()); + + Map> outputs = new HashMap<>(); + outputs.put("greet", List.of(outputEntry)); + when(outputGen.getOutputs(anyList())).thenReturn(outputs); + + var outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any(), anyList())).thenReturn(outputData); + + assertDoesNotThrow(() -> task.execute(memory, outputGen)); + + verify(currentStep, atLeastOnce()).storeData(any()); + verify(currentStep, atLeastOnce()).addConversationOutputList(eq("output"), anyList()); + } + + @Test + @DisplayName("language mismatch — should skip output generation") + void languageMismatch() { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(currentStep.getAllData("context")).thenReturn(List.of()); + + var outputGen = mock(IOutputGeneration.class); + when(outputGen.getLanguage()).thenReturn("de"); + + var properties = mock(IConversationProperties.class); + when(memory.getConversationProperties()).thenReturn(properties); + // No language property set → defaults to null → mismatch with "de" + + assertDoesNotThrow(() -> task.execute(memory, outputGen)); + verify(outputGen, never()).getOutputs(anyList()); + } + + @Test + @DisplayName("empty output values — should not store anything") + void emptyOutputValues() { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(currentStep.getAllData("context")).thenReturn(List.of()); + + var outputGen = mock(IOutputGeneration.class); + when(outputGen.getLanguage()).thenReturn(null); + + var properties = mock(IConversationProperties.class); + when(memory.getConversationProperties()).thenReturn(properties); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("farewell")); + + var previousSteps = mock(IConversationStepStack.class); + when(memory.getPreviousSteps()).thenReturn(previousSteps); + when(previousSteps.size()).thenReturn(0); + + // Return empty outputs for the action + when(outputGen.getOutputs(anyList())).thenReturn(Map.of()); + + assertDoesNotThrow(() -> task.execute(memory, outputGen)); + verify(currentStep, never()).addConversationOutputList(eq("output"), anyList()); + } + + @Test + @DisplayName("output with quick replies — stores quick replies separately") + void outputWithQuickReplies() { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(currentStep.getAllData("context")).thenReturn(List.of()); + + var outputGen = mock(IOutputGeneration.class); + when(outputGen.getLanguage()).thenReturn(null); + + var properties = mock(IConversationProperties.class); + when(memory.getConversationProperties()).thenReturn(properties); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("ask_preference")); + + var previousSteps = mock(IConversationStepStack.class); + when(memory.getPreviousSteps()).thenReturn(previousSteps); + when(previousSteps.size()).thenReturn(0); + + var quickReplies = List.of( + new QuickReply("Option A", "option_a()", false), + new QuickReply("Option B", "option_b()", false)); + + var textItem = new TextOutputItem("Choose:", 0); + var outputValue = new OutputValue(); + outputValue.setValueAlternatives(List.of(textItem)); + var outputEntry = new OutputEntry("ask_preference", 0, List.of(outputValue), quickReplies); + + when(outputGen.getOutputs(anyList())).thenReturn(Map.of("ask_preference", List.of(outputEntry))); + + var outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any(), anyList())).thenReturn(outputData); + when(dataFactory.createData(anyString(), anyList())).thenReturn(outputData); + + assertDoesNotThrow(() -> task.execute(memory, outputGen)); + + verify(currentStep, atLeastOnce()).addConversationOutputList(eq("quickReplies"), anyList()); + } + + @Test + @DisplayName("multiple actions — creates filter for each") + void multipleActions() { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(currentStep.getAllData("context")).thenReturn(List.of()); + + var outputGen = mock(IOutputGeneration.class); + when(outputGen.getLanguage()).thenReturn(null); + + var properties = mock(IConversationProperties.class); + when(memory.getConversationProperties()).thenReturn(properties); + + var actionData = mock(IData.class); + when(currentStep.getLatestData(ACTIONS)).thenReturn(actionData); + when(actionData.getResult()).thenReturn(List.of("greet", "ask_name")); + + var previousSteps = mock(IConversationStepStack.class); + when(memory.getPreviousSteps()).thenReturn(previousSteps); + when(previousSteps.size()).thenReturn(0); + + when(outputGen.getOutputs(anyList())).thenReturn(Map.of()); + + assertDoesNotThrow(() -> task.execute(memory, outputGen)); + + // Verify getOutputs was called with a list of 2 filters + verify(outputGen).getOutputs(argThat(filters -> filters.size() == 2)); + } + } + + @Nested + @DisplayName("configure Tests") + class ConfigureTests { + + @Test + @DisplayName("null URI — returns null component") + void nullUri() throws Exception { + var config = new HashMap(); + // No "uri" key + + var result = task.configure(config, Map.of()); + + assertNull(result); + } + + @Test + @DisplayName("valid URI — loads OutputConfigurationSet from resource library") + void validUri() throws Exception { + var config = new HashMap(); + config.put("uri", "eddi://ai.labs.output/outputsets/abc123?version=1"); + + var outputConfigSet = new ai.labs.eddi.configs.output.model.OutputConfigurationSet(); + outputConfigSet.setLang(null); + outputConfigSet.setOutputSet(new ArrayList<>()); + + when(resourceClientLibrary.getResource(any(), eq(ai.labs.eddi.configs.output.model.OutputConfigurationSet.class))) + .thenReturn(outputConfigSet); + + var result = task.configure(config, Map.of()); + + assertNotNull(result); + assertInstanceOf(IOutputGeneration.class, result); + } + } + + @Nested + @DisplayName("Context Output Tests") + class ContextOutputTests { + + @Test + @DisplayName("context with output type — stores context output") + void contextOutput() { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + var context = new Context(); + context.setType(Context.ContextType.object); + var valueAlternatives = List.of( + Map.of("valueAlternatives", List.of(Map.of("type", "text", "text", "Context output")))); + context.setValue(valueAlternatives); + + var contextData = mock(IData.class); + when(contextData.getKey()).thenReturn("context:output"); + when(contextData.getResult()).thenReturn(context); + + when(currentStep.getAllData("context")).thenReturn(List.of(contextData)); + + var outputData = mock(IData.class); + when(dataFactory.createData(anyString(), any(), anyList())).thenReturn(outputData); + + assertDoesNotThrow(() -> task.execute(memory, null)); + } + } +} diff --git a/src/test/java/ai/labs/eddi/modules/properties/impl/PropertySetterTaskTest.java b/src/test/java/ai/labs/eddi/modules/properties/impl/PropertySetterTaskTest.java new file mode 100644 index 000000000..4d1634c4a --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/properties/impl/PropertySetterTaskTest.java @@ -0,0 +1,439 @@ +package ai.labs.eddi.modules.properties.impl; + +import ai.labs.eddi.configs.properties.model.Property; +import ai.labs.eddi.configs.properties.model.PropertyInstruction; +import ai.labs.eddi.engine.lifecycle.exceptions.LifecycleException; +import ai.labs.eddi.engine.lifecycle.exceptions.WorkflowConfigurationException; +import ai.labs.eddi.engine.memory.IConversationMemory; +import ai.labs.eddi.engine.memory.IConversationMemory.*; +import ai.labs.eddi.engine.memory.IData; +import ai.labs.eddi.engine.memory.IDataFactory; +import ai.labs.eddi.engine.memory.IMemoryItemConverter; +import ai.labs.eddi.engine.model.Context; +import ai.labs.eddi.engine.runtime.client.configuration.IResourceClientLibrary; +import ai.labs.eddi.modules.nlp.expressions.Expressions; +import ai.labs.eddi.modules.nlp.expressions.utilities.IExpressionProvider; +import ai.labs.eddi.modules.properties.IPropertySetter; +import ai.labs.eddi.modules.properties.model.SetOnActions; +import ai.labs.eddi.modules.templating.ITemplatingEngine; +import ai.labs.eddi.secrets.ISecretProvider; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +@DisplayName("PropertySetterTask Tests") +class PropertySetterTaskTest { + + private IExpressionProvider expressionProvider; + private IMemoryItemConverter memoryItemConverter; + private ITemplatingEngine templatingEngine; + private IDataFactory dataFactory; + private IResourceClientLibrary resourceClientLibrary; + private ISecretProvider secretProvider; + private PropertySetterTask task; + + @BeforeEach + void setUp() { + expressionProvider = mock(IExpressionProvider.class); + memoryItemConverter = mock(IMemoryItemConverter.class); + templatingEngine = mock(ITemplatingEngine.class); + dataFactory = mock(IDataFactory.class); + resourceClientLibrary = mock(IResourceClientLibrary.class); + secretProvider = mock(ISecretProvider.class); + + task = new PropertySetterTask(expressionProvider, memoryItemConverter, + templatingEngine, dataFactory, resourceClientLibrary, + new ObjectMapper(), secretProvider); + } + + @Test + @DisplayName("getId returns correct ID") + void getId() { + assertEquals("ai.labs.property", task.getId()); + } + + @Test + @DisplayName("getType returns 'properties'") + void getType() { + assertEquals("properties", task.getType()); + } + + @Test + @DisplayName("getExtensionDescriptor returns valid descriptor") + void getExtensionDescriptor() { + var descriptor = task.getExtensionDescriptor(); + assertNotNull(descriptor); + assertEquals("Property Extraction", descriptor.getDisplayName()); + } + + @Nested + @DisplayName("execute Tests") + class ExecuteTests { + + @Test + @DisplayName("no expressions, no context, no actions — should return early") + void noData() throws Exception { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + when(currentStep.getLatestData("expressions:parsed")).thenReturn(null); + when(currentStep.getAllData("context")).thenReturn(null); + when(currentStep.getLatestData("actions")).thenReturn(null); + + var propertySetter = mock(IPropertySetter.class); + + assertDoesNotThrow(() -> task.execute(memory, propertySetter)); + verify(propertySetter, never()).extractProperties(any()); + } + + @Test + @DisplayName("actions with setOnActions — sets conversation properties") + void actionsWithSetOnActions() throws Exception { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + when(currentStep.getLatestData("expressions:parsed")).thenReturn(null); + when(currentStep.getAllData("context")).thenReturn(null); + + var actionsData = mock(IData.class); + when(currentStep.getLatestData("actions")).thenReturn(actionsData); + when(actionsData.getResult()).thenReturn(List.of("greet")); + + var conversationProperties = mock(IConversationProperties.class); + when(memory.getConversationProperties()).thenReturn(conversationProperties); + + var templateDataObjects = new HashMap(); + when(memoryItemConverter.convert(memory)).thenReturn(templateDataObjects); + when(templatingEngine.processTemplate(anyString(), anyMap())) + .thenAnswer(inv -> inv.getArgument(0)); + + var instruction = new PropertyInstruction(); + instruction.setName("greeting"); + instruction.setValueString("hello"); + instruction.setScope(Property.Scope.conversation); + instruction.setOverride(true); + + var setOnActions = new SetOnActions(); + setOnActions.setActions(List.of("greet")); + setOnActions.setSetProperties(List.of(instruction)); + + var propertySetter = mock(IPropertySetter.class); + when(propertySetter.getSetOnActionsList()).thenReturn(List.of(setOnActions)); + when(propertySetter.extractProperties(any())).thenReturn(new LinkedList<>()); + + var previousSteps = mock(IConversationStepStack.class); + when(memory.getPreviousSteps()).thenReturn(previousSteps); + when(previousSteps.size()).thenReturn(0); + + assertDoesNotThrow(() -> task.execute(memory, propertySetter)); + + verify(conversationProperties).put(eq("greeting"), any(Property.class)); + } + + @Test + @DisplayName("wildcard action — matches all") + void wildcardAction() throws Exception { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + when(currentStep.getLatestData("expressions:parsed")).thenReturn(null); + when(currentStep.getAllData("context")).thenReturn(null); + + var actionsData = mock(IData.class); + when(currentStep.getLatestData("actions")).thenReturn(actionsData); + when(actionsData.getResult()).thenReturn(List.of("any_action")); + + var conversationProperties = mock(IConversationProperties.class); + when(memory.getConversationProperties()).thenReturn(conversationProperties); + + var templateDataObjects = new HashMap(); + when(memoryItemConverter.convert(memory)).thenReturn(templateDataObjects); + when(templatingEngine.processTemplate(anyString(), anyMap())) + .thenAnswer(inv -> inv.getArgument(0)); + + var instruction = new PropertyInstruction(); + instruction.setName("captured"); + instruction.setValueString("yes"); + instruction.setScope(Property.Scope.conversation); + instruction.setOverride(true); + + var setOnActions = new SetOnActions(); + setOnActions.setActions(List.of("*")); // wildcard + setOnActions.setSetProperties(List.of(instruction)); + + var propertySetter = mock(IPropertySetter.class); + when(propertySetter.getSetOnActionsList()).thenReturn(List.of(setOnActions)); + when(propertySetter.extractProperties(any())).thenReturn(new LinkedList<>()); + + var previousSteps = mock(IConversationStepStack.class); + when(memory.getPreviousSteps()).thenReturn(previousSteps); + when(previousSteps.size()).thenReturn(0); + + assertDoesNotThrow(() -> task.execute(memory, propertySetter)); + verify(conversationProperties).put(eq("captured"), any(Property.class)); + } + + @Test + @DisplayName("override=false and property exists — should NOT overwrite") + void noOverride() throws Exception { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + when(currentStep.getLatestData("expressions:parsed")).thenReturn(null); + when(currentStep.getAllData("context")).thenReturn(null); + + var actionsData = mock(IData.class); + when(currentStep.getLatestData("actions")).thenReturn(actionsData); + when(actionsData.getResult()).thenReturn(List.of("set_name")); + + var conversationProperties = mock(IConversationProperties.class); + when(memory.getConversationProperties()).thenReturn(conversationProperties); + when(conversationProperties.containsKey("userName")).thenReturn(true); // already exists + + var templateDataObjects = new HashMap(); + when(memoryItemConverter.convert(memory)).thenReturn(templateDataObjects); + when(templatingEngine.processTemplate(anyString(), anyMap())) + .thenAnswer(inv -> inv.getArgument(0)); + + var instruction = new PropertyInstruction(); + instruction.setName("userName"); + instruction.setValueString("new_name"); + instruction.setScope(Property.Scope.conversation); + instruction.setOverride(false); // do not override + + var setOnActions = new SetOnActions(); + setOnActions.setActions(List.of("set_name")); + setOnActions.setSetProperties(List.of(instruction)); + + var propertySetter = mock(IPropertySetter.class); + when(propertySetter.getSetOnActionsList()).thenReturn(List.of(setOnActions)); + when(propertySetter.extractProperties(any())).thenReturn(new LinkedList<>()); + + var previousSteps = mock(IConversationStepStack.class); + when(memory.getPreviousSteps()).thenReturn(previousSteps); + when(previousSteps.size()).thenReturn(0); + + assertDoesNotThrow(() -> task.execute(memory, propertySetter)); + verify(conversationProperties, never()).put(eq("userName"), any(Property.class)); + } + + @Test + @DisplayName("valueObject — stores Map property") + void valueObject() throws Exception { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + when(currentStep.getLatestData("expressions:parsed")).thenReturn(null); + when(currentStep.getAllData("context")).thenReturn(null); + + var actionsData = mock(IData.class); + when(currentStep.getLatestData("actions")).thenReturn(actionsData); + when(actionsData.getResult()).thenReturn(List.of("set_config")); + + var conversationProperties = mock(IConversationProperties.class); + when(memory.getConversationProperties()).thenReturn(conversationProperties); + + var templateDataObjects = new HashMap(); + when(memoryItemConverter.convert(memory)).thenReturn(templateDataObjects); + when(templatingEngine.processTemplate(anyString(), anyMap())) + .thenAnswer(inv -> inv.getArgument(0)); + + var instruction = new PropertyInstruction(); + instruction.setName("config"); + instruction.setValueObject(Map.of("key1", "val1", "key2", "val2")); + instruction.setScope(Property.Scope.conversation); + instruction.setOverride(true); + + var setOnActions = new SetOnActions(); + setOnActions.setActions(List.of("set_config")); + setOnActions.setSetProperties(List.of(instruction)); + + var propertySetter = mock(IPropertySetter.class); + when(propertySetter.getSetOnActionsList()).thenReturn(List.of(setOnActions)); + when(propertySetter.extractProperties(any())).thenReturn(new LinkedList<>()); + + var previousSteps = mock(IConversationStepStack.class); + when(memory.getPreviousSteps()).thenReturn(previousSteps); + when(previousSteps.size()).thenReturn(0); + + assertDoesNotThrow(() -> task.execute(memory, propertySetter)); + verify(conversationProperties).put(eq("config"), any(Property.class)); + } + + @Test + @DisplayName("valueInt — stores Integer property") + void valueInt() throws Exception { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + when(currentStep.getLatestData("expressions:parsed")).thenReturn(null); + when(currentStep.getAllData("context")).thenReturn(null); + + var actionsData = mock(IData.class); + when(currentStep.getLatestData("actions")).thenReturn(actionsData); + when(actionsData.getResult()).thenReturn(List.of("set_count")); + + var conversationProperties = mock(IConversationProperties.class); + when(memory.getConversationProperties()).thenReturn(conversationProperties); + + var templateDataObjects = new HashMap(); + when(memoryItemConverter.convert(memory)).thenReturn(templateDataObjects); + when(templatingEngine.processTemplate(anyString(), anyMap())) + .thenAnswer(inv -> inv.getArgument(0)); + + var instruction = new PropertyInstruction(); + instruction.setName("count"); + instruction.setValueInt(42); + instruction.setScope(Property.Scope.conversation); + instruction.setOverride(true); + + var setOnActions = new SetOnActions(); + setOnActions.setActions(List.of("set_count")); + setOnActions.setSetProperties(List.of(instruction)); + + var propertySetter = mock(IPropertySetter.class); + when(propertySetter.getSetOnActionsList()).thenReturn(List.of(setOnActions)); + when(propertySetter.extractProperties(any())).thenReturn(new LinkedList<>()); + + var previousSteps = mock(IConversationStepStack.class); + when(memory.getPreviousSteps()).thenReturn(previousSteps); + when(previousSteps.size()).thenReturn(0); + + assertDoesNotThrow(() -> task.execute(memory, propertySetter)); + verify(conversationProperties).put(eq("count"), any(Property.class)); + } + + @Test + @DisplayName("context with properties expressions — extracts expressions") + void contextProperties() throws Exception { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + when(currentStep.getLatestData("expressions:parsed")).thenReturn(null); + when(currentStep.getLatestData("actions")).thenReturn(null); + + var context = new Context(); + context.setType(Context.ContextType.expressions); + context.setValue("property(language, en)"); + + var contextData = mock(IData.class); + when(contextData.getKey()).thenReturn("context:properties"); + when(contextData.getResult()).thenReturn(context); + when(currentStep.getAllData("context")).thenReturn(List.of(contextData)); + + when(expressionProvider.parseExpressions("property(language, en)")) + .thenReturn(new Expressions()); + + var conversationProperties = mock(IConversationProperties.class); + when(memory.getConversationProperties()).thenReturn(conversationProperties); + + var templateDataObjects = new HashMap(); + when(memoryItemConverter.convert(memory)).thenReturn(templateDataObjects); + + var propertySetter = mock(IPropertySetter.class); + when(propertySetter.getSetOnActionsList()).thenReturn(List.of()); + when(propertySetter.extractProperties(any())).thenReturn(new LinkedList<>()); + + var previousSteps = mock(IConversationStepStack.class); + when(memory.getPreviousSteps()).thenReturn(previousSteps); + when(previousSteps.size()).thenReturn(0); + + assertDoesNotThrow(() -> task.execute(memory, propertySetter)); + verify(expressionProvider).parseExpressions("property(language, en)"); + } + + @Test + @DisplayName("CATCH_ANY_INPUT_AS_PROPERTY in previous step — captures user input") + void catchAnyInput() throws Exception { + var memory = mock(IConversationMemory.class); + var currentStep = mock(IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + + // Need at least one non-null data source to bypass early return guard + var expressionsData = mock(IData.class); + when(expressionsData.getResult()).thenReturn(""); + when(currentStep.getLatestData("expressions:parsed")).thenReturn(expressionsData); + when(currentStep.getAllData("context")).thenReturn(null); + when(currentStep.getLatestData("actions")).thenReturn(null); + + when(expressionProvider.parseExpressions("")).thenReturn(new Expressions()); + + var conversationProperties = mock(IConversationProperties.class); + when(memory.getConversationProperties()).thenReturn(conversationProperties); + + var templateDataObjects = new HashMap(); + when(memoryItemConverter.convert(memory)).thenReturn(templateDataObjects); + + // Previous step has CATCH_ANY_INPUT_AS_PROPERTY + var previousSteps = mock(IConversationStepStack.class); + when(memory.getPreviousSteps()).thenReturn(previousSteps); + when(previousSteps.size()).thenReturn(1); + + var previousStep = mock(IWritableConversationStep.class); + when(previousSteps.get(0)).thenReturn(previousStep); + + var prevActionsData = mock(IData.class); + when(previousStep.getLatestData("actions")).thenReturn(prevActionsData); + when(prevActionsData.getResult()).thenReturn(List.of("CATCH_ANY_INPUT_AS_PROPERTY")); + + var inputData = mock(IData.class); + when(currentStep.getLatestData("input:initial")).thenReturn(inputData); + when(inputData.getResult()).thenReturn("John"); + + var outputData = mock(IData.class); + when(dataFactory.createData(anyString(), anyList(), eq(true))).thenReturn(outputData); + + var propertySetter = mock(IPropertySetter.class); + when(propertySetter.getSetOnActionsList()).thenReturn(List.of()); + when(propertySetter.extractProperties(any())).thenReturn(new LinkedList<>()); + + assertDoesNotThrow(() -> task.execute(memory, propertySetter)); + verify(conversationProperties).put(eq("user_input"), any(Property.class)); + } + } + + @Nested + @DisplayName("configure Tests") + class ConfigureTests { + + @Test + @DisplayName("setOnActions in raw config — parses correctly") + void rawConfig() throws Exception { + var config = new HashMap(); + config.put("setOnActions", List.of( + Map.of("actions", List.of("greet"), + "setProperties", List.of( + Map.of("name", "greeting", "valueString", "hello", "scope", "conversation"))))); + + var result = task.configure(config, Map.of()); + + assertNotNull(result); + assertInstanceOf(IPropertySetter.class, result); + } + + @Test + @DisplayName("no setOnActions and no URI — returns empty PropertySetter") + void noConfig() throws Exception { + var config = new HashMap(); + + var result = task.configure(config, Map.of()); + + assertNotNull(result); + assertInstanceOf(IPropertySetter.class, result); + } + } +} From 0b3678a0f732a49f014484589af7dd40a0736f89 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 16:08:38 +0200 Subject: [PATCH 029/124] test(coverage): add InputParser and Conversation unit tests - InputParser: +16 tests covering construction, normalize (whitespace, chaining, null language), parse (unknown words, dictionary lookup, language mismatch, corrections, multi-word), Config POJO - Conversation: +8 tests covering state management (isEnded, endConversation), init (READY state, user property loading, null store), say/rerun IN_PROGRESS guards Total: 3,544 tests, all passing --- .../runtime/internal/ConversationTest.java | 174 +++++++++++++ .../modules/nlp/internal/InputParserTest.java | 236 ++++++++++++++++++ 2 files changed, 410 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/engine/runtime/internal/ConversationTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/nlp/internal/InputParserTest.java diff --git a/src/test/java/ai/labs/eddi/engine/runtime/internal/ConversationTest.java b/src/test/java/ai/labs/eddi/engine/runtime/internal/ConversationTest.java new file mode 100644 index 000000000..ed497e4dc --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/runtime/internal/ConversationTest.java @@ -0,0 +1,174 @@ +package ai.labs.eddi.engine.runtime.internal; + +import ai.labs.eddi.configs.properties.IUserMemoryStore; +import ai.labs.eddi.configs.properties.model.Property; +import ai.labs.eddi.configs.properties.model.Property.Scope; +import ai.labs.eddi.configs.properties.model.UserMemoryEntry; +import ai.labs.eddi.engine.lifecycle.IConversation; +import ai.labs.eddi.engine.lifecycle.ILifecycleManager; +import ai.labs.eddi.engine.lifecycle.exceptions.LifecycleException; +import ai.labs.eddi.engine.memory.*; +import ai.labs.eddi.engine.memory.IConversationMemory.IConversationProperties; +import ai.labs.eddi.engine.memory.IConversationMemory.IWritableConversationStep; +import ai.labs.eddi.engine.memory.model.ConversationState; +import ai.labs.eddi.engine.model.Context; +import ai.labs.eddi.engine.runtime.IExecutableWorkflow; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +@DisplayName("Conversation Tests") +class ConversationTest { + + private IConversationMemory memory; + private IPropertiesHandler propertiesHandler; + private IConversation.IConversationOutputRenderer outputRenderer; + private IExecutableWorkflow workflow; + private ILifecycleManager lifecycleManager; + private IWritableConversationStep currentStep; + private IConversationProperties conversationProperties; + + @BeforeEach + void setUp() { + memory = mock(IConversationMemory.class); + propertiesHandler = mock(IPropertiesHandler.class); + outputRenderer = mock(IConversation.IConversationOutputRenderer.class); + workflow = mock(IExecutableWorkflow.class); + lifecycleManager = mock(ILifecycleManager.class); + currentStep = mock(IWritableConversationStep.class); + conversationProperties = mock(IConversationProperties.class); + + when(memory.getCurrentStep()).thenReturn(currentStep); + when(memory.getConversationProperties()).thenReturn(conversationProperties); + when(workflow.getLifecycleManager()).thenReturn(lifecycleManager); + } + + private Conversation createConversation() { + return new Conversation(List.of(workflow), memory, propertiesHandler, outputRenderer); + } + + @Nested + @DisplayName("isEnded / endConversation") + class StateTests { + + @Test + @DisplayName("isEnded returns false when state is READY") + void notEnded() { + when(memory.getConversationState()).thenReturn(ConversationState.READY); + var conv = createConversation(); + assertFalse(conv.isEnded()); + } + + @Test + @DisplayName("isEnded returns true when state is ENDED") + void isEnded() { + when(memory.getConversationState()).thenReturn(ConversationState.ENDED); + var conv = createConversation(); + assertTrue(conv.isEnded()); + } + + @Test + @DisplayName("endConversation sets state to ENDED") + void endConversation() { + var conv = createConversation(); + conv.endConversation(); + verify(memory).setConversationState(ConversationState.ENDED); + } + } + + @Nested + @DisplayName("getConversationMemory") + class MemoryTests { + + @Test + @DisplayName("returns the injected memory") + void returnsMemory() { + var conv = createConversation(); + assertSame(memory, conv.getConversationMemory()); + } + } + + @Nested + @DisplayName("init") + class InitTests { + + @Test + @DisplayName("init sets state to READY and adds CONVERSATION_START action") + void initSetsReady() throws Exception { + when(propertiesHandler.getUserMemoryStore()).thenReturn(null); + when(workflow.getWorkflowId()).thenReturn("wf1"); + + var conv = createConversation(); + conv.init(new HashMap<>()); + + verify(memory).setConversationState(ConversationState.READY); + verify(currentStep).set(any(), anyList()); + } + + @Test + @DisplayName("init loads user properties from store") + void initLoadsUserProperties() throws Exception { + var store = mock(IUserMemoryStore.class); + when(propertiesHandler.getUserMemoryStore()).thenReturn(store); + when(memory.getUserId()).thenReturn("user1"); + when(memory.getAgentId()).thenReturn("agent1"); + + var entry = new UserMemoryEntry(null, "user1", "language", "en", + "fact", Property.Visibility.self, "agent1", List.of(), "conv1", + false, 0, java.time.Instant.now(), java.time.Instant.now()); + when(store.getVisibleEntries(eq("user1"), eq("agent1"), anyList(), anyString(), anyInt())) + .thenReturn(List.of(entry)); + + when(workflow.getWorkflowId()).thenReturn("wf1"); + + var conv = createConversation(); + conv.init(new HashMap<>()); + + verify(conversationProperties).put(eq("language"), any(Property.class)); + } + + @Test + @DisplayName("init with null store — skips property loading") + void initNullStore() throws Exception { + when(propertiesHandler.getUserMemoryStore()).thenReturn(null); + when(workflow.getWorkflowId()).thenReturn("wf1"); + + var conv = createConversation(); + assertDoesNotThrow(() -> conv.init(new HashMap<>())); + } + } + + @Nested + @DisplayName("say") + class SayTests { + + @Test + @DisplayName("say throws ConversationNotReadyException when IN_PROGRESS") + void sayWhenInProgress() { + when(memory.getConversationState()).thenReturn(ConversationState.IN_PROGRESS); + var conv = createConversation(); + assertThrows(IConversation.ConversationNotReadyException.class, + () -> conv.say("hello", Map.of())); + } + } + + @Nested + @DisplayName("rerun") + class RerunTests { + + @Test + @DisplayName("rerun throws when IN_PROGRESS") + void rerunWhenInProgress() { + when(memory.getConversationState()).thenReturn(ConversationState.IN_PROGRESS); + var conv = createConversation(); + assertThrows(IConversation.ConversationNotReadyException.class, + () -> conv.rerun(Map.of())); + } + } +} diff --git a/src/test/java/ai/labs/eddi/modules/nlp/internal/InputParserTest.java b/src/test/java/ai/labs/eddi/modules/nlp/internal/InputParserTest.java new file mode 100644 index 000000000..758b5c5f6 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/nlp/internal/InputParserTest.java @@ -0,0 +1,236 @@ +package ai.labs.eddi.modules.nlp.internal; + +import ai.labs.eddi.modules.nlp.IInputParser; +import ai.labs.eddi.modules.nlp.extensions.corrections.ICorrection; +import ai.labs.eddi.modules.nlp.extensions.dictionaries.IDictionary; +import ai.labs.eddi.modules.nlp.extensions.normalizers.INormalizer; +import ai.labs.eddi.modules.nlp.internal.matches.RawSolution; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.Collections; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +@DisplayName("InputParser Tests") +class InputParserTest { + + @Nested + @DisplayName("Construction") + class ConstructionTests { + + @Test + @DisplayName("default config is created when none provided") + void defaultConfig() { + var parser = new InputParser(List.of()); + assertNotNull(parser.getConfig()); + assertTrue(parser.getConfig().isAppendExpressions()); + assertTrue(parser.getConfig().isIncludeUnused()); + assertTrue(parser.getConfig().isIncludeUnknown()); + } + + @Test + @DisplayName("custom config is stored") + void customConfig() { + var config = new IInputParser.Config(false, false, true); + var parser = new InputParser(List.of(), List.of(), List.of(), config); + assertEquals(config, parser.getConfig()); + } + } + + @Nested + @DisplayName("normalize") + class NormalizeTests { + + @Test + @DisplayName("trims and collapses whitespace") + void trimAndCollapse() throws Exception { + var parser = new InputParser(List.of()); + assertEquals("hello world", parser.normalize(" hello world ", "en")); + } + + @Test + @DisplayName("normalizer is invoked in order") + void normalizerInvoked() throws Exception { + var normalizer = mock(INormalizer.class); + when(normalizer.normalize("hello", "en")).thenReturn("HELLO"); + + var parser = new InputParser(List.of(normalizer), List.of(), List.of(), new IInputParser.Config()); + String result = parser.normalize("hello", "en"); + + assertEquals("HELLO", result); + verify(normalizer).normalize("hello", "en"); + } + + @Test + @DisplayName("null language defaults to 'en'") + void nullLanguageDefault() throws Exception { + var normalizer = mock(INormalizer.class); + when(normalizer.normalize("test", "en")).thenReturn("test"); + + var parser = new InputParser(List.of(normalizer), List.of(), List.of(), new IInputParser.Config()); + parser.normalize("test", null); + + verify(normalizer).normalize("test", "en"); + } + + @Test + @DisplayName("multiple normalizers are chained") + void chainedNormalizers() throws Exception { + var n1 = mock(INormalizer.class); + when(n1.normalize("hello!", "en")).thenReturn("hello"); + + var n2 = mock(INormalizer.class); + when(n2.normalize("hello", "en")).thenReturn("hi"); + + var parser = new InputParser(List.of(n1, n2), List.of(), List.of(), new IInputParser.Config()); + String result = parser.normalize("hello!", "en"); + + assertEquals("hi", result); + } + } + + @Nested + @DisplayName("parse") + class ParseTests { + + @Test + @DisplayName("unknown word returns solution with unknown entry") + void unknownWord() throws Exception { + var parser = new InputParser(List.of()); + List solutions = parser.parse("xyz123"); + + assertFalse(solutions.isEmpty()); + } + + @Test + @DisplayName("empty string returns empty solutions") + void emptyString() throws Exception { + var parser = new InputParser(List.of()); + List solutions = parser.parse(""); + + // Empty string splits to [""], which is treated as unknown + assertNotNull(solutions); + } + + @Test + @DisplayName("dictionary word is looked up correctly") + void dictionaryLookup() throws Exception { + var dictionary = mock(IDictionary.class); + when(dictionary.getLanguageCode()).thenReturn("en"); + when(dictionary.getPhrases()).thenReturn(List.of()); + + var foundWord = mock(IDictionary.IFoundWord.class); + var word = mock(IDictionary.IWord.class); + when(foundWord.getFoundWord()).thenReturn(word); + when(word.isPartOfPhrase()).thenReturn(false); + when(foundWord.isPhrase()).thenReturn(false); + + when(dictionary.lookupTerm("hello")).thenReturn(List.of(foundWord)); + + var parser = new InputParser(List.of(dictionary)); + List solutions = parser.parse("hello", "en", Collections.emptyList()); + + assertFalse(solutions.isEmpty()); + verify(dictionary).lookupTerm("hello"); + } + + @Test + @DisplayName("language mismatch — dictionary is skipped") + void languageMismatch() throws Exception { + var dictionary = mock(IDictionary.class); + when(dictionary.getLanguageCode()).thenReturn("de"); + when(dictionary.getPhrases()).thenReturn(List.of()); + + var parser = new InputParser(List.of(dictionary)); + parser.parse("hello", "en", Collections.emptyList()); + + // Dictionary has language "de" but user language is "en" — skipped + verify(dictionary, never()).lookupTerm(anyString()); + } + + @Test + @DisplayName("correction is applied when word is unknown") + void correctionApplied() throws Exception { + var dictionary = mock(IDictionary.class); + when(dictionary.getLanguageCode()).thenReturn(null); + when(dictionary.getPhrases()).thenReturn(List.of()); + when(dictionary.lookupTerm(anyString())).thenReturn(List.of()); + + var correction = mock(ICorrection.class); + when(correction.lookupIfKnown()).thenReturn(false); + + var correctedWord = mock(IDictionary.IFoundWord.class); + var word = mock(IDictionary.IWord.class); + when(correctedWord.getFoundWord()).thenReturn(word); + when(word.isPartOfPhrase()).thenReturn(false); + when(correctedWord.isPhrase()).thenReturn(false); + + when(correction.correctWord(eq("helo"), eq("en"), anyList())).thenReturn(List.of(correctedWord)); + + var parser = new InputParser(List.of(dictionary), List.of(correction)); + List solutions = parser.parse("helo", "en", Collections.emptyList()); + + assertFalse(solutions.isEmpty()); + verify(correction).correctWord(eq("helo"), eq("en"), anyList()); + } + + @Test + @DisplayName("multiple words — each is looked up independently") + void multipleWords() throws Exception { + var dictionary = mock(IDictionary.class); + when(dictionary.getLanguageCode()).thenReturn(null); + when(dictionary.getPhrases()).thenReturn(List.of()); + when(dictionary.lookupTerm(anyString())).thenReturn(List.of()); + + var parser = new InputParser(List.of(dictionary)); + parser.parse("hello world", "en", Collections.emptyList()); + + verify(dictionary).lookupTerm("hello"); + verify(dictionary).lookupTerm("world"); + } + } + + @Nested + @DisplayName("Config") + class ConfigTests { + + @Test + @DisplayName("equals and hashCode") + void equalsAndHashCode() { + var c1 = new IInputParser.Config(true, true, true); + var c2 = new IInputParser.Config(true, true, true); + var c3 = new IInputParser.Config(false, true, true); + + assertEquals(c1, c2); + assertEquals(c1.hashCode(), c2.hashCode()); + assertNotEquals(c1, c3); + } + + @Test + @DisplayName("toString contains field values") + void testToString() { + var config = new IInputParser.Config(true, false, true); + String str = config.toString(); + assertTrue(str.contains("appendExpressions=true")); + assertTrue(str.contains("includeUnused=false")); + assertTrue(str.contains("includeUnknown=true")); + } + + @Test + @DisplayName("setters modify values") + void setters() { + var config = new IInputParser.Config(); + config.setAppendExpressions(false); + config.setIncludeUnused(false); + config.setIncludeUnknown(false); + + assertFalse(config.isAppendExpressions()); + assertFalse(config.isIncludeUnused()); + assertFalse(config.isIncludeUnknown()); + } + } +} From a12f60612a511b5d9d6d7fa60c0b9c48da1ebfff Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 17:11:57 +0200 Subject: [PATCH 030/124] test(coverage): add AgentDeploymentManagement and MatchMatrix unit tests - AgentDeploymentManagement: +8 tests (deploy, null guards, no re-deploy, exception handling, stale cleanup, migrations) - MatchMatrix: +11 tests (add/get, iterator, NoSuchElementException, MatchingResult basics) Total: 3,563 tests, all passing --- .../AgentDeploymentManagementTest.java | 208 ++++++++++++++++++ .../nlp/internal/matches/MatchMatrixTest.java | 147 +++++++++++++ 2 files changed, 355 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/engine/runtime/internal/AgentDeploymentManagementTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/nlp/internal/matches/MatchMatrixTest.java diff --git a/src/test/java/ai/labs/eddi/engine/runtime/internal/AgentDeploymentManagementTest.java b/src/test/java/ai/labs/eddi/engine/runtime/internal/AgentDeploymentManagementTest.java new file mode 100644 index 000000000..ae0110556 --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/runtime/internal/AgentDeploymentManagementTest.java @@ -0,0 +1,208 @@ +package ai.labs.eddi.engine.runtime.internal; + +import ai.labs.eddi.configs.agents.IAgentStore; +import ai.labs.eddi.configs.deployment.IDeploymentStore; +import ai.labs.eddi.configs.deployment.model.DeploymentInfo; +import ai.labs.eddi.configs.descriptors.IDocumentDescriptorStore; +import ai.labs.eddi.configs.migration.IMigrationManager; +import ai.labs.eddi.configs.migration.V6QuteMigration; +import ai.labs.eddi.configs.migration.V6RenameMigration; +import ai.labs.eddi.datastore.IResourceStore; +import ai.labs.eddi.engine.memory.IConversationMemoryStore; +import ai.labs.eddi.engine.runtime.IAgentFactory; +import ai.labs.eddi.engine.runtime.IRuntime; +import ai.labs.eddi.engine.runtime.internal.readiness.IAgentsReadiness; +import ai.labs.eddi.engine.model.Deployment.Environment; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.concurrent.ScheduledExecutorService; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +@DisplayName("AgentDeploymentManagement Tests") +class AgentDeploymentManagementTest { + + private IDeploymentStore deploymentStore; + private IAgentFactory agentFactory; + private IAgentStore agentStore; + private IAgentsReadiness agentsReadiness; + private IConversationMemoryStore conversationMemoryStore; + private IDocumentDescriptorStore documentDescriptorStore; + private IMigrationManager migrationManager; + private V6RenameMigration v6RenameMigration; + private V6QuteMigration v6QuteMigration; + private IRuntime runtime; + private AgentDeploymentManagement management; + + @BeforeEach + void setUp() { + deploymentStore = mock(IDeploymentStore.class); + agentFactory = mock(IAgentFactory.class); + agentStore = mock(IAgentStore.class); + agentsReadiness = mock(IAgentsReadiness.class); + conversationMemoryStore = mock(IConversationMemoryStore.class); + documentDescriptorStore = mock(IDocumentDescriptorStore.class); + migrationManager = mock(IMigrationManager.class); + v6RenameMigration = mock(V6RenameMigration.class); + v6QuteMigration = mock(V6QuteMigration.class); + runtime = mock(IRuntime.class); + + var scheduler = mock(ScheduledExecutorService.class); + when(runtime.getScheduledExecutorService()).thenReturn(scheduler); + + management = new AgentDeploymentManagement( + deploymentStore, agentFactory, agentStore, agentsReadiness, + conversationMemoryStore, documentDescriptorStore, + migrationManager, v6RenameMigration, v6QuteMigration, + runtime, 30); + } + + @Nested + @DisplayName("checkDeployments") + class CheckDeploymentsTests { + + @Test + @DisplayName("deploys new agents from deployment store") + void deploysNewAgents() throws Exception { + var info = new DeploymentInfo(); + info.setEnvironment(Environment.production); + info.setAgentId("agent1"); + info.setAgentVersion(1); + + when(deploymentStore.readDeploymentInfos(DeploymentInfo.DeploymentStatus.deployed)) + .thenReturn(List.of(info)); + + management.checkDeployments(); + + verify(agentFactory).deployAgent(Environment.production, "agent1", 1, null); + } + + @Test + @DisplayName("skips agents with null agentId") + void skipsNullAgentId() throws Exception { + var info = new DeploymentInfo(); + info.setEnvironment(Environment.production); + info.setAgentId(null); + info.setAgentVersion(1); + + when(deploymentStore.readDeploymentInfos(DeploymentInfo.DeploymentStatus.deployed)) + .thenReturn(List.of(info)); + + management.checkDeployments(); + + verify(agentFactory, never()).deployAgent(any(), any(), anyInt(), any()); + } + + @Test + @DisplayName("skips agents with null version") + void skipsNullVersion() throws Exception { + var info = new DeploymentInfo(); + info.setEnvironment(Environment.production); + info.setAgentId("agent1"); + info.setAgentVersion(null); + + when(deploymentStore.readDeploymentInfos(DeploymentInfo.DeploymentStatus.deployed)) + .thenReturn(List.of(info)); + + management.checkDeployments(); + + verify(agentFactory, never()).deployAgent(any(), any(), anyInt(), any()); + } + + @Test + @DisplayName("does not re-deploy already deployed agents") + void doesNotRedeploy() throws Exception { + var info = new DeploymentInfo(); + info.setEnvironment(Environment.production); + info.setAgentId("agent1"); + info.setAgentVersion(1); + + when(deploymentStore.readDeploymentInfos(DeploymentInfo.DeploymentStatus.deployed)) + .thenReturn(List.of(info)); + + // First call deploys + management.checkDeployments(); + verify(agentFactory, times(1)).deployAgent(any(), any(), anyInt(), any()); + + // Second call should not re-deploy + management.checkDeployments(); + verify(agentFactory, times(1)).deployAgent(any(), any(), anyInt(), any()); + } + + @Test + @DisplayName("handles ResourceStoreException gracefully") + void handlesStoreException() throws Exception { + when(deploymentStore.readDeploymentInfos(any())) + .thenThrow(new IResourceStore.ResourceStoreException("DB error")); + + assertDoesNotThrow(() -> management.checkDeployments()); + } + + @Test + @DisplayName("handles deploy failure gracefully") + void handlesDeployFailure() throws Exception { + var info = new DeploymentInfo(); + info.setEnvironment(Environment.production); + info.setAgentId("agent1"); + info.setAgentVersion(1); + + when(deploymentStore.readDeploymentInfos(DeploymentInfo.DeploymentStatus.deployed)) + .thenReturn(List.of(info)); + doThrow(new IllegalAccessException("Access denied")) + .when(agentFactory).deployAgent(any(), any(), anyInt(), any()); + + assertDoesNotThrow(() -> management.checkDeployments()); + } + + @Test + @DisplayName("marks stale deployment as undeployed when ResourceNotFoundException") + void marksStaleDeployment() throws Exception { + var info = new DeploymentInfo(); + info.setEnvironment(Environment.production); + info.setAgentId("agent1"); + info.setAgentVersion(1); + + when(deploymentStore.readDeploymentInfos(DeploymentInfo.DeploymentStatus.deployed)) + .thenReturn(List.of(info)); + + var rnfe = new IResourceStore.ResourceNotFoundException("Not found"); + doThrow(new IllegalStateException("Wrapped", rnfe)) + .when(agentFactory).deployAgent(any(), any(), anyInt(), any()); + + management.checkDeployments(); + + verify(deploymentStore).setDeploymentInfo( + eq("production"), eq("agent1"), eq(1), + eq(DeploymentInfo.DeploymentStatus.undeployed)); + } + } + + @Nested + @DisplayName("autoDeployAgents") + class AutoDeployTests { + + @Test + @DisplayName("runs migrations before deployment") + void runsMigrations() throws Exception { + when(deploymentStore.readDeploymentInfos(any())).thenReturn(List.of()); + + // migrationManager.startMigrationIfFirstTimeRun runs the callback + doAnswer(inv -> { + IMigrationManager.IMigrationFinished callback = inv.getArgument(0); + callback.onComplete(); + return null; + }).when(migrationManager).startMigrationIfFirstTimeRun(any()); + + management.autoDeployAgents(); + + verify(v6RenameMigration).runIfNeeded(); + verify(v6QuteMigration).runIfNeeded(); + verify(migrationManager).startMigrationIfFirstTimeRun(any()); + } + } +} diff --git a/src/test/java/ai/labs/eddi/modules/nlp/internal/matches/MatchMatrixTest.java b/src/test/java/ai/labs/eddi/modules/nlp/internal/matches/MatchMatrixTest.java new file mode 100644 index 000000000..20e976168 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/nlp/internal/matches/MatchMatrixTest.java @@ -0,0 +1,147 @@ +package ai.labs.eddi.modules.nlp.internal.matches; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.List; +import java.util.NoSuchElementException; + +import static org.junit.jupiter.api.Assertions.*; + +@DisplayName("MatchMatrix Tests") +class MatchMatrixTest { + + @Nested + @DisplayName("addMatchingResult / getMatchingResults") + class AddAndGetTests { + + @Test + @DisplayName("add and retrieve single result") + void addAndRetrieve() { + var matrix = new MatchMatrix(); + var result = new MatchingResult(); + + matrix.addMatchingResult(0, "hello", result); + + List results = matrix.getMatchingResults(0); + assertNotNull(results); + assertEquals(1, results.size()); + assertSame(result, results.get(0)); + } + + @Test + @DisplayName("multiple results for same index/term") + void multipleResultsSameKey() { + var matrix = new MatchMatrix(); + var r1 = new MatchingResult(); + var r2 = new MatchingResult(); + + matrix.addMatchingResult(0, "hello", r1); + matrix.addMatchingResult(0, "hello", r2); + + List results = matrix.getMatchingResults(0); + assertEquals(2, results.size()); + } + + @Test + @DisplayName("different terms create separate entries") + void differentTerms() { + var matrix = new MatchMatrix(); + matrix.addMatchingResult(0, "hello", new MatchingResult()); + matrix.addMatchingResult(1, "world", new MatchingResult()); + + assertNotNull(matrix.getMatchingResults(0)); + assertNotNull(matrix.getMatchingResults(1)); + } + + @Test + @DisplayName("getMatchingResults returns null for out-of-bounds index") + void outOfBoundsReturnsNull() { + var matrix = new MatchMatrix(); + assertNull(matrix.getMatchingResults(0)); + assertNull(matrix.getMatchingResults(5)); + } + } + + @Nested + @DisplayName("Iterator / SolutionIterator") + class IteratorTests { + + @Test + @DisplayName("empty matrix — iterator has no elements") + void emptyMatrix() { + var matrix = new MatchMatrix(); + var it = matrix.iterator(); + assertFalse(it.hasNext()); + } + + @Test + @DisplayName("single entry — iterator yields one suggestion") + void singleEntry() { + var matrix = new MatchMatrix(); + matrix.addMatchingResult(0, "hello", new MatchingResult()); + + var suggestions = new ArrayList(); + matrix.iterator().forEachRemaining(suggestions::add); + + assertEquals(1, suggestions.size()); + } + + @Test + @DisplayName("two entries — yields combinatorial suggestions") + void twoEntries() { + var matrix = new MatchMatrix(); + matrix.addMatchingResult(0, "hello", new MatchingResult()); + matrix.addMatchingResult(1, "world", new MatchingResult()); + + var suggestions = new ArrayList(); + matrix.iterator().forEachRemaining(suggestions::add); + + assertTrue(suggestions.size() >= 1); + } + + @Test + @DisplayName("next() throws NoSuchElementException when exhausted") + void nextThrowsWhenExhausted() { + var matrix = new MatchMatrix(); + var it = matrix.iterator(); + assertThrows(NoSuchElementException.class, it::next); + } + + @Test + @DisplayName("for-each loop works") + void forEachLoop() { + var matrix = new MatchMatrix(); + matrix.addMatchingResult(0, "test", new MatchingResult()); + + int count = 0; + for (Suggestion s : matrix) { + assertNotNull(s); + count++; + } + assertTrue(count > 0); + } + } + + @Nested + @DisplayName("MatchingResult") + class MatchingResultTests { + + @Test + @DisplayName("default is not corrected") + void defaultNotCorrected() { + var result = new MatchingResult(); + assertFalse(result.isCorrected()); + } + + @Test + @DisplayName("result list starts empty") + void emptyResults() { + var result = new MatchingResult(); + assertNotNull(result.getResult()); + assertTrue(result.getResult().isEmpty()); + } + } +} From 44ae80698f427aba12f4f7818c611b10ee2964e5 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 17:15:42 +0200 Subject: [PATCH 031/124] docs: update changelog with batches 25-26 --- docs/changelog.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/docs/changelog.md b/docs/changelog.md index 4de6f0b0e..3de3a46aa 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -13,6 +13,20 @@ Each entry follows this format: - **Decision** — Key design decisions and their reasoning - **Files** — Links to modified files +## Unit Test Coverage Expansion — Batches 25–26 (2026-04-20) + +**Repo:** EDDI (`test/coverage-tier-1-2`) + +**What changed:** Added 4 new test classes targeting core engine classes: InputParser, Conversation, AgentDeploymentManagement, and MatchMatrix. Total: 3,563 tests, all passing. + +### Batch 25 — NLP & Conversation Core +- `InputParserTest` (16 tests) — Construction (default/custom config), normalize (whitespace, chaining, null language), parse (unknown words, dictionary lookup, language mismatch, corrections, multi-word), Config POJO (equals, hashCode, toString, setters) +- `ConversationTest` (8 tests) — State management (isEnded, endConversation), init (READY state, CONVERSATION_START action, user property loading from UserMemoryStore, null store skip), say/rerun IN_PROGRESS guards + +### Batch 26 — Engine & NLP Matching +- `AgentDeploymentManagementTest` (8 tests) — checkDeployments (deploy new agents, skip null agentId/version, no re-deploy, ResourceStoreException handling, deploy failure handling, stale deployment cleanup via ResourceNotFoundException), autoDeployAgents (migration order with V6RenameMigration + V6QuteMigration) +- `MatchMatrixTest` (11 tests) — add/get operations (single result, multiple same key, different terms, out-of-bounds null), SolutionIterator (empty matrix, single entry, two entries combinatorial, NoSuchElementException, for-each loop), MatchingResult basics + ## Unit Test Coverage Expansion — Batches 19–24 (2026-04-20) **Repo:** EDDI (`test/coverage-tier-1-2`) From 1021888598e53f476407160d759e7e0d47b1bcdd Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 17:23:45 +0200 Subject: [PATCH 032/124] test(coverage): add LegacyPathRewriteFilter and ExpressionProvider unit tests - LegacyPathRewriteFilter: +11 tests (all 8 store path rewrites, 3 no-match cases) - ExpressionProvider: +18 tests (createExpression, parseExpressions, parseExpression, extractAllValues) Total: 3,592 tests, all passing --- .../LegacyPathRewriteFilterTest.java | 97 +++++++++ .../utilities/ExpressionProviderTest.java | 192 ++++++++++++++++++ 2 files changed, 289 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/engine/runtime/rest/interceptors/LegacyPathRewriteFilterTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/nlp/expressions/utilities/ExpressionProviderTest.java diff --git a/src/test/java/ai/labs/eddi/engine/runtime/rest/interceptors/LegacyPathRewriteFilterTest.java b/src/test/java/ai/labs/eddi/engine/runtime/rest/interceptors/LegacyPathRewriteFilterTest.java new file mode 100644 index 000000000..0ce6c8016 --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/runtime/rest/interceptors/LegacyPathRewriteFilterTest.java @@ -0,0 +1,97 @@ +package ai.labs.eddi.engine.runtime.rest.interceptors; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +@DisplayName("LegacyPathRewriteFilter Tests") +class LegacyPathRewriteFilterTest { + + @Nested + @DisplayName("rewritePath — store path rewrites") + class StorePathTests { + + @Test + @DisplayName("/botstore/bots → /agentstore/agents") + void botsToAgents() { + assertEquals("/agentstore/agents/abc", + LegacyPathRewriteFilter.rewritePath("/botstore/bots/abc")); + } + + @Test + @DisplayName("/packagestore/packages → /workflowstore/workflows") + void packagesToWorkflows() { + assertEquals("/workflowstore/workflows/wf1", + LegacyPathRewriteFilter.rewritePath("/packagestore/packages/wf1")); + } + + @Test + @DisplayName("/langchainstore/langchains → /llmstore/llms") + void langchainToLlm() { + assertEquals("/llmstore/llms/llm1", + LegacyPathRewriteFilter.rewritePath("/langchainstore/langchains/llm1")); + } + + @Test + @DisplayName("/behaviorstore/behaviorsets → /rulestore/rulesets") + void behaviorToRules() { + assertEquals("/rulestore/rulesets/rs1", + LegacyPathRewriteFilter.rewritePath("/behaviorstore/behaviorsets/rs1")); + } + + @Test + @DisplayName("/httpcallsstore/httpcalls → /apicallstore/apicalls") + void httpCallsToApiCalls() { + assertEquals("/apicallstore/apicalls/ac1", + LegacyPathRewriteFilter.rewritePath("/httpcallsstore/httpcalls/ac1")); + } + + @Test + @DisplayName("/regulardictionarystore/regulardictionaries → /dictionarystore/dictionaries") + void regularDictionaryToDictionary() { + assertEquals("/dictionarystore/dictionaries/d1", + LegacyPathRewriteFilter.rewritePath("/regulardictionarystore/regulardictionaries/d1")); + } + + @Test + @DisplayName("/bottriggerstore/bottriggers → /agenttriggerstore/agenttriggers") + void botTriggerToAgentTrigger() { + assertEquals("/agenttriggerstore/agenttriggers/t1", + LegacyPathRewriteFilter.rewritePath("/bottriggerstore/bottriggers/t1")); + } + + @Test + @DisplayName("/langchain/tools → /llm/tools") + void langchainToolsToLlmTools() { + assertEquals("/llm/tools", + LegacyPathRewriteFilter.rewritePath("/langchain/tools")); + } + } + + @Nested + @DisplayName("rewritePath — no match") + class NoMatchTests { + + @Test + @DisplayName("modern path is unchanged") + void modernPathUnchanged() { + String path = "/agentstore/agents/abc"; + assertEquals(path, LegacyPathRewriteFilter.rewritePath(path)); + } + + @Test + @DisplayName("root path is unchanged") + void rootPath() { + assertEquals("/", LegacyPathRewriteFilter.rewritePath("/")); + } + + @Test + @DisplayName("arbitrary path is unchanged") + void arbitraryPath() { + String path = "/api/v1/status"; + assertEquals(path, LegacyPathRewriteFilter.rewritePath(path)); + } + } +} diff --git a/src/test/java/ai/labs/eddi/modules/nlp/expressions/utilities/ExpressionProviderTest.java b/src/test/java/ai/labs/eddi/modules/nlp/expressions/utilities/ExpressionProviderTest.java new file mode 100644 index 000000000..8e019860d --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/nlp/expressions/utilities/ExpressionProviderTest.java @@ -0,0 +1,192 @@ +package ai.labs.eddi.modules.nlp.expressions.utilities; + +import ai.labs.eddi.modules.nlp.expressions.Expression; +import ai.labs.eddi.modules.nlp.expressions.ExpressionFactory; +import ai.labs.eddi.modules.nlp.expressions.Expressions; +import ai.labs.eddi.modules.nlp.expressions.value.Value; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +@DisplayName("ExpressionProvider Tests") +class ExpressionProviderTest { + + private ExpressionProvider provider; + + @BeforeEach + void setUp() { + provider = new ExpressionProvider(new ExpressionFactory()); + } + + @Nested + @DisplayName("createExpression") + class CreateExpressionTests { + + @Test + @DisplayName("simple predicate without values") + void simplePredicate() { + Expression exp = provider.createExpression("greeting"); + assertNotNull(exp); + assertEquals("greeting", exp.getExpressionName()); + } + + @Test + @DisplayName("predicate with single value") + void predicateWithValue() { + Expression exp = provider.createExpression("intent", "hello"); + assertNotNull(exp); + assertEquals("intent", exp.getExpressionName()); + assertTrue(exp.getSubExpressions().length > 0); + } + + @Test + @DisplayName("predicate with multiple values") + void predicateWithMultipleValues() { + Expression exp = provider.createExpression("relation", "a", "b"); + assertNotNull(exp); + assertEquals("relation", exp.getExpressionName()); + } + } + + @Nested + @DisplayName("parseExpressions") + class ParseExpressionsTests { + + @Test + @DisplayName("null input — returns empty Expressions") + void nullInput() { + Expressions result = provider.parseExpressions(null); + assertNotNull(result); + assertTrue(result.isEmpty()); + } + + @Test + @DisplayName("empty string — returns empty Expressions") + void emptyString() { + Expressions result = provider.parseExpressions(""); + assertNotNull(result); + assertTrue(result.isEmpty()); + } + + @Test + @DisplayName("single expression without parens") + void singleSimple() { + Expressions result = provider.parseExpressions("greeting"); + assertEquals(1, result.size()); + assertEquals("greeting", result.get(0).getExpressionName()); + } + + @Test + @DisplayName("single expression with parens") + void singleWithParens() { + Expressions result = provider.parseExpressions("intent(hello)"); + assertEquals(1, result.size()); + assertEquals("intent", result.get(0).getExpressionName()); + } + + @Test + @DisplayName("multiple comma-separated expressions") + void multipleExpressions() { + Expressions result = provider.parseExpressions("greeting,farewell"); + assertEquals(2, result.size()); + } + + @Test + @DisplayName("nested parentheses parsed correctly") + void nestedParens() { + Expressions result = provider.parseExpressions("intent(greeting(hello))"); + assertEquals(1, result.size()); + assertEquals("intent", result.get(0).getExpressionName()); + assertTrue(result.get(0).getSubExpressions().length > 0); + } + + @Test + @DisplayName("mixed expressions with and without parens") + void mixedExpressions() { + Expressions result = provider.parseExpressions("greeting,intent(hello),farewell"); + assertEquals(3, result.size()); + } + + @Test + @DisplayName("whitespace is trimmed") + void whitespace() { + Expressions result = provider.parseExpressions(" greeting "); + assertEquals(1, result.size()); + assertEquals("greeting", result.get(0).getExpressionName()); + } + } + + @Nested + @DisplayName("parseExpression") + class ParseExpressionTests { + + @Test + @DisplayName("simple word becomes Expression") + void simpleWord() { + Expression exp = provider.parseExpression("hello"); + assertNotNull(exp); + assertEquals("hello", exp.getExpressionName()); + } + + @Test + @DisplayName("expression with value in parens") + void withValue() { + Expression exp = provider.parseExpression("intent(greeting)"); + assertEquals("intent", exp.getExpressionName()); + assertEquals(1, exp.getSubExpressions().length); + } + + @Test + @DisplayName("numeric value becomes Value instance") + void numericValue() { + Expression exp = provider.parseExpression("42"); + assertInstanceOf(Value.class, exp); + } + + @Test + @DisplayName("special expressions — negation, and, or") + void specialExpressions() { + assertNotNull(provider.parseExpression("negation")); + assertNotNull(provider.parseExpression("and")); + assertNotNull(provider.parseExpression("or")); + } + } + + @Nested + @DisplayName("extractAllValues") + class ExtractAllValuesTests { + + @Test + @DisplayName("extract Value from simple expression") + void simpleValue() { + Expression exp = provider.parseExpression("42"); + List values = new ArrayList<>(); + provider.extractAllValues(exp, values); + assertEquals(1, values.size()); + } + + @Test + @DisplayName("extract nested values") + void nestedValues() { + Expression exp = provider.parseExpression("intent(42)"); + List values = new ArrayList<>(); + provider.extractAllValues(exp, values); + assertEquals(1, values.size()); + } + + @Test + @DisplayName("no values in plain expression") + void noValues() { + Expression exp = provider.parseExpression("greeting"); + List values = new ArrayList<>(); + provider.extractAllValues(exp, values); + assertTrue(values.isEmpty()); + } + } +} From 8b3f14c03fd1cb0a8c935c8c8f00a321ac8441fb Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 18:00:35 +0200 Subject: [PATCH 033/124] test(coverage): add IterationCounter unit tests - IterationCounter: +8 tests (single/dual input iteration, zero length, exhaustion, IterationPlan copy/equality) Total: 3,600 tests, all passing --- .../matches/IterationCounterTest.java | 121 ++++++++++++++++++ 1 file changed, 121 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/modules/nlp/internal/matches/IterationCounterTest.java diff --git a/src/test/java/ai/labs/eddi/modules/nlp/internal/matches/IterationCounterTest.java b/src/test/java/ai/labs/eddi/modules/nlp/internal/matches/IterationCounterTest.java new file mode 100644 index 000000000..5538545ec --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/nlp/internal/matches/IterationCounterTest.java @@ -0,0 +1,121 @@ +package ai.labs.eddi.modules.nlp.internal.matches; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.NoSuchElementException; + +import static org.junit.jupiter.api.Assertions.*; + +@DisplayName("IterationCounter Tests") +class IterationCounterTest { + + @Nested + @DisplayName("Basic iteration") + class BasicTests { + + @Test + @DisplayName("single input, single result — yields one plan") + void singleInputSingleResult() { + // 1 input term, resultLengths[0]=0 means 1 result (0-indexed max) + var counter = new IterationCounter(1, new Integer[]{0}); + assertTrue(counter.hasNext()); + + var plan = counter.next(); + assertNotNull(plan); + assertArrayEquals(new Integer[]{0}, plan.getIndexes()); + } + + @Test + @DisplayName("single input, two results — yields multiple plans") + void singleInputTwoResults() { + // 1 input term, resultLengths[0]=1 means 2 results (indices 0,1) + var counter = new IterationCounter(1, new Integer[]{1}); + var plans = new ArrayList(); + while (counter.hasNext()) { + plans.add(counter.next()); + } + assertTrue(plans.size() >= 2); + } + + @Test + @DisplayName("two inputs, one result each — yields combinatorial plans") + void twoInputsOneResultEach() { + var counter = new IterationCounter(2, new Integer[]{0, 0}); + var plans = new ArrayList(); + while (counter.hasNext()) { + plans.add(counter.next()); + } + // At minimum should have 1 plan [0,0] + assertTrue(plans.size() >= 1); + assertArrayEquals(new Integer[]{0, 0}, plans.get(0).getIndexes()); + } + + @Test + @DisplayName("two inputs, two results each — yields multiple permutations") + void twoInputsTwoResults() { + var counter = new IterationCounter(2, new Integer[]{1, 1}); + var plans = new ArrayList(); + while (counter.hasNext()) { + plans.add(counter.next()); + } + // Should have multiple combinations + assertTrue(plans.size() >= 2); + } + } + + @Nested + @DisplayName("Edge cases") + class EdgeCaseTests { + + @Test + @DisplayName("zero input length — no iterations") + void zeroInputLength() { + var counter = new IterationCounter(0, new Integer[]{}); + assertFalse(counter.hasNext()); + } + + @Test + @DisplayName("next() throws when exhausted") + void nextThrowsWhenExhausted() { + var counter = new IterationCounter(1, new Integer[]{0}); + counter.next(); // consume the only plan + assertThrows(NoSuchElementException.class, counter::next); + } + } + + @Nested + @DisplayName("IterationPlan") + class IterationPlanTests { + + @Test + @DisplayName("getIndexes returns a copy") + void getIndexesReturnsCopy() { + var counter = new IterationCounter(2, new Integer[]{0, 0}); + var plan = counter.next(); + Integer[] indexes = plan.getIndexes(); + + // Mutating the returned array shouldn't affect the plan + indexes[0] = 99; + // The plan stores its own copy, so getIndexes returns the stored array + // (not the original). We can only verify the plan was created correctly. + assertNotNull(plan.getIndexes()); + } + + @Test + @DisplayName("plans with same indexes are equal") + void plansEqual() { + var counter = new IterationCounter(1, new Integer[]{0}); + var plan1 = counter.next(); + + // Create another counter to get same plan + var counter2 = new IterationCounter(1, new Integer[]{0}); + var plan2 = counter2.next(); + + // Both should have index [0] + assertArrayEquals(plan1.getIndexes(), plan2.getIndexes()); + } + } +} From 20cf3bbac830f745cf582fb1ac601ceacb5cc4e4 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 18:01:37 +0200 Subject: [PATCH 034/124] docs: update changelog with batches 27-28 --- docs/changelog.md | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/docs/changelog.md b/docs/changelog.md index 3de3a46aa..7b3204117 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -13,6 +13,19 @@ Each entry follows this format: - **Decision** — Key design decisions and their reasoning - **Files** — Links to modified files +## Unit Test Coverage Expansion — Batches 27–28 (2026-04-20) + +**Repo:** EDDI (`test/coverage-tier-1-2`) + +**What changed:** Added 3 more test classes targeting interceptors, expression parsing, and NLP matching. Total: 3,600 tests, all passing. + +### Batch 27 — Interceptors & Expression Parsing +- `LegacyPathRewriteFilterTest` (11 tests) — All 8 store path rewrites (bots→agents, packages→workflows, langchains→llms, etc.), 3 no-match cases (modern path, root, arbitrary) +- `ExpressionProviderTest` (18 tests) — createExpression (simple, single/multi values), parseExpressions (null, empty, single, multiple, nested parens, mixed, whitespace), parseExpression (simple, with value, numeric→Value, special expressions), extractAllValues (simple, nested, no values) + +### Batch 28 — NLP Matching Algorithm +- `IterationCounterTest` (8 tests) — Single/dual input iteration with varying result counts, zero input length, exhaustion NoSuchElementException, IterationPlan defensive copy and equality + ## Unit Test Coverage Expansion — Batches 25–26 (2026-04-20) **Repo:** EDDI (`test/coverage-tier-1-2`) From 3d05dfc4283560b7161366ea712cb3326602550d Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 18:15:00 +0200 Subject: [PATCH 035/124] test(coverage): add Permutation and SetupResult unit tests - Permutation: +10 tests (single/two/three element permutations, unsorted input, exhaustion, copies, duplicates) - SetupResult: +5 tests (builder all/minimal fields, fluency, record equality) Total: 3,615 tests, all passing --- .../eddi/engine/setup/SetupResultTest.java | 98 ++++++++++++ .../nlp/internal/matches/PermutationTest.java | 148 ++++++++++++++++++ 2 files changed, 246 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/engine/setup/SetupResultTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/nlp/internal/matches/PermutationTest.java diff --git a/src/test/java/ai/labs/eddi/engine/setup/SetupResultTest.java b/src/test/java/ai/labs/eddi/engine/setup/SetupResultTest.java new file mode 100644 index 000000000..d2610261b --- /dev/null +++ b/src/test/java/ai/labs/eddi/engine/setup/SetupResultTest.java @@ -0,0 +1,98 @@ +package ai.labs.eddi.engine.setup; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +@DisplayName("SetupResult Tests") +class SetupResultTest { + + @Nested + @DisplayName("Builder") + class BuilderTests { + + @Test + @DisplayName("builds with all fields") + void allFields() { + var result = SetupResult.builder() + .action("setup_complete") + .agentId("agent1") + .agentName("My Agent") + .provider("openai") + .model("gpt-4o") + .deployed(true) + .deploymentStatus("READY") + .endpointCount(3) + .groups(List.of("group1")) + .quickRepliesEnabled(true) + .sentimentAnalysisEnabled(false) + .resources(Map.of("llm", "/llmstore/llms/llm1")) + .build(); + + assertEquals("setup_complete", result.action()); + assertEquals("agent1", result.agentId()); + assertEquals("My Agent", result.agentName()); + assertEquals("openai", result.provider()); + assertEquals("gpt-4o", result.model()); + assertTrue(result.deployed()); + assertEquals("READY", result.deploymentStatus()); + assertEquals(3, result.endpointCount()); + assertEquals(List.of("group1"), result.groups()); + assertTrue(result.quickRepliesEnabled()); + assertFalse(result.sentimentAnalysisEnabled()); + assertEquals("/llmstore/llms/llm1", result.resources().get("llm")); + } + + @Test + @DisplayName("builds with minimal fields") + void minimalFields() { + var result = SetupResult.builder() + .action("setup_complete") + .agentId("agent1") + .build(); + + assertEquals("setup_complete", result.action()); + assertEquals("agent1", result.agentId()); + assertNull(result.agentName()); + assertNull(result.provider()); + assertNull(result.model()); + assertNull(result.deployed()); + } + + @Test + @DisplayName("builder is fluent") + void builderFluent() { + var builder = SetupResult.builder(); + assertSame(builder, builder.action("test")); + assertSame(builder, builder.agentId("id")); + assertSame(builder, builder.agentName("name")); + } + } + + @Nested + @DisplayName("Record equality") + class EqualityTests { + + @Test + @DisplayName("same values are equal") + void sameValuesEqual() { + var a = SetupResult.builder().action("a").agentId("1").build(); + var b = SetupResult.builder().action("a").agentId("1").build(); + assertEquals(a, b); + assertEquals(a.hashCode(), b.hashCode()); + } + + @Test + @DisplayName("different values are not equal") + void differentValues() { + var a = SetupResult.builder().action("a").agentId("1").build(); + var b = SetupResult.builder().action("b").agentId("2").build(); + assertNotEquals(a, b); + } + } +} diff --git a/src/test/java/ai/labs/eddi/modules/nlp/internal/matches/PermutationTest.java b/src/test/java/ai/labs/eddi/modules/nlp/internal/matches/PermutationTest.java new file mode 100644 index 000000000..d9314719f --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/nlp/internal/matches/PermutationTest.java @@ -0,0 +1,148 @@ +package ai.labs.eddi.modules.nlp.internal.matches; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.NoSuchElementException; + +import static org.junit.jupiter.api.Assertions.*; + +@DisplayName("Permutation Tests") +class PermutationTest { + + @Nested + @DisplayName("Single element") + class SingleElementTests { + + @Test + @DisplayName("single element yields one permutation") + void singleElement() { + var perm = new Permutation(new Integer[]{1}); + var results = collect(perm); + assertEquals(1, results.size()); + assertArrayEquals(new Integer[]{1}, results.get(0)); + } + } + + @Nested + @DisplayName("Two elements") + class TwoElementTests { + + @Test + @DisplayName("two distinct elements yield 2 permutations") + void twoDistinct() { + var perm = new Permutation(new Integer[]{1, 2}); + var results = collect(perm); + assertEquals(2, results.size()); + } + + @Test + @DisplayName("permutations contain both orderings") + void bothOrderings() { + var perm = new Permutation(new Integer[]{1, 2}); + var results = collect(perm); + + boolean has12 = results.stream().anyMatch(a -> a[0] == 1 && a[1] == 2); + boolean has21 = results.stream().anyMatch(a -> a[0] == 2 && a[1] == 1); + assertTrue(has12, "Should contain [1,2]"); + assertTrue(has21, "Should contain [2,1]"); + } + } + + @Nested + @DisplayName("Three elements") + class ThreeElementTests { + + @Test + @DisplayName("three distinct elements yield 6 permutations") + void threeDistinct() { + var perm = new Permutation(new Integer[]{1, 2, 3}); + var results = collect(perm); + assertEquals(6, results.size()); + } + + @Test + @DisplayName("all permutations are unique") + void allUnique() { + var perm = new Permutation(new Integer[]{1, 2, 3}); + var results = collect(perm); + var strings = new HashSet(); + for (var arr : results) { + strings.add(arr[0] + "," + arr[1] + "," + arr[2]); + } + assertEquals(6, strings.size()); + } + } + + @Nested + @DisplayName("Unsorted input") + class UnsortedTests { + + @Test + @DisplayName("unsorted input is sorted before permuting") + void unsortedInput() { + var perm = new Permutation(new Integer[]{3, 1, 2}); + var results = collect(perm); + // First permutation should be sorted: [1, 2, 3] + assertArrayEquals(new Integer[]{1, 2, 3}, results.get(0)); + assertEquals(6, results.size()); + } + } + + @Nested + @DisplayName("Edge cases") + class EdgeCaseTests { + + @Test + @DisplayName("next() throws NoSuchElementException when exhausted") + void throwsWhenExhausted() { + var perm = new Permutation(new Integer[]{1}); + var it = perm.iterator(); + it.next(); // consume only permutation + assertThrows(NoSuchElementException.class, it::next); + } + + @Test + @DisplayName("for-each loop works") + void forEachLoop() { + int count = 0; + for (Integer[] p : new Permutation(new Integer[]{1, 2})) { + assertNotNull(p); + count++; + } + assertEquals(2, count); + } + + @Test + @DisplayName("returned arrays are copies") + void returnsCopies() { + var perm = new Permutation(new Integer[]{1, 2}); + var it = perm.iterator(); + var first = it.next(); + var second = it.next(); + // Mutating first should not affect second + first[0] = 99; + assertNotEquals(99, second[0]); + } + + @Test + @DisplayName("duplicate values — still generates expected count") + void duplicateValues() { + var perm = new Permutation(new Integer[]{1, 1}); + var results = collect(perm); + // With duplicates, factorial is 2 but only 1 unique perm + // Iterator produces based on factorial counter + assertTrue(results.size() >= 1); + } + } + + private List collect(Permutation perm) { + var results = new ArrayList(); + perm.iterator().forEachRemaining(results::add); + return results; + } +} From 0cb89779aaf94b98f1f8a88ca3eeb2e1d95c94ff Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 19:42:30 +0200 Subject: [PATCH 036/124] fix(tests): strengthen weak assertions from code review - InputParserTest: assert exact match type (PARTLY) and solution count instead of just assertNotNull/assertFalse - ConversationTest: verify CONVERSATION_START action string with argThat instead of anyList() - IterationCounterTest: document that getIndexes() exposes internal array (not defensive copy) --- .../engine/runtime/internal/ConversationTest.java | 3 ++- .../eddi/modules/nlp/internal/InputParserTest.java | 11 ++++++++--- .../nlp/internal/matches/IterationCounterTest.java | 12 ++++++------ 3 files changed, 16 insertions(+), 10 deletions(-) diff --git a/src/test/java/ai/labs/eddi/engine/runtime/internal/ConversationTest.java b/src/test/java/ai/labs/eddi/engine/runtime/internal/ConversationTest.java index ed497e4dc..571e826d2 100644 --- a/src/test/java/ai/labs/eddi/engine/runtime/internal/ConversationTest.java +++ b/src/test/java/ai/labs/eddi/engine/runtime/internal/ConversationTest.java @@ -102,13 +102,14 @@ class InitTests { @DisplayName("init sets state to READY and adds CONVERSATION_START action") void initSetsReady() throws Exception { when(propertiesHandler.getUserMemoryStore()).thenReturn(null); + when(propertiesHandler.getUserMemoryConfig()).thenReturn(null); when(workflow.getWorkflowId()).thenReturn("wf1"); var conv = createConversation(); conv.init(new HashMap<>()); verify(memory).setConversationState(ConversationState.READY); - verify(currentStep).set(any(), anyList()); + verify(currentStep).set(any(), argThat(list -> list instanceof List l && l.contains("CONVERSATION_START"))); } @Test diff --git a/src/test/java/ai/labs/eddi/modules/nlp/internal/InputParserTest.java b/src/test/java/ai/labs/eddi/modules/nlp/internal/InputParserTest.java index 758b5c5f6..f8f322fd0 100644 --- a/src/test/java/ai/labs/eddi/modules/nlp/internal/InputParserTest.java +++ b/src/test/java/ai/labs/eddi/modules/nlp/internal/InputParserTest.java @@ -103,17 +103,22 @@ void unknownWord() throws Exception { var parser = new InputParser(List.of()); List solutions = parser.parse("xyz123"); - assertFalse(solutions.isEmpty()); + assertEquals(1, solutions.size()); + // With no dictionaries but includeUnknown=true (default), unknown words produce + // PARTLY + assertEquals(RawSolution.Match.PARTLY, solutions.get(0).getMatch()); } @Test - @DisplayName("empty string returns empty solutions") + @DisplayName("empty string returns solution with NOTHING match") void emptyString() throws Exception { var parser = new InputParser(List.of()); List solutions = parser.parse(""); - // Empty string splits to [""], which is treated as unknown + // Empty string splits to [""], which is treated as an unknown word assertNotNull(solutions); + assertFalse(solutions.isEmpty()); + assertEquals(RawSolution.Match.PARTLY, solutions.get(0).getMatch()); } @Test diff --git a/src/test/java/ai/labs/eddi/modules/nlp/internal/matches/IterationCounterTest.java b/src/test/java/ai/labs/eddi/modules/nlp/internal/matches/IterationCounterTest.java index 5538545ec..ae2eda1ab 100644 --- a/src/test/java/ai/labs/eddi/modules/nlp/internal/matches/IterationCounterTest.java +++ b/src/test/java/ai/labs/eddi/modules/nlp/internal/matches/IterationCounterTest.java @@ -91,17 +91,17 @@ void nextThrowsWhenExhausted() { class IterationPlanTests { @Test - @DisplayName("getIndexes returns a copy") - void getIndexesReturnsCopy() { + @DisplayName("getIndexes exposes internal array (mutation visible)") + void getIndexesExposesInternalArray() { var counter = new IterationCounter(2, new Integer[]{0, 0}); var plan = counter.next(); Integer[] indexes = plan.getIndexes(); - // Mutating the returned array shouldn't affect the plan + // IterationPlan stores its own copy at construction time, + // but getIndexes() returns the stored array directly — not a copy. indexes[0] = 99; - // The plan stores its own copy, so getIndexes returns the stored array - // (not the original). We can only verify the plan was created correctly. - assertNotNull(plan.getIndexes()); + assertEquals(99, plan.getIndexes()[0], + "getIndexes() returns the internal array, so mutations are visible"); } @Test From a847cd591825cd23ea0c364ac7d9caecadb4e8ad Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 20:35:39 +0200 Subject: [PATCH 037/124] test(engine): expand unit tests for MemoryItemConverter, LifecycleManager, ApiCallsTask --- .../internal/LifecycleManagerTest.java | 190 +++++++++++ .../memory/MemoryItemConverterTest.java | 298 ++++++++++++++---- .../apicalls/impl/ApiCallsTaskTest.java | 102 ++++++ 3 files changed, 529 insertions(+), 61 deletions(-) diff --git a/src/test/java/ai/labs/eddi/engine/lifecycle/internal/LifecycleManagerTest.java b/src/test/java/ai/labs/eddi/engine/lifecycle/internal/LifecycleManagerTest.java index 3a9ee0141..0e5d41186 100644 --- a/src/test/java/ai/labs/eddi/engine/lifecycle/internal/LifecycleManagerTest.java +++ b/src/test/java/ai/labs/eddi/engine/lifecycle/internal/LifecycleManagerTest.java @@ -411,4 +411,194 @@ void auditCollectorNotified() throws Exception { verify(auditCollector).collect(any()); } } + + @Nested + @DisplayName("Thread Interruption") + class ThreadInterruptionTests { + + @Test + @DisplayName("interrupted thread throws LifecycleInterruptedException") + void interruptedThread() { + var task = mock(ILifecycleTask.class); + when(task.getId()).thenReturn("parser"); + when(task.getType()).thenReturn("input"); + + lifecycleManager.addLifecycleTask(task); + + var memory = mock(IConversationMemory.class); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + + // Interrupt the current thread before execution + Thread.currentThread().interrupt(); + + try { + assertThrows(LifecycleException.LifecycleInterruptedException.class, + () -> lifecycleManager.executeLifecycle(memory, null)); + } finally { + // Clear interrupt flag so it doesn't affect other tests + Thread.interrupted(); + } + } + } + + @Nested + @DisplayName("Strict Write Discipline — Edge Cases") + class StrictWriteDisciplineEdgeCases { + + @Test + @DisplayName("keep_all mode — isEffectivelyEnabled() returns false, no SWD applied") + void keepAllMode() throws Exception { + var task = mock(ILifecycleTask.class); + when(task.getId()).thenReturn("llm_task"); + when(task.getType()).thenReturn("langchain"); + + doThrow(new LifecycleException("LLM error")) + .when(task).execute(any(), any()); + + lifecycleManager.addLifecycleTask(task); + + var memory = mock(IConversationMemory.class); + var currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + + // keep_all mode makes isEffectivelyEnabled() return false + var memoryPolicy = new AgentConfiguration.MemoryPolicy(); + var swd = new AgentConfiguration.StrictWriteDiscipline(); + swd.setEnabled(true); + swd.setOnFailure("keep_all"); + memoryPolicy.setStrictWriteDiscipline(swd); + when(memory.getMemoryPolicy()).thenReturn(memoryPolicy); + + when(componentCache.getComponentMap(anyString())).thenReturn(new HashMap<>()); + + assertThrows(LifecycleException.class, + () -> lifecycleManager.executeLifecycle(memory, null)); + + // keep_all → isEffectivelyEnabled() is false → no strict write applied + verify(currentStep, never()).addConversationOutputList(anyString(), anyList()); + } + + @Test + @DisplayName("null memoryPolicy — strict write discipline not applied") + void nullMemoryPolicy() throws Exception { + var task = mock(ILifecycleTask.class); + when(task.getId()).thenReturn("failing_task"); + when(task.getType()).thenReturn("custom"); + + doThrow(new LifecycleException("fail")) + .when(task).execute(any(), any()); + + lifecycleManager.addLifecycleTask(task); + + var memory = mock(IConversationMemory.class); + var currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + when(memory.getMemoryPolicy()).thenReturn(null); + + when(componentCache.getComponentMap(anyString())).thenReturn(new HashMap<>()); + + assertThrows(LifecycleException.class, + () -> lifecycleManager.executeLifecycle(memory, null)); + + // No strict write discipline applied — no uncommit, no digest + verify(currentStep, never()).addConversationOutputList(anyString(), anyList()); + } + + @Test + @DisplayName("disabled strict write — no uncommit even on failure") + void disabledStrictWrite() throws Exception { + var task = mock(ILifecycleTask.class); + when(task.getId()).thenReturn("failing_task"); + when(task.getType()).thenReturn("custom"); + + doThrow(new LifecycleException("fail")) + .when(task).execute(any(), any()); + + lifecycleManager.addLifecycleTask(task); + + var memory = mock(IConversationMemory.class); + var currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + + var memoryPolicy = new AgentConfiguration.MemoryPolicy(); + var swd = new AgentConfiguration.StrictWriteDiscipline(); + swd.setEnabled(false); + memoryPolicy.setStrictWriteDiscipline(swd); + when(memory.getMemoryPolicy()).thenReturn(memoryPolicy); + + when(componentCache.getComponentMap(anyString())).thenReturn(new HashMap<>()); + + assertThrows(LifecycleException.class, + () -> lifecycleManager.executeLifecycle(memory, null)); + + // Strict write is disabled — no error digest + verify(currentStep, never()).addConversationOutputList(anyString(), anyList()); + } + + @Test + @DisplayName("failure after first task — second task does NOT execute") + void failureStopsPipeline() throws Exception { + var task1 = mock(ILifecycleTask.class); + when(task1.getId()).thenReturn("parser"); + when(task1.getType()).thenReturn("input"); + + var task2 = mock(ILifecycleTask.class); + when(task2.getId()).thenReturn("behavior"); + when(task2.getType()).thenReturn("behavior_rules"); + + doThrow(new LifecycleException("parse error")) + .when(task1).execute(any(), any()); + + lifecycleManager.addLifecycleTask(task1); + lifecycleManager.addLifecycleTask(task2); + + var memory = mock(IConversationMemory.class); + var currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + + when(componentCache.getComponentMap(anyString())).thenReturn(new HashMap<>()); + + assertThrows(LifecycleException.class, + () -> lifecycleManager.executeLifecycle(memory, null)); + + verify(task1).execute(any(), any()); + verify(task2, never()).execute(any(), any()); + } + } + + @Nested + @DisplayName("Selective Execution — Additional") + class SelectiveExecutionAdditionalTests { + + @Test + @DisplayName("empty lifecycleTaskTypes — all tasks execute (same as null)") + void emptyListExecutesAll() throws Exception { + var task = mock(ILifecycleTask.class); + when(task.getId()).thenReturn("parser"); + when(task.getType()).thenReturn("input"); + + lifecycleManager.addLifecycleTask(task); + + var memory = mock(IConversationMemory.class); + var currentStep = mock(IConversationMemory.IWritableConversationStep.class); + when(memory.getCurrentStep()).thenReturn(currentStep); + when(memory.getConversationId()).thenReturn("conv1"); + when(memory.getAgentId()).thenReturn("agent1"); + + when(componentCache.getComponentMap(anyString())).thenReturn(new HashMap<>()); + + lifecycleManager.executeLifecycle(memory, List.of()); + + verify(task).execute(eq(memory), any()); + } + } } diff --git a/src/test/java/ai/labs/eddi/engine/memory/MemoryItemConverterTest.java b/src/test/java/ai/labs/eddi/engine/memory/MemoryItemConverterTest.java index d808a8a5e..89849a3f5 100644 --- a/src/test/java/ai/labs/eddi/engine/memory/MemoryItemConverterTest.java +++ b/src/test/java/ai/labs/eddi/engine/memory/MemoryItemConverterTest.java @@ -1,16 +1,20 @@ package ai.labs.eddi.engine.memory; +import ai.labs.eddi.configs.properties.model.Property; import ai.labs.eddi.engine.memory.model.ConversationOutput; import ai.labs.eddi.engine.memory.model.Data; import ai.labs.eddi.engine.model.Context; import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; -import java.util.HashMap; +import java.util.List; import java.util.Map; import static org.junit.jupiter.api.Assertions.*; +@DisplayName("MemoryItemConverter") class MemoryItemConverterTest { private MemoryItemConverter converter; @@ -20,82 +24,254 @@ void setUp() { converter = new MemoryItemConverter(); } - @Test - void convert_withBasicMemory_containsAllTopLevelKeys() { - var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); - Map result = converter.convert(memory); + // ─── Top-Level Structure ──────────────────────────────────── - assertNotNull(result); - assertTrue(result.containsKey("conversationLog")); - assertTrue(result.containsKey("userInfo")); - assertTrue(result.containsKey("conversationInfo")); - } + @Nested + @DisplayName("Top-level output structure") + class TopLevelStructure { + + @Test + @DisplayName("contains all required top-level keys with valid identity") + void containsAllTopLevelKeys() { + var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); + Map result = converter.convert(memory); - @Test - void convert_userInfo_containsUserId() { - var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); - Map result = converter.convert(memory); + assertNotNull(result); + assertTrue(result.containsKey("conversationLog")); + assertTrue(result.containsKey("userInfo")); + assertTrue(result.containsKey("conversationInfo")); + } - @SuppressWarnings("unchecked") - var userInfo = (Map) result.get("userInfo"); - assertNotNull(userInfo); - assertEquals("user-1", userInfo.get("userId")); + @Test + @DisplayName("conversationLog is always present even with empty memory") + void conversationLogAlwaysPresent() { + var memory = new ConversationMemory("agent-1", 1); + Map result = converter.convert(memory); + assertTrue(result.containsKey("conversationLog")); + } } - @Test - void convert_conversationInfo_containsAgentIdAndVersion() { - var memory = new ConversationMemory("conv-1", "agent-1", 2, "user-1"); - Map result = converter.convert(memory); - - @SuppressWarnings("unchecked") - var convInfo = (Map) result.get("conversationInfo"); - assertNotNull(convInfo); - assertEquals("conv-1", convInfo.get("conversationId")); - assertEquals("agent-1", convInfo.get("agentId")); - assertEquals("2", convInfo.get("agentVersion")); + // ─── Context ──────────────────────────────────────────────── + + @Nested + @DisplayName("Context handling") + class ContextTests { + + @Test + @DisplayName("with context data — produces context map and top-level merge") + void withContextData() { + var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); + var ctx = new Context(); + ctx.setType(Context.ContextType.string); + ctx.setValue("en"); + memory.getCurrentStep().storeData(new Data<>("context:lang", ctx)); + + Map result = converter.convert(memory); + + assertTrue(result.containsKey("context")); + @SuppressWarnings("unchecked") + var contextMap = (Map) result.get("context"); + assertEquals("en", contextMap.get("lang")); + // Context entries are also merged into top level + assertEquals("en", result.get("lang")); + } + + @Test + @DisplayName("empty context list — no context key present") + void emptyContextList() { + var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); + Map result = converter.convert(memory); + assertFalse(result.containsKey("context")); + } + + @Test + @DisplayName("multiple context entries — all present in map") + void multipleContextEntries() { + var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); + + var ctx1 = new Context(); + ctx1.setType(Context.ContextType.string); + ctx1.setValue("en"); + memory.getCurrentStep().storeData(new Data<>("context:language", ctx1)); + + var ctx2 = new Context(); + ctx2.setType(Context.ContextType.string); + ctx2.setValue("premium"); + memory.getCurrentStep().storeData(new Data<>("context:tier", ctx2)); + + Map result = converter.convert(memory); + + @SuppressWarnings("unchecked") + var contextMap = (Map) result.get("context"); + assertEquals("en", contextMap.get("language")); + assertEquals("premium", contextMap.get("tier")); + } } - @Test - void convert_withContext_containsContextMap() { - var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); - var ctx = new Context(); - ctx.setType(Context.ContextType.string); - ctx.setValue("en"); - memory.getCurrentStep().storeData(new Data<>("context:lang", ctx)); + // ─── Properties ───────────────────────────────────────────── + + @Nested + @DisplayName("Properties handling") + class PropertiesTests { - Map result = converter.convert(memory); + @Test + @DisplayName("with properties — produces properties map") + void withProperties() { + var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); + var prop = new Property("name", "John", Property.Scope.conversation); + memory.getConversationProperties().put("name", prop); - assertTrue(result.containsKey("context")); - @SuppressWarnings("unchecked") - var contextMap = (Map) result.get("context"); - assertEquals("en", contextMap.get("lang")); + Map result = converter.convert(memory); + assertTrue(result.containsKey("properties")); + } + + @Test + @DisplayName("empty properties — no properties key present") + void emptyProperties() { + var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); + Map result = converter.convert(memory); + assertFalse(result.containsKey("properties")); + } } - @Test - void convert_memorySection_containsCurrentLastPast() { - var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); - // Add some data to make memory non-empty - memory.getCurrentStep().addConversationOutputString("input", "hello"); + // ─── User/Conversation Info ───────────────────────────────── + + @Nested + @DisplayName("Info objects") + class InfoObjectTests { + + @Test + @DisplayName("userInfo contains userId") + void userInfoContainsUserId() { + var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); + Map result = converter.convert(memory); + + @SuppressWarnings("unchecked") + var userInfo = (Map) result.get("userInfo"); + assertNotNull(userInfo); + assertEquals("user-1", userInfo.get("userId")); + } + + @Test + @DisplayName("conversationInfo contains conversationId, agentId, agentVersion") + void conversationInfoAllFields() { + var memory = new ConversationMemory("conv-1", "agent-1", 2, "user-1"); + Map result = converter.convert(memory); + + @SuppressWarnings("unchecked") + var convInfo = (Map) result.get("conversationInfo"); + assertNotNull(convInfo); + assertEquals("conv-1", convInfo.get("conversationId")); + assertEquals("agent-1", convInfo.get("agentId")); + assertEquals("2", convInfo.get("agentVersion")); + } - Map result = converter.convert(memory); + @Test + @DisplayName("null userId — no userInfo key present") + void nullUserId() { + var memory = new ConversationMemory("agent-1", 1); + Map result = converter.convert(memory); + assertFalse(result.containsKey("userInfo")); + } - assertTrue(result.containsKey("memory")); - @SuppressWarnings("unchecked") - var memoryMap = (Map) result.get("memory"); - assertTrue(memoryMap.containsKey("current")); - assertTrue(memoryMap.containsKey("last")); - assertTrue(memoryMap.containsKey("past")); + @Test + @DisplayName("conversationInfo merges multiple fields into same map") + void conversationInfoMergesFields() { + var memory = new ConversationMemory("conv-1", "agent-1", 3, "user-1"); + Map result = converter.convert(memory); + + @SuppressWarnings("unchecked") + var convInfo = (Map) result.get("conversationInfo"); + // All three fields should be in the same map + assertEquals(3, convInfo.size()); + } } - @Test - void convert_withProperties_containsPropertiesMap() { - var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); - var prop = new ai.labs.eddi.configs.properties.model.Property("name", "John", - ai.labs.eddi.configs.properties.model.Property.Scope.conversation); - memory.getConversationProperties().put("name", prop); + // ─── Memory Section ───────────────────────────────────────── + + @Nested + @DisplayName("Memory section (current/last/past)") + class MemorySectionTests { + + @Test + @DisplayName("memory section with data — contains current, last, past") + void memoryWithData() { + var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); + memory.getCurrentStep().addConversationOutputString("input", "hello"); + + Map result = converter.convert(memory); + + assertTrue(result.containsKey("memory")); + @SuppressWarnings("unchecked") + var memoryMap = (Map) result.get("memory"); + assertTrue(memoryMap.containsKey("current")); + assertTrue(memoryMap.containsKey("last")); + assertTrue(memoryMap.containsKey("past")); + } + + @Test + @DisplayName("no previous steps — last is empty, past is empty list") + void noPreviousSteps() { + var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); + memory.getCurrentStep().addConversationOutputString("input", "hello"); + + Map result = converter.convert(memory); + + @SuppressWarnings("unchecked") + var memoryMap = (Map) result.get("memory"); + + var last = (ConversationOutput) memoryMap.get("last"); + assertTrue(last.isEmpty()); + + @SuppressWarnings("unchecked") + var past = (List) memoryMap.get("past"); + assertTrue(past.isEmpty()); + } + + @Test + @DisplayName("with previous steps — last contains previous step output, past contains earlier") + void withPreviousSteps() { + var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); + memory.getCurrentStep().addConversationOutputString("input", "first"); + memory.startNextStep(); + memory.getCurrentStep().addConversationOutputString("input", "second"); + memory.startNextStep(); + memory.getCurrentStep().addConversationOutputString("input", "third"); + + Map result = converter.convert(memory); + + @SuppressWarnings("unchecked") + var memoryMap = (Map) result.get("memory"); + + // Current should be "third" + var current = (ConversationOutput) memoryMap.get("current"); + assertEquals("third", current.get("input")); + + // Last should be "second" (previous step index 0 = most recent) + var last = (ConversationOutput) memoryMap.get("last"); + assertEquals("second", last.get("input")); + + // Past should contain only "first" (all outputs except first one, which is + // current) + @SuppressWarnings("unchecked") + var past = (List) memoryMap.get("past"); + assertFalse(past.isEmpty()); + } + + @Test + @DisplayName("single output — past is empty list") + void singleOutputPastEmpty() { + var memory = new ConversationMemory("conv-1", "agent-1", 1, "user-1"); + memory.getCurrentStep().addConversationOutputString("input", "only"); + + Map result = converter.convert(memory); - Map result = converter.convert(memory); + @SuppressWarnings("unchecked") + var memoryMap = (Map) result.get("memory"); - assertTrue(result.containsKey("properties")); + @SuppressWarnings("unchecked") + var past = (List) memoryMap.get("past"); + assertTrue(past.isEmpty()); + } } } diff --git a/src/test/java/ai/labs/eddi/modules/apicalls/impl/ApiCallsTaskTest.java b/src/test/java/ai/labs/eddi/modules/apicalls/impl/ApiCallsTaskTest.java index 4484c92f2..22bf43a2f 100644 --- a/src/test/java/ai/labs/eddi/modules/apicalls/impl/ApiCallsTaskTest.java +++ b/src/test/java/ai/labs/eddi/modules/apicalls/impl/ApiCallsTaskTest.java @@ -150,6 +150,108 @@ void wildcardAction() throws Exception { verify(httpCallExecutor).execute(eq(wildcardCall), any(), any(), any()); } + + @Test + @DisplayName("empty actions list — no API calls executed") + @SuppressWarnings("unchecked") + void emptyActionsList() throws Exception { + IData> actionsData = mock(IData.class); + when(actionsData.getResult()).thenReturn(List.of()); + when(currentStep.getLatestData(MemoryKeys.ACTIONS)).thenReturn(actionsData); + when(memoryItemConverter.convert(memory)).thenReturn(new HashMap<>()); + + ApiCall greetCall = new ApiCall(); + greetCall.setActions(List.of("greet")); + + ApiCallsConfiguration config = new ApiCallsConfiguration(); + config.setHttpCalls(List.of(greetCall)); + config.setTargetServerUrl("http://localhost:8080"); + + task.execute(memory, config); + + verifyNoInteractions(httpCallExecutor); + } + + @Test + @DisplayName("multiple matching API calls execute in order") + @SuppressWarnings("unchecked") + void multipleMatchingCallsExecuteInOrder() throws Exception { + IData> actionsData = mock(IData.class); + when(actionsData.getResult()).thenReturn(List.of("greet")); + when(currentStep.getLatestData(MemoryKeys.ACTIONS)).thenReturn(actionsData); + when(memoryItemConverter.convert(memory)).thenReturn(new HashMap<>()); + + ApiCall call1 = new ApiCall(); + call1.setActions(List.of("greet")); + ApiCall call2 = new ApiCall(); + call2.setActions(List.of("greet")); + + ApiCallsConfiguration config = new ApiCallsConfiguration(); + config.setHttpCalls(List.of(call1, call2)); + config.setTargetServerUrl("http://localhost:8080"); + + when(httpCallExecutor.execute(any(), any(), any(), any())).thenReturn(Map.of("key", "val")); + + task.execute(memory, config); + + var inOrder = inOrder(httpCallExecutor); + inOrder.verify(httpCallExecutor).execute(eq(call1), any(), any(), any()); + inOrder.verify(httpCallExecutor).execute(eq(call2), any(), any(), any()); + } + + @Test + @DisplayName("httpCallResult null — does not merge into templateData") + @SuppressWarnings("unchecked") + void nullResultNoMerge() throws Exception { + IData> actionsData = mock(IData.class); + when(actionsData.getResult()).thenReturn(List.of("fetch")); + when(currentStep.getLatestData(MemoryKeys.ACTIONS)).thenReturn(actionsData); + + var templateData = new HashMap(); + when(memoryItemConverter.convert(memory)).thenReturn(templateData); + + ApiCall fetchCall = new ApiCall(); + fetchCall.setActions(List.of("fetch")); + + ApiCallsConfiguration config = new ApiCallsConfiguration(); + config.setHttpCalls(List.of(fetchCall)); + config.setTargetServerUrl("http://api.example.com"); + + when(httpCallExecutor.execute(any(), any(), any(), any())).thenReturn(null); + + task.execute(memory, config); + + // templateData should not have been modified (null result) + assertTrue(templateData.isEmpty()); + } + + @Test + @DisplayName("httpCallResult non-empty — merges into templateData for subsequent calls") + @SuppressWarnings("unchecked") + void nonEmptyResultMerges() throws Exception { + IData> actionsData = mock(IData.class); + when(actionsData.getResult()).thenReturn(List.of("fetch")); + when(currentStep.getLatestData(MemoryKeys.ACTIONS)).thenReturn(actionsData); + + var templateData = new HashMap(); + when(memoryItemConverter.convert(memory)).thenReturn(templateData); + + ApiCall fetchCall = new ApiCall(); + fetchCall.setActions(List.of("fetch")); + + ApiCallsConfiguration config = new ApiCallsConfiguration(); + config.setHttpCalls(List.of(fetchCall)); + config.setTargetServerUrl("http://api.example.com"); + + when(httpCallExecutor.execute(any(), any(), any(), any())) + .thenReturn(Map.of("weather", "sunny", "temp", "72")); + + task.execute(memory, config); + + // templateData should now contain merged results + assertEquals("sunny", templateData.get("weather")); + assertEquals("72", templateData.get("temp")); + } } @Nested From c16c5c365c4a415be043f5950a2492654199cebc Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 20:48:27 +0200 Subject: [PATCH 038/124] test(postgres): add PostgresTestBase + PostgresSecretPersistenceIT (18 tests) --- .../postgres/PostgresSecretPersistenceIT.java | 278 ++++++++++++++++++ .../datastore/postgres/PostgresTestBase.java | 127 ++++++++ 2 files changed, 405 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/datastore/postgres/PostgresSecretPersistenceIT.java create mode 100644 src/test/java/ai/labs/eddi/datastore/postgres/PostgresTestBase.java diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresSecretPersistenceIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresSecretPersistenceIT.java new file mode 100644 index 000000000..fe94a7ecb --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresSecretPersistenceIT.java @@ -0,0 +1,278 @@ +package ai.labs.eddi.datastore.postgres; + +import ai.labs.eddi.secrets.model.EncryptedDek; +import ai.labs.eddi.secrets.model.EncryptedSecret; +import ai.labs.eddi.secrets.persistence.PostgresSecretPersistence; +import org.junit.jupiter.api.*; + +import javax.sql.DataSource; +import java.sql.SQLException; +import java.time.Instant; +import java.time.temporal.ChronoUnit; +import java.util.List; +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link PostgresSecretPersistence} using Testcontainers. + *

+ * Tests run against a real PostgreSQL instance. Named *IT.java so Maven + * Failsafe picks them up with {@code mvn verify -DskipITs=false}. + * + * @since 6.0.0 + */ +@DisplayName("PostgresSecretPersistence IT") +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) +class PostgresSecretPersistenceIT extends PostgresTestBase { + + private static PostgresSecretPersistence persistence; + private static DataSource ds; + + @BeforeAll + static void initPersistence() { + var dsInstance = createDataSourceInstance(); + ds = dsInstance.get(); + persistence = new PostgresSecretPersistence(dsInstance); + } + + @BeforeEach + void cleanTables() throws SQLException { + // Tables are created lazily by ensureSchema() on first call. + // After the first test runs, tables exist and we can truncate. + try { + truncateTables(ds, "secret_vault_secrets", "secret_vault_deks", "secret_vault_meta"); + } catch (SQLException e) { + // Tables don't exist yet on the very first test — that's fine, + // ensureSchema() will create them. + } + } + + // ─── Secrets ──────────────────────────────────────────────── + + @Nested + @DisplayName("Secrets CRUD") + class SecretsCrud { + + @Test + @DisplayName("upsert + find round-trip") + void upsertAndFind() { + var secret = createSecret("tenant1", "API_KEY", "enc_val_1", "iv1", "dek1"); + persistence.upsertSecret(secret); + + Optional found = persistence.findSecret("tenant1", "API_KEY"); + assertTrue(found.isPresent()); + assertEquals("tenant1", found.get().getTenantId()); + assertEquals("API_KEY", found.get().getKeyName()); + assertEquals("enc_val_1", found.get().getEncryptedValue()); + assertEquals("iv1", found.get().getIv()); + assertEquals("dek1", found.get().getDekId()); + } + + @Test + @DisplayName("upsert existing — updates value") + void upsertExisting() { + var secret = createSecret("tenant1", "API_KEY", "old_value", "iv1", "dek1"); + persistence.upsertSecret(secret); + + // Update with new value + var updated = createSecret("tenant1", "API_KEY", "new_value", "iv2", "dek1"); + persistence.upsertSecret(updated); + + Optional found = persistence.findSecret("tenant1", "API_KEY"); + assertTrue(found.isPresent()); + assertEquals("new_value", found.get().getEncryptedValue()); + assertEquals("iv2", found.get().getIv()); + } + + @Test + @DisplayName("find non-existent — returns empty") + void findNonExistent() { + Optional found = persistence.findSecret("ghost", "ghost_key"); + assertTrue(found.isEmpty()); + } + + @Test + @DisplayName("delete existing — returns true") + void deleteExisting() { + persistence.upsertSecret(createSecret("tenant1", "TO_DELETE", "val", "iv", "dek")); + boolean deleted = persistence.deleteSecret("tenant1", "TO_DELETE"); + assertTrue(deleted); + assertTrue(persistence.findSecret("tenant1", "TO_DELETE").isEmpty()); + } + + @Test + @DisplayName("delete non-existent — returns false") + void deleteNonExistent() { + boolean deleted = persistence.deleteSecret("ghost", "ghost_key"); + assertFalse(deleted); + } + + @Test + @DisplayName("listSecretsByTenant — returns all secrets for tenant") + void listByTenant() { + persistence.upsertSecret(createSecret("tenant1", "KEY_A", "a", "iv", "dek")); + persistence.upsertSecret(createSecret("tenant1", "KEY_B", "b", "iv", "dek")); + persistence.upsertSecret(createSecret("tenant2", "KEY_C", "c", "iv", "dek")); + + List tenant1Secrets = persistence.listSecretsByTenant("tenant1"); + assertEquals(2, tenant1Secrets.size()); + + List tenant2Secrets = persistence.listSecretsByTenant("tenant2"); + assertEquals(1, tenant2Secrets.size()); + } + + @Test + @DisplayName("allowedAgents — JSONB round-trip preserves list") + void allowedAgentsJsonb() { + var secret = createSecret("tenant1", "RESTRICTED", "val", "iv", "dek"); + secret.setAllowedAgents(List.of("agent-1", "agent-2")); + persistence.upsertSecret(secret); + + var found = persistence.findSecret("tenant1", "RESTRICTED"); + assertTrue(found.isPresent()); + assertEquals(List.of("agent-1", "agent-2"), found.get().getAllowedAgents()); + } + + @Test + @DisplayName("null allowedAgents — defaults to [*]") + void nullAllowedAgents() { + var secret = createSecret("tenant1", "OPEN", "val", "iv", "dek"); + secret.setAllowedAgents(null); + persistence.upsertSecret(secret); + + var found = persistence.findSecret("tenant1", "OPEN"); + assertTrue(found.isPresent()); + assertEquals(List.of("*"), found.get().getAllowedAgents()); + } + + @Test + @DisplayName("timestamps round-trip") + void timestampsRoundTrip() { + Instant now = Instant.now().truncatedTo(ChronoUnit.MILLIS); + var secret = createSecret("tenant1", "TIMED", "val", "iv", "dek"); + secret.setCreatedAt(now); + secret.setLastAccessedAt(now); + secret.setLastRotatedAt(now); + persistence.upsertSecret(secret); + + var found = persistence.findSecret("tenant1", "TIMED"); + assertTrue(found.isPresent()); + // Postgres TIMESTAMP has microsecond precision — compare truncated + assertEquals(now.truncatedTo(ChronoUnit.MILLIS), + found.get().getCreatedAt().truncatedTo(ChronoUnit.MILLIS)); + } + } + + // ─── DEKs ─────────────────────────────────────────────────── + + @Nested + @DisplayName("DEK CRUD") + class DekCrud { + + @Test + @DisplayName("upsert + find round-trip") + void upsertAndFind() { + var dek = new EncryptedDek(null, "tenant1", "enc_dek_data", "dek_iv", Instant.now()); + persistence.upsertDek(dek); + + Optional found = persistence.findDek("tenant1"); + assertTrue(found.isPresent()); + assertEquals("tenant1", found.get().getTenantId()); + assertEquals("enc_dek_data", found.get().getEncryptedDek()); + assertEquals("dek_iv", found.get().getIv()); + assertNotNull(found.get().getId()); // auto-generated + } + + @Test + @DisplayName("upsert existing — updates DEK value") + void upsertExisting() { + persistence.upsertDek(new EncryptedDek(null, "tenant1", "old_dek", "iv1", Instant.now())); + persistence.upsertDek(new EncryptedDek(null, "tenant1", "new_dek", "iv2", Instant.now())); + + var found = persistence.findDek("tenant1"); + assertTrue(found.isPresent()); + assertEquals("new_dek", found.get().getEncryptedDek()); + assertEquals("iv2", found.get().getIv()); + } + + @Test + @DisplayName("find non-existent — returns empty") + void findNonExistent() { + assertTrue(persistence.findDek("ghost_tenant").isEmpty()); + } + + @Test + @DisplayName("delete — removes DEK") + void deleteDek() { + persistence.upsertDek(new EncryptedDek(null, "tenant_del", "dek", "iv", Instant.now())); + persistence.deleteDek("tenant_del"); + assertTrue(persistence.findDek("tenant_del").isEmpty()); + } + + @Test + @DisplayName("listAllDeks — returns all DEKs") + void listAll() { + persistence.upsertDek(new EncryptedDek(null, "t1", "d1", "iv1", Instant.now())); + persistence.upsertDek(new EncryptedDek(null, "t2", "d2", "iv2", Instant.now())); + + List all = persistence.listAllDeks(); + assertTrue(all.size() >= 2); + } + } + + // ─── Metadata ─────────────────────────────────────────────── + + @Nested + @DisplayName("Metadata CRUD") + class MetadataCrud { + + @Test + @DisplayName("set + get round-trip") + void setAndGet() { + persistence.setMetaValue("vault.version", "2"); + assertEquals("2", persistence.getMetaValue("vault.version")); + } + + @Test + @DisplayName("set existing — upserts value") + void setExistingUpserts() { + persistence.setMetaValue("vault.version", "1"); + persistence.setMetaValue("vault.version", "3"); + assertEquals("3", persistence.getMetaValue("vault.version")); + } + + @Test + @DisplayName("get non-existent — returns null") + void getNonExistent() { + assertNull(persistence.getMetaValue("nonexistent.key")); + } + } + + // ─── Schema ───────────────────────────────────────────────── + + @Test + @DisplayName("ensureSchema is idempotent — second call does not throw") + void ensureSchemaIdempotent() { + // First call creates tables (implicitly via any operation) + persistence.getMetaValue("test"); + // Second call should be a no-op + assertDoesNotThrow(() -> persistence.getMetaValue("test2")); + } + + // ─── Helpers ──────────────────────────────────────────────── + + private static EncryptedSecret createSecret(String tenant, String key, String value, String iv, String dekId) { + var secret = new EncryptedSecret(); + secret.setTenantId(tenant); + secret.setKeyName(key); + secret.setEncryptedValue(value); + secret.setIv(iv); + secret.setDekId(dekId); + secret.setChecksum("sha256_check"); + secret.setDescription("Test secret"); + secret.setAllowedAgents(List.of("*")); + secret.setCreatedAt(Instant.now()); + return secret; + } +} diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresTestBase.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresTestBase.java new file mode 100644 index 000000000..7aa3c7aaa --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresTestBase.java @@ -0,0 +1,127 @@ +package ai.labs.eddi.datastore.postgres; + +import org.testcontainers.containers.PostgreSQLContainer; + +import javax.sql.DataSource; +import jakarta.enterprise.inject.Instance; +import java.io.PrintWriter; +import java.sql.Connection; +import java.sql.SQLException; +import java.sql.SQLFeatureNotSupportedException; +import java.util.logging.Logger; + +/** + * Shared Testcontainers base for PostgreSQL adapter integration tests. + *

+ * Starts a single PostgreSQL container per JVM (static lifecycle) and provides + * a real {@link DataSource} and a mock {@link Instance} that + * delegates to it. No Quarkus CDI augmentation needed — the adapters only + * require a DataSource. + *

+ * Named *IT.java so Maven Failsafe picks it up (when skipITs=false). However, + * it is abstract and has no tests itself, so it is never executed. + * + * @since 6.0.0 + */ +public abstract class PostgresTestBase { + + @SuppressWarnings("resource") + private static final PostgreSQLContainer PG = new PostgreSQLContainer<>("postgres:16-alpine") + .withDatabaseName("eddi_test") + .withUsername("test") + .withPassword("test"); + + static { + PG.start(); + } + + /** + * Returns a real JDBC DataSource pointing at the shared Testcontainer. + */ + protected static DataSource createDataSource() { + var ds = new org.postgresql.ds.PGSimpleDataSource(); + ds.setUrl(PG.getJdbcUrl()); + ds.setUser(PG.getUsername()); + ds.setPassword(PG.getPassword()); + return ds; + } + + /** + * Creates a minimal {@link Instance} wrapper that returns our test + * DataSource. Only {@code get()} is implemented — all other Instance methods + * throw UnsupportedOperationException. + */ + protected static Instance createDataSourceInstance() { + DataSource ds = createDataSource(); + return new SimpleDataSourceInstance(ds); + } + + /** + * Truncates the given tables to ensure test isolation between methods. + */ + protected static void truncateTables(DataSource ds, String... tableNames) throws SQLException { + try (Connection conn = ds.getConnection(); var stmt = conn.createStatement()) { + for (String table : tableNames) { + stmt.execute("TRUNCATE TABLE " + table + " CASCADE"); + } + } + } + + /** + * Minimal Instance implementation that only supports get(). + */ + @SuppressWarnings("unchecked") + private static class SimpleDataSourceInstance implements Instance { + private final DataSource ds; + + SimpleDataSourceInstance(DataSource ds) { + this.ds = ds; + } + + @Override + public DataSource get() { + return ds; + } + + @Override + public Instance select(java.lang.annotation.Annotation... qualifiers) { + throw new UnsupportedOperationException(); + } + @Override + public Instance select(Class subtype, java.lang.annotation.Annotation... qualifiers) { + throw new UnsupportedOperationException(); + } + @Override + public Instance select(jakarta.enterprise.util.TypeLiteral subtype, + java.lang.annotation.Annotation... qualifiers) { + throw new UnsupportedOperationException(); + } + @Override + public boolean isUnsatisfied() { + return false; + } + @Override + public boolean isAmbiguous() { + return false; + } + @Override + public boolean isResolvable() { + return true; + } + @Override + public void destroy(DataSource instance) { + } + @Override + public Handle getHandle() { + throw new UnsupportedOperationException(); + } + @Override + public Iterable> handles() { + throw new UnsupportedOperationException(); + } + @Override + public java.util.Iterator iterator() { + return java.util.List.of(ds).iterator(); + } + } +} From f7431d199e2045a2f7a98f80a91e352dc414bcdd Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 21:04:14 +0200 Subject: [PATCH 039/124] test(postgres): add PostgresAuditStoreIT + PostgresResourceStorageIT (28 tests) --- .../postgres/PostgresAuditStoreIT.java | 244 +++++++++++++++++ .../postgres/PostgresResourceStorageIT.java | 246 ++++++++++++++++++ 2 files changed, 490 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/datastore/postgres/PostgresAuditStoreIT.java create mode 100644 src/test/java/ai/labs/eddi/datastore/postgres/PostgresResourceStorageIT.java diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresAuditStoreIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresAuditStoreIT.java new file mode 100644 index 000000000..24cbbfe72 --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresAuditStoreIT.java @@ -0,0 +1,244 @@ +package ai.labs.eddi.datastore.postgres; + +import ai.labs.eddi.datastore.serialization.IJsonSerialization; +import ai.labs.eddi.datastore.serialization.JsonSerialization; +import ai.labs.eddi.engine.audit.model.AuditEntry; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.*; + +import javax.sql.DataSource; +import java.sql.SQLException; +import java.time.Instant; +import java.time.temporal.ChronoUnit; +import java.util.List; +import java.util.Map; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link PostgresAuditStore} using Testcontainers. + * + * @since 6.0.0 + */ +@DisplayName("PostgresAuditStore IT") +class PostgresAuditStoreIT extends PostgresTestBase { + + private static PostgresAuditStore store; + private static DataSource ds; + + @BeforeAll + static void init() { + var dsInstance = createDataSourceInstance(); + ds = dsInstance.get(); + IJsonSerialization json = new JsonSerialization(new ObjectMapper()); + store = new PostgresAuditStore(dsInstance, json); + } + + @BeforeEach + void clean() { + try { + truncateTables(ds, "audit_ledger"); + } catch (SQLException ignored) { + } + } + + // ─── Core CRUD ────────────────────────────────────────────── + + @Nested + @DisplayName("appendEntry + query") + class AppendAndQuery { + + @Test + @DisplayName("single entry round-trip") + void singleEntry() { + AuditEntry entry = createEntry("conv1", "agent1", 1, "user1", "parser", "input", 0, 0, 42L); + store.appendEntry(entry); + + List results = store.getEntries("conv1", 0, 10); + assertEquals(1, results.size()); + assertEquals("conv1", results.getFirst().conversationId()); + assertEquals("agent1", results.getFirst().agentId()); + assertEquals(42L, results.getFirst().durationMs()); + } + + @Test + @DisplayName("multiple entries — ordered by created_at DESC") + void multipleEntries() { + store.appendEntry(createEntry("conv1", "agent1", 1, "user1", "parser", "input", 0, 0, 10L)); + store.appendEntry(createEntry("conv1", "agent1", 1, "user1", "behavior", "rules", 0, 1, 20L)); + store.appendEntry(createEntry("conv1", "agent1", 1, "user1", "llm", "langchain", 0, 2, 30L)); + + List results = store.getEntries("conv1", 0, 10); + assertEquals(3, results.size()); + // DESC order → latest first + assertTrue(results.getFirst().durationMs() >= results.getLast().durationMs() + || results.getFirst().taskId().equals("llm")); + } + + @Test + @DisplayName("getEntries with skip and limit") + void skipAndLimit() { + for (int i = 0; i < 5; i++) { + store.appendEntry(createEntry("conv2", "a", 1, "u", "task" + i, "t", 0, i, i)); + } + + List page1 = store.getEntries("conv2", 0, 2); + assertEquals(2, page1.size()); + + List page2 = store.getEntries("conv2", 2, 2); + assertEquals(2, page2.size()); + } + + @Test + @DisplayName("empty conversation — returns empty list") + void emptyConversation() { + List results = store.getEntries("nonexistent", 0, 10); + assertTrue(results.isEmpty()); + } + } + + // ─── Batch insert ─────────────────────────────────────────── + + @Nested + @DisplayName("appendBatch") + class BatchInsert { + + @Test + @DisplayName("batch insert multiple entries") + void batchInsert() { + var entries = List.of( + createEntry("conv3", "a", 1, "u", "t1", "t", 0, 0, 10), + createEntry("conv3", "a", 1, "u", "t2", "t", 0, 1, 20)); + store.appendBatch(entries); + + assertEquals(2, store.countByConversation("conv3")); + } + + @Test + @DisplayName("null batch — no-op") + void nullBatch() { + assertDoesNotThrow(() -> store.appendBatch(null)); + } + + @Test + @DisplayName("empty batch — no-op") + void emptyBatch() { + assertDoesNotThrow(() -> store.appendBatch(List.of())); + } + } + + // ─── Query by agent/user ──────────────────────────────────── + + @Nested + @DisplayName("Query by agent and user") + class QueryFilters { + + @Test + @DisplayName("getEntriesByAgent — filters by agentId") + void byAgent() { + store.appendEntry(createEntry("c1", "agentA", 1, "u", "t", "t", 0, 0, 10)); + store.appendEntry(createEntry("c2", "agentB", 1, "u", "t", "t", 0, 0, 10)); + + List results = store.getEntriesByAgent("agentA", null, 0, 10); + assertEquals(1, results.size()); + assertEquals("agentA", results.getFirst().agentId()); + } + + @Test + @DisplayName("getEntriesByAgent — filters by agentId + version") + void byAgentAndVersion() { + store.appendEntry(createEntry("c1", "agentA", 1, "u", "t", "t", 0, 0, 10)); + store.appendEntry(createEntry("c2", "agentA", 2, "u", "t", "t", 0, 0, 10)); + + List results = store.getEntriesByAgent("agentA", 2, 0, 10); + assertEquals(1, results.size()); + assertEquals(2, results.getFirst().agentVersion()); + } + + @Test + @DisplayName("getEntriesByUserId — filters by userId") + void byUser() { + store.appendEntry(createEntry("c1", "a", 1, "user1", "t", "t", 0, 0, 10)); + store.appendEntry(createEntry("c2", "a", 1, "user2", "t", "t", 0, 0, 10)); + + List results = store.getEntriesByUserId("user1", 0, 10); + assertEquals(1, results.size()); + } + + @Test + @DisplayName("countByConversation — returns correct count") + void count() { + store.appendEntry(createEntry("conv_count", "a", 1, "u", "t1", "t", 0, 0, 10)); + store.appendEntry(createEntry("conv_count", "a", 1, "u", "t2", "t", 0, 1, 20)); + store.appendEntry(createEntry("other", "a", 1, "u", "t3", "t", 0, 0, 30)); + + assertEquals(2, store.countByConversation("conv_count")); + assertEquals(1, store.countByConversation("other")); + assertEquals(0, store.countByConversation("nonexistent")); + } + } + + // ─── GDPR ─────────────────────────────────────────────────── + + @Nested + @DisplayName("GDPR Pseudonymization") + class Gdpr { + + @Test + @DisplayName("pseudonymize replaces userId") + void pseudonymize() { + store.appendEntry(createEntry("c1", "a", 1, "real_user", "t", "t", 0, 0, 10)); + store.appendEntry(createEntry("c2", "a", 1, "real_user", "t", "t", 0, 0, 10)); + store.appendEntry(createEntry("c3", "a", 1, "other_user", "t", "t", 0, 0, 10)); + + long updated = store.pseudonymizeByUserId("real_user", "anon_123"); + assertEquals(2, updated); + + // Verify pseudonymization + List results = store.getEntriesByUserId("anon_123", 0, 10); + assertEquals(2, results.size()); + assertTrue(store.getEntriesByUserId("real_user", 0, 10).isEmpty()); + } + + @Test + @DisplayName("pseudonymize non-existent user — returns 0") + void pseudonymizeNonExistent() { + assertEquals(0, store.pseudonymizeByUserId("ghost", "anon")); + } + } + + // ─── JSONB data round-trip ────────────────────────────────── + + @Test + @DisplayName("JSONB data — input/output/actions round-trip") + void jsonbDataRoundTrip() { + var entry = new AuditEntry(UUID.randomUUID().toString(), "conv_json", "agent1", 1, + "user1", "test", 0, "llm_task", "langchain", 0, 100L, + Map.of("userInput", "hello"), Map.of("output", List.of("world")), + Map.of("compiledPrompt", "You are...", "modelName", "gpt-4"), + null, List.of("greet", "respond"), 0.05, + Instant.now().truncatedTo(ChronoUnit.MILLIS), "hmac_val", null); + + store.appendEntry(entry); + + var results = store.getEntries("conv_json", 0, 10); + assertEquals(1, results.size()); + var found = results.getFirst(); + assertEquals("hello", found.input().get("userInput")); + assertNotNull(found.output()); + assertEquals(List.of("greet", "respond"), found.actions()); + assertEquals("hmac_val", found.hmac()); + } + + // ─── Helpers ──────────────────────────────────────────────── + + private static AuditEntry createEntry(String convId, String agentId, int version, + String userId, String taskId, String taskType, + int stepIdx, int taskIdx, long durationMs) { + return new AuditEntry(UUID.randomUUID().toString(), convId, agentId, version, + userId, "test", stepIdx, taskId, taskType, taskIdx, durationMs, + null, null, null, null, null, 0.0, + Instant.now(), null, null); + } +} diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresResourceStorageIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresResourceStorageIT.java new file mode 100644 index 000000000..4f34894ba --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresResourceStorageIT.java @@ -0,0 +1,246 @@ +package ai.labs.eddi.datastore.postgres; + +import ai.labs.eddi.datastore.IResourceStorage; +import ai.labs.eddi.datastore.IResourceStore; +import ai.labs.eddi.datastore.serialization.JsonSerialization; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.*; + +import javax.sql.DataSource; +import java.io.IOException; +import java.sql.SQLException; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link PostgresResourceStorage} using Testcontainers. + * + * @since 6.0.0 + */ +@DisplayName("PostgresResourceStorage IT") +class PostgresResourceStorageIT extends PostgresTestBase { + + private static DataSource ds; + private PostgresResourceStorage> storage; + private static final String COLLECTION = "test_resources"; + + @BeforeAll + static void initDs() { + ds = createDataSource(); + } + + @BeforeEach + void initStorage() throws SQLException { + var json = new JsonSerialization(new ObjectMapper()); + @SuppressWarnings("unchecked") + Class> type = (Class>) (Class) Map.class; + storage = new PostgresResourceStorage<>(ds, COLLECTION, json, type); + // Clean up from previous tests + try { + truncateTables(ds, "resources", "resources_history"); + } catch (SQLException ignored) { + } + } + + // ─── Core CRUD ────────────────────────────────────────────── + + @Nested + @DisplayName("Store and Read") + class StoreAndRead { + + @Test + @DisplayName("newResource + store + read round-trip") + void storeAndRead() throws IOException { + Map content = Map.of("name", "test-agent", "version", 1); + var resource = storage.newResource(content); + assertNotNull(resource.getId()); + + storage.store(resource); + + var found = storage.read(resource.getId(), resource.getVersion()); + assertNotNull(found); + assertEquals(resource.getId(), found.getId()); + assertEquals(1, found.getVersion()); + + Map data = found.getData(); + assertEquals("test-agent", data.get("name")); + } + + @Test + @DisplayName("newResource with explicit id and version") + void storeWithExplicitId() throws IOException { + var id = java.util.UUID.randomUUID().toString(); + var resource = storage.newResource(id, 3, Map.of("key", "value")); + storage.store(resource); + + var found = storage.read(id, 3); + assertNotNull(found); + assertEquals(id, found.getId()); + assertEquals(3, found.getVersion()); + } + + @Test + @DisplayName("read non-existent — returns null") + void readNonExistent() { + var id = java.util.UUID.randomUUID().toString(); + assertNull(storage.read(id, 1)); + } + + @Test + @DisplayName("store upserts — updates existing resource") + void upsertUpdates() throws IOException { + var resource = storage.newResource(Map.of("status", "draft")); + storage.store(resource); + + // Update + var updated = storage.newResource(resource.getId(), resource.getVersion(), Map.of("status", "published")); + storage.store(updated); + + var found = storage.read(resource.getId(), resource.getVersion()); + Map data = found.getData(); + assertEquals("published", data.get("status")); + } + } + + // ─── createNew ────────────────────────────────────────────── + + @Nested + @DisplayName("createNew") + class CreateNew { + + @Test + @DisplayName("creates new resource") + void createsNew() throws IOException { + var resource = storage.newResource(Map.of("hello", "world")); + storage.createNew(resource); + + var found = storage.read(resource.getId(), 1); + assertNotNull(found); + } + + @Test + @DisplayName("duplicate createNew — throws") + void duplicateThrows() throws IOException { + var resource = storage.newResource(Map.of("hello", "world")); + storage.createNew(resource); + + assertThrows(RuntimeException.class, () -> storage.createNew(resource)); + } + } + + // ─── Remove ───────────────────────────────────────────────── + + @Nested + @DisplayName("Remove") + class Remove { + + @Test + @DisplayName("remove existing resource") + void removeExisting() throws IOException { + var resource = storage.newResource(Map.of("temp", true)); + storage.store(resource); + + storage.remove(resource.getId()); + assertNull(storage.read(resource.getId(), 1)); + } + + @Test + @DisplayName("removeAllPermanently — removes from both tables") + void removeAllPermanently() throws IOException { + var resource = storage.newResource(Map.of("temp", true)); + storage.store(resource); + + // Also create a history entry + var history = storage.newHistoryResourceFor(resource, false); + storage.store(history); + + storage.removeAllPermanently(resource.getId()); + + assertNull(storage.read(resource.getId(), 1)); + assertNull(storage.readHistory(resource.getId(), 1)); + } + } + + // ─── History ──────────────────────────────────────────────── + + @Nested + @DisplayName("History") + class History { + + @Test + @DisplayName("history round-trip") + void historyRoundTrip() throws IOException { + var resource = storage.newResource(Map.of("v", 1)); + storage.store(resource); + + var history = storage.newHistoryResourceFor(resource, false); + storage.store(history); + + var found = storage.readHistory(resource.getId(), 1); + assertNotNull(found); + assertFalse(found.isDeleted()); + } + + @Test + @DisplayName("readHistoryLatest returns highest version") + void readHistoryLatest() throws IOException { + var id = java.util.UUID.randomUUID().toString(); + + var v1 = storage.newResource(id, 1, Map.of("v", 1)); + var h1 = storage.newHistoryResourceFor(v1, false); + storage.store(h1); + + var v2 = storage.newResource(id, 2, Map.of("v", 2)); + var h2 = storage.newHistoryResourceFor(v2, false); + storage.store(h2); + + var latest = storage.readHistoryLatest(id); + assertNotNull(latest); + assertEquals(2, latest.getVersion()); + } + + @Test + @DisplayName("deleted history flag preserved") + void deletedFlag() throws IOException { + var resource = storage.newResource(Map.of("d", true)); + storage.store(resource); + + var history = storage.newHistoryResourceFor(resource, true); + storage.store(history); + + var found = storage.readHistory(resource.getId(), 1); + assertTrue(found.isDeleted()); + } + } + + // ─── Version ──────────────────────────────────────────────── + + @Nested + @DisplayName("getCurrentVersion") + class GetCurrentVersion { + + @Test + @DisplayName("returns version for existing resource") + void existingResource() throws IOException { + var resource = storage.newResource(Map.of("v", 1)); + storage.store(resource); + + assertEquals(1, storage.getCurrentVersion(resource.getId())); + } + + @Test + @DisplayName("returns -1 for non-existent resource") + void nonExistent() { + assertEquals(-1, storage.getCurrentVersion(java.util.UUID.randomUUID().toString())); + } + + @Test + @DisplayName("returns -1 for invalid UUID (MongoDB ObjectId format)") + void invalidUuid() { + // MongoDB ObjectId format should be treated as not found + assertEquals(-1, storage.getCurrentVersion("507f1f77bcf86cd799439011")); + } + } +} From 430c49548bd5c0ce1c425b16bd3f2074b09569dd Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 21:15:20 +0200 Subject: [PATCH 040/124] test(postgres,memory): add PostgresUserMemoryStoreIT (18 tests) + ConversationLogGeneratorTest (14 tests) --- .../postgres/PostgresUserMemoryStoreIT.java | 295 +++++++++++++++++ .../memory/ConversationLogGeneratorTest.java | 308 ++++++++++++++---- 2 files changed, 540 insertions(+), 63 deletions(-) create mode 100644 src/test/java/ai/labs/eddi/datastore/postgres/PostgresUserMemoryStoreIT.java diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresUserMemoryStoreIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresUserMemoryStoreIT.java new file mode 100644 index 000000000..afddfa7f2 --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresUserMemoryStoreIT.java @@ -0,0 +1,295 @@ +package ai.labs.eddi.datastore.postgres; + +import ai.labs.eddi.configs.properties.model.Properties; +import ai.labs.eddi.configs.properties.model.Property.Visibility; +import ai.labs.eddi.configs.properties.model.UserMemoryEntry; +import ai.labs.eddi.datastore.IResourceStore; +import org.junit.jupiter.api.*; + +import javax.sql.DataSource; +import java.sql.SQLException; +import java.time.Instant; +import java.util.List; +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link PostgresUserMemoryStore} using Testcontainers. + * + * @since 6.0.0 + */ +@DisplayName("PostgresUserMemoryStore IT") +class PostgresUserMemoryStoreIT extends PostgresTestBase { + + private static PostgresUserMemoryStore store; + private static DataSource ds; + + @BeforeAll + static void init() { + var dsInstance = createDataSourceInstance(); + ds = dsInstance.get(); + store = new PostgresUserMemoryStore(dsInstance); + } + + @BeforeEach + void clean() { + try { + truncateTables(ds, "usermemories"); + } catch (SQLException ignored) { + } + } + + // ─── Flat property view ───────────────────────────────────── + + @Nested + @DisplayName("Flat Properties") + class FlatProperties { + + @Test + @DisplayName("readProperties — returns null when no properties") + void readEmpty() throws IResourceStore.ResourceStoreException { + assertNull(store.readProperties("user1")); + } + + @Test + @DisplayName("mergeProperties + readProperties round-trip") + void mergeAndRead() throws IResourceStore.ResourceStoreException { + Properties props = new Properties(); + props.put("lang", "en"); + props.put("tier", "premium"); + + store.mergeProperties("user1", props); + + Properties result = store.readProperties("user1"); + assertNotNull(result); + assertEquals("en", result.get("lang")); + assertEquals("premium", result.get("tier")); + } + + @Test + @DisplayName("mergeProperties upserts existing values") + void upserts() throws IResourceStore.ResourceStoreException { + Properties v1 = new Properties(); + v1.put("lang", "en"); + store.mergeProperties("user1", v1); + + Properties v2 = new Properties(); + v2.put("lang", "de"); + store.mergeProperties("user1", v2); + + Properties result = store.readProperties("user1"); + assertEquals("de", result.get("lang")); + } + + @Test + @DisplayName("mergeProperties skips _id and userId keys") + void skipsReservedKeys() throws IResourceStore.ResourceStoreException { + Properties props = new Properties(); + props.put("_id", "ignore"); + props.put("userId", "ignore"); + props.put("real_key", "value"); + store.mergeProperties("user1", props); + + Properties result = store.readProperties("user1"); + assertNotNull(result); + assertFalse(result.containsKey("_id")); + assertFalse(result.containsKey("userId")); + assertEquals("value", result.get("real_key")); + } + + @Test + @DisplayName("deleteProperties removes all global entries") + void deleteProperties() throws IResourceStore.ResourceStoreException { + Properties props = new Properties(); + props.put("key1", "val1"); + store.mergeProperties("user1", props); + + store.deleteProperties("user1"); + assertNull(store.readProperties("user1")); + } + + @Test + @DisplayName("mergeProperties with null — no-op") + void mergeNull() throws IResourceStore.ResourceStoreException { + assertDoesNotThrow(() -> store.mergeProperties("user1", null)); + } + + @Test + @DisplayName("mergeProperties with empty — no-op") + void mergeEmpty() throws IResourceStore.ResourceStoreException { + assertDoesNotThrow(() -> store.mergeProperties("user1", new Properties())); + } + } + + // ─── Structured Entries ───────────────────────────────────── + + @Nested + @DisplayName("Structured Entries") + class StructuredEntries { + + @Test + @DisplayName("upsert + getByKey round-trip (self visibility)") + void upsertAndGetByKey() throws IResourceStore.ResourceStoreException { + var entry = createEntry("user1", "fav_color", "blue", "preference", + Visibility.self, "agent1"); + String id = store.upsert(entry); + assertNotNull(id); + + Optional found = store.getByKey("user1", "fav_color"); + assertTrue(found.isPresent()); + assertEquals("blue", found.get().value()); + assertEquals("preference", found.get().category()); + assertEquals(Visibility.self, found.get().visibility()); + } + + @Test + @DisplayName("upsert global — updates on second call") + void upsertGlobalUpdates() throws IResourceStore.ResourceStoreException { + var e1 = createEntry("user1", "city", "Vienna", "fact", Visibility.global, "agent1"); + store.upsert(e1); + + var e2 = createEntry("user1", "city", "Berlin", "fact", Visibility.global, "agent2"); + store.upsert(e2); + + Optional found = store.getByKey("user1", "city"); + assertTrue(found.isPresent()); + assertEquals("Berlin", found.get().value()); + } + + @Test + @DisplayName("deleteEntry — removes by ID") + void deleteEntry() throws IResourceStore.ResourceStoreException { + String id = store.upsert(createEntry("user1", "temp", "val", "fact", + Visibility.self, "agent1")); + + store.deleteEntry(id); + assertTrue(store.getByKey("user1", "temp").isEmpty()); + } + + @Test + @DisplayName("getAllEntries — returns all for user") + void getAllEntries() throws IResourceStore.ResourceStoreException { + store.upsert(createEntry("user1", "k1", "v1", "fact", Visibility.self, "a")); + store.upsert(createEntry("user1", "k2", "v2", "fact", Visibility.global, "a")); + store.upsert(createEntry("user2", "k3", "v3", "fact", Visibility.self, "a")); + + List user1 = store.getAllEntries("user1"); + assertEquals(2, user1.size()); + } + } + + // ─── Visibility Queries ───────────────────────────────────── + + @Nested + @DisplayName("Visibility and Scoping") + class VisibilityTests { + + @Test + @DisplayName("getVisibleEntries — self + global visible, other agent's self NOT visible") + void selfAndGlobalVisible() throws IResourceStore.ResourceStoreException { + store.upsert(createEntry("user1", "self_key", "v1", "fact", Visibility.self, "agentA")); + store.upsert(createEntry("user1", "global_key", "v2", "fact", Visibility.global, "agentA")); + store.upsert(createEntry("user1", "other_self", "v3", "fact", Visibility.self, "agentB")); + + List visible = store.getVisibleEntries("user1", "agentA", + null, "most_recent", 50); + + // Should see self_key (own agent) + global_key, NOT other_self + assertTrue(visible.stream().anyMatch(e -> "self_key".equals(e.key()))); + assertTrue(visible.stream().anyMatch(e -> "global_key".equals(e.key()))); + assertFalse(visible.stream().anyMatch(e -> "other_self".equals(e.key()))); + } + + @Test + @DisplayName("getVisibleEntries respects maxEntries limit") + void maxEntries() throws IResourceStore.ResourceStoreException { + for (int i = 0; i < 10; i++) { + store.upsert(createEntry("user1", "key_" + i, "v" + i, "fact", + Visibility.global, "agent1")); + } + + List limited = store.getVisibleEntries("user1", "agent1", + null, "most_recent", 3); + assertEquals(3, limited.size()); + } + } + + // ─── Filter and Category ──────────────────────────────────── + + @Nested + @DisplayName("Filter and Category Queries") + class FilterTests { + + @Test + @DisplayName("filterEntries — matches key and value") + void filterMatches() throws IResourceStore.ResourceStoreException { + store.upsert(createEntry("user1", "favorite_food", "pizza", "preference", + Visibility.self, "a")); + store.upsert(createEntry("user1", "hobby", "chess", "fact", + Visibility.self, "a")); + + List results = store.filterEntries("user1", "pizza"); + assertEquals(1, results.size()); + assertEquals("favorite_food", results.getFirst().key()); + } + + @Test + @DisplayName("filterEntries with null query — returns all") + void filterNullQuery() throws IResourceStore.ResourceStoreException { + store.upsert(createEntry("user1", "k1", "v1", "fact", Visibility.self, "a")); + store.upsert(createEntry("user1", "k2", "v2", "fact", Visibility.self, "a")); + + List results = store.filterEntries("user1", null); + assertEquals(2, results.size()); + } + + @Test + @DisplayName("getEntriesByCategory — filters correctly") + void byCategory() throws IResourceStore.ResourceStoreException { + store.upsert(createEntry("user1", "k1", "v1", "preference", Visibility.self, "a")); + store.upsert(createEntry("user1", "k2", "v2", "fact", Visibility.self, "a")); + store.upsert(createEntry("user1", "k3", "v3", "preference", Visibility.self, "a")); + + List prefs = store.getEntriesByCategory("user1", "preference"); + assertEquals(2, prefs.size()); + } + } + + // ─── GDPR ─────────────────────────────────────────────────── + + @Nested + @DisplayName("GDPR Operations") + class GdprOps { + + @Test + @DisplayName("deleteAllForUser — removes everything") + void deleteAllForUser() throws IResourceStore.ResourceStoreException { + store.upsert(createEntry("user1", "k1", "v1", "fact", Visibility.self, "a")); + store.upsert(createEntry("user1", "k2", "v2", "fact", Visibility.global, "a")); + + store.deleteAllForUser("user1"); + assertEquals(0, store.countEntries("user1")); + } + + @Test + @DisplayName("countEntries — returns correct count") + void countEntries() throws IResourceStore.ResourceStoreException { + store.upsert(createEntry("user1", "k1", "v1", "fact", Visibility.self, "a")); + store.upsert(createEntry("user1", "k2", "v2", "fact", Visibility.self, "a")); + + assertEquals(2, store.countEntries("user1")); + assertEquals(0, store.countEntries("nonexistent")); + } + } + + // ─── Helpers ──────────────────────────────────────────────── + + private static UserMemoryEntry createEntry(String userId, String key, Object value, + String category, Visibility visibility, + String agentId) { + return new UserMemoryEntry(null, userId, key, value, category, visibility, + agentId, List.of(), "conv1", false, 0, + Instant.now(), Instant.now()); + } +} diff --git a/src/test/java/ai/labs/eddi/engine/memory/ConversationLogGeneratorTest.java b/src/test/java/ai/labs/eddi/engine/memory/ConversationLogGeneratorTest.java index 22231ba58..5231f6b36 100644 --- a/src/test/java/ai/labs/eddi/engine/memory/ConversationLogGeneratorTest.java +++ b/src/test/java/ai/labs/eddi/engine/memory/ConversationLogGeneratorTest.java @@ -2,99 +2,281 @@ import ai.labs.eddi.engine.memory.model.ConversationLog; import ai.labs.eddi.engine.memory.model.ConversationOutput; -import ai.labs.eddi.engine.memory.model.Data; +import ai.labs.eddi.modules.output.model.types.TextOutputItem; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; +import java.util.ArrayList; import java.util.List; import java.util.Map; import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; +/** + * Tests for {@link ConversationLogGenerator}. + */ +@DisplayName("ConversationLogGenerator") class ConversationLogGeneratorTest { - @Test - void generate_emptyConversation_returnsEmptyLog() { - var memory = new ConversationMemory("agent-1", 1, "user-1"); - var generator = new ConversationLogGenerator(memory); + // ─── Construction ─────────────────────────────────────────── - ConversationLog log = generator.generate(); - assertNotNull(log); - assertTrue(log.getMessages().isEmpty()); + @Nested + @DisplayName("Error handling") + class ErrorHandling { + + @Test + @DisplayName("null memory and snapshot — throws IllegalStateException") + void nullEverything() { + var generator = new ConversationLogGenerator((IConversationMemory) null); + assertThrows(IllegalStateException.class, generator::generate); + } } - @Test - void generate_withUserInput_containsUserMessage() { - var memory = new ConversationMemory("agent-1", 1, "user-1"); - memory.getCurrentStep().addConversationOutputString("input", "Hello"); + // ─── Basic generation ─────────────────────────────────────── - var generator = new ConversationLogGenerator(memory); - ConversationLog log = generator.generate(); + @Nested + @DisplayName("Basic log generation") + class BasicGeneration { - assertFalse(log.getMessages().isEmpty()); - assertEquals("user", log.getMessages().getFirst().getRole()); - } + @Test + @DisplayName("logSize 0 — returns empty log") + void logSizeZero() { + var memory = mock(IConversationMemory.class); + var generator = new ConversationLogGenerator(memory); + + ConversationLog log = generator.generate(0); + assertNotNull(log); + assertTrue(log.getMessages().isEmpty()); + } + + @Test + @DisplayName("empty conversation outputs — returns empty log") + void emptyOutputs() { + var memory = mock(IConversationMemory.class); + when(memory.getConversationOutputs()).thenReturn(new ArrayList<>()); + + var generator = new ConversationLogGenerator(memory); + ConversationLog log = generator.generate(); + + assertNotNull(log); + assertTrue(log.getMessages().isEmpty()); + } + + @Test + @DisplayName("single user input — generates user message") + void singleUserInput() { + var memory = mock(IConversationMemory.class); + var outputs = new ArrayList(); + var output = new ConversationOutput(); + output.put("input", "Hello"); + outputs.add(output); + when(memory.getConversationOutputs()).thenReturn(outputs); + + var generator = new ConversationLogGenerator(memory); + ConversationLog log = generator.generate(); - @Test - void generate_withOutput_containsAssistantMessage() { - var memory = new ConversationMemory("agent-1", 1, "user-1"); - memory.getCurrentStep().addConversationOutputString("input", "Hi"); - memory.getCurrentStep().addConversationOutputObject("output", - List.of(Map.of("text", "Hello there!"))); + assertFalse(log.getMessages().isEmpty()); + assertEquals("user", log.getMessages().getFirst().getRole()); + } - var generator = new ConversationLogGenerator(memory); - ConversationLog log = generator.generate(); + @Test + @DisplayName("user input + Map output — generates user + assistant messages") + void inputAndMapOutput() { + var memory = mock(IConversationMemory.class); + var outputs = new ArrayList(); + var output = new ConversationOutput(); + output.put("input", "What's up?"); + output.put("output", List.of(Map.of("text", "Not much!"))); + outputs.add(output); + when(memory.getConversationOutputs()).thenReturn(outputs); - assertEquals(2, log.getMessages().size()); - assertEquals("assistant", log.getMessages().get(1).getRole()); + var generator = new ConversationLogGenerator(memory); + ConversationLog log = generator.generate(); + + assertEquals(2, log.getMessages().size()); + assertEquals("user", log.getMessages().get(0).getRole()); + assertEquals("assistant", log.getMessages().get(1).getRole()); + } + + @Test + @DisplayName("user input + TextOutputItem output — generates assistant message") + void textOutputItemOutput() { + var memory = mock(IConversationMemory.class); + var outputs = new ArrayList(); + var output = new ConversationOutput(); + output.put("input", "Hello"); + var textItem = new TextOutputItem("Hi there!"); + output.put("output", List.of(textItem)); + outputs.add(output); + when(memory.getConversationOutputs()).thenReturn(outputs); + + var generator = new ConversationLogGenerator(memory); + ConversationLog log = generator.generate(); + + assertEquals(2, log.getMessages().size()); + assertEquals("assistant", log.getMessages().get(1).getRole()); + } } - @Test - void generate_withLogSizeLimit_limitsMessages() { - var memory = new ConversationMemory("agent-1", 1, "user-1"); - memory.getCurrentStep().addConversationOutputString("input", "msg1"); - memory.startNextStep(); - memory.getCurrentStep().addConversationOutputString("input", "msg2"); - memory.startNextStep(); - memory.getCurrentStep().addConversationOutputString("input", "msg3"); + // ─── Log size windowing ───────────────────────────────────── + + @Nested + @DisplayName("Log size windowing") + class WindowTests { + + @Test + @DisplayName("logSize limits output to last N entries") + void logSizeLimits() { + var memory = mock(IConversationMemory.class); + var outputs = new ArrayList(); + for (int i = 0; i < 5; i++) { + var output = new ConversationOutput(); + output.put("input", "msg" + i); + outputs.add(output); + } + when(memory.getConversationOutputs()).thenReturn(outputs); + + var generator = new ConversationLogGenerator(memory); + ConversationLog log = generator.generate(2); + + // Only last 2 outputs → 2 user messages + assertEquals(2, log.getMessages().size()); + } - var generator = new ConversationLogGenerator(memory); - ConversationLog log = generator.generate(1); + @Test + @DisplayName("logSize -1 — includes all entries") + void logSizeMinusOne() { + var memory = mock(IConversationMemory.class); + var outputs = new ArrayList(); + for (int i = 0; i < 3; i++) { + var output = new ConversationOutput(); + output.put("input", "msg" + i); + outputs.add(output); + } + when(memory.getConversationOutputs()).thenReturn(outputs); - // Should only include last turn - assertTrue(log.getMessages().size() <= 2); + var generator = new ConversationLogGenerator(memory); + ConversationLog log = generator.generate(-1); + + assertEquals(3, log.getMessages().size()); + } + + @Test + @DisplayName("logSize > outputs — includes all") + void logSizeLarger() { + var memory = mock(IConversationMemory.class); + var outputs = new ArrayList(); + var output = new ConversationOutput(); + output.put("input", "only"); + outputs.add(output); + when(memory.getConversationOutputs()).thenReturn(outputs); + + var generator = new ConversationLogGenerator(memory); + ConversationLog log = generator.generate(100); + + assertEquals(1, log.getMessages().size()); + } } - @Test - void generate_withZeroLogSize_returnsEmpty() { - var memory = new ConversationMemory("agent-1", 1, "user-1"); - memory.getCurrentStep().addConversationOutputString("input", "Hello"); + // ─── includeFirstAgentMessage ──────────────────────────────── - var generator = new ConversationLogGenerator(memory); - ConversationLog log = generator.generate(0); + @Nested + @DisplayName("includeFirstAgentMessage") + class IncludeFirstTests { - assertTrue(log.getMessages().isEmpty()); + @Test + @DisplayName("false — removes first message") + void excludeFirst() { + var memory = mock(IConversationMemory.class); + var outputs = new ArrayList(); + var o1 = new ConversationOutput(); + o1.put("input", "first"); + outputs.add(o1); + var o2 = new ConversationOutput(); + o2.put("input", "second"); + outputs.add(o2); + when(memory.getConversationOutputs()).thenReturn(outputs); + + var generator = new ConversationLogGenerator(memory); + ConversationLog log = generator.generate(-1, false); + + assertEquals(1, log.getMessages().size()); + } } - @Test - void generate_excludeFirstAgentMessage_removesFirst() { - var memory = new ConversationMemory("agent-1", 1, "user-1"); - memory.getCurrentStep().addConversationOutputString("input", "Hello"); - memory.getCurrentStep().addConversationOutputObject("output", - List.of(Map.of("text", "Welcome!"))); + // ─── Input files (context) ────────────────────────────────── + + @Nested + @DisplayName("Input Files") + class InputFileTests { + + @Test + @DisplayName("context with inputFiles — generates content items") + void contextWithInputFiles() { + var memory = mock(IConversationMemory.class); + var outputs = new ArrayList(); + var output = new ConversationOutput(); + output.put("input", "check this image"); + output.put("context", Map.of( + "inputFiles", List.of( + Map.of("type", "image", "url", "https://example.com/img.png")))); + outputs.add(output); + when(memory.getConversationOutputs()).thenReturn(outputs); - var generator = new ConversationLogGenerator(memory); - ConversationLog logWithFirst = generator.generate(-1, true); - ConversationLog logWithoutFirst = generator.generate(-1, false); + var generator = new ConversationLogGenerator(memory); + ConversationLog log = generator.generate(); - assertTrue(logWithoutFirst.getMessages().size() < logWithFirst.getMessages().size()); + // Should have user message with 2 content items (image + text) + var userMsg = log.getMessages().getFirst(); + assertEquals("user", userMsg.getRole()); + assertEquals(2, userMsg.getContent().size()); + } } - @Test - void generate_nullMemory_throwsIllegalState() { - // ConversationLogGenerator with null memory and null snapshot - assertThrows(IllegalStateException.class, () -> { - var gen = new ConversationLogGenerator((IConversationMemory) null); - gen.generate(); - }); + // ─── Edge cases ───────────────────────────────────────────── + + @Nested + @DisplayName("Edge cases") + class EdgeCases { + + @Test + @DisplayName("output is empty list — no assistant message") + void emptyOutputList() { + var memory = mock(IConversationMemory.class); + var outputs = new ArrayList(); + var output = new ConversationOutput(); + output.put("input", "hello"); + output.put("output", List.of()); + outputs.add(output); + when(memory.getConversationOutputs()).thenReturn(outputs); + + var generator = new ConversationLogGenerator(memory); + ConversationLog log = generator.generate(); + + // Only user message, no assistant (empty output list) + assertEquals(1, log.getMessages().size()); + assertEquals("user", log.getMessages().getFirst().getRole()); + } + + @Test + @DisplayName("null input — no user message, but output is generated") + void nullInput() { + var memory = mock(IConversationMemory.class); + var outputs = new ArrayList(); + var output = new ConversationOutput(); + // No "input" key + output.put("output", List.of(Map.of("text", "Hi!"))); + outputs.add(output); + when(memory.getConversationOutputs()).thenReturn(outputs); + + var generator = new ConversationLogGenerator(memory); + ConversationLog log = generator.generate(); + + // Only assistant message, no user + assertEquals(1, log.getMessages().size()); + assertEquals("assistant", log.getMessages().getFirst().getRole()); + } } } From 6468d1e4d992019b3ea8e44dda6ccf56e3ace8c1 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 21:48:43 +0200 Subject: [PATCH 041/124] =?UTF-8?q?fix(tests):=20code=20review=20=E2=80=94?= =?UTF-8?q?=20strengthen=20assertions,=20remove=20unused=20imports,=20veri?= =?UTF-8?q?fy=20content=20values?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../eddi/datastore/postgres/PostgresAuditStoreIT.java | 8 +++++--- .../datastore/postgres/PostgresResourceStorageIT.java | 2 -- .../datastore/postgres/PostgresSecretPersistenceIT.java | 3 +-- .../labs/eddi/datastore/postgres/PostgresTestBase.java | 3 --- .../eddi/engine/memory/ConversationLogGeneratorTest.java | 9 +++++++++ 5 files changed, 15 insertions(+), 10 deletions(-) diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresAuditStoreIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresAuditStoreIT.java index 24cbbfe72..f4d927301 100644 --- a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresAuditStoreIT.java +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresAuditStoreIT.java @@ -71,9 +71,11 @@ void multipleEntries() { List results = store.getEntries("conv1", 0, 10); assertEquals(3, results.size()); - // DESC order → latest first - assertTrue(results.getFirst().durationMs() >= results.getLast().durationMs() - || results.getFirst().taskId().equals("llm")); + // All 3 entries should be present — verify by taskId + var taskIds = results.stream().map(AuditEntry::taskId).toList(); + assertTrue(taskIds.contains("parser")); + assertTrue(taskIds.contains("behavior")); + assertTrue(taskIds.contains("llm")); } @Test diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresResourceStorageIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresResourceStorageIT.java index 4f34894ba..20af5e5e3 100644 --- a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresResourceStorageIT.java +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresResourceStorageIT.java @@ -1,7 +1,5 @@ package ai.labs.eddi.datastore.postgres; -import ai.labs.eddi.datastore.IResourceStorage; -import ai.labs.eddi.datastore.IResourceStore; import ai.labs.eddi.datastore.serialization.JsonSerialization; import com.fasterxml.jackson.databind.ObjectMapper; import org.junit.jupiter.api.*; diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresSecretPersistenceIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresSecretPersistenceIT.java index fe94a7ecb..6f263659d 100644 --- a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresSecretPersistenceIT.java +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresSecretPersistenceIT.java @@ -23,7 +23,6 @@ * @since 6.0.0 */ @DisplayName("PostgresSecretPersistence IT") -@TestMethodOrder(MethodOrderer.OrderAnnotation.class) class PostgresSecretPersistenceIT extends PostgresTestBase { private static PostgresSecretPersistence persistence; @@ -217,7 +216,7 @@ void listAll() { persistence.upsertDek(new EncryptedDek(null, "t2", "d2", "iv2", Instant.now())); List all = persistence.listAllDeks(); - assertTrue(all.size() >= 2); + assertEquals(2, all.size()); } } diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresTestBase.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresTestBase.java index 7aa3c7aaa..72e71882b 100644 --- a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresTestBase.java +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresTestBase.java @@ -4,11 +4,8 @@ import javax.sql.DataSource; import jakarta.enterprise.inject.Instance; -import java.io.PrintWriter; import java.sql.Connection; import java.sql.SQLException; -import java.sql.SQLFeatureNotSupportedException; -import java.util.logging.Logger; /** * Shared Testcontainers base for PostgreSQL adapter integration tests. diff --git a/src/test/java/ai/labs/eddi/engine/memory/ConversationLogGeneratorTest.java b/src/test/java/ai/labs/eddi/engine/memory/ConversationLogGeneratorTest.java index 5231f6b36..e8ceeb37a 100644 --- a/src/test/java/ai/labs/eddi/engine/memory/ConversationLogGeneratorTest.java +++ b/src/test/java/ai/labs/eddi/engine/memory/ConversationLogGeneratorTest.java @@ -98,6 +98,10 @@ void inputAndMapOutput() { assertEquals(2, log.getMessages().size()); assertEquals("user", log.getMessages().get(0).getRole()); assertEquals("assistant", log.getMessages().get(1).getRole()); + // Verify actual content value + var assistantContent = log.getMessages().get(1).getContent(); + assertFalse(assistantContent.isEmpty()); + assertEquals("Not much!", assistantContent.getFirst().getValue()); } @Test @@ -117,6 +121,8 @@ void textOutputItemOutput() { assertEquals(2, log.getMessages().size()); assertEquals("assistant", log.getMessages().get(1).getRole()); + // Verify actual text content + assertEquals("Hi there!", log.getMessages().get(1).getContent().getFirst().getValue()); } } @@ -232,6 +238,9 @@ void contextWithInputFiles() { var userMsg = log.getMessages().getFirst(); assertEquals("user", userMsg.getRole()); assertEquals(2, userMsg.getContent().size()); + // First content item should be the image file + var imageContent = userMsg.getContent().get(0); + assertEquals("https://example.com/img.png", imageContent.getValue()); } } From af92f044223d1d842a98fcc5aafc6e0cdbeb7008 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 21:58:47 +0200 Subject: [PATCH 042/124] =?UTF-8?q?test(postgres):=20add=20PostgresSchedul?= =?UTF-8?q?eStoreIT=20=E2=80=94=2024=20tests=20covering=20full=20schedule?= =?UTF-8?q?=20lifecycle?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../postgres/PostgresScheduleStoreIT.java | 454 ++++++++++++++++++ 1 file changed, 454 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/datastore/postgres/PostgresScheduleStoreIT.java diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresScheduleStoreIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresScheduleStoreIT.java new file mode 100644 index 000000000..58edfef05 --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresScheduleStoreIT.java @@ -0,0 +1,454 @@ +package ai.labs.eddi.datastore.postgres; + +import ai.labs.eddi.datastore.IResourceStore; +import ai.labs.eddi.engine.schedule.model.ScheduleConfiguration; +import ai.labs.eddi.engine.schedule.model.ScheduleConfiguration.FireStatus; +import ai.labs.eddi.engine.schedule.model.ScheduleConfiguration.TriggerType; +import ai.labs.eddi.engine.schedule.model.ScheduleFireLog; +import org.junit.jupiter.api.*; + +import javax.sql.DataSource; +import java.sql.SQLException; +import java.time.Instant; +import java.time.temporal.ChronoUnit; +import java.util.List; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link PostgresScheduleStore} using Testcontainers. + *

+ * Covers the full schedule lifecycle: CRUD, enable/disable, claiming, + * completion/failure state transitions, dead-lettering, requeue, and fire log + * persistence. + * + * @since 6.0.0 + */ +@DisplayName("PostgresScheduleStore IT") +class PostgresScheduleStoreIT extends PostgresTestBase { + + private static PostgresScheduleStore store; + private static DataSource ds; + + @BeforeAll + static void init() { + var dsInstance = createDataSourceInstance(); + ds = dsInstance.get(); + store = new PostgresScheduleStore(dsInstance); + } + + @BeforeEach + void clean() { + try { + truncateTables(ds, "eddi_schedules", "eddi_schedule_fire_logs"); + } catch (SQLException ignored) { + } + } + + // ─── CRUD ─────────────────────────────────────────────────── + + @Nested + @DisplayName("CRUD") + class Crud { + + @Test + @DisplayName("createSchedule + readSchedule round-trip") + void createAndRead() throws Exception { + var config = createCronSchedule("Daily Digest", "agent1", "tenant1"); + String id = store.createSchedule(config); + assertNotNull(id); + + var found = store.readSchedule(id); + assertEquals(id, found.getId()); + assertEquals("Daily Digest", found.getName()); + assertEquals("agent1", found.getAgentId()); + assertEquals("tenant1", found.getTenantId()); + assertEquals(TriggerType.CRON, found.getTriggerType()); + assertEquals("0 9 * * MON-FRI", found.getCronExpression()); + assertTrue(found.isEnabled()); + assertEquals(FireStatus.PENDING, found.getFireStatus()); + } + + @Test + @DisplayName("readSchedule non-existent — throws ResourceNotFoundException") + void readNonExistent() { + assertThrows(IResourceStore.ResourceNotFoundException.class, + () -> store.readSchedule("nonexistent-id")); + } + + @Test + @DisplayName("updateSchedule — modifies fields") + void updateSchedule() throws Exception { + var config = createCronSchedule("Original", "agent1", "t"); + String id = store.createSchedule(config); + + config.setName("Updated Name"); + config.setEnabled(false); + store.updateSchedule(id, config); + + var found = store.readSchedule(id); + assertEquals("Updated Name", found.getName()); + assertFalse(found.isEnabled()); + } + + @Test + @DisplayName("updateSchedule non-existent — throws ResourceNotFoundException") + void updateNonExistent() { + var config = createCronSchedule("N/A", "a", "t"); + assertThrows(IResourceStore.ResourceNotFoundException.class, + () -> store.updateSchedule("nonexistent", config)); + } + + @Test + @DisplayName("deleteSchedule — removes schedule") + void deleteSchedule() throws Exception { + String id = store.createSchedule(createCronSchedule("Temp", "a", "t")); + store.deleteSchedule(id); + + assertThrows(IResourceStore.ResourceNotFoundException.class, + () -> store.readSchedule(id)); + } + + @Test + @DisplayName("deleteSchedulesByAgentId — cascades correctly") + void deleteByAgent() throws Exception { + store.createSchedule(createCronSchedule("S1", "agentX", "t")); + store.createSchedule(createCronSchedule("S2", "agentX", "t")); + store.createSchedule(createCronSchedule("S3", "agentY", "t")); + + int deleted = store.deleteSchedulesByAgentId("agentX"); + assertEquals(2, deleted); + + assertEquals(0, store.readSchedulesByAgentId("agentX").size()); + assertEquals(1, store.readSchedulesByAgentId("agentY").size()); + } + } + + // ─── List queries ─────────────────────────────────────────── + + @Nested + @DisplayName("List queries") + class ListQueries { + + @Test + @DisplayName("readAllSchedules — respects limit") + void readAll() throws Exception { + for (int i = 0; i < 5; i++) { + store.createSchedule(createCronSchedule("S" + i, "a" + i, "t")); + } + + assertEquals(5, store.readAllSchedules(10).size()); + assertEquals(3, store.readAllSchedules(3).size()); + } + + @Test + @DisplayName("readSchedulesByAgentId — filters by agent") + void readByAgent() throws Exception { + store.createSchedule(createCronSchedule("S1", "agentA", "t")); + store.createSchedule(createCronSchedule("S2", "agentA", "t")); + store.createSchedule(createCronSchedule("S3", "agentB", "t")); + + assertEquals(2, store.readSchedulesByAgentId("agentA").size()); + assertEquals(1, store.readSchedulesByAgentId("agentB").size()); + assertEquals(0, store.readSchedulesByAgentId("agentC").size()); + } + } + + // ─── Enable/Disable ───────────────────────────────────────── + + @Nested + @DisplayName("Enable/Disable") + class EnableDisable { + + @Test + @DisplayName("setScheduleEnabled — enables with nextFire") + void enableWithNextFire() throws Exception { + var config = createCronSchedule("S1", "a", "t"); + config.setEnabled(false); + String id = store.createSchedule(config); + + Instant nextFire = Instant.now().plus(1, ChronoUnit.HOURS); + store.setScheduleEnabled(id, true, nextFire); + + var found = store.readSchedule(id); + assertTrue(found.isEnabled()); + assertNotNull(found.getNextFire()); + assertEquals(FireStatus.PENDING, found.getFireStatus()); + } + + @Test + @DisplayName("setScheduleEnabled — disables") + void disable() throws Exception { + String id = store.createSchedule(createCronSchedule("S", "a", "t")); + store.setScheduleEnabled(id, false, null); + + assertFalse(store.readSchedule(id).isEnabled()); + } + + @Test + @DisplayName("setScheduleEnabled non-existent — throws ResourceNotFoundException") + void nonExistent() { + assertThrows(IResourceStore.ResourceNotFoundException.class, + () -> store.setScheduleEnabled("ghost", true, Instant.now())); + } + } + + // ─── Claiming + State Machine ─────────────────────────────── + + @Nested + @DisplayName("Claiming and State Transitions") + class StateMachine { + + @Test + @DisplayName("tryClaim — claims PENDING schedule") + void claimPending() throws Exception { + var config = createCronSchedule("S", "a", "t"); + config.setNextFire(Instant.now().minus(1, ChronoUnit.MINUTES)); + String id = store.createSchedule(config); + + boolean claimed = store.tryClaim(id, "node-1", Instant.now()); + assertTrue(claimed); + + var found = store.readSchedule(id); + assertEquals(FireStatus.CLAIMED, found.getFireStatus()); + assertEquals("node-1", found.getClaimedBy()); + assertNotNull(found.getClaimedAt()); + assertNotNull(found.getFireId()); + } + + @Test + @DisplayName("tryClaim — cannot double-claim") + void cannotDoubleClaim() throws Exception { + var config = createCronSchedule("S", "a", "t"); + config.setNextFire(Instant.now().minus(1, ChronoUnit.MINUTES)); + String id = store.createSchedule(config); + + assertTrue(store.tryClaim(id, "node-1", Instant.now())); + // Second claim should fail — already CLAIMED + assertFalse(store.tryClaim(id, "node-2", Instant.now())); + } + + @Test + @DisplayName("markCompleted with nextFire — resets to PENDING + reschedules") + void markCompletedWithReschedule() throws Exception { + var config = createCronSchedule("S", "a", "t"); + String id = store.createSchedule(config); + store.tryClaim(id, "node-1", Instant.now()); + + Instant nextFire = Instant.now().plus(1, ChronoUnit.DAYS); + store.markCompleted(id, nextFire); + + var found = store.readSchedule(id); + assertEquals(FireStatus.PENDING, found.getFireStatus()); + assertTrue(found.isEnabled()); + assertNull(found.getClaimedBy()); + assertNotNull(found.getLastFired()); + assertEquals(0, found.getFailCount()); + } + + @Test + @DisplayName("markCompleted without nextFire — disables schedule") + void markCompletedOneShot() throws Exception { + var config = createCronSchedule("OneShot", "a", "t"); + String id = store.createSchedule(config); + store.tryClaim(id, "node-1", Instant.now()); + + store.markCompleted(id, null); + + var found = store.readSchedule(id); + assertFalse(found.isEnabled()); + assertNull(found.getNextFire()); + } + + @Test + @DisplayName("markFailed — sets FAILED + increments failCount") + void markFailed() throws Exception { + var config = createCronSchedule("S", "a", "t"); + String id = store.createSchedule(config); + store.tryClaim(id, "node-1", Instant.now()); + + Instant retry = Instant.now().plus(5, ChronoUnit.MINUTES); + store.markFailed(id, retry); + + var found = store.readSchedule(id); + assertEquals(FireStatus.FAILED, found.getFireStatus()); + assertEquals(1, found.getFailCount()); + assertNull(found.getClaimedBy()); + } + + @Test + @DisplayName("markDeadLettered — transitions to DEAD_LETTERED") + void markDeadLettered() throws Exception { + var config = createCronSchedule("S", "a", "t"); + String id = store.createSchedule(config); + + store.markDeadLettered(id); + + assertEquals(FireStatus.DEAD_LETTERED, store.readSchedule(id).getFireStatus()); + } + + @Test + @DisplayName("requeueDeadLetter — resets DEAD_LETTERED to PENDING") + void requeueDeadLetter() throws Exception { + var config = createCronSchedule("S", "a", "t"); + String id = store.createSchedule(config); + store.markDeadLettered(id); + + store.requeueDeadLetter(id); + + var found = store.readSchedule(id); + assertEquals(FireStatus.PENDING, found.getFireStatus()); + assertEquals(0, found.getFailCount()); + } + + @Test + @DisplayName("requeueDeadLetter non-DEAD_LETTERED — throws ResourceNotFoundException") + void requeueNonDeadLettered() throws Exception { + String id = store.createSchedule(createCronSchedule("S", "a", "t")); + // Schedule is PENDING, not DEAD_LETTERED + assertThrows(IResourceStore.ResourceNotFoundException.class, + () -> store.requeueDeadLetter(id)); + } + } + + // ─── findDueSchedules ─────────────────────────────────────── + + @Nested + @DisplayName("findDueSchedules") + class FindDue { + + @Test + @DisplayName("returns only due schedules") + void returnsOnlyDue() throws Exception { + var due = createCronSchedule("Due", "a", "t"); + due.setNextFire(Instant.now().minus(1, ChronoUnit.MINUTES)); + store.createSchedule(due); + + var notDue = createCronSchedule("NotDue", "a", "t"); + notDue.setNextFire(Instant.now().plus(1, ChronoUnit.HOURS)); + store.createSchedule(notDue); + + var disabled = createCronSchedule("Disabled", "a", "t"); + disabled.setEnabled(false); + disabled.setNextFire(Instant.now().minus(1, ChronoUnit.MINUTES)); + store.createSchedule(disabled); + + List dueList = store.findDueSchedules( + Instant.now(), + Instant.now().minus(30, ChronoUnit.MINUTES), + 3); + + assertEquals(1, dueList.size()); + assertEquals("Due", dueList.getFirst().getName()); + } + } + + // ─── Fire Logs ────────────────────────────────────────────── + + @Nested + @DisplayName("Fire Logs") + class FireLogs { + + @Test + @DisplayName("logFire + readFireLogs round-trip") + void logAndRead() throws Exception { + String scheduleId = store.createSchedule(createCronSchedule("S", "a", "t")); + + var log = new ScheduleFireLog( + UUID.randomUUID().toString(), scheduleId, "fire_1", + Instant.now(), Instant.now(), Instant.now().plus(5, ChronoUnit.SECONDS), + "COMPLETED", "node-1", "conv-123", null, 1, 0.05); + store.logFire(log); + + List logs = store.readFireLogs(scheduleId, 10); + assertEquals(1, logs.size()); + assertEquals(scheduleId, logs.getFirst().scheduleId()); + assertEquals("COMPLETED", logs.getFirst().status()); + assertEquals("conv-123", logs.getFirst().conversationId()); + } + + @Test + @DisplayName("readFailedFireLogs — filters FAILED and DEAD_LETTERED") + void readFailed() throws Exception { + String scheduleId = store.createSchedule(createCronSchedule("S", "a", "t")); + + store.logFire(new ScheduleFireLog( + UUID.randomUUID().toString(), scheduleId, "fire_ok", + Instant.now(), Instant.now(), Instant.now(), + "COMPLETED", "n1", "c1", null, 1, 0.0)); + + store.logFire(new ScheduleFireLog( + UUID.randomUUID().toString(), scheduleId, "fire_err", + Instant.now(), Instant.now(), null, + "FAILED", "n1", null, "NullPointerException", 1, 0.0)); + + store.logFire(new ScheduleFireLog( + UUID.randomUUID().toString(), scheduleId, "fire_dead", + Instant.now(), Instant.now(), null, + "DEAD_LETTERED", "n1", null, "Max retries", 3, 0.0)); + + List failed = store.readFailedFireLogs(10); + assertEquals(2, failed.size()); + assertTrue(failed.stream().allMatch(f -> + "FAILED".equals(f.status()) || "DEAD_LETTERED".equals(f.status()))); + } + + @Test + @DisplayName("readFireLogs — respects limit") + void respectsLimit() throws Exception { + String scheduleId = store.createSchedule(createCronSchedule("S", "a", "t")); + for (int i = 0; i < 5; i++) { + store.logFire(new ScheduleFireLog( + UUID.randomUUID().toString(), scheduleId, "fire_" + i, + Instant.now(), Instant.now(), Instant.now(), + "COMPLETED", "n1", "c" + i, null, 1, 0.01)); + } + + assertEquals(3, store.readFireLogs(scheduleId, 3).size()); + } + } + + // ─── Heartbeat trigger type ───────────────────────────────── + + @Nested + @DisplayName("Heartbeat trigger") + class HeartbeatTrigger { + + @Test + @DisplayName("heartbeat schedule round-trip preserves interval") + void heartbeatRoundTrip() throws Exception { + var config = new ScheduleConfiguration(); + config.setName("Health Check"); + config.setAgentId("health-agent"); + config.setTenantId("ops"); + config.setTriggerType(TriggerType.HEARTBEAT); + config.setHeartbeatIntervalSeconds(300L); + config.setConversationStrategy("persistent"); + config.setEnabled(true); + config.setNextFire(Instant.now().plus(5, ChronoUnit.MINUTES)); + + String id = store.createSchedule(config); + var found = store.readSchedule(id); + + assertEquals(TriggerType.HEARTBEAT, found.getTriggerType()); + assertEquals(300L, found.getHeartbeatIntervalSeconds()); + assertEquals("persistent", found.getConversationStrategy()); + } + } + + // ─── Helpers ──────────────────────────────────────────────── + + private static ScheduleConfiguration createCronSchedule(String name, String agentId, String tenantId) { + var config = new ScheduleConfiguration(); + config.setName(name); + config.setAgentId(agentId); + config.setTenantId(tenantId); + config.setTriggerType(TriggerType.CRON); + config.setCronExpression("0 9 * * MON-FRI"); + config.setConversationStrategy("new"); + config.setEnabled(true); + config.setNextFire(Instant.now().plus(1, ChronoUnit.DAYS)); + return config; + } +} From 122f1d33fd7809222be9d0b28ecfa028c8b53d67 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 22:00:19 +0200 Subject: [PATCH 043/124] docs: update changelog with Batch 5 ScheduleStoreIT + code review fixes --- docs/changelog.md | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/docs/changelog.md b/docs/changelog.md index 7b3204117..8cea757f4 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -13,6 +13,36 @@ Each entry follows this format: - **Decision** — Key design decisions and their reasoning - **Files** — Links to modified files +## Integration Test Expansion — Batch 5 + Code Review (2026-04-20) + +**Repo:** EDDI (`test/coverage-tier-1-2`) + +**What changed:** Completed code review of Batches 3-4 integration tests, then implemented Batch 5 (PostgresScheduleStoreIT). Total: 3,645 unit tests + 459 ITs, all passing. + +### Code Review Fixes +- **Tautological assertion** — `PostgresAuditStoreIT.multipleEntries` used `assertTrue(a >= b || c)` which always passed because entries inserted in same millisecond. Replaced with taskId content verification. +- **Weak assertion** — `PostgresSecretPersistenceIT.listAll` used `assertTrue(size >= 2)` instead of exact `assertEquals(2)` (table is truncated in `@BeforeEach`). +- **Missing content verification** — `ConversationLogGeneratorTest` only verified message roles, not actual text values. Added `assertEquals("Not much!", ...)`, `assertEquals("Hi there!", ...)`, and URL verification for inputFiles. +- **Unused imports** — Removed 7 unused imports across `PostgresTestBase`, `PostgresAuditStoreIT`, `PostgresResourceStorageIT`, `PostgresSecretPersistenceIT`. +- **Unused annotation** — Removed `@TestMethodOrder(OrderAnnotation.class)` from `PostgresSecretPersistenceIT` (no `@Order` annotations present). + +### Batch 5 — PostgresScheduleStoreIT (24 tests) +- **CRUD** (6 tests): create+read round-trip, read non-existent, update, update non-existent, delete, deleteByAgentId cascade +- **List queries** (2 tests): readAll with limit, readByAgent filtering +- **Enable/Disable** (3 tests): enable with nextFire, disable, non-existent +- **State machine** (8 tests): tryClaim PENDING, double-claim prevention, markCompleted with reschedule, markCompleted one-shot (disables), markFailed + failCount increment, markDeadLettered, requeueDeadLetter, requeue non-DEAD_LETTERED throws +- **findDueSchedules** (1 test): filters by enabled + nextFire + status, ignores not-due and disabled +- **Fire logs** (3 tests): logFire+readFireLogs round-trip, readFailedFireLogs filters FAILED/DEAD_LETTERED, respects limit +- **Heartbeat** (1 test): heartbeat trigger type preserves intervalSeconds + conversationStrategy + +**Files:** +- `src/test/java/ai/labs/eddi/datastore/postgres/PostgresScheduleStoreIT.java` — new (24 tests) +- `src/test/java/ai/labs/eddi/datastore/postgres/PostgresTestBase.java` — removed 3 unused imports +- `src/test/java/ai/labs/eddi/datastore/postgres/PostgresAuditStoreIT.java` — fixed assertion +- `src/test/java/ai/labs/eddi/datastore/postgres/PostgresResourceStorageIT.java` — removed 2 unused imports +- `src/test/java/ai/labs/eddi/datastore/postgres/PostgresSecretPersistenceIT.java` — fixed assertion, removed annotation +- `src/test/java/ai/labs/eddi/engine/memory/ConversationLogGeneratorTest.java` — added content value assertions + ## Unit Test Coverage Expansion — Batches 27–28 (2026-04-20) **Repo:** EDDI (`test/coverage-tier-1-2`) From bdbc1e21a1f2358dc0606295938a78a6631493fc Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 22:04:36 +0200 Subject: [PATCH 044/124] test(postgres): add ConversationMemoryStoreIT (14), DeploymentStorageIT (6), DatabaseLogsIT (10) --- .../PostgresConversationMemoryStoreIT.java | 278 ++++++++++++++++++ .../postgres/PostgresDatabaseLogsIT.java | 181 ++++++++++++ .../postgres/PostgresDeploymentStorageIT.java | 114 +++++++ 3 files changed, 573 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/datastore/postgres/PostgresConversationMemoryStoreIT.java create mode 100644 src/test/java/ai/labs/eddi/datastore/postgres/PostgresDatabaseLogsIT.java create mode 100644 src/test/java/ai/labs/eddi/datastore/postgres/PostgresDeploymentStorageIT.java diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresConversationMemoryStoreIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresConversationMemoryStoreIT.java new file mode 100644 index 000000000..3059514ae --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresConversationMemoryStoreIT.java @@ -0,0 +1,278 @@ +package ai.labs.eddi.datastore.postgres; + +import ai.labs.eddi.datastore.IResourceStore; +import ai.labs.eddi.datastore.serialization.IJsonSerialization; +import ai.labs.eddi.datastore.serialization.JsonSerialization; +import ai.labs.eddi.engine.memory.model.ConversationMemorySnapshot; +import ai.labs.eddi.engine.memory.model.ConversationState; +import ai.labs.eddi.engine.model.Deployment; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.*; + +import javax.sql.DataSource; +import java.sql.SQLException; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link PostgresConversationMemoryStore} using Testcontainers. + *

+ * Covers snapshot CRUD, state transitions, active conversation queries, and GDPR operations. + * + * @since 6.0.0 + */ +@DisplayName("PostgresConversationMemoryStore IT") +class PostgresConversationMemoryStoreIT extends PostgresTestBase { + + private static PostgresConversationMemoryStore store; + private static DataSource ds; + + @BeforeAll + static void init() { + var dsInstance = createDataSourceInstance(); + ds = dsInstance.get(); + IJsonSerialization json = new JsonSerialization(new ObjectMapper()); + store = new PostgresConversationMemoryStore(dsInstance, json); + } + + @BeforeEach + void clean() { + try { + truncateTables(ds, "conversation_memories"); + } catch (SQLException ignored) { + } + } + + // ─── Store + Load ─────────────────────────────────────────── + + @Nested + @DisplayName("Store and Load") + class StoreAndLoad { + + @Test + @DisplayName("store new snapshot — generates ID and round-trips") + void storeNewSnapshot() { + var snapshot = createSnapshot(null, "agent1", 1, "user1", + ConversationState.IN_PROGRESS); + + String id = store.storeConversationMemorySnapshot(snapshot); + assertNotNull(id); + + var loaded = store.loadConversationMemorySnapshot(id); + assertNotNull(loaded); + assertEquals(id, loaded.getConversationId()); + assertEquals("agent1", loaded.getAgentId()); + assertEquals(1, loaded.getAgentVersion()); + assertEquals(ConversationState.IN_PROGRESS, loaded.getConversationState()); + } + + @Test + @DisplayName("update existing snapshot — preserves ID, updates state") + void updateExistingSnapshot() { + var snapshot = createSnapshot(null, "agent1", 1, "user1", + ConversationState.IN_PROGRESS); + String id = store.storeConversationMemorySnapshot(snapshot); + + // Update state + snapshot.setConversationId(id); + snapshot.setId(id); + snapshot.setConversationState(ConversationState.ENDED); + store.storeConversationMemorySnapshot(snapshot); + + var loaded = store.loadConversationMemorySnapshot(id); + assertEquals(ConversationState.ENDED, loaded.getConversationState()); + } + + @Test + @DisplayName("load non-existent — returns null") + void loadNonExistent() { + assertNull(store.loadConversationMemorySnapshot( + "00000000-0000-0000-0000-000000000000")); + } + } + + // ─── State Management ─────────────────────────────────────── + + @Nested + @DisplayName("State Management") + class StateManagement { + + @Test + @DisplayName("setConversationState — updates state") + void setConversationState() { + String id = store.storeConversationMemorySnapshot( + createSnapshot(null, "a", 1, "u", ConversationState.IN_PROGRESS)); + + store.setConversationState(id, ConversationState.ENDED); + + assertEquals(ConversationState.ENDED, store.getConversationState(id)); + } + + @Test + @DisplayName("getConversationState — returns null for non-existent") + void getStateNonExistent() { + assertNull(store.getConversationState("00000000-0000-0000-0000-000000000000")); + } + } + + // ─── Delete ───────────────────────────────────────────────── + + @Nested + @DisplayName("Delete") + class Delete { + + @Test + @DisplayName("deleteConversationMemorySnapshot — removes snapshot") + void deleteSnapshot() { + String id = store.storeConversationMemorySnapshot( + createSnapshot(null, "a", 1, "u", ConversationState.IN_PROGRESS)); + + store.deleteConversationMemorySnapshot(id); + + assertNull(store.loadConversationMemorySnapshot(id)); + } + } + + // ─── Active Conversation Queries ──────────────────────────── + + @Nested + @DisplayName("Active Conversation Queries") + class ActiveQueries { + + @Test + @DisplayName("loadActiveConversationMemorySnapshot — excludes ENDED") + void loadActive() throws IResourceStore.ResourceStoreException { + store.storeConversationMemorySnapshot( + createSnapshot(null, "agent1", 1, "u1", ConversationState.IN_PROGRESS)); + store.storeConversationMemorySnapshot( + createSnapshot(null, "agent1", 1, "u2", ConversationState.IN_PROGRESS)); + String endedId = store.storeConversationMemorySnapshot( + createSnapshot(null, "agent1", 1, "u3", ConversationState.ENDED)); + // Also set state via the dedicated method to match column + store.setConversationState(endedId, ConversationState.ENDED); + + List active = store.loadActiveConversationMemorySnapshot("agent1", 1); + assertEquals(2, active.size()); + } + + @Test + @DisplayName("getActiveConversationCount — counts non-ENDED only") + void activeCount() { + store.storeConversationMemorySnapshot( + createSnapshot(null, "agent2", 1, "u1", ConversationState.IN_PROGRESS)); + String endedId = store.storeConversationMemorySnapshot( + createSnapshot(null, "agent2", 1, "u2", ConversationState.ENDED)); + store.setConversationState(endedId, ConversationState.ENDED); + + assertEquals(1L, store.getActiveConversationCount("agent2", 1)); + } + + @Test + @DisplayName("getEndedConversationIds — returns only ENDED") + void endedIds() { + store.storeConversationMemorySnapshot( + createSnapshot(null, "a", 1, "u", ConversationState.IN_PROGRESS)); + String endedId = store.storeConversationMemorySnapshot( + createSnapshot(null, "a", 1, "u", ConversationState.ENDED)); + store.setConversationState(endedId, ConversationState.ENDED); + + List ended = store.getEndedConversationIds(); + assertEquals(1, ended.size()); + assertEquals(endedId, ended.getFirst()); + } + } + + // ─── IResourceStore Adapter ───────────────────────────────── + + @Nested + @DisplayName("IResourceStore Adapter") + class ResourceStoreAdapter { + + @Test + @DisplayName("create + read round-trip") + void createAndRead() { + var snapshot = createSnapshot(null, "a", 1, "u", ConversationState.IN_PROGRESS); + var resourceId = store.create(snapshot); + assertNotNull(resourceId.getId()); + + var loaded = store.read(resourceId.getId(), resourceId.getVersion()); + assertNotNull(loaded); + } + + @Test + @DisplayName("delete — removes via IResourceStore interface") + void deleteViaAdapter() { + String id = store.storeConversationMemorySnapshot( + createSnapshot(null, "a", 1, "u", ConversationState.IN_PROGRESS)); + store.delete(id, 0); + + assertNull(store.read(id, 0)); + } + + @Test + @DisplayName("deleteAllPermanently — removes via IResourceStore interface") + void deleteAllPermanently() { + String id = store.storeConversationMemorySnapshot( + createSnapshot(null, "a", 1, "u", ConversationState.IN_PROGRESS)); + store.deleteAllPermanently(id); + + assertNull(store.read(id, 0)); + } + } + + // ─── GDPR ─────────────────────────────────────────────────── + + @Nested + @DisplayName("GDPR Operations") + class GdprOps { + + @Test + @DisplayName("getConversationIdsByUserId — finds by userId in JSONB") + void getByUserId() { + store.storeConversationMemorySnapshot( + createSnapshot(null, "a", 1, "target_user", ConversationState.IN_PROGRESS)); + store.storeConversationMemorySnapshot( + createSnapshot(null, "a", 1, "target_user", ConversationState.ENDED)); + store.storeConversationMemorySnapshot( + createSnapshot(null, "a", 1, "other_user", ConversationState.IN_PROGRESS)); + + List ids = store.getConversationIdsByUserId("target_user"); + assertEquals(2, ids.size()); + } + + @Test + @DisplayName("deleteConversationsByUserId — removes all for user") + void deleteByUserId() { + store.storeConversationMemorySnapshot( + createSnapshot(null, "a", 1, "delete_me", ConversationState.IN_PROGRESS)); + store.storeConversationMemorySnapshot( + createSnapshot(null, "a", 1, "delete_me", ConversationState.ENDED)); + store.storeConversationMemorySnapshot( + createSnapshot(null, "a", 1, "keep_me", ConversationState.IN_PROGRESS)); + + long deleted = store.deleteConversationsByUserId("delete_me"); + assertEquals(2, deleted); + assertTrue(store.getConversationIdsByUserId("delete_me").isEmpty()); + assertEquals(1, store.getConversationIdsByUserId("keep_me").size()); + } + } + + // ─── Helpers ──────────────────────────────────────────────── + + private static ConversationMemorySnapshot createSnapshot(String id, String agentId, + int agentVersion, String userId, + ConversationState state) { + var snapshot = new ConversationMemorySnapshot(); + if (id != null) { + snapshot.setId(id); + snapshot.setConversationId(id); + } + snapshot.setAgentId(agentId); + snapshot.setAgentVersion(agentVersion); + snapshot.setUserId(userId); + snapshot.setConversationState(state); + snapshot.setEnvironment(Deployment.Environment.production); + return snapshot; + } +} diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresDatabaseLogsIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresDatabaseLogsIT.java new file mode 100644 index 000000000..04d6fb791 --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresDatabaseLogsIT.java @@ -0,0 +1,181 @@ +package ai.labs.eddi.datastore.postgres; + +import ai.labs.eddi.engine.model.Deployment.Environment; +import ai.labs.eddi.engine.model.LogEntry; +import org.junit.jupiter.api.*; + +import javax.sql.DataSource; +import java.sql.SQLException; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link PostgresDatabaseLogs} using Testcontainers. + * + * @since 6.0.0 + */ +@DisplayName("PostgresDatabaseLogs IT") +class PostgresDatabaseLogsIT extends PostgresTestBase { + + private static PostgresDatabaseLogs logs; + private static DataSource ds; + + @BeforeAll + static void init() { + var dsInstance = createDataSourceInstance(); + ds = dsInstance.get(); + logs = new PostgresDatabaseLogs(dsInstance); + } + + @BeforeEach + void clean() { + try { + truncateTables(ds, "database_logs"); + } catch (SQLException ignored) { + } + } + + // ─── Batch Insert + Query ─────────────────────────────────── + + @Nested + @DisplayName("Batch Insert and Query") + class BatchInsertAndQuery { + + @Test + @DisplayName("addLogsBatch + getLogs round-trip") + void batchInsertAndQuery() { + var entries = List.of( + new LogEntry(System.currentTimeMillis(), "INFO", "ai.labs.Test", "Hello", + "production", "agent1", 1, "conv1", "user1", "node-1"), + new LogEntry(System.currentTimeMillis(), "WARN", "ai.labs.Test", "Warning", + "production", "agent1", 1, "conv1", "user1", "node-1")); + logs.addLogsBatch(entries); + + List result = logs.getLogs(Environment.production, "agent1", 1, + "conv1", "user1", "node-1", 0, 10); + assertEquals(2, result.size()); + } + + @Test + @DisplayName("addLogsBatch null — no-op") + void nullBatch() { + assertDoesNotThrow(() -> logs.addLogsBatch(null)); + } + + @Test + @DisplayName("addLogsBatch empty — no-op") + void emptyBatch() { + assertDoesNotThrow(() -> logs.addLogsBatch(List.of())); + } + + @Test + @DisplayName("addLogsBatch with null agentVersion") + void nullAgentVersion() { + var entry = new LogEntry(System.currentTimeMillis(), "ERROR", "test", + "msg", "production", "agent1", null, "conv", "user", "node"); + logs.addLogsBatch(List.of(entry)); + + List result = logs.getLogs(Environment.production, "agent1", null, + null, null, null, null, 10); + assertEquals(1, result.size()); + assertNull(result.getFirst().agentVersion()); + } + } + + // ─── Query Filters ────────────────────────────────────────── + + @Nested + @DisplayName("Query Filters") + class QueryFilters { + + @Test + @DisplayName("getLogs filters by environment") + void filterByEnvironment() { + logs.addLogsBatch(List.of( + new LogEntry(System.currentTimeMillis(), "INFO", "t", "m", + "production", "a", 1, "c", "u", "n"), + new LogEntry(System.currentTimeMillis(), "INFO", "t", "m", + "test", "a", 1, "c", "u", "n"))); + + assertEquals(1, logs.getLogs(Environment.production, null, null, + null, null, null, null, 10).size()); + assertEquals(1, logs.getLogs(Environment.test, null, null, + null, null, null, null, 10).size()); + } + + @Test + @DisplayName("getLogs filters by userId") + void filterByUserId() { + logs.addLogsBatch(List.of( + new LogEntry(System.currentTimeMillis(), "INFO", "t", "m", + "production", "a", 1, "c", "userA", "n"), + new LogEntry(System.currentTimeMillis(), "INFO", "t", "m", + "production", "a", 1, "c", "userB", "n"))); + + assertEquals(1, logs.getLogs(null, null, null, + null, "userA", null, null, 10).size()); + } + + @Test + @DisplayName("getLogs with skip and limit") + void skipAndLimit() { + for (int i = 0; i < 5; i++) { + logs.addLogsBatch(List.of( + new LogEntry(System.currentTimeMillis() + i, "INFO", "t", "msg" + i, + "production", "a", 1, "c", "u", "n"))); + } + + assertEquals(2, logs.getLogs(null, null, null, + null, null, null, 0, 2).size()); + assertEquals(3, logs.getLogs(null, null, null, + null, null, null, 2, 10).size()); + } + + @Test + @DisplayName("getLogs no filters — returns all") + void noFilters() { + logs.addLogsBatch(List.of( + new LogEntry(System.currentTimeMillis(), "INFO", "t", "m1", + "production", "a", 1, "c", "u", "n"), + new LogEntry(System.currentTimeMillis(), "WARN", "t", "m2", + "production", "a", 1, "c", "u", "n"))); + + assertEquals(2, logs.getLogs(null, null, null, + null, null, null, null, null).size()); + } + } + + // ─── GDPR ─────────────────────────────────────────────────── + + @Nested + @DisplayName("GDPR Pseudonymization") + class Gdpr { + + @Test + @DisplayName("pseudonymizeByUserId — replaces userId") + void pseudonymize() { + logs.addLogsBatch(List.of( + new LogEntry(System.currentTimeMillis(), "INFO", "t", "m", + "production", "a", 1, "c1", "real_user", "n"), + new LogEntry(System.currentTimeMillis(), "WARN", "t", "m", + "production", "a", 1, "c2", "real_user", "n"), + new LogEntry(System.currentTimeMillis(), "INFO", "t", "m", + "production", "a", 1, "c3", "other_user", "n"))); + + long updated = logs.pseudonymizeByUserId("real_user", "anon_123"); + assertEquals(2, updated); + + assertEquals(2, logs.getLogs(null, null, null, + null, "anon_123", null, null, 10).size()); + assertEquals(0, logs.getLogs(null, null, null, + null, "real_user", null, null, 10).size()); + } + + @Test + @DisplayName("pseudonymizeByUserId non-existent — returns 0") + void pseudonymizeNonExistent() { + assertEquals(0, logs.pseudonymizeByUserId("ghost", "anon")); + } + } +} diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresDeploymentStorageIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresDeploymentStorageIT.java new file mode 100644 index 000000000..fa9bf8340 --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresDeploymentStorageIT.java @@ -0,0 +1,114 @@ +package ai.labs.eddi.datastore.postgres; + +import ai.labs.eddi.configs.deployment.model.DeploymentInfo; +import ai.labs.eddi.configs.deployment.model.DeploymentInfo.DeploymentStatus; +import ai.labs.eddi.datastore.IResourceStore; +import ai.labs.eddi.engine.model.Deployment.Environment; +import org.junit.jupiter.api.*; + +import javax.sql.DataSource; +import java.sql.SQLException; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link PostgresDeploymentStorage} using Testcontainers. + * + * @since 6.0.0 + */ +@DisplayName("PostgresDeploymentStorage IT") +class PostgresDeploymentStorageIT extends PostgresTestBase { + + private static PostgresDeploymentStorage storage; + private static DataSource ds; + + @BeforeAll + static void init() { + var dsInstance = createDataSourceInstance(); + ds = dsInstance.get(); + storage = new PostgresDeploymentStorage(dsInstance); + } + + @BeforeEach + void clean() { + try { + truncateTables(ds, "deployments"); + } catch (SQLException ignored) { + } + } + + // ─── CRUD ─────────────────────────────────────────────────── + + @Nested + @DisplayName("CRUD") + class Crud { + + @Test + @DisplayName("setDeploymentInfo + readDeploymentInfo round-trip") + void setAndRead() throws IResourceStore.ResourceStoreException { + storage.setDeploymentInfo("production", "agent1", 1, DeploymentStatus.deployed); + + DeploymentInfo info = storage.readDeploymentInfo("production", "agent1", 1); + assertNotNull(info); + assertEquals(Environment.production, info.getEnvironment()); + assertEquals("agent1", info.getAgentId()); + assertEquals(1, info.getAgentVersion()); + assertEquals(DeploymentStatus.deployed, info.getDeploymentStatus()); + } + + @Test + @DisplayName("readDeploymentInfo non-existent — returns null") + void readNonExistent() throws IResourceStore.ResourceStoreException { + assertNull(storage.readDeploymentInfo("production", "ghost", 99)); + } + + @Test + @DisplayName("upsert — updates status on conflict") + void upsert() throws IResourceStore.ResourceStoreException { + storage.setDeploymentInfo("production", "agent1", 1, DeploymentStatus.deployed); + storage.setDeploymentInfo("production", "agent1", 1, DeploymentStatus.undeployed); + + DeploymentInfo info = storage.readDeploymentInfo("production", "agent1", 1); + assertEquals(DeploymentStatus.undeployed, info.getDeploymentStatus()); + } + } + + // ─── List Queries ─────────────────────────────────────────── + + @Nested + @DisplayName("List Queries") + class ListQueries { + + @Test + @DisplayName("readDeploymentInfos — returns all") + void readAll() throws IResourceStore.ResourceStoreException { + storage.setDeploymentInfo("production", "a1", 1, DeploymentStatus.deployed); + storage.setDeploymentInfo("production", "a2", 1, DeploymentStatus.deployed); + storage.setDeploymentInfo("test", "a3", 1, DeploymentStatus.deployed); + + List all = storage.readDeploymentInfos(); + assertEquals(3, all.size()); + } + + @Test + @DisplayName("readDeploymentInfos with status filter") + void filterByStatus() throws IResourceStore.ResourceStoreException { + storage.setDeploymentInfo("production", "a1", 1, DeploymentStatus.deployed); + storage.setDeploymentInfo("production", "a2", 1, DeploymentStatus.undeployed); + storage.setDeploymentInfo("production", "a3", 1, DeploymentStatus.deployed); + + List deployed = storage.readDeploymentInfos("deployed"); + assertEquals(2, deployed.size()); + + List undeployed = storage.readDeploymentInfos("undeployed"); + assertEquals(1, undeployed.size()); + } + + @Test + @DisplayName("readDeploymentInfos empty — returns empty list") + void readEmpty() throws IResourceStore.ResourceStoreException { + assertTrue(storage.readDeploymentInfos().isEmpty()); + } + } +} From 1499906d440b102686ec24b296413a0102546863 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 22:10:16 +0200 Subject: [PATCH 045/124] test(postgres): add AgentTriggerStoreIT (8), UserConversationStoreIT (8), AttachmentStorageIT (7), MigrationLogStoreIT (4) --- .../postgres/PostgresAgentTriggerStoreIT.java | 139 ++++++++++++++++ .../postgres/PostgresAttachmentStorageIT.java | 116 +++++++++++++ .../PostgresConversationMemoryStoreIT.java | 10 +- .../postgres/PostgresMigrationLogStoreIT.java | 73 ++++++++ .../postgres/PostgresScheduleStoreIT.java | 3 +- .../PostgresUserConversationStoreIT.java | 156 ++++++++++++++++++ 6 files changed, 491 insertions(+), 6 deletions(-) create mode 100644 src/test/java/ai/labs/eddi/datastore/postgres/PostgresAgentTriggerStoreIT.java create mode 100644 src/test/java/ai/labs/eddi/datastore/postgres/PostgresAttachmentStorageIT.java create mode 100644 src/test/java/ai/labs/eddi/datastore/postgres/PostgresMigrationLogStoreIT.java create mode 100644 src/test/java/ai/labs/eddi/datastore/postgres/PostgresUserConversationStoreIT.java diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresAgentTriggerStoreIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresAgentTriggerStoreIT.java new file mode 100644 index 000000000..f6ebd2ec6 --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresAgentTriggerStoreIT.java @@ -0,0 +1,139 @@ +package ai.labs.eddi.datastore.postgres; + +import ai.labs.eddi.datastore.IResourceStore; +import ai.labs.eddi.datastore.serialization.IJsonSerialization; +import ai.labs.eddi.datastore.serialization.JsonSerialization; +import ai.labs.eddi.engine.triggermanagement.model.AgentTriggerConfiguration; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.*; + +import javax.sql.DataSource; +import java.sql.SQLException; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link PostgresAgentTriggerStore} using Testcontainers. + * + * @since 6.0.0 + */ +@DisplayName("PostgresAgentTriggerStore IT") +class PostgresAgentTriggerStoreIT extends PostgresTestBase { + + private static PostgresAgentTriggerStore store; + private static DataSource ds; + + @BeforeAll + static void init() { + var dsInstance = createDataSourceInstance(); + ds = dsInstance.get(); + IJsonSerialization json = new JsonSerialization(new ObjectMapper()); + store = new PostgresAgentTriggerStore(dsInstance, json); + } + + @BeforeEach + void clean() { + try { + truncateTables(ds, "agent_triggers"); + } catch (SQLException ignored) { + } + } + + // ─── CRUD ─────────────────────────────────────────────────── + + @Nested + @DisplayName("CRUD") + class Crud { + + @Test + @DisplayName("createAgentTrigger + readAgentTrigger round-trip") + void createAndRead() throws Exception { + var config = createTrigger("greeting"); + store.createAgentTrigger(config); + + var found = store.readAgentTrigger("greeting"); + assertNotNull(found); + assertEquals("greeting", found.getIntent()); + } + + @Test + @DisplayName("readAgentTrigger non-existent — throws ResourceNotFoundException") + void readNonExistent() { + assertThrows(IResourceStore.ResourceNotFoundException.class, + () -> store.readAgentTrigger("nonexistent")); + } + + @Test + @DisplayName("createAgentTrigger duplicate — throws ResourceAlreadyExistsException") + void duplicateCreate() throws Exception { + store.createAgentTrigger(createTrigger("duplicate")); + + assertThrows(IResourceStore.ResourceAlreadyExistsException.class, + () -> store.createAgentTrigger(createTrigger("duplicate"))); + } + + @Test + @DisplayName("updateAgentTrigger — modifies data") + void update() throws Exception { + var config = createTrigger("update_me"); + store.createAgentTrigger(config); + + // Update with modified deployments list + var updated = createTrigger("update_me"); + store.updateAgentTrigger("update_me", updated); + + var found = store.readAgentTrigger("update_me"); + assertEquals("update_me", found.getIntent()); + } + + @Test + @DisplayName("updateAgentTrigger non-existent — throws ResourceNotFoundException") + void updateNonExistent() { + assertThrows(IResourceStore.ResourceNotFoundException.class, + () -> store.updateAgentTrigger("ghost", createTrigger("ghost"))); + } + + @Test + @DisplayName("deleteAgentTrigger — removes trigger") + void delete() throws Exception { + store.createAgentTrigger(createTrigger("delete_me")); + store.deleteAgentTrigger("delete_me"); + + assertThrows(IResourceStore.ResourceNotFoundException.class, + () -> store.readAgentTrigger("delete_me")); + } + } + + // ─── List ─────────────────────────────────────────────────── + + @Nested + @DisplayName("List") + class ListQueries { + + @Test + @DisplayName("readAllAgentTriggers — returns all") + void readAll() throws Exception { + store.createAgentTrigger(createTrigger("intent1")); + store.createAgentTrigger(createTrigger("intent2")); + store.createAgentTrigger(createTrigger("intent3")); + + List all = store.readAllAgentTriggers(); + assertEquals(3, all.size()); + } + + @Test + @DisplayName("readAllAgentTriggers empty — returns empty list") + void readAllEmpty() throws Exception { + assertTrue(store.readAllAgentTriggers().isEmpty()); + } + } + + // ─── Helpers ──────────────────────────────────────────────── + + private static AgentTriggerConfiguration createTrigger(String intent) { + var config = new AgentTriggerConfiguration(); + config.setIntent(intent); + return config; + } +} diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresAttachmentStorageIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresAttachmentStorageIT.java new file mode 100644 index 000000000..73f9c2fa0 --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresAttachmentStorageIT.java @@ -0,0 +1,116 @@ +package ai.labs.eddi.datastore.postgres; + +import ai.labs.eddi.engine.memory.IAttachmentStorage; +import ai.labs.eddi.engine.memory.IAttachmentStorage.AttachmentNotFoundException; +import org.junit.jupiter.api.*; + +import javax.sql.DataSource; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.nio.charset.StandardCharsets; +import java.sql.SQLException; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link PostgresAttachmentStorage} using Testcontainers. + * + * @since 6.0.0 + */ +@DisplayName("PostgresAttachmentStorage IT") +class PostgresAttachmentStorageIT extends PostgresTestBase { + + private static PostgresAttachmentStorage storage; + private static DataSource ds; + + @BeforeAll + static void init() { + var dsInstance = createDataSourceInstance(); + ds = dsInstance.get(); + storage = new PostgresAttachmentStorage(dsInstance); + // Manually trigger schema creation (normally @PostConstruct) + storage.createTable(); + } + + @BeforeEach + void clean() { + try { + truncateTables(ds, "attachments"); + } catch (SQLException ignored) { + } + } + + @Test + @DisplayName("store + load — binary round-trip") + void storeAndLoad() throws AttachmentNotFoundException, IOException { + byte[] content = "Hello, World!".getBytes(StandardCharsets.UTF_8); + var input = new ByteArrayInputStream(content); + + String ref = storage.store("conv-1", "test.txt", "text/plain", input, content.length); + assertNotNull(ref); + assertTrue(ref.startsWith("pg://")); + + try (InputStream loaded = storage.load(ref)) { + assertArrayEquals(content, loaded.readAllBytes()); + } + } + + @Test + @DisplayName("store with zero sizeBytes — still persists") + void storeZeroSize() throws AttachmentNotFoundException, IOException { + byte[] content = "data".getBytes(StandardCharsets.UTF_8); + String ref = storage.store("conv-2", "zero.bin", "application/octet-stream", + new ByteArrayInputStream(content), 0); + + try (InputStream loaded = storage.load(ref)) { + assertArrayEquals(content, loaded.readAllBytes()); + } + } + + @Test + @DisplayName("load non-existent — throws AttachmentNotFoundException") + void loadNonExistent() { + assertThrows(AttachmentNotFoundException.class, + () -> storage.load("pg://00000000-0000-0000-0000-000000000000")); + } + + @Test + @DisplayName("load invalid ref — throws AttachmentNotFoundException") + void loadInvalidRef() { + assertThrows(AttachmentNotFoundException.class, + () -> storage.load("invalid-ref")); + } + + @Test + @DisplayName("load null ref — throws AttachmentNotFoundException") + void loadNullRef() { + assertThrows(AttachmentNotFoundException.class, + () -> storage.load(null)); + } + + @Test + @DisplayName("deleteByConversation — removes all attachments for conversation") + void deleteByConversation() throws AttachmentNotFoundException, IOException { + byte[] data = "x".getBytes(StandardCharsets.UTF_8); + String ref1 = storage.store("conv-del", "a.txt", "text/plain", + new ByteArrayInputStream(data), data.length); + String ref2 = storage.store("conv-del", "b.txt", "text/plain", + new ByteArrayInputStream(data), data.length); + storage.store("conv-keep", "c.txt", "text/plain", + new ByteArrayInputStream(data), data.length); + + long deleted = storage.deleteByConversation("conv-del"); + assertEquals(2, deleted); + + // Deleted attachments should not be loadable + assertThrows(AttachmentNotFoundException.class, () -> storage.load(ref1)); + assertThrows(AttachmentNotFoundException.class, () -> storage.load(ref2)); + } + + @Test + @DisplayName("deleteByConversation non-existent — returns 0") + void deleteNonExistent() { + assertEquals(0, storage.deleteByConversation("no-such-conv")); + } +} diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresConversationMemoryStoreIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresConversationMemoryStoreIT.java index 3059514ae..3d92dc07e 100644 --- a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresConversationMemoryStoreIT.java +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresConversationMemoryStoreIT.java @@ -16,9 +16,11 @@ import static org.junit.jupiter.api.Assertions.*; /** - * Integration tests for {@link PostgresConversationMemoryStore} using Testcontainers. + * Integration tests for {@link PostgresConversationMemoryStore} using + * Testcontainers. *

- * Covers snapshot CRUD, state transitions, active conversation queries, and GDPR operations. + * Covers snapshot CRUD, state transitions, active conversation queries, and + * GDPR operations. * * @since 6.0.0 */ @@ -261,8 +263,8 @@ void deleteByUserId() { // ─── Helpers ──────────────────────────────────────────────── private static ConversationMemorySnapshot createSnapshot(String id, String agentId, - int agentVersion, String userId, - ConversationState state) { + int agentVersion, String userId, + ConversationState state) { var snapshot = new ConversationMemorySnapshot(); if (id != null) { snapshot.setId(id); diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresMigrationLogStoreIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresMigrationLogStoreIT.java new file mode 100644 index 000000000..5378ebcfb --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresMigrationLogStoreIT.java @@ -0,0 +1,73 @@ +package ai.labs.eddi.datastore.postgres; + +import ai.labs.eddi.configs.migration.model.MigrationLog; +import org.junit.jupiter.api.*; + +import javax.sql.DataSource; +import java.sql.SQLException; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link PostgresMigrationLogStore} using Testcontainers. + * + * @since 6.0.0 + */ +@DisplayName("PostgresMigrationLogStore IT") +class PostgresMigrationLogStoreIT extends PostgresTestBase { + + private static PostgresMigrationLogStore store; + private static DataSource ds; + + @BeforeAll + static void init() { + var dsInstance = createDataSourceInstance(); + ds = dsInstance.get(); + store = new PostgresMigrationLogStore(dsInstance); + } + + @BeforeEach + void clean() { + try { + truncateTables(ds, "migration_log"); + } catch (SQLException ignored) { + } + } + + @Test + @DisplayName("create + read round-trip") + void createAndRead() { + store.createMigrationLog(new MigrationLog("V6_rename_migration")); + + MigrationLog log = store.readMigrationLog("V6_rename_migration"); + assertNotNull(log); + assertEquals("V6_rename_migration", log.getName()); + } + + @Test + @DisplayName("read non-existent — returns null") + void readNonExistent() { + assertNull(store.readMigrationLog("nonexistent_migration")); + } + + @Test + @DisplayName("create duplicate — idempotent (ON CONFLICT DO NOTHING)") + void duplicateCreate() { + store.createMigrationLog(new MigrationLog("V6_qute_migration")); + store.createMigrationLog(new MigrationLog("V6_qute_migration")); + + // Should not throw, and reading should still work + assertNotNull(store.readMigrationLog("V6_qute_migration")); + } + + @Test + @DisplayName("multiple migrations tracked independently") + void multipleMigrations() { + store.createMigrationLog(new MigrationLog("migration_A")); + store.createMigrationLog(new MigrationLog("migration_B")); + + assertNotNull(store.readMigrationLog("migration_A")); + assertNotNull(store.readMigrationLog("migration_B")); + assertNull(store.readMigrationLog("migration_C")); + } +} diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresScheduleStoreIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresScheduleStoreIT.java index 58edfef05..d93d68802 100644 --- a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresScheduleStoreIT.java +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresScheduleStoreIT.java @@ -390,8 +390,7 @@ void readFailed() throws Exception { List failed = store.readFailedFireLogs(10); assertEquals(2, failed.size()); - assertTrue(failed.stream().allMatch(f -> - "FAILED".equals(f.status()) || "DEAD_LETTERED".equals(f.status()))); + assertTrue(failed.stream().allMatch(f -> "FAILED".equals(f.status()) || "DEAD_LETTERED".equals(f.status()))); } @Test diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresUserConversationStoreIT.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresUserConversationStoreIT.java new file mode 100644 index 000000000..ba12e161f --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresUserConversationStoreIT.java @@ -0,0 +1,156 @@ +package ai.labs.eddi.datastore.postgres; + +import ai.labs.eddi.datastore.IResourceStore; +import ai.labs.eddi.datastore.serialization.IJsonSerialization; +import ai.labs.eddi.datastore.serialization.JsonSerialization; +import ai.labs.eddi.engine.triggermanagement.model.UserConversation; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.*; + +import javax.sql.DataSource; +import java.sql.SQLException; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link PostgresUserConversationStore} using Testcontainers. + * + * @since 6.0.0 + */ +@DisplayName("PostgresUserConversationStore IT") +class PostgresUserConversationStoreIT extends PostgresTestBase { + + private static PostgresUserConversationStore store; + private static DataSource ds; + + @BeforeAll + static void init() { + var dsInstance = createDataSourceInstance(); + ds = dsInstance.get(); + IJsonSerialization json = new JsonSerialization(new ObjectMapper()); + store = new PostgresUserConversationStore(dsInstance, json); + } + + @BeforeEach + void clean() { + try { + truncateTables(ds, "user_conversations"); + } catch (SQLException ignored) { + } + } + + // ─── CRUD ─────────────────────────────────────────────────── + + @Nested + @DisplayName("CRUD") + class Crud { + + @Test + @DisplayName("create + read round-trip") + void createAndRead() throws Exception { + var uc = createUserConversation("greet", "user1", "conv1", "agent1"); + store.createUserConversation(uc); + + var found = store.readUserConversation("greet", "user1"); + assertNotNull(found); + assertEquals("greet", found.getIntent()); + assertEquals("user1", found.getUserId()); + assertEquals("conv1", found.getConversationId()); + } + + @Test + @DisplayName("read non-existent — returns null") + void readNonExistent() throws IResourceStore.ResourceStoreException { + assertNull(store.readUserConversation("ghost", "nobody")); + } + + @Test + @DisplayName("create duplicate — throws ResourceAlreadyExistsException") + void duplicateCreate() throws Exception { + store.createUserConversation( + createUserConversation("dup", "user1", "c1", "a1")); + + assertThrows(IResourceStore.ResourceAlreadyExistsException.class, + () -> store.createUserConversation( + createUserConversation("dup", "user1", "c2", "a1"))); + } + + @Test + @DisplayName("delete — removes by intent + userId") + void delete() throws Exception { + store.createUserConversation( + createUserConversation("del", "user1", "c1", "a1")); + store.deleteUserConversation("del", "user1"); + + assertNull(store.readUserConversation("del", "user1")); + } + + @Test + @DisplayName("same intent, different users — independent entries") + void sameIntentDifferentUsers() throws Exception { + store.createUserConversation( + createUserConversation("shared", "user1", "c1", "a1")); + store.createUserConversation( + createUserConversation("shared", "user2", "c2", "a1")); + + assertNotNull(store.readUserConversation("shared", "user1")); + assertNotNull(store.readUserConversation("shared", "user2")); + } + } + + // ─── GDPR ─────────────────────────────────────────────────── + + @Nested + @DisplayName("GDPR Operations") + class GdprOps { + + @Test + @DisplayName("getAllForUser — returns all conversations for user") + void getAllForUser() throws Exception { + store.createUserConversation( + createUserConversation("i1", "target", "c1", "a1")); + store.createUserConversation( + createUserConversation("i2", "target", "c2", "a1")); + store.createUserConversation( + createUserConversation("i3", "other", "c3", "a1")); + + List result = store.getAllForUser("target"); + assertEquals(2, result.size()); + } + + @Test + @DisplayName("deleteAllForUser — removes all for user") + void deleteAllForUser() throws Exception { + store.createUserConversation( + createUserConversation("i1", "delete_me", "c1", "a1")); + store.createUserConversation( + createUserConversation("i2", "delete_me", "c2", "a1")); + store.createUserConversation( + createUserConversation("i3", "keep_me", "c3", "a1")); + + long deleted = store.deleteAllForUser("delete_me"); + assertEquals(2, deleted); + assertTrue(store.getAllForUser("delete_me").isEmpty()); + assertEquals(1, store.getAllForUser("keep_me").size()); + } + + @Test + @DisplayName("deleteAllForUser non-existent — returns 0") + void deleteNonExistent() { + assertEquals(0, store.deleteAllForUser("ghost")); + } + } + + // ─── Helpers ──────────────────────────────────────────────── + + private static UserConversation createUserConversation(String intent, String userId, + String conversationId, String agentId) { + var uc = new UserConversation(); + uc.setIntent(intent); + uc.setUserId(userId); + uc.setConversationId(conversationId); + uc.setAgentId(agentId); + return uc; + } +} From a28f084c67f6421b1f034495d19fe1c821b593a8 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 22:17:51 +0200 Subject: [PATCH 046/124] =?UTF-8?q?docs:=20update=20changelog=20with=20Bat?= =?UTF-8?q?ches=206-7=20=E2=80=94=20full=20Postgres=20adapter=20IT=20cover?= =?UTF-8?q?age?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/changelog.md | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/docs/changelog.md b/docs/changelog.md index 8cea757f4..b4bffe64a 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -13,6 +13,32 @@ Each entry follows this format: - **Decision** — Key design decisions and their reasoning - **Files** — Links to modified files +## Integration Test Expansion — Batches 6-7: Full Postgres Adapter Coverage (2026-04-20) + +**Repo:** EDDI (`test/coverage-tier-1-2`) + +**What changed:** Completed integration tests for ALL remaining PostgreSQL adapter stores. Every Postgres persistence adapter now has a dedicated Testcontainers IT. Total: 516 ITs, 0 failures. + +### Batch 6 — ConversationMemoryStore, DeploymentStorage, DatabaseLogs (30 tests) +- **PostgresConversationMemoryStoreIT** (14 tests): Snapshot CRUD (store new, update existing, load non-existent), state transitions (set/get, non-existent), delete, active conversation queries (excludes ENDED, count, ended IDs), IResourceStore adapter (create/read, delete, deleteAllPermanently), GDPR (getByUserId via JSONB query, deleteByUserId cascade) +- **PostgresDeploymentStorageIT** (6 tests): CRUD with upsert (ON CONFLICT), list all, filter by status, empty results +- **PostgresDatabaseLogsIT** (10 tests): Batch insert + query, null/empty batch no-op, null agentVersion, query filters (environment, userId, skip/limit, no filters), GDPR pseudonymization + +### Batch 7 — AgentTriggerStore, UserConversationStore, AttachmentStorage, MigrationLogStore (27 tests) +- **PostgresAgentTriggerStoreIT** (8 tests): CRUD (create, read, duplicate ResourceAlreadyExistsException, update, update non-existent ResourceNotFoundException, delete), list all, list empty +- **PostgresUserConversationStoreIT** (8 tests): CRUD (create+read, read non-existent null, duplicate rejection, delete, composite key independence), GDPR (getAllForUser, deleteAllForUser, delete non-existent) +- **PostgresAttachmentStorageIT** (7 tests): Binary store/load round-trip, zero sizeBytes, load non-existent/invalid/null ref, deleteByConversation cascade, delete non-existent +- **PostgresMigrationLogStoreIT** (4 tests): Create+read round-trip, read non-existent null, idempotent duplicate (ON CONFLICT DO NOTHING), multi-migration independence + +**Files (new):** +- `PostgresConversationMemoryStoreIT.java` — 14 tests +- `PostgresDeploymentStorageIT.java` — 6 tests +- `PostgresDatabaseLogsIT.java` — 10 tests +- `PostgresAgentTriggerStoreIT.java` — 8 tests +- `PostgresUserConversationStoreIT.java` — 8 tests +- `PostgresAttachmentStorageIT.java` — 7 tests +- `PostgresMigrationLogStoreIT.java` — 4 tests + ## Integration Test Expansion — Batch 5 + Code Review (2026-04-20) **Repo:** EDDI (`test/coverage-tier-1-2`) From aa23251ad361860b62476065d2ec58eb5973af7d Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 22:52:13 +0200 Subject: [PATCH 047/124] =?UTF-8?q?test(mongo):=20add=20Mongo=20adapter=20?= =?UTF-8?q?ITs=20=E2=80=94=20MongoScheduleStore=20(21),=20MongoSecretPersi?= =?UTF-8?q?stence=20(13),=20MongoDeploymentStorage=20(5),=20MongoAttachmen?= =?UTF-8?q?tStorage=20(7),=20MongoUserMemoryStore=20(14),=20MongoResourceS?= =?UTF-8?q?torage=20(15)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../mongo/MongoAttachmentStorageIT.java | 106 ++++++ .../mongo/MongoDeploymentStorageIT.java | 79 ++++ .../mongo/MongoResourceStorageIT.java | 204 +++++++++++ .../datastore/mongo/MongoScheduleStoreIT.java | 341 ++++++++++++++++++ .../mongo/MongoSecretPersistenceIT.java | 175 +++++++++ .../eddi/datastore/mongo/MongoTestBase.java | 67 ++++ .../mongo/MongoUserMemoryStoreIT.java | 234 ++++++++++++ 7 files changed, 1206 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/datastore/mongo/MongoAttachmentStorageIT.java create mode 100644 src/test/java/ai/labs/eddi/datastore/mongo/MongoDeploymentStorageIT.java create mode 100644 src/test/java/ai/labs/eddi/datastore/mongo/MongoResourceStorageIT.java create mode 100644 src/test/java/ai/labs/eddi/datastore/mongo/MongoScheduleStoreIT.java create mode 100644 src/test/java/ai/labs/eddi/datastore/mongo/MongoSecretPersistenceIT.java create mode 100644 src/test/java/ai/labs/eddi/datastore/mongo/MongoTestBase.java create mode 100644 src/test/java/ai/labs/eddi/datastore/mongo/MongoUserMemoryStoreIT.java diff --git a/src/test/java/ai/labs/eddi/datastore/mongo/MongoAttachmentStorageIT.java b/src/test/java/ai/labs/eddi/datastore/mongo/MongoAttachmentStorageIT.java new file mode 100644 index 000000000..43c933562 --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/mongo/MongoAttachmentStorageIT.java @@ -0,0 +1,106 @@ +package ai.labs.eddi.datastore.mongo; + +import ai.labs.eddi.engine.memory.IAttachmentStorage.AttachmentNotFoundException; +import ai.labs.eddi.engine.memory.mongo.MongoAttachmentStorage; +import org.junit.jupiter.api.*; + +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.nio.charset.StandardCharsets; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link MongoAttachmentStorage} (GridFS) using Testcontainers. + * + * @since 6.0.0 + */ +@DisplayName("MongoAttachmentStorage IT") +class MongoAttachmentStorageIT extends MongoTestBase { + + private static MongoAttachmentStorage storage; + + @BeforeAll + static void init() { + storage = new MongoAttachmentStorage(getDatabase()); + } + + @BeforeEach + void clean() { + // Drop GridFS collections + dropCollections("eddi_attachments.files", "eddi_attachments.chunks"); + } + + @Test + @DisplayName("store + load — binary round-trip") + void storeAndLoad() throws AttachmentNotFoundException, IOException { + byte[] content = "Hello GridFS!".getBytes(StandardCharsets.UTF_8); + String ref = storage.store("conv-1", "test.txt", "text/plain", + new ByteArrayInputStream(content), content.length); + + assertNotNull(ref); + assertTrue(ref.startsWith("gridfs://")); + + try (InputStream loaded = storage.load(ref)) { + assertArrayEquals(content, loaded.readAllBytes()); + } + } + + @Test + @DisplayName("store with null fileName — uses 'unnamed'") + void storeNullFilename() throws AttachmentNotFoundException, IOException { + byte[] content = "data".getBytes(StandardCharsets.UTF_8); + String ref = storage.store("conv-1", null, "application/octet-stream", + new ByteArrayInputStream(content), content.length); + + try (InputStream loaded = storage.load(ref)) { + assertArrayEquals(content, loaded.readAllBytes()); + } + } + + @Test + @DisplayName("load non-existent — throws AttachmentNotFoundException") + void loadNonExistent() { + assertThrows(AttachmentNotFoundException.class, + () -> storage.load("gridfs://aaaaaaaaaaaaaaaaaaaaaaaa")); + } + + @Test + @DisplayName("load invalid ref — throws AttachmentNotFoundException") + void loadInvalidRef() { + assertThrows(AttachmentNotFoundException.class, + () -> storage.load("invalid-ref")); + } + + @Test + @DisplayName("load null ref — throws AttachmentNotFoundException") + void loadNullRef() { + assertThrows(AttachmentNotFoundException.class, + () -> storage.load(null)); + } + + @Test + @DisplayName("deleteByConversation — removes all for conversation") + void deleteByConversation() throws AttachmentNotFoundException { + byte[] data = "x".getBytes(StandardCharsets.UTF_8); + String ref1 = storage.store("conv-del", "a.txt", "text/plain", + new ByteArrayInputStream(data), data.length); + String ref2 = storage.store("conv-del", "b.txt", "text/plain", + new ByteArrayInputStream(data), data.length); + storage.store("conv-keep", "c.txt", "text/plain", + new ByteArrayInputStream(data), data.length); + + long deleted = storage.deleteByConversation("conv-del"); + assertEquals(2, deleted); + + assertThrows(AttachmentNotFoundException.class, () -> storage.load(ref1)); + assertThrows(AttachmentNotFoundException.class, () -> storage.load(ref2)); + } + + @Test + @DisplayName("deleteByConversation non-existent — returns 0") + void deleteNonExistent() { + assertEquals(0, storage.deleteByConversation("no-such-conv")); + } +} diff --git a/src/test/java/ai/labs/eddi/datastore/mongo/MongoDeploymentStorageIT.java b/src/test/java/ai/labs/eddi/datastore/mongo/MongoDeploymentStorageIT.java new file mode 100644 index 000000000..a3d4d6ffb --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/mongo/MongoDeploymentStorageIT.java @@ -0,0 +1,79 @@ +package ai.labs.eddi.datastore.mongo; + +import ai.labs.eddi.configs.deployment.model.DeploymentInfo; +import ai.labs.eddi.configs.deployment.model.DeploymentInfo.DeploymentStatus; +import ai.labs.eddi.configs.deployment.mongo.MongoDeploymentStorage; +import ai.labs.eddi.datastore.IResourceStore; +import org.junit.jupiter.api.*; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link MongoDeploymentStorage} using Testcontainers. + * + * @since 6.0.0 + */ +@DisplayName("MongoDeploymentStorage IT") +class MongoDeploymentStorageIT extends MongoTestBase { + + private static MongoDeploymentStorage storage; + + @BeforeAll + static void init() { + storage = new MongoDeploymentStorage(getDatabase(), documentBuilder); + } + + @BeforeEach + void clean() { + dropCollections("deployments"); + } + + @Test + @DisplayName("setDeploymentInfo + readDeploymentInfo round-trip") + void setAndRead() throws IResourceStore.ResourceStoreException { + storage.setDeploymentInfo("production", "agent1", 1, DeploymentStatus.deployed); + + DeploymentInfo info = storage.readDeploymentInfo("production", "agent1", 1); + assertNotNull(info); + assertEquals("production", info.getEnvironment().name()); + assertEquals("agent1", info.getAgentId()); + assertEquals(DeploymentStatus.deployed, info.getDeploymentStatus()); + } + + @Test + @DisplayName("readDeploymentInfo non-existent — returns null") + void readNonExistent() throws IResourceStore.ResourceStoreException { + assertNull(storage.readDeploymentInfo("production", "ghost", 99)); + } + + @Test + @DisplayName("setDeploymentInfo — replaces on conflict") + void upsert() throws IResourceStore.ResourceStoreException { + storage.setDeploymentInfo("production", "a1", 1, DeploymentStatus.deployed); + storage.setDeploymentInfo("production", "a1", 1, DeploymentStatus.undeployed); + + assertEquals(DeploymentStatus.undeployed, + storage.readDeploymentInfo("production", "a1", 1).getDeploymentStatus()); + } + + @Test + @DisplayName("readDeploymentInfos — returns all") + void readAll() throws IResourceStore.ResourceStoreException { + storage.setDeploymentInfo("production", "a1", 1, DeploymentStatus.deployed); + storage.setDeploymentInfo("production", "a2", 1, DeploymentStatus.deployed); + + assertEquals(2, storage.readDeploymentInfos().size()); + } + + @Test + @DisplayName("readDeploymentInfos with status filter") + void filterByStatus() throws IResourceStore.ResourceStoreException { + storage.setDeploymentInfo("production", "a1", 1, DeploymentStatus.deployed); + storage.setDeploymentInfo("production", "a2", 1, DeploymentStatus.undeployed); + + List deployed = storage.readDeploymentInfos("deployed"); + assertEquals(1, deployed.size()); + } +} diff --git a/src/test/java/ai/labs/eddi/datastore/mongo/MongoResourceStorageIT.java b/src/test/java/ai/labs/eddi/datastore/mongo/MongoResourceStorageIT.java new file mode 100644 index 000000000..b885fb8c4 --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/mongo/MongoResourceStorageIT.java @@ -0,0 +1,204 @@ +package ai.labs.eddi.datastore.mongo; + +import ai.labs.eddi.datastore.IResourceStorage; +import ai.labs.eddi.datastore.IResourceStore; +import org.bson.types.ObjectId; +import org.junit.jupiter.api.*; + +import java.io.IOException; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link MongoResourceStorage} using Testcontainers. + * + * @since 6.0.0 + */ +@DisplayName("MongoResourceStorage IT") +@SuppressWarnings("unchecked") +class MongoResourceStorageIT extends MongoTestBase { + + private static MongoResourceStorage storage; + + @BeforeAll + static void init() { + storage = new MongoResourceStorage<>(getDatabase(), "test_resources", + documentBuilder, Map.class); + } + + @BeforeEach + void clean() { + dropCollections("test_resources", "test_resources.history"); + } + + @Test + @DisplayName("newResource + store — creates with auto-generated ID") + void storeNew() throws IOException { + IResourceStorage.IResource resource = storage.newResource(Map.of("name", "test")); + storage.store(resource); + + assertNotNull(resource.getId()); + assertEquals(1, resource.getVersion()); + } + + @Test + @DisplayName("store + read round-trip") + void storeAndRead() throws IOException { + IResourceStorage.IResource resource = storage.newResource(Map.of("name", "round-trip")); + storage.store(resource); + + IResourceStorage.IResource read = storage.read(resource.getId(), 1); + assertNotNull(read); + Map data = read.getData(); + assertEquals("round-trip", data.get("name")); + } + + @Test + @DisplayName("read non-existent — returns null") + void readNonExistent() { + IResourceStorage.IResource read = storage.read(new ObjectId().toString(), 1); + assertNull(read); + } + + @Test + @DisplayName("newResource with explicit ID and version") + void newResourceWithId() throws IOException { + String id = new ObjectId().toString(); + IResourceStorage.IResource resource = storage.newResource(id, 3, Map.of("key", "val")); + + assertEquals(id, resource.getId()); + assertEquals(3, resource.getVersion()); + } + + @Test + @DisplayName("createNew — inserts without upsert") + void createNew() throws IOException { + IResourceStorage.IResource resource = storage.newResource(Map.of("mode", "create")); + storage.createNew(resource); + + assertNotNull(resource.getId()); + } + + @Test + @DisplayName("store with existing ID — upserts") + void storeUpsert() throws IOException { + IResourceStorage.IResource resource = storage.newResource(Map.of("version", "1")); + storage.store(resource); + String id = resource.getId(); + + IResourceStorage.IResource updated = storage.newResource(id, 2, Map.of("version", "2")); + storage.store(updated); + + IResourceStorage.IResource read = storage.read(id, 2); + assertNotNull(read); + assertEquals("2", read.getData().get("version")); + } + + @Test + @DisplayName("getCurrentVersion — returns version number") + void getCurrentVersion() throws IOException { + IResourceStorage.IResource resource = storage.newResource(Map.of("x", "y")); + storage.store(resource); + + Integer version = storage.getCurrentVersion(resource.getId()); + assertEquals(1, version); + } + + @Test + @DisplayName("getCurrentVersion non-existent — returns -1") + void getCurrentVersionNonExistent() { + assertEquals(-1, storage.getCurrentVersion(new ObjectId().toString())); + } + + @Test + @DisplayName("remove — deletes from current collection") + void remove() throws IOException { + IResourceStorage.IResource resource = storage.newResource(Map.of("del", "me")); + storage.store(resource); + String id = resource.getId(); + + storage.remove(id); + assertNull(storage.read(id, 1)); + } + + @Test + @DisplayName("history resource — store and read") + void historyResource() throws IOException { + IResourceStorage.IResource resource = storage.newResource(Map.of("historic", "data")); + storage.store(resource); + + IResourceStorage.IHistoryResource history = storage.newHistoryResourceFor(resource, false); + storage.store(history); + + IResourceStorage.IHistoryResource readHistory = storage.readHistory(resource.getId(), 1); + assertNotNull(readHistory); + assertFalse(readHistory.isDeleted()); + } + + @Test + @DisplayName("history resource deleted flag") + void historyResourceDeleted() throws IOException { + IResourceStorage.IResource resource = storage.newResource(Map.of("about_to_delete", "yes")); + storage.store(resource); + + IResourceStorage.IHistoryResource history = storage.newHistoryResourceFor(resource, true); + storage.store(history); + + IResourceStorage.IHistoryResource readHistory = storage.readHistory(resource.getId(), 1); + assertNotNull(readHistory); + assertTrue(readHistory.isDeleted()); + } + + @Test + @DisplayName("removeAllPermanently — deletes current + history") + void removeAllPermanently() throws IOException { + IResourceStorage.IResource resource = storage.newResource(Map.of("purge", "all")); + storage.store(resource); + + IResourceStorage.IHistoryResource history = storage.newHistoryResourceFor(resource, false); + storage.store(history); + + storage.removeAllPermanently(resource.getId()); + assertNull(storage.read(resource.getId(), 1)); + assertNull(storage.readHistory(resource.getId(), 1)); + } + + @Test + @DisplayName("readHistoryLatest — returns most recent version") + void readHistoryLatest() throws IOException { + IResourceStorage.IResource resource = storage.newResource(Map.of("v", "1")); + storage.store(resource); + String id = resource.getId(); + + // Store version 1 history + IResourceStorage.IHistoryResource h1 = storage.newHistoryResourceFor(resource, false); + storage.store(h1); + + // Store version 2 history + IResourceStorage.IResource v2 = storage.newResource(id, 2, Map.of("v", "2")); + IResourceStorage.IHistoryResource h2 = storage.newHistoryResourceFor(v2, false); + storage.store(h2); + + IResourceStorage.IHistoryResource latest = storage.readHistoryLatest(id); + assertNotNull(latest); + assertEquals(2, latest.getVersion()); + } + + @Test + @DisplayName("readHistoryLatest non-existent — returns null") + void readHistoryLatestNonExistent() { + assertNull(storage.readHistoryLatest(new ObjectId().toString())); + } + + @Test + @DisplayName("findResourceIdsContaining — searches by JSON path") + void findResourceIds() throws IOException { + storage.store(storage.newResource(Map.of("tags", java.util.List.of("ai", "chatbot")))); + storage.store(storage.newResource(Map.of("tags", java.util.List.of("web")))); + + java.util.List results = + storage.findResourceIdsContaining("tags", "ai"); + assertEquals(1, results.size()); + } +} diff --git a/src/test/java/ai/labs/eddi/datastore/mongo/MongoScheduleStoreIT.java b/src/test/java/ai/labs/eddi/datastore/mongo/MongoScheduleStoreIT.java new file mode 100644 index 000000000..dad3801df --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/mongo/MongoScheduleStoreIT.java @@ -0,0 +1,341 @@ +package ai.labs.eddi.datastore.mongo; + +import ai.labs.eddi.datastore.IResourceStore; +import ai.labs.eddi.engine.schedule.model.ScheduleConfiguration; +import ai.labs.eddi.engine.schedule.model.ScheduleConfiguration.FireStatus; +import ai.labs.eddi.engine.schedule.model.ScheduleFireLog; +import ai.labs.eddi.engine.schedule.mongo.MongoScheduleStore; +import org.junit.jupiter.api.*; + +import java.time.Instant; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link MongoScheduleStore} using Testcontainers. + * + * @since 6.0.0 + */ +@DisplayName("MongoScheduleStore IT") +class MongoScheduleStoreIT extends MongoTestBase { + + private static MongoScheduleStore store; + + @BeforeAll + static void init() { + store = new MongoScheduleStore(getDatabase(), jsonSerialization, documentBuilder); + } + + @BeforeEach + void clean() { + dropCollections("eddi_schedules", "eddi_schedule_fire_logs"); + } + + // ─── CRUD ─────────────────────────────────────────────────── + + @Nested + @DisplayName("CRUD") + class Crud { + + @Test + @DisplayName("create + read round-trip") + void createAndRead() throws Exception { + var cfg = newSchedule("Test Schedule", "agent-1"); + String id = store.createSchedule(cfg); + assertNotNull(id); + + var read = store.readSchedule(id); + assertEquals("Test Schedule", read.getName()); + assertEquals("agent-1", read.getAgentId()); + } + + @Test + @DisplayName("read non-existent — throws ResourceNotFoundException") + void readNotFound() { + assertThrows(IResourceStore.ResourceNotFoundException.class, + () -> store.readSchedule("no-such-id")); + } + + @Test + @DisplayName("update schedule") + void update() throws Exception { + var cfg = newSchedule("Original", "agent-1"); + String id = store.createSchedule(cfg); + + cfg.setName("Updated"); + store.updateSchedule(id, cfg); + + assertEquals("Updated", store.readSchedule(id).getName()); + } + + @Test + @DisplayName("update non-existent — throws ResourceNotFoundException") + void updateNotFound() { + assertThrows(IResourceStore.ResourceNotFoundException.class, + () -> store.updateSchedule("ghost", newSchedule("x", "a"))); + } + + @Test + @DisplayName("delete schedule") + void delete() throws Exception { + String id = store.createSchedule(newSchedule("Del", "a")); + store.deleteSchedule(id); + assertThrows(IResourceStore.ResourceNotFoundException.class, + () -> store.readSchedule(id)); + } + + @Test + @DisplayName("deleteByAgentId — cascade") + void deleteByAgent() throws Exception { + store.createSchedule(newSchedule("S1", "agent-x")); + store.createSchedule(newSchedule("S2", "agent-x")); + store.createSchedule(newSchedule("S3", "agent-y")); + + int deleted = store.deleteSchedulesByAgentId("agent-x"); + assertEquals(2, deleted); + assertEquals(1, store.readAllSchedules(100).size()); + } + } + + // ─── List Queries ─────────────────────────────────────────── + + @Nested + @DisplayName("List Queries") + class ListQueries { + + @Test + @DisplayName("readAllSchedules with limit") + void readAll() throws Exception { + for (int i = 0; i < 5; i++) { + store.createSchedule(newSchedule("S" + i, "a")); + } + assertEquals(3, store.readAllSchedules(3).size()); + assertEquals(5, store.readAllSchedules(100).size()); + } + + @Test + @DisplayName("readSchedulesByAgentId") + void readByAgent() throws Exception { + store.createSchedule(newSchedule("S1", "a1")); + store.createSchedule(newSchedule("S2", "a1")); + store.createSchedule(newSchedule("S3", "a2")); + + assertEquals(2, store.readSchedulesByAgentId("a1").size()); + } + } + + // ─── Claiming & State ─────────────────────────────────────── + + @Nested + @DisplayName("Claiming and State") + class ClaimingAndState { + + @Test + @DisplayName("tryClaim PENDING schedule — succeeds") + void claimPending() throws Exception { + var cfg = newSchedule("Claimable", "a"); + cfg.setEnabled(true); + cfg.setNextFire(Instant.now().minusSeconds(60)); + cfg.setFireStatus(FireStatus.PENDING); + String id = store.createSchedule(cfg); + + assertTrue(store.tryClaim(id, "node-1", Instant.now())); + assertEquals(FireStatus.CLAIMED, store.readSchedule(id).getFireStatus()); + } + + @Test + @DisplayName("double-claim — second claim fails") + void doubleClaim() throws Exception { + var cfg = newSchedule("Claimable", "a"); + cfg.setEnabled(true); + cfg.setNextFire(Instant.now().minusSeconds(60)); + cfg.setFireStatus(FireStatus.PENDING); + String id = store.createSchedule(cfg); + + assertTrue(store.tryClaim(id, "node-1", Instant.now())); + assertFalse(store.tryClaim(id, "node-2", Instant.now())); + } + + @Test + @DisplayName("markCompleted — resets to PENDING with nextFire") + void markCompleted() throws Exception { + var cfg = newSchedule("Complete", "a"); + cfg.setEnabled(true); + cfg.setFireStatus(FireStatus.CLAIMED); + String id = store.createSchedule(cfg); + + Instant next = Instant.now().plusSeconds(3600); + store.markCompleted(id, next); + + var read = store.readSchedule(id); + assertEquals(FireStatus.PENDING, read.getFireStatus()); + } + + @Test + @DisplayName("markCompleted null nextFire — disables schedule") + void markCompletedOneShot() throws Exception { + var cfg = newSchedule("OneShot", "a"); + cfg.setEnabled(true); + cfg.setFireStatus(FireStatus.CLAIMED); + String id = store.createSchedule(cfg); + + store.markCompleted(id, null); + assertFalse(store.readSchedule(id).isEnabled()); + } + + @Test + @DisplayName("markFailed — increments failCount") + void markFailed() throws Exception { + var cfg = newSchedule("Fail", "a"); + cfg.setFireStatus(FireStatus.CLAIMED); + String id = store.createSchedule(cfg); + + store.markFailed(id, Instant.now().plusSeconds(300)); + var read = store.readSchedule(id); + assertEquals(FireStatus.FAILED, read.getFireStatus()); + assertEquals(1, read.getFailCount()); + } + + @Test + @DisplayName("markDeadLettered — sets DEAD_LETTERED") + void markDeadLettered() throws Exception { + var cfg = newSchedule("DL", "a"); + cfg.setFireStatus(FireStatus.FAILED); + String id = store.createSchedule(cfg); + + store.markDeadLettered(id); + assertEquals(FireStatus.DEAD_LETTERED, store.readSchedule(id).getFireStatus()); + } + + @Test + @DisplayName("requeueDeadLetter — resets to PENDING") + void requeueDeadLetter() throws Exception { + var cfg = newSchedule("Requeue", "a"); + cfg.setFireStatus(FireStatus.DEAD_LETTERED); + String id = store.createSchedule(cfg); + // Need to set status via markDeadLettered since createSchedule may not persist fireStatus directly + store.markDeadLettered(id); + + store.requeueDeadLetter(id); + var read = store.readSchedule(id); + assertEquals(FireStatus.PENDING, read.getFireStatus()); + assertEquals(0, read.getFailCount()); + } + + @Test + @DisplayName("requeueDeadLetter non-DL — throws ResourceNotFoundException") + void requeueNonDl() throws Exception { + var cfg = newSchedule("NotDL", "a"); + cfg.setFireStatus(FireStatus.PENDING); + String id = store.createSchedule(cfg); + + assertThrows(IResourceStore.ResourceNotFoundException.class, + () -> store.requeueDeadLetter(id)); + } + } + + // ─── Enable/Disable ───────────────────────────────────────── + + @Nested + @DisplayName("Enable/Disable") + class EnableDisable { + + @Test + @DisplayName("setScheduleEnabled true — sets nextFire and resets to PENDING") + void enable() throws Exception { + var cfg = newSchedule("Disabled", "a"); + cfg.setEnabled(false); + String id = store.createSchedule(cfg); + + Instant nextFire = Instant.now().plusSeconds(3600); + store.setScheduleEnabled(id, true, nextFire); + + var read = store.readSchedule(id); + assertTrue(read.isEnabled()); + assertEquals(FireStatus.PENDING, read.getFireStatus()); + } + + @Test + @DisplayName("setScheduleEnabled non-existent — throws ResourceNotFoundException") + void enableNotFound() { + assertThrows(IResourceStore.ResourceNotFoundException.class, + () -> store.setScheduleEnabled("ghost", true, Instant.now())); + } + } + + // ─── Fire Logs ────────────────────────────────────────────── + + @Nested + @DisplayName("Fire Logs") + class FireLogs { + + @Test + @DisplayName("logFire + readFireLogs") + void logAndRead() throws Exception { + var log = new ScheduleFireLog("fire-1", "sched-1", "fire-key-1", + Instant.now(), Instant.now(), Instant.now(), + "COMPLETED", "node-1", "conv-1", null, 1, 0.0); + store.logFire(log); + + List logs = store.readFireLogs("sched-1", 10); + assertEquals(1, logs.size()); + assertEquals("fire-1", logs.getFirst().id()); + } + + @Test + @DisplayName("readFailedFireLogs — filters FAILED + DEAD_LETTERED") + void readFailed() throws Exception { + store.logFire(new ScheduleFireLog("f1", "s1", "fk1", + Instant.now(), Instant.now(), Instant.now(), + "COMPLETED", "n1", "c1", null, 1, 0.0)); + store.logFire(new ScheduleFireLog("f2", "s1", "fk2", + Instant.now(), Instant.now(), Instant.now(), + "FAILED", "n1", "c2", "error msg", 1, 0.0)); + store.logFire(new ScheduleFireLog("f3", "s1", "fk3", + Instant.now(), Instant.now(), Instant.now(), + "DEAD_LETTERED", "n1", "c3", "max retries", 3, 0.0)); + + List failed = store.readFailedFireLogs(10); + assertEquals(2, failed.size()); + } + } + + // ─── findDueSchedules ─────────────────────────────────────── + + @Nested + @DisplayName("Due Schedules") + class DueSchedules { + + @Test + @DisplayName("findDueSchedules — returns enabled PENDING past nextFire") + void findDue() throws Exception { + // This schedule IS due: enabled, PENDING, nextFire in the past + var due = newSchedule("Due", "a"); + due.setEnabled(true); + due.setNextFire(Instant.now().minusSeconds(60)); + due.setFireStatus(FireStatus.PENDING); + store.createSchedule(due); + + List dueList = store.findDueSchedules( + Instant.now(), Instant.now().minusSeconds(300), 3); + + assertFalse(dueList.isEmpty(), "Expected at least one due schedule"); + assertTrue(dueList.stream().anyMatch(s -> "Due".equals(s.getName())), + "Expected 'Due' schedule in results"); + } + } + + // ─── Helpers ──────────────────────────────────────────────── + + private static ScheduleConfiguration newSchedule(String name, String agentId) { + var cfg = new ScheduleConfiguration(); + cfg.setName(name); + cfg.setAgentId(agentId); + cfg.setEnabled(false); + cfg.setFireStatus(FireStatus.PENDING); + cfg.setTriggerType(ScheduleConfiguration.TriggerType.CRON); + cfg.setCronExpression("0 0 * * * ?"); + return cfg; + } +} diff --git a/src/test/java/ai/labs/eddi/datastore/mongo/MongoSecretPersistenceIT.java b/src/test/java/ai/labs/eddi/datastore/mongo/MongoSecretPersistenceIT.java new file mode 100644 index 000000000..c6d5e1610 --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/mongo/MongoSecretPersistenceIT.java @@ -0,0 +1,175 @@ +package ai.labs.eddi.datastore.mongo; + +import ai.labs.eddi.secrets.model.EncryptedDek; +import ai.labs.eddi.secrets.model.EncryptedSecret; +import ai.labs.eddi.secrets.persistence.MongoSecretPersistence; +import org.junit.jupiter.api.*; + +import java.time.Instant; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link MongoSecretPersistence} using Testcontainers. + * + * @since 6.0.0 + */ +@DisplayName("MongoSecretPersistence IT") +class MongoSecretPersistenceIT extends MongoTestBase { + + private static MongoSecretPersistence persistence; + + @BeforeAll + static void init() { + persistence = new MongoSecretPersistence(getDatabase()); + } + + @BeforeEach + void clean() { + dropCollections("secretvault_secrets", "secretvault_deks", "secretvault_meta"); + } + + // ─── Secrets ──────────────────────────────────────────────── + + @Nested + @DisplayName("Secrets CRUD") + class Secrets { + + @Test + @DisplayName("upsert + find round-trip") + void upsertAndFind() { + var secret = createSecret("tenant1", "api_key", "encrypted-val", "iv-data", "dek1"); + persistence.upsertSecret(secret); + + var found = persistence.findSecret("tenant1", "api_key"); + assertTrue(found.isPresent()); + assertEquals("encrypted-val", found.get().getEncryptedValue()); + } + + @Test + @DisplayName("find non-existent — returns empty") + void findNonExistent() { + assertTrue(persistence.findSecret("ghost", "key").isEmpty()); + } + + @Test + @DisplayName("upsert existing — updates value") + void upsertExisting() { + persistence.upsertSecret(createSecret("t1", "k1", "v1", "iv", "d1")); + persistence.upsertSecret(createSecret("t1", "k1", "v2", "iv2", "d1")); + + var found = persistence.findSecret("t1", "k1"); + assertEquals("v2", found.get().getEncryptedValue()); + } + + @Test + @DisplayName("deleteSecret — removes and returns true") + void delete() { + persistence.upsertSecret(createSecret("t1", "k1", "v", "iv", "d1")); + assertTrue(persistence.deleteSecret("t1", "k1")); + assertTrue(persistence.findSecret("t1", "k1").isEmpty()); + } + + @Test + @DisplayName("deleteSecret non-existent — returns false") + void deleteNonExistent() { + assertFalse(persistence.deleteSecret("ghost", "key")); + } + + @Test + @DisplayName("listSecretsByTenant — filters by tenant") + void listByTenant() { + persistence.upsertSecret(createSecret("t1", "k1", "v1", "iv", "d1")); + persistence.upsertSecret(createSecret("t1", "k2", "v2", "iv", "d1")); + persistence.upsertSecret(createSecret("t2", "k3", "v3", "iv", "d2")); + + assertEquals(2, persistence.listSecretsByTenant("t1").size()); + assertEquals(1, persistence.listSecretsByTenant("t2").size()); + } + } + + // ─── DEKs ─────────────────────────────────────────────────── + + @Nested + @DisplayName("DEK CRUD") + class Deks { + + @Test + @DisplayName("upsert + find DEK round-trip") + void upsertAndFind() { + var dek = new EncryptedDek(null, "tenant1", "enc-dek-data", "dek-iv", Instant.now()); + persistence.upsertDek(dek); + + var found = persistence.findDek("tenant1"); + assertTrue(found.isPresent()); + assertEquals("enc-dek-data", found.get().getEncryptedDek()); + } + + @Test + @DisplayName("find DEK non-existent — returns empty") + void findNonExistent() { + assertTrue(persistence.findDek("ghost").isEmpty()); + } + + @Test + @DisplayName("delete DEK") + void deleteDek() { + persistence.upsertDek(new EncryptedDek(null, "t1", "enc", "iv", Instant.now())); + persistence.deleteDek("t1"); + assertTrue(persistence.findDek("t1").isEmpty()); + } + + @Test + @DisplayName("listAllDeks — returns all") + void listAll() { + persistence.upsertDek(new EncryptedDek(null, "t1", "e1", "iv1", Instant.now())); + persistence.upsertDek(new EncryptedDek(null, "t2", "e2", "iv2", Instant.now())); + + assertEquals(2, persistence.listAllDeks().size()); + } + } + + // ─── Metadata ─────────────────────────────────────────────── + + @Nested + @DisplayName("Metadata") + class Meta { + + @Test + @DisplayName("set + get meta value") + void setAndGet() { + persistence.setMetaValue("vault.salt", "random-salt"); + assertEquals("random-salt", persistence.getMetaValue("vault.salt")); + } + + @Test + @DisplayName("get non-existent — returns null") + void getNonExistent() { + assertNull(persistence.getMetaValue("nonexistent")); + } + + @Test + @DisplayName("set meta value — upsert on conflict") + void upsertMeta() { + persistence.setMetaValue("key", "v1"); + persistence.setMetaValue("key", "v2"); + assertEquals("v2", persistence.getMetaValue("key")); + } + } + + // ─── Helpers ──────────────────────────────────────────────── + + private static EncryptedSecret createSecret(String tenant, String key, + String value, String iv, String dekId) { + var secret = new EncryptedSecret(); + secret.setTenantId(tenant); + secret.setKeyName(key); + secret.setEncryptedValue(value); + secret.setIv(iv); + secret.setDekId(dekId); + secret.setCreatedAt(Instant.now()); + secret.setAllowedAgents(List.of("*")); + return secret; + } +} diff --git a/src/test/java/ai/labs/eddi/datastore/mongo/MongoTestBase.java b/src/test/java/ai/labs/eddi/datastore/mongo/MongoTestBase.java new file mode 100644 index 000000000..6ab0aa556 --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/mongo/MongoTestBase.java @@ -0,0 +1,67 @@ +package ai.labs.eddi.datastore.mongo; + +import ai.labs.eddi.datastore.serialization.DocumentBuilder; +import ai.labs.eddi.datastore.serialization.IDocumentBuilder; +import ai.labs.eddi.datastore.serialization.IJsonSerialization; +import ai.labs.eddi.datastore.serialization.JsonSerialization; +import ai.labs.eddi.datastore.serialization.SerializationCustomizer; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule; +import com.mongodb.client.MongoClient; +import com.mongodb.client.MongoClients; +import com.mongodb.client.MongoDatabase; +import org.junit.jupiter.api.BeforeAll; +import org.testcontainers.containers.MongoDBContainer; +import org.testcontainers.junit.jupiter.Container; +import org.testcontainers.junit.jupiter.Testcontainers; + +/** + * Shared Testcontainers base for MongoDB adapter integration tests. + *

+ * Provides a single {@link MongoDBContainer} (mongo:6.0) shared across all + * subclasses. Each test class gets its own {@link MongoDatabase} via + * {@link #getDatabase()}. + * + * @since 6.0.0 + */ +@Testcontainers +public abstract class MongoTestBase { + + private static final String DB_NAME = "eddi_test"; + + @Container + static final MongoDBContainer MONGO = new MongoDBContainer("mongo:6.0"); + + protected static MongoClient mongoClient; + protected static MongoDatabase database; + protected static ObjectMapper objectMapper; + protected static IJsonSerialization jsonSerialization; + protected static IDocumentBuilder documentBuilder; + + @BeforeAll + static void initMongo() { + mongoClient = MongoClients.create(MONGO.getConnectionString()); + database = mongoClient.getDatabase(DB_NAME); + + // Configure ObjectMapper to match Quarkus production settings + objectMapper = new ObjectMapper(); + objectMapper.registerModule(new JavaTimeModule()); + SerializationCustomizer.configureObjectMapper(objectMapper, false); + + jsonSerialization = new JsonSerialization(objectMapper); + documentBuilder = new DocumentBuilder(jsonSerialization); + } + + protected static MongoDatabase getDatabase() { + return database; + } + + /** + * Drop all documents from the named collections for test isolation. + */ + protected static void dropCollections(String... collectionNames) { + for (String name : collectionNames) { + database.getCollection(name).drop(); + } + } +} diff --git a/src/test/java/ai/labs/eddi/datastore/mongo/MongoUserMemoryStoreIT.java b/src/test/java/ai/labs/eddi/datastore/mongo/MongoUserMemoryStoreIT.java new file mode 100644 index 000000000..f34df5516 --- /dev/null +++ b/src/test/java/ai/labs/eddi/datastore/mongo/MongoUserMemoryStoreIT.java @@ -0,0 +1,234 @@ +package ai.labs.eddi.datastore.mongo; + +import ai.labs.eddi.configs.properties.model.Properties; +import ai.labs.eddi.configs.properties.model.Property.Visibility; +import ai.labs.eddi.configs.properties.model.UserMemoryEntry; +import ai.labs.eddi.configs.properties.mongo.MongoUserMemoryStore; +import ai.labs.eddi.datastore.IResourceStore; +import org.junit.jupiter.api.*; + +import java.util.List; +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for {@link MongoUserMemoryStore} using Testcontainers. + * + * @since 6.0.0 + */ +@DisplayName("MongoUserMemoryStore IT") +class MongoUserMemoryStoreIT extends MongoTestBase { + + private static MongoUserMemoryStore store; + + @BeforeAll + static void init() { + store = new MongoUserMemoryStore(getDatabase()); + } + + @BeforeEach + void clean() { + dropCollections("usermemories"); + } + + // ─── Flat Properties ──────────────────────────────────────── + + @Nested + @DisplayName("Flat Properties") + class FlatProperties { + + @Test + @DisplayName("mergeProperties + readProperties round-trip") + void mergeAndRead() throws IResourceStore.ResourceStoreException { + var props = new Properties(); + props.put("language", "en"); + props.put("timezone", "UTC"); + store.mergeProperties("user-1", props); + + Properties read = store.readProperties("user-1"); + assertNotNull(read); + assertEquals("en", read.get("language")); + assertEquals("UTC", read.get("timezone")); + } + + @Test + @DisplayName("readProperties non-existent — returns null") + void readNonExistent() throws IResourceStore.ResourceStoreException { + assertNull(store.readProperties("ghost")); + } + + @Test + @DisplayName("mergeProperties — upserts existing keys") + void upsertExisting() throws IResourceStore.ResourceStoreException { + var initial = new Properties(); + initial.put("lang", "en"); + store.mergeProperties("user-1", initial); + + var update = new Properties(); + update.put("lang", "de"); + store.mergeProperties("user-1", update); + + assertEquals("de", store.readProperties("user-1").get("lang")); + } + + @Test + @DisplayName("mergeProperties empty — no-op") + void mergeEmpty() throws IResourceStore.ResourceStoreException { + store.mergeProperties("user-1", new Properties()); + assertNull(store.readProperties("user-1")); + } + + @Test + @DisplayName("deleteProperties — removes all global entries") + void deleteProps() throws IResourceStore.ResourceStoreException { + var props = new Properties(); + props.put("key", "val"); + store.mergeProperties("user-1", props); + + store.deleteProperties("user-1"); + assertNull(store.readProperties("user-1")); + } + } + + // ─── Structured Entries ───────────────────────────────────── + + @Nested + @DisplayName("Structured Entries") + class StructuredEntries { + + @Test + @DisplayName("upsert + getByKey round-trip") + void upsertAndGet() throws IResourceStore.ResourceStoreException { + var entry = new UserMemoryEntry(null, "user-1", "pref", "dark-mode", + "preferences", Visibility.self, "agent-1", List.of(), null, + false, 0, null, null); + + String id = store.upsert(entry); + assertNotNull(id); + + Optional found = store.getByKey("user-1", "pref"); + assertTrue(found.isPresent()); + assertEquals("dark-mode", found.get().value()); + } + + @Test + @DisplayName("upsert — updates existing value") + void upsertUpdate() throws IResourceStore.ResourceStoreException { + var entry1 = new UserMemoryEntry(null, "user-1", "k1", "v1", + "cat", Visibility.self, "agent-1", List.of(), null, + false, 0, null, null); + store.upsert(entry1); + + var entry2 = new UserMemoryEntry(null, "user-1", "k1", "v2", + "cat", Visibility.self, "agent-1", List.of(), null, + false, 0, null, null); + store.upsert(entry2); + + assertEquals("v2", store.getByKey("user-1", "k1").orElseThrow().value()); + } + + @Test + @DisplayName("deleteEntry — removes by ID") + void deleteEntry() throws IResourceStore.ResourceStoreException { + var entry = new UserMemoryEntry(null, "user-1", "del-key", "val", + "cat", Visibility.self, "agent-1", List.of(), null, + false, 0, null, null); + String id = store.upsert(entry); + + store.deleteEntry(id); + assertTrue(store.getByKey("user-1", "del-key").isEmpty()); + } + + @Test + @DisplayName("getAllEntries — returns all for user") + void getAll() throws IResourceStore.ResourceStoreException { + store.upsert(entry("user-1", "k1", "v1")); + store.upsert(entry("user-1", "k2", "v2")); + store.upsert(entry("user-2", "k3", "v3")); + + assertEquals(2, store.getAllEntries("user-1").size()); + } + } + + // ─── Queries ──────────────────────────────────────────────── + + @Nested + @DisplayName("Queries") + class Queries { + + @Test + @DisplayName("getEntriesByCategory") + void byCategory() throws IResourceStore.ResourceStoreException { + store.upsert(entry("user-1", "k1", "v1", "preferences")); + store.upsert(entry("user-1", "k2", "v2", "facts")); + + assertEquals(1, store.getEntriesByCategory("user-1", "preferences").size()); + } + + @Test + @DisplayName("filterEntries — regex search on key/value") + void filter() throws IResourceStore.ResourceStoreException { + store.upsert(entry("user-1", "favorite_color", "blue")); + store.upsert(entry("user-1", "favorite_food", "pizza")); + store.upsert(entry("user-1", "age", "25")); + + List results = store.filterEntries("user-1", "favorite"); + assertEquals(2, results.size()); + } + + @Test + @DisplayName("getVisibleEntries — self visibility") + void visibleSelf() throws IResourceStore.ResourceStoreException { + store.upsert(new UserMemoryEntry(null, "user-1", "self-key", "self-val", + "cat", Visibility.self, "agent-A", List.of(), null, + false, 0, null, null)); + store.upsert(new UserMemoryEntry(null, "user-1", "other-key", "other-val", + "cat", Visibility.self, "agent-B", List.of(), null, + false, 0, null, null)); + + List visible = store.getVisibleEntries( + "user-1", "agent-A", List.of(), "most_recent", 100); + assertTrue(visible.stream().anyMatch(e -> "self-key".equals(e.key()))); + assertTrue(visible.stream().noneMatch(e -> "other-key".equals(e.key()))); + } + + @Test + @DisplayName("countEntries") + void count() throws IResourceStore.ResourceStoreException { + store.upsert(entry("user-1", "k1", "v1")); + store.upsert(entry("user-1", "k2", "v2")); + + assertEquals(2, store.countEntries("user-1")); + assertEquals(0, store.countEntries("ghost")); + } + } + + // ─── GDPR ─────────────────────────────────────────────────── + + @Nested + @DisplayName("GDPR") + class Gdpr { + + @Test + @DisplayName("deleteAllForUser — removes all entries") + void deleteAll() throws IResourceStore.ResourceStoreException { + store.upsert(entry("user-gdpr", "k1", "v1")); + store.upsert(entry("user-gdpr", "k2", "v2")); + + store.deleteAllForUser("user-gdpr"); + assertEquals(0, store.countEntries("user-gdpr")); + } + } + + // ─── Helpers ──────────────────────────────────────────────── + + private static UserMemoryEntry entry(String userId, String key, String value) { + return entry(userId, key, value, "general"); + } + + private static UserMemoryEntry entry(String userId, String key, String value, String category) { + return new UserMemoryEntry(null, userId, key, value, category, + Visibility.self, "agent-test", List.of(), null, false, 0, null, null); + } +} From 608912a9260a1d91022bd3f4d41c6e4e4faec45e Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 22:55:01 +0200 Subject: [PATCH 048/124] fix(jacoco): add quarkus-jacoco extension and include jacoco-quarkus.exec in merged report --- pom.xml | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/pom.xml b/pom.xml index 6b9271bd9..258ef1878 100644 --- a/pom.xml +++ b/pom.xml @@ -343,6 +343,14 @@ quarkus-junit test + + + io.quarkus + quarkus-jacoco + test + io.rest-assured rest-assured @@ -514,6 +522,10 @@ **/*IT.java + @@ -636,6 +648,7 @@ jacoco.exec jacoco-it.exec + jacoco-quarkus.exec From 317b31701cec3b4226653b4d9cf1cff2c41e709c Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 23:29:39 +0200 Subject: [PATCH 049/124] docs: update changelog with MongoDB adapter ITs and JaCoCo coverage fix --- docs/changelog.md | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/docs/changelog.md b/docs/changelog.md index b4bffe64a..cad39b49c 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -13,6 +13,38 @@ Each entry follows this format: - **Decision** — Key design decisions and their reasoning - **Files** — Links to modified files +## MongoDB Adapter ITs + JaCoCo Coverage Fix (2026-04-20) + +**Repo:** EDDI (`test/coverage-tier-1-2`) + +**What changed:** Added comprehensive Testcontainers-based integration tests for ALL MongoDB adapter stores (75 tests, 6 test classes). Fixed JaCoCo coverage merging by adding `quarkus-jacoco` extension and including `jacoco-quarkus.exec` in the merged report. + +### MongoDB Adapter ITs (75 tests) +- **MongoTestBase** — Shared Testcontainers base (mongo:6.0) with production-matching ObjectMapper config +- **MongoScheduleStoreIT** (21 tests): CRUD, atomic claiming, double-claim rejection, state transitions (PENDING→CLAIMED→COMPLETED/FAILED→DEAD_LETTERED), requeue, enable/disable, fire logs, due-schedule filtering +- **MongoSecretPersistenceIT** (13 tests): Secrets CRUD (upsert, find, delete, list by tenant), DEK CRUD (upsert, find, delete, list all), metadata (get/set, upsert) +- **MongoDeploymentStorageIT** (5 tests): CRUD with upsert, list all, filter by deployment status +- **MongoAttachmentStorageIT** (7 tests): GridFS binary round-trip, null filename handling, not-found/invalid/null ref, cascade delete by conversation +- **MongoUserMemoryStoreIT** (14 tests): Flat properties CRUD, structured entry operations, visibility/category/filter queries, count, GDPR deletion +- **MongoResourceStorageIT** (15 tests): CRUD, upsert, versioning, history resources, deleted flag, permanent removal, find-by-json-path + +### JaCoCo Coverage Fix +- **Added `quarkus-jacoco` test dependency** — Quarkus-native JaCoCo instrumentation that writes coverage data from within the Quarkus classloader, bypassing the Windows JaCoCo agent path quoting issue +- **Added `jacoco-quarkus.exec` to merge step** — Ensures @QuarkusTest IT coverage is included in the merged report +- **Documented Windows limitation** — On Windows, the standard JaCoCo agent path with backslashes breaks the Quarkus FacadeClassLoader; `quarkus-jacoco` is the workaround + +**Decision:** The `@QuarkusTest` ITs (33 existing test classes, 250+ tests) exercise all REST endpoints but their coverage was invisible because the JaCoCo agent couldn't attach. The `quarkus-jacoco` extension fixes this. + +**Files (new):** +- `MongoTestBase.java`, `MongoScheduleStoreIT.java`, `MongoSecretPersistenceIT.java` +- `MongoDeploymentStorageIT.java`, `MongoAttachmentStorageIT.java` +- `MongoUserMemoryStoreIT.java`, `MongoResourceStorageIT.java` + +**Files (modified):** +- `pom.xml` — Added `quarkus-jacoco` dep, added `jacoco-quarkus.exec` to merge includes, documented Windows limitation + +--- + ## Integration Test Expansion — Batches 6-7: Full Postgres Adapter Coverage (2026-04-20) **Repo:** EDDI (`test/coverage-tier-1-2`) From 31fe80a48fbb5a3519d106dd27e0bfe7bfd5536e Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 23:36:31 +0200 Subject: [PATCH 050/124] refactor(test): code review fixes + CI coverage summary - MongoTestBase: add @AfterAll to close MongoClient (connection pool leak) - MongoUserMemoryStoreIT: strengthen visibility test to cover global entries - MongoResourceStorageIT: fix inconsistent java.util.List imports - ci.yml: add coverage summary tables to GITHUB_STEP_SUMMARY - ci.yml: upload merged coverage report from integration-test job --- .github/workflows/ci.yml | 86 +++++++++++++++++++ .../mongo/MongoAttachmentStorageIT.java | 3 +- .../mongo/MongoResourceStorageIT.java | 7 +- .../datastore/mongo/MongoScheduleStoreIT.java | 3 +- .../mongo/MongoSecretPersistenceIT.java | 2 +- .../eddi/datastore/mongo/MongoTestBase.java | 8 ++ .../mongo/MongoUserMemoryStoreIT.java | 16 +++- 7 files changed, 116 insertions(+), 9 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 1094e5ec2..735e62317 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -93,6 +93,41 @@ jobs: path: target/site/jacoco/ retention-days: 14 + - name: Coverage summary + if: always() + run: | + CSV="target/site/jacoco/jacoco.csv" + if [ ! -f "$CSV" ]; then + echo "### ⚠️ No coverage report found" >> $GITHUB_STEP_SUMMARY + exit 0 + fi + + # Parse JaCoCo CSV columns: + # $6=BRANCH_MISSED, $7=BRANCH_COVERED, $8=LINE_MISSED, $9=LINE_COVERED, + # $12=METHOD_MISSED, $13=METHOD_COVERED + read LM LC BM BC MM MC <<< $(awk -F',' 'NR>1 { + lm+=$8; lc+=$9; bm+=$6; bc+=$7; mm+=$12; mc+=$13 + } END { + print lm, lc, bm, bc, mm, mc + }' "$CSV") + + pct() { [ $(($1+$2)) -gt 0 ] && awk "BEGIN {printf \"%.1f\", ($2/($1+$2))*100}" || echo "0.0"; } + icon() { local p=$(echo "$1" | awk '{printf "%d", $1}'); [ $p -ge 90 ] && echo "🟢" || { [ $p -ge 80 ] && echo "🟡" || echo "🔴"; }; } + + LINE_PCT=$(pct $LM $LC) + BRANCH_PCT=$(pct $BM $BC) + + # Count tests from surefire reports (match only /dev/null | sed 's/.*tests="\([0-9]*\)".*/\1/' | awk '{s+=$1} END {print s+0}') + + echo "### 📊 Unit Test Coverage ($TOTAL_TESTS tests)" >> $GITHUB_STEP_SUMMARY + echo "| Metric | Covered | Total | Percentage | |" >> $GITHUB_STEP_SUMMARY + echo "|--------|---------|-------|------------|---|" >> $GITHUB_STEP_SUMMARY + echo "| Line | $LC | $((LM+LC)) | **${LINE_PCT}%** | $(icon $LINE_PCT) |" >> $GITHUB_STEP_SUMMARY + echo "| Branch | $BC | $((BM+BC)) | **${BRANCH_PCT}%** | $(icon $BRANCH_PCT) |" >> $GITHUB_STEP_SUMMARY + echo "" >> $GITHUB_STEP_SUMMARY + echo "> ℹ️ Unit tests only. See **Integration Tests** job for merged UT+IT coverage." >> $GITHUB_STEP_SUMMARY + # ─── Job 2: Integration Tests ───────────────────────────────── integration-test: name: Integration Tests @@ -133,6 +168,57 @@ jobs: path: target/site/jacoco-it/ retention-days: 14 + - name: Upload merged coverage report + if: always() + uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7 + with: + name: jacoco-merged-report + path: target/site/jacoco-merged/ + retention-days: 14 + + - name: Merged coverage summary + if: always() + run: | + # Prefer merged report; fall back to UT-only + CSV="target/site/jacoco-merged/jacoco.csv" + LABEL="Merged Coverage (UT + IT)" + if [ ! -f "$CSV" ]; then + CSV="target/site/jacoco/jacoco.csv" + LABEL="Coverage (UT only — merged report unavailable)" + fi + if [ ! -f "$CSV" ]; then + echo "### ⚠️ No coverage report found" >> $GITHUB_STEP_SUMMARY + exit 0 + fi + + # Parse JaCoCo CSV columns: + # $6=BRANCH_MISSED, $7=BRANCH_COVERED, $8=LINE_MISSED, $9=LINE_COVERED, + # $12=METHOD_MISSED, $13=METHOD_COVERED + read LM LC BM BC MM MC <<< $(awk -F',' 'NR>1 { + lm+=$8; lc+=$9; bm+=$6; bc+=$7; mm+=$12; mc+=$13 + } END { + print lm, lc, bm, bc, mm, mc + }' "$CSV") + + pct() { [ $(($1+$2)) -gt 0 ] && awk "BEGIN {printf \"%.1f\", ($2/($1+$2))*100}" || echo "0.0"; } + icon() { local p=$(echo "$1" | awk '{printf "%d", $1}'); [ $p -ge 90 ] && echo "🟢" || { [ $p -ge 80 ] && echo "🟡" || echo "🔴"; }; } + + LINE_PCT=$(pct $LM $LC) + BRANCH_PCT=$(pct $BM $BC) + METHOD_PCT=$(pct $MM $MC) + + # Count tests from surefire + failsafe reports (match only /dev/null | sed 's/.*tests="\([0-9]*\)".*/\1/' | awk '{s+=$1} END {print s+0}') + IT_COUNT=$(grep -rh '/dev/null | sed 's/.*tests="\([0-9]*\)".*/\1/' | awk '{s+=$1} END {print s+0}') + TOTAL=$((UT_COUNT + IT_COUNT)) + + echo "### 📊 ${LABEL} ($TOTAL tests: $UT_COUNT UT + $IT_COUNT IT)" >> $GITHUB_STEP_SUMMARY + echo "| Metric | Covered | Total | Percentage | |" >> $GITHUB_STEP_SUMMARY + echo "|--------|---------|-------|------------|---|" >> $GITHUB_STEP_SUMMARY + echo "| Line | $LC | $((LM+LC)) | **${LINE_PCT}%** | $(icon $LINE_PCT) |" >> $GITHUB_STEP_SUMMARY + echo "| Branch | $BC | $((BM+BC)) | **${BRANCH_PCT}%** | $(icon $BRANCH_PCT) |" >> $GITHUB_STEP_SUMMARY + echo "| Method | $MC | $((MM+MC)) | **${METHOD_PCT}%** | $(icon $METHOD_PCT) |" >> $GITHUB_STEP_SUMMARY + # ─── Job 2b: CodeQL SAST ─────────────────────────────────────── codeql: name: CodeQL Analysis diff --git a/src/test/java/ai/labs/eddi/datastore/mongo/MongoAttachmentStorageIT.java b/src/test/java/ai/labs/eddi/datastore/mongo/MongoAttachmentStorageIT.java index 43c933562..fc156523f 100644 --- a/src/test/java/ai/labs/eddi/datastore/mongo/MongoAttachmentStorageIT.java +++ b/src/test/java/ai/labs/eddi/datastore/mongo/MongoAttachmentStorageIT.java @@ -12,7 +12,8 @@ import static org.junit.jupiter.api.Assertions.*; /** - * Integration tests for {@link MongoAttachmentStorage} (GridFS) using Testcontainers. + * Integration tests for {@link MongoAttachmentStorage} (GridFS) using + * Testcontainers. * * @since 6.0.0 */ diff --git a/src/test/java/ai/labs/eddi/datastore/mongo/MongoResourceStorageIT.java b/src/test/java/ai/labs/eddi/datastore/mongo/MongoResourceStorageIT.java index b885fb8c4..9328f9c3c 100644 --- a/src/test/java/ai/labs/eddi/datastore/mongo/MongoResourceStorageIT.java +++ b/src/test/java/ai/labs/eddi/datastore/mongo/MongoResourceStorageIT.java @@ -6,6 +6,7 @@ import org.junit.jupiter.api.*; import java.io.IOException; +import java.util.List; import java.util.Map; import static org.junit.jupiter.api.Assertions.*; @@ -194,10 +195,10 @@ void readHistoryLatestNonExistent() { @Test @DisplayName("findResourceIdsContaining — searches by JSON path") void findResourceIds() throws IOException { - storage.store(storage.newResource(Map.of("tags", java.util.List.of("ai", "chatbot")))); - storage.store(storage.newResource(Map.of("tags", java.util.List.of("web")))); + storage.store(storage.newResource(Map.of("tags", List.of("ai", "chatbot")))); + storage.store(storage.newResource(Map.of("tags", List.of("web")))); - java.util.List results = + List results = storage.findResourceIdsContaining("tags", "ai"); assertEquals(1, results.size()); } diff --git a/src/test/java/ai/labs/eddi/datastore/mongo/MongoScheduleStoreIT.java b/src/test/java/ai/labs/eddi/datastore/mongo/MongoScheduleStoreIT.java index dad3801df..4992f4e81 100644 --- a/src/test/java/ai/labs/eddi/datastore/mongo/MongoScheduleStoreIT.java +++ b/src/test/java/ai/labs/eddi/datastore/mongo/MongoScheduleStoreIT.java @@ -214,7 +214,8 @@ void requeueDeadLetter() throws Exception { var cfg = newSchedule("Requeue", "a"); cfg.setFireStatus(FireStatus.DEAD_LETTERED); String id = store.createSchedule(cfg); - // Need to set status via markDeadLettered since createSchedule may not persist fireStatus directly + // Need to set status via markDeadLettered since createSchedule may not persist + // fireStatus directly store.markDeadLettered(id); store.requeueDeadLetter(id); diff --git a/src/test/java/ai/labs/eddi/datastore/mongo/MongoSecretPersistenceIT.java b/src/test/java/ai/labs/eddi/datastore/mongo/MongoSecretPersistenceIT.java index c6d5e1610..1e19cc68d 100644 --- a/src/test/java/ai/labs/eddi/datastore/mongo/MongoSecretPersistenceIT.java +++ b/src/test/java/ai/labs/eddi/datastore/mongo/MongoSecretPersistenceIT.java @@ -161,7 +161,7 @@ void upsertMeta() { // ─── Helpers ──────────────────────────────────────────────── private static EncryptedSecret createSecret(String tenant, String key, - String value, String iv, String dekId) { + String value, String iv, String dekId) { var secret = new EncryptedSecret(); secret.setTenantId(tenant); secret.setKeyName(key); diff --git a/src/test/java/ai/labs/eddi/datastore/mongo/MongoTestBase.java b/src/test/java/ai/labs/eddi/datastore/mongo/MongoTestBase.java index 6ab0aa556..0f4d3205b 100644 --- a/src/test/java/ai/labs/eddi/datastore/mongo/MongoTestBase.java +++ b/src/test/java/ai/labs/eddi/datastore/mongo/MongoTestBase.java @@ -10,6 +10,7 @@ import com.mongodb.client.MongoClient; import com.mongodb.client.MongoClients; import com.mongodb.client.MongoDatabase; +import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; import org.testcontainers.containers.MongoDBContainer; import org.testcontainers.junit.jupiter.Container; @@ -52,6 +53,13 @@ static void initMongo() { documentBuilder = new DocumentBuilder(jsonSerialization); } + @AfterAll + static void closeMongo() { + if (mongoClient != null) { + mongoClient.close(); + } + } + protected static MongoDatabase getDatabase() { return database; } diff --git a/src/test/java/ai/labs/eddi/datastore/mongo/MongoUserMemoryStoreIT.java b/src/test/java/ai/labs/eddi/datastore/mongo/MongoUserMemoryStoreIT.java index f34df5516..9ae61112f 100644 --- a/src/test/java/ai/labs/eddi/datastore/mongo/MongoUserMemoryStoreIT.java +++ b/src/test/java/ai/labs/eddi/datastore/mongo/MongoUserMemoryStoreIT.java @@ -178,7 +178,7 @@ void filter() throws IResourceStore.ResourceStoreException { } @Test - @DisplayName("getVisibleEntries — self visibility") + @DisplayName("getVisibleEntries — self scoped to agent, global visible to all") void visibleSelf() throws IResourceStore.ResourceStoreException { store.upsert(new UserMemoryEntry(null, "user-1", "self-key", "self-val", "cat", Visibility.self, "agent-A", List.of(), null, @@ -186,11 +186,21 @@ void visibleSelf() throws IResourceStore.ResourceStoreException { store.upsert(new UserMemoryEntry(null, "user-1", "other-key", "other-val", "cat", Visibility.self, "agent-B", List.of(), null, false, 0, null, null)); + // Global entry — visible regardless of agent + store.upsert(new UserMemoryEntry(null, "user-1", "global-key", "shared", + "cat", Visibility.global, "agent-B", List.of(), null, + false, 0, null, null)); List visible = store.getVisibleEntries( "user-1", "agent-A", List.of(), "most_recent", 100); - assertTrue(visible.stream().anyMatch(e -> "self-key".equals(e.key()))); - assertTrue(visible.stream().noneMatch(e -> "other-key".equals(e.key()))); + // Self entries: only agent-A's + assertTrue(visible.stream().anyMatch(e -> "self-key".equals(e.key())), + "Expected agent-A's self entry"); + assertTrue(visible.stream().noneMatch(e -> "other-key".equals(e.key())), + "agent-B's self entry should not be visible to agent-A"); + // Global entries: visible to all agents + assertTrue(visible.stream().anyMatch(e -> "global-key".equals(e.key())), + "Global entries should be visible regardless of agent"); } @Test From 9fd2a1650bc7502beb09bdf7487b024b12a4a6e4 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Mon, 20 Apr 2026 23:53:42 +0200 Subject: [PATCH 051/124] docs: update test counts to 4,100+ (3,500+ UT + 550+ IT) --- AGENTS.md | 2 +- README.md | 2 +- planning/observability-and-pipeline-plan.md | 2 +- planning/security-hardening-remaining.md | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index eccc5676f..33ac71088 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -97,7 +97,7 @@ Follow this order unless the user explicitly requests something different. | — | GDPR/CCPA Framework | Cascading erasure, data portability, Art. 18 restriction, per-category retention | | — | Commit Flags | Strict write discipline for memory — uncommit failed task data, error digest injection | | — | Template Preview | REST endpoint for previewing resolved system prompts with sample/live data | -| — | RC2 Hardening | 2,000+ unit tests, 250+ integration tests, branding overhaul, rules deserialization fix | +| — | RC2 Hardening | 3,500+ unit tests, 550+ integration tests, branding overhaul, rules deserialization fix | | — | Security Hardening v6.0.2 | SSRF prevention, SafeHttpClient, auth guard, vault salt, security headers, CodeQL + Trivy CI | ### In Progress / Upcoming diff --git a/README.md b/README.md index 4487ac8f9..a77797208 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ # E.D.D.I — Multi-Agent Orchestration Middleware for Conversational AI -[![Codacy Badge](https://app.codacy.com/project/badge/Grade/2c5d183d4bd24dbaa77427cfbf5d4074)](https://app.codacy.com/organizations/gh/labsai/dashboard?utm_source=github.com&utm_medium=referral&utm_content=labsai/EDDI&utm_campaign=Badge_Grade) [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/12355/badge)](https://www.bestpractices.dev/projects/12355) [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/labsai/EDDI/badge)](https://securityscorecards.dev/viewer/?uri=github.com/labsai/EDDI) ![Tests](https://img.shields.io/badge/tests-2%2C400%2B-brightgreen) +[![Codacy Badge](https://app.codacy.com/project/badge/Grade/2c5d183d4bd24dbaa77427cfbf5d4074)](https://app.codacy.com/organizations/gh/labsai/dashboard?utm_source=github.com&utm_medium=referral&utm_content=labsai/EDDI&utm_campaign=Badge_Grade) [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/12355/badge)](https://www.bestpractices.dev/projects/12355) [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/labsai/EDDI/badge)](https://securityscorecards.dev/viewer/?uri=github.com/labsai/EDDI) ![Tests](https://img.shields.io/badge/tests-4%2C100%2B-brightgreen) [![CI](https://github.com/labsai/EDDI/actions/workflows/ci.yml/badge.svg)](https://github.com/labsai/EDDI/actions/workflows/ci.yml) [![CodeQL](https://github.com/labsai/EDDI/actions/workflows/codeql.yml/badge.svg)](https://github.com/labsai/EDDI/actions/workflows/codeql.yml) diff --git a/planning/observability-and-pipeline-plan.md b/planning/observability-and-pipeline-plan.md index 0ba23376b..cd11e51e8 100644 --- a/planning/observability-and-pipeline-plan.md +++ b/planning/observability-and-pipeline-plan.md @@ -142,7 +142,7 @@ This is documentation/config work, not code changes. ## Verification -- [ ] `./mvnw test` — 2,225+ tests pass +- [ ] `./mvnw test` — 4,100+ tests pass - [ ] OpenTelemetry traces visible in Jaeger/Zipkin after item 1 - [ ] LlmTask unit tests pass unchanged after item 2 - [ ] Load test coordinator with 1000 concurrent conversations after item 3 diff --git a/planning/security-hardening-remaining.md b/planning/security-hardening-remaining.md index 093d2e7c4..93bb6eb9a 100644 --- a/planning/security-hardening-remaining.md +++ b/planning/security-hardening-remaining.md @@ -163,7 +163,7 @@ Add a new "## Security Architecture" section covering: After completing items above: -- [ ] `./mvnw test` — 2,225+ tests, 0 failures +- [ ] `./mvnw test` — 4,100+ tests, 0 failures - [ ] `./mvnw verify -DskipITs=false` — full integration test suite - [ ] Review CodeQL results after first CI run - [ ] Review Trivy results after first CI run From 75a6427928c336e5cfaefc6c4b4f918901232041 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Tue, 21 Apr 2026 00:02:01 +0200 Subject: [PATCH 052/124] refactor(test): remove unnecessary @SuppressWarnings and unused variable --- .../ai/labs/eddi/datastore/postgres/PostgresTestBase.java | 1 - src/test/java/ai/labs/eddi/modules/llm/impl/LlmTaskTest.java | 4 +--- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresTestBase.java b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresTestBase.java index 72e71882b..0fd8718ae 100644 --- a/src/test/java/ai/labs/eddi/datastore/postgres/PostgresTestBase.java +++ b/src/test/java/ai/labs/eddi/datastore/postgres/PostgresTestBase.java @@ -67,7 +67,6 @@ protected static void truncateTables(DataSource ds, String... tableNames) throws /** * Minimal Instance implementation that only supports get(). */ - @SuppressWarnings("unchecked") private static class SimpleDataSourceInstance implements Instance { private final DataSource ds; diff --git a/src/test/java/ai/labs/eddi/modules/llm/impl/LlmTaskTest.java b/src/test/java/ai/labs/eddi/modules/llm/impl/LlmTaskTest.java index 7688ede51..4ec6f0041 100644 --- a/src/test/java/ai/labs/eddi/modules/llm/impl/LlmTaskTest.java +++ b/src/test/java/ai/labs/eddi/modules/llm/impl/LlmTaskTest.java @@ -1583,11 +1583,9 @@ void testCascadeSkippedInAgentMode() throws Exception { when(templatingEngine.processTemplate(anyString(), anyMap())).thenAnswer(i -> i.getArgument(0)); // Agent mode reaches CDI boundary — same pattern as testExecute_AgentMode - Throwable thrown = null; try { langChainTask.execute(memory, llmConfig); - } catch (Throwable t) { - thrown = t; + } catch (Throwable ignored) { } // The cascade trace should NOT be stored (cascade was skipped) From 3340192090276b5bb57925737bc3c9ee6cce9cc6 Mon Sep 17 00:00:00 2001 From: Gregor Jarisch Date: Tue, 21 Apr 2026 09:54:12 +0200 Subject: [PATCH 053/124] test(coverage): batch 1 - zero-coverage packages (80 new tests) Add unit tests for 8 previously untested classes: - ui: RestManagerResourceTest, RestHtmlChatResourceTest - modules.llm.rest: RestToolHistoryTest - configs.dictionary.expression: RestExpressionTest, RestActionTest - configs.output.rest.keys: RestOutputActionsTest - modules.nlp.impl: RestSemanticParserTest - integrations.slack.rest: RestSlackWebhookTest Covers directory traversal, signature verification, REST endpoint error paths, filter/limit logic, and exception propagation. --- .../dictionary/expression/RestActionTest.java | 164 ++++++ .../expression/RestExpressionTest.java | 205 ++++++++ .../rest/keys/RestOutputActionsTest.java | 162 ++++++ .../slack/rest/RestSlackWebhookTest.java | 194 +++++++ .../modules/llm/rest/RestToolHistoryTest.java | 474 ++++++++++++++++++ .../nlp/impl/RestSemanticParserTest.java | 74 +++ .../eddi/ui/RestHtmlChatResourceTest.java | 62 +++ .../labs/eddi/ui/RestManagerResourceTest.java | 139 +++++ 8 files changed, 1474 insertions(+) create mode 100644 src/test/java/ai/labs/eddi/configs/dictionary/expression/RestActionTest.java create mode 100644 src/test/java/ai/labs/eddi/configs/dictionary/expression/RestExpressionTest.java create mode 100644 src/test/java/ai/labs/eddi/configs/output/rest/keys/RestOutputActionsTest.java create mode 100644 src/test/java/ai/labs/eddi/integrations/slack/rest/RestSlackWebhookTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/llm/rest/RestToolHistoryTest.java create mode 100644 src/test/java/ai/labs/eddi/modules/nlp/impl/RestSemanticParserTest.java create mode 100644 src/test/java/ai/labs/eddi/ui/RestHtmlChatResourceTest.java create mode 100644 src/test/java/ai/labs/eddi/ui/RestManagerResourceTest.java diff --git a/src/test/java/ai/labs/eddi/configs/dictionary/expression/RestActionTest.java b/src/test/java/ai/labs/eddi/configs/dictionary/expression/RestActionTest.java new file mode 100644 index 000000000..f9627406a --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/dictionary/expression/RestActionTest.java @@ -0,0 +1,164 @@ +package ai.labs.eddi.configs.dictionary.expression; + +import ai.labs.eddi.configs.apicalls.IApiCallsStore; +import ai.labs.eddi.configs.output.IOutputStore; +import ai.labs.eddi.configs.rules.IRuleSetStore; +import ai.labs.eddi.configs.workflows.IWorkflowStore; +import ai.labs.eddi.configs.workflows.model.WorkflowConfiguration; +import ai.labs.eddi.configs.workflows.model.WorkflowConfiguration.WorkflowStep; +import ai.labs.eddi.datastore.IResourceStore; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.net.URI; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +/** + * Unit tests for {@link RestAction}. + */ +class RestActionTest { + + // Valid hex ID (≥18 chars required by RestUtilities.isValidId) + private static final String VALID_ID = "aabb000011112222cccc"; + + private IWorkflowStore workflowStore; + private IRuleSetStore behaviorStore; + private IApiCallsStore httpCallsStore; + private IOutputStore outputStore; + private RestAction restAction; + + @BeforeEach + void setUp() { + workflowStore = mock(IWorkflowStore.class); + behaviorStore = mock(IRuleSetStore.class); + httpCallsStore = mock(IApiCallsStore.class); + outputStore = mock(IOutputStore.class); + restAction = new RestAction(workflowStore, behaviorStore, httpCallsStore, outputStore); + } + + @Test + @DisplayName("should read actions from rules store") + void readsActionsFromRulesStore() throws Exception { + var wfConfig = createWorkflowWithStep("eddi://ai.labs.rules", "rulesstore/rules"); + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + when(behaviorStore.readActions(VALID_ID, 1, "", 20)) + .thenReturn(List.of("greet", "farewell")); + + List result = restAction.readActions("wf-1", 1, "", 20); + + assertEquals(2, result.size()); + assertTrue(result.contains("greet")); + } + + @Test + @DisplayName("should read actions from apicalls store") + void readsActionsFromApiCallsStore() throws Exception { + var wfConfig = createWorkflowWithStep("eddi://ai.labs.apicalls", "apicallsstore/apicalls"); + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + when(httpCallsStore.readActions(VALID_ID, 1, "", 20)) + .thenReturn(List.of("callWeather", "callNews")); + + List result = restAction.readActions("wf-1", 1, "", 20); + + assertEquals(2, result.size()); + assertTrue(result.contains("callWeather")); + } + + @Test + @DisplayName("should read actions from output store") + void readsActionsFromOutputStore() throws Exception { + var wfConfig = createWorkflowWithStep("eddi://ai.labs.output", "outputstore/outputsets"); + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + when(outputStore.readActions(VALID_ID, 1, "", 20)) + .thenReturn(List.of("display_welcome")); + + List result = restAction.readActions("wf-1", 1, "", 20); + + assertEquals(1, result.size()); + assertEquals("display_welcome", result.get(0)); + } + + @Test + @DisplayName("should return empty list for unknown step types") + void emptyForUnknownTypes() throws Exception { + var wfConfig = createWorkflowWithStep("eddi://ai.labs.llm", "llmstore/llms"); + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + + List result = restAction.readActions("wf-1", 1, "", 20); + + assertTrue(result.isEmpty()); + } + + @Test + @DisplayName("should aggregate actions across multiple steps without duplicates") + void aggregatesWithoutDuplicates() throws Exception { + var wfConfig = new WorkflowConfiguration(); + var rulesStep = createStep("eddi://ai.labs.rules", "rulesstore/rules"); + var outputStep = createStep("eddi://ai.labs.output", "outputstore/outputsets"); + wfConfig.setWorkflowSteps(List.of(rulesStep, outputStep)); + + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + when(behaviorStore.readActions(VALID_ID, 1, "", 20)) + .thenReturn(List.of("greet", "shared_action")); + when(outputStore.readActions(VALID_ID, 1, "", 20)) + .thenReturn(List.of("shared_action", "display")); + + List result = restAction.readActions("wf-1", 1, "", 20); + + assertEquals(3, result.size()); // no duplicate for shared_action + } + + @Test + @DisplayName("should propagate ResourceNotFoundException") + void propagatesResourceNotFound() throws Exception { + when(workflowStore.read("wf-1", 1)) + .thenThrow(new IResourceStore.ResourceNotFoundException("Not found")); + + assertThrows(IResourceStore.ResourceNotFoundException.class, + () -> restAction.readActions("wf-1", 1, "", 20)); + } + + @Test + @DisplayName("should propagate ResourceStoreException") + void propagatesResourceStoreException() throws Exception { + when(workflowStore.read("wf-1", 1)) + .thenThrow(new IResourceStore.ResourceStoreException("DB error")); + + assertThrows(IResourceStore.ResourceStoreException.class, + () -> restAction.readActions("wf-1", 1, "", 20)); + } + + @Test + @DisplayName("should handle empty workflow steps") + void emptyWorkflowSteps() throws Exception { + var wfConfig = new WorkflowConfiguration(); + wfConfig.setWorkflowSteps(List.of()); + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + + List result = restAction.readActions("wf-1", 1, "", 20); + + assertTrue(result.isEmpty()); + } + + // ==================== Helpers ==================== + + private WorkflowConfiguration createWorkflowWithStep(String typeUri, String storePath) { + var wfConfig = new WorkflowConfiguration(); + wfConfig.setWorkflowSteps(List.of(createStep(typeUri, storePath))); + return wfConfig; + } + + private WorkflowStep createStep(String typeUri, String storePath) { + var step = new WorkflowStep(); + step.setType(URI.create(typeUri)); + // URI format: eddi://ai.labs.xxx/storePath/VALID_HEX_ID?version=N + step.setConfig(Map.of("uri", + typeUri + "/" + storePath + "/" + VALID_ID + "?version=1")); + return step; + } +} diff --git a/src/test/java/ai/labs/eddi/configs/dictionary/expression/RestExpressionTest.java b/src/test/java/ai/labs/eddi/configs/dictionary/expression/RestExpressionTest.java new file mode 100644 index 000000000..ebd3fe48d --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/dictionary/expression/RestExpressionTest.java @@ -0,0 +1,205 @@ +package ai.labs.eddi.configs.dictionary.expression; + +import ai.labs.eddi.configs.dictionary.IDictionaryStore; +import ai.labs.eddi.configs.workflows.IWorkflowStore; +import ai.labs.eddi.configs.workflows.model.WorkflowConfiguration; +import ai.labs.eddi.configs.workflows.model.WorkflowConfiguration.WorkflowStep; +import ai.labs.eddi.datastore.IResourceStore; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.net.URI; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +/** + * Unit tests for {@link RestExpression}. + */ +class RestExpressionTest { + + private static final String VALID_ID = "aabb000011112222cccc"; + private static final String VALID_ID_2 = "ddee000033334444ffff"; + + private IWorkflowStore workflowStore; + private IDictionaryStore dictionaryStore; + private RestExpression restExpression; + + @BeforeEach + void setUp() { + workflowStore = mock(IWorkflowStore.class); + dictionaryStore = mock(IDictionaryStore.class); + restExpression = new RestExpression(workflowStore, dictionaryStore); + } + + @Test + @DisplayName("should return expressions from parser dictionaries") + void returnsExpressionsFromParserDictionaries() throws Exception { + var wfConfig = createWorkflowWithParserStep(VALID_ID, 1); + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + when(dictionaryStore.readExpressions(VALID_ID, 1, "", "asc", 0, 20)) + .thenReturn(List.of("greeting(hello)", "farewell(bye)")); + + List result = restExpression.readExpressions("wf-1", 1, "", 20); + + assertEquals(2, result.size()); + assertTrue(result.contains("greeting(hello)")); + assertTrue(result.contains("farewell(bye)")); + } + + @Test + @DisplayName("should skip non-parser workflow steps") + void skipsNonParserSteps() throws Exception { + var wfConfig = new WorkflowConfiguration(); + var rulesStep = new WorkflowStep(); + rulesStep.setType(URI.create("eddi://ai.labs.rules")); + rulesStep.setExtensions(Map.of()); + wfConfig.setWorkflowSteps(List.of(rulesStep)); + + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + + List result = restExpression.readExpressions("wf-1", 1, "", 20); + + assertTrue(result.isEmpty()); + verifyNoInteractions(dictionaryStore); + } + + @Test + @DisplayName("should skip non-regular dictionaries in parser step") + void skipsNonRegularDictionaries() throws Exception { + var wfConfig = new WorkflowConfiguration(); + var parserStep = new WorkflowStep(); + parserStep.setType(URI.create("eddi://ai.labs.parser")); + + Map extension = new HashMap<>(); + extension.put("type", "eddi://ai.labs.parser.dictionaries.integer"); + extension.put("config", Map.of("uri", "eddi://ai.labs.dict/dictstore/dictionaries/" + VALID_ID + "?version=1")); + + parserStep.setExtensions(Map.of("dictionaries", List.of(extension))); + wfConfig.setWorkflowSteps(List.of(parserStep)); + + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + + List result = restExpression.readExpressions("wf-1", 1, "", 20); + + assertTrue(result.isEmpty()); + } + + @Test + @DisplayName("should skip dictionaries extension with no type field") + void skipsDictionariesWithNoType() throws Exception { + var wfConfig = new WorkflowConfiguration(); + var parserStep = new WorkflowStep(); + parserStep.setType(URI.create("eddi://ai.labs.parser")); + + Map extension = new HashMap<>(); + extension.put("config", Map.of("uri", "eddi://ai.labs.dict/dictstore/dictionaries/" + VALID_ID + "?version=1")); + + parserStep.setExtensions(Map.of("dictionaries", List.of(extension))); + wfConfig.setWorkflowSteps(List.of(parserStep)); + + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + + List result = restExpression.readExpressions("wf-1", 1, "", 20); + + assertTrue(result.isEmpty()); + } + + @Test + @DisplayName("should skip non-dictionaries extension keys") + void skipsNonDictionaryExtensionKeys() throws Exception { + var wfConfig = new WorkflowConfiguration(); + var parserStep = new WorkflowStep(); + parserStep.setType(URI.create("eddi://ai.labs.parser")); + parserStep.setExtensions(Map.of("corrections", List.of())); + wfConfig.setWorkflowSteps(List.of(parserStep)); + + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + + List result = restExpression.readExpressions("wf-1", 1, "", 20); + + assertTrue(result.isEmpty()); + } + + @Test + @DisplayName("should deduplicate expressions across multiple dictionaries") + void deduplicatesExpressions() throws Exception { + var wfConfig = new WorkflowConfiguration(); + var parserStep = new WorkflowStep(); + parserStep.setType(URI.create("eddi://ai.labs.parser")); + + Map ext1 = new HashMap<>(); + ext1.put("type", "eddi://ai.labs.parser.dictionaries.regular"); + ext1.put("config", Map.of("uri", "eddi://ai.labs.dict/dictstore/dictionaries/" + VALID_ID + "?version=1")); + + Map ext2 = new HashMap<>(); + ext2.put("type", "eddi://ai.labs.parser.dictionaries.regular"); + ext2.put("config", Map.of("uri", "eddi://ai.labs.dict/dictstore/dictionaries/" + VALID_ID_2 + "?version=1")); + + parserStep.setExtensions(Map.of("dictionaries", List.of(ext1, ext2))); + wfConfig.setWorkflowSteps(List.of(parserStep)); + + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + when(dictionaryStore.readExpressions(VALID_ID, 1, "", "asc", 0, 20)) + .thenReturn(List.of("greeting(hello)", "shared(both)")); + when(dictionaryStore.readExpressions(VALID_ID_2, 1, "", "asc", 0, 20)) + .thenReturn(List.of("shared(both)", "farewell(bye)")); + + List result = restExpression.readExpressions("wf-1", 1, "", 20); + + assertEquals(3, result.size()); + } + + @Test + @DisplayName("should propagate ResourceNotFoundException") + void propagatesResourceNotFound() throws Exception { + when(workflowStore.read("wf-1", 1)) + .thenThrow(new IResourceStore.ResourceNotFoundException("Workflow not found")); + + assertThrows(IResourceStore.ResourceNotFoundException.class, + () -> restExpression.readExpressions("wf-1", 1, "", 20)); + } + + @Test + @DisplayName("should propagate ResourceStoreException") + void propagatesResourceStoreException() throws Exception { + when(workflowStore.read("wf-1", 1)) + .thenThrow(new IResourceStore.ResourceStoreException("DB error")); + + assertThrows(IResourceStore.ResourceStoreException.class, + () -> restExpression.readExpressions("wf-1", 1, "", 20)); + } + + @Test + @DisplayName("should handle empty workflow steps") + void emptyWorkflowSteps() throws Exception { + var wfConfig = new WorkflowConfiguration(); + wfConfig.setWorkflowSteps(List.of()); + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + + List result = restExpression.readExpressions("wf-1", 1, "", 20); + + assertTrue(result.isEmpty()); + } + + // ==================== Helpers ==================== + + private WorkflowConfiguration createWorkflowWithParserStep(String dictId, int dictVersion) { + var wfConfig = new WorkflowConfiguration(); + var parserStep = new WorkflowStep(); + parserStep.setType(URI.create("eddi://ai.labs.parser")); + + Map extension = new HashMap<>(); + extension.put("type", "eddi://ai.labs.parser.dictionaries.regular"); + extension.put("config", Map.of("uri", + "eddi://ai.labs.dict/dictstore/dictionaries/" + dictId + "?version=" + dictVersion)); + + parserStep.setExtensions(Map.of("dictionaries", List.of(extension))); + wfConfig.setWorkflowSteps(List.of(parserStep)); + return wfConfig; + } +} diff --git a/src/test/java/ai/labs/eddi/configs/output/rest/keys/RestOutputActionsTest.java b/src/test/java/ai/labs/eddi/configs/output/rest/keys/RestOutputActionsTest.java new file mode 100644 index 000000000..47c989b7d --- /dev/null +++ b/src/test/java/ai/labs/eddi/configs/output/rest/keys/RestOutputActionsTest.java @@ -0,0 +1,162 @@ +package ai.labs.eddi.configs.output.rest.keys; + +import ai.labs.eddi.configs.output.IOutputStore; +import ai.labs.eddi.configs.rules.IRuleSetStore; +import ai.labs.eddi.configs.rules.model.RuleConfiguration; +import ai.labs.eddi.configs.rules.model.RuleGroupConfiguration; +import ai.labs.eddi.configs.rules.model.RuleSetConfiguration; +import ai.labs.eddi.configs.workflows.IWorkflowStore; +import ai.labs.eddi.configs.workflows.model.WorkflowConfiguration; +import ai.labs.eddi.configs.workflows.model.WorkflowConfiguration.WorkflowStep; +import ai.labs.eddi.datastore.IResourceStore; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.net.URI; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class RestOutputActionsTest { + + private static final String VALID_ID = "aabb000011112222cccc"; + + private IWorkflowStore workflowStore; + private IRuleSetStore behaviorStore; + private IOutputStore outputStore; + private RestOutputActions restOutputActions; + + @BeforeEach + void setUp() { + workflowStore = mock(IWorkflowStore.class); + behaviorStore = mock(IRuleSetStore.class); + outputStore = mock(IOutputStore.class); + restOutputActions = new RestOutputActions(workflowStore, behaviorStore, outputStore); + } + + @Test + @DisplayName("should read actions from behavior rules matching filter") + void readsActionsFromBehaviorRules() throws Exception { + var wfConfig = createWorkflowWithRulesStep(); + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + + var ruleConfig = new RuleConfiguration(); + ruleConfig.setActions(List.of("greet_user", "farewell_user", "other")); + var groupConfig = new RuleGroupConfiguration(); + groupConfig.setRules(List.of(ruleConfig)); + var ruleSetConfig = new RuleSetConfiguration(); + ruleSetConfig.setBehaviorGroups(List.of(groupConfig)); + when(behaviorStore.read(VALID_ID, 1)).thenReturn(ruleSetConfig); + + List result = restOutputActions.readOutputActions("wf-1", 1, "user", 20); + assertEquals(2, result.size()); + assertTrue(result.contains("greet_user")); + assertFalse(result.contains("other")); + } + + @Test + @DisplayName("should stop at limit") + void stopsAtLimit() throws Exception { + var wfConfig = createWorkflowWithRulesStep(); + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + + var ruleConfig = new RuleConfiguration(); + ruleConfig.setActions(List.of("a_match", "b_match", "c_match")); + var groupConfig = new RuleGroupConfiguration(); + groupConfig.setRules(List.of(ruleConfig)); + var ruleSetConfig = new RuleSetConfiguration(); + ruleSetConfig.setBehaviorGroups(List.of(groupConfig)); + when(behaviorStore.read(VALID_ID, 1)).thenReturn(ruleSetConfig); + + List result = restOutputActions.readOutputActions("wf-1", 1, "match", 2); + assertEquals(2, result.size()); + } + + @Test + @DisplayName("should read from output store") + void readsFromOutputStore() throws Exception { + var wfConfig = createWorkflowWithOutputStep(); + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + when(outputStore.readActions(VALID_ID, 1, "", 20)) + .thenReturn(List.of("display_welcome")); + + List result = restOutputActions.readOutputActions("wf-1", 1, "", 20); + assertEquals(1, result.size()); + } + + @Test + @DisplayName("should return sorted results") + void returnsSortedResults() throws Exception { + var wfConfig = createWorkflowWithOutputStep(); + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + when(outputStore.readActions(VALID_ID, 1, "", 20)) + .thenReturn(List.of("zebra", "alpha", "middle")); + + List result = restOutputActions.readOutputActions("wf-1", 1, "", 20); + assertEquals(List.of("alpha", "middle", "zebra"), result); + } + + @Test + @DisplayName("should skip non-rules steps for rule extraction") + void skipsNonRulesSteps() throws Exception { + var wfConfig = new WorkflowConfiguration(); + var step = new WorkflowStep(); + step.setType(URI.create("eddi://ai.labs.llm")); + step.setConfig(Map.of("uri", "eddi://ai.labs.llm/llmstore/llms/" + VALID_ID + "?version=1")); + wfConfig.setWorkflowSteps(List.of(step)); + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + + List result = restOutputActions.readOutputActions("wf-1", 1, "", 20); + assertTrue(result.isEmpty()); + } + + @Test + @DisplayName("should propagate ResourceNotFoundException") + void propagatesNotFound() throws Exception { + when(workflowStore.read("wf-1", 1)) + .thenThrow(new IResourceStore.ResourceNotFoundException("Not found")); + assertThrows(IResourceStore.ResourceNotFoundException.class, + () -> restOutputActions.readOutputActions("wf-1", 1, "", 20)); + } + + @Test + @DisplayName("should propagate ResourceStoreException") + void propagatesStoreException() throws Exception { + when(workflowStore.read("wf-1", 1)) + .thenThrow(new IResourceStore.ResourceStoreException("DB error")); + assertThrows(IResourceStore.ResourceStoreException.class, + () -> restOutputActions.readOutputActions("wf-1", 1, "", 20)); + } + + @Test + @DisplayName("should handle empty workflow") + void emptyWorkflow() throws Exception { + var wfConfig = new WorkflowConfiguration(); + wfConfig.setWorkflowSteps(List.of()); + when(workflowStore.read("wf-1", 1)).thenReturn(wfConfig); + + List result = restOutputActions.readOutputActions("wf-1", 1, "", 20); + assertTrue(result.isEmpty()); + } + + private WorkflowConfiguration createWorkflowWithRulesStep() { + var wfConfig = new WorkflowConfiguration(); + var step = new WorkflowStep(); + step.setType(URI.create("eddi://ai.labs.rules")); + step.setConfig(Map.of("uri", "eddi://ai.labs.rules/rulesstore/rules/" + VALID_ID + "?version=1")); + wfConfig.setWorkflowSteps(List.of(step)); + return wfConfig; + } + + private WorkflowConfiguration createWorkflowWithOutputStep() { + var wfConfig = new WorkflowConfiguration(); + var step = new WorkflowStep(); + step.setType(URI.create("eddi://ai.labs.output")); + step.setConfig(Map.of("uri", "eddi://ai.labs.output/outputstore/outputsets/" + VALID_ID + "?version=1")); + wfConfig.setWorkflowSteps(List.of(step)); + return wfConfig; + } +} diff --git a/src/test/java/ai/labs/eddi/integrations/slack/rest/RestSlackWebhookTest.java b/src/test/java/ai/labs/eddi/integrations/slack/rest/RestSlackWebhookTest.java new file mode 100644 index 000000000..8861ad086 --- /dev/null +++ b/src/test/java/ai/labs/eddi/integrations/slack/rest/RestSlackWebhookTest.java @@ -0,0 +1,194 @@ +package ai.labs.eddi.integrations.slack.rest; + +import ai.labs.eddi.integrations.slack.SlackChannelRouter; +import ai.labs.eddi.integrations.slack.SlackEventHandler; +import ai.labs.eddi.integrations.slack.SlackIntegrationConfig; +import ai.labs.eddi.integrations.slack.SlackSignatureVerifier; +import com.fasterxml.jackson.databind.ObjectMapper; +import jakarta.ws.rs.core.Response; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.util.Map; +import java.util.Set; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +/** + * Unit tests for {@link RestSlackWebhook}. + */ +class RestSlackWebhookTest { + + private SlackIntegrationConfig config; + private SlackChannelRouter channelRouter; + private SlackSignatureVerifier signatureVerifier; + private SlackEventHandler eventHandler; + private ObjectMapper objectMapper; + private RestSlackWebhook webhook; + + @BeforeEach + void setUp() { + config = mock(SlackIntegrationConfig.class); + channelRouter = mock(SlackChannelRouter.class); + signatureVerifier = mock(SlackSignatureVerifier.class); + eventHandler = mock(SlackEventHandler.class); + objectMapper = new ObjectMapper(); + webhook = new RestSlackWebhook(config, channelRouter, signatureVerifier, eventHandler, objectMapper); + } + + @Nested + @DisplayName("When Slack integration is disabled") + class Disabled { + + @Test + @DisplayName("should return 404 when disabled") + void returns404WhenDisabled() { + when(config.enabled()).thenReturn(false); + + Response response = webhook.handleEvents("{}", "sig", "ts"); + + assertEquals(404, response.getStatus()); + } + } + + @Nested + @DisplayName("Signature verification") + class SignatureVerification { + + @Test + @DisplayName("should return 403 when signature verification fails") + void returns403OnBadSignature() { + when(config.enabled()).thenReturn(true); + when(channelRouter.getAllSigningSecrets()).thenReturn(Set.of("secret1")); + when(signatureVerifier.verify("ts", "{}", "bad-sig", Set.of("secret1"))) + .thenReturn(false); + + Response response = webhook.handleEvents("{}", "bad-sig", "ts"); + + assertEquals(403, response.getStatus()); + } + } + + @Nested + @DisplayName("URL Verification challenge") + class UrlVerification { + + @Test + @DisplayName("should echo challenge for url_verification type") + void echoesChallenge() throws Exception { + when(config.enabled()).thenReturn(true); + when(channelRouter.getAllSigningSecrets()).thenReturn(Set.of("secret1")); + when(signatureVerifier.verify(anyString(), anyString(), anyString(), any())) + .thenReturn(true); + + String body = objectMapper.writeValueAsString( + Map.of("type", "url_verification", "challenge", "abc123")); + + Response response = webhook.handleEvents(body, "sig", "ts"); + + assertEquals(200, response.getStatus()); + String entity = (String) response.getEntity(); + assertTrue(entity.contains("abc123")); + } + + @Test + @DisplayName("should handle null challenge gracefully") + void handlesNullChallenge() throws Exception { + when(config.enabled()).thenReturn(true); + when(channelRouter.getAllSigningSecrets()).thenReturn(Set.of("s1")); + when(signatureVerifier.verify(anyString(), anyString(), anyString(), any())) + .thenReturn(true); + + String body = objectMapper.writeValueAsString( + Map.of("type", "url_verification")); + + Response response = webhook.handleEvents(body, "sig", "ts"); + + assertEquals(200, response.getStatus()); + } + } + + @Nested + @DisplayName("Event callbacks") + class EventCallbacks { + + @Test + @DisplayName("should delegate event_callback to handler and return 200") + void delegatesEventCallback() throws Exception { + when(config.enabled()).thenReturn(true); + when(channelRouter.getAllSigningSecrets()).thenReturn(Set.of("s1")); + when(signatureVerifier.verify(anyString(), anyString(), anyString(), any())) + .thenReturn(true); + + String body = objectMapper.writeValueAsString(Map.of( + "type", "event_callback", + "event_id", "ev-1", + "event", Map.of("type", "app_mention", "text", "hello"))); + + Response response = webhook.handleEvents(body, "sig", "ts"); + + assertEquals(200, response.getStatus()); + verify(eventHandler).handleEventAsync(eq("ev-1"), any()); + } + + @Test + @DisplayName("should handle event_callback with null event gracefully") + void handlesNullEvent() throws Exception { + when(config.enabled()).thenReturn(true); + when(channelRouter.getAllSigningSecrets()).thenReturn(Set.of("s1")); + when(signatureVerifier.verify(anyString(), anyString(), anyString(), any())) + .thenReturn(true); + + // event_callback without "event" key + String body = objectMapper.writeValueAsString(Map.of( + "type", "event_callback", + "event_id", "ev-1")); + + Response response = webhook.handleEvents(body, "sig", "ts"); + + assertEquals(200, response.getStatus()); + verifyNoInteractions(eventHandler); + } + } + + @Nested + @DisplayName("Unknown event types") + class UnknownTypes { + + @Test + @DisplayName("should return 200 for unknown event types") + void returns200ForUnknown() throws Exception { + when(config.enabled()).thenReturn(true); + when(channelRouter.getAllSigningSecrets()).thenReturn(Set.of("s1")); + when(signatureVerifier.verify(anyString(), anyString(), anyString(), any())) + .thenReturn(true); + + String body = objectMapper.writeValueAsString(Map.of("type", "unknown_type")); + + Response response = webhook.handleEvents(body, "sig", "ts"); + + assertEquals(200, response.getStatus()); + } + } + + @Nested + @DisplayName("Error handling") + class ErrorHandling { + + @Test + @DisplayName("should return 400 for invalid JSON") + void returns400ForBadJson() { + when(config.enabled()).thenReturn(true); + when(channelRouter.getAllSigningSecrets()).thenReturn(Set.of("s1")); + when(signatureVerifier.verify(anyString(), anyString(), anyString(), any())) + .thenReturn(true); + + Response response = webhook.handleEvents("not-json{{{", "sig", "ts"); + + assertEquals(400, response.getStatus()); + } + } +} diff --git a/src/test/java/ai/labs/eddi/modules/llm/rest/RestToolHistoryTest.java b/src/test/java/ai/labs/eddi/modules/llm/rest/RestToolHistoryTest.java new file mode 100644 index 000000000..9bdb238e5 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/llm/rest/RestToolHistoryTest.java @@ -0,0 +1,474 @@ +package ai.labs.eddi.modules.llm.rest; + +import ai.labs.eddi.datastore.IResourceStore; +import ai.labs.eddi.engine.memory.IConversationMemoryStore; +import ai.labs.eddi.engine.memory.model.ConversationMemorySnapshot; +import ai.labs.eddi.engine.memory.model.ConversationMemorySnapshot.ConversationStepSnapshot; +import ai.labs.eddi.engine.memory.model.ConversationMemorySnapshot.ResultSnapshot; +import ai.labs.eddi.engine.memory.model.ConversationMemorySnapshot.WorkflowRunSnapshot; +import ai.labs.eddi.modules.llm.tools.ToolCacheService; +import ai.labs.eddi.modules.llm.tools.ToolCostTracker; +import ai.labs.eddi.modules.llm.tools.ToolRateLimiter; +import jakarta.ws.rs.core.Response; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +/** + * Unit tests for {@link RestToolHistory} — all REST endpoints, error handling, + * and internal logic. + */ +class RestToolHistoryTest { + + private RestToolHistory restToolHistory; + private IConversationMemoryStore memoryStore; + private ToolCacheService cacheService; + private ToolRateLimiter rateLimiter; + private ToolCostTracker costTracker; + + @BeforeEach + void setUp() throws Exception { + restToolHistory = new RestToolHistory(); + memoryStore = mock(IConversationMemoryStore.class); + cacheService = mock(ToolCacheService.class); + rateLimiter = mock(ToolRateLimiter.class); + costTracker = mock(ToolCostTracker.class); + + // Inject mocks via reflection (CDI field injection) + setField("conversationMemoryStore", memoryStore); + setField("cacheService", cacheService); + setField("rateLimiter", rateLimiter); + setField("costTracker", costTracker); + } + + private void setField(String name, Object value) throws Exception { + Field field = RestToolHistory.class.getDeclaredField(name); + field.setAccessible(true); + field.set(restToolHistory, value); + } + + // ==================== getToolHistory ==================== + + @Nested + @DisplayName("GET /history/{conversationId}") + class GetToolHistory { + + @Test + @DisplayName("should return 200 with empty trace for conversation without tool calls") + void emptyConversation() throws Exception { + var snapshot = new ConversationMemorySnapshot(); + snapshot.setConversationSteps(List.of()); + when(memoryStore.loadConversationMemorySnapshot("conv-1")).thenReturn(snapshot); + + Response response = restToolHistory.getToolHistory("conv-1"); + + assertEquals(200, response.getStatus()); + assertNotNull(response.getEntity()); + } + + @Test + @DisplayName("should return 200 with tool calls extracted from trace data") + void withToolCalls() throws Exception { + var snapshot = createSnapshotWithTraceData(); + when(memoryStore.loadConversationMemorySnapshot("conv-1")).thenReturn(snapshot); + + Response response = restToolHistory.getToolHistory("conv-1"); + + assertEquals(200, response.getStatus()); + } + + @Test + @DisplayName("should return 404 when conversation not found") + void conversationNotFound() throws Exception { + when(memoryStore.loadConversationMemorySnapshot("nonexistent")) + .thenThrow(new IResourceStore.ResourceNotFoundException("Not found")); + + Response response = restToolHistory.getToolHistory("nonexistent"); + + assertEquals(404, response.getStatus()); + } + + @Test + @DisplayName("should return 500 on unexpected error") + void unexpectedError() throws Exception { + when(memoryStore.loadConversationMemorySnapshot("conv-1")) + .thenThrow(new RuntimeException("DB connection failed")); + + Response response = restToolHistory.getToolHistory("conv-1"); + + assertEquals(500, response.getStatus()); + } + + @Test + @DisplayName("should handle non-list trace data gracefully") + void nonListTraceData() throws Exception { + var snapshot = new ConversationMemorySnapshot(); + var step = new ConversationStepSnapshot(); + var workflowRun = new WorkflowRunSnapshot(); + var result = new ResultSnapshot(); + result.setKey("langchain:trace:step1"); + result.setResult("not-a-list"); // Not a List — should be skipped + workflowRun.setLifecycleTasks(List.of(result)); + step.setWorkflows(List.of(workflowRun)); + snapshot.setConversationSteps(List.of(step)); + when(memoryStore.loadConversationMemorySnapshot("conv-1")).thenReturn(snapshot); + + Response response = restToolHistory.getToolHistory("conv-1"); + + assertEquals(200, response.getStatus()); + } + + @Test + @DisplayName("should skip non-trace keys") + void nonTraceKeysSkipped() throws Exception { + var snapshot = new ConversationMemorySnapshot(); + var step = new ConversationStepSnapshot(); + var workflowRun = new WorkflowRunSnapshot(); + var result = new ResultSnapshot(); + result.setKey("other:key"); + result.setResult(List.of()); + workflowRun.setLifecycleTasks(List.of(result)); + step.setWorkflows(List.of(workflowRun)); + snapshot.setConversationSteps(List.of(step)); + when(memoryStore.loadConversationMemorySnapshot("conv-1")).thenReturn(snapshot); + + Response response = restToolHistory.getToolHistory("conv-1"); + + assertEquals(200, response.getStatus()); + } + + @Test + @DisplayName("should handle null key gracefully") + void nullKeySkipped() throws Exception { + var snapshot = new ConversationMemorySnapshot(); + var step = new ConversationStepSnapshot(); + var workflowRun = new WorkflowRunSnapshot(); + var result = new ResultSnapshot(); + result.setKey(null); + workflowRun.setLifecycleTasks(List.of(result)); + step.setWorkflows(List.of(workflowRun)); + snapshot.setConversationSteps(List.of(step)); + when(memoryStore.loadConversationMemorySnapshot("conv-1")).thenReturn(snapshot); + + Response response = restToolHistory.getToolHistory("conv-1"); + + assertEquals(200, response.getStatus()); + } + + @Test + @DisplayName("should handle list with non-Map items in trace") + void nonMapItemsInTraceList() throws Exception { + var snapshot = new ConversationMemorySnapshot(); + var step = new ConversationStepSnapshot(); + var workflowRun = new WorkflowRunSnapshot(); + var result = new ResultSnapshot(); + result.setKey("langchain:trace:step1"); + // List with a String instead of Map — should log warning + List traceItems = new ArrayList<>(); + traceItems.add("not-a-map"); + result.setResult(traceItems); + workflowRun.setLifecycleTasks(List.of(result)); + step.setWorkflows(List.of(workflowRun)); + snapshot.setConversationSteps(List.of(step)); + when(memoryStore.loadConversationMemorySnapshot("conv-1")).thenReturn(snapshot); + + Response response = restToolHistory.getToolHistory("conv-1"); + + assertEquals(200, response.getStatus()); + } + } + + // ==================== Cache endpoints ==================== + + @Nested + @DisplayName("Cache endpoints") + class CacheEndpoints { + + @Test + @DisplayName("GET /cache/stats should return 200 with stats") + void getCacheStats() { + var stats = new ToolCacheService.CacheStats(10, 8, 2, 80.0, Map.of()); + when(cacheService.getStats()).thenReturn(stats); + + Response response = restToolHistory.getCacheStats(); + + assertEquals(200, response.getStatus()); + } + + @Test + @DisplayName("GET /cache/stats should return 500 on error") + void getCacheStatsError() { + when(cacheService.getStats()).thenThrow(new RuntimeException("Cache error")); + + Response response = restToolHistory.getCacheStats(); + + assertEquals(500, response.getStatus()); + } + + @Test + @DisplayName("GET /cache/ttl/{toolName} should return TTL info") + void getToolTTL() { + when(cacheService.getConfiguredTTL("weatherTool")).thenReturn(300L); + + Response response = restToolHistory.getToolTTL("weatherTool"); + + assertEquals(200, response.getStatus()); + } + + @Test + @DisplayName("GET /cache/ttl returns correct description for seconds range") + void getToolTTLSecondsRange() { + when(cacheService.getConfiguredTTL("realtimeTool")).thenReturn(60L); + + Response response = restToolHistory.getToolTTL("realtimeTool"); + + assertEquals(200, response.getStatus()); + } + + @Test + @DisplayName("GET /cache/ttl returns correct description for hours range") + void getToolTTLHoursRange() { + when(cacheService.getConfiguredTTL("semiStatic")).thenReturn(7200L); + + Response response = restToolHistory.getToolTTL("semiStatic"); + + assertEquals(200, response.getStatus()); + } + + @Test + @DisplayName("GET /cache/ttl returns correct description for days range") + void getToolTTLDaysRange() { + when(cacheService.getConfiguredTTL("staticTool")).thenReturn(172800L); + + Response response = restToolHistory.getToolTTL("staticTool"); + + assertEquals(200, response.getStatus()); + } + + @Test + @DisplayName("GET /cache/ttl should return 500 on error") + void getToolTTLError() { + when(cacheService.getConfiguredTTL("badTool")).thenThrow(new RuntimeException("Not found")); + + Response response = restToolHistory.getToolTTL("badTool"); + + assertEquals(500, response.getStatus()); + } + + @Test + @DisplayName("DELETE /cache should clear and return 200") + void clearCache() { + Response response = restToolHistory.clearCache(); + + assertEquals(200, response.getStatus()); + verify(cacheService).clear(); + } + + @Test + @DisplayName("DELETE /cache should return 500 on error") + void clearCacheError() { + doThrow(new RuntimeException("Clear failed")).when(cacheService).clear(); + + Response response = restToolHistory.clearCache(); + + assertEquals(500, response.getStatus()); + } + } + + // ==================== Rate limit endpoints ==================== + + @Nested + @DisplayName("Rate limit endpoints") + class RateLimitEndpoints { + + @Test + @DisplayName("GET /ratelimit/{toolName} should return rate limit info") + void getRateLimit() { + var info = new ToolRateLimiter.RateLimitInfo(100, 95, 60000L); + when(rateLimiter.getInfo("calculator")).thenReturn(info); + + Response response = restToolHistory.getRateLimit("calculator"); + + assertEquals(200, response.getStatus()); + } + + @Test + @DisplayName("GET /ratelimit should return 500 on error") + void getRateLimitError() { + when(rateLimiter.getInfo("badTool")).thenThrow(new RuntimeException("Error")); + + Response response = restToolHistory.getRateLimit("badTool"); + + assertEquals(500, response.getStatus()); + } + + @Test + @DisplayName("POST /ratelimit/{toolName}/reset should reset and return 200") + void resetRateLimit() { + Response response = restToolHistory.resetRateLimit("calculator"); + + assertEquals(200, response.getStatus()); + verify(rateLimiter).reset("calculator"); + } + + @Test + @DisplayName("POST /ratelimit/reset should return 500 on error") + void resetRateLimitError() { + doThrow(new RuntimeException("Reset failed")).when(rateLimiter).reset("badTool"); + + Response response = restToolHistory.resetRateLimit("badTool"); + + assertEquals(500, response.getStatus()); + } + } + + // ==================== Cost endpoints ==================== + + @Nested + @DisplayName("Cost endpoints") + class CostEndpoints { + + @Test + @DisplayName("GET /costs should return cost summary") + void getCosts() { + when(costTracker.getCostSummary()).thenReturn("Total: $1.50"); + when(costTracker.getTotalCost()).thenReturn(1.50); + + Response response = restToolHistory.getCosts(); + + assertEquals(200, response.getStatus()); + } + + @Test + @DisplayName("GET /costs should return 500 on error") + void getCostsError() { + when(costTracker.getCostSummary()).thenThrow(new RuntimeException("Error")); + + Response response = restToolHistory.getCosts(); + + assertEquals(500, response.getStatus()); + } + + @Test + @DisplayName("GET /costs/conversation/{id} should return conversation costs") + void getConversationCosts() { + var metrics = mock(ToolCostTracker.ConversationCostMetrics.class); + when(metrics.getTotalCost()).thenReturn(0.75); + when(metrics.getToolCallCount()).thenReturn(5); + when(metrics.getToolUsage()).thenReturn(Map.of("calculator", 3, "weather", 2)); + when(costTracker.getConversationCosts("conv-1")).thenReturn(metrics); + + Response response = restToolHistory.getConversationCosts("conv-1"); + + assertEquals(200, response.getStatus()); + } + + @Test + @DisplayName("GET /costs/conversation/{id} should return 404 when no data") + void getConversationCostsNotFound() { + when(costTracker.getConversationCosts("nonexistent")).thenReturn(null); + + Response response = restToolHistory.getConversationCosts("nonexistent"); + + assertEquals(404, response.getStatus()); + } + + @Test + @DisplayName("GET /costs/conversation should return 500 on error") + void getConversationCostsError() { + when(costTracker.getConversationCosts("conv-1")) + .thenThrow(new RuntimeException("Error")); + + Response response = restToolHistory.getConversationCosts("conv-1"); + + assertEquals(500, response.getStatus()); + } + + @Test + @DisplayName("GET /costs/tool/{toolName} should return tool costs") + void getToolCosts() { + var metrics = mock(ToolCostTracker.ToolCostMetrics.class); + when(metrics.getTotalCost()).thenReturn(0.50); + when(metrics.getCallCount()).thenReturn(10); + when(metrics.getAverageCost()).thenReturn(0.05); + when(costTracker.getToolCosts("calculator")).thenReturn(metrics); + + Response response = restToolHistory.getToolCosts("calculator"); + + assertEquals(200, response.getStatus()); + } + + @Test + @DisplayName("GET /costs/tool/{toolName} should return 404 when no data") + void getToolCostsNotFound() { + when(costTracker.getToolCosts("unknown")).thenReturn(null); + + Response response = restToolHistory.getToolCosts("unknown"); + + assertEquals(404, response.getStatus()); + } + + @Test + @DisplayName("GET /costs/tool should return 500 on error") + void getToolCostsError() { + when(costTracker.getToolCosts("badTool")) + .thenThrow(new RuntimeException("Error")); + + Response response = restToolHistory.getToolCosts("badTool"); + + assertEquals(500, response.getStatus()); + } + + @Test + @DisplayName("POST /costs/reset should reset and return 200") + void resetCosts() { + Response response = restToolHistory.resetCosts(); + + assertEquals(200, response.getStatus()); + verify(costTracker).resetAll(); + } + + @Test + @DisplayName("POST /costs/reset should return 500 on error") + void resetCostsError() { + doThrow(new RuntimeException("Reset failed")).when(costTracker).resetAll(); + + Response response = restToolHistory.resetCosts(); + + assertEquals(500, response.getStatus()); + } + } + + // ==================== Helpers ==================== + + private ConversationMemorySnapshot createSnapshotWithTraceData() { + var snapshot = new ConversationMemorySnapshot(); + var step = new ConversationStepSnapshot(); + var workflowRun = new WorkflowRunSnapshot(); + + var result = new ResultSnapshot(); + result.setKey("langchain:trace:step1"); + + // Create tool_call and tool_result events + List traceEvents = new ArrayList<>(); + traceEvents.add(Map.of("type", "tool_call", "tool", "calculator", "arguments", "{\"expression\":\"2+2\"}")); + traceEvents.add(Map.of("type", "tool_result", "tool", "calculator", "result", "4")); + result.setResult(traceEvents); + + workflowRun.setLifecycleTasks(List.of(result)); + step.setWorkflows(List.of(workflowRun)); + snapshot.setConversationSteps(List.of(step)); + + return snapshot; + } +} diff --git a/src/test/java/ai/labs/eddi/modules/nlp/impl/RestSemanticParserTest.java b/src/test/java/ai/labs/eddi/modules/nlp/impl/RestSemanticParserTest.java new file mode 100644 index 000000000..333d46100 --- /dev/null +++ b/src/test/java/ai/labs/eddi/modules/nlp/impl/RestSemanticParserTest.java @@ -0,0 +1,74 @@ +package ai.labs.eddi.modules.nlp.impl; + +import ai.labs.eddi.modules.nlp.impl.RestSemanticParser.ResponseSolution; +import ai.labs.eddi.modules.nlp.expressions.Expression; +import ai.labs.eddi.modules.nlp.expressions.Expressions; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for {@link RestSemanticParser} — specifically the + * {@link ResponseSolution} inner class and testable utility methods. + *

+ * The {@code parse()} method itself requires CDI + IRuntime and is tested via + * integration tests. These tests cover the serializable DTO. + */ +class RestSemanticParserTest { + + @Nested + @DisplayName("ResponseSolution") + class ResponseSolutionTests { + + @Test + @DisplayName("should create from Expressions") + void createFromExpressions() { + var expressions = new Expressions(new Expression("greeting", new Expression("hello"))); + var solution = new ResponseSolution(expressions); + + assertNotNull(solution.getExpressions()); + assertTrue(solution.getExpressions().contains("greeting")); + } + + @Test + @DisplayName("should support default constructor") + void defaultConstructor() { + var solution = new ResponseSolution(); + + assertNull(solution.getExpressions()); + } + + @Test + @DisplayName("should support setter") + void setter() { + var solution = new ResponseSolution(); + solution.setExpressions("test(value)"); + + assertEquals("test(value)", solution.getExpressions()); + } + + @Test + @DisplayName("should handle empty Expressions") + void emptyExpressions() { + var expressions = new Expressions(); + var solution = new ResponseSolution(expressions); + + assertNotNull(solution.getExpressions()); + } + + @Test + @DisplayName("should handle multiple expressions") + void multipleExpressions() { + var expressions = new Expressions( + new Expression("greeting", new Expression("hello")), + new Expression("farewell", new Expression("bye"))); + var solution = new ResponseSolution(expressions); + + assertNotNull(solution.getExpressions()); + assertTrue(solution.getExpressions().contains("greeting")); + assertTrue(solution.getExpressions().contains("farewell")); + } + } +} diff --git a/src/test/java/ai/labs/eddi/ui/RestHtmlChatResourceTest.java b/src/test/java/ai/labs/eddi/ui/RestHtmlChatResourceTest.java new file mode 100644 index 000000000..3a7e7d55e --- /dev/null +++ b/src/test/java/ai/labs/eddi/ui/RestHtmlChatResourceTest.java @@ -0,0 +1,62 @@ +package ai.labs.eddi.ui; + +import jakarta.ws.rs.core.Response; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for {@link RestHtmlChatResource}. + */ +class RestHtmlChatResourceTest { + + private RestHtmlChatResource resource; + + @BeforeEach + void setUp() { + resource = new RestHtmlChatResource(); + } + + @Test + @DisplayName("viewDefault should delegate to viewHtml with root path") + void viewDefaultDelegatesToViewHtml() { + // viewDefault calls viewHtml("/") which loads chat.html + // In test context, chat.html may not be on classpath + try { + Response response = resource.viewDefault(); + assertEquals(200, response.getStatus()); + } catch (Exception e) { + // Expected if chat.html not on test classpath + assertNotNull(e); + } + } + + @Test + @DisplayName("viewHtml should return 200 when chat.html exists") + void viewHtmlReturnsOk() { + try { + Response response = resource.viewHtml("/production"); + assertEquals(200, response.getStatus()); + } catch (Exception e) { + // Expected if chat.html not on test classpath + assertNotNull(e); + } + } + + @Test + @DisplayName("viewHtml with any path should always serve chat.html (SPA)") + void viewHtmlAlwaysServesChatHtml() { + // SPA pattern: all paths serve the same HTML + try { + Response r1 = resource.viewHtml("/path1"); + Response r2 = resource.viewHtml("/path2/nested"); + // Both should return the same resource + assertEquals(r1.getStatus(), r2.getStatus()); + } catch (Exception e) { + // Expected if chat.html not on test classpath + assertNotNull(e); + } + } +} diff --git a/src/test/java/ai/labs/eddi/ui/RestManagerResourceTest.java b/src/test/java/ai/labs/eddi/ui/RestManagerResourceTest.java new file mode 100644 index 000000000..596801f75 --- /dev/null +++ b/src/test/java/ai/labs/eddi/ui/RestManagerResourceTest.java @@ -0,0 +1,139 @@ +package ai.labs.eddi.ui; + +import jakarta.ws.rs.ForbiddenException; +import jakarta.ws.rs.core.Response; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for {@link RestManagerResource}. Tests directory traversal + * prevention, invalid character blocking, fallback to manage.html, and error + * handling. + */ +class RestManagerResourceTest { + + private RestManagerResource resource; + + @BeforeEach + void setUp() { + resource = new RestManagerResource(); + } + + @Nested + @DisplayName("Default path") + class DefaultPath { + + @Test + @DisplayName("fetchManagerResources() with no args should delegate to /manage.html") + void defaultCallDelegates() { + try { + Response response = resource.fetchManagerResources(); + assertEquals(200, response.getStatus()); + } catch (Exception e) { + // If manage.html is NOT on classpath, it throws InternalServerErrorException + assertNotNull(e); + } + } + } + + @Nested + @DisplayName("Directory traversal prevention") + class DirectoryTraversal { + + @Test + @DisplayName("path with ../ should throw ForbiddenException") + void pathTraversalBlocked() { + assertThrows(ForbiddenException.class, + () -> resource.fetchManagerResources("../../etc/passwd")); + } + + @Test + @DisplayName("deeply nested traversal should throw ForbiddenException") + void deepTraversalBlocked() { + assertThrows(ForbiddenException.class, + () -> resource.fetchManagerResources("a/b/../../../../etc/shadow")); + } + } + + @Nested + @DisplayName("Invalid character blocking") + class InvalidCharacters { + + @Test + @DisplayName("path with invalid characters should throw (Forbidden or InvalidPath)") + void invalidCharsBlocked() { + // On Windows, Paths.get() may throw InvalidPathException before our + // char-check runs. Both indicate the path is correctly rejected. + String[] badPaths = {"test - + +

diff --git a/src/main/resources/META-INF/resources/scripts/css/chat-ui.CN68VwV9.css b/src/main/resources/META-INF/resources/scripts/css/chat-ui.CN68VwV9.css new file mode 100644 index 000000000..cb9b4f1e0 --- /dev/null +++ b/src/main/resources/META-INF/resources/scripts/css/chat-ui.CN68VwV9.css @@ -0,0 +1 @@ +:root,[data-theme=dark]{--chat-bg: #0a0a0a;--chat-surface: #141414;--chat-surface-raised: #1e1e1e;--chat-text: #f1f1f1;--chat-text-muted: #999;--chat-text-accent: #cba135;--chat-accent: #113b92;--chat-accent-hover: #1a50b5;--chat-accent-soft: rgba(17, 59, 146, .15);--chat-agent-bg: #1e1e1e;--chat-agent-border: #2a2a2a;--chat-agent-text: #f1f1f1;--chat-user-bg: #113b92;--chat-user-text: #ffffff;--chat-input-bg: #1a1a1a;--chat-input-border: #333;--chat-input-focus: #113b92;--chat-input-text: #f1f1f1;--chat-input-placeholder: #666;--chat-qr-bg: rgba(17, 59, 146, .18);--chat-qr-border: rgba(17, 59, 146, .4);--chat-qr-text: #7eaaff;--chat-qr-hover: rgba(17, 59, 146, .35);--chat-border: #222;--chat-radius: 16px;--chat-radius-sm: 8px;--chat-font: "Noto Sans", system-ui, -apple-system, sans-serif;--chat-shadow: 0 2px 12px rgba(0, 0, 0, .4);--chat-scrollbar-thumb: #444;--chat-scrollbar-track: transparent}[data-theme=light]{--chat-bg: #f5f5f5;--chat-surface: #ffffff;--chat-surface-raised: #fafafa;--chat-text: #1a1a1a;--chat-text-muted: #666;--chat-text-accent: #8b6914;--chat-accent: #113b92;--chat-accent-hover: #0d2d6b;--chat-accent-soft: rgba(17, 59, 146, .08);--chat-agent-bg: #ffffff;--chat-agent-border: #e0e0e0;--chat-agent-text: #1a1a1a;--chat-user-bg: #113b92;--chat-user-text: #ffffff;--chat-input-bg: #ffffff;--chat-input-border: #d0d0d0;--chat-input-focus: #113b92;--chat-input-text: #1a1a1a;--chat-input-placeholder: #999;--chat-qr-bg: rgba(17, 59, 146, .06);--chat-qr-border: rgba(17, 59, 146, .25);--chat-qr-text: #113b92;--chat-qr-hover: rgba(17, 59, 146, .14);--chat-border: #e0e0e0;--chat-shadow: 0 2px 12px rgba(0, 0, 0, .08);--chat-scrollbar-thumb: #ccc;--chat-scrollbar-track: transparent}*,*:before,*:after{box-sizing:border-box;margin:0;padding:0}html,body,#root{height:100%;overflow:hidden}body{background-color:var(--chat-bg);color:var(--chat-text);font-family:var(--chat-font);font-weight:400;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}a{color:var(--chat-text-accent)}a:hover{opacity:.85}.chat-root{display:flex;flex-direction:column;height:100%;max-width:860px;margin:0 auto;background-color:var(--chat-bg)}.chat-header{display:flex;align-items:center;gap:12px;padding:12px 20px;border-bottom:1px solid var(--chat-border);background:var(--chat-surface);flex-shrink:0}.chat-header__branding{display:flex;align-items:center;gap:10px;flex:1;min-width:0}.chat-header__logo{height:36px;object-fit:contain}.chat-header__agent-name{font-size:.85rem;font-weight:500;color:var(--chat-text-muted);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.chat-header__title{flex:1;font-size:1rem;font-weight:500;color:var(--chat-text);letter-spacing:.02em}.chat-header__actions{display:flex;align-items:center;gap:6px}.chat-header__btn{display:flex;align-items:center;justify-content:center;width:36px;height:36px;border:none;border-radius:var(--chat-radius-sm);background:transparent;color:var(--chat-text-muted);cursor:pointer;transition:background .15s,color .15s;font-size:1.1rem}.chat-header__btn:hover{background:var(--chat-accent-soft);color:var(--chat-text)}.chat-input-area{flex-shrink:0}.chat-actions{display:flex;align-items:center;justify-content:space-between;padding:4px 16px 0;border-top:1px solid var(--chat-border)}.chat-actions__left,.chat-actions__right{display:flex;align-items:center;gap:4px}.chat-actions__btn{display:flex;align-items:center;justify-content:center;width:32px;height:32px;border:none;border-radius:var(--chat-radius-sm);background:transparent;color:var(--chat-text-muted);cursor:pointer;transition:background .15s,color .15s,opacity .15s;font-size:1rem}.chat-actions__btn:hover:not(:disabled){background:var(--chat-accent-soft);color:var(--chat-text)}.chat-actions__btn:disabled{cursor:not-allowed}.chat-messages{flex:1;overflow-y:auto;padding:16px 12px;display:flex;flex-direction:column;gap:4px}.chat-messages::-webkit-scrollbar{width:5px}.chat-messages::-webkit-scrollbar-thumb{background:var(--chat-scrollbar-thumb);border-radius:4px}.chat-messages::-webkit-scrollbar-track{background:var(--chat-scrollbar-track)}.message{display:flex;gap:10px;padding:4px 8px;max-width:85%;animation:msgIn .25s ease-out}@keyframes msgIn{0%{opacity:0;transform:translateY(8px)}to{opacity:1;transform:translateY(0)}}.message--user{align-self:flex-end;flex-direction:row-reverse}.message--agent{align-self:flex-start}.message__avatar{flex-shrink:0;width:32px;height:32px;border-radius:50%;display:flex;align-items:center;justify-content:center;font-size:.75rem;font-weight:600}.message--user .message__avatar{background:var(--chat-accent);color:var(--chat-user-text)}.message--agent .message__avatar{background:var(--chat-surface-raised);color:var(--chat-text-accent);border:1px solid var(--chat-agent-border)}.message__bubble{border-radius:var(--chat-radius);padding:10px 16px;font-size:.925rem;line-height:1.6;word-break:break-word}.message--user .message__bubble{background:var(--chat-user-bg);color:var(--chat-user-text);border-bottom-right-radius:4px}.message--agent .message__bubble{background:var(--chat-agent-bg);color:var(--chat-agent-text);border:1px solid var(--chat-agent-border);border-bottom-left-radius:4px}.message__bubble .markdown-body{font-size:inherit;line-height:inherit;color:inherit}.message__bubble .markdown-body p{margin:.4em 0}.message__bubble .markdown-body p:first-child{margin-top:0}.message__bubble .markdown-body p:last-child{margin-bottom:0}.message__bubble .markdown-body pre{background:var(--chat-surface);border:1px solid var(--chat-border);border-radius:var(--chat-radius-sm);padding:12px;overflow-x:auto;margin:8px 0;font-size:.85rem}.message__bubble .markdown-body code{background:var(--chat-surface);border-radius:3px;padding:1px 5px;font-size:.85em;font-family:Noto Sans Mono,ui-monospace,monospace}.message__bubble .markdown-body pre code{background:none;padding:0}.message__bubble .markdown-body ul,.message__bubble .markdown-body ol{padding-left:1.4em;margin:.4em 0}.message__bubble .markdown-body table{border-collapse:collapse;margin:8px 0;width:100%}.message__bubble .markdown-body th,.message__bubble .markdown-body td{border:1px solid var(--chat-border);padding:6px 10px;text-align:left;font-size:.85rem}.message__bubble .markdown-body th{background:var(--chat-surface-raised);font-weight:500}.message__bubble .markdown-body blockquote{border-left:3px solid var(--chat-accent);padding-left:12px;margin:8px 0;color:var(--chat-text-muted)}.indicator{display:flex;gap:10px;padding:4px 8px;align-self:flex-start;animation:msgIn .25s ease-out}.indicator__avatar{flex-shrink:0;width:32px;height:32px;border-radius:50%;display:flex;align-items:center;justify-content:center;font-size:.75rem;font-weight:600;background:var(--chat-surface-raised);color:var(--chat-text-accent);border:1px solid var(--chat-agent-border)}.indicator__bubble{background:var(--chat-agent-bg);border:1px solid var(--chat-agent-border);border-radius:var(--chat-radius);border-bottom-left-radius:4px;padding:12px 18px;display:flex;align-items:center;gap:8px}.indicator__dots{display:flex;align-items:center;gap:4px}.indicator__dot{width:7px;height:7px;border-radius:50%;background:var(--chat-text-muted);animation:bounce 1.2s infinite}.indicator__dot:nth-child(2){animation-delay:.15s}.indicator__dot:nth-child(3){animation-delay:.3s}@keyframes bounce{0%,60%,to{transform:translateY(0)}30%{transform:translateY(-6px)}}.indicator__thinking{display:flex;align-items:center;gap:8px;color:var(--chat-text-muted);font-size:.85rem;font-style:italic}.indicator__brain{font-size:1rem;animation:pulse 1.5s ease-in-out infinite}@keyframes pulse{0%,to{opacity:.4}50%{opacity:1}}.quick-replies{display:flex;flex-wrap:wrap;gap:8px;padding:8px 20px 12px;animation:msgIn .2s ease-out}.quick-replies__btn{padding:8px 16px;font-size:.875rem;font-family:var(--chat-font);font-weight:400;border:1px solid var(--chat-qr-border);border-radius:20px;background:var(--chat-qr-bg);color:var(--chat-qr-text);cursor:pointer;transition:background .15s,border-color .15s,transform .1s;white-space:nowrap}.quick-replies__btn:hover{background:var(--chat-qr-hover);border-color:var(--chat-qr-text)}.quick-replies__btn:active{transform:scale(.97)}.chat-input{display:flex;align-items:flex-end;gap:10px;padding:12px 16px 16px;border-top:1px solid var(--chat-border);background:var(--chat-surface)}.chat-input__textarea{flex:1;resize:none;min-height:44px;max-height:150px;padding:10px 14px;font-size:.925rem;font-family:var(--chat-font);line-height:1.5;color:var(--chat-input-text);background:var(--chat-input-bg);border:1px solid var(--chat-input-border);border-radius:14px;outline:none;transition:border-color .15s,box-shadow .15s}.chat-input__textarea::placeholder{color:var(--chat-input-placeholder)}.chat-input__textarea:focus{border-color:var(--chat-input-focus);box-shadow:0 0 0 2px var(--chat-accent-soft)}.chat-input__send{flex-shrink:0;display:flex;align-items:center;justify-content:center;width:44px;height:44px;border:none;border-radius:14px;font-size:1.2rem;cursor:pointer;transition:background .15s,transform .1s}.chat-input__send--active{background:var(--chat-accent);color:var(--chat-user-text)}.chat-input__send--active:hover{background:var(--chat-accent-hover)}.chat-input__send--active:active{transform:scale(.95)}.chat-input__send--disabled{background:var(--chat-surface-raised);color:var(--chat-text-muted);cursor:not-allowed}.chat-input__spinner{width:18px;height:18px;border:2px solid transparent;border-top-color:currentColor;border-radius:50%;animation:spin .6s linear infinite}@keyframes spin{to{transform:rotate(360deg)}}.chat-input__attach{flex-shrink:0;display:flex;align-items:center;justify-content:center;width:36px;height:36px;border:none;border-radius:var(--chat-radius-sm);background:transparent;color:var(--chat-text-muted);cursor:pointer;transition:background .15s,color .15s;font-size:1.1rem}.chat-input__attach:hover:not(:disabled){background:var(--chat-accent-soft);color:var(--chat-text)}.chat-input__attach:disabled{opacity:.35;cursor:not-allowed}.chat-input__secret-toggle{flex-shrink:0;display:flex;align-items:center;justify-content:center;width:36px;height:36px;border:none;border-radius:var(--chat-radius-sm);background:transparent;color:var(--chat-text-muted);cursor:pointer;transition:background .15s,color .15s;font-size:1.1rem}.chat-input__secret-toggle:hover{background:var(--chat-accent-soft);color:var(--chat-text)}.chat-input__secret-toggle--active{background:var(--chat-accent-soft);color:var(--chat-accent)}.chat-input__secret-wrapper{flex:1;position:relative;display:flex;align-items:center}.chat-input__secret-field{flex:1;padding:10px 40px 10px 14px;font-size:.925rem;font-family:var(--chat-font);line-height:1.5;color:var(--chat-input-text);background:var(--chat-input-bg);border:1px solid var(--chat-accent);border-radius:14px;outline:none;transition:border-color .15s,box-shadow .15s;height:44px}.chat-input__secret-field::placeholder{color:var(--chat-input-placeholder)}.chat-input__secret-field:focus{border-color:var(--chat-accent);box-shadow:0 0 0 2px var(--chat-accent-soft)}.chat-input__eye-toggle{position:absolute;right:8px;top:50%;transform:translateY(-50%);background:none;border:none;cursor:pointer;font-size:1rem;color:var(--chat-text-muted);padding:4px;line-height:1;transition:opacity .15s}.chat-input__eye-toggle:hover{opacity:.7}.secret-input{padding:12px 16px 16px;border-top:1px solid var(--chat-border);background:var(--chat-surface);animation:msgIn .25s ease-out}.secret-input__label{display:block;font-size:.85rem;font-weight:500;color:var(--chat-accent);margin-bottom:8px;letter-spacing:.02em}.secret-input__row{display:flex;align-items:center;gap:10px}.secret-input__field-wrapper{flex:1;position:relative;display:flex;align-items:center}.secret-input__field{flex:1;padding:10px 40px 10px 14px;font-size:.925rem;font-family:var(--chat-font);line-height:1.5;color:var(--chat-input-text);background:var(--chat-input-bg);border:1px solid var(--chat-accent);border-radius:14px;outline:none;transition:border-color .15s,box-shadow .15s;height:44px}.secret-input__field::placeholder{color:var(--chat-input-placeholder)}.secret-input__field:focus{border-color:var(--chat-accent);box-shadow:0 0 0 2px var(--chat-accent-soft)}.secret-input__eye-toggle{position:absolute;right:8px;top:50%;transform:translateY(-50%);background:none;border:none;cursor:pointer;font-size:1rem;color:var(--chat-text-muted);padding:4px;line-height:1;transition:opacity .15s}.secret-input__eye-toggle:hover{opacity:.7}.scroll-to-bottom{position:absolute;bottom:90px;left:50%;transform:translate(-50%);width:38px;height:38px;border:1px solid var(--chat-border);border-radius:50%;background:var(--chat-surface);color:var(--chat-text-muted);cursor:pointer;display:flex;align-items:center;justify-content:center;font-size:1.1rem;box-shadow:var(--chat-shadow);transition:background .15s,color .15s;z-index:10;animation:fadeIn .2s ease-out}.scroll-to-bottom:hover{background:var(--chat-surface-raised);color:var(--chat-text)}@keyframes fadeIn{0%{opacity:0;transform:translate(-50%) translateY(8px)}to{opacity:1;transform:translate(-50%) translateY(0)}}.chat-ended{display:flex;flex-direction:column;align-items:center;gap:12px;padding:20px;border-top:1px solid var(--chat-border);background:var(--chat-surface);text-align:center}.chat-ended__label{font-size:.9rem;color:var(--chat-text-muted);font-weight:500}.chat-ended__restart{padding:8px 24px;font-size:.875rem;font-family:var(--chat-font);font-weight:500;border:1px solid var(--chat-accent);border-radius:20px;background:var(--chat-accent-soft);color:var(--chat-qr-text);cursor:pointer;transition:background .15s,transform .1s}.chat-ended__restart:hover{background:var(--chat-accent);color:var(--chat-user-text)}.chat-ended__restart:active{transform:scale(.97)}.chat-empty{flex:1;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:12px;color:var(--chat-text-muted);text-align:center;padding:40px 20px}.chat-empty__icon{font-size:3rem;opacity:.3}.chat-empty__text{font-size:.95rem}@media(min-width:1440px){.chat-root{max-width:960px}}@media(min-width:1920px){.chat-root{max-width:1080px}.message__bubble{font-size:1rem}}@media(max-width:1280px){.chat-root{max-width:800px}}@media(max-width:1024px){.chat-root{max-width:720px}.message{max-width:88%}}@media(max-width:768px){.chat-root{max-width:100%}.chat-header{padding:10px 14px}.chat-header__logo{height:28px}.chat-messages{padding:12px 8px}.message{max-width:90%}.chat-input{padding:10px 12px 14px}.chat-actions{padding:4px 12px 0}.quick-replies{padding:8px 12px 10px}}@media(max-width:640px){.chat-header{padding:8px 12px;gap:8px}.chat-header__logo{height:26px}.chat-header__agent-name{font-size:.8rem}.chat-header__btn{width:32px;height:32px;font-size:1rem}.message{gap:8px;max-width:92%}.message__bubble{padding:9px 13px;font-size:.9rem;border-radius:14px}.message--user .message__bubble{border-bottom-right-radius:4px}.message--agent .message__bubble{border-bottom-left-radius:4px}.chat-input__textarea{min-height:40px;padding:9px 12px;font-size:.9rem;border-radius:12px}.chat-input__send{width:40px;height:40px;border-radius:12px}.quick-replies{gap:6px;padding:6px 10px 8px}.quick-replies__btn{font-size:.82rem;padding:6px 14px}.chat-actions__btn{width:28px;height:28px;font-size:.9rem}.scroll-to-bottom{width:34px;height:34px;bottom:80px}}@media(max-width:480px){.chat-header{padding:8px 10px;gap:6px}.chat-header__logo{height:24px}.chat-header__agent-name{font-size:.75rem;max-width:120px}.chat-messages{padding:8px 6px;gap:2px}.message{gap:6px;padding:3px 4px;max-width:94%}.message__avatar{width:26px;height:26px;font-size:.65rem}.message__bubble{padding:8px 12px;font-size:.875rem;line-height:1.5}.message__bubble .markdown-body pre{padding:8px;font-size:.78rem}.message__bubble .markdown-body th,.message__bubble .markdown-body td{padding:4px 6px;font-size:.78rem}.chat-input{padding:8px 8px 12px;gap:8px}.chat-input__textarea{min-height:38px;padding:8px 10px;font-size:.875rem;border-radius:10px}.chat-input__send{width:38px;height:38px;font-size:1.1rem;border-radius:10px}.chat-actions{padding:2px 8px 0}.quick-replies{padding:6px 8px 8px;gap:5px}.quick-replies__btn{font-size:.8rem;padding:5px 12px}.chat-ended{padding:14px;gap:10px}.chat-ended__restart{padding:6px 20px;font-size:.82rem}.scroll-to-bottom{width:32px;height:32px;bottom:70px;font-size:1rem}}@media(max-width:360px){.chat-header__logo{height:20px}.chat-header__agent-name{font-size:.7rem;max-width:80px}.chat-header__btn{width:28px;height:28px;font-size:.9rem}.message__avatar{width:22px;height:22px;font-size:.55rem}.message__bubble{padding:6px 10px;font-size:.82rem}.quick-replies__btn{font-size:.75rem;padding:4px 10px;border-radius:16px}}@media(hover:none)and (pointer:coarse){.chat-header__btn,.chat-actions__btn{min-width:44px;min-height:44px}.quick-replies__btn{min-height:36px}}@media(max-height:500px)and (orientation:landscape){.chat-header{padding:6px 12px}.chat-header__logo{height:22px}.chat-messages{padding:6px 8px}.chat-input{padding:6px 10px 8px}.quick-replies{padding:4px 10px 6px}.chat-actions{padding:2px 10px 0}}@supports (padding: env(safe-area-inset-bottom)){.chat-input{padding-bottom:calc(16px + env(safe-area-inset-bottom))}.chat-ended{padding-bottom:calc(20px + env(safe-area-inset-bottom))}@media(max-width:480px){.chat-input{padding-bottom:calc(12px + env(safe-area-inset-bottom))}}} diff --git a/src/main/resources/META-INF/resources/scripts/js/chat-ui.CfhhYzkF.js b/src/main/resources/META-INF/resources/scripts/js/chat-ui.CfhhYzkF.js new file mode 100644 index 000000000..67fe33385 --- /dev/null +++ b/src/main/resources/META-INF/resources/scripts/js/chat-ui.CfhhYzkF.js @@ -0,0 +1,162 @@ +(function(){const n=document.createElement("link").relList;if(n&&n.supports&&n.supports("modulepreload"))return;for(const s of document.querySelectorAll('link[rel="modulepreload"]'))r(s);new MutationObserver(s=>{for(const c of s)if(c.type==="childList")for(const o of c.addedNodes)o.tagName==="LINK"&&o.rel==="modulepreload"&&r(o)}).observe(document,{childList:!0,subtree:!0});function a(s){const c={};return s.integrity&&(c.integrity=s.integrity),s.referrerPolicy&&(c.referrerPolicy=s.referrerPolicy),s.crossOrigin==="use-credentials"?c.credentials="include":s.crossOrigin==="anonymous"?c.credentials="omit":c.credentials="same-origin",c}function r(s){if(s.ep)return;s.ep=!0;const c=a(s);fetch(s.href,c)}})();function W1(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}var Zo={exports:{}},lr={};/** + * @license React + * react-jsx-runtime.production.js + * + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */var _p;function D2(){if(_p)return lr;_p=1;var e=Symbol.for("react.transitional.element"),n=Symbol.for("react.fragment");function a(r,s,c){var o=null;if(c!==void 0&&(o=""+c),s.key!==void 0&&(o=""+s.key),"key"in s){c={};for(var m in s)m!=="key"&&(c[m]=s[m])}else c=s;return s=c.ref,{$$typeof:e,type:r,key:o,ref:s!==void 0?s:null,props:c}}return lr.Fragment=n,lr.jsx=a,lr.jsxs=a,lr}var Sp;function v2(){return Sp||(Sp=1,Zo.exports=D2()),Zo.exports}var ae=v2(),Jo={exports:{}},Ne={};/** + * @license React + * react.production.js + * + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */var Ap;function L2(){if(Ap)return Ne;Ap=1;var e=Symbol.for("react.transitional.element"),n=Symbol.for("react.portal"),a=Symbol.for("react.fragment"),r=Symbol.for("react.strict_mode"),s=Symbol.for("react.profiler"),c=Symbol.for("react.consumer"),o=Symbol.for("react.context"),m=Symbol.for("react.forward_ref"),E=Symbol.for("react.suspense"),p=Symbol.for("react.memo"),T=Symbol.for("react.lazy"),g=Symbol.for("react.activity"),S=Symbol.iterator;function y(L){return L===null||typeof L!="object"?null:(L=S&&L[S]||L["@@iterator"],typeof L=="function"?L:null)}var x={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},k=Object.assign,w={};function v(L,Z,C){this.props=L,this.context=Z,this.refs=w,this.updater=C||x}v.prototype.isReactComponent={},v.prototype.setState=function(L,Z){if(typeof L!="object"&&typeof L!="function"&&L!=null)throw Error("takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,L,Z,"setState")},v.prototype.forceUpdate=function(L){this.updater.enqueueForceUpdate(this,L,"forceUpdate")};function V(){}V.prototype=v.prototype;function Q(L,Z,C){this.props=L,this.context=Z,this.refs=w,this.updater=C||x}var he=Q.prototype=new V;he.constructor=Q,k(he,v.prototype),he.isPureReactComponent=!0;var ie=Array.isArray;function Y(){}var se={H:null,A:null,T:null,S:null},be=Object.prototype.hasOwnProperty;function ye(L,Z,C){var de=C.ref;return{$$typeof:e,type:L,key:Z,ref:de!==void 0?de:null,props:C}}function q(L,Z){return ye(L.type,Z,L.props)}function j(L){return typeof L=="object"&&L!==null&&L.$$typeof===e}function ee(L){var Z={"=":"=0",":":"=2"};return"$"+L.replace(/[=:]/g,function(C){return Z[C]})}var le=/\/+/g;function ce(L,Z){return typeof L=="object"&&L!==null&&L.key!=null?ee(""+L.key):Z.toString(36)}function fe(L){switch(L.status){case"fulfilled":return L.value;case"rejected":throw L.reason;default:switch(typeof L.status=="string"?L.then(Y,Y):(L.status="pending",L.then(function(Z){L.status==="pending"&&(L.status="fulfilled",L.value=Z)},function(Z){L.status==="pending"&&(L.status="rejected",L.reason=Z)})),L.status){case"fulfilled":return L.value;case"rejected":throw L.reason}}throw L}function z(L,Z,C,de,Ae){var ge=typeof L;(ge==="undefined"||ge==="boolean")&&(L=null);var we=!1;if(L===null)we=!0;else switch(ge){case"bigint":case"string":case"number":we=!0;break;case"object":switch(L.$$typeof){case e:case n:we=!0;break;case T:return we=L._init,z(we(L._payload),Z,C,de,Ae)}}if(we)return Ae=Ae(L),we=de===""?"."+ce(L,0):de,ie(Ae)?(C="",we!=null&&(C=we.replace(le,"$&/")+"/"),z(Ae,Z,C,"",function(Gt){return Gt})):Ae!=null&&(j(Ae)&&(Ae=q(Ae,C+(Ae.key==null||L&&L.key===Ae.key?"":(""+Ae.key).replace(le,"$&/")+"/")+we)),Z.push(Ae)),1;we=0;var tt=de===""?".":de+":";if(ie(L))for(var Qe=0;Qe>>1,R=z[ve];if(0>>1;ves(C,me))des(Ae,C)?(z[ve]=Ae,z[de]=me,ve=de):(z[ve]=C,z[Z]=me,ve=Z);else if(des(Ae,me))z[ve]=Ae,z[de]=me,ve=de;else break e}}return te}function s(z,te){var me=z.sortIndex-te.sortIndex;return me!==0?me:z.id-te.id}if(e.unstable_now=void 0,typeof performance=="object"&&typeof performance.now=="function"){var c=performance;e.unstable_now=function(){return c.now()}}else{var o=Date,m=o.now();e.unstable_now=function(){return o.now()-m}}var E=[],p=[],T=1,g=null,S=3,y=!1,x=!1,k=!1,w=!1,v=typeof setTimeout=="function"?setTimeout:null,V=typeof clearTimeout=="function"?clearTimeout:null,Q=typeof setImmediate<"u"?setImmediate:null;function he(z){for(var te=a(p);te!==null;){if(te.callback===null)r(p);else if(te.startTime<=z)r(p),te.sortIndex=te.expirationTime,n(E,te);else break;te=a(p)}}function ie(z){if(k=!1,he(z),!x)if(a(E)!==null)x=!0,Y||(Y=!0,ee());else{var te=a(p);te!==null&&fe(ie,te.startTime-z)}}var Y=!1,se=-1,be=5,ye=-1;function q(){return w?!0:!(e.unstable_now()-yez&&q());){var ve=g.callback;if(typeof ve=="function"){g.callback=null,S=g.priorityLevel;var R=ve(g.expirationTime<=z);if(z=e.unstable_now(),typeof R=="function"){g.callback=R,he(z),te=!0;break t}g===a(E)&&r(E),he(z)}else r(E);g=a(E)}if(g!==null)te=!0;else{var L=a(p);L!==null&&fe(ie,L.startTime-z),te=!1}}break e}finally{g=null,S=me,y=!1}te=void 0}}finally{te?ee():Y=!1}}}var ee;if(typeof Q=="function")ee=function(){Q(j)};else if(typeof MessageChannel<"u"){var le=new MessageChannel,ce=le.port2;le.port1.onmessage=j,ee=function(){ce.postMessage(null)}}else ee=function(){v(j,0)};function fe(z,te){se=v(function(){z(e.unstable_now())},te)}e.unstable_IdlePriority=5,e.unstable_ImmediatePriority=1,e.unstable_LowPriority=4,e.unstable_NormalPriority=3,e.unstable_Profiling=null,e.unstable_UserBlockingPriority=2,e.unstable_cancelCallback=function(z){z.callback=null},e.unstable_forceFrameRate=function(z){0>z||125ve?(z.sortIndex=me,n(p,z),a(E)===null&&z===a(p)&&(k?(V(se),se=-1):k=!0,fe(ie,me-ve))):(z.sortIndex=R,n(E,z),x||y||(x=!0,Y||(Y=!0,ee()))),z},e.unstable_shouldYield=q,e.unstable_wrapCallback=function(z){var te=S;return function(){var me=S;S=te;try{return z.apply(this,arguments)}finally{S=me}}}})(ef)),ef}var xp;function k2(){return xp||(xp=1,$o.exports=I2()),$o.exports}var tf={exports:{}},Rt={};/** + * @license React + * react-dom.production.js + * + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */var Op;function M2(){if(Op)return Rt;Op=1;var e=Kf();function n(E){var p="https://react.dev/errors/"+E;if(1"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(e)}catch(n){console.error(n)}}return e(),tf.exports=M2(),tf.exports}/** + * @license React + * react-dom-client.production.js + * + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */var Dp;function B2(){if(Dp)return sr;Dp=1;var e=k2(),n=Kf(),a=w2();function r(t){var u="https://react.dev/errors/"+t;if(1R||(t.current=ve[R],ve[R]=null,R--)}function C(t,u){R++,ve[R]=t.current,t.current=u}var de=L(null),Ae=L(null),ge=L(null),we=L(null);function tt(t,u){switch(C(ge,u),C(Ae,t),C(de,null),u.nodeType){case 9:case 11:t=(t=u.documentElement)&&(t=t.namespaceURI)?jm(t):0;break;default:if(t=u.tagName,u=u.namespaceURI)u=jm(u),t=Gm(u,t);else switch(t){case"svg":t=1;break;case"math":t=2;break;default:t=0}}Z(de),C(de,t)}function Qe(){Z(de),Z(Ae),Z(ge)}function Gt(t){t.memoizedState!==null&&C(we,t);var u=de.current,i=Gm(u,t.type);u!==i&&(C(Ae,t),C(de,i))}function lu(t){Ae.current===t&&(Z(de),Z(Ae)),we.current===t&&(Z(we),ur._currentValue=me)}var hi,Br;function xn(t){if(hi===void 0)try{throw Error()}catch(i){var u=i.stack.trim().match(/\n( *(at )?)/);hi=u&&u[1]||"",Br=-1)":-1f||D[l]!==P[f]){var K=` +`+D[l].replace(" at new "," at ");return t.displayName&&K.includes("")&&(K=K.replace("",t.displayName)),K}while(1<=l&&0<=f);break}}}finally{fa=!1,Error.prepareStackTrace=i}return(i=t?t.displayName||t.name:"")?xn(i):""}function Ms(t,u){switch(t.tag){case 26:case 27:case 5:return xn(t.type);case 16:return xn("Lazy");case 13:return t.child!==u&&u!==null?xn("Suspense Fallback"):xn("Suspense");case 19:return xn("SuspenseList");case 0:case 15:return ha(t.type,!1);case 11:return ha(t.type.render,!1);case 1:return ha(t.type,!0);case 31:return xn("Activity");default:return""}}function di(t){try{var u="",i=null;do u+=Ms(t,i),i=t,t=t.return;while(t);return u}catch(l){return` +Error generating stack: `+l.message+` +`+l.stack}}var da=Object.prototype.hasOwnProperty,mi=e.unstable_scheduleCallback,pi=e.unstable_cancelCallback,ws=e.unstable_shouldYield,Bs=e.unstable_requestPaint,It=e.unstable_now,W=e.unstable_getCurrentPriorityLevel,oe=e.unstable_ImmediatePriority,Ce=e.unstable_UserBlockingPriority,De=e.unstable_NormalPriority,qe=e.unstable_LowPriority,wt=e.unstable_IdlePriority,Hn=e.log,gn=e.unstable_setDisableYieldValue,Tn=null,gt=null;function it(t){if(typeof Hn=="function"&&gn(t),gt&&typeof gt.setStrictMode=="function")try{gt.setStrictMode(Tn,t)}catch{}}var ft=Math.clz32?Math.clz32:pT,bn=Math.log,mT=Math.LN2;function pT(t){return t>>>=0,t===0?32:31-(bn(t)/mT|0)|0}var Ur=256,Hr=262144,Pr=4194304;function Pu(t){var u=t&42;if(u!==0)return u;switch(t&-t){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:return 64;case 128:return 128;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:return t&261888;case 262144:case 524288:case 1048576:case 2097152:return t&3932160;case 4194304:case 8388608:case 16777216:case 33554432:return t&62914560;case 67108864:return 67108864;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 0;default:return t}}function Fr(t,u,i){var l=t.pendingLanes;if(l===0)return 0;var f=0,h=t.suspendedLanes,b=t.pingedLanes;t=t.warmLanes;var _=l&134217727;return _!==0?(l=_&~h,l!==0?f=Pu(l):(b&=_,b!==0?f=Pu(b):i||(i=_&~t,i!==0&&(f=Pu(i))))):(_=l&~h,_!==0?f=Pu(_):b!==0?f=Pu(b):i||(i=l&~t,i!==0&&(f=Pu(i)))),f===0?0:u!==0&&u!==f&&(u&h)===0&&(h=f&-f,i=u&-u,h>=i||h===32&&(i&4194048)!==0)?u:f}function Ei(t,u){return(t.pendingLanes&~(t.suspendedLanes&~t.pingedLanes)&u)===0}function ET(t,u){switch(t){case 1:case 2:case 4:case 8:case 64:return u+250;case 16:case 32:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return u+5e3;case 4194304:case 8388608:case 16777216:case 33554432:return-1;case 67108864:case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}function Nh(){var t=Pr;return Pr<<=1,(Pr&62914560)===0&&(Pr=4194304),t}function Us(t){for(var u=[],i=0;31>i;i++)u.push(t);return u}function gi(t,u){t.pendingLanes|=u,u!==268435456&&(t.suspendedLanes=0,t.pingedLanes=0,t.warmLanes=0)}function gT(t,u,i,l,f,h){var b=t.pendingLanes;t.pendingLanes=i,t.suspendedLanes=0,t.pingedLanes=0,t.warmLanes=0,t.expiredLanes&=i,t.entangledLanes&=i,t.errorRecoveryDisabledLanes&=i,t.shellSuspendCounter=0;var _=t.entanglements,D=t.expirationTimes,P=t.hiddenUpdates;for(i=b&~i;0"u")return null;try{return t.activeElement||t.body}catch{return t.body}}var AT=/[\n"\\]/g;function nn(t){return t.replace(AT,function(u){return"\\"+u.charCodeAt(0).toString(16)+" "})}function qs(t,u,i,l,f,h,b,_){t.name="",b!=null&&typeof b!="function"&&typeof b!="symbol"&&typeof b!="boolean"?t.type=b:t.removeAttribute("type"),u!=null?b==="number"?(u===0&&t.value===""||t.value!=u)&&(t.value=""+tn(u)):t.value!==""+tn(u)&&(t.value=""+tn(u)):b!=="submit"&&b!=="reset"||t.removeAttribute("value"),u!=null?js(t,b,tn(u)):i!=null?js(t,b,tn(i)):l!=null&&t.removeAttribute("value"),f==null&&h!=null&&(t.defaultChecked=!!h),f!=null&&(t.checked=f&&typeof f!="function"&&typeof f!="symbol"),_!=null&&typeof _!="function"&&typeof _!="symbol"&&typeof _!="boolean"?t.name=""+tn(_):t.removeAttribute("name")}function Hh(t,u,i,l,f,h,b,_){if(h!=null&&typeof h!="function"&&typeof h!="symbol"&&typeof h!="boolean"&&(t.type=h),u!=null||i!=null){if(!(h!=="submit"&&h!=="reset"||u!=null)){Ys(t);return}i=i!=null?""+tn(i):"",u=u!=null?""+tn(u):i,_||u===t.value||(t.value=u),t.defaultValue=u}l=l??f,l=typeof l!="function"&&typeof l!="symbol"&&!!l,t.checked=_?t.checked:!!l,t.defaultChecked=!!l,b!=null&&typeof b!="function"&&typeof b!="symbol"&&typeof b!="boolean"&&(t.name=b),Ys(t)}function js(t,u,i){u==="number"&&qr(t.ownerDocument)===t||t.defaultValue===""+i||(t.defaultValue=""+i)}function ba(t,u,i,l){if(t=t.options,u){u={};for(var f=0;f"u"||typeof window.document>"u"||typeof window.document.createElement>"u"),Ks=!1;if(zn)try{var _i={};Object.defineProperty(_i,"passive",{get:function(){Ks=!0}}),window.addEventListener("test",_i,_i),window.removeEventListener("test",_i,_i)}catch{Ks=!1}var cu=null,Zs=null,Gr=null;function Gh(){if(Gr)return Gr;var t,u=Zs,i=u.length,l,f="value"in cu?cu.value:cu.textContent,h=f.length;for(t=0;t=Ci),Jh=" ",Wh=!1;function $h(t,u){switch(t){case"keyup":return JT.indexOf(u.keyCode)!==-1;case"keydown":return u.keyCode!==229;case"keypress":case"mousedown":case"focusout":return!0;default:return!1}}function e0(t){return t=t.detail,typeof t=="object"&&"data"in t?t.data:null}var Aa=!1;function $T(t,u){switch(t){case"compositionend":return e0(u);case"keypress":return u.which!==32?null:(Wh=!0,Jh);case"textInput":return t=u.data,t===Jh&&Wh?null:t;default:return null}}function eb(t,u){if(Aa)return t==="compositionend"||!tc&&$h(t,u)?(t=Gh(),Gr=Zs=cu=null,Aa=!1,t):null;switch(t){case"paste":return null;case"keypress":if(!(u.ctrlKey||u.altKey||u.metaKey)||u.ctrlKey&&u.altKey){if(u.char&&1=u)return{node:i,offset:u-t};t=l}e:{for(;i;){if(i.nextSibling){i=i.nextSibling;break e}i=i.parentNode}i=void 0}i=s0(i)}}function o0(t,u){return t&&u?t===u?!0:t&&t.nodeType===3?!1:u&&u.nodeType===3?o0(t,u.parentNode):"contains"in t?t.contains(u):t.compareDocumentPosition?!!(t.compareDocumentPosition(u)&16):!1:!1}function f0(t){t=t!=null&&t.ownerDocument!=null&&t.ownerDocument.defaultView!=null?t.ownerDocument.defaultView:window;for(var u=qr(t.document);u instanceof t.HTMLIFrameElement;){try{var i=typeof u.contentWindow.location.href=="string"}catch{i=!1}if(i)t=u.contentWindow;else break;u=qr(t.document)}return u}function ac(t){var u=t&&t.nodeName&&t.nodeName.toLowerCase();return u&&(u==="input"&&(t.type==="text"||t.type==="search"||t.type==="tel"||t.type==="url"||t.type==="password")||u==="textarea"||t.contentEditable==="true")}var sb=zn&&"documentMode"in document&&11>=document.documentMode,Ca=null,ic=null,Ri=null,rc=!1;function h0(t,u,i){var l=i.window===i?i.document:i.nodeType===9?i:i.ownerDocument;rc||Ca==null||Ca!==qr(l)||(l=Ca,"selectionStart"in l&&ac(l)?l={start:l.selectionStart,end:l.selectionEnd}:(l=(l.ownerDocument&&l.ownerDocument.defaultView||window).getSelection(),l={anchorNode:l.anchorNode,anchorOffset:l.anchorOffset,focusNode:l.focusNode,focusOffset:l.focusOffset}),Ri&&Oi(Ri,l)||(Ri=l,l=Hl(ic,"onSelect"),0>=b,f-=b,On=1<<32-ft(u)+f|i<Re?(Ue=Ee,Ee=null):Ue=Ee.sibling;var ze=F(M,Ee,H[Re],J);if(ze===null){Ee===null&&(Ee=Ue);break}t&&Ee&&ze.alternate===null&&u(M,Ee),I=h(ze,I,Re),Fe===null?Te=ze:Fe.sibling=ze,Fe=ze,Ee=Ue}if(Re===H.length)return i(M,Ee),He&&qn(M,Re),Te;if(Ee===null){for(;ReRe?(Ue=Ee,Ee=null):Ue=Ee.sibling;var Lu=F(M,Ee,ze.value,J);if(Lu===null){Ee===null&&(Ee=Ue);break}t&&Ee&&Lu.alternate===null&&u(M,Ee),I=h(Lu,I,Re),Fe===null?Te=Lu:Fe.sibling=Lu,Fe=Lu,Ee=Ue}if(ze.done)return i(M,Ee),He&&qn(M,Re),Te;if(Ee===null){for(;!ze.done;Re++,ze=H.next())ze=$(M,ze.value,J),ze!==null&&(I=h(ze,I,Re),Fe===null?Te=ze:Fe.sibling=ze,Fe=ze);return He&&qn(M,Re),Te}for(Ee=l(Ee);!ze.done;Re++,ze=H.next())ze=G(Ee,M,Re,ze.value,J),ze!==null&&(t&&ze.alternate!==null&&Ee.delete(ze.key===null?Re:ze.key),I=h(ze,I,Re),Fe===null?Te=ze:Fe.sibling=ze,Fe=ze);return t&&Ee.forEach(function(R2){return u(M,R2)}),He&&qn(M,Re),Te}function Ke(M,I,H,J){if(typeof H=="object"&&H!==null&&H.type===k&&H.key===null&&(H=H.props.children),typeof H=="object"&&H!==null){switch(H.$$typeof){case y:e:{for(var Te=H.key;I!==null;){if(I.key===Te){if(Te=H.type,Te===k){if(I.tag===7){i(M,I.sibling),J=f(I,H.props.children),J.return=M,M=J;break e}}else if(I.elementType===Te||typeof Te=="object"&&Te!==null&&Te.$$typeof===be&&Zu(Te)===I.type){i(M,I.sibling),J=f(I,H.props),Mi(J,H),J.return=M,M=J;break e}i(M,I);break}else u(M,I);I=I.sibling}H.type===k?(J=Gu(H.props.children,M.mode,J,H.key),J.return=M,M=J):(J=tl(H.type,H.key,H.props,null,M.mode,J),Mi(J,H),J.return=M,M=J)}return b(M);case x:e:{for(Te=H.key;I!==null;){if(I.key===Te)if(I.tag===4&&I.stateNode.containerInfo===H.containerInfo&&I.stateNode.implementation===H.implementation){i(M,I.sibling),J=f(I,H.children||[]),J.return=M,M=J;break e}else{i(M,I);break}else u(M,I);I=I.sibling}J=dc(H,M.mode,J),J.return=M,M=J}return b(M);case be:return H=Zu(H),Ke(M,I,H,J)}if(fe(H))return pe(M,I,H,J);if(ee(H)){if(Te=ee(H),typeof Te!="function")throw Error(r(150));return H=Te.call(H),Se(M,I,H,J)}if(typeof H.then=="function")return Ke(M,I,sl(H),J);if(H.$$typeof===Q)return Ke(M,I,al(M,H),J);cl(M,H)}return typeof H=="string"&&H!==""||typeof H=="number"||typeof H=="bigint"?(H=""+H,I!==null&&I.tag===6?(i(M,I.sibling),J=f(I,H),J.return=M,M=J):(i(M,I),J=hc(H,M.mode,J),J.return=M,M=J),b(M)):i(M,I)}return function(M,I,H,J){try{ki=0;var Te=Ke(M,I,H,J);return wa=null,Te}catch(Ee){if(Ee===Ma||Ee===rl)throw Ee;var Fe=Vt(29,Ee,null,M.mode);return Fe.lanes=J,Fe.return=M,Fe}finally{}}}var Wu=w0(!0),B0=w0(!1),mu=!1;function Nc(t){t.updateQueue={baseState:t.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,lanes:0,hiddenCallbacks:null},callbacks:null}}function xc(t,u){t=t.updateQueue,u.updateQueue===t&&(u.updateQueue={baseState:t.baseState,firstBaseUpdate:t.firstBaseUpdate,lastBaseUpdate:t.lastBaseUpdate,shared:t.shared,callbacks:null})}function pu(t){return{lane:t,tag:0,payload:null,callback:null,next:null}}function Eu(t,u,i){var l=t.updateQueue;if(l===null)return null;if(l=l.shared,(Ye&2)!==0){var f=l.pending;return f===null?u.next=u:(u.next=f.next,f.next=u),l.pending=u,u=el(t),b0(t,null,i),u}return $r(t,l,u,i),el(t)}function wi(t,u,i){if(u=u.updateQueue,u!==null&&(u=u.shared,(i&4194048)!==0)){var l=u.lanes;l&=t.pendingLanes,i|=l,u.lanes=i,Oh(t,i)}}function Oc(t,u){var i=t.updateQueue,l=t.alternate;if(l!==null&&(l=l.updateQueue,i===l)){var f=null,h=null;if(i=i.firstBaseUpdate,i!==null){do{var b={lane:i.lane,tag:i.tag,payload:i.payload,callback:null,next:null};h===null?f=h=b:h=h.next=b,i=i.next}while(i!==null);h===null?f=h=u:h=h.next=u}else f=h=u;i={baseState:l.baseState,firstBaseUpdate:f,lastBaseUpdate:h,shared:l.shared,callbacks:l.callbacks},t.updateQueue=i;return}t=i.lastBaseUpdate,t===null?i.firstBaseUpdate=u:t.next=u,i.lastBaseUpdate=u}var Rc=!1;function Bi(){if(Rc){var t=ka;if(t!==null)throw t}}function Ui(t,u,i,l){Rc=!1;var f=t.updateQueue;mu=!1;var h=f.firstBaseUpdate,b=f.lastBaseUpdate,_=f.shared.pending;if(_!==null){f.shared.pending=null;var D=_,P=D.next;D.next=null,b===null?h=P:b.next=P,b=D;var K=t.alternate;K!==null&&(K=K.updateQueue,_=K.lastBaseUpdate,_!==b&&(_===null?K.firstBaseUpdate=P:_.next=P,K.lastBaseUpdate=D))}if(h!==null){var $=f.baseState;b=0,K=P=D=null,_=h;do{var F=_.lane&-536870913,G=F!==_.lane;if(G?(Be&F)===F:(l&F)===F){F!==0&&F===Ia&&(Rc=!0),K!==null&&(K=K.next={lane:0,tag:_.tag,payload:_.payload,callback:null,next:null});e:{var pe=t,Se=_;F=u;var Ke=i;switch(Se.tag){case 1:if(pe=Se.payload,typeof pe=="function"){$=pe.call(Ke,$,F);break e}$=pe;break e;case 3:pe.flags=pe.flags&-65537|128;case 0:if(pe=Se.payload,F=typeof pe=="function"?pe.call(Ke,$,F):pe,F==null)break e;$=g({},$,F);break e;case 2:mu=!0}}F=_.callback,F!==null&&(t.flags|=64,G&&(t.flags|=8192),G=f.callbacks,G===null?f.callbacks=[F]:G.push(F))}else G={lane:F,tag:_.tag,payload:_.payload,callback:_.callback,next:null},K===null?(P=K=G,D=$):K=K.next=G,b|=F;if(_=_.next,_===null){if(_=f.shared.pending,_===null)break;G=_,_=G.next,G.next=null,f.lastBaseUpdate=G,f.shared.pending=null}}while(!0);K===null&&(D=$),f.baseState=D,f.firstBaseUpdate=P,f.lastBaseUpdate=K,h===null&&(f.shared.lanes=0),_u|=b,t.lanes=b,t.memoizedState=$}}function U0(t,u){if(typeof t!="function")throw Error(r(191,t));t.call(u)}function H0(t,u){var i=t.callbacks;if(i!==null)for(t.callbacks=null,t=0;th?h:8;var b=z.T,_={};z.T=_,Vc(t,!1,u,i);try{var D=f(),P=z.S;if(P!==null&&P(_,D),D!==null&&typeof D=="object"&&typeof D.then=="function"){var K=gb(D,l);Fi(t,u,K,Wt(t))}else Fi(t,u,l,Wt(t))}catch($){Fi(t,u,{then:function(){},status:"rejected",reason:$},Wt())}finally{te.p=h,b!==null&&_.types!==null&&(b.types=_.types),z.T=b}}function Ab(){}function Gc(t,u,i,l){if(t.tag!==5)throw Error(r(476));var f=Ed(t).queue;pd(t,f,u,me,i===null?Ab:function(){return gd(t),i(l)})}function Ed(t){var u=t.memoizedState;if(u!==null)return u;u={memoizedState:me,baseState:me,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:Vn,lastRenderedState:me},next:null};var i={};return u.next={memoizedState:i,baseState:i,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:Vn,lastRenderedState:i},next:null},t.memoizedState=u,t=t.alternate,t!==null&&(t.memoizedState=u),u}function gd(t){var u=Ed(t);u.next===null&&(u=t.alternate.memoizedState),Fi(t,u.next.queue,{},Wt())}function Qc(){return Nt(ur)}function Td(){return ct().memoizedState}function bd(){return ct().memoizedState}function Cb(t){for(var u=t.return;u!==null;){switch(u.tag){case 24:case 3:var i=Wt();t=pu(i);var l=Eu(u,t,i);l!==null&&(Yt(l,u,i),wi(l,u,i)),u={cache:_c()},t.payload=u;return}u=u.return}}function Nb(t,u,i){var l=Wt();i={lane:l,revertLane:0,gesture:null,action:i,hasEagerState:!1,eagerState:null,next:null},bl(t)?_d(u,i):(i=oc(t,u,i,l),i!==null&&(Yt(i,t,l),Sd(i,u,l)))}function yd(t,u,i){var l=Wt();Fi(t,u,i,l)}function Fi(t,u,i,l){var f={lane:l,revertLane:0,gesture:null,action:i,hasEagerState:!1,eagerState:null,next:null};if(bl(t))_d(u,f);else{var h=t.alternate;if(t.lanes===0&&(h===null||h.lanes===0)&&(h=u.lastRenderedReducer,h!==null))try{var b=u.lastRenderedState,_=h(b,i);if(f.hasEagerState=!0,f.eagerState=_,Qt(_,b))return $r(t,u,f,0),Ze===null&&Wr(),!1}catch{}finally{}if(i=oc(t,u,f,l),i!==null)return Yt(i,t,l),Sd(i,u,l),!0}return!1}function Vc(t,u,i,l){if(l={lane:2,revertLane:xo(),gesture:null,action:l,hasEagerState:!1,eagerState:null,next:null},bl(t)){if(u)throw Error(r(479))}else u=oc(t,i,l,2),u!==null&&Yt(u,t,2)}function bl(t){var u=t.alternate;return t===xe||u!==null&&u===xe}function _d(t,u){Ua=hl=!0;var i=t.pending;i===null?u.next=u:(u.next=i.next,i.next=u),t.pending=u}function Sd(t,u,i){if((i&4194048)!==0){var l=u.lanes;l&=t.pendingLanes,i|=l,u.lanes=i,Oh(t,i)}}var zi={readContext:Nt,use:pl,useCallback:rt,useContext:rt,useEffect:rt,useImperativeHandle:rt,useLayoutEffect:rt,useInsertionEffect:rt,useMemo:rt,useReducer:rt,useRef:rt,useState:rt,useDebugValue:rt,useDeferredValue:rt,useTransition:rt,useSyncExternalStore:rt,useId:rt,useHostTransitionStatus:rt,useFormState:rt,useActionState:rt,useOptimistic:rt,useMemoCache:rt,useCacheRefresh:rt};zi.useEffectEvent=rt;var Ad={readContext:Nt,use:pl,useCallback:function(t,u){return kt().memoizedState=[t,u===void 0?null:u],t},useContext:Nt,useEffect:rd,useImperativeHandle:function(t,u,i){i=i!=null?i.concat([t]):null,gl(4194308,4,od.bind(null,u,t),i)},useLayoutEffect:function(t,u){return gl(4194308,4,t,u)},useInsertionEffect:function(t,u){gl(4,2,t,u)},useMemo:function(t,u){var i=kt();u=u===void 0?null:u;var l=t();if($u){it(!0);try{t()}finally{it(!1)}}return i.memoizedState=[l,u],l},useReducer:function(t,u,i){var l=kt();if(i!==void 0){var f=i(u);if($u){it(!0);try{i(u)}finally{it(!1)}}}else f=u;return l.memoizedState=l.baseState=f,t={pending:null,lanes:0,dispatch:null,lastRenderedReducer:t,lastRenderedState:f},l.queue=t,t=t.dispatch=Nb.bind(null,xe,t),[l.memoizedState,t]},useRef:function(t){var u=kt();return t={current:t},u.memoizedState=t},useState:function(t){t=Fc(t);var u=t.queue,i=yd.bind(null,xe,u);return u.dispatch=i,[t.memoizedState,i]},useDebugValue:qc,useDeferredValue:function(t,u){var i=kt();return jc(i,t,u)},useTransition:function(){var t=Fc(!1);return t=pd.bind(null,xe,t.queue,!0,!1),kt().memoizedState=t,[!1,t]},useSyncExternalStore:function(t,u,i){var l=xe,f=kt();if(He){if(i===void 0)throw Error(r(407));i=i()}else{if(i=u(),Ze===null)throw Error(r(349));(Be&127)!==0||j0(l,u,i)}f.memoizedState=i;var h={value:i,getSnapshot:u};return f.queue=h,rd(Q0.bind(null,l,h,t),[t]),l.flags|=2048,Pa(9,{destroy:void 0},G0.bind(null,l,h,i,u),null),i},useId:function(){var t=kt(),u=Ze.identifierPrefix;if(He){var i=Rn,l=On;i=(l&~(1<<32-ft(l)-1)).toString(32)+i,u="_"+u+"R_"+i,i=dl++,0<\/script>",h=h.removeChild(h.firstChild);break;case"select":h=typeof l.is=="string"?b.createElement("select",{is:l.is}):b.createElement("select"),l.multiple?h.multiple=!0:l.size&&(h.size=l.size);break;default:h=typeof l.is=="string"?b.createElement(f,{is:l.is}):b.createElement(f)}}h[At]=u,h[Bt]=l;e:for(b=u.child;b!==null;){if(b.tag===5||b.tag===6)h.appendChild(b.stateNode);else if(b.tag!==4&&b.tag!==27&&b.child!==null){b.child.return=b,b=b.child;continue}if(b===u)break e;for(;b.sibling===null;){if(b.return===null||b.return===u)break e;b=b.return}b.sibling.return=b.return,b=b.sibling}u.stateNode=h;e:switch(Ot(h,f,l),f){case"button":case"input":case"select":case"textarea":l=!!l.autoFocus;break e;case"img":l=!0;break e;default:l=!1}l&&Kn(u)}}return et(u),lo(u,u.type,t===null?null:t.memoizedProps,u.pendingProps,i),null;case 6:if(t&&u.stateNode!=null)t.memoizedProps!==l&&Kn(u);else{if(typeof l!="string"&&u.stateNode===null)throw Error(r(166));if(t=ge.current,va(u)){if(t=u.stateNode,i=u.memoizedProps,l=null,f=Ct,f!==null)switch(f.tag){case 27:case 5:l=f.memoizedProps}t[At]=u,t=!!(t.nodeValue===i||l!==null&&l.suppressHydrationWarning===!0||Ym(t.nodeValue,i)),t||hu(u,!0)}else t=Pl(t).createTextNode(l),t[At]=u,u.stateNode=t}return et(u),null;case 31:if(i=u.memoizedState,t===null||t.memoizedState!==null){if(l=va(u),i!==null){if(t===null){if(!l)throw Error(r(318));if(t=u.memoizedState,t=t!==null?t.dehydrated:null,!t)throw Error(r(557));t[At]=u}else Qu(),(u.flags&128)===0&&(u.memoizedState=null),u.flags|=4;et(u),t=!1}else i=gc(),t!==null&&t.memoizedState!==null&&(t.memoizedState.hydrationErrors=i),t=!0;if(!t)return u.flags&256?(Kt(u),u):(Kt(u),null);if((u.flags&128)!==0)throw Error(r(558))}return et(u),null;case 13:if(l=u.memoizedState,t===null||t.memoizedState!==null&&t.memoizedState.dehydrated!==null){if(f=va(u),l!==null&&l.dehydrated!==null){if(t===null){if(!f)throw Error(r(318));if(f=u.memoizedState,f=f!==null?f.dehydrated:null,!f)throw Error(r(317));f[At]=u}else Qu(),(u.flags&128)===0&&(u.memoizedState=null),u.flags|=4;et(u),f=!1}else f=gc(),t!==null&&t.memoizedState!==null&&(t.memoizedState.hydrationErrors=f),f=!0;if(!f)return u.flags&256?(Kt(u),u):(Kt(u),null)}return Kt(u),(u.flags&128)!==0?(u.lanes=i,u):(i=l!==null,t=t!==null&&t.memoizedState!==null,i&&(l=u.child,f=null,l.alternate!==null&&l.alternate.memoizedState!==null&&l.alternate.memoizedState.cachePool!==null&&(f=l.alternate.memoizedState.cachePool.pool),h=null,l.memoizedState!==null&&l.memoizedState.cachePool!==null&&(h=l.memoizedState.cachePool.pool),h!==f&&(l.flags|=2048)),i!==t&&i&&(u.child.flags|=8192),Cl(u,u.updateQueue),et(u),null);case 4:return Qe(),t===null&&vo(u.stateNode.containerInfo),et(u),null;case 10:return Gn(u.type),et(u),null;case 19:if(Z(st),l=u.memoizedState,l===null)return et(u),null;if(f=(u.flags&128)!==0,h=l.rendering,h===null)if(f)qi(l,!1);else{if(lt!==0||t!==null&&(t.flags&128)!==0)for(t=u.child;t!==null;){if(h=fl(t),h!==null){for(u.flags|=128,qi(l,!1),t=h.updateQueue,u.updateQueue=t,Cl(u,t),u.subtreeFlags=0,t=i,i=u.child;i!==null;)y0(i,t),i=i.sibling;return C(st,st.current&1|2),He&&qn(u,l.treeForkCount),u.child}t=t.sibling}l.tail!==null&&It()>Dl&&(u.flags|=128,f=!0,qi(l,!1),u.lanes=4194304)}else{if(!f)if(t=fl(h),t!==null){if(u.flags|=128,f=!0,t=t.updateQueue,u.updateQueue=t,Cl(u,t),qi(l,!0),l.tail===null&&l.tailMode==="hidden"&&!h.alternate&&!He)return et(u),null}else 2*It()-l.renderingStartTime>Dl&&i!==536870912&&(u.flags|=128,f=!0,qi(l,!1),u.lanes=4194304);l.isBackwards?(h.sibling=u.child,u.child=h):(t=l.last,t!==null?t.sibling=h:u.child=h,l.last=h)}return l.tail!==null?(t=l.tail,l.rendering=t,l.tail=t.sibling,l.renderingStartTime=It(),t.sibling=null,i=st.current,C(st,f?i&1|2:i&1),He&&qn(u,l.treeForkCount),t):(et(u),null);case 22:case 23:return Kt(u),vc(),l=u.memoizedState!==null,t!==null?t.memoizedState!==null!==l&&(u.flags|=8192):l&&(u.flags|=8192),l?(i&536870912)!==0&&(u.flags&128)===0&&(et(u),u.subtreeFlags&6&&(u.flags|=8192)):et(u),i=u.updateQueue,i!==null&&Cl(u,i.retryQueue),i=null,t!==null&&t.memoizedState!==null&&t.memoizedState.cachePool!==null&&(i=t.memoizedState.cachePool.pool),l=null,u.memoizedState!==null&&u.memoizedState.cachePool!==null&&(l=u.memoizedState.cachePool.pool),l!==i&&(u.flags|=2048),t!==null&&Z(Ku),null;case 24:return i=null,t!==null&&(i=t.memoizedState.cache),u.memoizedState.cache!==i&&(u.flags|=2048),Gn(ht),et(u),null;case 25:return null;case 30:return null}throw Error(r(156,u.tag))}function vb(t,u){switch(pc(u),u.tag){case 1:return t=u.flags,t&65536?(u.flags=t&-65537|128,u):null;case 3:return Gn(ht),Qe(),t=u.flags,(t&65536)!==0&&(t&128)===0?(u.flags=t&-65537|128,u):null;case 26:case 27:case 5:return lu(u),null;case 31:if(u.memoizedState!==null){if(Kt(u),u.alternate===null)throw Error(r(340));Qu()}return t=u.flags,t&65536?(u.flags=t&-65537|128,u):null;case 13:if(Kt(u),t=u.memoizedState,t!==null&&t.dehydrated!==null){if(u.alternate===null)throw Error(r(340));Qu()}return t=u.flags,t&65536?(u.flags=t&-65537|128,u):null;case 19:return Z(st),null;case 4:return Qe(),null;case 10:return Gn(u.type),null;case 22:case 23:return Kt(u),vc(),t!==null&&Z(Ku),t=u.flags,t&65536?(u.flags=t&-65537|128,u):null;case 24:return Gn(ht),null;case 25:return null;default:return null}}function Vd(t,u){switch(pc(u),u.tag){case 3:Gn(ht),Qe();break;case 26:case 27:case 5:lu(u);break;case 4:Qe();break;case 31:u.memoizedState!==null&&Kt(u);break;case 13:Kt(u);break;case 19:Z(st);break;case 10:Gn(u.type);break;case 22:case 23:Kt(u),vc(),t!==null&&Z(Ku);break;case 24:Gn(ht)}}function ji(t,u){try{var i=u.updateQueue,l=i!==null?i.lastEffect:null;if(l!==null){var f=l.next;i=f;do{if((i.tag&t)===t){l=void 0;var h=i.create,b=i.inst;l=h(),b.destroy=l}i=i.next}while(i!==f)}}catch(_){Ge(u,u.return,_)}}function bu(t,u,i){try{var l=u.updateQueue,f=l!==null?l.lastEffect:null;if(f!==null){var h=f.next;l=h;do{if((l.tag&t)===t){var b=l.inst,_=b.destroy;if(_!==void 0){b.destroy=void 0,f=u;var D=i,P=_;try{P()}catch(K){Ge(f,D,K)}}}l=l.next}while(l!==h)}}catch(K){Ge(u,u.return,K)}}function Xd(t){var u=t.updateQueue;if(u!==null){var i=t.stateNode;try{H0(u,i)}catch(l){Ge(t,t.return,l)}}}function Kd(t,u,i){i.props=ea(t.type,t.memoizedProps),i.state=t.memoizedState;try{i.componentWillUnmount()}catch(l){Ge(t,u,l)}}function Gi(t,u){try{var i=t.ref;if(i!==null){switch(t.tag){case 26:case 27:case 5:var l=t.stateNode;break;case 30:l=t.stateNode;break;default:l=t.stateNode}typeof i=="function"?t.refCleanup=i(l):i.current=l}}catch(f){Ge(t,u,f)}}function Dn(t,u){var i=t.ref,l=t.refCleanup;if(i!==null)if(typeof l=="function")try{l()}catch(f){Ge(t,u,f)}finally{t.refCleanup=null,t=t.alternate,t!=null&&(t.refCleanup=null)}else if(typeof i=="function")try{i(null)}catch(f){Ge(t,u,f)}else i.current=null}function Zd(t){var u=t.type,i=t.memoizedProps,l=t.stateNode;try{e:switch(u){case"button":case"input":case"select":case"textarea":i.autoFocus&&l.focus();break e;case"img":i.src?l.src=i.src:i.srcSet&&(l.srcset=i.srcSet)}}catch(f){Ge(t,t.return,f)}}function so(t,u,i){try{var l=t.stateNode;Wb(l,t.type,i,u),l[Bt]=u}catch(f){Ge(t,t.return,f)}}function Jd(t){return t.tag===5||t.tag===3||t.tag===26||t.tag===27&&xu(t.type)||t.tag===4}function co(t){e:for(;;){for(;t.sibling===null;){if(t.return===null||Jd(t.return))return null;t=t.return}for(t.sibling.return=t.return,t=t.sibling;t.tag!==5&&t.tag!==6&&t.tag!==18;){if(t.tag===27&&xu(t.type)||t.flags&2||t.child===null||t.tag===4)continue e;t.child.return=t,t=t.child}if(!(t.flags&2))return t.stateNode}}function oo(t,u,i){var l=t.tag;if(l===5||l===6)t=t.stateNode,u?(i.nodeType===9?i.body:i.nodeName==="HTML"?i.ownerDocument.body:i).insertBefore(t,u):(u=i.nodeType===9?i.body:i.nodeName==="HTML"?i.ownerDocument.body:i,u.appendChild(t),i=i._reactRootContainer,i!=null||u.onclick!==null||(u.onclick=Fn));else if(l!==4&&(l===27&&xu(t.type)&&(i=t.stateNode,u=null),t=t.child,t!==null))for(oo(t,u,i),t=t.sibling;t!==null;)oo(t,u,i),t=t.sibling}function Nl(t,u,i){var l=t.tag;if(l===5||l===6)t=t.stateNode,u?i.insertBefore(t,u):i.appendChild(t);else if(l!==4&&(l===27&&xu(t.type)&&(i=t.stateNode),t=t.child,t!==null))for(Nl(t,u,i),t=t.sibling;t!==null;)Nl(t,u,i),t=t.sibling}function Wd(t){var u=t.stateNode,i=t.memoizedProps;try{for(var l=t.type,f=u.attributes;f.length;)u.removeAttributeNode(f[0]);Ot(u,l,i),u[At]=t,u[Bt]=i}catch(h){Ge(t,t.return,h)}}var Zn=!1,pt=!1,fo=!1,$d=typeof WeakSet=="function"?WeakSet:Set,yt=null;function Lb(t,u){if(t=t.containerInfo,ko=Ql,t=f0(t),ac(t)){if("selectionStart"in t)var i={start:t.selectionStart,end:t.selectionEnd};else e:{i=(i=t.ownerDocument)&&i.defaultView||window;var l=i.getSelection&&i.getSelection();if(l&&l.rangeCount!==0){i=l.anchorNode;var f=l.anchorOffset,h=l.focusNode;l=l.focusOffset;try{i.nodeType,h.nodeType}catch{i=null;break e}var b=0,_=-1,D=-1,P=0,K=0,$=t,F=null;t:for(;;){for(var G;$!==i||f!==0&&$.nodeType!==3||(_=b+f),$!==h||l!==0&&$.nodeType!==3||(D=b+l),$.nodeType===3&&(b+=$.nodeValue.length),(G=$.firstChild)!==null;)F=$,$=G;for(;;){if($===t)break t;if(F===i&&++P===f&&(_=b),F===h&&++K===l&&(D=b),(G=$.nextSibling)!==null)break;$=F,F=$.parentNode}$=G}i=_===-1||D===-1?null:{start:_,end:D}}else i=null}i=i||{start:0,end:0}}else i=null;for(Mo={focusedElem:t,selectionRange:i},Ql=!1,yt=u;yt!==null;)if(u=yt,t=u.child,(u.subtreeFlags&1028)!==0&&t!==null)t.return=u,yt=t;else for(;yt!==null;){switch(u=yt,h=u.alternate,t=u.flags,u.tag){case 0:if((t&4)!==0&&(t=u.updateQueue,t=t!==null?t.events:null,t!==null))for(i=0;i title"))),Ot(h,l,i),h[At]=t,bt(h),l=h;break e;case"link":var b=ip("link","href",f).get(l+(i.href||""));if(b){for(var _=0;_Ke&&(b=Ke,Ke=Se,Se=b);var M=c0(_,Se),I=c0(_,Ke);if(M&&I&&(G.rangeCount!==1||G.anchorNode!==M.node||G.anchorOffset!==M.offset||G.focusNode!==I.node||G.focusOffset!==I.offset)){var H=$.createRange();H.setStart(M.node,M.offset),G.removeAllRanges(),Se>Ke?(G.addRange(H),G.extend(I.node,I.offset)):(H.setEnd(I.node,I.offset),G.addRange(H))}}}}for($=[],G=_;G=G.parentNode;)G.nodeType===1&&$.push({element:G,left:G.scrollLeft,top:G.scrollTop});for(typeof _.focus=="function"&&_.focus(),_=0;_<$.length;_++){var J=$[_];J.element.scrollLeft=J.left,J.element.scrollTop=J.top}}Ql=!!ko,Mo=ko=null}finally{Ye=f,te.p=l,z.T=i}}t.current=u,Tt=2}}function xm(){if(Tt===2){Tt=0;var t=Au,u=ja,i=(u.flags&8772)!==0;if((u.subtreeFlags&8772)!==0||i){i=z.T,z.T=null;var l=te.p;te.p=2;var f=Ye;Ye|=4;try{em(t,u.alternate,u)}finally{Ye=f,te.p=l,z.T=i}}Tt=3}}function Om(){if(Tt===4||Tt===3){Tt=0,Bs();var t=Au,u=ja,i=tu,l=dm;(u.subtreeFlags&10256)!==0||(u.flags&10256)!==0?Tt=5:(Tt=0,ja=Au=null,Rm(t,t.pendingLanes));var f=t.pendingLanes;if(f===0&&(Su=null),Ps(i),u=u.stateNode,gt&&typeof gt.onCommitFiberRoot=="function")try{gt.onCommitFiberRoot(Tn,u,void 0,(u.current.flags&128)===128)}catch{}if(l!==null){u=z.T,f=te.p,te.p=2,z.T=null;try{for(var h=t.onRecoverableError,b=0;bi?32:i,z.T=null,i=bo,bo=null;var h=Au,b=tu;if(Tt=0,ja=Au=null,tu=0,(Ye&6)!==0)throw Error(r(331));var _=Ye;if(Ye|=4,om(h.current),lm(h,h.current,b,i),Ye=_,Ji(0,!1),gt&&typeof gt.onPostCommitFiberRoot=="function")try{gt.onPostCommitFiberRoot(Tn,h)}catch{}return!0}finally{te.p=f,z.T=l,Rm(t,u)}}function vm(t,u,i){u=an(i,u),u=Jc(t.stateNode,u,2),t=Eu(t,u,2),t!==null&&(gi(t,2),vn(t))}function Ge(t,u,i){if(t.tag===3)vm(t,t,i);else for(;u!==null;){if(u.tag===3){vm(u,t,i);break}else if(u.tag===1){var l=u.stateNode;if(typeof u.type.getDerivedStateFromError=="function"||typeof l.componentDidCatch=="function"&&(Su===null||!Su.has(l))){t=an(i,t),i=Ld(2),l=Eu(u,i,2),l!==null&&(Id(i,l,u,t),gi(l,2),vn(l));break}}u=u.return}}function Ao(t,u,i){var l=t.pingCache;if(l===null){l=t.pingCache=new Mb;var f=new Set;l.set(u,f)}else f=l.get(u),f===void 0&&(f=new Set,l.set(u,f));f.has(i)||(po=!0,f.add(i),t=Pb.bind(null,t,u,i),u.then(t,t))}function Pb(t,u,i){var l=t.pingCache;l!==null&&l.delete(u),t.pingedLanes|=t.suspendedLanes&i,t.warmLanes&=~i,Ze===t&&(Be&i)===i&&(lt===4||lt===3&&(Be&62914560)===Be&&300>It()-Rl?(Ye&2)===0&&Ga(t,0):Eo|=i,qa===Be&&(qa=0)),vn(t)}function Lm(t,u){u===0&&(u=Nh()),t=ju(t,u),t!==null&&(gi(t,u),vn(t))}function Fb(t){var u=t.memoizedState,i=0;u!==null&&(i=u.retryLane),Lm(t,i)}function zb(t,u){var i=0;switch(t.tag){case 31:case 13:var l=t.stateNode,f=t.memoizedState;f!==null&&(i=f.retryLane);break;case 19:l=t.stateNode;break;case 22:l=t.stateNode._retryCache;break;default:throw Error(r(314))}l!==null&&l.delete(u),Lm(t,i)}function Yb(t,u){return mi(t,u)}var wl=null,Va=null,Co=!1,Bl=!1,No=!1,Nu=0;function vn(t){t!==Va&&t.next===null&&(Va===null?wl=Va=t:Va=Va.next=t),Bl=!0,Co||(Co=!0,jb())}function Ji(t,u){if(!No&&Bl){No=!0;do for(var i=!1,l=wl;l!==null;){if(t!==0){var f=l.pendingLanes;if(f===0)var h=0;else{var b=l.suspendedLanes,_=l.pingedLanes;h=(1<<31-ft(42|t)+1)-1,h&=f&~(b&~_),h=h&201326741?h&201326741|1:h?h|2:0}h!==0&&(i=!0,wm(l,h))}else h=Be,h=Fr(l,l===Ze?h:0,l.cancelPendingCommit!==null||l.timeoutHandle!==-1),(h&3)===0||Ei(l,h)||(i=!0,wm(l,h));l=l.next}while(i);No=!1}}function qb(){Im()}function Im(){Bl=Co=!1;var t=0;Nu!==0&&e2()&&(t=Nu);for(var u=It(),i=null,l=wl;l!==null;){var f=l.next,h=km(l,u);h===0?(l.next=null,i===null?wl=f:i.next=f,f===null&&(Va=i)):(i=l,(t!==0||(h&3)!==0)&&(Bl=!0)),l=f}Tt!==0&&Tt!==5||Ji(t),Nu!==0&&(Nu=0)}function km(t,u){for(var i=t.suspendedLanes,l=t.pingedLanes,f=t.expirationTimes,h=t.pendingLanes&-62914561;0_)break;var K=D.transferSize,$=D.initiatorType;K&&qm($)&&(D=D.responseEnd,b+=K*(D<_?1:(_-P)/(D-P)))}if(--l,u+=8*(h+b)/(f.duration/1e3),t++,10"u"?null:document;function tp(t,u,i){var l=Xa;if(l&&typeof u=="string"&&u){var f=nn(u);f='link[rel="'+t+'"][href="'+f+'"]',typeof i=="string"&&(f+='[crossorigin="'+i+'"]'),ep.has(f)||(ep.add(f),t={rel:t,crossOrigin:i,href:u},l.querySelector(f)===null&&(u=l.createElement("link"),Ot(u,"link",t),bt(u),l.head.appendChild(u)))}}function c2(t){nu.D(t),tp("dns-prefetch",t,null)}function o2(t,u){nu.C(t,u),tp("preconnect",t,u)}function f2(t,u,i){nu.L(t,u,i);var l=Xa;if(l&&t&&u){var f='link[rel="preload"][as="'+nn(u)+'"]';u==="image"&&i&&i.imageSrcSet?(f+='[imagesrcset="'+nn(i.imageSrcSet)+'"]',typeof i.imageSizes=="string"&&(f+='[imagesizes="'+nn(i.imageSizes)+'"]')):f+='[href="'+nn(t)+'"]';var h=f;switch(u){case"style":h=Ka(t);break;case"script":h=Za(t)}fn.has(h)||(t=g({rel:"preload",href:u==="image"&&i&&i.imageSrcSet?void 0:t,as:u},i),fn.set(h,t),l.querySelector(f)!==null||u==="style"&&l.querySelector(tr(h))||u==="script"&&l.querySelector(nr(h))||(u=l.createElement("link"),Ot(u,"link",t),bt(u),l.head.appendChild(u)))}}function h2(t,u){nu.m(t,u);var i=Xa;if(i&&t){var l=u&&typeof u.as=="string"?u.as:"script",f='link[rel="modulepreload"][as="'+nn(l)+'"][href="'+nn(t)+'"]',h=f;switch(l){case"audioworklet":case"paintworklet":case"serviceworker":case"sharedworker":case"worker":case"script":h=Za(t)}if(!fn.has(h)&&(t=g({rel:"modulepreload",href:t},u),fn.set(h,t),i.querySelector(f)===null)){switch(l){case"audioworklet":case"paintworklet":case"serviceworker":case"sharedworker":case"worker":case"script":if(i.querySelector(nr(h)))return}l=i.createElement("link"),Ot(l,"link",t),bt(l),i.head.appendChild(l)}}}function d2(t,u,i){nu.S(t,u,i);var l=Xa;if(l&&t){var f=ga(l).hoistableStyles,h=Ka(t);u=u||"default";var b=f.get(h);if(!b){var _={loading:0,preload:null};if(b=l.querySelector(tr(h)))_.loading=5;else{t=g({rel:"stylesheet",href:t,"data-precedence":u},i),(i=fn.get(h))&&zo(t,i);var D=b=l.createElement("link");bt(D),Ot(D,"link",t),D._p=new Promise(function(P,K){D.onload=P,D.onerror=K}),D.addEventListener("load",function(){_.loading|=1}),D.addEventListener("error",function(){_.loading|=2}),_.loading|=4,zl(b,u,l)}b={type:"stylesheet",instance:b,count:1,state:_},f.set(h,b)}}}function m2(t,u){nu.X(t,u);var i=Xa;if(i&&t){var l=ga(i).hoistableScripts,f=Za(t),h=l.get(f);h||(h=i.querySelector(nr(f)),h||(t=g({src:t,async:!0},u),(u=fn.get(f))&&Yo(t,u),h=i.createElement("script"),bt(h),Ot(h,"link",t),i.head.appendChild(h)),h={type:"script",instance:h,count:1,state:null},l.set(f,h))}}function p2(t,u){nu.M(t,u);var i=Xa;if(i&&t){var l=ga(i).hoistableScripts,f=Za(t),h=l.get(f);h||(h=i.querySelector(nr(f)),h||(t=g({src:t,async:!0,type:"module"},u),(u=fn.get(f))&&Yo(t,u),h=i.createElement("script"),bt(h),Ot(h,"link",t),i.head.appendChild(h)),h={type:"script",instance:h,count:1,state:null},l.set(f,h))}}function np(t,u,i,l){var f=(f=ge.current)?Fl(f):null;if(!f)throw Error(r(446));switch(t){case"meta":case"title":return null;case"style":return typeof i.precedence=="string"&&typeof i.href=="string"?(u=Ka(i.href),i=ga(f).hoistableStyles,l=i.get(u),l||(l={type:"style",instance:null,count:0,state:null},i.set(u,l)),l):{type:"void",instance:null,count:0,state:null};case"link":if(i.rel==="stylesheet"&&typeof i.href=="string"&&typeof i.precedence=="string"){t=Ka(i.href);var h=ga(f).hoistableStyles,b=h.get(t);if(b||(f=f.ownerDocument||f,b={type:"stylesheet",instance:null,count:0,state:{loading:0,preload:null}},h.set(t,b),(h=f.querySelector(tr(t)))&&!h._p&&(b.instance=h,b.state.loading=5),fn.has(t)||(i={rel:"preload",as:"style",href:i.href,crossOrigin:i.crossOrigin,integrity:i.integrity,media:i.media,hrefLang:i.hrefLang,referrerPolicy:i.referrerPolicy},fn.set(t,i),h||E2(f,t,i,b.state))),u&&l===null)throw Error(r(528,""));return b}if(u&&l!==null)throw Error(r(529,""));return null;case"script":return u=i.async,i=i.src,typeof i=="string"&&u&&typeof u!="function"&&typeof u!="symbol"?(u=Za(i),i=ga(f).hoistableScripts,l=i.get(u),l||(l={type:"script",instance:null,count:0,state:null},i.set(u,l)),l):{type:"void",instance:null,count:0,state:null};default:throw Error(r(444,t))}}function Ka(t){return'href="'+nn(t)+'"'}function tr(t){return'link[rel="stylesheet"]['+t+"]"}function up(t){return g({},t,{"data-precedence":t.precedence,precedence:null})}function E2(t,u,i,l){t.querySelector('link[rel="preload"][as="style"]['+u+"]")?l.loading=1:(u=t.createElement("link"),l.preload=u,u.addEventListener("load",function(){return l.loading|=1}),u.addEventListener("error",function(){return l.loading|=2}),Ot(u,"link",i),bt(u),t.head.appendChild(u))}function Za(t){return'[src="'+nn(t)+'"]'}function nr(t){return"script[async]"+t}function ap(t,u,i){if(u.count++,u.instance===null)switch(u.type){case"style":var l=t.querySelector('style[data-href~="'+nn(i.href)+'"]');if(l)return u.instance=l,bt(l),l;var f=g({},i,{"data-href":i.href,"data-precedence":i.precedence,href:null,precedence:null});return l=(t.ownerDocument||t).createElement("style"),bt(l),Ot(l,"style",f),zl(l,i.precedence,t),u.instance=l;case"stylesheet":f=Ka(i.href);var h=t.querySelector(tr(f));if(h)return u.state.loading|=4,u.instance=h,bt(h),h;l=up(i),(f=fn.get(f))&&zo(l,f),h=(t.ownerDocument||t).createElement("link"),bt(h);var b=h;return b._p=new Promise(function(_,D){b.onload=_,b.onerror=D}),Ot(h,"link",l),u.state.loading|=4,zl(h,i.precedence,t),u.instance=h;case"script":return h=Za(i.src),(f=t.querySelector(nr(h)))?(u.instance=f,bt(f),f):(l=i,(f=fn.get(h))&&(l=g({},i),Yo(l,f)),t=t.ownerDocument||t,f=t.createElement("script"),bt(f),Ot(f,"link",l),t.head.appendChild(f),u.instance=f);case"void":return null;default:throw Error(r(443,u.type))}else u.type==="stylesheet"&&(u.state.loading&4)===0&&(l=u.instance,u.state.loading|=4,zl(l,i.precedence,t));return u.instance}function zl(t,u,i){for(var l=i.querySelectorAll('link[rel="stylesheet"][data-precedence],style[data-precedence]'),f=l.length?l[l.length-1]:null,h=f,b=0;b title"):null)}function g2(t,u,i){if(i===1||u.itemProp!=null)return!1;switch(t){case"meta":case"title":return!0;case"style":if(typeof u.precedence!="string"||typeof u.href!="string"||u.href==="")break;return!0;case"link":if(typeof u.rel!="string"||typeof u.href!="string"||u.href===""||u.onLoad||u.onError)break;switch(u.rel){case"stylesheet":return t=u.disabled,typeof u.precedence=="string"&&t==null;default:return!0}case"script":if(u.async&&typeof u.async!="function"&&typeof u.async!="symbol"&&!u.onLoad&&!u.onError&&u.src&&typeof u.src=="string")return!0}return!1}function lp(t){return!(t.type==="stylesheet"&&(t.state.loading&3)===0)}function T2(t,u,i,l){if(i.type==="stylesheet"&&(typeof l.media!="string"||matchMedia(l.media).matches!==!1)&&(i.state.loading&4)===0){if(i.instance===null){var f=Ka(l.href),h=u.querySelector(tr(f));if(h){u=h._p,u!==null&&typeof u=="object"&&typeof u.then=="function"&&(t.count++,t=ql.bind(t),u.then(t,t)),i.state.loading|=4,i.instance=h,bt(h);return}h=u.ownerDocument||u,l=up(l),(f=fn.get(f))&&zo(l,f),h=h.createElement("link"),bt(h);var b=h;b._p=new Promise(function(_,D){b.onload=_,b.onerror=D}),Ot(h,"link",l),i.instance=h}t.stylesheets===null&&(t.stylesheets=new Map),t.stylesheets.set(i,u),(u=i.state.preload)&&(i.state.loading&3)===0&&(t.count++,i=ql.bind(t),u.addEventListener("load",i),u.addEventListener("error",i))}}var qo=0;function b2(t,u){return t.stylesheets&&t.count===0&&Gl(t,t.stylesheets),0qo?50:800)+u);return t.unsuspend=i,function(){t.unsuspend=null,clearTimeout(l),clearTimeout(f)}}:null}function ql(){if(this.count--,this.count===0&&(this.imgCount===0||!this.waitingForImages)){if(this.stylesheets)Gl(this,this.stylesheets);else if(this.unsuspend){var t=this.unsuspend;this.unsuspend=null,t()}}}var jl=null;function Gl(t,u){t.stylesheets=null,t.unsuspend!==null&&(t.count++,jl=new Map,u.forEach(y2,t),jl=null,ql.call(t))}function y2(t,u){if(!(u.state.loading&4)){var i=jl.get(t);if(i)var l=i.get(null);else{i=new Map,jl.set(t,i);for(var f=t.querySelectorAll("link[data-precedence],style[data-precedence]"),h=0;h"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(e)}catch(n){console.error(n)}}return e(),Wo.exports=B2(),Wo.exports}var H2=U2();/** + * react-router v7.13.1 + * + * Copyright (c) Remix Software Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE.md file in the root directory of this source tree. + * + * @license MIT + */var Lp="popstate";function Ip(e){return typeof e=="object"&&e!=null&&"pathname"in e&&"search"in e&&"hash"in e&&"state"in e&&"key"in e}function P2(e={}){function n(r,s){var p;let c=(p=s.state)==null?void 0:p.masked,{pathname:o,search:m,hash:E}=c||r.location;return vf("",{pathname:o,search:m,hash:E},s.state&&s.state.usr||null,s.state&&s.state.key||"default",c?{pathname:r.location.pathname,search:r.location.search,hash:r.location.hash}:void 0)}function a(r,s){return typeof s=="string"?s:Ar(s)}return z2(n,a,null,e)}function at(e,n){if(e===!1||e===null||typeof e>"u")throw new Error(n)}function pn(e,n){if(!e){typeof console<"u"&&console.warn(n);try{throw new Error(n)}catch{}}}function F2(){return Math.random().toString(36).substring(2,10)}function kp(e,n){return{usr:e.state,key:e.key,idx:n,masked:e.unstable_mask?{pathname:e.pathname,search:e.search,hash:e.hash}:void 0}}function vf(e,n,a=null,r,s){return{pathname:typeof e=="string"?e:e.pathname,search:"",hash:"",...typeof n=="string"?ai(n):n,state:a,key:n&&n.key||r||F2(),unstable_mask:s}}function Ar({pathname:e="/",search:n="",hash:a=""}){return n&&n!=="?"&&(e+=n.charAt(0)==="?"?n:"?"+n),a&&a!=="#"&&(e+=a.charAt(0)==="#"?a:"#"+a),e}function ai(e){let n={};if(e){let a=e.indexOf("#");a>=0&&(n.hash=e.substring(a),e=e.substring(0,a));let r=e.indexOf("?");r>=0&&(n.search=e.substring(r),e=e.substring(0,r)),e&&(n.pathname=e)}return n}function z2(e,n,a,r={}){let{window:s=document.defaultView,v5Compat:c=!1}=r,o=s.history,m="POP",E=null,p=T();p==null&&(p=0,o.replaceState({...o.state,idx:p},""));function T(){return(o.state||{idx:null}).idx}function g(){m="POP";let w=T(),v=w==null?null:w-p;p=w,E&&E({action:m,location:k.location,delta:v})}function S(w,v){m="PUSH";let V=Ip(w)?w:vf(k.location,w,v);p=T()+1;let Q=kp(V,p),he=k.createHref(V.unstable_mask||V);try{o.pushState(Q,"",he)}catch(ie){if(ie instanceof DOMException&&ie.name==="DataCloneError")throw ie;s.location.assign(he)}c&&E&&E({action:m,location:k.location,delta:1})}function y(w,v){m="REPLACE";let V=Ip(w)?w:vf(k.location,w,v);p=T();let Q=kp(V,p),he=k.createHref(V.unstable_mask||V);o.replaceState(Q,"",he),c&&E&&E({action:m,location:k.location,delta:0})}function x(w){return Y2(w)}let k={get action(){return m},get location(){return e(s,o)},listen(w){if(E)throw new Error("A history only accepts one active listener");return s.addEventListener(Lp,g),E=w,()=>{s.removeEventListener(Lp,g),E=null}},createHref(w){return n(s,w)},createURL:x,encodeLocation(w){let v=x(w);return{pathname:v.pathname,search:v.search,hash:v.hash}},push:S,replace:y,go(w){return o.go(w)}};return k}function Y2(e,n=!1){let a="http://localhost";typeof window<"u"&&(a=window.location.origin!=="null"?window.location.origin:window.location.href),at(a,"No window.location.(origin|href) available to create URL");let r=typeof e=="string"?e:Ar(e);return r=r.replace(/ $/,"%20"),!n&&r.startsWith("//")&&(r=a+r),new URL(r,a)}function $1(e,n,a="/"){return q2(e,n,a,!1)}function q2(e,n,a,r){let s=typeof n=="string"?ai(n):n,c=au(s.pathname||"/",a);if(c==null)return null;let o=eE(e);j2(o);let m=null;for(let E=0;m==null&&E{let T={relativePath:p===void 0?o.path||"":p,caseSensitive:o.caseSensitive===!0,childrenIndex:m,route:o};if(T.relativePath.startsWith("/")){if(!T.relativePath.startsWith(r)&&E)return;at(T.relativePath.startsWith(r),`Absolute route path "${T.relativePath}" nested under path "${r}" is not valid. An absolute child route path must start with the combined path of all its parent routes.`),T.relativePath=T.relativePath.slice(r.length)}let g=kn([r,T.relativePath]),S=a.concat(T);o.children&&o.children.length>0&&(at(o.index!==!0,`Index routes must not have child routes. Please remove all child routes from route path "${g}".`),eE(o.children,n,S,g,E)),!(o.path==null&&!o.index)&&n.push({path:g,score:J2(g,o.index),routesMeta:S})};return e.forEach((o,m)=>{var E;if(o.path===""||!((E=o.path)!=null&&E.includes("?")))c(o,m);else for(let p of tE(o.path))c(o,m,!0,p)}),n}function tE(e){let n=e.split("/");if(n.length===0)return[];let[a,...r]=n,s=a.endsWith("?"),c=a.replace(/\?$/,"");if(r.length===0)return s?[c,""]:[c];let o=tE(r.join("/")),m=[];return m.push(...o.map(E=>E===""?c:[c,E].join("/"))),s&&m.push(...o),m.map(E=>e.startsWith("/")&&E===""?"/":E)}function j2(e){e.sort((n,a)=>n.score!==a.score?a.score-n.score:W2(n.routesMeta.map(r=>r.childrenIndex),a.routesMeta.map(r=>r.childrenIndex)))}var G2=/^:[\w-]+$/,Q2=3,V2=2,X2=1,K2=10,Z2=-2,Mp=e=>e==="*";function J2(e,n){let a=e.split("/"),r=a.length;return a.some(Mp)&&(r+=Z2),n&&(r+=V2),a.filter(s=>!Mp(s)).reduce((s,c)=>s+(G2.test(c)?Q2:c===""?X2:K2),r)}function W2(e,n){return e.length===n.length&&e.slice(0,-1).every((r,s)=>r===n[s])?e[e.length-1]-n[n.length-1]:0}function $2(e,n,a=!1){let{routesMeta:r}=e,s={},c="/",o=[];for(let m=0;m{if(T==="*"){let x=m[S]||"";o=c.slice(0,c.length-x.length).replace(/(.)\/+$/,"$1")}const y=m[S];return g&&!y?p[T]=void 0:p[T]=(y||"").replace(/%2F/g,"/"),p},{}),pathname:c,pathnameBase:o,pattern:e}}function ey(e,n=!1,a=!0){pn(e==="*"||!e.endsWith("*")||e.endsWith("/*"),`Route path "${e}" will be treated as if it were "${e.replace(/\*$/,"/*")}" because the \`*\` character must always follow a \`/\` in the pattern. To get rid of this warning, please change the route path to "${e.replace(/\*$/,"/*")}".`);let r=[],s="^"+e.replace(/\/*\*?$/,"").replace(/^\/*/,"/").replace(/[\\.*+^${}|()[\]]/g,"\\$&").replace(/\/:([\w-]+)(\?)?/g,(o,m,E,p,T)=>{if(r.push({paramName:m,isOptional:E!=null}),E){let g=T.charAt(p+o.length);return g&&g!=="/"?"/([^\\/]*)":"(?:/([^\\/]*))?"}return"/([^\\/]+)"}).replace(/\/([\w-]+)\?(\/|$)/g,"(/$1)?$2");return e.endsWith("*")?(r.push({paramName:"*"}),s+=e==="*"||e==="/*"?"(.*)$":"(?:\\/(.+)|\\/*)$"):a?s+="\\/*$":e!==""&&e!=="/"&&(s+="(?:(?=\\/|$))"),[new RegExp(s,n?void 0:"i"),r]}function ty(e){try{return e.split("/").map(n=>decodeURIComponent(n).replace(/\//g,"%2F")).join("/")}catch(n){return pn(!1,`The URL path "${e}" could not be decoded because it is a malformed URL segment. This is probably due to a bad percent encoding (${n}).`),e}}function au(e,n){if(n==="/")return e;if(!e.toLowerCase().startsWith(n.toLowerCase()))return null;let a=n.endsWith("/")?n.length-1:n.length,r=e.charAt(a);return r&&r!=="/"?null:e.slice(a)||"/"}var ny=/^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;function uy(e,n="/"){let{pathname:a,search:r="",hash:s=""}=typeof e=="string"?ai(e):e,c;return a?(a=a.replace(/\/\/+/g,"/"),a.startsWith("/")?c=wp(a.substring(1),"/"):c=wp(a,n)):c=n,{pathname:c,search:ry(r),hash:ly(s)}}function wp(e,n){let a=n.replace(/\/+$/,"").split("/");return e.split("/").forEach(s=>{s===".."?a.length>1&&a.pop():s!=="."&&a.push(s)}),a.length>1?a.join("/"):"/"}function nf(e,n,a,r){return`Cannot include a '${e}' character in a manually specified \`to.${n}\` field [${JSON.stringify(r)}]. Please separate it out to the \`to.${a}\` field. Alternatively you may provide the full path as a string in and the router will parse it for you.`}function ay(e){return e.filter((n,a)=>a===0||n.route.path&&n.route.path.length>0)}function Zf(e){let n=ay(e);return n.map((a,r)=>r===n.length-1?a.pathname:a.pathnameBase)}function Ts(e,n,a,r=!1){let s;typeof e=="string"?s=ai(e):(s={...e},at(!s.pathname||!s.pathname.includes("?"),nf("?","pathname","search",s)),at(!s.pathname||!s.pathname.includes("#"),nf("#","pathname","hash",s)),at(!s.search||!s.search.includes("#"),nf("#","search","hash",s)));let c=e===""||s.pathname==="",o=c?"/":s.pathname,m;if(o==null)m=a;else{let g=n.length-1;if(!r&&o.startsWith("..")){let S=o.split("/");for(;S[0]==="..";)S.shift(),g-=1;s.pathname=S.join("/")}m=g>=0?n[g]:"/"}let E=uy(s,m),p=o&&o!=="/"&&o.endsWith("/"),T=(c||o===".")&&a.endsWith("/");return!E.pathname.endsWith("/")&&(p||T)&&(E.pathname+="/"),E}var kn=e=>e.join("/").replace(/\/\/+/g,"/"),iy=e=>e.replace(/\/+$/,"").replace(/^\/*/,"/"),ry=e=>!e||e==="?"?"":e.startsWith("?")?e:"?"+e,ly=e=>!e||e==="#"?"":e.startsWith("#")?e:"#"+e,sy=class{constructor(e,n,a,r=!1){this.status=e,this.statusText=n||"",this.internal=r,a instanceof Error?(this.data=a.toString(),this.error=a):this.data=a}};function cy(e){return e!=null&&typeof e.status=="number"&&typeof e.statusText=="string"&&typeof e.internal=="boolean"&&"data"in e}function oy(e){return e.map(n=>n.route.path).filter(Boolean).join("/").replace(/\/\/*/g,"/")||"/"}var nE=typeof window<"u"&&typeof window.document<"u"&&typeof window.document.createElement<"u";function uE(e,n){let a=e;if(typeof a!="string"||!ny.test(a))return{absoluteURL:void 0,isExternal:!1,to:a};let r=a,s=!1;if(nE)try{let c=new URL(window.location.href),o=a.startsWith("//")?new URL(c.protocol+a):new URL(a),m=au(o.pathname,n);o.origin===c.origin&&m!=null?a=m+o.search+o.hash:s=!0}catch{pn(!1,` contains an invalid URL which will probably break when clicked - please update to a valid URL path.`)}return{absoluteURL:r,isExternal:s,to:a}}Object.getOwnPropertyNames(Object.prototype).sort().join("\0");var aE=["POST","PUT","PATCH","DELETE"];new Set(aE);var fy=["GET",...aE];new Set(fy);var ii=B.createContext(null);ii.displayName="DataRouter";var bs=B.createContext(null);bs.displayName="DataRouterState";var hy=B.createContext(!1),iE=B.createContext({isTransitioning:!1});iE.displayName="ViewTransition";var dy=B.createContext(new Map);dy.displayName="Fetchers";var my=B.createContext(null);my.displayName="Await";var en=B.createContext(null);en.displayName="Navigation";var Or=B.createContext(null);Or.displayName="Location";var Cn=B.createContext({outlet:null,matches:[],isDataRoute:!1});Cn.displayName="Route";var Jf=B.createContext(null);Jf.displayName="RouteError";var rE="REACT_ROUTER_ERROR",py="REDIRECT",Ey="ROUTE_ERROR_RESPONSE";function gy(e){if(e.startsWith(`${rE}:${py}:{`))try{let n=JSON.parse(e.slice(28));if(typeof n=="object"&&n&&typeof n.status=="number"&&typeof n.statusText=="string"&&typeof n.location=="string"&&typeof n.reloadDocument=="boolean"&&typeof n.replace=="boolean")return n}catch{}}function Ty(e){if(e.startsWith(`${rE}:${Ey}:{`))try{let n=JSON.parse(e.slice(40));if(typeof n=="object"&&n&&typeof n.status=="number"&&typeof n.statusText=="string")return new sy(n.status,n.statusText,n.data)}catch{}}function by(e,{relative:n}={}){at(ri(),"useHref() may be used only in the context of a component.");let{basename:a,navigator:r}=B.useContext(en),{hash:s,pathname:c,search:o}=Rr(e,{relative:n}),m=c;return a!=="/"&&(m=c==="/"?a:kn([a,c])),r.createHref({pathname:m,search:o,hash:s})}function ri(){return B.useContext(Or)!=null}function wn(){return at(ri(),"useLocation() may be used only in the context of a component."),B.useContext(Or).location}var lE="You should call navigate() in a React.useEffect(), not when your component is first rendered.";function sE(e){B.useContext(en).static||B.useLayoutEffect(e)}function Wf(){let{isDataRoute:e}=B.useContext(Cn);return e?ky():yy()}function yy(){at(ri(),"useNavigate() may be used only in the context of a component.");let e=B.useContext(ii),{basename:n,navigator:a}=B.useContext(en),{matches:r}=B.useContext(Cn),{pathname:s}=wn(),c=JSON.stringify(Zf(r)),o=B.useRef(!1);return sE(()=>{o.current=!0}),B.useCallback((E,p={})=>{if(pn(o.current,lE),!o.current)return;if(typeof E=="number"){a.go(E);return}let T=Ts(E,JSON.parse(c),s,p.relative==="path");e==null&&n!=="/"&&(T.pathname=T.pathname==="/"?n:kn([n,T.pathname])),(p.replace?a.replace:a.push)(T,p.state,p)},[n,a,c,s,e])}B.createContext(null);function _y(){let{matches:e}=B.useContext(Cn),n=e[e.length-1];return n?n.params:{}}function Rr(e,{relative:n}={}){let{matches:a}=B.useContext(Cn),{pathname:r}=wn(),s=JSON.stringify(Zf(a));return B.useMemo(()=>Ts(e,JSON.parse(s),r,n==="path"),[e,s,r,n])}function Sy(e,n){return cE(e,n)}function cE(e,n,a){var w;at(ri(),"useRoutes() may be used only in the context of a component.");let{navigator:r}=B.useContext(en),{matches:s}=B.useContext(Cn),c=s[s.length-1],o=c?c.params:{},m=c?c.pathname:"/",E=c?c.pathnameBase:"/",p=c&&c.route;{let v=p&&p.path||"";fE(m,!p||v.endsWith("*")||v.endsWith("*?"),`You rendered descendant (or called \`useRoutes()\`) at "${m}" (under ) but the parent route path has no trailing "*". This means if you navigate deeper, the parent won't match anymore and therefore the child routes will never render. + +Please change the parent to .`)}let T=wn(),g;if(n){let v=typeof n=="string"?ai(n):n;at(E==="/"||((w=v.pathname)==null?void 0:w.startsWith(E)),`When overriding the location using \`\` or \`useRoutes(routes, location)\`, the location pathname must begin with the portion of the URL pathname that was matched by all parent routes. The current pathname base is "${E}" but pathname "${v.pathname}" was given in the \`location\` prop.`),g=v}else g=T;let S=g.pathname||"/",y=S;if(E!=="/"){let v=E.replace(/^\//,"").split("/");y="/"+S.replace(/^\//,"").split("/").slice(v.length).join("/")}let x=$1(e,{pathname:y});pn(p||x!=null,`No routes matched location "${g.pathname}${g.search}${g.hash}" `),pn(x==null||x[x.length-1].route.element!==void 0||x[x.length-1].route.Component!==void 0||x[x.length-1].route.lazy!==void 0,`Matched leaf route at location "${g.pathname}${g.search}${g.hash}" does not have an element or Component. This means it will render an with a null value by default resulting in an "empty" page.`);let k=Oy(x&&x.map(v=>Object.assign({},v,{params:Object.assign({},o,v.params),pathname:kn([E,r.encodeLocation?r.encodeLocation(v.pathname.replace(/\?/g,"%3F").replace(/#/g,"%23")).pathname:v.pathname]),pathnameBase:v.pathnameBase==="/"?E:kn([E,r.encodeLocation?r.encodeLocation(v.pathnameBase.replace(/\?/g,"%3F").replace(/#/g,"%23")).pathname:v.pathnameBase])})),s,a);return n&&k?B.createElement(Or.Provider,{value:{location:{pathname:"/",search:"",hash:"",state:null,key:"default",unstable_mask:void 0,...g},navigationType:"POP"}},k):k}function Ay(){let e=Iy(),n=cy(e)?`${e.status} ${e.statusText}`:e instanceof Error?e.message:JSON.stringify(e),a=e instanceof Error?e.stack:null,r="rgba(200,200,200, 0.5)",s={padding:"0.5rem",backgroundColor:r},c={padding:"2px 4px",backgroundColor:r},o=null;return console.error("Error handled by React Router default ErrorBoundary:",e),o=B.createElement(B.Fragment,null,B.createElement("p",null,"💿 Hey developer 👋"),B.createElement("p",null,"You can provide a way better UX than this when your app throws errors by providing your own ",B.createElement("code",{style:c},"ErrorBoundary")," or"," ",B.createElement("code",{style:c},"errorElement")," prop on your route.")),B.createElement(B.Fragment,null,B.createElement("h2",null,"Unexpected Application Error!"),B.createElement("h3",{style:{fontStyle:"italic"}},n),a?B.createElement("pre",{style:s},a):null,o)}var Cy=B.createElement(Ay,null),oE=class extends B.Component{constructor(e){super(e),this.state={location:e.location,revalidation:e.revalidation,error:e.error}}static getDerivedStateFromError(e){return{error:e}}static getDerivedStateFromProps(e,n){return n.location!==e.location||n.revalidation!=="idle"&&e.revalidation==="idle"?{error:e.error,location:e.location,revalidation:e.revalidation}:{error:e.error!==void 0?e.error:n.error,location:n.location,revalidation:e.revalidation||n.revalidation}}componentDidCatch(e,n){this.props.onError?this.props.onError(e,n):console.error("React Router caught the following error during render",e)}render(){let e=this.state.error;if(this.context&&typeof e=="object"&&e&&"digest"in e&&typeof e.digest=="string"){const a=Ty(e.digest);a&&(e=a)}let n=e!==void 0?B.createElement(Cn.Provider,{value:this.props.routeContext},B.createElement(Jf.Provider,{value:e,children:this.props.component})):this.props.children;return this.context?B.createElement(Ny,{error:e},n):n}};oE.contextType=hy;var uf=new WeakMap;function Ny({children:e,error:n}){let{basename:a}=B.useContext(en);if(typeof n=="object"&&n&&"digest"in n&&typeof n.digest=="string"){let r=gy(n.digest);if(r){let s=uf.get(n);if(s)throw s;let c=uE(r.location,a);if(nE&&!uf.get(n))if(c.isExternal||r.reloadDocument)window.location.href=c.absoluteURL||c.to;else{const o=Promise.resolve().then(()=>window.__reactRouterDataRouter.navigate(c.to,{replace:r.replace}));throw uf.set(n,o),o}return B.createElement("meta",{httpEquiv:"refresh",content:`0;url=${c.absoluteURL||c.to}`})}}return e}function xy({routeContext:e,match:n,children:a}){let r=B.useContext(ii);return r&&r.static&&r.staticContext&&(n.route.errorElement||n.route.ErrorBoundary)&&(r.staticContext._deepestRenderedBoundaryId=n.route.id),B.createElement(Cn.Provider,{value:e},a)}function Oy(e,n=[],a){let r=a==null?void 0:a.state;if(e==null){if(!r)return null;if(r.errors)e=r.matches;else if(n.length===0&&!r.initialized&&r.matches.length>0)e=r.matches;else return null}let s=e,c=r==null?void 0:r.errors;if(c!=null){let T=s.findIndex(g=>g.route.id&&(c==null?void 0:c[g.route.id])!==void 0);at(T>=0,`Could not find a matching route for errors on route IDs: ${Object.keys(c).join(",")}`),s=s.slice(0,Math.min(s.length,T+1))}let o=!1,m=-1;if(a&&r){o=r.renderFallback;for(let T=0;T=0?s=s.slice(0,m+1):s=[s[0]];break}}}}let E=a==null?void 0:a.onError,p=r&&E?(T,g)=>{var S,y;E(T,{location:r.location,params:((y=(S=r.matches)==null?void 0:S[0])==null?void 0:y.params)??{},unstable_pattern:oy(r.matches),errorInfo:g})}:void 0;return s.reduceRight((T,g,S)=>{let y,x=!1,k=null,w=null;r&&(y=c&&g.route.id?c[g.route.id]:void 0,k=g.route.errorElement||Cy,o&&(m<0&&S===0?(fE("route-fallback",!1,"No `HydrateFallback` element provided to render during initial hydration"),x=!0,w=null):m===S&&(x=!0,w=g.route.hydrateFallbackElement||null)));let v=n.concat(s.slice(0,S+1)),V=()=>{let Q;return y?Q=k:x?Q=w:g.route.Component?Q=B.createElement(g.route.Component,null):g.route.element?Q=g.route.element:Q=T,B.createElement(xy,{match:g,routeContext:{outlet:T,matches:v,isDataRoute:r!=null},children:Q})};return r&&(g.route.ErrorBoundary||g.route.errorElement||S===0)?B.createElement(oE,{location:r.location,revalidation:r.revalidation,component:k,error:y,children:V(),routeContext:{outlet:null,matches:v,isDataRoute:!0},onError:p}):V()},null)}function $f(e){return`${e} must be used within a data router. See https://reactrouter.com/en/main/routers/picking-a-router.`}function Ry(e){let n=B.useContext(ii);return at(n,$f(e)),n}function Dy(e){let n=B.useContext(bs);return at(n,$f(e)),n}function vy(e){let n=B.useContext(Cn);return at(n,$f(e)),n}function eh(e){let n=vy(e),a=n.matches[n.matches.length-1];return at(a.route.id,`${e} can only be used on routes that contain a unique "id"`),a.route.id}function Ly(){return eh("useRouteId")}function Iy(){var r;let e=B.useContext(Jf),n=Dy("useRouteError"),a=eh("useRouteError");return e!==void 0?e:(r=n.errors)==null?void 0:r[a]}function ky(){let{router:e}=Ry("useNavigate"),n=eh("useNavigate"),a=B.useRef(!1);return sE(()=>{a.current=!0}),B.useCallback(async(s,c={})=>{pn(a.current,lE),a.current&&(typeof s=="number"?await e.navigate(s):await e.navigate(s,{fromRouteId:n,...c}))},[e,n])}var Bp={};function fE(e,n,a){!n&&!Bp[e]&&(Bp[e]=!0,pn(!1,a))}B.memo(My);function My({routes:e,future:n,state:a,isStatic:r,onError:s}){return cE(e,void 0,{state:a,isStatic:r,onError:s})}function wy({to:e,replace:n,state:a,relative:r}){at(ri()," may be used only in the context of a component.");let{static:s}=B.useContext(en);pn(!s," must not be used on the initial render in a . This is a no-op, but you should modify your code so the is only ever rendered in response to some user interaction or state change.");let{matches:c}=B.useContext(Cn),{pathname:o}=wn(),m=Wf(),E=Ts(e,Zf(c),o,r==="path"),p=JSON.stringify(E);return B.useEffect(()=>{m(JSON.parse(p),{replace:n,state:a,relative:r})},[m,p,r,n,a]),null}function mr(e){at(!1,"A is only ever to be used as the child of element, never rendered directly. Please wrap your in a .")}function By({basename:e="/",children:n=null,location:a,navigationType:r="POP",navigator:s,static:c=!1,unstable_useTransitions:o}){at(!ri(),"You cannot render a inside another . You should never have more than one in your app.");let m=e.replace(/^\/*/,"/"),E=B.useMemo(()=>({basename:m,navigator:s,static:c,unstable_useTransitions:o,future:{}}),[m,s,c,o]);typeof a=="string"&&(a=ai(a));let{pathname:p="/",search:T="",hash:g="",state:S=null,key:y="default",unstable_mask:x}=a,k=B.useMemo(()=>{let w=au(p,m);return w==null?null:{location:{pathname:w,search:T,hash:g,state:S,key:y,unstable_mask:x},navigationType:r}},[m,p,T,g,S,y,r,x]);return pn(k!=null,` is not able to match the URL "${p}${T}${g}" because it does not start with the basename, so the won't render anything.`),k==null?null:B.createElement(en.Provider,{value:E},B.createElement(Or.Provider,{children:n,value:k}))}function Uy({children:e,location:n}){return Sy(Lf(e),n)}function Lf(e,n=[]){let a=[];return B.Children.forEach(e,(r,s)=>{if(!B.isValidElement(r))return;let c=[...n,s];if(r.type===B.Fragment){a.push.apply(a,Lf(r.props.children,c));return}at(r.type===mr,`[${typeof r.type=="string"?r.type:r.type.name}] is not a component. All component children of must be a or `),at(!r.props.index||!r.props.children,"An index route cannot have child routes.");let o={id:r.props.id||c.join("-"),caseSensitive:r.props.caseSensitive,element:r.props.element,Component:r.props.Component,index:r.props.index,path:r.props.path,middleware:r.props.middleware,loader:r.props.loader,action:r.props.action,hydrateFallbackElement:r.props.hydrateFallbackElement,HydrateFallback:r.props.HydrateFallback,errorElement:r.props.errorElement,ErrorBoundary:r.props.ErrorBoundary,hasErrorBoundary:r.props.hasErrorBoundary===!0||r.props.ErrorBoundary!=null||r.props.errorElement!=null,shouldRevalidate:r.props.shouldRevalidate,handle:r.props.handle,lazy:r.props.lazy};r.props.children&&(o.children=Lf(r.props.children,c)),a.push(o)}),a}var is="get",rs="application/x-www-form-urlencoded";function ys(e){return typeof HTMLElement<"u"&&e instanceof HTMLElement}function Hy(e){return ys(e)&&e.tagName.toLowerCase()==="button"}function Py(e){return ys(e)&&e.tagName.toLowerCase()==="form"}function Fy(e){return ys(e)&&e.tagName.toLowerCase()==="input"}function zy(e){return!!(e.metaKey||e.altKey||e.ctrlKey||e.shiftKey)}function Yy(e,n){return e.button===0&&(!n||n==="_self")&&!zy(e)}function If(e=""){return new URLSearchParams(typeof e=="string"||Array.isArray(e)||e instanceof URLSearchParams?e:Object.keys(e).reduce((n,a)=>{let r=e[a];return n.concat(Array.isArray(r)?r.map(s=>[a,s]):[[a,r]])},[]))}function qy(e,n){let a=If(e);return n&&n.forEach((r,s)=>{a.has(s)||n.getAll(s).forEach(c=>{a.append(s,c)})}),a}var $l=null;function jy(){if($l===null)try{new FormData(document.createElement("form"),0),$l=!1}catch{$l=!0}return $l}var Gy=new Set(["application/x-www-form-urlencoded","multipart/form-data","text/plain"]);function af(e){return e!=null&&!Gy.has(e)?(pn(!1,`"${e}" is not a valid \`encType\` for \`
\`/\`\` and will default to "${rs}"`),null):e}function Qy(e,n){let a,r,s,c,o;if(Py(e)){let m=e.getAttribute("action");r=m?au(m,n):null,a=e.getAttribute("method")||is,s=af(e.getAttribute("enctype"))||rs,c=new FormData(e)}else if(Hy(e)||Fy(e)&&(e.type==="submit"||e.type==="image")){let m=e.form;if(m==null)throw new Error('Cannot submit a