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

Merged HEAD-BUG-FIX (4.3/Cloud) to HEAD (4.3/Cloud)

Browse Source 
65781: Created ACE-1249: Fix HazelcastLockStoreTxTest.testReadsWhenNoTransaction


git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@66274 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
Alan Davis
2014-04-02 22:20:17 +00:00
parent 3caceb54e3
commit d9de96b496
1 changed files with 105 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

212
source/test-java/org/alfresco/repo/lock/mem/AbstractLockStoreTxTest.java
View File

@@ -19,8 +19,6 @@
package org.alfresco.repo.lock.mem; package org.alfresco.repo.lock.mem;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull; import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail; import static org.junit.Assert.fail;
@@ -41,7 +39,6 @@ import org.junit.BeforeClass;
import org.junit.Test; import org.junit.Test;
import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContext;
import org.springframework.dao.ConcurrencyFailureException; import org.springframework.dao.ConcurrencyFailureException;
import org.springframework.transaction.support.TransactionSynchronizationManager;
/** /**
* Integration tests that check transaction related functionality of {@link LockStore} implementations. * Integration tests that check transaction related functionality of {@link LockStore} implementations.
@@ -202,110 +199,111 @@ public abstract class AbstractLockStoreTxTest<T extends LockStore>
} }
} }
// @Test - only run by HazelcastLockStoreTxTest - fails a lot in HazelcastLockStoreTxTest // - only run by HazelcastLockStoreTxTest - fails a lot in HazelcastLockStoreTxTest
public void testReadsWhenNoTransaction() throws NotSupportedException, SystemException // @Test
{ // public void testReadsWhenNoTransaction() throws NotSupportedException, SystemException
final NodeRef nodeRef = new NodeRef("workspace://SpacesStore/UUID-1"); // {
final NodeRef nodeRef2 = new NodeRef("workspace://SpacesStore/UUID-2"); // final NodeRef nodeRef = new NodeRef("workspace://SpacesStore/UUID-1");
Date now = new Date(); // final NodeRef nodeRef2 = new NodeRef("workspace://SpacesStore/UUID-2");
Date expires = new Date(now.getTime() + 180000); // Date now = new Date();
final LockState lockState1 = LockState.createLock(nodeRef, LockType.WRITE_LOCK, // Date expires = new Date(now.getTime() + 180000);
"jbloggs", expires, Lifetime.EPHEMERAL, null); // final LockState lockState1 = LockState.createLock(nodeRef, LockType.WRITE_LOCK,
// "jbloggs", expires, Lifetime.EPHEMERAL, null);
//
assertFalse("Transaction present, but should not be. Leak?", //
TransactionSynchronizationManager.isSynchronizationActive()); // assertFalse("Transaction present, but should not be. Leak?",
// TransactionSynchronizationManager.isSynchronizationActive());
Thread thread2 = new Thread("Thread2") //
{ // Thread thread2 = new Thread("Thread2")
@Override // {
public void run() // @Override
{ // public void run()
assertFalse("Transaction present, but should not be. Leak?", // {
TransactionSynchronizationManager.isSynchronizationActive()); // assertFalse("Transaction present, but should not be. Leak?",
// TransactionSynchronizationManager.isSynchronizationActive());
Object main = AbstractLockStoreTxTest.this; //
try // Object main = AbstractLockStoreTxTest.this;
{ // try
// Thread2 read lock state // {
LockState lockState = lockStore.get(nodeRef); // // Thread2 read lock state
assertEquals("jbloggs", lockState.getOwner()); // LockState lockState = lockStore.get(nodeRef);
assertEquals(Lifetime.EPHEMERAL, lockState.getLifetime()); // assertEquals("jbloggs", lockState.getOwner());
// assertEquals(Lifetime.EPHEMERAL, lockState.getLifetime());
// Wait, while Thread1 changes the lock state //
passControl(this, main); // // Wait, while Thread1 changes the lock state
// passControl(this, main);
// assert Thread2 sees the updated state //
lockState = lockStore.get(nodeRef); // // assert Thread2 sees the updated state
assertEquals("another", lockState.getOwner()); // lockState = lockStore.get(nodeRef);
// assertEquals("another", lockState.getOwner());
// Thread2 sets lock state B //
AuthenticationUtil.setFullyAuthenticatedUser("another"); // Current lock owner // // Thread2 sets lock state B
lockStore.set(nodeRef, LockState.createUnlocked(nodeRef)); // AuthenticationUtil.setFullyAuthenticatedUser("another"); // Current lock owner
// lockStore.set(nodeRef, LockState.createUnlocked(nodeRef));
// Check it is still visible for this thread //
lockState = lockStore.get(nodeRef); // // Check it is still visible for this thread
assertFalse(lockState.isLockInfo()); // lockState = lockStore.get(nodeRef);
assertNull(lockState.getOwner()); // assertFalse(lockState.isLockInfo());
// assertNull(lockState.getOwner());
// Wait, while Thread1 checks initial LockState value for nodeRef2 (null) //
passControl(this, main); // // Wait, while Thread1 checks initial LockState value for nodeRef2 (null)
// passControl(this, main);
// Thread2 sets a value, already seen as null by Thread1 - the update will be seen by Thread1 //
lockStore.set(nodeRef2, LockState.createLock(nodeRef2, LockType.WRITE_LOCK, // // Thread2 sets a value, already seen as null by Thread1 - the update will be seen by Thread1
"not-null-lockstate", null, Lifetime.EPHEMERAL, null)); // lockStore.set(nodeRef2, LockState.createLock(nodeRef2, LockType.WRITE_LOCK,
} // "not-null-lockstate", null, Lifetime.EPHEMERAL, null));
finally // }
{ // finally
// Stop 'main' from waiting // {
synchronized(main) // // Stop 'main' from waiting
{ // synchronized(main)
main.notifyAll(); // {
} // main.notifyAll();
} // }
} // }
}; // }
// };
//
// Thread1 set lock state 1 //
lockStore.set(nodeRef, lockState1); // // Thread1 set lock state 1
// lockStore.set(nodeRef, lockState1);
// Wait while Thread2 reads and checks the LockState //
thread2.setDaemon(true); // // Wait while Thread2 reads and checks the LockState
thread2.start(); // thread2.setDaemon(true);
passControl(this, thread2); // thread2.start();
// passControl(this, thread2);
// Thread1 sets different lock state //
AuthenticationUtil.setFullyAuthenticatedUser("jbloggs"); // Current lock owner needed to change lock // // Thread1 sets different lock state
final LockState lockState2 = LockState.createWithOwner(lockState1, "another"); // AuthenticationUtil.setFullyAuthenticatedUser("jbloggs"); // Current lock owner needed to change lock
lockStore.set(nodeRef, lockState2); // final LockState lockState2 = LockState.createWithOwner(lockState1, "another");
// lockStore.set(nodeRef, lockState2);
// Wait while Thread2 reads the LockState again for nodeRef //
passControl(this, thread2); // // Wait while Thread2 reads the LockState again for nodeRef
// passControl(this, thread2);
// Thread2 has unlocked the node, we should see the result //
assertFalse("Node still locked, but shouldn't be", lockStore.get(nodeRef).isLockInfo()); // // Thread2 has unlocked the node, we should see the result
assertNull(lockStore.get(nodeRef).getOwner()); // assertFalse("Node still locked, but shouldn't be", lockStore.get(nodeRef).isLockInfo());
assertNull(lockStore.get(nodeRef).getExpires()); // assertNull(lockStore.get(nodeRef).getOwner());
// assertNull(lockStore.get(nodeRef).getExpires());
// Another update //
AuthenticationUtil.setFullyAuthenticatedUser("jbloggs"); // Current lock owner // // Another update
final LockState lockState3 = LockState.createWithOwner(lockState2, "bsmith"); // AuthenticationUtil.setFullyAuthenticatedUser("jbloggs"); // Current lock owner
lockStore.set(nodeRef, lockState3); // final LockState lockState3 = LockState.createWithOwner(lockState2, "bsmith");
// Check we can see the update. // lockStore.set(nodeRef, lockState3);
assertEquals("bsmith", lockStore.get(nodeRef).getOwner()); // // Check we can see the update.
// assertEquals("bsmith", lockStore.get(nodeRef).getOwner());
// Perform a read, that we know will retrieve a null value //
assertNull("Lock state should be null.", lockStore.get(nodeRef2)); // // Perform a read, that we know will retrieve a null value
// assertNull("Lock state should be null.", lockStore.get(nodeRef2));
// Wait while Thread2 populates the store with a value for nodeRef2 //
passControl(this, thread2); // // Wait while Thread2 populates the store with a value for nodeRef2
// passControl(this, thread2);
// Perform the read again - we should see Thread2's update //
assertNotNull("Lock state should NOT be null.", lockStore.get(nodeRef2)); // // Perform the read again - we should see Thread2's update
assertEquals("not-null-lockstate", lockStore.get(nodeRef2).getOwner()); // assertNotNull("Lock state should NOT be null.", lockStore.get(nodeRef2));
} // assertEquals("not-null-lockstate", lockStore.get(nodeRef2).getOwner());
// }
//
@Test @Test
public void testCannotSetLockWhenChangedByAnotherTx() throws NotSupportedException, SystemException public void testCannotSetLockWhenChangedByAnotherTx() throws NotSupportedException, SystemException
{ {