fix(BasicEntityMapper): ignore lists of Resources when patching object

solidify-model/src/main/java/ch/unige/solidify/util/BasicEntityMapper.java

@@ -100,7 +100,7 @@ public class BasicEntityMapper {
         this.patchResourceProperty((Resource) objectToUpdate, field, valueFromMap, typedValue);
       } else if (EmbeddableEntity.class.isAssignableFrom(propertyClass)) {
         this.patchEmbeddableEntityProperty(objectToUpdate, field, valueFromMap, typedValue);
-      } else if (!ChangeInfo.class.isAssignableFrom(field.getType())) {
+      } else if (!ChangeInfo.class.isAssignableFrom(field.getType()) && !this.ignoreListForPatch(field, objectToUpdate, typedValue)) {
         // Property is not an Entity nor an EmbeddableEntity nor a ChangeInfo --> assign value
         ReflectionUtils.setField(field, objectToUpdate, typedValue);
       }
@@ -213,4 +213,31 @@ public class BasicEntityMapper {
       return Objects.equals(field.get(objectToUpdate), field.get(newPropertiesAsObject));
     }
   }
+
+  /**
+   * Return true if the property is a List of Resources or if both lists (current and new value) are null or empty.
+   * Note: lists of Resources must be managed by using relation controllers and are ignored during patch.
+   *
+   * @param field
+   * @param objectToUpdate
+   * @param typedValue
+   * @return
+   * @throws IllegalAccessException
+   */
+  private boolean ignoreListForPatch(Field field, Object objectToUpdate, Object typedValue) throws IllegalAccessException {
+    if (List.class.isAssignableFrom(field.getType())) {
+      List<?> currentList = (List) field.get(objectToUpdate);
+      List<?> newList = (List) typedValue;
+
+      boolean currentListNullOrEmpty = currentList == null || currentList.isEmpty();
+      boolean newListNullOrEmpty = newList == null || newList.isEmpty();
+
+      if ((currentListNullOrEmpty && newListNullOrEmpty)
+              || (!currentListNullOrEmpty && currentList.get(0) instanceof ResourceBase)
+              || (!newListNullOrEmpty && newList.get(0) instanceof ResourceBase)) {
+        return true;
+      }
+    }
+    return false;
+  }
 }

solidify-model/src/test/java/ch/unige/solidify/test/util/BasicEntityMapperTest.java

@@ -25,12 +25,17 @@ package ch.unige.solidify.test.util;
 
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.time.DayOfWeek;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -74,6 +79,8 @@ class BasicEntityMapperTest {
     private EmbeddedEntity embeddableEntity = new EmbeddedEntity();
     private DayOfWeek dayOfWeek = DayOfWeek.MONDAY;
     private SubResourceTest subResourceTest = new SubResourceTest();
+    private List<SubResourceTest> subResourceTests = new ArrayList<>();
+    private List<String> keywords = new ArrayList<>();
 
     @Override
     public void init() {
@@ -103,6 +110,22 @@ class BasicEntityMapperTest {
     public void setSubResourceTest(SubResourceTest subResourceTest) {
       this.subResourceTest = subResourceTest;
     }
+
+    public void setSubResourceTests(List<SubResourceTest> subResourceTests) {
+      this.subResourceTests = subResourceTests;
+    }
+
+    public List<SubResourceTest> getSubResourceTests() {
+      return this.subResourceTests;
+    }
+
+    public List<String> getKeywords() {
+      return this.keywords;
+    }
+
+    public void setKeywords(List<String> keywords) {
+      this.keywords = keywords;
+    }
   }
 
   private static class SubResourceTest extends ResourceNormalized {
@@ -344,4 +367,200 @@ class BasicEntityMapperTest {
     assertEquals(subResourceResId, resourceTest.getSubResourceTest().getResId(), "resId of subResource should not have changed");
     assertEquals(description, resourceTest.getSubResourceTest().getDescription(), "description of subResource should not have changed");
   }
+
+  /**********************************************************************************************/
+
+  @Test
+  void updateNonEmptyListWithNonEmptyListOfSubResources() {
+    final ResourceTest resourceTest = new ResourceTest();
+    resourceTest.getSubResourceTests().add(new SubResourceTest());
+    resourceTest.getSubResourceTests().add(new SubResourceTest());
+    List<String> subResourceResIds = resourceTest.getSubResourceTests().stream().map(sr -> sr.getResId()).collect(Collectors.toList());
+
+    List<Map> subResourceTests = new ArrayList<>();
+    subResourceTests.add(Map.of("resId", "123-456-123-456"));
+    Map updateMap = Map.of("subResourceTests", subResourceTests);
+    assertDoesNotThrow(() -> this.basicEntityMapper.patchResource(resourceTest, updateMap));
+    assertEquals(2, resourceTest.getSubResourceTests().size());
+    assertEquals(subResourceResIds.get(0), resourceTest.getSubResourceTests().get(0).getResId());
+    assertEquals(subResourceResIds.get(1), resourceTest.getSubResourceTests().get(1).getResId());
+  }
+
+  @Test
+  void updateEmptyListWithEmptyListOfSubResources() {
+    final ResourceTest resourceTest = new ResourceTest();
+    assertEquals(0, resourceTest.getSubResourceTests().size());
+
+    List<Map> subResourceTests = new ArrayList<>();
+    Map updateMap = Map.of("subResourceTests", subResourceTests);
+    assertDoesNotThrow(() -> this.basicEntityMapper.patchResource(resourceTest, updateMap));
+    assertTrue(resourceTest.getSubResourceTests().isEmpty());
+  }
+
+  @Test
+  void updateNonEmptyListWithNullListOfSubResources() {
+    final ResourceTest resourceTest = new ResourceTest();
+    SubResourceTest subResourceTest = new SubResourceTest();
+    resourceTest.getSubResourceTests().add(subResourceTest);
+    assertEquals(1, resourceTest.getSubResourceTests().size());
+
+    Map updateMap = new HashMap();
+    updateMap.put("subResourceTests", null);
+    assertDoesNotThrow(() -> this.basicEntityMapper.patchResource(resourceTest, updateMap));
+    assertEquals(1, resourceTest.getSubResourceTests().size());
+    assertEquals(subResourceTest.getResId(), resourceTest.getSubResourceTests().get(0).getResId());
+  }
+
+  @Test
+  void updateEmptyListWithNullListOfSubResources() {
+    final ResourceTest resourceTest = new ResourceTest();
+    assertEquals(0, resourceTest.getSubResourceTests().size());
+
+    Map updateMap = new HashMap();
+    updateMap.put("subResourceTests", null);
+    assertDoesNotThrow(() -> this.basicEntityMapper.patchResource(resourceTest, updateMap));
+    assertTrue(resourceTest.getSubResourceTests().isEmpty());
+  }
+
+  @Test
+  void updateNullListWithNonEmptyListOfSubResources() {
+    final ResourceTest resourceTest = new ResourceTest();
+    resourceTest.setSubResourceTests(null);
+
+    List<Map> subResourceTests = new ArrayList<>();
+    subResourceTests.add(Map.of("resId", "123-456-123-456"));
+    Map updateMap = Map.of("subResourceTests", subResourceTests);
+    assertDoesNotThrow(() -> this.basicEntityMapper.patchResource(resourceTest, updateMap));
+    assertNull(resourceTest.getSubResourceTests());
+  }
+
+  @Test
+  void updateNullListWithEmptyListOfSubResources() {
+    final ResourceTest resourceTest = new ResourceTest();
+    resourceTest.setSubResourceTests(null);
+
+    List<Map> subResourceTests = new ArrayList<>();
+    Map updateMap = Map.of("subResourceTests", subResourceTests);
+    assertDoesNotThrow(() -> this.basicEntityMapper.patchResource(resourceTest, updateMap));
+    assertNull(resourceTest.getSubResourceTests());
+  }
+
+  @Test
+  void updateNullListWithNullListOfSubResources() {
+    final ResourceTest resourceTest = new ResourceTest();
+    resourceTest.setSubResourceTests(null);
+
+    Map updateMap = new HashMap();
+    updateMap.put("subResourceTests", null);
+    assertDoesNotThrow(() -> this.basicEntityMapper.patchResource(resourceTest, updateMap));
+    assertNull(resourceTest.getSubResourceTests());
+  }
+
+  /**********************************************************************************************/
+
+  @Test
+  void updateNonEmptyListWithNonEmptyListOfStrings() {
+    final ResourceTest resourceTest = new ResourceTest();
+    resourceTest.getKeywords().add("keyword1");
+    resourceTest.getKeywords().add("keyword2");
+
+    List<String> keywords = new ArrayList<>();
+    keywords.add("update1");
+    keywords.add("update2");
+    keywords.add("update3");
+    Map updateMap = Map.of("keywords", keywords);
+    assertDoesNotThrow(() -> this.basicEntityMapper.patchResource(resourceTest, updateMap));
+    assertEquals(keywords.size(), resourceTest.getKeywords().size());
+    assertEquals(keywords.get(0), resourceTest.getKeywords().get(0));
+    assertEquals(keywords.get(1), resourceTest.getKeywords().get(1));
+    assertEquals(keywords.get(2), resourceTest.getKeywords().get(2));
+  }
+
+  @Test
+  void updateEmptyListWithEmptyListOfStrings() {
+    final ResourceTest resourceTest = new ResourceTest();
+    assertEquals(0, resourceTest.getKeywords().size());
+
+    List<String> keywords = new ArrayList<>();
+    Map updateMap = Map.of("keywords", keywords);
+    assertDoesNotThrow(() -> this.basicEntityMapper.patchResource(resourceTest, updateMap));
+    assertTrue(resourceTest.getKeywords().isEmpty());
+  }
+
+  @Test
+  void updateNonEmptyListWithNullListOfStrings() {
+    final ResourceTest resourceTest = new ResourceTest();
+    resourceTest.getKeywords().add("keyword1");
+    resourceTest.getKeywords().add("keyword2");
+
+    Map updateMap = new HashMap();
+    updateMap.put("keywords", null);
+    assertDoesNotThrow(() -> this.basicEntityMapper.patchResource(resourceTest, updateMap));
+    assertNull(resourceTest.getKeywords());
+  }
+
+  @Test
+  void updateNonEmptyListWithEmptyListOfStrings() {
+    final ResourceTest resourceTest = new ResourceTest();
+    resourceTest.getKeywords().add("keyword1");
+    resourceTest.getKeywords().add("keyword2");
+
+    Map updateMap = new HashMap();
+    List<String> keywords = new ArrayList<>();
+    updateMap.put("keywords", keywords);
+    assertDoesNotThrow(() -> this.basicEntityMapper.patchResource(resourceTest, updateMap));
+    assertTrue(resourceTest.getKeywords().isEmpty());
+  }
+
+  @Test
+  void updateEmptyListWithNullListOfStrings() {
+    final ResourceTest resourceTest = new ResourceTest();
+    assertTrue(resourceTest.getKeywords().isEmpty());
+
+    Map updateMap = new HashMap();
+    updateMap.put("keywords", null);
+    assertDoesNotThrow(() -> this.basicEntityMapper.patchResource(resourceTest, updateMap));
+    //Note: as both list are null or empty, patchResource ignore the field --> it doesn't get null
+    assertTrue(resourceTest.getKeywords().isEmpty());
+  }
+
+  @Test
+  void updateNullListWithNonEmptyListOfStrings() {
+    final ResourceTest resourceTest = new ResourceTest();
+    resourceTest.setKeywords(null);
+
+    List<String> keywords = new ArrayList<>();
+    keywords.add("update1");
+    keywords.add("update2");
+    keywords.add("update3");
+    Map updateMap = Map.of("keywords", keywords);
+    assertDoesNotThrow(() -> this.basicEntityMapper.patchResource(resourceTest, updateMap));
+    assertNotNull(resourceTest.getKeywords());
+    assertEquals(keywords.size(), resourceTest.getKeywords().size());
+    assertEquals(keywords.get(0), resourceTest.getKeywords().get(0));
+    assertEquals(keywords.get(1), resourceTest.getKeywords().get(1));
+    assertEquals(keywords.get(2), resourceTest.getKeywords().get(2));
+  }
+
+  @Test
+  void updateNullListWithEmptyListOfStrings() {
+    final ResourceTest resourceTest = new ResourceTest();
+    resourceTest.setKeywords(null);
+
+    List<String> keywords = new ArrayList<>();
+    Map updateMap = Map.of("keywords", keywords);
+    assertDoesNotThrow(() -> this.basicEntityMapper.patchResource(resourceTest, updateMap));
+    assertNull(resourceTest.getKeywords());
+  }
+
+  @Test
+  void updateNullListWithNullListOfStrings() {
+    final ResourceTest resourceTest = new ResourceTest();
+    resourceTest.setKeywords(null);
+
+    Map updateMap = new HashMap();
+    updateMap.put("keywords", null);
+    assertDoesNotThrow(() -> this.basicEntityMapper.patchResource(resourceTest, updateMap));
+    assertNull(resourceTest.getKeywords());
+  }
 }