diff --git a/li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/ActivityStateSelector.java b/li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/ActivityStateSelector.java new file mode 100644 index 000000000..2d7a66f51 --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/ActivityStateSelector.java @@ -0,0 +1,39 @@ +/* + * Copyright 2013 Robert von Burg + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package li.strolch.runtime.query.inmemory; + +import li.strolch.model.State; +import li.strolch.model.activity.Activity; + +/** + * @author Robert von Burg + */ +public class ActivityStateSelector implements Selector { + + private State state; + + /** + * @param state + */ + public ActivityStateSelector(State state) { + this.state = state; + } + + @Override + public boolean select(Activity element) { + return this.state.equals(element.getState()); + } +} diff --git a/li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/InMemoryActivityQueryVisitor.java b/li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/InMemoryActivityQueryVisitor.java index 474f1789d..c486a45c1 100644 --- a/li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/InMemoryActivityQueryVisitor.java +++ b/li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/InMemoryActivityQueryVisitor.java @@ -20,6 +20,7 @@ import java.util.List; import li.strolch.model.activity.Activity; import li.strolch.model.query.ActivityQuery; import li.strolch.model.query.ActivityQueryVisitor; +import li.strolch.model.query.ActivityStateSelection; import li.strolch.model.query.StrolchTypeNavigation; import li.strolch.model.visitor.ActivityVisitor; import li.strolch.utils.dbc.DBC; @@ -62,4 +63,9 @@ public class InMemoryActivityQueryVisitor extends InMemoryQueryVisitor public void visit(StrolchTypeNavigation navigation) { setNavigator(new ActivityTypeNavigator(navigation.getType())); } + + @Override + public void visit(ActivityStateSelection selection) { + addSelector(new ActivityStateSelector(selection.getState())); + } } diff --git a/li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/InMemoryOrderQueryVisitor.java b/li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/InMemoryOrderQueryVisitor.java index ecff0addc..093f15e41 100644 --- a/li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/InMemoryOrderQueryVisitor.java +++ b/li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/InMemoryOrderQueryVisitor.java @@ -21,7 +21,7 @@ import li.strolch.model.Order; import li.strolch.model.query.DateSelection; import li.strolch.model.query.OrderQuery; import li.strolch.model.query.OrderQueryVisitor; -import li.strolch.model.query.StateSelection; +import li.strolch.model.query.OrderStateSelection; import li.strolch.model.query.StrolchTypeNavigation; import li.strolch.model.visitor.OrderVisitor; import li.strolch.utils.dbc.DBC; @@ -71,7 +71,7 @@ public class InMemoryOrderQueryVisitor extends InMemoryQueryVisitor imple } @Override - public void visit(StateSelection selection) { - addSelector(new StateSelector(selection.getState())); + public void visit(OrderStateSelection selection) { + addSelector(new OrderStateSelector(selection.getState())); } } diff --git a/li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/StateSelector.java b/li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/OrderStateSelector.java similarity index 90% rename from li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/StateSelector.java rename to li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/OrderStateSelector.java index d0268f643..1a329189d 100644 --- a/li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/StateSelector.java +++ b/li.strolch.agent/src/main/java/li/strolch/runtime/query/inmemory/OrderStateSelector.java @@ -20,16 +20,15 @@ import li.strolch.model.State; /** * @author Robert von Burg - * */ -public class StateSelector implements Selector { +public class OrderStateSelector implements Selector { private State state; /** * @param state */ - public StateSelector(State state) { + public OrderStateSelector(State state) { this.state = state; } diff --git a/li.strolch.agent/src/test/java/li/strolch/runtime/query/inmemory/InMemoryActivityQueryTest.java b/li.strolch.agent/src/test/java/li/strolch/runtime/query/inmemory/InMemoryActivityQueryTest.java index 31b0a6068..3d699d3be 100644 --- a/li.strolch.agent/src/test/java/li/strolch/runtime/query/inmemory/InMemoryActivityQueryTest.java +++ b/li.strolch.agent/src/test/java/li/strolch/runtime/query/inmemory/InMemoryActivityQueryTest.java @@ -19,7 +19,9 @@ import org.junit.Test; import li.strolch.model.ModelGenerator; import li.strolch.model.ParameterBag; +import li.strolch.model.State; import li.strolch.model.Version; +import li.strolch.model.activity.Action; import li.strolch.model.activity.Activity; import li.strolch.model.activity.TimeOrdering; import li.strolch.model.parameter.BooleanParameter; @@ -30,6 +32,7 @@ import li.strolch.model.parameter.LongListParameter; import li.strolch.model.parameter.StringListParameter; import li.strolch.model.parameter.StringParameter; import li.strolch.model.query.ActivityQuery; +import li.strolch.model.query.ActivityStateSelection; import li.strolch.model.query.IdSelection; import li.strolch.model.query.NameSelection; import li.strolch.model.query.ParameterSelection; @@ -251,10 +254,10 @@ public class InMemoryActivityQueryTest { @Test public void shouldQueryByName() { - List activitys = getActivities(); - activitys.add(getBallActivity()); + List activities = getActivities(); + activities.add(getBallActivity()); InMemoryActivityDao dao = daoInstance(); - dao.saveAll(activitys); + dao.saveAll(activities); ActivityQuery ballQuery = ActivityQuery.query("Ball"); ballQuery.with(new NameSelection("ball ", ci())); @@ -263,6 +266,25 @@ public class InMemoryActivityQueryTest { assertEquals(1, result.size()); } + @Test + public void shouldQueryByState() { + + List activities = getActivities(); + InMemoryActivityDao dao = daoInstance(); + dao.saveAll(activities); + + ActivityQuery ballQuery = ActivityQuery.query("MyType1"); + ballQuery.with(new ActivityStateSelection(State.STOPPED)); + + List result = dao.doQuery(ballQuery); + assertEquals(2, result.size()); + + ballQuery = ActivityQuery.query("MyType2"); + ballQuery.with(new ActivityStateSelection(State.STOPPED)); + result = dao.doQuery(ballQuery); + assertEquals(1, result.size()); + } + private Activity getBallActivity() { Activity res1 = new Activity("childrensBall", "Ball 1", "Ball", TimeOrdering.SERIES); Version.setInitialVersionFor(res1, "test"); @@ -281,19 +303,32 @@ public class InMemoryActivityQueryTest { } private List getActivities() { - Activity res1 = ModelGenerator.createActivity("@1", "Activity 1", "MyType1", TimeOrdering.SERIES); - Activity res2 = ModelGenerator.createActivity("@2", "Activity 2", "MyType1", TimeOrdering.SERIES); - Activity res3 = ModelGenerator.createActivity("@3", "Activity 3", "MyType2", TimeOrdering.SERIES); - Activity res4 = ModelGenerator.createActivity("@4", "Activity 4", "MyType2", TimeOrdering.SERIES); - Activity res5 = ModelGenerator.createActivity("@5", "Activity 5", "MyType3", TimeOrdering.SERIES); - Activity res6 = ModelGenerator.createActivity("@6", "Activity 6", "MyType3", TimeOrdering.SERIES); + + Activity activity1 = ModelGenerator.createActivity("@1", "Activity 1", "MyType1", TimeOrdering.SERIES); + ((Action) activity1.getElement("action_" + activity1.getId())).setState(State.STOPPED); + + Activity activity2 = ModelGenerator.createActivity("@2", "Activity 2", "MyType1", TimeOrdering.SERIES); + ((Action) activity2.getElement("action_" + activity2.getId())).setState(State.STOPPED); + + Activity activity3 = ModelGenerator.createActivity("@3", "Activity 3", "MyType2", TimeOrdering.SERIES); + ((Action) activity3.getElement("action_" + activity3.getId())).setState(State.STOPPED); + + Activity activity4 = ModelGenerator.createActivity("@4", "Activity 4", "MyType2", TimeOrdering.SERIES); + ((Action) activity4.getElement("action_" + activity4.getId())).setState(State.PLANNING); + + Activity activity5 = ModelGenerator.createActivity("@5", "Activity 5", "MyType3", TimeOrdering.SERIES); + ((Action) activity5.getElement("action_" + activity5.getId())).setState(State.ERROR); + + Activity activity6 = ModelGenerator.createActivity("@6", "Activity 6", "MyType3", TimeOrdering.SERIES); + ((Action) activity6.getElement("action_" + activity6.getId())).setState(State.CLOSED); + List activitys = new ArrayList<>(); - activitys.add(res1); - activitys.add(res2); - activitys.add(res3); - activitys.add(res4); - activitys.add(res5); - activitys.add(res6); + activitys.add(activity1); + activitys.add(activity2); + activitys.add(activity3); + activitys.add(activity4); + activitys.add(activity5); + activitys.add(activity6); for (Activity activity : activitys) { Version.setInitialVersionFor(activity, "test"); diff --git a/li.strolch.agent/src/test/java/li/strolch/runtime/query/inmemory/InMemoryOrderQueryTest.java b/li.strolch.agent/src/test/java/li/strolch/runtime/query/inmemory/InMemoryOrderQueryTest.java index 410b2a9be..540ab6cd3 100644 --- a/li.strolch.agent/src/test/java/li/strolch/runtime/query/inmemory/InMemoryOrderQueryTest.java +++ b/li.strolch.agent/src/test/java/li/strolch/runtime/query/inmemory/InMemoryOrderQueryTest.java @@ -48,6 +48,7 @@ import li.strolch.model.parameter.StringParameter; import li.strolch.model.query.IdSelection; import li.strolch.model.query.NameSelection; import li.strolch.model.query.OrderQuery; +import li.strolch.model.query.OrderStateSelection; import li.strolch.model.query.ParameterSelection; import li.strolch.persistence.inmemory.InMemoryOrderDao; @@ -283,6 +284,25 @@ public class InMemoryOrderQueryTest { assertEquals(1, result.size()); } + @Test + public void shouldQueryByState() { + + List orders = getOrders(); + InMemoryOrderDao dao = daoInstance(); + dao.saveAll(orders); + + OrderQuery ballQuery = OrderQuery.query("MyType1"); + ballQuery.with(new OrderStateSelection(State.STOPPED)); + + List result = dao.doQuery(ballQuery); + assertEquals(2, result.size()); + + ballQuery = OrderQuery.query("MyType2"); + ballQuery.with(new OrderStateSelection(State.STOPPED)); + result = dao.doQuery(ballQuery); + assertEquals(1, result.size()); + } + private Order getBallOrder() { Order o1 = new Order("childrensBall", "Ball 1", "Ball"); Version.setInitialVersionFor(o1, "test"); @@ -301,12 +321,12 @@ public class InMemoryOrderQueryTest { } private List getOrders() { - Order res1 = ModelGenerator.createOrder("@1", "Order 1", "MyType1", new Date(), State.CREATED); - Order res2 = ModelGenerator.createOrder("@2", "Order 2", "MyType1", new Date(), State.CREATED); - Order res3 = ModelGenerator.createOrder("@3", "Order 3", "MyType2", new Date(), State.CREATED); - Order res4 = ModelGenerator.createOrder("@4", "Order 4", "MyType2", new Date(), State.CREATED); - Order res5 = ModelGenerator.createOrder("@5", "Order 5", "MyType3", new Date(), State.CREATED); - Order res6 = ModelGenerator.createOrder("@6", "Order 6", "MyType3", new Date(), State.CREATED); + Order res1 = ModelGenerator.createOrder("@1", "Order 1", "MyType1", new Date(), State.STOPPED); + Order res2 = ModelGenerator.createOrder("@2", "Order 2", "MyType1", new Date(), State.STOPPED); + Order res3 = ModelGenerator.createOrder("@3", "Order 3", "MyType2", new Date(), State.STOPPED); + Order res4 = ModelGenerator.createOrder("@4", "Order 4", "MyType2", new Date(), State.PLANNING); + Order res5 = ModelGenerator.createOrder("@5", "Order 5", "MyType3", new Date(), State.ERROR); + Order res6 = ModelGenerator.createOrder("@6", "Order 6", "MyType3", new Date(), State.CLOSED); List orders = new ArrayList<>(); orders.add(res1); orders.add(res2); diff --git a/li.strolch.model/src/main/java/li/strolch/model/query/ActivityQueryVisitor.java b/li.strolch.model/src/main/java/li/strolch/model/query/ActivityQueryVisitor.java index 4f8a12fec..35b72e8fd 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/query/ActivityQueryVisitor.java +++ b/li.strolch.model/src/main/java/li/strolch/model/query/ActivityQueryVisitor.java @@ -20,8 +20,8 @@ import li.strolch.model.query.ordering.StrolchQueryOrderingVisitor; /** * @author Robert von Burg */ -public interface ActivityQueryVisitor extends StrolchRootElementSelectionVisitor, ParameterSelectionVisitor, - StrolchQueryOrderingVisitor { +public interface ActivityQueryVisitor + extends ActivitySelectionVisitor, ParameterSelectionVisitor, StrolchQueryOrderingVisitor { // marker interface } diff --git a/li.strolch.model/src/main/java/li/strolch/model/query/ActivitySelection.java b/li.strolch.model/src/main/java/li/strolch/model/query/ActivitySelection.java new file mode 100644 index 000000000..4d2fdf3b8 --- /dev/null +++ b/li.strolch.model/src/main/java/li/strolch/model/query/ActivitySelection.java @@ -0,0 +1,35 @@ +/* + * Copyright 2013 Robert von Burg + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package li.strolch.model.query; + +/** + * @author Robert von Burg + * + */ +public abstract class ActivitySelection implements Selection { + + @Override + public void accept(QueryVisitor visitor) { + accept((ActivitySelectionVisitor) visitor); + } + + @Override + public boolean hasSelection() { + return true; + } + + public abstract void accept(ActivitySelectionVisitor visitor); +} diff --git a/li.strolch.model/src/main/java/li/strolch/model/query/ActivitySelectionVisitor.java b/li.strolch.model/src/main/java/li/strolch/model/query/ActivitySelectionVisitor.java new file mode 100644 index 000000000..3a2dab8fc --- /dev/null +++ b/li.strolch.model/src/main/java/li/strolch/model/query/ActivitySelectionVisitor.java @@ -0,0 +1,24 @@ +/* + * Copyright 2013 Robert von Burg + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package li.strolch.model.query; + +/** + * @author Robert von Burg + */ +public interface ActivitySelectionVisitor extends StrolchRootElementSelectionVisitor { + + public void visit(ActivityStateSelection selection); +} diff --git a/li.strolch.model/src/main/java/li/strolch/model/query/ActivityStateSelection.java b/li.strolch.model/src/main/java/li/strolch/model/query/ActivityStateSelection.java new file mode 100644 index 000000000..3ee4620ab --- /dev/null +++ b/li.strolch.model/src/main/java/li/strolch/model/query/ActivityStateSelection.java @@ -0,0 +1,39 @@ +/* + * Copyright 2013 Robert von Burg + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package li.strolch.model.query; + +import li.strolch.model.State; + +/** + * @author Robert von Burg + */ +public class ActivityStateSelection extends ActivitySelection { + + private State state; + + public ActivityStateSelection(State state) { + this.state = state; + } + + public State getState() { + return this.state; + } + + @Override + public void accept(ActivitySelectionVisitor visitor) { + visitor.visit(this); + } +} diff --git a/li.strolch.model/src/main/java/li/strolch/model/query/OrderSelectionVisitor.java b/li.strolch.model/src/main/java/li/strolch/model/query/OrderSelectionVisitor.java index 6f3c36349..c216fe255 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/query/OrderSelectionVisitor.java +++ b/li.strolch.model/src/main/java/li/strolch/model/query/OrderSelectionVisitor.java @@ -17,11 +17,10 @@ package li.strolch.model.query; /** * @author Robert von Burg - * */ public interface OrderSelectionVisitor extends StrolchRootElementSelectionVisitor { public void visit(DateSelection selection); - public void visit(StateSelection selection); + public void visit(OrderStateSelection selection); } diff --git a/li.strolch.model/src/main/java/li/strolch/model/query/StateSelection.java b/li.strolch.model/src/main/java/li/strolch/model/query/OrderStateSelection.java similarity index 90% rename from li.strolch.model/src/main/java/li/strolch/model/query/StateSelection.java rename to li.strolch.model/src/main/java/li/strolch/model/query/OrderStateSelection.java index 8c4aae742..24dde94ad 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/query/StateSelection.java +++ b/li.strolch.model/src/main/java/li/strolch/model/query/OrderStateSelection.java @@ -20,11 +20,11 @@ import li.strolch.model.State; /** * @author Robert von Burg */ -public class StateSelection extends OrderSelection { +public class OrderStateSelection extends OrderSelection { private State state; - public StateSelection(State state) { + public OrderStateSelection(State state) { this.state = state; } diff --git a/li.strolch.persistence.postgresql/src/main/java/li/strolch/persistence/postgresql/PostgreSqlActivityDao.java b/li.strolch.persistence.postgresql/src/main/java/li/strolch/persistence/postgresql/PostgreSqlActivityDao.java index 0264d374d..e1c537aef 100644 --- a/li.strolch.persistence.postgresql/src/main/java/li/strolch/persistence/postgresql/PostgreSqlActivityDao.java +++ b/li.strolch.persistence.postgresql/src/main/java/li/strolch/persistence/postgresql/PostgreSqlActivityDao.java @@ -99,7 +99,7 @@ public class PostgreSqlActivityDao extends PostgresqlDao implements Ac protected void internalSave(final Activity activity) { String sql = "insert into " + getTableName() - + " (id, version, created_by, created_at, deleted, latest, name, type, asxml) values (?, ?, ?, ?, ?, ?, ?, ?, ?)"; + + " (id, version, created_by, created_at, deleted, latest, name, type, state, asxml) values (?, ?, ?, ?, ?, ?, ?, ?, ?::order_state, ?)"; try (PreparedStatement preparedStatement = tx().getConnection().prepareStatement(sql)) { @@ -118,9 +118,10 @@ public class PostgreSqlActivityDao extends PostgresqlDao implements Ac // attributes preparedStatement.setString(7, activity.getName()); preparedStatement.setString(8, activity.getType()); + preparedStatement.setString(9, activity.getState().name()); SQLXML sqlxml = createSqlXml(activity, preparedStatement); - preparedStatement.setSQLXML(9, sqlxml); + preparedStatement.setSQLXML(10, sqlxml); try { int modCount = preparedStatement.executeUpdate(); @@ -189,7 +190,7 @@ public class PostgreSqlActivityDao extends PostgresqlDao implements Ac } String sql = "update " + getTableName() - + " set created_by = ?, created_at = ?, deleted = ?, latest = ?, name = ?, type = ?, asxml = ? where id = ? and version = ?"; + + " set created_by = ?, created_at = ?, deleted = ?, latest = ?, name = ?, type = ?, state = ?, asxml = ? where id = ? and version = ?"; try (PreparedStatement preparedStatement = tx().getConnection().prepareStatement(sql)) { @@ -204,13 +205,14 @@ public class PostgreSqlActivityDao extends PostgresqlDao implements Ac // attributes preparedStatement.setString(5, activity.getName()); preparedStatement.setString(6, activity.getType()); + preparedStatement.setString(7, activity.getState().name()); SQLXML sqlxml = createSqlXml(activity, preparedStatement); - preparedStatement.setSQLXML(7, sqlxml); + preparedStatement.setSQLXML(8, sqlxml); // primary key - preparedStatement.setString(8, activity.getId()); - preparedStatement.setInt(9, activity.getVersion().getVersion()); + preparedStatement.setString(9, activity.getId()); + preparedStatement.setInt(10, activity.getVersion().getVersion()); try { int modCount = preparedStatement.executeUpdate(); diff --git a/li.strolch.persistence.postgresql/src/main/java/li/strolch/persistence/postgresql/PostgreSqlActivityQueryVisitor.java b/li.strolch.persistence.postgresql/src/main/java/li/strolch/persistence/postgresql/PostgreSqlActivityQueryVisitor.java index ecee7b37d..8f90046f5 100644 --- a/li.strolch.persistence.postgresql/src/main/java/li/strolch/persistence/postgresql/PostgreSqlActivityQueryVisitor.java +++ b/li.strolch.persistence.postgresql/src/main/java/li/strolch/persistence/postgresql/PostgreSqlActivityQueryVisitor.java @@ -17,6 +17,7 @@ package li.strolch.persistence.postgresql; import li.strolch.model.Tags; import li.strolch.model.query.ActivityQueryVisitor; +import li.strolch.model.query.ActivityStateSelection; /** * @author Robert von Burg @@ -39,4 +40,11 @@ public class PostgreSqlActivityQueryVisitor extends PostgreSqlQueryVisitor imple protected String getTableName() { return PostgreSqlActivityDao.ACTIVITIES; } + + @Override + public void visit(ActivityStateSelection selection) { + this.sb.append(this.indent); + this.sb.append("state = ?::order_state\n"); + this.values.add(selection.getState().name()); + } } diff --git a/li.strolch.persistence.postgresql/src/main/java/li/strolch/persistence/postgresql/PostgreSqlOrderQueryVisitor.java b/li.strolch.persistence.postgresql/src/main/java/li/strolch/persistence/postgresql/PostgreSqlOrderQueryVisitor.java index 40050292a..53491023b 100644 --- a/li.strolch.persistence.postgresql/src/main/java/li/strolch/persistence/postgresql/PostgreSqlOrderQueryVisitor.java +++ b/li.strolch.persistence.postgresql/src/main/java/li/strolch/persistence/postgresql/PostgreSqlOrderQueryVisitor.java @@ -18,7 +18,7 @@ package li.strolch.persistence.postgresql; import li.strolch.model.Tags; import li.strolch.model.query.DateSelection; import li.strolch.model.query.OrderQueryVisitor; -import li.strolch.model.query.StateSelection; +import li.strolch.model.query.OrderStateSelection; /** * @author Robert von Burg @@ -48,7 +48,7 @@ public class PostgreSqlOrderQueryVisitor extends PostgreSqlQueryVisitor implemen } @Override - public void visit(StateSelection selection) { + public void visit(OrderStateSelection selection) { this.sb.append(this.indent); this.sb.append("state = ?::order_state\n"); this.values.add(selection.getState().name()); diff --git a/li.strolch.persistence.postgresql/src/main/resources/strolch_db_schema_0.5.1_drop.sql b/li.strolch.persistence.postgresql/src/main/resources/strolch_db_schema_0.5.1_drop.sql new file mode 100644 index 000000000..0ff96e495 --- /dev/null +++ b/li.strolch.persistence.postgresql/src/main/resources/strolch_db_schema_0.5.1_drop.sql @@ -0,0 +1,11 @@ + +DROP TABLE IF EXISTS resources; +DROP TABLE IF EXISTS orders; +DROP TABLE IF EXISTS activities; + +DROP TABLE IF EXISTS audits; + +DROP TABLE IF EXISTS db_version; + +DROP TYPE IF EXISTS order_state; +DROP TYPE IF EXISTS access_type; diff --git a/li.strolch.persistence.postgresql/src/main/resources/strolch_db_schema_0.5.1_initial.sql b/li.strolch.persistence.postgresql/src/main/resources/strolch_db_schema_0.5.1_initial.sql new file mode 100644 index 000000000..18b800863 --- /dev/null +++ b/li.strolch.persistence.postgresql/src/main/resources/strolch_db_schema_0.5.1_initial.sql @@ -0,0 +1,141 @@ + +-- DB_VERSION +CREATE TABLE IF NOT EXISTS db_version ( + id serial primary key not null, + app varchar(255) not null, + version varchar(255) not null, + description varchar(255) not null, + created timestamp with time zone not null +); + +-- RESOURCES +CREATE TABLE IF NOT EXISTS resources ( + id varchar(255) not null, + version integer not null, + created_by varchar(255) not null, + created_at timestamp with time zone not null, + deleted boolean not null, + latest boolean not null, + name varchar(255) not null, + type varchar(255) not null, + asxml xml not null, + + PRIMARY KEY (id, version) +); + +-- ORDERS +CREATE TYPE order_state AS ENUM ('CREATED', 'OPEN', 'EXECUTION', 'CLOSED'); + +CREATE TABLE IF NOT EXISTS orders ( + id varchar(255) not null, + version integer not null, + created_by varchar(255) not null, + created_at timestamp with time zone not null, + deleted boolean, + latest boolean not null, + name varchar(255), + type varchar(255), + state order_state, + date timestamp with time zone, + asxml xml not null, + + PRIMARY KEY (id, version) +); + +-- ACTIVITIES +CREATE TABLE IF NOT EXISTS activities ( + id varchar(255) not null, + version integer not null, + created_by varchar(255) not null, + created_at timestamp with time zone not null, + deleted boolean not null, + latest boolean not null, + name varchar(255) not null, + type varchar(255) not null, + state order_state, + asxml xml not null, + + PRIMARY KEY (id, version) +); + +-- AUDITS +CREATE TYPE access_type AS ENUM ('READ', 'CREATE', 'UPDATE', 'DELETE'); +CREATE TABLE IF NOT EXISTS audits ( + id bigint PRIMARY KEY, + username varchar(255) NOT NULL, + firstname varchar(255) NOT NULL, + lastname varchar(255) NOT NULL, + date timestamp with time zone NOT NULL, + + element_type varchar(255) NOT NULL, + element_sub_type varchar(255) NOT NULL, + element_accessed varchar(255) NOT NULL, + new_version timestamp with time zone, + + action varchar(255) NOT NULL, + access_type access_type NOT NULL +); + +-- set version +INSERT INTO db_version + (version, app, description, created) +values( + '0.1.0', + 'strolch', + 'Initial schema version', + CURRENT_TIMESTAMP +); + +INSERT INTO db_version + (version, app, description, created) +values( + '0.2.0', + 'strolch', + 'Added new table for audits', + CURRENT_TIMESTAMP +); + +INSERT INTO db_version + (version, app, description, created) +values( + '0.2.1', + 'strolch', + 'Added new column app to table table version', + CURRENT_TIMESTAMP +); + +INSERT INTO db_version + (version, app, description, created) +values( + '0.3.0', + 'strolch', + 'Added new column element_sub_type to table audits', + CURRENT_TIMESTAMP +); + +INSERT INTO db_version + (version, app, description, created) +values( + '0.4.0', + 'strolch', + 'Added new table activities', + CURRENT_TIMESTAMP +); + +INSERT INTO db_version + (version, app, description, created) +values( + '0.5.0', + 'strolch', + 'Added versioning to root elements', + CURRENT_TIMESTAMP +); + +INSERT INTO db_version + (version, app, description, created) +values( + '0.5.1', + 'strolch', + 'Added state column to activity', + CURRENT_TIMESTAMP +); diff --git a/li.strolch.persistence.postgresql/src/main/resources/strolch_db_schema_0.5.1_migration.sql b/li.strolch.persistence.postgresql/src/main/resources/strolch_db_schema_0.5.1_migration.sql new file mode 100644 index 000000000..546fe890b --- /dev/null +++ b/li.strolch.persistence.postgresql/src/main/resources/strolch_db_schema_0.5.1_migration.sql @@ -0,0 +1,12 @@ + +-- add version columns +ALTER TABLE activities ADD COLUMN state order_state; + +INSERT INTO db_version + (version, app, description, created) +values( + '0.5.1', + 'strolch', + 'Added state column to activity', + CURRENT_TIMESTAMP +); diff --git a/li.strolch.persistence.postgresql/src/main/resources/strolch_db_version.properties b/li.strolch.persistence.postgresql/src/main/resources/strolch_db_version.properties index 0361a7be0..aed9e3f56 100644 --- a/li.strolch.persistence.postgresql/src/main/resources/strolch_db_version.properties +++ b/li.strolch.persistence.postgresql/src/main/resources/strolch_db_version.properties @@ -1,2 +1,2 @@ # Property file defining what the currently expected version is supposed to be -db_version=0.5.0 +db_version=0.5.1 diff --git a/li.strolch.persistence.postgresql/src/test/java/li/strolch/persistence/postgresql/dao/test/ActivityQueryTest.java b/li.strolch.persistence.postgresql/src/test/java/li/strolch/persistence/postgresql/dao/test/ActivityQueryTest.java new file mode 100644 index 000000000..458475250 --- /dev/null +++ b/li.strolch.persistence.postgresql/src/test/java/li/strolch/persistence/postgresql/dao/test/ActivityQueryTest.java @@ -0,0 +1,251 @@ +package li.strolch.persistence.postgresql.dao.test; + +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.CONFIG_SRC; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.DB_PASSWORD; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.DB_STORE_PATH_DIR; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.DB_URL; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.DB_USERNAME; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.RUNTIME_PATH; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.dropSchema; + +import java.io.File; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.util.Arrays; +import java.util.Date; +import java.util.List; + +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; + +import li.strolch.agent.api.ActivityMap; +import li.strolch.agent.api.StrolchRealm; +import li.strolch.model.ModelGenerator; +import li.strolch.model.State; +import li.strolch.model.activity.Action; +import li.strolch.model.activity.Activity; +import li.strolch.model.activity.TimeOrdering; +import li.strolch.model.query.ActivityQuery; +import li.strolch.model.query.ActivityStateSelection; +import li.strolch.model.query.IdSelection; +import li.strolch.model.query.NameSelection; +import li.strolch.model.query.ParameterBagSelection; +import li.strolch.model.query.ParameterBagSelection.NullParameterBagSelection; +import li.strolch.model.query.ParameterSelection; +import li.strolch.model.query.ordering.OrderById; +import li.strolch.persistence.api.StrolchTransaction; +import li.strolch.privilege.model.Certificate; +import li.strolch.runtime.StrolchConstants; +import li.strolch.testbase.runtime.RuntimeMock; +import li.strolch.utils.StringMatchMode; +import li.strolch.utils.collections.DateRange; + +public class ActivityQueryTest extends QueryTest { + + private static RuntimeMock runtimeMock; + + @BeforeClass + public static void beforeClass() throws Exception { + + dropSchema(DB_URL, DB_USERNAME, DB_PASSWORD); + + File rootPath = new File(RUNTIME_PATH); + File configSrc = new File(CONFIG_SRC); + runtimeMock = new RuntimeMock(); + runtimeMock.mockRuntime(rootPath, configSrc); + new File(rootPath, DB_STORE_PATH_DIR).mkdir(); + runtimeMock.startContainer(); + + Certificate cert = runtimeMock.getPrivilegeHandler().authenticate("test", "test".getBytes()); + StrolchRealm realm = runtimeMock.getRealm(StrolchConstants.DEFAULT_REALM); + try (StrolchTransaction tx = realm.openTx(cert, "test")) { + ActivityMap activityMap = tx.getActivityMap(); + + Activity activity = ModelGenerator.createActivity("@1", "Activity 1", "MyType1", TimeOrdering.SERIES); + activityMap.add(tx, activity); + + activity = ModelGenerator.createActivity("@2", "Activity 2", "MyType1", TimeOrdering.SERIES); + ((Action) activity.getElement("action_" + activity.getId())).setState(State.EXECUTION); + activityMap.add(tx, activity); + + activity = ModelGenerator.createActivity("@3", "Activity 3", "MyType1", TimeOrdering.SERIES); + ((Action) activity.getElement("action_" + activity.getId())).setState(State.CLOSED); + activityMap.add(tx, activity); + + activity = ModelGenerator.createActivity("@4", "Activity 4", "MyType2", TimeOrdering.SERIES); + ((Action) activity.getElement("action_" + activity.getId())).setState(State.CREATED); + activityMap.add(tx, activity); + + activity = ModelGenerator.createActivity("@5", "Activity 5", "MyType2", TimeOrdering.SERIES); + ((Action) activity.getElement("action_" + activity.getId())).setState(State.CLOSED); + activityMap.add(tx, activity); + + activity = ModelGenerator.createActivity("@6", "Activity 6", "MyType2", TimeOrdering.SERIES); + ((Action) activity.getElement("action_" + activity.getId())).setState(State.CLOSED); + activityMap.add(tx, activity); + + tx.commitOnClose(); + } + } + + @AfterClass + public static void afterClass() { + if (runtimeMock != null) + runtimeMock.destroyRuntime(); + } + + public Connection openConn() throws SQLException { + String url = "jdbc:postgresql://localhost/testdb"; + String username = "testuser"; + String password = "test"; + Connection connection = DriverManager.getConnection(url, username, password); + connection.setAutoCommit(false); + return connection; + } + + @Test + public void shouldQueryActivityAll() throws SQLException { + + ActivityQuery query = ActivityQuery.query("MyType1", new OrderById()); + query.withAny(); + performActivityQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryActivityByState() throws SQLException { + + ActivityQuery query = ActivityQuery.query("MyType1"); + query.and().with(new ActivityStateSelection(State.CREATED)); + performActivityQuery(query, Arrays.asList("@1")); + + query = ActivityQuery.query("MyType1"); + query.and().with(new ActivityStateSelection(State.EXECUTION)); + performActivityQuery(query, Arrays. asList("@2")); + } + + @Test + public void shouldQueryActivity1() throws SQLException { + + ActivityQuery query = ActivityQuery.query("MyType1", new OrderById()); + query.and().with(new IdSelection("@1", "@2"), + new NameSelection("Activity 1", StringMatchMode.EQUALS_CASE_SENSITIVE)); + performActivityQuery(query, Arrays.asList("@1")); + } + + @Test + public void shouldQueryActivity2() throws SQLException { + + ActivityQuery query = ActivityQuery.query("MyType1", new OrderById()); + query.or().with(new IdSelection("@1", "@2"), + new NameSelection("activity 1", StringMatchMode.EQUALS_CASE_SENSITIVE)); + performActivityQuery(query, Arrays.asList("@1", "@2")); + } + + @Test + public void shouldQueryActivityByBooleParam() throws SQLException { + ActivityQuery query = ActivityQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.booleanSelection("@bag01", "@param1", true)); + performActivityQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryActivityByFloatParam() throws SQLException { + ActivityQuery query = ActivityQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.floatSelection("@bag01", "@param2", 44.3)); + performActivityQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryActivityByIntegerParam() throws SQLException { + ActivityQuery query = ActivityQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.integerSelection("@bag01", "@param3", 77)); + performActivityQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryActivityByLongParam() throws SQLException { + ActivityQuery query = ActivityQuery.query("MyType2", new OrderById()); + query.and().with(ParameterSelection.longSelection("@bag01", "@param4", 4453234566L)); + performActivityQuery(query, Arrays.asList("@4", "@5", "@6")); + } + + @Test + public void shouldQueryActivityByStringParam() throws SQLException { + + List expected = Arrays.asList("@1", "@2", "@3"); + + ActivityQuery query = ActivityQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "Strolch", + StringMatchMode.EQUALS_CASE_SENSITIVE)); + performActivityQuery(query, expected); + + query = ActivityQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "strolch", + StringMatchMode.EQUALS_CASE_SENSITIVE)); + performActivityQuery(query, Arrays. asList()); + + query = ActivityQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "strolch", + StringMatchMode.EQUALS_CASE_INSENSITIVE)); + performActivityQuery(query, expected); + + query = ActivityQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "olch", + StringMatchMode.CONTAINS_CASE_INSENSITIVE)); + performActivityQuery(query, expected); + } + + @Test + public void shouldQueryActivityByDateParam() throws SQLException { + ActivityQuery query = ActivityQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.dateSelection("@bag01", "@param6", new Date(1354295525628L))); + performActivityQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Ignore("Not yet implemented") + @Test + public void shouldQueryActivityByDateRange() throws SQLException { + ActivityQuery query = ActivityQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.dateRangeSelection("@bag01", "@param6", + new DateRange().from(new Date(1354295525627L), false).to(new Date(1354295525629L), false))); + performActivityQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryActivityByDurationParam() throws SQLException { + ActivityQuery query = ActivityQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.durationSelection("@bag01", "@param8", "P1D")); + performActivityQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryActivityByNullParam1() throws SQLException { + ActivityQuery query = ActivityQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.nullSelection("@bag01", "@param6")); + performActivityQuery(query, Arrays. asList()); + } + + @Test + public void shouldQueryActivityByNullParam2() throws SQLException { + ActivityQuery query = ActivityQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.nullSelection("@bag01", "@param")); + performActivityQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryActivityByBag() throws SQLException { + ActivityQuery query = ActivityQuery.query("MyType1", new OrderById()); + query.and().with(new ParameterBagSelection("@bag01")); + performActivityQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryActivityByNullBag() throws SQLException { + ActivityQuery query = ActivityQuery.query("MyType1", new OrderById()); + query.and().with(new NullParameterBagSelection("@bag01")); + performActivityQuery(query, Arrays. asList()); + } +} diff --git a/li.strolch.persistence.postgresql/src/test/java/li/strolch/persistence/postgresql/dao/test/OrderQueryTest.java b/li.strolch.persistence.postgresql/src/test/java/li/strolch/persistence/postgresql/dao/test/OrderQueryTest.java new file mode 100644 index 000000000..de1fc75b5 --- /dev/null +++ b/li.strolch.persistence.postgresql/src/test/java/li/strolch/persistence/postgresql/dao/test/OrderQueryTest.java @@ -0,0 +1,298 @@ +package li.strolch.persistence.postgresql.dao.test; + +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.CONFIG_SRC; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.DB_PASSWORD; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.DB_STORE_PATH_DIR; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.DB_URL; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.DB_USERNAME; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.RUNTIME_PATH; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.dropSchema; + +import java.io.File; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.util.Arrays; +import java.util.Calendar; +import java.util.Date; +import java.util.List; + +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; + +import li.strolch.agent.api.OrderMap; +import li.strolch.agent.api.StrolchRealm; +import li.strolch.model.ModelGenerator; +import li.strolch.model.Order; +import li.strolch.model.State; +import li.strolch.model.query.DateSelection; +import li.strolch.model.query.IdSelection; +import li.strolch.model.query.NameSelection; +import li.strolch.model.query.OrderQuery; +import li.strolch.model.query.OrderStateSelection; +import li.strolch.model.query.ParameterBagSelection; +import li.strolch.model.query.ParameterBagSelection.NullParameterBagSelection; +import li.strolch.model.query.ParameterSelection; +import li.strolch.model.query.ordering.OrderById; +import li.strolch.persistence.api.StrolchTransaction; +import li.strolch.privilege.model.Certificate; +import li.strolch.runtime.StrolchConstants; +import li.strolch.testbase.runtime.RuntimeMock; +import li.strolch.utils.StringMatchMode; +import li.strolch.utils.collections.DateRange; + +public class OrderQueryTest extends QueryTest { + + private static RuntimeMock runtimeMock; + + private static Date past; + private static Date earlier; + private static Date current; + private static Date later; + private static Date future; + + @BeforeClass + public static void beforeClass() throws Exception { + + dropSchema(DB_URL, DB_USERNAME, DB_PASSWORD); + + File rootPath = new File(RUNTIME_PATH); + File configSrc = new File(CONFIG_SRC); + runtimeMock = new RuntimeMock(); + runtimeMock.mockRuntime(rootPath, configSrc); + new File(rootPath, DB_STORE_PATH_DIR).mkdir(); + runtimeMock.startContainer(); + + Calendar cal = Calendar.getInstance(); + cal.clear(); + cal.set(2000, 1, 1); + past = cal.getTime(); + cal.set(2000, 4, 1); + earlier = cal.getTime(); + cal.set(2000, 6, 1); + current = cal.getTime(); + cal.set(2000, 8, 1); + later = cal.getTime(); + cal.set(2000, 11, 1); + future = cal.getTime(); + + Certificate cert = runtimeMock.getPrivilegeHandler().authenticate("test", "test".getBytes()); + StrolchRealm realm = runtimeMock.getRealm(StrolchConstants.DEFAULT_REALM); + try (StrolchTransaction tx = realm.openTx(cert, "test")) { + OrderMap orderMap = tx.getOrderMap(); + + orderMap.add(tx, ModelGenerator.createOrder("@1", "Order 1", "MyType1", earlier, State.CREATED)); + orderMap.add(tx, ModelGenerator.createOrder("@2", "Order 2", "MyType1", current, State.EXECUTION)); + orderMap.add(tx, ModelGenerator.createOrder("@3", "Order 3", "MyType1", later, State.CLOSED)); + orderMap.add(tx, ModelGenerator.createOrder("@4", "Order 4", "MyType2", earlier, State.CREATED)); + orderMap.add(tx, ModelGenerator.createOrder("@5", "Order 5", "MyType2", current, State.CLOSED)); + orderMap.add(tx, ModelGenerator.createOrder("@6", "Order 6", "MyType2", later, State.CLOSED)); + + tx.commitOnClose(); + } + } + + @AfterClass + public static void afterClass() { + if (runtimeMock != null) + runtimeMock.destroyRuntime(); + } + + public Connection openConn() throws SQLException { + String url = "jdbc:postgresql://localhost/testdb"; + String username = "testuser"; + String password = "test"; + Connection connection = DriverManager.getConnection(url, username, password); + connection.setAutoCommit(false); + return connection; + } + + @Test + public void shouldQueryOrderAll() throws SQLException { + + OrderQuery query = OrderQuery.query("MyType1", new OrderById()); + query.withAny(); + performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryOrderByDate() throws SQLException { + + // range + OrderQuery query = OrderQuery.query("MyType1", new OrderById()); + query.and().with(new DateSelection().from(earlier, false).to(later, false)); + performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); + + // equals current + query = OrderQuery.query("MyType1"); + query.and().with(new DateSelection().from(current, false).to(current, false)); + performOrderQuery(query, Arrays.asList("@2")); + + // equals later + query = OrderQuery.query("MyType1"); + query.and().with(new DateSelection().from(later, false).to(later, false)); + performOrderQuery(query, Arrays. asList("@3")); + + // equals earlier + query = OrderQuery.query("MyType1"); + query.and().with(new DateSelection().from(earlier, false).to(earlier, false)); + performOrderQuery(query, Arrays. asList("@1")); + + // past + query = OrderQuery.query("MyType1"); + query.and().with(new DateSelection().to(past, false)); + performOrderQuery(query, Arrays. asList()); + + // future + query = OrderQuery.query("MyType1"); + query.and().with(new DateSelection().from(future, false)); + performOrderQuery(query, Arrays. asList()); + + // earlier + query = OrderQuery.query("MyType1"); + query.and().with(new DateSelection().from(past, false).to(earlier, true)); + performOrderQuery(query, Arrays. asList("@1")); + + // later + query = OrderQuery.query("MyType1"); + query.and().with(new DateSelection().from(later, false).to(future, true)); + performOrderQuery(query, Arrays. asList("@3")); + } + + @Test + public void shouldQueryOrderByState() throws SQLException { + + OrderQuery query = OrderQuery.query("MyType1"); + query.and().with(new OrderStateSelection(State.CREATED)); + performOrderQuery(query, Arrays.asList("@1")); + + query = OrderQuery.query("MyType1"); + query.and().with(new OrderStateSelection(State.EXECUTION)); + performOrderQuery(query, Arrays. asList("@2")); + } + + @Test + public void shouldQueryOrder1() throws SQLException { + + OrderQuery query = OrderQuery.query("MyType1", new OrderById()); + query.and().with(new IdSelection("@1", "@2"), + new NameSelection("Order 1", StringMatchMode.EQUALS_CASE_SENSITIVE)); + performOrderQuery(query, Arrays.asList("@1")); + } + + @Test + public void shouldQueryOrder2() throws SQLException { + + OrderQuery query = OrderQuery.query("MyType1", new OrderById()); + query.or().with(new IdSelection("@1", "@2"), + new NameSelection("order 1", StringMatchMode.EQUALS_CASE_SENSITIVE)); + performOrderQuery(query, Arrays.asList("@1", "@2")); + } + + @Test + public void shouldQueryOrderByBooleParam() throws SQLException { + OrderQuery query = OrderQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.booleanSelection("@bag01", "@param1", true)); + performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryOrderByFloatParam() throws SQLException { + OrderQuery query = OrderQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.floatSelection("@bag01", "@param2", 44.3)); + performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryOrderByIntegerParam() throws SQLException { + OrderQuery query = OrderQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.integerSelection("@bag01", "@param3", 77)); + performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryOrderByLongParam() throws SQLException { + OrderQuery query = OrderQuery.query("MyType2", new OrderById()); + query.and().with(ParameterSelection.longSelection("@bag01", "@param4", 4453234566L)); + performOrderQuery(query, Arrays.asList("@4", "@5", "@6")); + } + + @Test + public void shouldQueryOrderByStringParam() throws SQLException { + + List expected = Arrays.asList("@1", "@2", "@3"); + + OrderQuery query = OrderQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "Strolch", + StringMatchMode.EQUALS_CASE_SENSITIVE)); + performOrderQuery(query, expected); + + query = OrderQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "strolch", + StringMatchMode.EQUALS_CASE_SENSITIVE)); + performOrderQuery(query, Arrays. asList()); + + query = OrderQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "strolch", + StringMatchMode.EQUALS_CASE_INSENSITIVE)); + performOrderQuery(query, expected); + + query = OrderQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "olch", + StringMatchMode.CONTAINS_CASE_INSENSITIVE)); + performOrderQuery(query, expected); + } + + @Test + public void shouldQueryOrderByDateParam() throws SQLException { + OrderQuery query = OrderQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.dateSelection("@bag01", "@param6", new Date(1354295525628L))); + performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Ignore("Not yet implemented") + @Test + public void shouldQueryOrderByDateRange() throws SQLException { + OrderQuery query = OrderQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.dateRangeSelection("@bag01", "@param6", + new DateRange().from(new Date(1354295525627L), false).to(new Date(1354295525629L), false))); + performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryOrderByDurationParam() throws SQLException { + OrderQuery query = OrderQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.durationSelection("@bag01", "@param8", "P1D")); + performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryOrderByNullParam1() throws SQLException { + OrderQuery query = OrderQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.nullSelection("@bag01", "@param6")); + performOrderQuery(query, Arrays. asList()); + } + + @Test + public void shouldQueryOrderByNullParam2() throws SQLException { + OrderQuery query = OrderQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.nullSelection("@bag01", "@param")); + performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryOrderByBag() throws SQLException { + OrderQuery query = OrderQuery.query("MyType1", new OrderById()); + query.and().with(new ParameterBagSelection("@bag01")); + performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryOrderByNullBag() throws SQLException { + OrderQuery query = OrderQuery.query("MyType1", new OrderById()); + query.and().with(new NullParameterBagSelection("@bag01")); + performOrderQuery(query, Arrays. asList()); + } +} diff --git a/li.strolch.persistence.postgresql/src/test/java/li/strolch/persistence/postgresql/dao/test/QueryTest.java b/li.strolch.persistence.postgresql/src/test/java/li/strolch/persistence/postgresql/dao/test/QueryTest.java index 405223923..962507c04 100644 --- a/li.strolch.persistence.postgresql/src/test/java/li/strolch/persistence/postgresql/dao/test/QueryTest.java +++ b/li.strolch.persistence.postgresql/src/test/java/li/strolch/persistence/postgresql/dao/test/QueryTest.java @@ -15,133 +15,38 @@ */ package li.strolch.persistence.postgresql.dao.test; -import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.CONFIG_SRC; -import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.DB_PASSWORD; -import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.DB_STORE_PATH_DIR; -import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.DB_URL; -import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.DB_USERNAME; -import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.RUNTIME_PATH; -import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.dropSchema; import static org.junit.Assert.assertEquals; -import java.io.File; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.ArrayList; -import java.util.Arrays; -import java.util.Calendar; -import java.util.Date; import java.util.List; -import org.junit.AfterClass; -import org.junit.BeforeClass; -import org.junit.Ignore; -import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import li.strolch.agent.api.OrderMap; -import li.strolch.agent.api.ResourceMap; -import li.strolch.agent.api.StrolchRealm; -import li.strolch.model.ModelGenerator; import li.strolch.model.Order; import li.strolch.model.Resource; -import li.strolch.model.State; -import li.strolch.model.query.DateSelection; -import li.strolch.model.query.IdSelection; -import li.strolch.model.query.NameSelection; -import li.strolch.model.query.OrSelection; +import li.strolch.model.activity.Activity; +import li.strolch.model.query.ActivityQuery; import li.strolch.model.query.OrderQuery; -import li.strolch.model.query.ParameterBagSelection; -import li.strolch.model.query.ParameterBagSelection.NullParameterBagSelection; -import li.strolch.model.query.ParameterSelection; import li.strolch.model.query.ResourceQuery; -import li.strolch.model.query.StateSelection; -import li.strolch.model.query.ordering.OrderById; -import li.strolch.persistence.api.StrolchTransaction; +import li.strolch.persistence.postgresql.PostgreSqlActivityQueryVisitor; import li.strolch.persistence.postgresql.PostgreSqlOrderQueryVisitor; import li.strolch.persistence.postgresql.PostgreSqlQueryVisitor; import li.strolch.persistence.postgresql.PostgreSqlResourceQueryVisitor; -import li.strolch.privilege.model.Certificate; -import li.strolch.runtime.StrolchConstants; -import li.strolch.testbase.runtime.RuntimeMock; -import li.strolch.utils.StringMatchMode; -import li.strolch.utils.collections.DateRange; -import li.strolch.utils.iso8601.ISO8601FormatFactory; /** * @author Robert von Burg */ public class QueryTest { - private static final Logger logger = LoggerFactory.getLogger(QueryTest.class); - private static RuntimeMock runtimeMock; + protected static final Logger logger = LoggerFactory.getLogger(QueryTest.class); - private static Date past; - private static Date earlier; - private static Date current; - private static Date later; - private static Date future; - - @BeforeClass - public static void beforeClass() throws Exception { - - dropSchema(DB_URL, DB_USERNAME, DB_PASSWORD); - - File rootPath = new File(RUNTIME_PATH); - File configSrc = new File(CONFIG_SRC); - runtimeMock = new RuntimeMock(); - runtimeMock.mockRuntime(rootPath, configSrc); - new File(rootPath, DB_STORE_PATH_DIR).mkdir(); - runtimeMock.startContainer(); - - Calendar cal = Calendar.getInstance(); - cal.clear(); - cal.set(2000, 1, 1); - past = cal.getTime(); - cal.set(2000, 4, 1); - earlier = cal.getTime(); - cal.set(2000, 6, 1); - current = cal.getTime(); - cal.set(2000, 8, 1); - later = cal.getTime(); - cal.set(2000, 11, 1); - future = cal.getTime(); - - Certificate cert = runtimeMock.getPrivilegeHandler().authenticate("test", "test".getBytes()); - StrolchRealm realm = runtimeMock.getRealm(StrolchConstants.DEFAULT_REALM); - try (StrolchTransaction tx = realm.openTx(cert, "test")) { - OrderMap orderMap = tx.getOrderMap(); - - orderMap.add(tx, ModelGenerator.createOrder("@1", "Order 1", "MyType1", earlier, State.CREATED)); - orderMap.add(tx, ModelGenerator.createOrder("@2", "Order 2", "MyType1", current, State.EXECUTION)); - orderMap.add(tx, ModelGenerator.createOrder("@3", "Order 3", "MyType1", later, State.CLOSED)); - orderMap.add(tx, ModelGenerator.createOrder("@4", "Order 4", "MyType2", earlier, State.CREATED)); - orderMap.add(tx, ModelGenerator.createOrder("@5", "Order 5", "MyType2", current, State.CLOSED)); - orderMap.add(tx, ModelGenerator.createOrder("@6", "Order 6", "MyType2", later, State.CLOSED)); - - ResourceMap resourceMap = tx.getResourceMap(); - resourceMap.add(tx, ModelGenerator.createResource("@1", "Resource 1", "MyType1")); - resourceMap.add(tx, ModelGenerator.createResource("@2", "Resource 2", "MyType1")); - resourceMap.add(tx, ModelGenerator.createResource("@3", "Resource 3", "MyType1")); - resourceMap.add(tx, ModelGenerator.createResource("@4", "Resource 4", "MyType2")); - resourceMap.add(tx, ModelGenerator.createResource("@5", "Resource 5", "MyType2")); - resourceMap.add(tx, ModelGenerator.createResource("@6", "Resource 6", "MyType2")); - - tx.commitOnClose(); - } - } - - @AfterClass - public static void afterClass() { - if (runtimeMock != null) - runtimeMock.destroyRuntime(); - } - - public Connection openConn() throws SQLException { + protected Connection openConn() throws SQLException { String url = "jdbc:postgresql://localhost/testdb"; String username = "testuser"; String password = "test"; @@ -150,355 +55,21 @@ public class QueryTest { return connection; } - @Test - public void shouldQueryOrderAll() throws SQLException { - - OrderQuery query = OrderQuery.query("MyType1", new OrderById()); - query.withAny(); - performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Test - public void shouldQueryResourceAll() throws SQLException { - - ResourceQuery query = ResourceQuery.query("MyType2", new OrderById(false)); - query.withAny(); - performResourceQuery(query, Arrays.asList("@6", "@5", "@4")); - } - - @Test - public void shouldQueryOrderByDate() throws SQLException { - - // range - OrderQuery query = OrderQuery.query("MyType1", new OrderById()); - query.and().with(new DateSelection().from(earlier, false).to(later, false)); - performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); - - // equals current - query = OrderQuery.query("MyType1"); - query.and().with(new DateSelection().from(current, false).to(current, false)); - performOrderQuery(query, Arrays.asList("@2")); - - // equals later - query = OrderQuery.query("MyType1"); - query.and().with(new DateSelection().from(later, false).to(later, false)); - performOrderQuery(query, Arrays. asList("@3")); - - // equals earlier - query = OrderQuery.query("MyType1"); - query.and().with(new DateSelection().from(earlier, false).to(earlier, false)); - performOrderQuery(query, Arrays. asList("@1")); - - // past - query = OrderQuery.query("MyType1"); - query.and().with(new DateSelection().to(past, false)); - performOrderQuery(query, Arrays. asList()); - - // future - query = OrderQuery.query("MyType1"); - query.and().with(new DateSelection().from(future, false)); - performOrderQuery(query, Arrays. asList()); - - // earlier - query = OrderQuery.query("MyType1"); - query.and().with(new DateSelection().from(past, false).to(earlier, true)); - performOrderQuery(query, Arrays. asList("@1")); - - // later - query = OrderQuery.query("MyType1"); - query.and().with(new DateSelection().from(later, false).to(future, true)); - performOrderQuery(query, Arrays. asList("@3")); - } - - @Test - public void shouldQueryOrderByState() throws SQLException { - - OrderQuery query = OrderQuery.query("MyType1"); - query.and().with(new StateSelection(State.CREATED)); - performOrderQuery(query, Arrays.asList("@1")); - - query = OrderQuery.query("MyType1"); - query.and().with(new StateSelection(State.EXECUTION)); - performOrderQuery(query, Arrays. asList("@2")); - } - - @Test - public void shouldQueryOrder1() throws SQLException { - - OrderQuery query = OrderQuery.query("MyType1", new OrderById()); - query.and().with(new IdSelection("@1", "@2"), - new NameSelection("Order 1", StringMatchMode.EQUALS_CASE_SENSITIVE)); - performOrderQuery(query, Arrays.asList("@1")); - } - - @Test - public void shouldQueryOrder2() throws SQLException { - - OrderQuery query = OrderQuery.query("MyType1", new OrderById()); - query.or().with(new IdSelection("@1", "@2"), - new NameSelection("order 1", StringMatchMode.EQUALS_CASE_SENSITIVE)); - performOrderQuery(query, Arrays.asList("@1", "@2")); - } - - @Test - public void shouldQueryOrderByBooleParam() throws SQLException { - OrderQuery query = OrderQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.booleanSelection("@bag01", "@param1", true)); - performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Test - public void shouldQueryOrderByFloagParam() throws SQLException { - OrderQuery query = OrderQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.floatSelection("@bag01", "@param2", 44.3)); - performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Test - public void shouldQueryOrderByIntegerParam() throws SQLException { - OrderQuery query = OrderQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.integerSelection("@bag01", "@param3", 77)); - performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Test - public void shouldQueryOrderByLongParam() throws SQLException { - OrderQuery query = OrderQuery.query("MyType2", new OrderById()); - query.and().with(ParameterSelection.longSelection("@bag01", "@param4", 4453234566L)); - performOrderQuery(query, Arrays.asList("@4", "@5", "@6")); - } - - @Test - public void shouldQueryOrderByStringParam() throws SQLException { - - List expected = Arrays.asList("@1", "@2", "@3"); - - OrderQuery query = OrderQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "Strolch", - StringMatchMode.EQUALS_CASE_SENSITIVE)); - performOrderQuery(query, expected); - - query = OrderQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "strolch", - StringMatchMode.EQUALS_CASE_SENSITIVE)); - performOrderQuery(query, Arrays. asList()); - - query = OrderQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "strolch", - StringMatchMode.EQUALS_CASE_INSENSITIVE)); - performOrderQuery(query, expected); - - query = OrderQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "olch", - StringMatchMode.CONTAINS_CASE_INSENSITIVE)); - performOrderQuery(query, expected); - } - - @Test - public void shouldQueryOrderByDateParam() throws SQLException { - OrderQuery query = OrderQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.dateSelection("@bag01", "@param6", new Date(1354295525628L))); - performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Ignore("Not yet implemented") - @Test - public void shouldQueryOrderByDateRange() throws SQLException { - OrderQuery query = OrderQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.dateRangeSelection("@bag01", "@param6", - new DateRange().from(new Date(1354295525627L), false).to(new Date(1354295525629L), false))); - performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Test - public void shouldQueryOrderByDurationParam() throws SQLException { - OrderQuery query = OrderQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.durationSelection("@bag01", "@param8", "P1D")); - performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Test - public void shouldQueryOrderByNullParam1() throws SQLException { - OrderQuery query = OrderQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.nullSelection("@bag01", "@param6")); - performOrderQuery(query, Arrays. asList()); - } - - @Test - public void shouldQueryOrderByNullParam2() throws SQLException { - OrderQuery query = OrderQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.nullSelection("@bag01", "@param")); - performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Test - public void shouldQueryOrderByBag() throws SQLException { - OrderQuery query = OrderQuery.query("MyType1", new OrderById()); - query.and().with(new ParameterBagSelection("@bag01")); - performOrderQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Test - public void shouldQueryOrderByNullBag() throws SQLException { - OrderQuery query = OrderQuery.query("MyType1", new OrderById()); - query.and().with(new NullParameterBagSelection("@bag01")); - performOrderQuery(query, Arrays. asList()); - } - - @Test - public void shouldQueryResource1() throws SQLException { - - ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); - query.or().with(new IdSelection("@1", "@2"), - new NameSelection("Resource 1", StringMatchMode.EQUALS_CASE_SENSITIVE)); - performResourceQuery(query, Arrays.asList("@1", "@2")); - } - - @Test - public void shouldQueryResource2() throws SQLException { - ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(new OrSelection(new IdSelection("@1"), new IdSelection("@2")), - new OrSelection(new NameSelection("Resource 1", StringMatchMode.EQUALS_CASE_SENSITIVE), - new NameSelection("Resource 2", StringMatchMode.EQUALS_CASE_SENSITIVE))); - performResourceQuery(query, Arrays.asList("@1", "@2")); - } - - @Test - public void shouldQueryResourceByBooleParam() throws SQLException { - ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.booleanSelection("@bag01", "@param1", true)); - performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Test - public void shouldQueryResourceByFloagParam() throws SQLException { - ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.floatSelection("@bag01", "@param2", 44.3)); - performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Test - public void shouldQueryResourceByIntegerParam() throws SQLException { - ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.integerSelection("@bag01", "@param3", 77)); - performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Test - public void shouldQueryResourceByLongParam() throws SQLException { - ResourceQuery query = ResourceQuery.query("MyType2", new OrderById()); - query.and().with(ParameterSelection.longSelection("@bag01", "@param4", 4453234566L)); - performResourceQuery(query, Arrays.asList("@4", "@5", "@6")); - } - - @Test - public void shouldQueryResourceByStringParam() throws SQLException { - - List expected = Arrays.asList("@1", "@2", "@3"); - - ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "Strolch", - StringMatchMode.EQUALS_CASE_SENSITIVE)); - performResourceQuery(query, expected); - - query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "strolch", - StringMatchMode.EQUALS_CASE_SENSITIVE)); - performResourceQuery(query, Arrays. asList()); - - query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "strolch", - StringMatchMode.EQUALS_CASE_INSENSITIVE)); - performResourceQuery(query, expected); - - query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "olch", - StringMatchMode.CONTAINS_CASE_INSENSITIVE)); - performResourceQuery(query, expected); - - query = ResourceQuery.query("MyType1", new OrderById()); - query.and() - .with(ParameterSelection.stringSelection("@bag01", "@param5", "olch", - StringMatchMode.CONTAINS_CASE_INSENSITIVE), - ParameterSelection.stringSelection("@bag01", "@param5", "strolch", - StringMatchMode.CONTAINS_CASE_INSENSITIVE), - ParameterSelection.stringSelection("@bag01", "@param5", "Strolch", - StringMatchMode.EQUALS_CASE_SENSITIVE)); - performResourceQuery(query, expected); - } - - @Test - public void shouldQueryResourceByAnyTypeParam() throws SQLException { - - ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.anyTypeSelection("@bag01", "@param6", - ISO8601FormatFactory.getInstance().formatDate(new Date(1354295525628L)), StringMatchMode.ci())); - performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); - - query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.anyTypeSelection("@bag01", "@param8", "P1D", StringMatchMode.ci())); - performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Test - public void shouldQueryResourceByDateParam() throws SQLException { - ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.dateSelection("@bag01", "@param6", new Date(1354295525628L))); - performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Ignore("Not yet implemented") - @Test - public void shouldQueryResourceByDateRange() throws SQLException { - ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.dateRangeSelection("@bag01", "@param6", - new DateRange().from(new Date(1354295525627L), false).to(new Date(1354295525629L), false))); - performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Test - public void shouldQueryResourceByDurationParam() throws SQLException { - ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.durationSelection("@bag01", "@param8", "P1D")); - performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Test - public void shouldQueryResourceByNullParam1() throws SQLException { - ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.nullSelection("@bag01", "@param6")); - performResourceQuery(query, Arrays. asList()); - } - - @Test - public void shouldQueryResourceByNullParam2() throws SQLException { - ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(ParameterSelection.nullSelection("@bag01", "@param")); - performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Test - public void shouldQueryResourceByBag() throws SQLException { - ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(new ParameterBagSelection("@bag01")); - performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); - } - - @Test - public void shouldQueryResourceByNullBag() throws SQLException { - ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); - query.and().with(new NullParameterBagSelection("@bag01")); - performResourceQuery(query, Arrays. asList()); - } - - private void performOrderQuery(OrderQuery query, List expected) throws SQLException { + protected void performOrderQuery(OrderQuery query, List expected) throws SQLException { PostgreSqlOrderQueryVisitor visitor = new PostgreSqlOrderQueryVisitor("id"); query.accept(visitor); List ids = queryIds(visitor); assertEquals(expected, ids); } - private void performResourceQuery(ResourceQuery query, List expected) throws SQLException { + protected void performActivityQuery(ActivityQuery query, List expected) throws SQLException { + PostgreSqlActivityQueryVisitor visitor = new PostgreSqlActivityQueryVisitor("id"); + query.accept(visitor); + List ids = queryIds(visitor); + assertEquals(expected, ids); + } + + protected void performResourceQuery(ResourceQuery query, List expected) throws SQLException { PostgreSqlResourceQueryVisitor visitor = new PostgreSqlResourceQueryVisitor("id"); query.accept(visitor); List ids = queryIds(visitor); diff --git a/li.strolch.persistence.postgresql/src/test/java/li/strolch/persistence/postgresql/dao/test/ResourceDaoTest.java b/li.strolch.persistence.postgresql/src/test/java/li/strolch/persistence/postgresql/dao/test/ResourceDaoTest.java new file mode 100644 index 000000000..c284bd437 --- /dev/null +++ b/li.strolch.persistence.postgresql/src/test/java/li/strolch/persistence/postgresql/dao/test/ResourceDaoTest.java @@ -0,0 +1,234 @@ +package li.strolch.persistence.postgresql.dao.test; + +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.CONFIG_SRC; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.DB_PASSWORD; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.DB_STORE_PATH_DIR; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.DB_URL; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.DB_USERNAME; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.RUNTIME_PATH; +import static li.strolch.persistence.postgresql.dao.test.CachedDaoTest.dropSchema; + +import java.io.File; +import java.sql.SQLException; +import java.util.Arrays; +import java.util.Date; +import java.util.List; + +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; + +import li.strolch.agent.api.ResourceMap; +import li.strolch.agent.api.StrolchRealm; +import li.strolch.model.ModelGenerator; +import li.strolch.model.Resource; +import li.strolch.model.query.IdSelection; +import li.strolch.model.query.NameSelection; +import li.strolch.model.query.OrSelection; +import li.strolch.model.query.ParameterBagSelection; +import li.strolch.model.query.ParameterBagSelection.NullParameterBagSelection; +import li.strolch.model.query.ParameterSelection; +import li.strolch.model.query.ResourceQuery; +import li.strolch.model.query.ordering.OrderById; +import li.strolch.persistence.api.StrolchTransaction; +import li.strolch.privilege.model.Certificate; +import li.strolch.runtime.StrolchConstants; +import li.strolch.testbase.runtime.RuntimeMock; +import li.strolch.utils.StringMatchMode; +import li.strolch.utils.collections.DateRange; +import li.strolch.utils.iso8601.ISO8601FormatFactory; + +public class ResourceDaoTest extends QueryTest { + + private static RuntimeMock runtimeMock; + + @BeforeClass + public static void beforeClass() throws Exception { + + dropSchema(DB_URL, DB_USERNAME, DB_PASSWORD); + + File rootPath = new File(RUNTIME_PATH); + File configSrc = new File(CONFIG_SRC); + runtimeMock = new RuntimeMock(); + runtimeMock.mockRuntime(rootPath, configSrc); + new File(rootPath, DB_STORE_PATH_DIR).mkdir(); + runtimeMock.startContainer(); + + Certificate cert = runtimeMock.getPrivilegeHandler().authenticate("test", "test".getBytes()); + StrolchRealm realm = runtimeMock.getRealm(StrolchConstants.DEFAULT_REALM); + try (StrolchTransaction tx = realm.openTx(cert, "test")) { + + ResourceMap resourceMap = tx.getResourceMap(); + resourceMap.add(tx, ModelGenerator.createResource("@1", "Resource 1", "MyType1")); + resourceMap.add(tx, ModelGenerator.createResource("@2", "Resource 2", "MyType1")); + resourceMap.add(tx, ModelGenerator.createResource("@3", "Resource 3", "MyType1")); + resourceMap.add(tx, ModelGenerator.createResource("@4", "Resource 4", "MyType2")); + resourceMap.add(tx, ModelGenerator.createResource("@5", "Resource 5", "MyType2")); + resourceMap.add(tx, ModelGenerator.createResource("@6", "Resource 6", "MyType2")); + + tx.commitOnClose(); + } + } + + @AfterClass + public static void afterClass() { + if (runtimeMock != null) + runtimeMock.destroyRuntime(); + } + + @Test + public void shouldQueryResourceAll() throws SQLException { + + ResourceQuery query = ResourceQuery.query("MyType2", new OrderById(false)); + query.withAny(); + performResourceQuery(query, Arrays.asList("@6", "@5", "@4")); + } + + @Test + public void shouldQueryResource1() throws SQLException { + + ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); + query.or().with(new IdSelection("@1", "@2"), + new NameSelection("Resource 1", StringMatchMode.EQUALS_CASE_SENSITIVE)); + performResourceQuery(query, Arrays.asList("@1", "@2")); + } + + @Test + public void shouldQueryResource2() throws SQLException { + ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(new OrSelection(new IdSelection("@1"), new IdSelection("@2")), + new OrSelection(new NameSelection("Resource 1", StringMatchMode.EQUALS_CASE_SENSITIVE), + new NameSelection("Resource 2", StringMatchMode.EQUALS_CASE_SENSITIVE))); + performResourceQuery(query, Arrays.asList("@1", "@2")); + } + + @Test + public void shouldQueryResourceByBooleParam() throws SQLException { + ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.booleanSelection("@bag01", "@param1", true)); + performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryResourceByFloatParam() throws SQLException { + ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.floatSelection("@bag01", "@param2", 44.3)); + performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryResourceByIntegerParam() throws SQLException { + ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.integerSelection("@bag01", "@param3", 77)); + performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryResourceByLongParam() throws SQLException { + ResourceQuery query = ResourceQuery.query("MyType2", new OrderById()); + query.and().with(ParameterSelection.longSelection("@bag01", "@param4", 4453234566L)); + performResourceQuery(query, Arrays.asList("@4", "@5", "@6")); + } + + @Test + public void shouldQueryResourceByStringParam() throws SQLException { + + List expected = Arrays.asList("@1", "@2", "@3"); + + ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "Strolch", + StringMatchMode.EQUALS_CASE_SENSITIVE)); + performResourceQuery(query, expected); + + query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "strolch", + StringMatchMode.EQUALS_CASE_SENSITIVE)); + performResourceQuery(query, Arrays. asList()); + + query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "strolch", + StringMatchMode.EQUALS_CASE_INSENSITIVE)); + performResourceQuery(query, expected); + + query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.stringSelection("@bag01", "@param5", "olch", + StringMatchMode.CONTAINS_CASE_INSENSITIVE)); + performResourceQuery(query, expected); + + query = ResourceQuery.query("MyType1", new OrderById()); + query.and() + .with(ParameterSelection.stringSelection("@bag01", "@param5", "olch", + StringMatchMode.CONTAINS_CASE_INSENSITIVE), + ParameterSelection.stringSelection("@bag01", "@param5", "strolch", + StringMatchMode.CONTAINS_CASE_INSENSITIVE), + ParameterSelection.stringSelection("@bag01", "@param5", "Strolch", + StringMatchMode.EQUALS_CASE_SENSITIVE)); + performResourceQuery(query, expected); + } + + @Test + public void shouldQueryResourceByAnyTypeParam() throws SQLException { + + ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.anyTypeSelection("@bag01", "@param6", + ISO8601FormatFactory.getInstance().formatDate(new Date(1354295525628L)), StringMatchMode.ci())); + performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); + + query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.anyTypeSelection("@bag01", "@param8", "P1D", StringMatchMode.ci())); + performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryResourceByDateParam() throws SQLException { + ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.dateSelection("@bag01", "@param6", new Date(1354295525628L))); + performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Ignore("Not yet implemented") + @Test + public void shouldQueryResourceByDateRange() throws SQLException { + ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.dateRangeSelection("@bag01", "@param6", + new DateRange().from(new Date(1354295525627L), false).to(new Date(1354295525629L), false))); + performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryResourceByDurationParam() throws SQLException { + ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.durationSelection("@bag01", "@param8", "P1D")); + performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryResourceByNullParam1() throws SQLException { + ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.nullSelection("@bag01", "@param6")); + performResourceQuery(query, Arrays. asList()); + } + + @Test + public void shouldQueryResourceByNullParam2() throws SQLException { + ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(ParameterSelection.nullSelection("@bag01", "@param")); + performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryResourceByBag() throws SQLException { + ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(new ParameterBagSelection("@bag01")); + performResourceQuery(query, Arrays.asList("@1", "@2", "@3")); + } + + @Test + public void shouldQueryResourceByNullBag() throws SQLException { + ResourceQuery query = ResourceQuery.query("MyType1", new OrderById()); + query.and().with(new NullParameterBagSelection("@bag01")); + performResourceQuery(query, Arrays. asList()); + } + +}