diff --git a/config/alfresco/rule-services-context.xml b/config/alfresco/rule-services-context.xml index 3091716692..15eee57035 100644 --- a/config/alfresco/rule-services-context.xml +++ b/config/alfresco/rule-services-context.xml @@ -79,6 +79,7 @@ + @@ -181,4 +182,6 @@ + + diff --git a/source/java/org/alfresco/jcr/dictionary/ClassMap.java b/source/java/org/alfresco/jcr/dictionary/ClassMap.java index a4de4b6c63..da819c57dc 100644 --- a/source/java/org/alfresco/jcr/dictionary/ClassMap.java +++ b/source/java/org/alfresco/jcr/dictionary/ClassMap.java @@ -94,7 +94,7 @@ public class ClassMap */ public static QName convertClassToType(QName alfrescoClass) { - return JCRToAlfresco.get(alfrescoClass); + return AlfrescoToJCR.get(alfrescoClass); } /** diff --git a/source/java/org/alfresco/jcr/item/Alf1791Test.java b/source/java/org/alfresco/jcr/item/Alf1791Test.java new file mode 100644 index 0000000000..57fdf6de0c --- /dev/null +++ b/source/java/org/alfresco/jcr/item/Alf1791Test.java @@ -0,0 +1,68 @@ +package org.alfresco.jcr.item; + +import javax.jcr.Node; +import javax.jcr.RepositoryException; +import javax.jcr.Session; +import javax.jcr.SimpleCredentials; +import javax.jcr.nodetype.NodeType; + +import org.alfresco.jcr.test.BaseJCRTest; + +public class Alf1791Test extends BaseJCRTest +{ + + protected Session superuserSession; + protected Node node; + + @Override + protected void setUp() throws Exception + { + super.setUp(); + + SimpleCredentials superuser = new SimpleCredentials("superuser", "".toCharArray()); + superuserSession = repository.login(superuser, getWorkspace()); + Node rootNode = superuserSession.getRootNode(); + node = rootNode.addNode("alf1791", "cm:content"); + } + + @Override + protected void tearDown() throws Exception + { + node.remove(); + superuserSession.logout(); + super.tearDown(); + } + + + public void testAlf1791() + throws Exception + { + final String mixPrefix = node.getSession().getNamespacePrefix("http://www.jcp.org/jcr/mix/1.0"); + final String mixReferenceable = mixPrefix + ":referenceable"; + final String sysPrefix = node.getSession().getNamespacePrefix("http://www.alfresco.org/model/system/1.0"); + final String sysReferenceable = sysPrefix + ":referenceable"; + + node.addMixin(mixReferenceable); + if (!hasMixin(node, mixReferenceable)) + { + throw new RepositoryException("Node just made 'mix:referenceable' isn't! ('sys:referenceable'=" + hasMixin(node, sysReferenceable) + ")"); + } + } + + + public static final boolean hasMixin(final Node node, final String mixinName) + throws RepositoryException + { + final NodeType[] mixinNodeTypes = node.getMixinNodeTypes(); + if (mixinNodeTypes == null) + return false; + for (NodeType mixinNodeType : mixinNodeTypes) + { + if (mixinNodeType == null) + continue; + if (mixinName.equals(mixinNodeType.getName())) + return true; + } + return false; + } +} diff --git a/source/java/org/alfresco/repo/node/AbstractNodeServiceImpl.java b/source/java/org/alfresco/repo/node/AbstractNodeServiceImpl.java index 5ad114fece..31ef41b0e9 100644 --- a/source/java/org/alfresco/repo/node/AbstractNodeServiceImpl.java +++ b/source/java/org/alfresco/repo/node/AbstractNodeServiceImpl.java @@ -47,6 +47,7 @@ import org.alfresco.repo.node.NodeServicePolicies.OnDeleteChildAssociationPolicy import org.alfresco.repo.node.NodeServicePolicies.OnDeleteNodePolicy; import org.alfresco.repo.node.NodeServicePolicies.OnMoveNodePolicy; import org.alfresco.repo.node.NodeServicePolicies.OnRemoveAspectPolicy; +import org.alfresco.repo.node.NodeServicePolicies.OnRestoreNodePolicy; import org.alfresco.repo.node.NodeServicePolicies.OnUpdateNodePolicy; import org.alfresco.repo.node.NodeServicePolicies.OnUpdatePropertiesPolicy; import org.alfresco.repo.policy.AssociationPolicyDelegate; @@ -113,6 +114,7 @@ public abstract class AbstractNodeServiceImpl implements NodeService private ClassPolicyDelegate onUpdatePropertiesDelegate; private ClassPolicyDelegate beforeDeleteNodeDelegate; private ClassPolicyDelegate onDeleteNodeDelegate; + private ClassPolicyDelegate onRestoreNodePolicy; private ClassPolicyDelegate beforeAddAspectDelegate; private ClassPolicyDelegate onAddAspectDelegate; private ClassPolicyDelegate beforeRemoveAspectDelegate; @@ -201,6 +203,7 @@ public abstract class AbstractNodeServiceImpl implements NodeService onUpdatePropertiesDelegate = policyComponent.registerClassPolicy(NodeServicePolicies.OnUpdatePropertiesPolicy.class); beforeDeleteNodeDelegate = policyComponent.registerClassPolicy(NodeServicePolicies.BeforeDeleteNodePolicy.class); onDeleteNodeDelegate = policyComponent.registerClassPolicy(NodeServicePolicies.OnDeleteNodePolicy.class); + onRestoreNodePolicy = policyComponent.registerClassPolicy(NodeServicePolicies.OnRestoreNodePolicy.class); beforeAddAspectDelegate = policyComponent.registerClassPolicy(NodeServicePolicies.BeforeAddAspectPolicy.class); onAddAspectDelegate = policyComponent.registerClassPolicy(NodeServicePolicies.OnAddAspectPolicy.class); @@ -452,6 +455,19 @@ public abstract class AbstractNodeServiceImpl implements NodeService } } + /** + * @see NodeServicePolicies.OnRestoreNodePolicy#onDeleteNode(ChildAssociationRef) + */ + protected void invokeOnRestoreNode(ChildAssociationRef childAssocRef) + { + NodeRef childNodeRef = childAssocRef.getChildRef(); + // get qnames to invoke against + Set qnames = getTypeAndAspectQNames(childNodeRef); + // execute policy for node type and aspects + NodeServicePolicies.OnRestoreNodePolicy policy = onRestoreNodePolicy.get(childAssocRef.getChildRef(), qnames); + policy.onRestoreNode(childAssocRef); + } + /** * @see NodeServicePolicies.BeforeAddAspectPolicy#beforeAddAspect(NodeRef, * QName) diff --git a/source/java/org/alfresco/repo/node/NodeServicePolicies.java b/source/java/org/alfresco/repo/node/NodeServicePolicies.java index 790badb7cb..4a9c5fea43 100644 --- a/source/java/org/alfresco/repo/node/NodeServicePolicies.java +++ b/source/java/org/alfresco/repo/node/NodeServicePolicies.java @@ -218,6 +218,16 @@ public interface NodeServicePolicies public void onRemoveAspect(NodeRef nodeRef, QName aspectTypeQName); } + public interface OnRestoreNodePolicy extends ClassPolicy + { + /** + * Called after an archived node is restored. + * + * @param childAssocRef the newly created child association reference + */ + public void onRestoreNode(ChildAssociationRef childAssocRef); + } + public interface BeforeCreateNodeAssociationPolicy extends AssociationPolicy { public static final QName QNAME = QName.createQName(NamespaceService.ALFRESCO_URI, "beforeCreateNodeAssociation"); diff --git a/source/java/org/alfresco/repo/node/db/DbNodeServiceImpl.java b/source/java/org/alfresco/repo/node/db/DbNodeServiceImpl.java index 89eba3b924..f0f4bde9c6 100644 --- a/source/java/org/alfresco/repo/node/db/DbNodeServiceImpl.java +++ b/source/java/org/alfresco/repo/node/db/DbNodeServiceImpl.java @@ -1926,7 +1926,7 @@ public class DbNodeServiceImpl extends AbstractNodeServiceImpl // the node reference has changed due to the store move NodeRef restoredNodeRef = newChildAssocRef.getChildRef(); - + invokeOnRestoreNode(newChildAssocRef); // done if (logger.isDebugEnabled()) { diff --git a/source/java/org/alfresco/repo/rule/RuleServiceImpl.java b/source/java/org/alfresco/repo/rule/RuleServiceImpl.java index c4b2b81ded..4479f2f0af 100644 --- a/source/java/org/alfresco/repo/rule/RuleServiceImpl.java +++ b/source/java/org/alfresco/repo/rule/RuleServiceImpl.java @@ -1098,17 +1098,29 @@ public class RuleServiceImpl /** * Executes a pending rule * - * @param pendingRule the pending rule data object + * @param pendingRule the pending rule data object */ @SuppressWarnings("unchecked") private void executePendingRule(PendingRuleData pendingRule) { Set executedRules = (Set) AlfrescoTransactionSupport.getResource(KEY_RULES_EXECUTED); - + NodeRef actionedUponNodeRef = pendingRule.getActionedUponNodeRef(); Rule rule = pendingRule.getRule(); - + + NodeRef ruleNodeRef = rule.getNodeRef(); + if (!ruleNodeRef.getStoreRef().equals(actionedUponNodeRef.getStoreRef()) && !nodeService.exists(ruleNodeRef)) + { + NodeRef newRuleNodeRef = new NodeRef(actionedUponNodeRef.getStoreRef(), ruleNodeRef.getId()); + if (nodeService.exists(newRuleNodeRef)) + { + ruleNodeRef = newRuleNodeRef; + } + + } + //update all associations and actions + rule = getRule(ruleNodeRef); if (executedRules == null || canExecuteRule(executedRules, actionedUponNodeRef, rule) == true) { executeRule(rule, actionedUponNodeRef, executedRules); diff --git a/source/java/org/alfresco/repo/rule/RuleServiceImplTest.java b/source/java/org/alfresco/repo/rule/RuleServiceImplTest.java index 7b29e8a950..37d155e75b 100644 --- a/source/java/org/alfresco/repo/rule/RuleServiceImplTest.java +++ b/source/java/org/alfresco/repo/rule/RuleServiceImplTest.java @@ -31,16 +31,21 @@ import org.alfresco.repo.action.executer.ImageTransformActionExecuter; import org.alfresco.repo.content.MimetypeMap; import org.alfresco.repo.content.transform.AbstractContentTransformerTest; import org.alfresco.repo.security.authentication.AuthenticationUtil; +import org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback; import org.alfresco.service.cmr.action.Action; import org.alfresco.service.cmr.action.ActionCondition; +import org.alfresco.service.cmr.action.CompositeAction; import org.alfresco.service.cmr.repository.ChildAssociationRef; import org.alfresco.service.cmr.repository.ContentWriter; import org.alfresco.service.cmr.repository.CyclicChildRelationshipException; import org.alfresco.service.cmr.repository.NodeRef; +import org.alfresco.service.cmr.repository.StoreRef; import org.alfresco.service.cmr.rule.Rule; import org.alfresco.service.cmr.rule.RuleType; import org.alfresco.service.cmr.security.MutableAuthenticationService; import org.alfresco.service.cmr.security.PermissionService; +import org.alfresco.service.namespace.NamespaceService; +import org.alfresco.service.cmr.search.SearchService; import org.alfresco.service.namespace.QName; import org.alfresco.service.namespace.RegexQNamePattern; @@ -56,16 +61,20 @@ public class RuleServiceImplTest extends BaseRuleTest private RegexQNamePattern ASSOC_NAME_RULES_REGEX = new RegexQNamePattern(RuleModel.RULE_MODEL_URI, "^" + ASSOC_NAME_RULES_PREFIX + ".*"); MutableAuthenticationService authenticationService; - PermissionService permissionService; - - @Override - protected void onSetUpInTransaction() throws Exception - { - super.onSetUpInTransaction(); - this.permissionService = (PermissionService)this.applicationContext.getBean("permissionService"); + PermissionService permissionService; + SearchService searchService; + NamespaceService namespaceService; + + @Override + protected void onSetUpInTransaction() throws Exception + { + super.onSetUpInTransaction(); + this.permissionService = (PermissionService)this.applicationContext.getBean("permissionService"); this.authenticationService = (MutableAuthenticationService)this.applicationContext.getBean("authenticationService"); - } - + this.searchService = (SearchService) applicationContext.getBean("SearchService"); + this.namespaceService = (NamespaceService) applicationContext.getBean("NamespaceService"); + } + /** * Test get rule type */ @@ -76,9 +85,9 @@ public class RuleServiceImplTest extends BaseRuleTest // Visual check to make sure that the display labels are being returned correctly for (RuleType type : ruleTypes) - { - System.out.println(type.getDisplayLabel()); - } + { + System.out.println(type.getDisplayLabel()); + } } /** @@ -369,55 +378,55 @@ public class RuleServiceImplTest extends BaseRuleTest public void testRuleServicePermissionsConsumer() { - this.authenticationService.createAuthentication("conUser", "password".toCharArray()); - this.permissionService.setPermission(this.nodeRef, "conUser", PermissionService.CONSUMER, true); - this.permissionService.setInheritParentPermissions(this.nodeRef, true); - - this.authenticationService.authenticate("conUser", "password".toCharArray()); - Rule rule = createTestRule(); - try - { - this.ruleService.saveRule(this.nodeRef, rule); - // Fail - fail("Consumers cannot create rules."); - } - catch (Exception exception) - { - // Ok - } + this.authenticationService.createAuthentication("conUser", "password".toCharArray()); + this.permissionService.setPermission(this.nodeRef, "conUser", PermissionService.CONSUMER, true); + this.permissionService.setInheritParentPermissions(this.nodeRef, true); + + this.authenticationService.authenticate("conUser", "password".toCharArray()); + Rule rule = createTestRule(); + try + { + this.ruleService.saveRule(this.nodeRef, rule); + // Fail + fail("Consumers cannot create rules."); + } + catch (Exception exception) + { + // Ok + } } public void testRuleServicePermissionsEditor() { - this.authenticationService.createAuthentication("editorUser", "password".toCharArray()); - this.permissionService.setPermission(this.nodeRef, "editorUser", PermissionService.EDITOR, true); - this.permissionService.setInheritParentPermissions(this.nodeRef, true); - - this.authenticationService.authenticate("editorUser", "password".toCharArray()); - Rule rule = createTestRule(); - try - { - this.ruleService.saveRule(this.nodeRef, rule); - // Fail - fail("Editors cannot create rules."); - } - catch (Exception exception) - { - // Ok - } + this.authenticationService.createAuthentication("editorUser", "password".toCharArray()); + this.permissionService.setPermission(this.nodeRef, "editorUser", PermissionService.EDITOR, true); + this.permissionService.setInheritParentPermissions(this.nodeRef, true); + + this.authenticationService.authenticate("editorUser", "password".toCharArray()); + Rule rule = createTestRule(); + try + { + this.ruleService.saveRule(this.nodeRef, rule); + // Fail + fail("Editors cannot create rules."); + } + catch (Exception exception) + { + // Ok + } } public void testRuleServicePermissionsCoordinator() { - this.authenticationService.createAuthentication("coordUser", "password".toCharArray()); - this.permissionService.setPermission(this.nodeRef, "coordUser", PermissionService.COORDINATOR, true); - this.permissionService.setInheritParentPermissions(this.nodeRef, true); - + this.authenticationService.createAuthentication("coordUser", "password".toCharArray()); + this.permissionService.setPermission(this.nodeRef, "coordUser", PermissionService.COORDINATOR, true); + this.permissionService.setInheritParentPermissions(this.nodeRef, true); + this.authenticationService.authenticate(AuthenticationUtil.getAdminUserName(), "admin".toCharArray()); - Rule rule2 = createTestRule(); - this.ruleService.saveRule(this.nodeRef, rule2); - this.authenticationService.clearCurrentSecurityContext(); + Rule rule2 = createTestRule(); + this.ruleService.saveRule(this.nodeRef, rule2); + this.authenticationService.clearCurrentSecurityContext(); } /** @@ -863,4 +872,58 @@ public class RuleServiceImplTest extends BaseRuleTest // }; // }); } + + public void testDeleteSpaceWithExecuteScriptRule() throws Exception + { + transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback() + { + public Object execute() + { + NodeRef storeRootNodeRef = nodeService.getRootNode(new StoreRef("workspace://SpacesStore")); + // get company_home nodeRef + NodeRef companyHomeNodeRef = searchService.selectNodes(storeRootNodeRef, "/app:company_home", null, namespaceService, false).get(0); + + assertNotNull("NodeRef company_home is null", companyHomeNodeRef); + + // create test folder in company_home + QName testFolderName = QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, "ISSUE_ETWOTWO_738_" + System.currentTimeMillis()); + ChildAssociationRef childAssocRef = nodeService.createNode(companyHomeNodeRef, ContentModel.ASSOC_CONTAINS, testFolderName, ContentModel.TYPE_FOLDER); + NodeRef testFolderNodeRef = childAssocRef.getChildRef(); + + // get script nodeRef + NodeRef scriptRef = searchService.selectNodes(storeRootNodeRef, "/app:company_home/app:dictionary/app:scripts/cm:backup.js", null, namespaceService, false).get(0); + + assertNotNull("NodeRef script is null", scriptRef); + + // create rule + Rule rule = new Rule(); + rule.setRuleType("inbound"); + rule.setTitle("rule title " + System.currentTimeMillis()); + + CompositeAction compositeAction = actionService.createCompositeAction(); + rule.setAction(compositeAction); + + // add the conditions to the rule + ActionCondition condition = actionService.createActionCondition("no-condition"); + condition.setParameterValues(new HashMap()); + condition.setInvertCondition(false); + compositeAction.addActionCondition(condition); + + // add the action to the rule + Action action = actionService.createAction("script"); + Map repoActionParams = new HashMap(); + repoActionParams.put("script-ref", scriptRef); + action.setParameterValues(repoActionParams); + compositeAction.addAction(action); + + // save rule + ruleService.saveRule(testFolderNodeRef, rule); + + // delete node with rule + nodeService.deleteNode(testFolderNodeRef); + + return null; + } + }, false, true); + } } diff --git a/source/java/org/alfresco/repo/rule/ruletrigger/RestoreNodeRuleTrigger.java b/source/java/org/alfresco/repo/rule/ruletrigger/RestoreNodeRuleTrigger.java new file mode 100755 index 0000000000..9d4032efb0 --- /dev/null +++ b/source/java/org/alfresco/repo/rule/ruletrigger/RestoreNodeRuleTrigger.java @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2005-2007 Alfresco Software Limited. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program 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 General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + + * As a special exception to the terms and conditions of version 2.0 of + * the GPL, you may redistribute this Program in connection with Free/Libre + * and Open Source Software ("FLOSS") applications as described in Alfresco's + * FLOSS exception. You should have recieved a copy of the text describing + * the FLOSS exception, and it is also available here: + * http://www.alfresco.com/legal/licensing" + */ +package org.alfresco.repo.rule.ruletrigger; + +import org.alfresco.repo.node.NodeServicePolicies; +import org.alfresco.repo.policy.JavaBehaviour; +import org.alfresco.service.cmr.repository.ChildAssociationRef; +import org.alfresco.service.namespace.NamespaceService; +import org.alfresco.service.namespace.QName; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +/** + * Special rule trigger to be invoked when the node has been restored from the trashcan (recycle bin). + * + * @author arsenyko + */ +public class RestoreNodeRuleTrigger extends RuleTriggerAbstractBase implements NodeServicePolicies.OnRestoreNodePolicy +{ + private static Log logger = LogFactory.getLog(RestoreNodeRuleTrigger.class); + + private static final String POLICY = "onRestoreNode"; + + public void onRestoreNode(ChildAssociationRef childAssocRef) + { + if (logger.isDebugEnabled()) + { + logger.debug( + "Restore node rule trigger fired for parent node " + + this.nodeService.getType(childAssocRef.getParentRef()).toString() + " " + childAssocRef.getParentRef() + + " and child node " + + this.nodeService.getType(childAssocRef.getChildRef()).toString() + " " + childAssocRef.getChildRef()); + } + triggerRules(childAssocRef.getParentRef(), childAssocRef.getChildRef()); + } + + /** + * @see org.alfresco.repo.rule.ruletrigger.RuleTrigger#registerRuleTrigger() + */ + public void registerRuleTrigger() + { + this.policyComponent.bindClassBehaviour(QName.createQName(NamespaceService.ALFRESCO_URI, POLICY), this, new JavaBehaviour(this, POLICY)); + } + +} diff --git a/source/java/org/alfresco/repo/security/permissions/impl/PermissionServiceTest.java b/source/java/org/alfresco/repo/security/permissions/impl/PermissionServiceTest.java index e0c59e7556..862ec1cc31 100644 --- a/source/java/org/alfresco/repo/security/permissions/impl/PermissionServiceTest.java +++ b/source/java/org/alfresco/repo/security/permissions/impl/PermissionServiceTest.java @@ -1896,8 +1896,8 @@ public class PermissionServiceTest extends AbstractPermissionTest permissionService.hasPermission(n5, PermissionService.READ); } long end = System.nanoTime(); - System.out.println("Can in " + ((end - start) / 10e9f / 10000)); - System.out.println("Can per second " + (1 / ((end - start) / 10e9f / 10000))); + System.out.println("Can in " + ((end - start) / 1e9f / 10000)); + System.out.println("Can per second " + (1 / ((end - start) / 1e9f / 10000))); } diff --git a/source/java/org/alfresco/repo/security/person/PersonTest.java b/source/java/org/alfresco/repo/security/person/PersonTest.java index 4d0a460517..3dbca861d5 100644 --- a/source/java/org/alfresco/repo/security/person/PersonTest.java +++ b/source/java/org/alfresco/repo/security/person/PersonTest.java @@ -472,11 +472,11 @@ public class PersonTest extends TestCase personService.createPerson(createDefaultProperties("Derek", "Derek", "Hulley", "dh@dh", "alfresco", rootNodeRef)); testProperties(personService.getPerson("Derek"), "Derek", "Derek", "Hulley", "dh@dh", "alfresco"); - personService.setPersonProperties("Derek", createDefaultProperties("derek", "Derek_", "Hulley_", "dh@dh_", "alfresco_", rootNodeRef)); + personService.setPersonProperties("Derek", createDefaultProperties("notderek", "Derek_", "Hulley_", "dh@dh_", "alfresco_", rootNodeRef)); testProperties(personService.getPerson("Derek"), "Derek", "Derek_", "Hulley_", "dh@dh_", "alfresco_"); - personService.setPersonProperties("Derek", createDefaultProperties("derek", "Derek", "Hulley", "dh@dh", "alfresco", rootNodeRef)); + personService.setPersonProperties("Derek", createDefaultProperties("notderek", "Derek", "Hulley", "dh@dh", "alfresco", rootNodeRef)); testProperties(personService.getPerson("Derek"), "Derek", "Derek", "Hulley", "dh@dh", "alfresco"); diff --git a/source/java/org/alfresco/repo/security/sync/ChainingUserRegistrySynchronizerTest.java b/source/java/org/alfresco/repo/security/sync/ChainingUserRegistrySynchronizerTest.java index 76c0f9a10d..c65321eba2 100644 --- a/source/java/org/alfresco/repo/security/sync/ChainingUserRegistrySynchronizerTest.java +++ b/source/java/org/alfresco/repo/security/sync/ChainingUserRegistrySynchronizerTest.java @@ -32,6 +32,7 @@ import java.util.List; import java.util.Map; import java.util.Random; import java.util.Set; +import java.util.TreeMap; import junit.framework.TestCase; @@ -371,10 +372,18 @@ public class ChainingUserRegistrySynchronizerTest extends TestCase { setUpTestUsersAndGroups(); - // Get hold of the original person nodes so we can compare them later - NodeRef u1 = this.personService.getPerson("U1", false); - NodeRef u2 = this.personService.getPerson("U2", false); - NodeRef u6 = this.personService.getPerson("U6", false); + final Map personNodes = new TreeMap(); + this.retryingTransactionHelper.doInTransaction(new RetryingTransactionCallback() + { + public Object execute() throws Throwable + { + // Get hold of the original person nodes so we can compare them later + personNodes.put("u1", ChainingUserRegistrySynchronizerTest.this.personService.getPerson("U1", false)); + personNodes.put("u2", ChainingUserRegistrySynchronizerTest.this.personService.getPerson("U2", false)); + personNodes.put("u6", ChainingUserRegistrySynchronizerTest.this.personService.getPerson("U6", false)); + return null; + } + }, false, true); this.applicationContextManager.setUserRegistries(new MockUserRegistry("Z1", new NodeDescription[] { @@ -410,15 +419,18 @@ public class ChainingUserRegistrySynchronizerTest extends TestCase assertExists("Z2", "G2", "U3", "U4"); assertExists("Z2", "G6", "U3", "U4", "G7"); assertExists("Z2", "G7", "U5"); + + // Make sure the original people have been preserved + assertEquals(personNodes.get("u1"), ChainingUserRegistrySynchronizerTest.this.personService.getPerson( + "U1", false)); + assertEquals(personNodes.get("u2"), ChainingUserRegistrySynchronizerTest.this.personService.getPerson( + "U2", false)); + assertEquals(personNodes.get("u6"), ChainingUserRegistrySynchronizerTest.this.personService.getPerson( + "U6", false)); return null; } }, false, true); - // Make sure the original people have been preserved - assertEquals(u1, this.personService.getPerson("U1", false)); - assertEquals(u2, this.personService.getPerson("U2", false)); - assertEquals(u6, this.personService.getPerson("U6", false)); - tearDownTestUsersAndGroups(); }