bugfix: do not unlock branch's lock when redo operate

apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/aop/NamespaceUnlockAspect.java

 package com.ctrip.framework.apollo.adminservice.aop;
 
 
+import com.google.common.collect.MapDifference;
 import com.google.common.collect.Maps;
 import com.google.gson.Gson;
 
@@ -35,7 +36,6 @@ import java.util.Objects;
  * --------------------------------------------
  * First operate: change k1 = v2 (lock namespace)
  * Second operate: change k1 = v1 (unlock namespace)
- *
  */
 @Aspect
 @Component
@@ -106,42 +106,52 @@ public class NamespaceUnlockAspect {
     }
 
     Map<String, String> releasedConfiguration = gson.fromJson(release.getConfigurations(), GsonType.CONFIG);
-    Map<String, String> configurationFromItems = Maps.newHashMap();
+    Map<String, String> configurationFromItems = generateConfigurationFromItems(namespace, items);
+
+    MapDifference<String, String> difference = Maps.difference(releasedConfiguration, configurationFromItems);
 
+    return !difference.areEqual();
+
+  }
+
+  private boolean hasNormalItems(List<Item> items) {
     for (Item item : items) {
-      String key = item.getKey();
-      if (StringUtils.isBlank(key)) {
-        continue;
-      }
-      //added
-      if (releasedConfiguration.get(key) == null) {
+      if (!StringUtils.isEmpty(item.getKey())) {
         return true;
       }
-      configurationFromItems.put(key, item.getValue());
     }
 
-    for (Map.Entry<String, String> entry : releasedConfiguration.entrySet()) {
-      String key = entry.getKey();
-      String value = entry.getValue();
+    return false;
+  }
+
+  private Map<String, String> generateConfigurationFromItems(Namespace namespace, List<Item> namespaceItems) {
 
-      //deleted or modified
-      if (!Objects.equals(configurationFromItems.get(key), value)) {
-        return true;
-      }
+    Map<String, String> configurationFromItems = Maps.newHashMap();
 
+    Namespace parentNamespace = namespaceService.findParentNamespace(namespace);
+    //parent namespace
+    if (parentNamespace == null) {
+      generateMapFromItems(namespaceItems, configurationFromItems);
+    } else {//child namespace
+      List<Item> parentItems = itemService.findItems(parentNamespace.getId());
+
+      generateMapFromItems(parentItems, configurationFromItems);
+      generateMapFromItems(namespaceItems, configurationFromItems);
     }
 
-    return false;
+    return configurationFromItems;
   }
 
-  private boolean hasNormalItems(List<Item> items) {
+  private Map<String, String> generateMapFromItems(List<Item> items, Map<String, String> configurationFromItems) {
     for (Item item : items) {
-      if (!StringUtils.isEmpty(item.getKey())) {
-        return true;
+      String key = item.getKey();
+      if (StringUtils.isBlank(key)) {
+        continue;
       }
+      configurationFromItems.put(key, item.getValue());
     }
 
-    return false;
+    return configurationFromItems;
   }
 
 }

apollo-adminservice/src/test/java/com/ctrip/framework/apollo/adminservice/aop/NamespaceUnlockAspectTest.java

@@ -4,6 +4,7 @@ import com.ctrip.framework.apollo.biz.entity.Item;
 import com.ctrip.framework.apollo.biz.entity.Namespace;
 import com.ctrip.framework.apollo.biz.entity.Release;
 import com.ctrip.framework.apollo.biz.service.ItemService;
+import com.ctrip.framework.apollo.biz.service.NamespaceService;
 import com.ctrip.framework.apollo.biz.service.ReleaseService;
 
 import org.junit.Assert;
@@ -26,6 +27,8 @@ public class NamespaceUnlockAspectTest {
   private ReleaseService releaseService;
   @Mock
   private ItemService itemService;
+  @Mock
+  private NamespaceService namespaceService;
 
   @InjectMocks
   private NamespaceUnlockAspect namespaceUnlockAspect;
@@ -55,6 +58,7 @@ public class NamespaceUnlockAspectTest {
 
     when(releaseService.findLatestActiveRelease(namespace)).thenReturn(release);
     when(itemService.findItems(namespaceId)).thenReturn(items);
+    when(namespaceService.findParentNamespace(namespace)).thenReturn(null);
 
     boolean isModified = namespaceUnlockAspect.isModified(namespace);
 
@@ -71,6 +75,7 @@ public class NamespaceUnlockAspectTest {
 
     when(releaseService.findLatestActiveRelease(namespace)).thenReturn(release);
     when(itemService.findItems(namespaceId)).thenReturn(items);
+    when(namespaceService.findParentNamespace(namespace)).thenReturn(null);
 
     boolean isModified = namespaceUnlockAspect.isModified(namespace);
 
@@ -87,12 +92,54 @@ public class NamespaceUnlockAspectTest {
 
     when(releaseService.findLatestActiveRelease(namespace)).thenReturn(release);
     when(itemService.findItems(namespaceId)).thenReturn(items);
+    when(namespaceService.findParentNamespace(namespace)).thenReturn(null);
 
     boolean isModified = namespaceUnlockAspect.isModified(namespace);
 
     Assert.assertTrue(isModified);
   }
 
+  @Test
+  public void testChildNamespaceModified() {
+    long childNamespaceId = 1, parentNamespaceId = 2;
+    Namespace childNamespace = createNamespace(childNamespaceId);
+    Namespace parentNamespace = createNamespace(childNamespaceId);
+
+    Release childRelease = createRelease("{\"k1\":\"v1\", \"k2\":\"v2\"}");
+    List<Item> childItems = Arrays.asList(createItem("k1", "v3"));
+    List<Item> parentItems = Arrays.asList(createItem("k1", "v1"), createItem("k2", "v2"));
+
+    when(releaseService.findLatestActiveRelease(childNamespace)).thenReturn(childRelease);
+    when(itemService.findItems(childNamespaceId)).thenReturn(childItems);
+    when(itemService.findItems(parentNamespaceId)).thenReturn(parentItems);
+    when(namespaceService.findParentNamespace(parentNamespace)).thenReturn(parentNamespace);
+
+    boolean isModified = namespaceUnlockAspect.isModified(parentNamespace);
+
+    Assert.assertTrue(isModified);
+  }
+
+  @Test
+  public void testChildNamespaceNotModified() {
+    long childNamespaceId = 1, parentNamespaceId = 2;
+    Namespace childNamespace = createNamespace(childNamespaceId);
+    Namespace parentNamespace = createNamespace(childNamespaceId);
+
+    Release childRelease = createRelease("{\"k1\":\"v1\", \"k2\":\"v2\"}");
+    List<Item> childItems = Arrays.asList(createItem("k1", "v1"));
+    List<Item> parentItems = Arrays.asList(createItem("k2", "v2"));
+
+    when(releaseService.findLatestActiveRelease(childNamespace)).thenReturn(childRelease);
+    when(itemService.findItems(childNamespaceId)).thenReturn(childItems);
+    when(itemService.findItems(parentNamespaceId)).thenReturn(parentItems);
+    when(namespaceService.findParentNamespace(parentNamespace)).thenReturn(parentNamespace);
+
+    boolean isModified = namespaceUnlockAspect.isModified(parentNamespace);
+
+    Assert.assertTrue(isModified);
+  }
+
+
   private Namespace createNamespace(long namespaceId) {
     Namespace namespace = new Namespace();
     namespace.setId(namespaceId);