mirror of
https://github.com/ebean-orm/ebean.git
synced 2026-11-19 23:02:24 +00:00
Merge remote-tracking branch 'upstream/master'
# Conflicts: # ebean-ddl-generator/pom.xml # ebean-test/src/test/java/io/ebean/xtest/core/DatesAndTimesTest.java # ebean-test/src/test/java/io/ebean/xtest/core/DatesAndTimesWithJsonMillisTest.java # ebean-test/src/test/java/io/ebean/xtest/core/DatesAndTimesWithJsonNanosTest.java
This commit is contained in:
commit
0c9ec4ebfc
191 files changed
+2380
-1165
No files matched your search
@@ -1,7 +1,11 @@
|
||||
package io.ebean.test.config.platform;
|
||||
|
||||
import io.ebean.annotation.Platform;
|
||||
import io.ebean.config.DatabaseConfig;
|
||||
import io.ebean.datasource.DataSourceConfig;
|
||||
import io.ebeaninternal.api.DbOffline;
|
||||
import org.junit.jupiter.api.AfterAll;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Disabled;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
@@ -12,6 +16,17 @@ import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class ConfigTest {
|
||||
|
||||
@BeforeAll
|
||||
public static void before() {
|
||||
// so that RunOnceMarker is not set when running these tests
|
||||
DbOffline.setPlatform(Platform.H2);
|
||||
}
|
||||
|
||||
@AfterAll
|
||||
public static void after() {
|
||||
DbOffline.reset();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void trimExtensions() {
|
||||
|
||||
|
||||
@@ -1,6 +1,9 @@
|
||||
package io.ebean.xtest;
|
||||
|
||||
import io.ebean.*;
|
||||
import io.ebean.CacheMode;
|
||||
import io.ebean.DB;
|
||||
import io.ebean.Database;
|
||||
import io.ebean.Query;
|
||||
import io.ebean.annotation.PersistBatch;
|
||||
import io.ebean.annotation.Platform;
|
||||
import io.ebean.cache.ServerCacheStatistics;
|
||||
@@ -10,10 +13,7 @@ import io.ebean.meta.ServerMetrics;
|
||||
import io.ebean.util.StringHelper;
|
||||
import io.ebean.xtest.base.PlatformCondition;
|
||||
import io.ebeaninternal.api.SpiEbeanServer;
|
||||
import io.ebeaninternal.api.SpiQuery;
|
||||
import io.ebeaninternal.api.SpiTransaction;
|
||||
import io.ebeaninternal.server.core.HelpCreateQueryRequest;
|
||||
import io.ebeaninternal.server.core.OrmQueryRequest;
|
||||
import io.ebeaninternal.server.deploy.BeanDescriptor;
|
||||
import io.ebeaninternal.server.expression.platform.DbExpressionHandler;
|
||||
import io.ebeaninternal.server.expression.platform.DbExpressionHandlerFactory;
|
||||
@@ -325,8 +325,4 @@ public abstract class BaseTestCase {
|
||||
DbExpressionHandler dbExpressionHandler = DbExpressionHandlerFactory.from(spiEbeanServer().databasePlatform());
|
||||
return dbExpressionHandler.concat(property0, separator, property1, suffix);
|
||||
}
|
||||
|
||||
protected <T> OrmQueryRequest<T> createQueryRequest(SpiQuery.Type type, Query<T> query, Transaction t) {
|
||||
return HelpCreateQueryRequest.create(server(), type, query, t);
|
||||
}
|
||||
}
|
||||
+1
-1
@@ -1,4 +1,4 @@
|
||||
package io.ebeaninternal.server.core;
|
||||
package io.ebean.xtest.core;
|
||||
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
+9
-10
@@ -1,18 +1,17 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
package io.ebean.xtest.core;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.DB;
|
||||
import io.ebean.SqlRow;
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.UUOne;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
||||
|
||||
public class TestBinaryUUID extends BaseTestCase {
|
||||
public class TestBinaryUUID {
|
||||
|
||||
@Test
|
||||
public void test() {
|
||||
@@ -31,11 +30,11 @@ public class TestBinaryUUID extends BaseTestCase {
|
||||
UUOne fetch0 = DB.find(UUOne.class, one0.getId());
|
||||
UUOne fetch1 = DB.find(UUOne.class, one1.getId());
|
||||
|
||||
assertEquals(one0.getId(), fetch0.getId());
|
||||
assertEquals(one0.getName(), fetch0.getName());
|
||||
Assertions.assertEquals(one0.getId(), fetch0.getId());
|
||||
Assertions.assertEquals(one0.getName(), fetch0.getName());
|
||||
|
||||
assertEquals(one1.getId(), fetch1.getId());
|
||||
assertEquals(one1.getName(), fetch1.getName());
|
||||
Assertions.assertEquals(one1.getId(), fetch1.getId());
|
||||
Assertions.assertEquals(one1.getName(), fetch1.getName());
|
||||
|
||||
String sql = "select id, name from uuone";
|
||||
List<SqlRow> list = DB.sqlQuery(sql).findList();
|
||||
@@ -50,8 +49,8 @@ public class TestBinaryUUID extends BaseTestCase {
|
||||
String asJson = DB.json().toJson(fetch0);
|
||||
UUOne bean = DB.json().toBean(UUOne.class, asJson);
|
||||
|
||||
assertEquals(fetch0.getId(), bean.getId());
|
||||
assertEquals(fetch0.getName(), bean.getName());
|
||||
Assertions.assertEquals(fetch0.getId(), bean.getId());
|
||||
Assertions.assertEquals(fetch0.getName(), bean.getName());
|
||||
}
|
||||
|
||||
}
|
||||
+1
-1
@@ -1,4 +1,4 @@
|
||||
package io.ebeaninternal.server.deploy;
|
||||
package io.ebean.xtest.core;
|
||||
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
+1
-1
@@ -1,4 +1,4 @@
|
||||
package io.ebeaninternal.server.deploy;
|
||||
package io.ebean.xtest.core;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.BeanState;
|
||||
@@ -0,0 +1,64 @@
|
||||
package io.ebean.xtest.expression;
|
||||
|
||||
import io.ebean.Query;
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import org.assertj.core.api.Assertions;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Address;
|
||||
import org.tests.model.basic.Customer;
|
||||
import org.tests.model.basic.ResetBasicData;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
|
||||
public class DefaultExampleExpressionTest extends BaseTestCase {
|
||||
|
||||
Customer customer() {
|
||||
Address address = new Address();
|
||||
address.setCity("billingAddress.city");
|
||||
|
||||
Customer customer = new Customer();
|
||||
customer.setName("name");
|
||||
customer.setBillingAddress(address);
|
||||
return customer;
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test() {
|
||||
|
||||
Customer customer = customer();
|
||||
customer.setName("Rob");
|
||||
customer.getBillingAddress().setCity("Auckland");
|
||||
|
||||
ResetBasicData.reset();
|
||||
|
||||
Query<Customer> query1 = server().find(Customer.class)
|
||||
.where().exampleLike(customer)
|
||||
.query();
|
||||
|
||||
query1.findList();
|
||||
|
||||
assertThat(query1.getGeneratedSql()).contains("(t0.name like ");
|
||||
assertThat(query1.getGeneratedSql()).contains(" and t1.city like ");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void emptyExampleBean() {
|
||||
|
||||
ResetBasicData.reset();
|
||||
|
||||
Customer customer = new Customer();
|
||||
|
||||
Query<Customer> query = server().find(Customer.class)
|
||||
.where()
|
||||
.eq("status", Customer.Status.NEW)
|
||||
.exampleLike(customer)
|
||||
.startsWith("name", "Rob")
|
||||
.query();
|
||||
|
||||
query.findList();
|
||||
|
||||
Assertions.assertThat(sqlOf(query)).contains("and 1=1 and t0.name like");
|
||||
}
|
||||
|
||||
}
|
||||
+2
-1
@@ -1,9 +1,10 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
package io.ebean.xtest.expression;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.DB;
|
||||
import io.ebean.Query;
|
||||
import io.ebean.test.LoggedSql;
|
||||
import org.assertj.core.api.Assertions;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Contact;
|
||||
import org.tests.model.basic.Customer;
|
||||
-123
@@ -1,123 +0,0 @@
|
||||
package io.ebeaninternal.server.cache;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.bean.EntityBean;
|
||||
import io.ebean.bean.PersistenceContext;
|
||||
import io.ebeaninternal.api.SpiEbeanServer;
|
||||
import io.ebeaninternal.server.deploy.BeanDescriptor;
|
||||
import io.ebeaninternal.server.deploy.BeanPropertyAssocOne;
|
||||
import io.ebeaninternal.server.transaction.DefaultPersistenceContext;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Address;
|
||||
import org.tests.model.basic.Country;
|
||||
import org.tests.model.basic.Customer;
|
||||
import org.tests.model.basic.Customer.Status;
|
||||
import org.tests.model.embedded.EAddress;
|
||||
import org.tests.model.embedded.EPerson;
|
||||
|
||||
import java.sql.Timestamp;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
||||
|
||||
public class CacheBeanDataTest extends BaseTestCase {
|
||||
|
||||
@Test
|
||||
public void extract_load_on_customer() {
|
||||
|
||||
SpiEbeanServer server = spiEbeanServer();
|
||||
BeanDescriptor<Customer> desc = server.descriptor(Customer.class);
|
||||
|
||||
Customer c = new Customer();
|
||||
c.setId(98989);
|
||||
c.setName("Rob");
|
||||
c.setCretime(new Timestamp(System.currentTimeMillis()));
|
||||
c.setUpdtime(new Timestamp(System.currentTimeMillis()));
|
||||
c.setStatus(Status.ACTIVE);
|
||||
c.setSmallnote("somenote");
|
||||
|
||||
Address billingAddress = new Address();
|
||||
billingAddress.setId(12);
|
||||
billingAddress.setCity("Auckland");
|
||||
billingAddress.setCountry(server.reference(Country.class, "NZ"));
|
||||
billingAddress.setLine1("92 Someplace Else");
|
||||
c.setBillingAddress(billingAddress);
|
||||
|
||||
((EntityBean) c)._ebean_getIntercept().setLoaded();
|
||||
|
||||
CachedBeanData cacheData = CachedBeanDataFromBean.extract(desc, (EntityBean) c);
|
||||
|
||||
|
||||
assertNotNull(cacheData);
|
||||
|
||||
Customer newCustomer = new Customer();
|
||||
newCustomer.setId(c.getId());
|
||||
CachedBeanDataToBean.load(desc, (EntityBean) newCustomer, cacheData, new DefaultPersistenceContext());
|
||||
|
||||
assertEquals(c.getId(), newCustomer.getId());
|
||||
assertEquals(c.getName(), newCustomer.getName());
|
||||
assertEquals(c.getStatus(), newCustomer.getStatus());
|
||||
assertEquals(c.getSmallnote(), newCustomer.getSmallnote());
|
||||
assertEquals(c.getCretime(), newCustomer.getCretime());
|
||||
assertEquals(c.getUpdtime(), newCustomer.getUpdtime());
|
||||
assertEquals(c.getBillingAddress().getId(), newCustomer.getBillingAddress().getId());
|
||||
|
||||
assertNotNull(newCustomer.getId());
|
||||
assertNotNull(newCustomer.getName());
|
||||
assertNotNull(newCustomer.getStatus());
|
||||
assertNotNull(newCustomer.getSmallnote());
|
||||
assertNotNull(newCustomer.getCretime());
|
||||
assertNotNull(newCustomer.getUpdtime());
|
||||
assertNotNull(newCustomer.getBillingAddress());
|
||||
assertNotNull(newCustomer.getBillingAddress().getId());
|
||||
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void extract_load_withEmbeddedBean() {
|
||||
|
||||
SpiEbeanServer server = spiEbeanServer();
|
||||
BeanDescriptor<EPerson> desc = server.descriptor(EPerson.class);
|
||||
BeanPropertyAssocOne<?> addressBeanProperty = (BeanPropertyAssocOne<?>) desc.beanProperty("address");
|
||||
|
||||
EAddress address = new EAddress();
|
||||
address.setStreet("92 Someplace Else");
|
||||
address.setSuburb("Sandringham");
|
||||
address.setCity("Auckland");
|
||||
|
||||
EPerson person = new EPerson();
|
||||
person.setId(98989L);
|
||||
person.setName("Rob");
|
||||
person.setAddress(address);
|
||||
|
||||
CachedBeanData addressCacheData = (CachedBeanData) addressBeanProperty.getCacheDataValue((EntityBean) person);
|
||||
|
||||
PersistenceContext context = new DefaultPersistenceContext();
|
||||
|
||||
EPerson newPersonCheck = new EPerson();
|
||||
newPersonCheck.setId(98989L);
|
||||
addressBeanProperty.setCacheDataValue((EntityBean) newPersonCheck, addressCacheData, context);
|
||||
|
||||
EAddress newAddress = newPersonCheck.getAddress();
|
||||
assertEquals(address.getStreet(), newAddress.getStreet());
|
||||
assertEquals(address.getCity(), newAddress.getCity());
|
||||
assertEquals(address.getSuburb(), newAddress.getSuburb());
|
||||
|
||||
|
||||
CachedBeanData cacheData = desc.cacheEmbeddedBeanExtract((EntityBean) person);
|
||||
|
||||
assertNotNull(cacheData);
|
||||
|
||||
EPerson newPerson = (EPerson) desc.cacheEmbeddedBeanLoad(cacheData, context);
|
||||
|
||||
assertNotNull(newPerson.getId());
|
||||
assertNotNull(newPerson.getName());
|
||||
assertNotNull(newPerson.getAddress());
|
||||
|
||||
assertEquals(person.getId(), newPerson.getId());
|
||||
assertEquals(person.getName(), newPerson.getName());
|
||||
assertEquals(person.getAddress().getStreet(), newPerson.getAddress().getStreet());
|
||||
assertEquals(person.getAddress().getCity(), newPerson.getAddress().getCity());
|
||||
}
|
||||
}
|
||||
-127
@@ -1,127 +0,0 @@
|
||||
package io.ebeaninternal.server.cache;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.bean.EntityBean;
|
||||
import io.ebeaninternal.api.SpiEbeanServer;
|
||||
import io.ebeaninternal.server.deploy.BeanDescriptor;
|
||||
import io.ebeaninternal.server.transaction.DefaultPersistenceContext;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Address;
|
||||
import org.tests.model.basic.Car;
|
||||
import org.tests.model.basic.Contact;
|
||||
import org.tests.model.basic.Customer;
|
||||
|
||||
import java.sql.Date;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
public class CachedBeanDataFromBeanTest extends BaseTestCase {
|
||||
|
||||
private final SpiEbeanServer server = spiEbeanServer();
|
||||
|
||||
@Test
|
||||
public void extract() {
|
||||
|
||||
BeanDescriptor<Customer> desc = server.descriptor(Customer.class);
|
||||
|
||||
Date largeDate = new Date(9223372036825200000L);
|
||||
|
||||
Customer customer = new Customer();
|
||||
customer.setId(42);
|
||||
customer.setName("Rob");
|
||||
customer.setAnniversary(largeDate);
|
||||
|
||||
Address billingAddress = new Address();
|
||||
billingAddress.setId(12);
|
||||
billingAddress.setCity("SomePlace");
|
||||
|
||||
customer.setBillingAddress(billingAddress);
|
||||
|
||||
CachedBeanData cacheData = CachedBeanDataFromBean.extract(desc, (EntityBean) customer);
|
||||
|
||||
assertEquals(cacheData.getData("id"), "42");
|
||||
assertEquals(cacheData.getData("name"), "Rob");
|
||||
assertEquals(cacheData.getData("billingAddress"), "12");
|
||||
assertEquals(cacheData.getData("anniversary"), "9223372036825200000");
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void inheritance() {
|
||||
|
||||
Car car = new Car();
|
||||
car.setId(42);
|
||||
car.setDriver("Jimmy");
|
||||
car.setNotes("some notes");
|
||||
|
||||
BeanDescriptor<Car> carDesc = server.descriptor(Car.class);
|
||||
CachedBeanData cacheData = CachedBeanDataFromBean.extract(carDesc, (EntityBean) car);
|
||||
|
||||
Car newCar = new Car();
|
||||
EntityBean entityBean = (EntityBean) newCar;
|
||||
CachedBeanDataToBean.load(carDesc, entityBean, cacheData, new DefaultPersistenceContext());
|
||||
|
||||
assertEquals(newCar.getId(), car.getId());
|
||||
assertEquals(newCar.getDriver(), car.getDriver());
|
||||
assertEquals(newCar.getNotes(), car.getNotes());
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
@Test
|
||||
public void dirtyScalar_expect_originalValueUsed() {
|
||||
|
||||
Contact contact = new Contact();
|
||||
contact.setId(42);
|
||||
contact.setLastName("Bygrave");
|
||||
contact.setFirstName("Foo");
|
||||
contact.setEmail("rob@email.com");
|
||||
|
||||
EntityBean entityBean = (EntityBean)contact;
|
||||
entityBean._ebean_getIntercept().setLoaded();
|
||||
|
||||
// mutate, dirty
|
||||
contact.setLastName("Banana");
|
||||
|
||||
final BeanDescriptor<Contact> desc = getBeanDescriptor(Contact.class);
|
||||
CachedBeanData cacheData = CachedBeanDataFromBean.extract(desc, entityBean);
|
||||
|
||||
final Map<String, Object> data = cacheData.getData();
|
||||
assertThat(data.get("id")).isEqualTo("42");
|
||||
assertThat(data.get("lastName")).isEqualTo("Bygrave"); // ORIGINAL VALUE
|
||||
assertThat(data.get("firstName")).isEqualTo(contact.getFirstName());
|
||||
assertThat(data.get("email")).isEqualTo(contact.getEmail());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void dirtyManyToOne_expect_originalValueUsed() {
|
||||
|
||||
Customer customer = new Customer();
|
||||
customer.setId(99);
|
||||
|
||||
Contact contact = new Contact();
|
||||
contact.setFirstName("Foo");
|
||||
contact.setLastName("Bygrave");
|
||||
contact.setEmail("rob@email.com");
|
||||
contact.setCustomer(customer);
|
||||
|
||||
EntityBean entityBean = (EntityBean)contact;
|
||||
entityBean._ebean_getIntercept().setLoaded();
|
||||
|
||||
// mutate, dirty
|
||||
Customer customer2 = new Customer();
|
||||
customer2.setId(108);
|
||||
contact.setCustomer(customer2);
|
||||
contact.setLastName("Banana");
|
||||
|
||||
final BeanDescriptor<Contact> desc = getBeanDescriptor(Contact.class);
|
||||
CachedBeanData cacheData = CachedBeanDataFromBean.extract(desc, entityBean);
|
||||
|
||||
final Map<String, Object> data = cacheData.getData();
|
||||
assertThat(data.get("lastName")).isEqualTo("Bygrave"); // Original value
|
||||
assertThat(data.get("customer")).isEqualTo("99"); // Original value
|
||||
assertThat(data.get("firstName")).isEqualTo(contact.getFirstName());
|
||||
assertThat(data.get("email")).isEqualTo(contact.getEmail());
|
||||
}
|
||||
}
|
||||
-135
@@ -1,135 +0,0 @@
|
||||
package io.ebeaninternal.server.cache;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.DB;
|
||||
import io.ebean.bean.EntityBean;
|
||||
import io.ebeaninternal.server.deploy.BeanDescriptor;
|
||||
import io.ebeaninternal.server.transaction.DefaultPersistenceContext;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Customer;
|
||||
import org.tests.model.basic.ResetBasicData;
|
||||
import org.tests.model.basic.TBytesOnly;
|
||||
|
||||
import java.io.*;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.Arrays;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
|
||||
public class CachedBeanDataSerializeTest extends BaseTestCase {
|
||||
|
||||
@Test
|
||||
public void write() throws IOException, ClassNotFoundException {
|
||||
|
||||
Map<String, Object> map = new LinkedHashMap<>();
|
||||
map.put("name", "rob");
|
||||
map.put("some", "thing");
|
||||
map.put("whenCreated", "" + System.currentTimeMillis());
|
||||
|
||||
long version = System.currentTimeMillis();
|
||||
CachedBeanData write = new CachedBeanData(null, "C", map, version);
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
ObjectOutputStream oos = new ObjectOutputStream(os);
|
||||
|
||||
write.writeExternal(oos);
|
||||
oos.flush();
|
||||
oos.close();
|
||||
|
||||
byte[] bytes = os.toByteArray();
|
||||
|
||||
ByteArrayInputStream is = new ByteArrayInputStream(bytes);
|
||||
ObjectInputStream ois = new ObjectInputStream(is);
|
||||
|
||||
CachedBeanData read = new CachedBeanData();
|
||||
read.readExternal(ois);
|
||||
|
||||
assertEquals(read.getVersion(), write.getVersion());
|
||||
assertEquals(read.getWhenCreated(), write.getWhenCreated());
|
||||
assertEquals(read.getDiscValue(), write.getDiscValue());
|
||||
assertEquals(read.getData(), write.getData());
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void fullBean() throws IOException, ClassNotFoundException {
|
||||
|
||||
ResetBasicData.reset();
|
||||
|
||||
List<Customer> customers = DB.find(Customer.class)
|
||||
.order().asc("id")
|
||||
.setMaxRows(1).findList();
|
||||
|
||||
Customer customer = customers.get(0);
|
||||
|
||||
BeanDescriptor<Customer> desc = getBeanDescriptor(Customer.class);
|
||||
CachedBeanData extract = CachedBeanDataFromBean.extract(desc, (EntityBean) customer);
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
writeToStream(extract, os);
|
||||
|
||||
byte[] bytes = os.toByteArray();
|
||||
|
||||
CachedBeanData read = readFromStream(bytes);
|
||||
|
||||
assertEquals(read.getData(), extract.getData());
|
||||
|
||||
Customer loadCustomer = new Customer();
|
||||
CachedBeanDataToBean.load(desc, (EntityBean) loadCustomer, read, new DefaultPersistenceContext());
|
||||
|
||||
assertEquals(loadCustomer.getVersion(), customer.getVersion());
|
||||
assertEquals(loadCustomer.getId(), customer.getId());
|
||||
assertEquals(loadCustomer.getName(), customer.getName());
|
||||
assertEquals(loadCustomer.getStatus(), customer.getStatus());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void beanWithByteArray() throws IOException, ClassNotFoundException {
|
||||
|
||||
String stringContent = "ThisIsSome";
|
||||
|
||||
TBytesOnly bean = new TBytesOnly();
|
||||
bean.setId(42);
|
||||
bean.setContent(stringContent.getBytes(StandardCharsets.UTF_8));
|
||||
|
||||
BeanDescriptor<TBytesOnly> desc = getBeanDescriptor(TBytesOnly.class);
|
||||
CachedBeanData extract = CachedBeanDataFromBean.extract(desc, (EntityBean) bean);
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
writeToStream(extract, os);
|
||||
byte[] bytes = os.toByteArray();
|
||||
|
||||
CachedBeanData read = readFromStream(bytes);
|
||||
byte[] extraContent = (byte[]) extract.getData("content");
|
||||
|
||||
assertEquals(stringContent, new String(extraContent));
|
||||
assertTrue(Arrays.equals(bean.getContent(), extraContent));
|
||||
|
||||
TBytesOnly loadBean = new TBytesOnly();
|
||||
CachedBeanDataToBean.load(desc, (EntityBean) loadBean, read, new DefaultPersistenceContext());
|
||||
|
||||
assertEquals(loadBean.getId(), bean.getId());
|
||||
assertTrue(Arrays.equals(loadBean.getContent(), bean.getContent()));
|
||||
}
|
||||
|
||||
private CachedBeanData readFromStream(byte[] bytes) throws IOException, ClassNotFoundException {
|
||||
|
||||
ByteArrayInputStream is = new ByteArrayInputStream(bytes);
|
||||
ObjectInputStream ois = new ObjectInputStream(is);
|
||||
return (CachedBeanData) ois.readObject();
|
||||
}
|
||||
|
||||
private void writeToStream(CachedBeanData extract, ByteArrayOutputStream os) throws IOException {
|
||||
|
||||
ObjectOutputStream oos = new ObjectOutputStream(os);
|
||||
oos.writeObject(extract);
|
||||
oos.flush();
|
||||
oos.close();
|
||||
}
|
||||
|
||||
}
|
||||
Vendored
-56
@@ -1,56 +0,0 @@
|
||||
package io.ebeaninternal.server.cache;
|
||||
|
||||
import io.ebean.cache.ServerCacheOptions;
|
||||
import io.ebean.cache.ServerCacheType;
|
||||
import io.ebean.config.DatabaseConfig;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Article;
|
||||
import org.tests.model.basic.Order;
|
||||
import org.tests.model.basic.Product;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
public class DefaultCacheHolder_getCacheOptions_Test {
|
||||
|
||||
private final DefaultCacheHolder cacheHolder;
|
||||
|
||||
public DefaultCacheHolder_getCacheOptions_Test() {
|
||||
|
||||
ServerCacheOptions defaultOptions = new ServerCacheOptions();
|
||||
defaultOptions.setMaxSize(10000);
|
||||
defaultOptions.setMaxSecsToLive(120);
|
||||
|
||||
CacheManagerOptions builder = new CacheManagerOptions(null, new DatabaseConfig(), true)
|
||||
.with(defaultOptions, defaultOptions);
|
||||
|
||||
this.cacheHolder = new DefaultCacheHolder(builder);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void beanOptions_when_set() {
|
||||
|
||||
ServerCacheOptions options = cacheHolder.getCacheOptions(Article.class, ServerCacheType.BEAN);
|
||||
assertEquals(options.getMaxSecsToLive(), 45);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void beanOptions_when_notSet_expect_default() {
|
||||
|
||||
ServerCacheOptions options = cacheHolder.getCacheOptions(Order.class, ServerCacheType.BEAN);
|
||||
assertEquals(options.getMaxSecsToLive(), 120);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void queryOptions_when_set() {
|
||||
|
||||
ServerCacheOptions options = cacheHolder.getCacheOptions(Product.class, ServerCacheType.QUERY);
|
||||
assertEquals(options.getMaxSecsToLive(), 15);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void queryOptions_when_notSet_expect_default() {
|
||||
|
||||
ServerCacheOptions options = cacheHolder.getCacheOptions(Order.class, ServerCacheType.QUERY);
|
||||
assertEquals(options.getMaxSecsToLive(), 120);
|
||||
}
|
||||
}
|
||||
-124
@@ -1,124 +0,0 @@
|
||||
package io.ebeaninternal.server.cache;
|
||||
|
||||
import io.ebean.config.ContainerConfig;
|
||||
import io.ebean.config.CurrentTenantProvider;
|
||||
import io.ebean.config.DatabaseConfig;
|
||||
import io.ebeaninternal.server.cluster.ClusterManager;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Contact;
|
||||
import org.tests.model.basic.Customer;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
public class DefaultServerCacheManagerTest {
|
||||
|
||||
private final ThreadLocal<String> tenantId = new ThreadLocal<>();
|
||||
|
||||
class TdTenPro implements CurrentTenantProvider {
|
||||
|
||||
@Override
|
||||
public Object currentId() {
|
||||
return tenantId.get();
|
||||
}
|
||||
}
|
||||
|
||||
private final ClusterManager clusterManager = new ClusterManager(new ContainerConfig());
|
||||
|
||||
private final DefaultServerCacheManager manager = new DefaultServerCacheManager(new CacheManagerOptions(clusterManager, new DatabaseConfig(), true));
|
||||
|
||||
private final DefaultServerCacheManager multiTenantManager;
|
||||
|
||||
public DefaultServerCacheManagerTest(){
|
||||
CacheManagerOptions builder = new CacheManagerOptions(clusterManager, new DatabaseConfig(), true);
|
||||
builder.with(new TdTenPro());
|
||||
this.multiTenantManager = new DefaultServerCacheManager(builder);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void getCache_normal() {
|
||||
|
||||
DefaultServerCache cache = cache(manager, Customer.class);
|
||||
assertThat(cache.getName()).isEqualTo("org.tests.model.basic.Customer_B");
|
||||
assertThat(cache.getShortName()).isEqualTo("Customer_B");
|
||||
|
||||
DefaultServerCache cache1 = cache(manager, Customer.class);
|
||||
assertThat(cache1).isSameAs(cache);
|
||||
|
||||
DefaultServerCache cache2 = cache(manager, Contact.class);
|
||||
assertThat(cache1).isNotSameAs(cache2);
|
||||
assertThat(cache2.getName()).isEqualTo("org.tests.model.basic.Contact_B");
|
||||
assertThat(cache2.getShortName()).isEqualTo("Contact_B");
|
||||
|
||||
|
||||
DefaultServerCache natKeyCache = (DefaultServerCache) manager.getNaturalKeyCache(Customer.class);
|
||||
assertThat(natKeyCache.getName()).isEqualTo("org.tests.model.basic.Customer_N");
|
||||
assertThat(natKeyCache.getShortName()).isEqualTo("Customer_N");
|
||||
|
||||
DefaultServerCache queryCache = (DefaultServerCache) manager.getQueryCache(Customer.class);
|
||||
assertThat(queryCache.getName()).isEqualTo("org.tests.model.basic.Customer_Q");
|
||||
assertThat(queryCache.getShortName()).isEqualTo("Customer_Q");
|
||||
|
||||
DefaultServerCache collCache = (DefaultServerCache) manager.getCollectionIdsCache(Customer.class, "contacts");
|
||||
assertThat(collCache.getName()).isEqualTo("org.tests.model.basic.Customer.contacts_C");
|
||||
assertThat(collCache.getShortName()).isEqualTo("Customer.contacts_C");
|
||||
|
||||
cache.clearCount.reset();
|
||||
collCache.clearCount.reset();
|
||||
queryCache.clearCount.reset();
|
||||
natKeyCache.clearCount.reset();
|
||||
|
||||
manager.clear(Customer.class);
|
||||
|
||||
assertThat(cache.clearCount.get(true)).isEqualTo(1);
|
||||
assertThat(natKeyCache.clearCount.get(true)).isEqualTo(1);
|
||||
assertThat(queryCache.clearCount.get(true)).isEqualTo(1);
|
||||
assertThat(collCache.clearCount.get(true)).isEqualTo(1);
|
||||
}
|
||||
|
||||
private DefaultServerCache cache(DefaultServerCacheManager manager, Class<?> beanType) {
|
||||
return (DefaultServerCache) manager.getBeanCache(beanType);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getCache_multiTenant() {
|
||||
|
||||
tenantId.set("ten1");
|
||||
DefaultServerCache cache = cache(multiTenantManager, Customer.class);
|
||||
assertThat(cache.getName()).isEqualTo("org.tests.model.basic.Customer_B");
|
||||
cache.put("1", "tenant1");
|
||||
|
||||
tenantId.set("ten2");
|
||||
|
||||
assertThat(cache.get("1")).isNull();
|
||||
|
||||
tenantId.set("ten1");
|
||||
|
||||
assertThat(cache.get("1")).isNotNull();
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getCache_singleTenant() {
|
||||
|
||||
tenantId.set("ten1");
|
||||
DefaultServerCache cache = cache(manager, Customer.class);
|
||||
assertThat(cache.getName()).isEqualTo("org.tests.model.basic.Customer_B");
|
||||
|
||||
cache.put("1", "tenant1");
|
||||
|
||||
tenantId.set("ten2");
|
||||
|
||||
assertThat(cache.get("1")).isEqualTo("tenant1");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isLocalL2Caching() {
|
||||
|
||||
assertTrue(manager.isLocalL2Caching());
|
||||
assertTrue(multiTenantManager.isLocalL2Caching());
|
||||
}
|
||||
|
||||
}
|
||||
-354
@@ -1,354 +0,0 @@
|
||||
package io.ebeaninternal.server.core;
|
||||
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.DB;
|
||||
import io.ebean.FetchConfig;
|
||||
import io.ebean.Query;
|
||||
import io.ebeaninternal.server.querydefn.DefaultOrmQuery;
|
||||
import io.ebeaninternal.server.querydefn.OrmQueryDetail;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Order;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class DefaultServer_createOrmQueryRequestTest extends BaseTestCase {
|
||||
|
||||
Query<Order> query() {
|
||||
return server().find(Order.class);
|
||||
}
|
||||
|
||||
OrmQueryRequest<Order> queryRequest(Query<Order> query) {
|
||||
return OrmQueryRequestTestHelper.queryRequest(query);
|
||||
}
|
||||
|
||||
OrmQueryDetail detail(Query<Order> query) {
|
||||
return queryRequest(query).query().getDetail();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void when_empty_then_same() {
|
||||
|
||||
assertSame(detail(query()), detail(query()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void select_all_then_same() {
|
||||
|
||||
assertSame(detail(query().select("*")), detail(query().select("*")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void when_propertiesInOrder_then_same() {
|
||||
|
||||
assertSame(detail(query().select("id,name")), detail(query().select("id,name")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void when_propertiesInDifferentOrder_then_different() {
|
||||
|
||||
assertDifferent(detail(query().select("id,name")), detail(query().select("name, id")));
|
||||
|
||||
// but same from autotune perspective
|
||||
assertThat(detail(query().select("id,name")).isAutoTuneEqual(detail(query().select("name, id")))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void when_additional_fetch_then_different() {
|
||||
|
||||
assertDifferent(detail(query().select("id,name")), detail(query().select("id,name").fetch("details")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void when_same_fetch_then_same() {
|
||||
|
||||
assertSame(detail(query().select("id,name").fetch("details")), detail(query().select("id,name").fetch("details")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void when_fetch_order_different_then_different() {
|
||||
|
||||
assertDifferent(detail(query().select("id,name").fetch("details").fetch("customer")),
|
||||
detail(query().select("id,name").fetch("customer").fetch("details")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void when_extra_queryFetchToMany_then_same() {
|
||||
|
||||
assertDifferent(detail(query().select("id,name").fetch("customer")),
|
||||
detail(query().select("id,name").fetch("customer").fetch("details", FetchConfig.ofQuery())));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void when_extra_queryToOne_fetch_then_different() {
|
||||
|
||||
// with the fetch of customer the foreign key must be added to the root query
|
||||
assertDifferent(detail(query().select("id,name")),
|
||||
detail(query().select("id,name").fetch("customer", FetchConfig.ofQuery())));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void when_additional_fetch_V2_then_different() {
|
||||
|
||||
assertDifferent(detail(query().select("id,name")), detail(query().select("id,name").fetch("customer", "id")));
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void when_fetchConfig_then_differentPlan() throws Exception {
|
||||
|
||||
DefaultOrmQuery<Order> query1 = (DefaultOrmQuery<Order>) DB.find(Order.class)
|
||||
.select("status, shipDate")
|
||||
.fetchQuery("details", "orderQty, unitPrice")
|
||||
.fetch("details.product", "sku, name");
|
||||
|
||||
|
||||
DefaultOrmQuery<Order> query2 = (DefaultOrmQuery<Order>) DB.find(Order.class)
|
||||
.select("status, shipDate")
|
||||
.fetch("details", "orderQty, unitPrice")
|
||||
.fetch("details.product", "sku, name");
|
||||
|
||||
assertDifferent(detail(query1), detail(query2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinOrder_when_fetchJoins_expect_detailJoinsPreserveOrder() {
|
||||
|
||||
Query<Order> query = DB.find(Order.class)
|
||||
.select("status, orderDate")
|
||||
.fetch("customer", "name")
|
||||
.fetch("details");
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query);
|
||||
OrmQueryDetail detail = queryRequest.query().getDetail();
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("customer", "details");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinOrder_when_fetchJoinsAndWhere_expect_fetchJoinsOnlyInFetchPaths() {
|
||||
|
||||
Query<Order> query = DB.find(Order.class)
|
||||
.select("status, orderDate")
|
||||
.fetch("details")
|
||||
.where().eq("customer.name", "rob").query();
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query);
|
||||
OrmQueryDetail detail = queryRequest.query().getDetail();
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("details");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinOrder_when_queryFetch_expect_getFetchPaths_doesNotIncludeQueryJoin() {
|
||||
|
||||
Query<Order> query = DB.find(Order.class)
|
||||
.select("status, orderDate")
|
||||
.fetch("customer", "name")
|
||||
.fetchQuery("details");
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query);
|
||||
OrmQueryDetail detail = queryRequest.query().getDetail();
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("customer");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinOrder_when_queryFetch_expect_getFetchPaths_doesNotIncludeQueryJoin_via_fetchQuery() {
|
||||
|
||||
Query<Order> query = DB.find(Order.class)
|
||||
.select("status, orderDate")
|
||||
.fetch("customer", "name")
|
||||
.fetchQuery("details");
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query);
|
||||
OrmQueryDetail detail = queryRequest.query().getDetail();
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("customer");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinOrder_when_lazyFetch_expect_getFetchPaths_doesNotIncludeQueryJoin() {
|
||||
|
||||
Query<Order> query = DB.find(Order.class)
|
||||
.select("status, orderDate")
|
||||
.fetch("customer", "name")
|
||||
.fetch("details", FetchConfig.ofLazy());
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query);
|
||||
OrmQueryDetail detail = queryRequest.query().getDetail();
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("customer");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinOrder_when_lazyFetch_expect_getFetchPaths_doesNotIncludeQueryJoin_via_fetchLazy() {
|
||||
|
||||
Query<Order> query = DB.find(Order.class)
|
||||
.select("status, orderDate")
|
||||
.fetch("customer", "name")
|
||||
.fetchLazy("details");
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query);
|
||||
OrmQueryDetail detail = queryRequest.query().getDetail();
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("customer");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinOrder_when_lazyFetchAndHasChildren_expect_getFetchPaths_doesNotIncludeJoinOrChild() {
|
||||
|
||||
Query<Order> query = DB.find(Order.class)
|
||||
.select("status, orderDate")
|
||||
.fetch("customer", "name")
|
||||
.fetchLazy("details")
|
||||
.fetch("details.product");
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query);
|
||||
OrmQueryDetail detail = queryRequest.query().getDetail();
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("customer");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinOrder_when_fetchMany_expect_getFetchPaths_containsAllInOrder() {
|
||||
|
||||
Query<Order> query = DB.find(Order.class)
|
||||
.select("status, orderDate")
|
||||
.fetch("details")
|
||||
.fetch("details.product")
|
||||
.fetch("customer", "name");
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query);
|
||||
OrmQueryDetail detail = queryRequest.query().getDetail();
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("details", "details.product", "customer");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinOrder_when_queryJoin_expect_getFetchPaths_excludesQueryJoinAndChildren() {
|
||||
|
||||
Query<Order> query = DB.find(Order.class)
|
||||
.select("status, orderDate")
|
||||
.fetchQuery("details")
|
||||
.fetch("details.product")
|
||||
.fetch("customer", "name");
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query);
|
||||
OrmQueryDetail detail = queryRequest.query().getDetail();
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("customer");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test_removeJoinToMany_when_multipleManyPaths() {
|
||||
|
||||
Query<Order> query = DB.find(Order.class)
|
||||
.fetch("details")
|
||||
.fetch("details.product")
|
||||
.fetch("customer")
|
||||
.fetch("customer.contacts"); // second many path
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query);
|
||||
OrmQueryDetail detail = queryRequest.query().getDetail();
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("details", "details.product", "customer");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test_removeAllJoinToMany_when_firstRow() {
|
||||
|
||||
Query<Order> query = DB.find(Order.class)
|
||||
.setFirstRow(1)
|
||||
.fetch("details") // many path
|
||||
.fetch("details.product")
|
||||
.fetch("customer")
|
||||
.fetch("customer.contacts"); // many path
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query);
|
||||
OrmQueryDetail detail = queryRequest.query().getDetail();
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("customer");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test_removeAllJoinToMany_when_maxRows() {
|
||||
|
||||
Query<Order> query = DB.find(Order.class)
|
||||
.setMaxRows(1)
|
||||
.fetch("details") // many path
|
||||
.fetch("details.product")
|
||||
.fetch("customer")
|
||||
.fetch("customer.contacts"); // many path
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query);
|
||||
OrmQueryDetail detail = queryRequest.query().getDetail();
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("customer");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test_filterMany_included() {
|
||||
|
||||
Query<Order> query = DB.find(Order.class)
|
||||
.fetch("details")
|
||||
.fetch("details.product")
|
||||
.fetch("customer")
|
||||
.fetch("customer.contacts")
|
||||
.filterMany("details").eq("orderQuantity", 10)
|
||||
.query();
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query);
|
||||
OrmQueryDetail detail = queryRequest.query().getDetail();
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("details", "details.product", "customer");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test_filterMany_excludedByOrdering() {
|
||||
|
||||
Query<Order> query = DB.find(Order.class)
|
||||
.fetch("customer")
|
||||
.fetch("customer.contacts")
|
||||
.fetch("details")
|
||||
.fetch("details.product")
|
||||
.filterMany("details").eq("orderQuantity", 10)
|
||||
.query();
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query);
|
||||
OrmQueryDetail detail = queryRequest.query().getDetail();
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("customer", "customer.contacts");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test_filterMany_excludedExplicitly() {
|
||||
|
||||
Query<Order> query = DB.find(Order.class)
|
||||
.fetchQuery("details")
|
||||
.fetch("details.product")
|
||||
.fetch("customer")
|
||||
.fetch("customer.contacts")
|
||||
.filterMany("details").eq("orderQuantity", 10)
|
||||
.query();
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query);
|
||||
OrmQueryDetail detail = queryRequest.query().getDetail();
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("customer", "customer.contacts");
|
||||
}
|
||||
|
||||
private void assertSame(OrmQueryDetail detail1, OrmQueryDetail detail2) {
|
||||
assertThat(hash(detail1)).isEqualTo(hash(detail2));
|
||||
}
|
||||
|
||||
private void assertDifferent(OrmQueryDetail detail1, OrmQueryDetail detail2) {
|
||||
assertThat(hash(detail1)).isNotEqualTo(hash(detail2));
|
||||
}
|
||||
|
||||
private String hash(OrmQueryDetail detail1) {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
detail1.queryPlanHash(sb);
|
||||
return sb.toString();
|
||||
}
|
||||
}
|
||||
@@ -1,14 +0,0 @@
|
||||
package io.ebeaninternal.server.core;
|
||||
|
||||
import io.ebean.Database;
|
||||
import io.ebean.Query;
|
||||
import io.ebean.Transaction;
|
||||
import io.ebeaninternal.api.SpiQuery;
|
||||
|
||||
public class HelpCreateQueryRequest {
|
||||
|
||||
public static <T> OrmQueryRequest<T> create(Database server, SpiQuery.Type type, Query<T> query, Transaction t) {
|
||||
DefaultServer defaultServer = (DefaultServer) server;
|
||||
return (OrmQueryRequest<T>)defaultServer.createQueryRequest(type, query, t);
|
||||
}
|
||||
}
|
||||
@@ -1,18 +0,0 @@
|
||||
package io.ebeaninternal.server.core;
|
||||
|
||||
import io.ebean.DB;
|
||||
import io.ebean.Query;
|
||||
import io.ebeaninternal.api.SpiQuery;
|
||||
|
||||
public class OrmQueryRequestTestHelper {
|
||||
|
||||
static DefaultServer defaultServer = (DefaultServer) DB.getDefault();
|
||||
|
||||
/**
|
||||
* Create and return a OrmQueryRequest for the given query.
|
||||
*/
|
||||
public static <T> OrmQueryRequest<T> queryRequest(Query<T> query) {
|
||||
return (OrmQueryRequest<T>) defaultServer.createQueryRequest(SpiQuery.Type.LIST, query, null);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,169 +0,0 @@
|
||||
package io.ebeaninternal.server.core;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.DB;
|
||||
import io.ebean.Database;
|
||||
import io.ebean.ValuePair;
|
||||
import io.ebeaninternal.api.SpiEbeanServer;
|
||||
import io.ebeaninternal.server.deploy.BeanDescriptor;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Customer;
|
||||
import org.tests.model.basic.Order;
|
||||
import org.tests.model.basic.Order.Status;
|
||||
|
||||
import java.sql.Date;
|
||||
import java.sql.Timestamp;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class TestDiffHelpSimple extends BaseTestCase {
|
||||
|
||||
long firstTime = System.currentTimeMillis() - 10000;
|
||||
long secondTime = System.currentTimeMillis();
|
||||
|
||||
Database server;
|
||||
BeanDescriptor<Order> orderDesc;
|
||||
|
||||
TestDiffHelpSimple() {
|
||||
server = DB.getDefault();
|
||||
SpiEbeanServer spiServer = (SpiEbeanServer) server;
|
||||
orderDesc = spiServer.descriptor(Order.class);
|
||||
}
|
||||
|
||||
private Order createBaseOrder(Database server) {
|
||||
Order order1 = new Order();
|
||||
order1.setId(12);
|
||||
order1.setCretime(new Timestamp(firstTime));
|
||||
order1.setCustomer(server.reference(Customer.class, 1234));
|
||||
order1.setStatus(Status.NEW);
|
||||
order1.setShipDate(new Date(firstTime));
|
||||
order1.setOrderDate(new Date(firstTime));
|
||||
return order1;
|
||||
}
|
||||
|
||||
@Test
|
||||
void diffWhenNull_expect_empty() {
|
||||
assertThat(DB.diff(null, null)).isEmpty();
|
||||
}
|
||||
|
||||
@Test
|
||||
void testBasicChanges() {
|
||||
Order order1 = createBaseOrder(server);
|
||||
|
||||
Order order2 = new Order();
|
||||
order2.setId(14);
|
||||
order2.setCretime(new Timestamp(secondTime));
|
||||
order2.setCustomer(server.reference(Customer.class, 2133));
|
||||
order2.setStatus(Status.COMPLETE);
|
||||
order2.setShipDate(new Date(secondTime));
|
||||
order2.setOrderDate(new Date(secondTime));
|
||||
|
||||
Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
|
||||
|
||||
assertEquals(5, diff.size());
|
||||
|
||||
Set<String> keySet = diff.keySet();
|
||||
assertTrue(keySet.contains("cretime"));
|
||||
assertTrue(keySet.contains("status"));
|
||||
assertTrue(keySet.contains("shipDate"));
|
||||
assertTrue(keySet.contains("orderDate"));
|
||||
assertTrue(keySet.contains("customer.id"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void testBasicChanges_given_flatMode() {
|
||||
Order order1 = createBaseOrder(server);
|
||||
|
||||
Order order2 = new Order();
|
||||
order2.setId(14);
|
||||
order2.setCretime(new Timestamp(secondTime));
|
||||
order2.setCustomer(server.reference(Customer.class, 2133));
|
||||
order2.setStatus(Status.COMPLETE);
|
||||
order2.setShipDate(new Date(secondTime));
|
||||
order2.setOrderDate(new Date(secondTime));
|
||||
|
||||
Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
|
||||
|
||||
assertEquals(5, diff.size());
|
||||
|
||||
Set<String> keySet = diff.keySet();
|
||||
assertTrue(keySet.contains("cretime"));
|
||||
assertTrue(keySet.contains("status"));
|
||||
assertTrue(keySet.contains("shipDate"));
|
||||
assertTrue(keySet.contains("orderDate"));
|
||||
assertTrue(keySet.contains("customer.id"));
|
||||
assertEquals(2133, diff.get("customer.id").getOldValue());
|
||||
assertEquals(1234, diff.get("customer.id").getNewValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testIdIgnored() {
|
||||
Order order1 = createBaseOrder(server);
|
||||
Order order2 = createBaseOrder(server);
|
||||
order2.setId(14);
|
||||
|
||||
Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
|
||||
|
||||
assertEquals(0, diff.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSecondValueNull() {
|
||||
Order order1 = createBaseOrder(server);
|
||||
|
||||
Order order2 = createBaseOrder(server);
|
||||
order2.setCustomer(server.reference(Customer.class, 2133));
|
||||
order2.setStatus(Status.COMPLETE);
|
||||
order2.setShipDate(null);
|
||||
|
||||
Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
|
||||
|
||||
assertEquals(3, diff.size());
|
||||
|
||||
Set<String> keySet = diff.keySet();
|
||||
assertTrue(keySet.contains("status"));
|
||||
assertTrue(keySet.contains("customer.id"));
|
||||
assertTrue(keySet.contains("shipDate"));
|
||||
|
||||
ValuePair shipDatePair = diff.get("shipDate");
|
||||
assertEquals(order1.getShipDate(), shipDatePair.getNewValue());
|
||||
assertEquals(order2.getShipDate(), shipDatePair.getOldValue());
|
||||
assertNull(shipDatePair.getOldValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testFirstValueNull() {
|
||||
Order order1 = createBaseOrder(server);
|
||||
order1.setShipDate(null);
|
||||
|
||||
Order order2 = createBaseOrder(server);
|
||||
order2.setShipDate(new Date(secondTime));
|
||||
|
||||
Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
|
||||
|
||||
assertEquals(1, diff.size());
|
||||
Set<String> keySet = diff.keySet();
|
||||
assertTrue(keySet.contains("shipDate"));
|
||||
|
||||
ValuePair shipDatePair = diff.get("shipDate");
|
||||
assertEquals(order1.getShipDate(), shipDatePair.getNewValue());
|
||||
assertEquals(order2.getShipDate(), shipDatePair.getOldValue());
|
||||
assertNull(shipDatePair.getNewValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testBothNull() {
|
||||
Order order1 = createBaseOrder(server);
|
||||
order1.setShipDate(null);
|
||||
|
||||
Order order2 = createBaseOrder(server);
|
||||
order2.setShipDate(null);
|
||||
|
||||
Map<String, ValuePair> diff = DiffHelp.diff(order1, order2, orderDesc);
|
||||
|
||||
assertEquals(0, diff.size());
|
||||
}
|
||||
}
|
||||
@@ -1,156 +0,0 @@
|
||||
package io.ebeaninternal.server.core;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.DB;
|
||||
import io.ebean.Database;
|
||||
import io.ebean.ValuePair;
|
||||
import io.ebeaninternal.api.SpiEbeanServer;
|
||||
import io.ebeaninternal.server.deploy.BeanDescriptor;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.embedded.EMain;
|
||||
import org.tests.model.embedded.Eembeddable;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
public class TestDiffHelpWithEmbedded extends BaseTestCase {
|
||||
|
||||
Database server;
|
||||
|
||||
BeanDescriptor<EMain> emainDesc;
|
||||
|
||||
public TestDiffHelpWithEmbedded() {
|
||||
server = DB.getDefault();
|
||||
SpiEbeanServer spiServer = (SpiEbeanServer) server;
|
||||
emainDesc = spiServer.descriptor(EMain.class);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testChangeExistingEmbedded() {
|
||||
|
||||
EMain emain1 = createEMain();
|
||||
EMain emain2 = createEMain();
|
||||
|
||||
emain2.getEmbeddable().setDescription("baz");
|
||||
|
||||
Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
|
||||
assertEquals(1, diff.size());
|
||||
ValuePair valuePair = diff.get("embeddable.description");
|
||||
|
||||
assertNotNull(valuePair);
|
||||
assertEquals("bar", valuePair.getNewValue());
|
||||
assertEquals("baz", valuePair.getOldValue());
|
||||
}
|
||||
|
||||
/**
|
||||
* Same result as testChangeExistingEmbedded.
|
||||
*/
|
||||
@Test
|
||||
public void testSetViaNewEmbedded() {
|
||||
|
||||
EMain emain1 = createEMain();
|
||||
EMain emain2 = createEMain();
|
||||
|
||||
Eembeddable embeddable = new Eembeddable();
|
||||
embeddable.setDescription("baz");
|
||||
emain2.setEmbeddable(embeddable);
|
||||
|
||||
|
||||
Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
|
||||
assertEquals(1, diff.size());
|
||||
ValuePair valuePair = diff.get("embeddable.description");
|
||||
|
||||
assertNotNull(valuePair);
|
||||
assertEquals("bar", valuePair.getNewValue());
|
||||
assertEquals("baz", valuePair.getOldValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDiffEmbedded_flatMode() {
|
||||
|
||||
EMain emain1 = createEMain();
|
||||
EMain emain2 = createEMain();
|
||||
emain2.getEmbeddable().setDescription("baz");
|
||||
|
||||
Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
|
||||
assertEquals(1, diff.size());
|
||||
ValuePair valuePair = diff.get("embeddable.description");
|
||||
|
||||
assertNotNull(valuePair);
|
||||
assertEquals("bar", valuePair.getNewValue());
|
||||
assertEquals("baz", valuePair.getOldValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFirstEmbeddedIsNull() {
|
||||
|
||||
EMain emain1 = createEMain();
|
||||
emain1.setEmbeddable(null);
|
||||
EMain emain2 = createEMain();
|
||||
|
||||
Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
|
||||
assertEquals(1, diff.size());
|
||||
ValuePair valuePair = diff.get("embeddable.description");
|
||||
|
||||
assertNotNull(valuePair);
|
||||
assertNull(valuePair.getNewValue());
|
||||
assertEquals("bar", valuePair.getOldValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSecondEmbeddedIsNull() {
|
||||
|
||||
EMain emain1 = createEMain();
|
||||
EMain emain2 = createEMain();
|
||||
emain2.setEmbeddable(null);
|
||||
|
||||
Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
|
||||
assertEquals(1, diff.size());
|
||||
ValuePair valuePair = diff.get("embeddable.description");
|
||||
|
||||
assertNotNull(valuePair);
|
||||
assertNull(valuePair.getOldValue());
|
||||
assertEquals("bar", valuePair.getNewValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSecondEmbeddedIsNull_given_flatMode() {
|
||||
|
||||
EMain emain1 = createEMain();
|
||||
EMain emain2 = createEMain();
|
||||
emain2.setEmbeddable(null);
|
||||
|
||||
Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
|
||||
assertEquals(1, diff.size());
|
||||
ValuePair valuePair = diff.get("embeddable.description");
|
||||
|
||||
assertNotNull(valuePair);
|
||||
assertNull(valuePair.getOldValue());
|
||||
assertEquals("bar", valuePair.getNewValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBothEmbeddedIsNull() {
|
||||
|
||||
EMain emain1 = createEMain();
|
||||
emain1.setEmbeddable(null);
|
||||
EMain emain2 = createEMain();
|
||||
emain2.setEmbeddable(null);
|
||||
|
||||
Map<String, ValuePair> diff = DiffHelp.diff(emain1, emain2, emainDesc);
|
||||
assertEquals(0, diff.size());
|
||||
}
|
||||
|
||||
private EMain createEMain() {
|
||||
EMain emain = new EMain();
|
||||
emain.setName("foo");
|
||||
emain.setVersion(13L);
|
||||
|
||||
Eembeddable embeddable = new Eembeddable();
|
||||
embeddable.setDescription("bar");
|
||||
emain.setEmbeddable(embeddable);
|
||||
return emain;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,175 +0,0 @@
|
||||
package io.ebeaninternal.server.deploy;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.DB;
|
||||
import io.ebean.bean.EntityBean;
|
||||
import io.ebean.plugin.Property;
|
||||
import io.ebeaninternal.server.core.CacheOptions;
|
||||
import io.ebeaninternal.server.deploy.meta.DeployBeanDescriptor;
|
||||
import io.ebeaninternal.server.deploy.meta.DeployIdentityMode;
|
||||
import io.ebeanservice.docstore.api.DocStoreBeanAdapter;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.*;
|
||||
import org.tests.model.bridge.BSite;
|
||||
import org.tests.model.bridge.BUser;
|
||||
|
||||
import java.util.Collection;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
import static org.mockito.ArgumentMatchers.any;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
public class BeanDescriptorTest extends BaseTestCase {
|
||||
|
||||
private BeanDescriptor<Customer> customerDesc = spiEbeanServer().descriptor(Customer.class);
|
||||
|
||||
@Test
|
||||
public void createReference() {
|
||||
|
||||
Customer bean = customerDesc.createReference(null, false, 42, null);
|
||||
assertThat(bean.getId()).isEqualTo(42);
|
||||
assertThat(server().beanState(bean).isReadOnly()).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createReference_whenReadOnly() {
|
||||
|
||||
Customer bean = customerDesc.createReference(Boolean.TRUE, false, 42, null);
|
||||
assertThat(server().beanState(bean).isReadOnly()).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createReference_whenNotReadOnly() {
|
||||
|
||||
Customer bean = customerDesc.createReference(Boolean.FALSE, false, 42, null);
|
||||
assertThat(server().beanState(bean).isReadOnly()).isFalse();
|
||||
|
||||
bean = customerDesc.createReference(42, null);
|
||||
assertThat(server().beanState(bean).isReadOnly()).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createReference_when_disabledLazyLoad() {
|
||||
|
||||
Customer bean = customerDesc.createReference(Boolean.FALSE, true, 42, null);
|
||||
assertThat(server().beanState(bean).isDisableLazyLoad()).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createReference_with_inheritance() {
|
||||
Cat cat = new Cat();
|
||||
cat.setName("Puss");
|
||||
DB.save(cat);
|
||||
|
||||
Dog dog = new Dog();
|
||||
dog.setRegistrationNumber("DOGGIE");
|
||||
DB.save(dog);
|
||||
|
||||
AnimalShelter shelter = new AnimalShelter();
|
||||
shelter.setName("My Animal Shelter");
|
||||
shelter.getAnimals().add(cat);
|
||||
shelter.getAnimals().add(dog);
|
||||
|
||||
DB.save(shelter);
|
||||
|
||||
BeanDescriptor<Animal> animalDesc = spiEbeanServer().descriptor(Animal.class);
|
||||
|
||||
Animal bean = animalDesc.createReference(Boolean.FALSE, false, dog.getId(), null);
|
||||
assertThat(bean.getId()).isEqualTo(dog.getId());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void allProperties() {
|
||||
|
||||
BeanDescriptor<Order> desc = getBeanDescriptor(Order.class);
|
||||
Collection<? extends Property> props = desc.allProperties();
|
||||
|
||||
assertThat(props).extracting("name").contains("id", "status", "orderDate", "shipDate");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void matchBaseTable() {
|
||||
BeanDescriptor<Customer> desc = getBeanDescriptor(Customer.class);
|
||||
assertTrue(desc.matchBaseTable("o_customer"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void matchBaseTable_whenTableHasSchema_expect_matchRegardlessOfSchema() {
|
||||
|
||||
DeployBeanDescriptor<Customer> deploy = mockDeployCustomer();
|
||||
|
||||
when(deploy.getBaseTable()).thenReturn("foo.o_customer");
|
||||
BeanDescriptor<?> desc1 = new BeanDescriptor<>(mockOwner(), deploy);
|
||||
assertTrue(desc1.matchBaseTable("o_customer"));
|
||||
|
||||
when(deploy.getBaseTable()).thenReturn("bar.o_customer");
|
||||
BeanDescriptor<?> desc2 = new BeanDescriptor<>(mockOwner(), deploy);
|
||||
assertTrue(desc2.matchBaseTable("o_customer"));
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private DeployBeanDescriptor<Customer> mockDeployCustomer() {
|
||||
DeployBeanDescriptor<Customer> deploy = mock(DeployBeanDescriptor.class);
|
||||
when(deploy.getBeanType()).thenReturn(Customer.class);
|
||||
when(deploy.getIdentityMode()).thenReturn(DeployIdentityMode.auto());
|
||||
when(deploy.buildIdentityMode()).thenReturn(IdentityMode.NONE);
|
||||
when(deploy.getCacheOptions()).thenReturn(CacheOptions.NO_CACHING);
|
||||
return deploy;
|
||||
}
|
||||
|
||||
private BeanDescriptorMap mockOwner() {
|
||||
BeanDescriptorMap owner = mock(BeanDescriptorMap.class);
|
||||
when(owner.createDocStoreBeanAdapter(any(), any())).thenReturn(mock(DocStoreBeanAdapter.class));
|
||||
return owner;
|
||||
}
|
||||
|
||||
@Test
|
||||
public void merge_when_empty() {
|
||||
|
||||
Customer from = new Customer();
|
||||
from.setId(42);
|
||||
from.setName("rob");
|
||||
|
||||
Customer to = new Customer();
|
||||
customerDesc.merge((EntityBean) from, (EntityBean) to);
|
||||
|
||||
assertThat(to.getId()).isEqualTo(42);
|
||||
assertThat(to.getName()).isEqualTo("rob");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isIdTypeExternal_when_externalId() {
|
||||
|
||||
BeanDescriptor<Country> countryDesc = spiEbeanServer().descriptor(Country.class);
|
||||
assertThat(countryDesc.isIdGeneratedValue()).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isIdTypeExternal_when_platformGenerator_noGeneratedValueAnnotation() {
|
||||
|
||||
assertThat(customerDesc.isIdGeneratedValue()).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isIdTypeExternal_when_explicitGeneratedValue() {
|
||||
|
||||
BeanDescriptor<Contact> desc = spiEbeanServer().descriptor(Contact.class);
|
||||
assertThat(desc.isIdGeneratedValue()).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isIdTypeExternal_when_uuidGenerator_and_generatedValue() {
|
||||
|
||||
BeanDescriptor<BSite> desc = spiEbeanServer().descriptor(BSite.class);
|
||||
assertThat(desc.isIdGeneratedValue()).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isIdTypeExternal_when_uuidGenerator_and_noGeneratedValue() {
|
||||
|
||||
BeanDescriptor<BUser> desc = spiEbeanServer().descriptor(BUser.class);
|
||||
assertThat(desc.isIdGeneratedValue()).isFalse();
|
||||
}
|
||||
}
|
||||
-85
@@ -1,85 +0,0 @@
|
||||
package io.ebeaninternal.server.deploy;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebeanservice.docstore.api.mapping.DocPropertyAdapter;
|
||||
import io.ebeanservice.docstore.api.mapping.DocPropertyMapping;
|
||||
import io.ebeanservice.docstore.api.mapping.DocumentMapping;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Order;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class BeanDescriptor_documentMappingTest extends BaseTestCase {
|
||||
|
||||
|
||||
@Test
|
||||
public void docMapping() {
|
||||
|
||||
BeanDescriptor<Order> desc = getBeanDescriptor(Order.class);
|
||||
|
||||
DocumentMapping documentMapping = desc.docMapping();
|
||||
|
||||
DocPropertyMapping properties = documentMapping.getProperties();
|
||||
|
||||
assertThat(properties).isNotNull();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void docMapping_visitor() {
|
||||
|
||||
BeanDescriptor<Order> desc = getBeanDescriptor(Order.class);
|
||||
|
||||
DocumentMapping documentMapping = desc.docMapping();
|
||||
|
||||
DocPropertyMapping properties = documentMapping.getProperties();
|
||||
|
||||
assertThat(properties).isNotNull();
|
||||
|
||||
TDVisitor tdVisitor = new TDVisitor();
|
||||
documentMapping.visit(tdVisitor);
|
||||
|
||||
assertThat(tdVisitor.sb.toString()).isEqualTo("{status,orderDate,shipDate, object{customer:id,name,}customerName, nested{details: [id,orderQty,shipQty,unitPrice,cretime,updtime,]}cretime,updtime,}");
|
||||
}
|
||||
|
||||
class TDVisitor extends DocPropertyAdapter {
|
||||
|
||||
StringBuilder sb = new StringBuilder();
|
||||
|
||||
@Override
|
||||
public void visitProperty(DocPropertyMapping property) {
|
||||
sb.append(property.getName() + ",");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitBegin() {
|
||||
|
||||
sb.append("{");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitEnd() {
|
||||
sb.append("}");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitBeginObject(DocPropertyMapping property) {
|
||||
sb.append(" object{" + property.getName() + ":");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitEndObject(DocPropertyMapping property) {
|
||||
sb.append("}");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitBeginList(DocPropertyMapping property) {
|
||||
sb.append(" nested{" + property.getName() + ": [");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void visitEndList(DocPropertyMapping property) {
|
||||
sb.append("]}");
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
-114
@@ -1,114 +0,0 @@
|
||||
package io.ebeaninternal.server.deploy;
|
||||
|
||||
import io.ebean.DatabaseFactory;
|
||||
import io.ebean.config.DatabaseConfig;
|
||||
import io.ebean.event.AbstractBeanPersistListener;
|
||||
import io.ebean.event.BeanPersistAdapter;
|
||||
import io.ebean.event.BeanPersistListener;
|
||||
import io.ebeaninternal.api.SpiEbeanServer;
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.EBasic;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
public class BeanDescriptor_registerTest {
|
||||
|
||||
@Test
|
||||
public void testRegisterDeregister() {
|
||||
|
||||
DatabaseConfig config = new DatabaseConfig();
|
||||
|
||||
config.setName("h2other");
|
||||
config.loadFromProperties();
|
||||
config.setDdlExtra(false);
|
||||
config.setRegister(false);
|
||||
config.setDefaultServer(false);
|
||||
config.getClasses().add(EBasic.class);
|
||||
|
||||
SpiEbeanServer ebeanServer = (SpiEbeanServer)DatabaseFactory.create(config);
|
||||
try {
|
||||
BeanDescriptor<EBasic> desc = ebeanServer.descriptor(EBasic.class);
|
||||
persistListenerRegistrationTests(desc);
|
||||
persistControllerRegistrationTests(desc);
|
||||
} finally {
|
||||
ebeanServer.shutdown();
|
||||
}
|
||||
}
|
||||
|
||||
private void persistControllerRegistrationTests(BeanDescriptor<EBasic> desc) {
|
||||
|
||||
Controller1 controller1 = new Controller1();
|
||||
|
||||
assertNull(desc.persistController());
|
||||
desc.register(controller1);
|
||||
assertSame(controller1, desc.persistController());
|
||||
|
||||
Controller2 controller2 = new Controller2();
|
||||
desc.register(controller2);
|
||||
|
||||
Assertions.assertEquals(2, ((ChainedBeanPersistController) desc.persistController()).size());
|
||||
|
||||
desc.deregister(controller1);
|
||||
assertEquals(1, ((ChainedBeanPersistController) desc.persistController()).size());
|
||||
|
||||
desc.deregister(controller2);
|
||||
assertEquals(0, ((ChainedBeanPersistController) desc.persistController()).size());
|
||||
}
|
||||
|
||||
private void persistListenerRegistrationTests(BeanDescriptor<EBasic> desc) {
|
||||
|
||||
Listener1 listener1 = new Listener1();
|
||||
|
||||
assertNull(desc.persistListener());
|
||||
desc.register(listener1);
|
||||
assertSame(listener1, desc.persistListener());
|
||||
|
||||
Listener2 listener2 = new Listener2();
|
||||
desc.register(listener2);
|
||||
|
||||
BeanPersistListener persistListener = desc.persistListener();
|
||||
assertTrue(persistListener instanceof ChainedBeanPersistListener);
|
||||
assertEquals(2, ((ChainedBeanPersistListener) persistListener).size());
|
||||
|
||||
desc.deregister(listener1);
|
||||
assertEquals(1, ((ChainedBeanPersistListener) desc.persistListener()).size());
|
||||
|
||||
desc.deregister(listener2);
|
||||
assertEquals(0, ((ChainedBeanPersistListener) desc.persistListener()).size());
|
||||
}
|
||||
|
||||
public static class Listener1 extends AbstractBeanPersistListener {
|
||||
|
||||
@Override
|
||||
public boolean isRegisterFor(Class<?> cls) {
|
||||
return EBasic.class.isAssignableFrom(cls);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public static class Listener2 extends AbstractBeanPersistListener {
|
||||
|
||||
@Override
|
||||
public boolean isRegisterFor(Class<?> cls) {
|
||||
return EBasic.class.isAssignableFrom(cls);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public static class Controller1 extends BeanPersistAdapter {
|
||||
|
||||
@Override
|
||||
public boolean isRegisterFor(Class<?> cls) {
|
||||
return EBasic.class.isAssignableFrom(cls);
|
||||
}
|
||||
}
|
||||
|
||||
public static class Controller2 extends BeanPersistAdapter {
|
||||
|
||||
@Override
|
||||
public boolean isRegisterFor(Class<?> cls) {
|
||||
return EBasic.class.isAssignableFrom(cls);
|
||||
}
|
||||
}
|
||||
}
|
||||
-35
@@ -1,35 +0,0 @@
|
||||
package io.ebeaninternal.server.deploy;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.DB;
|
||||
import io.ebeaninternal.api.SpiEbeanServer;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Customer;
|
||||
import org.tests.model.basic.EBasic;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
|
||||
|
||||
public class BeanDescriptor_whenCreatedPropertyTest extends BaseTestCase {
|
||||
|
||||
|
||||
@Test
|
||||
public void test() {
|
||||
|
||||
SpiEbeanServer server = (SpiEbeanServer) DB.getDefault();
|
||||
|
||||
BeanDescriptor<Customer> desc = server.descriptor(Customer.class);
|
||||
|
||||
BeanProperty whenCreatedProperty = desc.whenCreatedProperty();
|
||||
assertEquals("cretime", whenCreatedProperty.dbColumn());
|
||||
|
||||
BeanProperty whenModifiedProperty = desc.whenModifiedProperty();
|
||||
assertEquals("updtime", whenModifiedProperty.dbColumn());
|
||||
|
||||
|
||||
BeanDescriptor<EBasic> eBasicDesc = server.descriptor(EBasic.class);
|
||||
assertNull(eBasicDesc.whenCreatedProperty());
|
||||
assertNull(eBasicDesc.whenModifiedProperty());
|
||||
}
|
||||
}
|
||||
-83
@@ -1,83 +0,0 @@
|
||||
package io.ebeaninternal.server.deploy;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.DB;
|
||||
import io.ebean.bean.BeanCollection;
|
||||
import io.ebean.bean.EntityBean;
|
||||
import io.ebean.common.BeanList;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Contact;
|
||||
import org.tests.model.basic.Customer;
|
||||
import org.tests.model.basic.ResetBasicData;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
|
||||
public class BeanPropertyAssocManyTest extends BaseTestCase {
|
||||
|
||||
private BeanDescriptor<Customer> customerDesc = spiEbeanServer().descriptor(Customer.class);
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private BeanPropertyAssocMany<Customer> contacts() {
|
||||
return (BeanPropertyAssocMany<Customer>) customerDesc.beanProperty("contacts");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createReferenceIfNull_when_notBeanCollection_expect_null() {
|
||||
|
||||
Customer customer = new Customer();
|
||||
customer.setContacts(new ArrayList<>());
|
||||
|
||||
BeanCollection<?> ref = contacts().createReferenceIfNull((EntityBean) customer);
|
||||
assertNull(ref);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createReferenceIfNull_when_null_expect_ref() {
|
||||
|
||||
Customer customer = new Customer();
|
||||
customer.setContacts(null);
|
||||
|
||||
BeanCollection<?> ref = contacts().createReferenceIfNull((EntityBean) customer);
|
||||
assertNotNull(ref);
|
||||
assertTrue(ref.isReference());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void lazyLoadMany_addsToParentCollection() {
|
||||
|
||||
Customer customer = new Customer();
|
||||
customer.setContacts(new BeanList<>());
|
||||
|
||||
Contact contact = new Contact();
|
||||
contact.setCustomer(customer);
|
||||
|
||||
contacts().lazyLoadMany((EntityBean) contact);
|
||||
|
||||
assertThat(customer.getContacts()).hasSize(1);
|
||||
assertThat(customer.getContacts().get(0)).isSameAs(contact);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void findIdsByParentId() {
|
||||
|
||||
ResetBasicData.reset();
|
||||
|
||||
List<Long> ids = DB.find(Customer.class).orderBy("id").setMaxRows(2).findIds();
|
||||
|
||||
List<Object> customerIds = new ArrayList<>();
|
||||
customerIds.add(ids.get(0));
|
||||
customerIds.add(ids.get(1));
|
||||
|
||||
List<Object> contactIdsForOne = contacts().findIdsByParentId(ids.get(0), null, null, null, true);
|
||||
|
||||
List<Object> contactIdsForMultiple = contacts().findIdsByParentId(null, customerIds, null, null, true);
|
||||
|
||||
assertThat(contactIdsForOne).isNotEmpty();
|
||||
assertThat(contactIdsForMultiple).isNotEmpty();
|
||||
}
|
||||
}
|
||||
@@ -1,98 +0,0 @@
|
||||
package io.ebeaninternal.server.deploy;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.xtest.ForPlatform;
|
||||
import io.ebean.annotation.Platform;
|
||||
import org.assertj.core.api.Assertions;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Address;
|
||||
import org.tests.model.basic.BWithQIdent;
|
||||
import org.tests.model.basic.Customer;
|
||||
|
||||
|
||||
public class DeployPropertyParserTest extends BaseTestCase {
|
||||
|
||||
private final BeanDescriptor<Customer> descriptor = getBeanDescriptor(Customer.class);
|
||||
|
||||
private final BeanDescriptor<Address> addressBeanDescriptor = getBeanDescriptor(Address.class);
|
||||
|
||||
private final BeanDescriptor<BWithQIdent> bWithQIdentDescriptor = getBeanDescriptor(BWithQIdent.class);
|
||||
|
||||
@Test
|
||||
public void from_prefix_expect_unchanged() {
|
||||
Assertions.assertThat(parser().parse("(select x from status join status)")).isEqualTo("(select x from status join status)");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void depth0_path() {
|
||||
Assertions.assertThat(parser().parse("pre status post")).isEqualTo("pre ${}status post");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void depth1_path() {
|
||||
Assertions.assertThat(parser().parse("billingAddress.city")).isEqualTo("${billingAddress}city");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void depth2_path() {
|
||||
Assertions.assertThat(parser().parse("max(billingAddress.country.name)")).isEqualTo("max(${billingAddress.country}name)");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void simpleMax() {
|
||||
Assertions.assertThat(parser().parse("max(name)")).isEqualTo("max(${}name)");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void combined() {
|
||||
Assertions.assertThat(parser().parse("sum(status * name)")).isEqualTo("sum(${}status * ${}name)");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void combined_withAtColumn() {
|
||||
Assertions.assertThat(addressParser().parse("concat(line1, line2, '-EA')")).isEqualTo("concat(${}line_1, ${}line_2, '-EA')");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void withExplicitQuote_all_platforms() {
|
||||
Assertions.assertThat(withQuoteParser().parse("t0.`CODE` like ?")).isEqualTo("t0.`CODE` like ?");
|
||||
Assertions.assertThat(withQuoteParser().parse("t0.[CODE] like ?")).isEqualTo("t0.[CODE] like ?");
|
||||
Assertions.assertThat(withQuoteParser().parse("t0.\"CODE\" like ?")).isEqualTo("t0.\"CODE\" like ?");
|
||||
}
|
||||
|
||||
@Test
|
||||
@ForPlatform({Platform.H2, Platform.POSTGRES})
|
||||
public void withQuote_when_match_h2() {
|
||||
Assertions.assertThat(withQuoteParser().parse("name like ?")).isEqualTo("${}\"Name\" like ?");
|
||||
}
|
||||
|
||||
@Test
|
||||
@ForPlatform(Platform.SQLSERVER)
|
||||
public void withQuote_when_match_sqlserver() {
|
||||
Assertions.assertThat(withQuoteParser().parse("name like ?")).isEqualTo("${}[Name] like ?");
|
||||
}
|
||||
|
||||
@Test
|
||||
@ForPlatform(Platform.MYSQL)
|
||||
public void withQuote_when_match_mysql() {
|
||||
Assertions.assertThat(withQuoteParser().parse("name like ?")).isEqualTo("${}`Name` like ?");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void unknown_path() {
|
||||
Assertions.assertThat(parser().parse(" foo ")).isEqualTo(" foo ");
|
||||
}
|
||||
|
||||
private DeployPropertyParser parser() {
|
||||
return descriptor.parser();
|
||||
}
|
||||
|
||||
private DeployPropertyParser addressParser() {
|
||||
return addressBeanDescriptor.parser();
|
||||
}
|
||||
|
||||
private DeployPropertyParser withQuoteParser() {
|
||||
return bWithQIdentDescriptor.parser();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,80 +0,0 @@
|
||||
package io.ebeaninternal.server.deploy;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Customer;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class FormulaPropertyPathTest extends BaseTestCase {
|
||||
|
||||
private BeanDescriptor<Customer> customerDesc = getBeanDescriptor(Customer.class);
|
||||
|
||||
@Test
|
||||
public void isFormula() {
|
||||
|
||||
assertFormula("max(version)", "max", "version");
|
||||
assertFormula("min(name)", "min", "name");
|
||||
assertFormula("avg(id)", "avg", "id");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isFormula_count() {
|
||||
assertFormula("count(status)", "count", "status");
|
||||
assertFormula("count(distinct name)", "count", "name");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void concat() {
|
||||
|
||||
assertFormula("concat(name,'-end')", "concat", "name,'-end'");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void castFormula() {
|
||||
|
||||
assertFormula("concat(name,'-end')::String", "concat", "name,'-end'", "String", null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void cast_javaInstant() {
|
||||
|
||||
assertFormula("max(updtime)::Instant", "max", "updtime", "Instant", null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void alias() {
|
||||
assertFormula("concat(name,'-end') name", "concat", "name,'-end'", null, "name");
|
||||
assertFormula("concat(name,'-end') as name", "concat", "name,'-end'", null, "name");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void castAndAlias() {
|
||||
assertFormula("concat(name,'-end')::String name", "concat", "name,'-end'", "String", "name");
|
||||
assertFormula("concat(name,'-end')::String as name", "concat", "name,'-end'", "String", "name");
|
||||
}
|
||||
|
||||
private void assertFormula(String input, String funcName, String expression) {
|
||||
assertFormula(input, funcName, expression, null, null);
|
||||
}
|
||||
|
||||
private void assertFormula(String input, String funcName, String expression, String cast, String alias) {
|
||||
|
||||
FormulaPropertyPath propertyPath = new FormulaPropertyPath(customerDesc, input, null);
|
||||
|
||||
assertThat(propertyPath.internalExpression()).isEqualTo(expression);
|
||||
assertThat(propertyPath.outerFunction()).isEqualTo(funcName);
|
||||
if (cast != null) {
|
||||
assertThat(propertyPath.cast()).isEqualTo(cast);
|
||||
} else {
|
||||
assertThat(propertyPath.cast()).isNull();
|
||||
}
|
||||
if (alias != null) {
|
||||
assertThat(propertyPath.alias()).isEqualTo(alias);
|
||||
} else {
|
||||
assertThat(propertyPath.alias()).isNull();
|
||||
}
|
||||
|
||||
assertThat(propertyPath.build()).isNotNull();
|
||||
}
|
||||
}
|
||||
-121
@@ -1,121 +0,0 @@
|
||||
package io.ebeaninternal.server.deploy;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.DB;
|
||||
import io.ebean.Database;
|
||||
import io.ebean.bean.EntityBean;
|
||||
import io.ebean.bean.EntityBeanIntercept;
|
||||
import io.ebeaninternal.api.SpiEbeanServer;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Customer;
|
||||
import org.tests.model.basic.Order;
|
||||
import org.tests.model.composite.RCustomer;
|
||||
import org.tests.model.composite.RCustomerKey;
|
||||
import org.tests.model.embedded.UserInterestLive;
|
||||
import org.tests.model.embedded.UserInterestLiveKey;
|
||||
|
||||
import java.sql.Timestamp;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
public class TestBeanDescriptorHasIdProperty extends BaseTestCase {
|
||||
|
||||
SpiEbeanServer spiServer;
|
||||
|
||||
public TestBeanDescriptorHasIdProperty() {
|
||||
Database server = DB.getDefault();
|
||||
spiServer = (SpiEbeanServer) server;
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testHasId() {
|
||||
|
||||
BeanDescriptor<Order> beanDescriptor = spiServer.descriptor(Order.class);
|
||||
assertNotNull(beanDescriptor.idProperty());
|
||||
assertEquals("id", beanDescriptor.idProperty().name());
|
||||
|
||||
assertNotNull(beanDescriptor.versionProperty());
|
||||
assertEquals("updtime", beanDescriptor.versionProperty().name());
|
||||
|
||||
Order order = new Order();
|
||||
|
||||
assertFalse(beanDescriptor.hasIdValue(entityBean(order)));
|
||||
assertFalse(beanDescriptor.hasVersionProperty(getIntercept(order)));
|
||||
|
||||
order.setId(23);
|
||||
order.setUpdtime(new Timestamp(System.currentTimeMillis()));
|
||||
|
||||
assertTrue(beanDescriptor.hasIdValue(entityBean(order)));
|
||||
assertTrue(beanDescriptor.hasVersionProperty(getIntercept(order)));
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsReference() {
|
||||
|
||||
BeanDescriptor<Customer> beanDescriptor = spiServer.descriptor(Customer.class);
|
||||
|
||||
Customer order = new Customer();
|
||||
EntityBeanIntercept ebi = getIntercept(order);
|
||||
assertFalse(beanDescriptor.referenceIdPropertyOnly(ebi));
|
||||
|
||||
order.setId(23);
|
||||
assertTrue(beanDescriptor.referenceIdPropertyOnly(ebi));
|
||||
|
||||
order.setName("custName");
|
||||
assertFalse(beanDescriptor.referenceIdPropertyOnly(ebi));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isReference_withGeneratedOnInsertOnlyProperty_expect_false() {
|
||||
BeanDescriptor<UserInterestLive> descriptor = spiServer.descriptor(UserInterestLive.class);
|
||||
UserInterestLive bean = new UserInterestLive(new UserInterestLiveKey(1L, 2L));
|
||||
EntityBeanIntercept ebi = getIntercept(bean);
|
||||
assertFalse(descriptor.referenceIdPropertyOnly(ebi));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test_getIdForJson() {
|
||||
|
||||
BeanDescriptor<Order> orderDesc = spiServer.descriptor(Order.class);
|
||||
|
||||
Order order = new Order();
|
||||
order.setId(42);
|
||||
assertEquals(42, orderDesc.idForJson(order));
|
||||
|
||||
assertEquals(42, orderDesc.convertIdFromJson(42));
|
||||
assertEquals(42, orderDesc.convertIdFromJson("42"));
|
||||
assertEquals(42, orderDesc.convertIdFromJson(42L));
|
||||
|
||||
|
||||
RCustomerKey key = new RCustomerKey();
|
||||
key.setCompany("comp");
|
||||
key.setName("fred");
|
||||
|
||||
RCustomer rCustomer = new RCustomer();
|
||||
rCustomer.setKey(key);
|
||||
|
||||
BeanDescriptor<RCustomer> rcustDesc = spiServer.descriptor(RCustomer.class);
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
Map<String, Object> idForJson = (Map<String, Object>) rcustDesc.idForJson(rCustomer);
|
||||
assertEquals("comp", idForJson.get("company"));
|
||||
assertEquals("fred", idForJson.get("name"));
|
||||
assertEquals(2, idForJson.size());
|
||||
|
||||
RCustomerKey keyVal = (RCustomerKey) rcustDesc.convertIdFromJson(idForJson);
|
||||
assertEquals("comp", keyVal.getCompany());
|
||||
assertEquals("fred", keyVal.getName());
|
||||
|
||||
}
|
||||
|
||||
private EntityBean entityBean(Object bean) {
|
||||
return (EntityBean) bean;
|
||||
}
|
||||
|
||||
private EntityBeanIntercept getIntercept(Object bean) {
|
||||
return ((EntityBean) bean)._ebean_getIntercept();
|
||||
}
|
||||
|
||||
}
|
||||
-42
@@ -1,42 +0,0 @@
|
||||
package io.ebeaninternal.server.deploy;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.DB;
|
||||
import io.ebean.bean.BeanCollection;
|
||||
import io.ebean.bean.EntityBean;
|
||||
import io.ebean.bean.EntityBeanIntercept;
|
||||
import io.ebeaninternal.api.SpiEbeanServer;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Contact;
|
||||
import org.tests.model.basic.Customer;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
public class TestCollectionLoadedStatus extends BaseTestCase {
|
||||
|
||||
@Test
|
||||
public void test() {
|
||||
|
||||
SpiEbeanServer server = (SpiEbeanServer) DB.getDefault();
|
||||
BeanDescriptor<Customer> custDesc = server.descriptor(Customer.class);
|
||||
|
||||
Customer customer = new Customer();
|
||||
EntityBean eb = (EntityBean) customer;
|
||||
EntityBeanIntercept ebi = eb._ebean_getIntercept();
|
||||
|
||||
BeanProperty contactsProperty = custDesc.beanProperty("contacts");
|
||||
assertFalse(ebi.isLoadedProperty(contactsProperty.propertyIndex()));
|
||||
|
||||
Object contactsViaInternal = contactsProperty.getValue(eb);
|
||||
assertNull(contactsViaInternal);
|
||||
assertFalse(ebi.isLoadedProperty(contactsProperty.propertyIndex()));
|
||||
|
||||
List<Contact> contacts = customer.getContacts();
|
||||
assertNotNull(contacts);
|
||||
assertTrue(contacts instanceof BeanCollection);
|
||||
assertTrue(ebi.isLoadedProperty(contactsProperty.propertyIndex()));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,68 +0,0 @@
|
||||
package io.ebeaninternal.server.deploy;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.DB;
|
||||
import io.ebean.Database;
|
||||
import io.ebean.bean.EntityBean;
|
||||
import io.ebeaninternal.api.SpiEbeanServer;
|
||||
import io.ebeaninternal.api.json.SpiJsonWriter;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Customer;
|
||||
import org.tests.model.basic.Order;
|
||||
import org.tests.model.basic.Order.Status;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.StringWriter;
|
||||
import java.sql.Date;
|
||||
import java.sql.Timestamp;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
|
||||
public class TestDiffHelpInsertSimple extends BaseTestCase {
|
||||
|
||||
private final long firstTime = System.currentTimeMillis() - 10000;
|
||||
|
||||
private final Database server;
|
||||
|
||||
private final BeanDescriptor<Order> orderDesc;
|
||||
|
||||
public TestDiffHelpInsertSimple() {
|
||||
server = DB.getDefault();
|
||||
SpiEbeanServer spiServer = (SpiEbeanServer) server;
|
||||
orderDesc = spiServer.descriptor(Order.class);
|
||||
}
|
||||
|
||||
private Order createBaseOrder(Database server) {
|
||||
Order order1 = new Order();
|
||||
order1.setId(12);
|
||||
order1.setCretime(new Timestamp(firstTime));
|
||||
order1.setCustomer(server.reference(Customer.class, 1234));
|
||||
order1.setStatus(Status.NEW);
|
||||
//order1.setShipDate(new Date(firstTime));
|
||||
order1.setOrderDate(new Date(firstTime));
|
||||
return order1;
|
||||
}
|
||||
|
||||
@Test
|
||||
public void basic() throws IOException {
|
||||
|
||||
Date date = Date.valueOf("2000-01-01");
|
||||
|
||||
Order order1 = createBaseOrder(server);
|
||||
order1.setOrderDate(date);
|
||||
|
||||
StringWriter buffer = new StringWriter();
|
||||
|
||||
SpiJsonWriter jsonWriter = spiEbeanServer().jsonExtended().createJsonWriter(buffer);
|
||||
|
||||
orderDesc.jsonWriteForInsert(jsonWriter, (EntityBean) order1);
|
||||
jsonWriter.flush();
|
||||
|
||||
String asJson = buffer.toString();
|
||||
|
||||
assertThat(asJson).startsWith("{\"status\":\"NEW\",\"orderDate\":\"2000-01-01\"");
|
||||
assertThat(asJson).endsWith(",\"customer\":{\"id\":1234}}");
|
||||
}
|
||||
|
||||
}
|
||||
-95
@@ -1,95 +0,0 @@
|
||||
package io.ebeaninternal.server.deploy;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.DB;
|
||||
import io.ebean.Database;
|
||||
import io.ebean.bean.EntityBean;
|
||||
import io.ebeaninternal.api.SpiEbeanServer;
|
||||
import io.ebeaninternal.api.json.SpiJsonWriter;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.embedded.EMain;
|
||||
import org.tests.model.embedded.Eembeddable;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.StringWriter;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class TestDiffHelpInsertWithEmbedded extends BaseTestCase {
|
||||
|
||||
private final BeanDescriptor<EMain> emainDesc;
|
||||
|
||||
public TestDiffHelpInsertWithEmbedded() {
|
||||
Database server = DB.getDefault();
|
||||
SpiEbeanServer spiServer = (SpiEbeanServer) server;
|
||||
emainDesc = spiServer.descriptor(EMain.class);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void simple() throws IOException {
|
||||
|
||||
EMain emain1 = createEMain();
|
||||
|
||||
String asJson = asInsertJson((EntityBean) emain1);
|
||||
|
||||
assertThat(asJson).contains("{\"name\":\"foo\",\"version\":13,\"embeddable\":{\"description\":\"bar\"}}");
|
||||
|
||||
}
|
||||
|
||||
private String asInsertJson(EntityBean emain1) throws IOException {
|
||||
StringWriter buffer = new StringWriter();
|
||||
|
||||
SpiJsonWriter jsonWriter = spiEbeanServer().jsonExtended().createJsonWriter(buffer);
|
||||
|
||||
emainDesc.jsonWriteForInsert(jsonWriter, emain1);
|
||||
jsonWriter.flush();
|
||||
|
||||
return buffer.toString();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void scalarPropertyAsNull() throws IOException {
|
||||
|
||||
EMain emain1 = createEMain();
|
||||
emain1.setName(null);
|
||||
|
||||
String asJson = asInsertJson((EntityBean) emain1);
|
||||
|
||||
assertThat(asJson).contains("{\"version\":13,\"embeddable\":{\"description\":\"bar\"}}");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void embeddedAsNull() throws IOException {
|
||||
|
||||
EMain emain1 = createEMain();
|
||||
emain1.setEmbeddable(null);
|
||||
|
||||
String asJson = asInsertJson((EntityBean) emain1);
|
||||
|
||||
assertThat(asJson).contains("{\"name\":\"foo\",\"version\":13}");
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void embeddedPropertiesAsNull() throws IOException {
|
||||
|
||||
EMain emain1 = createEMain();
|
||||
emain1.getEmbeddable().setDescription(null);
|
||||
|
||||
String asJson = asInsertJson((EntityBean) emain1);
|
||||
|
||||
assertThat(asJson).contains("{\"name\":\"foo\",\"version\":13,\"embeddable\":{}}");
|
||||
}
|
||||
|
||||
private EMain createEMain() {
|
||||
EMain emain = new EMain();
|
||||
emain.setName("foo");
|
||||
emain.setVersion(13L);
|
||||
|
||||
Eembeddable embeddable = new Eembeddable();
|
||||
embeddable.setDescription("bar");
|
||||
emain.setEmbeddable(embeddable);
|
||||
return emain;
|
||||
}
|
||||
|
||||
}
|
||||
-114
@@ -1,114 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import org.assertj.core.api.Assertions;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.Map;
|
||||
|
||||
public class AllEqualsExpressionTest extends BaseExpressionTest {
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
|
||||
same(exp("a", 10), exp("a", 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_sameMultiple() {
|
||||
|
||||
Assertions.assertThat(exp("a", 10, "b", "23").isSameByBind(exp("a", 10, "b", "23"))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBindValue() {
|
||||
|
||||
same(exp("a", 10), exp("a", 20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_multiple() {
|
||||
|
||||
same(exp("a", 10, "b", 20, "c", 30), exp("a", 10, "b", 20, "c", 30));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_less() {
|
||||
|
||||
different(exp("a", 10, "b", 20, "c", 30), exp("a", 10, "b", 20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_more() {
|
||||
|
||||
different(exp("a", 10, "b", 20), exp("a", 10, "b", 20, "c", 30));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffProperty_diff() {
|
||||
|
||||
different(exp("a", 10), exp("b", 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffType_diff() {
|
||||
|
||||
different(exp("a", 10), new NoopExpression());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBindByNull_last() {
|
||||
|
||||
different(exp("a", 10), exp("a", null));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBindByNull_first() {
|
||||
|
||||
different(exp("a", null), exp("a", 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_differentExpressionType() {
|
||||
|
||||
different(exp("a", null), new NoopExpression());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffBindByNull_last() {
|
||||
|
||||
Assertions.assertThat(exp("a", 10).isSameByBind(exp("a", null))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffBindByNull_first() {
|
||||
|
||||
Assertions.assertThat(exp("a", null).isSameByBind(exp("a", 10))).isFalse();
|
||||
}
|
||||
|
||||
private AllEqualsExpression exp(Map<String, Object> propMap) {
|
||||
return new AllEqualsExpression(propMap);
|
||||
}
|
||||
|
||||
AllEqualsExpression exp(String key0, Object val1) {
|
||||
LinkedHashMap<String, Object> map = new LinkedHashMap<>();
|
||||
map.put(key0, val1);
|
||||
return exp(map);
|
||||
}
|
||||
|
||||
|
||||
AllEqualsExpression exp(String key0, Object val1, String key2, Object val2) {
|
||||
LinkedHashMap<String, Object> map = new LinkedHashMap<>();
|
||||
map.put(key0, val1);
|
||||
map.put(key2, val2);
|
||||
return exp(map);
|
||||
}
|
||||
|
||||
AllEqualsExpression exp(String key0, Object val1, String key2, Object val2, String key3, Object val3) {
|
||||
LinkedHashMap<String, Object> map = new LinkedHashMap<>();
|
||||
map.put(key0, val1);
|
||||
map.put(key2, val2);
|
||||
map.put(key3, val3);
|
||||
return exp(map);
|
||||
}
|
||||
}
|
||||
@@ -1,94 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.EbeanServer;
|
||||
import io.ebean.Query;
|
||||
import io.ebean.Transaction;
|
||||
import io.ebean.event.BeanQueryRequest;
|
||||
import io.ebeaninternal.api.SpiExpression;
|
||||
import io.ebeaninternal.server.deploy.BeanDescriptor;
|
||||
import org.tests.model.basic.Customer;
|
||||
import org.tests.model.basic.Order;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public abstract class BaseExpressionTest extends BaseTestCase {
|
||||
|
||||
protected DefaultExpressionRequest newExpressionRequest() {
|
||||
BeanDescriptor<Order> desc = getBeanDescriptor(Order.class);
|
||||
return new DefaultExpressionRequest(desc);
|
||||
}
|
||||
|
||||
protected String hash(SpiExpression expression) {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
if (expression != null) {
|
||||
expression.queryPlanHash(sb);
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
protected void same(SpiExpression one, SpiExpression two) {
|
||||
assertThat(hash(one)).isEqualTo(hash(two));
|
||||
}
|
||||
|
||||
protected void different(SpiExpression one, SpiExpression two) {
|
||||
assertThat(hash(one)).isNotEqualTo(hash(two));
|
||||
}
|
||||
|
||||
/**
|
||||
* Request with Multi-Value support.
|
||||
*/
|
||||
protected InExpressionTest.TDQueryRequest<Customer> multi() {
|
||||
return MULTI_VALUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Request with NO Multi-Value support.
|
||||
*/
|
||||
protected InExpressionTest.TDQueryRequest<Customer> noMulti() {
|
||||
return NO_MULTI_VALUE;
|
||||
}
|
||||
|
||||
|
||||
private static final TDQueryRequest<Customer> MULTI_VALUE = new TDQueryRequest<>(true);
|
||||
private static final TDQueryRequest<Customer> NO_MULTI_VALUE = new TDQueryRequest<>(false);
|
||||
|
||||
static class TDQueryRequest<T> implements BeanQueryRequest<T> {
|
||||
|
||||
final boolean supported;
|
||||
|
||||
TDQueryRequest(boolean supported) {
|
||||
this.supported = supported;
|
||||
}
|
||||
|
||||
@Override
|
||||
public EbeanServer getEbeanServer() {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Transaction transaction() {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Query<T> query() {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isPadInExpression() {
|
||||
return supported;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isMultiValueIdSupported() {
|
||||
return supported;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isMultiValueSupported(Class<?> valueType) {
|
||||
return supported;
|
||||
}
|
||||
}
|
||||
}
|
||||
-69
@@ -1,69 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import io.ebeaninternal.api.SpiExpression;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class BetweenExpressionTest extends BaseExpressionTest {
|
||||
|
||||
@Test
|
||||
public void addSql() {
|
||||
|
||||
DefaultExpressionRequest expReq = newExpressionRequest();
|
||||
|
||||
BetweenExpression exp = new BetweenExpression("startDate", 1, 2);
|
||||
exp.addSql(expReq);
|
||||
|
||||
assertThat(expReq.getSql()).isEqualTo("startDate between ? and ?");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void copyForPlanKey_isSameInstance() {
|
||||
|
||||
BetweenExpression exp = new BetweenExpression("startDate", 1, 2);
|
||||
SpiExpression other = exp.copyForPlanKey();
|
||||
|
||||
assertThat(exp).isSameAs(other);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_properties_match() {
|
||||
|
||||
BetweenExpression exp0 = new BetweenExpression("startDate", 1, 2);
|
||||
BetweenExpression exp1 = new BetweenExpression("startDate", 3, 4);
|
||||
|
||||
same(exp0, exp1);
|
||||
same(exp1, exp0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_properties_do_not_match() {
|
||||
|
||||
BetweenExpression exp0 = new BetweenExpression("startDate", 1, 2);
|
||||
BetweenExpression exp1 = new BetweenExpression("endDate", 1, 2);
|
||||
|
||||
different(exp0, exp1);
|
||||
different(exp1, exp0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_values_do_not_match() {
|
||||
|
||||
BetweenExpression exp0 = new BetweenExpression("startDate", 1, 2);
|
||||
BetweenExpression exp1 = new BetweenExpression("startDate", 1, 3);
|
||||
|
||||
assertThat(exp0.isSameByBind(exp1)).isFalse();
|
||||
assertThat(exp1.isSameByBind(exp0)).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_values_match() {
|
||||
|
||||
BetweenExpression exp0 = new BetweenExpression("startDate", 1, 2);
|
||||
BetweenExpression exp1 = new BetweenExpression("startDate", 1, 2);
|
||||
|
||||
assertThat(exp0.isSameByBind(exp1)).isTrue();
|
||||
assertThat(exp1.isSameByBind(exp0)).isTrue();
|
||||
}
|
||||
}
|
||||
-50
@@ -1,50 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class BetweenPropertyExpressionTest extends BaseExpressionTest {
|
||||
|
||||
private BetweenPropertyExpression exp(String lowProperty, String highProperty, Object value) {
|
||||
return new BetweenPropertyExpression(lowProperty, highProperty, value);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sqlExpression() {
|
||||
TDSpiExpressionRequest request = new TDSpiExpressionRequest(null);
|
||||
exp("a", "b", 10).addSql(request);
|
||||
assertThat(request.getSql()).isEqualTo(" ? between a and b");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
same(exp("a", "b", 10), exp("a", "b", 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffValue() {
|
||||
same(exp("a", "b", 10), exp("a", "b", 20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffProperty() {
|
||||
different(exp("a", "b", 10), exp("a", "c", 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffExpressionType() {
|
||||
different(exp("a", "b", 10), new NoopExpression());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_same() {
|
||||
assertThat(exp("a", "b", 10).isSameByBind(exp("a", "b", 10))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diff() {
|
||||
assertThat(exp("a", "b", 10).isSameByBind(exp("a", "b", 20))).isFalse();
|
||||
}
|
||||
|
||||
}
|
||||
-50
@@ -1,50 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class CaseInsensitiveEqualExpressionTest extends BaseExpressionTest {
|
||||
|
||||
CaseInsensitiveEqualExpression exp(String propName, String value) {
|
||||
return new CaseInsensitiveEqualExpression(propName, value, false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
|
||||
same(exp("a", "10"), exp("a", "10"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBind_same() {
|
||||
|
||||
same(exp("a", "10"), exp("a", "20"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffProperty_diff() {
|
||||
|
||||
different(exp("a", "10"), exp("b", "10"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffType_diff() {
|
||||
|
||||
different(exp("a", "10"), new NoopExpression());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_sameBindValues() {
|
||||
|
||||
assertThat(exp("a", "10").isSameByBind(exp("b", "10"))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffBindValues() {
|
||||
|
||||
assertThat(exp("a", "10").isSameByBind(exp("b", "20"))).isFalse();
|
||||
}
|
||||
|
||||
}
|
||||
-141
@@ -1,141 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import io.ebean.LikeType;
|
||||
import io.ebean.Query;
|
||||
import io.ebean.bean.EntityBean;
|
||||
import io.ebean.event.BeanQueryRequest;
|
||||
import io.ebeaninternal.api.ManyWhereJoins;
|
||||
import io.ebeaninternal.api.SpiQuery;
|
||||
import io.ebeaninternal.server.core.OrmQueryRequest;
|
||||
import io.ebeaninternal.server.deploy.BeanDescriptor;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Address;
|
||||
import org.tests.model.basic.Customer;
|
||||
import org.tests.model.basic.ResetBasicData;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
|
||||
public class DefaultExampleExpressionTest extends BaseExpressionTest {
|
||||
|
||||
|
||||
Customer customer() {
|
||||
Address address = new Address();
|
||||
address.setCity("billingAddress.city");
|
||||
|
||||
Customer customer = new Customer();
|
||||
customer.setName("name");
|
||||
customer.setBillingAddress(address);
|
||||
return customer;
|
||||
}
|
||||
|
||||
DefaultExampleExpression exp() {
|
||||
Customer customer = customer();
|
||||
return new DefaultExampleExpression((EntityBean) customer, false, LikeType.EQUAL_TO);
|
||||
}
|
||||
|
||||
DefaultExampleExpression expExtra() {
|
||||
Customer customer = customer();
|
||||
customer.setSmallnote("smallNote");
|
||||
return new DefaultExampleExpression((EntityBean) customer, false, LikeType.EQUAL_TO);
|
||||
}
|
||||
|
||||
DefaultExampleExpression expDiffName() {
|
||||
Customer customer = customer();
|
||||
customer.setName("otherName");
|
||||
return new DefaultExampleExpression((EntityBean) customer, false, LikeType.EQUAL_TO);
|
||||
}
|
||||
|
||||
BeanDescriptor<Customer> customerBeanDescriptor() {
|
||||
return getBeanDescriptor(Customer.class);
|
||||
}
|
||||
|
||||
DefaultExampleExpression prepare(DefaultExampleExpression expr) {
|
||||
|
||||
SpiQuery<Customer> query = (SpiQuery<Customer>) spiEbeanServer().find(Customer.class);
|
||||
BeanQueryRequest<?> request = create(query);
|
||||
expr.containsMany(customerBeanDescriptor(), new ManyWhereJoins());
|
||||
expr.prepareExpression(request);
|
||||
return expr;
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test() {
|
||||
|
||||
DefaultExampleExpression expr = exp();
|
||||
|
||||
prepare(expr);
|
||||
|
||||
StringBuilder builder = new StringBuilder();
|
||||
expr.queryPlanHash(builder);
|
||||
|
||||
TDSpiExpressionRequest req = new TDSpiExpressionRequest(customerBeanDescriptor());
|
||||
expr.addBindValues(req);
|
||||
|
||||
assertThat(req.bindValues).contains("name", "billingAddress.city");
|
||||
|
||||
Customer customer = customer();
|
||||
customer.setName("Rob");
|
||||
customer.getBillingAddress().setCity("Auckland");
|
||||
|
||||
ResetBasicData.reset();
|
||||
|
||||
Query<Customer> query1 = server().find(Customer.class)
|
||||
.where().exampleLike(customer)
|
||||
.query();
|
||||
|
||||
query1.findList();
|
||||
|
||||
assertThat(query1.getGeneratedSql()).contains("(t0.name like ");
|
||||
assertThat(query1.getGeneratedSql()).contains(" and t1.city like ");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void emptyExampleBean() {
|
||||
|
||||
ResetBasicData.reset();
|
||||
|
||||
Customer customer = new Customer();
|
||||
|
||||
Query<Customer> query = server().find(Customer.class)
|
||||
.where()
|
||||
.eq("status", Customer.Status.NEW)
|
||||
.exampleLike(customer)
|
||||
.startsWith("name", "Rob")
|
||||
.query();
|
||||
|
||||
query.findList();
|
||||
|
||||
assertThat(sqlOf(query)).contains("and 1=1 and t0.name like");
|
||||
}
|
||||
|
||||
private <T> OrmQueryRequest<T> create(SpiQuery<T> query) {
|
||||
return new OrmQueryRequest<>(null, null, query, null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_whenSame() {
|
||||
|
||||
same(prepare(exp()), prepare(exp()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBindValue_stillSame() {
|
||||
|
||||
same(prepare(exp()), prepare(expDiffName()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_extraExpression_then_different() {
|
||||
|
||||
different(prepare(exp()), prepare(expExtra()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_lessExpression_then_different() {
|
||||
|
||||
different(prepare(expExtra()), prepare(exp()));
|
||||
}
|
||||
|
||||
}
|
||||
-93
@@ -1,93 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import io.ebean.Expression;
|
||||
import io.ebeaninternal.api.SpiExpression;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
|
||||
public class DefaultExpressionFactoryTest {
|
||||
|
||||
private String toQueryPlanHash(Expression expression) {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
((SpiExpression) expression).queryPlanHash(sb);
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLowerILike() {
|
||||
|
||||
DefaultExpressionFactory factory = new DefaultExpressionFactory(false, false);
|
||||
Expression expression = factory.ilike("name", "foo");
|
||||
assertThat(expression).isInstanceOf(LikeExpression.class);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNativeILike() {
|
||||
|
||||
DefaultExpressionFactory factory = new DefaultExpressionFactory(false, true);
|
||||
Expression expression = factory.ilike("name", "foo");
|
||||
assertThat(expression).isInstanceOf(NativeILikeExpression.class);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEq() {
|
||||
|
||||
DefaultExpressionFactory factory = new DefaultExpressionFactory(false, false);
|
||||
Expression expression = factory.eq("name", null);
|
||||
assertThat(expression).isInstanceOf(NullExpression.class);
|
||||
assertThat(toQueryPlanHash(expression)).isEqualTo("Null[name]");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNe() {
|
||||
|
||||
DefaultExpressionFactory factory = new DefaultExpressionFactory(false, false);
|
||||
Expression expression = factory.ne("name", null);
|
||||
assertThat(expression).isInstanceOf(NullExpression.class);
|
||||
assertThat(toQueryPlanHash(expression)).isEqualTo("NotNull[name]");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIeq() {
|
||||
|
||||
DefaultExpressionFactory factory = new DefaultExpressionFactory(false, false);
|
||||
Expression expression = factory.ieq("name", null);
|
||||
assertThat(expression).isInstanceOf(NullExpression.class);
|
||||
assertThat(toQueryPlanHash(expression)).isEqualTo("Null[name]");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIne() {
|
||||
|
||||
DefaultExpressionFactory factory = new DefaultExpressionFactory(false, false);
|
||||
Expression expression = factory.ine("name", null);
|
||||
assertThat(expression).isInstanceOf(NullExpression.class);
|
||||
assertThat(toQueryPlanHash(expression)).isEqualTo("NotNull[name]");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEq_with_equalsWithNullAsNoop() {
|
||||
|
||||
DefaultExpressionFactory factory = new DefaultExpressionFactory(true, false);
|
||||
Expression expression = factory.eq("name", null);
|
||||
assertThat(expression).isInstanceOf(NoopExpression.class);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNe_with_equalsWithNullAsNoop() {
|
||||
|
||||
DefaultExpressionFactory factory = new DefaultExpressionFactory(true, false);
|
||||
Expression expression = factory.ne("name", null);
|
||||
assertThat(expression).isInstanceOf(NoopExpression.class);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIeq_with_equalsWithNullAsNoop() {
|
||||
|
||||
DefaultExpressionFactory factory = new DefaultExpressionFactory(true, false);
|
||||
Expression expression = factory.ieq("name", null);
|
||||
assertThat(expression).isInstanceOf(NoopExpression.class);
|
||||
}
|
||||
}
|
||||
-98
@@ -1,98 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import io.ebean.ExpressionList;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class DefaultExpressionListTest extends BaseExpressionTest {
|
||||
|
||||
|
||||
DefaultExpressionList<?> exp() {
|
||||
|
||||
return new DefaultExpressionList<>(null, new DefaultExpressionFactory(true, true), null);
|
||||
}
|
||||
|
||||
private <T> DefaultExpressionList<T> spi(ExpressionList<T> list) {
|
||||
return (DefaultExpressionList<T>) list;
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
|
||||
same(spi(exp().eq("a", 10).eq("b", 20))
|
||||
,spi(exp().eq("a", 10).eq("b", 20)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffExpressionType() {
|
||||
|
||||
different(spi(exp().eq("a", 10).eq("b", 20))
|
||||
,new NoopExpression());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_less() {
|
||||
|
||||
different(spi(exp().eq("a", 10).eq("b", 20))
|
||||
,spi(exp().eq("a", 10)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_lessEmptyLast() {
|
||||
|
||||
different(spi(exp().eq("a", 10).eq("b", 20))
|
||||
,spi(exp()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_lessEmptyFirst() {
|
||||
|
||||
different(spi(exp())
|
||||
,spi(exp().eq("a", 10)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_more() {
|
||||
|
||||
different(spi(exp().eq("a", 10).eq("b", 20))
|
||||
,spi(exp().eq("a", 10).eq("b", 20).eq("c", 30)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffProperties() {
|
||||
|
||||
different(spi(exp().eq("a", 10).eq("b", 20))
|
||||
,spi(exp().eq("c", 10).eq("b", 20)));
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_same() {
|
||||
|
||||
assertThat(spi(exp().eq("a", 10).eq("b", 20))
|
||||
.isSameByBind(spi(exp().eq("a", 10).eq("b", 20)))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffValues() {
|
||||
|
||||
assertThat(spi(exp().eq("a", 10).eq("b", 20))
|
||||
.isSameByBind(spi(exp().eq("a", 10).eq("b", 30)))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_less() {
|
||||
|
||||
assertThat(spi(exp().eq("a", 10))
|
||||
.isSameByBind(spi(exp().eq("a", 10).eq("b", 20)))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_more() {
|
||||
|
||||
assertThat(spi(exp().eq("a", 10))
|
||||
.isSameByBind(spi(exp().eq("a", 10).eq("b", 20)))).isFalse();
|
||||
}
|
||||
|
||||
}
|
||||
-82
@@ -1,82 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class ExistsQueryExpressionTest extends BaseExpressionTest {
|
||||
|
||||
|
||||
private ExistsQueryExpression exp(boolean not, String sql, Object... bindValues) {
|
||||
return new ExistsQueryExpression(not, sql, Arrays.asList(bindValues));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
|
||||
same(exp(true, "a", 10), exp(true, "a", 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBind_same() {
|
||||
|
||||
same(exp(true, "a", 10), exp(true, "a", 20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffNot() {
|
||||
|
||||
different(exp(true, "a", 10), exp(false, "a", 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffSql() {
|
||||
|
||||
different(exp(true, "a", 10), exp(true, "b", 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_sameBindValues() {
|
||||
|
||||
same(exp(true, "a", 10), exp(true, "a", 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_sameMultipleBindValues() {
|
||||
|
||||
same(exp(true, "a", 10, "ABC", 20), exp(true, "a", 10, "ABC", 20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffMultipleBindValues() {
|
||||
|
||||
assertThat(exp(true, "a", 10, "ABC", 20).isSameByBind(exp(true, "a", 10, "ABC", 21))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffMultipleBindValuesByOrder() {
|
||||
|
||||
assertThat(exp(true, "a", 10, "ABC", 20).isSameByBind(exp(true, "a", 10, 20, "ABC"))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffBindValues() {
|
||||
|
||||
assertThat(exp(true, "a", 10).isSameByBind(exp(true, "a", 20))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_lessBindValues() {
|
||||
|
||||
assertThat(exp(true, "a", 10, 20).isSameByBind(exp(true, "a", 20))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_moreBindValues() {
|
||||
|
||||
assertThat(exp(true, "a", 10).isSameByBind(exp(true, "a", 10, 20))).isFalse();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class IdExpressionTest extends BaseExpressionTest {
|
||||
|
||||
|
||||
private IdExpression exp(Object value) {
|
||||
return new IdExpression(value);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
|
||||
same(exp(10), exp(10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBind_same() {
|
||||
|
||||
same(exp(10), exp(20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_sameBindValues() {
|
||||
|
||||
assertThat(exp(10).isSameByBind(exp(10))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffBindValues() {
|
||||
|
||||
assertThat(exp(10).isSameByBind(exp(20))).isFalse();
|
||||
assertThat(exp(10).isSameByBind(exp("junk"))).isFalse();
|
||||
}
|
||||
}
|
||||
@@ -1,65 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class IdInExpressionTest extends BaseExpressionTest {
|
||||
|
||||
|
||||
private IdInExpression exp(Object... values) {
|
||||
return new IdInExpression(Arrays.asList(values));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
|
||||
same(exp(10), exp(10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBind_same() {
|
||||
|
||||
same(exp(10), exp(20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBindCount_notPrepared() {
|
||||
|
||||
different(exp(10), exp(10, 20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_sameBindValues() {
|
||||
|
||||
assertThat(exp(10).isSameByBind(exp(10))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_mulitpleSameBindValues() {
|
||||
|
||||
assertThat(exp(10, "ABC", 20).isSameByBind(exp(10, "ABC", 20))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffBindValues() {
|
||||
|
||||
assertThat(exp(10).isSameByBind(exp("junk"))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_lessBindValues() {
|
||||
|
||||
assertThat(exp(10, "ABC", 20).isSameByBind(exp(10, "ABC"))).isFalse();
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_moreBindValues() {
|
||||
|
||||
assertThat(exp(10, "ABC").isSameByBind(exp(10, "ABC", 30))).isFalse();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,185 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class InExpressionTest extends BaseExpressionTest {
|
||||
|
||||
@Test
|
||||
public void queryPlanHash_given_diffEmpty_should_differentPlanHash() {
|
||||
|
||||
List<Integer> emptyValues = values();
|
||||
|
||||
InExpression ex1 = new InExpression("foo", emptyValues, false, true);
|
||||
InExpression ex2 = new InExpression("foo", emptyValues, false);
|
||||
InExpression ex3 = new InExpression("foo", emptyValues, false, true);
|
||||
InExpression ex4 = new InExpression("foo", null, false, true);
|
||||
|
||||
ex1.prepareExpression(multi());
|
||||
ex2.prepareExpression(multi());
|
||||
|
||||
different(ex1, ex2);
|
||||
same(ex1, ex3); // same empty
|
||||
same(ex1, ex4); // same null
|
||||
}
|
||||
|
||||
@Test
|
||||
public void queryPlanHash_given_diffPropertyName_should_differentPlanHash() {
|
||||
|
||||
List<Integer> values = values(42, 92);
|
||||
|
||||
InExpression ex1 = new InExpression("foo", values, false);
|
||||
InExpression ex2 = new InExpression("bar", values, false);
|
||||
|
||||
ex1.prepareExpression(multi());
|
||||
ex2.prepareExpression(multi());
|
||||
|
||||
different(ex1, ex2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void queryPlanHash_given_diffBindCount_should_differentPlanHash() {
|
||||
|
||||
List<Integer> values1 = values(42, 92);
|
||||
List<Integer> values2 = values(42, 92, 82);
|
||||
|
||||
InExpression ex1 = new InExpression("foo", values1, false);
|
||||
InExpression ex2 = new InExpression("foo", values2, false);
|
||||
|
||||
ex1.prepareExpression(noMulti());
|
||||
ex2.prepareExpression(noMulti());
|
||||
different(ex1, ex2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void queryPlanHash_given_diffBindCount_withMultiSupport_samePlanHash() {
|
||||
|
||||
List<Integer> values1 = values(42, 92);
|
||||
List<Integer> values2 = values(42, 92, 82);
|
||||
|
||||
InExpression ex1 = new InExpression("foo", values1, false);
|
||||
InExpression ex2 = new InExpression("foo", values2, false);
|
||||
|
||||
ex1.prepareExpression(multi());
|
||||
ex2.prepareExpression(multi());
|
||||
same(ex1, ex2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void queryPlanHash_given_diffNotFlag_should_differentPlanHash() {
|
||||
|
||||
List<Integer> values = values(42, 92);
|
||||
|
||||
InExpression ex1 = new InExpression("foo", values, true);
|
||||
InExpression ex2 = new InExpression("foo", values, false);
|
||||
|
||||
ex1.prepareExpression(multi());
|
||||
ex2.prepareExpression(multi());
|
||||
|
||||
different(ex1, ex2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void queryPlanHash_given_sameNotFlag_should_samePlanHash() {
|
||||
|
||||
List<Integer> values = values(42, 92);
|
||||
|
||||
InExpression ex1 = new InExpression("foo", values, true);
|
||||
InExpression ex2 = new InExpression("foo", values, true);
|
||||
|
||||
ex1.prepareExpression(multi());
|
||||
ex2.prepareExpression(multi());
|
||||
|
||||
same(ex1, ex2);
|
||||
}
|
||||
|
||||
private List<Integer> values(int... vals) {
|
||||
ArrayList<Integer> list = new ArrayList<>();
|
||||
for (int val : vals) {
|
||||
list.add(val);
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
private InExpression exp(String propName, boolean not, Object... values) {
|
||||
InExpression ex = new InExpression(propName, Arrays.asList(values), not);
|
||||
ex.prepareExpression(multi());
|
||||
return ex;
|
||||
}
|
||||
|
||||
private InExpression expNoMulti(String propName, boolean not, Object... values) {
|
||||
InExpression ex = new InExpression(propName, Arrays.asList(values), not);
|
||||
ex.prepareExpression(noMulti());
|
||||
return ex;
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
|
||||
same(exp("a", false, 10), exp("a", false, 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffPropertyName() {
|
||||
|
||||
different(exp("a", false, 10), exp("b", false, 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffNot() {
|
||||
|
||||
different(exp("a", false, 10), exp("a", true, 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBind_same() {
|
||||
|
||||
same(exp("a", false, 10), exp("a", false, 10, 20));
|
||||
different(expNoMulti("a", false, 10), expNoMulti("a", false, 10, 20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBindCount() {
|
||||
|
||||
same(exp("a", false, 10), exp("a", false, 10, 20));
|
||||
different(expNoMulti("a", false, 10), expNoMulti("a", false, 10, 20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_sameBindValues() {
|
||||
|
||||
assertThat(exp("a", false, 10).isSameByBind(exp("a", false, 10))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_sameMultipleBindValues() {
|
||||
|
||||
assertThat(exp("a", false, 10, "ABC", 20).isSameByBind(exp("a", false, 10, "ABC", 20))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffBindValues() {
|
||||
|
||||
assertThat(exp("a", false, 10).isSameByBind(exp("a", false, "foo"))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_lessBindValues() {
|
||||
|
||||
assertThat(exp("a", false, 10, "ABC", 20).isSameByBind(exp("a", false, 10, "ABC"))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_moreBindValues() {
|
||||
|
||||
assertThat(exp("a", false, 10, "ABC").isSameByBind(exp("a", false, 10, "ABC", 30))).isFalse();
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
-92
@@ -1,92 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import io.ebean.Pairs;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
public class InPairsExpressionTest extends BaseExpressionTest {
|
||||
|
||||
private Pairs pairs() {
|
||||
return pairs("sku", "code");
|
||||
}
|
||||
|
||||
private Pairs pairs(String property0, String property1) {
|
||||
Pairs pairs = new Pairs(property0, property1)
|
||||
.add("2", 1000)
|
||||
.add("2", 1001)
|
||||
.add("3", 1000);
|
||||
|
||||
return pairs;
|
||||
}
|
||||
|
||||
@Test
|
||||
public void same_samePlan_sameBind() throws Exception {
|
||||
|
||||
InPairsExpression e0 = new InPairsExpression(pairs(), false);
|
||||
InPairsExpression e1 = new InPairsExpression(pairs(), false);
|
||||
|
||||
same(e0, e1);
|
||||
|
||||
assertTrue(e0.isSameByBind(e1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void same_samePlan_diffBind() throws Exception {
|
||||
|
||||
InPairsExpression e0 = new InPairsExpression(pairs(), false);
|
||||
InPairsExpression e1 = new InPairsExpression(pairs().add("4", 1000), false);
|
||||
e0.prepareExpression(multi());
|
||||
e1.prepareExpression(multi());
|
||||
|
||||
// when multi() ... same as bind count not important
|
||||
same(e0, e1);
|
||||
assertFalse(e0.isSameByBind(e1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void same_noMulti_diffPlan() throws Exception {
|
||||
|
||||
InPairsExpression e0 = new InPairsExpression(pairs(), false);
|
||||
InPairsExpression e1 = new InPairsExpression(pairs().add("4", 1000), false);
|
||||
e0.prepareExpression(noMulti());
|
||||
e1.prepareExpression(noMulti());
|
||||
|
||||
// when noMulti() ... bind count different so different plan
|
||||
different(e0, e1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void diffProperty0_diff() throws Exception {
|
||||
|
||||
InPairsExpression e0 = new InPairsExpression(pairs(), false);
|
||||
InPairsExpression e1 = new InPairsExpression(pairs("k", "code"), false);
|
||||
different(e0, e1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void diffProperty1_diff() throws Exception {
|
||||
|
||||
InPairsExpression e0 = new InPairsExpression(pairs(), false);
|
||||
InPairsExpression e1 = new InPairsExpression(pairs("sku", "c"), false);
|
||||
different(e0, e1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void diffSeparator_diff() throws Exception {
|
||||
|
||||
InPairsExpression e0 = new InPairsExpression(pairs(), false);
|
||||
InPairsExpression e1 = new InPairsExpression(pairs().concatSeparator(":"), false);
|
||||
different(e0, e1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void diffSuffix_diff() throws Exception {
|
||||
|
||||
InPairsExpression e0 = new InPairsExpression(pairs(), false);
|
||||
InPairsExpression e1 = new InPairsExpression(pairs().concatSuffix(":"), false);
|
||||
different(e0, e1);
|
||||
}
|
||||
|
||||
}
|
||||
-87
@@ -1,87 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class InQueryExpressionTest extends BaseExpressionTest {
|
||||
|
||||
|
||||
private InQueryExpression exp(String propertyName, boolean not, String sql, Object... bindValues) {
|
||||
return new InQueryExpression(propertyName, not, sql, Arrays.asList(bindValues));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
|
||||
same(exp("name", true, "sql", 10), exp("name", true, "sql", 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBind_same() {
|
||||
|
||||
same(exp("name", true, "sql", 10), exp("name", true, "sql", 20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffNPropertyName() {
|
||||
|
||||
different(exp("name", true, "sql", 10), exp("nameDiff", true, "sql", 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffNot() {
|
||||
|
||||
different(exp("name", true, "sql", 10), exp("name", false, "sql", 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffSql() {
|
||||
|
||||
different(exp("name", true, "sql", 10), exp("name", true, "sqlDiff", 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_sameBindValues() {
|
||||
|
||||
assertThat(exp("name", true, "sql", 10).isSameByBind(exp("name", true, "sql", 10))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_sameMultipleBindValues() {
|
||||
|
||||
assertThat(exp("name", true, "sql", 10, "ABC", 20).isSameByBind(exp("name", true, "sql", 10, "ABC", 20))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffMultipleBindValues() {
|
||||
|
||||
assertThat(exp("name", true, "sql", 10, "ABC", 20).isSameByBind(exp("name", true, "sql", 10, "ABC", 21))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffMultipleBindValuesByOrder() {
|
||||
|
||||
assertThat(exp("name", true, "sql", 10, "ABC", 20).isSameByBind(exp("name", true, "sql", 10, 20, "ABC"))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffBindValues() {
|
||||
|
||||
assertThat(exp("name", true, "sql", 10).isSameByBind(exp("name", true, "sql", 20))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_lessBindValues() {
|
||||
|
||||
assertThat(exp("name", true, "sql", 10, 20).isSameByBind(exp("name", true, "sql", 20))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_moreBindValues() {
|
||||
|
||||
assertThat(exp("name", true, "sql", 10).isSameByBind(exp("name", true, "sql", 10, 20))).isFalse();
|
||||
}
|
||||
}
|
||||
-69
@@ -1,69 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import io.ebeaninternal.api.SpiExpression;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class InRangeExpressionTest extends BaseExpressionTest {
|
||||
|
||||
@Test
|
||||
public void addSql() {
|
||||
|
||||
DefaultExpressionRequest expReq = newExpressionRequest();
|
||||
|
||||
InRangeExpression exp = new InRangeExpression("startDate", 1, 2);
|
||||
exp.addSql(expReq);
|
||||
|
||||
assertThat(expReq.getSql()).isEqualTo("(startDate >= ? and startDate < ?)");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void copyForPlanKey_isSameInstance() {
|
||||
|
||||
InRangeExpression exp = new InRangeExpression("startDate", 1, 2);
|
||||
SpiExpression other = exp.copyForPlanKey();
|
||||
|
||||
assertThat(exp).isSameAs(other);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_properties_match() {
|
||||
|
||||
InRangeExpression exp0 = new InRangeExpression("startDate", 1, 2);
|
||||
InRangeExpression exp1 = new InRangeExpression("startDate", 3, 4);
|
||||
|
||||
same(exp0, exp1);
|
||||
same(exp1, exp0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_properties_do_not_match() {
|
||||
|
||||
InRangeExpression exp0 = new InRangeExpression("startDate", 1, 2);
|
||||
InRangeExpression exp1 = new InRangeExpression("endDate", 1, 2);
|
||||
|
||||
different(exp0, exp1);
|
||||
different(exp1, exp0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_values_do_not_match() {
|
||||
|
||||
InRangeExpression exp0 = new InRangeExpression("startDate", 1, 2);
|
||||
InRangeExpression exp1 = new InRangeExpression("startDate", 1, 3);
|
||||
|
||||
assertThat(exp0.isSameByBind(exp1)).isFalse();
|
||||
assertThat(exp1.isSameByBind(exp0)).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_values_match() {
|
||||
|
||||
InRangeExpression exp0 = new InRangeExpression("startDate", 1, 2);
|
||||
InRangeExpression exp1 = new InRangeExpression("startDate", 1, 2);
|
||||
|
||||
assertThat(exp0.isSameByBind(exp1)).isTrue();
|
||||
assertThat(exp1.isSameByBind(exp0)).isTrue();
|
||||
}
|
||||
}
|
||||
-79
@@ -1,79 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class JsonPathExpressionTest extends BaseExpressionTest {
|
||||
|
||||
private JsonPathExpression exp(String propertyName, String path, Op operator, Object value) {
|
||||
return new JsonPathExpression(propertyName, path, operator, value);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
|
||||
same(exp("a", "path", Op.EQ, 10), exp("a", "path", Op.EQ, 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBind_same() {
|
||||
|
||||
same(exp("a", "path", Op.EQ, 10), exp("a", "path", Op.EQ, 20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffPath() {
|
||||
|
||||
different(exp("a", "path", Op.EQ, 10), exp("a", "pathDiff", Op.EQ, 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffProperty_diff() {
|
||||
|
||||
different(exp("a", "path", Op.EQ, 10), exp("b", "path", Op.EQ, 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffOperator_diff() {
|
||||
|
||||
different(exp("a", "path", Op.EQ, 10), exp("a", "path", Op.LT, 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffType_diff() {
|
||||
|
||||
different(exp("a", "path", Op.EQ, 10), new NoopExpression());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_sameBindValues() {
|
||||
|
||||
assertThat(exp("a", "path", Op.EQ, 10).isSameByBind(exp("a", "path", Op.LT, 10))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_sameNullBindValues() {
|
||||
|
||||
assertThat(exp("a", "path", Op.EQ, null).isSameByBind(exp("a", "path", Op.LT, null))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffBindValues() {
|
||||
|
||||
assertThat(exp("a", "path", Op.EQ, 10).isSameByBind(exp("a", "path", Op.EQ, "junk"))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffFirstNullBindValues() {
|
||||
|
||||
assertThat(exp("a", "path", Op.EQ, null).isSameByBind(exp("a", "path", Op.LT, 10))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffLastNullBindValues() {
|
||||
|
||||
assertThat(exp("a", "path", Op.EQ, 10).isSameByBind(exp("a", "path", Op.LT, null))).isFalse();
|
||||
}
|
||||
|
||||
}
|
||||
-59
@@ -1,59 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import io.ebean.Expr;
|
||||
import io.ebean.Expression;
|
||||
import io.ebean.Junction;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
public class JunctionExpressionTest extends BaseExpressionTest {
|
||||
|
||||
Expression eq(String propName, int value) {
|
||||
return Expr.eq(propName, value);
|
||||
}
|
||||
|
||||
|
||||
DefaultExpressionList<?> exp(Expression... expressions) {
|
||||
|
||||
DefaultExpressionList<Object> list = new DefaultExpressionList<>(null, new DefaultExpressionFactory(true, false), null);
|
||||
for (Expression ex : expressions) {
|
||||
list.add(ex);
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
<T> JunctionExpression<T> and(DefaultExpressionList<T> list) {
|
||||
return new JunctionExpression<>(Junction.Type.AND, list);
|
||||
}
|
||||
|
||||
<T> JunctionExpression<T> or(DefaultExpressionList<T> list) {
|
||||
return new JunctionExpression<>(Junction.Type.OR, list);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
|
||||
same(and(exp(eq("a", 10), eq("b", 10))),
|
||||
and(exp(eq("a", 10), eq("b", 10))));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void copyForPlanKey_isSameByPlan_when_same() {
|
||||
|
||||
same(and(exp(eq("a", 10), eq("b", 10)).copyForPlanKey()),
|
||||
and(exp(eq("a", 10), eq("b", 10))));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void copyForPlanKey_isSameByPlan_when_diff() {
|
||||
|
||||
different(and(exp(eq("a", 10), eq("b", 10)).copyForPlanKey()),
|
||||
and(exp(eq("a", 10), eq("c", 10))));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffType() {
|
||||
|
||||
different(and(exp(eq("a", 10), eq("b", 10))),
|
||||
or(exp(eq("a", 10), eq("b", 10))));
|
||||
}
|
||||
}
|
||||
@@ -1,64 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import io.ebean.LikeType;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class LikeExpressionTest extends BaseExpressionTest {
|
||||
|
||||
|
||||
private LikeExpression exp(String propertyName, String value, boolean caseInsensitive, LikeType type) {
|
||||
return new LikeExpression(propertyName, value, caseInsensitive, type);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
|
||||
same(exp("a", "rob", true, LikeType.STARTS_WITH)
|
||||
, exp("a", "rob", true, LikeType.STARTS_WITH));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBind_then_stillSame() {
|
||||
|
||||
same(exp("a", "rob", true, LikeType.STARTS_WITH)
|
||||
, exp("a", "bor", true, LikeType.STARTS_WITH));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffCaseInsensitive() {
|
||||
|
||||
different(exp("a", "rob", true, LikeType.STARTS_WITH)
|
||||
, exp("a", "rob", false, LikeType.STARTS_WITH));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffLikeType() {
|
||||
|
||||
different(exp("a", "rob", true, LikeType.STARTS_WITH)
|
||||
, exp("a", "rob", true, LikeType.ENDS_WITH));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffProperty() {
|
||||
|
||||
different(exp("a", "rob", true, LikeType.STARTS_WITH)
|
||||
, exp("b", "rob", true, LikeType.STARTS_WITH));
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_sameBindValues() {
|
||||
|
||||
assertThat(exp("a", "rob", true, LikeType.STARTS_WITH)
|
||||
.isSameByBind(exp("a", "rob", true, LikeType.STARTS_WITH))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffBindValues() {
|
||||
|
||||
assertThat(exp("a", "rob", true, LikeType.STARTS_WITH)
|
||||
.isSameByBind(exp("a", "bor", true, LikeType.STARTS_WITH))).isFalse();
|
||||
}
|
||||
}
|
||||
@@ -1,140 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import io.ebean.Expr;
|
||||
import io.ebean.Expression;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Order;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class LogicExpressionTest extends BaseExpressionTest {
|
||||
|
||||
private Expression eq(String propName, int value) {
|
||||
return Expr.eq(propName, value);
|
||||
}
|
||||
|
||||
private LogicExpression and(Expression a, Expression b) {
|
||||
return new LogicExpression.And(a, b);
|
||||
}
|
||||
|
||||
private LogicExpression or(Expression a, Expression b) {
|
||||
return new LogicExpression.Or(a, b);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void addSql() {
|
||||
|
||||
DefaultExpressionRequest expReq = newExpressionRequest();
|
||||
|
||||
LogicExpression and = and(eq("a", 10), eq("b", 10));
|
||||
and.addSql(expReq);
|
||||
|
||||
assertThat(expReq.getSql()).isEqualTo("(a = ? and b = ?)");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
|
||||
same(and(eq("a", 10), eq("b", 10))
|
||||
, and(eq("a", 10), eq("b", 10)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBind_then_stillSame() {
|
||||
|
||||
same(and(eq("a", 10), eq("b", 10))
|
||||
, and(eq("a", 20), eq("b", 20)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffExp1_then_diff() {
|
||||
|
||||
different(and(eq("a", 10), eq("b", 10))
|
||||
, and(eq("c", 10), eq("b", 10)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffExp2_then_diff() {
|
||||
|
||||
different(and(eq("a", 10), eq("b", 10))
|
||||
, and(eq("a", 10), eq("c", 10)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffType_then_diff() {
|
||||
|
||||
different(or(eq("a", 10), eq("b", 10))
|
||||
, and(eq("a", 10), eq("c", 10)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffExpressionType() {
|
||||
|
||||
different(or(eq("a", 10), eq("b", 10))
|
||||
, new NoopExpression());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_sameBindValues() {
|
||||
|
||||
assertThat(and(eq("a", 10), eq("b", 10))
|
||||
.isSameByBind(and(eq("a", 10), eq("c", 10)))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffBindValues() {
|
||||
|
||||
assertThat(and(eq("a", 10), eq("b", 10))
|
||||
.isSameByBind(and(eq("a", 10), eq("c", 20)))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void nestedPath_when_notNested() {
|
||||
|
||||
LogicExpression and = and(eq("orderDate", 10), eq("shipDate", 10));
|
||||
|
||||
and.nestedPath(getBeanDescriptor(Order.class));
|
||||
|
||||
assertThat(and.expOne).isInstanceOf(SimpleExpression.class);
|
||||
assertThat(and.expTwo).isInstanceOf(SimpleExpression.class);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void nestedPath_when_nestedSame() {
|
||||
|
||||
LogicExpression and = and(eq("details.orderQty", 10), eq("details.unitPrice", 10));
|
||||
|
||||
String path = and.nestedPath(getBeanDescriptor(Order.class));
|
||||
|
||||
assertThat(path).isEqualTo("details");
|
||||
assertThat(and.expOne).isInstanceOf(SimpleExpression.class);
|
||||
assertThat(and.expTwo).isInstanceOf(SimpleExpression.class);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void nestedPath_when_nestedDifferent() {
|
||||
|
||||
LogicExpression and = and(eq("details.orderQty", 10), eq("shipments.shipTime", 10));
|
||||
|
||||
String path = and.nestedPath(getBeanDescriptor(Order.class));
|
||||
|
||||
assertThat(path).isNull();
|
||||
assertThat(and.expOne).isInstanceOf(NestedPathWrapperExpression.class);
|
||||
assertThat(((NestedPathWrapperExpression) and.expOne).nestedPath).isEqualTo("details");
|
||||
assertThat(and.expTwo).isInstanceOf(NestedPathWrapperExpression.class);
|
||||
assertThat(((NestedPathWrapperExpression) and.expTwo).nestedPath).isEqualTo("shipments");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void nestedPath_when_oneNested() {
|
||||
|
||||
LogicExpression and = and(eq("details.orderQty", 10), eq("orderDate", 10));
|
||||
|
||||
String path = and.nestedPath(getBeanDescriptor(Order.class));
|
||||
|
||||
assertThat(path).isNull();
|
||||
assertThat(and.expOne).isInstanceOf(NestedPathWrapperExpression.class);
|
||||
assertThat(((NestedPathWrapperExpression) and.expOne).nestedPath).isEqualTo("details");
|
||||
assertThat(and.expTwo).isInstanceOf(SimpleExpression.class);
|
||||
}
|
||||
}
|
||||
@@ -1,86 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import io.ebean.DB;
|
||||
import io.ebean.Query;
|
||||
import io.ebean.test.LoggedSql;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Customer;
|
||||
import org.tests.model.onetoone.album.Cover;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
|
||||
public class NoopExpressionTest extends BaseExpressionTest {
|
||||
|
||||
@Test
|
||||
public void test() {
|
||||
|
||||
Query<Customer> query = DB.find(Customer.class)
|
||||
.select("id")
|
||||
.where().add(NoopExpression.INSTANCE)
|
||||
.query();
|
||||
|
||||
query.findList();
|
||||
String generatedSql = sqlOf(query);
|
||||
|
||||
assertThat(generatedSql).contains("select t0.id from o_customer t0 where 1=1");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test_withSoftDeleteBean() {
|
||||
|
||||
Query<Cover> query = DB.find(Cover.class)
|
||||
.where().add(NoopExpression.INSTANCE)
|
||||
.query();
|
||||
|
||||
LoggedSql.start();
|
||||
|
||||
query.findCount();
|
||||
|
||||
List<String> sql = LoggedSql.stop();
|
||||
assertSql(sql.get(0)).contains("select count(*) from cover t0 where 1=1 and");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test_withPreAndPost() {
|
||||
|
||||
Query<Customer> query = DB.find(Customer.class)
|
||||
.select("id")
|
||||
.where().eq("name", null)
|
||||
.add(NoopExpression.INSTANCE)
|
||||
.ne("status", null)
|
||||
.query();
|
||||
|
||||
query.findList();
|
||||
String generatedSql = sqlOf(query);
|
||||
|
||||
assertThat(generatedSql).contains("select t0.id from o_customer t0 where t0.name is null and 1=1 and t0.status is not null");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
|
||||
same(new NoopExpression(), new NoopExpression());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffExpressionType() {
|
||||
|
||||
different(new NoopExpression(), null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_same() {
|
||||
|
||||
assertThat(new NoopExpression().isSameByBind(new NoopExpression())).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffExpressionType() {
|
||||
|
||||
assertThat(new NoopExpression().isSameByBind(null)).isTrue();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,54 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
|
||||
import io.ebean.Expression;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static io.ebean.Expr.eq;
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class NotExpressionTest extends BaseExpressionTest {
|
||||
|
||||
|
||||
NotExpression not(Expression expression) {
|
||||
return new NotExpression(expression);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
|
||||
same(not(eq("a", 10)), not(eq("a", 10)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_sameByPlan() {
|
||||
|
||||
same(not(eq("a", 10)), not(eq("a", 20)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_different() {
|
||||
|
||||
different(not(eq("a", 10)), not(eq("b", 10)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_differentExpressionType() {
|
||||
|
||||
different(not(eq("a", 10)), new NoopExpression());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_same() {
|
||||
|
||||
assertThat(not(eq("a", 10))
|
||||
.isSameByBind(not(eq("b", 10)))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_different() {
|
||||
|
||||
assertThat(not(eq("a", 10))
|
||||
.isSameByBind(not(eq("a", 20)))).isFalse();
|
||||
}
|
||||
}
|
||||
@@ -1,95 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import io.ebeaninternal.api.ManyWhereJoins;
|
||||
import io.ebeaninternal.api.SpiExpression;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Order;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class NullExpressionTest extends BaseExpressionTest {
|
||||
|
||||
private NullExpression nullExp(String propertyName, boolean notNull) {
|
||||
NullExpression expr = new NullExpression(propertyName, notNull);
|
||||
expr.containsMany(getBeanDescriptor(Order.class), new ManyWhereJoins());
|
||||
return expr;
|
||||
}
|
||||
|
||||
@Test
|
||||
public void addSql_when_notNull() throws Exception {
|
||||
|
||||
DefaultExpressionRequest expReq = newExpressionRequest();
|
||||
|
||||
nullExp("id", true).addSql(expReq);
|
||||
|
||||
assertThat(expReq.getSql()).isEqualTo("id is not null");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void addSql_when_null() throws Exception {
|
||||
|
||||
DefaultExpressionRequest expReq = newExpressionRequest();
|
||||
|
||||
nullExp("id", false).addSql(expReq);
|
||||
|
||||
assertThat(expReq.getSql()).isEqualTo("id is null");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void addSql_when_notNull_and_assocOne() throws Exception {
|
||||
|
||||
DefaultExpressionRequest expReq = newExpressionRequest();
|
||||
|
||||
nullExp("customer", true).addSql(expReq);
|
||||
|
||||
assertThat(expReq.getSql()).isEqualTo("customer.id is not null");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void addSql_when_null_and_assocOne() throws Exception {
|
||||
|
||||
DefaultExpressionRequest expReq = newExpressionRequest();
|
||||
|
||||
nullExp("customer", false).addSql(expReq);
|
||||
|
||||
assertThat(expReq.getSql()).isEqualTo("customer.id is null");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void copyForPlanKey_isSameInstance() throws Exception {
|
||||
|
||||
NullExpression exp = nullExp("customer.name", false);
|
||||
SpiExpression other = exp.copyForPlanKey();
|
||||
|
||||
assertThat(exp).isSameAs(other);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_true() throws Exception {
|
||||
|
||||
assertThat(nullExp("customer.name", false)
|
||||
.isSameByBind(nullExp("customer.name", false))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_true() throws Exception {
|
||||
|
||||
same(nullExp("customer.name", false),
|
||||
nullExp("customer.name", false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_false_when_notNullDiff() throws Exception {
|
||||
|
||||
different(new NullExpression("customer.name", false),
|
||||
new NullExpression("customer.name", true));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_false_when_propertyNameDiff() throws Exception {
|
||||
|
||||
different(new NullExpression("customer.startDate", true),
|
||||
new NullExpression("customer.name", true));
|
||||
}
|
||||
|
||||
}
|
||||
-148
@@ -1,148 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.DB;
|
||||
import io.ebean.ExpressionList;
|
||||
import io.ebeaninternal.api.SpiExpression;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Order;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
|
||||
public class PrepareDocNestedTest extends BaseTestCase {
|
||||
@Test
|
||||
public void prepare() throws Exception {
|
||||
|
||||
ExpressionList<Order> where = DB.find(Order.class)
|
||||
.where()
|
||||
.gt("details.orderQty", 1)
|
||||
.query().where();
|
||||
|
||||
|
||||
DefaultExpressionList<?> exp = (DefaultExpressionList<?>) where;
|
||||
PrepareDocNested.prepare(exp, getBeanDescriptor(Order.class));
|
||||
|
||||
List<SpiExpression> underlyingList = exp.getUnderlyingList();
|
||||
assertEquals(underlyingList.size(), 1);
|
||||
assertEquals(exp.allDocNestedPath, "details");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void prepare_when_multipleOfSamePath() throws Exception {
|
||||
|
||||
ExpressionList<Order> where = DB.find(Order.class)
|
||||
.where()
|
||||
.gt("details.orderQty", 1)
|
||||
.gt("details.unitPrice", 1)
|
||||
.query().where();
|
||||
|
||||
|
||||
DefaultExpressionList<?> exp = (DefaultExpressionList<?>) where;
|
||||
PrepareDocNested.prepare(exp, getBeanDescriptor(Order.class));
|
||||
|
||||
List<SpiExpression> underlyingList = exp.getUnderlyingList();
|
||||
assertEquals(underlyingList.size(), 2);
|
||||
assertEquals(exp.allDocNestedPath, "details");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void prepare_when_mixed() throws Exception {
|
||||
|
||||
ExpressionList<Order> where = DB.find(Order.class)
|
||||
.where()
|
||||
.gt("customer.id", 1)
|
||||
.gt("details.orderQty", 1)
|
||||
.gt("details.unitPrice", 1)
|
||||
.query().where();
|
||||
|
||||
|
||||
DefaultExpressionList<?> exp = (DefaultExpressionList<?>) where;
|
||||
PrepareDocNested.prepare(exp, getBeanDescriptor(Order.class));
|
||||
|
||||
List<SpiExpression> underlyingList = exp.getUnderlyingList();
|
||||
assertEquals(underlyingList.size(), 2);
|
||||
assertNull(exp.allDocNestedPath);
|
||||
|
||||
DefaultExpressionList<?> second = (DefaultExpressionList<?>) underlyingList.get(1);
|
||||
assertEquals(second.allDocNestedPath, "details");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void prepare_when_nestedJunction() throws Exception {
|
||||
|
||||
ExpressionList<Order> where = DB.find(Order.class)
|
||||
.where()
|
||||
.not()
|
||||
.gt("customer.id", 1)
|
||||
.gt("details.orderQty", 1)
|
||||
.gt("details.unitPrice", 1)
|
||||
.query().where();
|
||||
|
||||
DefaultExpressionList<?> exp = (DefaultExpressionList<?>) where;
|
||||
PrepareDocNested.prepare(exp, getBeanDescriptor(Order.class));
|
||||
|
||||
List<SpiExpression> underlyingList = exp.getUnderlyingList();
|
||||
assertEquals(underlyingList.size(), 1);
|
||||
assertNull(exp.allDocNestedPath);
|
||||
|
||||
JunctionExpression<?> junction = (JunctionExpression<?>) underlyingList.get(0);
|
||||
List<SpiExpression> junctionUnderlying = junction.exprList.getUnderlyingList();
|
||||
JunctionExpression<?> nestedNestedPath = (JunctionExpression<?>) junctionUnderlying.get(1);
|
||||
assertEquals(nestedNestedPath.exprList.allDocNestedPath, "details");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void prepare_when_nestedMultiple() throws Exception {
|
||||
|
||||
ExpressionList<Order> where = DB.find(Order.class)
|
||||
.where()
|
||||
.isNotNull("shipments.shipTime")
|
||||
.gt("details.orderQty", 1)
|
||||
.gt("details.unitPrice", 1)
|
||||
.query().where();
|
||||
|
||||
DefaultExpressionList<?> exp = (DefaultExpressionList<?>) where;
|
||||
PrepareDocNested.prepare(exp, getBeanDescriptor(Order.class));
|
||||
|
||||
List<SpiExpression> underlyingList = exp.getUnderlyingList();
|
||||
assertEquals(underlyingList.size(), 2);
|
||||
assertNull(exp.allDocNestedPath);
|
||||
|
||||
DefaultExpressionList<?> shipExpr = (DefaultExpressionList<?>) underlyingList.get(0);
|
||||
assertEquals(shipExpr.allDocNestedPath, "shipments");
|
||||
|
||||
DefaultExpressionList<?> detailsExpr = (DefaultExpressionList<?>) underlyingList.get(1);
|
||||
assertEquals(detailsExpr.allDocNestedPath, "details");
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void prepare_when_manyMixed() throws Exception {
|
||||
|
||||
ExpressionList<Order> where = DB.find(Order.class)
|
||||
.where()
|
||||
.gt("customer.id", 1) // 0
|
||||
.isNotNull("shipments.shipTime") // shipments 0
|
||||
.isNotNull("status") // 1
|
||||
.gt("details.orderQty", 1) // details 0
|
||||
.isNotNull("orderDate") // 2
|
||||
.gt("details.unitPrice", 1) // details 1
|
||||
.query().where();
|
||||
|
||||
DefaultExpressionList<?> exp = (DefaultExpressionList<?>) where;
|
||||
PrepareDocNested.prepare(exp, getBeanDescriptor(Order.class));
|
||||
|
||||
List<SpiExpression> underlyingList = exp.getUnderlyingList();
|
||||
assertEquals(underlyingList.size(), 5);
|
||||
assertNull(exp.allDocNestedPath);
|
||||
|
||||
DefaultExpressionList<?> shipExpr = (DefaultExpressionList<?>) underlyingList.get(3);
|
||||
assertEquals(shipExpr.allDocNestedPath, "shipments");
|
||||
|
||||
DefaultExpressionList<?> detailsExpr = (DefaultExpressionList<?>) underlyingList.get(4);
|
||||
assertEquals(detailsExpr.allDocNestedPath, "details");
|
||||
}
|
||||
}
|
||||
-90
@@ -1,90 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static java.util.Arrays.asList;
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class RawExpressionBuilderTest {
|
||||
|
||||
@Test
|
||||
public void buildSingle_noop() {
|
||||
|
||||
RawExpression exp = RawExpressionBuilder.buildSingle("foo = ?", 42);
|
||||
assertThat(exp.sql).isEqualTo("foo = ?");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void buildSingle_noExpand() {
|
||||
|
||||
RawExpression exp = RawExpressionBuilder.buildSingle("foo = ?", asList(42, 43));
|
||||
assertThat(exp.sql).isEqualTo("foo = ?");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void buildSingle_expand() {
|
||||
|
||||
RawExpression exp = RawExpressionBuilder.buildSingle("foo in (?1)", asList(42, 43));
|
||||
assertThat(exp.sql).isEqualTo("foo in (?,?)");
|
||||
assertThat(exp.values).contains(42, 43);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void buildSingle_expand_more() {
|
||||
|
||||
RawExpression exp = RawExpressionBuilder.buildSingle("foo in (?1)", asList(42, 43, 44, 45));
|
||||
assertThat(exp.sql).isEqualTo("foo in (?,?,?,?)");
|
||||
assertThat(exp.values).contains(42, 43, 44, 45);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void buildSingle_expand_single() {
|
||||
|
||||
RawExpression exp = RawExpressionBuilder.buildSingle("foo in (?1)", asList(42));
|
||||
assertThat(exp.sql).isEqualTo("foo in (?)");
|
||||
assertThat(exp.values).contains(42);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void build_noop() {
|
||||
RawExpression exp = RawExpressionBuilder.build("foo = ?", asArray(42));
|
||||
assertThat(exp.sql).isEqualTo("foo = ?");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void build_noExpand() {
|
||||
|
||||
RawExpression exp = RawExpressionBuilder.buildSingle("foo = ? and bar = any(?)", asArray(44, asList(42, 43)));
|
||||
assertThat(exp.sql).isEqualTo("foo = ? and bar = any(?)");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void build_expand() {
|
||||
|
||||
RawExpression exp = RawExpressionBuilder.build("foo in (?) and bar in (?2)", asArray(44, asList(42, 43)));
|
||||
assertThat(exp.sql).isEqualTo("foo in (?) and bar in (?,?)");
|
||||
assertThat(exp.values).contains(44, 42, 43);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void build_expand2() {
|
||||
|
||||
RawExpression exp = RawExpressionBuilder.build("foo in (?) and bar in (?2) (?3)", asArray(44, asList(42, 43), asList(91, 92, 93)));
|
||||
assertThat(exp.sql).isEqualTo("foo in (?) and bar in (?,?) (?,?,?)");
|
||||
assertThat(exp.values).containsExactly(44, 42, 43, 91, 92, 93);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void build_expand3() {
|
||||
|
||||
RawExpression exp = RawExpressionBuilder.build("foo in (?) and bar in (?2) (?3) and ?", asArray(44, asList(42, 43), asList(91, 92, 93), 87));
|
||||
assertThat(exp.sql).isEqualTo("foo in (?) and bar in (?,?) (?,?,?) and ?");
|
||||
assertThat(exp.values).containsExactly(44, 42, 43, 91, 92, 93, 87);
|
||||
}
|
||||
|
||||
private Object[] asArray(Object... values) {
|
||||
return values;
|
||||
}
|
||||
}
|
||||
@@ -1,77 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import io.ebeaninternal.api.BindValuesKey;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class RawExpressionTest extends BaseExpressionTest {
|
||||
|
||||
private RawExpression exp(String sql, Object... values) {
|
||||
return new RawExpression(sql, values);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
same(exp("a", 10), exp("a", 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBindValues() {
|
||||
same(exp("a", 10), exp("a", 20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffSql() {
|
||||
different(exp("a", 10), exp("b", 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_same() {
|
||||
assertThat(exp("a", 10).isSameByBind(exp("a", 10))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffBindValues() {
|
||||
assertThat(exp("a", 10).isSameByBind(exp("a", 20))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_moreBindValues() {
|
||||
assertThat(exp("a", 10).isSameByBind(exp("a", 10, 20))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_lessBindValues() {
|
||||
assertThat(exp("a", 10, 20).isSameByBind(exp("a", 10))).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void queryBindHash_when_sameBindValues() {
|
||||
assert_queryBindHash_isSame(exp("a", 10), exp("a", 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void queryBindHash_when_diffBindValues() {
|
||||
assert_queryBindHash_isDifferent(exp("a", 10), exp("a", 20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void queryBindHash_when_diffBindValues2() {
|
||||
assert_queryBindHash_isDifferent(exp("a", 10), exp("a", 10, 11));
|
||||
}
|
||||
|
||||
public void assert_queryBindHash_isDifferent(RawExpression exp0, RawExpression exp1) {
|
||||
assertThat(bindKey(exp0)).isNotEqualTo(bindKey(exp1));
|
||||
}
|
||||
|
||||
public void assert_queryBindHash_isSame(RawExpression exp0, RawExpression exp1) {
|
||||
assertThat(bindKey(exp0)).isEqualTo(bindKey(exp1));
|
||||
}
|
||||
|
||||
private BindValuesKey bindKey(RawExpression query) {
|
||||
BindValuesKey bindValuesKey = new BindValuesKey();
|
||||
query.queryBindKey(bindValuesKey);
|
||||
return bindValuesKey;
|
||||
}
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import org.assertj.core.api.Assertions;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
|
||||
public class SameTest {
|
||||
|
||||
@Test
|
||||
public void sameByNull() throws Exception {
|
||||
|
||||
Assertions.assertThat(Same.sameByNull("a", "a")).isTrue();
|
||||
assertThat(Same.sameByNull("a", "b")).isTrue();
|
||||
assertThat(Same.sameByNull(null, null)).isTrue();
|
||||
assertThat(Same.sameByNull("a", null)).isFalse();
|
||||
assertThat(Same.sameByNull(null, "a")).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sameByValue() throws Exception {
|
||||
|
||||
assertThat(Same.sameByValue("a", "a")).isTrue();
|
||||
assertThat(Same.sameByValue("a", "b")).isFalse();
|
||||
assertThat(Same.sameByValue(null, null)).isTrue();
|
||||
assertThat(Same.sameByValue("a", null)).isFalse();
|
||||
assertThat(Same.sameByValue(null, "a")).isFalse();
|
||||
}
|
||||
}
|
||||
@@ -1,56 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class SimpleExpressionTest extends BaseExpressionTest {
|
||||
|
||||
private SimpleExpression exp(String propertyName, Op operator, Object value) {
|
||||
return new SimpleExpression(propertyName, operator, value);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_same() {
|
||||
|
||||
same(exp("a", Op.EQ, 10), exp("a", Op.EQ, 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffBind_same() {
|
||||
|
||||
same(exp("a", Op.EQ, 10), exp("a", Op.EQ, 20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffProperty_diff() {
|
||||
|
||||
different(exp("a", Op.EQ, 10), exp("b", Op.EQ, 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffOperator_diff() {
|
||||
|
||||
different(exp("a", Op.EQ, 10), exp("a", Op.LT, 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByPlan_when_diffType_diff() {
|
||||
|
||||
different(exp("a", Op.EQ, 10), new NoopExpression());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_sameBindValues() {
|
||||
|
||||
assertThat(exp("a", Op.EQ, 10).isSameByBind(exp("a", Op.LT, 10))).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSameByBind_when_diffBindValues() {
|
||||
|
||||
assertThat(exp("a", Op.EQ, 10).isSameByBind(exp("a", Op.EQ, "junk"))).isFalse();
|
||||
}
|
||||
|
||||
}
|
||||
-91
@@ -1,91 +0,0 @@
|
||||
package io.ebeaninternal.server.expression;
|
||||
|
||||
import io.ebeaninternal.api.SpiExpressionRequest;
|
||||
import io.ebeaninternal.server.core.SpiOrmQueryRequest;
|
||||
import io.ebeaninternal.server.deploy.BeanDescriptor;
|
||||
import io.ebeaninternal.server.expression.platform.DbExpressionHandler;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Test double for testing with SpiExpressionRequest.
|
||||
*/
|
||||
public class TDSpiExpressionRequest implements SpiExpressionRequest {
|
||||
|
||||
List<Object> bindValues = new ArrayList<>();
|
||||
|
||||
final BeanDescriptor<?> descriptor;
|
||||
|
||||
StringBuilder sql = new StringBuilder();
|
||||
|
||||
public TDSpiExpressionRequest(BeanDescriptor<?> descriptor) {
|
||||
this.descriptor = descriptor;
|
||||
}
|
||||
|
||||
@Override
|
||||
public DbExpressionHandler getDbPlatformHandler() {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String parseDeploy(String logicalProp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public BeanDescriptor<?> getBeanDescriptor() {
|
||||
return descriptor;
|
||||
}
|
||||
|
||||
@Override
|
||||
public SpiOrmQueryRequest<?> getQueryRequest() {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public SpiExpressionRequest append(String sqlExpression) {
|
||||
sql.append(sqlExpression);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addBindEncryptKey(Object encryptKey) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addBindValue(Object bindValue) {
|
||||
bindValues.add(bindValue);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getSql() {
|
||||
return sql.toString();
|
||||
}
|
||||
|
||||
@Override
|
||||
public ArrayList<Object> getBindValues() {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int nextParameter() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void appendLike(boolean rawLikeExpression) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public String escapeLikeString(String value) {
|
||||
return value;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void appendInExpression(boolean not, List<Object> bindValues) {
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,104 +0,0 @@
|
||||
package io.ebeaninternal.server.loadcontext;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.FetchConfig;
|
||||
import io.ebean.Query;
|
||||
import io.ebeaninternal.server.core.OrmQueryRequest;
|
||||
import io.ebeaninternal.server.core.OrmQueryRequestTestHelper;
|
||||
import io.ebeaninternal.server.deploy.BeanPropertyAssocMany;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Order;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class DLoadContextTest extends BaseTestCase {
|
||||
|
||||
private OrmQueryRequest<Order> queryRequest(Query<Order> query) {
|
||||
return OrmQueryRequestTestHelper.queryRequest(query);
|
||||
}
|
||||
|
||||
private Query<Order> query() {
|
||||
return server().find(Order.class);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void construct_when_defaults_expect_defaultLazyBatchSizeServerDefaults() {
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query());
|
||||
queryRequest.initTransIfRequired();
|
||||
queryRequest.endTransIfRequired();
|
||||
|
||||
DLoadContext graphContext = (DLoadContext) queryRequest.loadContext();
|
||||
DLoadBeanContext customer = graphContext.getBeanContext("customer");
|
||||
|
||||
assertThat(customer.batchSize).isEqualTo(10);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void construct_when_fetchQuery_expect_100_batchSize() {
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query().fetch("customer", FetchConfig.ofQuery()));
|
||||
queryRequest.initTransIfRequired();
|
||||
queryRequest.endTransIfRequired();
|
||||
|
||||
DLoadContext graphContext = (DLoadContext) queryRequest.loadContext();
|
||||
DLoadBeanContext customer = graphContext.getBeanContext("customer");
|
||||
|
||||
assertThat(customer.batchSize).isEqualTo(100);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void construct_when_fetchQuery_expect_100_batchSize_viaFetchQuery() {
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query().fetchQuery("customer"));
|
||||
queryRequest.initTransIfRequired();
|
||||
queryRequest.endTransIfRequired();
|
||||
|
||||
DLoadContext graphContext = (DLoadContext) queryRequest.loadContext();
|
||||
DLoadBeanContext customer = graphContext.getBeanContext("customer");
|
||||
|
||||
assertThat(customer.batchSize).isEqualTo(100);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void construct_when_fetchQuery50_expect_50_batchSize() {
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query().fetch("customer", FetchConfig.ofQuery(50)));
|
||||
queryRequest.initTransIfRequired();
|
||||
queryRequest.endTransIfRequired();
|
||||
|
||||
DLoadContext graphContext = (DLoadContext) queryRequest.loadContext();
|
||||
DLoadBeanContext customer = graphContext.getBeanContext("customer");
|
||||
|
||||
assertThat(customer.batchSize).isEqualTo(50);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void construct_when_fetchQueryFirst20Lazy5_expect_20_5_batchSize() {
|
||||
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query().fetchQuery("customer"));
|
||||
queryRequest.initTransIfRequired();
|
||||
queryRequest.endTransIfRequired();
|
||||
|
||||
DLoadContext graphContext = (DLoadContext) queryRequest.loadContext();
|
||||
DLoadBeanContext customer = graphContext.getBeanContext("customer");
|
||||
|
||||
assertThat(customer.batchSize).isEqualTo(100);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void construct_when_fetch_expect_100_100_batchSize() {
|
||||
|
||||
BeanPropertyAssocMany<?> many = (BeanPropertyAssocMany<?>)getBeanDescriptor(Order.class).beanProperty("details");
|
||||
// the fetch is converted to a query join due to the maxRows
|
||||
OrmQueryRequest<Order> queryRequest = queryRequest(query().fetch("details").setMaxRows(50));
|
||||
queryRequest.initTransIfRequired();
|
||||
queryRequest.endTransIfRequired();
|
||||
|
||||
DLoadContext graphContext = (DLoadContext) queryRequest.loadContext();
|
||||
DLoadManyContext details = graphContext.getManyContext("details", many);
|
||||
|
||||
assertThat(details.batchSize).isEqualTo(100);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,120 +0,0 @@
|
||||
package io.ebeaninternal.server.querydefn;
|
||||
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.CacheMode;
|
||||
import io.ebean.DB;
|
||||
import io.ebeaninternal.api.BindValuesKey;
|
||||
import io.ebeaninternal.api.SpiQuery;
|
||||
import io.ebeaninternal.server.core.OrmQueryRequest;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Customer;
|
||||
import org.tests.model.basic.Order;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class DefaultOrmQueryTest extends BaseTestCase {
|
||||
|
||||
@Test
|
||||
public void when_forUpdate_then_excludeFromBeanCache() {
|
||||
|
||||
DefaultOrmQuery<Customer> q1 = (DefaultOrmQuery<Customer>) DB.find(Customer.class)
|
||||
.forUpdate().where().eq("id", 42).query();
|
||||
|
||||
assertThat(q1.getUseBeanCache()).isSameAs(CacheMode.OFF);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void checkForId_when_eqId_then_translatedTo_setId() {
|
||||
|
||||
DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) DB.find(Order.class).where().eq("id", 42).query();
|
||||
assertThat(q1.getWhereExpressions()).isNotNull();
|
||||
assertThat(q1.getId()).isNull();
|
||||
|
||||
assertThat(q1.isFindById()).isTrue();
|
||||
|
||||
assertThat(q1.getId()).isEqualTo(42);
|
||||
assertThat(q1.getWhereExpressions()).isNull();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void checkForId_when_idEq_ok() {
|
||||
|
||||
DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) DB.find(Order.class).where().idEq(42).query();
|
||||
assertThat(q1.getId()).isEqualTo(42);
|
||||
assertThat(q1.isFindById()).isTrue();
|
||||
assertThat(q1.getId()).isEqualTo(42);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void checkForId_when_setId_ok() {
|
||||
|
||||
DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) DB.find(Order.class).setId(42);
|
||||
assertThat(q1.getId()).isEqualTo(42);
|
||||
assertThat(q1.isFindById()).isTrue();
|
||||
assertThat(q1.getId()).isEqualTo(42);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void when_addWhere_then_planChanges() {
|
||||
|
||||
DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) DB.find(Order.class).where().in("name", "a", "b", "c").query();
|
||||
DefaultOrmQuery<Order> q2 = (DefaultOrmQuery<Order>) DB.find(Order.class).where().in("id", 2, 2, 3).query();
|
||||
|
||||
prepare(q1, q2);
|
||||
assertThat(q1.createQueryPlanKey()).isNotEqualTo(q2.createQueryPlanKey());
|
||||
assertThat(bindKey(q1)).isNotEqualTo(bindKey(q2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void when_sameWhereWithDiffBindValues_then_planSame_bindDiff() {
|
||||
|
||||
DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) DB.find(Order.class).where().in("id", 1, 2, 3).query();
|
||||
DefaultOrmQuery<Order> q2 = (DefaultOrmQuery<Order>) DB.find(Order.class).where().in("id", 2, 2, 3).query();
|
||||
|
||||
prepare(q1, q2);
|
||||
assertThat(q1.createQueryPlanKey()).isEqualTo(q2.createQueryPlanKey());
|
||||
assertThat(bindKey(q1)).isNotEqualTo(bindKey(q2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void when_sameWhereAndBindValues_then_planSameAndBind() {
|
||||
|
||||
DefaultOrmQuery<Order> q1 = (DefaultOrmQuery<Order>) DB.find(Order.class).where().in("id", 1, 2, 3).query();
|
||||
DefaultOrmQuery<Order> q2 = (DefaultOrmQuery<Order>) DB.find(Order.class).where().in("id", 1, 2, 3).query();
|
||||
|
||||
prepare(q1, q2);
|
||||
assertThat(q1.createQueryPlanKey()).isEqualTo(q2.createQueryPlanKey());
|
||||
assertThat(bindKey(q1)).isEqualTo(bindKey(q2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void when_diffFirstMaxRows_then_differentPlan() {
|
||||
|
||||
DefaultOrmQuery<Order> query1 = (DefaultOrmQuery<Order>) DB.find(Order.class)
|
||||
.setFirstRow(0)
|
||||
.setMaxRows(31);
|
||||
|
||||
DefaultOrmQuery<Order> query2 = (DefaultOrmQuery<Order>) DB.find(Order.class)
|
||||
.setFirstRow(1)
|
||||
.setMaxRows(0);
|
||||
|
||||
prepare(query1, query2);
|
||||
assertThat(query1.createQueryPlanKey()).isNotEqualTo(query2.createQueryPlanKey());
|
||||
}
|
||||
|
||||
private <T> void prepare(DefaultOrmQuery<T> q1, DefaultOrmQuery<T> q2) {
|
||||
|
||||
OrmQueryRequest<T> r1 = createQueryRequest(SpiQuery.Type.LIST, q1, null);
|
||||
q1.prepare(r1);
|
||||
|
||||
OrmQueryRequest<T> r2 = createQueryRequest(SpiQuery.Type.LIST, q2, null);
|
||||
q2.prepare(r2);
|
||||
}
|
||||
|
||||
private BindValuesKey bindKey(DefaultOrmQuery<Order> query) {
|
||||
BindValuesKey key = new BindValuesKey();
|
||||
query.queryBindKey(key);
|
||||
return key;
|
||||
}
|
||||
}
|
||||
@@ -1,258 +0,0 @@
|
||||
package io.ebeaninternal.server.querydefn;
|
||||
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebeaninternal.server.deploy.BeanDescriptor;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Order;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
public class OrmQueryDetailTest extends BaseTestCase {
|
||||
|
||||
OrmQueryDetail parse(String query) {
|
||||
return new OrmQueryDetailParser(query).parse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isEmpty_when_empty() {
|
||||
|
||||
OrmQueryDetail detail = new OrmQueryDetail();
|
||||
assertThat(detail.isEmpty()).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isEmpty_when_hasFetch_expect_false() {
|
||||
|
||||
OrmQueryDetail detail = new OrmQueryDetail();
|
||||
detail.fetch("customer", null, null);
|
||||
assertThat(detail.isEmpty()).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isEmpty_when_hasSelect_expect_false() {
|
||||
|
||||
OrmQueryDetail detail = new OrmQueryDetail();
|
||||
detail.select("name");
|
||||
assertThat(detail.isEmpty()).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAutoTuneEqual_when_fetchOrderIsDifferent_then_stillEqual() {
|
||||
|
||||
OrmQueryDetail detail1 = parse("select (id,name) fetch customer (name) fetch details (code)");
|
||||
OrmQueryDetail detail2 = parse("select (id,name) fetch details (code) fetch customer (name)");
|
||||
|
||||
assertTrue(detail1.isAutoTuneEqual(detail2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAutoTuneEqual_when_different_select() {
|
||||
|
||||
OrmQueryDetail detail1 = parse("select (id,name) fetch customer (name) fetch details (code)");
|
||||
OrmQueryDetail detail2 = parse("select (id) fetch details (code) fetch customer (name)");
|
||||
|
||||
assertFalse(detail1.isAutoTuneEqual(detail2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAutoTuneEqual_when_different_selectInFetch() {
|
||||
|
||||
OrmQueryDetail detail1 = parse("select (id,name) fetch customer (name) fetch details (code)");
|
||||
OrmQueryDetail detail2 = parse("select (id,name) fetch customer (id,name) fetch details (code)");
|
||||
|
||||
assertFalse(detail1.isAutoTuneEqual(detail2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAutoTuneEqual_when_different_additionalFetch() {
|
||||
|
||||
OrmQueryDetail detail1 = parse("select (id,name) fetch customer (name) fetch details (code)");
|
||||
OrmQueryDetail detail2 = parse("select (id,name) fetch customer (name) fetch details (code) fetch customer.contacts");
|
||||
|
||||
assertFalse(detail1.isAutoTuneEqual(detail2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAutoTuneEqual_when_different_removedFetch() {
|
||||
|
||||
OrmQueryDetail detail1 = parse("select (id,name) fetch customer (name) fetch details (code) fetch customer.contacts");
|
||||
OrmQueryDetail detail2 = parse("select (id,name) fetch customer (name) fetch details (code)");
|
||||
|
||||
assertFalse(detail1.isAutoTuneEqual(detail2));
|
||||
assertFalse(detail2.isAutoTuneEqual(detail1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAutoTuneEqual_when_different_removedFetchProperty() {
|
||||
|
||||
OrmQueryDetail detail1 = parse("select (id,name) fetch customer (name)");
|
||||
OrmQueryDetail detail2 = parse("select (id,name) fetch customer ");
|
||||
|
||||
assertFalse(detail1.isAutoTuneEqual(detail2));
|
||||
assertFalse(detail2.isAutoTuneEqual(detail1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAutoTuneEqual_when_different_path() {
|
||||
|
||||
OrmQueryDetail detail1 = parse("select (id,name) fetch customer (name)");
|
||||
OrmQueryDetail detail2 = parse("select (id,name) fetch details (id) ");
|
||||
|
||||
assertFalse(detail1.isAutoTuneEqual(detail2));
|
||||
assertFalse(detail2.isAutoTuneEqual(detail1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void select_whenMultiple() throws Exception {
|
||||
|
||||
OrmQueryDetail other = new OrmQueryDetail();
|
||||
other.select("id,name");
|
||||
|
||||
OrmQueryProperties root = other.getChunk(null, false);
|
||||
assertNull(root.getPath());
|
||||
assertThat(root.getIncluded()).containsExactly("id", "name");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void select_whenOne() throws Exception {
|
||||
|
||||
OrmQueryDetail other = new OrmQueryDetail();
|
||||
other.select("name");
|
||||
|
||||
OrmQueryProperties root = other.getChunk(null, false);
|
||||
assertNull(root.getPath());
|
||||
assertThat(root.getIncluded()).containsExactly("name");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getFetchPaths_when_noFetches_then_expect_empty() {
|
||||
|
||||
assertThat(new OrmQueryDetail().getFetchPaths()).isEmpty();
|
||||
|
||||
OrmQueryDetail detail = new OrmQueryDetail();
|
||||
detail.select("foo");
|
||||
|
||||
assertThat(detail.getFetchPaths()).isEmpty();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getFetchPaths_when_oneFetch() {
|
||||
|
||||
OrmQueryDetail detail = new OrmQueryDetail();
|
||||
detail.select("foo");
|
||||
detail.fetch("customer", null, null);
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("customer");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getFetchPaths_when_multipleFetch_expect_preserveOrder() {
|
||||
|
||||
OrmQueryDetail detail = new OrmQueryDetail();
|
||||
detail.select("foo");
|
||||
detail.fetch("customer", null, null);
|
||||
detail.fetch("details", null, null);
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("customer", "details");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getFetchPaths_when_multipleFetch_expect_preserveOrder_v2() {
|
||||
|
||||
OrmQueryDetail detail = new OrmQueryDetail();
|
||||
detail.select("foo");
|
||||
detail.fetch("details", null, null);
|
||||
detail.fetch("customer", null, null);
|
||||
detail.fetch("details.product", null, null);
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("details", "customer", "details.product");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void markQueryJoins_when_allowOne_expect_stillFetchJoin() {
|
||||
|
||||
OrmQueryDetail detail = new OrmQueryDetail();
|
||||
detail.fetch("details", null, null);
|
||||
|
||||
detail.markQueryJoins(orderDesc(), null, true, true);
|
||||
|
||||
assertThat(detail.getChunk("details", false).isQueryFetch()).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void markQueryJoins_when_allowNone_expect_queryJoin() {
|
||||
|
||||
OrmQueryDetail detail = new OrmQueryDetail();
|
||||
detail.fetch("details", null, null);
|
||||
|
||||
detail.markQueryJoins(orderDesc(), null, false, true);
|
||||
|
||||
assertThat(detail.getChunk("details", false).isQueryFetch()).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void markQueryJoins_when_allowOneButSecond_expect_queryJoin() {
|
||||
|
||||
OrmQueryDetail detail = new OrmQueryDetail();
|
||||
detail.fetch("details", null, null);
|
||||
detail.fetch("customer.contacts", null, null);
|
||||
|
||||
detail.markQueryJoins(orderDesc(), null, true, true);
|
||||
|
||||
assertThat(detail.getChunk("details", false).isQueryFetch()).isFalse();
|
||||
assertThat(detail.getChunk("customer.contacts", false).isQueryFetch()).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void markQueryJoins_when_allowNone_expect_bothQueryJoin() {
|
||||
|
||||
OrmQueryDetail detail = new OrmQueryDetail();
|
||||
detail.fetch("details", null, null);
|
||||
detail.fetch("customer.contacts", null, null);
|
||||
|
||||
detail.markQueryJoins(orderDesc(), null, false, true);
|
||||
|
||||
assertThat(detail.getChunk("details", false).isQueryFetch()).isTrue();
|
||||
assertThat(detail.getChunk("customer.contacts", false).isQueryFetch()).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sortFetchPaths_when_missingParent_expect_addsMissing() {
|
||||
|
||||
OrmQueryDetail detail = new OrmQueryDetail();
|
||||
detail.fetch("customer.contacts", null, null);
|
||||
|
||||
detail.sortFetchPaths(orderDesc());
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("customer", "customer.contacts");
|
||||
assertThat(detail.getChunk("customer", false).getIncluded()).containsExactly("id");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sortFetchPaths_when_outOfOrder_expect_correctOrder() {
|
||||
|
||||
OrmQueryDetail detail = new OrmQueryDetail();
|
||||
detail.fetch("customer.contacts", "email", null);
|
||||
detail.fetch("customer", "name", null);
|
||||
|
||||
detail.sortFetchPaths(orderDesc());
|
||||
|
||||
assertThat(detail.getFetchPaths()).containsExactly("customer", "customer.contacts");
|
||||
assertThat(detail.getChunk("customer", false).getIncluded()).containsExactly("name");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sortFetchPaths_when_empty_expect_stillEmpty() {
|
||||
|
||||
OrmQueryDetail detail = new OrmQueryDetail();
|
||||
detail.sortFetchPaths(orderDesc());
|
||||
|
||||
assertThat(detail.getFetchPaths()).isEmpty();
|
||||
}
|
||||
|
||||
BeanDescriptor<Order> orderDesc() {
|
||||
return getBeanDescriptor(Order.class);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,350 +0,0 @@
|
||||
package io.ebeaninternal.server.querydefn;
|
||||
|
||||
|
||||
import io.ebean.ExpressionList;
|
||||
import io.ebean.Query;
|
||||
import io.ebeaninternal.api.CQueryPlanKey;
|
||||
import io.ebeaninternal.api.SpiQuery;
|
||||
import io.ebeaninternal.server.deploy.TableJoin;
|
||||
import io.ebeaninternal.server.deploy.meta.DeployTableJoin;
|
||||
import io.ebeaninternal.server.deploy.meta.DeployTableJoinColumn;
|
||||
import io.ebeaninternal.server.expression.BaseExpressionTest;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.Customer;
|
||||
|
||||
import java.sql.Timestamp;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class OrmQueryPlanKeyTest extends BaseExpressionTest {
|
||||
|
||||
@SuppressWarnings({"unchecked", "rawtypes"})
|
||||
private DefaultOrmQuery<Customer> query() {
|
||||
return (DefaultOrmQuery) server().find(Customer.class);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_defaults() {
|
||||
|
||||
assertSame(query().createQueryPlanKey(), query().createQueryPlanKey());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_diffTableJoinNull() {
|
||||
|
||||
DefaultOrmQuery<Customer> q1 = query();
|
||||
q1.setM2MIncludeJoin(tableJoin("table", "id", "customer_id"));
|
||||
|
||||
assertDifferent(q1, query());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_diffTableJoin() {
|
||||
|
||||
DefaultOrmQuery<Customer> q1 = query();
|
||||
q1.setM2MIncludeJoin(tableJoin("one", "cid", "customer_id"));
|
||||
|
||||
DefaultOrmQuery<Customer> q2 = query();
|
||||
q2.setM2MIncludeJoin(tableJoin("two", "cid", "customer_id"));
|
||||
|
||||
assertDifferent(q1, q2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_sameTableJoin() {
|
||||
|
||||
DefaultOrmQuery<Customer> q1 = query();
|
||||
q1.setM2MIncludeJoin(tableJoin("one", "id", "cust_id"));
|
||||
|
||||
DefaultOrmQuery<Customer> q2 = query();
|
||||
q2.setM2MIncludeJoin(tableJoin("one", "id", "cust_id"));
|
||||
|
||||
assertSame(q1, q2);
|
||||
}
|
||||
|
||||
private TableJoin tableJoin(String table, String col1, String col2) {
|
||||
DeployTableJoin deploy = new DeployTableJoin();
|
||||
deploy.setTable(table);
|
||||
deploy.addJoinColumn(new DeployTableJoinColumn(col1, col2));
|
||||
return new TableJoin(deploy);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_diffQueryType() {
|
||||
|
||||
DefaultOrmQuery<Customer> q1 = query();
|
||||
q1.setType(SpiQuery.Type.BEAN);
|
||||
|
||||
DefaultOrmQuery<Customer> q2 = query();
|
||||
q2.setType(SpiQuery.Type.LIST);
|
||||
|
||||
assertDifferent(q1, q2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_firstRowsDifferent() {
|
||||
|
||||
CQueryPlanKey key1 = planKey(query().setFirstRow(10));
|
||||
CQueryPlanKey key2 = planKey(query());
|
||||
assertDifferent(key1, key2);
|
||||
|
||||
key1 = planKey(query().setFirstRow(10));
|
||||
key2 = planKey(query().setFirstRow(9));
|
||||
assertDifferent(key1, key2);
|
||||
|
||||
key1 = planKey(query());
|
||||
key2 = planKey(query().setFirstRow(9));
|
||||
assertDifferent(key1, key2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_maxRowsDifferent() {
|
||||
|
||||
CQueryPlanKey key1 = planKey(query().setMaxRows(10));
|
||||
CQueryPlanKey key2 = planKey(query());
|
||||
assertDifferent(key1, key2);
|
||||
|
||||
key1 = planKey(query().setMaxRows(10));
|
||||
key2 = planKey(query().setMaxRows(9));
|
||||
assertDifferent(key1, key2);
|
||||
|
||||
key1 = planKey(query());
|
||||
key2 = planKey(query().setMaxRows(9));
|
||||
assertDifferent(key1, key2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_firstRowsMaxRowsSame() {
|
||||
|
||||
CQueryPlanKey key1 = planKey(query().setMaxRows(10).setFirstRow(20));
|
||||
CQueryPlanKey key2 = planKey(query().setFirstRow(20).setMaxRows(10));
|
||||
assertSame(key1, key2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_diffDisableLazyLoading() {
|
||||
|
||||
assertDifferent(query().setDisableLazyLoading(true), query());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_diffOrderByNull() {
|
||||
|
||||
CQueryPlanKey key1 = planKey(query().order("id"));
|
||||
CQueryPlanKey key2 = planKey(query());
|
||||
assertDifferent(key1, key2);
|
||||
|
||||
key1 = planKey(query().order().asc("id"));
|
||||
key2 = planKey(query());
|
||||
assertDifferent(key1, key2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_orderBySame() {
|
||||
|
||||
CQueryPlanKey key1 = planKey(query().order("id, name"));
|
||||
CQueryPlanKey key2 = planKey(query().order("id, name"));
|
||||
assertSame(key1, key2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_diffDistinct() {
|
||||
|
||||
CQueryPlanKey key1 = planKey(query().setDistinct(true));
|
||||
CQueryPlanKey key2 = planKey(query());
|
||||
assertDifferent(key1, key2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_sameDistinct() {
|
||||
|
||||
CQueryPlanKey key1 = planKey(query().setDistinct(true));
|
||||
CQueryPlanKey key2 = planKey(query().setDistinct(true));
|
||||
assertSame(key1, key2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_useDocStore() {
|
||||
CQueryPlanKey key1 = planKey(query().setUseDocStore(true));
|
||||
CQueryPlanKey key2 = planKey(query());
|
||||
|
||||
assertDifferent(key1, key2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_diffMapKey() {
|
||||
|
||||
CQueryPlanKey key1 = planKey(query().setMapKey("name"));
|
||||
CQueryPlanKey key2 = planKey(query());
|
||||
assertDifferent(key1, key2);
|
||||
|
||||
CQueryPlanKey key3 = planKey(query().setMapKey("email"));
|
||||
assertDifferent(key1, key3);
|
||||
|
||||
CQueryPlanKey key4 = planKey(query().setMapKey("name"));
|
||||
assertSame(key1, key4);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_diffIdNull() {
|
||||
|
||||
CQueryPlanKey key1 = planKey(query().setId(42));
|
||||
CQueryPlanKey key2 = planKey(query());
|
||||
assertDifferent(key1, key2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_idBothGiven() {
|
||||
|
||||
CQueryPlanKey key1 = planKey(query().setId(42));
|
||||
CQueryPlanKey key2 = planKey(query().setId(23));
|
||||
assertSame(key1, key2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_diffTemporalMode() {
|
||||
|
||||
CQueryPlanKey key1 = planKey(query());
|
||||
CQueryPlanKey key2 = planKey(query().asDraft());
|
||||
assertDifferent(key1, key2);
|
||||
|
||||
CQueryPlanKey key3 = planKey(query().asOf(new Timestamp(System.currentTimeMillis())));
|
||||
assertDifferent(key1, key3);
|
||||
|
||||
CQueryPlanKey key4 = planKey(query().setIncludeSoftDeletes());
|
||||
assertDifferent(key1, key4);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_diffForUpdate() {
|
||||
|
||||
CQueryPlanKey key1 = planKey(query().forUpdate());
|
||||
CQueryPlanKey key2 = planKey(query());
|
||||
assertDifferent(key1, key2);
|
||||
|
||||
CQueryPlanKey key3 = planKey(query().forUpdateNoWait());
|
||||
assertDifferent(key1, key3);
|
||||
|
||||
CQueryPlanKey key4 = planKey(query().forUpdateSkipLocked());
|
||||
assertDifferent(key1, key4);
|
||||
|
||||
CQueryPlanKey key5 = planKey(query().forUpdate());
|
||||
assertSame(key1, key5);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_diffRootAliasNull() {
|
||||
|
||||
CQueryPlanKey key1 = planKey(query().alias("alias"));
|
||||
CQueryPlanKey key2 = planKey(query());
|
||||
assertDifferent(key1, key2);
|
||||
|
||||
CQueryPlanKey key3 = planKey(query().alias("diff"));
|
||||
assertDifferent(key1, key3);
|
||||
|
||||
CQueryPlanKey key4 = planKey(query().alias("alias"));
|
||||
assertSame(key1, key4);
|
||||
}
|
||||
|
||||
private DefaultOrmQuery<Customer> list_id_eq_42() {
|
||||
return (DefaultOrmQuery<Customer>) server().find(Customer.class)
|
||||
.where().eq("id", 42).query();
|
||||
}
|
||||
|
||||
private DefaultOrmQuery<Customer> list_id_eq_43() {
|
||||
return (DefaultOrmQuery<Customer>) server().find(Customer.class)
|
||||
.where().eq("id", 43).query();
|
||||
}
|
||||
|
||||
private DefaultOrmQuery<Customer> list_id_eq_42_and_name_eq_rob() {
|
||||
return (DefaultOrmQuery<Customer>) server().find(Customer.class)
|
||||
.where().eq("id", 43).eq("name", "rob").query();
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void equals_when_sameWhere() {
|
||||
|
||||
assertSame(list_id_eq_42(), list_id_eq_43());
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void equals_when_diffWhere() {
|
||||
|
||||
assertDifferent(list_id_eq_42(), list_id_eq_42_and_name_eq_rob());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_diffWhereNullLast() {
|
||||
|
||||
assertDifferent(list_id_eq_42(), query());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_diffHaving() {
|
||||
|
||||
CQueryPlanKey key1 = planKey(query().having().eq("id", 42));
|
||||
CQueryPlanKey key2 = planKey(query().having().eq("id", 42).eq("name", "Rob"));
|
||||
assertDifferent(key1, key2);
|
||||
|
||||
CQueryPlanKey key3 = planKey(query().where().eq("id", 42));
|
||||
assertDifferent(key1, key3);
|
||||
|
||||
CQueryPlanKey key4 = planKey(query().having().eq("name", "Rob"));
|
||||
assertDifferent(key1, key4);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_sameHaving() {
|
||||
|
||||
CQueryPlanKey key1 = planKey(query().having().eq("id", 42));
|
||||
CQueryPlanKey key2 = planKey(query().having().eq("id", 43));
|
||||
assertSame(key1, key2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_manualId_andSelectClause() {
|
||||
DefaultOrmQuery<Customer> q1 = (DefaultOrmQuery<Customer>)query().select("name");
|
||||
q1.setManualId();
|
||||
|
||||
assertDifferent(q1, query().select("name"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equals_when_manualId_andNoSelectClause() {
|
||||
DefaultOrmQuery<Customer> q1 = query();
|
||||
q1.setManualId();
|
||||
|
||||
assertSame(q1, query());
|
||||
}
|
||||
|
||||
private CQueryPlanKey planKey(ExpressionList<Customer> id) {
|
||||
return planKey(id.query());
|
||||
}
|
||||
|
||||
@SuppressWarnings({"rawtypes"})
|
||||
private CQueryPlanKey planKey(Query<Customer> query) {
|
||||
return ((DefaultOrmQuery) query).createQueryPlanKey();
|
||||
}
|
||||
|
||||
@SuppressWarnings({"unchecked", "rawtypes"})
|
||||
private void assertDifferent(Query q1, Query q2) {
|
||||
assertDifferent(planKey(q1), planKey(q2));
|
||||
}
|
||||
|
||||
@SuppressWarnings({"unchecked", "rawtypes"})
|
||||
private void assertSame(Query q1, Query q2) {
|
||||
assertSame(planKey(q1), planKey(q2));
|
||||
}
|
||||
|
||||
private void assertDifferent(CQueryPlanKey key1, CQueryPlanKey key2) {
|
||||
assertThat(key1).isNotEqualTo(key2);
|
||||
assertThat(key1.hashCode()).isNotEqualTo(key2.hashCode());
|
||||
}
|
||||
|
||||
private void assertSame(CQueryPlanKey key1, CQueryPlanKey key2) {
|
||||
assertThat(key1).isEqualTo(key2);
|
||||
assertThat(key1.hashCode()).isEqualTo(key2.hashCode());
|
||||
}
|
||||
}
|
||||
-93
@@ -1,93 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebean.core.type.ScalarType;
|
||||
import org.postgresql.util.PGobject;
|
||||
|
||||
import java.sql.SQLException;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
class BasePlatformArrayTypeFactoryTest {
|
||||
|
||||
void assertBindNullTo_Null(ScalarType<?> type) throws SQLException {
|
||||
|
||||
TestDoubleDataBind bind = new TestDoubleDataBind();
|
||||
type.bind(bind, null);
|
||||
assertTrue(bind.wasSetNull);
|
||||
}
|
||||
|
||||
void assertBindNullTo_EmptyArray(ScalarType<?> type) throws SQLException {
|
||||
|
||||
TestDoubleDataBind bind = new TestDoubleDataBind();
|
||||
type.bind(bind, null);
|
||||
|
||||
assertTrue(bind.wasEmptyArray);
|
||||
}
|
||||
|
||||
void assertBindNullTo_EmptyString(ScalarType<?> type) throws SQLException {
|
||||
|
||||
TestDoubleDataBind bind = new TestDoubleDataBind();
|
||||
type.bind(bind, null);
|
||||
assertTrue(bind.setEmptyString);
|
||||
}
|
||||
|
||||
void assertBindNullTo_PGObjectNull(ScalarType<?> type) throws SQLException {
|
||||
|
||||
TestDoubleDataBind bind = new TestDoubleDataBind();
|
||||
type.bind(bind, null);
|
||||
assertTrue(bind.wasPgoNull);
|
||||
}
|
||||
void assertBindNullTo_PGObjectEmpty(ScalarType<?> type) throws SQLException {
|
||||
|
||||
TestDoubleDataBind bind = new TestDoubleDataBind();
|
||||
type.bind(bind, null);
|
||||
assertTrue(bind.wasPgoEmpty);
|
||||
}
|
||||
|
||||
static class TestDoubleDataBind extends DataBind {
|
||||
|
||||
boolean setEmptyString;
|
||||
boolean wasSetNull;
|
||||
boolean setArray;
|
||||
boolean wasNull;
|
||||
boolean wasEmptyArray;
|
||||
boolean wasPgoNull;
|
||||
boolean wasPgoEmpty;
|
||||
|
||||
TestDoubleDataBind() {
|
||||
super(null, null, null);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setNull(int jdbcType) {
|
||||
wasSetNull = true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setString(String s) {
|
||||
setEmptyString = "[]".equals(s);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setObject(Object value) {
|
||||
wasNull = value == null;
|
||||
if (!wasNull) {
|
||||
if (value instanceof Object[]) {
|
||||
wasEmptyArray = ((Object[]) value).length == 0;
|
||||
} else {
|
||||
PGobject pgo = (PGobject) value;
|
||||
wasPgoEmpty = "[]".equals(pgo.getValue());
|
||||
wasPgoNull = pgo.getValue() == null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setArray(String arrayType, Object[] elements) {
|
||||
setArray = true;
|
||||
wasNull = elements == null;
|
||||
wasEmptyArray = (elements != null && elements.length == 0);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.net.InetAddress;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
public class ConvertInetAddressTest {
|
||||
|
||||
@Test
|
||||
public void forString() {
|
||||
|
||||
InetAddress addr = ConvertInetAddresses.forString("128.1.10.23");
|
||||
assertEquals("128.1.10.23", addr.getHostAddress());
|
||||
|
||||
String ip6addr = "2001:db8:85a3:0:0:8a2e:370:7334";
|
||||
InetAddress addr6 = ConvertInetAddresses.forString(ip6addr);
|
||||
String uriAddr6 = ConvertInetAddresses.toUriString(addr6);
|
||||
assertEquals("[" + ip6addr + "]", uriAddr6);
|
||||
assertEquals(ip6addr, addr6.getHostAddress());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void ipv6_fromHost_getHostAddress() {
|
||||
InetAddress addr2 = ConvertInetAddresses.fromHost("2001:4f8:3:ba:2e0:81ff:fe22:d1f1");
|
||||
assertEquals("2001:4f8:3:ba:2e0:81ff:fe22:d1f1", addr2.getHostAddress());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void ipv6_fromHost_getHostAddress_2() {
|
||||
InetAddress addr2 = ConvertInetAddresses.fromHost("2001:db8:85a3:0:0:8a2e:370:7334");
|
||||
assertEquals("2001:db8:85a3:0:0:8a2e:370:7334", addr2.getHostAddress());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void toUriString() {
|
||||
|
||||
InetAddress addr = ConvertInetAddresses.forString("128.1.10.23");
|
||||
assertEquals("128.1.10.23", addr.getHostAddress());
|
||||
|
||||
String uriAddr = ConvertInetAddresses.toUriString(addr);
|
||||
assertEquals("128.1.10.23", uriAddr);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.net.InetAddress;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
public class ConvertInetAddressesTest {
|
||||
|
||||
@Test
|
||||
public void testForString() throws Exception {
|
||||
|
||||
InetAddress loopbackAddress = InetAddress.getLoopbackAddress();
|
||||
|
||||
String uri = ConvertInetAddresses.toUriString(loopbackAddress);
|
||||
InetAddress inetAddress = ConvertInetAddresses.forString(uri);
|
||||
|
||||
assertEquals(loopbackAddress, inetAddress);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsInetAddress() throws Exception {
|
||||
|
||||
assertTrue(ConvertInetAddresses.isInetAddress("127.0.0.1"));
|
||||
|
||||
assertFalse(ConvertInetAddresses.isInetAddress("junk"));
|
||||
assertFalse(ConvertInetAddresses.isInetAddress("127.0.0.junk"));
|
||||
assertFalse(ConvertInetAddresses.isInetAddress("junk.0.0.23"));
|
||||
assertFalse(ConvertInetAddresses.isInetAddress(""));
|
||||
assertFalse(ConvertInetAddresses.isInetAddress("127.0.0"));
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToUriString() throws Exception {
|
||||
|
||||
InetAddress loopbackAddress = InetAddress.getLoopbackAddress();
|
||||
|
||||
String uri = ConvertInetAddresses.toUriString(loopbackAddress);
|
||||
InetAddress inetAddress = ConvertInetAddresses.forUriString(uri);
|
||||
|
||||
assertEquals(loopbackAddress, inetAddress);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,733 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import static java.lang.String.format;
|
||||
|
||||
import java.sql.Date;
|
||||
import java.sql.Timestamp;
|
||||
import java.time.Instant;
|
||||
import java.time.LocalDate;
|
||||
import java.time.LocalDateTime;
|
||||
import java.time.LocalTime;
|
||||
import java.time.MonthDay;
|
||||
import java.time.OffsetDateTime;
|
||||
import java.time.Year;
|
||||
import java.time.YearMonth;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.util.Calendar;
|
||||
import java.util.List;
|
||||
import java.util.TimeZone;
|
||||
|
||||
|
||||
import org.assertj.core.api.SoftAssertions;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.junit.jupiter.api.AfterAll;
|
||||
import org.junit.jupiter.api.AfterEach;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Disabled;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.TestInstance;
|
||||
import org.junit.jupiter.api.TestInstance.Lifecycle;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
import org.tests.model.basic.MDateTime;
|
||||
|
||||
import io.ebean.DB;
|
||||
import io.ebean.Database;
|
||||
import io.ebean.DatabaseFactory;
|
||||
import io.ebean.annotation.Platform;
|
||||
import io.ebean.config.DatabaseConfig;
|
||||
import io.ebean.core.type.ScalarType;
|
||||
import io.ebean.plugin.ExpressionPath;
|
||||
import io.ebean.plugin.Property;
|
||||
import io.ebean.text.PathProperties;
|
||||
import io.ebean.text.json.JsonWriteOptions;
|
||||
import io.ebean.util.CamelCaseHelper;
|
||||
import io.ebean.xtest.BaseTestCase;
|
||||
import io.ebean.xtest.IgnorePlatform;
|
||||
import io.ebean.xtest.base.PlatformCondition;
|
||||
import io.ebeaninternal.server.deploy.BeanProperty;
|
||||
|
||||
@TestInstance(Lifecycle.PER_CLASS)
|
||||
@ExtendWith(PlatformCondition.class)
|
||||
@Disabled("Does not work @github")
|
||||
public class DatesAndTimesTest extends BaseTestCase {
|
||||
|
||||
private Database db;
|
||||
private TimeZone tz;
|
||||
private DatabaseConfig config;
|
||||
private SoftAssertions softly;
|
||||
|
||||
private String json;
|
||||
private String formatted;
|
||||
private long millis;
|
||||
|
||||
@BeforeEach
|
||||
public void startTest() {
|
||||
softly = new SoftAssertions();
|
||||
tz = TimeZone.getDefault();
|
||||
if (db == null) {
|
||||
db = createServer("GMT"); // test uses GMT database
|
||||
} else {
|
||||
restartServer(null, "GMT");
|
||||
}
|
||||
json = null;
|
||||
formatted = null;
|
||||
millis = 0;
|
||||
}
|
||||
|
||||
@AfterEach
|
||||
public void stopTest() {
|
||||
setJavaTimeZone(tz);
|
||||
softly.assertAll();
|
||||
}
|
||||
|
||||
@AfterAll
|
||||
public void shutdown() {
|
||||
if (db != null) {
|
||||
db.find(MDateTime.class).delete();
|
||||
db.shutdown(false, false);
|
||||
}
|
||||
}
|
||||
|
||||
private void restartServer(String javaTimeZone, String dbTimeZone) {
|
||||
db.shutdown(false, false);
|
||||
if (javaTimeZone != null) {
|
||||
setJavaTimeZone(TimeZone.getTimeZone(javaTimeZone));
|
||||
}
|
||||
db = createServer(dbTimeZone);
|
||||
}
|
||||
|
||||
private void setJavaTimeZone(TimeZone newTz) {
|
||||
TimeZone.setDefault(newTz);
|
||||
DateTimeZone.setDefault(DateTimeZone.forTimeZone(newTz));
|
||||
org.h2.util.DateTimeUtils.resetCalendar();
|
||||
}
|
||||
|
||||
private Database createServer(String dbTimeZone) {
|
||||
|
||||
// we create a clone for the current default server
|
||||
config = new DatabaseConfig();
|
||||
config.setName(DB.getDefault().name());
|
||||
config.loadFromProperties();
|
||||
config.setDataSource(DB.getDefault().dataSource());
|
||||
config.setReadOnlyDataSource(DB.getDefault().readOnlyDataSource());
|
||||
config.setDdlExtra(false);
|
||||
config.setDdlGenerate(false);
|
||||
config.setDdlRun(false);
|
||||
config.setDefaultServer(false);
|
||||
config.setRegister(false);
|
||||
config.setChangeLogAsync(false);
|
||||
config.addClass(MDateTime.class);
|
||||
|
||||
config.setDumpMetricsOnShutdown(false);
|
||||
config.setDataTimeZone(dbTimeZone);
|
||||
reconfigure(config);
|
||||
|
||||
return DatabaseFactory.create(config);
|
||||
}
|
||||
|
||||
protected void reconfigure(DatabaseConfig config) {
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLocalTime() {
|
||||
if (config.isLocalTimeWithNanos()) {
|
||||
LocalTime lt = LocalTime.of(5, 15, 15,123456789);
|
||||
doTest("localTime", lt, String.valueOf(lt.toNanoOfDay()));
|
||||
softly.assertThat(json).isEqualTo("{\"localTime\":\"05:15:15.123456789\"}");
|
||||
softly.assertThat(formatted).isEqualTo("05:15:15.123456789");
|
||||
return;
|
||||
}
|
||||
// localTimes are never converted, when read or written to database
|
||||
doTest("localTime", LocalTime.of(5, 15, 15), "05:15:15");
|
||||
softly.assertThat(json).isEqualTo("{\"localTime\":\"05:15:15\"}");
|
||||
softly.assertThat(formatted).isEqualTo("05:15:15");
|
||||
|
||||
doTest("localTime", LocalTime.of(0, 0, 0), "00:00:00");
|
||||
doTest("localTime", LocalTime.of(23, 59, 59), "23:59:59");
|
||||
|
||||
// it does not matter in which timezone the server or java is!
|
||||
if (!isH2()) {
|
||||
restartServer("PST", "Europe/Berlin");
|
||||
doTest("localTime", LocalTime.of(5, 15, 15), "05:15:15");
|
||||
doTest("localTime", LocalTime.of(0, 0, 0), "00:00:00");
|
||||
doTest("localTime", LocalTime.of(23, 59, 59), "23:59:59");
|
||||
|
||||
restartServer("Europe/Berlin", "PST");
|
||||
doTest("localTime", LocalTime.of(5, 15, 15), "05:15:15");
|
||||
doTest("localTime", LocalTime.of(0, 0, 0), "00:00:00");
|
||||
doTest("localTime", LocalTime.of(23, 59, 59), "23:59:59");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJodaLocalTime() {
|
||||
// localTimes are never converted, when read or written to database
|
||||
doTest("jodaLocalTime", org.joda.time.LocalTime.parse("05:15:15"), "05:15:15");
|
||||
softly.assertThat(json).isEqualTo("{\"jodaLocalTime\":\"05:15:15.000\"}");
|
||||
softly.assertThat(formatted).isEqualTo("05:15:15.000");
|
||||
|
||||
doTest("jodaLocalTime", org.joda.time.LocalTime.parse("00:00:00"), "00:00:00");
|
||||
doTest("jodaLocalTime", org.joda.time.LocalTime.parse("23:59:59"), "23:59:59");
|
||||
|
||||
// it does not matter in which timezone the server or java is!
|
||||
if (!isH2()) {
|
||||
restartServer("PST", "Europe/Berlin");
|
||||
doTest("jodaLocalTime", org.joda.time.LocalTime.parse("05:15:15"), "05:15:15");
|
||||
doTest("jodaLocalTime", org.joda.time.LocalTime.parse("00:00:00"), "00:00:00");
|
||||
doTest("jodaLocalTime", org.joda.time.LocalTime.parse("23:59:59"), "23:59:59");
|
||||
|
||||
restartServer("Europe/Berlin", "PST");
|
||||
doTest("jodaLocalTime", org.joda.time.LocalTime.parse("05:15:15"), "05:15:15");
|
||||
doTest("jodaLocalTime", org.joda.time.LocalTime.parse("00:00:00"), "00:00:00");
|
||||
doTest("jodaLocalTime", org.joda.time.LocalTime.parse("23:59:59"), "23:59:59");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLocalDate() {
|
||||
|
||||
// Test with DST and no DST date (in germany)
|
||||
doTest("localDate", LocalDate.parse("2021-11-21"), "2021-11-21");
|
||||
softly.assertThat(formatted).isEqualTo(String.valueOf(1637452800000L - 3_600_000L));
|
||||
softly.assertThat(millis).isEqualTo(1637452800000L); // 00:00 in GMT
|
||||
|
||||
if (config.getJsonDate() == io.ebean.config.JsonConfig.Date.ISO8601) {
|
||||
softly.assertThat(json).isEqualTo("{\"localDate\":\"2021-11-21\"}");
|
||||
} else {
|
||||
softly.assertThat(json).isEqualTo("{\"localDate\":1637452800000}"); // 21-nov 00:00 GMT
|
||||
}
|
||||
|
||||
doTest("localDate", LocalDate.parse("1970-01-01"), "1970-01-01");
|
||||
// softly.assertThat(formatted).isEqualTo("0");
|
||||
softly.assertThat(formatted).isEqualTo("-3600000");
|
||||
softly.assertThat(millis).isEqualTo(0L);
|
||||
|
||||
doTest("localDate", LocalDate.parse("1969-12-31"), "1969-12-31");
|
||||
softly.assertThat(formatted).isEqualTo("-90000000");
|
||||
softly.assertThat(millis).isEqualTo(-86400000L);
|
||||
if (config.getJsonDate() == io.ebean.config.JsonConfig.Date.ISO8601) {
|
||||
softly.assertThat(json).isEqualTo("{\"localDate\":\"1969-12-31\"}");
|
||||
} else {
|
||||
softly.assertThat(json).isEqualTo("{\"localDate\":-86400000}");
|
||||
}
|
||||
|
||||
doTest("localDate", LocalDate.parse("2021-08-21"), "2021-08-21");
|
||||
|
||||
// restartServer("PST", "Europe/Berlin");
|
||||
// doTest("localDate", LocalDate.parse("2021-11-21"), "2021-11-21");
|
||||
// doTest("localDate", LocalDate.parse("2021-08-21"), "2021-08-21");
|
||||
|
||||
restartServer("Europe/Berlin", "PST");
|
||||
doTest("localDate", LocalDate.parse("2021-11-21"), "2021-11-21");
|
||||
doTest("localDate", LocalDate.parse("2021-08-21"), "2021-08-21");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJodaLocalDate() {
|
||||
|
||||
// Test with DST and no DST date (in germany)
|
||||
doTest("jodaLocalDate", org.joda.time.LocalDate.parse("2021-11-21"), "2021-11-21");
|
||||
if (config.getJsonDate() == io.ebean.config.JsonConfig.Date.ISO8601) {
|
||||
softly.assertThat(json).isEqualTo("{\"jodaLocalDate\":\"2021-11-21\"}");
|
||||
} else {
|
||||
softly.assertThat(json).isEqualTo("{\"jodaLocalDate\":1637452800000}"); // GMT: 00:00
|
||||
}
|
||||
|
||||
|
||||
doTest("jodaLocalDate", org.joda.time.LocalDate.parse("2021-08-21"), "2021-08-21");
|
||||
|
||||
doTest("jodaLocalDate", org.joda.time.LocalDate.parse("1970-01-01"), "1970-01-01");
|
||||
//softly.assertThat(formatted).isEqualTo("0");
|
||||
softly.assertThat(formatted).isEqualTo("-3600000");
|
||||
softly.assertThat(millis).isEqualTo(0L);
|
||||
|
||||
doTest("jodaLocalDate", org.joda.time.LocalDate.parse("1969-12-31"), "1969-12-31");
|
||||
softly.assertThat(formatted).isEqualTo("-90000000");
|
||||
softly.assertThat(millis).isEqualTo(-86400000L);
|
||||
|
||||
// restartServer("PST", "Europe/Berlin");
|
||||
// doTest("jodaLocalDate", org.joda.time.LocalDate.parse("2021-11-21"), "2021-11-21");
|
||||
// doTest("jodaLocalDate", org.joda.time.LocalDate.parse("2021-08-21"), "2021-08-20");
|
||||
|
||||
restartServer("Europe/Berlin", "PST");
|
||||
doTest("jodaLocalDate", org.joda.time.LocalDate.parse("2021-11-21"), "2021-11-21");
|
||||
doTest("jodaLocalDate", org.joda.time.LocalDate.parse("2021-08-21"), "2021-08-21");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
@IgnorePlatform(Platform.POSTGRES)
|
||||
public void testCalendar() {
|
||||
|
||||
restartServer("GMT", "GMT");
|
||||
Calendar cal = Calendar.getInstance();
|
||||
cal.clear();
|
||||
cal.set(2021, 8 - 1, 21, 5, 15, 15); // month 0-based!
|
||||
|
||||
softly.assertThat(cal.toInstant()).isEqualTo(Instant.parse("2021-08-21T05:15:15Z"));
|
||||
|
||||
doTest("propCalendar", cal, "2021-08-21 05:15:15");
|
||||
if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.ISO8601) {
|
||||
softly.assertThat(json).isEqualTo("{\"propCalendar\":\"2021-08-21T05:15:15.000Z\"}");
|
||||
} else if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.MILLIS) {
|
||||
softly.assertThat(json).isEqualTo("{\"propCalendar\":1629522915000}");
|
||||
} else {
|
||||
// softly.assertThat(json).isEqualTo("{\"propCalendar\":1629522915.000000000}"); // 05:15 GMT
|
||||
softly.assertThat(json).isEqualTo("{\"propCalendar\":1629522915000}"); // FIXME: this are millis!
|
||||
}
|
||||
|
||||
cal.clear();
|
||||
cal.setTimeInMillis(-1);
|
||||
doTest("propCalendar", cal, "1969-12-31 23:59:59.999");
|
||||
softly.assertThat(formatted).isEqualTo("-1");
|
||||
softly.assertThat(millis).isEqualTo(-1L);
|
||||
|
||||
if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.ISO8601) {
|
||||
softly.assertThat(json).isEqualTo("{\"propCalendar\":\"1969-12-31T23:59:59.999Z\"}");
|
||||
} else if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.MILLIS) {
|
||||
softly.assertThat(json).isEqualTo("{\"propCalendar\":-1}");
|
||||
} else {
|
||||
// softly.assertThat(json).isEqualTo("{\"propCalendar\":-0.001000000}");
|
||||
softly.assertThat(json).isEqualTo("{\"propCalendar\":-1}"); // FIXME: this are millis!
|
||||
}
|
||||
|
||||
// test in PST time zone
|
||||
restartServer("PST", "GMT");
|
||||
cal = Calendar.getInstance();
|
||||
cal.setTimeInMillis(0); // clear
|
||||
cal.set(2021, 8 - 1, 20, 22, 15, 15); // month 0-based!
|
||||
|
||||
softly.assertThat(cal.toInstant()).isEqualTo(Instant.parse("2021-08-21T05:15:15Z"));
|
||||
|
||||
doTest("propCalendar", cal, "2021-08-21 05:15:15");
|
||||
if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.ISO8601) {
|
||||
softly.assertThat(json).isEqualTo("{\"propCalendar\":\"2021-08-21T05:15:15.000Z\"}");
|
||||
} else if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.MILLIS) {
|
||||
softly.assertThat(json).isEqualTo("{\"propCalendar\":1629522915000}");
|
||||
} else {
|
||||
// softly.assertThat(json).isEqualTo("{\"propCalendar\":1629522915.000000000}");
|
||||
softly.assertThat(json).isEqualTo("{\"propCalendar\":1629522915000}"); // FIXME: this are millis!
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
@IgnorePlatform(Platform.POSTGRES)
|
||||
public void testInstant() {
|
||||
|
||||
// Test with DST and no DST date (in germany)
|
||||
doTest("propInstant", Instant.parse("2021-11-21T05:15:15Z"), "2021-11-21 05:15:15");
|
||||
if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.ISO8601) {
|
||||
softly.assertThat(json).isEqualTo("{\"propInstant\":\"2021-11-21T05:15:15Z\"}");
|
||||
} else if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.MILLIS) {
|
||||
softly.assertThat(json).isEqualTo("{\"propInstant\":1637471715000}");
|
||||
} else {
|
||||
softly.assertThat(json).isEqualTo("{\"propInstant\":1637471715.000000000}"); // 05:15 GMT
|
||||
}
|
||||
|
||||
doTest("propInstant", Instant.parse("1970-01-01T00:00:00Z"), "1970-01-01 00:00:00");
|
||||
softly.assertThat(formatted).isEqualTo("0");
|
||||
softly.assertThat(millis).isEqualTo(0L);
|
||||
|
||||
doTest("propInstant", Instant.parse("2021-08-21T05:15:15Z"), "2021-08-21 05:15:15");
|
||||
|
||||
restartServer("PST", "GMT");
|
||||
|
||||
doTest("propInstant", Instant.parse("2021-11-21T05:15:15Z"), "2021-11-21 05:15:15");
|
||||
doTest("propInstant", Instant.parse("2021-08-21T05:15:15Z"), "2021-08-21 05:15:15");
|
||||
}
|
||||
|
||||
@Test
|
||||
@IgnorePlatform(Platform.POSTGRES)
|
||||
public void testJodaDateTime() {
|
||||
|
||||
// Test with DST and no DST date (in germany)
|
||||
doTest("jodaDateTime", org.joda.time.DateTime.parse("2021-11-21T05:15:15Z"), "2021-11-21 05:15:15");
|
||||
if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.ISO8601) {
|
||||
softly.assertThat(json).isEqualTo("{\"jodaDateTime\":\"2021-11-21T05:15:15.000Z\"}");
|
||||
} else {
|
||||
softly.assertThat(json).isEqualTo("{\"jodaDateTime\":1637471715000}");
|
||||
}
|
||||
|
||||
doTest("jodaDateTime", org.joda.time.DateTime.parse("1970-01-01T00:00:00Z"), "1970-01-01 00:00:00");
|
||||
softly.assertThat(formatted).isEqualTo("0");
|
||||
softly.assertThat(millis).isEqualTo(0L);
|
||||
|
||||
restartServer("PST", "GMT");
|
||||
|
||||
doTest("jodaDateTime", org.joda.time.DateTime.parse("2021-11-21T05:15:15Z"), "2021-11-21 05:15:15");
|
||||
doTest("jodaDateTime", org.joda.time.DateTime.parse("2021-08-21T05:15:15Z"), "2021-08-21 05:15:15");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLocalDateTime() {
|
||||
|
||||
// Test with DST and no DST date (in germany)
|
||||
// CHECKME: LocalDateTimes are stored as instant in DB. (that may be justifiable)
|
||||
doTest("localDateTime", LocalDateTime.parse("2021-11-21T05:15:15"), "2021-11-21 04:15:15");
|
||||
// CHECKME: getJsonDateTime is not respected at LocalDateTime
|
||||
softly.assertThat(json).isEqualTo("{\"localDateTime\":\"2021-11-21T05:15:15\"}");
|
||||
// if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.ISO8601) {
|
||||
// } else if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.MILLIS) {
|
||||
// softly.assertThat(json).isEqualTo("{\"localDateTime\":1637471715000}");
|
||||
// } else {
|
||||
// softly.assertThat(json).isEqualTo("{\"localDateTime\":1637471715.000000000}");
|
||||
// }
|
||||
softly.assertThat(formatted).isEqualTo("2021-11-21T05:15:15"); // WHY is this not formatted in millis
|
||||
// CHECKME: TZ conversion may be justifiable
|
||||
softly.assertThat(millis).isEqualTo(1637471715000L - 3_600_000L);
|
||||
|
||||
// doTest("localDateTime", LocalDateTime.parse("1970-01-01T00:00:00"), "1970-01-01 00:00:00");
|
||||
// CHECKME: LocalDateTimes are stored as instant in DB. (that may be justifiable)
|
||||
doTest("localDateTime", LocalDateTime.parse("1970-01-01T00:00:00"), "1969-12-31 23:00:00");
|
||||
softly.assertThat(formatted).isEqualTo("1970-01-01T00:00");
|
||||
softly.assertThat(millis).isEqualTo(0L - 3_600_000L);
|
||||
|
||||
restartServer("PST", "Europe/Berlin");
|
||||
doTest("localDateTime", LocalDateTime.parse("2021-11-21T05:15:15"), "2021-11-21 14:15:15");
|
||||
doTest("localDateTime", LocalDateTime.parse("2021-08-21T05:15:15"), "2021-08-21 14:15:15");
|
||||
|
||||
restartServer("Europe/Berlin", "PST");
|
||||
doTest("localDateTime", LocalDateTime.parse("2021-11-21T05:15:15"), "2021-11-20 20:15:15");
|
||||
doTest("localDateTime", LocalDateTime.parse("2021-08-21T05:15:15"), "2021-08-20 20:15:15");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
@IgnorePlatform(Platform.POSTGRES)
|
||||
public void testJodaLocalDateTime() {
|
||||
|
||||
// Test with DST and no DST date (in germany)
|
||||
doTest("jodaLocalDateTime", org.joda.time.LocalDateTime.parse("2021-11-21T05:15:15"), "2021-11-21 04:15:15");
|
||||
if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.ISO8601) {
|
||||
softly.assertThat(json).isEqualTo("{\"jodaLocalDateTime\":\"2021-11-21T05:15:15.000\"}");
|
||||
} else if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.MILLIS) {
|
||||
softly.assertThat(json).isEqualTo("{\"jodaLocalDateTime\":1637468115000}"); // 05:15:15 Europe/Berlin correct?
|
||||
} else {
|
||||
// softly.assertThat(json).isEqualTo("{\"jodaLocalDateTime\":1637471715.000000000}"); // 05:15:15 GMT
|
||||
softly.assertThat(json).isEqualTo("{\"jodaLocalDateTime\":1637468115000}"); // Fixme: Joda uses millis here
|
||||
}
|
||||
|
||||
doTest("jodaLocalDateTime", org.joda.time.LocalDateTime.parse("2021-08-21T05:15:15"), "2021-08-21 03:15:15");
|
||||
|
||||
restartServer("PST", "Europe/Berlin");
|
||||
doTest("jodaLocalDateTime", org.joda.time.LocalDateTime.parse("2021-11-21T05:15:15"), "2021-11-21 14:15:15");
|
||||
doTest("jodaLocalDateTime", org.joda.time.LocalDateTime.parse("2021-08-21T05:15:15"), "2021-08-21 14:15:15");
|
||||
|
||||
restartServer("Europe/Berlin", "PST");
|
||||
doTest("jodaLocalDateTime", org.joda.time.LocalDateTime.parse("2021-11-21T05:15:15"), "2021-11-20 20:15:15");
|
||||
doTest("jodaLocalDateTime", org.joda.time.LocalDateTime.parse("2021-08-21T05:15:15"), "2021-08-20 20:15:15");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJodaDateMidnight() {
|
||||
|
||||
// Test with DST and no DST date (in germany)
|
||||
doTest("jodaDateMidnight", org.joda.time.DateMidnight.parse("2021-11-21"), "2021-11-21");
|
||||
if (config.getJsonDate() == io.ebean.config.JsonConfig.Date.ISO8601) {
|
||||
softly.assertThat(json).isEqualTo("{\"jodaDateMidnight\":\"2021-11-21\"}");
|
||||
} else {
|
||||
softly.assertThat(json).isEqualTo("{\"jodaDateMidnight\":1637449200000}");
|
||||
}
|
||||
|
||||
doTest("jodaDateMidnight", org.joda.time.DateMidnight.parse("2021-08-21"), "2021-08-21");
|
||||
|
||||
if (!isH2()) {
|
||||
restartServer("PST", "Europe/Berlin");
|
||||
doTest("jodaDateMidnight", org.joda.time.DateMidnight.parse("2021-11-21"), "2021-11-21");
|
||||
doTest("jodaDateMidnight", org.joda.time.DateMidnight.parse("2021-08-21"), "2021-08-21");
|
||||
|
||||
restartServer("Europe/Berlin", "PST");
|
||||
doTest("jodaDateMidnight", org.joda.time.DateMidnight.parse("2021-11-21"), "2021-11-21");
|
||||
doTest("jodaDateMidnight", org.joda.time.DateMidnight.parse("2021-08-21"), "2021-08-21");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testYearMonth() {
|
||||
|
||||
// Test with DST and no DST date (in germany)
|
||||
doTest("propYearMonth", YearMonth.of(2020, 2), "2020-02-01");
|
||||
if (config.getJsonDate() == io.ebean.config.JsonConfig.Date.ISO8601) {
|
||||
softly.assertThat(json).isEqualTo("{\"propYearMonth\":\"2020-02-01\"}");
|
||||
} else {
|
||||
softly.assertThat(json).isEqualTo("{\"propYearMonth\":1580515200000}"); // 00:00 GMT
|
||||
}
|
||||
doTest("propYearMonth", YearMonth.of(2020, 3), "2020-03-01");
|
||||
doTest("propYearMonth", YearMonth.of(2020, 4), "2020-04-01");
|
||||
|
||||
}
|
||||
@Test
|
||||
public void testYear() {
|
||||
|
||||
doTest("propYear", Year.of(2020), "2020");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMonthDay() {
|
||||
|
||||
// Test with DST and no DST date (in germany)
|
||||
doTest("propMonthDay", MonthDay.of(11, 21), "2000-11-21");
|
||||
softly.assertThat(json).isEqualTo("{\"propMonthDay\":\"--11-21\"}");
|
||||
doTest("propMonthDay", MonthDay.of(8, 21), "2000-08-21");
|
||||
doTest("propMonthDay", MonthDay.of(2, 29), "2000-02-29"); // leap year check
|
||||
|
||||
if (!isH2()) {
|
||||
restartServer("PST", "Europe/Berlin");
|
||||
doTest("propMonthDay", MonthDay.of(11, 21), "2000-11-21");
|
||||
doTest("propMonthDay", MonthDay.of(8, 21), "2000-08-21");
|
||||
doTest("propMonthDay", MonthDay.of(2, 29), "2000-02-29"); // leap year check
|
||||
|
||||
restartServer("Europe/Berlin", "PST");
|
||||
doTest("propMonthDay", MonthDay.of(11, 21), "2000-11-21");
|
||||
doTest("propMonthDay", MonthDay.of(8, 21), "2000-08-21");
|
||||
doTest("propMonthDay", MonthDay.of(2, 29), "2000-02-29"); // leap year check
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSqlDate() {
|
||||
// localTimes are never converted, when read or written to database
|
||||
doTest("sqlDate", new java.sql.Date(2021 - 1900, 11 - 1, 21), "2021-11-21");
|
||||
if (config.getJsonDate() == io.ebean.config.JsonConfig.Date.ISO8601) {
|
||||
softly.assertThat(json).isEqualTo("{\"sqlDate\":\"2021-11-21\"}");
|
||||
} else {
|
||||
softly.assertThat(json).isEqualTo("{\"sqlDate\":1637449200000}"); // 00:00 Europe/Berlin. correct?
|
||||
}
|
||||
|
||||
doTest("sqlDate", new java.sql.Date(2021 - 1900, 8 - 1, 21), "2021-08-21");
|
||||
|
||||
if (!isH2()) {
|
||||
// it does not matter in which timezone the server or java is!
|
||||
restartServer("PST", "Europe/Berlin");
|
||||
doTest("sqlDate", new java.sql.Date(2021 - 1900, 11 - 1, 21), "2021-11-21");
|
||||
doTest("sqlDate", new java.sql.Date(2021 - 1900, 8 - 1, 21), "2021-08-21");
|
||||
|
||||
restartServer("Europe/Berlin", "PST");
|
||||
doTest("sqlDate", new java.sql.Date(2021 - 1900, 11 - 1, 21), "2021-11-21");
|
||||
doTest("sqlDate", new java.sql.Date(2021 - 1900, 8 - 1, 21), "2021-08-21");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSqlTime() {
|
||||
|
||||
// Test with DST and no DST date (in germany)
|
||||
doTest("sqlTime", new java.sql.Time(5, 15, 15), "05:15:15");
|
||||
softly.assertThat(json).isEqualTo("{\"sqlTime\":\"05:15:15\"}");
|
||||
|
||||
doTest("sqlTime", new java.sql.Time(0, 0, 0), "00:00:00");
|
||||
doTest("sqlTime", new java.sql.Time(23, 59, 59), "23:59:59");
|
||||
|
||||
if (!isH2()) {
|
||||
restartServer("PST", "Europe/Berlin");
|
||||
doTest("sqlTime", new java.sql.Time(5, 15, 15), "05:15:15");
|
||||
doTest("sqlTime", new java.sql.Time(0, 0, 0), "00:00:00");
|
||||
doTest("sqlTime", new java.sql.Time(23, 59, 59), "23:59:59");
|
||||
|
||||
restartServer("Europe/Berlin", "PST");
|
||||
doTest("sqlTime", new java.sql.Time(5, 15, 15), "05:15:15");
|
||||
doTest("sqlTime", new java.sql.Time(0, 0, 0), "00:00:00");
|
||||
doTest("sqlTime", new java.sql.Time(23, 59, 59), "23:59:59");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
@IgnorePlatform(Platform.POSTGRES)
|
||||
public void testTimestamp() {
|
||||
restartServer("PST", "PST"); // java & db in same TZ
|
||||
doTest("propTimestamp", new Timestamp(2021 - 1900, 11 - 1, 21, 5, 15, 15, 0), "2021-11-21 05:15:15");
|
||||
if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.ISO8601) {
|
||||
softly.assertThat(json).isEqualTo("{\"propTimestamp\":\"2021-11-21T13:15:15Z\"}");
|
||||
} else if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.MILLIS) {
|
||||
softly.assertThat(json).isEqualTo("{\"propTimestamp\":1637500515000}");
|
||||
} else {
|
||||
// softly.assertThat(json).isEqualTo("{\"propTimestamp\":1637500515.000000000}");
|
||||
softly.assertThat(json).isEqualTo("{\"propTimestamp\":1637500515000}"); // FIXME: timestamp uses lillis here!
|
||||
}
|
||||
|
||||
|
||||
restartServer("Europe/Berlin", "GMT"); // go to germany
|
||||
doTest("propTimestamp", new Timestamp(2021 - 1900, 11 - 1, 21, 6, 15, 15, 0), "2021-11-21 05:15:15");
|
||||
doTest("propTimestamp", new Timestamp(2021 - 1900, 8 - 1, 21, 7, 15, 15, 0), "2021-08-21 05:15:15"); // Check DST
|
||||
|
||||
doTest("propTimestamp", new Timestamp(2021 - 1900, 3 - 1, 27, 23, 0, 0, 0), "2021-03-27 22:00:00");
|
||||
doTest("propTimestamp", new Timestamp(2021 - 1900, 3 - 1, 28, 0, 0, 0, 0), "2021-03-27 23:00:00");
|
||||
doTest("propTimestamp", new Timestamp(2021 - 1900, 3 - 1, 28, 1, 0, 0, 0), "2021-03-28 00:00:00");
|
||||
doTest("propTimestamp", new Timestamp(2021 - 1900, 3 - 1, 28, 2, 0, 0, 0), "2021-03-28 01:00:00");
|
||||
doTest("propTimestamp", new Timestamp(2021 - 1900, 3 - 1, 28, 3, 0, 1, 0), "2021-03-28 01:00:01");
|
||||
doTest("propTimestamp", new Timestamp(2021 - 1900, 3 - 1, 28, 4, 0, 0, 0), "2021-03-28 02:00:00");
|
||||
|
||||
restartServer("GMT", "Europe/Berlin");
|
||||
doTest("propTimestamp", new Timestamp(2021 - 1900, 11 - 1, 21, 4, 15, 15, 0), "2021-11-21 05:15:15");
|
||||
doTest("propTimestamp", new Timestamp(2021 - 1900, 8 - 1, 21, 3, 15, 15, 0), "2021-08-21 05:15:15"); // Check DST
|
||||
|
||||
doTest("propTimestamp", new Timestamp(2021 - 1900, 3 - 1, 27, 1, 0, 0, 0), "2021-03-27 02:00:00");
|
||||
doTest("propTimestamp", new Timestamp(2021 - 1900, 3 - 1, 27, 23, 0, 0, 0), "2021-03-28 00:00:00");
|
||||
doTest("propTimestamp", new Timestamp(2021 - 1900, 3 - 1, 28, 0, 0, 0, 0), "2021-03-28 01:00:00");
|
||||
doTest("propTimestamp", new Timestamp(2021 - 1900, 3 - 1, 28, 1, 0, 0, 0), "2021-03-28 03:00:00");
|
||||
}
|
||||
|
||||
@Test
|
||||
@IgnorePlatform(Platform.POSTGRES)
|
||||
public void testUtilDate() {
|
||||
restartServer("PST", "PST"); // java & db in same TZ
|
||||
doTest("utilDate", new java.util.Date(2021 - 1900, 11 - 1, 21, 5, 15, 15), "2021-11-21 05:15:15");
|
||||
if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.ISO8601) {
|
||||
softly.assertThat(json).isEqualTo("{\"utilDate\":\"2021-11-21T13:15:15.000Z\"}");
|
||||
} else if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.MILLIS) {
|
||||
softly.assertThat(json).isEqualTo("{\"utilDate\":1637500515000}");
|
||||
} else {
|
||||
// softly.assertThat(json).isEqualTo("{\"utilDate\":1637500515.000000000}");
|
||||
softly.assertThat(json).isEqualTo("{\"utilDate\":1637500515000}"); // FIXME: util date uses millis here
|
||||
}
|
||||
|
||||
|
||||
restartServer("Europe/Berlin", "GMT"); // go to germany
|
||||
doTest("utilDate", new java.util.Date(2021 - 1900, 11 - 1, 21, 6, 15, 15), "2021-11-21 05:15:15");
|
||||
doTest("utilDate", new java.util.Date(2021 - 1900, 8 - 1, 21, 7, 15, 15), "2021-08-21 05:15:15");
|
||||
|
||||
doTest("utilDate", new java.util.Date(2021 - 1900, 3 - 1, 27, 23, 0, 0), "2021-03-27 22:00:00");
|
||||
doTest("utilDate", new java.util.Date(2021 - 1900, 3 - 1, 28, 0, 0, 0), "2021-03-27 23:00:00");
|
||||
doTest("utilDate", new java.util.Date(2021 - 1900, 3 - 1, 28, 1, 0, 0), "2021-03-28 00:00:00");
|
||||
doTest("utilDate", new java.util.Date(2021 - 1900, 3 - 1, 28, 2, 0, 0), "2021-03-28 01:00:00");
|
||||
doTest("utilDate", new java.util.Date(2021 - 1900, 3 - 1, 28, 3, 0, 1), "2021-03-28 01:00:01");
|
||||
doTest("utilDate", new java.util.Date(2021 - 1900, 3 - 1, 28, 4, 0, 0), "2021-03-28 02:00:00");
|
||||
|
||||
restartServer("GMT", "Europe/Berlin");
|
||||
doTest("utilDate", new java.util.Date(2021 - 1900, 11 - 1, 21, 4, 15, 15), "2021-11-21 05:15:15");
|
||||
doTest("utilDate", new java.util.Date(2021 - 1900, 8 - 1, 21, 3, 15, 15), "2021-08-21 05:15:15");
|
||||
|
||||
doTest("utilDate", new java.util.Date(2021 - 1900, 3 - 1, 27, 1, 0, 0), "2021-03-27 02:00:00");
|
||||
doTest("utilDate", new java.util.Date(2021 - 1900, 3 - 1, 27, 23, 0, 0), "2021-03-28 00:00:00");
|
||||
doTest("utilDate", new java.util.Date(2021 - 1900, 3 - 1, 28, 0, 0, 0), "2021-03-28 01:00:00");
|
||||
doTest("utilDate", new java.util.Date(2021 - 1900, 3 - 1, 28, 1, 0, 0), "2021-03-28 03:00:00");
|
||||
}
|
||||
|
||||
@Test
|
||||
@IgnorePlatform(Platform.POSTGRES)
|
||||
public void testOffsetDateTime() {
|
||||
|
||||
restartServer("PST", "PST"); // be in the same TZ
|
||||
doTest("offsetDateTime", OffsetDateTime.parse("2021-11-20T21:15:15-08:00"), "2021-11-20 21:15:15");
|
||||
if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.ISO8601) {
|
||||
softly.assertThat(json).isEqualTo("{\"offsetDateTime\":\"2021-11-21T05:15:15Z\"}");
|
||||
} else if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.MILLIS) {
|
||||
softly.assertThat(json).isEqualTo("{\"offsetDateTime\":1637471715000}");
|
||||
} else {
|
||||
softly.assertThat(json).isEqualTo("{\"offsetDateTime\":1637471715.000000000}");
|
||||
}
|
||||
|
||||
restartServer("PST", "GMT"); // pass PST offsetDateTime to GMT DB
|
||||
doTest("offsetDateTime", OffsetDateTime.parse("2021-11-20T21:15:15-08:00"), "2021-11-21 05:15:15");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
@IgnorePlatform(Platform.POSTGRES)
|
||||
public void testZonedDateTime() {
|
||||
|
||||
restartServer("PST", "PST"); // be in the same TZ
|
||||
doTest("zonedDateTime", ZonedDateTime.parse("2021-11-20T21:15:15-08:00"), "2021-11-20 21:15:15");
|
||||
if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.ISO8601) {
|
||||
softly.assertThat(json).isEqualTo("{\"zonedDateTime\":\"2021-11-21T05:15:15Z\"}");
|
||||
} else if (config.getJsonDateTime() == io.ebean.config.JsonConfig.DateTime.MILLIS) {
|
||||
softly.assertThat(json).isEqualTo("{\"zonedDateTime\":1637471715000}"); // 05:15 GMT
|
||||
} else {
|
||||
softly.assertThat(json).isEqualTo("{\"zonedDateTime\":1637471715.000000000}");
|
||||
}
|
||||
|
||||
restartServer("PST", "GMT"); // pass PST offsetDateTime to GMT DB
|
||||
doTest("zonedDateTime", ZonedDateTime.parse("2021-11-20T21:15:15-08:00"), "2021-11-21 05:15:15");
|
||||
|
||||
}
|
||||
// offsetDateTime : OffsetDateTime
|
||||
// zonedDateTime : ZonedDateTime
|
||||
private String simpleClassNameOf(StackTraceElement testStackTraceElement) {
|
||||
String className = testStackTraceElement.getClassName();
|
||||
return className.substring(className.lastIndexOf('.') + 1);
|
||||
}
|
||||
|
||||
private <T extends Comparable<? super T>> void doTest(String property, T javaValue, String sqlValue) {
|
||||
StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
|
||||
String testClassName = simpleClassNameOf(stackTrace[2]);
|
||||
String testName = stackTrace[2].getMethodName();
|
||||
int lineNumber = stackTrace[2].getLineNumber();
|
||||
String testLoc = format("at %s.%s(%s.java:%s)", testClassName, testName, testClassName, lineNumber);
|
||||
|
||||
db.find(MDateTime.class).delete(); // clear database
|
||||
String sqlColumn = CamelCaseHelper.toUnderscoreFromCamel(property);
|
||||
// insert with raw sql
|
||||
db.sqlUpdate("insert into mdate_time (id, " + sqlColumn + ") values (1, '" + sqlValue + "')").execute();
|
||||
|
||||
// check findSingleAttributeList
|
||||
List<T> list = db.find(MDateTime.class).select(property).findSingleAttributeList();
|
||||
softly.assertThat(list).as("find " + testLoc).hasSize(1);
|
||||
T attr = list.get(0);
|
||||
assertTimeEquals("find attribute " + testLoc, attr, javaValue);
|
||||
|
||||
// check find model
|
||||
MDateTime model = db.find(MDateTime.class).where().eq(property, javaValue).findOne();
|
||||
Property beanProp = db.pluginApi().beanType(MDateTime.class).property(property);
|
||||
softly.assertThat(model).as("find model " + testLoc).isNotNull();
|
||||
if (model != null) {
|
||||
@SuppressWarnings("unchecked")
|
||||
T beanValue = (T) beanProp.value(model);
|
||||
assertTimeEquals("read from model " + testLoc, beanValue, javaValue);
|
||||
}
|
||||
// insert with "save"
|
||||
model = new MDateTime();
|
||||
model.setId(2);
|
||||
((ExpressionPath) beanProp).pathSet(model, javaValue);
|
||||
db.save(model);
|
||||
|
||||
// check findCount
|
||||
int count = db.find(MDateTime.class).where().eq(property, javaValue).findCount();
|
||||
softly.assertThat(count).as("find count " + testLoc).isEqualTo(2);
|
||||
|
||||
JsonWriteOptions opts = new JsonWriteOptions();
|
||||
opts.setPathProperties(PathProperties.parse(property));
|
||||
// check json roundtrip
|
||||
json = db.json().toJson(model, opts);
|
||||
model = db.json().toBean(MDateTime.class, json);
|
||||
T beanValue = (T) beanProp.value(model);
|
||||
assertTimeEquals("json roundtrip " + testLoc, beanValue, javaValue);
|
||||
|
||||
ScalarType<T> st = (ScalarType) ((BeanProperty) beanProp).scalarType();
|
||||
formatted = st.formatValue(javaValue);
|
||||
assertTimeEquals("parse/format symmetry " + testLoc, st.parse(formatted), javaValue);
|
||||
if (st instanceof ScalarTypeBaseDate) {
|
||||
ScalarTypeBaseDate<T> st2 = (ScalarTypeBaseDate<T>) st;
|
||||
Date date = st2.convertToDate(javaValue);
|
||||
assertTimeEquals("date convert symmetry " + testLoc, st2.convertFromDate(date), javaValue);
|
||||
millis = st2.convertToMillis(javaValue);
|
||||
assertTimeEquals("millis convert symmetry " + testLoc, st2.convertFromMillis(millis), javaValue);
|
||||
}
|
||||
if (st instanceof ScalarTypeBaseDateTime) {
|
||||
ScalarTypeBaseDateTime<T> st2 = (ScalarTypeBaseDateTime<T>) st;
|
||||
Timestamp ts = st2.convertToTimestamp(javaValue);
|
||||
assertTimeEquals("timestamp convert symmetry " + testLoc, st2.convertFromTimestamp(ts), javaValue);
|
||||
millis = st2.convertToMillis(javaValue);
|
||||
assertTimeEquals("millis convert symmetry " + testLoc, st2.convertFromMillis(millis), javaValue);
|
||||
assertTimeEquals("instant convert symmetry " + testLoc, st2.convertFromInstant(Instant.ofEpochMilli(millis)),
|
||||
javaValue);
|
||||
}
|
||||
}
|
||||
|
||||
private <T extends Comparable<? super T>> void assertTimeEquals(String msg, T value, T expected) {
|
||||
if (value instanceof java.sql.Date) {
|
||||
// SQL Dates may not be aligned at 00:00 - so compare toString representation
|
||||
softly.assertThat(value.toString()).as(msg).isEqualTo(expected.toString());
|
||||
} else if (value instanceof OffsetDateTime) {
|
||||
softly.assertThat((OffsetDateTime) value).as(msg).isAtSameInstantAs((OffsetDateTime) expected);
|
||||
} else if (value instanceof ZonedDateTime) {
|
||||
softly.assertThat(((ZonedDateTime) value).toInstant()).as(msg).isEqualTo(((ZonedDateTime) expected).toInstant());
|
||||
} else {
|
||||
softly.assertThat(value).as(msg).isEqualByComparingTo(expected);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
-13
@@ -1,13 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import org.junit.jupiter.api.Disabled;
|
||||
|
||||
import io.ebean.config.DatabaseConfig;
|
||||
@Disabled("Does not work @github")
|
||||
public class DatesAndTimesWithJsonMillisTest extends DatesAndTimesTest {
|
||||
@Override
|
||||
protected void reconfigure(DatabaseConfig config) {
|
||||
config.setJsonDate(io.ebean.config.JsonConfig.Date.MILLIS);
|
||||
config.setJsonDateTime(io.ebean.config.JsonConfig.DateTime.MILLIS);
|
||||
}
|
||||
}
|
||||
-12
@@ -1,12 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import org.junit.jupiter.api.Disabled;
|
||||
|
||||
import io.ebean.config.DatabaseConfig;
|
||||
@Disabled("Does not work @github")
|
||||
public class DatesAndTimesWithJsonNanosTest extends DatesAndTimesTest {
|
||||
@Override
|
||||
protected void reconfigure(DatabaseConfig config) {
|
||||
config.setJsonDateTime(io.ebean.config.JsonConfig.DateTime.NANOS);
|
||||
}
|
||||
}
|
||||
@@ -1,44 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.sql.Timestamp;
|
||||
import java.time.Duration;
|
||||
import java.time.Instant;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
public class DecimalUtilsTest {
|
||||
|
||||
@Test
|
||||
public void testToDecimal() throws Exception {
|
||||
|
||||
Instant now = Instant.now();
|
||||
BigDecimal value = DecimalUtils.toDecimal(now);
|
||||
|
||||
Instant instant = DecimalUtils.toInstant(value);
|
||||
Timestamp timestamp = DecimalUtils.toTimestamp(value);
|
||||
BigDecimal decimal = DecimalUtils.toDecimal(timestamp);
|
||||
|
||||
Instant instant1 = timestamp.toInstant();
|
||||
|
||||
assertEquals(instant, instant1);
|
||||
assertEquals(value, decimal);
|
||||
assertEquals(now, instant);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDuration() throws Exception {
|
||||
|
||||
|
||||
Duration duration = Duration.ofSeconds(323, 1500000);
|
||||
|
||||
BigDecimal bigDecimal = DecimalUtils.toDecimal(duration);
|
||||
Duration duration1 = DecimalUtils.toDuration(bigDecimal);
|
||||
|
||||
assertEquals(duration, duration1);
|
||||
assertEquals("PT5M23.0015S", duration1.toString());
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,28 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebean.core.type.ScalarType;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.sql.Types;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
|
||||
public class DefaultTypeFactoryTest {
|
||||
|
||||
DefaultTypeFactory defaultTypeFactory = new DefaultTypeFactory(null);
|
||||
|
||||
@Test
|
||||
public void testCreateBoolean() throws Exception {
|
||||
|
||||
ScalarType<Boolean> stIntBoolean = defaultTypeFactory.createBoolean("0", "1");
|
||||
assertEquals(Types.INTEGER, stIntBoolean.getJdbcType());
|
||||
|
||||
stIntBoolean = defaultTypeFactory.createBoolean("1", "2");
|
||||
assertEquals(Types.INTEGER, stIntBoolean.getJdbcType());
|
||||
|
||||
ScalarType<Boolean> stStringBoolean = defaultTypeFactory.createBoolean("Y", "N");
|
||||
assertEquals(Types.VARCHAR, stStringBoolean.getJdbcType());
|
||||
|
||||
}
|
||||
}
|
||||
@@ -1,135 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebean.config.DatabaseConfig;
|
||||
import io.ebean.config.dbplatform.postgres.PostgresPlatform;
|
||||
import io.ebean.core.type.ScalarType;
|
||||
import io.ebeaninternal.server.core.bootup.BootupClasses;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.array.IntEnum;
|
||||
import org.tests.model.array.VarcharEnum;
|
||||
import org.tests.model.basic.Car;
|
||||
|
||||
import javax.persistence.EnumType;
|
||||
import java.time.DayOfWeek;
|
||||
import java.time.Month;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
public class DefaultTypeManagerTest {
|
||||
|
||||
private DefaultTypeManager create() {
|
||||
DatabaseConfig serverConfig = new DatabaseConfig();
|
||||
serverConfig.setDatabasePlatform(new PostgresPlatform());
|
||||
BootupClasses bootupClasses = new BootupClasses();
|
||||
return new DefaultTypeManager(serverConfig, bootupClasses);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isIntegerType() {
|
||||
DefaultTypeManager typeManager = create();
|
||||
|
||||
assertTrue(typeManager.isIntegerType("1"));
|
||||
assertTrue(typeManager.isIntegerType("0"));
|
||||
|
||||
assertFalse(typeManager.isIntegerType("A"));
|
||||
assertFalse(typeManager.isIntegerType("01"));
|
||||
assertFalse(typeManager.isIntegerType(" 01"));
|
||||
assertFalse(typeManager.isIntegerType(" 0"));
|
||||
assertFalse(typeManager.isIntegerType(" 1"));
|
||||
assertFalse(typeManager.isIntegerType(" A"));
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void enumDayMonth_builtIn_overrideAsString() {
|
||||
DefaultTypeManager typeManager = create();
|
||||
|
||||
ScalarType<?> type = typeManager.createEnumScalarType(Month.class, null);
|
||||
assertThat(type).isInstanceOf(ScalarTypeEnumWithMapping.class).as("built in type");
|
||||
|
||||
// mapped explicitly as JPA EnumType.STRING
|
||||
type = typeManager.createEnumScalarType(Month.class, EnumType.STRING);
|
||||
assertThat(type).isInstanceOf(ScalarTypeEnumStandard.StringEnum.class).as("override built in type");
|
||||
try {
|
||||
typeManager.createEnumScalarType(Month.class, EnumType.ORDINAL);
|
||||
assertThat(true).isFalse().as("never get here");
|
||||
|
||||
} catch (IllegalStateException e) {
|
||||
assertThat(e.getMessage()).contains("It is mapped using 2 different modes when only one is supported");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void enumMonth_builtIn_overrideAsOrdinal() {
|
||||
DefaultTypeManager typeManager = create();
|
||||
|
||||
// mapped explicitly as JPA EnumType.STRING
|
||||
ScalarType<?> type = typeManager.createEnumScalarType(Month.class, EnumType.ORDINAL);
|
||||
assertThat(type).isInstanceOf(ScalarTypeEnumStandard.OrdinalEnum.class).as("override built in type");
|
||||
try {
|
||||
typeManager.createEnumScalarType(Month.class, EnumType.STRING);
|
||||
assertThat(true).isFalse().as("never get here");
|
||||
} catch (IllegalStateException e) {
|
||||
assertThat(e.getMessage()).contains("It is mapped using 2 different modes when only one is supported");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void enumDayOfWeek_builtIn_overrideAsString() {
|
||||
DefaultTypeManager typeManager = create();
|
||||
|
||||
ScalarType<?> type = typeManager.createEnumScalarType(DayOfWeek.class, null);
|
||||
assertThat(type).isInstanceOf(ScalarTypeEnumWithMapping.class).as("built in type");
|
||||
|
||||
// mapped explicitly as JPA EnumType.STRING
|
||||
type = typeManager.createEnumScalarType(DayOfWeek.class, EnumType.STRING);
|
||||
assertThat(type).isInstanceOf(ScalarTypeEnumStandard.StringEnum.class).as("override built in type");
|
||||
try {
|
||||
typeManager.createEnumScalarType(DayOfWeek.class, EnumType.ORDINAL);
|
||||
assertThat(true).isFalse().as("never get here");
|
||||
} catch (IllegalStateException e) {
|
||||
assertThat(e.getMessage()).contains("It is mapped using 2 different modes when only one is supported");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void enumDayOfWeek_builtIn_overrideAsOrdinal() {
|
||||
DefaultTypeManager typeManager = create();
|
||||
|
||||
// mapped explicitly as JPA EnumType.STRING
|
||||
ScalarType<?> type = typeManager.createEnumScalarType(DayOfWeek.class, EnumType.ORDINAL);
|
||||
assertThat(type).isInstanceOf(ScalarTypeEnumStandard.OrdinalEnum.class).as("override built in type");
|
||||
try {
|
||||
typeManager.createEnumScalarType(DayOfWeek.class, EnumType.STRING);
|
||||
assertThat(true).isFalse().as("never get here");
|
||||
} catch (IllegalStateException e) {
|
||||
assertThat(e.getMessage()).contains("It is mapped using 2 different modes when only one is supported");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createEnumScalarTypePerExtentions() {
|
||||
DefaultTypeManager typeManager = create();
|
||||
|
||||
ScalarType<?> type = typeManager.createEnumScalarType(VarcharEnum.class, EnumType.ORDINAL);
|
||||
assertThat(type).isInstanceOf(ScalarTypeEnumWithMapping.class);
|
||||
// withConstraint false
|
||||
assertThat(((ScalarTypeEnumWithMapping) type).getDbCheckConstraintValues()).isNull();
|
||||
|
||||
type = typeManager.createEnumScalarType(IntEnum.class, EnumType.ORDINAL);
|
||||
assertThat(type).isInstanceOf(ScalarTypeEnumWithMapping.class);
|
||||
ScalarTypeEnumWithMapping enumWithMapping = (ScalarTypeEnumWithMapping) type;
|
||||
// withConstraint true
|
||||
assertThat(enumWithMapping.getDbCheckConstraintValues()).hasSize(3);
|
||||
assertThat(enumWithMapping.getDbCheckConstraintValues()).contains("100", "101", "102");
|
||||
|
||||
type = typeManager.createEnumScalarType(Car.Size.class, EnumType.ORDINAL);
|
||||
assertThat(type).isInstanceOf(ScalarTypeEnumWithMapping.class);
|
||||
enumWithMapping = (ScalarTypeEnumWithMapping) type;
|
||||
// withConstraint true
|
||||
assertThat(enumWithMapping.getDbCheckConstraintValues()).hasSize(2);
|
||||
assertThat(enumWithMapping.getDbCheckConstraintValues()).contains("'L'", "'S'");
|
||||
}
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.time.Instant;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class IsoJsonDateTimeParserTest {
|
||||
|
||||
private IsoJsonDateTimeParser parser = new IsoJsonDateTimeParser();
|
||||
|
||||
@Test
|
||||
public void parseFormat_when_hasMillis() {
|
||||
parseAndFormat("2016-02-28T20:39:00.123Z", "2016-02-28T20:39:00.123Z");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parseFormat_when_noMillis() {
|
||||
parseAndFormat("2016-02-28T20:39:00Z", "2016-02-28T20:39:00.000Z");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parseFormat_when_millis_1dp() {
|
||||
parseAndFormat("2016-02-28T20:39:00.0Z", "2016-02-28T20:39:00.000Z");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parseFormat_when_millis_2dp() {
|
||||
parseAndFormat("2016-02-28T20:39:00.00Z", "2016-02-28T20:39:00.000Z");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parseFormat_when_millis_3dp() {
|
||||
parseAndFormat("2016-02-28T20:39:00.000Z", "2016-02-28T20:39:00.000Z");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parseFormat_when_millis_3dp_2() {
|
||||
parseAndFormat("2016-02-28T20:39:32.999000Z", "2016-02-28T20:39:32.999Z");
|
||||
}
|
||||
|
||||
private void parseAndFormat(String input, String expected) {
|
||||
Instant timestamp = parser.parseIso(input);
|
||||
String format = parser.formatIso(timestamp);
|
||||
assertThat(format).isEqualTo(expected);
|
||||
}
|
||||
}
|
||||
@@ -1,53 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import com.fasterxml.jackson.core.JsonFactory;
|
||||
import com.fasterxml.jackson.core.JsonGenerator;
|
||||
import com.fasterxml.jackson.core.JsonParser;
|
||||
import com.fasterxml.jackson.core.JsonToken;
|
||||
import io.ebean.config.JsonConfig;
|
||||
import io.ebean.core.type.ScalarType;
|
||||
import io.ebeaninternal.server.text.json.WriteJson;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.StringWriter;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
/**
|
||||
* Base class to help json testing.
|
||||
*/
|
||||
public class JsonTester<T> {
|
||||
|
||||
protected JsonFactory factory = new JsonFactory();
|
||||
|
||||
protected ScalarType<T> type;
|
||||
|
||||
public JsonTester(ScalarType<T> type) {
|
||||
this.type = type;
|
||||
}
|
||||
|
||||
public String test(T value) throws IOException {
|
||||
StringWriter writer = new StringWriter();
|
||||
|
||||
JsonGenerator generator = factory.createGenerator(writer);
|
||||
generator.writeStartObject();
|
||||
|
||||
WriteJson writeJson = new WriteJson(generator, JsonConfig.Include.ALL);
|
||||
writeJson.writeFieldName("key");
|
||||
type.jsonWrite(generator, value);
|
||||
generator.writeEndObject();
|
||||
generator.flush();
|
||||
|
||||
JsonParser parser = factory.createParser(writer.toString());
|
||||
JsonToken token = parser.nextToken();
|
||||
assertEquals(JsonToken.START_OBJECT, token);
|
||||
token = parser.nextToken();
|
||||
assertEquals(JsonToken.FIELD_NAME, token);
|
||||
parser.nextToken();
|
||||
|
||||
T val1 = type.jsonRead(parser);
|
||||
assertEquals(value, val1);
|
||||
|
||||
return writer.toString();
|
||||
}
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
class JsonTrimTest {
|
||||
|
||||
@Test
|
||||
void trim_array() {
|
||||
final String trimmed = JsonTrim.trim("[{\"name\": \"one\", \"along\": 1, \"timestamp\": 1629609021559}, {\"name\": \"two\", \"along\": 2, \"timestamp\": 1629609021559}]");
|
||||
assertThat(trimmed).isEqualTo("[{\"name\":\"one\",\"along\":1,\"timestamp\":1629609021559},{\"name\":\"two\",\"along\":2,\"timestamp\":1629609021559}]");
|
||||
}
|
||||
|
||||
@Test
|
||||
void trim_object() {
|
||||
final String trimmed = JsonTrim.trim("{\"name\": \"one\",\t \t \"along\": 1, \"timestamp\": 1629609021559}");
|
||||
assertThat(trimmed).isEqualTo("{\"name\":\"one\",\"along\":1,\"timestamp\":1629609021559}");
|
||||
}
|
||||
|
||||
@Test
|
||||
void trim_object_embeddedEscapeSlash() {
|
||||
final String trimmed = JsonTrim.trim("{\"a\": \"o\\nf\",\t \t \n \"b\": 1}");
|
||||
assertThat(trimmed).isEqualTo("{\"a\":\"o\\nf\",\"b\":1}");
|
||||
}
|
||||
|
||||
@Test
|
||||
void trim_escapedTabNewLine() {
|
||||
final String trimmed = JsonTrim.trim("{\"a\": \"o\\t\\nf\",\t \t \n \"b\": 1}");
|
||||
assertThat(trimmed).isEqualTo("{\"a\":\"o\\t\\nf\",\"b\":1}");
|
||||
}
|
||||
|
||||
@Test
|
||||
void trim_leadingEscapedNewLine() {
|
||||
final String trimmed = JsonTrim.trim("{\"a\": \"\\no\\t\\nf\\n\",\t \t \n \"b\": 1}");
|
||||
assertThat(trimmed).isEqualTo("{\"a\":\"\\no\\t\\nf\\n\",\"b\":1}");
|
||||
}
|
||||
|
||||
@Test
|
||||
void trim_trailingEscapedNewLine() {
|
||||
final String trimmed = JsonTrim.trim("{\"a\": \"o\\t\\nf\\n\",\t \t \n \"b\": 1}");
|
||||
assertThat(trimmed).isEqualTo("{\"a\":\"o\\t\\nf\\n\",\"b\":1}");
|
||||
}
|
||||
|
||||
@Test
|
||||
void trim_trailingEscapedSlash() {
|
||||
final String trimmed = JsonTrim.trim("{\"a\": \"o\\t\\nf\\\\\",\t \t \n \"b\": 1}");
|
||||
assertThat(trimmed).isEqualTo("{\"a\":\"o\\t\\nf\\\\\",\"b\":1}");
|
||||
}
|
||||
|
||||
@Test
|
||||
void trim_object_embeddedEscaped() {
|
||||
final String trimmed = JsonTrim.trim("{\"name\": \"one\nfoo\nbar\\bazz\tboo\",\t \t \n \"along\": 1}");
|
||||
assertThat(trimmed).isEqualTo("{\"name\":\"one\nfoo\nbar\\bazz\tboo\",\"along\":1}");
|
||||
}
|
||||
|
||||
@Test
|
||||
void trim_escaped() {
|
||||
final String trimmed = JsonTrim.trim(" \t \n {\"a\": \n \"\\t1\\t2\\n3\\\\\",\t \n \"b\": \"\\t1\\t2\\n3\\\\\" , \t \n \"c\": \"\\t1\\t2\\n3\\\\\" \t \n }");
|
||||
assertThat(trimmed).isEqualTo("{\"a\":\"\\t1\\t2\\n3\\\\\",\"b\":\"\\t1\\t2\\n3\\\\\",\"c\":\"\\t1\\t2\\n3\\\\\"}");
|
||||
}
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebeaninternal.json.ModifyAwareFlag;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.*;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class ModifyAwareFlagTest {
|
||||
|
||||
@Test
|
||||
public void serialise() throws IOException, ClassNotFoundException {
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
ObjectOutputStream oos = new ObjectOutputStream(os);
|
||||
|
||||
ModifyAwareFlag flag = new ModifyAwareFlag();
|
||||
flag.setMarkedDirty(true);
|
||||
oos.writeObject(flag);
|
||||
oos.flush();
|
||||
oos.close();
|
||||
|
||||
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
|
||||
ObjectInputStream ois = new ObjectInputStream(is);
|
||||
|
||||
ModifyAwareFlag read = (ModifyAwareFlag)ois.readObject();
|
||||
assertThat(read.isMarkedDirty()).isTrue();
|
||||
}
|
||||
}
|
||||
@@ -1,300 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebeaninternal.json.ModifyAwareList;
|
||||
import io.ebeaninternal.json.ModifyAwareSet;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.*;
|
||||
import java.util.*;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
|
||||
public class ModifyAwareListTest {
|
||||
|
||||
private ModifyAwareList<String> createList() {
|
||||
return new ModifyAwareList<>(new ArrayList<>(Arrays.asList("A", "B", "C", "D", "E")));
|
||||
}
|
||||
|
||||
private ModifyAwareList<String> createEmptyList() {
|
||||
return new ModifyAwareList<>(new ArrayList<>());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSize() {
|
||||
|
||||
assertEquals(5, createList().size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsEmpty() {
|
||||
|
||||
assertFalse(createList().isEmpty());
|
||||
assertTrue(createEmptyList().isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testContains() {
|
||||
|
||||
assertTrue(createList().contains("B"));
|
||||
assertFalse(createList().contains("Z"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIterator() {
|
||||
|
||||
ModifyAwareList<String> list = createList();
|
||||
Iterator<String> iterator = list.iterator();
|
||||
assertTrue(iterator.hasNext());
|
||||
assertEquals("A", iterator.next());
|
||||
assertFalse(list.isMarkedDirty());
|
||||
|
||||
iterator.remove();
|
||||
assertTrue(list.isMarkedDirty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToArray() {
|
||||
|
||||
Object[] objects = createList().toArray();
|
||||
assertEquals(5, objects.length);
|
||||
assertEquals("A", objects[0]);
|
||||
assertEquals("E", objects[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToArray1() {
|
||||
|
||||
String[] objects = createList().toArray(new String[5]);
|
||||
assertEquals(5, objects.length);
|
||||
assertEquals("A", objects[0]);
|
||||
assertEquals("E", objects[4]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAdd() {
|
||||
|
||||
ModifyAwareList<String> list = createList();
|
||||
assertFalse(list.isMarkedDirty());
|
||||
|
||||
list.add("F");
|
||||
assertTrue(list.isMarkedDirty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRemove() {
|
||||
|
||||
ModifyAwareList<String> list = createList();
|
||||
assertFalse(list.isMarkedDirty());
|
||||
|
||||
list.remove("A");
|
||||
assertTrue(list.isMarkedDirty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testContainsAll() {
|
||||
|
||||
ModifyAwareList<String> list = createList();
|
||||
|
||||
assertTrue(list.containsAll(Arrays.asList("A", "B")));
|
||||
assertFalse(list.containsAll(Arrays.asList("A", "B", "Z")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAddAll() {
|
||||
|
||||
ModifyAwareList<String> list = createList();
|
||||
assertFalse(list.isMarkedDirty());
|
||||
|
||||
assertTrue(list.addAll(Arrays.asList("F", "G")));
|
||||
assertTrue(list.isMarkedDirty());
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testRemoveAll() {
|
||||
|
||||
ModifyAwareList<String> list = createList();
|
||||
assertFalse(list.isMarkedDirty());
|
||||
|
||||
assertTrue(list.removeAll(Arrays.asList("A", "G")));
|
||||
assertTrue(list.isMarkedDirty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRetainAll() {
|
||||
|
||||
ModifyAwareList<String> list = createList();
|
||||
assertFalse(list.isMarkedDirty());
|
||||
|
||||
assertTrue(list.retainAll(Arrays.asList("A", "B")));
|
||||
assertTrue(list.isMarkedDirty());
|
||||
assertEquals(2, list.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testClear() {
|
||||
|
||||
ModifyAwareList<String> list = createList();
|
||||
assertFalse(list.isMarkedDirty());
|
||||
|
||||
list.clear();
|
||||
assertTrue(list.isMarkedDirty());
|
||||
assertEquals(0, list.size());
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGet() {
|
||||
|
||||
ModifyAwareList<String> list = createList();
|
||||
|
||||
assertEquals("A", list.get(0));
|
||||
assertEquals("B", list.get(1));
|
||||
assertEquals("E", list.get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSet() {
|
||||
|
||||
ModifyAwareList<String> list = createList();
|
||||
assertFalse(list.isMarkedDirty());
|
||||
|
||||
list.set(0, "Z");
|
||||
assertTrue(list.isMarkedDirty());
|
||||
assertEquals(5, list.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIndexOf() {
|
||||
|
||||
ModifyAwareList<String> list = createList();
|
||||
assertFalse(list.isMarkedDirty());
|
||||
|
||||
assertEquals(2, list.indexOf("C"));
|
||||
assertEquals(-1, list.indexOf("Z"));
|
||||
assertFalse(list.isMarkedDirty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLastIndexOf() {
|
||||
|
||||
ModifyAwareList<String> list = createList();
|
||||
assertFalse(list.isMarkedDirty());
|
||||
|
||||
assertEquals(2, list.lastIndexOf("C"));
|
||||
assertEquals(-1, list.lastIndexOf("Z"));
|
||||
assertFalse(list.isMarkedDirty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testListIterator() {
|
||||
|
||||
ModifyAwareList<String> list = createList();
|
||||
ListIterator<String> iterator = list.listIterator();
|
||||
assertTrue(iterator.hasNext());
|
||||
assertEquals("A", iterator.next());
|
||||
assertFalse(list.isMarkedDirty());
|
||||
|
||||
iterator.remove();
|
||||
assertTrue(list.isMarkedDirty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testListIterator1() {
|
||||
|
||||
ModifyAwareList<String> list = createList();
|
||||
ListIterator<String> iterator = list.listIterator(2);
|
||||
assertTrue(iterator.hasNext());
|
||||
assertEquals("C", iterator.next());
|
||||
assertFalse(list.isMarkedDirty());
|
||||
|
||||
iterator.remove();
|
||||
assertTrue(list.isMarkedDirty());
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSubList() {
|
||||
|
||||
ModifyAwareList<String> list = createList();
|
||||
List<String> sub = list.subList(1, 3);
|
||||
assertEquals("B", sub.get(0));
|
||||
assertEquals("C", sub.get(1));
|
||||
|
||||
assertFalse(list.isMarkedDirty());
|
||||
|
||||
sub.remove("C");
|
||||
assertTrue(list.isMarkedDirty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAsSet() {
|
||||
|
||||
ModifyAwareList<String> list = createList();
|
||||
ModifyAwareSet<String> set = list.asSet();
|
||||
assertFalse(set.isMarkedDirty());
|
||||
|
||||
set.add("next");
|
||||
|
||||
assertTrue(set.isMarkedDirty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void serialise() throws IOException, ClassNotFoundException {
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
ObjectOutputStream oos = new ObjectOutputStream(os);
|
||||
|
||||
ModifyAwareList<String> orig = createList();
|
||||
oos.writeObject(orig);
|
||||
oos.flush();
|
||||
oos.close();
|
||||
|
||||
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
|
||||
ObjectInputStream ois = new ObjectInputStream(is);
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
ModifyAwareList<String> read = (ModifyAwareList<String>)ois.readObject();
|
||||
assertThat(read).contains("A", "B", "C", "D", "E");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equalsWhenEqual() {
|
||||
|
||||
ModifyAwareList<String> listA = createList();
|
||||
ModifyAwareList<String> listB = createList();
|
||||
|
||||
assertThat(listA).isEqualTo(listB);
|
||||
assertThat(listA.hashCode()).isEqualTo(listB.hashCode());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equalsWhenNotEqual() {
|
||||
|
||||
ModifyAwareList<String> listA = createList();
|
||||
ModifyAwareList<String> listB = createList();
|
||||
listB.add("F");
|
||||
|
||||
assertThat(listA).isNotEqualTo(listB);
|
||||
assertThat(listA.hashCode()).isNotEqualTo(listB.hashCode());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEqualsAndHashCode() throws Exception {
|
||||
ModifyAwareList<String> listA = createEmptyList();
|
||||
ArrayList<String> listB = new ArrayList<>();
|
||||
|
||||
assertThat(listA).isEqualTo(listB);
|
||||
assertThat(listA.hashCode()).isEqualTo(listB.hashCode());
|
||||
|
||||
listA.add("foo");
|
||||
assertThat(listA).isNotEqualTo(listB);
|
||||
assertThat(listA.hashCode()).isNotEqualTo(listB.hashCode());
|
||||
|
||||
listB.add("foo");
|
||||
assertThat(listA).isEqualTo(listB);
|
||||
assertThat(listA.hashCode()).isEqualTo(listB.hashCode());
|
||||
}
|
||||
}
|
||||
@@ -1,83 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebeaninternal.json.ModifyAwareMap;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.*;
|
||||
import java.util.HashMap;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class ModifyAwareMapTest {
|
||||
|
||||
private ModifyAwareMap<String, Integer> createMap() {
|
||||
HashMap<String, Integer> set = new HashMap<>();
|
||||
set.put("A", 1);
|
||||
set.put("B", 2);
|
||||
set.put("C", 3);
|
||||
set.put("D", 4);
|
||||
set.put("E", 5);
|
||||
return new ModifyAwareMap<>(set);
|
||||
}
|
||||
|
||||
private ModifyAwareMap<String, Integer> createEmptyMap() {
|
||||
HashMap<String, Integer> set = new HashMap<>();
|
||||
return new ModifyAwareMap<>(set);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void serialise() throws IOException, ClassNotFoundException {
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
ObjectOutputStream oos = new ObjectOutputStream(os);
|
||||
|
||||
oos.writeObject(createMap());
|
||||
oos.flush();
|
||||
oos.close();
|
||||
|
||||
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
|
||||
ObjectInputStream ois = new ObjectInputStream(is);
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
ModifyAwareMap<String, Integer> read = (ModifyAwareMap<String, Integer>) ois.readObject();
|
||||
assertThat(read).containsKeys("A", "B", "C", "D", "E").containsValues(1, 2, 3, 4, 5);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equalsWhenEqual() {
|
||||
|
||||
ModifyAwareMap<String, Integer> setA = createMap();
|
||||
ModifyAwareMap<String, Integer> setB = createMap();
|
||||
|
||||
assertThat(setA).isEqualTo(setB);
|
||||
assertThat(setA.hashCode()).isEqualTo(setB.hashCode());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equalsWhenNotEqual() {
|
||||
|
||||
ModifyAwareMap<String, Integer> setA = createMap();
|
||||
ModifyAwareMap<String, Integer> setB = createMap();
|
||||
setB.put("F", 6);
|
||||
|
||||
assertThat(setA).isNotEqualTo(setB);
|
||||
assertThat(setA.hashCode()).isNotEqualTo(setB.hashCode());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEqualsAndHashCode() throws Exception {
|
||||
ModifyAwareMap<String, Integer> setA = createEmptyMap();
|
||||
HashMap<String, Integer> setB = new HashMap<>();
|
||||
|
||||
assertThat(setA).isEqualTo(setB);
|
||||
assertThat(setA.hashCode()).isEqualTo(setB.hashCode());
|
||||
|
||||
setA.put("foo", 42);
|
||||
assertThat(setA).isNotEqualTo(setB);
|
||||
assertThat(setA.hashCode()).isNotEqualTo(setB.hashCode());
|
||||
|
||||
setB.put("foo", 42);
|
||||
assertThat(setA).isEqualTo(setB);
|
||||
assertThat(setA.hashCode()).isEqualTo(setB.hashCode());
|
||||
}
|
||||
}
|
||||
@@ -1,80 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebeaninternal.json.ModifyAwareSet;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.*;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashSet;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class ModifyAwareSetTest {
|
||||
|
||||
private ModifyAwareSet<String> createSet() {
|
||||
HashSet<String> set = new HashSet<>();
|
||||
set.addAll(Arrays.asList("A", "B", "C", "D", "E"));
|
||||
return new ModifyAwareSet<>(set);
|
||||
}
|
||||
|
||||
private ModifyAwareSet<String> createEmptySet() {
|
||||
HashSet<String> set = new HashSet<>();
|
||||
return new ModifyAwareSet<>(set);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void serialise() throws IOException, ClassNotFoundException {
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
ObjectOutputStream oos = new ObjectOutputStream(os);
|
||||
|
||||
oos.writeObject(createSet());
|
||||
oos.flush();
|
||||
oos.close();
|
||||
|
||||
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
|
||||
ObjectInputStream ois = new ObjectInputStream(is);
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
ModifyAwareSet<String> read = (ModifyAwareSet<String>)ois.readObject();
|
||||
assertThat(read).contains("A", "B", "C", "D", "E");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equalsWhenEqual() {
|
||||
|
||||
ModifyAwareSet<String> setA = createSet();
|
||||
ModifyAwareSet<String> setB = createSet();
|
||||
|
||||
assertThat(setA).isEqualTo(setB);
|
||||
assertThat(setA.hashCode()).isEqualTo(setB.hashCode());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equalsWhenNotEqual() {
|
||||
|
||||
ModifyAwareSet<String> setA = createSet();
|
||||
ModifyAwareSet<String> setB = createSet();
|
||||
setB.add("F");
|
||||
|
||||
assertThat(setA).isNotEqualTo(setB);
|
||||
assertThat(setA.hashCode()).isNotEqualTo(setB.hashCode());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEqualsAndHashCode() throws Exception {
|
||||
ModifyAwareSet<String> setA = createEmptySet();
|
||||
HashSet<String> setB = new HashSet<>();
|
||||
|
||||
assertThat(setA).isEqualTo(setB);
|
||||
assertThat(setA.hashCode()).isEqualTo(setB.hashCode());
|
||||
|
||||
setA.add("foo");
|
||||
assertThat(setA).isNotEqualTo(setB);
|
||||
assertThat(setA.hashCode()).isNotEqualTo(setB.hashCode());
|
||||
|
||||
setB.add("foo");
|
||||
assertThat(setA).isEqualTo(setB);
|
||||
assertThat(setA.hashCode()).isEqualTo(setB.hashCode());
|
||||
}
|
||||
}
|
||||
@@ -1,52 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.sql.SQLException;
|
||||
import java.util.UUID;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class ScalarTypeArrayListH2Test extends BasePlatformArrayTypeFactoryTest {
|
||||
|
||||
private final PlatformArrayTypeFactory factory = ScalarTypeArrayListH2.factory();
|
||||
|
||||
@Test
|
||||
public void notSameInstance() {
|
||||
assertThat(factory.typeFor(UUID.class, true))
|
||||
.isNotSameAs(factory.typeFor(UUID.class, false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sameInstance_when_notNull() {
|
||||
assertThat(factory.typeFor(UUID.class, false))
|
||||
.isSameAs(factory.typeFor(UUID.class, false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sameInstance_when_nullable() {
|
||||
assertThat(factory.typeFor(UUID.class, true))
|
||||
.isSameAs(factory.typeFor(UUID.class, true));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void bindNullToEmpty_when_nullableIsFalse() throws SQLException {
|
||||
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(Integer.class, false));
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(Long.class, false));
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(Double.class, false));
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(String.class, false));
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(UUID.class, false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void bindNullToNull_when_nullable() throws SQLException {
|
||||
|
||||
assertBindNullTo_Null(factory.typeFor(Integer.class, true));
|
||||
assertBindNullTo_Null(factory.typeFor(Long.class, true));
|
||||
assertBindNullTo_Null(factory.typeFor(Double.class, true));
|
||||
assertBindNullTo_Null(factory.typeFor(String.class, true));
|
||||
assertBindNullTo_Null(factory.typeFor(UUID.class, true));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,151 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
|
||||
import com.fasterxml.jackson.core.JsonParser;
|
||||
import io.ebean.DB;
|
||||
import io.ebean.core.type.DataReader;
|
||||
import io.ebean.core.type.ScalarType;
|
||||
import io.ebean.text.json.EJson;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.mockito.Mockito;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.StringReader;
|
||||
import java.sql.SQLException;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class ScalarTypeArrayListTest extends BasePlatformArrayTypeFactoryTest {
|
||||
|
||||
private final PlatformArrayTypeFactory factory = ScalarTypeArrayList.factory();
|
||||
|
||||
@Test
|
||||
public void notSameInstance() {
|
||||
assertThat(factory.typeFor(UUID.class, true))
|
||||
.isNotSameAs(factory.typeFor(UUID.class, false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sameInstance_when_notNull() {
|
||||
assertThat(factory.typeFor(UUID.class, false))
|
||||
.isSameAs(factory.typeFor(UUID.class, false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sameInstance_when_nullable() {
|
||||
assertThat(factory.typeFor(UUID.class, true))
|
||||
.isSameAs(factory.typeFor(UUID.class, true));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void read_when_null() throws SQLException {
|
||||
|
||||
DataReader mock = Mockito.mock(DataReader.class);
|
||||
Mockito.when(mock.getArray()).thenReturn(null);
|
||||
|
||||
ScalarType<?> scalarType = ScalarTypeArrayList.factory().typeFor(Long.class, true);
|
||||
scalarType.read(mock);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void bindNullToEmpty_when_nullableIsFalse() throws SQLException {
|
||||
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(Integer.class, false));
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(Long.class, false));
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(Double.class, false));
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(String.class, false));
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(UUID.class, false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void bindNullToNull_when_nullable() throws SQLException {
|
||||
|
||||
assertBindNullTo_Null(factory.typeFor(Integer.class, true));
|
||||
assertBindNullTo_Null(factory.typeFor(Long.class, true));
|
||||
assertBindNullTo_Null(factory.typeFor(Double.class, true));
|
||||
assertBindNullTo_Null(factory.typeFor(String.class, true));
|
||||
assertBindNullTo_Null(factory.typeFor(UUID.class, true));
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void parse_withUuidType_expect_uuidTypeReturned() {
|
||||
|
||||
ScalarType<?> scalarType = factory.typeFor(UUID.class, true);
|
||||
|
||||
List<UUID> input = new ArrayList<>();
|
||||
input.add(UUID.randomUUID());
|
||||
input.add(UUID.randomUUID());
|
||||
|
||||
String formatToJson = scalarType.format(input);
|
||||
|
||||
Object parsed = scalarType.parse(formatToJson);
|
||||
assertThat(parsed).isEqualTo(input);
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void parse_withIntegerType_expect_longIntegerReturned() {
|
||||
|
||||
ScalarType<?> scalarType = factory.typeFor(Integer.class, true);
|
||||
|
||||
List<Integer> input = new ArrayList<>();
|
||||
input.add(2);
|
||||
input.add(4);
|
||||
|
||||
String formatToJson = scalarType.format(input);
|
||||
|
||||
Object parsed = scalarType.parse(formatToJson);
|
||||
assertThat(parsed).isEqualTo(input);
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void parse_withLongType_expect_longTypeReturned() {
|
||||
|
||||
ScalarType<?> scalarType = factory.typeFor(Long.class, true);
|
||||
|
||||
List<Long> input = new ArrayList<>();
|
||||
input.add(2L);
|
||||
input.add(4L);
|
||||
|
||||
String formatToJson = scalarType.format(input);
|
||||
|
||||
Object parsed = scalarType.parse(formatToJson);
|
||||
assertThat(parsed).isEqualTo(input);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parse_withDoubleType_expect_longTypeReturned() {
|
||||
|
||||
ScalarType<?> scalarType = factory.typeFor(Double.class, true);
|
||||
|
||||
List<Double> input = new ArrayList<>();
|
||||
input.add(2D);
|
||||
input.add(4D);
|
||||
|
||||
String formatToJson = scalarType.format(input);
|
||||
|
||||
Object parsed = scalarType.parse(formatToJson);
|
||||
assertThat(parsed).isEqualTo(input);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void jsonRead_withUuidType() throws IOException {
|
||||
|
||||
ScalarType<?> scalarType = factory.typeFor(UUID.class, true);
|
||||
|
||||
List<UUID> input = new ArrayList<>();
|
||||
input.add(UUID.randomUUID());
|
||||
input.add(UUID.randomUUID());
|
||||
String asJson = EJson.write(input);
|
||||
|
||||
JsonParser parser = DB.json().createParser(new StringReader(asJson));
|
||||
|
||||
Object parsed = scalarType.jsonRead(parser);
|
||||
assertThat(parsed).isEqualTo(input);
|
||||
}
|
||||
}
|
||||
@@ -1,138 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import com.fasterxml.jackson.core.JsonParser;
|
||||
import io.ebean.DB;
|
||||
import io.ebean.core.type.ScalarType;
|
||||
import io.ebean.text.json.EJson;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.StringReader;
|
||||
import java.sql.SQLException;
|
||||
import java.util.LinkedHashSet;
|
||||
import java.util.Set;
|
||||
import java.util.UUID;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class ScalarTypeArraySetH2Test extends BasePlatformArrayTypeFactoryTest {
|
||||
|
||||
private final PlatformArrayTypeFactory factory = ScalarTypeArraySetH2.factory();
|
||||
|
||||
@Test
|
||||
public void notSameInstance() {
|
||||
assertThat(factory.typeFor(UUID.class, true))
|
||||
.isNotSameAs(factory.typeFor(UUID.class, false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sameInstance_when_notNull() {
|
||||
assertThat(factory.typeFor(UUID.class, false))
|
||||
.isSameAs(factory.typeFor(UUID.class, false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sameInstance_when_nullable() {
|
||||
assertThat(factory.typeFor(UUID.class, true))
|
||||
.isSameAs(factory.typeFor(UUID.class, true));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void bindNullToEmpty_when_nullableIsFalse() throws SQLException {
|
||||
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(Integer.class, false));
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(Long.class, false));
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(Double.class, false));
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(String.class, false));
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(UUID.class, false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void bindNullToNull_when_nullable() throws SQLException {
|
||||
|
||||
assertBindNullTo_Null(factory.typeFor(Integer.class, true));
|
||||
assertBindNullTo_Null(factory.typeFor(Long.class, true));
|
||||
assertBindNullTo_Null(factory.typeFor(Double.class, true));
|
||||
assertBindNullTo_Null(factory.typeFor(String.class, true));
|
||||
assertBindNullTo_Null(factory.typeFor(UUID.class, true));
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void parse_withUuidType_expect_uuidTypeReturned() {
|
||||
|
||||
ScalarType<?> scalarType = factory.typeFor(UUID.class, true);
|
||||
|
||||
Set<UUID> input = new LinkedHashSet<>();
|
||||
input.add(UUID.randomUUID());
|
||||
input.add(UUID.randomUUID());
|
||||
|
||||
String formatToJson = scalarType.format(input);
|
||||
|
||||
Set<UUID> parsed = (Set<UUID>)scalarType.parse(formatToJson);
|
||||
assertThat(parsed).isEqualTo(input);
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void parse_withIntegerType_expect_longIntegerReturned() {
|
||||
|
||||
ScalarType<?> scalarType = factory.typeFor(Integer.class, true);
|
||||
|
||||
Set<Integer> input = new LinkedHashSet<>();
|
||||
input.add(2);
|
||||
input.add(4);
|
||||
|
||||
String formatToJson = scalarType.format(input);
|
||||
|
||||
Set<Integer> parsed = (Set<Integer>)scalarType.parse(formatToJson);
|
||||
assertThat(parsed).isEqualTo(input);
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void parse_withLongType_expect_longTypeReturned() {
|
||||
|
||||
ScalarType<?> scalarType = factory.typeFor(Long.class, true);
|
||||
|
||||
Set<Long> input = new LinkedHashSet<>();
|
||||
input.add(2L);
|
||||
input.add(4L);
|
||||
|
||||
String formatToJson = scalarType.format(input);
|
||||
|
||||
Set<Long> parsed = (Set<Long>)scalarType.parse(formatToJson);
|
||||
assertThat(parsed).isEqualTo(input);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parse_withDoubleType_expect_longTypeReturned() {
|
||||
|
||||
ScalarType<?> scalarType = factory.typeFor(Double.class, true);
|
||||
|
||||
Set<Double> input = new LinkedHashSet<>();
|
||||
input.add(2D);
|
||||
input.add(4D);
|
||||
|
||||
String formatToJson = scalarType.format(input);
|
||||
|
||||
Object parsed = scalarType.parse(formatToJson);
|
||||
assertThat(parsed).isEqualTo(input);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void jsonRead_withUuidType() throws IOException {
|
||||
|
||||
ScalarType<?> scalarType = factory.typeFor(UUID.class, true);
|
||||
|
||||
Set<UUID> input = new LinkedHashSet<>();
|
||||
input.add(UUID.randomUUID());
|
||||
input.add(UUID.randomUUID());
|
||||
String asJson = EJson.write(input);
|
||||
|
||||
JsonParser parser = DB.json().createParser(new StringReader(asJson));
|
||||
|
||||
Object parsed = scalarType.jsonRead(parser);
|
||||
assertThat(parsed).isEqualTo(input);
|
||||
}
|
||||
}
|
||||
@@ -1,52 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.sql.SQLException;
|
||||
import java.util.UUID;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class ScalarTypeArraySetTest extends BasePlatformArrayTypeFactoryTest {
|
||||
|
||||
private final PlatformArrayTypeFactory factory = ScalarTypeArraySet.factory();
|
||||
|
||||
@Test
|
||||
public void notSameInstance() {
|
||||
assertThat(factory.typeFor(UUID.class, true))
|
||||
.isNotSameAs(factory.typeFor(UUID.class, false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sameInstance_when_notNull() {
|
||||
assertThat(factory.typeFor(UUID.class, false))
|
||||
.isSameAs(factory.typeFor(UUID.class, false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sameInstance_when_nullable() {
|
||||
assertThat(factory.typeFor(UUID.class, true))
|
||||
.isSameAs(factory.typeFor(UUID.class, true));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void bindNullToEmpty_when_nullableIsFalse() throws SQLException {
|
||||
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(Integer.class, false));
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(Long.class, false));
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(Double.class, false));
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(String.class, false));
|
||||
assertBindNullTo_EmptyArray(factory.typeFor(UUID.class, false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void bindNullToNull_when_nullable() throws SQLException {
|
||||
|
||||
assertBindNullTo_Null(factory.typeFor(Integer.class, true));
|
||||
assertBindNullTo_Null(factory.typeFor(Long.class, true));
|
||||
assertBindNullTo_Null(factory.typeFor(Double.class, true));
|
||||
assertBindNullTo_Null(factory.typeFor(String.class, true));
|
||||
assertBindNullTo_Null(factory.typeFor(UUID.class, true));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,55 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
|
||||
import io.ebean.DB;
|
||||
import io.ebean.text.json.JsonContext;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.TOne;
|
||||
|
||||
import java.sql.Types;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
public class ScalarTypeBooleanTest {
|
||||
|
||||
JsonContext jsonContext = DB.getDefault().json();
|
||||
|
||||
@Test
|
||||
public void json_true() {
|
||||
|
||||
TOne bean = new TOne();
|
||||
bean.setId(42);
|
||||
bean.setActive(true);
|
||||
|
||||
String json = jsonContext.toJson(bean);
|
||||
TOne tOne = jsonContext.toBean(TOne.class, json);
|
||||
|
||||
assertTrue(tOne.isActive());
|
||||
assertEquals(json, "{\"id\":42,\"active\":true}");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void json_false() {
|
||||
|
||||
TOne bean = new TOne();
|
||||
bean.setId(42);
|
||||
bean.setActive(false);
|
||||
|
||||
String json = jsonContext.toJson(bean);
|
||||
TOne tOne = jsonContext.toBean(TOne.class, json);
|
||||
|
||||
assertFalse(tOne.isActive());
|
||||
assertEquals(json, "{\"id\":42,\"active\":false}");
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void IntBoolean_isLogicalBoolean() {
|
||||
|
||||
ScalarTypeBoolean.IntBoolean intBoolean = new ScalarTypeBoolean.IntBoolean(1, 0);
|
||||
assertThat(intBoolean).isInstanceOf(ScalarTypeLogicalType.class);
|
||||
|
||||
assertThat(intBoolean.getLogicalType()).isEqualTo(Types.BOOLEAN);
|
||||
}
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebean.config.JsonConfig;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.sql.Types;
|
||||
import java.util.Calendar;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class ScalarTypeCalendarTest {
|
||||
|
||||
private ScalarTypeCalendar type = new ScalarTypeCalendar(JsonConfig.DateTime.ISO8601, Types.TIMESTAMP);
|
||||
|
||||
@Test
|
||||
public void toJsonISO8601() {
|
||||
|
||||
Calendar instance = Calendar.getInstance();
|
||||
String asUtc = type.toJsonISO8601(instance);
|
||||
Calendar calendar = type.fromJsonISO8601(asUtc);
|
||||
|
||||
assertThat(instance).isEqualTo(calendar);
|
||||
}
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebean.config.JsonConfig;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.sql.Date;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
public class ScalarTypeDateTest {
|
||||
|
||||
private ScalarTypeDate type = new ScalarTypeDate(JsonConfig.Date.MILLIS);
|
||||
|
||||
@Test
|
||||
public void formatParse_PG_DATE_POSITIVE_INFINITY() {
|
||||
|
||||
Date postgresInfinityDate = new Date(9223372036825200000L);
|
||||
|
||||
String format = type.formatValue(postgresInfinityDate);
|
||||
Date parsed = type.parse(format);
|
||||
assertEquals(parsed, postgresInfinityDate);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void json() throws IOException {
|
||||
|
||||
|
||||
Date val = new Date(1557360000000L);
|
||||
|
||||
JsonTester<Date> jsonMillis = new JsonTester<>(type);
|
||||
assertThat(jsonMillis.test(val)).isEqualTo("{\"key\":1557360000000}");
|
||||
|
||||
JsonTester<Date> jsonIso = new JsonTester<>(new ScalarTypeDate(JsonConfig.Date.ISO8601));
|
||||
Date val1 = jsonIso.type.parse("2019-05-09");
|
||||
assertThat(jsonIso.test(val1)).isEqualTo("{\"key\":\"2019-05-09\"}");
|
||||
}
|
||||
}
|
||||
@@ -1,103 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebean.text.TextException;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.ObjectInputStream;
|
||||
import java.io.ObjectOutputStream;
|
||||
import java.time.Duration;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
public class ScalarTypeDurationTest {
|
||||
|
||||
ScalarTypeDuration type = new ScalarTypeDuration();
|
||||
|
||||
@Test
|
||||
public void testReadData() throws Exception {
|
||||
|
||||
Duration duration = Duration.ofSeconds(1234);
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
ObjectOutputStream out = new ObjectOutputStream(os);
|
||||
|
||||
type.writeData(out, duration);
|
||||
type.writeData(out, null);
|
||||
out.flush();
|
||||
out.close();
|
||||
|
||||
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
|
||||
ObjectInputStream in = new ObjectInputStream(is);
|
||||
|
||||
Duration val1 = type.readData(in);
|
||||
Duration val2 = type.readData(in);
|
||||
|
||||
assertEquals(duration, val1);
|
||||
assertNull(val2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToJdbcType() throws Exception {
|
||||
|
||||
Duration duration = Duration.ofSeconds(1234);
|
||||
long seconds = duration.getSeconds();
|
||||
|
||||
Object val1 = type.toJdbcType(duration);
|
||||
Object val2 = type.toJdbcType(seconds);
|
||||
|
||||
assertEquals(seconds, val1);
|
||||
assertEquals(seconds, val2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToBeanType() throws Exception {
|
||||
|
||||
Duration duration = Duration.ofSeconds(1234);
|
||||
long seconds = duration.getSeconds();
|
||||
|
||||
Duration val1 = type.toBeanType(duration);
|
||||
Duration val2 = type.toBeanType(seconds);
|
||||
Duration val3 = type.toBeanType((int) seconds);
|
||||
|
||||
assertEquals(duration, val1);
|
||||
assertEquals(duration, val2);
|
||||
assertEquals(duration, val3);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFormatValue() throws Exception {
|
||||
|
||||
Duration duration = Duration.ofSeconds(1234);
|
||||
String formatValue = type.formatValue(duration);
|
||||
assertEquals("PT20M34S", formatValue);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParse() {
|
||||
Duration duration = type.parse("PT20M34S");
|
||||
assertEquals(Duration.ofSeconds(1234), duration);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsDateTimeCapable() {
|
||||
assertFalse(type.isDateTimeCapable());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConvertFromMillis() {
|
||||
assertThrows(TextException.class, () -> type.convertFromMillis(1000));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJsonRead() throws Exception {
|
||||
|
||||
Duration duration = Duration.ofSeconds(1234);
|
||||
|
||||
JsonTester<Duration> jsonTester = new JsonTester<>(type);
|
||||
jsonTester.test(duration);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
-101
@@ -1,101 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebean.text.TextException;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.ObjectInputStream;
|
||||
import java.io.ObjectOutputStream;
|
||||
import java.math.BigDecimal;
|
||||
import java.time.Duration;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
public class ScalarTypeDurationWithNanosTest {
|
||||
|
||||
ScalarTypeDurationWithNanos type = new ScalarTypeDurationWithNanos();
|
||||
|
||||
@Test
|
||||
public void testReadData() throws Exception {
|
||||
|
||||
Duration duration = Duration.ofSeconds(323, 1500000);
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
ObjectOutputStream out = new ObjectOutputStream(os);
|
||||
|
||||
type.writeData(out, duration);
|
||||
type.writeData(out, null);
|
||||
out.flush();
|
||||
out.close();
|
||||
|
||||
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
|
||||
ObjectInputStream in = new ObjectInputStream(is);
|
||||
|
||||
Duration val1 = type.readData(in);
|
||||
Duration val2 = type.readData(in);
|
||||
|
||||
assertEquals(duration, val1);
|
||||
assertNull(val2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToJdbcType() throws Exception {
|
||||
|
||||
Duration duration = Duration.ofSeconds(323, 1500000);
|
||||
BigDecimal bigDecimal = DecimalUtils.toDecimal(duration);
|
||||
|
||||
Object val1 = type.toJdbcType(duration);
|
||||
Object val2 = type.toJdbcType(bigDecimal);
|
||||
|
||||
assertEquals(bigDecimal, val1);
|
||||
assertEquals(bigDecimal, val2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToBeanType() throws Exception {
|
||||
|
||||
Duration duration = Duration.ofSeconds(323, 1500000);
|
||||
BigDecimal bigDecimal = DecimalUtils.toDecimal(duration);
|
||||
|
||||
Duration val1 = type.toBeanType(duration);
|
||||
Duration val2 = type.toBeanType(bigDecimal);
|
||||
|
||||
assertEquals(duration, val1);
|
||||
assertEquals(duration, val2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFormatValue() throws Exception {
|
||||
|
||||
Duration duration = Duration.ofSeconds(323, 1500000);
|
||||
String formatValue = type.formatValue(duration);
|
||||
assertEquals("PT5M23.0015S", formatValue);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParse() {
|
||||
Duration duration = Duration.ofSeconds(323, 1500000);
|
||||
Duration val1 = type.parse("PT5M23.0015S");
|
||||
assertEquals(duration, val1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsDateTimeCapable() {
|
||||
assertFalse(type.isDateTimeCapable());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConvertFromMillis() {
|
||||
assertThrows(TextException.class, () -> type.convertFromMillis(1000));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJsonRead() throws Exception {
|
||||
Duration duration = Duration.ofSeconds(323, 1500000);
|
||||
|
||||
JsonTester<Duration> jsonTester = new JsonTester<>(type);
|
||||
jsonTester.test(duration);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,153 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebean.config.JsonConfig;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.ObjectInputStream;
|
||||
import java.io.ObjectOutputStream;
|
||||
import java.sql.Timestamp;
|
||||
import java.time.Instant;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
public class ScalarTypeInstantTest {
|
||||
|
||||
ScalarTypeInstant type = new ScalarTypeInstant(JsonConfig.DateTime.MILLIS);
|
||||
|
||||
private Instant now() {
|
||||
// in JDK11 Instant.now() returns a nanosecond precise instant.
|
||||
// as ScalarTypeInstant is only milliSecond precise, tests may fail with
|
||||
// expected:<2019-02-10T15:39:36.702700200Z> but was:<2019-02-10T15:39:36.702Z>
|
||||
// if we use Instant.now() - so we use this workaround here.
|
||||
return Instant.ofEpochMilli(System.currentTimeMillis());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testReadData() throws Exception {
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
ObjectOutputStream out = new ObjectOutputStream(os);
|
||||
|
||||
Instant now = now();
|
||||
type.writeData(out, now);
|
||||
type.writeData(out, null);
|
||||
out.flush();
|
||||
out.close();
|
||||
|
||||
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
|
||||
ObjectInputStream in = new ObjectInputStream(is);
|
||||
|
||||
Instant val1 = type.readData(in);
|
||||
Instant val2 = type.readData(in);
|
||||
|
||||
assertEquals(now, val1);
|
||||
assertNull(val2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToJdbcType() throws Exception {
|
||||
|
||||
Instant now = now();
|
||||
Timestamp timestamp = Timestamp.from(now);
|
||||
Object val1 = type.toJdbcType(now);
|
||||
Object val2 = type.toJdbcType(timestamp);
|
||||
|
||||
assertEquals(timestamp, val1);
|
||||
assertEquals(timestamp, val2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToBeanType() throws Exception {
|
||||
|
||||
Instant now = now();
|
||||
Instant val1 = type.toBeanType(now);
|
||||
Instant val2 = type.toBeanType(Timestamp.from(now));
|
||||
|
||||
assertEquals(now, val1);
|
||||
assertEquals(now, val2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFormatValue() throws Exception {
|
||||
|
||||
Instant now = now();
|
||||
Timestamp timestamp = Timestamp.from(now);
|
||||
String formatted = type.formatValue(now);
|
||||
assertEquals("" + timestamp.getTime(), formatted);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParse_when_epochMillis() throws Exception {
|
||||
|
||||
Instant now = now();
|
||||
Timestamp timestamp = Timestamp.from(now);
|
||||
Instant val1 = type.parse("" + timestamp.getTime());
|
||||
assertEquals(now, val1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParse_when_timestampForm() throws Exception {
|
||||
|
||||
Instant now = now();
|
||||
Timestamp timestamp = Timestamp.from(now);
|
||||
Instant val1 = type.parse(timestamp.toString());
|
||||
assertEquals(now, val1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFormatAndParse() throws Exception {
|
||||
|
||||
Instant now = now();
|
||||
|
||||
String format = type.format(now);
|
||||
Instant val1 = type.parse(format);
|
||||
assertEquals(now, val1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsDateTimeCapable() throws Exception {
|
||||
|
||||
assertTrue(type.isDateTimeCapable());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConvertFromMillis() throws Exception {
|
||||
|
||||
Instant now = now();
|
||||
Instant val = type.convertFromMillis(now.toEpochMilli());
|
||||
assertEquals(now, val);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJsonRead() throws Exception {
|
||||
|
||||
Instant now = now();
|
||||
|
||||
JsonTester<Instant> jsonTester = new JsonTester<>(type);
|
||||
jsonTester.test(now);
|
||||
|
||||
ScalarTypeInstant typeNanos = new ScalarTypeInstant(JsonConfig.DateTime.NANOS);
|
||||
jsonTester = new JsonTester<>(typeNanos);
|
||||
jsonTester.test(now);
|
||||
|
||||
ScalarTypeInstant typeIso = new ScalarTypeInstant(JsonConfig.DateTime.ISO8601);
|
||||
jsonTester = new JsonTester<>(typeIso);
|
||||
jsonTester.test(now);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isoJsonParseFormat() {
|
||||
|
||||
ScalarTypeInstant typeIso = new ScalarTypeInstant(JsonConfig.DateTime.ISO8601);
|
||||
|
||||
Instant instant = Instant.now();
|
||||
String asJson = typeIso.toJsonISO8601(instant);
|
||||
|
||||
Instant value = typeIso.fromJsonISO8601(asJson);
|
||||
assertThat(instant).isEqualTo(value);
|
||||
}
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class ScalarTypeIntegerTest {
|
||||
|
||||
private final ScalarTypeInteger type = new ScalarTypeInteger();
|
||||
|
||||
@Test
|
||||
public void format_when_string() {
|
||||
assertThat(type.format("1")).isEqualTo("1");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void format_when_integer() {
|
||||
assertThat(type.format(1)).isEqualTo("1");
|
||||
}
|
||||
|
||||
}
|
||||
-92
@@ -1,92 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebean.config.JsonConfig;
|
||||
import org.joda.time.LocalDate;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.sql.Date;
|
||||
import java.util.TimeZone;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
|
||||
public class ScalarTypeJodaLocalDateTest {
|
||||
|
||||
private ScalarTypeJodaLocalDate type = new ScalarTypeJodaLocalDate(JsonConfig.Date.MILLIS);
|
||||
|
||||
@Test
|
||||
public void convertToMillis_convertFromMillis() {
|
||||
|
||||
LocalDate localDate = new LocalDate();
|
||||
long millis = type.convertToMillis(localDate);
|
||||
LocalDate localDate1 = type.convertFromMillis(millis);
|
||||
|
||||
assertThat(localDate).isEqualTo(localDate1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void convertToDate_convertFromDate_westOfUtc() {
|
||||
final TimeZone originaDefaultTimezone = TimeZone.getDefault();
|
||||
try {
|
||||
TimeZone.setDefault(TimeZone.getTimeZone("America/Chicago"));
|
||||
|
||||
convertDate(new LocalDate());
|
||||
convertDate(new LocalDate(1899, 12, 1));
|
||||
convertDate(new LocalDate(1900, 1, 1));
|
||||
convertDate(new LocalDate(2021, 2, 8));
|
||||
|
||||
} finally {
|
||||
TimeZone.setDefault(originaDefaultTimezone);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void convertToDate_convertFromDate() {
|
||||
|
||||
convertDate(new LocalDate());
|
||||
convertDate(new LocalDate(1899, 12, 1));
|
||||
convertDate(new LocalDate(1900, 1, 1));
|
||||
convertDate(new LocalDate(2021, 2, 8));
|
||||
}
|
||||
|
||||
private void convertDate(LocalDate localDate) {
|
||||
|
||||
Date dateValue = type.convertToDate(localDate);
|
||||
LocalDate localDate1 = type.convertFromDate(dateValue);
|
||||
|
||||
assertThat(localDate).isEqualTo(localDate1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void toJdbcType() {
|
||||
|
||||
LocalDate localDate = new LocalDate();
|
||||
Object jdbcType = type.toJdbcType(localDate);
|
||||
Date dateValue = type.convertToDate(localDate);
|
||||
|
||||
assertThat(jdbcType).isEqualTo(dateValue);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void toBeanType() {
|
||||
|
||||
LocalDate localDate = new LocalDate();
|
||||
Date dateValue = type.convertToDate(localDate);
|
||||
LocalDate beanType = type.toBeanType(dateValue);
|
||||
|
||||
assertThat(beanType).isEqualTo(localDate);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void json() throws IOException {
|
||||
|
||||
LocalDate val = new LocalDate(2019, 5, 9);
|
||||
|
||||
JsonTester<LocalDate> jsonMillis = new JsonTester<>(type);
|
||||
assertThat(jsonMillis.test(val)).isEqualTo("{\"key\":1557360000000}");
|
||||
|
||||
JsonTester<LocalDate> jsonIso = new JsonTester<>(new ScalarTypeJodaLocalDate(JsonConfig.Date.ISO8601) );
|
||||
assertThat(jsonIso.test(val)).isEqualTo("{\"key\":\"2019-05-09\"}");
|
||||
}
|
||||
}
|
||||
-43
@@ -1,43 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebean.config.JsonConfig;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.joda.time.LocalDateTime;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.sql.Timestamp;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
public class ScalarTypeJodaLocalDateTimeTest {
|
||||
|
||||
ScalarTypeJodaLocalDateTime type = new ScalarTypeJodaLocalDateTime(JsonConfig.DateTime.ISO8601);
|
||||
|
||||
@Test
|
||||
public void testConvertFromTimestamp() throws Exception {
|
||||
|
||||
long now = System.currentTimeMillis();
|
||||
Timestamp nowTs = new Timestamp(now);
|
||||
|
||||
LocalDateTime ldt1 = type.convertFromTimestamp(nowTs);
|
||||
LocalDateTime ldt2 = localConvertFromTimestamp(nowTs);
|
||||
|
||||
assertEquals(ldt1, ldt2);
|
||||
|
||||
Timestamp ts1 = type.convertToTimestamp(ldt1);
|
||||
Timestamp ts2 = localConvertToTimestamp(ldt2);
|
||||
|
||||
assertEquals(ts1, ts2);
|
||||
}
|
||||
|
||||
|
||||
LocalDateTime localConvertFromTimestamp(Timestamp ts) {
|
||||
return new LocalDateTime(ts.getTime(), DateTimeZone.getDefault());
|
||||
}
|
||||
|
||||
|
||||
Timestamp localConvertToTimestamp(LocalDateTime t) {
|
||||
return new Timestamp(t.toDateTime(DateTimeZone.getDefault()).getMillis());
|
||||
}
|
||||
|
||||
}
|
||||
-63
@@ -1,63 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebean.DB;
|
||||
import org.joda.time.DateTimeZone;
|
||||
import org.joda.time.LocalDateTime;
|
||||
import org.joda.time.LocalTime;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.tests.model.basic.TJodaEntity;
|
||||
|
||||
import java.sql.Timestamp;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
public class ScalarTypeJodaLocalTimeTest {
|
||||
|
||||
ScalarTypeJodaLocalTime type = new ScalarTypeJodaLocalTime();
|
||||
|
||||
@Test
|
||||
public void toJdbcType_toBeanType() {
|
||||
|
||||
LocalTime localTime0 = new LocalTime().withMillisOfSecond(0);
|
||||
Object time = type.toJdbcType(localTime0);
|
||||
LocalTime localTime1 = type.toBeanType(time);
|
||||
|
||||
assertThat(localTime0).isEqualTo(localTime1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void test() {
|
||||
|
||||
long now = System.currentTimeMillis();
|
||||
|
||||
//DateTimeZone timeZone = DateTimeZone.getDefault();
|
||||
//ISOChronology instance = ISOChronology.getInstance();
|
||||
|
||||
LocalDateTime ldt1 = new LocalDateTime(now, DateTimeZone.getDefault());
|
||||
LocalDateTime ldt2 = new LocalDateTime(now);
|
||||
|
||||
assertEquals(ldt1, ldt2);
|
||||
|
||||
Timestamp ts1 = new Timestamp(ldt1.toDateTime(DateTimeZone.getDefault()).getMillis());
|
||||
Timestamp ts2 = new Timestamp(ldt2.toDateTime().getMillis());
|
||||
|
||||
assertEquals(ts1, ts2);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void toJson() {
|
||||
|
||||
LocalTime now = new LocalTime();
|
||||
|
||||
TJodaEntity bean = new TJodaEntity();
|
||||
bean.setId(42);
|
||||
bean.setLocalTime(now);
|
||||
|
||||
String json = DB.json().toJson(bean);
|
||||
TJodaEntity bean1 = DB.json().toBean(TJodaEntity.class, json);
|
||||
|
||||
assertEquals(bean1.getLocalTime(), now);
|
||||
}
|
||||
}
|
||||
@@ -1,43 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import org.joda.time.Period;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class ScalarTypeJodaPeriodTest {
|
||||
|
||||
private ScalarTypeJodaPeriod scalarType = new ScalarTypeJodaPeriod();
|
||||
|
||||
@Test
|
||||
public void getLength() {
|
||||
assertThat(scalarType.getLength()).isEqualTo(50);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void formatAndParse() {
|
||||
|
||||
Period original = Period.years(1).plusMonths(2).plusDays(4)
|
||||
.plusHours(12).plusMinutes(19).plusSeconds(20);
|
||||
|
||||
String value = scalarType.formatValue(original);
|
||||
assertThat(value).isEqualTo("P1Y2M4DT12H19M20S");
|
||||
|
||||
Period period = scalarType.parse(value);
|
||||
assertThat(period).isEqualTo(original);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void convertFromDbString() {
|
||||
|
||||
Period original = Period.years(1).plusMonths(2).plusDays(4)
|
||||
.plusHours(23).plusMinutes(19).plusSeconds(20).plusMillis(987);
|
||||
|
||||
String stringVal = scalarType.convertToDbString(original);
|
||||
Period period = scalarType.convertFromDbString(stringVal);
|
||||
|
||||
assertThat(period).isEqualTo(original);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebean.config.dbplatform.ExtraDbTypes;
|
||||
import io.ebean.core.type.DocPropertyType;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.sql.SQLException;
|
||||
|
||||
public class ScalarTypeJsonListTest extends BasePlatformArrayTypeFactoryTest {
|
||||
|
||||
@Test
|
||||
public void typeFor_expect_nullToEmpty_when_postgresNonNull() throws SQLException {
|
||||
|
||||
assertBindNullTo_PGObjectEmpty(ScalarTypeJsonList.typeFor(true, ExtraDbTypes.JSONB, DocPropertyType.OBJECT, false, false));
|
||||
assertBindNullTo_PGObjectEmpty(ScalarTypeJsonList.typeFor(true, ExtraDbTypes.JSON, DocPropertyType.OBJECT, false, false));
|
||||
|
||||
assertBindNullTo_EmptyString(ScalarTypeJsonList.typeFor(true, ExtraDbTypes.JSONVarchar, DocPropertyType.OBJECT, false, false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void typeFor_expect_nullToNull_when_nullable() throws SQLException {
|
||||
|
||||
assertBindNullTo_PGObjectNull(ScalarTypeJsonList.typeFor(true, ExtraDbTypes.JSONB, DocPropertyType.OBJECT, true, false));
|
||||
assertBindNullTo_PGObjectNull(ScalarTypeJsonList.typeFor(true, ExtraDbTypes.JSON, DocPropertyType.OBJECT, true, false));
|
||||
|
||||
assertBindNullTo_Null(ScalarTypeJsonList.typeFor(true, ExtraDbTypes.JSONVarchar, DocPropertyType.OBJECT, true, false));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,79 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebean.config.JsonConfig;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.sql.Date;
|
||||
import java.time.LocalDate;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
public class ScalarTypeLocalDateTest {
|
||||
|
||||
ScalarTypeLocalDate type = new ScalarTypeLocalDate(JsonConfig.Date.ISO8601);
|
||||
|
||||
@Test
|
||||
public void testConvertToMillis() {
|
||||
|
||||
LocalDate date = LocalDate.of(2014, 5, 20);
|
||||
long millis = type.convertToMillis(date);
|
||||
|
||||
LocalDate parseDate = type.convertFromMillis(millis);
|
||||
assertEquals(date, parseDate);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConvertFromDate() {
|
||||
|
||||
LocalDate localDate = LocalDate.now();
|
||||
Date date = Date.valueOf(localDate);
|
||||
|
||||
LocalDate localDate1 = type.convertFromDate(date);
|
||||
assertEquals(localDate, localDate1);
|
||||
|
||||
Date date1 = type.convertToDate(localDate);
|
||||
assertEquals(date, date1);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testToJdbcType() {
|
||||
|
||||
LocalDate localDate = LocalDate.now();
|
||||
Object o = type.toJdbcType(localDate);
|
||||
assertTrue(o instanceof Date);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void olderDates_ToFromJdbcType() {
|
||||
LocalDate localDate = LocalDate.of(1850,12,1);
|
||||
Object o = type.toJdbcType(localDate);
|
||||
LocalDate localDate1 = type.toBeanType(o);
|
||||
assertThat(localDate1).isEqualTo(localDate);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToBeanType() {
|
||||
|
||||
LocalDate localDate = LocalDate.now();
|
||||
Date date = Date.valueOf(localDate);
|
||||
|
||||
LocalDate localDate1 = type.toBeanType(date);
|
||||
assertEquals(localDate, localDate1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void json() throws IOException {
|
||||
|
||||
LocalDate val = LocalDate.of(2019, 5, 9);
|
||||
|
||||
JsonTester<LocalDate> jsonMillis = new JsonTester<>(new ScalarTypeLocalDate(JsonConfig.Date.MILLIS));
|
||||
assertThat(jsonMillis.test(val)).isEqualTo("{\"key\":1557360000000}");
|
||||
|
||||
JsonTester<LocalDate> jsonIso = new JsonTester<>(new ScalarTypeLocalDate(JsonConfig.Date.ISO8601) );
|
||||
assertThat(jsonIso.test(val)).isEqualTo("{\"key\":\"2019-05-09\"}");
|
||||
}
|
||||
}
|
||||
-144
@@ -1,144 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import com.fasterxml.jackson.core.JsonFactory;
|
||||
import com.fasterxml.jackson.core.JsonGenerator;
|
||||
import io.ebean.config.JsonConfig;
|
||||
|
||||
import org.junit.jupiter.api.Disabled;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.StringWriter;
|
||||
import java.sql.Timestamp;
|
||||
import java.time.LocalDateTime;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
public class ScalarTypeLocalDateTimeTest {
|
||||
|
||||
private final ScalarTypeLocalDateTime type = new ScalarTypeLocalDateTime(JsonConfig.DateTime.MILLIS);
|
||||
|
||||
private final JsonFactory factory = new JsonFactory();
|
||||
|
||||
// warm up
|
||||
private final LocalDateTime warmUp = LocalDateTime.now();
|
||||
|
||||
@Test
|
||||
public void testNowToMillis() {
|
||||
|
||||
warmUp.hashCode();
|
||||
|
||||
long now = System.currentTimeMillis();
|
||||
long toMillis = type.convertToMillis(LocalDateTime.now());
|
||||
assertTrue(toMillis - now < 30);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConvertToMillis() {
|
||||
|
||||
LocalDateTime now = LocalDateTime.now().withNano(123_000_000); // jdk11 workaround
|
||||
long asMillis = type.convertToMillis(now);
|
||||
LocalDateTime fromMillis = type.convertFromMillis(asMillis);
|
||||
|
||||
assertEquals(now, fromMillis);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConvertFromTimestamp() {
|
||||
|
||||
Timestamp now = new Timestamp(System.currentTimeMillis());
|
||||
|
||||
LocalDateTime localDateTime = type.convertFromTimestamp(now);
|
||||
Timestamp timestamp = type.convertToTimestamp(localDateTime);
|
||||
|
||||
assertEquals(now, timestamp);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testToJdbcType() throws Exception {
|
||||
|
||||
Object jdbcType = type.toJdbcType(LocalDateTime.now());
|
||||
assertTrue(jdbcType instanceof Timestamp);
|
||||
|
||||
jdbcType = type.toJdbcType(new Timestamp(System.currentTimeMillis()));
|
||||
assertTrue(jdbcType instanceof Timestamp);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToBeanType() throws Exception {
|
||||
|
||||
Timestamp timestamp = new Timestamp(System.currentTimeMillis());
|
||||
LocalDateTime val1 = type.toBeanType(timestamp);
|
||||
assertNotNull(val1);
|
||||
|
||||
LocalDateTime val2 = type.toBeanType(timestamp.toLocalDateTime());
|
||||
assertNotNull(val2);
|
||||
|
||||
Timestamp timestamp1 = type.convertToTimestamp(val1);
|
||||
assertEquals(timestamp, timestamp1);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testJsonRaw() throws Exception {
|
||||
|
||||
final LocalDateTime of = LocalDateTime.of(2020, 5, 4, 13, 20, 40);
|
||||
|
||||
ScalarTypeLocalDateTime typeIso = new ScalarTypeLocalDateTime(JsonConfig.DateTime.ISO8601);
|
||||
|
||||
StringWriter writer = new StringWriter();
|
||||
JsonGenerator generator = factory.createGenerator(writer);
|
||||
|
||||
typeIso.jsonWrite(generator, of);
|
||||
generator.flush();
|
||||
|
||||
assertThat(of.toString()).isEqualTo("2020-05-04T13:20:40");
|
||||
assertThat(writer.toString()).isEqualTo("\"2020-05-04T13:20:40\"");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJson() throws Exception {
|
||||
|
||||
LocalDateTime now = LocalDateTime.now().withNano(123_000_000); // jdk11 workaround
|
||||
|
||||
JsonTester<LocalDateTime> jsonTester = new JsonTester<>(type);
|
||||
jsonTester.test(now);
|
||||
|
||||
ScalarTypeLocalDateTime typeNanos = new ScalarTypeLocalDateTime(JsonConfig.DateTime.NANOS);
|
||||
jsonTester = new JsonTester<>(typeNanos);
|
||||
jsonTester.test(now);
|
||||
|
||||
ScalarTypeLocalDateTime typeIso = new ScalarTypeLocalDateTime(JsonConfig.DateTime.ISO8601);
|
||||
jsonTester = new JsonTester<>(typeIso);
|
||||
jsonTester.test(now);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isoJsonFormatParse() {
|
||||
|
||||
ScalarTypeLocalDateTime typeIso = new ScalarTypeLocalDateTime(JsonConfig.DateTime.ISO8601);
|
||||
|
||||
LocalDateTime localDateTime = LocalDateTime.now();
|
||||
String asJson = typeIso.toJsonISO8601(localDateTime);
|
||||
|
||||
LocalDateTime value = typeIso.fromJsonISO8601(asJson);
|
||||
assertThat(localDateTime).isEqualToIgnoringNanos(value);
|
||||
}
|
||||
|
||||
@Test
|
||||
@Disabled("Does not work @github due different timezone")
|
||||
// Expecting actual:
|
||||
// 2018-02-03T03:05:06 (java.time.LocalDateTime)
|
||||
// to have same year, month, day, hour, minute and second as:
|
||||
// 2018-02-03T04:05:06 (java.time.LocalDateTime)
|
||||
public void testParseEbean11() {
|
||||
|
||||
ScalarTypeLocalDateTime typeDefault = new ScalarTypeLocalDateTime(JsonConfig.DateTime.ISO8601);
|
||||
|
||||
LocalDateTime fromMillis = typeDefault.parse("1517627106000");
|
||||
LocalDateTime fromIso= typeDefault.parse("2018-02-03T04:05:06");
|
||||
|
||||
assertThat(fromMillis).isEqualToIgnoringNanos(fromIso);
|
||||
}
|
||||
}
|
||||
@@ -1,98 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebean.text.TextException;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.ObjectInputStream;
|
||||
import java.io.ObjectOutputStream;
|
||||
import java.sql.Time;
|
||||
import java.time.LocalTime;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
public class ScalarTypeLocalTimeTest {
|
||||
|
||||
ScalarTypeLocalTime type = new ScalarTypeLocalTime();
|
||||
|
||||
@Test
|
||||
public void testReadData() throws Exception {
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
ObjectOutputStream out = new ObjectOutputStream(os);
|
||||
|
||||
LocalTime localTime = LocalTime.of(9, 23, 45);
|
||||
type.writeData(out, localTime);
|
||||
type.writeData(out, null);
|
||||
out.flush();
|
||||
out.close();
|
||||
|
||||
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
|
||||
ObjectInputStream in = new ObjectInputStream(is);
|
||||
|
||||
LocalTime val1 = type.readData(in);
|
||||
LocalTime val2 = type.readData(in);
|
||||
|
||||
assertEquals(localTime, val1);
|
||||
assertNull(val2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToJdbcType() throws Exception {
|
||||
|
||||
LocalTime localTime = LocalTime.of(9, 23, 45, 123);
|
||||
Time time = Time.valueOf(localTime);
|
||||
|
||||
Object val1 = type.toJdbcType(localTime);
|
||||
Object val2 = type.toJdbcType(time);
|
||||
|
||||
assertEquals(time, val1);
|
||||
assertEquals(time, val2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToBeanType() throws Exception {
|
||||
|
||||
LocalTime localTime = LocalTime.of(9, 23, 45);
|
||||
LocalTime val1 = type.toBeanType(localTime);
|
||||
LocalTime val2 = type.toBeanType(Time.valueOf(localTime));
|
||||
|
||||
assertEquals(localTime, val1);
|
||||
assertEquals(localTime, val2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFormatValue() throws Exception {
|
||||
|
||||
LocalTime localTime = LocalTime.of(9, 23, 45);
|
||||
String formatted = type.formatValue(localTime);
|
||||
assertEquals("09:23:45", formatted);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParse() {
|
||||
LocalTime localTime = LocalTime.of(9, 23, 45);
|
||||
LocalTime val1 = type.parse("09:23:45");
|
||||
assertEquals(localTime, val1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsDateTimeCapable() {
|
||||
assertFalse(type.isDateTimeCapable());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConvertFromMillis() {
|
||||
assertThrows(TextException.class, () -> type.convertFromMillis(1234));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJsonRead() throws Exception {
|
||||
LocalTime localTime = LocalTime.of(9, 23, 45);
|
||||
|
||||
JsonTester<LocalTime> jsonTester = new JsonTester<>(type);
|
||||
jsonTester.test(localTime);
|
||||
}
|
||||
|
||||
}
|
||||
-97
@@ -1,97 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebean.text.TextException;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.ObjectInputStream;
|
||||
import java.io.ObjectOutputStream;
|
||||
import java.time.LocalTime;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
public class ScalarTypeLocalTimeWithNanosTest {
|
||||
|
||||
ScalarTypeLocalTimeWithNanos type = new ScalarTypeLocalTimeWithNanos();
|
||||
|
||||
@Test
|
||||
public void testReadData() throws Exception {
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
ObjectOutputStream out = new ObjectOutputStream(os);
|
||||
|
||||
LocalTime localTime = LocalTime.of(9, 23, 45, 115);
|
||||
type.writeData(out, localTime);
|
||||
type.writeData(out, null);
|
||||
out.flush();
|
||||
out.close();
|
||||
|
||||
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
|
||||
ObjectInputStream in = new ObjectInputStream(is);
|
||||
|
||||
LocalTime val1 = type.readData(in);
|
||||
LocalTime val2 = type.readData(in);
|
||||
|
||||
assertEquals(localTime, val1);
|
||||
assertNull(val2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToJdbcType() throws Exception {
|
||||
|
||||
LocalTime localTime = LocalTime.of(9, 23, 45, 115);
|
||||
long asNanos = localTime.toNanoOfDay();
|
||||
Object val1 = type.toJdbcType(localTime);
|
||||
Object val2 = type.toJdbcType(asNanos);
|
||||
|
||||
assertEquals(asNanos, val1);
|
||||
assertEquals(asNanos, val2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToBeanType() throws Exception {
|
||||
|
||||
LocalTime localTime = LocalTime.of(9, 23, 45);
|
||||
LocalTime val1 = type.toBeanType(localTime);
|
||||
LocalTime val2 = type.toBeanType(localTime.toNanoOfDay());
|
||||
|
||||
assertEquals(localTime, val1);
|
||||
assertEquals(localTime, val2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFormatValue() throws Exception {
|
||||
LocalTime localTime = LocalTime.of(9, 23, 45);
|
||||
String formatted = type.formatValue(localTime);
|
||||
assertEquals("09:23:45", formatted);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParse() {
|
||||
LocalTime localTime = LocalTime.of(9, 23, 45);
|
||||
LocalTime val1 = type.parse("09:23:45");
|
||||
assertEquals(localTime, val1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsDateTimeCapable() {
|
||||
assertFalse(type.isDateTimeCapable());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConvertFromMillis() {
|
||||
assertThrows(TextException.class, () -> type.convertFromMillis(1234));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJsonRead() throws Exception {
|
||||
LocalTime localTime = LocalTime.of(9, 23, 45);
|
||||
|
||||
JsonTester<LocalTime> jsonTester = new JsonTester<>(type);
|
||||
jsonTester.test(localTime);
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -1,22 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class ScalarTypeLongTest {
|
||||
|
||||
private final ScalarTypeLong type = new ScalarTypeLong();
|
||||
|
||||
@Test
|
||||
public void format_when_string() {
|
||||
assertThat(type.format("1")).isEqualTo("1");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void format_when_long() {
|
||||
assertThat(type.format(1L)).isEqualTo("1");
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,68 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.sql.Date;
|
||||
import java.time.LocalDate;
|
||||
import java.time.MonthDay;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
public class ScalarTypeMonthDayTest {
|
||||
|
||||
ScalarTypeMonthDay type = new ScalarTypeMonthDay();
|
||||
|
||||
@Test
|
||||
public void testToJdbcType() throws Exception {
|
||||
|
||||
MonthDay value = MonthDay.of(4, 29);
|
||||
Date date = Date.valueOf(LocalDate.of(2000, 4, 29));
|
||||
|
||||
Object val1 = type.toJdbcType(value);
|
||||
Object val2 = type.toJdbcType(date);
|
||||
|
||||
assertEquals(date, val1);
|
||||
assertEquals(date, val2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToBeanType() throws Exception {
|
||||
|
||||
MonthDay value = MonthDay.of(4, 29);
|
||||
Date date = Date.valueOf(LocalDate.of(2000, 4, 29));
|
||||
|
||||
MonthDay val1 = type.toBeanType(value);
|
||||
MonthDay val2 = type.toBeanType(date);
|
||||
|
||||
assertEquals(value, val1);
|
||||
assertEquals(value, val2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFormatParse() {
|
||||
MonthDay value = MonthDay.of(4, 29);
|
||||
String val1 = type.formatValue(value);
|
||||
MonthDay monthDay = type.parse(val1);
|
||||
|
||||
assertEquals("--04-29", val1);
|
||||
assertEquals(value, monthDay);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsDateTimeCapable() {
|
||||
assertFalse(type.isDateTimeCapable());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConvertFromMillis() {
|
||||
assertThrows(RuntimeException.class, () -> type.convertFromMillis(1203));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJson() throws Exception {
|
||||
MonthDay value = MonthDay.of(4, 29);
|
||||
JsonTester<MonthDay> jsonTester = new JsonTester<>(type);
|
||||
jsonTester.test(value);
|
||||
}
|
||||
|
||||
}
|
||||
-128
@@ -1,128 +0,0 @@
|
||||
package io.ebeaninternal.server.type;
|
||||
|
||||
import io.ebean.config.JsonConfig;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.sql.Timestamp;
|
||||
import java.time.OffsetDateTime;
|
||||
import java.time.ZoneOffset;
|
||||
import java.util.TimeZone;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
public class ScalarTypeOffsetDateTimeTest {
|
||||
|
||||
|
||||
ScalarTypeOffsetDateTime type = new ScalarTypeOffsetDateTime(JsonConfig.DateTime.MILLIS, ZoneOffset.systemDefault());
|
||||
|
||||
OffsetDateTime warmUp = OffsetDateTime.now();
|
||||
|
||||
@Test
|
||||
public void testConvertToMillis() {
|
||||
|
||||
warmUp.hashCode();
|
||||
|
||||
long now = System.currentTimeMillis();
|
||||
long toMillis = type.convertToMillis(OffsetDateTime.now());
|
||||
|
||||
assertTrue(toMillis - now < 10);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void convertFromInstant_with_UTC_expect_matchingZoneOffset() {
|
||||
final TimeZone timeZoneToUse = TimeZone.getTimeZone("UTC");
|
||||
final ZoneOffset expectedZoneOffset = ZoneOffset.UTC;
|
||||
|
||||
convertFromInstantWithConfiguredTimeZone(timeZoneToUse, expectedZoneOffset);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void convertFromInstant_with_EST_expect_matchingZoneOffset() {
|
||||
final TimeZone timeZoneToUse = TimeZone.getTimeZone("EST");
|
||||
final ZoneOffset expectedOffset = OffsetDateTime.now(timeZoneToUse.toZoneId()).getOffset();
|
||||
|
||||
convertFromInstantWithConfiguredTimeZone(timeZoneToUse, expectedOffset);
|
||||
}
|
||||
|
||||
private void convertFromInstantWithConfiguredTimeZone(TimeZone timeZoneToUse, ZoneOffset expectedZoneOffset) {
|
||||
TimeZone previous = TimeZone.getDefault();
|
||||
try {
|
||||
OffsetDateTime dateTime = OffsetDateTime.parse("2021-01-01T00:00:00+11:00");
|
||||
|
||||
// test ScalarTypeOffsetDateTime with the configured timeZone to use
|
||||
ScalarTypeOffsetDateTime type = new ScalarTypeOffsetDateTime(JsonConfig.DateTime.MILLIS, timeZoneToUse.toZoneId());
|
||||
|
||||
// effectively we desire to ignore the system timezone and use the configured one
|
||||
TimeZone.setDefault(timeZoneToUse);
|
||||
|
||||
final OffsetDateTime offsetDateTime = type.convertFromInstant(dateTime.toInstant());
|
||||
|
||||
assertEquals(expectedZoneOffset, offsetDateTime.getOffset());
|
||||
|
||||
} finally {
|
||||
TimeZone.setDefault(previous);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConvertFromTimestamp() {
|
||||
|
||||
Timestamp now = new Timestamp(System.currentTimeMillis());
|
||||
|
||||
OffsetDateTime localDateTime = type.convertFromTimestamp(now);
|
||||
Timestamp timestamp = type.convertToTimestamp(localDateTime);
|
||||
|
||||
assertEquals(now, timestamp);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testToJdbcType() throws Exception {
|
||||
|
||||
Object jdbcType = type.toJdbcType(OffsetDateTime.now());
|
||||
assertTrue(jdbcType instanceof Timestamp);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToBeanType() throws Exception {
|
||||
|
||||
Timestamp timestamp = new Timestamp(System.currentTimeMillis());
|
||||
OffsetDateTime localDateTime = type.toBeanType(timestamp);
|
||||
|
||||
assertNotNull(localDateTime);
|
||||
|
||||
Timestamp timestamp1 = type.convertToTimestamp(localDateTime);
|
||||
assertEquals(timestamp, timestamp1);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJson() throws Exception {
|
||||
|
||||
OffsetDateTime now = OffsetDateTime.now().withNano(123_000_000); // jdk11 workaround
|
||||
|
||||
JsonTester<OffsetDateTime> jsonTester = new JsonTester<>(type);
|
||||
jsonTester.test(now);
|
||||
|
||||
ScalarTypeOffsetDateTime typeNanos = new ScalarTypeOffsetDateTime(JsonConfig.DateTime.NANOS, ZoneOffset.systemDefault());
|
||||
jsonTester = new JsonTester<>(typeNanos);
|
||||
jsonTester.test(now);
|
||||
|
||||
ScalarTypeOffsetDateTime typeIso = new ScalarTypeOffsetDateTime(JsonConfig.DateTime.ISO8601, ZoneOffset.systemDefault());
|
||||
jsonTester = new JsonTester<>(typeIso);
|
||||
jsonTester.test(now);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isoJsonFormatParse() {
|
||||
|
||||
ScalarTypeOffsetDateTime typeIso = new ScalarTypeOffsetDateTime(JsonConfig.DateTime.ISO8601, ZoneOffset.systemDefault());
|
||||
|
||||
OffsetDateTime now = OffsetDateTime.now();
|
||||
String asJson = typeIso.toJsonISO8601(now);
|
||||
|
||||
OffsetDateTime value = typeIso.fromJsonISO8601(asJson);
|
||||
assertThat(now).isEqualToIgnoringNanos(value);
|
||||
}
|
||||
}
|
||||
Loaded 100 of 191 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user