@Override public TimestampRange getFreshTimestamps(int numTimestampsRequested) { return timestampService.getFreshTimestamps(numTimestampsRequested); }
@Override public TimestampRange getFreshTimestamps(int numTimestampsRequested) { return decoratedTimestamps.getFreshTimestamps(numTimestampsRequested); }
public TimestampRange getFreshTimestamps(int num) { return timestampService.getFreshTimestamps(num); }
@Override public TimestampRange getFreshTimestamps(@QueryParam("number") int numTimestampsRequested) { return timestampService.getFreshTimestamps(numTimestampsRequested); }
@Test(expected = IllegalArgumentException.class) public void shouldThrowIfRequestingZeroTimestamps() { timestampService.getFreshTimestamps(0); }
@Test(expected = IllegalArgumentException.class) public void shouldThrowIfRequestingNegativeNumbersOfTimestamps() { timestampService.getFreshTimestamps(-1); }
@Test public void timestampRangesAreReturnedInNonOverlappingOrder() { TimestampRange timestampRange1 = timestampService.getFreshTimestamps(10); TimestampRange timestampRange2 = timestampService.getFreshTimestamps(10); long firstUpperBound = timestampRange1.getUpperBound(); long secondLowerBound = timestampRange2.getLowerBound(); Assertions.assertThat(firstUpperBound).isLessThan(secondLowerBound); }
private static TimestampRange getFreshTimestampsFromDelegate(TimestampService timestampService, int timestamps) { if (timestamps == 1) { long timestamp = timestampService.getFreshTimestamp(); return TimestampRange.createInclusiveRange(timestamp, timestamp); } return timestampService.getFreshTimestamps(timestamps); }
@Test public void dynamicallySwitchesCorrectlyForMethodsWithArguments() throws Exception { proxy.getFreshTimestamps(10); verify(decorated, never()).getFreshTimestamps(10); verify(delegate, times(1)).getFreshTimestamps(10); atomicBoolean.set(true); proxy.getFreshTimestamps(20); verify(decorated, times(1)).getFreshTimestamps(20); verify(delegate, never()).getFreshTimestamps(20); atomicBoolean.set(false); proxy.getFreshTimestamps(30); verify(decorated, never()).getFreshTimestamps(30); verify(delegate, times(1)).getFreshTimestamps(30); } }
@Test public void canRequestMoreTimestampsThanAreAllocatedAtOnce() { for (int i = 0; i < ONE_MILLION / ONE_THOUSAND; i++) { timestampService.getFreshTimestamps(ONE_THOUSAND); } Assertions.assertThat(timestampService.getFreshTimestamp()).isGreaterThanOrEqualTo(ONE_MILLION + 1); }
@Test public void testGetFreshTimestampsDefersToTimestampService() { managedTimestampService.getFreshTimestamps(FORTY_TWO); verify(timestampService, times(1)).getFreshTimestamps(eq(FORTY_TWO)); }
@Test public void multipleFreshTimestampsRoutedToDecoratedService() { int numTimestamps = 42; decoratingService.getFreshTimestamps(numTimestamps); verify(decoratedTimestamps).getFreshTimestamps(numTimestamps); }
@Test public void coalescesRequestsTogether() { assertThat(requestBatches(1, 2, 3)).containsExactly(single(1), range(2, 4), range(4, 7)); verify(unbatchedDelegate).getFreshTimestamps(6); verifyNoMoreInteractions(unbatchedDelegate); }
@Test public void canRequestTimestampRangeWithGetFreshTimestamps() { int expectedNumTimestamps = 5; TimestampRange range = timestampService.getFreshTimestamps(expectedNumTimestamps); Assertions.assertThat((int) range.size()) .withFailMessage("Expected %d timestamps, got %d timestamps. (The returned range was: %d-%d)", expectedNumTimestamps, range.size(), range.getLowerBound(), range.getUpperBound()) .isGreaterThanOrEqualTo(1) .isLessThanOrEqualTo(expectedNumTimestamps); }
@Test public void freshTimestampsDelegatesToTimestampService() { int numTimestamps = 10; TimestampRange range = TimestampRange.createInclusiveRange(21L, 30L); when(timestampService.getFreshTimestamps(numTimestamps)).thenReturn(range); assertEquals(range, timelock.getFreshTimestamps(numTimestamps)); }
private void punch(TestAtlasDbServices services, TimestampService tss, Clock clock) { // this is a really hacky way of forcing a punch to test the datetime output Uninterruptibles.sleepUninterruptibly(2, TimeUnit.MILLISECONDS); long punchTs = tss.getFreshTimestamps(1000).getUpperBound(); PuncherStore puncherStore = KeyValueServicePuncherStore.create(services.getKeyValueService()); Puncher puncher = SimplePuncher.create(puncherStore, clock, Suppliers.ofInstance(AtlasDbConstants.DEFAULT_TRANSACTION_READ_TIMEOUT)); puncher.punch(punchTs); Uninterruptibles.sleepUninterruptibly(2, TimeUnit.MILLISECONDS); }
private void runAndVerifyCli(Verifier verifier) throws Exception { try (SingleBackendCliTestRunner runner = makeRunner(cliArgs.toArray(new String[0]))) { TestAtlasDbServices services = runner.connect(moduleFactory); LockService lockService = services.getLockService(); TimestampService tss = services.getTimestampService(); LockClient client = services.getTestLockClient(); Clock clock = GlobalClock.create(lockService); long prePunch = clock.getTimeMillis(); punch(services, tss, clock); long postPunch = clock.getTimeMillis(); long immutableTs = tss.getFreshTimestamp(); LockRequest request = LockRequest.builder(ImmutableSortedMap.of(lock, LockMode.WRITE)) .withLockedInVersionId(immutableTs) .doNotBlock() .build(); LockRefreshToken token = lockService.lock(client.getClientId(), request); long lastFreshTs = tss.getFreshTimestamps(1000).getUpperBound(); verifier.verify(runner, tss, immutableTs, prePunch, postPunch, lastFreshTs, true); lockService.unlock(token); lastFreshTs = tss.getFreshTimestamps(1000).getUpperBound(); // there are no locks so we now expect immutable to just be a fresh runner.freshCommand(); verifier.verify(runner, tss, immutableTs, prePunch, postPunch, lastFreshTs, false); } }
@Test public void timestampRangesAreReturnedInNonOverlappingOrder() { TimestampRange timestampRange1 = timestampService.getFreshTimestamps(10); TimestampRange timestampRange2 = timestampService.getFreshTimestamps(10); long firstUpperBound = timestampRange1.getUpperBound(); long secondLowerBound = timestampRange2.getLowerBound(); Assertions.assertThat(firstUpperBound).isLessThan(secondLowerBound); }
private static TimestampRange getFreshTimestampsFromDelegate(TimestampService timestampService, int timestamps) { if (timestamps == 1) { long timestamp = timestampService.getFreshTimestamp(); return TimestampRange.createInclusiveRange(timestamp, timestamp); } return timestampService.getFreshTimestamps(timestamps); }
@Test public void canRequestMoreTimestampsThanAreAllocatedAtOnce() { for (int i = 0; i < ONE_MILLION / ONE_THOUSAND; i++) { timestampService.getFreshTimestamps(ONE_THOUSAND); } Assertions.assertThat(timestampService.getFreshTimestamp()).isGreaterThanOrEqualTo(ONE_MILLION + 1); }