From d17c97618872771e873923f5d8024694dfd1e8c5 Mon Sep 17 00:00:00 2001 From: Antonio Perez Dieppa Date: Fri, 17 Apr 2026 18:51:52 +0100 Subject: [PATCH 1/2] refactor: rolled_back in markerType --- .../java/io/flamingock/cloud/api/request/ChangeRequest.java | 2 +- .../cloud/api/vo/CloudTargetSystemAuditMarkType.java | 2 +- .../common/core/targets/TargetSystemAuditMarkType.java | 2 +- .../targetsystem/sql/SqlAuditMarkerDialectHelperTest.java | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/cloud/flamingock-cloud-api/src/main/java/io/flamingock/cloud/api/request/ChangeRequest.java b/cloud/flamingock-cloud-api/src/main/java/io/flamingock/cloud/api/request/ChangeRequest.java index fbb9b4963..1c4721e9b 100644 --- a/cloud/flamingock-cloud-api/src/main/java/io/flamingock/cloud/api/request/ChangeRequest.java +++ b/cloud/flamingock-cloud-api/src/main/java/io/flamingock/cloud/api/request/ChangeRequest.java @@ -39,7 +39,7 @@ public static ChangeRequest ongoingExecution(String id, boolean transactional) { } public static ChangeRequest ongoingRollback(String id, boolean transactional) { - return new ChangeRequest(id, CloudTargetSystemAuditMarkType.ROLLBACK, transactional); + return new ChangeRequest(id, CloudTargetSystemAuditMarkType.ROLLED_BACK, transactional); } public ChangeRequest(String id, CloudTargetSystemAuditMarkType ongoingStatus, boolean transactional) { diff --git a/cloud/flamingock-cloud-api/src/main/java/io/flamingock/cloud/api/vo/CloudTargetSystemAuditMarkType.java b/cloud/flamingock-cloud-api/src/main/java/io/flamingock/cloud/api/vo/CloudTargetSystemAuditMarkType.java index d7a287aa1..43c94ae71 100644 --- a/cloud/flamingock-cloud-api/src/main/java/io/flamingock/cloud/api/vo/CloudTargetSystemAuditMarkType.java +++ b/cloud/flamingock-cloud-api/src/main/java/io/flamingock/cloud/api/vo/CloudTargetSystemAuditMarkType.java @@ -16,5 +16,5 @@ package io.flamingock.cloud.api.vo; public enum CloudTargetSystemAuditMarkType { - NONE, APPLIED, ROLLBACK + NONE, APPLIED, ROLLED_BACK } diff --git a/core/flamingock-core-commons/src/main/java/io/flamingock/internal/common/core/targets/TargetSystemAuditMarkType.java b/core/flamingock-core-commons/src/main/java/io/flamingock/internal/common/core/targets/TargetSystemAuditMarkType.java index da33f5285..6d9faac8a 100644 --- a/core/flamingock-core-commons/src/main/java/io/flamingock/internal/common/core/targets/TargetSystemAuditMarkType.java +++ b/core/flamingock-core-commons/src/main/java/io/flamingock/internal/common/core/targets/TargetSystemAuditMarkType.java @@ -16,5 +16,5 @@ package io.flamingock.internal.common.core.targets; public enum TargetSystemAuditMarkType { - NONE, APPLIED, ROLLBACK + NONE, APPLIED, ROLLED_BACK } \ No newline at end of file diff --git a/core/target-systems/flamingock-sql-targetsystem/src/test/java/io/flamingock/targetsystem/sql/SqlAuditMarkerDialectHelperTest.java b/core/target-systems/flamingock-sql-targetsystem/src/test/java/io/flamingock/targetsystem/sql/SqlAuditMarkerDialectHelperTest.java index ef32e7189..d92f4a8d4 100644 --- a/core/target-systems/flamingock-sql-targetsystem/src/test/java/io/flamingock/targetsystem/sql/SqlAuditMarkerDialectHelperTest.java +++ b/core/target-systems/flamingock-sql-targetsystem/src/test/java/io/flamingock/targetsystem/sql/SqlAuditMarkerDialectHelperTest.java @@ -175,7 +175,7 @@ void addOngoingChangeMark(SqlDialect dialect) { // GIVEN String changeId1 = "test-change-id1"; String changeId2 = "test-change-id2"; - TargetSystemAuditMarkType operation = TargetSystemAuditMarkType.ROLLBACK; + TargetSystemAuditMarkType operation = TargetSystemAuditMarkType.ROLLED_BACK; TargetSystemAuditMark mark1 = new TargetSystemAuditMark(changeId1, operation); TargetSystemAuditMark mark2 = new TargetSystemAuditMark(changeId2, operation); @@ -221,7 +221,7 @@ void removeOngoingChangeMark(SqlDialect dialect) { // GIVEN String changeId1 = "test-change-id1"; String changeId2 = "test-change-id2"; - TargetSystemAuditMarkType operation = TargetSystemAuditMarkType.ROLLBACK; + TargetSystemAuditMarkType operation = TargetSystemAuditMarkType.ROLLED_BACK; TargetSystemAuditMark mark1 = new TargetSystemAuditMark(changeId1, operation); TargetSystemAuditMark mark2 = new TargetSystemAuditMark(changeId2, operation); From 3c6addaf590c8a0a9945574a3dad26a8f89c3120 Mon Sep 17 00:00:00 2001 From: Antonio Perez Dieppa Date: Sun, 19 Apr 2026 16:32:50 +0100 Subject: [PATCH 2/2] refactor: fix enums --- .../audit/domain/AuditContextBundle.java | 27 +++- .../audit/domain/OperationMappingTest.java | 119 ++++++++++++++++++ .../sql/SqlTargetSystemAuditMarker.java | 6 +- 3 files changed, 146 insertions(+), 6 deletions(-) create mode 100644 core/flamingock-core/src/test/java/io/flamingock/internal/core/external/store/audit/domain/OperationMappingTest.java diff --git a/core/flamingock-core/src/main/java/io/flamingock/internal/core/external/store/audit/domain/AuditContextBundle.java b/core/flamingock-core/src/main/java/io/flamingock/internal/core/external/store/audit/domain/AuditContextBundle.java index c26084841..f4ec187c4 100644 --- a/core/flamingock-core/src/main/java/io/flamingock/internal/core/external/store/audit/domain/AuditContextBundle.java +++ b/core/flamingock-core/src/main/java/io/flamingock/internal/core/external/store/audit/domain/AuditContextBundle.java @@ -35,12 +35,33 @@ public enum Operation { START_EXECUTION, EXECUTION, ROLLBACK; + private static final java.util.Map TO_MARK_TYPE; + private static final java.util.Map FROM_MARK_TYPE; + + static { + TO_MARK_TYPE = new java.util.EnumMap<>(Operation.class); + TO_MARK_TYPE.put(EXECUTION, TargetSystemAuditMarkType.APPLIED); + TO_MARK_TYPE.put(ROLLBACK, TargetSystemAuditMarkType.ROLLED_BACK); + + FROM_MARK_TYPE = new java.util.EnumMap<>(TargetSystemAuditMarkType.class); + FROM_MARK_TYPE.put(TargetSystemAuditMarkType.APPLIED, EXECUTION); + FROM_MARK_TYPE.put(TargetSystemAuditMarkType.ROLLED_BACK, ROLLBACK); + } + public TargetSystemAuditMarkType toOngoingStatusOperation() { - return TargetSystemAuditMarkType.valueOf(this.name()); + TargetSystemAuditMarkType result = TO_MARK_TYPE.get(this); + if (result == null) { + throw new IllegalArgumentException("No TargetSystemAuditMarkType mapping for Operation." + this.name()); + } + return result; } - public static AuditContextBundle.Operation fromOngoingStatusOperation(TargetSystemAuditMarkType ongoingOperation) { - return AuditContextBundle.Operation.valueOf(ongoingOperation.name()); + public static Operation fromOngoingStatusOperation(TargetSystemAuditMarkType ongoingOperation) { + Operation result = FROM_MARK_TYPE.get(ongoingOperation); + if (result == null) { + throw new IllegalArgumentException("No Operation mapping for TargetSystemAuditMarkType." + ongoingOperation.name()); + } + return result; } } diff --git a/core/flamingock-core/src/test/java/io/flamingock/internal/core/external/store/audit/domain/OperationMappingTest.java b/core/flamingock-core/src/test/java/io/flamingock/internal/core/external/store/audit/domain/OperationMappingTest.java new file mode 100644 index 000000000..13db170f3 --- /dev/null +++ b/core/flamingock-core/src/test/java/io/flamingock/internal/core/external/store/audit/domain/OperationMappingTest.java @@ -0,0 +1,119 @@ +/* + * Copyright 2026 Flamingock (https://www.flamingock.io) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.flamingock.internal.core.external.store.audit.domain; + +import io.flamingock.internal.common.core.targets.TargetSystemAuditMarkType; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; + +import static org.junit.jupiter.api.Assertions.*; + +class OperationMappingTest { + + @Test + @DisplayName("EXECUTION should map to APPLIED") + void executionMapsToApplied() { + assertEquals(TargetSystemAuditMarkType.APPLIED, + AuditContextBundle.Operation.EXECUTION.toOngoingStatusOperation()); + } + + @Test + @DisplayName("ROLLBACK should map to ROLLED_BACK") + void rollbackMapsToRolledBack() { + assertEquals(TargetSystemAuditMarkType.ROLLED_BACK, + AuditContextBundle.Operation.ROLLBACK.toOngoingStatusOperation()); + } + + @Test + @DisplayName("APPLIED should map back to EXECUTION") + void appliedMapsToExecution() { + assertEquals(AuditContextBundle.Operation.EXECUTION, + AuditContextBundle.Operation.fromOngoingStatusOperation(TargetSystemAuditMarkType.APPLIED)); + } + + @Test + @DisplayName("ROLLED_BACK should map back to ROLLBACK") + void rolledBackMapsToRollback() { + assertEquals(AuditContextBundle.Operation.ROLLBACK, + AuditContextBundle.Operation.fromOngoingStatusOperation(TargetSystemAuditMarkType.ROLLED_BACK)); + } + + @Test + @DisplayName("START_EXECUTION should throw when mapped to TargetSystemAuditMarkType") + void startExecutionHasNoMapping() { + assertThrows(IllegalArgumentException.class, + () -> AuditContextBundle.Operation.START_EXECUTION.toOngoingStatusOperation()); + } + + @Test + @DisplayName("NONE should throw when mapped to Operation") + void noneHasNoMapping() { + assertThrows(IllegalArgumentException.class, + () -> AuditContextBundle.Operation.fromOngoingStatusOperation(TargetSystemAuditMarkType.NONE)); + } + + @ParameterizedTest(name = "Every mappable Operation.{0} should round-trip through TargetSystemAuditMarkType") + @EnumSource(value = AuditContextBundle.Operation.class, names = {"EXECUTION", "ROLLBACK"}) + void operationRoundTrips(AuditContextBundle.Operation operation) { + TargetSystemAuditMarkType markType = operation.toOngoingStatusOperation(); + AuditContextBundle.Operation back = AuditContextBundle.Operation.fromOngoingStatusOperation(markType); + assertEquals(operation, back); + } + + @ParameterizedTest(name = "Every mappable TargetSystemAuditMarkType.{0} should round-trip through Operation") + @EnumSource(value = TargetSystemAuditMarkType.class, names = {"APPLIED", "ROLLED_BACK"}) + void markTypeRoundTrips(TargetSystemAuditMarkType markType) { + AuditContextBundle.Operation operation = AuditContextBundle.Operation.fromOngoingStatusOperation(markType); + TargetSystemAuditMarkType back = operation.toOngoingStatusOperation(); + assertEquals(markType, back); + } + + @Test + @DisplayName("All mappable Operations must have a mapping — fails if a new Operation is added without updating the map") + void allMappableOperationsCovered() { + int expectedMappable = 2; // EXECUTION, ROLLBACK — START_EXECUTION is intentionally unmapped + int actualMappable = 0; + for (AuditContextBundle.Operation op : AuditContextBundle.Operation.values()) { + try { + op.toOngoingStatusOperation(); + actualMappable++; + } catch (IllegalArgumentException ignored) { + } + } + assertEquals(expectedMappable, actualMappable, + "A new Operation value was added without updating the mapping in Operation. " + + "Update TO_MARK_TYPE/FROM_MARK_TYPE maps and this test."); + } + + @Test + @DisplayName("All mappable TargetSystemAuditMarkTypes must have a mapping — fails if a new value is added without updating the map") + void allMappableMarkTypesCovered() { + int expectedMappable = 2; // APPLIED, ROLLED_BACK — NONE is intentionally unmapped + int actualMappable = 0; + for (TargetSystemAuditMarkType mt : TargetSystemAuditMarkType.values()) { + try { + AuditContextBundle.Operation.fromOngoingStatusOperation(mt); + actualMappable++; + } catch (IllegalArgumentException ignored) { + } + } + assertEquals(expectedMappable, actualMappable, + "A new TargetSystemAuditMarkType value was added without updating the mapping in Operation. " + + "Update TO_MARK_TYPE/FROM_MARK_TYPE maps and this test."); + } +} diff --git a/core/target-systems/flamingock-sql-targetsystem/src/main/java/io/flamingock/targetsystem/sql/SqlTargetSystemAuditMarker.java b/core/target-systems/flamingock-sql-targetsystem/src/main/java/io/flamingock/targetsystem/sql/SqlTargetSystemAuditMarker.java index 479263b9e..2ce16160d 100644 --- a/core/target-systems/flamingock-sql-targetsystem/src/main/java/io/flamingock/targetsystem/sql/SqlTargetSystemAuditMarker.java +++ b/core/target-systems/flamingock-sql-targetsystem/src/main/java/io/flamingock/targetsystem/sql/SqlTargetSystemAuditMarker.java @@ -18,7 +18,7 @@ import io.flamingock.internal.common.core.error.FlamingockException; import io.flamingock.internal.common.sql.SqlDialect; import io.flamingock.internal.core.transaction.TransactionManager; -import io.flamingock.internal.core.external.store.audit.domain.AuditContextBundle; +import io.flamingock.internal.common.core.targets.TargetSystemAuditMarkType; import io.flamingock.internal.core.external.targets.mark.TargetSystemAuditMark; import io.flamingock.internal.core.external.targets.mark.TargetSystemAuditMarker; @@ -66,8 +66,8 @@ public Set listAll() { Set ongoingStatuses = new HashSet<>(); while (resultSet.next()) { String changeId = resultSet.getString("change_id"); - AuditContextBundle.Operation operation = AuditContextBundle.Operation.valueOf(resultSet.getString("operation")); - ongoingStatuses.add(new TargetSystemAuditMark(changeId, operation.toOngoingStatusOperation())); + TargetSystemAuditMarkType markType = TargetSystemAuditMarkType.valueOf(resultSet.getString("operation")); + ongoingStatuses.add(new TargetSystemAuditMark(changeId, markType)); } return ongoingStatuses; } catch (SQLException ex) {