diff --git a/db/core/build.gradle b/db/core/build.gradle index 9d228310f..6ee6126af 100644 --- a/db/core/build.gradle +++ b/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' + } + } } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java new file mode 100644 index 000000000..179f9231a --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -0,0 +1,191 @@ +package org.ethereum.beacon.db; + +import org.ethereum.beacon.db.source.DataSource; +import org.ethereum.beacon.db.util.FileUtil; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +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.Paths; +import java.util.stream.Stream; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +class DatabaseTest { + + private static final String TEST_DB_NAME = "rocksdb"; + private static final BytesValue KEY = BytesValue.of(123); + private static final BytesValue VALUE = BytesValue.of(1, 2, 3); + + @BeforeEach + @AfterEach + void setUp() throws IOException { + FileUtil.removeRecursively(TEST_DB_NAME); + } + + @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); + } + + @Test + void testCreateNotClosedDatabase() { + final Database database = Database.rocksDB(TEST_DB_NAME, 0); + database.createStorage("test-db"); + + final Database newDatabase = Database.rocksDB(TEST_DB_NAME, 0); + assertThatThrownBy(() -> newDatabase.createStorage("test-db")) + .isInstanceOf(RuntimeException.class) + .hasCauseExactlyInstanceOf(RocksDBException.class); + + database.close(); + } + + @ParameterizedTest + @MethodSource("validArgumentsProvider") + void testValidCreation(String path, long bufferLimitsInBytes) throws IOException { + final Database database = Database.rocksDB(path, bufferLimitsInBytes); + final DataSource storage = database.createStorage("test-db"); + assertThat(Files.exists(Paths.get(path))).isTrue(); + + storage.put(KEY, VALUE); + assertThat(storage.get(KEY)).isPresent().hasValue(VALUE); + storage.remove(KEY); + assertThat(storage.get(KEY)).isNotPresent(); + + database.close(); + } + + private static Stream validArgumentsProvider() { + return Stream.of( + Arguments.of(TEST_DB_NAME, 0), + Arguments.of(TEST_DB_NAME, Long.MAX_VALUE), + Arguments.of(TEST_DB_NAME, Long.MIN_VALUE)); + } + + @Test + void testCommitAfterClose() { + final Database database = Database.rocksDB(TEST_DB_NAME, Long.MAX_VALUE); + final DataSource storage = database.createStorage("test-db"); + + storage.put(KEY, VALUE); + database.close(); + + //TODO: something should throw an Exception after close + assertThatThrownBy(() -> storage.remove(KEY)).isInstanceOf(Exception.class); + assertThatThrownBy(database::commit).isInstanceOf(Exception.class); + } + + @Test + void testCreateDuplicateStorage() { + final Database database = Database.rocksDB(TEST_DB_NAME, Long.MAX_VALUE); + final DataSource s1 = database.createStorage("test-db"); + final DataSource s2 = database.createStorage("test-db"); + + s1.put(KEY, VALUE); + assertThat(s1.get(KEY)).isPresent().hasValue(VALUE); + assertThat(s1.get(KEY)).isEqualTo(s2.get(KEY)); + + s2.put(KEY, BytesValue.of(3, 2, 1)); + assertThat(s2.get(KEY)).isPresent().hasValue(BytesValue.of(3, 2, 1)); + assertThat(s1.get(KEY)).isNotEqualTo(VALUE); + assertThat(s1.get(KEY)).isEqualTo(s2.get(KEY)); + + s1.remove(KEY); + assertThat(s1.get(KEY)).isNotPresent(); + assertThat(s2.get(KEY)).isNotPresent(); + + database.close(); + } + + @Test + void testCreateDifferentStorage() { + final Database database = Database.rocksDB(TEST_DB_NAME, Long.MAX_VALUE); + final DataSource s1 = database.createStorage("test-db"); + final DataSource s2 = database.createStorage("test-db2"); + + s1.put(KEY, VALUE); + assertThat(s1.get(KEY)).isPresent().hasValue(VALUE); + assertThat(s2.get(KEY)).isNotPresent(); + + final BytesValue s2Value = BytesValue.of(3, 2, 1); + s2.put(KEY, s2Value); + assertThat(s2.get(KEY)).isPresent().hasValue(s2Value); + assertThat(s1.get(KEY)).isNotEqualTo(s2Value); + + s1.remove(KEY); + assertThat(s1.get(KEY)).isNotPresent(); + assertThat(s2.get(KEY)).isPresent().hasValue(s2Value); + + database.close(); + } + + @Test + void testCreateDifferentDatabase_SameStorage() throws IOException { + final Database db1 = Database.rocksDB(TEST_DB_NAME, Long.MAX_VALUE); + final DataSource s1 = db1.createStorage("test-db"); + + final Database db2 = Database.rocksDB("rocksdb2", Long.MAX_VALUE); + final DataSource s2 = db2.createStorage("test-db2"); + + s1.put(KEY, VALUE); + assertThat(s1.get(KEY)).isPresent().hasValue(VALUE); + assertThat(s2.get(KEY)).isNotPresent(); + + final BytesValue s2Value = BytesValue.of(3, 2, 1); + s2.put(KEY, s2Value); + assertThat(s2.get(KEY)).isPresent().hasValue(s2Value); + assertThat(s1.get(KEY)).isNotEqualTo(s2Value); + + s1.remove(KEY); + assertThat(s1.get(KEY)).isNotPresent(); + assertThat(s2.get(KEY)).isPresent().hasValue(s2Value); + + db1.close(); + db2.close(); + FileUtil.removeRecursively("rocksdb2"); + } + + @Test + void testSavedDataAfterReopen() { + Database database = Database.rocksDB(TEST_DB_NAME, Long.MAX_VALUE); + DataSource storage = database.createStorage("test-db"); + storage.put(KEY, VALUE); + database.commit(); + database.close(); + + database = Database.rocksDB(TEST_DB_NAME, Long.MAX_VALUE); + storage = database.createStorage("test-db"); + assertThat(storage.get(KEY)).isPresent().hasValue(VALUE); + database.close(); + } + + @Test + void testNotSaveUncommittedDataAfterReopen() { + Database database = Database.rocksDB(TEST_DB_NAME, Long.MAX_VALUE); + DataSource storage = database.createStorage("test-db"); + storage.put(KEY, VALUE); + database.close(); + + database = Database.rocksDB(TEST_DB_NAME, Long.MAX_VALUE); + storage = database.createStorage("test-db"); + assertThat(storage.get(KEY)).isNotPresent(); //TODO: data were not committed before + database.close(); + } +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java index 28f27f043..e9273951a 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/EngineDrivenDatabaseTest.java +++ b/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,9 +61,9 @@ 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(); @@ -70,13 +71,13 @@ public void generalCasesAreCorrect() { 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 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); diff --git a/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java new file mode 100644 index 000000000..c217df6a5 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java @@ -0,0 +1,59 @@ +package org.ethereum.beacon.db; + +import org.ethereum.beacon.db.source.DataSource; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import tech.pegasys.artemis.util.bytes.BytesValue; + +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThat; + +class InMemoryDatabaseTest { + + @ParameterizedTest + @ValueSource(strings = {"TEST_KEY"}) + void testGetBackingDataSource(String param) { + final InMemoryDatabase database = new InMemoryDatabase(); + final DataSource dataSource = database.getBackingDataSource(); + final BytesValue key = BytesValue.wrap(param.getBytes()); + final BytesValue value = BytesValue.EMPTY; + dataSource.put(key, value); + + final Optional expected = dataSource.get(key); + assertThat(expected).isPresent().hasValue(value); + assertThat(database.getBackingDataSource().get(key)).isPresent().hasValue(expected.get()); + + dataSource.remove(key); + assertThat(dataSource.get(key)).isNotPresent(); + assertThat(database.getBackingDataSource().get(key)).isNotPresent(); + } + + @Test + void testPutGetRemove_DifferentDatabase() { + final InMemoryDatabase first = new InMemoryDatabase(); + final InMemoryDatabase second = new InMemoryDatabase(); + + final BytesValue key = BytesValue.of(123); + final BytesValue value = BytesValue.of(1, 2, 3); + + final DataSource firstDS = first.getBackingDataSource(); + final DataSource secondDS = second.getBackingDataSource(); + + firstDS.put(key, value); + assertThat(first.getBackingDataSource().get(key)).isPresent().hasValue(value); + assertThat(secondDS.get(key)).isNotPresent(); + + firstDS.put(key, value); + secondDS.put(key, value); + assertThat(first.getBackingDataSource().get(key)).isPresent().hasValue(value); + assertThat(second.getBackingDataSource().get(key)).isPresent().hasValue(value); + + firstDS.remove(key); + assertThat(first.getBackingDataSource().get(key)).isNotPresent(); + assertThat(second.getBackingDataSource().get(key)).isPresent().hasValue(value); + } + + //TODO: commit and close methods do nothing, is it ok? +} diff --git a/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java index 6cdccc574..cb4c196f4 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java @@ -1,26 +1,26 @@ package org.ethereum.beacon.db; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; - -import java.io.IOException; import org.ethereum.beacon.db.source.DataSource; import org.ethereum.beacon.db.util.FileUtil; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import tech.pegasys.artemis.util.bytes.BytesValue; -public class RocksDbDrivenDatabaseTest { +import java.io.IOException; + +import static org.assertj.core.api.Assertions.assertThat; + +class RocksDbDrivenDatabaseTest { - @After - @Before - public void cleanUp() throws IOException { + @AfterEach + @BeforeEach + void cleanUp() throws IOException { FileUtil.removeRecursively("test-db"); } @Test - public void basicOperations() { + void basicOperations() { Database db = Database.rocksDB("test-db", -1); DataSource uno = db.createStorage("uno"); @@ -33,42 +33,42 @@ public void basicOperations() { 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()); - assertFalse(uno.get(wrap("FOUR")).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(); + assertThat(uno.get(wrap("FOUR"))).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(); db.close(); } @Test - public void reopenWithoutFlush() { + void reopenWithoutFlush() { Database db = Database.rocksDB("test-db", -1); DataSource storage = db.createStorage("uno"); @@ -81,9 +81,9 @@ public void reopenWithoutFlush() { storage = db.createStorage("uno"); - assertEquals(wrap("FIRST"), storage.get(wrap("ONE")).get()); - assertEquals(wrap("SECOND"), storage.get(wrap("TWO")).get()); - assertEquals(wrap("THIRD"), storage.get(wrap("THREE")).get()); + assertThat(wrap("FIRST")).isEqualTo(storage.get(wrap("ONE")).get()); + assertThat(wrap("SECOND")).isEqualTo(storage.get(wrap("TWO")).get()); + assertThat(wrap("THIRD")).isEqualTo(storage.get(wrap("THREE")).get()); db.close(); } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java b/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java index ce9a837f5..2d662dc98 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/rocksdb/RocksDbSourceTest.java @@ -1,35 +1,35 @@ package org.ethereum.beacon.db.rocksdb; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; +import org.ethereum.beacon.db.util.FileUtil; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import tech.pegasys.artemis.util.bytes.BytesValue; import java.io.IOException; import java.nio.file.Paths; import java.util.HashMap; import java.util.Map; -import org.ethereum.beacon.db.util.FileUtil; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import tech.pegasys.artemis.util.bytes.BytesValue; -public class RocksDbSourceTest { +import static org.assertj.core.api.Assertions.assertThat; + +class RocksDbSourceTest { - @After - @Before - public void cleanUp() throws IOException { + @AfterEach + @BeforeEach + void cleanUp() throws IOException { FileUtil.removeRecursively("test-db"); } @Test - public void basicOperations() { + void basicOperations() { RocksDbSource rocksDb = new RocksDbSource(Paths.get("test-db")); rocksDb.open(); rocksDb.put(wrap("ONE"), wrap("FIRST")); - assertFalse(rocksDb.get(wrap("TWO")).isPresent()); - assertEquals(wrap("FIRST"), rocksDb.get(wrap("ONE")).get()); + assertThat(rocksDb.get(wrap("TWO"))).isNotPresent(); + assertThat(wrap("FIRST")).isEqualTo(rocksDb.get(wrap("ONE")).get()); Map batch = new HashMap<>(); batch.put(wrap("ONE"), null); @@ -39,22 +39,22 @@ public void basicOperations() { rocksDb.batchUpdate(batch); - assertFalse(rocksDb.get(wrap("ONE")).isPresent()); - assertEquals(wrap("SECOND"), rocksDb.get(wrap("TWO")).get()); - assertEquals(wrap("THIRD"), rocksDb.get(wrap("THREE")).get()); - assertEquals(wrap("FOURTH"), rocksDb.get(wrap("FOUR")).get()); + assertThat(rocksDb.get(wrap("ONE"))).isNotPresent(); + assertThat(wrap("SECOND")).isEqualTo(rocksDb.get(wrap("TWO")).get()); + assertThat(wrap("THIRD")).isEqualTo(rocksDb.get(wrap("THREE")).get()); + assertThat(wrap("FOURTH")).isEqualTo(rocksDb.get(wrap("FOUR")).get()); rocksDb.remove(wrap("THREE")); - assertFalse(rocksDb.get(wrap("THREE")).isPresent()); + assertThat(rocksDb.get(wrap("THREE"))).isNotPresent(); rocksDb.close(); rocksDb.open(); - assertFalse(rocksDb.get(wrap("ONE")).isPresent()); - assertEquals(wrap("SECOND"), rocksDb.get(wrap("TWO")).get()); - assertFalse(rocksDb.get(wrap("THREE")).isPresent()); - assertEquals(wrap("FOURTH"), rocksDb.get(wrap("FOUR")).get()); - assertFalse(rocksDb.get(wrap("FIVE")).isPresent()); + assertThat(rocksDb.get(wrap("ONE"))).isNotPresent(); + assertThat(wrap("SECOND")).isEqualTo(rocksDb.get(wrap("TWO")).get()); + assertThat(rocksDb.get(wrap("THREE"))).isNotPresent(); + assertThat(wrap("FOURTH")).isEqualTo(rocksDb.get(wrap("FOUR")).get()); + assertThat(rocksDb.get(wrap("FIVE"))).isNotPresent(); rocksDb.close(); } diff --git a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/MemSizeEvaluatorTest.java b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/MemSizeEvaluatorTest.java index 3a203e477..d5632d9bd 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/source/impl/MemSizeEvaluatorTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/source/impl/MemSizeEvaluatorTest.java @@ -1,16 +1,17 @@ package org.ethereum.beacon.db.source.impl; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; import tech.pegasys.artemis.util.bytes.BytesValue; -public class MemSizeEvaluatorTest { +import static org.assertj.core.api.Assertions.assertThat; + +class MemSizeEvaluatorTest { @Test - public void bytesValueEvaluator() { + void bytesValueEvaluator() { long evaluatedSize = MemSizeEvaluators.BytesValueEvaluator.apply(BytesValue.wrap(new byte[1000])); System.out.println("Evaluated size: " + evaluatedSize); - Assert.assertTrue(evaluatedSize > 1000); + assertThat(evaluatedSize).isGreaterThan(1000); } } diff --git a/test/build.gradle b/test/build.gradle index 6a5d5561b..761796a80 100644 --- a/test/build.gradle +++ b/test/build.gradle @@ -9,7 +9,9 @@ dependencies { testImplementation project(':consensus') testImplementation project(':core') testImplementation project(':start:config') - testImplementation project(':db:core') + testImplementation(project(':db:core')) { + exclude group: 'org.junit.jupiter' + } testImplementation project(':chain') testImplementation project(':start:simulator') testImplementation project(':util') @@ -35,4 +37,4 @@ task submodulesUpdate(type:Exec) { group 'Build Setup' } -test.dependsOn(submodulesUpdate) \ No newline at end of file +test.dependsOn(submodulesUpdate)