public void testEmptyStateIsEmpty() { assertNull(target.getSnapshot()); assertEquals(V0, target.getCurrentVersion()); assertEquals(V0, target.getHashedVersion(0)); assertNull(target.getTransformedDelta(V0)); assertNull(target.getAppliedDelta(V0)); }
public void checkManyDeltasPersistFutureDone() throws Exception { appendDeltas(d1, d2, d3); Future<Void> future = target.persist(d3.getResultingVersion()); awaitPersistence(); assertTrue(future.isDone()); assertEquals(null, future.get()); assertEquals(d3.getResultingVersion(), target.getLastPersistedVersion()); }
public void testHashedVersionAccessibleOnDeltaBoundaries() throws Exception { appendDeltas(d1, d2, d3); assertEquals(V0, target.getHashedVersion(0)); assertEquals(d1.getResultingVersion(), target.getHashedVersion(2)); assertEquals(d2.getResultingVersion(), target.getHashedVersion(4)); assertEquals(d3.getResultingVersion(), target.getHashedVersion(5)); assertNull(target.getHashedVersion(1)); assertNull(target.getHashedVersion(3)); assertNull(target.getHashedVersion(6)); }
public void testCanPersistOnlySomeDeltas() throws Exception { appendDeltas(d1, d2, d3); Future<Void> future = target.persist(d2.getResultingVersion()); awaitPersistence(); assertTrue(future.isDone()); assertEquals(null, future.get()); assertEquals(d2.getResultingVersion(), target.getLastPersistedVersion()); future = target.persist(d3.getResultingVersion()); awaitPersistence(); assertTrue(future.isDone()); assertEquals(null, future.get()); assertEquals(d3.getResultingVersion(), target.getLastPersistedVersion()); }
public void testSingleDeltaHistoryAccessible() throws Exception { appendDeltas(d1); DeltaSequence transformedHistory = target.getTransformedDeltaHistory(V0, d1.getResultingVersion()); assertNotNull(transformedHistory); assertEquals(1, transformedHistory.size()); assertEquals(d1.transformed, transformedHistory.get(0)); Collection<ByteStringMessage<ProtocolAppliedWaveletDelta>> appliedHistory = target.getAppliedDeltaHistory(V0, d1.getResultingVersion()); assertNotNull(appliedHistory); assertEquals(1, appliedHistory.size()); assertEquals(d1.applied, Iterables.getOnlyElement(appliedHistory)); }
public void testDeltasAccesssibleByEndVersion() throws Exception { appendDeltas(d1, d2, d3); for (WaveletDeltaRecord d : Arrays.asList(d1, d2, d3)) { assertEquals(d.transformed, target.getTransformedDeltaByEndVersion(d.getResultingVersion())); assertEquals(d.applied, target.getAppliedDeltaByEndVersion(d.getResultingVersion())); } // Wrong hashes return null. assertNull( target.getTransformedDeltaByEndVersion( HashedVersion.unsigned(d1.getResultingVersion().getVersion()))); assertNull( target.getAppliedDeltaByEndVersion( HashedVersion.unsigned(d1.getResultingVersion().getVersion()))); }
public void testDeltaHistoryRequiresCorrectHash() throws Exception { appendDeltas(d1); // Wrong start hash. assertNull( target.getTransformedDeltaHistory(HashedVersion.unsigned(0), d1.getResultingVersion())); assertNull(target.getAppliedDeltaHistory(HashedVersion.unsigned(0), d1.getResultingVersion())); // Wrong end hash. assertNull( target.getTransformedDeltaHistory( V0, HashedVersion.unsigned(d1.getResultingVersion().getVersion()))); assertNull( target.getAppliedDeltaHistory( V0, HashedVersion.unsigned(d1.getResultingVersion().getVersion()))); }
public void testSnapshotMetadataReflectsDeltas() throws Exception { HashedVersion v2 = d1.getResultingVersion(); appendDeltas(d1); assertEquals(v2, target.getCurrentVersion()); ReadableWaveletData snapshot = target.getSnapshot(); assertEquals(AUTHOR, snapshot.getCreator()); assertEquals(v2, snapshot.getHashedVersion()); assertEquals(TS, snapshot.getCreationTime()); assertEquals(TS, snapshot.getLastModifiedTime()); assertEquals(2, snapshot.getVersion()); HashedVersion v4 = d2.getResultingVersion(); appendDeltas(d2); assertEquals(v4, target.getCurrentVersion()); snapshot = target.getSnapshot(); assertEquals(v4, snapshot.getHashedVersion()); assertEquals(4, snapshot.getVersion()); // Last-modified-time doesn't change due to unworthiness. }
/** * Checks that a request for the deltas spanning a contiguous sequence of delta facets produces * correct results. */ private void checkHistoryForDeltas(WaveletDeltaRecord... deltas) { HashedVersion beginVersion = deltas[0].appliedAtVersion; HashedVersion endVersion = deltas[deltas.length - 1].transformed.getResultingVersion(); { List<TransformedWaveletDelta> expected = Lists.newArrayListWithExpectedSize(deltas.length); for (WaveletDeltaRecord d : deltas) { expected.add(d.transformed); } assertEquals(expected, target.getTransformedDeltaHistory(beginVersion, endVersion)); } { List<ByteStringMessage<ProtocolAppliedWaveletDelta>> expected = Lists.newArrayListWithExpectedSize(deltas.length); for (WaveletDeltaRecord d : deltas) { expected.add(d.applied); } assertTrue( Iterables.elementsEqual( expected, target.getAppliedDeltaHistory(beginVersion, endVersion))); } }
public void testDeltasAccessibleByBeginVersion() throws Exception { appendDeltas(d1, d2, d3); assertEquals(d1.transformed, target.getTransformedDelta(V0)); assertEquals(d1.applied, target.getAppliedDelta(V0)); assertEquals(d2.transformed, target.getTransformedDelta(d1.getResultingVersion())); assertEquals(d2.applied, target.getAppliedDelta(d1.getResultingVersion())); assertEquals(d3.transformed, target.getTransformedDelta(d2.getResultingVersion())); assertEquals(d3.applied, target.getAppliedDelta(d2.getResultingVersion())); // Wrong hashes return null. assertNull(target.getTransformedDelta(HashedVersion.unsigned(0))); assertNull(target.getAppliedDelta(HashedVersion.unsigned(0))); }
public void testReportsWaveletName() { assertEquals(NAME, target.getWaveletName()); }
/** Applies a delta to the target. */ private void appendDeltas(WaveletDeltaRecord... deltas) throws InvalidProtocolBufferException, OperationException { for (WaveletDeltaRecord delta : deltas) { target.appendDelta(delta.appliedAtVersion, delta.transformed, delta.applied); } }