#919 - io.ebean package initial

src/test/java/org/tests/persistencecontext/TestPersistenceContextOnUpdateDuringTxn.java

@@ -0,0 +1,43 @@
+package org.tests.persistencecontext;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.EbeanServer;
+import org.tests.model.basic.EBasic;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestPersistenceContextOnUpdateDuringTxn extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    EbeanServer server = Ebean.getServer(null);
+
+    server.beginTransaction();
+    try {
+
+      EBasic bean1 = new EBasic();
+      bean1.setName("hello");
+
+      server.save(bean1);
+
+      EBasic updatedEntity = new EBasic();
+      updatedEntity.setId(bean1.getId());
+      updatedEntity.setName("hello-changed");
+
+      server.update(updatedEntity);
+
+      // actually the bean is not in the persistence context so ...  the assert is fine
+      EBasic loadedEntity = server.find(EBasic.class, bean1.getId());
+
+      assertThat(loadedEntity.getName()).isEqualTo("hello-changed");
+
+    } finally {
+      server.endTransaction();
+    }
+
+  }
+
+}

src/test/java/org/tests/persistencecontext/TestPersistenceContextQueryScope.java

@@ -0,0 +1,74 @@
+package org.tests.persistencecontext;
+
+import io.ebean.BaseTestCase;
+import io.ebean.Ebean;
+import io.ebean.SqlUpdate;
+import org.tests.model.basic.EBasicVer;
+import org.junit.Test;
+
+import static io.ebean.PersistenceContextScope.QUERY;
+import static io.ebean.PersistenceContextScope.TRANSACTION;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+
+
+public class TestPersistenceContextQueryScope extends BaseTestCase {
+
+  @Test
+  public void test() {
+
+    EBasicVer bean = new EBasicVer("first");
+    Ebean.save(bean);
+
+    //Ebean.getServerCacheManager().setCaching(EBasicVer.class, true);
+
+    Ebean.beginTransaction();
+    try {
+      EBasicVer bean1 = Ebean.find(EBasicVer.class, bean.getId());
+
+      // do an update of the name in the DB
+      SqlUpdate sqlUpdate = Ebean.createSqlUpdate("update e_basicver set name=? where id=?");
+      sqlUpdate.setParameter(1, "second");
+      sqlUpdate.setParameter(2, bean.getId());
+      int rowCount = sqlUpdate.execute();
+      assertEquals(1, rowCount);
+
+      // fetch the bean again... but doesn't hit DB as it
+      // is in the PersistenceContext which is transaction scoped
+      EBasicVer bean2 = Ebean.find(EBasicVer.class)
+        .setId(bean.getId())
+        .setUseCache(false) // ignore L2 cache
+        .findUnique();
+
+      // QUERY scope hits the DB (doesn't use the existing transactions persistence context)
+      // ... also explicitly not use bean cache
+      EBasicVer bean3 = Ebean.find(EBasicVer.class)
+        .setId(bean.getId())
+        .setUseCache(false) // ignore L2 cache
+        .setPersistenceContextScope(QUERY)
+        .findUnique();
+
+      // TRANsACTION scope ... same as bean2 and does not hit the DB
+      EBasicVer bean5 = Ebean.find(EBasicVer.class)
+        .setId(bean.getId())
+        .setUseCache(false) // ignore L2 cache
+        .setPersistenceContextScope(TRANSACTION)
+        .findUnique();
+
+      assertEquals("first", bean.getName());
+      assertEquals("first", bean1.getName());
+      assertEquals("first", bean2.getName());
+      assertEquals("first", bean5.getName());
+      assertSame(bean1, bean2);
+      assertSame(bean1, bean5);
+
+      assertEquals("second", bean3.getName());
+      Ebean.delete(bean3);
+
+      Ebean.commitTransaction();
+
+    } finally {
+      Ebean.endTransaction();
+    }
+  }
+}

src/test/java/org/tests/persistencecontext/TestPersistenceContextScopeUsingOrders.java

@@ -0,0 +1,51 @@
+package org.tests.persistencecontext;
+
+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.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import static io.ebean.PersistenceContextScope.QUERY;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class TestPersistenceContextScopeUsingOrders extends BaseTestCase {
+
+  @Test
+  public void test_persistenceContextScopeQuery() {
+
+    ResetBasicData.reset();
+
+    List<Order> orders = Ebean.find(Order.class)
+      // Use QUERY or TRANSACTION scope (just not NONE)
+      .setPersistenceContextScope(QUERY)
+      .fetch("customer", "id, name")
+      .where().istartsWith("customer.name", "rob").eq("customer.id", 1)
+      .orderBy().asc("customer.name")
+      .findList();
+
+    assertTrue(!orders.isEmpty());
+
+    // collect the customer instances
+    List<Customer> customers = new ArrayList<>();
+    Set<Integer> identities = new HashSet<>();
+
+    for (Order order : orders) {
+      Customer customer = order.getCustomer();
+      identities.add(System.identityHashCode(customer));
+      customers.add(customer);
+    }
+
+    // only one instance of Customer this time ...
+    assertEquals(1, identities.size());
+    assertTrue(customers.size() > 1);
+  }
+
+}

src/test/java/org/tests/persistencecontext/TestPersistenceContextServerConfig.java

@@ -0,0 +1,63 @@
+package org.tests.persistencecontext;
+
+import io.ebean.BaseTestCase;
+import io.ebean.EbeanServer;
+import io.ebean.EbeanServerFactory;
+import io.ebean.PersistenceContextScope;
+import io.ebean.Query;
+import io.ebean.config.ContainerConfig;
+import io.ebean.config.ServerConfig;
+import io.ebeaninternal.api.SpiEbeanServer;
+import io.ebeaninternal.api.SpiQuery;
+import org.tests.model.basic.EBasicVer;
+import org.junit.Test;
+
+import java.util.Properties;
+
+import static org.junit.Assert.assertEquals;
+
+public class TestPersistenceContextServerConfig extends BaseTestCase {
+
+  @Test
+  public void test_config() {
+
+    SpiEbeanServer ebeanServer = (SpiEbeanServer) create();
+
+    Query<EBasicVer> query = ebeanServer.find(EBasicVer.class);
+
+    PersistenceContextScope scope = ebeanServer.getPersistenceContextScope((SpiQuery<?>) query);
+
+    assertEquals(PersistenceContextScope.QUERY, scope);
+  }
+
+  static EbeanServer create() {
+
+    System.setProperty("ebean.ignoreExtraDdl", "true");
+
+    ServerConfig config = new ServerConfig();
+    config.setName("withPCQuery");
+
+    Properties properties = new Properties();
+    properties.setProperty("datasource.withPCQuery.username", "sa");
+    properties.setProperty("datasource.withPCQuery.password", "");
+    properties.setProperty("datasource.withPCQuery.databaseUrl", "jdbc:h2:mem:withPCQuery;");
+    properties.setProperty("datasource.withPCQuery.databaseDriver", "org.h2.Driver");
+
+    config.loadFromProperties(properties);
+    config.setPersistenceContextScope(PersistenceContextScope.QUERY);
+    config.setContainerConfig(new ContainerConfig());
+    config.setDefaultServer(false);
+    config.setRegister(false);
+
+//    DataSourceConfig dataSourceConfig = new DataSourceConfig();
+//    dataSourceConfig.setUsername("sa");
+//    dataSourceConfig.setPassword("");
+//    dataSourceConfig.setUrl("jdbc:h2:mem:withPCQuery;");
+//    dataSourceConfig.setDriver("org.h2.Driver");
+//    config.setDataSourceConfig(dataSourceConfig);
+
+    config.addClass(EBasicVer.class);
+
+    return EbeanServerFactory.create(config);
+  }
+}