package eu.fbk.knowledgestore.datastore;
   
   import java.io.IOException;
   import java.util.ArrayList;
   import java.util.HashSet;
   import java.util.List;
   
   import org.junit.After;
   import org.junit.Assert;
  import org.junit.Before;
  import org.junit.Test;
  import org.openrdf.model.URI;
  import org.openrdf.model.impl.URIImpl;
  import org.openrdf.model.vocabulary.RDF;
  
  import eu.fbk.knowledgestore.data.Record;
  import eu.fbk.knowledgestore.data.Stream;
  import eu.fbk.knowledgestore.vocabulary.KS;
  
  /**
   * Abstract class for defining data store tests.
   */
  public abstract class AbstractDataStoreTest {
  
      /** Data store to be used. */
      private DataStore dataStore;
  
      protected abstract DataStore createDataStore();
  
      /**
       * @return the dataStore
       */
      protected final DataStore getDataStore() {
          return this.dataStore;
      }
  
      @Before
      public void setUp() throws IOException {
          this.dataStore = createDataStore();
          this.dataStore.init();
      }
  
      @After
      public void tearDown() throws IOException {
          this.dataStore.close();
      }
  
      @Test
      public void testDataModifyResources() throws Throwable {
          try {
              final List<Record> records = createRecords(3, KS.RESOURCE);
              final DataTransaction dataTran = this.dataStore.begin(false);
              dataTran.store(KS.RESOURCE, records.get(0));
              dataTran.store(KS.RESOURCE, records.get(1));
              dataTran.delete(KS.RESOURCE, records.get(2).getID());
              dataTran.end(true);
          } catch (final IOException e) {
              e.printStackTrace();
          }
      }
  
      @Test
      public void testDataLookup() throws Throwable {
          Stream<Record> stream = null;
          final DataTransaction dt = this.dataStore.begin(true);
          try {
              stream = dt.lookup(KS.RESOURCE, new HashSet<URI>(createURIs(3)), null);
              Assert.assertNotNull(stream);
              Assert.assertTrue(stream.iterator().hasNext());
          } finally {
              if (stream != null) {
                  stream.close();
              }
              dt.end(true);
          }
      }
  
      /**
       * Creates a list of URIs.
       * 
       * @param number
       *            of URIs to be created
       * @return list of URIs created
       */
      protected final List<URI> createURIs(final int number) {
          final List<URI> uris = new ArrayList<URI>();
          for (int cont = 0; cont < number; cont++) {
              final URI idTmp = new URIImpl("http://example.org/" + cont);
              uris.add(idTmp);
          }
          return uris;
      }
  
      /**
       * Method that creates a list of URI as identifies.
       * 
       * @param number
       *            of URIs to be created
       * @param type
      *            the type of record
      * @return list of URIs created
      */
     protected final List<Record> createRecords(final int number, final URI type) {
         final List<Record> records = new ArrayList<Record>();
         final List<URI> uris = createURIs(number);
         for (int cont = 0; cont < number; cont++) {
             final Record rTmp = Record.create();
             rTmp.set(RDF.TYPE, type);
             rTmp.setID(uris.get(cont));
             records.add(rTmp);
         }
         return records;
     }
 
 }