BaseDataAccessObjectTest.java

package org.hivedb.hibernate;

import org.hibernate.shards.strategy.access.SequentialShardAccessStrategy;
import org.hivedb.Hive;
import org.hivedb.HiveLockableException;
import org.hivedb.util.classgen.GenerateInstance;
import org.hivedb.util.classgen.GeneratedClassFactory;
import org.hivedb.util.classgen.GeneratedInstanceInterceptor;
import org.hivedb.util.classgen.ReflectionTools;
import org.hivedb.util.database.test.HiveTest;
import org.hivedb.util.database.test.HiveTest.Config;
import org.hivedb.util.database.test.WeatherReport;
import org.hivedb.util.functional.*;
import org.junit.Assert;
import static org.junit.Assert.*;
import org.junit.Test;

import java.util.*;
import java.util.Map.Entry;

@Config("hive_default")
public class BaseDataAccessObjectTest extends HiveTest {

  private static Random random = new Random();

  @SuppressWarnings("unchecked")
  @Test
  public void testGet() throws Exception {
    DataAccessObject<WeatherReport, Integer> dao = (DataAccessObject<WeatherReport, Integer>) getDao(getGeneratedClass());
    WeatherReport original = getPersistentInstance(dao);
    WeatherReport report = dao.get(original.getReportId());
    assertEquals(ReflectionTools.getDifferingFields(original, report, WeatherReport.class).toString(), original.hashCode(), report.hashCode());
  }

  @SuppressWarnings("unchecked")
  @Test
  public void testGetMissingRecord() throws Exception {
    DataAccessObject<WeatherReport, Integer> dao = (DataAccessObject<WeatherReport, Integer>) getDao(getGeneratedClass());
    WeatherReport original = getInstance(WeatherReport.class);
    HiveIndexer indexer = new HiveIndexer(getHive());
    indexer.insert(getEntityHiveConfig().getEntityConfig(WeatherReport.class), original);
    assertTrue(dao.exists(original.getReportId()));
    WeatherReport report = dao.get(original.getReportId());
    assertFalse(dao.exists(original.getReportId()));
    assertEquals(null, report);
//		assertEquals(ReflectionTools.getDifferingFields(original, report, WeatherReport.class).toString(), original.hashCode(), report.hashCode());
  }

  @SuppressWarnings("unchecked")
  @Test
  public void testFindByProperty() throws Exception {
    DataAccessObject<WeatherReport, Integer> dao = (DataAccessObject<WeatherReport, Integer>) getDao(getGeneratedClass());
    WeatherReport report = new GenerateInstance<WeatherReport>(WeatherReport.class).generate();
    dao.save(report);
    int temperature = random.nextInt();
    GeneratedInstanceInterceptor.setProperty(report, "temperature", temperature);
    dao.save(report);
    WeatherReport found = Atom.getFirstOrThrow(dao.findByProperty("temperature", temperature));
    Assert.assertEquals(report.hashCode(), found.hashCode());
    found = Atom.getFirstOrThrow(dao.findByProperty("regionCode", report.getRegionCode()));
    assertEquals(report.hashCode(), found.hashCode());
    found = Atom.getFirstOrThrow(dao.findByProperty("weatherEvents", Atom.getFirstOrThrow(report.getWeatherEvents()).getEventId()));
    assertEquals(report.hashCode(), found.hashCode());
    found = Atom.getFirstOrThrow(dao.findByProperty("continent", report.getContinent()));
    assertEquals(report.hashCode(), found.hashCode());
    found = Atom.getFirstOrThrow(dao.findByProperty("sources", Atom.getFirstOrThrow(report.getSources())));
    assertEquals(report.hashCode(), found.hashCode());
    // Test find by multiple properties
    found = Atom.getFirstOrThrow(dao.findByProperties("regionCode", Transform.toMap(
        new Entry[]{
            new Pair<String, Object>("regionCode", report.getRegionCode()),
            new Pair<String, Object>("weatherEvents", Atom.getFirstOrThrow(report.getWeatherEvents()).getEventId()),
        })));
    assertEquals(report.hashCode(), found.hashCode());
  }

  @SuppressWarnings("unchecked")
  @Test
  public void testFindByPropertyPaged() throws Exception {
    final DataAccessObject<WeatherReport, Integer> dao = (DataAccessObject<WeatherReport, Integer>) getDao(getGeneratedClass());

    Collection<WeatherReport> reports =
        Generate.create(new Generator<WeatherReport>() {
          public WeatherReport generate() {
            WeatherReport report = new GenerateInstance<WeatherReport>(WeatherReport.class).generate();
            GeneratedInstanceInterceptor.setProperty(report, "continent", "Derkaderkastan");
            GeneratedInstanceInterceptor.setProperty(report, "temperature", 101);
            GeneratedInstanceInterceptor.setProperty(report, "sources", Arrays.asList(new Integer[]{101, 102, 103}));
            return dao.save(report);
          }
        }, new NumberIterator(12));

    for (final String property : new String[]{"temperature", "sources"}) {
      Assert.assertEquals(dao.findByProperty(property, 101).size(), 12);
      final Collection<WeatherReport> results = Filter.grepUnique(Transform.flatten(Transform.map(new Unary<Integer, Collection<WeatherReport>>() {
        public Collection<WeatherReport> f(Integer i) {
          return dao.findByProperty(property, 101, (i - 1) * 4, 4);
        }
      }, new NumberIterator(3))));
      Assert.assertEquals(
          new HashSet<WeatherReport>(results).hashCode(),
          new HashSet(reports).hashCode());
    }
  }

  @SuppressWarnings("unchecked")
  @Test
  public void testFindByPropertyRange() throws Exception {

    Collection<WeatherReport> reports =
        Generate.create(new Generator<WeatherReport>() {
          public WeatherReport generate() {
            return new GenerateInstance<WeatherReport>(WeatherReport.class).generate();
          }
        }, new NumberIterator(5));

    DataAccessObject<WeatherReport, Integer> dao = (DataAccessObject<WeatherReport, Integer>) getDao(getGeneratedClass());
    dao.saveAll(reports);
    //Collection<WeatherReport> x = dao.findByProperty("temperature", Atom.getFirst(reports).getTemperature());
    Integer min = Amass.min(
        new Unary<WeatherReport, Integer>() {
          public Integer f(WeatherReport weatherReport) {
            return weatherReport.getTemperature();
          }
        },
        reports,
        Integer.class);
    Integer max = Amass.max(
        new Unary<WeatherReport, Integer>() {
          public Integer f(WeatherReport weatherReport) {
            return weatherReport.getTemperature();
          }
        },
        reports,
        Integer.class);
    Collection<WeatherReport> range = dao.findByPropertyRange("temperature", min, max);
    assertEquals(reports.size(), range.size());

    Collection<WeatherReport> smallerRange =
        dao.findByPropertyRange("temperature", Atom.getFirst(reports).getTemperature(), Atom.getFirst(reports).getTemperature());
    assertEquals(1, smallerRange.size());
  }

  @SuppressWarnings("unchecked")
  @Test
  public void testFindByPropertyRangePaged() throws Exception {
    final DataAccessObject<WeatherReport, Integer> dao = (DataAccessObject<WeatherReport, Integer>) getDao(getGeneratedClass());
    final int INSTANCE_COUNT = 12;
    Collection<WeatherReport> set = new HashSet<WeatherReport>();
    int min = 0, max = 0;
    for (int i = 0; i < INSTANCE_COUNT; i++) {
      int temperature = random.nextInt();
      min = Math.min(min, temperature);
      max = Math.max(max, temperature);
      WeatherReport report = new GenerateInstance<WeatherReport>(WeatherReport.class).generate();
      GeneratedInstanceInterceptor.setProperty(report, "temperature", temperature);
      dao.save(report);
      set.add(report);
    }
    final int finalMin = min;
    final int finalMax = max;
    Assert.assertEquals(
        new HashSet<WeatherReport>(Transform.flatten(Transform.map(new Unary<Integer, Collection<WeatherReport>>() {
          public Collection<WeatherReport> f(Integer i) {
            final Collection<WeatherReport> value = dao.findByPropertyRange("temperature", finalMin, finalMax, (i - 1) * 4, 4);
            return value;
          }
        }, new NumberIterator(3)))).hashCode(),
        set.hashCode());
  }

  @SuppressWarnings("unchecked")
  @Test
  public void testGetCount() throws Exception {

    final int temperature = random.nextInt();
    final List<String> partitionDimensionKeys = Arrays.asList(new String[]{"Asia", "Andromida"});
    Collection<WeatherReport> reports =
        Generate.create(new Generator<WeatherReport>() {
          public WeatherReport generate() {
            WeatherReport weatherReport = new GenerateInstance<WeatherReport>(WeatherReport.class).generate();
            // Set the same temperature for each partition dimension id. The partition dimension id will be calculated from the report id
            GeneratedInstanceInterceptor.setProperty(weatherReport, "temperature", temperature + weatherReport.getReportId() % 2);
            GeneratedInstanceInterceptor.setProperty(weatherReport, "continent", partitionDimensionKeys.get(weatherReport.getReportId() % 2));
            GeneratedInstanceInterceptor.setProperty(weatherReport, "regionCode", 4);
            return weatherReport;
          }
        }, new NumberIterator(5));

    DataAccessObject<WeatherReport, Integer> dao = (DataAccessObject<WeatherReport, Integer>) getDao(getGeneratedClass());
    dao.saveAll(reports);
    Assert.assertEquals(dao.getCount("temperature", temperature) + dao.getCount("temperature", temperature + 1), 5);
    Assert.assertEquals(dao.getCountByRange("temperature", temperature, temperature + 1), (Integer) 5);
    Assert.assertEquals((Integer) (dao.getCountByProperties("temperature", Transform.toMap(
        new Entry[]{
            new Pair<String, Object>("temperature", temperature),
            new Pair<String, Object>("regionCode", 4),
        })) +
        dao.getCountByProperties("temperature", Transform.toMap(
            new Entry[]{
                new Pair<String, Object>("temperature", temperature + 1),
                new Pair<String, Object>("regionCode", 4),
            }))), (Integer) 5);
  }

  @SuppressWarnings("unchecked")
  @Test
  public void testDelete() throws Exception {
    DataAccessObject<WeatherReport, Integer> dao = (DataAccessObject<WeatherReport, Integer>) getDao(getGeneratedClass());
    WeatherReport original = getPersistentInstance(dao);
    dao.delete(original.getReportId());
    assertNull(dao.get(original.getReportId()));
  }

  @SuppressWarnings("unchecked")
  @Test
  public void testInsert() {
    DataAccessObject<WeatherReport, Integer> dao = (DataAccessObject<WeatherReport, Integer>) getDao(getGeneratedClass());
    WeatherReport report = new GenerateInstance<WeatherReport>(WeatherReport.class).generate();
    dao.save(report);
    WeatherReport savedReport = dao.get(report.getReportId());
    assertNotNull(savedReport);
    assertEquals(report.hashCode(), savedReport.hashCode());
  }

  @SuppressWarnings("unchecked")
  private Class getGeneratedClass() {
    return GeneratedClassFactory.newInstance(WeatherReport.class).getClass();
  }

  private <T> T getInstance(Class<T> clazz) throws Exception {
    return new GenerateInstance<T>(clazz).generate();
  }

  private WeatherReport getPersistentInstance(DataAccessObject<WeatherReport, Integer> dao) throws Exception {
    return dao.save(getInstance(WeatherReport.class));
  }

  @SuppressWarnings("unchecked")
  @Test
  public void testUpdate() throws Exception {
    DataAccessObject<WeatherReport, Integer> dao = (DataAccessObject<WeatherReport, Integer>) getDao(getGeneratedClass());
    WeatherReport original = getPersistentInstance(dao);
    WeatherReport updated = dao.get(original.getReportId());
    GeneratedInstanceInterceptor.setProperty(updated, "latitude", new Double(30));
    GeneratedInstanceInterceptor.setProperty(updated, "longitude", new Double(30));
    /* TODO this fails because we currently don't support one-to-many relationships. We need to reenable the
        deleteOrphanItems in our BaseDataAccessObject to support this
       */
    /*
      // Test collection item updates
      List<WeatherEvent> weatherEvents = new ArrayList<WeatherEvent>(original.getWeatherEvents());
      // Delete the first
      weatherEvents.remove(0);
      // Update the second
      weatherEvents.get(0).setName("foobar");
      // Add a third
      weatherEvents.add(new GenerateInstance<WeatherEvent>(WeatherEvent.class).generate());
      GeneratedInstanceInterceptor.setProperty(updated, "weatherEvents", weatherEvents);
    */
    dao.save(updated);
    //final WeatherReport persisted = dao.get(updated.getReportId());
    assertFalse(updated.getLatitude().equals(original.getLatitude()));
    // Check the updated collection
    // size should be equal
    //assertEquals(original.getWeatherEvents().size(), persisted.getWeatherEvents().size());
    // first item should be removed
    //assertFalse(Filter.grepItemAgainstList(Atom.getFirst(original.getWeatherEvents()), persisted.getWeatherEvents()));
    // should be an updated item named foobar
    /* assertTrue(Filter.grepItemAgainstList("foobar",
          Transform.map(new Unary<WeatherEvent,String>() {
            public String f(WeatherEvent weatherEvent) {
              return weatherEvent.getName();
          }}, persisted.getWeatherEvents()))); */
    // new item should exist
    //assertTrue(Filter.grepItemAgainstList(Atom.getLast(weatherEvents), persisted.getWeatherEvents()));

    String newPrimaryIndexKey = findPrimaryKeyOnDifferentNode(original);
    GeneratedInstanceInterceptor.setProperty(updated, "continent", new Integer(newPrimaryIndexKey).toString());
    Assert.assertEquals(getHive().directory().getNodeIdsOfResourceId("WeatherReport", original.getReportId()).size(), 1);
    dao.save(updated);
    final Collection<Integer> nodeIdsOfResourceId = getHive().directory().getNodeIdsOfResourceId("WeatherReport", updated.getReportId());
    // Make sure the resource is only on 1 hive node
    Assert.assertEquals(nodeIdsOfResourceId.size(), 1);
    // Make sure the node matches the new node
    Assert.assertEquals(Atom.getFirstOrThrow(nodeIdsOfResourceId), Atom.getFirstOrThrow(getHive().directory().getNodeIdsOfPrimaryIndexKey(newPrimaryIndexKey)));
    // Make sure the entity can be fetched on the new node
    Assert.assertNotNull(dao.get(updated.getReportId()));
  }

  private String findPrimaryKeyOnDifferentNode(WeatherReport original)
      throws HiveLockableException {
    // Update the primary index key
    int i = 1;
    // Get a primary index key on a different node
    for (; i < 100; i++) {
      getHive().directory().insertPrimaryIndexKey(new Integer(i).toString());
      if (!Atom.getFirstOrThrow(getHive().directory().getNodeIdsOfPrimaryIndexKey(new Integer(i).toString())).equals(
          Atom.getFirstOrThrow(getHive().directory().getNodeIdsOfPrimaryIndexKey(original.getContinent()))))
        break;
    }
    return new Integer(i).toString();
  }

  @SuppressWarnings("unchecked")
  @Test
  public void testSaveAll() throws Exception {
    Collection<WeatherReport> reports = new ArrayList<WeatherReport>();
    for (int i = 0; i < 54; i++) {
      WeatherReport report = new GenerateInstance<WeatherReport>(WeatherReport.class).generate();
      GeneratedInstanceInterceptor.setProperty(report, "reportId", i);
      reports.add(report);
    }
    DataAccessObject<WeatherReport, Integer> dao = (DataAccessObject<WeatherReport, Integer>) getDao(getGeneratedClass());
    dao.saveAll(reports);

    for (WeatherReport report : reports)
      assertEquals(report, dao.get(report.getReportId()));
  }

  @SuppressWarnings("unchecked")
  @Test
  public void testHealDataNodeOnlyRecord() throws Exception {
    WeatherReport report = new GenerateInstance<WeatherReport>(WeatherReport.class).generate();

    DataAccessObject<WeatherReport, Integer> dao = (DataAccessObject<WeatherReport, Integer>) getDao(getGeneratedClass());
    dao.save(report);
    assertEquals(report, dao.get(report.getReportId()));
    Hive hive = getHive();
    hive.directory().deleteResourceId(config.getEntityConfig(getGeneratedClass()).getResourceName(), report.getReportId());
    ReflectionTools.invokeSetter(report, "regionCode", report.getRegionCode() + 1);
    assertFalse(dao.exists(report.getReportId()));
    dao.save(report);
    assertEquals(report, dao.get(report.getReportId()));
  }

  @SuppressWarnings("unchecked")
  @Test
  public void testHealDataNodeOnlyRecordSaveAll() throws Exception {
    Collection<WeatherReport> reports = new ArrayList<WeatherReport>();
    for (int i = 0; i < 5; i++) {
      WeatherReport report = new GenerateInstance<WeatherReport>(WeatherReport.class).generate();
      GeneratedInstanceInterceptor.setProperty(report, "reportId", i);
      reports.add(report);
    }

    DataAccessObject<WeatherReport, Integer> dao = (DataAccessObject<WeatherReport, Integer>) getDao(getGeneratedClass());
    dao.saveAll(reports);
    for (WeatherReport report : reports)
      assertEquals(report, dao.get(report.getReportId()));

    WeatherReport orphan = Atom.getFirstOrThrow(reports);

    Hive hive = getHive();
    hive.directory().deleteResourceId(config.getEntityConfig(getGeneratedClass()).getResourceName(), orphan.getReportId());
    for (WeatherReport report : reports)
      ReflectionTools.invokeSetter(report, "regionCode", report.getRegionCode() + 1);
    assertFalse(dao.exists(orphan.getReportId()));
    dao.saveAll(reports);

    for (WeatherReport report : reports)
      assertEquals(report, dao.get(report.getReportId()));

    HiveIndexer indexer = new HiveIndexer(getHive());

    dao.delete(orphan.getReportId());
    indexer.insert(config.getEntityConfig(dao.getRespresentedClass()), orphan);

    dao.saveAll(reports);
    for (WeatherReport report : reports)
      assertEquals(report, dao.get(report.getReportId()));
  }


  @SuppressWarnings("unchecked")
  @Test
  public void testUpdateAll() throws Exception {
    Collection<WeatherReport> reports = new ArrayList<WeatherReport>();
    for (int i = 0; i < 5; i++) {
      WeatherReport report = new GenerateInstance<WeatherReport>(WeatherReport.class).generate();
      GeneratedInstanceInterceptor.setProperty(report, "reportId", i);
      reports.add(report);
    }
    DataAccessObject<WeatherReport, Integer> dao = (DataAccessObject<WeatherReport, Integer>) getDao(getGeneratedClass());
    dao.saveAll(reports);


    Collection<WeatherReport> updated = new ArrayList<WeatherReport>();
    for (WeatherReport report : reports) {
      GeneratedInstanceInterceptor.setProperty(report, "temperature", 100);
      updated.add(report);
    }
    dao.saveAll(updated);

    for (WeatherReport report : updated) {
      final WeatherReport weatherReport = dao.get(report.getReportId());
      assertEquals(report, weatherReport);
    }

    // Test changing the partition dimension key
    String newPrimaryIndexKey = findPrimaryKeyOnDifferentNode(Atom.getFirstOrThrow(reports));
    for (WeatherReport report : reports) {
      GeneratedInstanceInterceptor.setProperty(report, "continent", new Integer(newPrimaryIndexKey).toString());
      Assert.assertEquals(getHive().directory().getNodeIdsOfResourceId("WeatherReport", report.getReportId()).size(), 1);
    }
    dao.saveAll(reports);
    for (WeatherReport report : reports) {
      final Collection<Integer> nodeIdsOfResourceId = getHive().directory().getNodeIdsOfResourceId("WeatherReport", report.getReportId());
      // Make sure the resource is only on 1 hive node
      Assert.assertEquals(nodeIdsOfResourceId.size(), 1);
      // Make sure the node matches the new node
      Assert.assertEquals(Atom.getFirstOrThrow(nodeIdsOfResourceId), Atom.getFirstOrThrow(getHive().directory().getNodeIdsOfPrimaryIndexKey(newPrimaryIndexKey)));
      // Make sure the entity can be fetched on the new node
      Assert.assertNotNull(dao.get(report.getReportId()));
    }
  }

  @SuppressWarnings("unchecked")
  @Test
  public void testExists() throws Exception {
    DataAccessObject<WeatherReport, Integer> dao = (DataAccessObject<WeatherReport, Integer>) getDao(getGeneratedClass());
    assertFalse(dao.exists(88));
    WeatherReport original = getPersistentInstance(dao);
    assertTrue(dao.exists(original.getReportId()));
  }

  @SuppressWarnings("unchecked")
  @Test
  public void testAllShardsQuery() {
    final DataAccessObject<WeatherReport, Integer> dao = (DataAccessObject<WeatherReport, Integer>) getDao(getGeneratedClass());
    final int INSTANCES = 20;
    Collection<WeatherReport> reports = Generate.create(new Generator<WeatherReport>() {
      public WeatherReport generate() {
        WeatherReport report = new GenerateInstance<WeatherReport>(WeatherReport.class).generate();
        GeneratedInstanceInterceptor.setProperty(report, "latitude", 1d);
        GeneratedInstanceInterceptor.setProperty(report, "regionCode", 1); // used to verify node spread
        dao.save(report);
        return report;
      }
    }, new NumberIterator(INSTANCES));

    Hive hive = getHive();
    // Make sure we saved to > 1 node
    Assert.assertTrue(1 < hive.directory().getNodeIdsOfSecondaryIndexKey("WeatherReport", "regionCode", Atom.getFirstOrThrow(reports).getRegionCode()).size());
    // Make sure all instances are found across nodes
    Assert.assertEquals(INSTANCES, dao.findByProperty("latitude", 1d).size());
  }

  /**
   * Test illustrating bug 6520-6522.
   * <p/>
   * The count code issues a count query to each node. The broken code was then looking only at the count returned by the first node. This was
   * only the correct behavior 1/n percent of the time. The correct behavior is to sum the counts from all the nodes.
   */
  @Test
  public void shouldSumCountsFromAllNodes() throws Exception {
    final QueryCountStubDAO dao = new QueryCountStubDAO(getGeneratedClass());

    assertEquals(5, dao.getCount("foo", "bar").intValue());
    assertEquals(5, dao.getCount("foo", "bar").intValue());
    assertEquals(5, dao.getCount("foo", "bar").intValue());

    assertEquals(3, dao.callCount);
  }

  /**
   * Overrides the counts returned in support of the shouldSumCountsFromAllNodes test.
   */
  public class QueryCountStubDAO extends BaseDataAccessObject {
    int callCount = 0;

    public QueryCountStubDAO(Class clazz) {
      super(
          config.getEntityConfig(clazz),
          hive,
          new HiveSessionFactoryBuilderImpl(
              config,
              getMappedClasses(),
              hive,
              new SequentialShardAccessStrategy()));
    }

    @Override
    protected Collection<Object> queryByProperties(String partitioningPropertyName, Map<String, Object> propertyNameValueMap, Integer firstResult, Integer maxResults, boolean justCount) {
      ArrayList<Object> list = new ArrayList<Object>();
      switch (callCount++) {
        case 0:
          list.add(0);
          list.add(5);
          return list;
        case 1:
          list.add(5);
          list.add(0);
          return list;
        case 2:
          list.add(2);
          list.add(3);
          return list;
        default:
          throw new RuntimeException("unexpect call");
      }
    }
  }
}