mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-08-07 17:49:17 +00:00
Massive renaming. Delegate/Delegation becomes Referrer, Referent and things *do* make a little more sense.
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/modules/recordsmanagement/BRANCHES/classified_renditions@111633 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
Neil McErlean
@@ -1,194 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2005-2015 Alfresco Software Limited.
|
||||
*
|
||||
* This file is part of Alfresco
|
||||
*
|
||||
* 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/>.
|
||||
*/
|
||||
package org.alfresco.module.org_alfresco_module_rm.metadatadelegation;
|
||||
|
||||
import static java.util.Collections.emptyMap;
|
||||
import static java.util.Arrays.asList;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.metadatadelegation.DelegationException.DelegateNotFound;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.metadatadelegation.DelegationException.DelegationNotFound;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.test.util.ExceptionUtils.expectedException;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.test.util.FPUtils.asSet;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.mockito.Mockito.any;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.eq;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
import org.alfresco.service.cmr.dictionary.ClassDefinition;
|
||||
import org.alfresco.service.cmr.dictionary.DictionaryService;
|
||||
import org.alfresco.service.cmr.dictionary.PropertyDefinition;
|
||||
import org.alfresco.service.cmr.repository.AssociationRef;
|
||||
import org.alfresco.service.cmr.repository.NodeRef;
|
||||
import org.alfresco.service.cmr.repository.NodeService;
|
||||
import org.alfresco.service.cmr.repository.StoreRef;
|
||||
import org.alfresco.service.namespace.QName;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.MockitoAnnotations;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Unit tests for {@link DelegationServiceImpl}.
|
||||
*
|
||||
* @author Neil Mc Erlean
|
||||
* @since 3.0.a
|
||||
*/
|
||||
public class DelegationServiceImplUnitTest
|
||||
{
|
||||
@InjectMocks private final DelegationServiceImpl delegationService = new DelegationServiceImpl();
|
||||
|
||||
@Mock DictionaryService mockDictionaryService;
|
||||
@Mock NodeService mockNodeService;
|
||||
@Mock DelegationAdminServiceImpl mockDelegationAdminService;
|
||||
|
||||
/** This node has a delegate node. */
|
||||
private final NodeRef nodeWithDelegate = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, "nodeWithDelegate");
|
||||
/** This is the delgate for {@link #nodeWithDelegate}. */
|
||||
private final NodeRef delegateNode = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, "delegateNode");
|
||||
/** This node has no delegate node. */
|
||||
private final NodeRef nodeWithoutDelegate = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, "nodeWithoutDelegate");
|
||||
|
||||
/** The type of the peer association that links the delegate to its source. */
|
||||
private final QName delegateAssocType = QName.createQName("test", "delegateAssocType");
|
||||
/** The instance of the association between {@link #nodeWithDelegate} and {@link #delegateNode}. */
|
||||
private final AssociationRef delegateAssocRef = new AssociationRef(nodeWithDelegate, delegateAssocType, delegateNode);
|
||||
|
||||
/** Name of an aspect that has been delegated. */
|
||||
private final QName delegatedAspect1 = QName.createQName("test", "delegatedAspect1");
|
||||
/** Name of an aspect that has been delegated. */
|
||||
private final QName delegatedAspect2 = QName.createQName("test", "delegatedAspect2");
|
||||
/** Name of a content class (a type in this case) that has not been delegated.
|
||||
* N.B. Types can't be delegated currently. */
|
||||
private final QName undelegatedType = QName.createQName("test", "undelegatedType");
|
||||
|
||||
private final QName delegatedProp = QName.createQName("test", "delegatedProp");
|
||||
private final Serializable delegatedPropValue = "hello";
|
||||
private final QName undelegatedProp = QName.createQName("test", "undelegatedProp");
|
||||
|
||||
private final Delegation delegate = new Delegation()
|
||||
{{
|
||||
this.setAssocType(delegateAssocType);
|
||||
this.setAspects(asSet(delegatedAspect1, delegatedAspect2));
|
||||
}};
|
||||
|
||||
@Before public void setUp()
|
||||
{
|
||||
MockitoAnnotations.initMocks(this);
|
||||
|
||||
final PropertyDefinition aspectProp = mock(PropertyDefinition.class);
|
||||
final ClassDefinition aspectDefn = mock(ClassDefinition.class);
|
||||
when(aspectDefn.getName()).thenReturn(delegatedAspect1);
|
||||
when(aspectProp.getContainerClass()).thenReturn(aspectDefn);
|
||||
when(aspectDefn.isAspect()).thenReturn(true);
|
||||
|
||||
final PropertyDefinition typeProp = mock(PropertyDefinition.class);
|
||||
final ClassDefinition typeDefn = mock(ClassDefinition.class);
|
||||
when(typeDefn.getName()).thenReturn(undelegatedType);
|
||||
when(typeProp.getContainerClass()).thenReturn(typeDefn);
|
||||
when(typeDefn.isAspect()).thenReturn(false);
|
||||
|
||||
when(mockDictionaryService.getProperty(delegatedProp)).thenReturn(aspectProp);
|
||||
|
||||
when(mockDelegationAdminService.getDelegationsFrom(nodeWithDelegate)).thenReturn(asSet(delegate));
|
||||
for (QName delegatedAspect : asSet(delegatedAspect1, delegatedAspect2))
|
||||
{
|
||||
when(mockDelegationAdminService.getDelegationFor(delegatedAspect)).thenReturn(delegate);
|
||||
when(mockNodeService.hasAspect(delegateNode, delegatedAspect)).thenReturn(true);
|
||||
}
|
||||
when(mockNodeService.getSourceAssocs(delegateNode, delegateAssocType)).thenReturn(asList(delegateAssocRef));
|
||||
when(mockNodeService.getTargetAssocs(nodeWithDelegate, delegateAssocType)).thenReturn(asList(delegateAssocRef));
|
||||
when(mockNodeService.exists(any(NodeRef.class))).thenReturn(true);
|
||||
when(mockNodeService.getProperties(delegateNode))
|
||||
.thenReturn(new HashMap<QName, Serializable>()
|
||||
{{
|
||||
this.put(delegatedProp, delegatedPropValue);
|
||||
}});
|
||||
}
|
||||
|
||||
@Test public void hasDelegateForAspect()
|
||||
{
|
||||
assertTrue(delegationService.hasDelegateForAspect(nodeWithDelegate, delegatedAspect1));
|
||||
expectedException(DelegationNotFound.class, () -> delegationService.hasDelegateForAspect(nodeWithoutDelegate, undelegatedType));
|
||||
assertFalse(delegationService.hasDelegateForAspect(nodeWithoutDelegate, delegatedAspect1));
|
||||
}
|
||||
|
||||
@Test public void getDelegateFor()
|
||||
{
|
||||
assertEquals(delegateNode, delegationService.getDelegateFor(nodeWithDelegate, delegatedAspect1));
|
||||
expectedException(DelegationNotFound.class, () ->
|
||||
{
|
||||
delegationService.getDelegateFor(nodeWithDelegate, undelegatedType);
|
||||
return null;
|
||||
});
|
||||
assertNull(delegationService.getDelegateFor(nodeWithoutDelegate, delegatedAspect1));
|
||||
}
|
||||
|
||||
@Test public void getDelegateProperties()
|
||||
{
|
||||
final Map<QName, Serializable> expectedProps = new HashMap<>();
|
||||
expectedProps.put(delegatedProp, delegatedPropValue);
|
||||
|
||||
assertEquals(expectedProps, delegationService.getDelegateProperties(nodeWithDelegate, delegatedAspect1));
|
||||
|
||||
expectedException(DelegationNotFound.class,
|
||||
() -> delegationService.getDelegateProperties(nodeWithDelegate, undelegatedType));
|
||||
|
||||
expectedException(DelegateNotFound.class,
|
||||
() -> delegationService.getDelegateProperties(nodeWithoutDelegate, delegatedAspect1));
|
||||
}
|
||||
|
||||
@Test public void getDelegateProperty()
|
||||
{
|
||||
assertEquals(delegatedPropValue, delegationService.getDelegateProperty(nodeWithDelegate, delegatedProp));
|
||||
|
||||
expectedException(IllegalArgumentException.class,
|
||||
() -> delegationService.getDelegateProperty(nodeWithDelegate, undelegatedProp));
|
||||
|
||||
expectedException(DelegationNotFound.class,
|
||||
() -> delegationService.getDelegateProperties(nodeWithoutDelegate, delegatedProp));
|
||||
}
|
||||
|
||||
@Test public void hasAspectOnDelegate()
|
||||
{
|
||||
assertTrue(delegationService.hasAspectOnDelegate(nodeWithDelegate, delegatedAspect1));
|
||||
|
||||
expectedException(DelegationNotFound.class,
|
||||
() -> delegationService.hasAspectOnDelegate(nodeWithDelegate, undelegatedType));
|
||||
|
||||
expectedException(DelegateNotFound.class,
|
||||
() -> delegationService.hasAspectOnDelegate(nodeWithoutDelegate, delegatedAspect1));
|
||||
}
|
||||
|
||||
@Test public void getDelegations()
|
||||
{
|
||||
final Map<Delegation, NodeRef> expectedDelegations = new HashMap<>();
|
||||
expectedDelegations.put(delegate, delegateNode);
|
||||
|
||||
assertEquals(expectedDelegations, delegationService.getDelegations(nodeWithDelegate));
|
||||
assertEquals(emptyMap(), delegationService.getDelegations(nodeWithoutDelegate));
|
||||
}
|
||||
}
|
||||
@@ -16,10 +16,10 @@
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package org.alfresco.module.org_alfresco_module_rm.metadatadelegation;
|
||||
package org.alfresco.module.org_alfresco_module_rm.referredmetadata;
|
||||
|
||||
import static java.util.Collections.emptySet;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.metadatadelegation.DelegationException.InvalidDelegation;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.referredmetadata.ReferredMetadataException.InvalidMetadataReferral;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.test.util.ExceptionUtils.expectedException;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.test.util.FPUtils.asListFrom;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.test.util.FPUtils.asSet;
|
||||
@@ -41,17 +41,17 @@ import org.mockito.MockitoAnnotations;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Unit tests for {@link Delegation}.
|
||||
* Unit tests for {@link MetadataReferral}.
|
||||
*
|
||||
* @author Neil Mc Erlean
|
||||
* @since 3.0.a
|
||||
*/
|
||||
public class DelegationUnitTest
|
||||
public class MetadataReferralUnitTest
|
||||
{
|
||||
@Mock DictionaryService mockDictionaryService;
|
||||
@Mock NodeService mockNodeService;
|
||||
|
||||
private final DelegationAdminServiceImpl metadataDelegationService = new DelegationAdminServiceImpl();
|
||||
private final ReferralAdminServiceImpl referralAdminService = new ReferralAdminServiceImpl();
|
||||
|
||||
private final NodeRef node1 = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, "node1");
|
||||
private final NodeRef node2 = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, "node2");
|
||||
@@ -63,66 +63,66 @@ public class DelegationUnitTest
|
||||
{
|
||||
MockitoAnnotations.initMocks(this);
|
||||
|
||||
metadataDelegationService.setNodeService(mockNodeService);
|
||||
referralAdminService.setNodeService(mockNodeService);
|
||||
}
|
||||
|
||||
@Test public void nullOrEmptyDelegatesAreForbidden()
|
||||
@Test public void nullOrEmptyReferralsAreForbidden()
|
||||
{
|
||||
List<Delegation> invalidDelegations = asListFrom(() -> new Delegation(),
|
||||
List<MetadataReferral> invalidMetadataReferrals = asListFrom(() -> new MetadataReferral(),
|
||||
() -> {
|
||||
Delegation d = new Delegation();
|
||||
d.setAssocType(assoc1);
|
||||
d.setAspects(null);
|
||||
d.setDictionaryService(mockDictionaryService);
|
||||
return d;
|
||||
MetadataReferral mr = new MetadataReferral();
|
||||
mr.setAssocType(assoc1);
|
||||
mr.setAspects(null);
|
||||
mr.setDictionaryService(mockDictionaryService);
|
||||
return mr;
|
||||
},
|
||||
() -> {
|
||||
Delegation d = new Delegation();
|
||||
d.setAssocType(assoc1);
|
||||
d.setAspects(emptySet());
|
||||
d.setDictionaryService(mockDictionaryService);
|
||||
return d;
|
||||
MetadataReferral mr = new MetadataReferral();
|
||||
mr.setAssocType(assoc1);
|
||||
mr.setAspects(emptySet());
|
||||
mr.setDictionaryService(mockDictionaryService);
|
||||
return mr;
|
||||
},
|
||||
() -> {
|
||||
Delegation d = new Delegation();
|
||||
d.setAssocType(null);
|
||||
d.setAspects(asSet(aspect1, aspect2));
|
||||
d.setDictionaryService(mockDictionaryService);
|
||||
return d;
|
||||
MetadataReferral mr = new MetadataReferral();
|
||||
mr.setAssocType(null);
|
||||
mr.setAspects(asSet(aspect1, aspect2));
|
||||
mr.setDictionaryService(mockDictionaryService);
|
||||
return mr;
|
||||
});
|
||||
|
||||
invalidDelegations.stream()
|
||||
.forEach(d -> expectedException(InvalidDelegation.class, () -> {
|
||||
d.validateAndRegister();
|
||||
invalidMetadataReferrals.stream()
|
||||
.forEach(mr -> expectedException(InvalidMetadataReferral.class, () -> {
|
||||
mr.validateAndRegister();
|
||||
return null;
|
||||
}
|
||||
));
|
||||
}
|
||||
|
||||
@Test(expected=InvalidDelegation.class)
|
||||
public void delegateMustHaveAssocThatExists()
|
||||
@Test(expected=InvalidMetadataReferral.class)
|
||||
public void referralMustHaveAssocThatExists()
|
||||
{
|
||||
when(mockDictionaryService.getAssociation(assoc1)).thenReturn(null);
|
||||
when(mockDictionaryService.getAspect(aspect1)).thenReturn(mock(AspectDefinition.class));
|
||||
|
||||
Delegation d = new Delegation();
|
||||
d.setAssocType(assoc1);
|
||||
d.setAspects(asSet(aspect1));
|
||||
d.setDictionaryService(mockDictionaryService);
|
||||
d.validateAndRegister();
|
||||
MetadataReferral mr = new MetadataReferral();
|
||||
mr.setAssocType(assoc1);
|
||||
mr.setAspects(asSet(aspect1));
|
||||
mr.setDictionaryService(mockDictionaryService);
|
||||
mr.validateAndRegister();
|
||||
}
|
||||
|
||||
@Test(expected=InvalidDelegation.class)
|
||||
public void delegateMustHaveAspectsAllOfWhichExist()
|
||||
@Test(expected=InvalidMetadataReferral.class)
|
||||
public void referralMustHaveAspectsAllOfWhichExist()
|
||||
{
|
||||
when(mockDictionaryService.getAssociation(assoc1)).thenReturn(mock(AssociationDefinition.class));
|
||||
when(mockDictionaryService.getAspect(aspect1)).thenReturn(mock(AspectDefinition.class));
|
||||
when(mockDictionaryService.getAspect(aspect2)).thenReturn(null);
|
||||
|
||||
Delegation d = new Delegation();
|
||||
d.setAssocType(assoc1);
|
||||
d.setAspects(asSet(aspect1, aspect2));
|
||||
d.setDictionaryService(mockDictionaryService);
|
||||
d.validateAndRegister();
|
||||
MetadataReferral mr = new MetadataReferral();
|
||||
mr.setAssocType(assoc1);
|
||||
mr.setAspects(asSet(aspect1, aspect2));
|
||||
mr.setDictionaryService(mockDictionaryService);
|
||||
mr.validateAndRegister();
|
||||
}
|
||||
}
|
||||
@@ -16,10 +16,10 @@
|
||||
* You should have received a copy of the GNU Lesser General Public License
|
||||
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package org.alfresco.module.org_alfresco_module_rm.metadatadelegation;
|
||||
package org.alfresco.module.org_alfresco_module_rm.referredmetadata;
|
||||
|
||||
import static java.util.Arrays.asList;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.metadatadelegation.DelegationException.ChainedDelegationUnsupported;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.referredmetadata.ReferredMetadataException.ChainedMetadataReferralUnsupported;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.test.util.ExceptionUtils.expectedException;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.test.util.FPUtils.asSet;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
@@ -40,37 +40,37 @@ import org.mockito.Mock;
|
||||
import org.mockito.MockitoAnnotations;
|
||||
|
||||
/**
|
||||
* Unit tests for {@link DelegationAdminServiceImpl}.
|
||||
* Unit tests for {@link ReferralAdminServiceImpl}.
|
||||
*
|
||||
* @author Neil Mc Erlean
|
||||
* @since 3.0.a
|
||||
* @since 2.4.a
|
||||
*/
|
||||
public class DelegationAdminServiceImplUnitTest
|
||||
public class ReferralAdminServiceImplUnitTest
|
||||
{
|
||||
@InjectMocks private final DelegationAdminServiceImpl delegationAdminService = new DelegationAdminServiceImpl();
|
||||
@InjectMocks private final ReferralAdminServiceImpl referralAdminService = new ReferralAdminServiceImpl();
|
||||
|
||||
@Mock DictionaryService mockDictionaryService;
|
||||
@Mock NodeService mockNodeService;
|
||||
@Mock DelegationRegistry mockRegistry;
|
||||
@Mock DelegationServiceImpl mockDelegationService;
|
||||
@Mock DictionaryService mockDictionaryService;
|
||||
@Mock NodeService mockNodeService;
|
||||
@Mock ReferralRegistry mockRegistry;
|
||||
@Mock ReferredMetadataServiceImpl mockReferredMetadataService;
|
||||
|
||||
private final NodeRef node1 = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, "node1");
|
||||
private final NodeRef node2 = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, "node2");
|
||||
private final NodeRef node3 = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, "node3");
|
||||
|
||||
private final QName assoc1 = QName.createQName("test", "assoc1");
|
||||
private final QName assoc2 = QName.createQName("test", "assoc2");
|
||||
|
||||
private final QName aspect1 = QName.createQName("test", "aspect1");
|
||||
private final QName aspect2 = QName.createQName("test", "aspect2");
|
||||
|
||||
private final QName assoc2 = QName.createQName("test", "assoc2");
|
||||
private final QName aspect3 = QName.createQName("test", "aspect3");
|
||||
|
||||
private final Delegation delegate1 = new Delegation()
|
||||
private final MetadataReferral referral1 = new MetadataReferral()
|
||||
{{
|
||||
this.setAssocType(assoc1);
|
||||
this.setAspects(asSet(aspect1, aspect2));
|
||||
}};
|
||||
private final Delegation delegate2 = new Delegation()
|
||||
private final MetadataReferral referral2 = new MetadataReferral()
|
||||
{{
|
||||
this.setAssocType(assoc2);
|
||||
this.setAspects(asSet(aspect3));
|
||||
@@ -80,61 +80,61 @@ public class DelegationAdminServiceImplUnitTest
|
||||
{
|
||||
MockitoAnnotations.initMocks(this);
|
||||
|
||||
when(mockRegistry.getDelegations()).thenReturn(asSet(delegate1, delegate2));
|
||||
when(mockRegistry.getMetadataReferrals()).thenReturn(asSet(referral1, referral2));
|
||||
}
|
||||
|
||||
@Test(expected=IllegalArgumentException.class)
|
||||
public void attachingDelegateWithNoAssociationConfiguredShouldFail()
|
||||
public void attachingReferrerWithNoAssociationConfiguredShouldFail()
|
||||
{
|
||||
delegationAdminService.attachDelegate(node1, node2, assoc1);
|
||||
referralAdminService.attachReferrer(node2, node1, assoc1);
|
||||
}
|
||||
|
||||
@Test public void attachDetach()
|
||||
{
|
||||
when(mockRegistry.getDelegateForAssociation(assoc1)).thenReturn(delegate1);
|
||||
when(mockRegistry.getReferralForAssociation(assoc1)).thenReturn(referral1);
|
||||
|
||||
// attach
|
||||
Delegation d = attachDelegate(node1, node2, assoc1);
|
||||
MetadataReferral d = attachReferrer(node1, node2, assoc1);
|
||||
|
||||
// validate
|
||||
assertEquals(assoc1, d.getAssocType());
|
||||
assertEquals(asSet(aspect1, aspect2), d.getAspects());
|
||||
assertTrue(mockDelegationService.hasDelegateForAspect(node1, aspect1));
|
||||
assertFalse(mockDelegationService.hasDelegateForAspect(node1, aspect3));
|
||||
assertTrue(mockReferredMetadataService.isReferringMetadata(node1, aspect1));
|
||||
assertFalse(mockReferredMetadataService.isReferringMetadata(node1, aspect3));
|
||||
|
||||
// detach
|
||||
assertEquals(d, delegationAdminService.detachDelegate(node1, assoc1));
|
||||
assertEquals(d, referralAdminService.detachReferrer(node1, assoc1));
|
||||
}
|
||||
|
||||
private Delegation attachDelegate(NodeRef from, NodeRef to, QName assocType)
|
||||
private MetadataReferral attachReferrer(NodeRef referrer, NodeRef referent, QName assocType)
|
||||
{
|
||||
Delegation d = delegationAdminService.attachDelegate(from, to, assocType);
|
||||
when(mockNodeService.getSourceAssocs(to, assocType)).thenReturn(asList(new AssociationRef(from, assocType, to)));
|
||||
when(mockNodeService.getTargetAssocs(from, assocType)).thenReturn(asList(new AssociationRef(from, assocType, to)));
|
||||
MetadataReferral d = referralAdminService.attachReferrer(referrer, referent, assocType);
|
||||
when(mockNodeService.getSourceAssocs(referent, assocType)).thenReturn(asList(new AssociationRef(referrer, assocType, referent)));
|
||||
when(mockNodeService.getTargetAssocs(referrer, assocType)).thenReturn(asList(new AssociationRef(referrer, assocType, referent)));
|
||||
for (QName aspect : d.getAspects())
|
||||
{
|
||||
when(mockDelegationService.hasDelegateForAspect(from, aspect)).thenReturn(true);
|
||||
when(mockReferredMetadataService.isReferringMetadata(referrer, aspect)).thenReturn(true);
|
||||
}
|
||||
return d;
|
||||
}
|
||||
|
||||
@Test public void chainsOfDelegationShouldBePrevented()
|
||||
{
|
||||
when(mockRegistry.getDelegateForAssociation(assoc1)).thenReturn(delegate1);
|
||||
when(mockRegistry.getReferralForAssociation(assoc1)).thenReturn(referral1);
|
||||
|
||||
// The node already has a delegation in place: node1 -> node2. We're trying to add to the
|
||||
// end of the chain: node2 -> node3
|
||||
when(mockNodeService.getSourceAssocs(node2, assoc1)).thenReturn(asList(new AssociationRef(node1, assoc1, node2)));
|
||||
when(mockNodeService.getTargetAssocs(node1, assoc1)).thenReturn(asList(new AssociationRef(node1, assoc1, node2)));
|
||||
|
||||
expectedException(ChainedDelegationUnsupported.class, () -> {
|
||||
delegationAdminService.attachDelegate(node2, node3, assoc1);
|
||||
expectedException(ChainedMetadataReferralUnsupported.class, () -> {
|
||||
referralAdminService.attachReferrer(node2, node3, assoc1);
|
||||
return null;
|
||||
});
|
||||
|
||||
// Now try to add to the start of the chain: node3 -> node1
|
||||
expectedException(ChainedDelegationUnsupported.class, () -> {
|
||||
delegationAdminService.attachDelegate(node3, node1, assoc1);
|
||||
expectedException(ChainedMetadataReferralUnsupported.class, () -> {
|
||||
referralAdminService.attachReferrer(node3, node1, assoc1);
|
||||
return null;
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,195 @@
|
||||
/*
|
||||
* Copyright (C) 2005-2015 Alfresco Software Limited.
|
||||
*
|
||||
* This file is part of Alfresco
|
||||
*
|
||||
* 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/>.
|
||||
*/
|
||||
package org.alfresco.module.org_alfresco_module_rm.referredmetadata;
|
||||
|
||||
import static java.util.Collections.emptyMap;
|
||||
import static java.util.Arrays.asList;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.referredmetadata.ReferredMetadataException.ReferentNodeNotFound;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.referredmetadata.ReferredMetadataException.MetadataReferralNotFound;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.test.util.ExceptionUtils.expectedException;
|
||||
import static org.alfresco.module.org_alfresco_module_rm.test.util.FPUtils.asSet;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.mockito.Mockito.any;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.eq;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
import org.alfresco.service.cmr.dictionary.ClassDefinition;
|
||||
import org.alfresco.service.cmr.dictionary.DictionaryService;
|
||||
import org.alfresco.service.cmr.dictionary.PropertyDefinition;
|
||||
import org.alfresco.service.cmr.repository.AssociationRef;
|
||||
import org.alfresco.service.cmr.repository.NodeRef;
|
||||
import org.alfresco.service.cmr.repository.NodeService;
|
||||
import org.alfresco.service.cmr.repository.StoreRef;
|
||||
import org.alfresco.service.namespace.QName;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.MockitoAnnotations;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Unit tests for {@link ReferredMetadataServiceImpl}.
|
||||
*
|
||||
* @author Neil Mc Erlean
|
||||
* @since 3.0.a
|
||||
*/
|
||||
public class ReferredMetadataServiceImplUnitTest
|
||||
{
|
||||
@InjectMocks private final ReferredMetadataServiceImpl referredMetadataService = new ReferredMetadataServiceImpl();
|
||||
|
||||
@Mock DictionaryService mockDictionaryService;
|
||||
@Mock NodeService mockNodeService;
|
||||
@Mock ReferralAdminServiceImpl mockReferralAdminService;
|
||||
|
||||
/** This node has a referent node. */
|
||||
private final NodeRef referringNode = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, "referringNode");
|
||||
/** This is the referent for {@link #referringNode}. */
|
||||
private final NodeRef referentNode = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, "referentNode");
|
||||
/** This node has no referent node. */
|
||||
private final NodeRef nodeWithoutReferent = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, "nodeWithoutReferent");
|
||||
|
||||
/** The type of the peer association that links the referringNode to its source. */
|
||||
private final QName referralAssocType = QName.createQName("test", "referralAssocType");
|
||||
/** The instance of the association between {@link #referringNode} and {@link #referentNode}. */
|
||||
private final AssociationRef attachedReferralAssocRef = new AssociationRef(referringNode, referralAssocType, referentNode);
|
||||
|
||||
/** Name of an aspect that has been referred. */
|
||||
private final QName referredAspect1 = QName.createQName("test", "referredAspect1");
|
||||
/** Name of an aspect that has been referred. */
|
||||
private final QName referredAspect2 = QName.createQName("test", "referredAspect2");
|
||||
/** Name of a content class (a type in this case) that has not been referred.
|
||||
* N.B. Types can't be referred currently. */
|
||||
private final QName unreferredType = QName.createQName("test", "unreferredType");
|
||||
|
||||
private final QName referredProp = QName.createQName("test", "referredProp");
|
||||
private final Serializable referredPropValue = "hello";
|
||||
private final QName unreferredProp = QName.createQName("test", "unreferredProp");
|
||||
|
||||
private final MetadataReferral referral = new MetadataReferral()
|
||||
{{
|
||||
this.setAssocType(referralAssocType);
|
||||
this.setAspects(asSet(referredAspect1, referredAspect2));
|
||||
}};
|
||||
|
||||
@Before public void setUp()
|
||||
{
|
||||
MockitoAnnotations.initMocks(this);
|
||||
|
||||
final PropertyDefinition aspectProp = mock(PropertyDefinition.class);
|
||||
final ClassDefinition aspectDefn = mock(ClassDefinition.class);
|
||||
when(aspectDefn.getName()).thenReturn(referredAspect1);
|
||||
when(aspectProp.getContainerClass()).thenReturn(aspectDefn);
|
||||
when(aspectDefn.isAspect()).thenReturn(true);
|
||||
|
||||
final PropertyDefinition typeProp = mock(PropertyDefinition.class);
|
||||
final ClassDefinition typeDefn = mock(ClassDefinition.class);
|
||||
when(typeDefn.getName()).thenReturn(unreferredType);
|
||||
when(typeProp.getContainerClass()).thenReturn(typeDefn);
|
||||
when(typeDefn.isAspect()).thenReturn(false);
|
||||
|
||||
when(mockDictionaryService.getProperty(referredProp)).thenReturn(aspectProp);
|
||||
|
||||
when(mockReferralAdminService.getAttachedReferralsFrom(referringNode)).thenReturn(asSet(referral));
|
||||
for (QName referredAspect : asSet(referredAspect1, referredAspect2))
|
||||
{
|
||||
when(mockReferralAdminService.getReferralFor(referredAspect)).thenReturn(referral);
|
||||
when(mockNodeService.hasAspect(referentNode, referredAspect)).thenReturn(true);
|
||||
}
|
||||
when(mockNodeService.getSourceAssocs(referentNode, referralAssocType)).thenReturn(asList(attachedReferralAssocRef));
|
||||
when(mockNodeService.getTargetAssocs(referringNode, referralAssocType)).thenReturn(asList(attachedReferralAssocRef));
|
||||
when(mockNodeService.exists(any(NodeRef.class))).thenReturn(true);
|
||||
when(mockNodeService.getProperties(referentNode))
|
||||
.thenReturn(new HashMap<QName, Serializable>()
|
||||
{{
|
||||
this.put(referredProp, referredPropValue);
|
||||
}});
|
||||
}
|
||||
|
||||
@Test public void isReferringMetadata()
|
||||
{
|
||||
assertTrue(referredMetadataService.isReferringMetadata(referringNode, referredAspect1));
|
||||
expectedException(MetadataReferralNotFound.class,
|
||||
() -> referredMetadataService.isReferringMetadata(nodeWithoutReferent, unreferredType));
|
||||
assertFalse(referredMetadataService.isReferringMetadata(nodeWithoutReferent, referredAspect1));
|
||||
}
|
||||
|
||||
@Test public void getReferentNode()
|
||||
{
|
||||
assertEquals(referentNode, referredMetadataService.getReferentNode(referringNode, referredAspect1));
|
||||
expectedException(MetadataReferralNotFound.class,
|
||||
() -> {
|
||||
referredMetadataService.getReferentNode(referringNode, unreferredType);
|
||||
return null;
|
||||
});
|
||||
assertNull(referredMetadataService.getReferentNode(nodeWithoutReferent, referredAspect1));
|
||||
}
|
||||
|
||||
@Test public void getReferredProperties()
|
||||
{
|
||||
final Map<QName, Serializable> expectedProps = new HashMap<>();
|
||||
expectedProps.put(referredProp, referredPropValue);
|
||||
|
||||
assertEquals(expectedProps, referredMetadataService.getReferredProperties(referringNode, referredAspect1));
|
||||
|
||||
expectedException(MetadataReferralNotFound.class,
|
||||
() -> referredMetadataService.getReferredProperties(referringNode, unreferredType));
|
||||
|
||||
expectedException(ReferentNodeNotFound.class,
|
||||
() -> referredMetadataService.getReferredProperties(nodeWithoutReferent, referredAspect1));
|
||||
}
|
||||
|
||||
@Test public void getReferredProperty()
|
||||
{
|
||||
assertEquals(referredPropValue, referredMetadataService.getReferredProperty(referringNode, referredProp));
|
||||
|
||||
expectedException(IllegalArgumentException.class,
|
||||
() -> referredMetadataService.getReferredProperty(referringNode, unreferredProp));
|
||||
|
||||
expectedException(MetadataReferralNotFound.class,
|
||||
() -> referredMetadataService.getReferredProperties(nodeWithoutReferent, referredProp));
|
||||
}
|
||||
|
||||
@Test public void hasReferredAspect()
|
||||
{
|
||||
assertTrue(referredMetadataService.hasReferredAspect(referringNode, referredAspect1));
|
||||
|
||||
expectedException(MetadataReferralNotFound.class,
|
||||
() -> referredMetadataService.hasReferredAspect(referringNode, unreferredType));
|
||||
|
||||
expectedException(ReferentNodeNotFound.class,
|
||||
() -> referredMetadataService.hasReferredAspect(nodeWithoutReferent, referredAspect1));
|
||||
}
|
||||
|
||||
@Test public void getAttachedReferrals()
|
||||
{
|
||||
final Map<MetadataReferral, NodeRef> expectedReferrals = new HashMap<>();
|
||||
expectedReferrals.put(referral, referentNode);
|
||||
|
||||
assertEquals(expectedReferrals, referredMetadataService.getAttachedReferrals(referringNode));
|
||||
assertEquals(emptyMap(), referredMetadataService.getAttachedReferrals(nodeWithoutReferent));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user