TestProductDao.java

package fr.gael.dhus.database.dao;

import java.math.BigInteger;
import java.net.MalformedURLException;
import java.net.URL;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ContextConfiguration;
import org.testng.Assert;
import org.testng.annotations.Test;

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;

import fr.gael.dhus.database.dao.interfaces.HibernateDao;
import fr.gael.dhus.database.object.Collection;
import fr.gael.dhus.database.object.MetadataIndex;
import fr.gael.dhus.database.object.Product;
import fr.gael.dhus.database.object.Product.Download;
import fr.gael.dhus.database.object.User;
import fr.gael.dhus.util.CheckIterator;
import fr.gael.dhus.util.TestContextLoader;

@ContextConfiguration (
      locations = "classpath:fr/gael/dhus/spring/context-test.xml",
      loader = TestContextLoader.class)
@DirtiesContext (classMode = DirtiesContext.ClassMode.AFTER_CLASS)
public class TestProductDao extends TestAbstractHibernateDao<Product, Long>
{

   @Autowired
   private ProductDao dao;

   @Autowired
   private UserDao udao;

   @Override
   protected HibernateDao<Product, Long> getHibernateDao ()
   {
      return dao;
   }

   @Override
   protected int howMany ()
   {
      return 8;
   }

   @Override
   public void create ()
   {
      String identifier = "test-create-product";
      String indexName = "index-name";
      String indexCategory = "category";
      String indexValue = "test";

      MetadataIndex mi = new MetadataIndex ();
      mi.setName (indexName);
      mi.setCategory (indexCategory);
      mi.setQueryable (null);
      mi.setValue (indexValue);

      Product product = new Product ();
      product.setIdentifier (identifier);
      product.setLocked (false);
      product.setProcessed (true);
      product.setIndexes (Arrays.asList (mi));
      try
      {
         product.setPath (new URL ("file:/titi/tata"));
      }
      catch (MalformedURLException e)
      {
         Assert.fail (e.getMessage (), e);
      }

      Product createdProduct = dao.create (product);
      Assert.assertNotNull (createdProduct);
      Assert.assertEquals (dao.count (), (howMany () + 1));
      Assert.assertEquals (createdProduct.getUuid (), product.getUuid ());

      List<MetadataIndex> indexes = createdProduct.getIndexes ();
      Assert.assertEquals (indexes.size (), 1);
      Assert.assertEquals (indexes.get (0), mi);
   }

   @Override
   public void read ()
   {
      Product p = dao.read (6L);
      Assert.assertNotNull (p);
      Assert.assertEquals (p.getIdentifier (), "prod6");
      Download dl = p.getDownload ();
      Map<String, String> checksums = dl.getChecksums ();
      Assert.assertEquals (checksums.get ("MD5"), "abc");
   }

   @Override
   public void update ()
   {
      String productIdentifier = "test-prod-7";
      String indexName = "updatable";
      Long pid = Long.valueOf (7);

      Product product = dao.read (pid);
      List<MetadataIndex> indexes = product.getIndexes ();
      product.setIdentifier (productIdentifier);
      for (MetadataIndex mi : indexes)
      {
         mi.setName (indexName);
      }
      dao.setIndexes (pid, indexes);
      dao.update (product);

      product = dao.read (pid);
      indexes = product.getIndexes ();
      Assert.assertNotNull (product);
      Assert.assertEquals (product.getIdentifier (), productIdentifier);
      for (MetadataIndex mi : indexes)
      {
         Assert.assertEquals (mi.getName (), indexName);
      }
   }

   private int countElements (final String table, final Long pid)
   {
      return dao.getHibernateTemplate ().execute (
            new HibernateCallback<Integer> ()
            {
               @Override
               public Integer doInHibernate (Session session)
                     throws HibernateException, SQLException
               {
                  String sql =
                        "SELECT count(*) FROM " + table +
                              " WHERE PRODUCT_ID = ?";
                  Query query = session.createSQLQuery (sql).setLong (0, pid);
                  return ((BigInteger) query.uniqueResult ()).intValue ();
               }
            });
   }

   @Override
  public void delete ()
   {
      cancelListeners (getHibernateDao ());
      
      Long pid = Long.valueOf (6L);
      Product product = dao.read (pid);
      Assert.assertNotNull (product);
      Set<User> authorizedUsers = product.getAuthorizedUsers ();
      
      List<MetadataIndex> indexes = product.getIndexes ();
      Assert.assertNotNull (indexes);
      Assert.assertFalse (indexes.isEmpty ());
      Assert.assertFalse (authorizedUsers.isEmpty ());

      dao.delete (product);
      getHibernateDao ().getSessionFactory ().getCurrentSession ().flush ();
      
      Assert.assertNull (dao.read (pid));
      Assert.assertEquals (countElements ("METADATA_INDEXES", pid), 0);
      Assert.assertEquals (countElements ("CHECKSUMS", pid), 0);

      for (User user : authorizedUsers)
      {
         Assert.assertNotNull (udao.read (user.getUUID ()));
      }
   }
   
   @Override
   public void scroll ()
   {
      String hql = "WHERE processed IS TRUE";
      Iterator<Product> it = dao.scroll (hql, -1, -1).iterator ();
      Assert.assertTrue (CheckIterator.checkElementNumber (it, 4));
   }

   @Override
   public void first ()
   {
      String hql = "FROM Product WHERE processed IS FALSE ORDER BY id DESC";
      Product product = dao.first (hql);
      Assert.assertNotNull (product);
      Assert.assertEquals (product.getId ().intValue (), 4);
   }

   @Test
   public void exists ()
   {
      boolean bool;
      String path;
      try
      {
         path = "file:/home/lambert/test/prod0";
         bool = dao.exists (new URL (path));
         Assert.assertTrue (bool,
               "product with path '" + path + "' should be" + "exists");

         path = "file:/home/lambert/test/product999";
         bool = dao.exists (new URL (path));
         Assert.assertFalse (bool,
               "product with path '" + path + "' should be npt exists");
      }
      catch (MalformedURLException e)
      {
         Assert.fail ("Error: malformed URL", e);
      }
   }

   @Test
   public void getAuthorizedProduct ()
   {
      String uid;
      List<Long> expected;
      List<Long> products;

      uid = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0";
      expected = Arrays.asList (0L, 5L, 6L, 7L);
      products = dao.getAuthorizedProducts (uid);
      Assert.assertEquals (products.size (), expected.size ());
      Assert.assertTrue (products.containsAll (expected));
   }

   private User emulateUser (String uid, String username)
   {
      User user = new User ();
      user.setUUID (uid);
      user.setUsername (username);
      return user;
   }

   @Test
   public void getNoCollectionProducts ()
   {
      String uid = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0";
      long expectedPid1 = 6;
      long expectedPid2 = 7;

      List<Product> products =
            dao.getNoCollectionProducts (emulateUser (uid, "koko"));
      Assert.assertEquals (products.size (), 2);
      Assert.assertEquals (products.get (0).getId ().intValue (), expectedPid1);
      Assert.assertEquals (products.get (1).getId ().intValue (), expectedPid2);
   }
   
   @Test
   public void count ()
   {
      Assert.assertEquals (dao.count(null, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa3"), 1);
   }

   @Test
   public void getOwerOfProduct ()
   {
      User expectedUser = new User ();
      expectedUser.setUsername ("koko");
      
      Product product = dao.read (0L);
      Assert.assertNotNull (product);
      
      User user = dao.getOwnerOfProduct (product);
      // To be sure that both are equals...
      expectedUser.setUUID (user.getUUID ());

      Assert.assertNotNull (user);
      Assert.assertTrue (user.equals (expectedUser), 
         "User " + user.getUsername () + "#" + user.getUUID() + 
         " not expected (" + expectedUser.getUsername () + "#" + 
         expectedUser.getUUID () + ").");

      product = dao.read (6L);
      user = dao.getOwnerOfProduct (product);
      Assert.assertNull (user);
   }

   @Test
   public void getProductByDownloadableFilename ()
   {
      fr.gael.dhus.database.object.Collection validCollection;
      fr.gael.dhus.database.object.Collection invalidCollection;
      Product product;

      validCollection = new Collection ();
      validCollection.setUUID ("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa3");
      validCollection.setName ("Japan");

      invalidCollection = new Collection ();
      invalidCollection.setUUID ("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa4");
      invalidCollection.setName ("China");

      product = dao.getProductByDownloadableFilename("prod0",validCollection);
      Assert.assertNotNull(product);
      Assert.assertEquals(product.getId ().intValue(), 0);

      product = dao.getProductByDownloadableFilename("prod6",validCollection);
      Assert.assertNull(product);

      product = dao.getProductByDownloadableFilename("prod0",invalidCollection);
      Assert.assertNull (product);

      product = dao.getProductByDownloadableFilename("prod6",null);
      Assert.assertNotNull(product);
      Assert.assertEquals(product.getId ().intValue (), 6);

      product = dao.getProductByDownloadableFilename (null, null);
      Assert.assertNull (product);
   }

   @Test
   public void getProductByPath ()
   {
      URL valid = null;
      URL invalid = null;
      try
      {
         valid = new URL ("file:/home/lambert/test/prod5");
         invalid = new URL ("file:/home/lambert/test/prod512");
      }
      catch (MalformedURLException e)
      {
         Assert.fail ("Malformed URL !", e);
      }

      Product product = dao.getProductByPath (valid);
      Assert.assertNotNull (product);
      Assert.assertEquals (product.getId ().intValue (), 5);

      product = dao.getProductByPath (invalid);
      Assert.assertNull (product);

      product = dao.getProductByPath (null);
      Assert.assertNull (product);
   }

   @Test
   public void getProductByUuid ()
   {
      String valid = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa6";
      String invalid = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb6";
      User user = new User ();
      user.setUUID ("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0");
      user.setUsername ("koko");

      Product product = dao.getProductByUuid (valid);
      Assert.assertNotNull (product);
      Assert.assertEquals (product.getId ().intValue (), 6);

      product = dao.getProductByUuid (invalid);
      Assert.assertNull (product);

      product = dao.getProductByUuid (valid);
      Assert.assertNotNull (product);
      Assert.assertEquals (product.getId ().intValue (), 6);

      product = dao.getProductByUuid (null);
      Assert.assertNull (product);
   }

   @Test
   public void getProductByIngestionDate ()
   {
      Date date = new Date ();
      Iterator<Product> products = dao.getProductsByIngestionDate (date);
      Assert.assertEquals (getIteratorSize (products), 4);

      Calendar calendar =  Calendar.getInstance ();
      calendar.set (2014, Calendar.JUNE, 07, 0, 0, 0);
      date = calendar.getTime ();
      products = dao.getProductsByIngestionDate (date);
      Assert.assertEquals (getIteratorSize (products), 1);
   }

   private int getIteratorSize (Iterator iterator)
   {
      int count = 0;
      while (iterator.hasNext ())
      {
         iterator.next ();
         count++;
      }
      return count;
   }
   
   @Test
   public void isAuthorized ()
   {
      Assert.assertTrue (dao.isAuthorized ("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", 0));
      Assert.assertTrue (dao.isAuthorized ("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1", 0));
      Assert.assertTrue (dao.isAuthorized ("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa2", 0));
      Assert.assertTrue (dao.isAuthorized ("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa3", 0));
      
      Assert.assertTrue (dao.isAuthorized ("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0", 1));
      Assert.assertTrue (dao.isAuthorized ("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa2", 1));
      Assert.assertTrue (dao.isAuthorized ("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa3", 1));
      
      // Unknown user
      Assert.assertFalse (dao.isAuthorized ("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1000", 1));
      // Unknown product
      Assert.assertFalse (dao.isAuthorized ("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1", 1000));
   }

   // TODO merge others test
   
   @Test (groups={"non-regression"})
   public void testChecksumUpdate () throws MalformedURLException
   {
      Product product = new Product ();
      product.setPath (new URL ("file:/product/path"));
      
      Download download = new Product.Download ();
      download.setPath ("/no/path/file");
      download.setSize (0L);
      download.setType ("application/octet-stream");
      download.setChecksums (
         Maps.newHashMap (ImmutableMap.of(
            "MD5", "54ABCDEF98765", 
            "SHA-1", "9876FEDCBA1234")));
      
      product.setDownload (download);
      
      
      // First create the defined product: 
      try
      {
         product = dao.create (product);
      }
      catch (Exception e)
      {
         Assert.fail ("Creation of product fails", e);
      }
      
      /**
       * Clear/putAll feature testing
       */
      product.getDownload ().getChecksums ().clear ();
      product.getDownload ().getChecksums ().putAll (
         Maps.newHashMap (ImmutableMap.of(
            "SHA-256", "4554ABCDEF98765", 
            "SHA-512", "ABDEFFE9876FEDCBA1234")));
      try
      {
         dao.update (product);
      }
      catch (Exception e)
      {
         Assert.fail ("Modifying checksums with map clear/put fails", e);
      }
      
      /**
       * Set feature testing
       */
      product.getDownload ().setChecksums (
         Maps.newHashMap (ImmutableMap.of(
            "MD5", "54ABCDEF98765", 
            "SHA-1", "9876FEDCBA1234")));
      try
      {
         dao.update (product);
      }
      catch (Exception e)
      {
         Assert.fail ("Modifying checksums with \"set\" fails", e);
      }
      
      /**
       * Remove residuals for this test
       */
      cancelListeners (getHibernateDao ());
      dao.delete (product);
      
   }
   
}