XWIKI-19165: Equals and hashcode are not implemented for MergeDocumentResult

  * Implements equals and hashCode in both MergeManagerResult and
    MergeDocumentResult
  * Add tests

xwiki-platform-core/xwiki-platform-store/xwiki-platform-store-merge/xwiki-platform-store-merge-api/src/main/java/org/xwiki/store/merge/MergeDocumentResult.java

@@ -23,6 +23,9 @@
 import java.util.List;
 import java.util.Map;
 
+import org.apache.commons.lang3.builder.EqualsBuilder;
+import org.apache.commons.lang3.builder.HashCodeBuilder;
+import org.apache.commons.lang3.builder.ToStringBuilder;
 import org.xwiki.bridge.DocumentModelBridge;
 import org.xwiki.diff.Conflict;
 
@@ -205,4 +208,49 @@ public List<Conflict<?>> getConflicts(DocumentPart documentPart)
         }
         return null;
     }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if (this == o) {
+            return true;
+        }
+
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        MergeDocumentResult that = (MergeDocumentResult) o;
+
+        return new EqualsBuilder()
+            .appendSuper(super.equals(o))
+            .append(currentDocument, that.currentDocument)
+            .append(previousDocument, that.previousDocument)
+            .append(nextDocument, that.nextDocument)
+            .append(mergeResults, that.mergeResults)
+            .isEquals();
+    }
+
+    @Override
+    public int hashCode()
+    {
+        return new HashCodeBuilder(95, 23)
+            .appendSuper(super.hashCode())
+            .append(currentDocument)
+            .append(previousDocument)
+            .append(nextDocument)
+            .append(mergeResults)
+            .toHashCode();
+    }
+
+    @Override
+    public String toString()
+    {
+        return new ToStringBuilder(this)
+            .append("currentDocument", currentDocument)
+            .append("previousDocument", previousDocument)
+            .append("nextDocument", nextDocument)
+            .append("mergeResults", mergeResults)
+            .toString();
+    }
 }

xwiki-platform-core/xwiki-platform-store/xwiki-platform-store-merge/xwiki-platform-store-merge-api/src/main/java/org/xwiki/store/merge/MergeManagerResult.java

@@ -22,6 +22,9 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import org.apache.commons.lang3.builder.EqualsBuilder;
+import org.apache.commons.lang3.builder.HashCodeBuilder;
+import org.apache.commons.lang3.builder.ToStringBuilder;
 import org.xwiki.diff.Conflict;
 import org.xwiki.logging.LogLevel;
 import org.xwiki.logging.LogQueue;
@@ -126,4 +129,49 @@ public boolean hasConflicts()
         // create proper conflicts, and not log errors.
         return !(this.getConflicts().isEmpty() && this.log.getLogs(LogLevel.ERROR).isEmpty());
     }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if (this == o) {
+            return true;
+        }
+
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        MergeManagerResult<?, ?> that = (MergeManagerResult<?, ?>) o;
+
+        return new EqualsBuilder()
+            .append(modified, that.modified)
+            .append(conflicts, that.conflicts)
+            .append(mergeResult, that.mergeResult)
+            // we cannot compare logs for equality, but we compare hasConflicts since it's using log error emptyness
+            .append(this.hasConflicts(), that.hasConflicts())
+            .isEquals();
+    }
+
+    @Override
+    public int hashCode()
+    {
+        return new HashCodeBuilder(69, 33)
+            .append(conflicts)
+            .append(mergeResult)
+            // we cannot compare logs for equality, but we compare hasConflicts since it's using log error emptyness
+            .append(this.hasConflicts())
+            .append(modified)
+            .toHashCode();
+    }
+
+    @Override
+    public String toString()
+    {
+        return new ToStringBuilder(this)
+            .append("conflicts", conflicts)
+            .append("mergeResult", mergeResult)
+            .append("log", log)
+            .append("modified", modified)
+            .toString();
+    }
 }

xwiki-platform-core/xwiki-platform-store/xwiki-platform-store-merge/xwiki-platform-store-merge-api/src/test/java/org/xwiki/store/merge/MergeDocumentResultTest.java

@@ -23,16 +23,20 @@
 import java.util.Collections;
 
 import org.junit.jupiter.api.Test;
+import org.xwiki.bridge.DocumentModelBridge;
 import org.xwiki.diff.Conflict;
+import org.xwiki.logging.LogQueue;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 /**
  * Tests for {@link MergeDocumentResult}.
@@ -129,4 +133,111 @@ public void putMergeResultTwice()
         });
         assertEquals("The merge result of document part [CONTENT] has already been put.", exception.getMessage());
     }
+
+    @Test
+    void equalsAndHashCode()
+    {
+        DocumentModelBridge currentDoc = mock(DocumentModelBridge.class);
+        DocumentModelBridge previousDoc = mock(DocumentModelBridge.class);
+        DocumentModelBridge nextDoc = mock(DocumentModelBridge.class);
+        DocumentModelBridge mergeResult = mock(DocumentModelBridge.class);
+
+        MergeDocumentResult mergeDocumentResult = new MergeDocumentResult(currentDoc, previousDoc, nextDoc);
+        mergeDocumentResult.setMergeResult(mergeResult);
+
+        MergeManagerResult contentResult = mock(MergeManagerResult.class);
+        when(contentResult.getLog()).thenReturn(new LogQueue());
+        mergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.CONTENT, contentResult);
+
+        MergeManagerResult xObjectsResult = mock(MergeManagerResult.class);
+        when(xObjectsResult.getLog()).thenReturn(new LogQueue());
+        mergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.XOBJECTS, xObjectsResult);
+
+        mergeDocumentResult.getLog().info("Something");
+
+        MergeDocumentResult otherMergeDocumentResult = new MergeDocumentResult(currentDoc, previousDoc, nextDoc);
+        otherMergeDocumentResult.setMergeResult(mergeResult);
+        otherMergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.CONTENT, contentResult);
+        otherMergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.XOBJECTS, xObjectsResult);
+        otherMergeDocumentResult.getLog().info("Something");
+
+        assertEquals(mergeDocumentResult, otherMergeDocumentResult);
+        assertEquals(mergeDocumentResult.hashCode(), otherMergeDocumentResult.hashCode());
+
+        // adding logs doesn't change equality, unless it's an error log
+        mergeDocumentResult.getLog().warn("Another log");
+        assertEquals(mergeDocumentResult, otherMergeDocumentResult);
+        assertEquals(mergeDocumentResult.hashCode(), otherMergeDocumentResult.hashCode());
+
+        otherMergeDocumentResult.getLog().error("SOmething's wrong");
+        assertNotEquals(mergeDocumentResult, otherMergeDocumentResult);
+        assertNotEquals(mergeDocumentResult.hashCode(), otherMergeDocumentResult.hashCode());
+
+        otherMergeDocumentResult = new MergeDocumentResult(currentDoc, previousDoc, nextDoc);
+        otherMergeDocumentResult.setMergeResult(mergeResult);
+        otherMergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.CONTENT, contentResult);
+        otherMergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.XOBJECTS, xObjectsResult);
+        otherMergeDocumentResult.getLog().info("Something");
+
+        MergeManagerResult titleResult = mock(MergeManagerResult.class);
+        when(titleResult.getLog()).thenReturn(new LogQueue());
+        otherMergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.TITLE, titleResult);
+
+        assertNotEquals(mergeDocumentResult, otherMergeDocumentResult);
+        assertNotEquals(mergeDocumentResult.hashCode(), otherMergeDocumentResult.hashCode());
+
+        otherMergeDocumentResult = new MergeDocumentResult(mock(DocumentModelBridge.class), previousDoc, nextDoc);
+        otherMergeDocumentResult.setMergeResult(mergeResult);
+        otherMergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.CONTENT, contentResult);
+        otherMergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.XOBJECTS, xObjectsResult);
+        otherMergeDocumentResult.getLog().info("Something");
+
+        assertNotEquals(mergeDocumentResult, otherMergeDocumentResult);
+        assertNotEquals(mergeDocumentResult.hashCode(), otherMergeDocumentResult.hashCode());
+
+        otherMergeDocumentResult = new MergeDocumentResult(currentDoc, mock(DocumentModelBridge.class), nextDoc);
+        otherMergeDocumentResult.setMergeResult(mergeResult);
+        otherMergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.CONTENT, contentResult);
+        otherMergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.XOBJECTS, xObjectsResult);
+        otherMergeDocumentResult.getLog().info("Something");
+
+        assertNotEquals(mergeDocumentResult, otherMergeDocumentResult);
+        assertNotEquals(mergeDocumentResult.hashCode(), otherMergeDocumentResult.hashCode());
+
+        otherMergeDocumentResult = new MergeDocumentResult(currentDoc, previousDoc, mock(DocumentModelBridge.class));
+        otherMergeDocumentResult.setMergeResult(mergeResult);
+        otherMergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.CONTENT, contentResult);
+        otherMergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.XOBJECTS, xObjectsResult);
+        otherMergeDocumentResult.getLog().info("Something");
+
+        assertNotEquals(mergeDocumentResult, otherMergeDocumentResult);
+        assertNotEquals(mergeDocumentResult.hashCode(), otherMergeDocumentResult.hashCode());
+
+        otherMergeDocumentResult = new MergeDocumentResult(currentDoc, previousDoc, nextDoc);
+        otherMergeDocumentResult.setMergeResult(mock(DocumentModelBridge.class));
+        otherMergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.CONTENT, contentResult);
+        otherMergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.XOBJECTS, xObjectsResult);
+        otherMergeDocumentResult.getLog().info("Something");
+
+        assertNotEquals(mergeDocumentResult, otherMergeDocumentResult);
+        assertNotEquals(mergeDocumentResult.hashCode(), otherMergeDocumentResult.hashCode());
+
+        otherMergeDocumentResult = new MergeDocumentResult(currentDoc, previousDoc, nextDoc);
+        otherMergeDocumentResult.setMergeResult(mergeResult);
+        otherMergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.XOBJECTS, xObjectsResult);
+        otherMergeDocumentResult.getLog().info("Something");
+
+        assertNotEquals(mergeDocumentResult, otherMergeDocumentResult);
+        assertNotEquals(mergeDocumentResult.hashCode(), otherMergeDocumentResult.hashCode());
+
+        otherMergeDocumentResult = new MergeDocumentResult(currentDoc, previousDoc, nextDoc);
+        otherMergeDocumentResult.setMergeResult(mergeResult);
+        otherMergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.CONTENT, contentResult);
+        otherMergeDocumentResult.putMergeResult(MergeDocumentResult.DocumentPart.XOBJECTS, xObjectsResult);
+        otherMergeDocumentResult.getLog().info("Something");
+        otherMergeDocumentResult.setModified(true);
+
+        assertNotEquals(mergeDocumentResult, otherMergeDocumentResult);
+        assertNotEquals(mergeDocumentResult.hashCode(), otherMergeDocumentResult.hashCode());
+    }
 }

xwiki-platform-core/xwiki-platform-store/xwiki-platform-store-merge/xwiki-platform-store-merge-api/src/test/java/org/xwiki/store/merge/MergeManagerResultTest.java

@@ -19,13 +19,18 @@
  */
 package org.xwiki.store.merge;
 
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
+import java.util.List;
 
 import org.junit.jupiter.api.Test;
+import org.xwiki.bridge.DocumentModelBridge;
 import org.xwiki.diff.Conflict;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.mock;
 
@@ -63,4 +68,77 @@ public void hasConflict()
         assertTrue(mergeManagerResult.hasConflicts());
         assertTrue(mergeManagerResult.getConflicts().isEmpty());
     }
+
+    @Test
+    void equalsAndHashCode()
+    {
+        MergeManagerResult<DocumentModelBridge, Object> mergeManagerResult = new MergeManagerResult<>();
+        MergeManagerResult<DocumentModelBridge, Object> otherMergeManager = new MergeManagerResult<>();
+        assertEquals(mergeManagerResult, otherMergeManager);
+        assertEquals(mergeManagerResult.hashCode(), otherMergeManager.hashCode());
+
+        DocumentModelBridge result = mock(DocumentModelBridge.class);
+        mergeManagerResult.setMergeResult(result);
+        otherMergeManager.setMergeResult(result);
+
+        mergeManagerResult.getLog().info("test");
+        otherMergeManager.getLog().info("test");
+
+        assertEquals(mergeManagerResult, otherMergeManager);
+        assertEquals(mergeManagerResult.hashCode(), otherMergeManager.hashCode());
+
+        // changing logs doesn't impact equals unless it's an error log on a manager without conflicts
+        otherMergeManager.getLog().info("other");
+        assertEquals(mergeManagerResult, otherMergeManager);
+        assertEquals(mergeManagerResult.hashCode(), otherMergeManager.hashCode());
+
+        otherMergeManager.getLog().error("something");
+        assertNotEquals(mergeManagerResult, otherMergeManager);
+        assertNotEquals(mergeManagerResult.hashCode(), otherMergeManager.hashCode());
+
+        otherMergeManager = new MergeManagerResult<>();
+        otherMergeManager.setMergeResult(result);
+
+        List<Conflict<Object>> conflictList = new ArrayList<>();
+        conflictList.add(mock(Conflict.class));
+        conflictList.add(mock(Conflict.class));
+
+        mergeManagerResult.addConflicts(conflictList);
+        otherMergeManager.addConflicts(conflictList);
+
+        assertEquals(mergeManagerResult, otherMergeManager);
+        assertEquals(mergeManagerResult.hashCode(), otherMergeManager.hashCode());
+
+        // error log doesn't impact equals here since there was already conflicts listed
+        otherMergeManager.getLog().error("something");
+        assertEquals(mergeManagerResult, otherMergeManager);
+        assertEquals(mergeManagerResult.hashCode(), otherMergeManager.hashCode());
+
+        otherMergeManager = new MergeManagerResult<>();
+        otherMergeManager.setMergeResult(mock(DocumentModelBridge.class));
+        otherMergeManager.addConflicts(conflictList);
+        assertNotEquals(mergeManagerResult, otherMergeManager);
+        assertNotEquals(mergeManagerResult.hashCode(), otherMergeManager.hashCode());
+
+        otherMergeManager = new MergeManagerResult<>();
+        otherMergeManager.setMergeResult(result);
+        otherMergeManager.addConflicts(Arrays.asList(mock(Conflict.class), mock(Conflict.class)));
+        assertNotEquals(mergeManagerResult, otherMergeManager);
+        assertNotEquals(mergeManagerResult.hashCode(), otherMergeManager.hashCode());
+
+        otherMergeManager = new MergeManagerResult<>();
+        otherMergeManager.setMergeResult(result);
+        assertNotEquals(mergeManagerResult, otherMergeManager);
+        assertNotEquals(mergeManagerResult.hashCode(), otherMergeManager.hashCode());
+
+        otherMergeManager = new MergeManagerResult<>();
+        otherMergeManager.setMergeResult(result);
+        otherMergeManager.addConflicts(conflictList);
+        assertEquals(mergeManagerResult, otherMergeManager);
+        assertEquals(mergeManagerResult.hashCode(), otherMergeManager.hashCode());
+
+        otherMergeManager.setModified(true);
+        assertNotEquals(mergeManagerResult, otherMergeManager);
+        assertNotEquals(mergeManagerResult.hashCode(), otherMergeManager.hashCode());
+    }
 }