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

Reintroduced the transfer test case that was showing a problem with the recent changes made to the TransactionalCache. This is now working.

Browse Source 
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@19052 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
Brian Remmington
2010-03-04 09:02:39 +00:00
parent 1544887f4e
commit 7f66912891
2 changed files with 235 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
source/java/org/alfresco/repo/transfer/RepoPrimaryManifestProcessorImpl.java
View File

@@ -131,6 +131,10 @@ public class RepoPrimaryManifestProcessorImpl extends AbstractManifestProcessorB
} }
logProgress("Deleting local node: " + resolvedNodes.resolvedChild); logProgress("Deleting local node: " + resolvedNodes.resolvedChild);
nodeService.deleteNode(resolvedNodes.resolvedChild); nodeService.deleteNode(resolvedNodes.resolvedChild);
if (log.isDebugEnabled())
{
log.debug("Deleted local node: " + resolvedNodes.resolvedChild);
}
} }
else else
{ {

402
source/java/org/alfresco/repo/transfer/RepoTransferReceiverImplTest.java
View File

@@ -79,7 +79,8 @@ public class RepoTransferReceiverImplTest extends BaseAlfrescoSpringTest
private SearchService searchService; private SearchService searchService;
private String dummyContent; private String dummyContent;
private byte[] dummyContentBytes; private byte[] dummyContentBytes;
private NodeRef guestHome;
@Override @Override
public void runBare() throws Throwable public void runBare() throws Throwable
{ {
@@ -110,8 +111,65 @@ public class RepoTransferReceiverImplTest extends BaseAlfrescoSpringTest
this.dummyContentBytes = dummyContent.getBytes("UTF-8"); this.dummyContentBytes = dummyContent.getBytes("UTF-8");
setTransactionDefinition(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRES_NEW)); setTransactionDefinition(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRES_NEW));
authenticationComponent.setSystemUserAsCurrentUser(); authenticationComponent.setSystemUserAsCurrentUser();
startNewTransaction();
String guestHomeQuery = "/app:company_home/app:guest_home";
ResultSet guestHomeResult = searchService.query(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, SearchService.LANGUAGE_XPATH, guestHomeQuery);
assertEquals("", 1, guestHomeResult.length());
guestHome = guestHomeResult.getNodeRef(0);
endTransaction();
} }
public void testDelete()
{
setDefaultRollback(false);
String uuid = GUID.generate();
ChildAssociationRef childAssoc;
startNewTransaction();
try
{
ResultSet rs = searchService.query(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, SearchService.LANGUAGE_XPATH,
"/app:company_home");
assertEquals(1, rs.length());
NodeRef companyHome = rs.getNodeRef(0);
Map<QName, Serializable> props = new HashMap<QName, Serializable>();
props.put(ContentModel.PROP_NAME, uuid);
childAssoc = nodeService.createNode(companyHome, ContentModel.ASSOC_CONTAINS,
QName.createQName(NamespaceService.APP_MODEL_1_0_URI, uuid), ContentModel.TYPE_CONTENT, props);
}
finally
{
endTransaction();
}
startNewTransaction();
try
{
nodeService.deleteNode(childAssoc.getChildRef());
}
finally
{
endTransaction();
}
startNewTransaction();
try
{
log.debug("Test that original node no longer exists...");
assertFalse(nodeService.exists(childAssoc.getChildRef()));
log.debug("PASS - Original node no longer exists.");
NodeRef archiveNodeRef = new NodeRef(StoreRef.STORE_REF_ARCHIVE_SPACESSTORE, childAssoc.getChildRef().getId());
log.debug("Test that archive node exists...");
assertTrue(nodeService.exists(archiveNodeRef));
log.debug("PASS - Archive node exists.");
}
finally
{
endTransaction();
}
}
public void testStartAndEnd() throws Exception public void testStartAndEnd() throws Exception
{ {
log.info("testStartAndEnd"); log.info("testStartAndEnd");
@@ -344,170 +402,178 @@ public class RepoTransferReceiverImplTest extends BaseAlfrescoSpringTest
} }
// TODO Brian please take a look at the test below. public void testNodeDeleteAndRestore() throws Exception
// public void testNodeDeleteAndRestore() throws Exception {
// { log.info("testNodeDeleteAndRestore");
// log.info("testNodeDeleteAndRestore");
// setDefaultRollback(true);
// this.setDefaultRollback(false); startNewTransaction();
// startNewTransaction(); String transferId = receiver.start();
// String transferId = receiver.start();
// List<TransferManifestNode> nodes = new ArrayList<TransferManifestNode>();
// List<TransferManifestNode> nodes = new ArrayList<TransferManifestNode>(); TransferManifestNormalNode node1 = createContentNode(transferId);
// TransferManifestNormalNode node1 = createContentNode(transferId); nodes.add(node1);
// nodes.add(node1); TransferManifestNormalNode node2 = createContentNode(transferId);
// TransferManifestNormalNode node2 = createContentNode(transferId); nodes.add(node2);
// nodes.add(node2); TransferManifestNode node3 = createContentNode(transferId);
// TransferManifestNode node3 = createContentNode(transferId); nodes.add(node3);
// nodes.add(node3); TransferManifestNode node4 = createContentNode(transferId);
// TransferManifestNode node4 = createContentNode(transferId); nodes.add(node4);
// nodes.add(node4); TransferManifestNode node5 = createContentNode(transferId);
// TransferManifestNode node5 = createContentNode(transferId); nodes.add(node5);
// nodes.add(node5); TransferManifestNode node6 = createContentNode(transferId);
// TransferManifestNode node6 = createContentNode(transferId); nodes.add(node6);
// nodes.add(node6); TransferManifestNode node7 = createContentNode(transferId);
// TransferManifestNode node7 = createContentNode(transferId); nodes.add(node7);
// nodes.add(node7); TransferManifestNode node8 = createFolderNode(transferId);
// TransferManifestNode node8 = createFolderNode(transferId); nodes.add(node8);
// nodes.add(node8); TransferManifestNode node9 = createFolderNode(transferId);
// TransferManifestNode node9 = createFolderNode(transferId); nodes.add(node9);
// nodes.add(node9); TransferManifestNode node10 = createFolderNode(transferId);
// TransferManifestNode node10 = createFolderNode(transferId); nodes.add(node10);
// nodes.add(node10); TransferManifestNormalNode node11 = createFolderNode(transferId);
// TransferManifestNormalNode node11 = createFolderNode(transferId); nodes.add(node11);
// nodes.add(node11); TransferManifestNode node12 = createFolderNode(transferId);
// TransferManifestNode node12 = createFolderNode(transferId); nodes.add(node12);
// nodes.add(node12);
// associatePeers(node1, node2);
// associatePeers(node1, node2); moveNode(node2, node11);
// moveNode(node2, node11);
// TransferManifestDeletedNode deletedNode8 = createDeletedNode(node8);
// TransferManifestDeletedNode deletedNode8 = createDeletedNode(node8); TransferManifestDeletedNode deletedNode2 = createDeletedNode(node2);
// TransferManifestDeletedNode deletedNode2 = createDeletedNode(node2); TransferManifestDeletedNode deletedNode11 = createDeletedNode(node11);
// TransferManifestDeletedNode deletedNode11 = createDeletedNode(node11);
// endTransaction();
// endTransaction();
// this.setDefaultRollback(false);
// startNewTransaction(); startNewTransaction();
// try try
// { {
// String snapshot = createSnapshot(nodes); String snapshot = createSnapshot(nodes);
// log.debug(snapshot); log.debug(snapshot);
// receiver.saveSnapshot(transferId, new StringInputStream(snapshot, "UTF-8")); receiver.saveSnapshot(transferId, new StringInputStream(snapshot, "UTF-8"));
//
// for (TransferManifestNode node : nodes) for (TransferManifestNode node : nodes)
// { {
// receiver.saveContent(transferId, node.getUuid(), new ByteArrayInputStream(dummyContentBytes)); receiver.saveContent(transferId, node.getUuid(), new ByteArrayInputStream(dummyContentBytes));
// } }
// receiver.commit(transferId); receiver.commit(transferId);
//
// assertTrue(nodeService.getAspects(node1.getNodeRef()).contains(ContentModel.ASPECT_ATTACHABLE)); assertTrue(nodeService.getAspects(node1.getNodeRef()).contains(ContentModel.ASPECT_ATTACHABLE));
// assertFalse(nodeService.getSourceAssocs(node2.getNodeRef(), ContentModel.ASSOC_ATTACHMENTS).isEmpty()); assertFalse(nodeService.getSourceAssocs(node2.getNodeRef(), ContentModel.ASSOC_ATTACHMENTS).isEmpty());
// for (TransferManifestNode node : nodes) for (TransferManifestNode node : nodes)
// { {
// assertTrue(nodeService.exists(node.getNodeRef())); assertTrue(nodeService.exists(node.getNodeRef()));
// } }
// } }
// finally finally
// { {
// endTransaction(); endTransaction();
// } }
//
// startNewTransaction(); startNewTransaction();
// try try
// { {
// // Now delete nodes 8, 2, and 11 (2 and 11 are parent/child) // Now delete nodes 8, 2, and 11 (11 and 2 are parent/child)
// transferId = receiver.start(); transferId = receiver.start();
// String snapshot = createSnapshot(Arrays.asList(new TransferManifestNode[] { deletedNode8, deletedNode2, String snapshot = createSnapshot(Arrays.asList(new TransferManifestNode[] { deletedNode8, deletedNode2,
// deletedNode11 })); deletedNode11 }));
// receiver.saveSnapshot(transferId, new StringInputStream(snapshot, "UTF-8")); log.debug(snapshot);
// receiver.commit(transferId); receiver.saveSnapshot(transferId, new StringInputStream(snapshot, "UTF-8"));
// } receiver.commit(transferId);
// finally }
// { finally
// endTransaction(); {
// } endTransaction();
// }
// startNewTransaction();
// try startNewTransaction();
// { try
// assertTrue(nodeService.exists(deletedNode8.getNodeRef())); {
// assertTrue(nodeService.hasAspect(deletedNode8.getNodeRef(), ContentModel.ASPECT_ARCHIVED)); log.debug("Test success of transfer...");
// assertTrue(nodeService.exists(deletedNode2.getNodeRef())); TransferProgress progress = receiver.getProgressMonitor().getProgress(transferId);
// assertTrue(nodeService.hasAspect(deletedNode2.getNodeRef(), ContentModel.ASPECT_ARCHIVED)); assertEquals(TransferProgress.Status.COMPLETE, progress.getStatus());
// assertTrue(nodeService.exists(deletedNode11.getNodeRef()));
// assertTrue(nodeService.hasAspect(deletedNode11.getNodeRef(), ContentModel.ASPECT_ARCHIVED)); assertTrue(nodeService.exists(deletedNode8.getNodeRef()));
// TransferProgress progress = receiver.getProgressMonitor().getProgress(transferId); assertTrue(nodeService.hasAspect(deletedNode8.getNodeRef(), ContentModel.ASPECT_ARCHIVED));
// assertEquals(TransferProgress.Status.COMPLETE, progress.getStatus()); log.debug("Successfully tested existence of archive node: " + deletedNode8.getNodeRef());
// log.debug("Progress indication: " + progress.getCurrentPosition() + "/" + progress.getEndPosition());
// } assertTrue(nodeService.exists(deletedNode2.getNodeRef()));
// finally assertTrue(nodeService.hasAspect(deletedNode2.getNodeRef(), ContentModel.ASPECT_ARCHIVED));
// { log.debug("Successfully tested existence of archive node: " + deletedNode2.getNodeRef());
// endTransaction();
// } assertTrue(nodeService.exists(deletedNode11.getNodeRef()));
// System.out.println("Now try to restore orphan node 2."); assertTrue(nodeService.hasAspect(deletedNode11.getNodeRef(), ContentModel.ASPECT_ARCHIVED));
// log.debug("Successfully tested existence of archive node: " + deletedNode11.getNodeRef());
// String errorMsgId = null;
// startNewTransaction(); log.debug("Successfully tested existence of all archive nodes");
// try
// { log.debug("Testing existence of original node: " + node8.getNodeRef());
// // try to restore node 2. Expect an "orphan" failure, since its parent (node11) is deleted assertFalse(nodeService.exists(node8.getNodeRef()));
// transferId = receiver.start();
// String snapshot = createSnapshot(Arrays.asList(new TransferManifestNode[] { node2 })); log.debug("Testing existence of original node: " + node2.getNodeRef());
// log.debug(snapshot); assertFalse(nodeService.exists(node2.getNodeRef()));
// receiver.saveSnapshot(transferId, new StringInputStream(snapshot, "UTF-8"));
// receiver.saveContent(transferId, node2.getUuid(), new ByteArrayInputStream(dummyContentBytes)); log.debug("Testing existence of original node: " + node11.getNodeRef());
// try assertFalse(nodeService.exists(node11.getNodeRef()));
// {
// receiver.commit(transferId); log.debug("Successfully tested non-existence of all original nodes");
// TransferProgress progress = receiver.getStatus(transferId);
// while(!progress.isFinished()) log.debug("Progress indication: " + progress.getCurrentPosition() + "/" + progress.getEndPosition());
// { }
// System.out.println("waiting for commit"); finally
// Thread.sleep(1000); {
// } endTransaction();
// if(progress.getError() == null ) }
// { System.out.println("Now try to restore orphan node 2.");
// fail("Expected an exception!");
// } String errorMsgId = null;
// if(progress.getError() instanceof TransferException) startNewTransaction();
// { try
// TransferException te = (TransferException)progress.getError(); {
// errorMsgId = te.getMsgId(); // try to restore node 2. Expect an "orphan" failure, since its parent (node11) is deleted
// } transferId = receiver.start();
// } String snapshot = createSnapshot(Arrays.asList(new TransferManifestNode[] { node2 }));
// catch (TransferException ex) log.debug(snapshot);
// { receiver.saveSnapshot(transferId, new StringInputStream(snapshot, "UTF-8"));
// // Expected receiver.saveContent(transferId, node2.getUuid(), new ByteArrayInputStream(dummyContentBytes));
// errorMsgId = ex.getMsgId(); try
// } {
// receiver.commit(transferId);
// } fail("Expected an exception");
// catch (Exception ex) }
// { catch (TransferException ex)
// receiver.end(transferId); {
// throw ex; // Expected
// } errorMsgId = ex.getMsgId();
// finally }
// {
// endTransaction(); }
// } catch (Exception ex)
// {
// startNewTransaction(); receiver.end(transferId);
// try throw ex;
// { }
// TransferProgress progress = receiver.getProgressMonitor().getProgress(transferId); finally
// assertEquals(TransferProgress.Status.ERROR, progress.getStatus()); {
// log.debug("Progress indication: " + progress.getCurrentPosition() + "/" + progress.getEndPosition()); endTransaction();
// assertNotNull("Progress error", progress.getError()); }
// assertTrue(progress.getError() instanceof Exception);
// assertTrue(errorMsgId, errorMsgId.contains("orphan")); startNewTransaction();
// } try
// finally {
// { TransferProgress progress = receiver.getProgressMonitor().getProgress(transferId);
// endTransaction(); assertEquals(TransferProgress.Status.ERROR, progress.getStatus());
// } log.debug("Progress indication: " + progress.getCurrentPosition() + "/" + progress.getEndPosition());
// } assertNotNull("Progress error", progress.getError());
assertTrue(progress.getError() instanceof Exception);
assertTrue(errorMsgId, errorMsgId.contains("orphan"));
}
finally
{
endTransaction();
}
}
public void testAsyncCommit() throws Exception public void testAsyncCommit() throws Exception
{ {
@@ -710,13 +776,8 @@ public class RepoTransferReceiverImplTest extends BaseAlfrescoSpringTest
/** /**
* Get guest home * Get guest home
*/ */
String guestHomeQuery = "/app:company_home/app:guest_home";
ResultSet guestHomeResult = searchService.query(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, SearchService.LANGUAGE_XPATH, guestHomeQuery);
assertEquals("", 1, guestHomeResult.length());
NodeRef guestHome = guestHomeResult.getNodeRef(0);
NodeRef parentFolder = guestHome; NodeRef parentFolder = guestHome;
// NodeRef parentFolder = receiver.getTempFolder(transferId);
String nodeName = uuid + ".testnode" + getNameSuffix(); String nodeName = uuid + ".testnode" + getNameSuffix();
List<ChildAssociationRef> parents = new ArrayList<ChildAssociationRef>(); List<ChildAssociationRef> parents = new ArrayList<ChildAssociationRef>();
@@ -755,7 +816,6 @@ public class RepoTransferReceiverImplTest extends BaseAlfrescoSpringTest
assertEquals("", 1, guestHomeResult.length()); assertEquals("", 1, guestHomeResult.length());
NodeRef guestHome = guestHomeResult.getNodeRef(0); NodeRef guestHome = guestHomeResult.getNodeRef(0);
NodeRef parentFolder = guestHome; NodeRef parentFolder = guestHome;
//NodeRef parentFolder = receiver.getTempFolder(transferId);
String nodeName = uuid + ".folder" + getNameSuffix(); String nodeName = uuid + ".folder" + getNameSuffix();