TSK-235 sort workbasket query results case insensitive

lib/taskana-cdi/src/test/java/pro/taskana/TaskanaProducersTest.java

@@ -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()) {

lib/taskana-core/src/main/java/pro/taskana/WorkbasketQuery.java

@@ -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;
+    WorkbasketQuery orderByKey(SortDirection sortDirection);
-
-    /**
-     * 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;
 
 }

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

@@ -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);
     }
 

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

@@ -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(columnName + orderByDirection);
-            orderBy.add("UPPER(" + columnName + ")" + orderByDirection);
-        } else {
-            orderBy.add(columnName + orderByDirection);
-        }
         return this;
     }
 }

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

@@ -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 {
+    public WorkbasketQuery orderByName(SortDirection sortDirection) {
-        if (orderClause.contains(NAME_COL_NAME)) {
+        return addOrderCriteria("NAME", sortDirection);
-            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;
     }
 
     @Override
-    public WorkbasketQuery orderByKey() throws InvalidRequestException {
+    public WorkbasketQuery orderByKey(SortDirection sortDirection) {
-        if (orderClause.contains(KEY_COL_NAME)) {
+        return addOrderCriteria("KEY", sortDirection);
-            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;
     }
 
     @Override
@@ -370,8 +306,8 @@ public class WorkbasketQueryImpl implements WorkbasketQuery {
         return owner;
     }
 
-    public String getOrderClause() {
+    public List<String> getOrderBy() {
-        return orderClause;
+        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;
+    }
+
 }

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

@@ -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"),

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

@@ -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()
+            .orderByName(asc)
-            .ascending()
             .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%")
+            .nameLike("basxet%")
-            .orderByName()
+            .orderByName(desc)
-            .descending()
             .list();
-        Assert.assertEquals(6L, results.size());
+        Assert.assertEquals(10L, results.size());
-        Assert.assertEquals("GPK_B_KSC_2", 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
@@ -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%")
+            .nameLike("basxet%")
-            .orderByKey()
+            .orderByKey(asc)
-            .ascending()
             .list();
-        Assert.assertEquals(6L, results.size());
+        Assert.assertEquals(10L, results.size());
-        Assert.assertEquals("GPK_B_KSC", results.get(0).getKey());
+        // 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%")
+            .nameLike("basxet%")
-            .orderByKey()
+            .orderByKey(desc)
-            .descending()
             .list();
-        Assert.assertEquals(6L, results.size());
+        Assert.assertEquals(10L, results.size());
-        Assert.assertEquals("GPK_KSC_2", results.get(0).getKey());
+        // check sort order is correct
-    }
+        WorkbasketSummary previousSummary = null;
-
+        for (WorkbasketSummary wbSummary : results) {
-    @Test
+            if (previousSummary != null) {
-    public void testQuerySortingWithInvalidInput()
+                Assert.assertTrue(wbSummary.getKey().compareToIgnoreCase(
-        throws SQLException, NotAuthorizedException, InvalidArgumentException {
+                    previousSummary.getKey()) <= 0);
-        WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+            }
-
+            previousSummary = wbSummary;
-        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
         }
     }
+
 }

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

@@ -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()
+            .orderByName(asc)
-            .ascending()
             .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()
+            .orderByName(desc)
-            .descending()
+            .orderByKey(asc)
-            .orderByKey()
-            .ascending()
             .list();
         Assert.assertEquals(9, results.size());
         Assert.assertEquals("USER_2_2", results.get(0).getKey());

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

@@ -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()
+            .orderByKey(asc)
-            .ascending()
             .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()
+            .orderByKey(desc)
-            .descending()
             .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()
+            .orderByKey(asc)
-            .ascending()
             .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()
+            .orderByKey(desc)
-            .descending()
             .list(5, 5);
         assertThat(results.size(), equalTo(5));
         assertThat(results.get(0).getKey(), equalTo("TEAMLEAD_1"));

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

@@ -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,23 +42,23 @@ public class TaskanaEngineConfigurationTest {
     }
 
     /**
-     * returns the Datasource used for Junit test.
+     * returns the Datasource used for Junit test. If the file {user.home}/taskanaUnitTest.properties is present, the
-     * If the file {user.home}/taskanaUnitTest.properties is present, the Datasource is created according to the
+     * Datasource is created according to the properties jdbcDriver, jdbcUrl, dbUserName and dbPassword. Assuming, the
-     * properties jdbcDriver, jdbcUrl, dbUserName and dbPassword.
+     * database has the name tskdb, a sample properties file for DB2 looks as follows:
-     * Assuming, the database has the name tskdb, a sample properties file for DB2 looks as follows:
      *
-     *      jdbcDriver=com.ibm.db2.jcc.DB2Driver
+     * jdbcDriver=com.ibm.db2.jcc.DB2Driver
-     *      jdbcUrl=jdbc:db2://localhost:50000/tskdb
+     * jdbcUrl=jdbc:db2://localhost:50000/tskdb
-     *      dbUserName=db2user
+     * dbUserName=db2user
-     *      dbPassword=db2password
+     * 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
      */
     public static DataSource getDataSource() {
         if (dataSource == null) {
-            String userHomeDirectroy  = System.getProperty("user.home");
+            String userHomeDirectroy = System.getProperty("user.home");
             String propertiesFileName = userHomeDirectroy + "/taskanaUnitTest.properties";
             File f = new File(propertiesFileName);
             if (f.exists() && !f.isDirectory()) {
@@ -69,20 +72,21 @@ public class TaskanaEngineConfigurationTest {
 
     /**
      * create Default Datasource for in-memory database.
+     *
      * @return
      */
     private static DataSource createDefaultDataSource() {
-//        JdbcDataSource ds = new JdbcDataSource();
+        // JdbcDataSource ds = new JdbcDataSource();
-//        ds.setURL("jdbc:h2:mem:taskana");
+        // ds.setURL("jdbc:h2:mem:taskana;IGNORECASE=TRUE");
-//        ds.setPassword("sa");
+        // ds.setPassword("sa");
-//        ds.setUser("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,
-                jdbcUrl, dbUserName, dbPassword);
+            jdbcUrl, dbUserName, dbPassword);
         ((PooledDataSource) ds).setPoolTimeToWait(POOL_TIME_TO_WAIT);
         ((PooledDataSource) ds).forceCloseAll();  // otherwise the MyBatis pool is not initialized correctly
 
@@ -91,6 +95,7 @@ public class TaskanaEngineConfigurationTest {
 
     /**
      * create data source from properties file.
+     *
      * @param propertiesFileName
      * @return
      */
@@ -101,22 +106,22 @@ public class TaskanaEngineConfigurationTest {
             prop.load(input);
             boolean propertiesFileIsComplete = true;
             String warningMessage = "";
-            String jdbcDriver  = prop.getProperty("jdbcDriver");
+            String jdbcDriver = prop.getProperty("jdbcDriver");
             if (jdbcDriver == null || jdbcDriver.length() == 0) {
                 propertiesFileIsComplete = false;
                 warningMessage += ", jdbcDriver property missing";
             }
-            String jdbcUrl     = prop.getProperty("jdbcUrl");
+            String jdbcUrl = prop.getProperty("jdbcUrl");
             if (jdbcUrl == null || jdbcUrl.length() == 0) {
                 propertiesFileIsComplete = false;
                 warningMessage += ", jdbcUrl property missing";
             }
-            String dbUserName  = prop.getProperty("dbUserName");
+            String dbUserName = prop.getProperty("dbUserName");
             if (dbUserName == null || dbUserName.length() == 0) {
                 propertiesFileIsComplete = false;
                 warningMessage += ", dbUserName property missing";
             }
-            String dbPassword  = prop.getProperty("dbPassword");
+            String dbPassword = prop.getProperty("dbPassword");
             if (dbPassword == null || dbPassword.length() == 0) {
                 propertiesFileIsComplete = false;
                 warningMessage += ", dbPassword property missing";
@@ -124,7 +129,7 @@ public class TaskanaEngineConfigurationTest {
 
             if (propertiesFileIsComplete) {
                 ds = new PooledDataSource(Thread.currentThread().getContextClassLoader(), jdbcDriver,
-                                            jdbcUrl, dbUserName, dbPassword);
+                    jdbcUrl, dbUserName, dbPassword);
                 ((PooledDataSource) ds).forceCloseAll();  // otherwise the MyBatis pool is not initialized correctly
             } else {
                 LOGGER.warn("propertiesFile " + propertiesFileName + " is incomplete" + warningMessage);
@@ -145,5 +150,4 @@ public class TaskanaEngineConfigurationTest {
         return ds;
     }
 
-
 }

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

@@ -1,9 +1,9 @@
-INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('1', 'key1', 'Elena', 	true, true, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false);
+INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('1', 'key1', 'Elena',        true, true, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false);
-INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('2', 'key2', 'Max', 		true, true, true, true, true, true,  true,  true,  true,  false, false, false, false, false, false, false, false);
+INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('2', 'key2', 'Max',          true, true, true, true, true, true,  true,  true,  true,  false, false, false, false, false, false, false, false);
-INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('3', 'key3', 'Simone', 	true, true, true, true, true, true,  true,  true,  true,  true,  true,  true,  true,  true,  true,  true,  true);
+INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('3', 'key3', 'Simone',       true, true, true, true, true, true,  true,  true,  true,  true,  true,  true,  true,  true,  true,  true,  true);
 INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('4', 'key4', 'user_1_1', true, true, true, true, true, true,  true,  true,  true,  true,  true,  true,  true,  true,  true,  true,  true);
 
--- KSC authorizations (                    ID, 										   WB_KEY, 	     ACCESS_ID,    READ, OPEN, APPEND, TRANSFER, DISTRIBUTE, C1, .., C12)
+-- KSC authorizations (                    ID,                                                                             WB_KEY,           ACCESS_ID,    READ, OPEN, APPEND, TRANSFER, DISTRIBUTE, C1, .., C12)
 -- PPKs
 INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000001', 'TEAMLEAD_1', 'teamlead_1', true, true, true,   true,     true,       true, true, true, true, true, true, true, true, true, true, true, true);
 INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000002', 'TEAMLEAD_2', 'teamlead_2', true, true, true,   true,     true,       true, true, true, true, true, true, true, true, true, true, true, true);
@@ -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);

lib/taskana-core/src/test/resources/sql/workbasket.sql

@@ -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', '', '', '', '', '', '', '', '');
+

lib/taskana-spring/src/test/java/pro/taskana/TransactionTest.java

@@ -28,56 +28,56 @@ import org.springframework.test.context.junit4.SpringRunner;
 @DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD)
 public class TransactionTest {
 
-	@Autowired
+    @Autowired
-	TaskService taskService;
+    TaskService taskService;
 
-	@Autowired
+    @Autowired
-	private TestRestTemplate restTemplate;
+    private TestRestTemplate restTemplate;
 
-	@LocalServerPort
+    @LocalServerPort
-	int port;
+    int port;
 
-	@Before
+    @Before
-	public void init() throws SQLException, ClassNotFoundException {
+    public void init() throws SQLException, ClassNotFoundException {
-		Class.forName("org.h2.Driver");
+        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.createStatement().executeUpdate("DELETE FROM TASK WHERE 1=1");
-			conn.commit();
+            conn.commit();
-		}
+        }
-	}
+    }
 
-	@Test
+    @Test
-	@Ignore
+    @Ignore
-	public void testCommit() throws SQLException {
+    public void testCommit() throws SQLException {
-		restTemplate.getForEntity("http://127.0.0.1:" + port + "/test", String.class);
+        restTemplate.getForEntity("http://127.0.0.1:" + port + "/test", String.class);
 
-		int resultCount = 0;
+        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");
+            ResultSet rs = conn.createStatement().executeQuery("SELECT ID FROM TASK");
 
-			while (rs.next()) {
+            while (rs.next()) {
-				resultCount++;
+                resultCount++;
-			}
+            }
-		}
+        }
 
-		Assert.assertEquals(1, resultCount);
+        Assert.assertEquals(1, resultCount);
-	}
+    }
 
-	@Test
+    @Test
-	@Ignore
+    @Ignore
-	public void testRollback() throws SQLException {
+    public void testRollback() throws SQLException {
-		restTemplate.postForEntity("http://127.0.0.1:" + port + "/test", null, String.class);
+        restTemplate.postForEntity("http://127.0.0.1:" + port + "/test", null, String.class);
 
-		int resultCount = 0;
+        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");
+            ResultSet rs = conn.createStatement().executeQuery("SELECT ID FROM TASK");
 
-			while (rs.next()) {
+            while (rs.next()) {
-				resultCount++;
+                resultCount++;
-			}
+            }
-		}
+        }
 
-		Assert.assertEquals(0, resultCount);
+        Assert.assertEquals(0, resultCount);
-	}
+    }
 
 }