Example 16 with TransferDefinition
use of org.alfresco.service.cmr.transfer.TransferDefinition in project alfresco-repository by Alfresco.
the class TransferServiceToBeRefactoredTest method testLocalAlienRestore.
/**
* Test restore of a local node.
* <pre>
* Tree of nodes
* A1 B1
* |
* B2
* |
* B3
* <pre>
* <ol>
* <li>Add B2. A1 is alien.</li>
* <li>Delete B2. A1 not alien</li>
* <li>Restore B2. A1 is alien</li>
* <li>Add B3. A1 is alien</li>
* <li>Delete B2. A1 not alien</li>
* <li>Restore to B1. B2 and B3 not alien.</li>
* </ol>
* @throws Exception
*/
@Test
public void testLocalAlienRestore() throws Exception {
final String CONTENT_TITLE = "ContentTitle";
/**
* Now go ahead and create our first transfer target
*/
final String targetName = "testRestoreOfAlienNodes";
class TestData {
@SuppressWarnings("unused")
TransferTarget transferMe;
NodeRef S0NodeRef;
NodeRef A0NodeRef;
NodeRef A1NodeRef;
NodeRef B1NodeRef;
NodeRef B2NodeRef;
NodeRef B3NodeRef;
NodeRef destNodeRef;
}
final TestData testData = new TestData();
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
NodeRef guestHome = repositoryHelper.getGuestHome();
/**
* Create a test nodes A1 through A8 that we will read and write
*/
{
// Node S0
String name = GUID.generate();
ChildAssociationRef child = nodeService.createNode(guestHome, ContentModel.ASSOC_CONTAINS, QName.createQName(name), ContentModel.TYPE_FOLDER);
testData.S0NodeRef = child.getChildRef();
nodeService.setProperty(testData.S0NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.S0NodeRef, ContentModel.PROP_NAME, name);
}
{
// Node A1
ChildAssociationRef child = nodeService.createNode(testData.S0NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A0"), ContentModel.TYPE_FOLDER);
testData.A0NodeRef = child.getChildRef();
nodeService.setProperty(testData.A0NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.A0NodeRef, ContentModel.PROP_NAME, "A0");
}
{
// Node A1
ChildAssociationRef child = nodeService.createNode(testData.A0NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A1"), ContentModel.TYPE_FOLDER);
testData.A1NodeRef = child.getChildRef();
nodeService.setProperty(testData.A1NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.A1NodeRef, ContentModel.PROP_NAME, "A1");
}
{
// Node B1
ChildAssociationRef child = nodeService.createNode(testData.S0NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("B1"), ContentModel.TYPE_FOLDER);
testData.B1NodeRef = child.getChildRef();
nodeService.setProperty(testData.B1NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.B1NodeRef, ContentModel.PROP_NAME, "B1");
}
// Create the transfer target if it does not already exist
if (!transferService.targetExists(targetName)) {
testData.transferMe = createTransferTarget(targetName);
} else {
testData.transferMe = transferService.getTransferTarget(targetName);
}
return null;
}
});
/**
* For unit test
* - replace the HTTP transport with the in-process transport
* - replace the node factory with one that will map node refs, paths etc.
*
* Mock the transfer service to be from Repo A
*/
TransferTransmitter transmitter = new UnitTestInProcessTransmitterImpl(receiver, contentService, transactionService);
transferServiceImpl.setTransmitter(transmitter);
final UnitTestTransferManifestNodeFactory testNodeFactory = new UnitTestTransferManifestNodeFactory(this.transferManifestNodeFactory);
transferServiceImpl.setTransferManifestNodeFactory(testNodeFactory);
final List<Pair<Path, Path>> pathMap = testNodeFactory.getPathMap();
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
pathMap.add(new Pair<Path, Path>(nodeService.getPath(testData.A0NodeRef), nodeService.getPath(testData.B1NodeRef)));
return null;
}
});
DescriptorService mockedDescriptorService = getMockDescriptorService(REPO_ID_A);
transferServiceImpl.setDescriptorService(mockedDescriptorService);
/**
* Step 1. add A1 transfer(sync)
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
/**
* Transfer Nodes A1
*/
{
TransferDefinition definition = new TransferDefinition();
Set<NodeRef> nodes = new HashSet<NodeRef>();
nodes.add(testData.A1NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
}
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
// Now validate that the target node exists and has similar properties to the source
NodeRef A1destNodeRef = testNodeFactory.getMappedNodeRef(testData.A1NodeRef);
assertTrue("dest node ref does not exist", nodeService.exists(A1destNodeRef));
assertFalse("A1 is alien", nodeService.hasAspect(A1destNodeRef, TransferModel.ASPECT_ALIEN));
// Check injected transferred aspect.
assertNotNull("transferredAspect", (String) nodeService.getProperty(A1destNodeRef, TransferModel.PROP_REPOSITORY_ID));
return null;
}
});
/**
* Step 2 add Alien node B1 child of A1(dest).
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
testData.destNodeRef = testNodeFactory.getMappedNodeRef(testData.A1NodeRef);
ChildAssociationRef child = nodeService.createNode(testData.destNodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("B2"), ContentModel.TYPE_FOLDER);
testData.B2NodeRef = child.getChildRef();
nodeService.setProperty(testData.B2NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.B2NodeRef, ContentModel.PROP_NAME, "B2");
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
// Now validate that the target node exists and has similar properties to the source
NodeRef A1destNodeRef = testNodeFactory.getMappedNodeRef(testData.A1NodeRef);
assertTrue("dest node ref does not exist", nodeService.exists(A1destNodeRef));
// Check injected transferred aspect.
assertTrue("node A1 is not alien aspect", (Boolean) nodeService.hasAspect(A1destNodeRef, TransferModel.ASPECT_ALIEN));
assertNotNull("repository id is null", (String) nodeService.getProperty(A1destNodeRef, TransferModel.PROP_REPOSITORY_ID));
assertNotNull("from repository id is null", (String) nodeService.getProperty(A1destNodeRef, TransferModel.PROP_FROM_REPOSITORY_ID));
assertTrue("node B2 is not alien", (Boolean) nodeService.hasAspect(testData.B2NodeRef, TransferModel.ASPECT_ALIEN));
return null;
}
});
/**
* Step 3 remove alien node B2. A1 becomes non Alien.
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
logger.debug("delete node B2");
nodeService.deleteNode(testData.B2NodeRef);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
NodeRef A1destNodeRef = testNodeFactory.getMappedNodeRef(testData.A1NodeRef);
@SuppressWarnings({ "unchecked", "unused" }) List<String> invaders = (List<String>) nodeService.getProperty(A1destNodeRef, TransferModel.PROP_INVADED_BY);
assertTrue("dest node ref does not exist", nodeService.exists(A1destNodeRef));
assertFalse("node A1 is still alien", (Boolean) nodeService.hasAspect(A1destNodeRef, TransferModel.ASPECT_ALIEN));
assertNotNull("repository id is null", (String) nodeService.getProperty(A1destNodeRef, TransferModel.PROP_REPOSITORY_ID));
assertNotNull("from repository id is null", (String) nodeService.getProperty(A1destNodeRef, TransferModel.PROP_FROM_REPOSITORY_ID));
return null;
}
});
/**
* Step 4 restore alien node B2. A1 becomes Alien again
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
logger.debug("restore node B2");
NodeRef B2ArchiveNodeRef = new NodeRef(StoreRef.STORE_REF_ARCHIVE_SPACESSTORE, testData.B2NodeRef.getId());
nodeService.restoreNode(B2ArchiveNodeRef, testNodeFactory.getMappedNodeRef(testData.A1NodeRef), ContentModel.ASSOC_CONTAINS, QName.createQName("B2"));
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
NodeRef A1destNodeRef = testNodeFactory.getMappedNodeRef(testData.A1NodeRef);
assertTrue("dest node ref does not exist", nodeService.exists(A1destNodeRef));
assertTrue("node A1 is not alien", (Boolean) nodeService.hasAspect(A1destNodeRef, TransferModel.ASPECT_ALIEN));
assertNotNull("repository id is null", (String) nodeService.getProperty(A1destNodeRef, TransferModel.PROP_REPOSITORY_ID));
assertNotNull("from repository id is null", (String) nodeService.getProperty(A1destNodeRef, TransferModel.PROP_FROM_REPOSITORY_ID));
return null;
}
});
/**
* Step 5 - add B3
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
ChildAssociationRef child = nodeService.createNode(testData.B2NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("B3"), ContentModel.TYPE_FOLDER);
testData.B3NodeRef = child.getChildRef();
nodeService.setProperty(testData.B3NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.B3NodeRef, ContentModel.PROP_NAME, "B3");
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
assertTrue("node B3 is not alien", (Boolean) nodeService.hasAspect(testData.B3NodeRef, TransferModel.ASPECT_ALIEN));
return null;
}
});
/**
* Step 5 remove alien node B2. A1 becomes non Alien (again).
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
logger.debug("delete node B2");
nodeService.deleteNode(testData.B2NodeRef);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
NodeRef A1destNodeRef = testNodeFactory.getMappedNodeRef(testData.A1NodeRef);
@SuppressWarnings({ "unused", "unchecked" }) List<String> invaders = (List<String>) nodeService.getProperty(A1destNodeRef, TransferModel.PROP_INVADED_BY);
assertTrue("dest node ref does not exist", nodeService.exists(A1destNodeRef));
assertFalse("node A1 is still alien", (Boolean) nodeService.hasAspect(A1destNodeRef, TransferModel.ASPECT_ALIEN));
assertNotNull("repository id is null", (String) nodeService.getProperty(A1destNodeRef, TransferModel.PROP_REPOSITORY_ID));
assertNotNull("from repository id is null", (String) nodeService.getProperty(A1destNodeRef, TransferModel.PROP_FROM_REPOSITORY_ID));
return null;
}
});
/**
* Step6 restore B2 and B3 to B1.
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
logger.debug("restore node B2");
NodeRef B2ArchiveNodeRef = new NodeRef(StoreRef.STORE_REF_ARCHIVE_SPACESSTORE, testData.B2NodeRef.getId());
nodeService.restoreNode(B2ArchiveNodeRef, testData.B1NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("B2"));
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
assertFalse("node A1 is still alien", (Boolean) nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.A1NodeRef), TransferModel.ASPECT_ALIEN));
assertFalse("node A2 is still alien", (Boolean) nodeService.hasAspect(testData.B2NodeRef, TransferModel.ASPECT_ALIEN));
assertFalse("node A3 is still alien", (Boolean) nodeService.hasAspect(testData.B3NodeRef, TransferModel.ASPECT_ALIEN));
return null;
}
});
}
Also used :
TransferTarget(org.alfresco.service.cmr.transfer.TransferTarget)
ChildAssociationRef(org.alfresco.service.cmr.repository.ChildAssociationRef)
TransferDefinition(org.alfresco.service.cmr.transfer.TransferDefinition)
NodeRef(org.alfresco.service.cmr.repository.NodeRef)
List(java.util.List)
ArrayList(java.util.ArrayList)
DescriptorService(org.alfresco.service.descriptor.DescriptorService)
Pair(org.alfresco.util.Pair)
HashSet(java.util.HashSet)
BaseAlfrescoSpringTest(org.alfresco.util.BaseAlfrescoSpringTest)
Test(org.junit.Test)
Example 17 with TransferDefinition
use of org.alfresco.service.cmr.transfer.TransferDefinition in project alfresco-repository by Alfresco.
the class TransferServiceToBeRefactoredTest method testTransferSyncNodes.
/**
* Test the transfer method behaviour with respect to sync folders - sending a complete set
* of nodes and implying delete from the absence of an association.
*
* This is a unit test so it does some shenanigans to send to the same instance of alfresco.
*
* Tree of nodes
*
* A1
* | |
* A2 A3 (Content Node)
* |
* A4 A5 (Content Node)
*
* Test steps -
* 1 add A1
* transfer(sync)
* 2 add A2, A3, A4, A5
* transfer(sync)
* 3 remove A2
* transfer(sync) A4 and A5 should cascade delete on source
* 4 remove A3
* transfer(sync)
* 5 add back A3 - new node ref
* transfer(sync)
* 6 add A2, A4, A5
* transfer(sync)
* 7 test delete and restore of a single node
* remove A3 .
* transfer
* restore node A3
* transfer
* 8 test delete and restore of a tree of nodes
* remove A2 (A4 and A5 should cascade delete on source as well)
* transfer
* restore node A2 (and A4 and A5 cascade restore)
* transfer
*/
@Test
public void testTransferSyncNodes() throws Exception {
final String CONTENT_TITLE = "ContentTitle";
final Locale CONTENT_LOCALE = Locale.GERMAN;
final String CONTENT_STRING = "Hello";
/**
* For unit test
* - replace the HTTP transport with the in-process transport
* - replace the node factory with one that will map node refs, paths etc.
*/
TransferTransmitter transmitter = new UnitTestInProcessTransmitterImpl(receiver, contentService, transactionService);
transferServiceImpl.setTransmitter(transmitter);
final UnitTestTransferManifestNodeFactory testNodeFactory = new UnitTestTransferManifestNodeFactory(this.transferManifestNodeFactory);
transferServiceImpl.setTransferManifestNodeFactory(testNodeFactory);
final List<Pair<Path, Path>> pathMap = testNodeFactory.getPathMap();
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
// Map company_home/guest_home to company_home so tranferred nodes and moved "up" one level.
pathMap.add(new Pair<Path, Path>(PathHelper.stringToPath(GUEST_HOME_XPATH_QUERY), PathHelper.stringToPath(COMPANY_HOME_XPATH_QUERY)));
return null;
}
});
DescriptorService mockedDescriptorService = getMockDescriptorService(REPO_ID_A);
transferServiceImpl.setDescriptorService(mockedDescriptorService);
/**
* Now go ahead and create our first transfer target
*/
final String targetName = "testTransferSyncNodes";
class TestData {
TransferTarget transferMe;
NodeRef A1NodeRef;
NodeRef A2NodeRef;
NodeRef A3NodeRef;
NodeRef A4NodeRef;
NodeRef A5NodeRef;
NodeRef destNodeRef;
}
final TestData testData = new TestData();
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
NodeRef guestHome = repositoryHelper.getGuestHome();
/**
* Create a test nodes A1 through A5 that we will read and write
*/
{
// Node A1
String name = GUID.generate();
ChildAssociationRef child = nodeService.createNode(guestHome, ContentModel.ASSOC_CONTAINS, QName.createQName(name), ContentModel.TYPE_FOLDER);
testData.A1NodeRef = child.getChildRef();
nodeService.setProperty(testData.A1NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.A1NodeRef, ContentModel.PROP_NAME, name);
}
{
// Node A2
ChildAssociationRef child = nodeService.createNode(testData.A1NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A2"), ContentModel.TYPE_FOLDER);
testData.A2NodeRef = child.getChildRef();
nodeService.setProperty(testData.A2NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.A2NodeRef, ContentModel.PROP_NAME, "A2");
}
{
// Node A3
ChildAssociationRef child = nodeService.createNode(testData.A1NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A3"), ContentModel.TYPE_CONTENT);
testData.A3NodeRef = child.getChildRef();
nodeService.setProperty(testData.A3NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.A3NodeRef, ContentModel.PROP_NAME, "A3");
ContentWriter writer = contentService.getWriter(testData.A3NodeRef, ContentModel.PROP_CONTENT, true);
writer.setLocale(CONTENT_LOCALE);
writer.putContent(CONTENT_STRING);
}
{
// Node A4
ChildAssociationRef child = nodeService.createNode(testData.A2NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A4"), ContentModel.TYPE_CONTENT);
testData.A4NodeRef = child.getChildRef();
nodeService.setProperty(testData.A4NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.A4NodeRef, ContentModel.PROP_NAME, "A4");
ContentWriter writer = contentService.getWriter(testData.A4NodeRef, ContentModel.PROP_CONTENT, true);
writer.setLocale(CONTENT_LOCALE);
writer.putContent(CONTENT_STRING);
}
{
// Node A5
ChildAssociationRef child = nodeService.createNode(testData.A2NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A5"), ContentModel.TYPE_CONTENT);
testData.A5NodeRef = child.getChildRef();
nodeService.setProperty(testData.A5NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.A5NodeRef, ContentModel.PROP_NAME, "A5");
ContentWriter writer = contentService.getWriter(testData.A5NodeRef, ContentModel.PROP_CONTENT, true);
writer.setLocale(CONTENT_LOCALE);
writer.putContent(CONTENT_STRING);
}
// Create the transfer target if it does not already exist
if (!transferService.targetExists(targetName)) {
testData.transferMe = createTransferTarget(targetName);
} else {
testData.transferMe = transferService.getTransferTarget(targetName);
}
return null;
}
});
/**
* Step 1. Add Node A1.
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
/**
* Transfer Node A with no children
*/
{
TransferDefinition definition = new TransferDefinition();
Set<NodeRef> nodes = new HashSet<NodeRef>();
nodes.add(testData.A1NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
}
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
// Now validate that the target node exists and has similar properties to the source
testData.destNodeRef = testNodeFactory.getMappedNodeRef(testData.A1NodeRef);
assertFalse("unit test stuffed up - comparing with self", testData.destNodeRef.equals(testData.transferMe.getNodeRef()));
assertTrue("dest node ref does not exist", nodeService.exists(testData.destNodeRef));
assertEquals("title is wrong", (String) nodeService.getProperty(testData.destNodeRef, ContentModel.PROP_TITLE), CONTENT_TITLE);
assertEquals("type is wrong", nodeService.getType(testData.A1NodeRef), nodeService.getType(testData.destNodeRef));
// Check injected transferred aspect.
assertNotNull("transferredAspect", (String) nodeService.getProperty(testData.destNodeRef, TransferModel.PROP_REPOSITORY_ID));
return null;
}
});
/**
* Step 2. Add Node A2, A3, A4, A5.
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
/**
* Transfer Node A 1-5
*/
{
TransferDefinition definition = new TransferDefinition();
Set<NodeRef> nodes = new HashSet<NodeRef>();
nodes.add(testData.A1NodeRef);
nodes.add(testData.A2NodeRef);
nodes.add(testData.A3NodeRef);
nodes.add(testData.A4NodeRef);
nodes.add(testData.A5NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
}
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
// Now validate that the target node exists and has similar properties to the source
testData.destNodeRef = testNodeFactory.getMappedNodeRef(testData.A1NodeRef);
assertFalse("unit test stuffed up - comparing with self", testData.destNodeRef.equals(testData.transferMe.getNodeRef()));
assertTrue("dest node ref A1 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A1NodeRef)));
assertTrue("dest node ref A2 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A2NodeRef)));
assertTrue("dest node ref A3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A3NodeRef)));
assertTrue("dest node ref A4 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A4NodeRef)));
assertTrue("dest node ref A5 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A5NodeRef)));
// Check injected transferred aspect.
assertNotNull("transferredAspect", (String) nodeService.getProperty(testData.destNodeRef, TransferModel.PROP_REPOSITORY_ID));
return null;
}
});
/**
* Step 3 - remove folder node A2
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
nodeService.deleteNode(testData.A2NodeRef);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
/**
* Transfer Node A 1-5
*/
{
TransferDefinition definition = new TransferDefinition();
Set<NodeRef> nodes = new HashSet<NodeRef>();
nodes.add(testData.A1NodeRef);
// nodes.add(A2NodeRef);
nodes.add(testData.A3NodeRef);
// nodes.add(A4NodeRef);
// nodes.add(A5NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
}
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
// Now validate that the target node exists and has similar properties to the source
testData.destNodeRef = testNodeFactory.getMappedNodeRef(testData.A1NodeRef);
assertFalse("unit test stuffed up - comparing with self", testData.destNodeRef.equals(testData.transferMe.getNodeRef()));
assertTrue("dest node ref A1 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A1NodeRef)));
assertFalse("dest node ref A2 has not been deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A2NodeRef)));
assertTrue("dest node ref A3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A3NodeRef)));
assertFalse("dest node ref A4 has not been deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A4NodeRef)));
assertFalse("dest node ref A5 has not been deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A5NodeRef)));
// Check injected transferred aspect.
assertNotNull("transferredAspect", (String) nodeService.getProperty(testData.destNodeRef, TransferModel.PROP_REPOSITORY_ID));
return null;
}
});
/**
* Step 4 - remove content node A3
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
nodeService.deleteNode(testData.A3NodeRef);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
/**
* Transfer Node A 1-5
*/
{
TransferDefinition definition = new TransferDefinition();
Set<NodeRef> nodes = new HashSet<NodeRef>();
nodes.add(testData.A1NodeRef);
// nodes.add(A2NodeRef);
// nodes.add(A3NodeRef);
// nodes.add(A4NodeRef);
// nodes.add(A5NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
}
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
// Now validate that the target node exists and has similar properties to the source
testData.destNodeRef = testNodeFactory.getMappedNodeRef(testData.A1NodeRef);
assertFalse("unit test stuffed up - comparing with self", testData.destNodeRef.equals(testData.transferMe.getNodeRef()));
assertTrue("dest node ref A1 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A1NodeRef)));
assertFalse("dest node ref A2 has not been deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A2NodeRef)));
assertFalse("dest node ref A3 has not been deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A3NodeRef)));
assertFalse("dest node ref A4 has not been deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A4NodeRef)));
assertFalse("dest node ref A5 has not been deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A5NodeRef)));
// Check injected transferred aspect.
assertNotNull("transferredAspect", (String) nodeService.getProperty(testData.destNodeRef, TransferModel.PROP_REPOSITORY_ID));
return null;
}
});
/**
* Step 5. Add back A3.
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
ChildAssociationRef child = nodeService.createNode(testData.A1NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A3"), ContentModel.TYPE_CONTENT);
testData.A3NodeRef = child.getChildRef();
nodeService.setProperty(testData.A3NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.A3NodeRef, ContentModel.PROP_NAME, "A3");
ContentWriter writer = contentService.getWriter(testData.A3NodeRef, ContentModel.PROP_CONTENT, true);
writer.setLocale(CONTENT_LOCALE);
writer.putContent(CONTENT_STRING);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
/**
* Transfer Node A 1-5
*/
{
TransferDefinition definition = new TransferDefinition();
Set<NodeRef> nodes = new HashSet<NodeRef>();
nodes.add(testData.A1NodeRef);
// nodes.add(A2NodeRef);
nodes.add(testData.A3NodeRef);
// nodes.add(A4NodeRef);
// nodes.add(A5NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
}
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
// Now validate that the target node exists and has similar properties to the source
testData.destNodeRef = testNodeFactory.getMappedNodeRef(testData.A1NodeRef);
assertFalse("unit test stuffed up - comparing with self", testData.destNodeRef.equals(testData.transferMe.getNodeRef()));
assertTrue("dest node ref A1 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A1NodeRef)));
assertFalse("dest node ref A2 has not been deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A2NodeRef)));
assertTrue("dest node A3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A3NodeRef)));
assertFalse("dest node ref A4 has not been deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A4NodeRef)));
assertFalse("dest node ref A5 has not been deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A5NodeRef)));
// Check injected transferred aspect.
assertNotNull("transferredAspect", (String) nodeService.getProperty(testData.destNodeRef, TransferModel.PROP_REPOSITORY_ID));
return null;
}
});
/**
* Step 6. add A2, A4, A5
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
{
// Node A2
ChildAssociationRef child = nodeService.createNode(testData.A1NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A2"), ContentModel.TYPE_FOLDER);
testData.A2NodeRef = child.getChildRef();
nodeService.setProperty(testData.A2NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.A2NodeRef, ContentModel.PROP_NAME, "A2");
}
{
// Node A4
ChildAssociationRef child = nodeService.createNode(testData.A2NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A4"), ContentModel.TYPE_CONTENT);
testData.A4NodeRef = child.getChildRef();
nodeService.setProperty(testData.A4NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.A4NodeRef, ContentModel.PROP_NAME, "A4");
ContentWriter writer = contentService.getWriter(testData.A4NodeRef, ContentModel.PROP_CONTENT, true);
writer.setLocale(CONTENT_LOCALE);
writer.putContent(CONTENT_STRING);
}
{
// Node A5
ChildAssociationRef child = nodeService.createNode(testData.A2NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A5"), ContentModel.TYPE_CONTENT);
testData.A5NodeRef = child.getChildRef();
nodeService.setProperty(testData.A5NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.A5NodeRef, ContentModel.PROP_NAME, "A5");
ContentWriter writer = contentService.getWriter(testData.A5NodeRef, ContentModel.PROP_CONTENT, true);
writer.setLocale(CONTENT_LOCALE);
writer.putContent(CONTENT_STRING);
}
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
/**
* Transfer Node A 1-5
*/
{
TransferDefinition definition = new TransferDefinition();
Set<NodeRef> nodes = new HashSet<NodeRef>();
nodes.add(testData.A1NodeRef);
nodes.add(testData.A2NodeRef);
nodes.add(testData.A3NodeRef);
nodes.add(testData.A4NodeRef);
nodes.add(testData.A5NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
}
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
// Now validate that the target node exists and has similar properties to the source
testData.destNodeRef = testNodeFactory.getMappedNodeRef(testData.A1NodeRef);
assertFalse("unit test stuffed up - comparing with self", testData.destNodeRef.equals(testData.transferMe.getNodeRef()));
assertTrue("dest node A1 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A1NodeRef)));
assertTrue("dest node A2 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A2NodeRef)));
assertTrue("dest node A3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A3NodeRef)));
assertTrue("dest node A4 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A4NodeRef)));
assertTrue("dest node A5 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A5NodeRef)));
// Check injected transferred aspect.
assertNotNull("transferredAspect", (String) nodeService.getProperty(testData.destNodeRef, TransferModel.PROP_REPOSITORY_ID));
return null;
}
});
/**
* Step 7 - test delete and restore of a single node
* remove A3 .
* transfer
* restore node A3
* transfer
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
logger.debug("Step 7 - delete node A3");
nodeService.deleteNode(testData.A3NodeRef);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
/**
* Transfer Node A 1-5
*/
{
TransferDefinition definition = new TransferDefinition();
Set<NodeRef> nodes = new HashSet<NodeRef>();
nodes.add(testData.A1NodeRef);
nodes.add(testData.A2NodeRef);
// nodes.add(testData.A3NodeRef); A3 has gone.
nodes.add(testData.A4NodeRef);
nodes.add(testData.A5NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
}
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
assertTrue("dest node ref A1 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A1NodeRef)));
assertTrue("dest node ref A2 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A2NodeRef)));
assertFalse("dest node ref A3 has not been deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A3NodeRef)));
assertTrue("dest node ref A4 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A4NodeRef)));
assertTrue("dest node ref A5 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A5NodeRef)));
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
NodeRef archivedNode = new NodeRef(StoreRef.STORE_REF_ARCHIVE_SPACESSTORE, testData.A3NodeRef.getId());
NodeRef newNodeRef = nodeService.restoreNode(archivedNode, testData.A1NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A3"));
assertEquals("restored node ref is different", newNodeRef, testData.A3NodeRef);
logger.debug("Step 7 - restore node A3");
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
/**
* Transfer Node A 1-5. (So we are seeing what happens to node 3 on the target
*/
{
TransferDefinition definition = new TransferDefinition();
Set<NodeRef> nodes = new HashSet<NodeRef>();
nodes.add(testData.A1NodeRef);
nodes.add(testData.A2NodeRef);
nodes.add(testData.A3NodeRef);
nodes.add(testData.A4NodeRef);
nodes.add(testData.A5NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
}
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
// Now validate that the target node exists and has similar properties to the source
assertFalse("unit test stuffed up - comparing with self", testData.destNodeRef.equals(testData.transferMe.getNodeRef()));
assertTrue("dest node ref A1 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A1NodeRef)));
assertTrue("dest node ref A2 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A2NodeRef)));
assertTrue("dest node ref A3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A3NodeRef)));
assertTrue("dest node ref A4 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A4NodeRef)));
assertTrue("dest node ref A5 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A5NodeRef)));
return null;
}
});
/**
* Step 8 - test delete and restore of a tree
* remove A2 (A4, A5) should cascade delete.
* transfer
* restore node A2
* transfer
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
nodeService.deleteNode(testData.A2NodeRef);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
/**
* Transfer Node A 1-5
*/
{
TransferDefinition definition = new TransferDefinition();
Set<NodeRef> nodes = new HashSet<NodeRef>();
nodes.add(testData.A1NodeRef);
// nodes.add(testData.A2NodeRef);
nodes.add(testData.A3NodeRef);
// nodes.add(testData.A4NodeRef);
// nodes.add(testData.A5NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
}
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
// Now validate that the target node exists and has similar properties to the source
testData.destNodeRef = testNodeFactory.getMappedNodeRef(testData.A1NodeRef);
assertFalse("unit test stuffed up - comparing with self", testData.destNodeRef.equals(testData.transferMe.getNodeRef()));
assertTrue("dest node ref A1 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A1NodeRef)));
assertFalse("dest node ref A2 has not been deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A2NodeRef)));
assertTrue("dest node ref A3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A3NodeRef)));
assertFalse("dest node ref A4 has not been deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A4NodeRef)));
assertFalse("dest node ref A5 has not been deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A5NodeRef)));
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
NodeRef archivedNode = new NodeRef(StoreRef.STORE_REF_ARCHIVE_SPACESSTORE, testData.A2NodeRef.getId());
nodeService.restoreNode(archivedNode, testData.A1NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A2"));
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
/**
* Transfer Node A 1-5. (So we are seeing what happens to node 2, 4, 5 on the target
*/
{
TransferDefinition definition = new TransferDefinition();
Set<NodeRef> nodes = new HashSet<NodeRef>();
nodes.add(testData.A1NodeRef);
nodes.add(testData.A2NodeRef);
nodes.add(testData.A3NodeRef);
nodes.add(testData.A4NodeRef);
nodes.add(testData.A5NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
}
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
// Now validate that the target node exists and has similar properties to the source
testData.destNodeRef = testNodeFactory.getMappedNodeRef(testData.A1NodeRef);
assertFalse("unit test stuffed up - comparing with self", testData.destNodeRef.equals(testData.transferMe.getNodeRef()));
assertTrue("dest node ref A1 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A1NodeRef)));
assertTrue("dest node ref A2 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A2NodeRef)));
assertTrue("dest node ref A3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A3NodeRef)));
assertTrue("dest node ref A4 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A4NodeRef)));
assertTrue("dest node ref A5 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A5NodeRef)));
return null;
}
});
}
Also used :
Locale(java.util.Locale)
TransferTarget(org.alfresco.service.cmr.transfer.TransferTarget)
ChildAssociationRef(org.alfresco.service.cmr.repository.ChildAssociationRef)
TransferDefinition(org.alfresco.service.cmr.transfer.TransferDefinition)
NodeRef(org.alfresco.service.cmr.repository.NodeRef)
ContentWriter(org.alfresco.service.cmr.repository.ContentWriter)
DescriptorService(org.alfresco.service.descriptor.DescriptorService)
Pair(org.alfresco.util.Pair)
HashSet(java.util.HashSet)
BaseAlfrescoSpringTest(org.alfresco.util.BaseAlfrescoSpringTest)
Test(org.junit.Test)
Example 18 with TransferDefinition
use of org.alfresco.service.cmr.transfer.TransferDefinition in project alfresco-repository by Alfresco.
the class TransferServiceToBeRefactoredTest method testMultiRepoTransferMove.
/**
* Test the transfer method behaviour with respect to move and alien nodes.
*
* So we have Repository A transferring content and Repository B is the local repo that we
* move alien nodes in and out.
*
* Tree
* <pre>
* B1
* | | |
* C2(p1) C3(p2) A4
* |
* A5
* |
* B6
* </pre>
*
* Step 1: Tansfer in C's nodes to Repo B
*
* Step 2. Transfer in A's nodes to Repo B
*
* Setup tree above. Validat that A2 is child of C2 dest.
* A4 is a child of B1
*
* Step 3. Move A5 from C2 to C3 via transfer.
* C2Dest should stop being invaded by A5, C3Dest should be invaded by A5.
*
* Step 4. Invade A5 by B6. Move from C3 to C2 via transfer.
* C2Dest should be invaded by A and B.
* C3Dest should not be invaded.
*
* Step 5. Move A5 to A4.
* A4 should be invaded by B due to B6 but not by A.
* C2Dest should not be invaded.
*/
@Test
public void testMultiRepoTransferMove() throws Exception {
final String localRepositoryId = descriptorService.getCurrentRepositoryDescriptor().getId();
final String CONTENT_TITLE = "ContentTitle";
final String targetName = "testMultiRepoTransferMove";
class TestData {
@SuppressWarnings("unused")
TransferTarget transferMe;
NodeRef S0NodeRef;
NodeRef A1NodeRef;
NodeRef B1NodeRef;
NodeRef C1NodeRef;
NodeRef C2NodeRef;
NodeRef C3NodeRef;
NodeRef A4NodeRef;
NodeRef A5NodeRef;
NodeRef B6NodeRef;
NodeRef C2DummyNodeRef;
NodeRef C3DummyNodeRef;
}
final TestData testData = new TestData();
final QName C2Path = QName.createQName("p2");
final QName C3Path = QName.createQName("p3");
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
NodeRef guestHome = repositoryHelper.getGuestHome();
{
/**
* Node Source - located under guest home
*/
String name = GUID.generate();
ChildAssociationRef child = nodeService.createNode(guestHome, ContentModel.ASSOC_CONTAINS, QName.createQName(name), ContentModel.TYPE_FOLDER);
testData.S0NodeRef = child.getChildRef();
nodeService.setProperty(testData.S0NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.S0NodeRef, ContentModel.PROP_NAME, name);
}
{
// Node A1
ChildAssociationRef child = nodeService.createNode(testData.S0NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A1"), ContentModel.TYPE_FOLDER);
testData.A1NodeRef = child.getChildRef();
nodeService.setProperty(testData.A1NodeRef, ContentModel.PROP_TITLE, "A1");
nodeService.setProperty(testData.A1NodeRef, ContentModel.PROP_NAME, "A1");
}
{
// Node B1
ChildAssociationRef child = nodeService.createNode(testData.S0NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("B1"), ContentModel.TYPE_FOLDER);
testData.B1NodeRef = child.getChildRef();
nodeService.setProperty(testData.B1NodeRef, ContentModel.PROP_TITLE, "B1");
nodeService.setProperty(testData.B1NodeRef, ContentModel.PROP_NAME, "B1");
}
{
// Node C1
ChildAssociationRef child = nodeService.createNode(testData.S0NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("C1"), ContentModel.TYPE_FOLDER);
testData.C1NodeRef = child.getChildRef();
nodeService.setProperty(testData.C1NodeRef, ContentModel.PROP_TITLE, "C1");
nodeService.setProperty(testData.C1NodeRef, ContentModel.PROP_NAME, "C1");
}
{
// Node C2
ChildAssociationRef child = nodeService.createNode(testData.C1NodeRef, ContentModel.ASSOC_CONTAINS, C2Path, ContentModel.TYPE_FOLDER);
testData.C2NodeRef = child.getChildRef();
nodeService.setProperty(testData.C2NodeRef, ContentModel.PROP_TITLE, "C2");
nodeService.setProperty(testData.C2NodeRef, ContentModel.PROP_NAME, "C2");
}
{
// Node C3
ChildAssociationRef child = nodeService.createNode(testData.C1NodeRef, ContentModel.ASSOC_CONTAINS, C3Path, ContentModel.TYPE_FOLDER);
testData.C3NodeRef = child.getChildRef();
nodeService.setProperty(testData.C3NodeRef, ContentModel.PROP_TITLE, "C3");
nodeService.setProperty(testData.C3NodeRef, ContentModel.PROP_NAME, "C3");
}
{
// Node C2 (Dummy)
ChildAssociationRef child = nodeService.createNode(testData.A1NodeRef, ContentModel.ASSOC_CONTAINS, C2Path, ContentModel.TYPE_FOLDER);
testData.C2DummyNodeRef = child.getChildRef();
nodeService.setProperty(testData.C2DummyNodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.C2DummyNodeRef, ContentModel.PROP_NAME, "C2 Dummy");
}
{
// Node C3 (Dummy)
ChildAssociationRef child = nodeService.createNode(testData.A1NodeRef, ContentModel.ASSOC_CONTAINS, C3Path, ContentModel.TYPE_FOLDER);
testData.C3DummyNodeRef = child.getChildRef();
nodeService.setProperty(testData.C3DummyNodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.C3DummyNodeRef, ContentModel.PROP_NAME, "C3 Dummy");
}
{
// Node A4
ChildAssociationRef child = nodeService.createNode(testData.A1NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("C4"), ContentModel.TYPE_FOLDER);
testData.A4NodeRef = child.getChildRef();
nodeService.setProperty(testData.A4NodeRef, ContentModel.PROP_TITLE, "A4");
nodeService.setProperty(testData.A4NodeRef, ContentModel.PROP_NAME, "A4");
}
{
// Node A5
ChildAssociationRef child = nodeService.createNode(testData.C2DummyNodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A5"), ContentModel.TYPE_FOLDER);
testData.A5NodeRef = child.getChildRef();
nodeService.setProperty(testData.A5NodeRef, ContentModel.PROP_TITLE, "A5");
nodeService.setProperty(testData.A5NodeRef, ContentModel.PROP_NAME, "A5");
}
// Create the transfer target if it does not already exist
if (!transferService.targetExists(targetName)) {
testData.transferMe = createTransferTarget(targetName);
} else {
testData.transferMe = transferService.getTransferTarget(targetName);
}
return null;
}
});
/**
* For unit test
* - replace the HTTP transport with the in-process transport
* - Map path from A1 to B1 (So transfer will transfer by path)
* - Map path from C1 to B1
*/
TransferTransmitter transmitter = new UnitTestInProcessTransmitterImpl(receiver, contentService, transactionService);
transferServiceImpl.setTransmitter(transmitter);
final UnitTestTransferManifestNodeFactory testNodeFactory = new UnitTestTransferManifestNodeFactory(this.transferManifestNodeFactory);
transferServiceImpl.setTransferManifestNodeFactory(testNodeFactory);
final List<Pair<Path, Path>> pathMap = testNodeFactory.getPathMap();
// Map Project A to Project B
// Map Project C to Project B
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
pathMap.add(new Pair<Path, Path>(nodeService.getPath(testData.A1NodeRef), nodeService.getPath(testData.B1NodeRef)));
pathMap.add(new Pair<Path, Path>(nodeService.getPath(testData.C1NodeRef), nodeService.getPath(testData.B1NodeRef)));
return null;
}
}, true);
DescriptorService mockedDescriptorService = getMockDescriptorService(REPO_ID_C);
transferServiceImpl.setDescriptorService(mockedDescriptorService);
/**
* Step 1
* Now transfer in C's nodes to Repo B
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
TransferDefinition definition = new TransferDefinition();
Collection<NodeRef> nodes = new ArrayList<NodeRef>();
nodes.add(testData.C1NodeRef);
nodes.add(testData.C2NodeRef);
nodes.add(testData.C3NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
assertTrue("dest node C2 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C2NodeRef)));
assertTrue("dest node C3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C3NodeRef)));
// Check that C3 dest is a child of B1
ChildAssociationRef C3Ref = nodeService.getPrimaryParent(testNodeFactory.getMappedNodeRef(testData.C3NodeRef));
assertEquals("A3 dest is connected to the wrong node", C3Ref.getParentRef(), testData.B1NodeRef);
ChildAssociationRef C2Ref = nodeService.getPrimaryParent(testNodeFactory.getMappedNodeRef(testData.C2NodeRef));
assertEquals("A2 dest is connected to the wrong node", C2Ref.getParentRef(), testData.B1NodeRef);
return null;
}
});
mockedDescriptorService = getMockDescriptorService(REPO_ID_A);
transferServiceImpl.setDescriptorService(mockedDescriptorService);
/**
* Step 2
* Now transfer in A's nodes
* C2 (Dest) gets invaded by A4
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
TransferDefinition definition = new TransferDefinition();
Collection<NodeRef> nodes = new ArrayList<NodeRef>();
nodes.add(testData.A4NodeRef);
nodes.add(testData.A5NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
assertTrue("dest node A5 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A5NodeRef)));
assertTrue("dest node C3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C3NodeRef)));
assertTrue("dest node C2 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C2NodeRef)));
ChildAssociationRef A5Ref = nodeService.getPrimaryParent(testNodeFactory.getMappedNodeRef(testData.A5NodeRef));
assertEquals("A5 dest is connected to the wrong node", A5Ref.getParentRef(), testNodeFactory.getMappedNodeRef(testData.C2NodeRef));
assertTrue("C2 dest is not invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.C2NodeRef), TransferModel.ASPECT_ALIEN));
assertFalse("C3 dest is not invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.C3NodeRef), TransferModel.ASPECT_ALIEN));
ChildAssociationRef A4Ref = nodeService.getPrimaryParent(testNodeFactory.getMappedNodeRef(testData.A4NodeRef));
assertEquals("A4 dest is connected to the wrong node", A4Ref.getParentRef(), testData.B1NodeRef);
return null;
}
});
/**
* Step 3
* Now move A5
* C3 (Dest) gets invaded by A5
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
nodeService.moveNode(testData.A5NodeRef, testData.C3DummyNodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("C4"));
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
TransferDefinition definition = new TransferDefinition();
Collection<NodeRef> nodes = new ArrayList<NodeRef>();
nodes.add(testData.A5NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
assertTrue("dest node A5 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A5NodeRef)));
assertTrue("dest node C3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C3NodeRef)));
assertTrue("dest node C2 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C2NodeRef)));
// Check that A4 dest is a child of C3Dest which is a child of B1
ChildAssociationRef A5Ref = nodeService.getPrimaryParent(testNodeFactory.getMappedNodeRef(testData.A5NodeRef));
assertEquals("A5 dest is connected to the wrong node", A5Ref.getParentRef(), testNodeFactory.getMappedNodeRef(testData.C3NodeRef));
assertTrue("A5 dest is not invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.A5NodeRef), TransferModel.ASPECT_ALIEN));
assertTrue("C3 dest is not invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.C3NodeRef), TransferModel.ASPECT_ALIEN));
assertFalse("C2 dest is still invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.C2NodeRef), TransferModel.ASPECT_ALIEN));
return null;
}
});
/**
* Step 4 - multi invasion move via transfer service.
* Invade A5 by B6.
* Transfer from C3 back to C2.
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
nodeService.moveNode(testData.A5NodeRef, testData.C2DummyNodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("B6"));
// Node B6
ChildAssociationRef child = nodeService.createNode(testNodeFactory.getMappedNodeRef(testData.A5NodeRef), ContentModel.ASSOC_CONTAINS, QName.createQName("B6"), ContentModel.TYPE_FOLDER);
testData.B6NodeRef = child.getChildRef();
nodeService.setProperty(testData.B6NodeRef, ContentModel.PROP_TITLE, "B6");
nodeService.setProperty(testData.B6NodeRef, ContentModel.PROP_NAME, "B6");
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
TransferDefinition definition = new TransferDefinition();
Collection<NodeRef> nodes = new ArrayList<NodeRef>();
nodes.add(testData.A5NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
assertTrue("dest node A5 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A5NodeRef)));
assertTrue("dest node C3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C3NodeRef)));
assertTrue("dest node C2 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C2NodeRef)));
// Check that A4 dest is a child of C2Dest which is a child of B1
ChildAssociationRef A5Ref = nodeService.getPrimaryParent(testNodeFactory.getMappedNodeRef(testData.A5NodeRef));
ChildAssociationRef B6Ref = nodeService.getPrimaryParent(testData.B6NodeRef);
assertEquals("A5 dest is connected to the wrong node", A5Ref.getParentRef(), testNodeFactory.getMappedNodeRef(testData.C2NodeRef));
assertEquals("B6 connected to the wrong node", B6Ref.getParentRef(), testNodeFactory.getMappedNodeRef(testData.A5NodeRef));
assertTrue("A5 dest is not invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.A5NodeRef), TransferModel.ASPECT_ALIEN));
assertTrue("C2 dest is not invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.C2NodeRef), TransferModel.ASPECT_ALIEN));
assertFalse("C3 dest is still invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.C3NodeRef), TransferModel.ASPECT_ALIEN));
@SuppressWarnings("unchecked") List<String> invaders = (List<String>) nodeService.getProperty(testNodeFactory.getMappedNodeRef(testData.C2NodeRef), TransferModel.PROP_INVADED_BY);
assertTrue("invaders is too small", invaders.size() > 1);
assertTrue("invaders does not contain REPO A", invaders.contains(REPO_ID_A));
assertTrue("invaders does not contain REPO B", invaders.contains(localRepositoryId));
return null;
}
});
/**
* Step 5 Move
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
nodeService.moveNode(testData.A5NodeRef, testData.A4NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A5"));
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
TransferDefinition definition = new TransferDefinition();
Collection<NodeRef> nodes = new ArrayList<NodeRef>();
nodes.add(testData.A5NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
assertTrue("dest node A5 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A5NodeRef)));
assertTrue("dest node C3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C3NodeRef)));
assertTrue("dest node C2 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C2NodeRef)));
// Check that A5dest is a child of A4Dest which is a child of B1
ChildAssociationRef A5Ref = nodeService.getPrimaryParent(testNodeFactory.getMappedNodeRef(testData.A5NodeRef));
assertEquals("A5 dest is connected to the wrong node", A5Ref.getParentRef(), testNodeFactory.getMappedNodeRef(testData.A4NodeRef));
assertTrue("A4 dest is not invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.A4NodeRef), TransferModel.ASPECT_ALIEN));
assertTrue("A5 dest is not invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.A5NodeRef), TransferModel.ASPECT_ALIEN));
assertTrue("B6 dest is not invaded", nodeService.hasAspect(testData.B6NodeRef, TransferModel.ASPECT_ALIEN));
assertFalse("C2 dest is still invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.C2NodeRef), TransferModel.ASPECT_ALIEN));
assertFalse("C3 dest is still invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.C3NodeRef), TransferModel.ASPECT_ALIEN));
@SuppressWarnings("unchecked") List<String> invaders = (List<String>) nodeService.getProperty(testNodeFactory.getMappedNodeRef(testData.A4NodeRef), TransferModel.PROP_INVADED_BY);
assertTrue("invaders is too big", invaders.size() < 2);
assertFalse("invaders contains REPO A", invaders.contains(REPO_ID_A));
assertTrue("invaders does not contains REPO B", invaders.contains(REPO_ID_B));
return null;
}
});
}
Also used :
QName(org.alfresco.service.namespace.QName)
TransferTarget(org.alfresco.service.cmr.transfer.TransferTarget)
ChildAssociationRef(org.alfresco.service.cmr.repository.ChildAssociationRef)
TransferDefinition(org.alfresco.service.cmr.transfer.TransferDefinition)
NodeRef(org.alfresco.service.cmr.repository.NodeRef)
Collection(java.util.Collection)
List(java.util.List)
ArrayList(java.util.ArrayList)
DescriptorService(org.alfresco.service.descriptor.DescriptorService)
Pair(org.alfresco.util.Pair)
BaseAlfrescoSpringTest(org.alfresco.util.BaseAlfrescoSpringTest)
Test(org.junit.Test)
Example 19 with TransferDefinition
use of org.alfresco.service.cmr.transfer.TransferDefinition in project alfresco-repository by Alfresco.
the class TransferServiceToBeRefactoredTest method testCopyAlien.
/**
* Test the behaviour with respect to copy of alien nodes.
*
* So we have Repository A transferring content and Repository B is the local repo that we
* copy alien nodes in and out. Copied nodes are not "transferred" so they change
* from being "from repository A" to "from the local repository".
*
* Tree
* <pre>
* B1
* | | |
* C2(p1) C3(p2) A4
* |
* A5
* |
* B6
* </pre>
*
* Step 1: Tansfer in C's nodes to Repo B
*
* Step 2. Transfer in A's nodes to Repo B
*
* Setup tree above. Validat that A2 is child of C2 dest.
* A4 is a child of B1
*
* Step 3. Copy A5 from C2 to C3.
* C2Dest should still be invaded by A5
* C3Dest should be invaded by A5(copy 1) which is now a "B" invader.
*
* Step 4. Copy A5 from C2 to A4.
* C2Dest should still be invaded by A5
* A4Dest should be invaded by A5(copy 2) which is now a "B" invader.
*
* Step 5. Invade A5 dest with B6.
* Copy A5(Dest) to B1 (A5 Copy 3)
* B1 should not be invaded.
* A5 Copy 3 not invaded.
* B6 Copy not invaded.
*
* Step 6. Invade A5 dest with B6.
* Copy A5(Dest) to B1 (A5 Copy 3) with children
* B1 should not be invaded.
* A5 Copy 4 not invaded.
* B6 Copy not invaded.
*/
@Test
public void testCopyAlien() throws Exception {
final String CONTENT_TITLE = "ContentTitle";
final String targetName = "testCopyAlien";
class TestData {
@SuppressWarnings("unused")
TransferTarget transferMe;
NodeRef S0NodeRef;
NodeRef A1NodeRef;
NodeRef B1NodeRef;
NodeRef C1NodeRef;
NodeRef C2NodeRef;
NodeRef C3NodeRef;
NodeRef A4NodeRef;
NodeRef A5NodeRef;
NodeRef B6NodeRef;
NodeRef C2DummyNodeRef;
NodeRef C3DummyNodeRef;
}
final TestData testData = new TestData();
final QName C2Path = QName.createQName("p2");
final QName C3Path = QName.createQName("p3");
final String localRepositoryId = descriptorService.getCurrentRepositoryDescriptor().getId();
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
NodeRef guestHome = repositoryHelper.getGuestHome();
{
/**
* Node Source - located under guest home
*/
String name = GUID.generate();
ChildAssociationRef child = nodeService.createNode(guestHome, ContentModel.ASSOC_CONTAINS, QName.createQName(name), ContentModel.TYPE_FOLDER);
testData.S0NodeRef = child.getChildRef();
nodeService.setProperty(testData.S0NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.S0NodeRef, ContentModel.PROP_NAME, name);
}
{
// Node A1
ChildAssociationRef child = nodeService.createNode(testData.S0NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A1"), ContentModel.TYPE_FOLDER);
testData.A1NodeRef = child.getChildRef();
nodeService.setProperty(testData.A1NodeRef, ContentModel.PROP_TITLE, "A1");
nodeService.setProperty(testData.A1NodeRef, ContentModel.PROP_NAME, "A1");
}
{
// Node B1
ChildAssociationRef child = nodeService.createNode(testData.S0NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("B1"), ContentModel.TYPE_FOLDER);
testData.B1NodeRef = child.getChildRef();
nodeService.setProperty(testData.B1NodeRef, ContentModel.PROP_TITLE, "B1");
nodeService.setProperty(testData.B1NodeRef, ContentModel.PROP_NAME, "B1");
}
{
// Node C1
ChildAssociationRef child = nodeService.createNode(testData.S0NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("C1"), ContentModel.TYPE_FOLDER);
testData.C1NodeRef = child.getChildRef();
nodeService.setProperty(testData.C1NodeRef, ContentModel.PROP_TITLE, "C1");
nodeService.setProperty(testData.C1NodeRef, ContentModel.PROP_NAME, "C1");
}
{
// Node C2
ChildAssociationRef child = nodeService.createNode(testData.C1NodeRef, ContentModel.ASSOC_CONTAINS, C2Path, ContentModel.TYPE_FOLDER);
testData.C2NodeRef = child.getChildRef();
nodeService.setProperty(testData.C2NodeRef, ContentModel.PROP_TITLE, "C2");
nodeService.setProperty(testData.C2NodeRef, ContentModel.PROP_NAME, "C2");
}
{
// Node C3
ChildAssociationRef child = nodeService.createNode(testData.C1NodeRef, ContentModel.ASSOC_CONTAINS, C3Path, ContentModel.TYPE_FOLDER);
testData.C3NodeRef = child.getChildRef();
nodeService.setProperty(testData.C3NodeRef, ContentModel.PROP_TITLE, "C3");
nodeService.setProperty(testData.C3NodeRef, ContentModel.PROP_NAME, "C3");
}
{
// Node C2 (Dummy)
ChildAssociationRef child = nodeService.createNode(testData.A1NodeRef, ContentModel.ASSOC_CONTAINS, C2Path, ContentModel.TYPE_FOLDER);
testData.C2DummyNodeRef = child.getChildRef();
nodeService.setProperty(testData.C2DummyNodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.C2DummyNodeRef, ContentModel.PROP_NAME, "C2 Dummy");
}
{
// Node C3 (Dummy)
ChildAssociationRef child = nodeService.createNode(testData.A1NodeRef, ContentModel.ASSOC_CONTAINS, C3Path, ContentModel.TYPE_FOLDER);
testData.C3DummyNodeRef = child.getChildRef();
nodeService.setProperty(testData.C3DummyNodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.C3DummyNodeRef, ContentModel.PROP_NAME, "C3 Dummy");
}
{
// Node A4
ChildAssociationRef child = nodeService.createNode(testData.A1NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("C4"), ContentModel.TYPE_FOLDER);
testData.A4NodeRef = child.getChildRef();
nodeService.setProperty(testData.A4NodeRef, ContentModel.PROP_TITLE, "A4");
nodeService.setProperty(testData.A4NodeRef, ContentModel.PROP_NAME, "A4");
}
{
// Node A5
ChildAssociationRef child = nodeService.createNode(testData.C2DummyNodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A5"), ContentModel.TYPE_FOLDER);
testData.A5NodeRef = child.getChildRef();
nodeService.setProperty(testData.A5NodeRef, ContentModel.PROP_TITLE, "A5");
nodeService.setProperty(testData.A5NodeRef, ContentModel.PROP_NAME, "A5");
}
// Create the transfer target if it does not already exist
if (!transferService.targetExists(targetName)) {
testData.transferMe = createTransferTarget(targetName);
} else {
testData.transferMe = transferService.getTransferTarget(targetName);
}
return null;
}
});
/**
* For unit test
* - replace the HTTP transport with the in-process transport
* - Map path from A1 to B1 (So transfer will transfer by path)
* - Map path from C1 to B1
*/
TransferTransmitter transmitter = new UnitTestInProcessTransmitterImpl(receiver, contentService, transactionService);
transferServiceImpl.setTransmitter(transmitter);
final UnitTestTransferManifestNodeFactory testNodeFactory = new UnitTestTransferManifestNodeFactory(this.transferManifestNodeFactory);
transferServiceImpl.setTransferManifestNodeFactory(testNodeFactory);
final List<Pair<Path, Path>> pathMap = testNodeFactory.getPathMap();
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
// Map Project A to Project B
// Map Project C to Project B
pathMap.add(new Pair<Path, Path>(nodeService.getPath(testData.A1NodeRef), nodeService.getPath(testData.B1NodeRef)));
pathMap.add(new Pair<Path, Path>(nodeService.getPath(testData.C1NodeRef), nodeService.getPath(testData.B1NodeRef)));
return null;
}
});
DescriptorService mockedDescriptorService = getMockDescriptorService(REPO_ID_C);
transferServiceImpl.setDescriptorService(mockedDescriptorService);
/**
* Step 1
* Now transfer in C's nodes to Repo B
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
TransferDefinition definition = new TransferDefinition();
Collection<NodeRef> nodes = new ArrayList<NodeRef>();
nodes.add(testData.C1NodeRef);
nodes.add(testData.C2NodeRef);
nodes.add(testData.C3NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
assertTrue("dest node C2 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C2NodeRef)));
assertTrue("dest node C3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C3NodeRef)));
// Check that C3 dest is a child of B1
ChildAssociationRef C3Ref = nodeService.getPrimaryParent(testNodeFactory.getMappedNodeRef(testData.C3NodeRef));
assertEquals("A3 dest is connected to the wrong node", C3Ref.getParentRef(), testData.B1NodeRef);
ChildAssociationRef C2Ref = nodeService.getPrimaryParent(testNodeFactory.getMappedNodeRef(testData.C2NodeRef));
assertEquals("A2 dest is connected to the wrong node", C2Ref.getParentRef(), testData.B1NodeRef);
return null;
}
});
mockedDescriptorService = getMockDescriptorService(REPO_ID_A);
transferServiceImpl.setDescriptorService(mockedDescriptorService);
/**
* Step 2
* Now transfer in A's nodes
* C2 (Dest) gets invaded by A4
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
TransferDefinition definition = new TransferDefinition();
Collection<NodeRef> nodes = new ArrayList<NodeRef>();
nodes.add(testData.A4NodeRef);
nodes.add(testData.A5NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
assertTrue("dest node A5 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A5NodeRef)));
assertTrue("dest node C3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C3NodeRef)));
assertTrue("dest node C2 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C2NodeRef)));
ChildAssociationRef A5Ref = nodeService.getPrimaryParent(testNodeFactory.getMappedNodeRef(testData.A5NodeRef));
assertEquals("A5 dest is connected to the wrong node", A5Ref.getParentRef(), testNodeFactory.getMappedNodeRef(testData.C2NodeRef));
assertTrue("C2 dest is not invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.C2NodeRef), TransferModel.ASPECT_ALIEN));
assertFalse("C3 dest is not invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.C3NodeRef), TransferModel.ASPECT_ALIEN));
ChildAssociationRef A4Ref = nodeService.getPrimaryParent(testNodeFactory.getMappedNodeRef(testData.A4NodeRef));
assertEquals("A4 dest is connected to the wrong node", A4Ref.getParentRef(), testData.B1NodeRef);
return null;
}
});
/**
* Step 3. Copy A5 from C2 to C3.
* C2Dest should still be invaded by A5
* C3Dest should be invaded by A5(copy) which is now a "B/local" invader.
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
NodeRef copyRef = copyService.copy(testNodeFactory.getMappedNodeRef(testData.A5NodeRef), testNodeFactory.getMappedNodeRef(testData.C3NodeRef), ContentModel.ASSOC_CONTAINS, QName.createQName("A5 Copy 1"));
assertTrue("dest node C3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C3NodeRef)));
assertTrue("dest node C2 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C2NodeRef)));
assertTrue("A5(copy 1) is not invaded", nodeService.hasAspect(copyRef, TransferModel.ASPECT_ALIEN));
assertTrue("C3 dest is not invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.C3NodeRef), TransferModel.ASPECT_ALIEN));
assertTrue("C2 dest is not invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.C2NodeRef), TransferModel.ASPECT_ALIEN));
@SuppressWarnings("unchecked") List<String> C2invaders = (List<String>) nodeService.getProperty(testNodeFactory.getMappedNodeRef(testData.C2NodeRef), TransferModel.PROP_INVADED_BY);
@SuppressWarnings("unchecked") List<String> C3invaders = (List<String>) nodeService.getProperty(testNodeFactory.getMappedNodeRef(testData.C3NodeRef), TransferModel.PROP_INVADED_BY);
assertTrue("C3 invaders contains local repository Id", C3invaders.contains(localRepositoryId));
assertFalse("C3 invaders contains REPO_ID_A", C3invaders.contains(REPO_ID_A));
assertFalse("C2 invaders contains local repository Id", C2invaders.contains(localRepositoryId));
assertTrue("C2 invaders contains REPO_ID_A", C2invaders.contains(REPO_ID_A));
return null;
}
});
/**
* Step 4. Copy A5 from C2 to A4.
* C2Dest should still be invaded by A5
* A4Dest should be invaded by A5(copy 2) which is now a "B" invader.
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
NodeRef copyRef = copyService.copy(testNodeFactory.getMappedNodeRef(testData.A5NodeRef), testNodeFactory.getMappedNodeRef(testData.A4NodeRef), ContentModel.ASSOC_CONTAINS, QName.createQName("A5 Copy 2"));
assertTrue("dest node A4 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A4NodeRef)));
assertTrue("dest node C2 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C2NodeRef)));
assertTrue("A5(copy 2) is not invaded", nodeService.hasAspect(copyRef, TransferModel.ASPECT_ALIEN));
assertTrue("A4 dest is not invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.A4NodeRef), TransferModel.ASPECT_ALIEN));
assertTrue("C2 dest is not invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.C2NodeRef), TransferModel.ASPECT_ALIEN));
@SuppressWarnings("unchecked") List<String> C2invaders = (List<String>) nodeService.getProperty(testNodeFactory.getMappedNodeRef(testData.C2NodeRef), TransferModel.PROP_INVADED_BY);
@SuppressWarnings("unchecked") List<String> A4invaders = (List<String>) nodeService.getProperty(testNodeFactory.getMappedNodeRef(testData.A4NodeRef), TransferModel.PROP_INVADED_BY);
assertTrue("A4 invaders contains local repository Id", A4invaders.contains(localRepositoryId));
assertFalse("C2 invaders contains local repository Id", C2invaders.contains(localRepositoryId));
assertTrue("C2 invaders contains REPO_ID_A", C2invaders.contains(REPO_ID_A));
return null;
}
});
/**
* Step 5. Invade A5 dest with B6.
* Copy A5(Dest) to B1 (A5 Copy 3) no children
* B1 should not be invaded.
* A5 Copy 3 not invaded.
* B6 Copy not invaded.
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
ChildAssociationRef child = nodeService.createNode(testNodeFactory.getMappedNodeRef(testData.A5NodeRef), ContentModel.ASSOC_CONTAINS, QName.createQName("B6"), ContentModel.TYPE_FOLDER);
testData.B6NodeRef = child.getChildRef();
nodeService.setProperty(testData.B6NodeRef, ContentModel.PROP_TITLE, "B6");
nodeService.setProperty(testData.B6NodeRef, ContentModel.PROP_NAME, "B6");
assertTrue("A4 dest is not invaded prior to test - test error", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.A4NodeRef), TransferModel.ASPECT_ALIEN));
NodeRef copyRef = copyService.copy(testNodeFactory.getMappedNodeRef(testData.A5NodeRef), testData.B1NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A5 Copy 3"));
assertFalse("B1 is invaded", nodeService.hasAspect(testData.B1NodeRef, TransferModel.ASPECT_ALIEN));
assertFalse("A5 copy 3 is invaded", nodeService.hasAspect(copyRef, TransferModel.ASPECT_ALIEN));
return null;
}
});
/**
* Step 6. Invade A5 dest with B6.
* Copy A5(Dest) to B1 (A5 Copy 3) with children
* B1 should not be invaded.
* A5 Copy 4 not invaded.
* B6 Copy not invaded.
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
assertFalse("B1 is invaded prior to test - test error", nodeService.hasAspect(testData.B1NodeRef, TransferModel.ASPECT_ALIEN));
NodeRef copyRef = copyService.copy(testNodeFactory.getMappedNodeRef(testData.A5NodeRef), testData.B1NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A5 Copy 4"), true);
assertFalse("B1 is invaded", nodeService.hasAspect(testData.B1NodeRef, TransferModel.ASPECT_ALIEN));
assertFalse("A5 copy 4 is invaded", nodeService.hasAspect(copyRef, TransferModel.ASPECT_ALIEN));
List<ChildAssociationRef> refs = nodeService.getChildAssocs(copyRef);
assertTrue("can't find child of A5 copy 4", refs.size() == 1);
for (ChildAssociationRef ref : refs) {
assertFalse("B6 copy is invaded", nodeService.hasAspect(ref.getChildRef(), TransferModel.ASPECT_ALIEN));
}
return null;
}
});
}
Also used :
QName(org.alfresco.service.namespace.QName)
TransferTarget(org.alfresco.service.cmr.transfer.TransferTarget)
ChildAssociationRef(org.alfresco.service.cmr.repository.ChildAssociationRef)
TransferDefinition(org.alfresco.service.cmr.transfer.TransferDefinition)
NodeRef(org.alfresco.service.cmr.repository.NodeRef)
Collection(java.util.Collection)
List(java.util.List)
ArrayList(java.util.ArrayList)
DescriptorService(org.alfresco.service.descriptor.DescriptorService)
Pair(org.alfresco.util.Pair)
BaseAlfrescoSpringTest(org.alfresco.util.BaseAlfrescoSpringTest)
Test(org.junit.Test)
Example 20 with TransferDefinition
use of org.alfresco.service.cmr.transfer.TransferDefinition in project alfresco-repository by Alfresco.
the class TransferServiceToBeRefactoredTest method testMultiRepoTransfer.
// test two repo sync
/**
* Transfer sync from multiple repos.
*
* This is a unit test so does lots of shenanigans to fake transfer from three repositories on a single repo.
*
* Trees of nodes
* <pre>
* A1 B1 C1
* | |
* A2/images A2 Dummy/images
* | |
* A3 C3
*
* Destination
* B1
* |
* A2/images
* | |
* C3 A3
* |
* C4
* </pre>
* Step 1. Transfer from A to B.
* Step 2. Transfer from C to B (crossing over on A2Dest)
* Step 3. Invade A3Dest via C4
* Step 4. Delete C4. Sync from C
* Step 5. Delete C3 - A2 dest images folder uninvaded.
*/
@Test
public void testMultiRepoTransfer() throws Exception {
final String CONTENT_TITLE = "ContentTitle";
final String targetName = "testMultiRepoTransfer";
class TestData {
@SuppressWarnings("unused")
TransferTarget transferMe;
NodeRef S0NodeRef;
NodeRef A1NodeRef;
NodeRef A2NodeRef;
NodeRef A3NodeRef;
NodeRef B1NodeRef;
NodeRef C1NodeRef;
NodeRef C2NodeRef;
NodeRef C3NodeRef;
NodeRef C4NodeRef;
NodeRef A3Dummy;
}
final TestData testData = new TestData();
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
NodeRef guestHome = repositoryHelper.getGuestHome();
{
/**
* Node Source - located under guest home
*/
String name = GUID.generate();
ChildAssociationRef child = nodeService.createNode(guestHome, ContentModel.ASSOC_CONTAINS, QName.createQName(name), ContentModel.TYPE_FOLDER);
testData.S0NodeRef = child.getChildRef();
nodeService.setProperty(testData.S0NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.S0NodeRef, ContentModel.PROP_NAME, name);
}
{
// Node A1
ChildAssociationRef child = nodeService.createNode(testData.S0NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A1"), ContentModel.TYPE_FOLDER);
testData.A1NodeRef = child.getChildRef();
nodeService.setProperty(testData.A1NodeRef, ContentModel.PROP_TITLE, "A1");
nodeService.setProperty(testData.A1NodeRef, ContentModel.PROP_NAME, "A1");
}
{
// Node A2
ChildAssociationRef child = nodeService.createNode(testData.A1NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("images"), ContentModel.TYPE_FOLDER);
testData.A2NodeRef = child.getChildRef();
nodeService.setProperty(testData.A2NodeRef, ContentModel.PROP_TITLE, "images");
nodeService.setProperty(testData.A2NodeRef, ContentModel.PROP_NAME, "images");
}
{
// Node A3
ChildAssociationRef child = nodeService.createNode(testData.A2NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A3"), ContentModel.TYPE_FOLDER);
testData.A3NodeRef = child.getChildRef();
nodeService.setProperty(testData.A3NodeRef, ContentModel.PROP_TITLE, "A3");
nodeService.setProperty(testData.A3NodeRef, ContentModel.PROP_NAME, "A3");
}
{
// Node B1
ChildAssociationRef child = nodeService.createNode(testData.S0NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("B1"), ContentModel.TYPE_FOLDER);
testData.B1NodeRef = child.getChildRef();
nodeService.setProperty(testData.B1NodeRef, ContentModel.PROP_TITLE, "B1");
nodeService.setProperty(testData.B1NodeRef, ContentModel.PROP_NAME, "B1");
}
{
// Node C1
ChildAssociationRef child = nodeService.createNode(testData.S0NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("C1"), ContentModel.TYPE_FOLDER);
testData.C1NodeRef = child.getChildRef();
nodeService.setProperty(testData.C1NodeRef, ContentModel.PROP_TITLE, "C1");
nodeService.setProperty(testData.C1NodeRef, ContentModel.PROP_NAME, "C1");
}
{
// Node C2/images
ChildAssociationRef child = nodeService.createNode(testData.C1NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("images"), ContentModel.TYPE_FOLDER);
testData.C2NodeRef = child.getChildRef();
nodeService.setProperty(testData.C2NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.C2NodeRef, ContentModel.PROP_NAME, "images");
}
{
// Node C3
ChildAssociationRef child = nodeService.createNode(testData.C2NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("C3"), ContentModel.TYPE_FOLDER);
testData.C3NodeRef = child.getChildRef();
nodeService.setProperty(testData.C3NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.C3NodeRef, ContentModel.PROP_NAME, "C3");
}
{
// Node A3 (Dummy)
ChildAssociationRef child = nodeService.createNode(testData.C2NodeRef, ContentModel.ASSOC_CONTAINS, QName.createQName("A3"), ContentModel.TYPE_FOLDER);
testData.A3Dummy = child.getChildRef();
nodeService.setProperty(testData.A3Dummy, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.A3Dummy, ContentModel.PROP_NAME, "A3 Dummy");
}
{
// Node C4
ChildAssociationRef child = nodeService.createNode(testData.A3Dummy, ContentModel.ASSOC_CONTAINS, QName.createQName("C4"), ContentModel.TYPE_FOLDER);
testData.C4NodeRef = child.getChildRef();
nodeService.setProperty(testData.C4NodeRef, ContentModel.PROP_TITLE, CONTENT_TITLE);
nodeService.setProperty(testData.C4NodeRef, ContentModel.PROP_NAME, "C4");
}
// Create the transfer target if it does not already exist
if (!transferService.targetExists(targetName)) {
testData.transferMe = createTransferTarget(targetName);
} else {
testData.transferMe = transferService.getTransferTarget(targetName);
}
return null;
}
});
/**
* For unit test
* - replace the HTTP transport with the in-process transport
* - Map path from A1 to B1 (So transfer will transfer by path)
* - Map path from C1 to B1
*/
TransferTransmitter transmitter = new UnitTestInProcessTransmitterImpl(receiver, contentService, transactionService);
transferServiceImpl.setTransmitter(transmitter);
final UnitTestTransferManifestNodeFactory testNodeFactory = new UnitTestTransferManifestNodeFactory(this.transferManifestNodeFactory);
transferServiceImpl.setTransferManifestNodeFactory(testNodeFactory);
final List<Pair<Path, Path>> pathMap = testNodeFactory.getPathMap();
// Map Project A/images to Project B/images
// Map Project C/images to Project A/images
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
nodeService.getPath(testData.A2NodeRef);
pathMap.add(new Pair<Path, Path>(nodeService.getPath(testData.A1NodeRef), nodeService.getPath(testData.B1NodeRef)));
pathMap.add(new Pair<Path, Path>(nodeService.getPath(testData.C1NodeRef), nodeService.getPath(testData.B1NodeRef)));
return null;
}
}, true);
{
DescriptorService mockedDescriptorService = getMockDescriptorService(REPO_ID_A);
transferServiceImpl.setDescriptorService(mockedDescriptorService);
}
/**
* Step 1 Now transfer in A's nodes to Repo B
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
TransferDefinition definition = new TransferDefinition();
Collection<NodeRef> nodes = new ArrayList<NodeRef>();
nodes.add(testData.A1NodeRef);
nodes.add(testData.A2NodeRef);
nodes.add(testData.A3NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
assertTrue("dest node A2 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A2NodeRef)));
assertTrue("dest node A3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A3NodeRef)));
// Check that A3 dest is a child of A2Dest which is a child of B1
ChildAssociationRef A3Ref = nodeService.getPrimaryParent(testNodeFactory.getMappedNodeRef(testData.A3NodeRef));
assertEquals("A3 dest is connected to the wrong node", A3Ref.getParentRef(), testNodeFactory.getMappedNodeRef(testData.A2NodeRef));
ChildAssociationRef A2Ref = nodeService.getPrimaryParent(testNodeFactory.getMappedNodeRef(testData.A2NodeRef));
assertEquals("A2 dest is connected to the wrong node", A2Ref.getParentRef(), testData.B1NodeRef);
assertEquals("A2 dest owned by wrong repo", nodeService.getProperty(testNodeFactory.getMappedNodeRef(testData.A2NodeRef), TransferModel.PROP_FROM_REPOSITORY_ID), REPO_ID_A);
assertEquals("A3 dest owned by wrong repo", nodeService.getProperty(testNodeFactory.getMappedNodeRef(testData.A3NodeRef), TransferModel.PROP_FROM_REPOSITORY_ID), REPO_ID_A);
return null;
}
});
/**
* Step 2 Now transfer in C's nodes B2 (Owned by A) gets invaded by C
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
DescriptorService mockedDescriptorService = getMockDescriptorService(REPO_ID_C);
transferServiceImpl.setDescriptorService(mockedDescriptorService);
TransferDefinition definition = new TransferDefinition();
Collection<NodeRef> nodes = new ArrayList<NodeRef>();
nodes.add(testData.C1NodeRef);
nodes.add(testData.C2NodeRef);
nodes.add(testData.C3NodeRef);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
assertTrue("dest node A3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A3NodeRef)));
assertTrue("dest node C3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C3NodeRef)));
// Check that A3 dest is a child of A2Dest which is a child of B1
// Check that C3 dest is a child of A2Dest
ChildAssociationRef A3Ref = nodeService.getPrimaryParent(testNodeFactory.getMappedNodeRef(testData.A3NodeRef));
assertEquals("A3 dest is connected to the wrong node", A3Ref.getParentRef(), testNodeFactory.getMappedNodeRef(testData.A2NodeRef));
ChildAssociationRef C3Ref = nodeService.getPrimaryParent(testNodeFactory.getMappedNodeRef(testData.A3NodeRef));
assertEquals("C3 dest is connected to the wrong node", C3Ref.getParentRef(), testNodeFactory.getMappedNodeRef(testData.A2NodeRef));
ChildAssociationRef A2Ref = nodeService.getPrimaryParent(testNodeFactory.getMappedNodeRef(testData.A2NodeRef));
assertEquals("A2 dest is connected to the wrong node", A2Ref.getParentRef(), testData.B1NodeRef);
assertTrue("A2 dest is not invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.A2NodeRef), TransferModel.ASPECT_ALIEN));
assertTrue("C3 dest is not invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.C3NodeRef), TransferModel.ASPECT_ALIEN));
assertFalse("A3 dest is invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.A3NodeRef), TransferModel.ASPECT_ALIEN));
assertEquals("A2 dest owned by wrong repo", nodeService.getProperty(testNodeFactory.getMappedNodeRef(testData.A2NodeRef), TransferModel.PROP_FROM_REPOSITORY_ID), REPO_ID_A);
assertEquals("A3 dest owned by wrong repo", nodeService.getProperty(testNodeFactory.getMappedNodeRef(testData.A3NodeRef), TransferModel.PROP_FROM_REPOSITORY_ID), REPO_ID_A);
assertEquals("C3 dest owned by wrong repo", nodeService.getProperty(testNodeFactory.getMappedNodeRef(testData.C3NodeRef), TransferModel.PROP_FROM_REPOSITORY_ID), REPO_ID_C);
return null;
}
});
/**
* Step 3 Invade A3Dest via transfer of C4 from C
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
DescriptorService mockedDescriptorService = getMockDescriptorService(REPO_ID_C);
transferServiceImpl.setDescriptorService(mockedDescriptorService);
TransferDefinition definition = new TransferDefinition();
Collection<NodeRef> nodes = new ArrayList<NodeRef>();
nodes.add(testData.C4NodeRef);
definition.setNodes(nodes);
definition.setSync(false);
transferService.transfer(targetName, definition);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
assertTrue("dest node A3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A3NodeRef)));
assertTrue("dest node C3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C3NodeRef)));
assertTrue("dest node C4 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C4NodeRef)));
assertTrue("C4 is not an invader", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.C4NodeRef), TransferModel.ASPECT_ALIEN));
assertTrue("A3 is not an invader", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.A3NodeRef), TransferModel.ASPECT_ALIEN));
assertEquals("A2 dest owned by wrong repo", nodeService.getProperty(testNodeFactory.getMappedNodeRef(testData.A2NodeRef), TransferModel.PROP_FROM_REPOSITORY_ID), REPO_ID_A);
assertEquals("A3 dest owned by wrong repo", nodeService.getProperty(testNodeFactory.getMappedNodeRef(testData.A3NodeRef), TransferModel.PROP_FROM_REPOSITORY_ID), REPO_ID_A);
assertEquals("C3 dest owned by wrong repo", nodeService.getProperty(testNodeFactory.getMappedNodeRef(testData.C3NodeRef), TransferModel.PROP_FROM_REPOSITORY_ID), REPO_ID_C);
return null;
}
});
/**
* Step 4
* Uninvade A3 from C by deleting C4
* Via Sync of A3Dummy (which has the same destination path as A3).
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
nodeService.deleteNode(testData.C4NodeRef);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
DescriptorService mockedDescriptorService = getMockDescriptorService(REPO_ID_C);
transferServiceImpl.setDescriptorService(mockedDescriptorService);
TransferDefinition definition = new TransferDefinition();
Collection<NodeRef> nodes = new ArrayList<NodeRef>();
nodes.add(testData.A3Dummy);
definition.setNodes(nodes);
definition.setSync(true);
transferService.transfer(targetName, definition);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
assertTrue("dest node A3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A3NodeRef)));
assertTrue("dest node C3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C3NodeRef)));
assertFalse("dest node C4 not deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C4NodeRef)));
logger.debug("A3 Dest is " + testNodeFactory.getMappedNodeRef(testData.A3NodeRef));
assertFalse("A3 Dest still invaded by C4", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.A3NodeRef), TransferModel.ASPECT_ALIEN));
return null;
}
});
/**
* Step 5 - repeat the above test with transfer(non sync) rather than transfer(sync) Uninvade by deleting C3.
*/
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
nodeService.deleteNode(testData.C3NodeRef);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
DescriptorService mockedDescriptorService = getMockDescriptorService(REPO_ID_C);
transferServiceImpl.setDescriptorService(mockedDescriptorService);
TransferDefinition definition = new TransferDefinition();
Collection<NodeRef> nodes = new ArrayList<NodeRef>();
NodeRef C3Deleted = new NodeRef(StoreRef.STORE_REF_ARCHIVE_SPACESSTORE, testData.C3NodeRef.getId());
nodes.add(C3Deleted);
definition.setNodes(nodes);
definition.setSync(false);
transferService.transfer(targetName, definition);
return null;
}
});
transactionService.getRetryingTransactionHelper().doInTransaction(new RetryingTransactionCallback<Void>() {
@Override
public Void execute() throws Throwable {
assertTrue("dest node A3 does not exist", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.A3NodeRef)));
assertFalse("dest node C3 not deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C3NodeRef)));
assertFalse("dest node C4 not deleted", nodeService.exists(testNodeFactory.getMappedNodeRef(testData.C4NodeRef)));
assertFalse("A3 still invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.A3NodeRef), TransferModel.ASPECT_ALIEN));
assertFalse("A2 still invaded", nodeService.hasAspect(testNodeFactory.getMappedNodeRef(testData.A2NodeRef), TransferModel.ASPECT_ALIEN));
return null;
}
});
}
Also used :
TransferTarget(org.alfresco.service.cmr.transfer.TransferTarget)
ChildAssociationRef(org.alfresco.service.cmr.repository.ChildAssociationRef)
TransferDefinition(org.alfresco.service.cmr.transfer.TransferDefinition)
NodeRef(org.alfresco.service.cmr.repository.NodeRef)
Collection(java.util.Collection)
DescriptorService(org.alfresco.service.descriptor.DescriptorService)
Pair(org.alfresco.util.Pair)
BaseAlfrescoSpringTest(org.alfresco.util.BaseAlfrescoSpringTest)
Test(org.junit.Test)
Aggregations
TransferDefinition (org.alfresco.service.cmr.transfer.TransferDefinition)38
NodeRef (org.alfresco.service.cmr.repository.NodeRef)31
TransferTarget (org.alfresco.service.cmr.transfer.TransferTarget)25
ChildAssociationRef (org.alfresco.service.cmr.repository.ChildAssociationRef)24
BaseAlfrescoSpringTest (org.alfresco.util.BaseAlfrescoSpringTest)24
Test (org.junit.Test)24
HashSet (java.util.HashSet)21
Locale (java.util.Locale)19
DescriptorService (org.alfresco.service.descriptor.DescriptorService)18
ArrayList (java.util.ArrayList)17
Pair (org.alfresco.util.Pair)16
ContentWriter (org.alfresco.service.cmr.repository.ContentWriter)14
RetryingTransactionCallback (org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback)13
RetryingTransactionHelper (org.alfresco.repo.transaction.RetryingTransactionHelper)11
List (java.util.List)10
Path (org.alfresco.service.cmr.repository.Path)10
TransferEvent (org.alfresco.service.cmr.transfer.TransferEvent)8
Collection (java.util.Collection)7
QName (org.alfresco.service.namespace.QName)7
ContentReader (org.alfresco.service.cmr.repository.ContentReader)5
