/*
* Hibernate Search, full-text search for your domain model
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
package org.hibernate.search.test.serialization;
import static org.fest.assertions.Assertions.assertThat;
import static org.junit.Assert.assertTrue;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.DoubleField;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.document.FloatField;
import org.apache.lucene.document.IntField;
import org.apache.lucene.document.LongField;
import org.apache.lucene.util.AttributeImpl;
import org.hibernate.search.backend.AddLuceneWork;
import org.hibernate.search.backend.DeleteLuceneWork;
import org.hibernate.search.backend.LuceneWork;
import org.hibernate.search.backend.OptimizeLuceneWork;
import org.hibernate.search.backend.PurgeAllLuceneWork;
import org.hibernate.search.backend.UpdateLuceneWork;
import org.hibernate.search.engine.service.impl.StandardServiceManager;
import org.hibernate.search.engine.service.spi.ServiceManager;
import org.hibernate.search.indexes.serialization.avro.impl.AvroSerializationProvider;
import org.hibernate.search.indexes.serialization.impl.CopyTokenStream;
import org.hibernate.search.indexes.serialization.impl.LuceneWorkSerializerImpl;
import org.hibernate.search.indexes.serialization.spi.LuceneWorkSerializer;
import org.hibernate.search.indexes.serialization.spi.SerializationProvider;
import org.hibernate.search.test.serialization.AvroTestHelpers.SerializableStringReader;
import org.hibernate.search.testsupport.junit.SearchFactoryHolder;
import org.hibernate.search.testsupport.setup.SearchConfigurationForTest;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
/**
* This tests backwards compatibility with version 1.0
* of the Avro based protocol.
* A test model was serialized into a resource "persistent-avro-1.0"
* which is stored in version control, this test verifies the current
* Avro based serialization service is able to deserialize that same
* model correctly.
*
* @author Sanne Grinovero <sanne@hibernate.org>
*/
public class ProtocolVersion10Test {
private static final String RESOURCE_NAME = "persistent-avro-1.0";
@Rule
public SearchFactoryHolder searchFactoryHolder = new SearchFactoryHolder( RemoteEntity.class );
private SerializationProvider serializationProvider;
@Before
public void setUp() {
ServiceManager serviceManager = new StandardServiceManager(
new SearchConfigurationForTest(),
null
);
serializationProvider = serviceManager.requestService( SerializationProvider.class );
assertTrue( "Wrong serialization provider", serializationProvider instanceof AvroSerializationProvider );
}
@Test
public void testAvroSerialization() throws Exception {
LuceneWorkSerializer converter = new LuceneWorkSerializerImpl(
serializationProvider,
searchFactoryHolder.getSearchFactory()
);
List<LuceneWork> worksAsSerialized = buildWorks();
//this is how the 'persistent-avro-1.0' resource was created:
// final byte[] outbytes = converter.toSerializedModel( worksAsSerialized );
// storeSerializedForm(outbytes);
byte[] bytes = loadResource();
List<LuceneWork> deserialized = converter.toLuceneWorks( bytes );
assertThat( deserialized ).hasSize( worksAsSerialized.size() );
for ( int index = 0; index < worksAsSerialized.size(); index++ ) {
AvroTestHelpers.assertLuceneWork( worksAsSerialized.get( index ), deserialized.get( index ) );
}
}
private byte[] loadResource() throws IOException {
int pos = 0;
final int SIZE = 665;//taking advantage of the known size to avoid dealing with buffer resizing
byte[] buffer = new byte[SIZE];
try (InputStream in = getClass().getClassLoader().getResourceAsStream( RESOURCE_NAME ) ) {
while ( pos != SIZE ) {
int read = in.read( buffer, pos, SIZE - pos );
pos += read;
}
}
return buffer;
}
private void storeSerializedForm(byte[] outbytes) throws IOException {
try ( OutputStream out = new FileOutputStream( RESOURCE_NAME ) ) {
out.write( outbytes );
out.flush();
}
System.out.println( "Resource file created. Length is " + outbytes.length );
}
/**
* This is copied from SerializationTest; it needs to be a copy to not evolve further
* as it needs to match the binary representation stored in 'persistent-avro-1.0'.
*/
public static List<LuceneWork> buildWorks() throws Exception {
List<LuceneWork> works = new ArrayList<LuceneWork>();
works.add( OptimizeLuceneWork.INSTANCE );
works.add( OptimizeLuceneWork.INSTANCE );
works.add( new OptimizeLuceneWork( RemoteEntity.class ) ); //class won't be send over
works.add( new PurgeAllLuceneWork( RemoteEntity.class ) );
works.add( new PurgeAllLuceneWork( RemoteEntity.class ) );
works.add( new DeleteLuceneWork( 123l, "123", RemoteEntity.class ) );
works.add( new DeleteLuceneWork( "Sissi", "Sissi", RemoteEntity.class ) );
works.add(
new DeleteLuceneWork(
new URL( "http://emmanuelbernard.com" ),
"http://emmanuelbernard.com",
RemoteEntity.class
)
);
Document doc = new Document();
Field numField = new DoubleField( "double", 23d, Store.NO );
doc.add( numField );
numField = new IntField( "int", 23, Store.NO );
doc.add( numField );
numField = new FloatField( "float", 2.3f, Store.NO );
doc.add( numField );
numField = new LongField( "long", 23l, Store.NO );
doc.add( numField );
Map<String, String> analyzers = new HashMap<String, String>();
analyzers.put( "godo", "ngram" );
works.add( new AddLuceneWork( 123, "123", RemoteEntity.class, doc, analyzers ) );
doc = new Document();
Field field = new Field(
"StringF",
"String field",
Field.Store.YES,
Field.Index.ANALYZED,
Field.TermVector.WITH_OFFSETS
);
field.setBoost( 3f );
doc.add( field );
field = new Field(
"StringF2",
"String field 2",
Field.Store.YES,
Field.Index.ANALYZED,
Field.TermVector.WITH_OFFSETS
);
doc.add( field );
byte[] array = new byte[4];
array[0] = 2;
array[1] = 5;
array[2] = 5;
array[3] = 8;
field = new Field( "binary", array, 0, array.length );
doc.add( field );
SerializableStringReader reader = new SerializableStringReader();
field = new Field( "ReaderField", reader, Field.TermVector.WITH_OFFSETS );
doc.add( field );
List<List<AttributeImpl>> tokens = AvroTestHelpers.buildTokenSteamWithAttributes();
CopyTokenStream tokenStream = new CopyTokenStream( tokens );
field = new Field( "tokenstream", tokenStream, Field.TermVector.WITH_POSITIONS_OFFSETS );
field.setBoost( 3f );
doc.add( field );
works.add( new UpdateLuceneWork( 1234, "1234", RemoteEntity.class, doc ) );
works.add( new AddLuceneWork( 125, "125", RemoteEntity.class, new Document() ) );
return works;
}
}