@Test public void shouldReadDefragCountUsingStaticMethod() throws Exception { EphemeralFileSystemAbstraction fs = fsr.get(); IdGeneratorImpl.createGenerator( fs, file, 0, false ); IdGeneratorImpl idGenerator = new IdGeneratorImpl( fs, file, 1, 10000, false, IdType.NODE, () -> 0L ); idGenerator.nextId(); long a = idGenerator.nextId(); idGenerator.nextId(); long b = idGenerator.nextId(); idGenerator.nextId(); idGenerator.freeId( a ); idGenerator.freeId( b ); long expectedDefragCount = idGenerator.getDefragCount(); idGenerator.close(); long actualDefragCount = IdGeneratorImpl.readDefragCount( fs, file ); assertEquals( 2, expectedDefragCount ); assertEquals( expectedDefragCount, actualDefragCount ); }
ReadOnlyIdGenerator( LongSupplier highId, FileSystemAbstraction fs, File filename ) { if ( fs != null && fs.fileExists( filename ) ) { try { this.highId = IdGeneratorImpl.readHighId( fs, filename ); defragCount = IdGeneratorImpl.readDefragCount( fs, filename ); } catch ( IOException e ) { throw new UnderlyingStorageException( "Failed to read id counts of the id file: " + filename, e ); } } else { this.highId = highId.getAsLong(); defragCount = 0; } }
@Test public void delete() { IdGeneratorImpl.createGenerator( fs, idGeneratorFile(), 0, false ); IdGeneratorImpl idGenerator = new IdGeneratorImpl( fs, idGeneratorFile(), 10, 1000, false, IdType.NODE, () -> 0L ); long id = idGenerator.nextId(); idGenerator.nextId(); idGenerator.freeId( id ); idGenerator.close(); idGenerator.delete(); assertFalse( idGeneratorFile().exists() ); IdGeneratorImpl.createGenerator( fs, idGeneratorFile(), 0, false ); idGenerator = new IdGeneratorImpl( fs, idGeneratorFile(), 10, 1000, false, IdType.NODE, () -> 0L ); assertEquals( id, idGenerator.nextId() ); idGenerator.close(); }
@Test public void shouldNotAcceptMinusOne() { // GIVEN IdGeneratorImpl.createGenerator( fsr.get(), file, 0, false ); IdGenerator idGenerator = new IdGeneratorImpl( fsr.get(), file, 100, 100, false, IdType.NODE, () -> 0L ); expectedException.expect( NegativeIdException.class ); // WHEN idGenerator.setHighId( -1 ); }
@Test public void shouldBeAbleToReadWrittenGenerator() { // Given IdGeneratorImpl.createGenerator( fsr.get(), file, 42, false ); IdGeneratorImpl idGenerator = new IdGeneratorImpl( fsr.get(), file, 100, 100, false, IdType.NODE, () -> 42L ); idGenerator.close(); // When idGenerator = new IdGeneratorImpl( fsr.get(), file, 100, 100, false, IdType.NODE, () -> 0L ); // Then assertThat( idGenerator.getHighId(), equalTo( 42L ) ); }
@Test( expected = IllegalArgumentException.class ) public void grabSizeCannotBeNegative() { IdGeneratorImpl.createGenerator( fs, idGeneratorFile(), 0, false ); new IdGeneratorImpl( fs, idGeneratorFile(), -1, 100, false, IdType.NODE, () -> 0L ).close(); }
@Test public void shouldReadHighIdUsingStaticMethod() throws Exception { // GIVEN long highId = 12345L; IdGeneratorImpl.createGenerator( fsr.get(), file, highId, false ); // WHEN long readHighId = IdGeneratorImpl.readHighId( fsr.get(), file ); // THEN assertEquals( highId, readHighId ); }
protected IdGenerator instantiate( FileSystemAbstraction fs, File fileName, int grabSize, long maxValue, boolean aggressiveReuse, IdType idType, LongSupplier highId ) { return new IdGeneratorImpl( fs, fileName, grabSize, maxValue, aggressiveReuse, idType, highId ); }
@Override public void create( File fileName, long highId, boolean throwIfFileExists ) { IdGeneratorImpl.createGenerator( fs, fileName, highId, throwIfFileExists ); } }
@Test public void constructorShouldCallHighIdSupplierOnNonExistingIdFile() { // Given // An empty file (default, nothing to do) // and a mock supplier to test against LongSupplier highId = mock( LongSupplier.class ); when( highId.getAsLong() ).thenReturn( 0L ); // necessary, otherwise it runs into NPE in the constructor below // When // The id generator is started IdGeneratorImpl idGenerator = new IdGeneratorImpl( fsr.get(), file, 100, 100, false, IdType.NODE, highId ); // Then // The highId supplier must have been called to get the high id verify( highId ).getAsLong(); idGenerator.close(); }
@Override public synchronized long getNumberOfIdsInUse() { return highId - getDefragCount(); }
@Test public void throwsWhenGivenHighIdIsTooHigh() { long maxId = 10; IdGeneratorImpl.createGenerator( fsr.get(), file, 0, false ); IdGenerator idGenerator = new IdGeneratorImpl( fsr.get(), file, 1, maxId, false, IdType.RELATIONSHIP_TYPE_TOKEN, () -> 0L ); expectedException.expect( IdCapacityExceededException.class ); expectedException.expectMessage( "Maximum id limit for RELATIONSHIP_TYPE_TOKEN has been reached. Generated id 11 is out of permitted range [0, 10]." ); idGenerator.setHighId( maxId + 1 ); }
@Test( expected = IllegalArgumentException.class ) public void grabSizeCannotBeZero() { IdGeneratorImpl.createGenerator( fs, idGeneratorFile(), 0, false ); new IdGeneratorImpl( fs, idGeneratorFile(), 0, 100, false, IdType.NODE, () -> 0L ).close(); }
private void clearIdFiles( FileSystemAbstraction fileSystem, Path targetDirectory ) throws IOException { File dir = targetDirectory.toFile(); for ( File file : fileSystem.listFiles( dir ) ) { if ( !fileSystem.isDirectory( file ) && file.getName().endsWith( ".id" ) ) { long highId = IdGeneratorImpl.readHighId( fileSystem, file ); fileSystem.deleteFile( file ); IdGeneratorImpl.createGenerator( fileSystem, file, highId, true ); } } }
@Override protected IdGenerator openIdGenerator( int grabSize ) { return new IdGeneratorImpl( fs, idGeneratorFile(), grabSize, 1000, false, IdType.NODE, () -> 0L ); }
@Test( expected = IllegalArgumentException.class ) public void cannotCreateIdGeneratorWithNullFile() { IdGeneratorImpl.createGenerator( fs, null, 0, false ); }
@Override public synchronized long getNumberOfIdsInUse() { return highId - getDefragCount(); }
/** * It should be fine to set high id to {@link IdGeneratorImpl#INTEGER_MINUS_ONE}. * It will just be never returned from {@link IdGeneratorImpl#nextId()}. */ @Test public void highIdCouldBeSetToReservedId() { IdGeneratorImpl.createGenerator( fsr.get(), file, 0, false ); IdGenerator idGenerator = new IdGeneratorImpl( fsr.get(), file, 1, Long.MAX_VALUE, false, IdType.NODE, () -> 0L ); idGenerator.setHighId( IdGeneratorImpl.INTEGER_MINUS_ONE ); assertEquals( IdGeneratorImpl.INTEGER_MINUS_ONE + 1, idGenerator.nextId() ); }
public void clearIdFiles( Path backupLocation ) throws IOException { IOException exception = null; File targetDirectory = backupLocation.toFile(); File[] files = fs.listFiles( targetDirectory ); for ( File file : files ) { if ( !fs.isDirectory( file ) && file.getName().endsWith( ".id" ) ) { try { long highId = IdGeneratorImpl.readHighId( fs, file ); fs.deleteFile( file ); IdGeneratorImpl.createGenerator( fs, file, highId, true ); } catch ( IOException e ) { exception = Exceptions.chain( exception, e ); } } } if ( exception != null ) { throw exception; } }
@Test public void constructorShouldNotCallHighIdSupplierOnCleanIdFile() { // Given // A non empty, clean id file IdContainer.createEmptyIdFile( fsr.get(), file, 42, true ); // and a mock supplier to test against LongSupplier highId = mock( LongSupplier.class ); // When // An IdGenerator is created over the previous properly closed file IdGenerator idGenerator = new IdGeneratorImpl( fsr.get(), file, 100, 100, false, IdType.NODE, highId ); idGenerator.close(); // Then // The supplier must have remained untouched verifyZeroInteractions( highId ); } }