From 08825959f0ff43c2de38a5f1c4d4b102aec75bff Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Tue, 17 Sep 2019 18:44:14 +0300 Subject: [PATCH 01/16] test: add junit5 into gradle --- db/core/build.gradle | 17 ++++++++++++++++- test/src/test/resources/eth2.0-spec-tests | 2 +- 2 files changed, 17 insertions(+), 2 deletions(-) diff --git a/db/core/build.gradle b/db/core/build.gradle index 9d228310f..4e763afb7 100644 --- a/db/core/build.gradle +++ b/db/core/build.gradle @@ -1,7 +1,22 @@ dependencies { - api project(':types') + api(project(':types')) { + exclude group: 'junit' + } + api project(':crypto') api "org.rocksdb:rocksdbjni" api "com.googlecode.concurrent-locks:concurrent-locks" + + testImplementation 'org.junit.jupiter:junit-jupiter:5.5.1' + + test { + useJUnitPlatform { + excludeTags 'FIX' + } + } +} + +configurations { + testImplementation.exclude group: 'junit', module: 'junit' } diff --git a/test/src/test/resources/eth2.0-spec-tests b/test/src/test/resources/eth2.0-spec-tests index ae6dd9011..aaa1673f5 160000 --- a/test/src/test/resources/eth2.0-spec-tests +++ b/test/src/test/resources/eth2.0-spec-tests @@ -1 +1 @@ -Subproject commit ae6dd9011df05fab8c7e651c09cf9c940973bf81 +Subproject commit aaa1673f508103e11304833e0456e4149f880065 From ab80471770c89cd6fefbf2119e23f66e73777297 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Tue, 17 Sep 2019 18:48:09 +0300 Subject: [PATCH 02/16] test: replace junit4 with junit5 in java code --- .../beacon/db/EngineDrivenDatabaseTest.java | 133 ++++++++---------- .../beacon/db/RocksDbDrivenDatabaseTest.java | 68 +++++---- .../beacon/db/rocksdb/RocksDbSourceTest.java | 49 +++---- .../db/source/impl/MemSizeEvaluatorTest.java | 11 +- 4 files changed, 123 insertions(+), 138 deletions(-) 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..fc708f596 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,32 +1,21 @@ package org.ethereum.beacon.db; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -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.*; 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 org.junit.jupiter.api.*; +import tech.pegasys.artemis.util.bytes.*; import tech.pegasys.artemis.util.uint.UInt64; -public class EngineDrivenDatabaseTest { +import javax.annotation.Nonnull; +import java.util.*; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +class EngineDrivenDatabaseTest { @Test - public void generalCasesAreCorrect() { + void generalCasesAreCorrect() { TestStorageSource engineSource = new TestStorageSource(); EngineDrivenDatabase db = EngineDrivenDatabase.createWithInstantFlusher(engineSource); @@ -36,21 +25,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 +49,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 +59,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 +79,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 +131,29 @@ 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)), + assertThat( + 4 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd))).isEqualTo( db.getWriteBuffer().evaluateSize()); storage.remove(wrap("FIVE")); - assertEquals( - 2 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd)), + 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 +193,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/RocksDbDrivenDatabaseTest.java b/db/core/src/test/java/org/ethereum/beacon/db/RocksDbDrivenDatabaseTest.java index 6cdccc574..bf6577f56 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,24 @@ 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.*; 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 +31,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 +79,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..1bdbafe6c 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,32 @@ 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.*; +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; +import java.util.*; + +import static org.assertj.core.api.Assertions.assertThat; -public class RocksDbSourceTest { +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 +36,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); } } From 173a95ca3570f1b6f468b04b233c9a82cd3f244e Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Tue, 17 Sep 2019 19:15:34 +0300 Subject: [PATCH 03/16] test: db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest --- .../org/ethereum/beacon/db/DatabaseTest.java | 102 ++++++++++++++++++ 1 file changed, 102 insertions(+) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java 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..8b918e352 --- /dev/null +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -0,0 +1,102 @@ +package org.ethereum.beacon.db; + +import org.ethereum.beacon.db.source.DataSource; +import org.ethereum.beacon.db.source.impl.HashMapDataSource; +import org.junit.jupiter.api.Tag; +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 tech.pegasys.artemis.util.bytes.BytesValue; + +import java.nio.file.InvalidPathException; +import java.util.stream.Stream; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class DatabaseTest { + + @Tag("FIX") + @ParameterizedTest + @MethodSource("invalidArgumentsProvider") + void testInvalidCreation(String path, long bufferLimitsInBytes) { + assertThatThrownBy(() -> Database.rocksDB(path, bufferLimitsInBytes)).isInstanceOf(InvalidPathException.class); + } + + @Test + void testInvalidCreationWithNull() { + assertThatThrownBy(() -> Database.rocksDB(null, 0)).isInstanceOf(NullPointerException.class); + } + + private static Stream invalidArgumentsProvider() { + return Stream.of( + Arguments.of("null", 0), + Arguments.of("", 0), + Arguments.of("0123", 0) + ); + } + + @ParameterizedTest + @MethodSource("validArgumentsProvider") + void testValidCreation(String path, long bufferLimitsInBytes) { + final Database database = Database.rocksDB(path, bufferLimitsInBytes); + assertThat(database).isNotNull(); + } + + private static Stream validArgumentsProvider() { + return Stream.of( + Arguments.of("/tmp", 0), + Arguments.of("/tmp", Long.MAX_VALUE), + Arguments.of("/tmp", Long.MIN_VALUE) + ); + } + + + private static final String TEST_STORAGE_NAME = "TEST_STORAGE_NAME"; + + private boolean committed; + private boolean closed; + private String storageName; + + @Test + void testDatabaseCommitCloseCreateStorage() { + final DataSource dataSource = new HashMapDataSource<>(); + committed = false; + closed = false; + storageName = null; + + final Database db = new Database() { + @Override + public DataSource createStorage(String name) { + storageName = name; + return dataSource; + } + + @Override + public void commit() { + committed = true; + } + + @Override + public void close() { + closed = true; + } + }; + + final DataSource storage = db.createStorage(TEST_STORAGE_NAME); + assertThat(storage).isNotNull(); + assertThat(storage).isEqualTo(dataSource); + assertThat(storageName).isEqualTo(TEST_STORAGE_NAME); + + assertFalse(committed); + db.commit(); + assertTrue(committed); + + assertFalse(closed); + db.close(); + assertTrue(closed); + } +} From 01478a7e29510b49ff15b11e67c4e3f30f6d1108 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Tue, 17 Sep 2019 19:50:26 +0300 Subject: [PATCH 04/16] test: db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest --- .../java/org/ethereum/beacon/db/DatabaseTest.java | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) 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 index 8b918e352..99cc76c78 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -14,8 +14,6 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; class DatabaseTest { @@ -87,16 +85,15 @@ public void close() { }; final DataSource storage = db.createStorage(TEST_STORAGE_NAME); - assertThat(storage).isNotNull(); assertThat(storage).isEqualTo(dataSource); assertThat(storageName).isEqualTo(TEST_STORAGE_NAME); - assertFalse(committed); + assertThat(committed).isFalse(); db.commit(); - assertTrue(committed); + assertThat(committed).isTrue(); - assertFalse(closed); + assertThat(closed).isFalse(); db.close(); - assertTrue(closed); + assertThat(closed).isTrue(); } } From 0f07f8db215c9c4d633ae5e8d306983e6738a3cb Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 18 Sep 2019 14:10:16 +0300 Subject: [PATCH 05/16] test: add junit4 dependency into test module --- test/build.gradle | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/build.gradle b/test/build.gradle index 6a5d5561b..ddd5433c6 100644 --- a/test/build.gradle +++ b/test/build.gradle @@ -14,6 +14,7 @@ dependencies { testImplementation project(':start:simulator') testImplementation project(':util') testImplementation project(':pow:core') + testImplementation 'junit:junit' } task activateLfs(type:Exec) { @@ -35,4 +36,4 @@ task submodulesUpdate(type:Exec) { group 'Build Setup' } -test.dependsOn(submodulesUpdate) \ No newline at end of file +test.dependsOn(submodulesUpdate) From 2b935f66c078675b75eb110e258ac389b2d4a70d Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 18 Sep 2019 14:37:45 +0300 Subject: [PATCH 06/16] test: fix junit 4/5 dependencies --- db/core/build.gradle | 8 +++----- test/build.gradle | 5 +++-- 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/db/core/build.gradle b/db/core/build.gradle index 4e763afb7..6ee6126af 100644 --- a/db/core/build.gradle +++ b/db/core/build.gradle @@ -3,7 +3,9 @@ dependencies { exclude group: 'junit' } - api project(':crypto') + api(project(':crypto')) { + exclude group: 'junit' + } api "org.rocksdb:rocksdbjni" api "com.googlecode.concurrent-locks:concurrent-locks" @@ -16,7 +18,3 @@ dependencies { } } } - -configurations { - testImplementation.exclude group: 'junit', module: 'junit' -} diff --git a/test/build.gradle b/test/build.gradle index ddd5433c6..761796a80 100644 --- a/test/build.gradle +++ b/test/build.gradle @@ -9,12 +9,13 @@ 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') testImplementation project(':pow:core') - testImplementation 'junit:junit' } task activateLfs(type:Exec) { From 042ee95644a816565d53c21704bebc4cff0f54d0 Mon Sep 17 00:00:00 2001 From: Dmitrii Shmatko Date: Wed, 18 Sep 2019 15:50:48 +0300 Subject: [PATCH 07/16] Community tests updated to be in line with develop --- test/src/test/resources/eth2.0-spec-tests | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/src/test/resources/eth2.0-spec-tests b/test/src/test/resources/eth2.0-spec-tests index aaa1673f5..ae6dd9011 160000 --- a/test/src/test/resources/eth2.0-spec-tests +++ b/test/src/test/resources/eth2.0-spec-tests @@ -1 +1 @@ -Subproject commit aaa1673f508103e11304833e0456e4149f880065 +Subproject commit ae6dd9011df05fab8c7e651c09cf9c940973bf81 From aac0059ccaf00b4f115113a26f3c3cbb08c2ad15 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 18 Sep 2019 15:56:21 +0300 Subject: [PATCH 08/16] test: reformat code --- .../org/ethereum/beacon/db/DatabaseTest.java | 134 +++++++++--------- .../beacon/db/EngineDrivenDatabaseTest.java | 32 +++-- .../beacon/db/RocksDbDrivenDatabaseTest.java | 4 +- .../beacon/db/rocksdb/RocksDbSourceTest.java | 7 +- test/src/test/resources/eth2.0-spec-tests | 2 +- 5 files changed, 95 insertions(+), 84 deletions(-) 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 index 99cc76c78..f138da453 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -17,83 +17,79 @@ class DatabaseTest { - @Tag("FIX") - @ParameterizedTest - @MethodSource("invalidArgumentsProvider") - void testInvalidCreation(String path, long bufferLimitsInBytes) { - assertThatThrownBy(() -> Database.rocksDB(path, bufferLimitsInBytes)).isInstanceOf(InvalidPathException.class); - } - - @Test - void testInvalidCreationWithNull() { - assertThatThrownBy(() -> Database.rocksDB(null, 0)).isInstanceOf(NullPointerException.class); - } - - private static Stream invalidArgumentsProvider() { - return Stream.of( - Arguments.of("null", 0), - Arguments.of("", 0), - Arguments.of("0123", 0) - ); - } - - @ParameterizedTest - @MethodSource("validArgumentsProvider") - void testValidCreation(String path, long bufferLimitsInBytes) { - final Database database = Database.rocksDB(path, bufferLimitsInBytes); - assertThat(database).isNotNull(); - } - - private static Stream validArgumentsProvider() { - return Stream.of( - Arguments.of("/tmp", 0), - Arguments.of("/tmp", Long.MAX_VALUE), - Arguments.of("/tmp", Long.MIN_VALUE) - ); - } - - - private static final String TEST_STORAGE_NAME = "TEST_STORAGE_NAME"; - - private boolean committed; - private boolean closed; - private String storageName; - - @Test - void testDatabaseCommitCloseCreateStorage() { - final DataSource dataSource = new HashMapDataSource<>(); - committed = false; - closed = false; - storageName = null; - - final Database db = new Database() { - @Override - public DataSource createStorage(String name) { + @Tag("FIX") + @ParameterizedTest + @MethodSource("invalidArgumentsProvider") + void testInvalidCreation(String path, long bufferLimitsInBytes) { + assertThatThrownBy(() -> Database.rocksDB(path, bufferLimitsInBytes)) + .isInstanceOf(InvalidPathException.class); + } + + @Test + void testInvalidCreationWithNull() { + assertThatThrownBy(() -> Database.rocksDB(null, 0)).isInstanceOf(NullPointerException.class); + } + + private static Stream invalidArgumentsProvider() { + return Stream.of(Arguments.of("null", 0), Arguments.of("", 0), Arguments.of("0123", 0)); + } + + @ParameterizedTest + @MethodSource("validArgumentsProvider") + void testValidCreation(String path, long bufferLimitsInBytes) { + final Database database = Database.rocksDB(path, bufferLimitsInBytes); + assertThat(database).isNotNull(); + } + + private static Stream validArgumentsProvider() { + return Stream.of( + Arguments.of("/tmp", 0), + Arguments.of("/tmp", Long.MAX_VALUE), + Arguments.of("/tmp", Long.MIN_VALUE)); + } + + private static final String TEST_STORAGE_NAME = "TEST_STORAGE_NAME"; + + private boolean committed; + private boolean closed; + private String storageName; + + @Test + void testDatabaseCommitCloseCreateStorage() { + final DataSource dataSource = new HashMapDataSource<>(); + committed = false; + closed = false; + storageName = null; + + final Database db = + new Database() { + @Override + public DataSource createStorage(String name) { storageName = name; return dataSource; - } + } - @Override - public void commit() { + @Override + public void commit() { committed = true; - } + } - @Override - public void close() { + @Override + public void close() { closed = true; - } + } }; - final DataSource storage = db.createStorage(TEST_STORAGE_NAME); - assertThat(storage).isEqualTo(dataSource); - assertThat(storageName).isEqualTo(TEST_STORAGE_NAME); + final DataSource storage = db.createStorage(TEST_STORAGE_NAME); + assertThat(storage).isEqualTo(dataSource); + assertThat(storageName).isEqualTo(TEST_STORAGE_NAME); - assertThat(committed).isFalse(); - db.commit(); - assertThat(committed).isTrue(); + assertThat(committed).isFalse(); + db.commit(); + assertThat(committed).isTrue(); - assertThat(closed).isFalse(); - db.close(); - assertThat(closed).isTrue(); - } + assertThat(closed).isFalse(); + db.close(); + assertThat(closed).isTrue(); + } } 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 fc708f596..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,16 +1,28 @@ package org.ethereum.beacon.db; -import org.ethereum.beacon.db.source.*; +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.*; -import tech.pegasys.artemis.util.bytes.*; +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.*; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Random; +import java.util.Set; import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; class EngineDrivenDatabaseTest { @@ -140,15 +152,13 @@ void checkBufferSizeFlusher() { storage.put(wrap("FIVE"), Bytes32.random(rnd)); storage.put(wrap("SIX"), Bytes32.random(rnd)); - assertThat( - 4 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd))).isEqualTo( - db.getWriteBuffer().evaluateSize()); + assertThat(4 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd))) + .isEqualTo(db.getWriteBuffer().evaluateSize()); storage.remove(wrap("FIVE")); - assertThat( - 2 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd))).isEqualTo( - db.getWriteBuffer().evaluateSize()); + assertThat(2 * MemSizeEvaluators.BytesValueEvaluator.apply(Bytes32.random(rnd))) + .isEqualTo(db.getWriteBuffer().evaluateSize()); } @Test 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 bf6577f56..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 @@ -2,7 +2,9 @@ import org.ethereum.beacon.db.source.DataSource; import org.ethereum.beacon.db.util.FileUtil; -import org.junit.jupiter.api.*; +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; 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 1bdbafe6c..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,12 +1,15 @@ package org.ethereum.beacon.db.rocksdb; import org.ethereum.beacon.db.util.FileUtil; -import org.junit.jupiter.api.*; +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.*; +import java.util.HashMap; +import java.util.Map; import static org.assertj.core.api.Assertions.assertThat; diff --git a/test/src/test/resources/eth2.0-spec-tests b/test/src/test/resources/eth2.0-spec-tests index ae6dd9011..aaa1673f5 160000 --- a/test/src/test/resources/eth2.0-spec-tests +++ b/test/src/test/resources/eth2.0-spec-tests @@ -1 +1 @@ -Subproject commit ae6dd9011df05fab8c7e651c09cf9c940973bf81 +Subproject commit aaa1673f508103e11304833e0456e4149f880065 From 01e17cb8cb963b4f009793e7a2b9d0a84c1d9421 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 18 Sep 2019 16:41:56 +0300 Subject: [PATCH 09/16] test: update subproject --- test/src/test/resources/eth2.0-spec-tests | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/src/test/resources/eth2.0-spec-tests b/test/src/test/resources/eth2.0-spec-tests index aaa1673f5..ae6dd9011 160000 --- a/test/src/test/resources/eth2.0-spec-tests +++ b/test/src/test/resources/eth2.0-spec-tests @@ -1 +1 @@ -Subproject commit aaa1673f508103e11304833e0456e4149f880065 +Subproject commit ae6dd9011df05fab8c7e651c09cf9c940973bf81 From 4fdb06d52171510294be9332259e0e52742ad5f2 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 18 Sep 2019 20:47:37 +0300 Subject: [PATCH 10/16] test: fix DatabaseTest after code review --- .../org/ethereum/beacon/db/DatabaseTest.java | 78 +++++-------------- 1 file changed, 19 insertions(+), 59 deletions(-) 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 index f138da453..d052febc4 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -1,15 +1,13 @@ package org.ethereum.beacon.db; -import org.ethereum.beacon.db.source.DataSource; -import org.ethereum.beacon.db.source.impl.HashMapDataSource; -import org.junit.jupiter.api.Tag; +import org.ethereum.beacon.db.rocksdb.RocksDbSource; 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.nio.file.InvalidPathException; import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThat; @@ -17,12 +15,18 @@ class DatabaseTest { - @Tag("FIX") @ParameterizedTest @MethodSource("invalidArgumentsProvider") - void testInvalidCreation(String path, long bufferLimitsInBytes) { - assertThatThrownBy(() -> Database.rocksDB(path, bufferLimitsInBytes)) - .isInstanceOf(InvalidPathException.class); + void testInvalidCreation() { + final EngineDrivenDatabase database = (EngineDrivenDatabase) Database.rocksDB("", 0); + final RocksDbSource upstream = (RocksDbSource) database.getWriteBuffer().getUpstream(); + assertThatThrownBy(upstream::open) + .isInstanceOf(RuntimeException.class) + .hasCauseExactlyInstanceOf(RocksDBException.class); + } + + private static Stream invalidArgumentsProvider() { + return Stream.of(Arguments.of("", 0), Arguments.of("0123", 0)); } @Test @@ -30,66 +34,22 @@ void testInvalidCreationWithNull() { assertThatThrownBy(() -> Database.rocksDB(null, 0)).isInstanceOf(NullPointerException.class); } - private static Stream invalidArgumentsProvider() { - return Stream.of(Arguments.of("null", 0), Arguments.of("", 0), Arguments.of("0123", 0)); - } - @ParameterizedTest @MethodSource("validArgumentsProvider") void testValidCreation(String path, long bufferLimitsInBytes) { - final Database database = Database.rocksDB(path, bufferLimitsInBytes); - assertThat(database).isNotNull(); + final EngineDrivenDatabase database = (EngineDrivenDatabase) Database.rocksDB(path, bufferLimitsInBytes); + final RocksDbSource upstream = (RocksDbSource) database.getWriteBuffer().getUpstream(); + upstream.open(); + upstream.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); + assertThat(database.getWriteBuffer().get(BytesValue.of(123))).isPresent().hasValue(BytesValue.of(1, 2, 3)); + upstream.close(); } private static Stream validArgumentsProvider() { return Stream.of( + Arguments.of("", 0), Arguments.of("/tmp", 0), Arguments.of("/tmp", Long.MAX_VALUE), Arguments.of("/tmp", Long.MIN_VALUE)); } - - private static final String TEST_STORAGE_NAME = "TEST_STORAGE_NAME"; - - private boolean committed; - private boolean closed; - private String storageName; - - @Test - void testDatabaseCommitCloseCreateStorage() { - final DataSource dataSource = new HashMapDataSource<>(); - committed = false; - closed = false; - storageName = null; - - final Database db = - new Database() { - @Override - public DataSource createStorage(String name) { - storageName = name; - return dataSource; - } - - @Override - public void commit() { - committed = true; - } - - @Override - public void close() { - closed = true; - } - }; - - final DataSource storage = db.createStorage(TEST_STORAGE_NAME); - assertThat(storage).isEqualTo(dataSource); - assertThat(storageName).isEqualTo(TEST_STORAGE_NAME); - - assertThat(committed).isFalse(); - db.commit(); - assertThat(committed).isTrue(); - - assertThat(closed).isFalse(); - db.close(); - assertThat(closed).isTrue(); - } } From 23994a6dcf92898fa1eaca49deb099c17289d9c9 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 18 Sep 2019 21:59:47 +0300 Subject: [PATCH 11/16] test: fix DatabaseTest after code review --- .../org/ethereum/beacon/db/DatabaseTest.java | 39 ++++++++----------- 1 file changed, 17 insertions(+), 22 deletions(-) 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 index d052febc4..3663f4eb0 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -1,6 +1,6 @@ package org.ethereum.beacon.db; -import org.ethereum.beacon.db.rocksdb.RocksDbSource; +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.Arguments; @@ -8,27 +8,23 @@ 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 { - @ParameterizedTest - @MethodSource("invalidArgumentsProvider") + @Test void testInvalidCreation() { - final EngineDrivenDatabase database = (EngineDrivenDatabase) Database.rocksDB("", 0); - final RocksDbSource upstream = (RocksDbSource) database.getWriteBuffer().getUpstream(); - assertThatThrownBy(upstream::open) + final Database database = Database.rocksDB("", 0); + assertThatThrownBy(() -> database.createStorage("test-db")) .isInstanceOf(RuntimeException.class) .hasCauseExactlyInstanceOf(RocksDBException.class); } - private static Stream invalidArgumentsProvider() { - return Stream.of(Arguments.of("", 0), Arguments.of("0123", 0)); - } - @Test void testInvalidCreationWithNull() { assertThatThrownBy(() -> Database.rocksDB(null, 0)).isInstanceOf(NullPointerException.class); @@ -36,20 +32,19 @@ void testInvalidCreationWithNull() { @ParameterizedTest @MethodSource("validArgumentsProvider") - void testValidCreation(String path, long bufferLimitsInBytes) { - final EngineDrivenDatabase database = (EngineDrivenDatabase) Database.rocksDB(path, bufferLimitsInBytes); - final RocksDbSource upstream = (RocksDbSource) database.getWriteBuffer().getUpstream(); - upstream.open(); - upstream.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); - assertThat(database.getWriteBuffer().get(BytesValue.of(123))).isPresent().hasValue(BytesValue.of(1, 2, 3)); - upstream.close(); + void testValidCreation(String path, long bufferLimitsInBytes) throws IOException { + final Database database = Database.rocksDB(path, bufferLimitsInBytes); + final DataSource storage = database.createStorage("test-db"); + storage.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); + database.commit(); + + Files.deleteIfExists(Paths.get(path)); } private static Stream validArgumentsProvider() { return Stream.of( - Arguments.of("", 0), - Arguments.of("/tmp", 0), - Arguments.of("/tmp", Long.MAX_VALUE), - Arguments.of("/tmp", Long.MIN_VALUE)); + Arguments.of("/tmp/rocksdb", 0), + Arguments.of("/tmp/rocksdb", 1), + Arguments.of("/tmp/rocksdb", -1)); } } From 29245fb2e1b20ac5ef1abb4c18eaec0630ca62e0 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 18 Sep 2019 22:22:17 +0300 Subject: [PATCH 12/16] test: delete directories --- .../org/ethereum/beacon/db/DatabaseTest.java | 32 ++++++++++++++----- 1 file changed, 24 insertions(+), 8 deletions(-) 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 index 3663f4eb0..801cecd07 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -1,18 +1,21 @@ 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.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.FileVisitResult; import java.nio.file.Files; +import java.nio.file.Path; import java.nio.file.Paths; +import java.nio.file.SimpleFileVisitor; +import java.nio.file.attribute.BasicFileAttributes; import java.util.stream.Stream; +import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; class DatabaseTest { @@ -34,17 +37,30 @@ void testInvalidCreationWithNull() { @MethodSource("validArgumentsProvider") void testValidCreation(String path, long bufferLimitsInBytes) throws IOException { final Database database = Database.rocksDB(path, bufferLimitsInBytes); - final DataSource storage = database.createStorage("test-db"); - storage.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); - database.commit(); + database.createStorage("test-db"); + final Path directory = Paths.get(path); + assertThat(Files.exists(directory)).isTrue(); - Files.deleteIfExists(Paths.get(path)); + Files.walkFileTree(directory, new SimpleFileVisitor() { + + @Override + public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { + Files.delete(file); + return FileVisitResult.CONTINUE; + } + + @Override + public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException { + Files.delete(dir); + return FileVisitResult.CONTINUE; + } + }); } private static Stream validArgumentsProvider() { return Stream.of( Arguments.of("/tmp/rocksdb", 0), - Arguments.of("/tmp/rocksdb", 1), - Arguments.of("/tmp/rocksdb", -1)); + Arguments.of("/tmp/rocksdb1", Long.MAX_VALUE), + Arguments.of("/tmp/rocksdb2", Long.MIN_VALUE)); } } From 355bc81db92bca4d6d3902d5b813e3c529fb894e Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Wed, 18 Sep 2019 22:28:00 +0300 Subject: [PATCH 13/16] test: add relative directories --- .../org/ethereum/beacon/db/DatabaseTest.java | 25 ++++--------------- 1 file changed, 5 insertions(+), 20 deletions(-) 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 index 801cecd07..99265d6a2 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -1,5 +1,6 @@ package org.ethereum.beacon.db; +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; @@ -7,12 +8,9 @@ import org.rocksdb.RocksDBException; import java.io.IOException; -import java.nio.file.FileVisitResult; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; -import java.nio.file.SimpleFileVisitor; -import java.nio.file.attribute.BasicFileAttributes; import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThat; @@ -41,26 +39,13 @@ void testValidCreation(String path, long bufferLimitsInBytes) throws IOException final Path directory = Paths.get(path); assertThat(Files.exists(directory)).isTrue(); - Files.walkFileTree(directory, new SimpleFileVisitor() { - - @Override - public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { - Files.delete(file); - return FileVisitResult.CONTINUE; - } - - @Override - public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException { - Files.delete(dir); - return FileVisitResult.CONTINUE; - } - }); + FileUtil.removeRecursively("rocksdb"); } private static Stream validArgumentsProvider() { return Stream.of( - Arguments.of("/tmp/rocksdb", 0), - Arguments.of("/tmp/rocksdb1", Long.MAX_VALUE), - Arguments.of("/tmp/rocksdb2", Long.MIN_VALUE)); + Arguments.of("rocksdb", 0), + Arguments.of("rocksdb2", Long.MAX_VALUE), + Arguments.of("rocksdb3", Long.MIN_VALUE)); } } From b2a818656b193c82d18958189e9079d802a25f32 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Thu, 19 Sep 2019 09:28:22 +0300 Subject: [PATCH 14/16] test: add additional test for Database --- .../org/ethereum/beacon/db/DatabaseTest.java | 45 ++++++++++++++++++- 1 file changed, 44 insertions(+), 1 deletion(-) 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 index 99265d6a2..033629359 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -1,11 +1,13 @@ 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; @@ -35,10 +37,17 @@ void testInvalidCreationWithNull() { @MethodSource("validArgumentsProvider") void testValidCreation(String path, long bufferLimitsInBytes) throws IOException { final Database database = Database.rocksDB(path, bufferLimitsInBytes); - database.createStorage("test-db"); + final DataSource storage = database.createStorage("test-db"); final Path directory = Paths.get(path); assertThat(Files.exists(directory)).isTrue(); + //TODO: how to test without casting + storage.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); + database.commit(); + storage.remove(BytesValue.of(123)); + database.commit(); + database.close(); + FileUtil.removeRecursively("rocksdb"); } @@ -48,4 +57,38 @@ private static Stream validArgumentsProvider() { 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 s1 = database.createStorage("test-db"); + final DataSource 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 s1 = database.createStorage("test-db"); + final DataSource 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"); + } } From b5757972661210bb3fff38a3fee3801f2eaaa177 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Thu, 19 Sep 2019 10:32:43 +0300 Subject: [PATCH 15/16] test: correct InMemoryDatabaseTest --- .../beacon/db/InMemoryDatabaseTest.java | 59 +++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 db/core/src/test/java/org/ethereum/beacon/db/InMemoryDatabaseTest.java 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? +} From 1cb4db6b8d509bcdd7a02f1eb090994632d980e3 Mon Sep 17 00:00:00 2001 From: Eugene Ustimenko Date: Fri, 20 Sep 2019 17:27:14 +0300 Subject: [PATCH 16/16] test: add Database tests --- .../org/ethereum/beacon/db/DatabaseTest.java | 161 ++++++++++++++---- 1 file changed, 129 insertions(+), 32 deletions(-) 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 index 033629359..179f9231a 100644 --- a/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java +++ b/db/core/src/test/java/org/ethereum/beacon/db/DatabaseTest.java @@ -2,6 +2,8 @@ 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; @@ -11,7 +13,6 @@ import java.io.IOException; import java.nio.file.Files; -import java.nio.file.Path; import java.nio.file.Paths; import java.util.stream.Stream; @@ -20,6 +21,16 @@ 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); @@ -33,62 +44,148 @@ 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"); - final Path directory = Paths.get(path); - assertThat(Files.exists(directory)).isTrue(); + assertThat(Files.exists(Paths.get(path))).isTrue(); - //TODO: how to test without casting - storage.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); - database.commit(); - storage.remove(BytesValue.of(123)); - database.commit(); - database.close(); + storage.put(KEY, VALUE); + assertThat(storage.get(KEY)).isPresent().hasValue(VALUE); + storage.remove(KEY); + assertThat(storage.get(KEY)).isNotPresent(); - FileUtil.removeRecursively("rocksdb"); + database.close(); } private static Stream validArgumentsProvider() { return Stream.of( - Arguments.of("rocksdb", 0), - Arguments.of("rocksdb2", Long.MAX_VALUE), - Arguments.of("rocksdb3", Long.MIN_VALUE)); + Arguments.of(TEST_DB_NAME, 0), + Arguments.of(TEST_DB_NAME, Long.MAX_VALUE), + Arguments.of(TEST_DB_NAME, Long.MIN_VALUE)); } @Test - void testCreateDifferentStoresForSameDb() throws IOException { - final Database database = Database.rocksDB("rocksdb", Long.MAX_VALUE); - final DataSource s1 = database.createStorage("test-db"); - final DataSource s2 = database.createStorage("test-db2"); - assertThat(Files.exists(Paths.get("rocksdb"))).isTrue(); + void testCommitAfterClose() { + final Database database = Database.rocksDB(TEST_DB_NAME, Long.MAX_VALUE); + final DataSource storage = database.createStorage("test-db"); - s1.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); - s2.put(BytesValue.of(123), BytesValue.of(1, 2, 3)); - database.commit(); + storage.put(KEY, VALUE); 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"); + //TODO: something should throw an Exception after close + assertThatThrownBy(() -> storage.remove(KEY)).isInstanceOf(Exception.class); + assertThatThrownBy(database::commit).isInstanceOf(Exception.class); } @Test - void testCreateDuplicateStorage() throws IOException { - final Database database = Database.rocksDB("rocksdb", Long.MAX_VALUE); + 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"); - 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)); + 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(); - FileUtil.removeRecursively("rocksdb"); + 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(); } }