#919 - io.ebean package initial

src/test/java/org/Main.java

@@ -0,0 +1,29 @@
+package org;
+
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class Main {
+
+  public static void main(String[] args) throws SQLException {
+
+
+    EbeanServer ms = Ebean.getServer("ms");
+    DataSource dataSource = ms.getPluginApi().getDataSource();
+
+    Connection connection = dataSource.getConnection();
+    PreparedStatement statement = connection.prepareStatement("select next VALUE for j2_seq");
+    ResultSet resultSet = statement.executeQuery();
+    if (resultSet.next()) {
+      Object val = resultSet.getObject(1);
+      System.out.println(""+val);
+    }
+    connection.close();
+  }
+}

src/test/java/org/avaje/test/model/inheritmany/test/TestInheritWithMany.java

@@ -1,15 +1,15 @@
 package org.avaje.test.model.inheritmany.test;
 
-import com.avaje.ebean.BaseTestCase;
-import com.avaje.ebean.Ebean;
-import com.avaje.ebean.EbeanServer;
-import com.avaje.ebeaninternal.api.SpiEbeanServer;
-import com.avaje.ebeaninternal.server.deploy.BeanDescriptor;
-import com.avaje.ebeaninternal.server.deploy.InheritInfo;
-import com.avaje.tests.model.inheritmany.IMRelated;
-import com.avaje.tests.model.inheritmany.IMRoot;
-import com.avaje.tests.model.inheritmany.IMRootOne;
-import com.avaje.tests.model.inheritmany.IMRootTwo;
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.deploy.InheritInfo;
+import org.tests.model.inheritmany.IMRelated;
+import org.tests.model.inheritmany.IMRoot;
+import org.tests.model.inheritmany.IMRootOne;
+import org.tests.model.inheritmany.IMRootTwo;
 import org.junit.Assert;
 import org.junit.Test;
 

src/test/java/org/avaje/test/model/rawsql/inherit/ParentAggregate.java

@@ -1,6 +1,6 @@
 package org.avaje.test.model.rawsql.inherit;
 
-import com.avaje.ebean.annotation.Sql;
+import io.ebean.annotation.Sql;
 
 import javax.persistence.Entity;
 import javax.persistence.OneToOne;

src/test/java/org/example/ModUuidGenerator.java

@@ -1,6 +1,6 @@
 package org.example;
 
-import com.avaje.ebean.config.IdGenerator;
+import io.ebean.config.IdGenerator;
 import org.avaje.moduuid.ModUUID;
 
 /**

src/test/java/org/tests/autofetch/AutofetchEmbeddedTest.java

@@ -0,0 +1,67 @@
+package org.tests.autofetch;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.embedded.EMain;
+import org.tests.model.embedded.Eembeddable;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+public class AutofetchEmbeddedTest extends BaseTestCase {
+
+  private final Logger logger = LoggerFactory.getLogger(AutofetchEmbeddedTest.class);
+
+  @Test
+  public void testEmbeddedBeanLazyLoadAndUpdate() {
+
+    EMain testBean = new EMain();
+    testBean.setName("test");
+    testBean.getEmbeddable().setDescription("test description");
+    Ebean.save(testBean);
+
+    EMain partialBean = Ebean.find(EMain.class).select("version").setId(testBean.getId()).findUnique();
+
+    logger.info(" -- invoke lazy loading of embedded bean");
+    Eembeddable embeddable = partialBean.getEmbeddable();
+    embeddable.setDescription("modified description");
+
+    logger.info(" -- update bean");
+    Ebean.save(partialBean);
+
+  }
+
+  @Test
+  public void testEmbeddedBeanQueryTuning() {
+//    Ebean.getServer(null).getAutoTune().setProfiling(true);
+//    Ebean.getServer(null).getAutoTune().setQueryTuning(true);
+//    Ebean.getServer(null).getAutoTune().setProfilingBase(1);
+//
+//    EMain testBean = new EMain();
+//    testBean.setName("test");
+//    testBean.getEmbeddable().setDescription("test description");
+//    Ebean.save(testBean);
+//
+//    //This should not throw an exception
+//    for (int i = 0; i < 5; i++) {
+//      Ebean.beginTransaction();
+//      try {
+//        List<EMain> result = Ebean.find(EMain.class).setAutoTune(true).findList();
+//        for (EMain e : result) {
+//          e.getEmbeddable().setDescription("Test" + i);
+//          Ebean.save(e);
+//        }
+//        Ebean.commitTransaction();
+//      } finally {
+//        Ebean.endTransaction();
+//        logger.debug(Ebean.getServer(null).getAutoTune().collectProfiling());
+//      }
+//    }
+  }
+
+  @Test
+  public void testEmbeddedFetch() {
+    Ebean.find(EMain.class).fetch("embeddable").findList();
+  }
+}

src/test/java/org/tests/autofetch/MainAutoFetchExcludeLazyLobs.java

@@ -0,0 +1,32 @@
+package org.tests.autofetch;
+
+import io.ebean.Ebean;
+import org.tests.model.basic.EBasicClob;
+
+import java.util.List;
+
+public class MainAutoFetchExcludeLazyLobs {
+
+  public static void main(String[] args) {
+
+    EBasicClob a = new EBasicClob();
+    a.setName("name 1");
+    a.setTitle("a title");
+    a.setDescription("not that meaningful");
+
+    Ebean.save(a);
+
+    List<EBasicClob> list = Ebean.find(EBasicClob.class)
+      .setAutoTune(true)
+      .findList();
+
+    for (EBasicClob bean : list) {
+      bean.getName();
+      // although we read the description
+      // autofetch will not include it later
+      bean.getDescription();
+    }
+
+
+  }
+}

src/test/java/org/tests/autofetch/MainAutoQueryTune1.java

@@ -0,0 +1,34 @@
+package org.tests.autofetch;
+
+import io.ebean.Ebean;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+
+import java.util.List;
+
+public class MainAutoQueryTune1 {
+
+  public static void main(String[] args) {
+
+    ResetBasicData.reset();
+
+    MainAutoQueryTune1 me = new MainAutoQueryTune1();
+    me.tuneJoin();
+  }
+
+  private void tuneJoin() {
+    List<Order> list = Ebean.find(Order.class)
+      .setAutoTune(true)
+      .fetch("customer")
+      .where()
+      .eq("status", Order.Status.NEW)
+      .eq("customer.name", "Rob")
+      .order().asc("id")
+      .findList();
+
+    for (Order order : list) {
+      order.getId();
+      order.getOrderDate();
+    }
+  }
+}

src/test/java/org/tests/autofetch/TunedQueryInfoTest.java

@@ -0,0 +1,176 @@
+package org.tests.autofetch;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.Query;
+import io.ebean.bean.EntityBean;
+import io.ebean.bean.EntityBeanIntercept;
+import io.ebean.cache.ServerCacheManager;
+import io.ebeaninternal.api.SpiQuery;
+import io.ebeaninternal.server.autotune.model.Origin;
+import io.ebeaninternal.server.autotune.service.TunedQueryInfo;
+import io.ebeaninternal.server.querydefn.OrmQueryDetail;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.avaje.ebeantest.LoggedSqlCollector;
+import org.jetbrains.annotations.NotNull;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Set;
+
+public class TunedQueryInfoTest extends BaseTestCase {
+
+  EbeanServer server = Ebean.getServer(null);
+
+  private void init() {
+
+    ResetBasicData.reset();
+
+    ServerCacheManager serverCacheManager = Ebean.getServer(null).getServerCacheManager();
+    serverCacheManager.clearAll();
+  }
+
+  @Test
+  public void withSelectEmpty() {
+
+    init();
+
+    OrmQueryDetail tunedDetail = new OrmQueryDetail();
+    tunedDetail.select("");
+
+    TunedQueryInfo tunedInfo = createTunedQueryInfo(tunedDetail);
+
+    Query<Order> query = server.find(Order.class).setId(1);
+
+    tunedInfo.tuneQuery((SpiQuery<?>) query);
+
+    Order order = query.findUnique();
+    EntityBean eb = (EntityBean) order;
+    EntityBeanIntercept ebi = eb._ebean_getIntercept();
+
+    Assert.assertTrue(ebi.isFullyLoadedBean());
+
+    Set<String> loadedPropertyNames = ebi.getLoadedPropertyNames();
+    Assert.assertNull(loadedPropertyNames);
+
+    // invoke lazy loading
+    order.getCustomer();
+  }
+
+  @Test
+  public void withSelectSomethingThatDoesNotExist() {
+
+    init();
+
+    OrmQueryDetail tunedDetail = new OrmQueryDetail();
+    tunedDetail.select("somethingThatDoesNotExist");
+
+    TunedQueryInfo tunedInfo = createTunedQueryInfo(tunedDetail);
+
+    Query<Order> query = server.find(Order.class).setId(1);
+
+    tunedInfo.tuneQuery((SpiQuery<?>) query);
+
+    LoggedSqlCollector.start();
+
+    Order order = query.findUnique();
+    EntityBean eb = (EntityBean) order;
+    EntityBeanIntercept ebi = eb._ebean_getIntercept();
+
+    Assert.assertFalse(ebi.isFullyLoadedBean());
+
+    // id and any ToMany relationships
+    Set<String> loadedPropertyNames = ebi.getLoadedPropertyNames();
+    Assert.assertNotNull(loadedPropertyNames);
+
+    // invoke lazy loading
+    order.getCustomer();
+
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    Assert.assertEquals(2, loggedSql.size());
+
+    Assert.assertTrue(trimSql(loggedSql.get(0), 1).contains("select t0.id, t0.id from o_order t0 where t0.id = ?"));
+    Assert.assertTrue(trimSql(loggedSql.get(1), 1).contains("select t0.id, t0.status,"));
+  }
+
+  @NotNull
+  private TunedQueryInfo createTunedQueryInfo(OrmQueryDetail tunedDetail) {
+    Origin origin = new Origin();
+    origin.setDetail(tunedDetail.asString());
+    return new TunedQueryInfo(origin);
+  }
+
+  @Test
+  public void withSelectSomeIncludeLazyLoaded() {
+
+    init();
+
+    OrmQueryDetail tunedDetail = new OrmQueryDetail();
+    tunedDetail.select("status, customer");
+
+    TunedQueryInfo tunedInfo = createTunedQueryInfo(tunedDetail);
+
+    Query<Order> query = server.find(Order.class).setId(1);
+
+    tunedInfo.tuneQuery((SpiQuery<?>) query);
+
+    LoggedSqlCollector.start();
+
+    Order order = query.findUnique();
+    EntityBean eb = (EntityBean) order;
+    EntityBeanIntercept ebi = eb._ebean_getIntercept();
+
+    Assert.assertFalse(ebi.isFullyLoadedBean());
+
+    Set<String> loadedPropertyNames = ebi.getLoadedPropertyNames();
+    Assert.assertNotNull(loadedPropertyNames);
+
+    Assert.assertTrue(loadedPropertyNames.contains("status"));
+    Assert.assertTrue(loadedPropertyNames.contains("customer"));
+
+    // no lazy loading expected here
+    order.getCustomer();
+
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    Assert.assertEquals(1, loggedSql.size());
+  }
+
+  @Test
+  public void withSelectSome() {
+
+    init();
+
+    OrmQueryDetail tunedDetail = new OrmQueryDetail();
+    tunedDetail.select("status");
+
+    TunedQueryInfo tunedInfo = createTunedQueryInfo(tunedDetail);
+
+    Query<Order> query = server.find(Order.class).setId(1);
+
+    tunedInfo.tuneQuery((SpiQuery<?>) query);
+
+    LoggedSqlCollector.start();
+
+    Order order = query.findUnique();
+    EntityBean eb = (EntityBean) order;
+    EntityBeanIntercept ebi = eb._ebean_getIntercept();
+
+    Assert.assertFalse(ebi.isFullyLoadedBean());
+
+    Set<String> loadedPropertyNames = ebi.getLoadedPropertyNames();
+    Assert.assertNotNull(loadedPropertyNames);
+
+    Assert.assertTrue(loadedPropertyNames.contains("status"));
+    Assert.assertFalse(loadedPropertyNames.contains("customer"));
+
+    // no lazy loading expected here
+    order.getCustomer();
+
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    Assert.assertEquals(2, loggedSql.size());
+  }
+
+}

src/test/java/org/tests/autofetch/TunedQueryWithNullFetchedBeanTest.java

@@ -0,0 +1,67 @@
+package org.tests.autofetch;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.Query;
+import io.ebean.bean.EntityBean;
+import io.ebean.bean.EntityBeanIntercept;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.avaje.ebeantest.LoggedSqlCollector;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Set;
+
+public class TunedQueryWithNullFetchedBeanTest extends BaseTestCase {
+
+  EbeanServer server = Ebean.getServer(null);
+
+  @Test
+  public void withFetchOfNullBeanJoin() {
+
+    ResetBasicData.reset();
+
+    Customer newCustomer = new Customer();
+    newCustomer.setName("TestFetchBillingAddress");
+    server.save(newCustomer);
+
+    Query<Customer> query = server.find(Customer.class)
+      .setId(newCustomer.getId())
+      .fetch("billingAddress", "id");
+
+    LoggedSqlCollector.start();
+
+    Customer customer = query.findUnique();
+    EntityBean eb = (EntityBean) customer;
+    EntityBeanIntercept ebi = eb._ebean_getIntercept();
+
+    Assert.assertTrue(ebi.isFullyLoadedBean());
+
+    // find the internal property index for "billingAddress"
+    String[] propNames = eb._ebean_getPropertyNames();
+    int pos = 0;
+    for (int i = 0; i < propNames.length; i++) {
+      if (propNames[i].equals("billingAddress")) {
+        pos = i;
+      }
+    }
+
+    // The billing address is loaded (but value null)
+    Assert.assertTrue(ebi.isLoadedProperty(pos));
+
+    Set<String> loadedPropertyNames = ebi.getLoadedPropertyNames();
+    Assert.assertNull(loadedPropertyNames);
+
+    // no lazy loading expected here, value is null
+    Address billingAddress = customer.getBillingAddress();
+    Assert.assertNull(billingAddress);
+
+    // assert only one query executed
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    Assert.assertEquals(1, loggedSql.size());
+  }
+}

src/test/java/org/tests/basic/MainDbBoolean.java

@@ -0,0 +1,154 @@
+package org.tests.basic;
+
+import io.ebean.EbeanServer;
+import io.ebean.EbeanServerFactory;
+import io.ebean.Query;
+import io.ebean.SqlRow;
+import io.ebean.config.ServerConfig;
+import io.ebean.config.dbplatform.postgres.PostgresPlatform;
+import org.tests.model.basic.TOne;
+import org.tests.model.basic.TSDetail;
+import org.tests.model.basic.TSMaster;
+import org.avaje.datasource.DataSourceConfig;
+import org.junit.Assert;
+
+import java.util.List;
+
+/**
+ * Used to run some tests manually on a specific Database type.
+ */
+public class MainDbBoolean {
+
+  public static void main(String[] args) {
+
+    MainDbBoolean me = new MainDbBoolean();
+
+    EbeanServer server = me.createEbeanServer();
+    me.simpleCheck(server);
+
+    EbeanServer oraServer = me.createOracleEbeanServer();
+    me.simpleCheck(oraServer);
+  }
+
+  /**
+   * Create a server for running small oracle specific tests manually.
+   * DDL generation etc.
+   */
+  private EbeanServer createOracleEbeanServer() {
+
+    System.setProperty("ebean.ignoreExtraDdl", "true");
+
+    ServerConfig c = new ServerConfig();
+    c.setName("ora");
+
+    // requires oracle driver in class path
+    DataSourceConfig oraDb = new DataSourceConfig();
+    oraDb.setDriver("oracle.jdbc.driver.OracleDriver");
+    oraDb.setUsername("junk");
+    oraDb.setPassword("junk");
+    oraDb.setUrl("jdbc:oracle:thin:junk/junk@localhost:1521:XE");
+    oraDb.setHeartbeatSql("select count(*) from dual");
+
+
+    c.loadFromProperties();
+    c.setDdlGenerate(true);
+    c.setDdlRun(true);
+    c.setDefaultServer(false);
+    c.setRegister(false);
+    c.setDataSourceConfig(oraDb);
+
+    //c.setDatabaseBooleanTrue("1");
+    //c.setDatabaseBooleanFalse("0");
+    c.setDatabaseBooleanTrue("T");
+    c.setDatabaseBooleanFalse("F");
+
+    c.addClass(TOne.class);
+    c.addClass(TSMaster.class);
+    c.addClass(TSDetail.class);
+
+    return EbeanServerFactory.create(c);
+
+  }
+
+  private EbeanServer createEbeanServer() {
+
+    System.setProperty("ebean.ignoreExtraDdl", "true");
+
+    ServerConfig c = new ServerConfig();
+    c.setName("pgtest");
+
+    // requires postgres driver in class path
+    DataSourceConfig postgresDb = new DataSourceConfig();
+    postgresDb.setDriver("org.postgresql.Driver");
+    postgresDb.setUsername("test");
+    postgresDb.setPassword("test");
+    postgresDb.setUrl("jdbc:postgresql://127.0.0.1:5432/test");
+    postgresDb.setHeartbeatSql("select count(*) from t_one");
+
+    c.loadFromProperties();
+    c.setDdlGenerate(true);
+    c.setDdlRun(true);
+    c.setDefaultServer(false);
+    c.setRegister(false);
+    c.setDataSourceConfig(postgresDb);
+
+    //c.setDatabaseBooleanTrue("1");
+    //c.setDatabaseBooleanFalse("0");
+    c.setDatabaseBooleanTrue("T");
+    c.setDatabaseBooleanFalse("F");
+
+    c.setDatabasePlatform(new PostgresPlatform());
+
+    c.addClass(TOne.class);
+
+    return EbeanServerFactory.create(c);
+
+  }
+
+  private void simpleCheck(EbeanServer server) {
+
+    TOne o = new TOne();
+    o.setName("banan");
+    o.setDescription("this one is true");
+    o.setActive(true);
+
+    server.save(o);
+
+    TOne o2 = new TOne();
+    o2.setName("banan");
+    o2.setDescription("this one is false");
+    o2.setActive(false);
+
+    server.save(o2);
+
+
+    List<TOne> list = server.find(TOne.class)
+      .setAutoTune(false)
+      .order("id")
+      .findList();
+
+    Assert.assertTrue(list.size() == 2);
+    Assert.assertTrue(list.get(0).isActive());
+    Assert.assertFalse(!list.get(0).isActive());
+
+    String sql = "select id, name, active from t_oneb order by id";
+    List<SqlRow> sqlRows = server.createSqlQuery(sql).findList();
+    Assert.assertTrue(sqlRows.size() == 2);
+    Object active0 = sqlRows.get(0).get("active");
+    Object active1 = sqlRows.get(1).get("active");
+
+    Assert.assertTrue("T".equals(active0));
+    Assert.assertTrue("F".equals(active1));
+
+
+    Query<TOne> query = server.find(TOne.class)
+      .setAutoTune(false)
+      .order("id");
+
+    int rc = query.findCount();
+    Assert.assertTrue(rc > 0);
+
+
+    System.out.println("done");
+  }
+}

src/test/java/org/tests/basic/MyTestDataSourcePoolListener.java

@@ -0,0 +1,22 @@
+package org.tests.basic;
+
+import org.avaje.datasource.DataSourcePoolListener;
+
+import java.sql.Connection;
+
+public class MyTestDataSourcePoolListener implements DataSourcePoolListener {
+  public static int SLEEP_AFTER_BORROW = 0;
+
+  public void onAfterBorrowConnection(Connection c) {
+    if (SLEEP_AFTER_BORROW > 0) {
+      try {
+        Thread.sleep(SLEEP_AFTER_BORROW);
+      } catch (InterruptedException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  public void onBeforeReturnConnection(Connection c) {
+  }
+}

src/test/java/org/tests/basic/TestAnnotationBase.java

@@ -0,0 +1,194 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.annotation.EbeanDDL;
+import io.ebean.annotation.Where;
+import io.ebean.Platform;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.deploy.BeanProperty;
+import io.ebeaninternal.server.deploy.parse.AnnotationBase;
+import org.tests.model.basic.ValidationGroupSomething;
+import org.junit.Test;
+
+import javax.persistence.Entity;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Size;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+
+public class TestAnnotationBase extends BaseTestCase {
+
+  @Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})
+  @Retention(RetentionPolicy.RUNTIME)
+  @Where(clause = "SELECT 'mysql' from 1", platforms = Platform.MYSQL)
+  @Where(clause = "SELECT 'h2' from 1", platforms = Platform.H2)
+  @Where(clause = "SELECT 'other' from 1")
+  public @interface MetaTest {
+
+  }
+
+  @Entity
+  public static class TestAnnotationBaseEntity {
+
+    @Where(clause = "SELECT 'mysql' from 1", platforms = Platform.MYSQL)
+    @Where(clause = "SELECT 'h2' from 1", platforms = Platform.H2)
+    @Where(clause = "SELECT 'other' from 1")
+    private String direct;
+
+    @MetaTest
+    private String meta;
+
+
+    @MetaTest
+    @Where(clause = "SELECT 'oracle' from 1", platforms = Platform.ORACLE)
+    private String mixed;
+
+    @Size.List({
+      @Size(max = 10, message = "max length for you is 10"),
+      @Size(min = 1),
+      @Size(max = 40, message = "max value for you is 40", groups = ValidationGroupSomething.class)
+    })
+    private String constraintAnnotation;
+
+    @NotNull
+    private String null1;
+
+
+    @NotNull(groups = ValidationGroupSomething.class)
+    private String null2;
+
+    @NotNull(groups = {ValidationGroupSomething.class, EbeanDDL.class})
+    private String null3;
+
+
+    public String getDirect() {
+      return direct;
+    }
+
+    public void setDirect(String direct) {
+      this.direct = direct;
+    }
+
+    public String getMeta() {
+      return meta;
+    }
+
+    public void setMeta(String meta) {
+      this.meta = meta;
+    }
+
+    public String getMixed() {
+      return mixed;
+    }
+
+    public void setMixed(String mixed) {
+      this.mixed = mixed;
+    }
+
+    public String getConstraintAnnotation() {
+      return constraintAnnotation;
+    }
+
+    public void setConstraintAnnotation(String constraintAnnotation) {
+      this.constraintAnnotation = constraintAnnotation;
+    }
+
+    public String getNull1() {
+      return null1;
+    }
+
+    public void setNull1(String null1) {
+      this.null1 = null1;
+    }
+
+    public String getNull2() {
+      return null2;
+    }
+
+    public void setNull2(String null2) {
+      this.null2 = null2;
+    }
+
+    public String getNull3() {
+      return null3;
+    }
+
+    public void setNull3(String null3) {
+      this.null3 = null3;
+    }
+  }
+
+
+  @Test
+  public void testFindMaxSize() throws NoSuchFieldException, SecurityException {
+    BeanDescriptor<TestAnnotationBaseEntity> descriptor = spiEbeanServer().getBeanDescriptor(TestAnnotationBaseEntity.class);
+    BeanProperty bp = descriptor.findBeanProperty("constraintAnnotation");
+    assertEquals(40, bp.getDbLength());
+  }
+
+  @Test
+  public void testNotNullWithGroup() throws NoSuchFieldException, SecurityException {
+    BeanDescriptor<TestAnnotationBaseEntity> descriptor = spiEbeanServer().getBeanDescriptor(TestAnnotationBaseEntity.class);
+
+    BeanProperty bp = descriptor.findBeanProperty("null1");
+    assertFalse(bp.isNullable());
+
+    bp = descriptor.findBeanProperty("null2");
+    assertTrue(bp.isNullable());
+
+    bp = descriptor.findBeanProperty("null3");
+    assertFalse(bp.isNullable());
+  }
+
+  @Test
+  public void testFindAnnotation() throws NoSuchFieldException, SecurityException {
+    Field fld = TestAnnotationBaseEntity.class.getDeclaredField("direct");
+    String s;
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.MYSQL).clause();
+    assertEquals("SELECT 'mysql' from 1", s);
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.H2).clause();
+    assertEquals("SELECT 'h2' from 1", s);
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.POSTGRES).clause();
+    assertEquals("SELECT 'other' from 1", s);
+
+    // meta
+    fld = TestAnnotationBaseEntity.class.getDeclaredField("meta");
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.MYSQL).clause();
+    assertEquals("SELECT 'mysql' from 1", s);
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.H2).clause();
+    assertEquals("SELECT 'h2' from 1", s);
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.POSTGRES).clause();
+    assertEquals("SELECT 'other' from 1", s);
+
+
+    // mixed
+    fld = TestAnnotationBaseEntity.class.getDeclaredField("mixed");
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.MYSQL).clause();
+    assertEquals("SELECT 'mysql' from 1", s);
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.H2).clause();
+    assertEquals("SELECT 'h2' from 1", s);
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.POSTGRES).clause();
+    assertEquals("SELECT 'other' from 1", s);
+
+    s = AnnotationBase.findAnnotation(fld, Where.class, Platform.ORACLE).clause();
+    assertEquals("SELECT 'oracle' from 1", s);
+  }
+
+}

src/test/java/org/tests/basic/TestAssocOneEqExpression.java

@@ -0,0 +1,43 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestAssocOneEqExpression extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    Customer c = new Customer();
+    c.setId(1);
+
+    Query<Order> query = Ebean.find(Order.class)
+      .where().eq("customer", c)
+      .query();
+
+    query.findList();
+    String sql = query.getGeneratedSql();
+    Assert.assertTrue(sql.contains("where t0.kcustomer_id = ?"));
+
+    Address b = new Address();
+    b.setId((short) 1);
+
+    Query<Order> q2 = Ebean.find(Order.class)
+      .where().eq("customer.billingAddress", b)
+      .query();
+
+    q2.findList();
+    sql = q2.getGeneratedSql();
+    Assert.assertTrue(sql.contains("where t1.billing_address_id = ?"));
+
+  }
+}

src/test/java/org/tests/basic/TestBatchLazy.java

@@ -0,0 +1,41 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.OrderDetail;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestBatchLazy extends BaseTestCase {
+
+  @Test
+  public void testMe() {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class);
+    List<Order> list = query.findList();
+
+
+    for (Order order : list) {
+      Customer customer = order.getCustomer();
+      customer.getName();
+
+      List<OrderDetail> details = order.getDetails();
+      for (OrderDetail orderDetail : details) {
+        orderDetail.getProduct().getSku();
+      }
+    }
+
+    Ebean.getDefaultServer().getAutoTune().collectProfiling();
+    Ebean.getDefaultServer().getAutoTune().reportProfiling();
+
+  }
+
+
+}

src/test/java/org/tests/basic/TestBatchLazyMany.java

@@ -0,0 +1,35 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+public class TestBatchLazyMany extends BaseTestCase {
+
+  @Test
+  public void testMe() {
+
+    ResetBasicData.reset();
+
+    Order order2 = Ebean.getReference(Order.class, 1);
+    order2.getOrderDate();
+
+//		List<Order> list = Ebean.find(Order.class)
+//			//.join("details")
+//			//.join("details", "+fetchquery")
+//			.findList();
+//
+//		Order order = list.get(0);
+//		//List<OrderDetail> details = order.getDetails();
+//		//details.size();
+//
+//		Customer customer = order.getCustomer();
+//		customer.getName();
+//		System.out.println("done");
+
+  }
+
+
+}

src/test/java/org/tests/basic/TestBeanReferenceRefresh.java

@@ -0,0 +1,52 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.cache.ServerCache;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.Order.Status;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.sql.Date;
+
+public class TestBeanReferenceRefresh extends BaseTestCase {
+
+  @Test
+  public void testMe() {
+
+    ResetBasicData.reset();
+
+    ServerCache beanCache = Ebean.getServerCacheManager().getBeanCache(Order.class);
+    beanCache.clear();
+
+    Order order = Ebean.getReference(Order.class, 1);
+
+    Assert.assertTrue(Ebean.getBeanState(order).isReference());
+
+    // invoke lazy loading
+    Date orderDate = order.getOrderDate();
+    Assert.assertNotNull(orderDate);
+
+    Customer customer = order.getCustomer();
+    Assert.assertNotNull(customer);
+
+    Assert.assertFalse(Ebean.getBeanState(order).isReference());
+    Assert.assertNotNull(order.getStatus());
+    Assert.assertNotNull(order.getDetails());
+    Assert.assertNull(Ebean.getBeanState(order).getLoadedProps());
+
+    Status status = order.getStatus();
+    Assert.assertTrue(status != Order.Status.SHIPPED);
+    order.setStatus(Order.Status.SHIPPED);
+    Ebean.refresh(order);
+
+    Status statusRefresh = order.getStatus();
+    Assert.assertEquals(status, statusRefresh);
+
+  }
+
+
+}

src/test/java/org/tests/basic/TestDeleteByIdCollection.java

@@ -0,0 +1,79 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TestDeleteByIdCollection extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    Customer c0 = ResetBasicData.createCustomer("del1", "del1 ship", "del1 bill", 1);
+    Customer c1 = ResetBasicData.createCustomer("del2", "del2 ship", "del2 bill", 2);
+
+    Ebean.save(c0);
+    Ebean.save(c1);
+
+    Customer c0Back = Ebean.find(Customer.class, c0.getId());
+    Customer c1Back = Ebean.find(Customer.class, "" + c1.getId());
+
+    Assert.assertNotNull(c0Back);
+    Assert.assertNotNull(c1Back);
+
+    List<String> ids = new ArrayList<>();
+    // also test id type conversion
+    ids.add("" + c0.getId());
+    ids.add("" + c1.getId());
+
+
+    Ebean.deleteAll(Customer.class, ids);
+    awaitL2Cache();
+
+    c0Back = Ebean.find(Customer.class, c0.getId());
+    c1Back = Ebean.find(Customer.class, "" + c1.getId());
+
+    Assert.assertNull(c0Back);
+    Assert.assertNull(c1Back);
+  }
+
+  @Test
+  public void testDelByStatement() {
+
+    ResetBasicData.reset();
+
+    Order order0 = ResetBasicData.createOrderCustAndOrder("delBySql 0");
+    Order order1 = ResetBasicData.createOrderCustAndOrder("delBySql 1");
+
+    Order o0Back = Ebean.find(Order.class, order0.getId());
+    Order o1Back = Ebean.find(Order.class, order1.getId());
+
+    Assert.assertNotNull(o0Back);
+    Assert.assertNotNull(o1Back);
+
+
+    List<Object> ids = new ArrayList<>();
+    // also test id type conversion
+    ids.add(order0.getId());
+    ids.add(order1.getId());
+
+    Ebean.deleteAll(Order.class, ids);
+    awaitL2Cache();
+
+    o0Back = Ebean.find(Order.class, order0.getId());
+    o1Back = Ebean.find(Order.class, order1.getId());
+
+    Assert.assertNull(o0Back);
+    Assert.assertNull(o1Back);
+  }
+
+}

src/test/java/org/tests/basic/TestDeleteCascadingOneToMany.java

@@ -0,0 +1,20 @@
+package org.tests.basic;
+
+import io.ebean.Ebean;
+import org.tests.model.basic.Article;
+import org.tests.model.basic.Section;
+import junit.framework.TestCase;
+
+public class TestDeleteCascadingOneToMany extends TestCase {
+
+  public void testDeleteCascadingOneToMany() {
+    Section s0 = new Section("some content");
+    Article a0 = new Article("art1", "auth1");
+    a0.addSection(s0);
+
+    Ebean.save(a0);
+
+    Ebean.delete(a0);
+  }
+
+}

src/test/java/org/tests/basic/TestDeleteImportedPartial.java

@@ -0,0 +1,34 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.PFile;
+import org.tests.model.basic.PFileContent;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestDeleteImportedPartial extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    PFile persistentFile = new PFile("test.txt", new PFileContent("test".getBytes()));
+
+    Ebean.save(persistentFile);
+    Integer id = persistentFile.getId();
+    Integer contentId = persistentFile.getFileContent().getId();
+
+    PFile partialPfile = Ebean.find(PFile.class).select("id").where().idEq(persistentFile.getId())
+      .findUnique();
+
+    // should delete file and fileContent
+    Ebean.delete(partialPfile);
+
+    PFile file1 = Ebean.find(PFile.class, id);
+    PFileContent content1 = Ebean.find(PFileContent.class, contentId);
+
+    Assert.assertNull(file1);
+    Assert.assertNull(content1);
+
+  }
+}

src/test/java/org/tests/basic/TestDeleteOneToOne.java

@@ -0,0 +1,50 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.PersistentFile;
+import org.tests.model.basic.PersistentFileContent;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestDeleteOneToOne extends BaseTestCase {
+
+  @Test
+  public void testCreateDeletePersistentFile() {
+
+    PersistentFile persistentFile = new PersistentFile("test.txt", new PersistentFileContent(
+      "test".getBytes()));
+
+    Ebean.save(persistentFile);
+    Integer id = persistentFile.getId();
+    Integer contentId = persistentFile.getPersistentFileContent().getId();
+
+    // should delete file and fileContent
+    Ebean.delete(PersistentFile.class, id);
+
+    PersistentFile file1 = Ebean.find(PersistentFile.class, id);
+    PersistentFileContent content1 = Ebean.find(PersistentFileContent.class, contentId);
+
+    Assert.assertNull(file1);
+    Assert.assertNull(content1);
+
+  }
+
+  // public void testDeleteMany() {
+  //
+  // Customer c = new Customer();
+  // c.setName("Fiona");
+  // c.setStatus(Customer.Status.ACTIVE);
+  // c.addContact(new Contact("Fiona", "Black"));
+  // c.addContact(new Contact("Tracy", "Red"));
+  //
+  // Ebean.save(c);
+  //
+  // Ebean.delete(Customer.class, c.getId());
+  //
+  // Customer deletedCustomer = Ebean.find(Customer.class, c.getId());
+  //
+  // Assert.assertNull(deletedCustomer);
+  //
+  // }
+}

src/test/java/org/tests/basic/TestDeleteOneToOneMultiple.java

@@ -0,0 +1,37 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.PFile;
+import org.tests.model.basic.PFileContent;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestDeleteOneToOneMultiple extends BaseTestCase {
+
+  @Test
+  public void testCreateDeletePersistentFile() {
+
+    PFile persistentFile = new PFile("test.txt", new PFileContent("test".getBytes()));
+//    PFile persistentFile = new PFile();
+//    persistentFile.setName("test.txt");
+//    PFileContent content = new PFileContent();
+//    content.setContent("test".getBytes());
+//    persistentFile.setFileContent(content);
+
+    Ebean.save(persistentFile);
+    Integer id = persistentFile.getId();
+    Integer contentId = persistentFile.getFileContent().getId();
+
+    // should delete file and fileContent
+    Ebean.delete(PFile.class, id);
+
+    PFile file1 = Ebean.find(PFile.class, id);
+    PFileContent content1 = Ebean.find(PFileContent.class, contentId);
+
+    Assert.assertNull(file1);
+    Assert.assertNull(content1);
+
+  }
+
+}

src/test/java/org/tests/basic/TestDeletePartialNoVersion.java

@@ -0,0 +1,54 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TMapSuperEntity;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestDeletePartialNoVersion extends BaseTestCase {
+
+  @Test
+  public void testNoVersion() {
+
+    TMapSuperEntity e = new TMapSuperEntity();
+    e.setName("babanaone");
+
+    Ebean.save(e);
+
+    // select includes a transient property
+    TMapSuperEntity e2 = Ebean.find(TMapSuperEntity.class)
+      .where().idEq(e.getId())
+      .select("id, name")
+      .findUnique();
+
+    Assert.assertNotNull(e2);
+
+    e2.setName("banaban2");
+    Ebean.save(e2);
+
+    Ebean.delete(e2);
+  }
+
+
+  public void testWithVersion() {
+
+    TMapSuperEntity e = new TMapSuperEntity();
+    e.setName("babanatwo");
+
+    Ebean.save(e);
+
+    // select includes a transient property
+    TMapSuperEntity e2 = Ebean.find(TMapSuperEntity.class)
+      .where().idEq(e.getId())
+      .select("id, name, version")
+      .findUnique();
+
+    Assert.assertNotNull(e2);
+
+    e2.setName("banaban2two");
+    Ebean.save(e2);
+
+    Ebean.delete(e2);
+  }
+}

src/test/java/org/tests/basic/TestDynamicUpdate.java

@@ -0,0 +1,53 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import org.tests.model.embedded.EMain;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestDynamicUpdate extends BaseTestCase {
+
+  @Test
+  public void testUpdate() {
+
+    // insert
+    EMain b = new EMain();
+    b.setName("aaa");
+    b.getEmbeddable().setDescription("123");
+
+    EbeanServer server = Ebean.getServer(null);
+
+    server.save(b);
+
+    Assert.assertNotNull(b.getId());
+
+    // reload object und update the name
+    EMain b2 = server.find(EMain.class, b.getId());
+
+    b2.getEmbeddable().setDescription("ABC");
+
+    BeanState beanState = server.getBeanState(b2);
+    boolean dirty = beanState.isDirty();
+    Assert.assertTrue(dirty);
+
+    server.save(b2);
+
+    server.beginTransaction();
+    try {
+      EMain b3 = server.find(EMain.class, b.getId());
+      Assert.assertEquals("ABC", b3.getEmbeddable().getDescription());
+    } finally {
+      server.endTransaction();
+    }
+    EMain b4 = server.find(EMain.class, b.getId());
+    b4.setName("bbb");
+    b4.getEmbeddable().setDescription("123");
+    server.save(b4);
+
+    EMain b5 = server.find(EMain.class, b.getId());
+    Assert.assertEquals("123", b5.getEmbeddable().getDescription());
+  }
+}

src/test/java/org/tests/basic/TestEnhancementCollectionInitialisation.java

@@ -0,0 +1,28 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.Ebean;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+
+public class TestEnhancementCollectionInitialisation extends BaseTestCase {
+
+  @Test
+  public void testListInitialisation() {
+
+    Customer customer = new Customer();
+    BeanState beanState = Ebean.getBeanState(customer);
+    if (beanState != null) {
+      List<Order> orders = customer.getOrders();
+      Assert.assertNotNull(orders);
+    }
+
+  }
+
+}

src/test/java/org/tests/basic/TestErrorBindLog.java

@@ -0,0 +1,24 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Order;
+import org.junit.Assert;
+import org.junit.Test;
+
+import javax.persistence.PersistenceException;
+
+public class TestErrorBindLog extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    try {
+      Ebean.find(Order.class).where().gt("id", "JUNK").findList();
+
+    } catch (PersistenceException e) {
+      String msg = e.getMessage();
+      Assert.assertTrue(msg.contains("Bind values:"));
+    }
+  }
+}

src/test/java/org/tests/basic/TestExplicitInsert.java

@@ -0,0 +1,90 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.EBasic;
+import org.tests.model.basic.MyEBasicConfigStartup;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
+public class TestExplicitInsert extends BaseTestCase {
+
+  @Test
+  public void setId_when_converted() {
+
+    EbeanServer server = Ebean.getDefaultServer();
+
+    Customer cust = new Customer();
+    Object returnId = server.setBeanId(cust, "42");
+
+    assertThat(returnId).isEqualTo(42);
+    assertThat(cust.getId()).isEqualTo(42);
+  }
+
+  @Test
+  public void setId_when_correctType() {
+
+    EbeanServer server = Ebean.getDefaultServer();
+
+    Customer customer = new Customer();
+    Object returnId = server.setBeanId(customer, 42);
+
+    assertThat(returnId).isEqualTo(42);
+    assertThat(customer.getId()).isEqualTo(42);
+  }
+
+  @Test
+  public void test() throws InterruptedException {
+
+    Thread.sleep(100);
+
+    MyEBasicConfigStartup.resetCounters();
+
+    EBasic b = new EBasic();
+    b.setName("exp insert");
+    b.setDescription("explicit insert");
+    b.setStatus(EBasic.Status.ACTIVE);
+
+    EbeanServer server = Ebean.getDefaultServer();
+    server.insert(b);
+
+    Assert.assertNotNull(b.getId());
+
+    Assert.assertEquals(b.getId(), server.getBeanId(b));
+
+
+    EBasic b2 = server.find(EBasic.class, b.getId());
+    b2.setId(null);
+
+    b2.setName("force insert");
+    server.insert(b2);
+
+    Assert.assertNotNull(b2.getId());
+    Assert.assertTrue(!b.getId().equals(b2.getId()));
+
+    List<EBasic> list = server.find(EBasic.class).where().in("id", b.getId(), b2.getId()).findList();
+
+    assertEquals(2, list.size());
+
+    b2.setName("do an update");
+    server.save(b2);
+
+    server.delete(b);
+    server.delete(b2);
+
+    // just sleep a little to allow the background thread to fire
+    Thread.sleep(100);
+
+    assertEquals(2, MyEBasicConfigStartup.insertCount.get());
+    assertEquals(1, MyEBasicConfigStartup.updateCount.get());
+    assertEquals(2, MyEBasicConfigStartup.deleteCount.get());
+  }
+
+}

src/test/java/org/tests/basic/TestFetchId.java

@@ -0,0 +1,39 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.FutureIds;
+import io.ebean.Query;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestFetchId extends BaseTestCase {
+
+  @Test
+  public void testFetchId() throws InterruptedException, ExecutionException {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .where().gt("id", 1)
+      .gt("details.id", 0)
+      .query();
+
+    List<Object> ids = Ebean.getServer(null).findIds(query, null);
+    assertThat(ids).isNotEmpty();
+
+    FutureIds<Order> futureIds = Ebean.getServer(null).findFutureIds(query, null);
+
+    // wait for all the id's to be fetched
+    List<Object> idList = futureIds.get();
+    assertThat(idList).isNotEmpty();
+  }
+}

src/test/java/org/tests/basic/TestIUDVanilla.java

@@ -0,0 +1,51 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.EBasicVer;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+
+public class TestIUDVanilla extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    EBasicVer e0 = new EBasicVer("vanilla");
+
+    Ebean.save(e0);
+
+    Assert.assertNotNull(e0.getId());
+    Assert.assertNotNull(e0.getLastUpdate());
+
+    Timestamp lastUpdate0 = e0.getLastUpdate();
+
+    e0.setName("modified");
+    Ebean.save(e0);
+
+    Timestamp lastUpdate1 = e0.getLastUpdate();
+    Assert.assertNotNull(lastUpdate1);
+    Assert.assertNotSame(lastUpdate0, lastUpdate1);
+
+    EBasicVer e2 = Ebean.getServer(null).createEntityBean(EBasicVer.class);
+
+    e2.setId(e0.getId());
+    e2.setLastUpdate(lastUpdate1);
+
+    e2.setName("forcedUpdate");
+    Ebean.update(e2);
+
+    EBasicVer e3 = new EBasicVer("ModNoOCC");
+    e3.setId(e0.getId());
+
+    Ebean.update(e3);
+
+    e3.setName("ModAgain");
+    e3.setDescription("Banana");
+
+    Ebean.update(e3);
+
+  }
+}

src/test/java/org/tests/basic/TestInEmpty.java

@@ -0,0 +1,37 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.Order;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.StrictAssertions.assertThat;
+import static org.junit.Assert.assertEquals;
+
+public class TestInEmpty extends BaseTestCase {
+
+  @Test
+  public void test_in_empty() {
+
+    Query<Order> query = Ebean.find(Order.class).where().in("id", new Object[0]).gt("id", 0)
+      .query();
+
+    List<Order> list = query.findList();
+    assertThat(query.getGeneratedSql()).contains("1=0");
+    assertEquals(0, list.size());
+  }
+
+  @Test
+  public void test_notIn_empty() {
+
+    Query<Order> query = Ebean.find(Order.class).where().notIn("id", new Object[0]).gt("id", 0)
+      .query();
+
+    query.findList();
+    assertThat(query.getGeneratedSql()).contains("1=1");
+  }
+
+}

src/test/java/org/tests/basic/TestInheritRef.java

@@ -0,0 +1,58 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Car;
+import org.tests.model.basic.Truck;
+import org.tests.model.basic.Vehicle;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestInheritRef extends BaseTestCase {
+
+  @Test
+  public void testAssocOne() {
+
+    Ebean.beginTransaction();
+    try {
+      Ebean.createUpdate(Vehicle.class, "delete from vehicle");
+
+      Car c = new Car();
+      c.setLicenseNumber("C6788");
+      c.setDriver("CarDriver");
+      Ebean.save(c);
+
+      Truck t = new Truck();
+      t.setLicenseNumber("T1098BBX");
+      t.setCapacity(20D);
+      Ebean.save(t);
+
+      List<Vehicle> list = Ebean.find(Vehicle.class)
+        .setAutoTune(false)
+        .findList();
+
+      Assert.assertTrue(!list.isEmpty());
+
+      Truck foundTruck = null;
+      int found = 0;
+
+      for (Vehicle vehicle : list) {
+        if (vehicle instanceof Truck) {
+          Truck truck = (Truck) vehicle;
+          if ("T1098BBX".equals(truck.getLicenseNumber())) {
+            found++;
+            foundTruck = truck;
+          }
+        }
+      }
+
+      Assert.assertEquals(1, found);
+      Assert.assertTrue(foundTruck.getCapacity() == 20D);
+
+    } finally {
+      Ebean.rollbackTransaction();
+    }
+  }
+}

src/test/java/org/tests/basic/TestJodaType.java

@@ -0,0 +1,43 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import io.ebeaninternal.server.deploy.BeanProperty;
+import io.ebeaninternal.server.type.ScalarType;
+import org.tests.model.basic.TJodaEntity;
+import org.joda.time.LocalTime;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestJodaType extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+    BeanDescriptor<TJodaEntity> beanDescriptor = server.getBeanDescriptor(TJodaEntity.class);
+    BeanProperty beanProperty = beanDescriptor.getBeanProperty("localTime");
+    ScalarType<?> scalarType = beanProperty.getScalarType();
+
+    Assert.assertNotNull(scalarType);
+  }
+
+  @Test
+  public void test_insert_find() {
+
+    LocalTime now = new LocalTime().withMillisOfSecond(0);
+
+    TJodaEntity bean = new TJodaEntity();
+    bean.setLocalTime(now);
+    Ebean.save(bean);
+
+    TJodaEntity foundBean = Ebean.find(TJodaEntity.class, bean.getId());
+
+    assertThat(foundBean.getLocalTime()).isEqualTo(bean.getLocalTime());
+  }
+
+}

src/test/java/org/tests/basic/TestJoinInheritance.java

@@ -0,0 +1,80 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Car;
+import org.tests.model.basic.Trip;
+import org.tests.model.basic.Vehicle;
+import org.tests.model.basic.VehicleDriver;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+import java.util.Date;
+
+public class TestJoinInheritance extends BaseTestCase {
+
+
+  /**
+   * Test join hierarchy assoc one.
+   * <p>
+   * This test catches the problem where the discriminator column is select
+   * but is not skipped if the parent bean is already in the presistence context.
+   * <p>
+   * Test case: We have several trips with different addresses but always the same
+   * driver and car (the cars could be different). So the driver will be loaded
+   * when the first trip is loaded but when the second trip is loaded the driver is
+   * found in the persistence context. So the bean is not read but the index in the
+   * result set is forwarded by the number of properties - however, the vehicle type
+   * column was not being skipped - but the query reads happily - only the data is
+   * then wrong in the address object.
+   */
+  @Test
+  public void testJoinHierarchyAssocOne() {
+
+    Ebean.createUpdate(Vehicle.class, "delete from vehicle");
+
+
+    Address address = new Address();
+    address.setLine1("Street");
+    address.setLine2("Street");
+    address.setCity("City");
+
+    address.setCretime(new Timestamp(new Date().getTime()));
+
+    Ebean.save(address);
+
+    Car c = new Car();
+    c.setLicenseNumber("C6788");
+    c.setDriver("CarDriver");
+    c.setRegistrationDate(new Date());
+    Ebean.save(c);
+
+    VehicleDriver driver = new VehicleDriver();
+
+    driver.setVehicle(c);
+    driver.setAddress(address);
+    driver.setLicenseIssuedOn(new Date());
+    Ebean.save(driver);
+
+    final String line1 = "Street1";
+    final String line2 = "Street2";
+    final String city = "City";
+
+    int nrDrivers = 2;
+    for (int i = 0; i < nrDrivers; i++) {
+      Address address1 = new Address();
+      address1.setLine1(line1);
+      address1.setLine2(line2);
+      address1.setCity(city);
+      Ebean.save(address1);
+
+      Trip trip = new Trip();
+      trip.setVehicleDriver(driver);
+      trip.setAddress(address1);
+      trip.setCretime(new Timestamp(new Date().getTime()));
+      Ebean.save(trip);
+    }
+
+  }
+}

src/test/java/org/tests/basic/TestLazyLoadEmptyOneToMany.java

@@ -0,0 +1,37 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Contact;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestLazyLoadEmptyOneToMany extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    Customer c = new Customer();
+    c.setName("testll");
+
+    Ebean.save(c);
+
+    Customer c1 = Ebean.find(Customer.class)
+      .setAutoTune(false)
+      .select("id")
+      .fetch("contacts", "id")
+      .where().idEq(c.getId())
+      .findUnique();
+
+    List<Contact> contacts = c1.getContacts();
+    int sz = contacts.size();
+
+    Assert.assertTrue(sz == 0);
+  }
+}

src/test/java/org/tests/basic/TestLazyLoadInCache.java

@@ -0,0 +1,63 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.Ebean;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class TestLazyLoadInCache extends BaseTestCase {
+
+  @Test
+  public void testLoadInCache() {
+
+    ResetBasicData.reset();
+
+    Map<Integer, Customer> map = Ebean.find(Customer.class)
+      .select("id, name")
+      .setLoadBeanCache(true)
+      .setReadOnly(true)
+      .orderBy().asc("id")
+      .findMap();
+
+    assertTrue(!map.isEmpty());
+
+    Object id = map.keySet().iterator().next();
+
+    Customer cust1 = map.get(id);
+
+    Customer cust1B = Ebean.find(Customer.class)
+      .setReadOnly(true)
+      .setId(id)
+      .findUnique();
+
+    assertTrue(cust1 != cust1B);
+
+    Set<String> loadedProps = Ebean.getBeanState(cust1).getLoadedProps();
+
+    assertTrue(loadedProps.contains("name"));
+    assertFalse(loadedProps.contains("status"));
+
+    cust1.getStatus();
+
+    // a readOnly reference
+    Address billingAddress = cust1.getBillingAddress();
+    BeanState billAddrState = Ebean.getBeanState(billingAddress);
+    assertTrue(billAddrState.isReference());
+    assertTrue(billAddrState.isReadOnly());
+
+    // lazy load .. no longer a reference
+    billingAddress.getCity();
+    assertFalse(billAddrState.isReference());
+
+  }
+
+}

src/test/java/org/tests/basic/TestLimitQuery.java

@@ -0,0 +1,139 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+public class TestLimitQuery extends BaseTestCase {
+
+  @Test
+  public void testLimitWithMany() {
+    rob();
+    rob();
+  }
+
+  @Test
+  public void testMaxRowsZeroWithFirstRow() {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .where().gt("details.id", 0)
+      .setMaxRows(0)
+      .setFirstRow(3)
+      .order().asc("orderDate");
+
+    query.findList();
+
+    String sql = query.getGeneratedSql();
+    if (isH2()) {
+      assertThat(sql).contains("offset 3");
+      assertThat(sql).contains("limit 0");
+    }
+  }
+
+  @Test
+  public void testMaxRowsWithFirstRowZero() {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .where().gt("details.id", 0)
+      .setMaxRows(3)
+      .setFirstRow(0);
+
+    query.findList();
+
+    String sql = query.getGeneratedSql();
+    boolean hasLimit = sql.contains("limit 3");
+    boolean hasOffset = sql.contains("offset");
+
+    if (isH2()) {
+      Assert.assertTrue(sql, hasLimit);
+      Assert.assertFalse(sql, hasOffset);
+    }
+  }
+
+  @Test
+  public void testDefaults() {
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .where().gt("details.id", 0)
+      .query();
+
+    query.findList();
+
+    String sql = query.getGeneratedSql();
+    boolean hasLimit = sql.contains("limit");
+    boolean hasOffset = sql.contains("offset");
+
+    if (isH2()) {
+      Assert.assertFalse(hasLimit);
+      Assert.assertFalse(hasOffset);
+    }
+  }
+
+  private void rob() {
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .where().gt("details.id", 0)
+      .setMaxRows(10);
+    //.findList();
+
+    List<Order> list = query.findList();
+
+    Assert.assertTrue("sz > 0", !list.isEmpty());
+
+    String sql = query.getGeneratedSql();
+    boolean hasDetailsJoin = sql.contains("join o_order_detail");
+    boolean hasLimit = sql.contains("limit 10");
+    boolean hasSelectedDetails = sql.contains("od.id,");
+    boolean hasDistinct = sql.contains("select distinct");
+
+    Assert.assertTrue(hasDetailsJoin);
+    Assert.assertFalse(hasSelectedDetails);
+    Assert.assertTrue(hasDistinct);
+    if (isH2()) {
+      Assert.assertTrue(hasLimit);
+    }
+
+    query = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .fetch("details")
+      .setMaxRows(10);
+
+    query.findList();
+
+    sql = query.getGeneratedSql();
+    hasDetailsJoin = sql.contains("left join o_order_detail");
+    hasLimit = sql.contains("limit 10");
+    hasSelectedDetails = sql.contains("od.id");
+    hasDistinct = sql.contains("select distinct");
+
+    Assert.assertFalse("no join with maxRows", hasDetailsJoin);
+    Assert.assertFalse(hasSelectedDetails);
+    Assert.assertFalse(hasDistinct);
+    if (isH2()) {
+      Assert.assertTrue(hasLimit);
+    }
+  }
+}

src/test/java/org/tests/basic/TestLoadBeanCache.java

@@ -0,0 +1,33 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Country;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Map;
+
+public class TestLoadBeanCache extends BaseTestCase {
+
+  @Test
+  public void testLoad() {
+
+    ResetBasicData.reset();
+
+    Map<String, Country> map = Ebean.find(Country.class)
+      .setLoadBeanCache(true)
+      .setUseQueryCache(true)
+      .setReadOnly(true)
+      .order("name")
+      .findMap();
+
+    Country loadedNz = map.get("NZ");
+
+    // this will hit the cache
+    Country nz = Ebean.find(Country.class, "NZ");
+
+    Assert.assertTrue(loadedNz == nz);
+  }
+}

src/test/java/org/tests/basic/TestLogTransLogOnError.java

@@ -0,0 +1,78 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.EBasicVer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestLogTransLogOnError extends BaseTestCase {
+
+  @Test
+  public void testQueryError() {
+
+    ResetBasicData.reset();
+
+    Ebean.beginTransaction();
+    try {
+
+      Ebean.find(Customer.class).findList();
+      Ebean.find(Order.class).where().gt("id", 1).findList();
+
+      EBasicVer newBean = new EBasicVer("aName");
+      newBean.setDescription("something");
+
+      // Ebean.save(newBean);
+
+      // t.log("--- next query should error");
+      List<Customer> list = Ebean.find(Customer.class).where().eq("id", "NotAnInt!!").findList();
+
+      Assert.assertEquals(0, list.size());
+      // Get here with mysql?
+      // Assert.assertTrue(false);
+
+    } catch (RuntimeException e) {
+      // e.printStackTrace();
+      Assert.assertTrue(true);
+
+    } finally {
+      Ebean.endTransaction();
+    }
+  }
+
+  public void testPersistError() {
+
+    ResetBasicData.reset();
+
+    Ebean.beginTransaction();
+    try {
+      Ebean.find(Customer.class).findList();
+
+      EBasicVer newBean = new EBasicVer("aName");
+      newBean
+        .setDescription("something sdfjksdjflsjdflsjdflksjdfkjd fsjdfkjsdkfjsdkfjskdjfskjdf"
+          + " sjdf sdjflksjdfkjsdlfkjsdkfjs ksjdfksjdlfjsldf something sdfjksdjflsjdflsjdflksjdfkjd"
+          + "fsjdfkjsdkfjsdkfjskdjfskjdf sjdf sdjflksjdfkjsdlfkjsdkfjs ksjdfksjdlfjsldf something s"
+          + "dfjksdjflsjdflsjdflksjdfkjd fsjdfkjsdkfjsdkfjskdjfskjdf sjdf sdjflksjdfkjsdlfkjsdkfjs ");
+
+      // t.log("--- next insert should error");
+      Ebean.save(newBean);
+
+      // never get here
+      Assert.assertTrue(false);
+
+    } catch (RuntimeException e) {
+      // e.printStackTrace();
+      Assert.assertTrue(true);
+
+    } finally {
+      Ebean.endTransaction();
+    }
+
+  }
+}

src/test/java/org/tests/basic/TestM2MCascadeOne.java

@@ -0,0 +1,48 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.MRole;
+import org.tests.model.basic.MUser;
+import org.junit.Test;
+
+public class TestM2MCascadeOne extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    MUser u = new MUser();
+    u.setUserName("testM2M");
+
+    u.getRoles();
+    Ebean.save(u);
+
+    MRole r0 = new MRole();
+    r0.setRoleName("rol_0");
+    Ebean.save(r0);
+
+    MRole r1 = new MRole();
+    r1.setRoleName("rol_1");
+
+    MUser u1 = Ebean.find(MUser.class, u.getUserid());
+
+    u1.addRole(r0);
+    u1.addRole(r1);
+
+    Ebean.save(u1);
+
+  }
+
+  @Test
+  public void testRawPredicate_with_ManyToManyPath() {
+
+    Query<MUser> query = Ebean.find(MUser.class)
+      .select("userid")
+      .where().raw("roles.roleid in (?)", 24)
+      .query();
+
+    query.findList();
+
+  }
+}

src/test/java/org/tests/basic/TestM2MVanilla.java

@@ -0,0 +1,102 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import io.ebean.SqlUpdate;
+import org.tests.model.basic.MRole;
+import org.tests.model.basic.MUser;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TestM2MVanilla extends BaseTestCase {
+
+  @Test
+  public void testVanilla() {
+
+    SqlUpdate delInt = Ebean.createSqlUpdate("delete from mrole_muser");
+    SqlUpdate delRoles = Ebean.createSqlUpdate("delete from mrole");
+    SqlUpdate delUsers = Ebean.createSqlUpdate("delete from muser");
+
+    Ebean.execute(delInt);
+    Ebean.execute(delRoles);
+    Ebean.execute(delUsers);
+
+    MRole r1 = new MRole();
+    r1.setRoleName("role1");
+    Ebean.save(r1);
+
+    MRole r2 = new MRole();
+    r2.setRoleName("role2");
+    Ebean.save(r2);
+
+    MRole r3 = new MRole();
+    r3.setRoleName("role3");
+    Ebean.save(r3);
+
+    MUser u0 = new MUser();
+    u0.setUserName("something");
+
+    Ebean.save(u0);
+
+    MUser user = Ebean.find(MUser.class, u0.getUserid());
+
+    List<MRole> roleList = new ArrayList<>();
+    roleList.add(r1);
+    roleList.add(r2);
+
+    user.setRoles(roleList);
+
+    Ebean.save(user);
+    // Ebean.saveManyToManyAssociations(user, "roles");
+
+    MUser checkUser = Ebean.find(MUser.class, u0.getUserid());
+    List<MRole> checkRoles = checkUser.getRoles();
+    Assert.assertNotNull(checkRoles);
+    Assert.assertEquals(2, checkRoles.size());
+
+    checkRoles.add(r3);
+
+    Ebean.save(checkUser);
+    // Ebean.saveManyToManyAssociations(checkUser, "roles");
+
+    MUser checkUser2 = Ebean.find(MUser.class, u0.getUserid());
+    List<MRole> checkRoles2 = checkUser2.getRoles();
+    Assert.assertNotNull(checkRoles2);
+    Assert.assertEquals("added a role", 3, checkRoles2.size());
+
+    Query<MUser> rolesQuery0 = Ebean.find(MUser.class).where().eq("roles", r1).query();
+
+    rolesQuery0.findList();
+
+    Query<MUser> rolesQuery = Ebean.find(MUser.class).where().in("roles", roleList).query();
+
+    List<MUser> userInRolesList = rolesQuery.findList();
+    Assert.assertTrue(!userInRolesList.isEmpty());
+
+    List<MUser> list = Ebean.find(MUser.class)
+      .where().in("roles", roleList)
+      .filterMany("roles").eq("roleName", "role1")
+      .findList();
+
+    MUser mUser = list.get(0);
+    List<MRole> roles = mUser.getRoles();
+    Assert.assertEquals(1, roles.size());
+
+    checkRoles2.remove(0);
+    checkRoles2.remove(0);
+    Ebean.save(checkUser2);
+
+    checkUser2 = Ebean.find(MUser.class, u0.getUserid());
+    checkRoles2 = checkUser2.getRoles();
+    Assert.assertNotNull(checkRoles2);
+    Assert.assertEquals("added a role", 1, checkRoles2.size());
+
+    Ebean.delete(checkUser2);
+
+  }
+
+}

src/test/java/org/tests/basic/TestManyLazyLoad.java

@@ -0,0 +1,64 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.OrderDetail;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.sql.Date;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class TestManyLazyLoad extends BaseTestCase {
+
+  @Test
+  public void testLazyLoadRef() throws InterruptedException {
+
+    ResetBasicData.reset();
+
+    awaitL2Cache();
+
+    List<Order> list = Ebean.find(Order.class).order().asc("id").findList();
+    assertTrue(list.size() + " > 0", !list.isEmpty());
+
+    // just use the first one
+    Order order = list.get(0);
+
+    // get it as a reference
+    Order order1 = Ebean.getReference(Order.class, order.getId());
+    assertNotNull(order1);
+
+    Date orderDate = order1.getOrderDate();
+    assertNotNull(orderDate);
+
+    List<OrderDetail> details = order1.getDetails();
+
+    // lazy load the details
+    int sz = details.size();
+    assertTrue(sz + " > 0", sz > 0);
+
+    OrderDetail orderDetail = details.get(0);
+    Order o = orderDetail.getOrder();
+    assertSame(o, order1);
+
+    // load detail into cache
+    Ebean.find(OrderDetail.class, orderDetail.getId());
+
+    // change order... list before a scalar property
+    Order order2 = Ebean.getReference(Order.class, order.getId());
+    assertNotNull(order2);
+
+    List<OrderDetail> details2 = order2.getDetails();
+
+    // lazy load the details
+    int sz2 = details2.size();
+    assertTrue(sz2 + " > 0", sz2 > 0);
+
+    Order o2 = details2.get(0).getOrder();
+    assertSame(o2, order2);
+  }
+
+}

src/test/java/org/tests/basic/TestManyOneInterface.java

@@ -0,0 +1,31 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.ResetBasicData;
+import org.tests.model.interfaces.Address;
+import org.tests.model.interfaces.IAddress;
+import org.tests.model.interfaces.IPerson;
+import org.tests.model.interfaces.Person;
+import org.junit.Test;
+
+public class TestManyOneInterface extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    IAddress a = new Address();
+
+    IPerson p = new Person();
+
+    p.setDefaultAddress(a);
+
+    Ebean.save(a);
+    Ebean.save(p);
+
+    //Assert.assertTrue();
+
+  }
+}

src/test/java/org/tests/basic/TestMappedSuper.java

@@ -0,0 +1,35 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TMapSuperEntity;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestMappedSuper extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    TMapSuperEntity e = new TMapSuperEntity();
+    e.setName("babana");
+
+    Ebean.save(e);
+
+    // select includes a transient property
+    TMapSuperEntity e2 = Ebean.find(TMapSuperEntity.class)
+      .where().idEq(e.getId())
+      .select("id, name, myint, someObject, bananan")
+      .findUnique();
+
+    Assert.assertNotNull(e2);
+
+    TMapSuperEntity eSaveDelete = new TMapSuperEntity();
+    eSaveDelete.setName("babana");
+
+    Ebean.save(eSaveDelete);
+
+    Ebean.delete(eSaveDelete);
+  }
+
+}

src/test/java/org/tests/basic/TestMetaAnnotation.java

@@ -0,0 +1,81 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.metaannotation.SizeMedium;
+import org.junit.Test;
+
+import javax.persistence.PersistenceException;
+
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Very simple test case to check if Ebean recognizes meta-annotation correctly.
+ *
+ * @author Roland Praml, FOCONIS AG
+ */
+public class TestMetaAnnotation extends BaseTestCase {
+
+  private static final String spaces100 = new String(new char[100]).replace('\0', ' ');
+  private static final String spaces101 = new String(new char[101]).replace('\0', ' ');
+
+  /**
+   * This test writes 100 spaces to "line1" which is annotated with @Size(max=100)
+   */
+  @Test
+  public void testWrite100SpacesToLine1() {
+
+    Address address = new Address();
+    address.setLine1(spaces100);
+    Ebean.save(address);
+  }
+
+  /**
+   * This test writes 100 spaces to "line1" which is meta-annotated with {@link SizeMedium}.
+   */
+  @Test
+  public void testWrite100SpacesToLine2() {
+
+    Address address = new Address();
+    address.setLine2(spaces100);
+    Ebean.save(address);
+  }
+
+  /**
+   * This test writes 101 spaces to "line1" which is annotated with @Size(max=100).
+   */
+  @Test
+  public void testWrite101SpacesToLine1() {
+
+    if (isH2()) {
+      Address address = new Address();
+      address.setLine1(spaces101);
+      try {
+        Ebean.save(address);
+        assertTrue("H2 fails this insert", false);
+      } catch (PersistenceException e) {
+        assertTrue(true);
+      }
+    }
+  }
+
+  /**
+   * This test writes 101 spaces to "line1" which is meta-annotated with {@link SizeMedium}.
+   */
+  @Test
+  public void testWrite101SpacesToLine2() {
+
+    if (isH2()) {
+      Address address = new Address();
+      address.setLine2(spaces101);
+      try {
+        Ebean.save(address);
+        assertTrue("H2 fails this insert", false);
+      } catch (PersistenceException e) {
+        assertTrue(true);
+      }
+    }
+  }
+
+}

src/test/java/org/tests/basic/TestMultipleOneToOneIUD.java

@@ -0,0 +1,60 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.OCar;
+import org.tests.model.basic.OEngine;
+import org.tests.model.basic.OGearBox;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestMultipleOneToOneIUD extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    OEngine engine = new OEngine();
+    engine.setShortDesc("engine 1");
+
+    OGearBox gearBox = new OGearBox();
+    gearBox.setBoxDesc("6 speed manual");
+    gearBox.setSize(6);
+
+    OCar car = new OCar();
+    car.setVin("xx4534");
+    car.setName("test car");
+    car.setEngine(engine);
+
+    Ebean.beginTransaction();
+    try {
+      Ebean.save(gearBox);
+      Ebean.save(car);
+
+      Assert.assertNotNull(car.getId());
+      Assert.assertNotNull(engine.getEngineId());
+      Assert.assertNotNull(gearBox.getId());
+
+      Ebean.commitTransaction();
+
+    } finally {
+      Ebean.endTransaction();
+    }
+
+    OCar c2 = Ebean.find(OCar.class, car.getId());
+    Assert.assertNotNull(c2);
+    Assert.assertNotNull(c2.getEngine());
+    // gearBox not assigned yet
+    Assert.assertNull(c2.getGearBox());
+
+    // ok, assign gearBox
+    c2.setGearBox(gearBox);
+    Ebean.save(c2);
+
+    // now all should be there...
+    OCar c3 = Ebean.find(OCar.class, car.getId());
+    Assert.assertNotNull(c3);
+    Assert.assertNotNull(c3.getEngine());
+    Assert.assertNotNull(c3.getGearBox());
+
+  }
+}

src/test/java/org/tests/basic/TestNonUpdateProperty.java

@@ -0,0 +1,25 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.MNonUpdPropEntity;
+import org.junit.Test;
+
+public class TestNonUpdateProperty extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    MNonUpdPropEntity e = new MNonUpdPropEntity();
+    e.setName("name");
+    e.setNote("note");
+
+    Ebean.save(e);
+
+    MNonUpdPropEntity e2 = Ebean.find(MNonUpdPropEntity.class, e.getId());
+
+    e2.setName("mod");
+    Ebean.update(e2);
+
+  }
+}

src/test/java/org/tests/basic/TestOrderByAnnotation.java

@@ -0,0 +1,37 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestOrderByAnnotation extends BaseTestCase {
+
+  @Test
+  public void testOrderBy() {
+
+    ResetBasicData.reset();
+    Customer custTest = ResetBasicData.createCustAndOrder("testOrderByAnn");
+
+    Customer customer = Ebean.find(Customer.class, custTest.getId());
+    List<Order> orders = customer.getOrders();
+
+    Assert.assertTrue(!orders.isEmpty());
+
+
+    Query<Order> q1 = Ebean.find(Order.class)
+      .fetch("details");
+
+    q1.findList();
+
+    String s1 = q1.getGeneratedSql();
+
+    Assert.assertTrue(s1.contains("order by t0.id, t1.id asc, t1.order_qty asc, t1.cretime desc"));
+  }
+}

src/test/java/org/tests/basic/TestOrderTotalAmountFormula.java

@@ -0,0 +1,38 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestOrderTotalAmountFormula extends BaseTestCase {
+
+  @Test
+  public void testAsJoin() {
+
+    ResetBasicData.reset();
+
+    List<Customer> l0 = Ebean.find(Customer.class)
+      .select("id, name")
+      .fetch("orders", "status, totalAmount")
+      .where()
+      .eq("orders.details.product.name", "Desk")
+      .like("contacts.firstName", "Ji%")
+      .findList();
+
+    for (Customer c0 : l0) {
+      c0.getId();
+      List<Order> orders = c0.getOrders();
+      for (Order order : orders) {
+        order.getId();
+      }
+    }
+
+  }
+
+
+}

src/test/java/org/tests/basic/TestOrderTotalAmountReportBean.java

@@ -0,0 +1,153 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import io.ebean.RawSql;
+import io.ebean.RawSqlBuilder;
+import org.tests.model.basic.OrderAggregate;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertNotNull;
+
+public class TestOrderTotalAmountReportBean extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    String sql =
+      "select order_id, count(*) as totalItems, sum(order_qty*unit_price) as totalAmount \n" +
+        "from o_order_detail \n" +
+        "group by order_id";
+
+    RawSql rawSql = RawSqlBuilder.parse(sql).columnMapping("order_id", "order.id").create();
+
+    List<OrderAggregate> l0 =
+      Ebean.find(OrderAggregate.class)
+        .setRawSql(rawSql)
+        .findList();
+
+    for (OrderAggregate r0 : l0) {
+      r0.toString();
+    }
+
+    List<OrderAggregate> l2 = Ebean.createQuery(OrderAggregate.class)
+      .setRawSql(rawSql)
+      .where().gt("order.id", 0)
+      .having().lt("totalItems", 3).gt("totalAmount", 50).findList();
+
+    for (OrderAggregate r2 : l2) {
+      Assert.assertTrue(r2.getTotalItems() < 3);
+    }
+
+  }
+
+  @Test
+  public void test_when_aliasInUnderscore() {
+
+    ResetBasicData.reset();
+
+    String sql =
+      "select order_id, count(*) as total_items, sum(order_qty*unit_price) as total_amount \n" +
+        "from o_order_detail \n" +
+        "group by order_id";
+
+    RawSql rawSql = RawSqlBuilder.parse(sql)
+      .columnMapping("order_id", "order.id")
+      .create();
+
+    Query<OrderAggregate> query = Ebean.find(OrderAggregate.class)
+      .setRawSql(rawSql);
+
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("count(*) as total_items, sum(order_qty*unit_price) as total_amount");
+  }
+
+  @Test
+  public void test_when_aliasInCamelCase() {
+
+    ResetBasicData.reset();
+
+    String sql =
+      "select order_id, count(*) as totalItems, sum(order_qty*unit_price) as totalAmount \n" +
+        "from o_order_detail \n" +
+        "group by order_id";
+
+    RawSql rawSql = RawSqlBuilder.parse(sql)
+      .columnMapping("order_id", "order.id")
+      .create();
+
+    Query<OrderAggregate> query = Ebean.find(OrderAggregate.class)
+      .setRawSql(rawSql);
+
+    query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("count(*) as totalItems, sum(order_qty*unit_price) as totalAmount");
+  }
+
+  @Test
+  public void testDefaultNamedRawSql() {
+
+    Query<OrderAggregate> query = Ebean.find(OrderAggregate.class);
+    List<OrderAggregate> list = query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("count(*) as total_items, sum(order_qty*unit_price) as total_amount");
+    assertNotNull(list);
+  }
+
+  @Test
+  public void testNamedRawSql() {
+
+    ResetBasicData.reset();
+
+    Query<OrderAggregate> query = Ebean.getDefaultServer().createNamedQuery(OrderAggregate.class, "withMax");
+    List<OrderAggregate> list = query.findList();
+
+    assertThat(query.getGeneratedSql()).contains("count(*) as total_items, sum(order_qty*unit_price) as total_amount, max(order_qty*unit_price) as maxAmount from o_order_detail");
+    assertNotNull(list);
+  }
+
+  @Test
+  public void testNamedRawSql_with_extraPredicates() {
+
+    ResetBasicData.reset();
+
+    Query<OrderAggregate> query = Ebean.getDefaultServer().createNamedQuery(OrderAggregate.class, "withMax");
+    List<OrderAggregate> list = query
+      .where().gt("order.id", 1)
+      .having().gt("totalItems", 1)
+      .order().desc("totalAmount")
+      .findList();
+
+    assertThat(query.getGeneratedSql()).contains("count(*) as total_items, sum(order_qty*unit_price) as total_amount, max(order_qty*unit_price) as maxAmount from o_order_detail");
+    assertThat(query.getGeneratedSql()).contains("from o_order_detail  where order_id > ?  group by order_id  having count(*) > ?   order by sum(order_qty*unit_price) desc");
+    assertNotNull(list);
+  }
+
+  @Test
+  public void testNamedRawSql_with_param() {
+
+    ResetBasicData.reset();
+
+    Query<OrderAggregate> query = Ebean.getDefaultServer().createNamedQuery(OrderAggregate.class, "withParam");
+    List<OrderAggregate> list = query
+      .setParameter("minId", 2)
+      .where().isNotNull("order.id")
+      .having().lt("totalAmount", 100)
+      .order().desc("totalAmount")
+      .setMaxRows(10)
+      .findList();
+
+    assertThat(query.getGeneratedSql()).contains("count(*) as totalItems, sum(order_qty*unit_price) as totalAmount, max(order_qty*unit_price) as maxAmount from o_order_detail");
+    assertThat(query.getGeneratedSql()).contains("from o_order_detail where id > ?  and order_id is not null  group by order_id  having sum(order_qty*unit_price) < ?   order by sum(order_qty*unit_price) desc");
+    assertNotNull(list);
+  }
+}

src/test/java/org/tests/basic/TestOrderTotalAmountSql.java

@@ -0,0 +1,30 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.SqlRow;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestOrderTotalAmountSql extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    String sql = "select order_id, sum(order_qty*unit_price) as total_amount from o_order_detail  where order_qty > :minQty  group by order_id";
+    List<SqlRow> sqlRows = Ebean.createSqlQuery(sql).setParameter("minQty", 1).findList();
+
+    for (SqlRow sqlRow : sqlRows) {
+      Integer id = sqlRow.getInteger("order_id");
+      Double amount = sqlRow.getDouble("total_amount");
+      Assert.assertNotNull("sqlRows: " + sqlRows, id);
+      Assert.assertNotNull("sqlRows: " + sqlRows, amount);
+    }
+  }
+
+}

src/test/java/org/tests/basic/TestPersistenceContext.java

@@ -0,0 +1,81 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestPersistenceContext extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    // implicit transaction with its own
+    // persistence context
+    Order oBefore = Ebean.find(Order.class, 1);
+
+    Order order = null;
+
+    // start a persistence context
+    Ebean.beginTransaction();
+    try {
+
+      order = Ebean.find(Order.class, 1);
+
+      // not the same instance ...as a different
+      // persistence context
+      Assert.assertTrue(order != oBefore);
+
+
+      // finds an existing bean in the persistence context
+      // ... so doesn't even execute a query
+      Order o2 = Ebean.find(Order.class, 1);
+      Order o3 = Ebean.getReference(Order.class, 1);
+
+      // all the same instance
+      Assert.assertTrue(order == o2);
+      Assert.assertTrue(order == o3);
+
+    } finally {
+      Ebean.endTransaction();
+    }
+
+    // implicit transaction with its own
+    // persistence context
+    Order oAfter = Ebean.find(Order.class, 1);
+
+    Assert.assertTrue(oAfter != oBefore);
+    Assert.assertTrue(oAfter != order);
+
+
+    Order testOrder = ResetBasicData.createOrderCustAndOrder("testPC");
+    Integer id = testOrder.getCustomer().getId();
+    Integer orderId = testOrder.getId();
+
+    // start a persistence context
+    Ebean.beginTransaction();
+    try {
+      Customer customer = Ebean.find(Customer.class)
+        .setUseCache(false)
+        .setId(id)
+        .findUnique();
+
+      System.gc();
+      Order order2 = Ebean.find(Order.class, orderId);
+      Customer customer2 = order2.getCustomer();
+
+      Assert.assertEquals(customer.getId(), customer2.getId());
+
+      Assert.assertTrue(customer == customer2);
+
+    } finally {
+      Ebean.endTransaction();
+    }
+  }
+
+}

src/test/java/org/tests/basic/TestQuery.java

@@ -0,0 +1,47 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestQuery extends BaseTestCase {
+
+  @Test
+  public void testCountOrderBy() {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class).setAutoTune(false).order().asc("orderDate")
+      .order().desc("id");
+    // .orderBy("orderDate");
+
+    int rc = query.findList().size();
+    // int rc = query.findRowCount();
+    Assert.assertTrue(rc > 0);
+    // String generatedSql = query.getGeneratedSql();
+    // Assert.assertFalse(generatedSql.contains("order by"));
+
+  }
+
+  public void testForUpdate() {
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class).setAutoTune(false).setForUpdate(false)
+      .setMaxRows(1).order().asc("orderDate").order().desc("id");
+
+    int rc = query.findList().size();
+    Assert.assertTrue(rc > 0);
+    Assert.assertTrue(!query.getGeneratedSql().toLowerCase().contains("for update"));
+
+    query = Ebean.find(Order.class).setAutoTune(false).setForUpdate(true).setMaxRows(1).order()
+      .asc("orderDate").order().desc("id");
+
+    rc = query.findList().size();
+    Assert.assertTrue(rc > 0);
+    Assert.assertTrue(query.getGeneratedSql().toLowerCase().contains("for update"));
+  }
+}

src/test/java/org/tests/basic/TestQueryWhereBetween.java

@@ -0,0 +1,30 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+
+public class TestQueryWhereBetween extends BaseTestCase {
+
+  @Test
+  public void testCountOrderBy() {
+
+    ResetBasicData.reset();
+
+    Timestamp t = new Timestamp(System.currentTimeMillis());
+
+    Query<Order> query = Ebean.find(Order.class).setAutoTune(false).where()
+      .betweenProperties("cretime", "updtime", t).order().asc("orderDate").order().desc("id");
+
+    query.findList();
+
+    String sql = query.getGeneratedSql();
+    Assert.assertTrue(sql.contains("between t0.cretime and t0.updtime"));
+  }
+}

src/test/java/org/tests/basic/TestQueryWithCache.java

@@ -0,0 +1,73 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import io.ebean.cache.ServerCache;
+import io.ebean.cache.ServerCacheManager;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.server.core.CacheOptions;
+import io.ebeaninternal.server.deploy.BeanDescriptor;
+import org.tests.model.basic.Country;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.*;
+
+public class TestQueryWithCache extends BaseTestCase {
+
+  @Test
+  public void testCountryDeploy() {
+
+    ResetBasicData.reset();
+
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+    BeanDescriptor<Country> beanDescriptor = server.getBeanDescriptor(Country.class);
+    CacheOptions cacheOptions = beanDescriptor.getCacheOptions();
+
+    assertNotNull(cacheOptions);
+    assertTrue(cacheOptions.isReadOnly());
+    assertTrue(beanDescriptor.isCacheSharableBeans());
+
+    ServerCacheManager serverCacheManager = server.getServerCacheManager();
+    serverCacheManager.clear(Country.class);
+
+    ServerCache beanCache = serverCacheManager.getBeanCache(Country.class);
+    assertEquals(0, beanCache.size());
+
+    Country nz1 = Ebean.getReference(Country.class, "NZ");
+    assertEquals(0, beanCache.size());
+
+    // has the effect of loading the cache via lazy loading
+    nz1.getName();
+    assertEquals(1, beanCache.size());
+
+    Country nz2 = Ebean.getReference(Country.class, "NZ");
+    Country nz2b = Ebean.getReference(Country.class, "NZ");
+
+    Country nz3 = Ebean.find(Country.class, "NZ");
+
+    Country nz4 = Ebean.find(Country.class).setId("NZ").setAutoTune(false).setUseCache(false)
+      .findUnique();
+
+    assertTrue(nz2 == nz2b);
+    assertTrue(nz2 == nz3);
+    assertTrue(nz3 != nz4);
+
+  }
+
+  @Test
+  public void testSkipCache() {
+
+    ResetBasicData.reset();
+
+    Ebean.find(Country.class, "NZ");
+
+    Query<Country> query = Ebean.find(Country.class).setId("NZ").setUseCache(false);
+    query.findUnique();
+
+    assertThat(query.getGeneratedSql()).isNotNull();
+  }
+
+}

src/test/java/org/tests/basic/TestReadOnlyPropagation.java

@@ -0,0 +1,91 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.bean.BeanCollection;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.OrderDetail;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+public class TestReadOnlyPropagation extends BaseTestCase {
+
+  @Test
+  public void testReadOnly() {
+
+    ResetBasicData.reset();
+
+    Order order = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .setUseCache(false)
+      .setReadOnly(true)
+      .setId(1)
+      .findUnique();
+
+    Assert.assertTrue(Ebean.getBeanState(order).isReadOnly());
+
+
+    Customer customer = order.getCustomer();
+    Assert.assertTrue(Ebean.getBeanState(customer).isReadOnly());
+
+    Address billingAddress = customer.getBillingAddress();
+    Assert.assertTrue(Ebean.getBeanState(billingAddress).isReadOnly());
+
+
+    List<OrderDetail> details = order.getDetails();
+    BeanCollection<?> bc = (BeanCollection<?>) details;
+
+    Assert.assertTrue(bc.isReadOnly());
+    Assert.assertTrue(!bc.isPopulated());
+
+    bc.size();
+    Assert.assertTrue(!bc.isEmpty());
+    Assert.assertTrue(bc.isReadOnly());
+    Assert.assertTrue(bc.isPopulated());
+    try {
+      details.add(new OrderDetail());
+      Assert.assertTrue(false);
+    } catch (IllegalStateException e) {
+      Assert.assertTrue(true);
+    }
+    try {
+      details.remove(0);
+      Assert.assertTrue(false);
+    } catch (IllegalStateException e) {
+      Assert.assertTrue(true);
+    }
+    try {
+      Iterator<OrderDetail> it = details.iterator();
+      it.next();
+      it.remove();
+      Assert.assertTrue(false);
+    } catch (IllegalStateException e) {
+      Assert.assertTrue(true);
+    }
+    try {
+      ListIterator<OrderDetail> it = details.listIterator();
+      it.next();
+      it.remove();
+      Assert.assertTrue(false);
+    } catch (IllegalStateException e) {
+      Assert.assertTrue(true);
+    }
+    try {
+      List<OrderDetail> subList = details.subList(0, 1);
+      subList.remove(0);
+      Assert.assertTrue(false);
+    } catch (UnsupportedOperationException e) {
+      Assert.assertTrue(true);
+    }
+
+
+  }
+
+}

src/test/java/org/tests/basic/TestSaveDeleteOneToOne.java

@@ -0,0 +1,38 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.PersistentFile;
+import org.tests.model.basic.PersistentFileContent;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestSaveDeleteOneToOne extends BaseTestCase {
+
+  @Test
+  public void testCreateDeletePersistentFile() {
+    PersistentFile persistentFile = new PersistentFile("test.txt",
+      new PersistentFileContent("test".getBytes()));
+
+    Ebean.save(persistentFile);
+    Ebean.delete(persistentFile);
+  }
+
+  @Test
+  public void testCreateLoadDeletePersistentFile() {
+    PersistentFile persistentFile = new PersistentFile("test.txt",
+      new PersistentFileContent("test".getBytes()));
+
+    Ebean.save(persistentFile);
+
+    persistentFile = Ebean.find(PersistentFile.class, persistentFile.getId());
+
+    PersistentFileContent persistentFileContent = persistentFile.getPersistentFileContent();
+
+    Assert.assertNotNull(persistentFileContent);
+
+    Assert.assertNotNull("load byte content", persistentFileContent.getContent());
+
+    Ebean.delete(persistentFile);
+  }
+}

src/test/java/org/tests/basic/TestSaveDeleteOneToOneMultiple.java

@@ -0,0 +1,37 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.PFile;
+import org.tests.model.basic.PFileContent;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestSaveDeleteOneToOneMultiple extends BaseTestCase {
+
+//	public void testCreateDeletePFile() {
+//		PFile persistentFile = new PFile("test.txt",
+//				new PFileContent("test".getBytes()));
+//
+//		Ebean.save(persistentFile);
+//		Ebean.delete(persistentFile);
+//	}
+
+  @Test
+  public void testCreateLoadDeletePFile() {
+    PFile persistentFile = new PFile("test.txt",
+      new PFileContent("test".getBytes()));
+
+    Ebean.save(persistentFile);
+
+    persistentFile = Ebean.find(PFile.class, persistentFile.getId());
+
+    PFileContent persistentFileContent = persistentFile.getFileContent();
+
+    Assert.assertNotNull(persistentFileContent);
+
+    Assert.assertNotNull("load byte content", persistentFileContent.getContent());
+
+    Ebean.delete(persistentFile);
+  }
+}

src/test/java/org/tests/basic/TestSharedInstancePropagation.java

@@ -0,0 +1,63 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.bean.BeanCollection;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.OrderDetail;
+import org.tests.model.basic.Product;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class TestSharedInstancePropagation extends BaseTestCase {
+
+
+  /**
+   * Test that the sharedInstance status is propagated on lazy loading.
+   */
+  @Test
+  public void testSharedListNavigate() {
+
+    ResetBasicData.reset();
+
+    Ebean.getServerCacheManager().clearAll();
+
+    Order order = Ebean.find(Order.class)
+      .setAutoTune(false)
+      .setReadOnly(true)
+      .setId(1)
+      .findUnique();
+
+
+    assertNotNull(order);
+    assertTrue(Ebean.getBeanState(order).isReadOnly());
+
+    List<OrderDetail> details = order.getDetails();
+    BeanCollection<?> bc = (BeanCollection<?>) details;
+    assertTrue(bc.isReadOnly());
+    assertFalse(bc.isPopulated());
+
+    // lazy load
+    bc.size();
+
+    assertTrue(bc.isPopulated());
+    assertTrue(!bc.isEmpty());
+    OrderDetail detail = details.get(0);
+
+    assertTrue(Ebean.getBeanState(detail).isReadOnly());
+    assertFalse(Ebean.getBeanState(detail).isReference());
+
+    Product product = detail.getProduct();
+
+    assertTrue(Ebean.getBeanState(product).isReadOnly());
+
+    // lazy load
+    product.getName();
+    assertFalse(Ebean.getBeanState(product).isReference());
+
+  }
+}

src/test/java/org/tests/basic/TestTransient.java

@@ -0,0 +1,62 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.BeanState;
+import io.ebean.Ebean;
+import org.tests.model.basic.Customer;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestTransient extends BaseTestCase {
+
+  @Test
+  public void testTransient() {
+
+    Customer cnew = new Customer();
+    cnew.setName("testTrans");
+
+    Ebean.save(cnew);
+    Integer custId = cnew.getId();
+
+    Customer c = Ebean.find(Customer.class).setAutoTune(false).setId(custId).findUnique();
+
+    Assert.assertNotNull(c);
+
+    BeanState beanState = Ebean.getBeanState(c);
+    Assert.assertFalse("not new or dirty as transient", beanState.isNewOrDirty());
+
+    c.getLock().tryLock();
+    try {
+      c.setSelected(Boolean.TRUE);
+    } finally {
+      c.getLock().unlock();
+    }
+
+    Boolean selected = c.getSelected();
+    Assert.assertNotNull(selected);
+
+    Assert.assertFalse("not new or dirty as transient", beanState.isNewOrDirty());
+
+    Ebean.save(c);
+
+    selected = c.getSelected();
+    Assert.assertNotNull(selected);
+
+    c.setName("Modified");
+    Assert.assertTrue("dirty now", beanState.isNewOrDirty());
+
+    selected = c.getSelected();
+    Assert.assertNotNull(selected);
+
+    Ebean.save(c);
+    Assert.assertFalse("Not dirty after save", beanState.isNewOrDirty());
+
+    selected = c.getSelected();
+    Assert.assertNotNull(selected);
+
+    String updateStmt = "update customer set name = 'Rob' where id = :id";
+    int rows = Ebean.createUpdate(Customer.class, updateStmt).set("id", custId).execute();
+
+    Assert.assertTrue("changed name back", 1 == rows);
+  }
+}

src/test/java/org/tests/basic/TestUpdateManyToOne.java

@@ -0,0 +1,40 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestUpdateManyToOne extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    List<Customer> custs = Ebean.find(Customer.class).findList();
+
+    List<Order> orders = Ebean.find(Order.class).setMaxRows(1).findList();
+
+    Order order = orders.get(0);
+    Customer customer = order.getCustomer();
+
+    Customer changeCust = null;
+    for (Customer c : custs) {
+      if (!customer.getId().equals(c.getId())) {
+        changeCust = c;
+        break;
+      }
+    }
+    order.setCustomer(changeCust);
+    Ebean.save(order);
+
+    order.setCustomer(customer);
+    Ebean.save(order);
+
+  }
+}

src/test/java/org/tests/basic/TestUuidInsert.java

@@ -0,0 +1,25 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TUuidEntity;
+import org.junit.Test;
+
+public class TestUuidInsert extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    TUuidEntity e = new TUuidEntity();
+    e.setName("bana");
+
+    Ebean.save(e);
+
+    TUuidEntity e2 = Ebean.find(TUuidEntity.class, e.getId());
+    e2.setName("apple");
+
+    Ebean.save(e2);
+
+    Ebean.delete(e2);
+  }
+}

src/test/java/org/tests/basic/TestUuidInsertMasterDetail.java

@@ -0,0 +1,44 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.UUOne;
+import org.tests.model.basic.UUTwo;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class TestUuidInsertMasterDetail extends BaseTestCase {
+
+  @Test
+  public void testInsert() {
+
+    UUTwo two = new UUTwo();
+    two.setName("something");
+
+    ArrayList<UUTwo> list = new ArrayList<>();
+    list.add(two);
+
+    UUOne one = new UUOne();
+    one.setName("some one");
+    one.setComments(list);
+
+    Ebean.save(one);
+
+    UUOne oneB = Ebean.find(UUOne.class, one.getId());
+
+    UUTwo twoB = new UUTwo();
+    twoB.setName("another something");
+    oneB.getComments().add(twoB);
+
+    Ebean.save(oneB);
+  }
+
+  public void testNullFK() {
+
+    UUTwo two = new UUTwo();
+    two.setName("something");
+    Ebean.save(two);
+  }
+
+}

src/test/java/org/tests/basic/TestWhereAnnotation.java

@@ -0,0 +1,34 @@
+package org.tests.basic;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestWhereAnnotation extends BaseTestCase {
+
+  @Test
+  public void testWhere() {
+
+    ResetBasicData.reset();
+    Customer custTest = ResetBasicData.createCustAndOrder("testWhereAnn");
+
+    Customer customer = Ebean.find(Customer.class, custTest.getId());
+    List<Order> orders = customer.getOrders();
+
+    Assert.assertTrue(!orders.isEmpty());
+
+    Query<Customer> q1 = Ebean.find(Customer.class).setUseCache(false).fetch("orders").where()
+      .idEq(1).query();
+
+    q1.findUnique();
+    String s1 = q1.getGeneratedSql();
+    Assert.assertTrue(s1.contains("t1.order_date is not null"));
+  }
+}

src/test/java/org/tests/basic/delete/TestDeleteByIdList.java

@@ -0,0 +1,38 @@
+package org.tests.basic.delete;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebeaninternal.api.SpiEbeanServer;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.OrderDetail;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestDeleteByIdList extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    OrderDetail dummy = Ebean.getReference(OrderDetail.class, 1);
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+    server.getBeanDescriptor(OrderDetail.class).cacheBeanPut(dummy);
+
+    Customer c0 = ResetBasicData.createCustAndOrder("DelIdList-0");
+    Assert.assertNotNull(c0);
+
+    Customer c1 = ResetBasicData.createCustAndOrder("DelIdList-1");
+
+    List<Object> orderIds = Ebean.find(Order.class).where().in("customer", c0, c1).findIds();
+
+    Assert.assertEquals(2, orderIds.size());
+
+    Ebean.deleteAll(Order.class, orderIds);
+
+  }
+}

src/test/java/org/tests/basic/delete/TestDeleteCascadeById.java

@@ -0,0 +1,38 @@
+package org.tests.basic.delete;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebeaninternal.api.SpiEbeanServer;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.OrderDetail;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestDeleteCascadeById extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    OrderDetail dummy = Ebean.getReference(OrderDetail.class, 1);
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+    server.getBeanDescriptor(OrderDetail.class).cacheBeanPut(dummy);
+
+    Customer cust = ResetBasicData.createCustAndOrder("DelCas");
+    Assert.assertNotNull(cust);
+
+    List<Order> orders = Ebean.find(Order.class).where().eq("customer", cust).findList();
+
+    Assert.assertEquals(1, orders.size());
+    Order o = orders.get(0);
+    Assert.assertNotNull(o);
+
+    Ebean.delete(o);
+
+  }
+}

src/test/java/org/tests/basic/encrypt/BasicEncryptKey.java

@@ -0,0 +1,18 @@
+package org.tests.basic.encrypt;
+
+import io.ebean.config.EncryptKey;
+
+public class BasicEncryptKey implements EncryptKey {
+
+  private final String key;
+
+  public BasicEncryptKey(String key) {
+    this.key = key;
+  }
+
+  public String getStringValue() {
+    return key;
+  }
+
+
+}

src/test/java/org/tests/basic/encrypt/BasicEncyptKeyManager.java

@@ -0,0 +1,20 @@
+package org.tests.basic.encrypt;
+
+import io.ebean.config.EncryptKey;
+import io.ebean.config.EncryptKeyManager;
+
+public class BasicEncyptKeyManager implements EncryptKeyManager {
+
+  /**
+   * Initialise the key manager.
+   */
+  public void initialise() {
+
+  }
+
+  public EncryptKey getEncryptKey(String tableName, String columnName) {
+    // Must be 16 Chars for Oracle function
+    return new BasicEncryptKey("simple0123456789");
+  }
+
+}

src/test/java/org/tests/basic/encrypt/TestEncrypt.java

@@ -0,0 +1,98 @@
+package org.tests.basic.encrypt;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.SqlQuery;
+import io.ebean.SqlRow;
+import io.ebean.Update;
+import io.ebean.config.dbplatform.DbEncrypt;
+import io.ebeaninternal.api.SpiEbeanServer;
+import org.tests.model.basic.EBasicEncrypt;
+import org.avaje.ebeantest.LoggedSqlCollector;
+import org.junit.Assert;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.sql.Date;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestEncrypt extends BaseTestCase {
+
+
+  @Test
+  public void testQueryBind() {
+
+    if (!isH2()) {
+      // only run this on H2 - PGCrypto not happy on CI server
+      return;
+    }
+
+    LoggedSqlCollector.start();
+    Ebean.find(EBasicEncrypt.class)
+      .where().startsWith("description", "Rob")
+      .findList();
+
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    assertThat(loggedSql).hasSize(1);
+    assertThat(loggedSql.get(0)).contains("; --bind(****,Rob%)");
+  }
+
+  @Ignore
+  @Test
+  public void test() {
+
+    Update<EBasicEncrypt> deleteAll = Ebean.createUpdate(EBasicEncrypt.class, "delete from EBasicEncrypt");
+    deleteAll.execute();
+
+    EBasicEncrypt e = new EBasicEncrypt();
+    e.setName("testname");
+    e.setDescription("testdesc");
+    e.setDob(new Date(System.currentTimeMillis() - 100000));
+
+    Ebean.save(e);
+
+    Date earlyDob = new Date(System.currentTimeMillis() - 500000);
+
+    SqlQuery q = Ebean.createSqlQuery("select * from e_basicenc where id = :id");
+    q.setParameter("id", e.getId());
+
+    SqlRow row = q.findUnique();
+    row.getString("name");
+    row.get("description");
+
+    EBasicEncrypt e1 = Ebean.find(EBasicEncrypt.class, e.getId());
+
+    e1.getDescription();
+
+    e1.setName("testmod");
+    e1.setDescription("moddesc");
+
+    Ebean.save(e1);
+
+    EBasicEncrypt e2 = Ebean.find(EBasicEncrypt.class, e.getId());
+
+    e2.getDescription();
+
+    SpiEbeanServer server = (SpiEbeanServer) Ebean.getServer(null);
+    DbEncrypt dbEncrypt = server.getDatabasePlatform().getDbEncrypt();
+
+    if (dbEncrypt == null) {
+      // can not test the where clause
+      System.out.println("TestEncrypt: Not testing where clause as no DbEncrypt");
+
+    } else {
+
+      List<EBasicEncrypt> list = Ebean.find(EBasicEncrypt.class).where()
+        .eq("description", "moddesc").findList();
+
+      Assert.assertEquals(1, list.size());
+
+      list = Ebean.find(EBasicEncrypt.class).where().startsWith("description", "modde").findList();
+
+      Assert.assertEquals(1, list.size());
+    }
+  }
+
+}

src/test/java/org/tests/basic/encrypt/TestEncryptBinary.java

@@ -0,0 +1,53 @@
+package org.tests.basic.encrypt;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.SqlQuery;
+import io.ebean.SqlRow;
+import org.tests.model.basic.EBasicEncryptBinary;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+
+public class TestEncryptBinary extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Timestamp t0 = new Timestamp(System.currentTimeMillis());
+    EBasicEncryptBinary e = new EBasicEncryptBinary();
+    e.setName("test1");
+    e.setDescription("testdesc1");
+    e.setSomeTime(t0);
+    e.setData("HelloWorld".getBytes());
+
+    Ebean.save(e);
+
+    SqlQuery q = Ebean.createSqlQuery("select * from e_basicenc_bin where id = :id");
+    q.setParameter("id", e.getId());
+
+    SqlRow row = q.findUnique();
+    row.getString("name");
+    row.get("data");
+    row.get("some_time");
+
+    EBasicEncryptBinary e1 = Ebean.find(EBasicEncryptBinary.class, e.getId());
+
+    Timestamp t1 = e1.getSomeTime();
+    e1.getData();
+
+    e1.getDescription();
+
+    Assert.assertEquals(t0, t1);
+
+    e1.setName("testmod");
+    e1.setDescription("moddesc");
+
+    Ebean.save(e1);
+
+    EBasicEncryptBinary e2 = Ebean.find(EBasicEncryptBinary.class, e.getId());
+    e2.getDescription();
+  }
+
+}

src/test/java/org/tests/basic/event/TestPreInsertValidation.java

@@ -0,0 +1,49 @@
+package org.tests.basic.event;
+
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TWithPreInsert;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestPreInsertValidation extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    TWithPreInsert e = new TWithPreInsert();
+    e.setTitle("Mister");
+    // the perInsert should populate the
+    // name with should not be null
+    Ebean.save(e);
+
+    // the save worked and name set in preInsert
+    Assert.assertNotNull(e.getId());
+    Assert.assertNotNull(e.getName());
+
+    TWithPreInsert e1 = Ebean.find(TWithPreInsert.class, e.getId());
+
+    e1.setTitle("Missus");
+    Ebean.save(e1);
+  }
+
+  @Test
+  public void testStatelessUpdate() {
+
+    TWithPreInsert e = new TWithPreInsert();
+    e.setName("BeanForUpdateTest");
+    Ebean.save(e);
+
+    TWithPreInsert bean2 = new TWithPreInsert();
+    bean2.setId(e.getId());
+    bean2.setName("stateless-update-name");
+    bean2.setTitle(null);
+
+    Ebean.update(bean2);
+
+    // title set on preUpdate
+    Assert.assertNotNull(bean2.getTitle());
+  }
+
+}

src/test/java/org/tests/basic/event/TestQueryAdapter.java

@@ -0,0 +1,35 @@
+package org.tests.basic.event;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.ResetBasicData;
+import org.tests.model.basic.TOne;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestQueryAdapter extends BaseTestCase {
+
+  @Test
+  public void testSimple() {
+
+    ResetBasicData.reset();
+
+    TOne o = new TOne();
+    o.setName("something");
+
+    Ebean.save(o);
+
+    //Ebean.find(TOne.class, o.getId());
+
+    Query<TOne> queryFindId = Ebean.find(TOne.class)
+      .setId(o.getId());
+
+    TOne one = queryFindId.findUnique();
+    Assert.assertNotNull(one);
+    Assert.assertEquals(one.getId(), o.getId());
+    String generatedSql = queryFindId.getGeneratedSql();
+    Assert.assertTrue(generatedSql.contains(" 1=1"));
+
+  }
+}

src/test/java/org/tests/basic/join/TestSecondaryJoin.java

@@ -0,0 +1,31 @@
+package org.tests.basic.join;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.Order.Status;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestSecondaryJoin extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    List<Order> list = Ebean.find(Order.class)
+      // .select("*")
+      // .join("customer")
+      .findList();
+
+    Order o0 = list.get(0);
+    o0.setCustomerName("Banan");
+    o0.setStatus(Status.APPROVED);
+
+    Ebean.save(o0);
+  }
+
+}

src/test/java/org/tests/basic/lob/TestBasicClobFetchEager.java

@@ -0,0 +1,82 @@
+package org.tests.basic.lob;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.Query;
+import org.tests.model.basic.EBasicClobFetchEager;
+import org.avaje.ebeantest.LoggedSqlCollector;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestBasicClobFetchEager extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    EBasicClobFetchEager entity = new EBasicClobFetchEager();
+    entity.setName("test");
+    entity.setDescription("initialClobValue");
+    EbeanServer server = Ebean.getServer(null);
+    server.save(entity);
+
+
+    String expectedSql = "select t0.id, t0.name, t0.title, t0.description, t0.last_update from ebasic_clob_fetch_eager t0 where t0.id = ?";
+
+    // Clob included in fetch as FetchType.EAGER set by annotation
+    Query<EBasicClobFetchEager> defaultQuery = Ebean.find(EBasicClobFetchEager.class).setId(entity.getId());
+    defaultQuery.findUnique();
+    String sql = trimSql(defaultQuery.getGeneratedSql(), 6);
+
+    assertThat(sql).contains(expectedSql);
+
+
+    LoggedSqlCollector.start();
+
+    // Same as previous query - clob included by default based on annotation
+    Ebean.find(EBasicClobFetchEager.class, entity.getId());
+
+    // Assert query same as previous ...
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    Assert.assertEquals(1, loggedSql.size());
+    assertThat(trimSql(loggedSql.get(0), 6)).contains(expectedSql);
+
+
+    // Explicitly select * including Clob
+    Query<EBasicClobFetchEager> explicitQuery = Ebean.find(EBasicClobFetchEager.class).setId(entity.getId()).select("*");
+
+    explicitQuery.findUnique();
+    sql = sqlOf(explicitQuery, 6);
+
+    assertThat(sql).contains(expectedSql);
+
+    // Update description to test refresh
+
+    EBasicClobFetchEager updateBean = new EBasicClobFetchEager();
+    updateBean.setId(entity.getId());
+    updateBean.setDescription("modified");
+    Ebean.update(updateBean);
+
+
+    // Test refresh function
+
+    Assert.assertEquals("initialClobValue", entity.getDescription());
+
+    LoggedSqlCollector.start();
+
+    // Refresh query includes all properties
+    server.refresh(entity);
+
+    // Assert all properties fetched in refresh
+    loggedSql = LoggedSqlCollector.stop();
+    Assert.assertEquals(1, loggedSql.size());
+    assertThat(trimSql(loggedSql.get(0), 6)).contains(expectedSql);
+    Assert.assertEquals("modified", entity.getDescription());
+
+  }
+
+}

src/test/java/org/tests/basic/lob/TestBasicClobNoVer.java

@@ -0,0 +1,73 @@
+package org.tests.basic.lob;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.Query;
+import org.tests.model.basic.EBasicClobNoVer;
+import org.avaje.ebeantest.LoggedSqlCollector;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestBasicClobNoVer extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    EBasicClobNoVer entity = new EBasicClobNoVer();
+    entity.setName("test");
+    entity.setDescription("initialClobValue");
+    EbeanServer server = Ebean.getServer(null);
+    server.save(entity);
+
+
+    String sqlNoClob = "select t0.id, t0.name from ebasic_clob_no_ver t0 where t0.id = ?";
+    String sqlWithClob = "select t0.id, t0.name, t0.description from ebasic_clob_no_ver t0 where t0.id = ?";
+
+
+    // Clob by default is Fetch Lazy
+    Query<EBasicClobNoVer> defaultQuery = Ebean.find(EBasicClobNoVer.class).setId(entity.getId());
+    defaultQuery.findUnique();
+    String sql = sqlOf(defaultQuery, 2);
+
+    Assert.assertTrue("Clob is fetch lazy by default", sql.contains(sqlNoClob));
+
+
+    // Explicitly select * including Clob
+    Query<EBasicClobNoVer> explicitQuery = Ebean.find(EBasicClobNoVer.class).setId(entity.getId()).select("*");
+
+    explicitQuery.findUnique();
+    sql = sqlOf(explicitQuery, 2);
+
+    Assert.assertTrue("Explicitly include Clob", sql.contains(sqlWithClob));
+
+    // Update description to test refresh
+
+    EBasicClobNoVer updateBean = new EBasicClobNoVer();
+    updateBean.setId(entity.getId());
+    updateBean.setDescription("modified");
+    Ebean.update(updateBean);
+
+
+    // Test refresh function
+
+    Assert.assertEquals("initialClobValue", entity.getDescription());
+
+    LoggedSqlCollector.start();
+
+    // Refresh query includes all properties
+    server.refresh(entity);
+
+    // Assert all properties fetched in refresh
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    Assert.assertEquals(1, loggedSql.size());
+    assertThat(trimSql(loggedSql.get(0), 2)).contains(sqlWithClob);
+    Assert.assertEquals("modified", entity.getDescription());
+
+  }
+
+}

src/test/java/org/tests/basic/lob/TestByteOnly.java

@@ -0,0 +1,27 @@
+package org.tests.basic.lob;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TBytesOnly;
+import org.junit.Test;
+
+public class TestByteOnly extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    byte[] content = new byte[]{1, 1};
+    TBytesOnly e = new TBytesOnly();
+    e.setContent(content);
+
+    Ebean.save(e);
+
+    byte[] content2 = new byte[]{1, 1};
+
+    TBytesOnly e2 = Ebean.find(TBytesOnly.class, e.getId());
+    e2.setContent(content2);
+
+    Ebean.save(e2);
+  }
+
+}

src/test/java/org/tests/basic/one2one/Booking.java

@@ -0,0 +1,92 @@
+package org.tests.basic.one2one;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.OneToMany;
+import javax.persistence.OneToOne;
+import javax.persistence.Table;
+import javax.persistence.Version;
+import java.util.List;
+
+@Entity
+@Table(name = "drel_booking")
+public class Booking {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.SEQUENCE)
+  private Long id;
+
+  @Column(unique = true)
+  Long bookingUid;
+
+  @Version
+  private int version;
+
+  @OneToOne(cascade = CascadeType.ALL)
+  @JoinColumn(name = "agent_invoice")
+  private Invoice agentInvoice;
+
+  @OneToOne(cascade = CascadeType.ALL)
+  @JoinColumn(name = "client_invoice")
+  private Invoice clientInvoice;
+
+  @OneToMany(mappedBy = "booking")
+  private List<Invoice> invoices;
+
+  public Booking(Long bookingUid) {
+    this.bookingUid = bookingUid;
+  }
+
+  public Long getId() {
+    return id;
+  }
+
+  public void setId(Long id) {
+    this.id = id;
+  }
+
+  public Long getBookingUid() {
+    return bookingUid;
+  }
+
+  public void setBookingUid(Long bookingUid) {
+    this.bookingUid = bookingUid;
+  }
+
+  public int getVersion() {
+    return version;
+  }
+
+  public void setVersion(int version) {
+    this.version = version;
+  }
+
+  public Invoice getAgentInvoice() {
+    return agentInvoice;
+  }
+
+  public void setAgentInvoice(Invoice agentInvoice) {
+    this.agentInvoice = agentInvoice;
+  }
+
+  public Invoice getClientInvoice() {
+    return clientInvoice;
+  }
+
+  public void setClientInvoice(Invoice clientInvoice) {
+    this.clientInvoice = clientInvoice;
+  }
+
+  public List<Invoice> getInvoices() {
+    return invoices;
+  }
+
+  public void setInvoices(List<Invoice> invoices) {
+    this.invoices = invoices;
+  }
+}

src/test/java/org/tests/basic/one2one/Invoice.java

@@ -0,0 +1,51 @@
+package org.tests.basic.one2one;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.ManyToOne;
+import javax.persistence.Table;
+import javax.persistence.Version;
+
+@Entity
+@Table(name = "drel_invoice")
+public class Invoice {
+
+  @Id
+  @GeneratedValue(strategy = GenerationType.SEQUENCE)
+  private Long id;
+
+  @Version
+  private int version;
+
+  @ManyToOne(cascade = CascadeType.ALL)
+  @JoinColumn(name = "booking")//_xid", referencedColumnName = "booking_uid")
+  private Booking booking;
+
+  public Long getId() {
+    return id;
+  }
+
+  public void setId(Long id) {
+    this.id = id;
+  }
+
+  public int getVersion() {
+    return version;
+  }
+
+  public void setVersion(int version) {
+    this.version = version;
+  }
+
+  public Booking getBooking() {
+    return booking;
+  }
+
+  public void setBooking(Booking booking) {
+    this.booking = booking;
+  }
+}

src/test/java/org/tests/basic/one2one/TestOne2OneBookingInvoice.java

@@ -0,0 +1,46 @@
+package org.tests.basic.one2one;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestOne2OneBookingInvoice extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Booking b = new Booking(3000L);
+
+    Invoice ai = new Invoice();
+    Invoice ci = new Invoice();
+
+    ai.setBooking(b);
+    ci.setBooking(b);
+
+    b.setAgentInvoice(ai);
+    b.setClientInvoice(ci);
+
+    Ebean.save(b);
+
+    Invoice invoice = Ebean.find(Invoice.class, ai.getId());
+    Assert.assertEquals(b.getId(), invoice.getBooking().getId());
+
+    Booking b1 = Ebean.find(Booking.class, b.getId());
+
+    Invoice ai1 = b1.getAgentInvoice();
+    Assert.assertNotNull(ai1);
+
+    Booking b2 = ai1.getBooking();
+    Assert.assertNotNull(b2);
+    Assert.assertEquals(b1.getId(), b2.getId());
+    Assert.assertSame(b1, b2);
+
+    Invoice ci1 = b1.getClientInvoice();
+    Booking b3 = ci1.getBooking();
+    Assert.assertNotNull(b3);
+    Assert.assertEquals(b1.getId(), b2.getId());
+    Assert.assertSame(b1, b2);
+
+  }
+}

src/test/java/org/tests/basic/one2one/TestOneToOneWheelTire.java

@@ -0,0 +1,22 @@
+package org.tests.basic.one2one;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.junit.Test;
+
+public class TestOneToOneWheelTire extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Wheel w = new Wheel();
+    Tire t = new Tire();
+    t.setWheel(w);
+    w.setTire(t);
+
+    Ebean.save(t);
+
+    Ebean.delete(t);
+  }
+
+}

src/test/java/org/tests/basic/one2one/Tire.java

@@ -0,0 +1,52 @@
+package org.tests.basic.one2one;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.OneToOne;
+import javax.persistence.Table;
+import javax.persistence.Version;
+
+@Entity
+@Table(name = "tire")
+public class Tire {
+  @Id
+  @GeneratedValue(strategy = GenerationType.SEQUENCE)
+  private Long id;
+  @Version
+  private int version;
+  @OneToOne(cascade = CascadeType.ALL)
+  @JoinColumn(name = "wheel")
+  private Wheel wheel;
+
+  public Tire() {
+    super();
+  }
+
+  public Long getId() {
+    return id;
+  }
+
+  public void setId(Long id) {
+    this.id = id;
+  }
+
+  public int getVersion() {
+    return version;
+  }
+
+  public void setVersion(int version) {
+    this.version = version;
+  }
+
+  public Wheel getWheel() {
+    return wheel;
+  }
+
+  public void setWheel(Wheel wheel) {
+    this.wheel = wheel;
+  }
+}

src/test/java/org/tests/basic/one2one/Wheel.java

@@ -0,0 +1,52 @@
+package org.tests.basic.one2one;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.OneToOne;
+import javax.persistence.Table;
+import javax.persistence.Version;
+
+@Entity
+@Table(name = "wheel")
+public class Wheel {
+  @Id
+  @GeneratedValue(strategy = GenerationType.SEQUENCE)
+  private Long id;
+
+  @Version
+  private int version;
+
+  @OneToOne(mappedBy = "wheel", cascade = CascadeType.PERSIST)
+  private Tire tire;
+
+  public Long getId() {
+    return id;
+  }
+
+  public Wheel() {
+    super();
+  }
+
+  public void setId(Long id) {
+    this.id = id;
+  }
+
+  public int getVersion() {
+    return version;
+  }
+
+  public void setVersion(int version) {
+    this.version = version;
+  }
+
+  public Tire getTire() {
+    return tire;
+  }
+
+  public void setTire(Tire tire) {
+    this.tire = tire;
+  }
+}

src/test/java/org/tests/basic/type/BSimpleWithGen.java

@@ -0,0 +1,44 @@
+package org.tests.basic.type;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Transient;
+import java.util.List;
+import java.util.Map;
+
+@Entity
+public class BSimpleWithGen {
+
+  @Id
+  Integer id;
+
+  String name;
+
+  @Transient
+  Map<String, List<String>> someMap;
+
+  public Integer getId() {
+    return id;
+  }
+
+  public void setId(Integer id) {
+    this.id = id;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public Map<String, List<String>> getSomeMap() {
+    return someMap;
+  }
+
+  public void setSomeMap(Map<String, List<String>> someMap) {
+    this.someMap = someMap;
+  }
+
+}

src/test/java/org/tests/basic/type/TestEnumValueAnnotation.java

@@ -0,0 +1,98 @@
+package org.tests.basic.type;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.SqlQuery;
+import io.ebean.SqlRow;
+import org.tests.model.basic.EBasic;
+import org.tests.model.basic.EBasic.Status;
+import org.tests.model.basic.EBasicEnumId;
+import org.tests.model.basic.EBasicEnumInt;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class TestEnumValueAnnotation extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    EBasic b = new EBasic();
+    b.setName("Banana");
+    b.setStatus(Status.NEW);
+
+    Ebean.save(b);
+
+    SqlQuery q = Ebean.createSqlQuery("select * from e_basic where id = :id");
+    q.setParameter("id", b.getId());
+
+    SqlRow sqlRow = q.findUnique();
+    String strStatus = sqlRow.getString("status");
+
+    assertEquals("N", strStatus);
+
+    EBasic b2 = new EBasic();
+    b2.setName("Apple");
+    b2.setStatus(Status.NEW);
+
+    Ebean.save(b2);
+
+    EBasic b3 = Ebean.find(EBasic.class, b2.getId());
+    b3.setName("Orange");
+
+    Ebean.save(b3);
+  }
+
+  @Test
+  public void testAsId() {
+    EBasicEnumId b = new EBasicEnumId();
+    b.setName("Banana");
+    b.setStatus(EBasicEnumId.Status.NEW);
+
+    Ebean.save(b);
+
+    SqlQuery q = Ebean.createSqlQuery("select * from e_basic_enum_id where status = :status");
+    q.setParameter("status", b.getStatus());
+
+    SqlRow sqlRow = q.findUnique();
+    String strStatus = sqlRow.getString("status");
+
+    assertEquals("N", strStatus);
+
+    try {
+      b = Ebean.find(EBasicEnumId.class, b.getStatus());
+    } catch (java.lang.IllegalArgumentException iae) {
+      Assert.fail("The use of an enum as id should work : " + iae.getLocalizedMessage());
+    }
+
+    assertEquals(EBasicEnumId.Status.NEW, b.getStatus());
+  }
+
+  @Test
+  public void testDbEnumValueInt() {
+
+    EBasicEnumInt b = new EBasicEnumInt();
+    b.setName("Banana");
+    b.setStatus(EBasicEnumInt.Status.NEW);
+
+    Ebean.save(b);
+
+    SqlQuery q = Ebean.createSqlQuery("select * from e_basic_eni where id = :id");
+    q.setParameter("id", b.getId());
+
+    SqlRow sqlRow = q.findUnique();
+    Integer intStatus = sqlRow.getInteger("status");
+
+    assertEquals(Integer.valueOf(1), intStatus);
+
+
+    EBasicEnumInt b2 = Ebean.find(EBasicEnumInt.class)
+      .where().eq("id", b.getId())
+      .eq("status", EBasicEnumInt.Status.NEW)
+      .findUnique();
+
+    assertNotNull(b2);
+  }
+}

src/test/java/org/tests/basic/type/TestExtraScalarTypes.java

@@ -0,0 +1,48 @@
+package org.tests.basic.type;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.ESomeType;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Currency;
+import java.util.List;
+import java.util.Locale;
+import java.util.TimeZone;
+
+import static org.junit.Assert.assertTrue;
+
+public class TestExtraScalarTypes extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Locale locale = Locale.getDefault();
+    Currency currency = Currency.getInstance(locale);
+    TimeZone tz = TimeZone.getDefault();
+
+    ESomeType e = new ESomeType();
+    e.setLocale(locale);
+    e.setTimeZone(tz);
+    e.setCurrency(currency);
+
+    Ebean.save(e);
+
+    ESomeType e2 = Ebean.find(ESomeType.class).setAutoTune(false).setId(e.getId()).findUnique();
+
+    Assert.assertNotNull(e2.getCurrency());
+    Assert.assertNotNull(e2.getLocale());
+    Assert.assertNotNull(e2.getTimeZone());
+
+    List<ESomeType> list = Ebean.find(ESomeType.class)
+      .setAutoTune(false).where()
+      .eq("locale", locale)
+      .eq("timeZone", tz.getID())
+      .eq("currency", currency)
+      .findList();
+
+    assertTrue(!list.isEmpty());
+  }
+
+}

src/test/java/org/tests/basic/type/TestInetAddressType.java

@@ -0,0 +1,60 @@
+package org.tests.basic.type;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.EWithInetAddr;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+public class TestInetAddressType extends BaseTestCase {
+
+  @Test
+  public void testIp4() throws UnknownHostException {
+
+    insertUpdateDeleteFind("120.12.12.56");
+  }
+
+  @Test
+  public void testIp6() throws UnknownHostException {
+
+    insertUpdateDeleteFind("2001:db8:85a3:0:0:8a2e:370:7334");
+  }
+
+  private void insertUpdateDeleteFind(String ipAddress) throws UnknownHostException {
+
+    EWithInetAddr bean1 = new EWithInetAddr();
+    bean1.setName("jim");
+
+    InetAddress address1 = InetAddress.getByName(ipAddress);
+    bean1.setInetAddress(address1);
+
+    Ebean.save(bean1);
+
+    EWithInetAddr bean2 = Ebean.find(EWithInetAddr.class, bean1.getId());
+    InetAddress address2 = bean2.getInetAddress();
+    Assert.assertNotNull(address2.getHostAddress());
+    Assert.assertEquals(address1.getHostAddress(), address2.getHostAddress());
+
+    bean2.setName("modJim");
+    bean2.setInetAddress(InetAddress.getByName("120.12.20.80"));
+    Ebean.save(bean2);
+    Ebean.delete(bean2);
+  }
+
+  @Test
+  public void use_null() throws UnknownHostException {
+
+    EWithInetAddr bean1 = new EWithInetAddr();
+    bean1.setName("jim");
+
+    Ebean.save(bean1);
+
+    EWithInetAddr bean2 = Ebean.find(EWithInetAddr.class, bean1.getId());
+    InetAddress address2 = bean2.getInetAddress();
+    Assert.assertNull(address2);
+  }
+
+}

src/test/java/org/tests/basic/type/TestQueryBooleanProperty.java

@@ -0,0 +1,16 @@
+package org.tests.basic.type;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.TOne;
+import org.junit.Test;
+
+public class TestQueryBooleanProperty extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    // when run in MySql is test for BUG 323
+    Ebean.find(TOne.class).where().eq("active", true).findList();
+  }
+}

src/test/java/org/tests/basic/type/TestSqlRowUUID.java

@@ -0,0 +1,34 @@
+package org.tests.basic.type;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.SqlQuery;
+import io.ebean.SqlRow;
+import org.tests.model.basic.TUuidEntity;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.UUID;
+
+public class TestSqlRowUUID extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    TUuidEntity e = new TUuidEntity();
+    e.setName("blah");
+
+    Ebean.save(e);
+
+    SqlQuery q = Ebean.createSqlQuery("select * from tuuid_entity where id = :id");
+    q.setParameter("id", e.getId());
+    SqlRow sqlRow = q.findUnique();
+
+    UUID id = sqlRow.getUUID("id");
+
+    Assert.assertNotNull(id);
+
+    Boolean b = sqlRow.getBoolean("name");
+    Assert.assertFalse(b);
+  }
+}

src/test/java/org/tests/basic/type/TestTransientMap.java

@@ -0,0 +1,18 @@
+package org.tests.basic.type;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.junit.Test;
+
+public class TestTransientMap extends BaseTestCase {
+
+  @Test
+  public void testMe() {
+
+    BSimpleWithGen b = new BSimpleWithGen();
+    b.setName("blah");
+
+    Ebean.save(b);
+
+  }
+}

src/test/java/org/tests/batchinsert/TestBatchInsertFlush.java

@@ -0,0 +1,117 @@
+package org.tests.batchinsert;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.Transaction;
+import io.ebean.annotation.Transactional;
+import io.ebean.PersistBatch;
+import org.tests.model.basic.EBasicVer;
+import org.junit.Test;
+
+import java.sql.Timestamp;
+
+import static org.junit.Assert.assertNotNull;
+
+public class TestBatchInsertFlush extends BaseTestCase {
+
+  @Test
+  @Transactional(batch = PersistBatch.ALL)
+  public void transactional_flushOnGetId() {
+
+    EbeanServer server = Ebean.getDefaultServer();
+
+    EBasicVer b1 = new EBasicVer("b1");
+    server.save(b1);
+
+    EBasicVer b2 = new EBasicVer("b2");
+    server.save(b2);
+
+    Integer id = b1.getId();
+    assertNotNull(id);
+    EBasicVer b3 = new EBasicVer("b3");
+    server.save(b3);
+  }
+
+  @Test
+  public void testFlushOnGetId() {
+
+    EbeanServer server = Ebean.getDefaultServer();
+    Transaction txn = server.beginTransaction();
+    try {
+      txn.setBatch(PersistBatch.ALL);
+
+      EBasicVer b1 = new EBasicVer("b1");
+      server.save(b1, txn);
+
+      EBasicVer b2 = new EBasicVer("b2");
+      server.save(b2, txn);
+
+      Integer id = b1.getId();
+      assertNotNull(id);
+
+      EBasicVer b3 = new EBasicVer("b3");
+      server.save(b3, txn);
+
+      txn.commit();
+
+    } finally {
+      txn.end();
+    }
+  }
+
+  @Test
+  public void testFlushOnGetProperty() {
+
+    EbeanServer server = Ebean.getDefaultServer();
+    Transaction txn = server.beginTransaction();
+    try {
+      txn.setBatch(PersistBatch.ALL);
+
+      EBasicVer b1 = new EBasicVer("b1");
+      server.save(b1, txn);
+
+      EBasicVer b2 = new EBasicVer("b2");
+      server.save(b2, txn);
+
+      // flush here
+      Timestamp lastUpdate = b1.getLastUpdate();
+      assertNotNull(lastUpdate);
+
+      EBasicVer b3 = new EBasicVer("b3");
+      server.save(b3, txn);
+
+      txn.commit();
+
+    } finally {
+      txn.end();
+    }
+  }
+
+  @Test
+  public void testFlushOnSetProperty() {
+
+    EbeanServer server = Ebean.getDefaultServer();
+    Transaction txn = server.beginTransaction();
+    try {
+      txn.setBatch(PersistBatch.ALL);
+
+      EBasicVer b1 = new EBasicVer("b1");
+      server.save(b1, txn);
+
+      EBasicVer b2 = new EBasicVer("b2");
+      server.save(b2, txn);
+
+      // flush here
+      b1.setDescription("modify");
+
+      EBasicVer b3 = new EBasicVer("b3");
+      server.save(b3, txn);
+
+      txn.commit();
+
+    } finally {
+      txn.end();
+    }
+  }
+}

src/test/java/org/tests/batchinsert/TestBatchInsertSimple.java

@@ -0,0 +1,213 @@
+package org.tests.batchinsert;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Transaction;
+import io.ebean.annotation.Transactional;
+import io.ebean.PersistBatch;
+import org.tests.model.basic.UTDetail;
+import org.tests.model.basic.UTMaster;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+//import static org.assertj.core.api.Assertions.assertThat;
+//import static org.junit.Assert.assertNull;
+
+public class TestBatchInsertSimple extends BaseTestCase {
+
+  Random random = new Random();
+
+  @Test
+  public void testJdbcBatchPerRequestWithMasterAndDetails() {
+
+    int numOfMasters = 4;// 2 + random.nextInt(8);
+
+    Transaction transaction = Ebean.beginTransaction();
+    try {
+      transaction.setBatch(PersistBatch.NONE);
+      transaction.setBatchOnCascade(PersistBatch.INSERT);
+      transaction.setBatchSize(30);
+      // setBatchGetGeneratedKeys MUST be turned off for MS SQL Server because :(
+      transaction.setBatchGetGeneratedKeys(false);
+
+      for (int i = 0; i < numOfMasters; i++) {
+        UTMaster master = createMasterAndDetails(i, 20);
+        master.save();
+      }
+
+      transaction.commit();
+
+    } finally {
+      transaction.end();
+    }
+  }
+
+  @Test
+  public void testTransactional() {
+
+    if (isMsSqlServer()) return;
+
+    saveWithFullBatchMode();
+  }
+
+  @Transactional(batchSize = 50)
+  public void saveWithFullBatchMode() {
+
+    int numOfMasters = 4;
+
+    for (int i = 0; i < numOfMasters; i++) {
+      UTMaster master = createMasterAndDetails(i, 5);
+      // the save is 'batched' and does not execute immediately
+      // ... it now acts more like 'merge/persist'
+      master.save();
+    }
+  }
+
+//  @Test
+//  public void testTransactional_skipGeneratedBeans() {
+//
+//    if (isMsSqlServer()) return;
+//
+//    List<UTMaster> beans = saveWithFullBatchMode_skipGeneratedKeys();
+//    for (UTMaster bean : beans) {
+//      assertNull(bean.getId());
+//    }
+//  }
+//
+//  @Transactional(batch=PersistBatch.ALL, batchSize=50, getGeneratedKeys = false)
+//  public List<UTMaster> saveWithFullBatchMode_skipGeneratedKeys() {
+//
+//    Transaction transaction = server().currentTransaction();
+//    SpiTransaction spiTxn = (SpiTransaction)transaction;
+//    Boolean generatedKeys = spiTxn.getBatchGetGeneratedKeys();
+//
+//    assertThat(generatedKeys).isFalse();
+//
+//    List<UTMaster> beans = new ArrayList<UTMaster>();
+//    for (int i = 0; i < 4; i++) {
+//     beans.add(createMaster(i));
+//    }
+//
+//    server().saveAll(beans);
+//    return beans;
+//  }
+
+  @Test
+  public void testJdbcBatchPerRequestWithMasterOnly() {
+
+    int numOfMasters = 4;
+
+    Transaction transaction = Ebean.beginTransaction();
+    try {
+      transaction.setBatch(PersistBatch.NONE);
+      transaction.setBatchOnCascade(PersistBatch.INSERT);
+      transaction.setBatchSize(30);
+      // setBatchGetGeneratedKeys MUST be turned off for MS SQL Server because :(
+      transaction.setBatchGetGeneratedKeys(false);
+
+      for (int i = 0; i < numOfMasters; i++) {
+        UTMaster master = createMaster(i);
+        Ebean.save(master);
+      }
+
+      transaction.commit();
+
+    } finally {
+      transaction.end();
+    }
+  }
+
+  @Test
+  public void testJdbcBatchOnCollection() {
+
+    // MS SQL Server doesn't like batch inserts when we need getGeneratedKeys
+    if (isMsSqlServer()) return;
+
+    int numOfMasters = 3;
+
+    List<UTMaster> masters = new ArrayList<>();
+    for (int i = 0; i < numOfMasters; i++) {
+      masters.add(createMasterAndDetails(i, 7));
+    }
+
+    Transaction transaction = Ebean.beginTransaction();
+    try {
+      transaction.setBatch(PersistBatch.NONE);
+      transaction.setBatchOnCascade(PersistBatch.ALL);
+      transaction.setBatchSize(20);
+
+      // escalate based on batchOnCascade value
+      Ebean.saveAll(masters);
+
+      transaction.commit();
+
+    } finally {
+      transaction.end();
+    }
+  }
+
+  @Test
+  public void testJdbcBatchOnCollectionNoTransaction() {
+
+    int numOfMasters = 3;
+
+    List<UTMaster> masters = new ArrayList<>();
+    for (int i = 0; i < numOfMasters; i++) {
+      masters.add(createMasterAndDetails(i, 5));
+    }
+
+    // escalate based on batchOnCascade value
+    Ebean.saveAll(masters);
+
+    for (int i = 0; i < masters.size(); i++) {
+      UTMaster utMaster = masters.get(i);
+      utMaster.setName(utMaster.getName() + "-Mod");
+      if (i % 2 == 0) {
+        // make the updates a little bit different
+        utMaster.setDescription("Blah");
+      }
+    }
+
+    Ebean.saveAll(masters);
+  }
+
+  private UTMaster createMasterAndDetails(int masterPos, int size) {
+
+    UTMaster master = createMaster(masterPos);
+    List<UTDetail> details = new ArrayList<>();
+
+    int count = 2 + random.nextInt(size);
+
+    for (int i = 0; i < count; i++) {
+
+      int qty = 1 + random.nextInt(99);
+      double amount = random.nextDouble();
+
+      details.add(createDetail(masterPos + "-" + i, qty, amount));
+    }
+    master.setDetails(details);
+    return master;
+  }
+
+  private UTMaster createMaster(int position) {
+    UTMaster m = new UTMaster();
+    m.setName("batchInsert-master" + position);
+    return m;
+  }
+
+  private UTDetail createDetail(String position, int qty, double amount) {
+
+    UTDetail detail = new UTDetail();
+    detail.setName("batchInsert-detail-" + position);
+    detail.setQty(qty);
+    detail.setAmount(amount);
+
+    // System.out.println("-- "+detail);
+
+    return detail;
+  }
+
+}

src/test/java/org/tests/batchinsert/TestBatchInsertWithInitialisedCollection.java

@@ -0,0 +1,53 @@
+package org.tests.batchinsert;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Transaction;
+import io.ebean.PersistBatch;
+import org.tests.model.basic.OCachedBean;
+import org.avaje.ebeantest.LoggedSqlCollector;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestBatchInsertWithInitialisedCollection extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    if (isMsSqlServer()) return;
+
+    List<OCachedBean> list = new ArrayList();
+
+    for (int i = 0; i < 3; i++) {
+      OCachedBean bean = new OCachedBean();
+      bean.setName("name " + i);
+      list.add(bean);
+    }
+
+    LoggedSqlCollector.start();
+
+    Transaction txn = Ebean.beginTransaction();
+    try {
+      txn.setBatch(PersistBatch.ALL);
+
+      Ebean.saveAll(list);
+      txn.commit();
+
+    } finally {
+      txn.end();
+    }
+
+    List<String> loggedSql = LoggedSqlCollector.stop();
+    assertThat(loggedSql).hasSize(3);
+
+    for (String sql : loggedSql) {
+      assertThat(sql).contains("insert into o_cached_bean (");
+      assertThat(sql).contains("name) values (?");
+    }
+
+  }
+}

src/test/java/org/tests/batchinsert/TestBatchOnCascadeExceptionHandling.java

@@ -0,0 +1,110 @@
+package org.tests.batchinsert;
+
+import io.ebean.BaseTestCase;
+import io.ebean.EbeanServer;
+import io.ebean.Transaction;
+import io.ebean.PersistBatch;
+import io.ebeaninternal.api.SpiTransaction;
+import io.ebeaninternal.server.persist.BatchControl;
+import org.tests.model.basic.EBasicWithUniqueCon;
+import org.tests.model.basic.EOptOneB;
+import org.tests.model.basic.EOptOneC;
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+
+import javax.persistence.PersistenceException;
+import java.sql.SQLException;
+import java.sql.Savepoint;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestBatchOnCascadeExceptionHandling extends BaseTestCase {
+
+  @Test
+  public void testBatchScenarioWithSavepoint() throws SQLException {
+    server().save(createEntityWithName("conflict", "before"));
+
+    Transaction txn = server().beginTransaction();
+    try {
+      EBasicWithUniqueCon v2 = createEntityWithName("conflict", "after");
+      txn.flushBatch();
+      Savepoint sp = txn.getConnection().setSavepoint();
+      try {
+        server().save(v2); // unique key violation
+      } catch (PersistenceException e) {
+        txn.getConnection().rollback(sp);
+
+        EBasicWithUniqueCon conflicting = server().find(EBasicWithUniqueCon.class).where().eq("name", "conflict").findUnique();
+        assertThat(conflicting).isNotNull();
+        server().delete(conflicting);
+        server().save(v2); // try again
+      }
+      txn.commit();
+    } finally {
+      txn.end();
+    }
+
+    EBasicWithUniqueCon winner = server().find(EBasicWithUniqueCon.class).where().eq("name", "conflict").findUnique();
+    assertThat(winner).isNotNull();
+    assertThat(winner.getDescription()).isEqualTo("after");
+  }
+
+  @Test
+  public void testBatchedInsertFailure() {
+    server().save(createEntityWithName("foo"));
+    testBatchOnCascadeIsExceptionSafe(server(), () -> {
+      server().save(createEntityWithName("foo")); // duplicate name on insert
+    });
+  }
+
+  @Test
+  public void testBatchedUpdateFailure() {
+    server().save(createEntityWithName("bla"));
+    final EBasicWithUniqueCon bar = createEntityWithName("bar");
+    server().save(bar);
+    testBatchOnCascadeIsExceptionSafe(server(), () -> {
+      bar.setName("bla");
+      server().save(bar); // duplicate name on update
+    });
+  }
+
+  @Test
+  public void testBatchedDeleteFailure() {
+    final EOptOneC c = new EOptOneC();
+    server().save(c);
+    final EOptOneB b = new EOptOneB();
+    b.setC(c);
+    server().save(b);
+    testBatchOnCascadeIsExceptionSafe(server(), () -> {
+      server().delete(c); // foreign key violation
+    });
+  }
+
+  protected void testBatchOnCascadeIsExceptionSafe(EbeanServer server, Runnable failingOperation) {
+    Transaction txn = server.beginTransaction();
+    assertThat(txn.getBatch()).isSameAs(PersistBatch.NONE);
+    assertThat(txn.getBatchOnCascade()).isSameAs(PersistBatch.ALL);
+
+    try {
+      failingOperation.run();
+      Assertions.fail("PersistenceException expected");
+    } catch (PersistenceException e) {
+      assertThat(txn.getBatch()).as("batch mode").isSameAs(PersistBatch.NONE); // should not have changed
+      BatchControl bc = ((SpiTransaction) txn).getBatchControl();
+      assertThat(bc == null || bc.isEmpty()).as("batch emtpy").isTrue();
+    } finally {
+      txn.end();
+    }
+  }
+
+  protected EBasicWithUniqueCon createEntityWithName(String name) {
+    return createEntityWithName(name, null);
+  }
+
+  protected EBasicWithUniqueCon createEntityWithName(String name, String description) {
+    EBasicWithUniqueCon it = new EBasicWithUniqueCon();
+    it.setName(name);
+    it.setDescription(description);
+    return it;
+  }
+}

src/test/java/org/tests/batchinsert/TestBatchSaveWithGetBeanId.java

@@ -0,0 +1,34 @@
+package org.tests.batchinsert;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import io.ebean.annotation.Transactional;
+import org.tests.model.basic.Customer;
+import org.junit.Test;
+
+import static org.junit.Assert.assertNotNull;
+
+public class TestBatchSaveWithGetBeanId extends BaseTestCase {
+
+  /**
+   * Making this transaction with batchSize means that the insert
+   * below does not occur immediately ... and the getBeanId()
+   * should invoke the flush (and hence trigger the insert).
+   */
+  @Transactional(batchSize = 10)
+  @Test
+  public void test() {
+
+    EbeanServer server = Ebean.getDefaultServer();
+    Customer model = new Customer();
+    model.setName("foo");
+
+    server.insert(model);
+
+    // should invoke a flush which then means the
+    // insert occurs and the bean has an Id value
+    Object beanId = server.getBeanId(model);
+    assertNotNull(beanId);
+  }
+}

src/test/java/org/tests/batchload/TestBasicLazy.java

@@ -0,0 +1,206 @@
+package org.tests.batchload;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Expr;
+import io.ebean.FetchConfig;
+import io.ebean.Transaction;
+import org.tests.basic.MyTestDataSourcePoolListener;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Contact;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class TestBasicLazy extends BaseTestCase {
+
+  @Test
+  public void testQueries() {
+
+    ResetBasicData.reset();
+
+    Order order = Ebean.find(Order.class).select("totalAmount").setMaxRows(1).order("id")
+      .findUnique();
+
+    Assert.assertNotNull(order);
+
+    Customer customer = order.getCustomer();
+    Assert.assertNotNull(customer);
+    Assert.assertNotNull(customer.getName());
+
+    Address address = customer.getBillingAddress();
+    Assert.assertNotNull(address);
+    Assert.assertNotNull(address.getCity());
+  }
+
+  public void test_N1N() {
+    ResetBasicData.reset();
+
+    // safety check to see if our customer we are going to use for the test has
+    // some contacts
+    Customer c = Ebean.find(Customer.class).setId(1).findUnique();
+    Assert.assertNotNull(c.getContacts());
+    Assert.assertTrue("no contacts on test customer 1", !c.getContacts().isEmpty());
+
+    // start transaction so we have a "long running" persistence context
+    Transaction tx = Ebean.beginTransaction();
+    try {
+      List<Order> order = Ebean.find(Order.class).where(Expr.eq("customer.id", 1)).findList();
+
+      Assert.assertNotNull(order);
+      Assert.assertTrue(!order.isEmpty());
+
+      Customer customer = order.get(0).getCustomer();
+      Assert.assertNotNull(customer);
+      Assert.assertEquals(1, customer.getId().intValue());
+
+      // this should lazily fetch the contacts
+      List<Contact> contacts = customer.getContacts();
+
+      Assert.assertNotNull(contacts);
+      Assert.assertTrue("contacts not lazily fetched", !contacts.isEmpty());
+    } finally {
+      tx.commit();
+    }
+  }
+
+  public void testRaceCondition_Simple() throws Throwable {
+    ResetBasicData.reset();
+
+    Order order = Ebean.find(Order.class).select("totalAmount").setMaxRows(1).order("id")
+      .findUnique();
+
+    Assert.assertNotNull(order);
+
+    final Customer customer = order.getCustomer();
+    Assert.assertNotNull(customer);
+
+    Assert.assertTrue(Ebean.getBeanState(customer).isReference());
+
+    final Throwable throwables[] = new Throwable[2];
+    Thread t1 = new Thread() {
+      @Override
+      public void run() {
+        try {
+          Assert.assertNotNull(customer.getName());
+        } catch (Throwable e) {
+          throwables[0] = e;
+        }
+      }
+    };
+
+    Thread t2 = new Thread() {
+      @Override
+      public void run() {
+        try {
+          Assert.assertNotNull(customer.getName());
+        } catch (Throwable e) {
+          throwables[1] = e;
+        }
+      }
+    };
+
+    try {
+      // prepare for race condition
+      MyTestDataSourcePoolListener.SLEEP_AFTER_BORROW = 2000;
+
+      t1.start();
+      t2.start();
+      t1.join();
+      t2.join();
+    } finally {
+      MyTestDataSourcePoolListener.SLEEP_AFTER_BORROW = 0;
+    }
+
+    Assert.assertFalse(Ebean.getBeanState(customer).isReference());
+
+    if (throwables[0] != null) {
+      throw throwables[0];
+    }
+    if (throwables[1] != null) {
+      throw throwables[1];
+    }
+  }
+
+  private final AtomicBoolean mutex = new AtomicBoolean(false);
+  private List<Order> orders;
+
+  private List<Throwable> exceptions = Collections.synchronizedList(new ArrayList<Throwable>());
+
+  private class FetchThread extends Thread {
+    private int index;
+
+    private FetchThread(ThreadGroup tg, int index) {
+      super(tg, "fetcher-" + index);
+      this.index = index;
+    }
+
+    @Override
+    public void run() {
+      synchronized (mutex) {
+        System.err.println("** WAIT **");
+        try {
+          while (!mutex.get()) {
+            mutex.wait(100);
+          }
+        } catch (InterruptedException e) {
+          throw new RuntimeException(e);
+        }
+      }
+
+      try {
+        System.err.println("** DO LAZY FETCH **");
+        orders.get(index).getCustomer().getName();
+      } catch (Throwable e) {
+        exceptions.add(e);
+      }
+    }
+  }
+
+  public void testRaceCondition_Complex() throws Throwable {
+    ResetBasicData.reset();
+
+    ThreadGroup tg = new ThreadGroup("fetchers");
+    new FetchThread(tg, 0).start();
+    new FetchThread(tg, 1).start();
+    new FetchThread(tg, 2).start();
+    new FetchThread(tg, 3).start();
+    new FetchThread(tg, 0).start();
+    new FetchThread(tg, 1).start();
+    new FetchThread(tg, 2).start();
+    new FetchThread(tg, 3).start();
+
+    orders = Ebean.find(Order.class).fetch("customer", new FetchConfig().lazy(100)).findList();
+    Assert.assertTrue(orders.size() >= 4);
+
+    try {
+      MyTestDataSourcePoolListener.SLEEP_AFTER_BORROW = 2000;
+
+      synchronized (mutex) {
+        mutex.set(true);
+        mutex.notifyAll();
+      }
+
+      while (tg.activeCount() > 0) {
+        Thread.sleep(100);
+      }
+    } finally {
+      MyTestDataSourcePoolListener.SLEEP_AFTER_BORROW = 0;
+    }
+
+    if (!exceptions.isEmpty()) {
+      System.err.println("Seen Exceptions:");
+      for (Throwable exception : exceptions) {
+        exception.printStackTrace();
+      }
+      Assert.fail();
+    }
+  }
+}

src/test/java/org/tests/batchload/TestBasicNavOnEmpty.java

@@ -0,0 +1,28 @@
+package org.tests.batchload;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Contact;
+import org.tests.model.basic.Customer;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestBasicNavOnEmpty extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    Customer c = new Customer();
+    c.setName("HelloRob");
+
+    Ebean.save(c);
+
+    c = Ebean.find(Customer.class, c.getId());
+
+    List<Contact> contacts = c.getContacts();
+    Assert.assertEquals(0, contacts.size());
+  }
+
+}

src/test/java/org/tests/batchload/TestBatchLazyWithCacheHits.java

@@ -0,0 +1,87 @@
+package org.tests.batchload;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.cache.ServerCache;
+import io.ebean.cache.ServerCacheManager;
+import io.ebean.cache.ServerCacheStatistics;
+import org.tests.model.basic.UUOne;
+import org.avaje.ebeantest.LoggedSqlCollector;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class TestBatchLazyWithCacheHits extends BaseTestCase {
+
+  private UUOne insert(String name) {
+    UUOne one = new UUOne();
+    one.setName("testBLWCH" + name);
+    Ebean.save(one);
+    return one;
+  }
+
+  @Test
+  public void testOnCacheHit() {
+
+    ArrayList<UUOne> inserted = new ArrayList<>();
+    String[] names = "A,B,C,D,E,F,G,H,I,J".split(",");
+    for (String name : names) {
+      inserted.add(insert(name));
+    }
+
+    ServerCacheManager serverCacheManager = Ebean.getDefaultServer().getServerCacheManager();
+    ServerCache beanCache = serverCacheManager.getBeanCache(UUOne.class);
+    beanCache.clear();
+
+    UUOne b = Ebean.find(UUOne.class, inserted.get(1).getId());
+    assertNotNull(b);
+
+    UUOne b2 = Ebean.find(UUOne.class, inserted.get(1).getId());
+    assertNotNull(b2);
+    ServerCacheStatistics statistics = beanCache.getStatistics(true);
+    assertEquals(statistics.getHitCount(), 1);
+
+    UUOne c = Ebean.find(UUOne.class)
+      .where().idEq(inserted.get(2).getId())
+      .findUnique();
+    assertNotNull(c);
+
+    UUOne c2 = Ebean.find(UUOne.class)
+      .where().idEq(inserted.get(2).getId())
+      .findUnique();
+    assertNotNull(c2);
+    statistics = beanCache.getStatistics(true);
+    assertEquals(statistics.getHitCount(), 1);
+
+    LoggedSqlCollector.start();
+
+    List<UUOne> list = Ebean.find(UUOne.class)
+      //.setDefaultLazyLoadBatchSize(5)
+      .select("id")
+      .where().startsWith("name", "testBLWCH")
+      .order("name")
+      .findList();
+
+    for (UUOne uuOne : list) {
+      uuOne.getName();
+    }
+    list.get(0).getName();
+
+    List<String> sql = LoggedSqlCollector.stop();
+    System.out.println("sql:" + sql);
+
+    // batch lazy loading into cache
+    assertThat(sql).hasSize(2);
+    assertThat(sql.get(0)).contains("from uuone t0 where t0.name like ?");
+    assertThat(sql.get(1)).contains("from uuone t0 where t0.id in (?,");
+
+    statistics = beanCache.getStatistics(true);
+    assertThat(statistics.getSize()).isGreaterThan(3);
+  }
+
+}

src/test/java/org/tests/batchload/TestBatchLazyWithDeleted.java

@@ -0,0 +1,85 @@
+package org.tests.batchload;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.FetchConfig;
+import org.tests.model.basic.UUOne;
+import org.tests.model.basic.UUTwo;
+import org.junit.Assert;
+import org.junit.Test;
+
+import javax.persistence.EntityNotFoundException;
+import java.util.List;
+
+public class TestBatchLazyWithDeleted extends BaseTestCase {
+
+  @Test
+  public void testOnDeleted() {
+
+    Ebean.deleteAll(Ebean.find(UUTwo.class).findList());
+    Ebean.deleteAll(Ebean.find(UUOne.class).findList());
+
+    UUOne oneA = new UUOne();
+    oneA.setName("oneA");
+
+    UUOne oneB = new UUOne();
+    oneB.setName("oneB");
+
+    UUTwo two = new UUTwo();
+    two.setName("two-bld-A");
+    two.setMaster(oneA);
+
+    UUTwo twoB = new UUTwo();
+    twoB.setName("two-bld-B");
+    twoB.setMaster(oneA);
+
+    UUTwo twoC = new UUTwo();
+    twoC.setName("two-bld-C");
+    twoC.setMaster(oneB);
+
+    Ebean.save(oneA);
+    Ebean.save(oneB);
+    Ebean.save(two);
+    Ebean.save(twoB);
+    Ebean.save(twoC);
+
+    List<UUTwo> list = Ebean.find(UUTwo.class)
+      .fetch("master", new FetchConfig().lazy(5))
+      .where().startsWith("name", "two-bld-")
+      .order("name")
+      .findList();
+
+    // delete a bean that will be batch lazy loaded but
+    // is NOT the bean that will invoke the lazy loading
+    // (in this case it is the second bean in the list).
+    int deletedCount = Ebean.delete(UUOne.class, oneB.getId());
+    Assert.assertEquals(1, deletedCount);
+
+    for (UUTwo u : list) {
+      u.getMaster();
+      //BeanState beanState = Ebean.getBeanState(master);
+      //Assert.assertTrue(beanState.isReference());
+    }
+
+    // invoke lazy loading on the second 'master' bean
+    // list.get(2).getMaster().getName();
+
+    // invoke lazy loading on the first 'master' bean
+    list.get(0).getMaster().getName();
+
+    // this breaks with IllegalStateException
+    // because the 2nd UUOne bean is still in 'reference' state
+    // and has not had its lazyLoadProperty set so it fails as
+    // it was removed from the "lazy load context" earlier
+    try {
+      list.get(2).getMaster().getName();
+      Assert.assertTrue(false);
+    } catch (EntityNotFoundException e) {
+      // this bean was deleted and lazy loading failed
+      Assert.assertTrue(true);
+    }
+
+
+  }
+
+}

src/test/java/org/tests/batchload/TestEmptyManyLazyLoad.java

@@ -0,0 +1,30 @@
+package org.tests.batchload;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.Order.Status;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+public class TestEmptyManyLazyLoad extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    Customer c = Ebean.find(Customer.class).findList().get(0);
+
+    Order o = new Order();
+    o.setCustomer(c);
+    o.setStatus(Status.NEW);
+
+    Ebean.save(o);
+
+    Order o2 = Ebean.find(Order.class, o.getId());
+    o2.getDetails().size();
+
+  }
+}

src/test/java/org/tests/batchload/TestLazyJoin.java

@@ -0,0 +1,42 @@
+package org.tests.batchload;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.Query;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestLazyJoin extends BaseTestCase {
+
+  @Test
+  public void testLazyOnNonLoaded() {
+
+    ResetBasicData.reset();
+
+    Query<Order> query = Ebean.find(Order.class)
+      .select("status")
+      .fetch("customer", "+lazy(10) name, status")
+      .fetch("customer.contacts")
+      .order().asc("id");
+
+    List<Order> list = query.findList();
+
+    Order order = list.get(0);
+    Customer customer = order.getCustomer();
+
+    // this invokes lazy loading on a property that is
+    // not one of the selected ones (name, status) ... and
+    // therefore the lazy load query selects all properties
+    // in the customer (not just name and status)
+    Address billingAddress = customer.getBillingAddress();
+
+    Assert.assertNotNull(billingAddress);
+  }
+
+}

src/test/java/org/tests/batchload/TestLazyJoin2.java

@@ -0,0 +1,74 @@
+package org.tests.batchload;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.FetchConfig;
+import org.tests.model.basic.Address;
+import org.tests.model.basic.Contact;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.Order;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestLazyJoin2 extends BaseTestCase {
+
+  @Test
+  public void testLazyOnNonLoaded() {
+
+    ResetBasicData.reset();
+
+    // This will use 3 SQL queries to build this object graph
+    List<Order> l0 = Ebean.find(Order.class).select("status, shipDate")
+
+      .fetch("details", "orderQty, unitPrice", new FetchConfig().query())
+      .fetch("details.product", "sku, name")
+
+      .fetch("customer", "name", new FetchConfig().query(10))
+      .fetch("customer.contacts", "firstName, lastName, mobile")
+      .fetch("customer.shippingAddress", "line1, city").order().asc("id").findList();
+
+    Order o0 = l0.get(0);
+    Customer c0 = o0.getCustomer();
+    List<Contact> contacts = c0.getContacts();
+    Assert.assertTrue(!contacts.isEmpty());
+
+    // query 1) find order (status, shipDate)
+    // query 2) find orderDetail (quantity, price) join product (sku, name)
+    // where order.id in (?,? ...)
+    // query 3) find customer (name) join contacts (*) join shippingAddress (*)
+    // where id in (?,?,?,?,?)
+
+    List<Order> orders = Ebean.find(Order.class)
+      // .select("status")
+      .fetch("customer", new FetchConfig().query(3).lazy(10)).order().asc("id").findList();
+    // .join("customer.contacts");
+
+    // List<Order> list = query.findList();
+
+    Order order = orders.get(0);
+    Customer customer = order.getCustomer();
+
+    // this invokes lazy loading on a property that is
+    // not one of the selected ones (name, status) ... and
+    // therefore the lazy load query selects all properties
+    // in the customer (not just name and status)
+    Address billingAddress = customer.getBillingAddress();
+
+    Assert.assertNotNull(billingAddress);
+
+    List<Order> list = Ebean.find(Order.class).fetch("customer", "name", new FetchConfig().lazy(5))
+      .fetch("customer.contacts", "contactName, phone, email").fetch("customer.shippingAddress")
+      .where().eq("status", Order.Status.NEW).order().asc("id").findList();
+
+    Order order2 = list.get(0);
+    Customer customer2 = order2.getCustomer();
+    // customer2.getStatus();
+    String name = customer2.getName();
+    Assert.assertNotNull(name);
+
+  }
+
+}

src/test/java/org/tests/batchload/TestLazyLoadEmptyCollection.java

@@ -0,0 +1,42 @@
+package org.tests.batchload;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.FetchConfig;
+import org.tests.model.basic.Contact;
+import org.tests.model.basic.Customer;
+import org.tests.model.basic.ResetBasicData;
+import org.junit.Test;
+
+import java.util.List;
+
+public class TestLazyLoadEmptyCollection extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    ResetBasicData.reset();
+
+    Customer c = new Customer();
+    c.setName("lazytest");
+
+    Contact con = new Contact("jim", "slim");
+    c.addContact(con);
+
+    Ebean.save(c);
+
+    List<Customer> list = Ebean.find(Customer.class)
+      .fetch("contacts", new FetchConfig().query(0))
+      .fetch("contacts.notes", new FetchConfig().query(100))
+      .findList();
+
+    for (Customer customer : list) {
+      List<Contact> contacts = customer.getContacts();
+      for (Contact contact : contacts) {
+        contact.getNotes();
+      }
+    }
+
+  }
+
+}