union-ark-web 1.0.1

package/ark-control/src/test/java/com/union/control/ArkControlStructureContractTest.java

@@ -0,0 +1,107 @@
+package com.union.control;
+
+import org.junit.Test;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ArkControlStructureContractTest {
+
+    private static final Path JAVA_ROOT = Paths.get("src/main/java");
+
+    @Test
+    public void applicationStartsAHeadlessDubboProvider() throws Exception {
+        String application = source("com/union/control/ArkControlApplication.java");
+        String config = resource("application.yml");
+
+        assertThat(application)
+                .contains("class ArkControlApplication")
+                .contains("@MapperScan(\"com.union.control.mapper\")")
+                .contains("@EnableScheduling")
+                .contains("@ImportResource(\"classpath:dubbo-provider.xml\")");
+        assertThat(config).contains("web-environment: false");
+    }
+
+    @Test
+    public void providerPublishesEveryFacadeService() throws Exception {
+        String dubbo = resource("dubbo-provider.xml");
+        assertThat(dubbo).contains("<dubbo:provider filter=\"providerAccessLog\"");
+        for (String service : Arrays.asList(
+                "AgentExecutionService",
+                "AgentProxyService",
+                "ConversationService",
+                "MemoryStoreService",
+                "RunningAnalysisMockService",
+                "ScheduledTaskService",
+                "SensitiveDataDemoService")) {
+            assertThat(dubbo).contains(
+                    "interface=\"com.union.control.service." + service + "\"");
+        }
+        assertThat(dubbo).contains(
+                "interface=\"com.union.control.service.sensitive.SensitiveRevealService\"");
+
+        assertThat(resource("META-INF/dubbo/com.alibaba.dubbo.rpc.Filter"))
+                .contains("providerAccessLog=com.union.control.dubbo.ProviderAccessLogFilter");
+        assertThat(source("com/union/control/dubbo/ProviderAccessLogFilter.java"))
+                .contains("Dubbo provider request started")
+                .contains("Dubbo provider request completed")
+                .doesNotContain("getArguments()");
+    }
+
+    @Test
+    public void providerDoesNotExposeTheWebOnlyStream() throws Exception {
+        String dubbo = resource("dubbo-provider.xml");
+        String facade = new String(Files.readAllBytes(Paths.get(
+                "../ark-control-facade/src/main/java/com/union/control/service/AgentProxyService.java")),
+                StandardCharsets.UTF_8);
+
+        assertThat(dubbo)
+                .doesNotContain("name=\"stream\"")
+                .doesNotContain("callback=\"true\"");
+        assertThat(facade).doesNotContain("stream(").doesNotContain("AgentStreamCallback");
+    }
+
+    @Test
+    public void providerContainsNoWebControllerOrShiroBoundary() throws Exception {
+        List<Path> javaFiles = Files.walk(JAVA_ROOT)
+                .filter(Files::isRegularFile)
+                .collect(Collectors.toList());
+        String source = javaFiles.stream()
+                .map(path -> {
+                    try {
+                        return new String(Files.readAllBytes(path), StandardCharsets.UTF_8);
+                    } catch (Exception error) {
+                        throw new IllegalStateException(error);
+                    }
+                })
+                .collect(Collectors.joining("\n"));
+
+        assertThat(javaFiles.stream()
+                .map(path -> path.getFileName().toString())
+                .filter(name -> name.endsWith("Controller.java"))
+                .collect(Collectors.toList())).isEmpty();
+        assertThat(source)
+                .doesNotContain("org.apache.shiro")
+                .doesNotContain("HttpServletRequest")
+                .doesNotContain("HttpServletResponse");
+        assertThat(JAVA_ROOT.resolve("com/union/control/schedule/ScheduledTaskScheduler.java")).exists();
+        assertThat(JAVA_ROOT.resolve("com/union/control/schedule/ScheduledExecutionToken.java")).exists();
+    }
+
+    private static String source(String relative) throws Exception {
+        return new String(Files.readAllBytes(JAVA_ROOT.resolve(relative)), StandardCharsets.UTF_8);
+    }
+
+    private static String resource(String relative) throws Exception {
+        return new String(Files.readAllBytes(Paths.get("src/main/resources").resolve(relative)),
+                StandardCharsets.UTF_8);
+    }
+
+}

package/ark-control/src/test/java/com/union/control/ConversationServiceTest.java

@@ -0,0 +1,89 @@
+package com.union.control;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.union.control.mapper.AgentExecutionMapper;
+import com.union.control.mapper.ConversationMapper;
+import com.union.control.mapper.ScheduledTaskMapper;
+import com.union.control.service.impl.ConversationServiceImpl;
+import org.junit.Test;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Collections;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class ConversationServiceTest {
+    @Test
+    public void parsesAuthenticatedUserFromJsonBeforeCallingMapper() {
+        ConversationMapper conversations = mock(ConversationMapper.class);
+        AgentExecutionMapper executions = mock(AgentExecutionMapper.class);
+        ScheduledTaskMapper scheduledTasks = mock(ScheduledTaskMapper.class);
+        ConversationServiceImpl service = new ConversationServiceImpl(
+                conversations, executions, scheduledTasks, new ObjectMapper());
+        when(conversations.findConversations(TestJson.USER_ID, 20))
+                .thenReturn(Collections.emptyList());
+
+        service.conversations(TestJson.request("limit", 20));
+
+        verify(conversations).findConversations(TestJson.USER_ID, 20);
+    }
+
+    @Test
+    public void conversationDetailsLoadsExecutionsOnce() {
+        ConversationMapper conversations = mock(ConversationMapper.class);
+        AgentExecutionMapper executions = mock(AgentExecutionMapper.class);
+        when(conversations.findConversation(TestJson.USER_ID, "thread-1"))
+                .thenReturn(new java.util.LinkedHashMap<>());
+        when(executions.findExecutions(TestJson.USER_ID, "thread-1"))
+                .thenReturn(Collections.emptyList());
+        new ConversationServiceImpl(conversations, executions,
+                mock(ScheduledTaskMapper.class), new ObjectMapper())
+                .conversation(TestJson.request("conversationId", "thread-1"));
+        verify(executions).findExecutions(TestJson.USER_ID, "thread-1");
+    }
+
+    @Test
+    public void deletingConversationAlsoDeletesItsClaimedScheduledRun() {
+        ConversationMapper conversations = mock(ConversationMapper.class);
+        AgentExecutionMapper executions = mock(AgentExecutionMapper.class);
+        ScheduledTaskMapper scheduledTasks = mock(ScheduledTaskMapper.class);
+        ConversationServiceImpl service = new ConversationServiceImpl(
+                conversations, executions, scheduledTasks, new ObjectMapper());
+        when(conversations.softDeleteConversation("scheduled-7", TestJson.USER_ID))
+                .thenReturn(1);
+
+        service.deleteConversation(TestJson.request("conversationId", "scheduled-7"));
+
+        verify(scheduledTasks).softDeleteByConversation("scheduled-7", TestJson.USER_ID);
+    }
+
+    @Test
+    public void conversationMessagesRejectMissingOwnership() {
+        ConversationMapper conversations = mock(ConversationMapper.class);
+        ConversationServiceImpl service = new ConversationServiceImpl(
+                conversations, mock(AgentExecutionMapper.class),
+                mock(ScheduledTaskMapper.class), new ObjectMapper());
+        when(conversations.requireOwned("foreign-thread", TestJson.USER_ID, false))
+                .thenReturn(null);
+
+        assertThatThrownBy(() -> service.conversationMessages(
+                TestJson.request("conversationId", "foreign-thread")))
+                .isInstanceOf(java.util.NoSuchElementException.class);
+    }
+
+    @Test
+    public void claimedScheduledRunCleanupIsALogicalDelete() throws Exception {
+        String mapper = new String(Files.readAllBytes(Paths.get(
+                "src/main/resources/mapper/ScheduledTaskMapper.xml")), StandardCharsets.UTF_8);
+
+        assertTrue(mapper.contains("SET r.delete_flag=0"));
+        assertFalse(mapper.contains("DELETE FROM agent_scheduled_task_run"));
+    }
+}

package/ark-control/src/test/java/com/union/control/MemoryStoreServiceTest.java

@@ -0,0 +1,26 @@
+package com.union.control;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.union.control.mapper.MemoryStoreMapper;
+import com.union.control.service.impl.MemoryStoreServiceImpl;
+import org.junit.Test;
+
+import java.util.Collections;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class MemoryStoreServiceTest {
+    @Test
+    public void parsesAuthenticatedUserFromJsonBeforeCallingMapper() {
+        MemoryStoreMapper mapper = mock(MemoryStoreMapper.class);
+        MemoryStoreServiceImpl service = new MemoryStoreServiceImpl(mapper, new ObjectMapper());
+        String path = TestJson.USER_ID + "/personal/notes.md";
+        when(mapper.readMemory(TestJson.USER_ID, path)).thenReturn(Collections.emptyList());
+
+        service.memoryRead(TestJson.request("path", path, "maxChars", 100));
+
+        verify(mapper).readMemory(TestJson.USER_ID, path);
+    }
+}

package/ark-control/src/test/java/com/union/control/PydanticAiControlContractTest.java

@@ -0,0 +1,52 @@
+package com.union.control;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.union.control.service.impl.RunningAnalysisMockServiceImpl;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class PydanticAiControlContractTest {
+    @Test
+    public void springSelectsTheRunningAnalysisProductionConstructor() {
+        java.lang.reflect.Constructor<?>[] constructors = new AutowiredAnnotationBeanPostProcessor()
+                .determineCandidateConstructors(RunningAnalysisMockServiceImpl.class,
+                        "runningAnalysisMockService");
+
+        assertThat(constructors).hasSize(1);
+        assertThat(constructors[0].getParameterTypes()).containsExactly(ObjectMapper.class);
+    }
+
+    @Test
+    public void sharedRequestUtilitiesStayOutsideTheServicePackage() {
+        Path root = Paths.get("src/main/java/com/union/control");
+
+        assertThat(root.resolve("utils/AgentSupport.java")).exists();
+        assertThat(root.resolve("service/AgentSupport.java")).doesNotExist();
+        assertThat(root.resolve("service/ServiceExceptions.java")).doesNotExist();
+    }
+
+    @Test
+    public void serviceModuleHasNoAuthenticationRuntime() throws Exception {
+        Path root = Paths.get("src/main/java");
+        StringBuilder sources = new StringBuilder();
+        Files.walk(root).filter(path -> path.toString().endsWith(".java")).forEach(path -> {
+            try {
+                sources.append(new String(Files.readAllBytes(path), StandardCharsets.UTF_8));
+            } catch (Exception error) {
+                throw new RuntimeException(error);
+            }
+        });
+        assertThat(sources.toString())
+                .doesNotContain("org.apache.shiro")
+                .doesNotContain("AuthContextHolder")
+                .doesNotContain("currentUserId()")
+                .doesNotContain("@RequiresPermissions");
+    }
+}

package/ark-control/src/test/java/com/union/control/TestJson.java

@@ -0,0 +1,45 @@
+package com.union.control;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public final class TestJson {
+    public static final String USER_ID = "local-user";
+    public static final String ORG_CODE = "local-org";
+    public static final String ROLE_ID = "local-role";
+    private static final ObjectMapper JSON = new ObjectMapper();
+
+    private TestJson() {}
+
+    public static String request(String raw) {
+        try {
+            Map<String, Object> parsed = JSON.readValue(
+                    raw, new TypeReference<Map<String, Object>>() {});
+            return request(parsed);
+        } catch (Exception error) {
+            throw new AssertionError(error);
+        }
+    }
+
+    public static String request(Map<String, Object> values) {
+        Map<String, Object> input = new LinkedHashMap<>(values);
+        input.put("userId", USER_ID);
+        input.put("orgCode", ORG_CODE);
+        input.put("roleId", ROLE_ID);
+        try {
+            return JSON.writeValueAsString(input);
+        } catch (Exception error) {
+            throw new AssertionError(error);
+        }
+    }
+
+    public static String request(Object... entries) {
+        Map<String, Object> input = new LinkedHashMap<>();
+        for (int index = 0; index < entries.length; index += 2)
+            input.put(String.valueOf(entries[index]), entries[index + 1]);
+        return request(input);
+    }
+}

package/ark-control/src/test/java/com/union/control/dubbo/ProviderAccessLogFilterTest.java

@@ -0,0 +1,53 @@
+package com.union.control.dubbo;
+
+import ch.qos.logback.classic.Logger;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.read.ListAppender;
+import com.alibaba.dubbo.rpc.Invocation;
+import com.alibaba.dubbo.rpc.Invoker;
+import com.alibaba.dubbo.rpc.Result;
+import com.union.control.service.ConversationService;
+import org.junit.Test;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class ProviderAccessLogFilterTest {
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void logsOnlyTheRpcBoundaryAndDelegatesTheCall() {
+        Invoker<ConversationService> invoker = mock(Invoker.class);
+        Invocation invocation = mock(Invocation.class);
+        Result result = mock(Result.class);
+        when(invoker.getInterface()).thenReturn(ConversationService.class);
+        when(invocation.getMethodName()).thenReturn("conversations");
+        when(invoker.invoke(invocation)).thenReturn(result);
+
+        Logger logger = (Logger) LoggerFactory.getLogger(ProviderAccessLogFilter.class);
+        ListAppender<ILoggingEvent> appender = new ListAppender<>();
+        appender.start();
+        logger.addAppender(appender);
+        try {
+            assertThat(new ProviderAccessLogFilter().invoke(invoker, invocation)).isSameAs(result);
+        } finally {
+            logger.detachAppender(appender);
+        }
+
+        List<String> messages = appender.list.stream()
+                .map(ILoggingEvent::getFormattedMessage)
+                .collect(Collectors.toList());
+        assertThat(messages.toString())
+                .contains("request started: service=ConversationService, method=conversations")
+                .contains("request completed: service=ConversationService, method=conversations");
+        verify(invoker).invoke(invocation);
+        verify(invocation, never()).getArguments();
+    }
+}

package/ark-control/src/test/java/com/union/control/local/sensitive/LocalSensitiveProxyConfigurationTest.java

@@ -0,0 +1,23 @@
+package com.union.control.local.sensitive;
+
+import com.epcc.commons.securityproxy.api.SymmetricalSecurityService;
+import org.junit.Test;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class LocalSensitiveProxyConfigurationTest {
+
+    @Test
+    public void defaultProfileProvidesTheLocalSensitiveProxy() {
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
+        context.register(LocalSensitiveProxyConfiguration.class);
+        context.refresh();
+        try {
+            assertThat(context.getBean("sensitiveProxy"))
+                    .isInstanceOf(SymmetricalSecurityService.class);
+        } finally {
+            context.close();
+        }
+    }
+}