inteligr8/alfresco-community-repo
1
0
Fork 0
mirror of https://github.com/Alfresco/alfresco-community-repo.git synced 2025-07-31 17:39:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

RM-7034 Fixed unit tests and split class for add/remove from hold tests.

Browse Source
This commit is contained in:
Roxana Lucanu
2019-11-04 16:40:18 +02:00
parent c1b5f2a82d
commit 970bee3228
5 changed files with 697 additions and 564 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
rm-community/rm-community-repo/source/java/org/alfresco/module/org_alfresco_module_rm/hold/HoldServiceImpl.java
View File

@@ -651,7 +651,7 @@ public class HoldServiceImpl extends ServiceBaseImpl
if (!getHeld(hold).contains(nodeRef)) if (!getHeld(hold).contains(nodeRef))
{ {
// fire before add to hold policy // fire before add to hold policy
beforeAddToHoldPolicyDelegate.get(getTypeAndApsects(hold)).beforeAddToHold(hold, nodeRef); invokeBeforeAddToHold(hold, nodeRef);
// run as system to ensure we have all the appropriate permissions to perform the manipulations we require // run as system to ensure we have all the appropriate permissions to perform the manipulations we require
authenticationUtil.runAsSystem((RunAsWork<Void>) () -> { authenticationUtil.runAsSystem((RunAsWork<Void>) () -> {
// gather freeze properties // gather freeze properties
@@ -677,7 +677,7 @@ public class HoldServiceImpl extends ServiceBaseImpl
} }
// fire on add to hold policy // fire on add to hold policy
onAddToHoldPolicyDelegate.get(getTypeAndApsects(hold)).onAddToHold(hold, nodeRef); invokeOnAddToHold(hold, nodeRef);
return null; return null;
}); });
@@ -816,7 +816,7 @@ public class HoldServiceImpl extends ServiceBaseImpl
// we already know we have to have the correct capability to get here // we already know we have to have the correct capability to get here
authenticationUtil.runAsSystem((RunAsWork<Void>) () -> { authenticationUtil.runAsSystem((RunAsWork<Void>) () -> {
// fire before remove from hold policy // fire before remove from hold policy
beforeRemoveFromHoldPolicyDelegate.get(getTypeAndApsects(hold)).beforeRemoveFromHold(hold, nodeRef); invokeBeforeRemoveFromHold(hold, nodeRef);
// remove from hold // remove from hold
//set in transaction cache in order not to trigger update policy when removing the child association //set in transaction cache in order not to trigger update policy when removing the child association
transactionalResourceHelper.getSet("frozen").add(nodeRef); transactionalResourceHelper.getSet("frozen").add(nodeRef);
@@ -827,7 +827,7 @@ public class HoldServiceImpl extends ServiceBaseImpl
recordsManagementAuditService.auditEvent(nodeRef, AUDIT_REMOVE_FROM_HOLD); recordsManagementAuditService.auditEvent(nodeRef, AUDIT_REMOVE_FROM_HOLD);
// fire on remove from hold policy // fire on remove from hold policy
onRemoveFromHoldPolicyDelegate.get(getTypeAndApsects(hold)).onRemoveFromHold(hold, nodeRef); invokeOnRemoveFromHold(hold, nodeRef);
return null; return null;
@@ -939,4 +939,52 @@ public class HoldServiceImpl extends ServiceBaseImpl
} }
/**
* Invoke beforeAddToHold policy
*
* @param hold hold node reference
* @param contentNodeRef content node reference
*/
protected void invokeBeforeAddToHold(NodeRef hold, NodeRef contentNodeRef)
{
BeforeAddToHoldPolicy policy = beforeAddToHoldPolicyDelegate.get(getTypeAndApsects(hold));
policy.beforeAddToHold(hold, contentNodeRef);
}
/**
* Invoke onAddToHold policy
*
*@param hold hold node reference
*@param contentNodeRef content node reference
*/
protected void invokeOnAddToHold(NodeRef hold, NodeRef contentNodeRef)
{
OnAddToHoldPolicy policy = onAddToHoldPolicyDelegate.get(getTypeAndApsects(hold));
policy.onAddToHold(hold, contentNodeRef);
}
/**
* Invoke beforeRemoveFromHold policy
*
*@param hold hold node reference
*@param contentNodeRef content node reference
*/
protected void invokeBeforeRemoveFromHold(NodeRef hold, NodeRef contentNodeRef)
{
BeforeRemoveFromHoldPolicy policy = beforeRemoveFromHoldPolicyDelegate.get(getTypeAndApsects(hold));
policy.beforeRemoveFromHold(hold, contentNodeRef);
}
/**
* Invoke onRemoveFromHold policy
*
* @param hold hold node reference
* @param contentNodeRef content node reference
*/
protected void invokeOnRemoveFromHold(NodeRef hold, NodeRef contentNodeRef)
{
OnRemoveFromHoldPolicy policy = onRemoveFromHoldPolicyDelegate.get(getTypeAndApsects(hold));
policy.onRemoveFromHold(hold, contentNodeRef);
}
} }

560
rm-community/rm-community-repo/test/java/org/alfresco/module/org_alfresco_module_rm/test/integration/hold/AddRemoveFromHoldTest.java
View File

@@ -1,560 +0,0 @@
/*
* #%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 java.util.ArrayList;
import java.util.List;
import org.alfresco.model.ContentModel;
import org.alfresco.module.org_alfresco_module_rm.hold.HoldServicePolicies.BeforeAddToHoldPolicy;
import org.alfresco.module.org_alfresco_module_rm.hold.HoldServicePolicies.BeforeRemoveFromHoldPolicy;
import org.alfresco.module.org_alfresco_module_rm.hold.HoldServicePolicies.OnAddToHoldPolicy;
import org.alfresco.module.org_alfresco_module_rm.hold.HoldServicePolicies.OnRemoveFromHoldPolicy;
import org.alfresco.module.org_alfresco_module_rm.model.RecordsManagementModel;
import org.alfresco.module.org_alfresco_module_rm.test.util.BaseRMTestCase;
import org.alfresco.repo.policy.Behaviour.NotificationFrequency;
import org.alfresco.repo.policy.BehaviourDefinition;
import org.alfresco.repo.policy.ClassBehaviourBinding;
import org.alfresco.repo.policy.JavaBehaviour;
import org.alfresco.service.cmr.repository.NodeRef;
import org.springframework.extensions.webscripts.GUID;
/**
* Hold service integration test.
*
* @author Roy Wetherall
* @since 2.2
*/
public class AddRemoveFromHoldTest extends BaseRMTestCase implements BeforeAddToHoldPolicy, OnAddToHoldPolicy, BeforeRemoveFromHoldPolicy, OnRemoveFromHoldPolicy
{
private static final int RECORD_COUNT = 10;
private boolean beforeAddToHoldFlag = false;
private boolean onAddToHoldFlag = false;
private boolean beforeRemoveFromHoldFlag = false;
private boolean onRemoveFromHoldFlag = false;
public void testAddRecordToHold()
{
doBehaviourDrivenTest(new BehaviourDrivenTest()
{
private NodeRef hold;
private NodeRef recordCategory;
private NodeRef recordFolder;
private NodeRef record;
public void given()
{
// create a hold
hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
// create a record folder that contains records
recordCategory = filePlanService.createRecordCategory(filePlan, GUID.generate());
recordFolder = recordFolderService.createRecordFolder(recordCategory, GUID.generate());
record = recordService.createRecordFromContent(recordFolder, GUID.generate(), ContentModel.TYPE_CONTENT, null, null);
// assert current states
assertFalse(freezeService.isFrozen(recordFolder));
assertFalse(freezeService.isFrozen(record));
assertFalse(freezeService.hasFrozenChildren(recordFolder));
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(0, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
public void when() throws Exception
{
// add the record to hold
holdService.addToHold(hold, record);
}
public void then()
{
// record is held
assertTrue(freezeService.isFrozen(record));
// record folder has frozen children
assertFalse(freezeService.isFrozen(recordFolder));
assertTrue(freezeService.hasFrozenChildren(recordFolder));
// record folder is not held
assertFalse(holdService.getHeld(hold).contains(recordFolder));
assertFalse(holdService.heldBy(recordFolder, true).contains(hold));
// hold contains record
assertTrue(holdService.getHeld(hold).contains(record));
assertTrue(holdService.heldBy(record, true).contains(hold));
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(1, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
});
}
public void testAddRecordsToHold()
{
doBehaviourDrivenTest(new BehaviourDrivenTest()
{
private NodeRef hold;
private NodeRef recordCategory;
private NodeRef recordFolder;
private List<NodeRef> records = new ArrayList<>(RECORD_COUNT);
public void given()
{
// create a hold
hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
// create a record folder that contains records
recordCategory = filePlanService.createRecordCategory(filePlan, GUID.generate());
recordFolder = recordFolderService.createRecordFolder(recordCategory, GUID.generate());
for (int i = 0; i < RECORD_COUNT; i++)
{
records.add(recordService.createRecordFromContent(recordFolder, GUID.generate(), ContentModel.TYPE_CONTENT, null, null));
}
// assert current states
assertFalse(freezeService.isFrozen(recordFolder));
assertFalse(freezeService.hasFrozenChildren(recordFolder));
for (NodeRef record : records)
{
assertFalse(freezeService.isFrozen(record));
}
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(0, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
public void when() throws Exception
{
// add the record to hold
holdService.addToHold(hold, records);
}
public void then()
{
// record is held
for (NodeRef record : records)
{
assertTrue(freezeService.isFrozen(record));
}
// record folder has frozen children
assertFalse(freezeService.isFrozen(recordFolder));
assertTrue(freezeService.hasFrozenChildren(recordFolder));
// record folder is not held
assertFalse(holdService.getHeld(hold).contains(recordFolder));
assertFalse(holdService.heldBy(recordFolder, true).contains(hold));
for (NodeRef record : records)
{
// hold contains record
assertTrue(holdService.getHeld(hold).contains(record));
assertTrue(holdService.heldBy(record, true).contains(hold));
}
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(RECORD_COUNT, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
});
}
public void testAddRecordFolderToHold()
{
doBehaviourDrivenTest(new BehaviourDrivenTest()
{
private NodeRef hold;
private NodeRef recordCategory;
private NodeRef recordFolder;
private List<NodeRef> records = new ArrayList<>(RECORD_COUNT);
public void given()
{
// create a hold
hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
// create a record folder that contains records
recordCategory = filePlanService.createRecordCategory(filePlan, GUID.generate());
recordFolder = recordFolderService.createRecordFolder(recordCategory, GUID.generate());
for (int i = 0; i < RECORD_COUNT; i++)
{
records.add(recordService.createRecordFromContent(recordFolder, GUID.generate(), ContentModel.TYPE_CONTENT, null, null));
}
// assert current states
assertFalse(freezeService.isFrozen(recordFolder));
assertFalse(freezeService.hasFrozenChildren(recordFolder));
for (NodeRef record : records)
{
assertFalse(freezeService.isFrozen(record));
}
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(0, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
public void when() throws Exception
{
// add the record to hold
holdService.addToHold(hold, recordFolder);
}
public void then()
{
for (NodeRef record : records)
{
// record is held
assertTrue(freezeService.isFrozen(record));
assertFalse(holdService.getHeld(hold).contains(record));
assertTrue(holdService.heldBy(record, true).contains(hold));
}
// record folder has frozen children
assertTrue(freezeService.isFrozen(recordFolder));
assertTrue(freezeService.hasFrozenChildren(recordFolder));
// hold contains record folder
assertTrue(holdService.getHeld(hold).contains(recordFolder));
assertTrue(holdService.heldBy(recordFolder, true).contains(hold));
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(RECORD_COUNT, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
});
}
public void testRemoveRecordsFromHold()
{
doBehaviourDrivenTest(new BehaviourDrivenTest()
{
private NodeRef hold;
private NodeRef recordCategory;
private NodeRef recordFolder;
private List<NodeRef> records = new ArrayList<>(RECORD_COUNT);
public void given()
{
// create a hold
hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
// create a record folder that contains records
recordCategory = filePlanService.createRecordCategory(filePlan, GUID.generate());
recordFolder = recordFolderService.createRecordFolder(recordCategory, GUID.generate());
for (int i = 0; i < RECORD_COUNT; i++)
{
records.add(recordService.createRecordFromContent(recordFolder, GUID.generate(), ContentModel.TYPE_CONTENT, null, null));
}
// add records to hold
holdService.addToHold(hold, records);
}
public void when() throws Exception
{
// remove *some* of the records
holdService.removeFromHold(hold, records.subList(0, 5));
}
public void then()
{
// check record state (no longer held)
for (NodeRef record : records.subList(0, 5))
{
assertFalse(freezeService.isFrozen(record));
assertFalse(holdService.getHeld(hold).contains(record));
assertFalse(holdService.heldBy(record, true).contains(hold));
}
// check record state (still held)
for (NodeRef record : records.subList(5, 10))
{
assertTrue(freezeService.isFrozen(record));
assertTrue(holdService.getHeld(hold).contains(record));
assertTrue(holdService.heldBy(record, true).contains(hold));
}
// record folder has frozen children
assertFalse(freezeService.isFrozen(recordFolder));
assertTrue(freezeService.hasFrozenChildren(recordFolder));
// record folder is not held
assertFalse(holdService.getHeld(hold).contains(recordFolder));
assertFalse(holdService.heldBy(recordFolder, true).contains(hold));
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(5, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
});
}
public void testRemoveAllRecordsFromHold()
{
doBehaviourDrivenTest(new BehaviourDrivenTest()
{
private NodeRef hold;
private NodeRef recordCategory;
private NodeRef recordFolder;
private List<NodeRef> records = new ArrayList<>(RECORD_COUNT);
public void given()
{
// create a hold
hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
// create a record folder that contains records
recordCategory = filePlanService.createRecordCategory(filePlan, GUID.generate());
recordFolder = recordFolderService.createRecordFolder(recordCategory, GUID.generate());
for (int i = 0; i < RECORD_COUNT; i++)
{
records.add(recordService.createRecordFromContent(recordFolder, GUID.generate(), ContentModel.TYPE_CONTENT, null, null));
}
// add records to hold
holdService.addToHold(hold, records);
}
public void when() throws Exception
{
// remove all of the records
holdService.removeFromHold(hold, records);
}
public void then()
{
// check record state (no longer held)
for (NodeRef record : records)
{
assertFalse(freezeService.isFrozen(record));
assertFalse(holdService.getHeld(hold).contains(record));
assertFalse(holdService.heldBy(record, true).contains(hold));
}
// record folder has frozen children
assertFalse(freezeService.isFrozen(recordFolder));
assertFalse(freezeService.hasFrozenChildren(recordFolder));
// record folder is not held
assertFalse(holdService.getHeld(hold).contains(recordFolder));
assertFalse(holdService.heldBy(recordFolder, true).contains(hold));
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(0, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
});
}
public void testRemoveRecordFolderFromHold()
{
doBehaviourDrivenTest(new BehaviourDrivenTest()
{
private NodeRef hold;
private NodeRef recordCategory;
private NodeRef recordFolder;
private List<NodeRef> records = new ArrayList<>(RECORD_COUNT);
public void given()
{
// create a hold
hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
// create a record folder that contains records
recordCategory = filePlanService.createRecordCategory(filePlan, GUID.generate());
recordFolder = recordFolderService.createRecordFolder(recordCategory, GUID.generate());
for (int i = 0; i < RECORD_COUNT; i++)
{
records.add(recordService.createRecordFromContent(recordFolder, GUID.generate(), ContentModel.TYPE_CONTENT, null, null));
}
// add record folder to hold
holdService.addToHold(hold, recordFolder);
}
public void when() throws Exception
{
// remove record folder from hold
holdService.removeFromHold(hold, recordFolder);
}
public void then()
{
// check record states
for (NodeRef record : records)
{
assertFalse(freezeService.isFrozen(record));
assertFalse(holdService.getHeld(hold).contains(record));
assertFalse(holdService.heldBy(record, true).contains(hold));
}
// record folder has frozen children
assertFalse(freezeService.isFrozen(recordFolder));
assertFalse(freezeService.hasFrozenChildren(recordFolder));
// record folder is not held
assertFalse(holdService.getHeld(hold).contains(recordFolder));
assertFalse(holdService.heldBy(recordFolder, true).contains(hold));
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(0, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
});
}
public void testPolicyNotificationForAddToHold()
{
doBehaviourDrivenTest(new BehaviourDrivenTest()
{
private NodeRef hold;
private NodeRef recordCategory;
private NodeRef recordFolder;
BehaviourDefinition<ClassBehaviourBinding> beforeAddToHoldBehaviour;
BehaviourDefinition<ClassBehaviourBinding> onAddToHoldBehaviour;
public void given()
{
// create a hold
hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
// create a record category -> record folder
recordCategory = filePlanService.createRecordCategory(filePlan, GUID.generate());
recordFolder = recordFolderService.createRecordFolder(recordCategory, GUID.generate());
beforeAddToHoldBehaviour = policyComponent.bindClassBehaviour(BeforeAddToHoldPolicy.QNAME,
RecordsManagementModel.TYPE_HOLD, new JavaBehaviour(AddRemoveFromHoldTest.this, "beforeAddToHold", NotificationFrequency.EVERY_EVENT));
onAddToHoldBehaviour = policyComponent.bindClassBehaviour(OnAddToHoldPolicy.QNAME,
RecordsManagementModel.TYPE_HOLD, new JavaBehaviour(AddRemoveFromHoldTest.this, "onAddToHold", NotificationFrequency.EVERY_EVENT));
assertFalse(beforeAddToHoldFlag);
assertFalse(onAddToHoldFlag);
}
public void when() throws Exception
{
// add the record folder to hold
holdService.addToHold(hold, recordFolder);
}
public void then()
{
assertTrue(beforeAddToHoldFlag);
assertTrue(onAddToHoldFlag);
}
public void after()
{
policyComponent.removeClassDefinition(beforeAddToHoldBehaviour);
policyComponent.removeClassDefinition(onAddToHoldBehaviour);
}
});
}
public void testPolicyNotificationForRemoveFromHold()
{
doBehaviourDrivenTest(new BehaviourDrivenTest()
{
private NodeRef hold;
private NodeRef recordCategory;
private NodeRef recordFolder;
BehaviourDefinition<ClassBehaviourBinding> beforeRemoveFromHoldBehaviour;
BehaviourDefinition<ClassBehaviourBinding> onRemoveFromHoldBehaviour;
public void given()
{
// create a hold
hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
// create a record category -> record folder
recordCategory = filePlanService.createRecordCategory(filePlan, GUID.generate());
recordFolder = recordFolderService.createRecordFolder(recordCategory, GUID.generate());
// add the record folder to hold
holdService.addToHold(hold, recordFolder);
beforeRemoveFromHoldBehaviour = policyComponent.bindClassBehaviour(BeforeRemoveFromHoldPolicy.QNAME,
RecordsManagementModel.TYPE_HOLD, new JavaBehaviour(AddRemoveFromHoldTest.this, "beforeRemoveFromHold", NotificationFrequency.EVERY_EVENT));
onRemoveFromHoldBehaviour = policyComponent.bindClassBehaviour(OnRemoveFromHoldPolicy.QNAME,
RecordsManagementModel.TYPE_HOLD, new JavaBehaviour(AddRemoveFromHoldTest.this, "onRemoveFromHold", NotificationFrequency.EVERY_EVENT));
assertFalse(beforeRemoveFromHoldFlag);
assertFalse(onRemoveFromHoldFlag);
}
public void when() throws Exception
{
// remove the record folder from the hold
holdService.removeFromHold(hold, recordFolder);
}
public void then()
{
assertTrue(beforeRemoveFromHoldFlag);
assertTrue(onRemoveFromHoldFlag);
}
public void after()
{
policyComponent.removeClassDefinition(beforeRemoveFromHoldBehaviour);
policyComponent.removeClassDefinition(onRemoveFromHoldBehaviour);
}
});
}
@Override
public void beforeAddToHold(NodeRef hold, NodeRef contentNodeRef)
{
beforeAddToHoldFlag = true;
}
@Override
public void onAddToHold(NodeRef hold, NodeRef contentNodeRef)
{
onAddToHoldFlag = true;
}
@Override
public void beforeRemoveFromHold(NodeRef hold, NodeRef contentNodeRef)
{
beforeRemoveFromHoldFlag = true;
}
@Override
public void onRemoveFromHold(NodeRef hold, NodeRef contentNodeRef)
{
onRemoveFromHoldFlag = true;
}
}

315
rm-community/rm-community-repo/test/java/org/alfresco/module/org_alfresco_module_rm/test/integration/hold/AddToHoldTest.java Normal file
View File

@@ -0,0 +1,315 @@
/*
* #%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 java.util.ArrayList;
import java.util.List;
import org.alfresco.model.ContentModel;
import org.alfresco.module.org_alfresco_module_rm.hold.HoldServicePolicies.BeforeAddToHoldPolicy;
import org.alfresco.module.org_alfresco_module_rm.hold.HoldServicePolicies.OnAddToHoldPolicy;
import org.alfresco.module.org_alfresco_module_rm.model.RecordsManagementModel;
import org.alfresco.module.org_alfresco_module_rm.test.util.BaseRMTestCase;
import org.alfresco.repo.policy.Behaviour.NotificationFrequency;
import org.alfresco.repo.policy.BehaviourDefinition;
import org.alfresco.repo.policy.ClassBehaviourBinding;
import org.alfresco.repo.policy.JavaBehaviour;
import org.alfresco.service.cmr.repository.NodeRef;
import org.springframework.extensions.webscripts.GUID;
/**
* Add To Hold Integration Tests
*
* @author Roy Wetherall
* @since 2.2
*/
public class AddToHoldTest extends BaseRMTestCase implements BeforeAddToHoldPolicy, OnAddToHoldPolicy
{
private static final int RECORD_COUNT = 10;
private boolean beforeAddToHoldFlag = false;
private boolean onAddToHoldFlag = false;
public void testAddRecordToHold()
{
doBehaviourDrivenTest(new BehaviourDrivenTest()
{
private NodeRef hold;
private NodeRef recordCategory;
private NodeRef recordFolder;
private NodeRef record;
public void given()
{
// create a hold
hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
// create a record folder that contains records
recordCategory = filePlanService.createRecordCategory(filePlan, GUID.generate());
recordFolder = recordFolderService.createRecordFolder(recordCategory, GUID.generate());
record = recordService.createRecordFromContent(recordFolder, GUID.generate(), ContentModel.TYPE_CONTENT, null, null);
// assert current states
assertFalse(freezeService.isFrozen(recordFolder));
assertFalse(freezeService.isFrozen(record));
assertFalse(freezeService.hasFrozenChildren(recordFolder));
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(0, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
public void when() throws Exception
{
// add the record to hold
holdService.addToHold(hold, record);
}
public void then()
{
// record is held
assertTrue(freezeService.isFrozen(record));
// record folder has frozen children
assertFalse(freezeService.isFrozen(recordFolder));
assertTrue(freezeService.hasFrozenChildren(recordFolder));
// record folder is not held
assertFalse(holdService.getHeld(hold).contains(recordFolder));
assertFalse(holdService.heldBy(recordFolder, true).contains(hold));
// hold contains record
assertTrue(holdService.getHeld(hold).contains(record));
assertTrue(holdService.heldBy(record, true).contains(hold));
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(1, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
});
}
public void testAddRecordsToHold()
{
doBehaviourDrivenTest(new BehaviourDrivenTest()
{
private NodeRef hold;
private NodeRef recordCategory;
private NodeRef recordFolder;
private List<NodeRef> records = new ArrayList<>(RECORD_COUNT);
public void given()
{
// create a hold
hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
// create a record folder that contains records
recordCategory = filePlanService.createRecordCategory(filePlan, GUID.generate());
recordFolder = recordFolderService.createRecordFolder(recordCategory, GUID.generate());
for (int i = 0; i < RECORD_COUNT; i++)
{
records.add(recordService.createRecordFromContent(recordFolder, GUID.generate(), ContentModel.TYPE_CONTENT, null, null));
}
// assert current states
assertFalse(freezeService.isFrozen(recordFolder));
assertFalse(freezeService.hasFrozenChildren(recordFolder));
for (NodeRef record : records)
{
assertFalse(freezeService.isFrozen(record));
}
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(0, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
public void when() throws Exception
{
// add the record to hold
holdService.addToHold(hold, records);
}
public void then()
{
// record is held
for (NodeRef record : records)
{
assertTrue(freezeService.isFrozen(record));
}
// record folder has frozen children
assertFalse(freezeService.isFrozen(recordFolder));
assertTrue(freezeService.hasFrozenChildren(recordFolder));
// record folder is not held
assertFalse(holdService.getHeld(hold).contains(recordFolder));
assertFalse(holdService.heldBy(recordFolder, true).contains(hold));
for (NodeRef record : records)
{
// hold contains record
assertTrue(holdService.getHeld(hold).contains(record));
assertTrue(holdService.heldBy(record, true).contains(hold));
}
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(RECORD_COUNT, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
});
}
public void testAddRecordFolderToHold()
{
doBehaviourDrivenTest(new BehaviourDrivenTest()
{
private NodeRef hold;
private NodeRef recordCategory;
private NodeRef recordFolder;
private List<NodeRef> records = new ArrayList<>(RECORD_COUNT);
public void given()
{
// create a hold
hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
// create a record folder that contains records
recordCategory = filePlanService.createRecordCategory(filePlan, GUID.generate());
recordFolder = recordFolderService.createRecordFolder(recordCategory, GUID.generate());
for (int i = 0; i < RECORD_COUNT; i++)
{
records.add(recordService.createRecordFromContent(recordFolder, GUID.generate(), ContentModel.TYPE_CONTENT, null, null));
}
// assert current states
assertFalse(freezeService.isFrozen(recordFolder));
assertFalse(freezeService.hasFrozenChildren(recordFolder));
for (NodeRef record : records)
{
assertFalse(freezeService.isFrozen(record));
}
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(0, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
public void when() throws Exception
{
// add the record to hold
holdService.addToHold(hold, recordFolder);
}
public void then()
{
for (NodeRef record : records)
{
// record is held
assertTrue(freezeService.isFrozen(record));
assertFalse(holdService.getHeld(hold).contains(record));
assertTrue(holdService.heldBy(record, true).contains(hold));
}
// record folder has frozen children
assertTrue(freezeService.isFrozen(recordFolder));
assertTrue(freezeService.hasFrozenChildren(recordFolder));
// hold contains record folder
assertTrue(holdService.getHeld(hold).contains(recordFolder));
assertTrue(holdService.heldBy(recordFolder, true).contains(hold));
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(RECORD_COUNT, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
});
}
public void testPolicyNotificationForAddToHold()
{
doBehaviourDrivenTest(new BehaviourDrivenTest()
{
private NodeRef hold;
private NodeRef recordCategory;
private NodeRef recordFolder;
BehaviourDefinition<ClassBehaviourBinding> beforeAddToHoldBehaviour;
BehaviourDefinition<ClassBehaviourBinding> onAddToHoldBehaviour;
public void given()
{
// create a hold
hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
// create a record category -> record folder
recordCategory = filePlanService.createRecordCategory(filePlan, GUID.generate());
recordFolder = recordFolderService.createRecordFolder(recordCategory, GUID.generate());
beforeAddToHoldBehaviour = policyComponent.bindClassBehaviour(BeforeAddToHoldPolicy.QNAME,
RecordsManagementModel.TYPE_HOLD, new JavaBehaviour(AddToHoldTest.this, "beforeAddToHold", NotificationFrequency.EVERY_EVENT));
onAddToHoldBehaviour = policyComponent.bindClassBehaviour(OnAddToHoldPolicy.QNAME,
RecordsManagementModel.TYPE_HOLD, new JavaBehaviour(AddToHoldTest.this, "onAddToHold", NotificationFrequency.EVERY_EVENT));
assertFalse(beforeAddToHoldFlag);
assertFalse(onAddToHoldFlag);
}
public void when() throws Exception
{
// add the record folder to hold
holdService.addToHold(hold, recordFolder);
}
public void then()
{
assertTrue(beforeAddToHoldFlag);
assertTrue(onAddToHoldFlag);
}
public void after()
{
policyComponent.removeClassDefinition(beforeAddToHoldBehaviour);
policyComponent.removeClassDefinition(onAddToHoldBehaviour);
}
});
}
@Override
public void beforeAddToHold(NodeRef hold, NodeRef contentNodeRef)
{
beforeAddToHoldFlag = true;
}
@Override
public void onAddToHold(NodeRef hold, NodeRef contentNodeRef)
{
onAddToHoldFlag = true;
}
}

298
rm-community/rm-community-repo/test/java/org/alfresco/module/org_alfresco_module_rm/test/integration/hold/RemoveFromHoldTest.java Normal file
View File

@@ -0,0 +1,298 @@
/*
* #%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 java.util.ArrayList;
import java.util.List;
import org.alfresco.model.ContentModel;
import org.alfresco.module.org_alfresco_module_rm.hold.HoldServicePolicies.BeforeRemoveFromHoldPolicy;
import org.alfresco.module.org_alfresco_module_rm.hold.HoldServicePolicies.OnRemoveFromHoldPolicy;
import org.alfresco.module.org_alfresco_module_rm.model.RecordsManagementModel;
import org.alfresco.module.org_alfresco_module_rm.test.util.BaseRMTestCase;
import org.alfresco.repo.policy.Behaviour.NotificationFrequency;
import org.alfresco.repo.policy.BehaviourDefinition;
import org.alfresco.repo.policy.ClassBehaviourBinding;
import org.alfresco.repo.policy.JavaBehaviour;
import org.alfresco.service.cmr.repository.NodeRef;
import org.springframework.extensions.webscripts.GUID;
/**
* Remove From Hold integration tests.
*
* @author Roy Wetherall
* @since 2.2
*/
public class RemoveFromHoldTest extends BaseRMTestCase implements BeforeRemoveFromHoldPolicy, OnRemoveFromHoldPolicy
{
private static final int RECORD_COUNT = 10;
private boolean beforeRemoveFromHoldFlag = false;
private boolean onRemoveFromHoldFlag = false;
public void testRemoveRecordsFromHold()
{
doBehaviourDrivenTest(new BehaviourDrivenTest()
{
private NodeRef hold;
private NodeRef recordCategory;
private NodeRef recordFolder;
private List<NodeRef> records = new ArrayList<>(RECORD_COUNT);
public void given()
{
// create a hold
hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
// create a record folder that contains records
recordCategory = filePlanService.createRecordCategory(filePlan, GUID.generate());
recordFolder = recordFolderService.createRecordFolder(recordCategory, GUID.generate());
for (int i = 0; i < RECORD_COUNT; i++)
{
records.add(recordService.createRecordFromContent(recordFolder, GUID.generate(), ContentModel.TYPE_CONTENT, null, null));
}
// add records to hold
holdService.addToHold(hold, records);
}
public void when() throws Exception
{
// remove *some* of the records
holdService.removeFromHold(hold, records.subList(0, 5));
}
public void then()
{
// check record state (no longer held)
for (NodeRef record : records.subList(0, 5))
{
assertFalse(freezeService.isFrozen(record));
assertFalse(holdService.getHeld(hold).contains(record));
assertFalse(holdService.heldBy(record, true).contains(hold));
}
// check record state (still held)
for (NodeRef record : records.subList(5, 10))
{
assertTrue(freezeService.isFrozen(record));
assertTrue(holdService.getHeld(hold).contains(record));
assertTrue(holdService.heldBy(record, true).contains(hold));
}
// record folder has frozen children
assertFalse(freezeService.isFrozen(recordFolder));
assertTrue(freezeService.hasFrozenChildren(recordFolder));
// record folder is not held
assertFalse(holdService.getHeld(hold).contains(recordFolder));
assertFalse(holdService.heldBy(recordFolder, true).contains(hold));
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(5, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
});
}
public void testRemoveAllRecordsFromHold()
{
doBehaviourDrivenTest(new BehaviourDrivenTest()
{
private NodeRef hold;
private NodeRef recordCategory;
private NodeRef recordFolder;
private List<NodeRef> records = new ArrayList<>(RECORD_COUNT);
public void given()
{
// create a hold
hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
// create a record folder that contains records
recordCategory = filePlanService.createRecordCategory(filePlan, GUID.generate());
recordFolder = recordFolderService.createRecordFolder(recordCategory, GUID.generate());
for (int i = 0; i < RECORD_COUNT; i++)
{
records.add(recordService.createRecordFromContent(recordFolder, GUID.generate(), ContentModel.TYPE_CONTENT, null, null));
}
// add records to hold
holdService.addToHold(hold, records);
}
public void when() throws Exception
{
// remove all of the records
holdService.removeFromHold(hold, records);
}
public void then()
{
// check record state (no longer held)
for (NodeRef record : records)
{
assertFalse(freezeService.isFrozen(record));
assertFalse(holdService.getHeld(hold).contains(record));
assertFalse(holdService.heldBy(record, true).contains(hold));
}
// record folder has frozen children
assertFalse(freezeService.isFrozen(recordFolder));
assertFalse(freezeService.hasFrozenChildren(recordFolder));
// record folder is not held
assertFalse(holdService.getHeld(hold).contains(recordFolder));
assertFalse(holdService.heldBy(recordFolder, true).contains(hold));
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(0, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
});
}
public void testRemoveRecordFolderFromHold()
{
doBehaviourDrivenTest(new BehaviourDrivenTest()
{
private NodeRef hold;
private NodeRef recordCategory;
private NodeRef recordFolder;
private List<NodeRef> records = new ArrayList<>(RECORD_COUNT);
public void given()
{
// create a hold
hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
// create a record folder that contains records
recordCategory = filePlanService.createRecordCategory(filePlan, GUID.generate());
recordFolder = recordFolderService.createRecordFolder(recordCategory, GUID.generate());
for (int i = 0; i < RECORD_COUNT; i++)
{
records.add(recordService.createRecordFromContent(recordFolder, GUID.generate(), ContentModel.TYPE_CONTENT, null, null));
}
// add record folder to hold
holdService.addToHold(hold, recordFolder);
}
public void when() throws Exception
{
// remove record folder from hold
holdService.removeFromHold(hold, recordFolder);
}
public void then()
{
// check record states
for (NodeRef record : records)
{
assertFalse(freezeService.isFrozen(record));
assertFalse(holdService.getHeld(hold).contains(record));
assertFalse(holdService.heldBy(record, true).contains(hold));
}
// record folder has frozen children
assertFalse(freezeService.isFrozen(recordFolder));
assertFalse(freezeService.hasFrozenChildren(recordFolder));
// record folder is not held
assertFalse(holdService.getHeld(hold).contains(recordFolder));
assertFalse(holdService.heldBy(recordFolder, true).contains(hold));
// additional check for child held caching
assertTrue(nodeService.hasAspect(recordFolder, ASPECT_HELD_CHILDREN));
assertEquals(0, nodeService.getProperty(recordFolder, PROP_HELD_CHILDREN_COUNT));
}
});
}
public void testPolicyNotificationForRemoveFromHold()
{
doBehaviourDrivenTest(new BehaviourDrivenTest()
{
private NodeRef hold;
private NodeRef recordCategory;
private NodeRef recordFolder;
BehaviourDefinition<ClassBehaviourBinding> beforeRemoveFromHoldBehaviour;
BehaviourDefinition<ClassBehaviourBinding> onRemoveFromHoldBehaviour;
public void given()
{
// create a hold
hold = holdService.createHold(filePlan, GUID.generate(), GUID.generate(), GUID.generate());
// create a record category -> record folder
recordCategory = filePlanService.createRecordCategory(filePlan, GUID.generate());
recordFolder = recordFolderService.createRecordFolder(recordCategory, GUID.generate());
// add the record folder to hold
holdService.addToHold(hold, recordFolder);
beforeRemoveFromHoldBehaviour = policyComponent.bindClassBehaviour(BeforeRemoveFromHoldPolicy.QNAME,
RecordsManagementModel.TYPE_HOLD, new JavaBehaviour(RemoveFromHoldTest.this, "beforeRemoveFromHold", NotificationFrequency.EVERY_EVENT));
onRemoveFromHoldBehaviour = policyComponent.bindClassBehaviour(OnRemoveFromHoldPolicy.QNAME,
RecordsManagementModel.TYPE_HOLD, new JavaBehaviour(RemoveFromHoldTest.this, "onRemoveFromHold", NotificationFrequency.EVERY_EVENT));
assertFalse(beforeRemoveFromHoldFlag);
assertFalse(onRemoveFromHoldFlag);
}
public void when() throws Exception
{
// remove the record folder from the hold
holdService.removeFromHold(hold, recordFolder);
}
public void then()
{
assertTrue(beforeRemoveFromHoldFlag);
assertTrue(onRemoveFromHoldFlag);
}
public void after()
{
policyComponent.removeClassDefinition(beforeRemoveFromHoldBehaviour);
policyComponent.removeClassDefinition(onRemoveFromHoldBehaviour);
}
});
}
@Override
public void beforeRemoveFromHold(NodeRef hold, NodeRef contentNodeRef)
{
beforeRemoveFromHoldFlag = true;
}
@Override
public void onRemoveFromHold(NodeRef hold, NodeRef contentNodeRef)
{
onRemoveFromHoldFlag = true;
}
}

32
rm-community/rm-community-repo/unit-test/java/org/alfresco/module/org_alfresco_module_rm/hold/HoldServiceImplUnitTest.java
View File

@@ -340,6 +340,8 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
@Test @Test
public void addToHoldNotInHold() public void addToHoldNotInHold()
{ {
mockPoliciesForAddToHold();
holdService.addToHold(hold, recordFolder); holdService.addToHold(hold, recordFolder);
verify(mockedNodeService).addChild(hold, recordFolder, ASSOC_FROZEN_CONTENT, ASSOC_FROZEN_CONTENT); verify(mockedNodeService).addChild(hold, recordFolder, ASSOC_FROZEN_CONTENT, ASSOC_FROZEN_CONTENT);
@@ -387,6 +389,8 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(record, ASPECT_FROZEN); doReturn(true).when(mockedNodeService).hasAspect(record, ASPECT_FROZEN);
doReturn(true).when(mockedNodeService).hasAspect(activeContent, ASPECT_FROZEN); doReturn(true).when(mockedNodeService).hasAspect(activeContent, ASPECT_FROZEN);
mockPoliciesForAddToHold();
holdService.addToHold(hold, recordFolder); holdService.addToHold(hold, recordFolder);
verify(mockedNodeService).addChild(hold, recordFolder, ASSOC_FROZEN_CONTENT, ASSOC_FROZEN_CONTENT); verify(mockedNodeService).addChild(hold, recordFolder, ASSOC_FROZEN_CONTENT, ASSOC_FROZEN_CONTENT);
@@ -448,6 +452,8 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
}).when(mockedNodeService).addAspect(any(NodeRef.class), eq(ASPECT_FROZEN), any(Map.class)); }).when(mockedNodeService).addAspect(any(NodeRef.class), eq(ASPECT_FROZEN), any(Map.class));
mockPoliciesForAddToHold();
// build a list of holds // build a list of holds
List<NodeRef> holds = new ArrayList<>(2); List<NodeRef> holds = new ArrayList<>(2);
holds.add(hold); holds.add(hold);
@@ -473,6 +479,8 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
@Test @Test
public void removeFromHoldNotInHold() public void removeFromHoldNotInHold()
{ {
mockPoliciesForRemoveFromHold();
holdService.removeFromHold(hold, recordFolder); holdService.removeFromHold(hold, recordFolder);
verify(mockedNodeService, never()).removeChild(hold, recordFolder); verify(mockedNodeService, never()).removeChild(hold, recordFolder);
@@ -488,6 +496,8 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(recordFolder, ASPECT_FROZEN); doReturn(true).when(mockedNodeService).hasAspect(recordFolder, ASPECT_FROZEN);
doReturn(true).when(mockedNodeService).hasAspect(record, ASPECT_FROZEN); doReturn(true).when(mockedNodeService).hasAspect(record, ASPECT_FROZEN);
mockPoliciesForRemoveFromHold();
holdService.removeFromHold(hold, recordFolder); holdService.removeFromHold(hold, recordFolder);
verify(mockedNodeService, times(1)).removeChild(hold, recordFolder); verify(mockedNodeService, times(1)).removeChild(hold, recordFolder);
@@ -504,6 +514,8 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
doReturn(true).when(mockedNodeService).hasAspect(recordFolder, ASPECT_FROZEN); doReturn(true).when(mockedNodeService).hasAspect(recordFolder, ASPECT_FROZEN);
doReturn(true).when(mockedNodeService).hasAspect(record, ASPECT_FROZEN); doReturn(true).when(mockedNodeService).hasAspect(record, ASPECT_FROZEN);
mockPoliciesForRemoveFromHold();
// build a list of holds // build a list of holds
List<NodeRef> holds = new ArrayList<>(2); List<NodeRef> holds = new ArrayList<>(2);
holds.add(hold); holds.add(hold);
@@ -536,6 +548,8 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
}).when(mockedNodeService).removeChild(hold, recordFolder); }).when(mockedNodeService).removeChild(hold, recordFolder);
mockPoliciesForRemoveFromHold();
doAnswer(new Answer<Void>() doAnswer(new Answer<Void>()
{ {
public Void answer(InvocationOnMock invocation) public Void answer(InvocationOnMock invocation)
@@ -576,4 +590,22 @@ public class HoldServiceImplUnitTest extends BaseUnitTest
holds.add(hold2); holds.add(hold2);
holdService.removeFromHolds(holds, activeContent); holdService.removeFromHolds(holds, activeContent);
} }
/**
* mocks policies for add to hold
*/
private void mockPoliciesForAddToHold()
{
doNothing().when(holdService).invokeBeforeAddToHold(any(), any());
doNothing().when(holdService).invokeOnAddToHold(any(), any());
}
/**
* mocks policies for remove from hold
*/
private void mockPoliciesForRemoveFromHold()
{
doNothing().when(holdService).invokeBeforeRemoveFromHold(any(), any());
doNothing().when(holdService).invokeOnRemoveFromHold(any(), any());
}
} }