fixed unit test

Author: rema-soptim

backend/src/main/java/org/rdfarchitect/api/dto/ChangeLogEntryMapper.java

@@ -25,7 +25,6 @@
 import org.rdfarchitect.models.cim.rdf.resources.RDFA;
 
 import java.lang.ref.WeakReference;
-import java.util.ArrayList;
 import java.util.List;
 
 @Mapper(componentModel = "spring")
@@ -46,7 +45,7 @@ default ContextDeltaDTO toContextDeltaDTO(ContextDelta contextDelta) {
     default List<TripleDTO> mapTriples(WeakReference<Graph> graphReference) {
         var graph = graphReference.get();
         if (graph == null) {
-            return new ArrayList<>();
+            return null;
         }
         return graph.stream()
                 .filter(triple -> !triple.getPredicate().equals(RDFA.uuid.asNode()))

backend/src/main/java/org/rdfarchitect/database/inmemory/GraphWithContextTransactional.java

@@ -41,6 +41,7 @@
 import org.slf4j.LoggerFactory;
 
 import java.lang.ref.WeakReference;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
@@ -71,7 +72,7 @@ public class GraphWithContextTransactional implements GraphContext {
     private final ConcurrentHashMap<UUID, CustomDiagram> customDiagrams = new ConcurrentHashMap<>();
 
     /** The fixed participants that are always part of every transaction. */
-    private final List<TransactionParticipant> coreTransactionParticipants;
+    private final List<RDFGraphDelta> graphParticipants;
 
     private final List<NamedRewindable> coreRewindables;
     private final AtomicInteger stepsSinceNamedCommit = new AtomicInteger(0);
@@ -94,7 +95,7 @@ public GraphWithContextTransactional(Graph base) {
         this.customSHACL =
                 new RDFGraphDelta(
                         GraphFactory.createDefaultGraph(), maxVersions, compressCount, txnContext);
-        this.coreTransactionParticipants = List.of(rdfGraph, diagramLayout, customSHACL, changeLog);
+        this.graphParticipants = List.of(rdfGraph, customSHACL);
         this.coreRewindables =
                 List.of(
                         new NamedRewindable("rdf", rdfGraph),
@@ -107,12 +108,11 @@ public GraphWithContextTransactional(Graph base) {
     // Helpers — build the effective participant / rewindable lists
     // -------------------------------------------------------------------------
 
-    /**
-     * Returns the core transaction participants. Custom diagrams are managed separately since they
-     * are not part of the undo/redo history.
-     */
-    private List<TransactionParticipant> allTransactionParticipants() {
-        return coreTransactionParticipants;
+    private List<TransactionParticipant> allParticipants() {
+        var all = new ArrayList<TransactionParticipant>(graphParticipants);
+        all.add(diagramLayout);
+        all.add(changeLog);
+        return all;
     }
 
     /**
@@ -182,9 +182,13 @@ public void commit() {
         }
         GraphUtils.enhanceWithUUIDs(rdfGraph);
         changeLog.clearRedo();
-        allTransactionParticipants().forEach(TransactionParticipant::commit);
+        if (graphParticipants.stream().anyMatch(TransactionParticipant::hasChanges)) {
+            graphParticipants.forEach(TransactionParticipant::commit);
+            stepsSinceNamedCommit.incrementAndGet();
+        }
+        diagramLayout.commit();
+        changeLog.commit();
         customDiagrams.values().forEach(CustomDiagram::commit);
-        stepsSinceNamedCommit.incrementAndGet();
         logger.debug("Context committed.");
     }
 
@@ -349,7 +353,7 @@ public void abort() {
         if (txnContext.transactionMode() == ReadWrite.READ) {
             throw new GraphTransactionException("Cannot abort a read transaction.");
         }
-        allTransactionParticipants().forEach(TransactionParticipant::abort);
+        allParticipants().forEach(TransactionParticipant::abort);
         customDiagrams.values().forEach(CustomDiagram::abort);
         logger.debug("Context aborted.");
     }
@@ -361,10 +365,9 @@ public void end() {
         }
         if (txnContext.transactionMode() == ReadWrite.WRITE
                 && !rdfGraph.isClosed()
-                && allTransactionParticipants().stream()
-                        .anyMatch(TransactionParticipant::hasChanges)) {
+                && allParticipants().stream().anyMatch(TransactionParticipant::hasChanges)) {
             logger.warn("Ending write transaction with uncommitted changes — aborting.");
-            allTransactionParticipants().forEach(TransactionParticipant::abort);
+            allParticipants().forEach(TransactionParticipant::abort);
             customDiagrams.values().forEach(CustomDiagram::abort);
         }
         var lock =

backend/src/main/java/org/rdfarchitect/models/changelog/ChangeLog.java

@@ -198,28 +198,6 @@ public void restore(UUID versionId) {
                 });
     }
 
-    /**
-     * Buffers replacing the oldest (bottom-most) entry of the undo stack with the given entry. As a
-     * side effect, the redo stack is cleared when the mutation is applied. This is used during
-     * delta compression to replace the base entry with a compressed version.
-     *
-     * <p>If the undo stack is empty when the mutation is applied, a {@link
-     * java.util.NoSuchElementException} will be thrown at commit time.
-     *
-     * @param entry the replacement entry
-     * @throws GraphNotInATransactionException if no transaction is active
-     * @throws GraphNotInAWriteTransactionException if the active transaction is read-only
-     */
-    public void replaceOldest(ChangeLogEntry entry) {
-        checkWriteTransaction();
-        pendingMutations.add(
-                () -> {
-                    undoStack.removeLast();
-                    undoStack.addLast(entry);
-                    redoStack.clear();
-                });
-    }
-
     // -------------------------------------------------------------------------
     // read queries
     // -------------------------------------------------------------------------