Improve SegmentedRaftLogRotationTest and reenable a test

neo4j · Jun 20, 2016 · b04896d · b04896d
1 parent a2a18a4
commit b04896d
Show file tree

Hide file tree

Showing 3 changed files with 46 additions and 59 deletions.
diff --git a/enterprise/core-edge/pom.xml b/enterprise/core-edge/pom.xml
@@ -96,6 +96,13 @@
         <type>test-jar</type>
         <scope>test</scope>
       </dependency>
+      <dependency>
+        <groupId>org.neo4j</groupId>
+        <artifactId>neo4j-common</artifactId>
+        <version>${project.version}</version>
+        <type>test-jar</type>
+        <scope>test</scope>
+      </dependency>
 
       <dependency>
           <groupId>org.neo4j</groupId>

diff --git a/...prise/core-edge/src/main/java/org/neo4j/coreedge/raft/log/segmented/SegmentedRaftLog.java b/...prise/core-edge/src/main/java/org/neo4j/coreedge/raft/log/segmented/SegmentedRaftLog.java
@@ -91,7 +91,6 @@ public synchronized void start() throws IOException, DamagedLogStorageException
 
         RecoveryProtocol recoveryProtocol = new RecoveryProtocol( fileSystem, fileNames, contentMarshal, logProvider );
         state = recoveryProtocol.run();
-
     }
 
     @Override

diff --git a/...dge/src/test/java/org/neo4j/coreedge/raft/log/segmented/SegmentedRaftLogRotationTest.java b/...dge/src/test/java/org/neo4j/coreedge/raft/log/segmented/SegmentedRaftLogRotationTest.java
@@ -19,101 +19,82 @@
  */
 package org.neo4j.coreedge.raft.log.segmented;
 
-import org.junit.After;
+import org.junit.Rule;
-import org.junit.Ignore;
 import org.junit.Test;
 
 import java.io.File;
-import java.util.concurrent.atomic.AtomicLong;
+import java.io.IOException;
+import java.util.stream.Stream;
 
 import org.neo4j.coreedge.raft.ReplicatedInteger;
 import org.neo4j.coreedge.raft.ReplicatedString;
 import org.neo4j.coreedge.raft.log.DummyRaftableContentSerializer;
 import org.neo4j.coreedge.raft.log.RaftLogEntry;
-import org.neo4j.graphdb.mockfs.EphemeralFileSystemAbstraction;
+import org.neo4j.kernel.lifecycle.Lifespan;
-import org.neo4j.io.fs.FileSystemAbstraction;
-import org.neo4j.kernel.lifecycle.LifeSupport;
 import org.neo4j.logging.NullLogProvider;
+import org.neo4j.test.rule.Resources;
 
 import static org.junit.Assert.assertEquals;
-import static org.neo4j.coreedge.raft.log.segmented.SegmentedRaftLog.SEGMENTED_LOG_DIRECTORY_NAME;
 import static org.neo4j.coreedge.server.CoreEdgeClusterSettings.raft_log_pruning_strategy;
+import static org.neo4j.test.rule.Resources.InitialLifecycle.STARTED;
+import static org.neo4j.test.rule.Resources.TestPath.EXISTING_DIRECTORY;
 
 public class SegmentedRaftLogRotationTest
 {
-    private LifeSupport life = new LifeSupport();
+    private final static int ROTATE_AT_SIZE_IN_BYTES = 100;
-    private FileSystemAbstraction fileSystem;
 
-    @After
+    @Rule
-    public void tearDown() throws Throwable
+    public final Resources resourceManager = new Resources( EXISTING_DIRECTORY );
-    {
-        life.stop();
-        life.shutdown();
-    }
 
-    private SegmentedRaftLog createRaftLog( long rotateAtSize )
+    private SegmentedRaftLog createRaftLog( long rotateAtSize ) throws IOException
     {
-        if ( fileSystem == null )
+        return new SegmentedRaftLog( resourceManager.fileSystem(), resourceManager.testPath(), rotateAtSize,
-        {
+                new DummyRaftableContentSerializer(), NullLogProvider.getInstance(),
-            fileSystem = new EphemeralFileSystemAbstraction();
+                raft_log_pruning_strategy.getDefaultValue() );
-        }
-        File directory = new File( SEGMENTED_LOG_DIRECTORY_NAME );
-        fileSystem.mkdir( directory );
-
-        SegmentedRaftLog newRaftLog = new SegmentedRaftLog( fileSystem, directory, rotateAtSize,
-                new DummyRaftableContentSerializer(),
-                NullLogProvider.getInstance(), raft_log_pruning_strategy.getDefaultValue() );
-        life.add( newRaftLog );
-        life.init();
-        life.start();
-        return newRaftLog;
     }
 
-    @Ignore( "This test is stupid - rewrite" )
+    @Test
+    @Resources.Life( STARTED )
     public void shouldRotateOnAppendWhenRotateSizeIsReached() throws Exception
     {
-        // Given
-        AtomicLong currentVersion = new AtomicLong();
-        int rotateAtSize = 100;
-        SegmentedRaftLog log = createRaftLog( rotateAtSize );
-
-        StringBuilder builder = new StringBuilder();
-        for ( int i = 0; i < rotateAtSize; i++ )
-        {
-            builder.append( "i" );
-        }
-
         // When
-        ReplicatedString stringThatIsMoreThan100Bytes = new ReplicatedString( builder.toString() );
+        SegmentedRaftLog log = resourceManager.managed( createRaftLog( ROTATE_AT_SIZE_IN_BYTES ) );
-        log.append( new RaftLogEntry( 0, stringThatIsMoreThan100Bytes ) );
+        log.append( new RaftLogEntry( 0, replicatedStringOfBytes( ROTATE_AT_SIZE_IN_BYTES ) ) );
 
         // Then
-        assertEquals( 1, currentVersion.get() );
+        File[] files = resourceManager.fileSystem().listFiles( resourceManager.testPath() );
+        assertEquals( 2, files.length );
     }
 
     @Test
+    @Resources.Life( STARTED )
     public void shouldBeAbleToRecoverToLatestStateAfterRotation() throws Throwable
     {
-        int rotateAtSize = 100;
+        // Given
-        SegmentedRaftLog log = createRaftLog( rotateAtSize );
+        int term = 0;
-
+        long indexToRestoreTo;
-        StringBuilder builder = new StringBuilder();
+        try ( Lifespan lifespan = new Lifespan() )
-        for ( int i = 0; i < rotateAtSize - 40; i++ )
         {
-            builder.append( "i" );
+            SegmentedRaftLog log = lifespan.add( createRaftLog( ROTATE_AT_SIZE_IN_BYTES ) );
+            log.append( new RaftLogEntry( term, replicatedStringOfBytes( ROTATE_AT_SIZE_IN_BYTES - 40 ) ) );
+            indexToRestoreTo = log.append( new RaftLogEntry( term, ReplicatedInteger.valueOf( 1 ) ) );
         }
 
-        ReplicatedString stringThatGetsTheSizeToAlmost100Bytes = new ReplicatedString( builder.toString() );
-        int term = 0;
-        log.append( new RaftLogEntry( term, stringThatGetsTheSizeToAlmost100Bytes ) );
-        long indexToRestoreTo = log.append( new RaftLogEntry( term, ReplicatedInteger.valueOf( 1 ) ) );
-
         // When
-        life.remove( log );
+        SegmentedRaftLog log = resourceManager.managed( createRaftLog( ROTATE_AT_SIZE_IN_BYTES ) );
-        log = createRaftLog( rotateAtSize );
 
         // Then
         assertEquals( indexToRestoreTo, log.appendIndex() );
         assertEquals( term, log.readEntryTerm( indexToRestoreTo ) );
     }
+
+    private ReplicatedString replicatedStringOfBytes( int size )
+    {
+        StringBuilder builder = new StringBuilder();
+        for ( int i = 0; i < size; i++ )
+        {
+            builder.append( "i" );
+        }
+        return new ReplicatedString( builder.toString() );
+    }
 }