nosu
/
taskana
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

TSK-235 sort workbasket query results case insensitive

This commit is contained in:
BerndBreier 2018-02-07 13:18:25 +01:00 committed by Holger Hagen
parent 43d4e9eafd
commit f6b9524bfe
13 changed files with 228 additions and 340 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/taskana-cdi/src/test/java/pro/taskana/TaskanaProducersTest.java
View File

@ -57,7 +57,7 @@ public class TaskanaProducersTest {
Class.forName("org.h2.Driver");
int resultCount = 0;
try (Connection conn = DriverManager.getConnection("jdbc:h2:~/data/testdb;AUTO_SERVER=TRUE", "SA", "SA")) {
try (Connection conn = DriverManager.getConnection("jdbc:h2:~/data/testdb;AUTO_SERVER=TRUE;IGNORECASE=TRUE", "SA", "SA")) {
ResultSet rs = conn.createStatement().executeQuery("SELECT ID, OWNER FROM TASK");
while (rs.next()) {
@ -74,7 +74,7 @@ public class TaskanaProducersTest {
Class.forName("org.h2.Driver");
int resultCount = 0;
try (Connection conn = DriverManager.getConnection("jdbc:h2:~/data/testdb;AUTO_SERVER=TRUE", "SA", "SA")) {
try (Connection conn = DriverManager.getConnection("jdbc:h2:~/data/testdb;AUTO_SERVER=TRUE;IGNORECASE=TRUE", "SA", "SA")) {
ResultSet rs = conn.createStatement().executeQuery("SELECT ID, OWNER FROM TASK");
while (rs.next()) {

37
lib/taskana-core/src/main/java/pro/taskana/WorkbasketQuery.java
View File

@ -3,7 +3,6 @@ package pro.taskana;
import java.time.Instant;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.InvalidRequestException;
import pro.taskana.model.WorkbasketAuthorization;
import pro.taskana.model.WorkbasketType;
@ -171,41 +170,21 @@ public interface WorkbasketQuery extends BaseQuery<WorkbasketSummary> {
/**
* Sort the query result by name.
*
* @param sortDirection
* Determines whether the result is sorted in ascending or descending order. If sortDirection is null,
* the result is sorted in ascending order
* @return the query
* @throws InvalidArgumentException
* when orderByName() has already been called.
* @throws InvalidRequestException
* when orderByName() has already been called.
*/
WorkbasketQuery orderByName() throws InvalidArgumentException, InvalidRequestException;
WorkbasketQuery orderByName(SortDirection sortDirection);
/**
* Sort the query result by key.
*
* @param sortDirection
* Determines whether the result is sorted in ascending or descending order. If sortDirection is null,
* the result is sorted in ascending order
* @return the query
* @throws InvalidRequestException
* when orderByKey() has already been called.
*/
WorkbasketQuery orderByKey() throws InvalidRequestException;
/**
* Sort the query result in ascending order.
*
* @return the query
* @throws InvalidRequestException
* when neither orderByKey() nor orderByName has already been called previously or when ascending() or
* descending() has been called immediately before this call
*/
WorkbasketQuery ascending() throws InvalidRequestException;
/**
* Sort the query result in descending order.
*
* @return the query
* @throws InvalidRequestException
* when neither orderByKey() nor orderByName has already been called previously or when ascending() or
* descending() has been called immediately before this call
*/
WorkbasketQuery descending() throws InvalidRequestException;
WorkbasketQuery orderByKey(SortDirection sortDirection);
}

4
lib/taskana-core/src/main/java/pro/taskana/configuration/TaskanaEngineConfiguration.java
View File

@ -20,7 +20,7 @@ public class TaskanaEngineConfiguration {
private static final String USER_NAME = "sa";
private static final String USER_PASSWORD = "sa";
private static final String JDBC_H2_MEM_TASKANA = "jdbc:h2:mem:taskana";
private static final String JDBC_H2_MEM_TASKANA = "jdbc:h2:mem:taskana;IGNORECASE=TRUE";
private static final String H2_DRIVER = "org.h2.Driver";
protected DataSource dataSource;
protected DbSchemaCreator dbScriptRunner;
@ -56,7 +56,7 @@ public class TaskanaEngineConfiguration {
public static DataSource createDefaultDataSource() {
LOGGER.warn("No datasource is provided. A inmemory db is used: "
+ "'org.h2.Driver', 'jdbc:h2:mem:taskana', 'sa', 'sa'");
+ "'org.h2.Driver', 'jdbc:h2:mem:taskana;IGNORECASE=TRUE', 'sa', 'sa'");
return createDatasource(H2_DRIVER, JDBC_H2_MEM_TASKANA, USER_NAME, USER_PASSWORD);
}

68
lib/taskana-core/src/main/java/pro/taskana/impl/TaskQueryImpl.java
View File

@ -458,169 +458,165 @@ public class TaskQueryImpl implements TaskQuery {
@Override
public TaskQuery orderByClassificationKey(SortDirection sortDirection) {
return addOrderCriteria("CLASSIFICATION_KEY", true, sortDirection);
return addOrderCriteria("CLASSIFICATION_KEY", sortDirection);
}
@Override
public TaskQuery orderByDomain(SortDirection sortDirection) {
return addOrderCriteria("DOMAIN", true, sortDirection);
return addOrderCriteria("DOMAIN", sortDirection);
}
@Override
public TaskQuery orderByPlanned(SortDirection sortDirection) {
return addOrderCriteria("PLANNED", false, sortDirection);
return addOrderCriteria("PLANNED", sortDirection);
}
@Override
public TaskQuery orderByDue(SortDirection sortDirection) {
return addOrderCriteria("DUE", false, sortDirection);
return addOrderCriteria("DUE", sortDirection);
}
@Override
public TaskQuery orderByModified(SortDirection sortDirection) {
return addOrderCriteria("MODIFIED", false, sortDirection);
return addOrderCriteria("MODIFIED", sortDirection);
}
@Override
public TaskQuery orderByName(SortDirection sortDirection) {
return addOrderCriteria("NAME", true, sortDirection);
return addOrderCriteria("NAME", sortDirection);
}
@Override
public TaskQuery orderByOwner(SortDirection sortDirection) {
return addOrderCriteria("OWNER", true, sortDirection);
return addOrderCriteria("OWNER", sortDirection);
}
@Override
public TaskQuery orderByPrimaryObjectReferenceCompany(SortDirection sortDirection) {
return addOrderCriteria("POR_COMPANY", true, sortDirection);
return addOrderCriteria("POR_COMPANY", sortDirection);
}
@Override
public TaskQuery orderByPrimaryObjectReferenceSystem(SortDirection sortDirection) {
return addOrderCriteria("POR_SYSTEM", true, sortDirection);
return addOrderCriteria("POR_SYSTEM", sortDirection);
}
@Override
public TaskQuery orderByPrimaryObjectReferenceSystemInstance(SortDirection sortDirection) {
return addOrderCriteria("POR_INSTANCE", true, sortDirection);
return addOrderCriteria("POR_INSTANCE", sortDirection);
}
@Override
public TaskQuery orderByPrimaryObjectReferenceType(SortDirection sortDirection) {
return addOrderCriteria("POR_TYPE", true, sortDirection);
return addOrderCriteria("POR_TYPE", sortDirection);
}
@Override
public TaskQuery orderByPrimaryObjectReferenceValue(SortDirection sortDirection) {
return addOrderCriteria("POR_VALUE", true, sortDirection);
return addOrderCriteria("POR_VALUE", sortDirection);
}
@Override
public TaskQuery orderByPriority(SortDirection sortDirection) {
return addOrderCriteria("PRIORITY", false, sortDirection);
return addOrderCriteria("PRIORITY", sortDirection);
}
@Override
public TaskQuery orderByState(SortDirection sortDirection) {
return addOrderCriteria("STATE", false, sortDirection);
return addOrderCriteria("STATE", sortDirection);
}
@Override
public TaskQuery orderByWorkbasketKey(SortDirection sortDirection) {
return addOrderCriteria("WORKBASKET_KEY", true, sortDirection);
return addOrderCriteria("WORKBASKET_KEY", sortDirection);
}
@Override
public TaskQuery orderByNote(SortDirection sortDirection) {
return addOrderCriteria("NOTE", true, sortDirection);
return addOrderCriteria("NOTE", sortDirection);
}
@Override
public TaskQuery orderByCustom1(SortDirection sortDirection) {
return addOrderCriteria("CUSTOM_1", true, sortDirection);
return addOrderCriteria("CUSTOM_1", sortDirection);
}
@Override
public TaskQuery orderByCustom2(SortDirection sortDirection) {
return addOrderCriteria("CUSTOM_2", true, sortDirection);
return addOrderCriteria("CUSTOM_2", sortDirection);
}
@Override
public TaskQuery orderByCustom3(SortDirection sortDirection) {
return addOrderCriteria("CUSTOM_3", true, sortDirection);
return addOrderCriteria("CUSTOM_3", sortDirection);
}
@Override
public TaskQuery orderByCustom4(SortDirection sortDirection) {
return addOrderCriteria("CUSTOM_4", true, sortDirection);
return addOrderCriteria("CUSTOM_4", sortDirection);
}
@Override
public TaskQuery orderByCustom5(SortDirection sortDirection) {
return addOrderCriteria("CUSTOM_5", true, sortDirection);
return addOrderCriteria("CUSTOM_5", sortDirection);
}
@Override
public TaskQuery orderByCustom6(SortDirection sortDirection) {
return addOrderCriteria("CUSTOM_6", true, sortDirection);
return addOrderCriteria("CUSTOM_6", sortDirection);
}
@Override
public TaskQuery orderByCustom7(SortDirection sortDirection) {
return addOrderCriteria("CUSTOM_7", true, sortDirection);
return addOrderCriteria("CUSTOM_7", sortDirection);
}
@Override
public TaskQuery orderByCustom8(SortDirection sortDirection) {
return addOrderCriteria("CUSTOM_8", true, sortDirection);
return addOrderCriteria("CUSTOM_8", sortDirection);
}
@Override
public TaskQuery orderByCustom9(SortDirection sortDirection) {
return addOrderCriteria("CUSTOM_9", true, sortDirection);
return addOrderCriteria("CUSTOM_9", sortDirection);
}
@Override
public TaskQuery orderByCustom10(SortDirection sortDirection) {
return addOrderCriteria("CUSTOM_10", true, sortDirection);
return addOrderCriteria("CUSTOM_10", sortDirection);
}
@Override
public TaskQuery orderByBusinessProcessId(SortDirection sortDirection) {
return addOrderCriteria("BUSINESS_PROCESS_ID", true, sortDirection);
return addOrderCriteria("BUSINESS_PROCESS_ID", sortDirection);
}
@Override
public TaskQuery orderByClaimed(SortDirection sortDirection) {
return addOrderCriteria("CLAIMED", false, sortDirection);
return addOrderCriteria("CLAIMED", sortDirection);
}
@Override
public TaskQuery orderByCompleted(SortDirection sortDirection) {
return addOrderCriteria("COMPLETED", false, sortDirection);
return addOrderCriteria("COMPLETED", sortDirection);
}
@Override
public TaskQuery orderByCreated(SortDirection sortDirection) {
return addOrderCriteria("CREATED", false, sortDirection);
return addOrderCriteria("CREATED", sortDirection);
}
@Override
public TaskQuery orderByParentBusinessProcessId(SortDirection sortDirection) {
return addOrderCriteria("PARENT_BUSINESS_PROCESS_ID", true, sortDirection);
return addOrderCriteria("PARENT_BUSINESS_PROCESS_ID", sortDirection);
}
private TaskQuery addOrderCriteria(String columnName, boolean useUpper, SortDirection sortDirection) {
private TaskQuery addOrderCriteria(String columnName, SortDirection sortDirection) {
String orderByDirection = " ASC";
if (sortDirection != null && SortDirection.DESCENDING.equals(sortDirection)) {
orderByDirection = " DESC";
}
if (useUpper) {
orderBy.add("UPPER(" + columnName + ")" + orderByDirection);
} else {
orderBy.add(columnName + orderByDirection);
}
return this;
}
}

91
lib/taskana-core/src/main/java/pro/taskana/impl/WorkbasketQueryImpl.java
View File

@ -1,6 +1,7 @@
package pro.taskana.impl;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@ -14,9 +15,7 @@ import pro.taskana.WorkbasketQuery;
import pro.taskana.WorkbasketSummary;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.InvalidRequestException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.exceptions.SystemException;
import pro.taskana.exceptions.TaskanaRuntimeException;
import pro.taskana.impl.util.LoggerUtils;
import pro.taskana.model.WorkbasketAuthorization;
@ -33,12 +32,6 @@ public class WorkbasketQueryImpl implements WorkbasketQuery {
private static final String LINK_TO_MAPPER = "pro.taskana.model.mappings.QueryMapper.queryWorkbasket";
private static final String LINK_TO_COUNTER = "pro.taskana.model.mappings.QueryMapper.countQueryWorkbaskets";
private static final Logger LOGGER = LoggerFactory.getLogger(WorkbasketQueryImpl.class);
private static final String KEY_COL_NAME = "KEY";
private static final String NAME_COL_NAME = "NAME";
private static final String ASCENDING = " ASC";
private static final String DESCENDING = " DESC";
private static final String ORDER_BY = "ORDER BY ";
private String[] accessId;
private WorkbasketAuthorization authorization;
private String[] nameIn;
@ -54,12 +47,12 @@ public class WorkbasketQueryImpl implements WorkbasketQuery {
private Instant modifiedBefore;
private String descriptionLike;
private String[] owner;
private String orderClause;
private TaskanaEngineImpl taskanaEngineImpl;
private List<String> orderBy;
public WorkbasketQueryImpl(TaskanaEngine taskanaEngine) {
this.taskanaEngineImpl = (TaskanaEngineImpl) taskanaEngine;
orderClause = "";
orderBy = new ArrayList<>();
}
@Override
@ -141,70 +134,13 @@ public class WorkbasketQueryImpl implements WorkbasketQuery {
}
@Override
public WorkbasketQuery orderByName() throws InvalidRequestException {
if (orderClause.contains(NAME_COL_NAME)) {
throw new InvalidRequestException("orderByName() has already been called");
}
if (orderClause.isEmpty()) {
orderClause = ORDER_BY + NAME_COL_NAME;
} else if (orderClause.contains(ORDER_BY)) {
orderClause += ", " + NAME_COL_NAME;
} else {
throw new SystemException("orderByName() was called, but orderClause is unexpectedly: " + orderClause);
}
return this;
public WorkbasketQuery orderByName(SortDirection sortDirection) {
return addOrderCriteria("NAME", sortDirection);
}
@Override
public WorkbasketQuery orderByKey() throws InvalidRequestException {
if (orderClause.contains(KEY_COL_NAME)) {
throw new InvalidRequestException("orderByKey() has already been called");
}
if (orderClause.isEmpty()) {
orderClause = ORDER_BY + KEY_COL_NAME;
} else if (orderClause.contains(ORDER_BY)) {
orderClause += ", " + KEY_COL_NAME;
} else {
throw new SystemException("orderByKey() was called, but orderClause is unexpectedly: " + orderClause);
}
return this;
}
@Override
public WorkbasketQuery ascending() throws InvalidRequestException {
if (!orderClause.startsWith(ORDER_BY)) {
throw new InvalidRequestException(
"ascending() has been called before orderByKey() or orderByName() was called");
}
if (orderClause.endsWith(KEY_COL_NAME) || orderClause.endsWith(NAME_COL_NAME)) {
orderClause += ASCENDING;
} else if (orderClause.endsWith(ASCENDING) || orderClause.endsWith(DESCENDING)) {
throw new InvalidRequestException(
"ascending() has been called immediately after ascending() or descending()");
} else {
throw new SystemException("ascending() was called, but orderClause is unexpectedly: " + orderClause);
}
return this;
}
@Override
public WorkbasketQuery descending() throws InvalidRequestException {
if (!orderClause.startsWith(ORDER_BY)) {
throw new InvalidRequestException(
"descending() has been called before orderByKey or orderByName was called");
}
if (orderClause.endsWith(KEY_COL_NAME) || orderClause.endsWith(NAME_COL_NAME)) {
orderClause += DESCENDING;
} else if (orderClause.endsWith(ASCENDING) || orderClause.endsWith(DESCENDING)) {
throw new InvalidRequestException(
"descending() has been called immediately after ascending() or descending()");
} else {
throw new SystemException("descending() was called, but orderClause is unexpectedly: " + orderClause);
}
return this;
public WorkbasketQuery orderByKey(SortDirection sortDirection) {
return addOrderCriteria("KEY", sortDirection);
}
@Override
@ -370,8 +306,8 @@ public class WorkbasketQueryImpl implements WorkbasketQuery {
return owner;
}
public String getOrderClause() {
return orderClause;
public List<String> getOrderBy() {
return orderBy;
}
@Override
@ -446,4 +382,13 @@ public class WorkbasketQueryImpl implements WorkbasketQuery {
return target;
}
private WorkbasketQuery addOrderCriteria(String colName, SortDirection sortDirection) {
String orderByDirection = " ASC";
if (sortDirection != null && SortDirection.DESCENDING.equals(sortDirection)) {
orderByDirection = " DESC";
}
orderBy.add(colName + orderByDirection);
return this;
}
}

5
lib/taskana-core/src/main/java/pro/taskana/model/mappings/QueryMapper.java
View File

@ -153,7 +153,8 @@ public interface QueryMapper {
@Result(property = "value", column = "VALUE")})
List<ObjectReference> queryObjectReference(ObjectReferenceQueryImpl objectReference);
@Select("<script>SELECT DISTINCT w.ID, w.KEY, w.NAME, w.DOMAIN, W.TYPE, w.DESCRIPTION, w.OWNER, w.ORG_LEVEL_1, w.ORG_LEVEL_2, w.ORG_LEVEL_3, w.ORG_LEVEL_4 from WORKBASKET w "
@Select("<script>"
+ "SELECT DISTINCT w.ID, w.KEY, w.NAME, w.DOMAIN, W.TYPE, w.DESCRIPTION, w.OWNER, w.ORG_LEVEL_1, w.ORG_LEVEL_2, w.ORG_LEVEL_3, w.ORG_LEVEL_4 from WORKBASKET w "
+ "<if test='accessId != null'>LEFT OUTER JOIN WORKBASKET_ACCESS_LIST a on w.KEY = a.WORKBASKET_KEY</if> "
+ "<where>"
+ "<if test='owner != null'>AND w.OWNER IN(<foreach item='item' collection='owner' separator=',' >#{item}</foreach>)</if> "
@ -190,7 +191,7 @@ public interface QueryMapper {
+ "<if test=\"authorization.name().equals('CUSTOM_12')\">PERM_CUSTOM_12</if> = 1 "
+ "</if>"
+ "</where>"
+ "<if test='!orderClause.isEmpty()'> ${orderClause}</if> "
+ "<if test='!orderBy.isEmpty()'>ORDER BY <foreach item='orderItem' collection='orderBy' separator=',' >${orderItem}</foreach></if> "
+ "</script>")
@Results({
@Result(property = "id", column = "ID"),

165
lib/taskana-core/src/test/java/acceptance/workbasket/QueryWorkbasketAccTest.java
View File

@ -1,7 +1,5 @@
package acceptance.workbasket;
import static org.junit.Assert.fail;
import java.sql.SQLException;
import java.util.List;
@ -12,6 +10,7 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import acceptance.AbstractAccTest;
import pro.taskana.BaseQuery.SortDirection;
import pro.taskana.WorkbasketService;
import pro.taskana.WorkbasketSummary;
import pro.taskana.exceptions.InvalidArgumentException;
@ -26,6 +25,9 @@ import pro.taskana.security.JAASRunner;
@RunWith(JAASRunner.class)
public class QueryWorkbasketAccTest extends AbstractAccTest {
private static SortDirection asc = SortDirection.ASCENDING;
private static SortDirection desc = SortDirection.DESCENDING;
public QueryWorkbasketAccTest() {
super();
}
@ -163,11 +165,21 @@ public class QueryWorkbasketAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
.nameLike("%Gruppenpostkorb KSC%")
.orderByName()
.ascending()
.orderByName(asc)
.list();
Assert.assertEquals(6L, results.size());
Assert.assertEquals("GPK_KSC", results.get(0).getKey());
// check sort order is correct
WorkbasketSummary previousSummary = null;
for (WorkbasketSummary wbSummary : results) {
if (previousSummary != null) {
Assert.assertTrue(wbSummary.getName().compareToIgnoreCase(
previousSummary.getName()) >= 0);
}
previousSummary = wbSummary;
}
}
@Test
@ -175,12 +187,19 @@ public class QueryWorkbasketAccTest extends AbstractAccTest {
throws SQLException, NotAuthorizedException, InvalidRequestException, InvalidArgumentException {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
.nameLike("%Gruppenpostkorb KSC%")
.orderByName()
.descending()
.nameLike("basxet%")
.orderByName(desc)
.list();
Assert.assertEquals(6L, results.size());
Assert.assertEquals("GPK_B_KSC_2", results.get(0).getKey());
Assert.assertEquals(10L, results.size());
// check sort order is correct
WorkbasketSummary previousSummary = null;
for (WorkbasketSummary wbSummary : results) {
if (previousSummary != null) {
Assert.assertTrue(wbSummary.getName().compareToIgnoreCase(
previousSummary.getName()) <= 0);
}
previousSummary = wbSummary;
}
}
@Test
@ -188,12 +207,19 @@ public class QueryWorkbasketAccTest extends AbstractAccTest {
throws SQLException, NotAuthorizedException, InvalidArgumentException, InvalidRequestException {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
.nameLike("%Gruppenpostkorb KSC%")
.orderByKey()
.ascending()
.nameLike("basxet%")
.orderByKey(asc)
.list();
Assert.assertEquals(6L, results.size());
Assert.assertEquals("GPK_B_KSC", results.get(0).getKey());
Assert.assertEquals(10L, results.size());
// check sort order is correct
WorkbasketSummary previousSummary = null;
for (WorkbasketSummary wbSummary : results) {
if (previousSummary != null) {
Assert.assertTrue(wbSummary.getKey().compareToIgnoreCase(
previousSummary.getKey()) >= 0);
}
previousSummary = wbSummary;
}
}
@Test
@ -201,108 +227,19 @@ public class QueryWorkbasketAccTest extends AbstractAccTest {
throws SQLException, NotAuthorizedException, InvalidArgumentException, InvalidRequestException {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
.nameLike("%Gruppenpostkorb KSC%")
.orderByKey()
.descending()
.nameLike("basxet%")
.orderByKey(desc)
.list();
Assert.assertEquals(6L, results.size());
Assert.assertEquals("GPK_KSC_2", results.get(0).getKey());
Assert.assertEquals(10L, results.size());
// check sort order is correct
WorkbasketSummary previousSummary = null;
for (WorkbasketSummary wbSummary : results) {
if (previousSummary != null) {
Assert.assertTrue(wbSummary.getKey().compareToIgnoreCase(
previousSummary.getKey()) <= 0);
}
@Test
public void testQuerySortingWithInvalidInput()
throws SQLException, NotAuthorizedException, InvalidArgumentException {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
try {
workbasketService.createWorkbasketQuery()
.nameLike("%Gruppenpostkorb KSC%")
.orderByName()
.orderByName()
.list();
fail("WorkbasketQuery should have thrown InvalidRequestException.");
} catch (InvalidRequestException ignored) {
// nothing to do
}
try {
workbasketService.createWorkbasketQuery()
.nameLike("%Gruppenpostkorb KSC%")
.orderByKey()
.orderByKey()
.list();
fail("WorkbasketQuery should have thrown InvalidRequestException.");
} catch (InvalidRequestException ignored) {
// nothing to do
}
try {
workbasketService.createWorkbasketQuery()
.nameLike("%Gruppenpostkorb KSC%")
.ascending()
.orderByName()
.list();
fail("WorkbasketQuery should have thrown InvalidRequestException.");
} catch (InvalidRequestException ignored) {
// nothing to do
}
try {
workbasketService.createWorkbasketQuery()
.nameLike("%Gruppenpostkorb KSC%")
.descending()
.orderByName()
.list();
fail("WorkbasketQuery should have thrown InvalidRequestException.");
} catch (InvalidRequestException ignored) {
// nothing to do
}
try {
workbasketService.createWorkbasketQuery()
.nameLike("%Gruppenpostkorb KSC%")
.orderByName()
.ascending()
.ascending();
fail("WorkbasketQuery should have thrown InvalidRequestException.");
} catch (InvalidRequestException ignored) {
// nothing to do
}
try {
workbasketService.createWorkbasketQuery()
.nameLike("%Gruppenpostkorb KSC%")
.orderByName()
.ascending()
.descending()
.list();
fail("WorkbasketQuery should have thrown InvalidRequestException.");
} catch (InvalidRequestException ignored) {
// nothing to do
}
try {
workbasketService.createWorkbasketQuery()
.nameLike("%Gruppenpostkorb KSC%")
.orderByName()
.descending()
.ascending()
.list();
fail("WorkbasketQuery should have thrown InvalidRequestException.");
} catch (InvalidRequestException ignored) {
// nothing to do
}
try {
workbasketService.createWorkbasketQuery()
.nameLike("%Gruppenpostkorb KSC%")
.orderByName()
.orderByName()
.list();
fail("WorkbasketQuery should have thrown InvalidRequestException.");
} catch (InvalidRequestException ignored) {
// nothing to do
previousSummary = wbSummary;
}
}
}

13
lib/taskana-core/src/test/java/acceptance/workbasket/QueryWorkbasketByPermissionAccTest.java
View File

@ -10,6 +10,7 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import acceptance.AbstractAccTest;
import pro.taskana.BaseQuery.SortDirection;
import pro.taskana.WorkbasketService;
import pro.taskana.WorkbasketSummary;
import pro.taskana.exceptions.InvalidArgumentException;
@ -26,6 +27,9 @@ import pro.taskana.security.WithAccessId;
@RunWith(JAASRunner.class)
public class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
private static SortDirection asc = SortDirection.ASCENDING;
private static SortDirection desc = SortDirection.DESCENDING;
public QueryWorkbasketByPermissionAccTest() {
super();
}
@ -58,8 +62,7 @@ public class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
.accessIdsHavePermission(WorkbasketAuthorization.APPEND, "user_1_1", "group_1")
.orderByName()
.ascending()
.orderByName(asc)
.list();
Assert.assertEquals(9, results.size());
Assert.assertEquals("key4", results.get(0).getKey());
@ -72,10 +75,8 @@ public class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
.accessIdsHavePermission(WorkbasketAuthorization.APPEND, "user_1_1", "group_1")
.orderByName()
.descending()
.orderByKey()
.ascending()
.orderByName(desc)
.orderByKey(asc)
.list();
Assert.assertEquals(9, results.size());
Assert.assertEquals("USER_2_2", results.get(0).getKey());

16
lib/taskana-core/src/test/java/acceptance/workbasket/WorkbasketQueryWithOrderedPaginationAccTest.java
View File

@ -12,6 +12,7 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import acceptance.AbstractAccTest;
import pro.taskana.BaseQuery.SortDirection;
import pro.taskana.WorkbasketService;
import pro.taskana.WorkbasketSummary;
import pro.taskana.exceptions.InvalidRequestException;
@ -24,6 +25,9 @@ import pro.taskana.security.JAASRunner;
@RunWith(JAASRunner.class)
public class WorkbasketQueryWithOrderedPaginationAccTest extends AbstractAccTest {
private static SortDirection asc = SortDirection.ASCENDING;
private static SortDirection desc = SortDirection.DESCENDING;
public WorkbasketQueryWithOrderedPaginationAccTest() {
super();
}
@ -35,8 +39,7 @@ public class WorkbasketQueryWithOrderedPaginationAccTest extends AbstractAccTest
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
.domainIn("DOMAIN_A")
.orderByKey()
.ascending()
.orderByKey(asc)
.list(0, 5);
assertThat(results.size(), equalTo(5));
assertThat(results.get(0).getKey(), equalTo("GPK_KSC"));
@ -44,8 +47,7 @@ public class WorkbasketQueryWithOrderedPaginationAccTest extends AbstractAccTest
results = workbasketService.createWorkbasketQuery()
.domainIn("DOMAIN_A")
.orderByKey()
.descending()
.orderByKey(desc)
.list(0, 5);
assertThat(results.size(), equalTo(5));
assertThat(results.get(0).getKey(), equalTo("USER_2_2"));
@ -59,8 +61,7 @@ public class WorkbasketQueryWithOrderedPaginationAccTest extends AbstractAccTest
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results = workbasketService.createWorkbasketQuery()
.domainIn("DOMAIN_A")
.orderByKey()
.ascending()
.orderByKey(asc)
.list(5, 5);
assertThat(results.size(), equalTo(5));
assertThat(results.get(0).getKey(), equalTo("key3"));
@ -68,8 +69,7 @@ public class WorkbasketQueryWithOrderedPaginationAccTest extends AbstractAccTest
results = workbasketService.createWorkbasketQuery()
.domainIn("DOMAIN_A")
.orderByKey()
.descending()
.orderByKey(desc)
.list(5, 5);
assertThat(results.size(), equalTo(5));
assertThat(results.get(0).getKey(), equalTo("TEAMLEAD_1"));

26
lib/taskana-core/src/test/java/pro/taskana/impl/configuration/TaskanaEngineConfigurationTest.java
View File

@ -19,11 +19,14 @@ import org.slf4j.LoggerFactory;
import pro.taskana.TaskanaEngine;
import pro.taskana.configuration.TaskanaEngineConfiguration;
/**
* Integration Test for TaskanaEngineConfiguration.
*
* @author EH
*/
public class TaskanaEngineConfigurationTest {
private static DataSource dataSource = null;
private static final Logger LOGGER = LoggerFactory.getLogger(TaskanaEngineConfigurationTest.class);
private static final int POOL_TIME_TO_WAIT = 50;
@ -39,17 +42,17 @@ public class TaskanaEngineConfigurationTest {
}
/**
* returns the Datasource used for Junit test.
* If the file {user.home}/taskanaUnitTest.properties is present, the Datasource is created according to the
* properties jdbcDriver, jdbcUrl, dbUserName and dbPassword.
* Assuming, the database has the name tskdb, a sample properties file for DB2 looks as follows:
* returns the Datasource used for Junit test. If the file {user.home}/taskanaUnitTest.properties is present, the
* Datasource is created according to the properties jdbcDriver, jdbcUrl, dbUserName and dbPassword. Assuming, the
* database has the name tskdb, a sample properties file for DB2 looks as follows:
*
* jdbcDriver=com.ibm.db2.jcc.DB2Driver
* jdbcUrl=jdbc:db2://localhost:50000/tskdb
* dbUserName=db2user
* dbPassword=db2password
*
* If any of these properties is missing, or the file doesn't exist, the default Datasource for h2 in-memory db is created.
* If any of these properties is missing, or the file doesn't exist, the default Datasource
* for h2 in-memory db is created.
*
* @return dataSource for unit test
*/
@ -69,16 +72,17 @@ public class TaskanaEngineConfigurationTest {
/**
* create Default Datasource for in-memory database.
*
* @return
*/
private static DataSource createDefaultDataSource() {
// JdbcDataSource ds = new JdbcDataSource();
// ds.setURL("jdbc:h2:mem:taskana");
// ds.setPassword("sa");
// ds.setUser("sa");
// JdbcDataSource ds = new JdbcDataSource();
// ds.setURL("jdbc:h2:mem:taskana;IGNORECASE=TRUE");
// ds.setPassword("sa");
// ds.setUser("sa");
String jdbcDriver = "org.h2.Driver";
String jdbcUrl = "jdbc:h2:mem:taskana";
String jdbcUrl = "jdbc:h2:mem:taskana;IGNORECASE=TRUE";
String dbUserName = "sa";
String dbPassword = "sa";
DataSource ds = new PooledDataSource(Thread.currentThread().getContextClassLoader(), jdbcDriver,
@ -91,6 +95,7 @@ public class TaskanaEngineConfigurationTest {
/**
* create data source from properties file.
*
* @param propertiesFileName
* @return
*/
@ -145,5 +150,4 @@ public class TaskanaEngineConfigurationTest {
return ds;
}
}

12
lib/taskana-core/src/test/resources/sql/workbasket-access-list.sql
View File

@ -38,3 +38,15 @@ INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:10000000000000000000000000000000
INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000024', 'GPK_B_KSC_2', 'group_2', true, false, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false);
INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000025', 'key5', 'group_1', true, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false);
-- Access to workbaskets for sorting test
INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('900', 'sort001', 'max', true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('901', 'Sort002', 'max', true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('902', 'sOrt003', 'max', true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('903', 'soRt004', 'max', true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('904', 'sorT005', 'max', true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('905', 'Sort006', 'max', true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('906', 'SOrt007', 'max', true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('907', 'SoRt008', 'max', true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('908', 'SorT009', 'max', true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);
INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('909', 'Sort010', 'max', true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true);

13
lib/taskana-core/src/test/resources/sql/workbasket.sql
View File

@ -20,3 +20,16 @@ INSERT INTO WORKBASKET VALUES ('WBI:100000000000000000000000000000000011', 'GPK_
INSERT INTO WORKBASKET VALUES ('WBI:100000000000000000000000000000000012', 'GPK_B_KSC_1', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'Gruppenpostkorb KSC B1', 'DOMAIN_B', 'GROUP', 'Gruppenpostkorb KSC 1', '', '', '', '', '', '', '', '', '');
INSERT INTO WORKBASKET VALUES ('WBI:100000000000000000000000000000000013', 'GPK_B_KSC_2', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'Gruppenpostkorb KSC B2', 'DOMAIN_B', 'GROUP', 'Gruppenpostkorb KSC 2', '', '', '', '', '', '', '', '', '');
-- Workbaskets for sorting test
INSERT INTO WORKBASKET VALUES ('900', 'sort001', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'basxet0', 'DOM_XY', 'TOPIC', 'Lorem ipsum dolor sit amet.', 'Max', '', '', '', '', '', '', '', '');
INSERT INTO WORKBASKET VALUES ('901', 'Sort002', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'Basxet1', 'DOM_XY', 'TOPIC', 'Lorem ipsum dolor sit amet.', 'Max', '', '', '', '', '', '', '', '');
INSERT INTO WORKBASKET VALUES ('902', 'sOrt003', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'bAsxet2', 'DOM_XY', 'TOPIC', 'Lorem ipsum dolor sit amet.', 'Max', '', '', '', '', '', '', '', '');
INSERT INTO WORKBASKET VALUES ('903', 'soRt004', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'baSxet3', 'DOM_XY', 'TOPIC', 'Lorem ipsum dolor sit amet.', 'Max', '', '', '', '', '', '', '', '');
INSERT INTO WORKBASKET VALUES ('904', 'sorT005', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'basXet4', 'DOM_XY', 'TOPIC', 'Lorem ipsum dolor sit amet.', 'Max', '', '', '', '', '', '', '', '');
INSERT INTO WORKBASKET VALUES ('905', 'Sort006', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'basxEt5', 'DOM_XY', 'TOPIC', 'Lorem ipsum dolor sit amet.', 'Max', '', '', '', '', '', '', '', '');
INSERT INTO WORKBASKET VALUES ('906', 'SOrt007', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'basxeT6', 'DOM_XY', 'TOPIC', 'Lorem ipsum dolor sit amet.', 'Max', '', '', '', '', '', '', '', '');
INSERT INTO WORKBASKET VALUES ('907', 'SoRt008', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'BAsxet7', 'DOM_XY', 'TOPIC', 'Lorem ipsum dolor sit amet.', 'Max', '', '', '', '', '', '', '', '');
INSERT INTO WORKBASKET VALUES ('908', 'SorT009', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'BaSxet8', 'DOM_XY', 'TOPIC', 'Lorem ipsum dolor sit amet.', 'Max', '', '', '', '', '', '', '', '');
INSERT INTO WORKBASKET VALUES ('909', 'Sort010', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'BasXet9', 'DOM_XY', 'TOPIC', 'Lorem ipsum dolor sit amet.', 'Max', '', '', '', '', '', '', '', '');

6
lib/taskana-spring/src/test/java/pro/taskana/TransactionTest.java
View File

@ -40,7 +40,7 @@ public class TransactionTest {
@Before
public void init() throws SQLException, ClassNotFoundException {
Class.forName("org.h2.Driver");
try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:task-engine", "SA", "SA")) {
try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:task-engine;IGNORECASE=TRUE", "SA", "SA")) {
conn.createStatement().executeUpdate("DELETE FROM TASK WHERE 1=1");
conn.commit();
}
@ -52,7 +52,7 @@ public class TransactionTest {
restTemplate.getForEntity("http://127.0.0.1:" + port + "/test", String.class);
int resultCount = 0;
try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:task-engine", "SA", "SA")) {
try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:task-engine;IGNORECASE=TRUE", "SA", "SA")) {
ResultSet rs = conn.createStatement().executeQuery("SELECT ID FROM TASK");
while (rs.next()) {
@ -69,7 +69,7 @@ public class TransactionTest {
restTemplate.postForEntity("http://127.0.0.1:" + port + "/test", null, String.class);
int resultCount = 0;
try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:task-engine", "SA", "SA")) {
try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:task-engine;IGNORECASE=TRUE", "SA", "SA")) {
ResultSet rs = conn.createStatement().executeQuery("SELECT ID FROM TASK");
while (rs.next()) {