Test/db module tests

db/core/build.gradle

@@ -1,7 +1,20 @@
 dependencies {
-    api project(':types')
-    api project(':crypto')
+    api(project(':types')) {
+        exclude group: 'junit'
+    }
+
+    api(project(':crypto')) {
+        exclude group: 'junit'
+    }
 
     api "org.rocksdb:rocksdbjni"
     api "com.googlecode.concurrent-locks:concurrent-locks"
+
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.5.1'
+
+    test {
+        useJUnitPlatform {
+            excludeTags 'FIX'
+        }
+    }
 }

db/core/src/main/java/org/ethereum/beacon/db/flush/BufferSizeObserver.java

@@ -4,6 +4,9 @@
 import org.apache.logging.log4j.Logger;
 import org.ethereum.beacon.db.source.WriteBuffer;
 
+import javax.annotation.Nonnull;
+import java.util.Objects;
+
 /**
  * Flushing strategy that observes a size of given buffer and emits a flush whenever size limit is
  * exceeded.
@@ -19,13 +22,16 @@ public class BufferSizeObserver implements DatabaseFlusher {
   /** A limit of buffer size in bytes. */
   private final long bufferSizeLimit;
 
-  BufferSizeObserver(WriteBuffer buffer, WriteBuffer commitTrack, long bufferSizeLimit) {
+  BufferSizeObserver(@Nonnull WriteBuffer buffer, @Nonnull WriteBuffer commitTrack, long bufferSizeLimit) {
+    Objects.requireNonNull(buffer);
+    Objects.requireNonNull(commitTrack);
     this.buffer = buffer;
     this.commitTrack = commitTrack;
     this.bufferSizeLimit = bufferSizeLimit;
   }
 
-  public static <K, V> BufferSizeObserver create(WriteBuffer<K, V> buffer, long bufferSizeLimit) {
+  public static <K, V> BufferSizeObserver create(@Nonnull WriteBuffer<K, V> buffer, long bufferSizeLimit) {
+    Objects.requireNonNull(buffer);
     WriteBuffer<K, V> commitTrack = new WriteBuffer<>(buffer, false);
     return new BufferSizeObserver(buffer, commitTrack, bufferSizeLimit);
   }

db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java

@@ -0,0 +1,97 @@
+package org.ethereum.beacon.db;
+
+import org.ethereum.beacon.db.source.DataSource;
+import org.ethereum.beacon.db.util.FileUtil;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.rocksdb.RocksDBException;
+import tech.pegasys.artemis.util.bytes.BytesValue;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class DatabaseTest {
+
+  @Test
+  void testInvalidCreation() {
+    final Database database = Database.rocksDB("", 0);
+    assertThatThrownBy(() -> database.createStorage("test-db"))
+            .isInstanceOf(RuntimeException.class)
+            .hasCauseExactlyInstanceOf(RocksDBException.class);
+  }
+
+  @Test
+  void testInvalidCreationWithNull() {
+    assertThatThrownBy(() -> Database.rocksDB(null, 0)).isInstanceOf(NullPointerException.class);
+  }
+
+  @ParameterizedTest
+  @MethodSource("validArgumentsProvider")
+  void testValidCreation(String path, long bufferLimitsInBytes) throws IOException {
+    final Database database = Database.rocksDB(path, bufferLimitsInBytes);
+    final DataSource<BytesValue, BytesValue> storage = database.createStorage("test-db");
+    final Path directory = Paths.get(path);
+    assertThat(Files.exists(directory)).isTrue();
+
+    final BytesValue key = BytesValue.of(123);
+    final BytesValue value = BytesValue.of(1, 2, 3);
+    storage.put(key, value);
+    assertThat(storage.get(key)).isPresent().hasValue(value);
+
+    storage.remove(key);
+    assertThat(storage.get(key)).isNotPresent();
+    database.close();
+
+    FileUtil.removeRecursively("rocksdb");
+  }
+
+  private static Stream<Arguments> validArgumentsProvider() {
+    return Stream.of(
+            Arguments.of("rocksdb", 0),
+            Arguments.of("rocksdb2", Long.MAX_VALUE),
+            Arguments.of("rocksdb3", Long.MIN_VALUE));
+  }
+
+  @Test
+  void testCreateDifferentStoresForSameDb() throws IOException {
+    final Database database = Database.rocksDB("rocksdb", Long.MAX_VALUE);
+    final DataSource<BytesValue, BytesValue> s1 = database.createStorage("test-db");
+    final DataSource<BytesValue, BytesValue> s2 = database.createStorage("test-db2");
+    assertThat(Files.exists(Paths.get("rocksdb"))).isTrue();
+
+    s1.put(BytesValue.of(123), BytesValue.of(1, 2, 3));
+    s2.put(BytesValue.of(123), BytesValue.of(1, 2, 3));
+    database.commit();
+    database.close();
+
+    s1.remove(BytesValue.of(123));
+    s2.remove(BytesValue.of(123));
+    assertThatThrownBy(database::commit).isInstanceOf(Exception.class); //TODO: should not commit after close
+
+    FileUtil.removeRecursively("rocksdb");
+  }
+
+  @Test
+  void testCreateDuplicateStorage() throws IOException {
+    final Database database = Database.rocksDB("rocksdb", Long.MAX_VALUE);
+    final DataSource<BytesValue, BytesValue> s1 = database.createStorage("test-db");
+    final DataSource<BytesValue, BytesValue> s2 = database.createStorage("test-db");
+    assertThat(Files.exists(Paths.get("rocksdb"))).isTrue();
+
+    //TODO: how to test without casting
+    s1.put(BytesValue.of(123), BytesValue.of(1, 2, 3));
+    s2.put(BytesValue.of(123), BytesValue.of(1, 2, 3));
+    database.commit();
+    database.close();
+
+    FileUtil.removeRecursively("rocksdb");
+  }
+}

db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java

@@ -1,9 +1,15 @@
 package org.ethereum.beacon.db;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import org.ethereum.beacon.db.source.DataSource;
+import org.ethereum.beacon.db.source.StorageEngineSource;
+import org.ethereum.beacon.db.source.impl.MemSizeEvaluators;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import tech.pegasys.artemis.util.bytes.Bytes32;
+import tech.pegasys.artemis.util.bytes.BytesValue;
+import tech.pegasys.artemis.util.uint.UInt64;
 
+import javax.annotation.Nonnull;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
@@ -13,20 +19,15 @@
 import java.util.Optional;
 import java.util.Random;
 import java.util.Set;
-import javax.annotation.Nonnull;
-import org.ethereum.beacon.db.source.DataSource;
-import org.ethereum.beacon.db.source.StorageEngineSource;
-import org.ethereum.beacon.db.source.impl.MemSizeEvaluators;
-import org.junit.Ignore;
-import org.junit.Test;
-import tech.pegasys.artemis.util.bytes.Bytes32;
-import tech.pegasys.artemis.util.bytes.BytesValue;
-import tech.pegasys.artemis.util.uint.UInt64;
 
-public class EngineDrivenDatabaseTest {
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class EngineDrivenDatabaseTest {
 
   @Test
-  public void generalCasesAreCorrect() {
+  void generalCasesAreCorrect() {
     TestStorageSource engineSource = new TestStorageSource();
     EngineDrivenDatabase db = EngineDrivenDatabase.createWithInstantFlusher(engineSource);
 
@@ -36,21 +37,21 @@ public void generalCasesAreCorrect() {
     storage.put(wrap("TWO"), wrap("SECOND"));
 
     assertTrue(engineSource.source.isEmpty());
-    assertEquals(wrap("FIRST"), storage.get(wrap("ONE")).get());
-    assertEquals(wrap("SECOND"), storage.get(wrap("TWO")).get());
-    assertFalse(storage.get(wrap("THREE")).isPresent());
+    assertThat(wrap("FIRST")).isEqualTo(storage.get(wrap("ONE")).get());
+    assertThat(wrap("SECOND")).isEqualTo(storage.get(wrap("TWO")).get());
+    assertThat(storage.get(wrap("THREE"))).isNotPresent();
 
     db.commit();
 
-    assertFalse(db.getWriteBuffer().getCacheEntry(wrap("ONE")).isPresent());
-    assertFalse(db.getWriteBuffer().getCacheEntry(wrap("TWO")).isPresent());
-    assertEquals(0L, db.getWriteBuffer().evaluateSize());
+    assertThat(db.getWriteBuffer().getCacheEntry(wrap("ONE"))).isNotPresent();
+    assertThat(db.getWriteBuffer().getCacheEntry(wrap("TWO"))).isNotPresent();
+    assertThat(0L).isEqualTo(db.getWriteBuffer().evaluateSize());
 
     assertTrue(engineSource.source.containsValue(wrap("FIRST")));
     assertTrue(engineSource.source.containsValue(wrap("SECOND")));
-    assertEquals(wrap("FIRST"), storage.get(wrap("ONE")).get());
-    assertEquals(wrap("SECOND"), storage.get(wrap("TWO")).get());
-    assertFalse(storage.get(wrap("THREE")).isPresent());
+    assertThat(wrap("FIRST")).isEqualTo(storage.get(wrap("ONE")).get());
+    assertThat(wrap("SECOND")).isEqualTo(storage.get(wrap("TWO")).get());
+    assertThat(storage.get(wrap("THREE"))).isNotPresent();
 
     storage.remove(wrap("SECOND"));
     storage.put(wrap("THREE"), wrap("THIRD"));
@@ -60,23 +61,23 @@ public void generalCasesAreCorrect() {
     assertTrue(engineSource.source.containsValue(wrap("SECOND")));
     assertFalse(engineSource.source.containsValue(wrap("THIRD")));
 
-    assertEquals(wrap("FIRST"), storage.get(wrap("ONE")).get());
-    assertFalse(storage.get(wrap("TWO")).isPresent());
-    assertEquals(wrap("THIRD"), storage.get(wrap("THREE")).get());
+    assertThat(wrap("FIRST")).isEqualTo(storage.get(wrap("ONE")).get());
+    assertThat(storage.get(wrap("TWO"))).isNotPresent();
+    assertThat(wrap("THIRD")).isEqualTo(storage.get(wrap("THREE")).get());
 
     db.commit();
 
     assertTrue(engineSource.source.containsValue(wrap("FIRST")));
     assertFalse(engineSource.source.containsValue(wrap("SECOND")));
     assertTrue(engineSource.source.containsValue(wrap("THIRD")));
 
-    assertEquals(wrap("FIRST"), storage.get(wrap("ONE")).get());
-    assertFalse(storage.get(wrap("TWO")).isPresent());
-    assertEquals(wrap("THIRD"), storage.get(wrap("THREE")).get());
+    assertThat(wrap("FIRST")).isEqualTo(storage.get(wrap("ONE")).get());
+    assertThat(storage.get(wrap("TWO"))).isNotPresent();
+    assertThat(wrap("THIRD")).isEqualTo(storage.get(wrap("THREE")).get());
   }
 
   @Test
-  public void multipleStorageCase() {
+  void multipleStorageCase() {
     TestStorageSource engineSource = new TestStorageSource();
     EngineDrivenDatabase db = EngineDrivenDatabase.createWithInstantFlusher(engineSource);
 
@@ -90,39 +91,39 @@ public void multipleStorageCase() {
     dos.put(wrap("FOUR"), wrap("DOS_FOURTH"));
 
     db.commit();
-    assertEquals(wrap("FIRST"), uno.get(wrap("ONE")).get());
-    assertEquals(wrap("SECOND"), uno.get(wrap("TWO")).get());
-    assertEquals(wrap("SECOND"), dos.get(wrap("TWO")).get());
-    assertEquals(wrap("UNO_THIRD"), uno.get(wrap("THREE")).get());
-    assertEquals(wrap("DOS_FOURTH"), dos.get(wrap("FOUR")).get());
-    assertFalse(uno.get(wrap("FOUR")).isPresent());
-    assertFalse(dos.get(wrap("ONE")).isPresent());
-    assertFalse(dos.get(wrap("THREE")).isPresent());
+    assertThat(wrap("FIRST")).isEqualTo(uno.get(wrap("ONE")).get());
+    assertThat(wrap("SECOND")).isEqualTo(uno.get(wrap("TWO")).get());
+    assertThat(wrap("SECOND")).isEqualTo(dos.get(wrap("TWO")).get());
+    assertThat(wrap("UNO_THIRD")).isEqualTo(uno.get(wrap("THREE")).get());
+    assertThat(wrap("DOS_FOURTH")).isEqualTo(dos.get(wrap("FOUR")).get());
+    assertThat(uno.get(wrap("FOUR"))).isNotPresent();
+    assertThat(dos.get(wrap("ONE"))).isNotPresent();
+    assertThat(dos.get(wrap("THREE"))).isNotPresent();
 
     uno.remove(wrap("TWO"));
     dos.put(wrap("THREE"), wrap("DOS_THIRD"));
 
-    assertFalse(uno.get(wrap("TWO")).isPresent());
-    assertEquals(wrap("DOS_THIRD"), dos.get(wrap("THREE")).get());
-    assertEquals(wrap("UNO_THIRD"), uno.get(wrap("THREE")).get());
+    assertThat(uno.get(wrap("TWO"))).isNotPresent();
+    assertThat(wrap("DOS_THIRD")).isEqualTo(dos.get(wrap("THREE")).get());
+    assertThat(wrap("UNO_THIRD")).isEqualTo(uno.get(wrap("THREE")).get());
 
     db.commit();
-    assertFalse(uno.get(wrap("TWO")).isPresent());
-    assertEquals(wrap("DOS_THIRD"), dos.get(wrap("THREE")).get());
-    assertEquals(wrap("UNO_THIRD"), uno.get(wrap("THREE")).get());
+    assertThat(uno.get(wrap("TWO"))).isNotPresent();
+    assertThat(wrap("DOS_THIRD")).isEqualTo(dos.get(wrap("THREE")).get());
+    assertThat(wrap("UNO_THIRD")).isEqualTo(uno.get(wrap("THREE")).get());
 
     dos.remove(wrap("FOUR"));
     uno.put(wrap("FOUR"), wrap("UNO_FOURTH"));
-    assertEquals(wrap("UNO_FOURTH"), uno.get(wrap("FOUR")).get());
-    assertFalse(dos.get(wrap("FOUR")).isPresent());
+    assertThat(wrap("UNO_FOURTH")).isEqualTo(uno.get(wrap("FOUR")).get());
+    assertThat(dos.get(wrap("FOUR"))).isNotPresent();
 
     db.commit();
-    assertEquals(wrap("UNO_FOURTH"), uno.get(wrap("FOUR")).get());
-    assertFalse(dos.get(wrap("FOUR")).isPresent());
+    assertThat(wrap("UNO_FOURTH")).isEqualTo(uno.get(wrap("FOUR")).get());
+    assertThat(dos.get(wrap("FOUR"))).isNotPresent();
   }
 
   @Test
-  public void checkBufferSizeFlusher() {
+  void checkBufferSizeFlusher() {
     TestStorageSource engineSource = new TestStorageSource();
     EngineDrivenDatabase db = EngineDrivenDatabase.create(engineSource, 512);
 
@@ -142,29 +143,27 @@ public void checkBufferSizeFlusher() {
 
     // should be flushed now
     db.commit();
-    assertEquals(4, engineSource.source.size());
-    assertEquals(0L, db.getWriteBuffer().evaluateSize());
-    assertFalse(db.getWriteBuffer().getCacheEntry(wrap("ONE")).isPresent());
-    assertFalse(db.getWriteBuffer().getCacheEntry(wrap("TWO")).isPresent());
-    assertFalse(db.getWriteBuffer().getCacheEntry(wrap("THREE")).isPresent());
-    assertFalse(db.getWriteBuffer().getCacheEntry(wrap("FOUR")).isPresent());
+    assertThat(4).isEqualTo(engineSource.source.size());
+    assertThat(0L).isEqualTo(db.getWriteBuffer().evaluateSize());
+    assertThat(db.getWriteBuffer().getCacheEntry(wrap("ONE"))).isNotPresent();
+    assertThat(db.getWriteBuffer().getCacheEntry(wrap("TWO"))).isNotPresent();
+    assertThat(db.getWriteBuffer().getCacheEntry(wrap("THREE"))).isNotPresent();
+    assertThat(db.getWriteBuffer().getCacheEntry(wrap("FOUR"))).isNotPresent();
 
     storage.put(wrap("FIVE"), Bytes32.random(rnd));
     storage.put(wrap("SIX"), Bytes32.random(rnd));
-    assertEquals(
-        4 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd)),
-        db.getWriteBuffer().evaluateSize());
+      assertThat(4 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd)))
+              .isEqualTo(db.getWriteBuffer().evaluateSize());
 
     storage.remove(wrap("FIVE"));
 
-    assertEquals(
-        2 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd)),
-        db.getWriteBuffer().evaluateSize());
+      assertThat(2 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd)))
+              .isEqualTo(db.getWriteBuffer().evaluateSize());
   }
 
   @Test
-  @Ignore
-  public void checkWithConcurrentAccessTake1() throws InterruptedException {
+  @Disabled
+  void checkWithConcurrentAccessTake1() throws InterruptedException {
     TestStorageSource engineSource = new TestStorageSource();
     EngineDrivenDatabase db = EngineDrivenDatabase.createWithInstantFlusher(engineSource);
 
@@ -204,12 +203,12 @@ public void checkWithConcurrentAccessTake1() throws InterruptedException {
     Set<BytesValue> expectedValues = new HashSet<>(writtenToOne.values());
     expectedValues.addAll(writtenToTwo.values());
 
-    assertEquals(expectedValues, sourceValues);
+    assertThat(expectedValues).isEqualTo(sourceValues);
   }
 
   @Test
-  @Ignore
-  public void checkWithConcurrentAccessTake2() throws InterruptedException {
+  @Disabled
+  void checkWithConcurrentAccessTake2() throws InterruptedException {
     TestStorageSource engineSource = new TestStorageSource();
     EngineDrivenDatabase db = EngineDrivenDatabase.createWithInstantFlusher(engineSource);