@Test public void requestsAreIdempotentAfterBeingAcquired() { LockToken token = lockSynchronously(REQUEST_1, LOCK_A); LockToken duplicate = lockSynchronously(REQUEST_1, LOCK_A); assertThat(token).isEqualTo(duplicate); }
private void assertNotLocked(String lock) { LockToken token = lockSynchronously(UUID.randomUUID(), lock); assertTrue(service.unlock(token)); }
@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 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 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 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); }
@Test public void requestsAreIdempotentDuringAcquisitionPhase() { LockToken currentHolder = lockSynchronously(REQUEST_1, LOCK_A); AsyncResult<LockToken> tokenResult = lock(REQUEST_2, LOCK_A); AsyncResult<LockToken> duplicateResult = lock(REQUEST_2, LOCK_A); service.unlock(currentHolder); assertThat(tokenResult.isCompletedSuccessfully()).isTrue(); assertThat(duplicateResult.isCompletedSuccessfully()).isTrue(); assertThat(tokenResult.get()).isEqualTo(duplicateResult.get()); }
@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 @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 @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 locksCanBeRefreshed() { LockToken token = lockSynchronously(REQUEST_1, LOCK_A); assertTrue(service.refresh(token)); }
@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 public void cannotUnlockAfterUnlocking() { LockToken token = lockSynchronously(REQUEST_1, LOCK_A); service.unlock(token); assertFalse(service.unlock(token)); }
@Test public void cannotRefreshAfterUnlocking() { LockToken token = lockSynchronously(REQUEST_1, LOCK_A); service.unlock(token); assertFalse(service.refresh(token)); }
@Test public void canUnlockAfterRefreshing() { LockToken token = lockSynchronously(REQUEST_1, LOCK_A); service.refresh(token); assertTrue(service.unlock(token)); }
@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 canLockAndUnlock() { LockToken token = lockSynchronously(REQUEST_1, LOCK_A); assertLocked(LOCK_A); assertTrue(service.unlock(token)); assertNotLocked(LOCK_A); }
@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 @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); }