@Test public void testTimestampBoundStore() { long upperLimit1 = store.getUpperLimit(); long upperLimit2 = store.getUpperLimit(); Assert.assertEquals(upperLimit1, upperLimit2); store.storeUpperLimit(upperLimit2 + 1); long upperLimit3 = store.getUpperLimit(); Assert.assertEquals(upperLimit3, upperLimit2 + 1); } }
@Override public long getUpperLimit() { return delegate.getUpperLimit(); }
private void storeUpperLimit(long upperLimit) { DebugLogger.willStoreNewUpperLimit(upperLimit); store.storeUpperLimit(upperLimit); DebugLogger.didStoreNewUpperLimit(upperLimit); }
public PersistentUpperLimit(TimestampBoundStore boundStore) { this.store = boundStore; this.currentLimit = boundStore.getUpperLimit(); }
@Override public synchronized void storeUpperLimit(long limit) { failures.verifyWeShouldIssueMoreTimestamps(); throwIfInterrupted(); try { delegate.storeUpperLimit(limit); } catch (Throwable t) { throw failures.responseTo(t); } }
private long getBoundAfterTakingOutOneMillionTimestamps() { TimestampBoundStore timestampBoundStore = CassandraTimestampBoundStore.create(kv); long newLimit = timestampBoundStore.getUpperLimit() + ONE_MILLION; timestampBoundStore.storeUpperLimit(newLimit); return newLimit; } }
private void assertBoundEquals(long timestampBound) { assertThat(timestampBoundStore.getUpperLimit()).isEqualTo(timestampBound); }
@Test public void shouldNotChangeTheCurrentUpperLimitIfItFailsToPersist() { doThrow(RuntimeException.class).when(boundStore).storeUpperLimit(anyLong()); try { upperLimit.increaseToAtLeast(INITIAL_UPPER_LIMIT + 10); } catch (Exception e) { // We expect this to throw } assertThat(upperLimit.get(), is(INITIAL_UPPER_LIMIT)); }
@Test public void testBounds() { TimestampBoundStore ts = CassandraTimestampBoundStore.create(kv); long limit = ts.getUpperLimit(); ts.storeUpperLimit(limit + 10); Assert.assertEquals(limit + 10, ts.getUpperLimit()); ts.storeUpperLimit(limit + 20); Assert.assertEquals(limit + 20, ts.getUpperLimit()); ts.storeUpperLimit(limit + 30); Assert.assertEquals(limit + 30, ts.getUpperLimit()); }
private void assertWeCanReadTimestamp(long expectedTimestamp) { TimestampBoundStore timestampBoundStore = CassandraTimestampBoundStore.create(kv); assertThat(timestampBoundStore.getUpperLimit()).isEqualTo(expectedTimestamp); }
@Test public void shouldPersistAnIncreasedTimestamp() { upperLimit.increaseToAtLeast(TIMESTAMP); long biggerLimit = upperLimit.get() + 1000; upperLimit.increaseToAtLeast(biggerLimit); verify(boundStore).storeUpperLimit(biggerLimit + BUFFER); }
@Test public void resilientToMultipleStoreUpperLimitBeforeGet() { TimestampBoundStore ts = CassandraTimestampBoundStore.create(kv); long limit = ts.getUpperLimit(); ts.storeUpperLimit(limit + 10); ts.storeUpperLimit(limit + 20); Assert.assertEquals(limit + 20, ts.getUpperLimit()); }
@Before public void setup() { boundStore = mock(TimestampBoundStore.class); when(boundStore.getUpperLimit()).thenReturn(INITIAL_UPPER_LIMIT); upperLimit = new PersistentUpperLimit(boundStore); }
private void storeUpperLimit(long upperLimit) { DebugLogger.willStoreNewUpperLimit(upperLimit); store.storeUpperLimit(upperLimit); DebugLogger.didStoreNewUpperLimit(upperLimit); }
@Test public void canBackupAlreadyStoredBound() { timestampBoundStore.getUpperLimit(); timestampBoundStore.storeUpperLimit(TIMESTAMP_1); assertThat(backupRunner.backupExistingTimestamp()).isEqualTo(TIMESTAMP_1); }
@Test public void shouldStartWithTheCurrentStoredLimit() { when(boundStore.getUpperLimit()).thenReturn(TIMESTAMP); PersistentUpperLimit brandNewUpperLimit = new PersistentUpperLimit(boundStore); assertThat(brandNewUpperLimit.get(), is(TIMESTAMP)); }
@Override public synchronized void storeUpperLimit(long limit) { failures.verifyWeShouldIssueMoreTimestamps(); throwIfInterrupted(); try { delegate.storeUpperLimit(limit); } catch (Throwable t) { throw failures.responseTo(t); } }
@Test public void canBackupAndRestoreTimestampTable() { TimestampBoundStore timestampBoundStore = CassandraTimestampBoundStore.create(kv); long limit = timestampBoundStore.getUpperLimit(); timestampBoundStore.storeUpperLimit(limit + ONE_MILLION); invalidator.backupAndInvalidate(); invalidator.revalidateFromBackup(); assertThat(timestampBoundStore.getUpperLimit()).isEqualTo(limit + ONE_MILLION); }
@Test public void shouldOnlyMakeOneGetCallToTheUnderlyingStore() { upperLimit.get(); upperLimit.get(); verify(boundStore, times(1)).getUpperLimit(); }
@Test public void ignoresInvalidBackupIfDataAvailable() { timestampBoundStore.getUpperLimit(); timestampBoundStore.storeUpperLimit(TIMESTAMP_3); backupRunner.restoreFromBackup(); assertBoundEquals(TIMESTAMP_3); }