From 06d5aa072386c70af31bced6c346f5c38b37e115 Mon Sep 17 00:00:00 2001 From: forge-bot Date: Sat, 18 Jul 2026 10:06:09 +0000 Subject: [PATCH] =?UTF-8?q?[framework]=20TxCore=20=E2=86=92=20common-frame?= =?UTF-8?q?work=20(TxContext=C2=B7MessageCodec)=20(ACM-FW-001)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../acquirecore/framework/TxCoreTest.java | 298 ++++++++++++++++++ 1 file changed, 298 insertions(+) create mode 100644 boot/common-framework/src/test/java/com/klaro/acquirecore/framework/TxCoreTest.java diff --git a/boot/common-framework/src/test/java/com/klaro/acquirecore/framework/TxCoreTest.java b/boot/common-framework/src/test/java/com/klaro/acquirecore/framework/TxCoreTest.java new file mode 100644 index 0000000..c5b2aa9 --- /dev/null +++ b/boot/common-framework/src/test/java/com/klaro/acquirecore/framework/TxCoreTest.java @@ -0,0 +1,298 @@ +package com.klaro.acquirecore.framework; + +import com.klaro.acquirecore.framework.MessageCodec.JsonMessageCodec; +import org.junit.jupiter.api.Test; + +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Comprehensive tests for TxCore migration components. + */ +class TxCoreTest { + + // ===== TxResult Tests ===== + + @Test + void testTxResultCodes() { + assertEquals(0, TxCore.TxResult.OK.getCode()); + assertEquals(-1, TxCore.TxResult.ERROR.getCode()); + assertEquals(-2, TxCore.TxResult.TIMEOUT.getCode()); + assertEquals(-3, TxCore.TxResult.ROLLBACK.getCode()); + assertEquals(-4, TxCore.TxResult.NESTED.getCode()); + } + + @Test + void testTxResultFromCode() { + assertEquals(TxCore.TxResult.OK, TxCore.TxResult.fromCode(0)); + assertEquals(TxCore.TxResult.ERROR, TxCore.TxResult.fromCode(-1)); + assertEquals(TxCore.TxResult.ERROR, TxCore.TxResult.fromCode(999)); + } + + @Test + void testTxResultIsSuccess() { + assertTrue(TxCore.TxResult.OK.isSuccess()); + assertFalse(TxCore.TxResult.ERROR.isSuccess()); + assertFalse(TxCore.TxResult.ROLLBACK.isSuccess()); + } + + // ===== TxBuffer Tests ===== + + @Test + void testTxBufferWriteRead() { + TxCore.TxBuffer buffer = new TxCore.TxBuffer(); + byte[] data = "Hello, TxCore!".getBytes(); + + int written = buffer.write(data); + assertEquals(data.length, written); + assertEquals(data.length, buffer.size()); + + buffer.rewind(); + byte[] read = new byte[data.length]; + assertEquals(data.length, buffer.read(read)); + assertArrayEquals(data, read); + } + + @Test + void testTxBufferMapOperations() { + TxCore.TxBuffer buffer = new TxCore.TxBuffer(); + buffer.put("key1", "value1"); + buffer.put("key2", 42); + + assertEquals("value1", buffer.get("key1")); + assertEquals(42, buffer.get("key2")); + assertNull(buffer.get("nonexistent")); + } + + @Test + void testTxBufferClear() { + TxCore.TxBuffer buffer = new TxCore.TxBuffer(); + buffer.write("test".getBytes()); + buffer.put("key", "value"); + + buffer.clear(); + assertEquals(0, buffer.size()); + assertTrue(buffer.getData().isEmpty()); + } + + // ===== TxContext Tests ===== + + @Test + void testTxContextCreation() { + TxCore.TxContext ctx = new TxCore.TxContext(); + assertTrue(ctx.getTxnId() > 0); + assertNotNull(ctx.getBuffer()); + assertEquals(0, ctx.getFlags()); + } + + @Test + void testTxContextWithFlags() { + TxCore.TxContext ctx = new TxCore.TxContext(0x01); + assertEquals(0x01, ctx.getFlags()); + } + + @Test + void testTxContextUserData() { + TxCore.TxContext ctx = new TxCore.TxContext(); + ctx.setUserData("key1", "value1"); + ctx.setUserData("key2", 123); + + assertEquals("value1", ctx.getUserData("key1")); + assertEquals(123, ctx.getUserData("key2")); + } + + @Test + void testTxContextResetBuffer() { + TxCore.TxContext ctx = new TxCore.TxContext(); + ctx.getBuffer().write("test".getBytes()); + assertEquals(4, ctx.getBuffer().size()); + + ctx.resetBuffer(); + assertEquals(0, ctx.getBuffer().size()); + } + + // ===== TxRequest Tests ===== + + @Test + void testTxRequestCreation() { + TxCore.TxRequest request = TxCore.TxRequest.of("testService"); + assertEquals("testService", request.getServiceName()); + assertTrue(request.getPayload().isEmpty()); + } + + @Test + void testTxRequestWithPayload() { + Map payload = Map.of("key", "value", "num", 42); + TxCore.TxRequest request = TxCore.TxRequest.of("testService", payload); + assertEquals("value", request.get("key")); + assertEquals(42, request.get("num")); + } + + // ===== TxResponse Tests ===== + + @Test + void testTxResponseSuccess() { + TxCore.TxResponse response = TxCore.TxResponse.success(); + assertTrue(response.isSuccess()); + assertEquals(TxCore.TxResult.OK, response.getResult()); + } + + @Test + void testTxResponseSuccessWithData() { + Map data = Map.of("result", "ok"); + TxCore.TxResponse response = TxCore.TxResponse.success(data); + assertTrue(response.isSuccess()); + assertEquals("ok", response.get("result")); + } + + @Test + void testTxResponseError() { + TxCore.TxResponse response = TxCore.TxResponse.error(TxCore.TxResult.ERROR, "Test error"); + assertFalse(response.isSuccess()); + assertEquals("Test error", response.getErrorMessage()); + } + + @Test + void testTxResponseWith() { + TxCore.TxResponse response = TxCore.TxResponse.success(); + TxCore.TxResponse newResponse = response.with("key", "value"); + assertEquals("value", newResponse.get("key")); + } + + // ===== MessageCodec Tests ===== + + @Test + void testJsonMessageCodecRequest() { + JsonMessageCodec codec = new JsonMessageCodec(); + TxCore.TxRequest original = TxCore.TxRequest.of("testService", Map.of("key", "value")); + + byte[] encoded = codec.encodeRequest(original); + TxCore.TxRequest decoded = codec.decodeRequest(encoded); + + assertEquals(original.getServiceName(), decoded.getServiceName()); + assertEquals("value", decoded.get("key")); + } + + @Test + void testJsonMessageCodecResponse() { + JsonMessageCodec codec = new JsonMessageCodec(); + TxCore.TxResponse original = TxCore.TxResponse.success(Map.of("result", 42)); + + byte[] encoded = codec.encodeResponse(original); + TxCore.TxResponse decoded = codec.decodeResponse(encoded); + + assertEquals(original.getResult(), decoded.getResult()); + assertEquals(42, decoded.get("result")); + } + + @Test + void testJsonMessageCodecContentType() { + assertEquals("application/json", new JsonMessageCodec().getContentType()); + } + + // ===== TxServiceRegistry Tests ===== + + @Test + void testServiceRegistryRegisterAndLookup() { + TxServiceRegistry registry = new TxServiceRegistry(); + TxCore.TxResponse response = TxCore.TxResponse.success(); + + registry.register("testService", req -> response, 1); + assertTrue(registry.hasService("testService")); + assertNotNull(registry.lookup("testService")); + } + + @Test + void testServiceRegistryDispatch() { + TxServiceRegistry registry = new TxServiceRegistry(); + registry.register("echoService", req -> { + String input = req.get("input"); + return TxCore.TxResponse.success(Map.of("echo", input)); + }, 1); + + TxCore.TxRequest request = TxCore.TxRequest.of("echoService", Map.of("input", "hello")); + TxCore.TxResponse response = registry.dispatch("echoService", request); + + assertTrue(response.isSuccess()); + assertEquals("hello", response.get("echo")); + } + + @Test + void testServiceRegistryDispatchNotFound() { + TxServiceRegistry registry = new TxServiceRegistry(); + TxCore.TxRequest request = TxCore.TxRequest.of("nonexistent"); + TxCore.TxResponse response = registry.dispatch("nonexistent", request); + + assertFalse(response.isSuccess()); + assertTrue(response.getErrorMessage().contains("not found")); + } + + @Test + void testServiceRegistryUnregister() { + TxServiceRegistry registry = new TxServiceRegistry(); + registry.register("toRemove", req -> TxCore.TxResponse.success(), 1); + assertTrue(registry.hasService("toRemove")); + + registry.unregister("toRemove"); + assertFalse(registry.hasService("toRemove")); + } + + // ===== TxTemplate Tests ===== + + @Test + void testTxTemplateBegin() { + TxServiceRegistry registry = new TxServiceRegistry(); + TxTemplate template = new TxTemplate(registry); + + TxCore.TxContext ctx = template.begin(); + assertNotNull(ctx); + assertTrue(ctx.getTxnId() > 0); + } + + @Test + void testTxTemplateExecute() { + TxServiceRegistry registry = new TxServiceRegistry(); + TxTemplate template = new TxTemplate(registry); + TxCore.TxContext ctx = template.begin(); + + String result = template.execute(ctx, c -> { + c.setUserData("key", "value"); + return "success"; + }); + + assertEquals("success", result); + assertEquals("value", ctx.getUserData("key")); + } + + @Test + void testTxTemplateExecuteWithRollback() { + TxServiceRegistry registry = new TxServiceRegistry(); + TxTemplate template = new TxTemplate(registry); + TxCore.TxContext ctx = template.begin(); + ctx.getBuffer().write("test".getBytes()); + + assertThrows(RuntimeException.class, () -> { + template.execute(ctx, c -> { + throw new RuntimeException("test error"); + }); + }); + + assertEquals(0, ctx.getBuffer().size()); + } + + @Test + void testTxTemplateDispatch() { + TxServiceRegistry registry = new TxServiceRegistry(); + registry.register("testService", req -> { + String input = req.get("input"); + return TxCore.TxResponse.success(Map.of("output", input + "-processed")); + }, 1); + + TxTemplate template = new TxTemplate(registry); + TxCore.TxResponse response = template.dispatch("testService", "testOp", "hello"); + + assertTrue(response.isSuccess()); + assertEquals("hello-processed", response.get("output")); + } +}