Refactor move tests from ebean-core to ebean-test

This commit is contained in:
rbygrave committed 2021-09-08 22:49:23 +12:00
1 parent 0b00a14fd3
commit eab56d323b
1650 files changed
+185 -147

No files matched your search

@@ -0,0 +1,43 @@
package org.tests.persistencecontext;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import io.ebean.Database;
import org.tests.model.basic.EBasic;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
public class TestPersistenceContextOnUpdateDuringTxn extends BaseTestCase {
@Test
public void test() {
Database server = DB.getDefault();
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();
}
}
}
@@ -0,0 +1,75 @@
package org.tests.persistencecontext;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import io.ebean.DB;
import org.junit.jupiter.api.Test;
import org.tests.model.basic.EBasicVer;
import static io.ebean.PersistenceContextScope.QUERY;
import static io.ebean.PersistenceContextScope.TRANSACTION;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertSame;
public class TestPersistenceContextQueryScope extends BaseTestCase {
@Test
public void test() {
EBasicVer bean = new EBasicVer("first");
DB.save(bean);
//DB.cacheManager().setCaching(EBasicVer.class, true);
DB.beginTransaction();
try {
EBasicVer bean1 = DB.find(EBasicVer.class, bean.getId());
// do an update of the name in the DB
int rowCount = DB.sqlUpdate("update e_basicver set name=? where id=?")
.setParameter("second")
.setParameter(bean.getId())
.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 = DB.find(EBasicVer.class)
.setId(bean.getId())
.setUseCache(false) // ignore L2 cache
.findOne();
// QUERY scope hits the DB (doesn't use the existing transactions persistence context)
// ... also explicitly not use bean cache
EBasicVer bean3 = DB.find(EBasicVer.class)
.setId(bean.getId())
.setUseCache(false) // ignore L2 cache
.setPersistenceContextScope(QUERY)
.findOne();
// TRANsACTION scope ... same as bean2 and does not hit the DB
EBasicVer bean5 = DB.find(EBasicVer.class)
.setId(bean.getId())
.setUseCache(false) // ignore L2 cache
.setPersistenceContextScope(TRANSACTION)
.findOne();
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());
DB.delete(bean3);
DB.commitTransaction();
} finally {
DB.endTransaction();
}
}
}
@@ -0,0 +1,51 @@
package org.tests.persistencecontext;
import io.ebean.BaseTestCase;
import io.ebean.DB;
import org.tests.model.basic.Customer;
import org.tests.model.basic.Order;
import org.tests.model.basic.ResetBasicData;
import org.junit.jupiter.api.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.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class TestPersistenceContextScopeUsingOrders extends BaseTestCase {
@Test
public void test_persistenceContextScopeQuery() {
ResetBasicData.reset();
List<Order> orders = DB.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)
.order().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);
}
}
@@ -0,0 +1,55 @@
package org.tests.persistencecontext;
import io.ebean.BaseTestCase;
import io.ebean.Database;
import io.ebean.DatabaseFactory;
import io.ebean.PersistenceContextScope;
import io.ebean.Query;
import io.ebean.config.ContainerConfig;
import io.ebean.config.DatabaseConfig;
import io.ebeaninternal.api.SpiEbeanServer;
import io.ebeaninternal.api.SpiQuery;
import org.junit.jupiter.api.Test;
import org.tests.model.basic.EBasicVer;
import java.util.Properties;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestPersistenceContextServerConfig extends BaseTestCase {
@Test
public void test_config() {
SpiEbeanServer ebeanServer = (SpiEbeanServer) create();
try {
Query<EBasicVer> query = ebeanServer.find(EBasicVer.class);
PersistenceContextScope scope = ebeanServer.persistenceContextScope((SpiQuery<?>) query);
assertEquals(PersistenceContextScope.QUERY, scope);
} finally {
ebeanServer.shutdown();
}
}
static Database create() {
DatabaseConfig config = new DatabaseConfig();
config.setName("withPCQuery");
config.setDdlExtra(false);
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);
config.addClass(EBasicVer.class);
return DatabaseFactory.create(config);
}
}