@Test public void canLockAndUnlock() { LockToken token = lockSynchronously(REQUEST_1, LOCK_A); assertLocked(LOCK_A); assertTrue(service.unlock(token)); assertNotLocked(LOCK_A); }
@Test @ShouldRetry public void timedOutRequestDoesNotHoldLocks() { LockToken lockBToken = lockSynchronously(REQUEST_1, LOCK_B); service.lock(REQUEST_2, descriptors(LOCK_A, LOCK_B), SHORT_TIMEOUT); waitForTimeout(SHORT_TIMEOUT); assertNotLocked(LOCK_A); service.unlock(lockBToken); assertNotLocked(LOCK_B); }
@Test public void outstandingRequestsReceiveNotCurrentLeaderExceptionOnClose() { lockSynchronously(REQUEST_1, LOCK_A); AsyncResult<LockToken> request2 = lock(REQUEST_2, LOCK_A); service.close(); assertThat(request2.isFailed()).isTrue(); assertThat(request2.getError()).isInstanceOf(NotCurrentLeaderException.class); }
@Test public void canLockAndUnlockMultipleLocks() { LockToken token = lockSynchronously(REQUEST_1, LOCK_A, LOCK_B, LOCK_C); assertTrue(service.unlock(token)); assertNotLocked(LOCK_A); assertNotLocked(LOCK_B); assertNotLocked(LOCK_C); }
@Test public void canWaitForMultipleLocks() { LockToken lockAHolder = lockSynchronously(REQUEST_1, LOCK_B, LOCK_C); AsyncResult<Void> waitResult = waitForLocks(REQUEST_2, LOCK_A, LOCK_B, LOCK_C); assertThat(waitResult.isComplete()).isFalse(); assertNotLocked(LOCK_A); service.unlock(lockAHolder); assertThat(waitResult.isCompletedSuccessfully()).isTrue(); assertNotLocked(LOCK_A); assertNotLocked(LOCK_C); }
@Test @ShouldRetry public void requestsAreIdempotentWithRespectToTimeout() { lockSynchronously(REQUEST_1, LOCK_A); service.lock(REQUEST_2, descriptors(LOCK_A), SHORT_TIMEOUT); AsyncResult<LockToken> duplicate = service.lock(REQUEST_2, descriptors(LOCK_A), LONG_TIMEOUT); waitForTimeout(SHORT_TIMEOUT); assertThat(duplicate.isTimedOut()).isTrue(); }
@Test public void waitForLocksRequestsAreIdempotent() { LockToken token = lockSynchronously(REQUEST_1, LOCK_A); AsyncResult<Void> request = service.waitForLocks(REQUEST_2, descriptors(LOCK_A), SHORT_TIMEOUT); AsyncResult<Void> duplicate = service.waitForLocks(REQUEST_2, descriptors(LOCK_A), SHORT_TIMEOUT); assertThat(request).isEqualTo(duplicate); service.unlock(token); assertThat(request.isCompletedSuccessfully()).isTrue(); assertThat(duplicate.isCompletedSuccessfully()).isTrue(); }
@Test public void requestsAreIdempotentAfterBeingAcquired() { LockToken token = lockSynchronously(REQUEST_1, LOCK_A); LockToken duplicate = lockSynchronously(REQUEST_1, LOCK_A); assertThat(token).isEqualTo(duplicate); }
private LockToken lockSynchronously(UUID requestId, String... locks) { return lock(requestId, locks).get(); }
private AsyncResult<LockToken> lock(UUID requestId, String... locks) { return service.lock(requestId, descriptors(locks), TIMEOUT); }
@Test @ShouldRetry public void waitForLocksRequestTimesOutWhenTimeoutPasses() { lockSynchronously(REQUEST_1, LOCK_A); AsyncResult<Void> result = service.waitForLocks(REQUEST_2, descriptors(LOCK_A), SHORT_TIMEOUT); assertThat(result.isTimedOut()).isFalse(); waitForTimeout(SHORT_TIMEOUT); assertThat(result.isTimedOut()).isTrue(); }
@Test public void canWaitForLock() { LockToken lockAHolder = lockSynchronously(REQUEST_1, LOCK_A); AsyncResult<Void> waitResult = waitForLocks(REQUEST_2, LOCK_A); assertThat(waitResult.isComplete()).isFalse(); service.unlock(lockAHolder); assertThat(waitResult.isCompletedSuccessfully()).isTrue(); assertNotLocked(LOCK_A); }
private void assertNotLocked(String lock) { LockToken token = lockSynchronously(UUID.randomUUID(), lock); assertTrue(service.unlock(token)); }
private void assertLocked(String... locks) { AsyncResult<LockToken> result = lock(UUID.randomUUID(), locks); assertFalse(result.isComplete()); result.map(token -> service.unlock(token)); }
private AsyncResult<Void> waitForLocks(UUID requestId, String... locks) { return service.waitForLocks(requestId, descriptors(locks), TIMEOUT); }
@Test @ShouldRetry public void lockRequestTimesOutWhenTimeoutPasses() { lockSynchronously(REQUEST_1, LOCK_A); AsyncResult<LockToken> result = service.lock(REQUEST_2, descriptors(LOCK_A), SHORT_TIMEOUT); assertThat(result.isTimedOut()).isFalse(); waitForTimeout(SHORT_TIMEOUT); assertThat(result.isTimedOut()).isTrue(); }
@Test public void waitingRequestGetsTheLockAfterItIsUnlocked() { LockToken request1 = lockSynchronously(REQUEST_1, LOCK_A); AsyncResult<LockToken> request2 = lock(REQUEST_2, LOCK_A); assertThat(request2.isComplete()).isFalse(); service.unlock(request1); assertThat(request2.isCompletedSuccessfully()).isTrue(); }
@Test public void locksCanBeRefreshed() { LockToken token = lockSynchronously(REQUEST_1, LOCK_A); assertTrue(service.refresh(token)); }
@Test public void waitingRequestGetsTheLockAfterItIsUnlockedWithMultipleLocks() { LockToken request1 = lockSynchronously(REQUEST_1, LOCK_A, LOCK_C); AsyncResult<LockToken> request2 = lock(REQUEST_2, LOCK_A, LOCK_B, LOCK_C, LOCK_D); assertThat(request2.isComplete()).isFalse(); service.unlock(request1); assertThat(request2.isCompletedSuccessfully()).isTrue(); }
@Test public void cannotUnlockAfterUnlocking() { LockToken token = lockSynchronously(REQUEST_1, LOCK_A); service.unlock(token); assertFalse(service.unlock(token)); }