Merge remote-tracking branch 'remotes/origin/feature/RM-6873_RemoveActiveContentFromHold' into feature/RM-6911_AddActiveContentToHoldRestAPI

rm-community/rm-community-repo/source/java/org/alfresco/module/org_alfresco_module_rm/model/rma/aspect/FrozenAspect.java

@@ -190,35 +190,33 @@ public class FrozenAspect extends    BaseBehaviourBean
             kind = BehaviourKind.CLASS,
             notificationFrequency = NotificationFrequency.TRANSACTION_COMMIT
     )
-    public void onRemoveAspect(final NodeRef record, QName aspectTypeQName)
+    public void onRemoveAspect(final NodeRef nodeRef, QName aspectTypeQName)
     {
         AuthenticationUtil.runAsSystem(new RunAsWork<Void>()
         {
             @Override
             public Void doWork()
             {
-                if (nodeService.exists(record) &&
+                if (nodeService.exists(nodeRef) &&
-                    isRecord(record))
+                        (isRecord(nodeRef) || instanceOf(nodeRef, TYPE_CONTENT)))
                 {
-                    // get the owning record folder
+                    // get the owning folder
-                    NodeRef recordFolder = nodeService.getPrimaryParent(record).getParentRef();
+                    NodeRef owningFolder = nodeService.getPrimaryParent(nodeRef).getParentRef();
         
                     // check that the aspect has been added
-                    if (nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN))
+                    if (nodeService.hasAspect(owningFolder, ASPECT_HELD_CHILDREN))
                     {
                         // decrement current count
-                        int currentCount = (Integer)nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT);
+                        int currentCount = (Integer)nodeService.getProperty(owningFolder, PROP_HELD_CHILDREN_COUNT);
                         if (currentCount > 0)
                         {
-                            currentCount = currentCount - 1;
+                            nodeService.setProperty(owningFolder, PROP_HELD_CHILDREN_COUNT, currentCount - 1 );
-                            nodeService.setProperty(recordFolder, PROP_HELD_CHILDREN_COUNT, currentCount);
                         }
                     }                   
                 }
                 return null;
             }
         });
-        
     }
 
 }

rm-community/rm-community-repo/test/java/org/alfresco/module/org_alfresco_module_rm/test/integration/hold/RemoveActiveContentToHoldTest.java

@@ -0,0 +1,194 @@
+/*
+ * #%L
+ * Alfresco Records Management Module
+ * %%
+ * Copyright (C) 2005 - 2019 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * -
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ * -
+ * Alfresco is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * -
+ * Alfresco is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * -
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ * #L%
+ */
+package org.alfresco.module.org_alfresco_module_rm.test.integration.hold;
+
+import static org.alfresco.repo.security.authentication.AuthenticationUtil.getAdminUserName;
+
+import org.alfresco.module.org_alfresco_module_rm.test.util.BaseRMTestCase;
+import org.alfresco.repo.security.authentication.AuthenticationUtil;
+import org.alfresco.repo.security.authentication.AuthenticationUtil.RunAsWork;
+import org.alfresco.repo.security.permissions.AccessDeniedException;
+import org.alfresco.repo.site.SiteModel;
+import org.alfresco.service.cmr.repository.NodeRef;
+import org.springframework.extensions.webscripts.GUID;
+
+/**
+ * Remove Active Content To Hold Integration Tests
+ *
+ * @author Ross Gale
+ * @since 3.2
+ */
+public class RemoveActiveContentToHoldTest extends BaseRMTestCase
+{
+    @Override
+    protected boolean isCollaborationSiteTest()
+    {
+        return true;
+    }
+
+    @Override
+    protected boolean isUserTest()
+    {
+        return true;
+    }
+
+    /**
+     * Given a piece of active content on hold
+     * When I try to remove the active content from the hold
+     * Then the active content is unfrozen
+     * And the active content is not contained within the hold
+     */
+    public void testRemoveDocumentFromHold()
+    {
+        doBehaviourDrivenTest(new BehaviourDrivenTest()
+        {
+            private NodeRef hold;
+            Integer before;
+
+            public void given()
+            {
+                hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
+                holdService.addToHold(hold, dmDocument);
+            }
+
+            public void when()
+            {
+                before = (Integer) nodeService.getProperty(dmFolder, PROP_HELD_CHILDREN_COUNT);
+                holdService.removeFromHold(hold, dmDocument);
+            }
+
+            public void then()
+            {
+                // active content is no longer frozen
+                assertFalse(freezeService.isFrozen(dmDocument));
+
+                // check the content is no longer held
+                assertFalse(holdService.getHeld(hold).contains(dmDocument));
+                assertFalse(holdService.heldBy(dmDocument, true).contains(hold));
+
+                // check the held count on the folder has been reduced
+                assertTrue(before > (Integer) nodeService.getProperty(dmFolder, PROP_HELD_CHILDREN_COUNT));
+            }
+        });
+    }
+
+    /**
+     * Given a piece of active content in multiple holds
+     * When I try to remove the active content from a single hold
+     * Then the active content is still frozen
+     * And the active content is not contained within the specified hold
+     * And is still added to any other holds
+     */
+    public void testRemoveDocumentFromASingleHold()
+    {
+        doBehaviourDrivenTest(new BehaviourDrivenTest()
+        {
+            private NodeRef hold;
+            private NodeRef hold2;
+            Integer before;
+
+            public void given()
+            {
+                hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
+                hold2 = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
+                holdService.addToHold(hold, dmDocument);
+                holdService.addToHold(hold2, dmDocument);
+            }
+
+            public void when()
+            {
+                before = (Integer) nodeService.getProperty(dmFolder, PROP_HELD_CHILDREN_COUNT);
+                holdService.removeFromHold(hold, dmDocument);
+            }
+
+            public void then()
+            {
+                assertTrue(freezeService.isFrozen(dmDocument));
+                assertFalse(holdService.heldBy(dmDocument, true).contains(hold));
+                assertTrue(holdService.heldBy(dmDocument, true).contains(hold2));
+            }
+        });
+    }
+
+    /**
+     * Given a piece of active content on hold
+     * When I try to remove the active content to the hold without permission
+     * Then an access denied exception is thrown
+     */
+    public void testRemoveDocumentFromHoldFailsWithoutPermission()
+    {
+        doBehaviourDrivenTest(new BehaviourDrivenTest(AccessDeniedException.class)
+        {
+            private NodeRef hold;
+
+            public void given()
+            {
+                hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
+                holdService.addToHold(hold, dmDocument);
+            }
+
+            public void when()
+            {
+                AuthenticationUtil.runAs(
+                        (RunAsWork<Void>) () -> {
+                            holdService.removeFromHold(hold, dmDocument);
+                            return null;
+                        }, recordsManagerName );
+            }
+        });
+    }
+
+    /**
+     * Given a piece of active content on hold
+     * When I try to remove the active content to the hold without the remove hold capability
+     * Then an access denied exception is thrown
+     */
+    public void testRemoveDocumentFromHoldFailsWithoutRemoveHoldPermission()
+    {
+        doBehaviourDrivenTest(new BehaviourDrivenTest(AccessDeniedException.class, powerUserName, false)
+        {
+            private NodeRef hold;
+
+            public void given()
+            {
+                //add powerUserPerson as manager in collaboration site to have write permissions on dmDocument
+                AuthenticationUtil.runAs(
+                        (RunAsWork<Void>) () -> {
+                            siteService.setMembership(collabSiteId, powerUserName, SiteModel.SITE_MANAGER);
+                            hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
+                            holdService.addToHold(hold, dmDocument);
+                        return null;
+                        }, getAdminUserName());
+            }
+
+            public void when()
+            {
+                holdService.removeFromHold(hold, dmDocument);
+            }
+        });
+    }
+}

rm-community/rm-community-repo/unit-test/java/org/alfresco/module/org_alfresco_module_rm/model/rma/aspect/FrozenAspectUnitTest.java

@@ -0,0 +1,126 @@
+/*
+ * #%L
+ * Alfresco Records Management Module
+ * %%
+ * Copyright (C) 2005 - 2019 Alfresco Software Limited
+ * %%
+ * This file is part of the Alfresco software.
+ * -
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ * -
+ * Alfresco is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * -
+ * Alfresco is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * -
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ * #L%
+ */
+package org.alfresco.module.org_alfresco_module_rm.model.rma.aspect;
+
+import static org.alfresco.module.org_alfresco_module_rm.model.RecordsManagementModel.ASPECT_HELD_CHILDREN;
+import static org.alfresco.module.org_alfresco_module_rm.model.RecordsManagementModel.ASPECT_RECORD;
+import static org.alfresco.module.org_alfresco_module_rm.model.RecordsManagementModel.PROP_HELD_CHILDREN_COUNT;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.alfresco.model.ContentModel;
+import org.alfresco.service.cmr.dictionary.DictionaryService;
+import org.alfresco.service.cmr.repository.ChildAssociationRef;
+import org.alfresco.service.cmr.repository.NodeRef;
+import org.alfresco.service.cmr.repository.NodeService;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.context.ApplicationContext;
+
+/**
+ * Test class for frozen aspect
+ * @author Ross Gale
+ * @since 3.2
+ */
+public class FrozenAspectUnitTest
+{
+    @Mock
+    private NodeService nodeService;
+
+    @Mock
+    private ApplicationContext applicationContext;
+
+    @Mock
+    private ChildAssociationRef childAssociationRef;
+
+    @Mock
+    private DictionaryService dictionaryService;
+
+    @InjectMocks
+    private FrozenAspect frozenAspect;
+
+    private NodeRef record = new NodeRef("workspace://record/node");
+    private NodeRef folder = new NodeRef("workspace://folder/node");
+    private NodeRef content = new NodeRef("workspace://content/node");
+
+    @Before
+    public void setUp()
+    {
+        MockitoAnnotations.initMocks(this);
+        when(nodeService.exists(record)).thenReturn(true);
+        when(nodeService.exists(content)).thenReturn(true);
+        when(nodeService.hasAspect(folder, ASPECT_HELD_CHILDREN)).thenReturn(true);
+        when(nodeService.getProperty(folder, PROP_HELD_CHILDREN_COUNT)).thenReturn(1);
+        when(applicationContext.getBean("dbNodeService")).thenReturn(nodeService);
+        when(nodeService.hasAspect(folder, ASPECT_HELD_CHILDREN)).thenReturn(true);
+        when(nodeService.getProperty(folder, PROP_HELD_CHILDREN_COUNT)).thenReturn(1);
+    }
+
+    /**
+     * Test that the held count is reduced on a record folder after the frozen aspect is removed from a record
+     */
+    @Test
+    public void testRemoveAspectForRecords()
+    {
+        when(nodeService.hasAspect(record, ASPECT_RECORD)).thenReturn(true);
+        when(nodeService.getPrimaryParent(record)).thenReturn(childAssociationRef);
+        when(childAssociationRef.getParentRef()).thenReturn(folder);
+        frozenAspect.onRemoveAspect(record, null);
+        verify(nodeService, times(1)).setProperty(folder, PROP_HELD_CHILDREN_COUNT, 0);
+    }
+
+    /**
+     * Test that the held count is reduced on a folder after the frozen aspect is removed from a piece of content
+     */
+    @Test
+    public void testRemoveAspectForContent()
+    {
+        when(nodeService.hasAspect(content, ASPECT_RECORD)).thenReturn(false);
+        when(nodeService.getType(content)).thenReturn(ContentModel.TYPE_CONTENT);
+        when(nodeService.getPrimaryParent(content)).thenReturn(childAssociationRef);
+        when(childAssociationRef.getParentRef()).thenReturn(folder);
+        frozenAspect.onRemoveAspect(content, null);
+        verify(nodeService, times(1)).setProperty(folder, PROP_HELD_CHILDREN_COUNT, 0);
+    }
+
+    /**
+     * Test that the remove code is only ran for records or active content
+     */
+    @Test
+    public void testRemoveAspectForContentDoesntUpdateForOtherTypes()
+    {
+        when(nodeService.hasAspect(content, ASPECT_RECORD)).thenReturn(false);
+        when(nodeService.getType(content)).thenReturn(ContentModel.TYPE_FOLDER);
+        when(dictionaryService.isSubClass(ContentModel.TYPE_FOLDER, ContentModel.TYPE_CONTENT)).thenReturn(false);
+        frozenAspect.onRemoveAspect(content, null);
+        verify(nodeService, times(0)).setProperty(folder, PROP_HELD_CHILDREN_COUNT, 0);
+    }
+}