diff --git a/lib/src/main/java/rife/database/types/SqlConversion.java b/lib/src/main/java/rife/database/types/SqlConversion.java index 09924e0c..31c0960b 100644 --- a/lib/src/main/java/rife/database/types/SqlConversion.java +++ b/lib/src/main/java/rife/database/types/SqlConversion.java @@ -11,13 +11,13 @@ import rife.validation.Constrained; import java.sql.ResultSet; public interface SqlConversion { - public String getSqlValue(Object value); + String getSqlValue(Object value); - public String getSqlType(Class type, int precision, int scale); + String getSqlType(Class type, int precision, int scale); - public Object getTypedObject(ResultSet resultSet, int columnNumber, int type, Class targetType) + Object getTypedObject(ResultSet resultSet, int columnNumber, int type, Class targetType) throws DatabaseException; - public void setTypedParameter(DbPreparedStatement statement, int parameterIndex, Class targetType, String name, Object value, Constrained constrained) + void setTypedParameter(DbPreparedStatement statement, int parameterIndex, Class targetType, String name, Object value, Constrained constrained) throws DatabaseException; } diff --git a/lib/src/main/java/rife/database/types/databasedrivers/Common.java b/lib/src/main/java/rife/database/types/databasedrivers/Common.java index 0207f5d0..14ab96fc 100644 --- a/lib/src/main/java/rife/database/types/databasedrivers/Common.java +++ b/lib/src/main/java/rife/database/types/databasedrivers/Common.java @@ -144,7 +144,7 @@ public abstract class Common implements SqlConversion { } else if (targetType.isEnum()) { return Enum.valueOf(targetType, result.toString()); } else if (targetType == UUID.class) { - return result.toString(); + return UUID.fromString(result.toString()); } else { return null; } diff --git a/lib/src/test/java/rife/database/querymanagers/generic/AggregatingCallbacksBeanListener.java b/lib/src/test/java/rife/database/querymanagers/generic/AggregatingCallbacksBeanListener.java new file mode 100644 index 00000000..393caba4 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/AggregatingCallbacksBeanListener.java @@ -0,0 +1,50 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic; + +import rife.database.querymanagers.generic.beans.CallbacksBean; + +import java.util.LinkedHashMap; +import java.util.Map; + +public class AggregatingCallbacksBeanListener implements GenericQueryManagerListener { + private Map mHistory = new LinkedHashMap(); + + public void clearHistory() { + mHistory.clear(); + } + + public Map getHistory() { + return mHistory; + } + + public void installed() { + mHistory.put("installed" + mHistory.size(), null); + } + + public void removed() { + mHistory.put("removed" + mHistory.size(), null); + } + + public void inserted(CallbacksBean bean) { + mHistory.put("inserted" + mHistory.size(), bean); + bean.setTestString("listener inserted"); + } + + public void updated(CallbacksBean bean) { + mHistory.put("updated" + mHistory.size(), bean); + bean.setTestString("listener updated"); + } + + public void restored(CallbacksBean bean) { + mHistory.put("restored" + mHistory.size(), bean); + bean.setTestString("listener restored"); + } + + public void deleted(int objectId) { + mHistory.put("deleted" + mHistory.size(), objectId); + } +} + diff --git a/lib/src/test/java/rife/database/querymanagers/generic/TestCountQuery.java b/lib/src/test/java/rife/database/querymanagers/generic/TestCountQuery.java new file mode 100644 index 00000000..6828315d --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/TestCountQuery.java @@ -0,0 +1,654 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ArgumentsSource; +import rife.database.Datasource; +import rife.database.TestDatasources; +import rife.database.exceptions.UnsupportedSqlFeatureException; +import rife.database.queries.Select; +import rife.database.querymanagers.generic.beans.BeanImpl; +import rife.database.querymanagers.generic.beans.LinkBean; +import rife.database.querymanagers.generic.beans.SimpleBean; + +import java.math.BigDecimal; +import java.sql.Time; +import java.sql.Timestamp; +import java.util.Calendar; + +import static org.junit.jupiter.api.Assertions.*; + +public class TestCountQuery { + private GenericQueryManager manager_ = null; + private GenericQueryManager linkManager_ = null; + private GenericQueryManager bigBeanManager_ = null; + + protected void setUp(Datasource datasource) { + manager_ = GenericQueryManagerFactory.getInstance(datasource, SimpleBean.class); + linkManager_ = GenericQueryManagerFactory.getInstance(datasource, LinkBean.class); + bigBeanManager_ = GenericQueryManagerFactory.getInstance(datasource, BeanImpl.class); + manager_.install(); + linkManager_.install(); + bigBeanManager_.install(); + } + + protected void tearDown() { + manager_.remove(); + linkManager_.remove(); + bigBeanManager_.remove(); + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testCloneToStringAndClear(Datasource datasource) { + setUp(datasource); + try { + var query = manager_.getCountQuery().where("testString", "=", "bean set 1"); + + assertEquals(query.toString(), "SELECT count(*) FROM SimpleBean WHERE testString = 'bean set 1'"); + + var query_clone = query.clone(); + + assertEquals(query_clone.toString(), "SELECT count(*) FROM SimpleBean WHERE testString = 'bean set 1'"); + + query_clone.where("testString", "!=", "bean set 2"); + + assertEquals(query_clone.toString(), "SELECT count(*) FROM SimpleBean WHERE testString = 'bean set 1' AND testString != 'bean set 2'"); + + query_clone.clear(); + + assertEquals(query_clone.toString(), "SELECT count(*) FROM SimpleBean WHERE testString = 'bean set 1'"); + + query.clear(); + + assertEquals(query.toString(), "SELECT count(*) FROM SimpleBean"); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetDatasource(Datasource datasource) { + setUp(datasource); + try { + assertEquals(datasource, manager_.getCountQuery().getDatasource()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetFrom(Datasource datasource) { + setUp(datasource); + try { + assertEquals(manager_ + .getCountQuery() + .getFrom(), SimpleBean.class + .getName() + .replaceAll(SimpleBean.class + .getPackage() + .getName() + ".", "")); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetParameters(Datasource datasource) { + setUp(datasource); + try { + var select = new Select(datasource); + select + .from("simplebean") + .whereParameter("testString", "="); + + var query = new CountQuery(select); + + assertEquals(query.getParameters().getOrderedNames().size(), 1); + assertTrue(query.getParameters().getOrderedNames().contains("testString")); + + assertEquals(query.getParameters().getOrderedNamesArray().length, 1); + assertEquals(query.getParameters().getOrderedNamesArray()[0], "testString"); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testJoin(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + var linkbean1 = new LinkBean(); + var linkbean2 = new LinkBean(); + + linkbean1.setTestString("linkbean 1"); + linkbean2.setTestString("linkbean 2"); + + linkManager_.save(linkbean1); + linkManager_.save(linkbean2); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + bean1.setLinkBean(linkbean1.getId()); + bean2.setLinkBean(linkbean1.getId()); + bean3.setLinkBean(linkbean1.getId()); + bean4.setLinkBean(linkbean2.getId()); + bean5.setLinkBean(linkbean2.getId()); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + manager_.save(bean4); + manager_.save(bean5); + + var table = manager_.getTable(); + var table2 = linkManager_.getTable(); + + var query = manager_.getCountQuery() + .join(table2) + .where(table2 + ".id = " + table + ".linkBean") + .whereAnd(table + ".linkBean", "=", linkbean2.getId()); + + assertEquals(2, manager_.count(query)); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testJoinCross(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + var linkbean1 = new LinkBean(); + var linkbean2 = new LinkBean(); + + linkbean1.setTestString("linkbean 1"); + linkbean2.setTestString("linkbean 2"); + + linkManager_.save(linkbean1); + linkManager_.save(linkbean2); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + bean1.setLinkBean(linkbean1.getId()); + bean2.setLinkBean(linkbean1.getId()); + bean3.setLinkBean(linkbean1.getId()); + bean4.setLinkBean(linkbean2.getId()); + bean5.setLinkBean(linkbean2.getId()); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + manager_.save(bean4); + manager_.save(bean5); + + var table = manager_.getTable(); + var table2 = linkManager_.getTable(); + + var query = manager_.getCountQuery() + .joinCross(table2) + .where(table2 + ".id = " + table + ".linkBean") + .whereAnd(table + ".linkBean", "=", linkbean2.getId()); + + try { + assertEquals(2, manager_.count(query)); + + if ("org.hsqldb.jdbcDriver".equals(datasource.getAliasedDriver()) || + "org.apache.derby.jdbc.EmbeddedDriver".equals(datasource.getAliasedDriver())) { + fail(); + } + } catch (UnsupportedSqlFeatureException e) { + assertEquals("CROSS JOIN", e.getFeature()); + assertTrue("org.hsqldb.jdbcDriver".equals(e.getDriver()) || + "org.apache.derby.jdbc.EmbeddedDriver".equals(e.getDriver())); + } + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testJoinInner(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + var link_bean1 = new LinkBean(); + var link_bean2 = new LinkBean(); + + link_bean1.setTestString("linkbean 1"); + link_bean2.setTestString("linkbean 2"); + + linkManager_.save(link_bean1); + linkManager_.save(link_bean2); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + bean1.setLinkBean(link_bean1.getId()); + bean2.setLinkBean(link_bean1.getId()); + bean3.setLinkBean(link_bean1.getId()); + bean4.setLinkBean(link_bean2.getId()); + bean5.setLinkBean(link_bean2.getId()); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + manager_.save(bean4); + manager_.save(bean5); + + var table = manager_.getTable(); + var table2 = linkManager_.getTable(); + + var query = manager_.getCountQuery() + .joinInner(table2, Select.ON, "0 = 0") // evals to true for mysql sake + .where(table2 + ".id = " + table + ".linkBean") + .whereAnd(table + ".linkBean", "=", link_bean2.getId()); + + assertEquals(2, manager_.count(query)); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testJoinOuter(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + var link_bean1 = new LinkBean(); + var link_bean2 = new LinkBean(); + + link_bean1.setTestString("linkbean 1"); + link_bean2.setTestString("linkbean 2"); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + bean1.setLinkBean(1); + bean2.setLinkBean(1); + bean3.setLinkBean(1); + bean4.setLinkBean(2); + bean5.setLinkBean(2); + + linkManager_.save(link_bean1); + linkManager_.save(link_bean2); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + manager_.save(bean4); + manager_.save(bean5); + + var table = manager_.getTable(); + var table2 = linkManager_.getTable(); + + var query = manager_.getCountQuery() + .joinOuter(table2, Select.LEFT, Select.ON, table2 + ".id = " + table + ".linkBean") // evals to true for mysql sake + .where(table + ".linkBean = 2"); + + assertEquals(2, manager_.count(query)); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testJoinCustom(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + var link_bean1 = new LinkBean(); + var link_bean2 = new LinkBean(); + + link_bean1.setTestString("linkbean 1"); + link_bean2.setTestString("linkbean 2"); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + bean1.setLinkBean(1); + bean2.setLinkBean(1); + bean3.setLinkBean(1); + bean4.setLinkBean(2); + bean5.setLinkBean(2); + + linkManager_.save(link_bean1); + linkManager_.save(link_bean2); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + manager_.save(bean4); + manager_.save(bean5); + + var table = manager_.getTable(); + var table2 = linkManager_.getTable(); + + var query = manager_.getCountQuery() + .joinCustom("LEFT OUTER JOIN " + table2 + " ON " + table2 + ".id = " + table + ".linkBean") // evals to true for mysql sake + .where(table + ".linkBean = 2"); + + assertEquals(2, manager_.count(query)); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testWhere(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new BeanImpl(); + + var cal = Calendar.getInstance(); + cal.set(2004, Calendar.JULY, 19, 16, 27, 15); + cal.set(Calendar.MILLISECOND, 765); + bean1.setPropertyBigDecimal(new BigDecimal("384834838434.38483")); + bean1.setPropertyBoolean(false); + bean1.setPropertyBooleanObject(true); + bean1.setPropertyByte((byte) 90); + bean1.setPropertyByteObject((byte) 35); + bean1.setPropertyCalendar(cal); + bean1.setPropertyChar('w'); + bean1.setPropertyCharacterObject('s'); + bean1.setPropertyDate(cal.getTime()); + bean1.setPropertyDouble(37478.34d); + bean1.setPropertyDoubleObject(384724.692d); + bean1.setPropertyFloat(34241.2f); + bean1.setPropertyFloatObject(3432.7f); + bean1.setPropertyLong(23432L); + bean1.setPropertyLongObject(23423L); + bean1.setPropertyShort((short) 44); + bean1.setPropertyShortObject((short) 69); + bean1.setPropertyIntegerObject(421); + bean1.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime())); + bean1.setPropertyString("nostringhere"); + bean1.setPropertyStringBuffer(new StringBuffer("buffbuffbuff")); + bean1.setPropertyTime(new Time(cal.getTime().getTime())); + bean1.setPropertyTimestamp(new Timestamp(cal.getTime().getTime())); + + bigBeanManager_.save(bean1); + + assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("propertyString = 'nostringhere'"))); + + assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("propertyBoolean", "=", false))); + + assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("propertyByte", "=", (byte) 90))); + + assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("propertyChar", "=", 'w'))); + + assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("propertyDouble", "=", 37478.34d))); + + assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("ABS(propertyFloat - 34241.2) < 0.001"))); + + assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("propertyLong", "=", 23432L))); + + assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("propertyShort", "=", (short) 44))); + + // cheating because the GQM doesn't currently return any queries with a where clause already + var query = new CountQuery(bigBeanManager_.getCountQuery().where("id", "=", bean1.getId()).getDelegate()); + + assertEquals(1, bigBeanManager_.count(query.where("propertyString = 'nostringhere'"))); + + assertEquals(1, bigBeanManager_.count(query.where("propertyBoolean", "=", false))); + + assertEquals(1, bigBeanManager_.count(query.where("propertyByte", "=", (byte) 90))); + + assertEquals(1, bigBeanManager_.count(query.where("propertyChar", "=", 'w'))); + + assertEquals(1, bigBeanManager_.count(query.where("propertyDouble", "=", 37478.34d))); + + assertEquals(1, bigBeanManager_.count(query.where("ABS(propertyFloat - 34241.2) < 0.001"))); + + assertEquals(1, bigBeanManager_.count(query.where("id", "=", bean1.getId()))); // primary key + + assertEquals(1, bigBeanManager_.count(query.where("propertyLong", "=", 23432L))); + + assertEquals(1, bigBeanManager_.count(query.where("propertyShort", "=", (short) 44))); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testWhereAnd(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new BeanImpl(); + + var cal = Calendar.getInstance(); + cal.set(2004, Calendar.JULY, 19, 16, 27, 15); + cal.set(Calendar.MILLISECOND, 765); + bean1.setPropertyBigDecimal(new BigDecimal("384834838434.38483")); + bean1.setPropertyBoolean(false); + bean1.setPropertyBooleanObject(true); + bean1.setPropertyByte((byte) 90); + bean1.setPropertyByteObject((byte) 35); + bean1.setPropertyCalendar(cal); + bean1.setPropertyChar('w'); + bean1.setPropertyCharacterObject('s'); + bean1.setPropertyDate(cal.getTime()); + bean1.setPropertyDouble(37478.34d); + bean1.setPropertyDoubleObject(384724.692d); + bean1.setPropertyFloat(34241.2f); + bean1.setPropertyFloatObject(3432.7f); + bean1.setPropertyLong(23432L); + bean1.setPropertyLongObject(23423L); + bean1.setPropertyShort((short) 44); + bean1.setPropertyShortObject((short) 69); + bean1.setPropertyIntegerObject(421); + bean1.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime())); + bean1.setPropertyString("nostringhere"); + bean1.setPropertyStringBuffer(new StringBuffer("buffbuffbuff")); + bean1.setPropertyTime(new Time(cal.getTime().getTime())); + bean1.setPropertyTimestamp(new Timestamp(cal.getTime().getTime())); + + bigBeanManager_.save(bean1); + + assertEquals(1, bigBeanManager_.count( + bigBeanManager_.getCountQuery() + .where("id", "=", bean1.getId()) + .whereAnd("propertyString = 'nostringhere'") + .whereAnd("propertyBoolean", "=", false) + .whereAnd("propertyByte", "=", (byte) 90) + .whereAnd("propertyChar", "=", 'w') + .whereAnd("propertyDouble", "=", 37478.34d) + .whereAnd("propertyLong", "=", 23432L) + .whereAnd("propertyString", "=", "nostringhere") + .whereAnd("propertyIntegerObject", "=", 421) + .whereAnd("propertyShort", "=", (short) 44) + )); + + assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("id", "=", bean1.getId()).whereAnd("ABS(propertyFloat - 34241.2) < 0.001"))); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testWhereOr(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new BeanImpl(); + + var cal = Calendar.getInstance(); + cal.set(2004, Calendar.JULY, 19, 16, 27, 15); + cal.set(Calendar.MILLISECOND, 765); + bean1.setPropertyBigDecimal(new BigDecimal("384834838434.38483")); + bean1.setPropertyBoolean(false); + bean1.setPropertyBooleanObject(true); + bean1.setPropertyByte((byte) 90); + bean1.setPropertyByteObject((byte) 35); + bean1.setPropertyCalendar(cal); + bean1.setPropertyChar('w'); + bean1.setPropertyCharacterObject('s'); + bean1.setPropertyDate(cal.getTime()); + bean1.setPropertyDouble(37478.34d); + bean1.setPropertyDoubleObject(384724.692d); + bean1.setPropertyFloat(34241.2f); + bean1.setPropertyFloatObject(3432.7f); + bean1.setPropertyLong(23432L); + bean1.setPropertyLongObject(23423L); + bean1.setPropertyShort((short) 44); + bean1.setPropertyShortObject((short) 69); + bean1.setPropertyIntegerObject(421); + bean1.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime())); + bean1.setPropertyString("nostringhere"); + bean1.setPropertyStringBuffer(new StringBuffer("buffbuffbuff")); + bean1.setPropertyTime(new Time(cal.getTime().getTime())); + bean1.setPropertyTimestamp(new Timestamp(cal.getTime().getTime())); + + bigBeanManager_.save(bean1); + + assertEquals(1, bigBeanManager_.count( + bigBeanManager_.getCountQuery() + .where("id", "=", bean1.getId()) + .whereOr("propertyString = 'nostringhere'") + .whereOr("propertyBoolean", "=", false) + .whereOr("propertyByte", "=", (byte) 90) + .whereOr("propertyChar", "=", 'w') + .whereOr("propertyDouble", "=", 37478.34d) + .whereOr("propertyLong", "=", 23432L) + .whereOr("propertyIntegerObject", "=", 421) + .whereOr("propertyShort", "=", (short) 44) + .whereOr("propertyString", "=", "nostringhere") + )); + + assertEquals(1, bigBeanManager_.count(bigBeanManager_.getCountQuery().where("id", "=", bean1.getId()).whereOr("ABS(propertyFloat - 34241.2) < 0.001"))); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testUnion(Datasource datasource) { + setUp(datasource); + try { + var query = manager_.getCountQuery(); + + query + .union("uexpr1") + .union(new Select(datasource).field("count(*)").from("table2")); + + + assertEquals(query.getSql(), "SELECT count(*) FROM SimpleBean UNION uexpr1 UNION SELECT count(*) FROM table2"); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testWhereSubSelect(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + var linkbean1 = new LinkBean(); + var linkbean2 = new LinkBean(); + + linkbean1.setTestString("linkbean 1"); + linkbean2.setTestString("linkbean 2"); + + linkManager_.save(linkbean1); + linkManager_.save(linkbean2); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + bean1.setLinkBean(linkbean1.getId()); + bean2.setLinkBean(linkbean1.getId()); + bean3.setLinkBean(linkbean1.getId()); + bean4.setLinkBean(linkbean2.getId()); + bean5.setLinkBean(linkbean2.getId()); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + manager_.save(bean4); + manager_.save(bean5); + + var select = new Select(datasource); + select + .from(linkManager_.getTable()) + .field("id") + .where("id", "=", linkbean1.getId()); + + var query = manager_.getCountQuery(); + query + .where("linkBean = (" + select.getSql() + ")") + .whereSubselect(select); + + assertEquals(3, manager_.count(query)); + } finally { + tearDown(); + } + } +} + diff --git a/lib/src/test/java/rife/database/querymanagers/generic/TestDeleteQuery.java b/lib/src/test/java/rife/database/querymanagers/generic/TestDeleteQuery.java new file mode 100644 index 00000000..189e3996 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/TestDeleteQuery.java @@ -0,0 +1,441 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ArgumentsSource; +import rife.database.Datasource; +import rife.database.TestDatasources; +import rife.database.queries.Delete; +import rife.database.queries.Select; +import rife.database.querymanagers.generic.beans.BeanImpl; +import rife.database.querymanagers.generic.beans.LinkBean; +import rife.database.querymanagers.generic.beans.SimpleBean; + +import java.math.BigDecimal; +import java.sql.Time; +import java.sql.Timestamp; +import java.util.Calendar; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class TestDeleteQuery { + private GenericQueryManager bigBeanManager_ = null; + private GenericQueryManager manager_ = null; + private GenericQueryManager linkManager_ = null; + + protected void setUp(Datasource datasource) { + manager_ = GenericQueryManagerFactory.getInstance(datasource, SimpleBean.class); + linkManager_ = GenericQueryManagerFactory.getInstance(datasource, LinkBean.class); + bigBeanManager_ = GenericQueryManagerFactory.getInstance(datasource, BeanImpl.class); + manager_.install(); + linkManager_.install(); + bigBeanManager_.install(); + } + + protected void tearDown() { + manager_.remove(); + linkManager_.remove(); + bigBeanManager_.remove(); + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testCloneToStringAndClear(Datasource datasource) { + setUp(datasource); + try { + var query = bigBeanManager_.getDeleteQuery().where("propertyString", "=", "bean set 1"); + + assertEquals(query.toString(), "DELETE FROM BeanImpl WHERE propertyString = 'bean set 1'"); + + var query_clone = query.clone(); + + assertEquals(query_clone.toString(), "DELETE FROM BeanImpl WHERE propertyString = 'bean set 1'"); + + query_clone.where("propertyString", "!=", "bean set 2"); + + assertEquals(query_clone.toString(), "DELETE FROM BeanImpl WHERE propertyString = 'bean set 1' AND propertyString != 'bean set 2'"); + + query_clone.clear(); + + assertEquals(query_clone.toString(), "DELETE FROM BeanImpl WHERE propertyString = 'bean set 1'"); + + query.clear(); + + assertEquals(query.toString(), "DELETE FROM BeanImpl"); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetParameters(Datasource datasource) { + setUp(datasource); + try { + var delete = new Delete(datasource); + delete + .from("simplebean") + .whereParameter("testString", "="); + + var query = new DeleteQuery(delete); + + assertEquals(query.getParameters().getOrderedNames().size(), 1); + assertTrue(query.getParameters().getOrderedNames().contains("testString")); + + assertEquals(query.getParameters().getOrderedNamesArray().length, 1); + assertEquals(query.getParameters().getOrderedNamesArray()[0], "testString"); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetDatasource(Datasource datasource) { + setUp(datasource); + try { + assertEquals(datasource, bigBeanManager_.getDeleteQuery().getDatasource()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetFrom(Datasource datasource) { + setUp(datasource); + try { + assertEquals(bigBeanManager_ + .getDeleteQuery() + .getFrom(), BeanImpl.class + .getName() + .replaceAll(BeanImpl.class + .getPackage() + .getName() + ".", "")); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testWhere(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new BeanImpl(); + + var cal = Calendar.getInstance(); + cal.set(2004, Calendar.JULY, 19, 16, 27, 15); + cal.set(Calendar.MILLISECOND, 765); + bean1.setPropertyBigDecimal(new BigDecimal("384834838434.38483")); + bean1.setPropertyBoolean(false); + bean1.setPropertyBooleanObject(true); + bean1.setPropertyByte((byte) 90); + bean1.setPropertyByteObject((byte) 35); + bean1.setPropertyCalendar(cal); + bean1.setPropertyChar('w'); + bean1.setPropertyCharacterObject('s'); + bean1.setPropertyDate(cal.getTime()); + bean1.setPropertyDouble(37478.34d); + bean1.setPropertyDoubleObject(384724.692d); + bean1.setPropertyFloat(34241.2f); + bean1.setPropertyFloatObject(3432.7f); + bean1.setPropertyLong(23432L); + bean1.setPropertyLongObject(23423L); + bean1.setPropertyShort((short) 44); + bean1.setPropertyShortObject((short) 69); + bean1.setPropertyIntegerObject(421); + bean1.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime())); + bean1.setPropertyString("nostringhere"); + bean1.setPropertyStringBuffer(new StringBuffer("buffbuffbuff")); + bean1.setPropertyTime(new Time(cal.getTime().getTime())); + bean1.setPropertyTimestamp(new Timestamp(cal.getTime().getTime())); + + var bean1id = bigBeanManager_.save(bean1); + bigBeanManager_.save(BeanImpl.getPopulatedBean()); + + bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("propertyString = 'nostringhere'")); + var list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + bean1id = bigBeanManager_.save(bean1); + + bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("propertyBoolean", "=", false)); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + bean1id = bigBeanManager_.save(bean1); + + bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("propertyByte", "=", (byte) 90)); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + bean1id = bigBeanManager_.save(bean1); + + bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("propertyChar", "=", 'w')); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + bean1id = bigBeanManager_.save(bean1); + + bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("propertyDouble", "=", 37478.34d)); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + bean1id = bigBeanManager_.save(bean1); + + bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("ABS(propertyFloat - 34241.2) < 0.001")); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + bean1id = bigBeanManager_.save(bean1); + + bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("propertyLong", "=", 23432L)); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + bean1id = bigBeanManager_.save(bean1); + + bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("propertyShort", "=", (short) 44)); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + + var query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate()); + + bigBeanManager_.delete(query.where("propertyString = 'nostringhere'")); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + bean1id = bigBeanManager_.save(bean1); + query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate()); + + bigBeanManager_.delete(query.where("propertyBoolean", "=", false)); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + bean1id = bigBeanManager_.save(bean1); + query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate()); + + bigBeanManager_.delete(query.where("propertyByte", "=", (byte) 90)); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + bean1id = bigBeanManager_.save(bean1); + query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate()); + + bigBeanManager_.delete(query.where("propertyChar", "=", 'w')); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + bean1id = bigBeanManager_.save(bean1); + query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate()); + + bigBeanManager_.delete(query.where("propertyDouble", "=", 37478.34d)); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + bean1id = bigBeanManager_.save(bean1); + query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate()); + + bigBeanManager_.delete(query.where("ABS(propertyFloat - 34241.2) < 0.001")); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + bean1id = bigBeanManager_.save(bean1); + query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate()); + + bigBeanManager_.delete(query.where("id", "=", bean1id)); // primary key + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + bean1id = bigBeanManager_.save(bean1); + query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate()); + + bigBeanManager_.delete(query.where("propertyLong", "=", 23432L)); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + bean1id = bigBeanManager_.save(bean1); + query = new DeleteQuery(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).getDelegate()); + + bigBeanManager_.delete(query.where("propertyShort", "=", (short) 44)); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testWhereAnd(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new BeanImpl(); + + var cal = Calendar.getInstance(); + cal.set(2004, Calendar.JULY, 19, 16, 27, 15); + cal.set(Calendar.MILLISECOND, 765); + bean1.setPropertyBigDecimal(new BigDecimal("384834838434.38483")); + bean1.setPropertyBoolean(false); + bean1.setPropertyBooleanObject(true); + bean1.setPropertyByte((byte) 90); + bean1.setPropertyByteObject((byte) 35); + bean1.setPropertyCalendar(cal); + bean1.setPropertyChar('w'); + bean1.setPropertyCharacterObject('s'); + bean1.setPropertyDate(cal.getTime()); + bean1.setPropertyDouble(37478.34d); + bean1.setPropertyDoubleObject(384724.692d); + bean1.setPropertyFloat(34241.2f); + bean1.setPropertyFloatObject(3432.7f); + bean1.setPropertyLong(23432L); + bean1.setPropertyLongObject(23423L); + bean1.setPropertyShort((short) 44); + bean1.setPropertyShortObject((short) 69); + bean1.setPropertyIntegerObject(421); + bean1.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime())); + bean1.setPropertyString("nostringhere"); + bean1.setPropertyStringBuffer(new StringBuffer("buffbuffbuff")); + bean1.setPropertyTime(new Time(cal.getTime().getTime())); + bean1.setPropertyTimestamp(new Timestamp(cal.getTime().getTime())); + + var bean1id = bigBeanManager_.save(bean1); + bigBeanManager_.save(BeanImpl.getPopulatedBean()); + + bigBeanManager_.delete( + bigBeanManager_.getDeleteQuery() + .where("id", "=", bean1id) + .whereAnd("propertyString = 'nostringhere'") + .whereAnd("propertyBoolean", "=", false) + .whereAnd("propertyByte", "=", (byte) 90) + .whereAnd("propertyChar", "=", 'w') + .whereAnd("propertyDouble", "=", 37478.34d) + .whereAnd("propertyLong", "=", 23432L) + .whereAnd("propertyString", "=", "nostringhere") + .whereAnd("propertyIntegerObject", "=", 421) + .whereAnd("propertyShort", "=", (short) 44) + ); + + var list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + + bean1id = bigBeanManager_.save(bean1); + bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).whereAnd("ABS(propertyFloat - 34241.2) < 0.001")); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testWhereOr(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new BeanImpl(); + + var cal = Calendar.getInstance(); + cal.set(2004, Calendar.JULY, 19, 16, 27, 15); + cal.set(Calendar.MILLISECOND, 765); + bean1.setPropertyBigDecimal(new BigDecimal("384834838434.38483")); + bean1.setPropertyBoolean(false); + bean1.setPropertyBooleanObject(true); + bean1.setPropertyByte((byte) 90); + bean1.setPropertyByteObject((byte) 35); + bean1.setPropertyCalendar(cal); + bean1.setPropertyChar('w'); + bean1.setPropertyCharacterObject('s'); + bean1.setPropertyDate(cal.getTime()); + bean1.setPropertyDouble(37478.34d); + bean1.setPropertyDoubleObject(384724.692d); + bean1.setPropertyFloat(34241.2f); + bean1.setPropertyFloatObject(3432.7f); + bean1.setPropertyLong(23432L); + bean1.setPropertyLongObject(23423L); + bean1.setPropertyShort((short) 44); + bean1.setPropertyShortObject((short) 69); + bean1.setPropertyIntegerObject(421); + bean1.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime())); + bean1.setPropertyString("nostringhere"); + bean1.setPropertyStringBuffer(new StringBuffer("buffbuffbuff")); + bean1.setPropertyTime(new Time(cal.getTime().getTime())); + bean1.setPropertyTimestamp(new Timestamp(cal.getTime().getTime())); + + var bean1id = bigBeanManager_.save(bean1); + bigBeanManager_.save(BeanImpl.getPopulatedBean()); + + bigBeanManager_.delete( + bigBeanManager_.getDeleteQuery() + .where("id", "=", bean1id) + .whereOr("propertyString = 'nostringhere'") + .whereOr("propertyBoolean", "=", false) + .whereOr("propertyByte", "=", (byte) 90) + .whereOr("propertyChar", "=", 'w') + .whereOr("propertyDouble", "=", 37478.34d) + .whereOr("propertyLong", "=", 23432L) + .whereOr("propertyIntegerObject", "=", 421) + .whereOr("propertyShort", "=", (short) 44) + .whereOr("propertyString", "=", "nostringhere") + ); + + var list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + + bean1id = bigBeanManager_.save(bean1); + + bigBeanManager_.delete(bigBeanManager_.getDeleteQuery().where("id", "=", bean1id).whereOr("ABS(propertyFloat - 34241.2) < 0.001")); + list = bigBeanManager_.restore(); + assertEquals(list.size(), 1); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testWhereSubselect(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + var link_bean1 = new LinkBean(); + var link_bean2 = new LinkBean(); + + link_bean1.setTestString("linkbean 1"); + link_bean2.setTestString("linkbean 2"); + + linkManager_.save(link_bean1); + linkManager_.save(link_bean2); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + bean1.setLinkBean(link_bean1.getId()); + bean2.setLinkBean(link_bean1.getId()); + bean3.setLinkBean(link_bean1.getId()); + bean4.setLinkBean(link_bean2.getId()); + bean5.setLinkBean(link_bean2.getId()); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + manager_.save(bean4); + manager_.save(bean5); + + var select = new Select(datasource); + select + .from(linkManager_.getTable()) + .field("id") + .where("id", "=", link_bean1.getId()); + + var query = manager_.getDeleteQuery(); + query + .where("linkBean = (" + select.getSql() + ")") + .whereSubselect(select); + + manager_.delete(query); + var list = manager_.restore(); + assertEquals(list.size(), 2); + } finally { + tearDown(); + } + } +} diff --git a/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerBinary.java b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerBinary.java new file mode 100644 index 00000000..e0e20289 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerBinary.java @@ -0,0 +1,108 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ArgumentsSource; +import rife.database.Datasource; +import rife.database.TestDatasources; +import rife.database.querymanagers.generic.beans.BinaryBean; + +import static org.junit.jupiter.api.Assertions.*; + +public class TestGenericQueryManagerBinary { + protected GenericQueryManager setUp(Datasource datasource) { + var manager = GenericQueryManagerFactory.getInstance(datasource, BinaryBean.class); + manager.install(); + return manager; + } + + protected void tearDown(GenericQueryManager manager) { + manager.remove(); + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetBaseClass(Datasource datasource) { + var manager = setUp(datasource); + try { + assertSame(BinaryBean.class, manager.getBaseClass()); + } finally { + tearDown(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testInstallCustomQuery(Datasource datasource) { + var manager = setUp(datasource); + try { + manager.remove(); + manager.install(manager.getInstallTableQuery()); + } finally { + tearDown(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testSaveRestoreBinary(Datasource datasource) { + var manager = setUp(datasource); + try { + var bean = new BinaryBean(); + BinaryBean newbean = null; + + var bytes1 = new byte[]{1, 3, 5, 7, 11, 13, 17, 19, 23}; + bean.setTheBytes(bytes1); + + var id = manager.save(bean); + + newbean = manager.restore(id); + + assertNotNull(newbean); + assertNotSame(newbean, bean); + assertArrayEquals(newbean.getTheBytes(), bean.getTheBytes()); + assertEquals(newbean.getId(), id); + + var bytes2 = new byte[]{10, 30, 50, 70, 110}; + bean.setId(id); + bean.setTheBytes(bytes2); + + assertEquals(manager.save(bean), id); + assertEquals(bean.getId(), id); + + newbean = manager.restore(id); + + assertNotNull(newbean); + assertNotSame(newbean, bean); + + assertArrayEquals(newbean.getTheBytes(), bytes2); + + var bytes3 = new byte[]{89, 22, 9, 31, 89}; + bean.setId(999999); + bean.setTheBytes(bytes3); + + assertNotEquals(999999, manager.save(bean)); + assertEquals(bean.getId(), id + 1); + + var manager_othertable = GenericQueryManagerFactory.getInstance(datasource, BinaryBean.class, "othertable"); + manager_othertable.install(); + + var bytes4 = new byte[]{79, 15, 88, 42}; + var bean2 = new BinaryBean(); + bean2.setTheBytes(bytes4); + + manager_othertable.save(bean2); + + var bean3 = manager_othertable.restore(bean2.getId()); + + assertArrayEquals(bean3.getTheBytes(), bean2.getTheBytes()); + + manager_othertable.remove(); + } finally { + tearDown(manager); + } + } +} diff --git a/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerCallbacks.java b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerCallbacks.java new file mode 100644 index 00000000..940121d5 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerCallbacks.java @@ -0,0 +1,960 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ArgumentsSource; +import rife.database.Datasource; +import rife.database.TestDatasources; +import rife.database.querymanagers.generic.beans.*; +import rife.tools.StringUtils; + +import java.util.Iterator; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.*; + +public class TestGenericQueryManagerCallbacks { + protected GenericQueryManager setUpCallbacksBeanManager(Datasource datasource) { + var manager = GenericQueryManagerFactory.getInstance(datasource, CallbacksBean.class); + try { + var listener = new AggregatingCallbacksBeanListener(); + manager.addListener(listener); + manager.install(); + assertEquals(1, listener.getHistory().size()); + assertEquals("installed0", listener.getHistory().entrySet().iterator().next().getKey()); + } finally { + manager.removeListeners(); + } + return manager; + } + + protected void tearDownCallbacksBean(GenericQueryManager manager) { + try { + var listener = new AggregatingCallbacksBeanListener(); + manager.addListener(listener); + manager.remove(); + assertEquals(1, listener.getHistory().size()); + assertEquals("removed0", listener.getHistory().entrySet().iterator().next().getKey()); + } finally { + manager.removeListeners(); + } + } + + protected GenericQueryManager setUpCallbacksSparseBeanManager(Datasource datasource) { + var manager = GenericQueryManagerFactory.getInstance(datasource, CallbacksSparseBean.class); + manager.install(); + return manager; + } + + protected void tearDownCallbacksSparseBean(GenericQueryManager manager) { + manager.remove(); + } + + protected GenericQueryManager setUpCallbacksProviderBeanManager(Datasource datasource) { + var manager = GenericQueryManagerFactory.getInstance(datasource, CallbacksProviderBean.class); + manager.install(); + return manager; + } + + protected void tearDownCallbacksProviderBean(GenericQueryManager manager) { + manager.remove(); + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetBaseClass(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + assertSame(CallbacksBean.class, manager.getBaseClass()); + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetBaseClassSparse(Datasource datasource) { + var manager = setUpCallbacksSparseBeanManager(datasource); + try { + assertSame(CallbacksSparseBean.class, manager.getBaseClass()); + } finally { + tearDownCallbacksSparseBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetBaseClassProvider(Datasource datasource) { + var manager = setUpCallbacksProviderBeanManager(datasource); + try { + assertSame(CallbacksProviderBean.class, manager.getBaseClass()); + } finally { + tearDownCallbacksProviderBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testInstallCustomQuery(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + manager.remove(); + manager.install(manager.getInstallTableQuery()); + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testInstallCustomQuerySparse(Datasource datasource) { + var manager = setUpCallbacksSparseBeanManager(datasource); + try { + manager.remove(); + manager.install(manager.getInstallTableQuery()); + } finally { + tearDownCallbacksSparseBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testInstallCustomQueryProvider(Datasource datasource) { + var manager = setUpCallbacksProviderBeanManager(datasource); + try { + manager.remove(); + manager.install(manager.getInstallTableQuery()); + } finally { + tearDownCallbacksProviderBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testValidateCallbacks(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + CallbacksBean.clearExecuteCallbacks(); + + var bean = new CallbacksBean(); + + bean.setTestString("This is my test string"); + + manager.validate(bean); + assertEquals("beforeValidate -1;This is my test string\n" + + "afterValidate -1;This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + bean.setTestString("This is a new test string"); + + manager.validate(bean); + assertEquals("beforeValidate -1;This is a new test string\n" + + "afterValidate -1;This is a new test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + bean.setId(999999); + bean.setTestString("This is another test string"); + + manager.validate(bean); + assertEquals("beforeValidate 999999;This is another test string\n" + + "afterValidate 999999;This is another test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.clearExecuteCallbacks(); + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testValidateCallbacksReturns(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + CallbacksBean.clearExecuteCallbacks(); + + var bean = new CallbacksBean(); + + bean.setTestString("This is my test string"); + + bean.setBeforeValidateReturn(false); + manager.validate(bean); + assertEquals("beforeValidate -1;This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + bean.setBeforeValidateReturn(true); + bean.setAfterValidateReturn(false); + manager.validate(bean); + assertEquals("beforeValidate -1;This is my test string\n" + + "afterValidate -1;This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.clearExecuteCallbacks(); + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testSaveCallbacks(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + CallbacksBean.clearExecuteCallbacks(); + + var bean = new CallbacksBean(); + + bean.setTestString("This is my test string"); + + var id = manager.save(bean); + assertEquals("beforeSave -1;This is my test string\n" + + "beforeInsert -1;This is my test string\n" + + "afterInsert true " + id + ";This is my test string\n" + + "afterSave true " + id + ";This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + bean.setTestString("This is a new test string"); + + id = manager.save(bean); + assertEquals("beforeSave " + id + ";This is a new test string\n" + + "beforeUpdate " + id + ";This is a new test string\n" + + "afterUpdate true " + id + ";This is a new test string\n" + + "afterSave true " + id + ";This is a new test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + bean.setId(999999); + bean.setTestString("This is another test string"); + + id = manager.save(bean); + assertEquals("beforeSave 999999;This is another test string\n" + + "beforeUpdate 999999;This is another test string\n" + + "afterUpdate false 999999;This is another test string\n" + + "beforeInsert 999999;This is another test string\n" + + "afterInsert true " + id + ";This is another test string\n" + + "afterSave true " + id + ";This is another test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testSaveCallbacksReturns(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + CallbacksBean.clearExecuteCallbacks(); + + var bean = new CallbacksBean(); + + bean.setTestString("This is my test string"); + + // test immediate inserts + bean.setBeforeSaveReturn(false); + manager.save(bean); + assertEquals("beforeSave -1;This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + assertNull(manager.restore(1)); + + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + bean.setBeforeSaveReturn(true); + bean.setBeforeInsertReturn(false); + manager.save(bean); + assertEquals("beforeSave -1;This is my test string\n" + + "beforeInsert -1;This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + assertNull(manager.restore(1)); + + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + bean.setBeforeInsertReturn(true); + bean.setAfterInsertReturn(false); + var id = manager.save(bean); + assertEquals("beforeSave -1;This is my test string\n" + + "beforeInsert -1;This is my test string\n" + + "afterInsert true " + id + ";This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + assertNotNull(manager.restore(id)); + + // test updates + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + bean.setTestString("This is a new test string"); + + bean.setBeforeUpdateReturn(false); + bean.setAfterInsertReturn(true); + assertEquals(-1, manager.save(bean)); + assertEquals("beforeSave " + id + ";This is a new test string\n" + + "beforeUpdate " + id + ";This is a new test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + assertEquals("This is my test string", manager.restore(id).getTestString()); + + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + bean.setBeforeUpdateReturn(true); + bean.setAfterUpdateReturn(false); + assertEquals(id, manager.save(bean)); + assertEquals("beforeSave " + id + ";This is a new test string\n" + + "beforeUpdate " + id + ";This is a new test string\n" + + "afterUpdate true " + id + ";This is a new test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + assertEquals("This is a new test string", manager.restore(id).getTestString()); + + // test insert after failed update + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + bean.setId(999999); + bean.setTestString("This is another test string"); + + bean.setAfterUpdateReturn(true); + bean.setBeforeInsertReturn(false); + + assertEquals(-1, manager.save(bean)); + assertEquals(""" + beforeSave 999999;This is another test string + beforeUpdate 999999;This is another test string + afterUpdate false 999999;This is another test string + beforeInsert 999999;This is another test string""", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + assertNull(manager.restore(999999)); + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + bean.setBeforeInsertReturn(true); + bean.setAfterInsertReturn(false); + + assertEquals(id + 1, manager.save(bean)); + id = id + 1; + assertEquals("beforeSave 999999;This is another test string\n" + + "beforeUpdate 999999;This is another test string\n" + + "afterUpdate false 999999;This is another test string\n" + + "beforeInsert 999999;This is another test string\n" + + "afterInsert true " + id + ";This is another test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + assertNotNull(manager.restore(id)); + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testSaveCallbacksSparse(Datasource datasource) { + var manager = setUpCallbacksSparseBeanManager(datasource); + try { + var bean = new CallbacksSparseBean(); + + bean.setId(1000); + bean.setTestString("Test String"); + + var id = manager.save(bean); + assertEquals("beforeSave " + id + ";Test String\n" + + "beforeInsert " + id + ";Test String\n" + + "afterInsert true " + id + ";Test String\n" + + "afterSave true " + id + ";Test String", StringUtils.join(bean.getExecutedCallbacks(), "\n")); + + bean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(bean.getExecutedCallbacks(), "\n")); + + bean.setTestString("This is a new test string"); + + id = manager.save(bean); + assertEquals("beforeSave " + id + ";This is a new test string\n" + + "beforeInsert " + id + ";This is a new test string\n" + + "afterInsert false " + id + ";This is a new test string\n" + + "beforeUpdate " + id + ";This is a new test string\n" + + "afterUpdate true " + id + ";This is a new test string\n" + + "afterSave true " + id + ";This is a new test string", StringUtils.join(bean.getExecutedCallbacks(), "\n")); + } finally { + tearDownCallbacksSparseBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testSaveCallbacksSparseReturns(Datasource datasource) { + var manager = setUpCallbacksSparseBeanManager(datasource); + try { + var bean = new CallbacksSparseBean(); + + bean.setId(1000); + bean.setTestString("Test String"); + + var id = 1000; + + // test immediate insert + bean.setBeforeSaveReturn(false); + assertEquals(-1, manager.save(bean)); + assertEquals("beforeSave " + id + ";Test String", StringUtils.join(bean.getExecutedCallbacks(), "\n")); + + bean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(bean.getExecutedCallbacks(), "\n")); + + bean.setBeforeSaveReturn(true); + bean.setBeforeInsertReturn(false); + + assertEquals(-1, manager.save(bean)); + assertEquals("beforeSave " + id + ";Test String\n" + + "beforeInsert " + id + ";Test String", StringUtils.join(bean.getExecutedCallbacks(), "\n")); + + bean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(bean.getExecutedCallbacks(), "\n")); + + bean.setBeforeInsertReturn(true); + bean.setAfterInsertReturn(false); + + assertEquals(id, manager.save(bean)); + assertEquals("beforeSave " + id + ";Test String\n" + + "beforeInsert " + id + ";Test String\n" + + "afterInsert true " + id + ";Test String", StringUtils.join(bean.getExecutedCallbacks(), "\n")); + + bean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(bean.getExecutedCallbacks(), "\n")); + + + // test update after failed insert + bean.setTestString("This is a new test string"); + + bean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(bean.getExecutedCallbacks(), "\n")); + + bean.setAfterInsertReturn(true); + bean.setBeforeUpdateReturn(false); + + assertEquals(-1, manager.save(bean)); + assertEquals("beforeSave " + id + ";This is a new test string\n" + + "beforeInsert " + id + ";This is a new test string\n" + + "afterInsert false " + id + ";This is a new test string\n" + + "beforeUpdate " + id + ";This is a new test string", StringUtils.join(bean.getExecutedCallbacks(), "\n")); + + bean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(bean.getExecutedCallbacks(), "\n")); + + bean.setBeforeUpdateReturn(true); + bean.setAfterUpdateReturn(false); + + assertEquals(id, manager.save(bean)); + assertEquals("beforeSave " + id + ";This is a new test string\n" + + "beforeInsert " + id + ";This is a new test string\n" + + "afterInsert false " + id + ";This is a new test string\n" + + "beforeUpdate " + id + ";This is a new test string\n" + + "afterUpdate true " + id + ";This is a new test string", StringUtils.join(bean.getExecutedCallbacks(), "\n")); + } finally { + tearDownCallbacksSparseBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testSaveListeners(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + CallbacksBean.clearExecuteCallbacks(); + + var listener = new AggregatingCallbacksBeanListener(); + manager.addListener(listener); + try { + var bean = new CallbacksBean(); + + bean.setTestString("This is my test string"); + + var id = manager.save(bean); + var history = listener.getHistory(); + assertEquals(1, history.size()); + var entry = history.entrySet().iterator().next(); + assertEquals("inserted0", entry.getKey()); + assertSame(bean, entry.getValue()); + assertEquals("beforeSave -1;This is my test string\n" + + "beforeInsert -1;This is my test string\n" + + "afterInsert true " + id + ";listener inserted\n" + + "afterSave true " + id + ";listener inserted", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.clearExecuteCallbacks(); + listener.clearHistory(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + bean.setTestString("This is a new test string"); + + id = manager.save(bean); + assertEquals(1, history.size()); + entry = history.entrySet().iterator().next(); + assertEquals("updated0", entry.getKey()); + assertSame(bean, entry.getValue()); + assertEquals("beforeSave " + id + ";This is a new test string\n" + + "beforeUpdate " + id + ";This is a new test string\n" + + "afterUpdate true " + id + ";listener updated\n" + + "afterSave true " + id + ";listener updated", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.clearExecuteCallbacks(); + listener.clearHistory(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + bean.setId(999999); + bean.setTestString("This is another test string"); + + id = manager.save(bean); + assertEquals(1, history.size()); + entry = history.entrySet().iterator().next(); + assertEquals("inserted0", entry.getKey()); + assertSame(bean, entry.getValue()); + assertEquals("beforeSave 999999;This is another test string\n" + + "beforeUpdate 999999;This is another test string\n" + + "afterUpdate false 999999;This is another test string\n" + + "beforeInsert 999999;This is another test string\n" + + "afterInsert true " + id + ";listener inserted\n" + + "afterSave true " + id + ";listener inserted", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + } finally { + manager.removeListeners(); + } + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testInsertCallbacks(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + CallbacksBean.clearExecuteCallbacks(); + + var bean = new CallbacksBean(); + + bean.setTestString("This is my test string"); + + var id = manager.insert(bean); + assertEquals("beforeInsert -1;This is my test string\n" + + "afterInsert true " + id + ";This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testInsertCallbacksReturns(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + CallbacksBean.clearExecuteCallbacks(); + + var bean = new CallbacksBean(); + + bean.setTestString("This is my test string"); + + bean.setBeforeInsertReturn(false); + manager.insert(bean); + assertEquals("beforeInsert -1;This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + assertNull(manager.restore(1)); + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testUpdateCallbacks(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + CallbacksBean.clearExecuteCallbacks(); + + var bean = new CallbacksBean(); + + bean.setTestString("This is my test string"); + + manager.update(bean); + assertEquals("beforeUpdate -1;This is my test string\n" + + "afterUpdate false -1;This is my test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + var id = manager.insert(bean); + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + bean.setTestString("This is a new test string"); + + manager.update(bean); + assertEquals("beforeUpdate " + id + ";This is a new test string\n" + + "afterUpdate true " + id + ";This is a new test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testUpdateCallbacksReturns(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + CallbacksBean.clearExecuteCallbacks(); + + var bean = new CallbacksBean(); + bean.setTestString("This is my test string"); + + var id = manager.insert(bean); + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + bean.setTestString("This is a new test string"); + + bean.setBeforeUpdateReturn(false); + manager.update(bean); + assertEquals("beforeUpdate " + id + ";This is a new test string", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + assertEquals("This is my test string", manager.restore(id).getTestString()); + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testDeleteCallbacks(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + CallbacksBean.clearExecuteCallbacks(); + + var bean = new CallbacksBean(); + + bean.setTestString("This is my test string"); + + var id = manager.save(bean); + + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + manager.delete(id); + assertEquals("beforeDelete " + id + "\n" + + "afterDelete true " + id + "", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testDeleteCallbacksReturns(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + CallbacksBean.clearExecuteCallbacks(); + + var bean = new CallbacksBean(); + + bean.setTestString("This is my test string"); + + var id = manager.save(bean); + + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.setBeforeDeleteReturn(false); + manager.delete(id); + assertEquals("beforeDelete " + id + "", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + assertNotNull(manager.restore(id)); + + CallbacksBean.setBeforeDeleteReturn(true); + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testDeleteListeners(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + CallbacksBean.clearExecuteCallbacks(); + + var bean = new CallbacksBean(); + + bean.setTestString("This is my test string"); + + var id = manager.save(bean); + + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + var listener = new AggregatingCallbacksBeanListener(); + try { + manager.addListener(listener); + manager.delete(id); + var history = listener.getHistory(); + assertEquals(1, history.size()); + var entry = history.entrySet().iterator().next(); + assertEquals("deleted0", entry.getKey()); + assertEquals(id, entry.getValue()); + assertEquals("beforeDelete " + id + "\n" + + "afterDelete true " + id + "", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + } finally { + manager.removeListeners(); + } + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testRestoreCallbacks(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + CallbacksBean.clearExecuteCallbacks(); + + var bean1 = new CallbacksBean(); + var bean2 = new CallbacksBean(); + var bean3 = new CallbacksBean(); + + bean1.setTestString("This is bean1"); + bean2.setTestString("This is bean2"); + bean3.setTestString("This is bean3"); + + var id1 = manager.save(bean1); + var id2 = manager.save(bean2); + var id3 = manager.save(bean3); + + CallbacksBean.clearExecuteCallbacks(); + + // restore all beans + assertEquals(3, manager.restore(manager.getRestoreQuery().orderBy("id")).size()); + + assertEquals("afterRestore " + id1 + ";This is bean1\n" + + "afterRestore " + id2 + ";This is bean2\n" + + "afterRestore " + id3 + ";This is bean3", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + // restore a specific bean + manager.restore(bean2.getId()); + + assertEquals("afterRestore " + id2 + ";This is bean2", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.clearExecuteCallbacks(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + // restore the first bean + manager.restoreFirst(manager.getRestoreQuery().orderBy("id")); + + assertEquals("afterRestore " + id1 + ";This is bean1", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.clearExecuteCallbacks(); + CallbacksBean.setAfterRestoreReturn(true); + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testRestoreCallbacksReturns(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + CallbacksBean.clearExecuteCallbacks(); + + var bean1 = new CallbacksBean(); + var bean2 = new CallbacksBean(); + var bean3 = new CallbacksBean(); + + bean1.setTestString("This is bean1"); + bean2.setTestString("This is bean2"); + bean3.setTestString("This is bean3"); + + var id = manager.save(bean1); + manager.save(bean2); + manager.save(bean3); + + CallbacksBean.clearExecuteCallbacks(); + CallbacksBean.setAfterRestoreReturn(false); + + assertEquals(1, manager.restore(manager.getRestoreQuery().orderBy("id")).size()); + + assertEquals("afterRestore " + id + ";This is bean1", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.setAfterRestoreReturn(true); + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testRestoreListeners(Datasource datasource) { + var manager = setUpCallbacksBeanManager(datasource); + try { + CallbacksBean.clearExecuteCallbacks(); + + var bean1 = new CallbacksBean(); + var bean2 = new CallbacksBean(); + var bean3 = new CallbacksBean(); + + bean1.setTestString("This is bean1"); + bean2.setTestString("This is bean2"); + bean3.setTestString("This is bean3"); + + var id1 = manager.save(bean1); + var id2 = manager.save(bean2); + var id3 = manager.save(bean3); + + CallbacksBean.clearExecuteCallbacks(); + + var listener = new AggregatingCallbacksBeanListener(); + manager.addListener(listener); + try { + // restore all beans + var restored = manager.restore(manager.getRestoreQuery().orderBy("id")); + assertEquals(3, restored.size()); + + Map history; + Iterator> it; + Map.Entry entry; + + history = listener.getHistory(); + assertEquals(3, history.size()); + it = history.entrySet().iterator(); + entry = it.next(); + assertEquals("restored0", entry.getKey()); + assertSame(restored.get(0), entry.getValue()); + entry = it.next(); + assertEquals("restored1", entry.getKey()); + assertSame(restored.get(1), entry.getValue()); + entry = it.next(); + assertEquals("restored2", entry.getKey()); + assertSame(restored.get(2), entry.getValue()); + assertEquals("afterRestore " + id1 + ";listener restored\n" + + "afterRestore " + id2 + ";listener restored\n" + + "afterRestore " + id3 + ";listener restored", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.clearExecuteCallbacks(); + listener.clearHistory(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + // restore a specific bean + var restored_specific = manager.restore(bean2.getId()); + + history = listener.getHistory(); + assertEquals(1, history.size()); + it = history.entrySet().iterator(); + entry = it.next(); + assertEquals("restored0", entry.getKey()); + assertSame(restored_specific, entry.getValue()); + assertEquals("afterRestore " + id2 + ";listener restored", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.clearExecuteCallbacks(); + listener.clearHistory(); + assertEquals("", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + // restore the first bean + var restored_first = manager.restoreFirst(manager.getRestoreQuery().orderBy("id")); + + history = listener.getHistory(); + assertEquals(1, history.size()); + it = history.entrySet().iterator(); + entry = it.next(); + assertEquals("restored0", entry.getKey()); + assertSame(restored_first, entry.getValue()); + assertEquals("afterRestore " + id1 + ";listener restored", StringUtils.join(CallbacksBean.getExecutedCallbacks(), "\n")); + + CallbacksBean.clearExecuteCallbacks(); + listener.clearHistory(); + CallbacksBean.setAfterRestoreReturn(true); + } finally { + manager.removeListeners(); + } + } finally { + tearDownCallbacksBean(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testCallbacksProvider(Datasource datasource) { + var manager = setUpCallbacksProviderBeanManager(datasource); + try { + CallbacksProviderBean.clearExecuteCallbacks(); + + var bean = new CallbacksProviderBean(); + CallbacksProviderBean new_bean = null; + + bean.setTestString("This is my test string"); + + var id1 = manager.save(bean); + + new_bean = manager.restore(id1); + + assertNotNull(new_bean); + assertNotSame(new_bean, bean); + assertEquals(new_bean.getTestString(), bean.getTestString()); + assertEquals(new_bean.getId(), id1); + + bean.setId(id1); + bean.setTestString("This is a new test string"); + + assertEquals(manager.save(bean), id1); + assertEquals(bean.getId(), id1); + + new_bean = manager.restore(id1); + + assertNotNull(new_bean); + assertNotSame(new_bean, bean); + + assertEquals(new_bean.getTestString(), "This is a new test string"); + + bean.setId(999999); + bean.setTestString("This is another test string"); + + var id2 = id1 + 1; + + assertEquals(id2, manager.save(bean)); + assertNotEquals(999999, id2); + assertEquals(bean.getId(), id1 + 1); + + bean.setId(76876); + bean.setTestString("This is a last test string"); + + var id3 = id2 + 1; + assertEquals(id3, manager.insert(bean)); + + bean.setTestString("This is an updated test string"); + assertEquals(id3, manager.update(bean)); + + assertTrue(manager.delete(id2)); + assertEquals(2, manager.restore().size()); + + assertEquals("beforeSave -1;This is my test string\n" + + "beforeInsert -1;This is my test string\n" + + "afterInsert true " + id1 + ";This is my test string\n" + + "afterSave true " + id1 + ";This is my test string\n" + + "afterRestore " + id1 + ";This is my test string\n" + + "beforeSave " + id1 + ";This is a new test string\n" + + "beforeUpdate " + id1 + ";This is a new test string\n" + + "afterUpdate true " + id1 + ";This is a new test string\n" + + "afterSave true " + id1 + ";This is a new test string\n" + + "afterRestore " + id1 + ";This is a new test string\n" + + "beforeSave 999999;This is another test string\n" + + "beforeUpdate 999999;This is another test string\n" + + "afterUpdate false 999999;This is another test string\n" + + "beforeInsert 999999;This is another test string\n" + + "afterInsert true " + id2 + ";This is another test string\n" + + "afterSave true " + id2 + ";This is another test string\n" + + "beforeInsert 76876;This is a last test string\n" + + "afterInsert true " + id3 + ";This is a last test string\n" + + "beforeUpdate " + id3 + ";This is an updated test string\n" + + "afterUpdate true " + id3 + ";This is an updated test string\n" + + "beforeDelete " + id2 + "\n" + + "afterDelete true " + id2 + "\n" + + "afterRestore " + id1 + ";This is a new test string\n" + + "afterRestore " + id3 + ";This is an updated test string", StringUtils.join(CallbacksProviderBean.getExecutedCallbacks(), "\n")); + } finally { + tearDownCallbacksProviderBean(manager); + } + } +} diff --git a/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerChild.java b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerChild.java new file mode 100644 index 00000000..49f547c4 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerChild.java @@ -0,0 +1,70 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ArgumentsSource; +import rife.database.Datasource; +import rife.database.TestDatasources; +import rife.database.querymanagers.generic.beans.ChildBean; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; + +public class TestGenericQueryManagerChild { + protected GenericQueryManager setUp(Datasource datasource) { + var manager = GenericQueryManagerFactory.getInstance(datasource, ChildBean.class); + manager.install(); + return manager; + } + + protected void tearDown(GenericQueryManager manager) { + manager.remove(); + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetBaseClass(Datasource datasource) { + var manager = setUp(datasource); + try { + assertSame(ChildBean.class, manager.getBaseClass()); + } finally { + tearDown(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testInstallCustomQuery(Datasource datasource) { + var manager = setUp(datasource); + try { + manager.remove(); + manager.install(manager.getInstallTableQuery()); + } finally { + tearDown(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testChildBean(Datasource datasource) { + var manager = setUp(datasource); + try { + var bean = new ChildBean(); + + bean.setParentString("This is bean"); + bean.setChildString("This is childbean"); + + var id = manager.save(bean); + + var rbean = manager.restore(id); + + assertEquals(rbean.getParentString(), bean.getParentString()); + assertEquals(rbean.getChildString(), bean.getChildString()); + } finally { + tearDown(manager); + } + } +} diff --git a/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerConstrained.java b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerConstrained.java new file mode 100644 index 00000000..eb845d57 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerConstrained.java @@ -0,0 +1,157 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ArgumentsSource; +import rife.database.Datasource; +import rife.database.TestDatasources; +import rife.database.exceptions.DatabaseException; +import rife.database.querymanagers.generic.beans.ConstrainedBean; +import rife.database.querymanagers.generic.beans.LinkBean; +import rife.validation.ValidationError; + +import java.sql.SQLException; + +import static org.junit.jupiter.api.Assertions.*; + +public class TestGenericQueryManagerConstrained { + private GenericQueryManager linkManager_ = null; + private GenericQueryManager constrainedManager_ = null; + + protected void setUp(Datasource datasource) { + linkManager_ = new TestGenericQueryManagerDelegate.GQMLinkBean(datasource); + constrainedManager_ = new TestGenericQueryManagerDelegate.GQMConstrainedBean(datasource); + linkManager_.install(); + constrainedManager_.install(); + } + + protected void tearDown() { + constrainedManager_.remove(); + linkManager_.remove(); + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetBaseClass(Datasource datasource) { + setUp(datasource); + try { + assertSame(LinkBean.class, linkManager_.getBaseClass()); + assertSame(ConstrainedBean.class, constrainedManager_.getBaseClass()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testInstallCustomQuery(Datasource datasource) { + setUp(datasource); + try { + constrainedManager_.remove(); + linkManager_.remove(); + + linkManager_.install(linkManager_.getInstallTableQuery()); + constrainedManager_.install(constrainedManager_.getInstallTableQuery()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testSaveRestoreConstrained(Datasource datasource) { + setUp(datasource); + try { + var bean = new ConstrainedBean(); + ConstrainedBean new_bean = null; + + bean.setTestString("This is my test string"); + + var id = constrainedManager_.save(bean); + + new_bean = constrainedManager_.restore(id); + + assertNotNull(new_bean); + assertNotSame(new_bean, bean); + assertEquals(new_bean.getTestString(), bean.getTestString()); + assertEquals(new_bean.getIdentifier(), id); + + bean.setIdentifier(id); + bean.setTestString("This is a new test string"); + + assertEquals(constrainedManager_.save(bean), id); + assertEquals(bean.getIdentifier(), id); + + new_bean = constrainedManager_.restore(id); + + assertNotNull(new_bean); + assertNotSame(new_bean, bean); + + assertEquals(new_bean.getTestString(), "This is a new test string"); + + bean.setIdentifier(999999); + bean.setTestString("This is another test string"); + + assertNotEquals(999999, constrainedManager_.save(bean)); + assertEquals(bean.getIdentifier(), id + 1); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testValidationContextManyToOne(Datasource datasource) { + setUp(datasource); + try { + var link_bean1 = new LinkBean(); + var link_bean2 = new LinkBean(); + var link_bean3 = new LinkBean(); + + link_bean1.setTestString("linkbean 1"); + link_bean2.setTestString("linkbean 2"); + link_bean3.setTestString("linkbean 3"); + + linkManager_.save(link_bean1); + linkManager_.save(link_bean2); + linkManager_.save(link_bean3); + + var bean1 = new ConstrainedBean(); + bean1.setTestString("test_string1"); + assertTrue(bean1.validate(constrainedManager_)); + var id1 = constrainedManager_.save(bean1); + + var bean2 = new ConstrainedBean(); + bean2.setTestString("test_string2"); + bean2.setLinkBean(link_bean1.getId()); + assertTrue(bean2.validate(constrainedManager_)); + var id2 = constrainedManager_.save(bean2); + assertTrue(id1 != id2); + + var bean3 = new ConstrainedBean(); + bean3.setTestString("test_string2"); + bean3.setLinkBean(23); + assertFalse(bean3.validate(constrainedManager_)); + var error = (ValidationError) bean3.getValidationErrors().iterator().next(); + assertEquals(error.getSubject(), "linkBean"); + assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID); + try { + constrainedManager_.save(bean3); + fail("exception not thrown"); + } catch (DatabaseException e) { + assertTrue(e.getCause() instanceof SQLException); + } + + bean3.resetValidation(); + bean3.setLinkBean(link_bean3.getId()); + assertTrue(bean3.validate(constrainedManager_)); + var id3 = constrainedManager_.save(bean3); + assertTrue(id2 != id3); + } finally { + tearDown(); + } + } +} diff --git a/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerDelegate.java b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerDelegate.java new file mode 100644 index 00000000..ea718d1b --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerDelegate.java @@ -0,0 +1,341 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ArgumentsSource; +import rife.database.*; +import rife.database.querymanagers.generic.beans.ChildBean; +import rife.database.querymanagers.generic.beans.ConstrainedBean; +import rife.database.querymanagers.generic.beans.LinkBean; +import rife.database.querymanagers.generic.beans.SimpleBean; + +import java.sql.ResultSet; +import java.sql.SQLException; + +import static org.junit.jupiter.api.Assertions.*; + +public class TestGenericQueryManagerDelegate { + static class GQMSimpleBean extends GenericQueryManagerDelegate { + GQMSimpleBean(Datasource datasource) { + super(datasource, SimpleBean.class); + } + } + + static class GQMLinkBean extends GenericQueryManagerDelegate { + GQMLinkBean(Datasource datasource) { + super(datasource, LinkBean.class); + } + } + + static class GQMChildBean extends GenericQueryManagerDelegate { + GQMChildBean(Datasource datasource) { + super(datasource, ChildBean.class); + } + } + + static class GQMConstrainedBean extends GenericQueryManagerDelegate { + GQMConstrainedBean(Datasource datasource) { + super(datasource, ConstrainedBean.class); + } + } + + private GQMSimpleBean manager_ = null; + private GQMLinkBean linkManager_ = null; + private GQMChildBean childManager_ = null; + private GQMConstrainedBean constrainedManager_ = null; + + protected void setUp(Datasource datasource) { + manager_ = new GQMSimpleBean(datasource); + linkManager_ = new GQMLinkBean(datasource); + childManager_ = new GQMChildBean(datasource); + constrainedManager_ = new GQMConstrainedBean(datasource); + + manager_.install(); + linkManager_.install(); + childManager_.install(); + constrainedManager_.install(); + } + + protected void tearDown() { + constrainedManager_.remove(); + manager_.remove(); + linkManager_.remove(); + childManager_.remove(); + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testSaveRestore(Datasource datasource) { + setUp(datasource); + try { + var bean = new SimpleBean(); + SimpleBean newbean = null; + + bean.setTestString("This is my test string"); + + var id = manager_.save(bean); + + newbean = manager_.restore(id); + + assertNotNull(newbean); + assertNotSame(newbean, bean); + assertEquals(newbean.getTestString(), bean.getTestString()); + assertEquals(newbean.getId(), id); + + bean.setId(id); + bean.setTestString("This is a new test string"); + + assertEquals(manager_.save(bean), id); + assertEquals(bean.getId(), id); + + newbean = manager_.restore(id); + + assertNotNull(newbean); + assertNotSame(newbean, bean); + + assertEquals(newbean.getTestString(), "This is a new test string"); + + bean.setId(999999); + bean.setTestString("This is another test string"); + + assertNotEquals(999999, manager_.save(bean)); + assertEquals(bean.getId(), id + 1); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testSaveRestoreConstrained(Datasource datasource) { + setUp(datasource); + try { + var bean = new ConstrainedBean(); + ConstrainedBean newbean = null; + + bean.setTestString("This is my test string"); + + var id = constrainedManager_.save(bean); + + newbean = constrainedManager_.restore(id); + + assertNotNull(newbean); + assertNotSame(newbean, bean); + assertEquals(newbean.getTestString(), bean.getTestString()); + assertEquals(newbean.getIdentifier(), id); + + bean.setIdentifier(id); + bean.setTestString("This is a new test string"); + + assertEquals(constrainedManager_.save(bean), id); + assertEquals(bean.getIdentifier(), id); + + newbean = constrainedManager_.restore(id); + + assertNotNull(newbean); + assertNotSame(newbean, bean); + + assertEquals(newbean.getTestString(), "This is a new test string"); + + bean.setIdentifier(999999); + bean.setTestString("This is another test string"); + + assertNotEquals(999999, constrainedManager_.save(bean)); + assertEquals(bean.getIdentifier(), id + 1); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testDelete(Datasource datasource) { + setUp(datasource); + try { + var bean = new SimpleBean(); + + bean.setTestString("This is my test string"); + + var id1 = manager_.save(bean); + assertNotNull(manager_.restore(id1)); + manager_.delete(id1); + assertNull(manager_.restoreFirst(manager_.getRestoreQuery(id1))); + + var id2 = manager_.save(bean); + assertNotNull(manager_.restoreFirst(manager_.getRestoreQuery(id2))); + manager_.delete(manager_.getDeleteQuery(id2)); + assertNull(manager_.restore(id2)); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testRestore(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + + bean1.setTestString("This is bean1"); + bean2.setTestString("This is bean2"); + bean3.setTestString("This is bean3"); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + + var list = manager_.restore(); + + assertEquals(list.size(), 3); + + for (var bean : list) { + assertNotNull(bean); + assertTrue(bean != bean1 || bean != bean2 || bean != bean3); + assertTrue( + bean.getTestString().equals("This is bean1") || + bean.getTestString().equals("This is bean2") || + bean.getTestString().equals("This is bean3")); + } + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testRestoreRowProcessor(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + + bean1.setTestString("This is bean1"); + bean2.setTestString("This is bean2"); + bean3.setTestString("This is bean3"); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + + final var count = new int[]{0}; + manager_.restore(new DbRowProcessor() { + public boolean processRow(ResultSet resultSet) + throws SQLException { + count[0]++; + + var test_string = resultSet.getString("testString"); + assertTrue( + test_string.equals("This is bean1") || + test_string.equals("This is bean2") || + test_string.equals("This is bean3")); + + return true; + } + }); + + assertEquals(count[0], 3); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testRestoreQueryRowProcessor(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + + bean1.setTestString("This is bean1"); + bean2.setTestString("This is bean2"); + bean3.setTestString("This is bean3"); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + + final var count = new int[]{0}; + manager_.restore(manager_.getRestoreQuery().where("testString", "LIKE", "%bean2"), new DbRowProcessor() { + public boolean processRow(ResultSet resultSet) + throws SQLException { + count[0]++; + + var test_string = resultSet.getString("testString"); + assertEquals("This is bean2", test_string); + + return true; + } + }); + + assertEquals(count[0], 1); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testChildBean(Datasource datasource) { + setUp(datasource); + try { + var bean = new ChildBean(); + + bean.setParentString("This is bean"); + bean.setChildString("This is childbean"); + + var id = childManager_.save(bean); + + var rbean = childManager_.restore(id); + + assertEquals(rbean.getParentString(), bean.getParentString()); + assertEquals(rbean.getChildString(), bean.getChildString()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testCount(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + manager_.save(bean4); + manager_.save(bean5); + + assertEquals(manager_.count(), 5); + + manager_.delete(bean1.getId()); + manager_.delete(bean2.getId()); + manager_.delete(bean3.getId()); + + assertEquals(manager_.count(), 2); + } finally { + tearDown(); + } + } +} + diff --git a/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerManyToMany.java b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerManyToMany.java new file mode 100644 index 00000000..6ceb7778 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerManyToMany.java @@ -0,0 +1,398 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ArgumentsSource; +import rife.database.*; +import rife.database.queries.Select; +import rife.database.querymanagers.generic.beans.MMFirstBean; +import rife.database.querymanagers.generic.beans.MMSecondBean; +import rife.validation.ValidationError; + +import java.util.ArrayList; +import java.util.Collection; + +import static org.junit.jupiter.api.Assertions.*; + +public class TestGenericQueryManagerManyToMany { + private GenericQueryManager firstManager_ = null; + private GenericQueryManager secondManager_ = null; + + protected void setUp(Datasource datasource) { + firstManager_ = GenericQueryManagerFactory.getInstance(datasource, MMFirstBean.class); + secondManager_ = GenericQueryManagerFactory.getInstance(datasource, MMSecondBean.class); + secondManager_.install(); + firstManager_.install(); + } + + protected void tearDown() { + firstManager_.remove(); + secondManager_.remove(); + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetBaseClass(Datasource datasource) { + setUp(datasource); + try { + assertSame(MMFirstBean.class, firstManager_.getBaseClass()); + assertSame(MMSecondBean.class, secondManager_.getBaseClass()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testInstallCustomQuery(Datasource datasource) { + setUp(datasource); + try { + firstManager_.remove(); + secondManager_.remove(); + + secondManager_.install(secondManager_.getInstallTableQuery()); + firstManager_.install(firstManager_.getInstallTableQuery()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testSaveRestoreConstrained(Datasource datasource) { + setUp(datasource); + try { + var bean = new MMFirstBean(); + MMFirstBean new_bean = null; + + bean.setFirstString("This is my test string"); + + // add the many-to-many relations to the bean instance + var bean2a = new MMSecondBean(); + bean2a.setSecondString("MMSecondBeanA"); + + var bean2b = new MMSecondBean(); + bean2b.setSecondString("MMSecondBeanB"); + + var bean2c = new MMSecondBean(); + bean2c.setSecondString("MMSecondBeanC"); + + Collection second_beans = new ArrayList<>(); + second_beans.add(bean2a); + second_beans.add(bean2b); + second_beans.add(bean2c); + bean.setSecondBeans(second_beans); + + // assert that the many-to-many relations have not been saved too + assertNull(bean2a.getIdentifier()); + assertNull(bean2b.getIdentifier()); + assertNull(bean2c.getIdentifier()); + + // save the bean instance + Integer id = firstManager_.save(bean); + + // assert that the many-to-many relations have been saved too + assertNotNull(bean2a.getIdentifier()); + assertNotNull(bean2b.getIdentifier()); + assertNotNull(bean2c.getIdentifier()); + + // restore the bean instance + new_bean = firstManager_.restore(id); + + // assert that the bean has correctly been restored + assertNotNull(new_bean); + assertNotSame(new_bean, bean); + assertEquals(new_bean.getFirstString(), bean.getFirstString()); + assertEquals(new_bean.getIdentifier(), id); + + // assert that the many-to-many relationships have correctly been restored + var second_beans_restored = new_bean.getSecondBeans(); + var bean2a_found = false; + var bean2b_found = false; + var bean2c_found = false; + for (var second_bean : second_beans_restored) { + if ("MMSecondBeanA".equals(second_bean.getSecondString())) { + assertFalse(bean2a_found); + assertEquals(bean2a.getIdentifier(), second_bean.getIdentifier()); + assertEquals(bean2a.getSecondString(), second_bean.getSecondString()); + bean2a_found = true; + } else if ("MMSecondBeanB".equals(second_bean.getSecondString())) { + assertFalse(bean2b_found); + assertEquals(bean2b.getIdentifier(), second_bean.getIdentifier()); + assertEquals(bean2b.getSecondString(), second_bean.getSecondString()); + bean2b_found = true; + } else if ("MMSecondBeanC".equals(second_bean.getSecondString())) { + assertFalse(bean2c_found); + assertEquals(bean2c.getIdentifier(), second_bean.getIdentifier()); + assertEquals(bean2c.getSecondString(), second_bean.getSecondString()); + bean2c_found = true; + } + + assertNotNull(second_bean.getFirstBeans()); + assertEquals(1, second_bean.getFirstBeans().size()); + + var first_bean = second_bean.getFirstBeans().iterator().next(); + assertEquals(new_bean.getIdentifier(), first_bean.getIdentifier()); + assertEquals(new_bean.getFirstString(), first_bean.getFirstString()); + } + assertTrue(bean2a_found); + assertTrue(bean2b_found); + assertTrue(bean2c_found); + + // perform update with changed many-to-many relationships + // only the data of those that haven't been saved before will + // be stored + bean.setIdentifier(id); + bean.setFirstString("This is a new test string"); + + bean2a.setSecondString("MMSecondBeanAUpdated"); + + var bean2d = new MMSecondBean(); + bean2d.setSecondString("MMSecondBeanD"); + second_beans = new ArrayList<>(); + second_beans.add(bean2a); + second_beans.add(bean2c); + second_beans.add(bean2d); + bean.setSecondBeans(second_beans); + + assertEquals(firstManager_.save(bean), id.intValue()); + assertEquals(bean.getIdentifier(), id); + + // restore the updated bean + new_bean = firstManager_.restore(id); + + assertNotNull(new_bean); + assertNotSame(new_bean, bean); + + // assert that the updated bean has been stored correctly + assertEquals(new_bean.getFirstString(), "This is a new test string"); + + // assert that the many-to-many relationships have correctly been stored and restored + second_beans_restored = new_bean.getSecondBeans(); + bean2a_found = false; + bean2b_found = false; + bean2c_found = false; + var bean2d_found = false; + for (var second_bean : second_beans_restored) { + if ("MMSecondBeanA".equals(second_bean.getSecondString())) { + assertFalse(bean2a_found); + assertEquals(bean2a.getIdentifier(), second_bean.getIdentifier()); + // the data of this many-to-many association hasn't been updated since the entity already was saved before + assertNotEquals(bean2a.getSecondString(), second_bean.getSecondString()); + bean2a_found = true; + } else if ("MMSecondBeanB".equals(second_bean.getSecondString())) { + bean2b_found = true; + } else if ("MMSecondBeanC".equals(second_bean.getSecondString())) { + assertFalse(bean2c_found); + assertEquals(bean2c.getIdentifier(), second_bean.getIdentifier()); + assertEquals(bean2c.getSecondString(), second_bean.getSecondString()); + bean2c_found = true; + } else if ("MMSecondBeanD".equals(second_bean.getSecondString())) { + assertFalse(bean2d_found); + assertEquals(bean2d.getIdentifier(), second_bean.getIdentifier()); + assertEquals(bean2d.getSecondString(), second_bean.getSecondString()); + bean2d_found = true; + } + + assertNotNull(second_bean.getFirstBeans()); + assertEquals(1, second_bean.getFirstBeans().size()); + + var first_bean = second_bean.getFirstBeans().iterator().next(); + assertEquals(new_bean.getIdentifier(), first_bean.getIdentifier()); + assertEquals(new_bean.getFirstString(), first_bean.getFirstString()); + } + assertTrue(bean2a_found); + assertFalse(bean2b_found); + assertTrue(bean2c_found); + assertTrue(bean2d_found); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testDelete(Datasource datasource) { + setUp(datasource); + try { + var bean = new MMFirstBean(); + + bean.setFirstString("This is my test string"); + + // add the many-to-many relations to the bean instance + var bean2a = new MMSecondBean(); + bean2a.setSecondString("MMSecondBeanA"); + + var bean2b = new MMSecondBean(); + bean2b.setSecondString("MMSecondBeanB"); + + Collection second_beans = new ArrayList<>(); + second_beans.add(bean2a); + second_beans.add(bean2b); + bean.setSecondBeans(second_beans); + + // save the bean instance + var id1 = firstManager_.save(bean); + + // ensure that everything was saved correctly + assertNotNull(firstManager_.restore(id1)); + assertEquals(2, new DbQueryManager(datasource) + .executeGetFirstInt(new Select(datasource) + .field("count(*)") + .from("mmfirstbean_mmsecondbean") + .where("mmfirstbean_identifier", "=", id1))); + assertEquals(2, secondManager_.count()); + + // delete the first bean + firstManager_.delete(id1); + + // ensure that everything was deleted correctly + assertNull(firstManager_.restore(id1)); + assertEquals(0, new DbQueryManager(datasource) + .executeGetFirstInt(new Select(datasource) + .field("count(*)") + .from("mmfirstbean_mmsecondbean") + .where("mmfirstbean_identifier", "=", id1))); + assertEquals(2, secondManager_.count()); + + // add another many-to-many relationship + var bean2c = new MMSecondBean(); + bean2b.setSecondString("MMSecondBeanC"); + second_beans.add(bean2c); + + // save the bean instance again + var id2 = firstManager_.save(bean); + + // ensure that everything was saved correctly + assertNotNull(firstManager_.restore(id2)); + assertEquals(3, new DbQueryManager(datasource) + .executeGetFirstInt(new Select(datasource) + .field("count(*)") + .from("mmfirstbean_mmsecondbean") + .where("mmfirstbean_identifier", "=", id2))); + assertEquals(3, secondManager_.count()); + + // delete the second bean + firstManager_.delete(id2); + + // ensure that everything was deleted correctly + assertNull(firstManager_.restore(id2)); + assertEquals(0, new DbQueryManager(datasource) + .executeGetFirstInt(new Select(datasource) + .field("count(*)") + .from("mmfirstbean_mmsecondbean") + .where("mmfirstbean_identifier", "=", id2))); + assertEquals(3, secondManager_.count()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testValidationContextManyToMany(Datasource datasource) { + setUp(datasource); + try { + var bean = new MMFirstBean(); + + bean.setFirstString("This is my test string"); + + // add the many-to-many relations to the bean instance + var bean2a = new MMSecondBean(); + bean2a.setIdentifier(23); + bean2a.setSecondString("MMSecondBeanA"); + + var bean2b = new MMSecondBean(); + bean2b.setIdentifier(24); + bean2b.setSecondString("MMSecondBeanB"); + + Collection second_beans = new ArrayList<>(); + second_beans.add(bean2a); + second_beans.add(bean2b); + bean.setSecondBeans(second_beans); + + // validate the bean instance + ValidationError error; + assertFalse(bean.validate(firstManager_)); + error = bean.getValidationErrors().iterator().next(); + assertEquals(error.getSubject(), "secondBeans"); + assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID); + + bean.resetValidation(); + + // store the first associated bean + secondManager_.save(bean2a); + + // validate the bean instance again + assertFalse(bean.validate(firstManager_)); + error = bean.getValidationErrors().iterator().next(); + assertEquals(error.getSubject(), "secondBeans"); + assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID); + + // store the second associated bean + secondManager_.save(bean2b); + + bean.resetValidation(); + + // validate the bean instance a last time + assertTrue(bean.validate(firstManager_)); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testValidationContextManyToManyAssociation(Datasource datasource) { + setUp(datasource); + try { + var bean2 = new MMSecondBean(); + bean2.setSecondString("This is my test string"); + + // add the many-to-many association relations to the bean instance + var bean1a = new MMFirstBean(); + bean1a.setIdentifier(23); + bean1a.setFirstString("MMFirstBeanA"); + + var bean1b = new MMFirstBean(); + bean1b.setIdentifier(24); + bean1b.setFirstString("MMFirstBeanB"); + + Collection first_beans = new ArrayList<>(); + first_beans.add(bean1a); + first_beans.add(bean1b); + bean2.setFirstBeans(first_beans); + + // validate the bean instance + ValidationError error; + assertFalse(bean2.validate(secondManager_)); + error = bean2.getValidationErrors().iterator().next(); + assertEquals(error.getSubject(), "firstBeans"); + assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID); + + bean2.resetValidation(); + + // store the first associated bean + firstManager_.save(bean1a); + + // validate the bean instance again + assertFalse(bean2.validate(secondManager_)); + error = bean2.getValidationErrors().iterator().next(); + assertEquals(error.getSubject(), "firstBeans"); + assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID); + + // store the second associated bean + firstManager_.save(bean1b); + + bean2.resetValidation(); + + // validate the bean instance a last time + assertTrue(bean2.validate(secondManager_)); + } finally { + tearDown(); + } + } +} diff --git a/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerManyToOne.java b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerManyToOne.java new file mode 100644 index 00000000..7a2103c4 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerManyToOne.java @@ -0,0 +1,533 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ArgumentsSource; +import rife.database.Datasource; +import rife.database.TestDatasources; +import rife.validation.ValidationError; +import rifetestmodels.MOFirstBean; +import rifetestmodels.MOSecondBean; +import rifetestmodels.MOThirdBean; + +import java.util.ArrayList; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +public class TestGenericQueryManagerManyToOne { + private GenericQueryManager firstManager_ = null; + private GenericQueryManager secondManager_ = null; + private GenericQueryManager thirdManager_ = null; + + protected void setUp(Datasource datasource) { + firstManager_ = GenericQueryManagerFactory.getInstance(datasource, MOFirstBean.class); + secondManager_ = GenericQueryManagerFactory.getInstance(datasource, MOSecondBean.class); + thirdManager_ = GenericQueryManagerFactory.getInstance(datasource, MOThirdBean.class); + thirdManager_.install(); + secondManager_.install(); + firstManager_.install(); + } + + protected void tearDown() { + firstManager_.remove(); + secondManager_.remove(); + thirdManager_.remove(); + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetBaseClass(Datasource datasource) { + setUp(datasource); + try { + assertSame(MOFirstBean.class, firstManager_.getBaseClass()); + assertSame(MOSecondBean.class, secondManager_.getBaseClass()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testInstallCustomQuery(Datasource datasource) { + setUp(datasource); + try { + firstManager_.remove(); + secondManager_.remove(); + + secondManager_.install(secondManager_.getInstallTableQuery()); + firstManager_.install(firstManager_.getInstallTableQuery()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testSaveRestoreConstrained(Datasource datasource) { + setUp(datasource); + try { + var bean_a = new MOFirstBean(); + var bean_b = new MOFirstBean(); + MOFirstBean new_bean_a = null; + MOFirstBean new_bean_b = null; + + bean_a.setFirstString("This is my test string"); + bean_b.setFirstString("This is my test string B"); + + // add the many-to-one relations to the bean instance + var bean_2a = new MOSecondBean(); + bean_2a.setSecondString("MOSecondBeanA"); + + var bean_2b = new MOSecondBean(); + bean_2b.setSecondString("MOSecondBeanB"); + + var bean_2c = new MOSecondBean(); + bean_2c.setSecondString("MOSecondBeanC"); + + var bean_3a = new MOThirdBean(); + bean_3a.setThirdString("MOThirdBeanA"); + + var bean_3b = new MOThirdBean(); + bean_3a.setThirdString("MOThirdBeanB"); + + bean_a.setSecondBean(bean_2a); + bean_a.setSecondBean2(bean_2b); + bean_a.setThirdBean(bean_3a); + + bean_b.setSecondBean(bean_2b); + bean_b.setSecondBean2(bean_2c); + bean_b.setThirdBean(bean_3b); + + // assert that the many-to-one relations have not been saved too + assertNull(bean_2a.getIdentifier()); + assertNull(bean_2b.getIdentifier()); + assertNull(bean_2c.getIdentifier()); + assertNull(bean_3a.getId()); + assertNull(bean_3b.getId()); + + // save the bean instances + Integer ida = firstManager_.save(bean_a); + Integer idb = firstManager_.save(bean_b); + + // assert that the many-to-one relations have been saved too + assertNotNull(bean_2a.getIdentifier()); + assertNotNull(bean_2b.getIdentifier()); + assertNotNull(bean_2c.getIdentifier()); + assertNotNull(bean_3a.getId()); + assertNotNull(bean_3b.getId()); + + // restore the bean instances + new_bean_a = firstManager_.restore(ida); + new_bean_b = firstManager_.restore(idb); + + // assert that the first bean has correctly been restored + assertNotNull(new_bean_a); + assertNotSame(new_bean_a, bean_a); + assertEquals(new_bean_a.getFirstString(), bean_a.getFirstString()); + assertEquals(new_bean_a.getIdentifier(), ida); + + // assert that the first bean's many-to-one relationships have correctly been restored + var second_bean_a = new_bean_a.getSecondBean(); + assertNotNull(second_bean_a); + assertEquals(bean_2a.getIdentifier(), second_bean_a.getIdentifier()); + assertEquals(bean_2a.getSecondString(), second_bean_a.getSecondString()); + + // assert that the second bean has correctly been restored + assertNotNull(new_bean_b); + assertNotSame(new_bean_b, bean_b); + assertEquals(new_bean_b.getFirstString(), bean_b.getFirstString()); + assertEquals(new_bean_b.getIdentifier(), idb); + + // assert that the second bean's many-to-one relationships have correctly been restored + var second_bean_b = new_bean_b.getSecondBean(); + assertNotNull(second_bean_b); + assertEquals(bean_2b.getIdentifier(), second_bean_b.getIdentifier()); + assertEquals(bean_2b.getSecondString(), second_bean_b.getSecondString()); + + // assert that exactly the same instance is returned the next time the property is retrieved + assertSame(second_bean_a, new_bean_a.getSecondBean()); + assertSame(second_bean_a, new_bean_a.getSecondBean()); + assertSame(second_bean_b, new_bean_b.getSecondBean()); + assertSame(second_bean_b, new_bean_b.getSecondBean()); + +/* TODO : requires the lazy loading bytecode infrastructure + + // set the property to null to cause a new instance to be fetched + new_bean_a.setSecondBean(null); + var second_bean_c = new_bean_a.getSecondBean(); + assertNotNull(second_bean_c); + assertEquals(second_bean_c.getIdentifier(), second_bean_a.getIdentifier()); + assertEquals(second_bean_c.getSecondString(), second_bean_a.getSecondString()); + assertNotSame(second_bean_c, second_bean_a); + + new_bean_b.setSecondBean(null); + var second_bean_d = new_bean_b.getSecondBean(); + assertNotNull(second_bean_d); + assertEquals(second_bean_d.getIdentifier(), second_bean_b.getIdentifier()); + assertEquals(second_bean_d.getSecondString(), second_bean_b.getSecondString()); + assertNotSame(second_bean_d, second_bean_b); +*/ + + // assert that the other many-to-one relationships have correctly been restored + var second_bean_2a = new_bean_a.getSecondBean2(); + assertNotNull(second_bean_2a); + assertEquals(bean_2b.getIdentifier(), second_bean_2a.getIdentifier()); + assertEquals(bean_2b.getSecondString(), second_bean_2a.getSecondString()); + + var third_bean_a = new_bean_a.getThirdBean(); + assertNotNull(third_bean_a); + assertEquals(bean_3a.getId(), third_bean_a.getId()); + assertEquals(bean_3a.getThirdString(), third_bean_a.getThirdString()); + + var second_bean_2b = new_bean_b.getSecondBean2(); + assertNotNull(second_bean_2b); + assertEquals(bean_2c.getIdentifier(), second_bean_2b.getIdentifier()); + assertEquals(bean_2c.getSecondString(), second_bean_2b.getSecondString()); + + var third_bean_b = new_bean_b.getThirdBean(); + assertNotNull(third_bean_b); + assertEquals(bean_3b.getId(), third_bean_b.getId()); + assertEquals(bean_3b.getThirdString(), third_bean_b.getThirdString()); + + // perform update with changed many-to-one relationships + // only the data of those that haven't been saved before will + // be stored + bean_a.setIdentifier(ida); + bean_a.setFirstString("This is a new test string"); + + bean_2a.setSecondString("MOSecondBeanAUpdated"); + + var bean2d = new MOSecondBean(); + bean2d.setSecondString("MOSecondBeanD"); + bean_a.setSecondBean2(bean2d); + + assertEquals(firstManager_.save(bean_a), ida.intValue()); + assertEquals(bean_a.getIdentifier(), ida); + + // restore the updated bean + new_bean_a = firstManager_.restore(ida); + + assertNotNull(new_bean_a); + assertNotSame(new_bean_a, bean_a); + + // assert that the updated bean has been stored correctly + assertEquals(new_bean_a.getFirstString(), "This is a new test string"); + + // assert that the many-to-one relationships have correctly been stored and restored + second_bean_a = new_bean_a.getSecondBean(); + assertNotNull(second_bean_a); + assertEquals(bean_2a.getIdentifier(), second_bean_a.getIdentifier()); + // the data of this many-to-one association hasn't been updated since the entity already was saved before + assertNotEquals(bean_2a.getSecondString(), second_bean_a.getSecondString()); + + var second_bean3 = new_bean_a.getSecondBean2(); + assertNotNull(second_bean3); + assertEquals(bean2d.getIdentifier(), second_bean3.getIdentifier()); + assertEquals(bean2d.getSecondString(), second_bean3.getSecondString()); + + third_bean_a = new_bean_a.getThirdBean(); + assertNotNull(third_bean_a); + assertEquals(bean_3a.getId(), third_bean_a.getId()); + assertEquals(bean_3a.getThirdString(), third_bean_a.getThirdString()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testSaveRestoreConstrainedAssociation(Datasource datasource) { + setUp(datasource); + try { + var bean1a = new MOFirstBean(); + bean1a.setFirstString("This is my test string"); + var bean2 = new MOSecondBean(); + bean2.setSecondString("MOSecondBeanA"); + bean1a.setSecondBean(bean2); + + // save the bean instance + Integer id = firstManager_.save(bean1a); + + // save a second instance of the first bean type + var bean1b = new MOFirstBean(); + bean1b.setFirstString("This is my test string B"); + bean1b.setSecondBean(bean2); + firstManager_.save(bean1b); + + // restore the second bean + var second_bean = secondManager_.restore(bean2.getIdentifier()); + + // assert that the second bean association links are correct + var first_beans = second_bean.getFirstBeans(); + assertNotNull(first_beans); + assertEquals(2, first_beans.size()); + for (var bean_assoc_restored : first_beans) { + if (bean_assoc_restored.getIdentifier().equals(bean1a.getIdentifier())) { + assertEquals(bean_assoc_restored.getFirstString(), bean1a.getFirstString()); + } else if (bean_assoc_restored.getIdentifier().equals(bean1b.getIdentifier())) { + assertEquals(bean_assoc_restored.getFirstString(), bean1b.getFirstString()); + } else { + fail(); + } + assertEquals(bean2.getIdentifier(), bean_assoc_restored.getSecondBean().getIdentifier()); + assertEquals(bean2.getSecondString(), bean_assoc_restored.getSecondBean().getSecondString()); + } + + // store the second bean with updated links + first_beans.remove(first_beans.iterator().next()); + secondManager_.save(second_bean); + second_bean = secondManager_.restore(bean2.getIdentifier()); + first_beans = second_bean.getFirstBeans(); + assertNotNull(first_beans); + assertEquals(1, first_beans.size()); + + // save a third instance of the first bean type and an updated + // version of the first instance, which will not be saved + var bean1c = new MOFirstBean(); + bean1c.setFirstString("This is my test string C"); + assertNull(bean1c.getIdentifier()); + List firstbeans2 = new ArrayList(); + firstbeans2.add(bean1a); + bean1a.setFirstString("This is my test string updated"); + firstbeans2.add(bean1c); + second_bean.setFirstBeans(firstbeans2); + secondManager_.save(second_bean); + assertNotNull(bean1c.getIdentifier()); + + second_bean = secondManager_.restore(bean2.getIdentifier()); + first_beans = second_bean.getFirstBeans(); + assertNotNull(first_beans); + assertEquals(2, first_beans.size()); + for (var bean_assoc_restored : first_beans) { + if (bean_assoc_restored.getIdentifier().equals(bean1a.getIdentifier())) { + assertEquals(bean_assoc_restored.getFirstString(), "This is my test string"); + assertNotEquals(bean_assoc_restored.getFirstString(), bean1a.getFirstString()); + } else if (bean_assoc_restored.getIdentifier().equals(bean1c.getIdentifier())) { + assertEquals(bean_assoc_restored.getFirstString(), bean1c.getFirstString()); + } else { + fail(); + } + assertEquals(bean2.getIdentifier(), bean_assoc_restored.getSecondBean().getIdentifier()); + assertEquals(bean2.getSecondString(), bean_assoc_restored.getSecondBean().getSecondString()); + } + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testDelete(Datasource datasource) { + setUp(datasource); + try { + assertEquals(0, secondManager_.count()); + assertEquals(0, thirdManager_.count()); + + var bean = new MOFirstBean(); + + bean.setFirstString("This is my test string"); + + // add the many-to-one relations to the bean instance + var bean_2a = new MOSecondBean(); + bean_2a.setSecondString("MOSecondBeanA"); + + var bean_3 = new MOThirdBean(); + bean_3.setThirdString("MOThirdBean"); + + bean.setSecondBean(bean_2a); + bean.setThirdBean(bean_3); + + // save the bean instance + var id1 = firstManager_.save(bean); + + // ensure that everything was saved correctly + assertNotNull(firstManager_.restore(id1)); + assertEquals(1, secondManager_.count()); + assertEquals(1, thirdManager_.count()); + + // delete the first bean + firstManager_.delete(id1); + + // ensure that everything was deleted correctly + assertNull(firstManager_.restore(id1)); + assertEquals(1, secondManager_.count()); + assertEquals(1, thirdManager_.count()); + + // add another many-to-one relationship + var bean_2c = new MOSecondBean(); + bean_2c.setSecondString("MOSecondBeanC"); + + bean.setSecondBean2(bean_2c); + + // save the bean instance again + var id2 = firstManager_.save(bean); + + // ensure that everything was saved correctly + assertNotNull(firstManager_.restore(id2)); + assertEquals(2, secondManager_.count()); + assertEquals(1, thirdManager_.count()); + + // delete the second bean + firstManager_.delete(id2); + + // ensure that everything was deleted correctly + assertNull(firstManager_.restore(id2)); + assertEquals(2, secondManager_.count()); + assertEquals(1, thirdManager_.count()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testDeleteAssociation(Datasource datasource) { + setUp(datasource); + try { + final var bean_1a = new MOFirstBean(); + bean_1a.setFirstString("This is my test string"); + + final var bean_1b = new MOFirstBean(); + bean_1b.setFirstString("This is my test string B"); + + var bean_2 = new MOSecondBean(); + bean_2.setSecondString("MOSecondBeanA"); + bean_2.setFirstBeans(new ArrayList() {{ + add(bean_1a); + add(bean_1b); + }}); + + // save the second bean + assertTrue(secondManager_.save(bean_2) > -1); + + // restore the second bean + var second_bean = secondManager_.restore(bean_2.getIdentifier()); + assertEquals(2, second_bean.getFirstBeans().size()); + + // delete the second bean + assertTrue(secondManager_.delete(bean_2.getIdentifier())); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testValidationContextManyToOne(Datasource datasource) { + setUp(datasource); + try { + var bean = new MOFirstBean(); + + bean.setFirstString("This is my test string"); + + // add the many-to-one relations to the bean instance + var bean_2a = new MOSecondBean(); + bean_2a.setIdentifier(23); + bean_2a.setSecondString("MOSecondBeanA"); + + var bean_2b = new MOSecondBean(); + bean_2b.setIdentifier(24); + bean_2b.setSecondString("MOSecondBeanB"); + + bean.setSecondBean(bean_2a); + bean.setSecondBean2(bean_2b); + + // validate the bean instance + ValidationError error; + assertFalse(bean.validate(firstManager_)); + assertEquals(2, bean.getValidationErrors().size()); + var error_it = bean.getValidationErrors().iterator(); + error = error_it.next(); + assertEquals(error.getSubject(), "secondBean"); + assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID); + error = error_it.next(); + assertEquals(error.getSubject(), "secondBean2"); + assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID); + assertFalse(error_it.hasNext()); + + bean.resetValidation(); + + // store the first associated bean + secondManager_.save(bean_2a); + + // validate the bean instance again + assertFalse(bean.validate(firstManager_)); + assertEquals(1, bean.getValidationErrors().size()); + error_it = bean.getValidationErrors().iterator(); + error = error_it.next(); + assertEquals(error.getSubject(), "secondBean2"); + assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID); + assertFalse(error_it.hasNext()); + + // store the second associated bean + secondManager_.save(bean_2b); + + bean.resetValidation(); + + // validate the bean instance a last time + assertTrue(bean.validate(firstManager_)); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testValidationContextManyToOneAssociation(Datasource datasource) { + setUp(datasource); + try { + final var bean_1a = new MOFirstBean(); + bean_1a.setIdentifier(23); + bean_1a.setFirstString("This is my test string"); + + final var bean_1b = new MOFirstBean(); + bean_1b.setIdentifier(27); + bean_1b.setFirstString("This is my test string B"); + + var bean_2 = new MOSecondBean(); + bean_2.setSecondString("MOSecondBeanA"); + bean_2.setFirstBeans(new ArrayList() {{ + add(bean_1a); + add(bean_1b); + }}); + + // validate the bean instance + ValidationError error; + assertFalse(bean_2.validate(secondManager_)); + assertEquals(1, bean_2.getValidationErrors().size()); + var error_it = bean_2.getValidationErrors().iterator(); + error = error_it.next(); + assertEquals(error.getSubject(), "firstBeans"); + assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID); + assertFalse(error_it.hasNext()); + + bean_2.resetValidation(); + + // store the first associated bean + firstManager_.save(bean_1a); + + // validate the bean instance + assertFalse(bean_2.validate(secondManager_)); + assertEquals(1, bean_2.getValidationErrors().size()); + error_it = bean_2.getValidationErrors().iterator(); + error = error_it.next(); + assertEquals(error.getSubject(), "firstBeans"); + assertEquals(error.getIdentifier(), ValidationError.IDENTIFIER_INVALID); + assertFalse(error_it.hasNext()); + + bean_2.resetValidation(); + + // store the first associated bean + firstManager_.save(bean_1b); + + // validate the bean instance a last time + assertTrue(bean_2.validate(secondManager_)); + } finally { + tearDown(); + } + } +} diff --git a/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerSimple.java b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerSimple.java new file mode 100644 index 00000000..026c1515 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerSimple.java @@ -0,0 +1,379 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.UUID; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ArgumentsSource; +import rife.database.*; +import rife.database.exceptions.DatabaseException; +import rife.database.querymanagers.generic.beans.*; +import rife.database.querymanagers.generic.exceptions.MissingDefaultConstructorException; + +import static org.junit.jupiter.api.Assertions.*; + +public class TestGenericQueryManagerSimple { + protected GenericQueryManager setUp(Datasource datasource) { + var manager = GenericQueryManagerFactory.getInstance(datasource, SimpleBean.class); + manager.install(); + return manager; + } + + protected void tearDown(GenericQueryManager manager) { + manager.remove(); + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testNoDefaultConstructor(Datasource datasource) { + var manager = setUp(datasource); + try { + GenericQueryManagerFactory.getInstance(datasource, NoDefaultConstructorBean.class); + fail("MissingDefaultConstructorException exception wasn't thrown"); + } catch (MissingDefaultConstructorException e) { + assertSame(e.getBeanClass(), NoDefaultConstructorBean.class); + } finally { + tearDown(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetBaseClass(Datasource datasource) { + var manager = setUp(datasource); + try { + assertSame(SimpleBean.class, manager.getBaseClass()); + } finally { + tearDown(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testInstallCustomQuery(Datasource datasource) { + var manager = setUp(datasource); + try { + manager.remove(); + manager.install(manager.getInstallTableQuery()); + } finally { + tearDown(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testSaveRestore(Datasource datasource) { + var manager = setUp(datasource); + try { + var bean = new SimpleBean(); + SimpleBean newbean = null; + + var uuid1 = UUID.randomUUID(); + bean.setTestString("This is my test string"); + bean.setUuid(uuid1); + bean.setEnum(SomeEnum.VALUE_TWO); + + var id = manager.save(bean); + + newbean = manager.restore(id); + + assertNotNull(newbean); + assertNotSame(newbean, bean); + assertEquals(newbean.getTestString(), bean.getTestString()); + assertEquals(newbean.getId(), id); + assertEquals(newbean.getUuid(), uuid1); + assertEquals(newbean.getEnum(), SomeEnum.VALUE_TWO); + + var uuid2 = UUID.randomUUID(); + bean.setId(id); + bean.setTestString("This is a new test string"); + bean.setUuid(uuid2); + bean.setEnum(SomeEnum.VALUE_THREE); + + assertEquals(manager.save(bean), id); + assertEquals(bean.getId(), id); + + newbean = manager.restore(id); + + assertNotNull(newbean); + assertNotSame(newbean, bean); + + assertEquals(newbean.getTestString(), "This is a new test string"); + assertEquals(newbean.getUuid(), uuid2); + assertEquals(newbean.getEnum(), SomeEnum.VALUE_THREE); + + bean.setId(999999); + bean.setTestString("This is another test string"); + + assertNotEquals(999999, manager.save(bean)); + assertEquals(bean.getId(), id + 1); + + var manager_othertable = GenericQueryManagerFactory.getInstance(datasource, SimpleBean.class, "othertable"); + manager_othertable.install(); + + var bean2 = new SimpleBean(); + bean2.setTestString("test"); + + manager_othertable.save(bean2); + + var bean3 = manager_othertable.restore(bean2.getId()); + + assertEquals(bean3.getTestString(), bean2.getTestString()); + + manager_othertable.remove(); + } finally { + tearDown(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testSparseIdentifier(Datasource datasource) { + var manager = setUp(datasource); + try { + var manager_sparsebean = GenericQueryManagerFactory.getInstance(datasource, SparseBean.class); + var sparse_bean = new SparseBean(); + + manager_sparsebean.install(); + + sparse_bean.setId(1000); + sparse_bean.setTestString("Test String"); + assertEquals(1000, manager_sparsebean.save(sparse_bean)); + + var restored_sparsebean = manager_sparsebean.restore(1000); + assertEquals(restored_sparsebean.getId(), 1000); + assertEquals(restored_sparsebean.getTestString(), "Test String"); + + try { + manager_sparsebean.insert(sparse_bean); + fail(); + } catch (DatabaseException e) { + assertTrue(true); + } + assertEquals(1000, manager_sparsebean.update(sparse_bean)); + + sparse_bean.setId(1001); + assertEquals(-1, manager_sparsebean.update(sparse_bean)); // not there; update should fail + + manager_sparsebean.remove(); + } finally { + tearDown(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testDelete(Datasource datasource) { + var manager = setUp(datasource); + try { + var bean = new SimpleBean(); + + bean.setTestString("This is my test string"); + + var id1 = manager.save(bean); + assertNotNull(manager.restore(id1)); + manager.delete(id1); + assertNull(manager.restoreFirst(manager.getRestoreQuery(id1))); + + var id2 = manager.save(bean); + assertNotNull(manager.restoreFirst(manager.getRestoreQuery(id2))); + manager.delete(manager.getDeleteQuery(id2)); + assertNull(manager.restore(id2)); + } finally { + tearDown(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testRestore(Datasource datasource) { + var manager = setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + + var uuid1 = UUID.randomUUID(); + var uuid2 = UUID.randomUUID(); + var uuid3 = UUID.randomUUID(); + + bean1.setTestString("This is bean1"); + bean1.setUuid(uuid1); + bean1.setEnum(SomeEnum.VALUE_ONE); + bean2.setTestString("This is bean2"); + bean2.setUuid(uuid2); + bean2.setEnum(SomeEnum.VALUE_TWO); + bean3.setTestString("This is bean3"); + bean3.setUuid(uuid3); + bean3.setEnum(SomeEnum.VALUE_THREE); + + manager.save(bean1); + manager.save(bean2); + manager.save(bean3); + + var list = manager.restore(); + + assertEquals(list.size(), 3); + + for (var bean : list) { + assertNotNull(bean); + assertTrue(bean != bean1 || bean != bean2 || bean != bean3); + assertTrue( + bean.getTestString().equals("This is bean1") && + bean.getUuid().equals(uuid1) && + bean.getEnum().equals(SomeEnum.VALUE_ONE) || + + bean.getTestString().equals("This is bean2") && + bean.getUuid().equals(uuid2) && + bean.getEnum().equals(SomeEnum.VALUE_TWO) || + + bean.getTestString().equals("This is bean3") && + bean.getUuid().equals(uuid3) && + bean.getEnum().equals(SomeEnum.VALUE_THREE)); + } + } finally { + tearDown(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testRestoreRowProcessor(Datasource datasource) { + var manager = setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + + final var uuid1 = UUID.randomUUID(); + final var uuid2 = UUID.randomUUID(); + final var uuid3 = UUID.randomUUID(); + + bean1.setTestString("This is bean1"); + bean1.setUuid(uuid1); + bean1.setEnum(SomeEnum.VALUE_ONE); + bean2.setTestString("This is bean2"); + bean2.setUuid(uuid2); + bean2.setEnum(SomeEnum.VALUE_TWO); + bean3.setTestString("This is bean3"); + bean3.setUuid(uuid3); + bean3.setEnum(SomeEnum.VALUE_THREE); + + manager.save(bean1); + manager.save(bean2); + manager.save(bean3); + + final var count = new int[]{0}; + manager.restore(new DbRowProcessor() { + public boolean processRow(ResultSet resultSet) + throws SQLException { + count[0]++; + + var test_string = resultSet.getString("testString"); + assertTrue( + test_string.equals("This is bean1") || + test_string.equals("This is bean2") || + test_string.equals("This is bean3")); + + var uuid = resultSet.getString("uuid"); + assertTrue( + uuid.equals(uuid1.toString()) || + uuid.equals(uuid2.toString()) || + uuid.equals(uuid3.toString())); + + return true; + } + }); + + assertEquals(count[0], 3); + } finally { + tearDown(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testRestoreQueryRowProcessor(Datasource datasource) { + var manager = setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + + final var uuid1 = UUID.randomUUID(); + final var uuid2 = UUID.randomUUID(); + final var uuid3 = UUID.randomUUID(); + + bean1.setTestString("This is bean1"); + bean1.setUuid(uuid1); + bean2.setTestString("This is bean2"); + bean2.setUuid(uuid2); + bean3.setTestString("This is bean3"); + bean3.setUuid(uuid3); + + manager.save(bean1); + manager.save(bean2); + manager.save(bean3); + + final var count = new int[]{0}; + manager.restore(manager.getRestoreQuery().where("testString", "LIKE", "%bean2"), new DbRowProcessor() { + public boolean processRow(ResultSet resultSet) + throws SQLException { + count[0]++; + + var test_string = resultSet.getString("testString"); + assertEquals("This is bean2", test_string); + + var uuid = resultSet.getString("uuid"); + assertEquals(uuid, uuid2.toString()); + + return true; + } + }); + + assertEquals(count[0], 1); + } finally { + tearDown(manager); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testCount(Datasource datasource) { + var manager = setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + manager.save(bean1); + manager.save(bean2); + manager.save(bean3); + manager.save(bean4); + manager.save(bean5); + + assertEquals(manager.count(), 5); + + manager.delete(bean1.getId()); + manager.delete(bean2.getId()); + manager.delete(bean3.getId()); + + assertEquals(manager.count(), 2); + } finally { + tearDown(manager); + } + } +} diff --git a/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerUnique.java b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerUnique.java new file mode 100644 index 00000000..3c6a4584 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/TestGenericQueryManagerUnique.java @@ -0,0 +1,233 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ArgumentsSource; +import rife.database.Datasource; +import rife.database.TestDatasources; +import rife.database.exceptions.DatabaseException; +import rife.database.querymanagers.generic.beans.UniqueBean; + +import java.sql.SQLException; + +import static org.junit.jupiter.api.Assertions.*; + +public class TestGenericQueryManagerUnique { + private GenericQueryManager uniqueManager_ = null; + + private UniqueBean createNewUniqueBean() { + return new UniqueBean(); + } + + protected void setUp(Datasource datasource) { + uniqueManager_ = GenericQueryManagerFactory.getInstance(datasource, UniqueBean.class); + uniqueManager_.install(); + } + + protected void tearDown() { + uniqueManager_.remove(); + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetBaseClass(Datasource datasource) { + setUp(datasource); + try { + assertSame(UniqueBean.class, uniqueManager_.getBaseClass()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testInstallCustomQuery(Datasource datasource) { + setUp(datasource); + try { + uniqueManager_.remove(); + uniqueManager_.install(uniqueManager_.getInstallTableQuery()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testValidationContextUnique(Datasource datasource) { + setUp(datasource); + try { + // uniqueness of individual properties + UniqueBean bean1 = createNewUniqueBean(); + bean1.setTestString("test_string"); + bean1.setAnotherString("another_string_one"); + bean1.setThirdString("third_string_one"); + assertTrue(bean1.validate(uniqueManager_)); + int id1 = uniqueManager_.save(bean1); + + bean1 = uniqueManager_.restore(id1); + bean1.setTestString("test_string_one"); + assertTrue(bean1.validate(uniqueManager_)); + assertEquals(id1, uniqueManager_.save(bean1)); + + UniqueBean bean2 = createNewUniqueBean(); + bean2.setTestString("test_string_one"); + bean2.setAnotherString("another_string_two"); + bean2.setThirdString("third_string_two"); + assertFalse(bean2.validate(uniqueManager_)); + try { + uniqueManager_.save(bean2); + fail(); + } catch (DatabaseException e) { + assertTrue(e.getCause() instanceof SQLException); + } + + bean2.resetValidation(); + bean2.setTestString("test_string_two"); + bean2.setAnotherString("another_string_two"); + assertTrue(bean2.validate(uniqueManager_)); + int id2 = uniqueManager_.save(bean2); + assertTrue(id1 != id2); + + bean1.resetValidation(); + bean1.setTestString("test_string_two"); + assertFalse(bean1.validate(uniqueManager_)); + try { + uniqueManager_.save(bean1); + fail(); + } catch (DatabaseException e) { + assertTrue(e.getCause() instanceof SQLException); + } + + // uniqueness of multiple properties + UniqueBean bean3 = createNewUniqueBean(); + bean3.setTestString("test_string_three"); + bean3.setAnotherString("another_string"); + bean3.setThirdString("third_string"); + assertTrue(bean3.validate(uniqueManager_)); + int id3 = uniqueManager_.save(bean3); + + bean3 = uniqueManager_.restore(id3); + bean3.setAnotherString("another_string_three"); + bean3.setThirdString("third_string_three"); + assertTrue(bean3.validate(uniqueManager_)); + assertEquals(id3, uniqueManager_.save(bean3)); + + UniqueBean bean4 = createNewUniqueBean(); + bean4.setTestString("test_string_four"); + bean4.setAnotherString("another_string_three"); + bean4.setThirdString("third_string_three"); + assertFalse(bean4.validate(uniqueManager_)); + try { + uniqueManager_.save(bean4); + fail(); + } catch (DatabaseException e) { + assertTrue(e.getCause() instanceof SQLException); + } + + bean4.resetValidation(); + bean4.setAnotherString("another_string_four"); + bean4.setThirdString("third_string_four"); + assertTrue(bean4.validate(uniqueManager_)); + int id4 = uniqueManager_.save(bean4); + assertTrue(id3 != id4); + + bean3.resetValidation(); + bean3.setAnotherString("another_string_four"); + bean3.setThirdString("third_string_four"); + assertFalse(bean3.validate(uniqueManager_)); + try { + uniqueManager_.save(bean3); + fail(); + } catch (DatabaseException e) { + assertTrue(e.getCause() instanceof SQLException); + } + + UniqueBean bean5 = createNewUniqueBean(); + bean5.setTestString("test_string_five"); + bean5.setAnotherString("another_string_five"); + assertTrue(bean5.validate(uniqueManager_)); + uniqueManager_.save(bean5); + + UniqueBean bean6 = createNewUniqueBean(); + bean6.setTestString("test_string_six"); + bean6.setAnotherString("another_string_five"); + assertTrue(bean6.validate(uniqueManager_)); + // this is DB-specific +// try +// { +// uniqueManager_.save(bean6); +// fail(); +// } +// catch (DatabaseException e) +// { +// assertTrue(e.getCause() instanceof SQLException); +// } + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGroupValidationContextUnique(Datasource datasource) { + setUp(datasource); + try { + // uniqueness of individual properties + UniqueBean bean1 = createNewUniqueBean(); + bean1.setTestString("test_string"); + bean1.setAnotherString("another_string_one"); + bean1.setThirdString("third_string_one"); + assertTrue(bean1.validateGroup("group1", uniqueManager_)); + bean1.resetValidation(); + assertTrue(bean1.validateGroup("group2", uniqueManager_)); + int id1 = uniqueManager_.save(bean1); + + bean1 = uniqueManager_.restore(id1); + bean1.setTestString("test_string_one"); + assertTrue(bean1.validateGroup("group1", uniqueManager_)); + bean1.resetValidation(); + assertTrue(bean1.validateGroup("group2", uniqueManager_)); + assertEquals(id1, uniqueManager_.save(bean1)); + + UniqueBean bean2 = createNewUniqueBean(); + bean2.setTestString("test_string_one"); + bean2.setAnotherString("another_string_two"); + bean2.setThirdString("third_string_two"); + assertFalse(bean2.validateGroup("group1", uniqueManager_)); + bean2.resetValidation(); + assertFalse(bean2.validateGroup("group2", uniqueManager_)); + try { + uniqueManager_.save(bean2); + fail(); + } catch (DatabaseException e) { + assertTrue(e.getCause() instanceof SQLException); + } + + bean2.resetValidation(); + bean2.setTestString("test_string_two"); + bean2.setAnotherString("another_string_two"); + assertTrue(bean2.validateGroup("group1", uniqueManager_)); + bean2.resetValidation(); + assertTrue(bean2.validateGroup("group2", uniqueManager_)); + int id2 = uniqueManager_.save(bean2); + assertTrue(id1 != id2); + + bean1.resetValidation(); + bean1.setTestString("test_string_two"); + assertFalse(bean1.validateGroup("group1", uniqueManager_)); + bean1.resetValidation(); + assertFalse(bean1.validateGroup("group2", uniqueManager_)); + try { + uniqueManager_.save(bean1); + fail(); + } catch (DatabaseException e) { + assertTrue(e.getCause() instanceof SQLException); + } + } finally { + tearDown(); + } + } +} diff --git a/lib/src/test/java/rife/database/querymanagers/generic/TestRestoreQuery.java b/lib/src/test/java/rife/database/querymanagers/generic/TestRestoreQuery.java new file mode 100644 index 00000000..19cbacb6 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/TestRestoreQuery.java @@ -0,0 +1,1014 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ArgumentsSource; +import rife.database.Datasource; +import rife.database.TestDatasources; +import rife.database.exceptions.DatabaseException; +import rife.database.exceptions.UnsupportedSqlFeatureException; +import rife.database.queries.Select; +import rife.database.querymanagers.generic.beans.BeanImpl; +import rife.database.querymanagers.generic.beans.LinkBean; +import rife.database.querymanagers.generic.beans.SimpleBean; + +import java.math.BigDecimal; +import java.sql.Time; +import java.sql.Timestamp; +import java.util.Calendar; + +import static org.junit.jupiter.api.Assertions.*; + +public class TestRestoreQuery { + private GenericQueryManager manager_ = null; + private GenericQueryManager linkManager_ = null; + private GenericQueryManager bigBeanManager_ = null; + + protected void setUp(Datasource datasource) { + manager_ = GenericQueryManagerFactory.getInstance(datasource, SimpleBean.class); + linkManager_ = GenericQueryManagerFactory.getInstance(datasource, LinkBean.class); + bigBeanManager_ = GenericQueryManagerFactory.getInstance(datasource, BeanImpl.class); + manager_.install(); + linkManager_.install(); + bigBeanManager_.install(); + } + + protected void tearDown() { + manager_.remove(); + linkManager_.remove(); + bigBeanManager_.remove(); + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testLimit(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + + bean1.setTestString("This is bean1"); + bean2.setTestString("This is bean2"); + bean3.setTestString("This is bean3"); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + + var list = manager_.restore(manager_.getRestoreQuery().limit(2)); + + assertEquals(list.size(), 2); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testOffset(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + + bean1.setTestString("This is bean1"); + bean2.setTestString("This is bean2"); + bean3.setTestString("This is bean3"); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + + var list = manager_.restore(manager_.getRestoreQuery().limit(1).offset(1).orderBy("id")); + + assertEquals(list.size(), 1); + + assertEquals("This is bean2", list.get(0).getTestString()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testCloneToStringAndClear(Datasource datasource) { + setUp(datasource); + try { + var query = manager_.getRestoreQuery().where("testString", "=", "bean set 1"); + + assertEquals(query.toString(), "SELECT * FROM SimpleBean WHERE testString = 'bean set 1'"); + + var queryclone = query.clone(); + + assertEquals(queryclone.toString(), "SELECT * FROM SimpleBean WHERE testString = 'bean set 1'"); + + queryclone.where("testString", "!=", "bean set 2"); + + assertEquals(queryclone.toString(), "SELECT * FROM SimpleBean WHERE testString = 'bean set 1' AND testString != 'bean set 2'"); + + queryclone.clear(); + + assertEquals(queryclone.toString(), "SELECT * FROM SimpleBean WHERE testString = 'bean set 1'"); + + query.clear(); + + assertEquals(query.toString(), "SELECT * FROM SimpleBean"); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testDistinctOn(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + manager_.save(bean4); + manager_.save(bean5); + + var query = manager_.getRestoreQuery().distinctOn("testString"); + + try { + var bean_list = manager_.restore(query); + + assertEquals(bean_list.size(), 2); + + if ("com.mysql.cj.jdbc.Driver".equals(datasource.getAliasedDriver()) || + "oracle.jdbc.driver.OracleDriver".equals(datasource.getAliasedDriver()) || + "org.hsqldb.jdbcDriver".equals(datasource.getAliasedDriver()) || + "org.h2.Driver".equals(datasource.getAliasedDriver()) || + "org.apache.derby.jdbc.EmbeddedDriver".equals(datasource.getAliasedDriver())) { + fail(); + } + } catch (UnsupportedSqlFeatureException e) { + assertEquals("DISTINCT ON", e.getFeature()); + assertTrue("com.mysql.cj.jdbc.Driver".equals(e.getDriver()) || + "oracle.jdbc.driver.OracleDriver".equals(e.getDriver()) || + "org.hsqldb.jdbcDriver".equals(e.getDriver()) || + "org.h2.Driver".equals(e.getDriver()) || + "org.apache.derby.jdbc.EmbeddedDriver".equals(e.getDriver())); + } + + query.clear(); + + query = manager_.getRestoreQuery().distinctOn(new String[]{"testString"}); + + try { + var bean_list = manager_.restore(query); + + assertEquals(bean_list.size(), 2); + + if ("com.mysql.cj.jdbc.Driver".equals(datasource.getAliasedDriver()) || + "oracle.jdbc.driver.OracleDriver".equals(datasource.getAliasedDriver()) || + "org.hsqldb.jdbcDriver".equals(datasource.getAliasedDriver()) || + "org.h2.Driver".equals(datasource.getAliasedDriver()) || + "org.apache.derby.jdbc.EmbeddedDriver".equals(datasource.getAliasedDriver())) { + fail(); + } + } catch (UnsupportedSqlFeatureException e) { + assertEquals("DISTINCT ON", e.getFeature()); + assertTrue("com.mysql.cj.jdbc.Driver".equals(e.getDriver()) || + "oracle.jdbc.driver.OracleDriver".equals(e.getDriver()) || + "org.hsqldb.jdbcDriver".equals(e.getDriver()) || + "org.h2.Driver".equals(e.getDriver()) || + "org.apache.derby.jdbc.EmbeddedDriver".equals(e.getDriver())); + } + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetDatasource(Datasource datasource) { + setUp(datasource); + try { + assertEquals(datasource, manager_.getRestoreQuery().getDatasource()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetFrom(Datasource datasource) { + setUp(datasource); + try { + assertEquals(manager_ + .getRestoreQuery() + .getFrom(), SimpleBean.class + .getName() + .replaceAll(SimpleBean.class + .getPackage() + .getName() + ".", "")); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testGetParameters(Datasource datasource) { + setUp(datasource); + try { + var select = new Select(datasource); + select + .from("simplebean") + .whereParameter("testString", "="); + + var query = new RestoreQuery(select); + + assertEquals(query.getParameters().getOrderedNames().size(), 1); + assertTrue(query.getParameters().getOrderedNames().contains("testString")); + + assertEquals(query.getParameters().getOrderedNamesArray().length, 1); + assertEquals(query.getParameters().getOrderedNamesArray()[0], "testString"); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testRestoreFirst(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + manager_.save(bean4); + manager_.save(bean5); + + var query = manager_.getRestoreQuery(); + query + .where("testString", "=", "bean set 1") + .orderBy("id", Select.ASC); + + var new_bean = manager_.restoreFirst(query); + + assertNotSame(new_bean, bean1); + assertEquals(new_bean.getTestString(), bean1.getTestString()); + assertEquals(new_bean.getId(), bean1.getId()); + + query.clear(); + query + .where("testString", "=", "bean set 2") + .orderBy("id", Select.DESC); + + var other_bean = manager_.restoreFirst(query); + + assertNotSame(other_bean, bean5); + assertEquals(other_bean.getTestString(), bean5.getTestString()); + assertEquals(other_bean.getId(), bean5.getId()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testJoin(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + var link_bean1 = new LinkBean(); + var link_bean2 = new LinkBean(); + + link_bean1.setTestString("linkbean 1"); + link_bean2.setTestString("linkbean 2"); + + linkManager_.save(link_bean1); + linkManager_.save(link_bean2); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + bean1.setLinkBean(link_bean1.getId()); + bean2.setLinkBean(link_bean1.getId()); + bean3.setLinkBean(link_bean1.getId()); + bean4.setLinkBean(link_bean2.getId()); + bean5.setLinkBean(link_bean2.getId()); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + manager_.save(bean4); + manager_.save(bean5); + + var table = manager_.getTable(); + var table2 = linkManager_.getTable(); + + var query = manager_.getRestoreQuery() + .join(table2) + .where(table2 + ".id = " + table + ".linkBean") + .whereAnd(table + ".linkBean", "=", link_bean2.getId()); + + var list = manager_.restore(query); + + assertEquals(list.size(), 2); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testJoinCross(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + var link_bean1 = new LinkBean(); + var link_bean2 = new LinkBean(); + + link_bean1.setTestString("linkbean 1"); + link_bean2.setTestString("linkbean 2"); + + linkManager_.save(link_bean1); + linkManager_.save(link_bean2); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + bean1.setLinkBean(link_bean1.getId()); + bean2.setLinkBean(link_bean1.getId()); + bean3.setLinkBean(link_bean1.getId()); + bean4.setLinkBean(link_bean2.getId()); + bean5.setLinkBean(link_bean2.getId()); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + manager_.save(bean4); + manager_.save(bean5); + + var table = manager_.getTable(); + var table2 = linkManager_.getTable(); + + var query = manager_.getRestoreQuery() + .joinCross(table2) + .where(table2 + ".id = " + table + ".linkBean") + .whereAnd(table + ".linkBean", "=", link_bean2.getId()); + + try { + var list = manager_.restore(query); + + assertEquals(list.size(), 2); + + if ("org.hsqldb.jdbcDriver".equals(datasource.getAliasedDriver()) || + "org.apache.derby.jdbc.EmbeddedDriver".equals(datasource.getAliasedDriver())) { + fail(); + } + } catch (UnsupportedSqlFeatureException e) { + assertEquals("CROSS JOIN", e.getFeature()); + assertTrue("org.hsqldb.jdbcDriver".equals(e.getDriver()) || + "org.apache.derby.jdbc.EmbeddedDriver".equals(e.getDriver())); + } + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testJoinInner(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + var link_bean1 = new LinkBean(); + var link_bean2 = new LinkBean(); + + link_bean1.setTestString("linkbean 1"); + link_bean2.setTestString("linkbean 2"); + + linkManager_.save(link_bean1); + linkManager_.save(link_bean2); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + bean1.setLinkBean(link_bean1.getId()); + bean2.setLinkBean(link_bean1.getId()); + bean3.setLinkBean(link_bean1.getId()); + bean4.setLinkBean(link_bean2.getId()); + bean5.setLinkBean(link_bean2.getId()); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + manager_.save(bean4); + manager_.save(bean5); + + var table = manager_.getTable(); + var table2 = linkManager_.getTable(); + + var query = manager_.getRestoreQuery() + .joinInner(table2, Select.ON, "0 = 0") // evals to true for mysql sake + .where(table2 + ".id = " + table + ".linkBean") + .whereAnd(table + ".linkBean", "=", link_bean2.getId()); + + var list = manager_.restore(query); + + assertEquals(list.size(), 2); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testJoinOuter(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + var link_bean1 = new LinkBean(); + var link_bean2 = new LinkBean(); + + link_bean1.setTestString("linkbean 1"); + link_bean2.setTestString("linkbean 2"); + + linkManager_.save(link_bean1); + linkManager_.save(link_bean2); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + bean1.setLinkBean(link_bean1.getId()); + bean2.setLinkBean(link_bean1.getId()); + bean3.setLinkBean(link_bean1.getId()); + bean4.setLinkBean(link_bean2.getId()); + bean5.setLinkBean(link_bean2.getId()); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + manager_.save(bean4); + manager_.save(bean5); + + var table = manager_.getTable(); + var table2 = linkManager_.getTable(); + + var query = manager_.getRestoreQuery() + .joinOuter(table2, Select.LEFT, Select.ON, "0 = 0") // evals to true for mysql sake + .where(table2 + ".id = " + table + ".linkBean") + .whereAnd(table + ".linkBean", "=", link_bean2.getId()); + + var list = manager_.restore(query); + + assertEquals(list.size(), 2); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testJoinCustom(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + var link_bean1 = new LinkBean(); + var link_bean2 = new LinkBean(); + + link_bean1.setTestString("linkbean 1"); + link_bean2.setTestString("linkbean 2"); + + linkManager_.save(link_bean1); + linkManager_.save(link_bean2); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + bean1.setLinkBean(link_bean1.getId()); + bean2.setLinkBean(link_bean1.getId()); + bean3.setLinkBean(link_bean1.getId()); + bean4.setLinkBean(link_bean2.getId()); + bean5.setLinkBean(link_bean2.getId()); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + manager_.save(bean4); + manager_.save(bean5); + + var table = manager_.getTable(); + var table2 = linkManager_.getTable(); + + var query = manager_.getRestoreQuery() + .joinCustom("LEFT OUTER JOIN " + table2 + " ON 0 = 0") // evals to true for mysql sake + .where(table2 + ".id = " + table + ".linkBean") + .whereAnd(table + ".linkBean", "=", link_bean2.getId()); + + var list = manager_.restore(query); + + assertEquals(list.size(), 2); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testOrderBy(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + + bean1.setTestString("This is bean1"); + bean2.setTestString("This is bean2"); + bean3.setTestString("This is bean3"); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + + var list = manager_.restore(manager_.getRestoreQuery().orderBy("id", Select.DESC)); + + assertEquals(list.size(), 3); + + assertEquals(list.get(0).getId(), bean3.getId()); + assertEquals(list.get(1).getId(), bean2.getId()); + assertEquals(list.get(2).getId(), bean1.getId()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testWhere(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new BeanImpl(); + + var cal = Calendar.getInstance(); + cal.set(2004, Calendar.JULY, 19, 16, 27, 15); + cal.set(Calendar.MILLISECOND, 765); + bean1.setPropertyBigDecimal(new BigDecimal("384834838434.38483")); + bean1.setPropertyBoolean(false); + bean1.setPropertyBooleanObject(true); + bean1.setPropertyByte((byte) 90); + bean1.setPropertyByteObject((byte) 35); + bean1.setPropertyCalendar(cal); + bean1.setPropertyChar('w'); + bean1.setPropertyCharacterObject('s'); + bean1.setPropertyDate(cal.getTime()); + bean1.setPropertyDouble(37478.34d); + bean1.setPropertyDoubleObject(384724.692d); + bean1.setPropertyFloat(34241.2f); + bean1.setPropertyFloatObject(3432.7f); + bean1.setPropertyLong(23432L); + bean1.setPropertyLongObject(23423L); + bean1.setPropertyShort((short) 44); + bean1.setPropertyShortObject((short) 69); + bean1.setPropertyIntegerObject(421); + bean1.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime())); + bean1.setPropertyString("nostringhere"); + bean1.setPropertyStringBuffer(new StringBuffer("buffbuffbuff")); + bean1.setPropertyTime(new Time(cal.getTime().getTime())); + bean1.setPropertyTimestamp(new Timestamp(cal.getTime().getTime())); + + bigBeanManager_.save(bean1); + + var list = bigBeanManager_.restore(bigBeanManager_.getRestoreQuery().where("propertyString = 'nostringhere'")); + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(bigBeanManager_.getRestoreQuery().where("propertyBoolean", "=", false)); + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(bigBeanManager_.getRestoreQuery().where("propertyByte", "=", (byte) 90)); + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(bigBeanManager_.getRestoreQuery().where("propertyChar", "=", 'w')); + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(bigBeanManager_.getRestoreQuery().where("propertyDouble", "=", 37478.34d)); + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(bigBeanManager_.getRestoreQuery().where("ABS(propertyFloat - 34241.2) < 0.001")); + + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(bigBeanManager_.getRestoreQuery().where("propertyLong", "=", 23432L)); + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(bigBeanManager_.getRestoreQuery().where("propertyShort", "=", (short) 44)); + assertEquals(list.size(), 1); + + // cheating because the GQM doesn't currently return any queries with a where clause already + var query = new RestoreQuery(bigBeanManager_.getRestoreQuery().where("id", "=", bean1.getId()).getDelegate()); + + list = bigBeanManager_.restore(query.where("propertyString = 'nostringhere'")); + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(query.where("propertyBoolean", "=", false)); + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(query.where("propertyByte", "=", (byte) 90)); + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(query.where("propertyChar", "=", 'w')); + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(query.where("propertyDouble", "=", 37478.34d)); + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(query.where("ABS(propertyFloat - 34241.2) < 0.001")); + + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(query.where("id", "=", bean1.getId())); // primary key + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(query.where("propertyLong", "=", 23432L)); + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(query.where("propertyShort", "=", (short) 44)); + assertEquals(list.size(), 1); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testWhereAnd(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new BeanImpl(); + + var cal = Calendar.getInstance(); + cal.set(2004, Calendar.JULY, 19, 16, 27, 15); + cal.set(Calendar.MILLISECOND, 765); + bean1.setPropertyBigDecimal(new BigDecimal("384834838434.38483")); + bean1.setPropertyBoolean(false); + bean1.setPropertyBooleanObject(true); + bean1.setPropertyByte((byte) 90); + bean1.setPropertyByteObject((byte) 35); + bean1.setPropertyCalendar(cal); + bean1.setPropertyChar('w'); + bean1.setPropertyCharacterObject('s'); + bean1.setPropertyDate(cal.getTime()); + bean1.setPropertyDouble(37478.34d); + bean1.setPropertyDoubleObject(384724.692d); + bean1.setPropertyFloat(34241.2f); + bean1.setPropertyFloatObject(3432.7f); + bean1.setPropertyLong(23432L); + bean1.setPropertyLongObject(23423L); + bean1.setPropertyShort((short) 44); + bean1.setPropertyShortObject((short) 69); + bean1.setPropertyIntegerObject(421); + bean1.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime())); + bean1.setPropertyString("nostringhere"); + bean1.setPropertyStringBuffer(new StringBuffer("buffbuffbuff")); + bean1.setPropertyTime(new Time(cal.getTime().getTime())); + bean1.setPropertyTimestamp(new Timestamp(cal.getTime().getTime())); + + bigBeanManager_.save(bean1); + + var list = bigBeanManager_.restore( + bigBeanManager_.getRestoreQuery() + .where("id", "=", bean1.getId()) + .whereAnd("propertyString = 'nostringhere'") + .whereAnd("propertyBoolean", "=", false) + .whereAnd("propertyByte", "=", (byte) 90) + .whereAnd("propertyChar", "=", 'w') + .whereAnd("propertyDouble", "=", 37478.34d) + .whereAnd("propertyLong", "=", 23432L) + .whereAnd("propertyString", "=", "nostringhere") + .whereAnd("propertyIntegerObject", "=", 421) + .whereAnd("propertyShort", "=", (short) 44) + ); + + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(bigBeanManager_.getRestoreQuery().where("id", "=", bean1.getId()).whereAnd("ABS(propertyFloat - 34241.2) < 0.001")); + + assertEquals(list.size(), 1); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testWhereOr(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new BeanImpl(); + + var cal = Calendar.getInstance(); + cal.set(2004, Calendar.JULY, 19, 16, 27, 15); + cal.set(Calendar.MILLISECOND, 765); + bean1.setPropertyBigDecimal(new BigDecimal("384834838434.38483")); + bean1.setPropertyBoolean(false); + bean1.setPropertyBooleanObject(true); + bean1.setPropertyByte((byte) 90); + bean1.setPropertyByteObject((byte) 35); + bean1.setPropertyCalendar(cal); + bean1.setPropertyChar('w'); + bean1.setPropertyCharacterObject('s'); + bean1.setPropertyDate(cal.getTime()); + bean1.setPropertyDouble(37478.34d); + bean1.setPropertyDoubleObject(384724.692d); + bean1.setPropertyFloat(34241.2f); + bean1.setPropertyFloatObject(3432.7f); + bean1.setPropertyLong(23432L); + bean1.setPropertyLongObject(23423L); + bean1.setPropertyShort((short) 44); + bean1.setPropertyShortObject((short) 69); + bean1.setPropertyIntegerObject(421); + bean1.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime())); + bean1.setPropertyString("nostringhere"); + bean1.setPropertyStringBuffer(new StringBuffer("buffbuffbuff")); + bean1.setPropertyTime(new Time(cal.getTime().getTime())); + bean1.setPropertyTimestamp(new Timestamp(cal.getTime().getTime())); + + bigBeanManager_.save(bean1); + + var list = bigBeanManager_.restore( + bigBeanManager_.getRestoreQuery() + .where("id = 1") + .whereOr("propertyString = 'nostringhere'") + .whereOr("propertyBoolean", "=", false) + .whereOr("propertyByte", "=", (byte) 90) + .whereOr("propertyChar", "=", 'w') + .whereOr("propertyDouble", "=", 37478.34d) + .whereOr("propertyLong", "=", 23432L) + .whereOr("propertyIntegerObject", "=", 421) + .whereOr("propertyShort", "=", (short) 44) + .whereOr("propertyString", "=", "nostringhere") + ); + + assertEquals(list.size(), 1); + + list = bigBeanManager_.restore(bigBeanManager_.getRestoreQuery().where("id = 1").whereOr("ABS(propertyFloat - 34241.2) < 0.001")); + + assertEquals(list.size(), 1); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testUnion(Datasource datasource) { + setUp(datasource); + try { + var query = manager_.getRestoreQuery(); + + query + .union("uexpr1") + .union(new Select(datasource).from("table2")); + + assertEquals(query.getSql(), "SELECT * FROM SimpleBean UNION uexpr1 UNION SELECT * FROM table2"); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testWhereSubSelect(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + var bean3 = new SimpleBean(); + var bean4 = new SimpleBean(); + var bean5 = new SimpleBean(); + + var link_bean1 = new LinkBean(); + var link_bean2 = new LinkBean(); + + link_bean1.setTestString("linkbean 1"); + link_bean2.setTestString("linkbean 2"); + + linkManager_.save(link_bean1); + linkManager_.save(link_bean2); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + bean3.setTestString("bean set 1"); + bean4.setTestString("bean set 2"); + bean5.setTestString("bean set 2"); + + bean1.setLinkBean(link_bean1.getId()); + bean2.setLinkBean(link_bean1.getId()); + bean3.setLinkBean(link_bean1.getId()); + bean4.setLinkBean(link_bean2.getId()); + bean5.setLinkBean(link_bean2.getId()); + + manager_.save(bean1); + manager_.save(bean2); + manager_.save(bean3); + manager_.save(bean4); + manager_.save(bean5); + + var select = new Select(datasource); + select + .from(linkManager_.getTable()) + .field("id") + .where("id", "=", link_bean1.getId()); + + var query = manager_.getRestoreQuery(); + query + .where("linkBean = (" + select.getSql() + ")") + .whereSubselect(select); + + var list = manager_.restore(query); + assertEquals(list.size(), 3); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testFields(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + var bean2 = new SimpleBean(); + + var link_bean1 = new LinkBean(); + + link_bean1.setTestString("linkbean 1"); + + bean1.setTestString("bean set 1"); + bean2.setTestString("bean set 1"); + + bean1.setLinkBean(1); + bean2.setLinkBean(1); + + linkManager_.save(link_bean1); + + manager_.save(bean1); + manager_.save(bean2); + + var query = manager_.getRestoreQuery(); + query + .field("testString"); + + var bean_list = manager_.restore(query); + + for (var bean : bean_list) { + assertEquals(-1, bean.getLinkBean()); + assertEquals("bean set 1", bean.getTestString()); + } + + query = manager_.getRestoreQuery(); + query + .fields(SimpleBean.class); + + bean_list = manager_.restore(query); + + query = manager_.getRestoreQuery(); + query + .fields("simplebean", SimpleBean.class); + + bean_list = manager_.restore(query); + + for (var bean : bean_list) { + assertEquals(1, bean.getLinkBean()); + assertEquals("bean set 1", bean.getTestString()); + } + + query = manager_.getRestoreQuery(); + query + .fieldsExcluded(SimpleBean.class, "testString"); + + bean_list = manager_.restore(query); + + query = manager_.getRestoreQuery(); + query + .fieldsExcluded("simplebean", SimpleBean.class, "testString"); + + bean_list = manager_.restore(query); + + for (var bean : bean_list) { + assertEquals(1, bean.getLinkBean()); + assertNull(bean.getTestString()); + } + + query = manager_.getRestoreQuery(); + query + .fields("linkBean"); + + bean_list = manager_.restore(query); + + for (var bean : bean_list) { + assertEquals(1, bean.getLinkBean()); + assertNull(bean.getTestString()); + } + + var select = new Select(datasource).field("name").from("tablename"); + + query = manager_.getRestoreQuery(); + query + .fieldSubselect(select) + .field('(' + select.getSql() + ')'); + + assertEquals("SELECT (SELECT name FROM tablename) FROM SimpleBean", query.getSql()); + } finally { + tearDown(); + } + } + + @ParameterizedTest + @ArgumentsSource(TestDatasources.class) + public void testWhereGroupChaining(Datasource datasource) { + setUp(datasource); + try { + var bean1 = new SimpleBean(); + bean1.setTestString("test"); + + manager_.save(bean1); + + var query = manager_.getRestoreQuery() + .where("id", ">=", 0) + .startWhereAnd() + .where("testString", "=", "test") + .end(); + + assertTrue(manager_.restore(query).size() > 0); + } finally { + tearDown(); + } + } +} + + diff --git a/lib/src/test/java/rife/database/querymanagers/generic/beans/BeanImpl.java b/lib/src/test/java/rife/database/querymanagers/generic/beans/BeanImpl.java new file mode 100644 index 00000000..23fabfb9 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/beans/BeanImpl.java @@ -0,0 +1,312 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic.beans; + +import rife.validation.ConstrainedProperty; +import rife.validation.Validation; + +import java.math.BigDecimal; +import java.sql.Time; +import java.sql.Timestamp; +import java.util.Calendar; + +public class BeanImpl extends Validation { + private int id_ = -1; + + private String propertyString_ = null; + private StringBuffer propertyStringBuffer_ = null; + private java.util.Date propertyDate_ = null; + private java.util.Calendar propertyCalendar_ = null; + private java.sql.Date propertySqlDate_ = null; + private java.sql.Time propertyTime_ = null; + private java.sql.Timestamp propertyTimestamp_ = null; + private char propertyChar_ = 0; + private Character propertyCharacterObject_ = null; + private boolean propertyBoolean_ = false; + private Boolean propertyBooleanObject_ = null; + private byte propertyByte_ = 0; + private Byte propertyByteObject_ = null; + private double propertyDouble_ = 0.0d; + private Double propertyDoubleObject_ = null; + private float propertyFloat_ = 0.0f; + private Float propertyFloatObject_ = null; + private int propertyInt_ = 0; + private Integer propertyIntegerObject_ = null; + private long propertyLong_ = 0; + private Long propertyLongObject_ = null; + private short propertyShort_ = 0; + private Short propertyShortObject_ = null; + private BigDecimal propertyBigDecimal_ = null; + + public BeanImpl() { + } + + protected void activateValidation() { + addConstraint(new ConstrainedProperty("propertyBigDecimal").precision(18).scale(5)); + } + + public void setId(int id) { + id_ = id; + } + + public int getId() { + return id_; + } + + public String getPropertyString() { + return propertyString_; + } + + public void setPropertyString(String propertyString) { + this.propertyString_ = propertyString; + } + + public StringBuffer getPropertyStringBuffer() { + return propertyStringBuffer_; + } + + public void setPropertyStringBuffer(StringBuffer propertyStringBuffer) { + propertyStringBuffer = propertyStringBuffer; + } + + public java.util.Date getPropertyDate() { + return propertyDate_; + } + + public void setPropertyDate(java.util.Date propertyDate) { + propertyDate_ = propertyDate; + } + + public java.util.Calendar getPropertyCalendar() { + return propertyCalendar_; + } + + public void setPropertyCalendar(java.util.Calendar propertyCalendar) { + propertyCalendar_ = propertyCalendar; + } + + public java.sql.Date getPropertySqlDate() { + return propertySqlDate_; + } + + public void setPropertySqlDate(java.sql.Date propertySqlDate) { + propertySqlDate_ = propertySqlDate; + } + + public java.sql.Time getPropertyTime() { + return propertyTime_; + } + + public void setPropertyTime(java.sql.Time propertyTime) { + propertyTime_ = propertyTime; + } + + public java.sql.Timestamp getPropertyTimestamp() { + return propertyTimestamp_; + } + + public void setPropertyTimestamp(java.sql.Timestamp propertyTimestamp) { + propertyTimestamp_ = propertyTimestamp; + } + + public boolean isPropertyBoolean() { + return propertyBoolean_; + } + + public void setPropertyBoolean(boolean propertyBoolean) { + propertyBoolean_ = propertyBoolean; + } + + public Boolean getPropertyBooleanObject() { + return propertyBooleanObject_; + } + + public void setPropertyBooleanObject(Boolean propertyBooleanObject) { + propertyBooleanObject_ = propertyBooleanObject; + } + + public byte getPropertyByte() { + return propertyByte_; + } + + public Byte getPropertyByteObject() { + return propertyByteObject_; + } + + public void setPropertyByte(byte propertyByte) { + propertyByte_ = propertyByte; + } + + public void setPropertyByteObject(Byte propertyByteObject) { + propertyByteObject_ = propertyByteObject; + } + + public double getPropertyDouble() { + return propertyDouble_; + } + + public void setPropertyDouble(double propertyDouble) { + propertyDouble_ = propertyDouble; + } + + public void setPropertyDoubleObject(Double propertyDoubleObject) { + propertyDoubleObject_ = propertyDoubleObject; + } + + public Double getPropertyDoubleObject() { + return propertyDoubleObject_; + } + + public float getPropertyFloat() { + return propertyFloat_; + } + + public void setPropertyFloat(float propertyFloat) { + propertyFloat_ = propertyFloat; + } + + public void setPropertyFloatObject(Float propertyFloatObject) { + propertyFloatObject_ = propertyFloatObject; + } + + public Float getPropertyFloatObject() { + return propertyFloatObject_; + } + + public int getPropertyInt() { + return propertyInt_; + } + + public void setPropertyInt(int propertyInt) { + propertyInt_ = propertyInt; + } + + public Integer getPropertyIntegerObject() { + return propertyIntegerObject_; + } + + public void setPropertyIntegerObject(Integer propertyIntegerObject) { + propertyIntegerObject_ = propertyIntegerObject; + } + + public long getPropertyLong() { + return propertyLong_; + } + + public void setPropertyLong(long propertyLong) { + propertyLong_ = propertyLong; + } + + public Long getPropertyLongObject() { + return propertyLongObject_; + } + + public void setPropertyLongObject(Long propertyLongObject) { + propertyLongObject_ = propertyLongObject; + } + + public short getPropertyShort() { + return propertyShort_; + } + + public void setPropertyShort(short propertyShort) { + propertyShort_ = propertyShort; + } + + public Short getPropertyShortObject() { + return propertyShortObject_; + } + + public void setPropertyShortObject(Short propertyShortObject) { + propertyShortObject_ = propertyShortObject; + } + + public char getPropertyChar() { + return propertyChar_; + } + + public void setPropertyChar(char propertyChar) { + propertyChar_ = propertyChar; + } + + public Character getPropertyCharacterObject() { + return propertyCharacterObject_; + } + + public void setPropertyCharacterObject(Character propertyCharacterObject) { + propertyCharacterObject_ = propertyCharacterObject; + } + + public BigDecimal getPropertyBigDecimal() { + return propertyBigDecimal_; + } + + public void setPropertyBigDecimal(BigDecimal propertyBigDecimal) { + propertyBigDecimal_ = propertyBigDecimal; + } + + public static BeanImpl getPopulatedBean() { + BeanImpl bean = new BeanImpl(); + Calendar cal = Calendar.getInstance(); + cal.set(2002, Calendar.JUNE, 18, 15, 26, 14); + cal.set(Calendar.MILLISECOND, 764); + bean.setPropertyBigDecimal(new BigDecimal("219038743.392874")); + bean.setPropertyBoolean(true); + bean.setPropertyBooleanObject(false); + bean.setPropertyByte((byte) 89); + bean.setPropertyByteObject((byte) 34); + bean.setPropertyCalendar(cal); + bean.setPropertyChar('v'); + bean.setPropertyCharacterObject('r'); + bean.setPropertyDate(cal.getTime()); + bean.setPropertyDouble(53348.34d); + bean.setPropertyDoubleObject(143298.692d); + bean.setPropertyFloat(98634.2f); + bean.setPropertyFloatObject(8734.7f); + bean.setPropertyInt(545); + bean.setPropertyIntegerObject(968); + bean.setPropertyLong(34563L); + bean.setPropertyLongObject(66875L); + bean.setPropertyShort((short) 43); + bean.setPropertyShortObject((short) 68); + bean.setPropertySqlDate(new java.sql.Date(cal.getTime().getTime())); + bean.setPropertyString("someotherstring"); + bean.setPropertyStringBuffer(new StringBuffer("someotherstringbuff")); + bean.setPropertyTime(new Time(cal.getTime().getTime())); + bean.setPropertyTimestamp(new Timestamp(cal.getTime().getTime())); + + return bean; + } + + public static BeanImpl getNullBean() { + BeanImpl bean = new BeanImpl(); + bean.setPropertyBigDecimal(null); + bean.setPropertyBoolean(false); + bean.setPropertyBooleanObject(false); + bean.setPropertyByte((byte) 0); + bean.setPropertyByteObject((byte) 0); + bean.setPropertyDate(null); + bean.setPropertyCalendar(null); + bean.setPropertyChar((char) 0); + bean.setPropertyCharacterObject(null); + bean.setPropertyDouble(0d); + bean.setPropertyDoubleObject(0d); + bean.setPropertyFloat(0f); + bean.setPropertyFloatObject(0f); + bean.setPropertyInt(0); + bean.setPropertyIntegerObject(0); + bean.setPropertyLong(0L); + bean.setPropertyLongObject(0L); + bean.setPropertyShort((short) 0); + bean.setPropertyShortObject((short) 0); + bean.setPropertySqlDate(null); + bean.setPropertyString(null); + bean.setPropertyStringBuffer(null); + bean.setPropertyTime(null); + bean.setPropertyTimestamp(null); + + return bean; + } +} \ No newline at end of file diff --git a/lib/src/test/java/rife/database/querymanagers/generic/beans/BinaryBean.java b/lib/src/test/java/rife/database/querymanagers/generic/beans/BinaryBean.java new file mode 100644 index 00000000..9ebe20cf --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/beans/BinaryBean.java @@ -0,0 +1,26 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic.beans; + +public class BinaryBean { + private int id_ = -1; + private byte[] theBytes_; + + public void setId(int id) { + id_ = id; + } + + public int getId() { + return id_; + } + + public byte[] getTheBytes() { + return theBytes_; + } + + public void setTheBytes(byte[] binary) { + theBytes_ = binary; + } +} \ No newline at end of file diff --git a/lib/src/test/java/rife/database/querymanagers/generic/beans/CallbacksBean.java b/lib/src/test/java/rife/database/querymanagers/generic/beans/CallbacksBean.java new file mode 100644 index 00000000..23322f20 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/beans/CallbacksBean.java @@ -0,0 +1,167 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic.beans; + +import rife.database.querymanagers.generic.Callbacks; +import rife.validation.ConstrainedProperty; +import rife.validation.Validation; + +import java.util.ArrayList; +import java.util.List; + +public class CallbacksBean extends Validation implements Callbacks { + private int id_ = -1; + private String testString_ = null; + + private static List sExecutedCallbacks = new ArrayList<>(); + + private boolean beforeValidateReturn_ = true; + private boolean beforeInsertReturn_ = true; + private static boolean sBeforeDeleteReturn = true; + private boolean beforeSaveReturn_ = true; + private boolean beforeUpdateReturn_ = true; + private boolean afterValidateReturn_ = true; + private boolean afterInsertReturn_ = true; + private static boolean sAfterDeleteReturn = true; + private boolean afterSaveReturn_ = true; + private boolean afterUpdateReturn_ = true; + private static boolean sAfterRestoreReturn = true; + + public CallbacksBean() { + } + + protected void activateValidation() { + addConstraint(new ConstrainedProperty("id").identifier(true).notNull(true)); + addConstraint(new ConstrainedProperty("testString").notNull(true)); + } + + public void setId(int id) { + id_ = id; + } + + public int getId() { + return id_; + } + + public void setTestString(String testString) { + this.testString_ = testString; + } + + public String getTestString() { + return testString_; + } + + public String toString() { + return id_ + ";" + testString_; + } + + public static List getExecutedCallbacks() { + return sExecutedCallbacks; + } + + public static void clearExecuteCallbacks() { + sExecutedCallbacks = new ArrayList(); + } + + public void setBeforeValidateReturn(boolean beforeValidateReturn) { + beforeValidateReturn_ = beforeValidateReturn; + } + + public void setBeforeInsertReturn(boolean beforeInsertReturn) { + beforeInsertReturn_ = beforeInsertReturn; + } + + public static void setBeforeDeleteReturn(boolean beforeDeleteReturn) { + sBeforeDeleteReturn = beforeDeleteReturn; + } + + public void setBeforeSaveReturn(boolean beforeSaveReturn) { + beforeSaveReturn_ = beforeSaveReturn; + } + + public void setBeforeUpdateReturn(boolean beforeUpdateReturn) { + beforeUpdateReturn_ = beforeUpdateReturn; + } + + public void setAfterValidateReturn(boolean afterValidateReturn) { + afterValidateReturn_ = afterValidateReturn; + } + + public void setAfterInsertReturn(boolean afterInsertReturn) { + afterInsertReturn_ = afterInsertReturn; + } + + public static void setAfterDeleteReturn(boolean afterDeleteReturn) { + sAfterDeleteReturn = afterDeleteReturn; + } + + public void setAfterSaveReturn(boolean afterSaveReturn) { + afterSaveReturn_ = afterSaveReturn; + } + + public void setAfterUpdateReturn(boolean afterUpdateReturn) { + afterUpdateReturn_ = afterUpdateReturn; + } + + public static void setAfterRestoreReturn(boolean afterRestoreReturn) { + sAfterRestoreReturn = afterRestoreReturn; + } + + public boolean beforeValidate(CallbacksBean object) { + sExecutedCallbacks.add("beforeValidate " + object.toString()); + return beforeValidateReturn_; + } + + public boolean beforeInsert(CallbacksBean object) { + sExecutedCallbacks.add("beforeInsert " + object.toString()); + return beforeInsertReturn_; + } + + public boolean beforeDelete(int objectId) { + sExecutedCallbacks.add("beforeDelete " + objectId); + return sBeforeDeleteReturn; + } + + public boolean beforeSave(CallbacksBean object) { + sExecutedCallbacks.add("beforeSave " + object.toString()); + return beforeSaveReturn_; + } + + public boolean beforeUpdate(CallbacksBean object) { + sExecutedCallbacks.add("beforeUpdate " + object.toString()); + return beforeUpdateReturn_; + } + + public boolean afterValidate(CallbacksBean object) { + sExecutedCallbacks.add("afterValidate " + object.toString()); + return afterValidateReturn_; + } + + public boolean afterInsert(CallbacksBean object, boolean success) { + sExecutedCallbacks.add("afterInsert " + success + " " + object.toString()); + return afterInsertReturn_; + } + + public boolean afterDelete(int objectId, boolean success) { + sExecutedCallbacks.add("afterDelete " + success + " " + objectId); + return sAfterDeleteReturn; + } + + public boolean afterSave(CallbacksBean object, boolean success) { + sExecutedCallbacks.add("afterSave " + success + " " + object.toString()); + return afterSaveReturn_; + } + + public boolean afterUpdate(CallbacksBean object, boolean success) { + sExecutedCallbacks.add("afterUpdate " + success + " " + object.toString()); + return afterUpdateReturn_; + } + + public boolean afterRestore(CallbacksBean object) { + sExecutedCallbacks.add("afterRestore " + object.toString()); + return sAfterRestoreReturn; + } +} + diff --git a/lib/src/test/java/rife/database/querymanagers/generic/beans/CallbacksProviderBean.java b/lib/src/test/java/rife/database/querymanagers/generic/beans/CallbacksProviderBean.java new file mode 100644 index 00000000..492a95ac --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/beans/CallbacksProviderBean.java @@ -0,0 +1,121 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic.beans; + +import java.util.ArrayList; +import java.util.List; + +import rife.database.querymanagers.generic.Callbacks; +import rife.database.querymanagers.generic.CallbacksProvider; + +public class CallbacksProviderBean implements CallbacksProvider { + private int id_ = -1; + private String testString_ = null; + + static TheCallbacks callbacks_ = new TheCallbacks(); + + public CallbacksProviderBean() { + } + + public void setId(int id) { + id_ = id; + } + + public int getId() { + return id_; + } + + public Callbacks getCallbacks() { + return callbacks_; + } + + public void setTestString(String testString) { + this.testString_ = testString; + } + + public String getTestString() { + return testString_; + } + + public String toString() { + return id_ + ";" + testString_; + } + + public static List getExecutedCallbacks() { + return callbacks_.getExecutedCallbacks(); + } + + public static void clearExecuteCallbacks() { + callbacks_.clearExecuteCallbacks(); + } + + public static class TheCallbacks implements Callbacks { + private List mExecutedCallbacks = new ArrayList(); + + public List getExecutedCallbacks() { + return mExecutedCallbacks; + } + + public void clearExecuteCallbacks() { + mExecutedCallbacks = new ArrayList(); + } + + public boolean beforeValidate(CallbacksProviderBean object) { + mExecutedCallbacks.add("beforeValidate " + object.toString()); + return true; + } + + public boolean beforeInsert(CallbacksProviderBean object) { + mExecutedCallbacks.add("beforeInsert " + object.toString()); + return true; + } + + public boolean beforeDelete(int objectId) { + mExecutedCallbacks.add("beforeDelete " + objectId); + return true; + } + + public boolean beforeSave(CallbacksProviderBean object) { + mExecutedCallbacks.add("beforeSave " + object.toString()); + return true; + } + + public boolean beforeUpdate(CallbacksProviderBean object) { + mExecutedCallbacks.add("beforeUpdate " + object.toString()); + return true; + } + + public boolean afterValidate(CallbacksProviderBean object) { + mExecutedCallbacks.add("afterValidate " + object.toString()); + return true; + } + + public boolean afterInsert(CallbacksProviderBean object, boolean success) { + mExecutedCallbacks.add("afterInsert " + success + " " + object.toString()); + return true; + } + + public boolean afterDelete(int objectId, boolean success) { + mExecutedCallbacks.add("afterDelete " + success + " " + objectId); + return true; + } + + public boolean afterSave(CallbacksProviderBean object, boolean success) { + mExecutedCallbacks.add("afterSave " + success + " " + object.toString()); + return true; + } + + public boolean afterUpdate(CallbacksProviderBean object, boolean success) { + mExecutedCallbacks.add("afterUpdate " + success + " " + object.toString()); + return true; + } + + public boolean afterRestore(CallbacksProviderBean object) { + mExecutedCallbacks.add("afterRestore " + object.toString()); + return true; + } + } +} + diff --git a/lib/src/test/java/rife/database/querymanagers/generic/beans/CallbacksSparseBean.java b/lib/src/test/java/rife/database/querymanagers/generic/beans/CallbacksSparseBean.java new file mode 100644 index 00000000..9ec0167f --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/beans/CallbacksSparseBean.java @@ -0,0 +1,163 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic.beans; + +import rife.database.querymanagers.generic.Callbacks; +import rife.validation.ConstrainedProperty; +import rife.validation.Validation; + +import java.util.ArrayList; +import java.util.List; + +public class CallbacksSparseBean extends Validation implements Callbacks { + private int id_ = -1; + private String testString_ = null; + + private List executedCallbacks_ = new ArrayList<>(); + + private boolean beforeValidateReturn_ = true; + private boolean beforeInsertReturn_ = true; + private boolean beforeDeleteReturn_ = true; + private boolean beforeSaveReturn_ = true; + private boolean beforeUpdateReturn_ = true; + private boolean afterValidateReturn_ = true; + private boolean afterInsertReturn_ = true; + private boolean afterDeleteReturn_ = true; + private boolean afterSaveReturn_ = true; + private boolean afterUpdateReturn_ = true; + private boolean afterRestoreReturn_ = true; + + public void activateValidation() { + addConstraint(new ConstrainedProperty("id").identifier(true).sparse(true)); + } + + public void setId(int id) { + id_ = id; + } + + public int getId() { + return id_; + } + + public void setTestString(String testString) { + this.testString_ = testString; + } + + public String getTestString() { + return testString_; + } + + public String toString() { + return id_ + ";" + testString_; + } + + public List getExecutedCallbacks() { + return executedCallbacks_; + } + + public void clearExecuteCallbacks() { + executedCallbacks_ = new ArrayList(); + } + + public void setBeforeValidateReturn(boolean beforeValidateReturn) { + beforeValidateReturn_ = beforeValidateReturn; + } + + public void setBeforeInsertReturn(boolean beforeInsertReturn) { + beforeInsertReturn_ = beforeInsertReturn; + } + + public void setBeforeDeleteReturn(boolean beforeDeleteReturn) { + beforeDeleteReturn_ = beforeDeleteReturn; + } + + public void setBeforeSaveReturn(boolean beforeSaveReturn) { + beforeSaveReturn_ = beforeSaveReturn; + } + + public void setBeforeUpdateReturn(boolean beforeUpdateReturn) { + beforeUpdateReturn_ = beforeUpdateReturn; + } + + public void setAfterValidateReturn(boolean afterValidateReturn) { + afterValidateReturn_ = afterValidateReturn; + } + + public void setAfterInsertReturn(boolean afterInsertReturn) { + afterInsertReturn_ = afterInsertReturn; + } + + public void setAfterDeleteReturn(boolean afterDeleteReturn) { + afterDeleteReturn_ = afterDeleteReturn; + } + + public void setAfterSaveReturn(boolean afterSaveReturn) { + afterSaveReturn_ = afterSaveReturn; + } + + public void setAfterUpdateReturn(boolean afterUpdateReturn) { + afterUpdateReturn_ = afterUpdateReturn; + } + + public void setAfterRestoreReturn(boolean afterRestoreReturn) { + afterRestoreReturn_ = afterRestoreReturn; + } + + public boolean beforeValidate(CallbacksSparseBean object) { + executedCallbacks_.add("beforeValidate " + object.toString()); + return beforeValidateReturn_; + } + + public boolean beforeInsert(CallbacksSparseBean object) { + executedCallbacks_.add("beforeInsert " + object.toString()); + return beforeInsertReturn_; + } + + public boolean beforeDelete(int objectId) { + executedCallbacks_.add("beforeDelete " + objectId); + return beforeDeleteReturn_; + } + + public boolean beforeSave(CallbacksSparseBean object) { + executedCallbacks_.add("beforeSave " + object.toString()); + return beforeSaveReturn_; + } + + public boolean beforeUpdate(CallbacksSparseBean object) { + executedCallbacks_.add("beforeUpdate " + object.toString()); + return beforeUpdateReturn_; + } + + public boolean afterValidate(CallbacksSparseBean object) { + executedCallbacks_.add("afterValidate " + object.toString()); + return afterValidateReturn_; + } + + public boolean afterInsert(CallbacksSparseBean object, boolean success) { + executedCallbacks_.add("afterInsert " + success + " " + object.toString()); + return afterInsertReturn_; + } + + public boolean afterDelete(int objectId, boolean success) { + executedCallbacks_.add("afterDelete " + success + " " + objectId); + return afterDeleteReturn_; + } + + public boolean afterSave(CallbacksSparseBean object, boolean success) { + executedCallbacks_.add("afterSave " + success + " " + object.toString()); + return afterSaveReturn_; + } + + public boolean afterUpdate(CallbacksSparseBean object, boolean success) { + executedCallbacks_.add("afterUpdate " + success + " " + object.toString()); + return afterUpdateReturn_; + } + + public boolean afterRestore(CallbacksSparseBean object) { + executedCallbacks_.add("afterRestore " + object.toString()); + return afterRestoreReturn_; + } +} + diff --git a/lib/src/test/java/rife/database/querymanagers/generic/beans/ChildBean.java b/lib/src/test/java/rife/database/querymanagers/generic/beans/ChildBean.java new file mode 100644 index 00000000..5adca0f1 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/beans/ChildBean.java @@ -0,0 +1,18 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic.beans; + +public class ChildBean extends ParentBean { + private String childString_ = null; + + public void setChildString(String childString) { + childString_ = childString; + } + + public String getChildString() { + return childString_; + } +} + diff --git a/lib/src/test/java/rife/database/querymanagers/generic/beans/ConstrainedBean.java b/lib/src/test/java/rife/database/querymanagers/generic/beans/ConstrainedBean.java new file mode 100644 index 00000000..e0530521 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/beans/ConstrainedBean.java @@ -0,0 +1,47 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic.beans; + +import rife.validation.ConstrainedProperty; +import rife.validation.MetaData; + +public class ConstrainedBean extends MetaData { + private int identifier_ = -1; + private Integer linkBean_ = null; + private String testString_ = null; + + public ConstrainedBean() { + } + + public void activateMetaData() { + addConstraint(new ConstrainedProperty("identifier").identifier(true)); + addConstraint(new ConstrainedProperty("linkBean").manyToOne(LinkBean.class, "id")); + } + + public void setIdentifier(int identifier) { + identifier_ = identifier; + } + + public int getIdentifier() { + return identifier_; + } + + public void setLinkBean(Integer linkBean) { + linkBean_ = linkBean; + } + + public Integer getLinkBean() { + return linkBean_; + } + + public void setTestString(String testString) { + this.testString_ = testString; + } + + public String getTestString() { + return testString_; + } +} + diff --git a/lib/src/test/java/rife/database/querymanagers/generic/beans/LinkBean.java b/lib/src/test/java/rife/database/querymanagers/generic/beans/LinkBean.java new file mode 100644 index 00000000..c3b7e988 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/beans/LinkBean.java @@ -0,0 +1,27 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic.beans; + +public class LinkBean { + private int id_ = -1; + private String testString_ = null; + + public void setId(int id) { + id_ = id; + } + + public int getId() { + return id_; + } + + public void setTestString(String testString) { + testString_ = testString; + } + + public String getTestString() { + return testString_; + } +} + diff --git a/lib/src/test/java/rife/database/querymanagers/generic/beans/MMFirstBean.java b/lib/src/test/java/rife/database/querymanagers/generic/beans/MMFirstBean.java new file mode 100644 index 00000000..f3207159 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/beans/MMFirstBean.java @@ -0,0 +1,49 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic.beans; + +import rife.validation.ConstrainedProperty; +import rife.validation.MetaData; + +import java.util.Collection; + +public class MMFirstBean extends MetaData { + private Integer identifier_; + private Collection secondBeans_; + private String firstString_; + + public MMFirstBean() { + } + + public void activateMetaData() { + addConstraint(new ConstrainedProperty("identifier").identifier(true)); + addConstraint(new ConstrainedProperty("secondBeans").manyToMany()); + } + + public void setIdentifier(Integer identifier) { + identifier_ = identifier; + } + + public Integer getIdentifier() { + return identifier_; + } + + public void setSecondBeans(Collection secondBeans) { + secondBeans_ = secondBeans; + } + + public Collection getSecondBeans() { + return secondBeans_; + } + + public void setFirstString(String firstString) { + firstString_ = firstString; + } + + public String getFirstString() { + return firstString_; + } +} + diff --git a/lib/src/test/java/rife/database/querymanagers/generic/beans/MMSecondBean.java b/lib/src/test/java/rife/database/querymanagers/generic/beans/MMSecondBean.java new file mode 100644 index 00000000..3ade90d0 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/beans/MMSecondBean.java @@ -0,0 +1,49 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic.beans; + +import rife.validation.ConstrainedProperty; +import rife.validation.MetaData; + +import java.util.Collection; + +public class MMSecondBean extends MetaData { + private Integer identifier_; + private Collection firstBeans_; + private String secondString_; + + public MMSecondBean() { + } + + public void activateMetaData() { + addConstraint(new ConstrainedProperty("identifier").identifier(true)); + addConstraint(new ConstrainedProperty("firstBeans").manyToManyAssociation()); + } + + public void setIdentifier(Integer identifier) { + identifier_ = identifier; + } + + public Integer getIdentifier() { + return identifier_; + } + + public void setFirstBeans(Collection firstBeans) { + firstBeans_ = firstBeans; + } + + public Collection getFirstBeans() { + return firstBeans_; + } + + public void setSecondString(String secondString) { + secondString_ = secondString; + } + + public String getSecondString() { + return secondString_; + } +} + diff --git a/lib/src/test/java/rife/database/querymanagers/generic/beans/NoDefaultConstructorBean.java b/lib/src/test/java/rife/database/querymanagers/generic/beans/NoDefaultConstructorBean.java new file mode 100644 index 00000000..8af9be82 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/beans/NoDefaultConstructorBean.java @@ -0,0 +1,44 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic.beans; + +public class NoDefaultConstructorBean { + private int id_ = -1; + private int linkBean_ = -1; + private String testString_ = null; + + public NoDefaultConstructorBean(int id) { + id_ = id; + } + + public void setLinkBean(int linkBean) { + linkBean_ = linkBean; + } + + public int getLinkBean() { + return linkBean_; + } + + public void setId(int id) { + id_ = id; + } + + public int getId() { + return id_; + } + + public void setTestString(String testString) { + this.testString_ = testString; + } + + public String getTestString() { + return testString_; + } + + public String toString() { + return id_ + ";" + linkBean_ + ";" + testString_; + } +} + diff --git a/lib/src/test/java/rife/database/querymanagers/generic/beans/ParentBean.java b/lib/src/test/java/rife/database/querymanagers/generic/beans/ParentBean.java new file mode 100644 index 00000000..4a877e57 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/beans/ParentBean.java @@ -0,0 +1,27 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic.beans; + +public class ParentBean { + protected int id_ = -1; + protected String parentString_ = null; + + public void setParentString(String parentString) { + parentString_ = parentString; + } + + public String getParentString() { + return parentString_; + } + + public void setId(int id) { + id_ = id; + } + + public int getId() { + return id_; + } +} + diff --git a/lib/src/test/java/rife/database/querymanagers/generic/beans/SimpleBean.java b/lib/src/test/java/rife/database/querymanagers/generic/beans/SimpleBean.java new file mode 100644 index 00000000..d6dd49ea --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/beans/SimpleBean.java @@ -0,0 +1,61 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic.beans; + +import rife.database.SomeEnum; + +import java.util.UUID; + +public class SimpleBean { + private int id_ = -1; + private int linkBean_ = -1; + private String testString_ = null; + private UUID uuid_ = null; + private SomeEnum enum_; + + public void setLinkBean(int linkBean) { + linkBean_ = linkBean; + } + + public int getLinkBean() { + return linkBean_; + } + + public void setId(int id) { + id_ = id; + } + + public int getId() { + return id_; + } + + public void setTestString(String testString) { + this.testString_ = testString; + } + + public String getTestString() { + return testString_; + } + + public String toString() { + return id_ + ";" + linkBean_ + ";" + testString_; + } + + public UUID getUuid() { + return uuid_; + } + + public void setUuid(UUID uuid) { + uuid_ = uuid; + } + + public void setEnum(SomeEnum e) { + enum_ = e; + } + + public SomeEnum getEnum() { + return enum_; + } +} diff --git a/lib/src/test/java/rife/database/querymanagers/generic/beans/SparseBean.java b/lib/src/test/java/rife/database/querymanagers/generic/beans/SparseBean.java new file mode 100644 index 00000000..9b0e3f94 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/beans/SparseBean.java @@ -0,0 +1,34 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic.beans; + +import rife.validation.ConstrainedProperty; +import rife.validation.MetaData; + +public class SparseBean extends MetaData { + private int id_ = -1; + private String testString_ = null; + + public void activateMetaData() { + addConstraint(new ConstrainedProperty("id").identifier(true).sparse(true)); + } + + public void setId(int id) { + id_ = id; + } + + public int getId() { + return id_; + } + + public void setTestString(String testString) { + this.testString_ = testString; + } + + public String getTestString() { + return testString_; + } +} + diff --git a/lib/src/test/java/rife/database/querymanagers/generic/beans/UniqueBean.java b/lib/src/test/java/rife/database/querymanagers/generic/beans/UniqueBean.java new file mode 100644 index 00000000..aa642677 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/beans/UniqueBean.java @@ -0,0 +1,62 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic.beans; + +import rife.validation.ConstrainedProperty; +import rife.validation.Validation; + +public class UniqueBean extends Validation { + private int identifier_ = -1; + private String testString_ = null; + private String anotherString_ = null; + private String thirdString_ = null; + + public UniqueBean() { + } + + protected void activateValidation() { + addConstraint(new ConstrainedProperty("identifier").identifier(true)); + addGroup("group1") + .addConstraint(new ConstrainedProperty("testString").unique(true).maxLength(20).notNull(true)) + .addConstraint(new ConstrainedProperty("anotherString").maxLength(20).notNull(true)); + addGroup("group2") + .addConstraint(new ConstrainedProperty("thirdString").maxLength(20)); + + addConstraint(new rife.validation.ConstrainedBean().unique("anotherString", "thirdString")); + } + + public void setIdentifier(int identifier) { + identifier_ = identifier; + } + + public int getIdentifier() { + return identifier_; + } + + public void setTestString(String testString) { + this.testString_ = testString; + } + + public String getTestString() { + return testString_; + } + + public void setAnotherString(String anotherString) { + anotherString_ = anotherString; + } + + public String getAnotherString() { + return anotherString_; + } + + public void setThirdString(String thirdString) { + thirdString_ = thirdString; + } + + public String getThirdString() { + return thirdString_; + } +} + diff --git a/lib/src/test/java/rife/database/querymanagers/generic/beans/UniqueBeanNotNull.java b/lib/src/test/java/rife/database/querymanagers/generic/beans/UniqueBeanNotNull.java new file mode 100644 index 00000000..91226de4 --- /dev/null +++ b/lib/src/test/java/rife/database/querymanagers/generic/beans/UniqueBeanNotNull.java @@ -0,0 +1,16 @@ +/* + * Copyright 2001-2022 Geert Bevin (gbevin[remove] at uwyn dot com) + * Licensed under the Apache License, Version 2.0 (the "License") + */ +package rife.database.querymanagers.generic.beans; + +import rife.validation.ConstrainedProperty; + +public class UniqueBeanNotNull extends UniqueBean { + protected void activateValidation() { + super.activateValidation(); + + addConstraint(new ConstrainedProperty("thirdString").maxLength(50).notNull(true).defaultValue("")); + } +} +