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

TSK-990: minor refactoring

This commit is contained in:
Mustapha Zorgati 2019-12-26 00:14:35 +01:00
parent 3ea0ab0bf4
commit c500599e1c
23 changed files with 144 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/configuration/DbSchemaCreator.java
View File

@ -50,8 +50,7 @@ public class DbSchemaCreator {
runner.setLogWriter(logWriter);
runner.setErrorLogWriter(errorLogWriter);
try {
InputStream resourceAsStream = this.getClass()
.getResourceAsStream(DB_SCHEMA);
InputStream resourceAsStream = this.getClass().getResourceAsStream(DB_SCHEMA);
BufferedReader reader = new BufferedReader(new InputStreamReader(resourceAsStream, StandardCharsets.UTF_8));
runner.runScript(getSqlWithSchemaNameParsed(reader));
} finally {
@ -64,13 +63,13 @@ public class DbSchemaCreator {
}
private StringReader getSqlWithSchemaNameParsed(BufferedReader reader) {
StringBuffer content = new StringBuffer();
StringBuilder content = new StringBuilder();
try {
String line = "";
while (line != null) {
line = reader.readLine();
if (line != null) {
content.append(line.replaceAll("%schemaName%", schemaName) + System.lineSeparator());
content.append(line.replaceAll("%schemaName%", schemaName)).append(System.lineSeparator());
}
}
} catch (IOException e) {

6
history/taskana-simplehistory-rest-spring/src/main/java/pro/taskana/rest/simplehistory/sampledata/SampleDataGenerator.java
View File

@ -15,6 +15,8 @@ import org.apache.ibatis.jdbc.ScriptRunner;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.configuration.DB;
/**
* This class generates sample data for manual testing purposes.
*/
@ -54,7 +56,7 @@ public class SampleDataGenerator {
runner.runScript(new BufferedReader(
new InputStreamReader(this.getClass().getResourceAsStream(CLEAR), StandardCharsets.UTF_8)));
} catch (Exception e) {
LOGGER.error("caught Exception {}", e);
LOGGER.error("caught Exception {}", e, e);
}
runner.setStopOnError(true);
@ -73,7 +75,7 @@ public class SampleDataGenerator {
}
private StringReader selectSchemaScript(String dbProductName, String schemaName) {
return new StringReader("PostgreSQL".equals(dbProductName)
return new StringReader(DB.isPostgreSQL(dbProductName)
? "SET search_path TO " + schemaName + ";"
: "SET SCHEMA " + schemaName + ";");
}

20
lib/taskana-core/src/main/java/pro/taskana/configuration/DB.java
View File

@ -20,27 +20,27 @@ public enum DB {
}
public static boolean isDb2(String dbProductName) {
return dbProductName.contains(DB2.dbProductname);
return dbProductName != null && dbProductName.contains(DB2.dbProductname);
}
public static boolean isH2(String databaseProductName) {
return databaseProductName.contains(H2.dbProductname);
public static boolean isH2(String dbProductName) {
return dbProductName != null && dbProductName.contains(H2.dbProductname);
}
public static boolean isPostgreSQL(String databaseProductName) {
return POSTGRESS.dbProductname.equals(databaseProductName);
public static boolean isPostgreSQL(String dbProductName) {
return POSTGRESS.dbProductname.equals(dbProductName);
}
public static String getDatabaseProductId(String databaseProductName) {
public static String getDatabaseProductId(String dbProductName) {
if (isDb2(databaseProductName)) {
if (isDb2(dbProductName)) {
return DB2.dbProductId;
} else if (isH2(databaseProductName)) {
} else if (isH2(dbProductName)) {
return H2.dbProductId;
} else if (isPostgreSQL(databaseProductName)) {
} else if (isPostgreSQL(dbProductName)) {
return POSTGRESS.dbProductId;
} else {
throw new UnsupportedDatabaseException(databaseProductName);
throw new UnsupportedDatabaseException(dbProductName);
}
}
}

6
lib/taskana-core/src/main/java/pro/taskana/configuration/DbSchemaCreator.java
View File

@ -69,8 +69,7 @@ public class DbSchemaCreator {
try {
if (!isSchemaPreexisting(connection)) {
String scriptPath = selectDbScriptFileName(connection.getMetaData().getDatabaseProductName());
InputStream resourceAsStream = this.getClass()
.getResourceAsStream(scriptPath);
InputStream resourceAsStream = this.getClass().getResourceAsStream(scriptPath);
BufferedReader reader = new BufferedReader(
new InputStreamReader(resourceAsStream, StandardCharsets.UTF_8));
runner.runScript(getSqlSchemaNameParsed(reader));
@ -98,8 +97,7 @@ public class DbSchemaCreator {
runner.setErrorLogWriter(new PrintWriter(errorWriter));
try {
String scriptPath = selectDbSchemaDetectionScript(connection.getMetaData().getDatabaseProductName());
InputStream resourceAsStream = this.getClass()
.getResourceAsStream(scriptPath);
InputStream resourceAsStream = this.getClass().getResourceAsStream(scriptPath);
BufferedReader reader = new BufferedReader(new InputStreamReader(resourceAsStream, StandardCharsets.UTF_8));
runner.runScript(getSqlSchemaNameParsed(reader));
} catch (Exception e) {

107
lib/taskana-core/src/main/java/pro/taskana/impl/DaysToWorkingDaysConverter.java
View File

@ -48,8 +48,7 @@ public final class DaysToWorkingDaysConverter {
negativeDaysToWorkingDays = generateNegativeDaysToWorkingDays(columnHeaders, referenceDate);
}
public static DaysToWorkingDaysConverter initialize()
throws InvalidArgumentException {
public static DaysToWorkingDaysConverter initialize() throws InvalidArgumentException {
return initialize(Collections.singletonList(new TimeIntervalColumnHeader(0)), Instant.now());
}
@ -95,6 +94,39 @@ public final class DaysToWorkingDaysConverter {
germanHolidaysEnabled = germanPublicHolidaysEnabled;
}
/**
* Computes the date of Easter Sunday for a given year.
*
* @param year for which the date of Easter Sunday should be calculated
* @return the date of Easter Sunday for the given year
*/
static LocalDate getEasterSunday(int year) {
// Formula to compute Easter Sunday by Gauss.
int a = year % 19;
int b = year % 4;
int c = year % 7;
int k = year / 100;
int p = (13 + 8 * k) / 25;
int q = k / 4;
int m = (15 - p + k - q) % 30;
int n = (4 + k - q) % 7;
int d = (19 * a + m) % 30;
int e = (2 * b + 4 * c + 6 * d + n) % 7;
if (d == 29 && e == 6) {
return LocalDate.of(year, 3, 15).plusDays(d + e);
}
if (d == 28 && e == 6 && (11 * m + 11) % 30 < 19) {
return LocalDate.of(year, 3, 15).plusDays(d + e);
}
return LocalDate.of(year, 3, 22).plusDays(d + e);
}
public static void setCustomHolidays(List<LocalDate> holidays) {
customHolidays = new HashSet<>(holidays == null ? Collections.emptyList() : holidays);
}
/**
* Converts an integer, that represents the age in days, to the age in working days by using the table that was
* created by initialization. If the age in days is beyond the limits of the table, the integer will be returned
@ -248,39 +280,6 @@ public final class DaysToWorkingDaysConverter {
.anyMatch(diff -> diff == diffFromEasterSunday);
}
/**
* Computes the date of Easter Sunday for a given year.
*
* @param year for which the date of Easter Sunday should be calculated
* @return the date of Easter Sunday for the given year
*/
static LocalDate getEasterSunday(int year) {
// Formula to compute Easter Sunday by Gauss.
int a = year % 19;
int b = year % 4;
int c = year % 7;
int k = year / 100;
int p = (13 + 8 * k) / 25;
int q = k / 4;
int m = (15 - p + k - q) % 30;
int n = (4 + k - q) % 7;
int d = (19 * a + m) % 30;
int e = (2 * b + 4 * c + 6 * d + n) % 7;
if (d == 29 && e == 6) {
return LocalDate.of(year, 3, 15).plusDays(d + e);
}
if (d == 28 && e == 6 && (11 * m + 11) % 30 < 19) {
return LocalDate.of(year, 3, 15).plusDays(d + e);
}
return LocalDate.of(year, 3, 22).plusDays(d + e);
}
public static void setCustomHolidays(List<LocalDate> holidays) {
customHolidays = new HashSet<>(holidays == null ? Collections.emptyList() : holidays);
}
@Override
public String toString() {
return "DaysToWorkingDaysConverter{"
@ -291,6 +290,25 @@ public final class DaysToWorkingDaysConverter {
+ '}';
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
DaysToWorkingDaysConverter that = (DaysToWorkingDaysConverter) o;
return positiveDaysToWorkingDays.equals(that.positiveDaysToWorkingDays)
&& negativeDaysToWorkingDays.equals(that.negativeDaysToWorkingDays)
&& dateCreated.equals(that.dateCreated);
}
@Override
public int hashCode() {
return Objects.hash(positiveDaysToWorkingDays, negativeDaysToWorkingDays, dateCreated);
}
/**
* Enumeration of German holidays.
*/
@ -313,23 +331,4 @@ public final class DaysToWorkingDaysConverter {
return date.getDayOfMonth() == day && date.getMonthValue() == month;
}
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
DaysToWorkingDaysConverter that = (DaysToWorkingDaysConverter) o;
return positiveDaysToWorkingDays.equals(that.positiveDaysToWorkingDays)
&& negativeDaysToWorkingDays.equals(that.negativeDaysToWorkingDays)
&& dateCreated.equals(that.dateCreated);
}
@Override
public int hashCode() {
return Objects.hash(positiveDaysToWorkingDays, negativeDaysToWorkingDays, dateCreated);
}
}

5
lib/taskana-core/src/test/java/acceptance/AbstractAccTest.java
View File

@ -19,6 +19,7 @@ import pro.taskana.ObjectReference;
import pro.taskana.TaskanaEngine;
import pro.taskana.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.TimeInterval;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.impl.configuration.TaskanaEngineTestConfiguration;
import pro.taskana.sampledata.SampleDataGenerator;
@ -28,7 +29,7 @@ import pro.taskana.sampledata.SampleDataGenerator;
*/
public abstract class AbstractAccTest {
protected static pro.taskana.configuration.TaskanaEngineConfiguration taskanaEngineConfiguration;
protected static TaskanaEngineConfiguration taskanaEngineConfiguration;
protected static TaskanaEngine taskanaEngine;
@BeforeAll
@ -44,7 +45,7 @@ public abstract class AbstractAccTest {
sampleDataGenerator.dropDb();
}
dataSource = TaskanaEngineTestConfiguration.getDataSource();
taskanaEngineConfiguration = new pro.taskana.configuration.TaskanaEngineConfiguration(dataSource, false,
taskanaEngineConfiguration = new TaskanaEngineConfiguration(dataSource, false,
schemaName);
taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
taskanaEngine.setConnectionManagementMode(ConnectionManagementMode.AUTOCOMMIT);

3
lib/taskana-core/src/test/java/acceptance/config/TaskanaConfigAccTest.java
View File

@ -15,6 +15,7 @@ import java.util.HashMap;
import org.h2.store.fs.FileUtils;
import org.junit.jupiter.api.Test;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.impl.TaskanaEngineImpl;
import pro.taskana.impl.configuration.TaskanaEngineTestConfiguration;
@ -26,7 +27,7 @@ import pro.taskana.impl.configuration.TaskanaEngineTestConfiguration;
class TaskanaConfigAccTest extends TaskanaEngineImpl {
TaskanaConfigAccTest() throws SQLException {
super(new pro.taskana.configuration.TaskanaEngineConfiguration(TaskanaEngineTestConfiguration.getDataSource(),
super(new TaskanaEngineConfiguration(TaskanaEngineTestConfiguration.getDataSource(),
true,
TaskanaEngineTestConfiguration.getSchemaName()));
}

3
lib/taskana-core/src/test/java/acceptance/config/TaskanaRoleConfigAccTest.java
View File

@ -12,6 +12,7 @@ import org.h2.store.fs.FileUtils;
import org.junit.jupiter.api.Test;
import pro.taskana.TaskanaRole;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.impl.TaskanaEngineImpl;
import pro.taskana.impl.configuration.TaskanaEngineTestConfiguration;
@ -23,7 +24,7 @@ import pro.taskana.impl.configuration.TaskanaEngineTestConfiguration;
class TaskanaRoleConfigAccTest extends TaskanaEngineImpl {
TaskanaRoleConfigAccTest() throws SQLException {
super(new pro.taskana.configuration.TaskanaEngineConfiguration(TaskanaEngineTestConfiguration.getDataSource(),
super(new TaskanaEngineConfiguration(TaskanaEngineTestConfiguration.getDataSource(),
true,
TaskanaEngineTestConfiguration.getSchemaName()));
}

1
lib/taskana-core/src/test/java/acceptance/jobs/TaskCleanupJobAccTest.java
View File

@ -40,7 +40,6 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
//required if single tests modify database
//TODO split test class into readOnly & modifying tests to improve performance
resetDb(false);
resetDb(false);
taskService = taskanaEngine.getTaskService();
}

8
lib/taskana-core/src/test/java/acceptance/report/AbstractReportAccTest.java
View File

@ -1,6 +1,5 @@
package acceptance.report;
import java.io.IOException;
import java.sql.SQLException;
import javax.sql.DataSource;
@ -8,6 +7,7 @@ import javax.sql.DataSource;
import org.junit.jupiter.api.BeforeAll;
import pro.taskana.TaskanaEngine;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.impl.configuration.TaskanaEngineTestConfiguration;
import pro.taskana.sampledata.SampleDataGenerator;
@ -16,7 +16,7 @@ import pro.taskana.sampledata.SampleDataGenerator;
*/
public class AbstractReportAccTest {
protected static pro.taskana.configuration.TaskanaEngineConfiguration taskanaEngineConfiguration;
protected static TaskanaEngineConfiguration taskanaEngineConfiguration;
protected static TaskanaEngine taskanaEngine;
// checkstyle needs this constructor, since this is only a "utility" class
@ -28,11 +28,11 @@ public class AbstractReportAccTest {
resetDb();
}
private static void resetDb() throws SQLException, IOException {
private static void resetDb() throws SQLException {
DataSource dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
SampleDataGenerator sampleDataGenerator = new SampleDataGenerator(dataSource, schemaName);
taskanaEngineConfiguration = new pro.taskana.configuration.TaskanaEngineConfiguration(dataSource, false,
taskanaEngineConfiguration = new TaskanaEngineConfiguration(dataSource, false,
schemaName);
taskanaEngineConfiguration.setGermanPublicHolidaysEnabled(false);
taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();

22
lib/taskana-core/src/test/java/acceptance/task/CallbackStateAccTest.java
View File

@ -1,17 +1,9 @@
package acceptance.task;
<<<<<<< master
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
=======
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
>>>>>>> TSK-983: Remove junit 4 from taskana-core
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
@ -222,7 +214,6 @@ class CallbackStateAccTest extends AbstractAccTest {
List<String> externalIds = new ArrayList<>(
Arrays.asList(createdTask1.getExternalId(), createdTask2.getExternalId(), createdTask3.getExternalId()));
//complete a task
createdTask3 = (TaskImpl) taskService.forceCompleteTask(createdTask3.getId());
@ -258,7 +249,6 @@ class CallbackStateAccTest extends AbstractAccTest {
List<String> externalIds = new ArrayList<>(
Arrays.asList(createdTask1.getExternalId(), createdTask2.getExternalId(), createdTask3.getExternalId()));
//claim two tasks
createdTask1 = (TaskImpl) taskService.forceClaim(createdTask1.getId());
createdTask2 = (TaskImpl) taskService.forceClaim(createdTask2.getId());
@ -281,7 +271,6 @@ class CallbackStateAccTest extends AbstractAccTest {
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException {
TaskService taskService = taskanaEngine.getTaskService();
TaskImpl createdTask1 = createTask(taskService, CallbackState.CALLBACK_PROCESSING_REQUIRED);
@ -296,7 +285,6 @@ class CallbackStateAccTest extends AbstractAccTest {
List<String> externalIds = new ArrayList<>(
Arrays.asList(createdTask1.getExternalId(), createdTask2.getExternalId(), createdTask3.getExternalId()));
//It's only allowed to set the CallbackState to REQUIRED if the TaskState doesn't equal COMPLETE
//Therefore 1 task should not get updated
BulkOperationResults<String, TaskanaException> bulkResult = taskService.setCallbackStateForTasks(externalIds,
@ -311,15 +299,7 @@ class CallbackStateAccTest extends AbstractAccTest {
userName = "admin",
groupNames = {"group_1"})
@Test
void testQueriesWithCallbackState()
<<<<<<< master
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException, InvalidStateException,
=======
throws NotAuthorizedException,
TaskNotFoundException, InvalidStateException,
>>>>>>> TSK-983: Remove junit 4 from taskana-core
InvalidOwnerException, SQLException, IOException {
void testQueriesWithCallbackState() throws Exception {
resetDb(false);
TaskService taskService = taskanaEngine.getTaskService();

3
lib/taskana-core/src/test/java/acceptance/task/UpdateTaskAccTest.java
View File

@ -120,8 +120,7 @@ class UpdateTaskAccTest extends AbstractAccTest {
Task task2 = taskService.getTask("TKI:000000000000000000000000000000000000");
task.setCustomAttribute("1", "willi");
Task updatedTask = taskService.updateTask(task);
taskService.getTask(updatedTask.getId());
taskService.updateTask(task);
task2.setCustomAttribute("2", "Walter");
//TODO flaky test ... if speed is too high,

57
lib/taskana-core/src/test/java/pro/taskana/impl/WorkbasketServiceImplTest.java
View File

@ -5,8 +5,8 @@ import static org.hamcrest.Matchers.startsWith;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.hamcrest.core.IsNot.not;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
@ -14,6 +14,7 @@ import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.jupiter.api.Assertions;
@ -52,7 +53,7 @@ class WorkbasketServiceImplTest {
@Spy
@InjectMocks
private WorkbasketServiceImpl cutSpy;
private WorkbasketServiceImpl workbasketServiceSpy;
@Mock
private WorkbasketMapper workbasketMapperMock;
@ -89,15 +90,16 @@ class WorkbasketServiceImplTest {
WorkbasketAlreadyExistException, DomainNotFoundException {
final int distTargetAmount = 2;
WorkbasketImpl expectedWb = createTestWorkbasket(null, "Key-1");
doReturn(expectedWb).when(cutSpy).getWorkbasket(any());
doReturn(expectedWb).when(workbasketServiceSpy).getWorkbasket(any());
when(internalTaskanaEngineMock.domainExists(any())).thenReturn(true);
Workbasket actualWb = cutSpy.createWorkbasket(expectedWb);
cutSpy.setDistributionTargets(expectedWb.getId(), createTestDistributionTargets(distTargetAmount));
Workbasket actualWb = workbasketServiceSpy.createWorkbasket(expectedWb);
workbasketServiceSpy.setDistributionTargets(expectedWb.getId(),
createTestDistributionTargets(distTargetAmount));
verify(internalTaskanaEngineMock, times(4)).openConnection();
verify(workbasketMapperMock, times(3)).insert(any());
verify(cutSpy, times(distTargetAmount + 1)).getWorkbasket(any());
verify(workbasketServiceSpy, times(distTargetAmount + 1)).getWorkbasket(any());
verify(distributionTargetMapperMock, times(1)).deleteAllDistributionTargetsBySourceId(any());
verify(distributionTargetMapperMock, times(distTargetAmount)).insert(any(), any());
verify(workbasketMapperMock, times(3)).findByKeyAndDomain(any(), any());
@ -116,35 +118,35 @@ class WorkbasketServiceImplTest {
}
@Test
void testCreateWorkbasket_DistibutionTargetNotExisting()
throws NotAuthorizedException, WorkbasketNotFoundException {
void testCreateWorkbasket_DistibutionTargetNotExisting() throws Exception {
WorkbasketImpl expectedWb = createTestWorkbasket("ID-1", "Key-1");
when(internalTaskanaEngineMock.domainExists(any())).thenReturn(true);
String otherWorkbasketId = "4711";
List<String> destinations = Collections.singletonList(otherWorkbasketId);
workbasketServiceSpy.createWorkbasket(expectedWb);
doReturn(expectedWb).when(workbasketServiceSpy).getWorkbasket(eq(expectedWb.getId()));
WorkbasketNotFoundException e = Assertions.assertThrows(
WorkbasketNotFoundException.class, () -> {
cutSpy.createWorkbasket(expectedWb);
String id1 = "4711";
List<String> destinations = new ArrayList<>(Arrays.asList(id1));
cutSpy.setDistributionTargets(expectedWb.getId(), destinations);
doThrow(WorkbasketNotFoundException.class).when(cutSpy)
.getDistributionTargets(expectedWb.getId())
.get(0);
WorkbasketNotFoundException.class,
() -> workbasketServiceSpy.setDistributionTargets(expectedWb.getId(), destinations));
});
Assertions.assertEquals(e.getId(), otherWorkbasketId);
Assertions.assertNull(e.getKey());
Assertions.assertNull(e.getDomain());
verify(internalTaskanaEngineMock, times(3)).openConnection();
verify(workbasketMapperMock, times(1)).insert(expectedWb);
verify(workbasketMapperMock, times(1)).findById(any());
verify(workbasketMapperMock, times(1)).findByKeyAndDomain(any(), any());
verify(cutSpy, times(1)).getWorkbasket(any());
verify(workbasketServiceSpy, times(2)).getWorkbasket(any());
verify(internalTaskanaEngineMock, times(3)).returnConnection();
verify(taskanaEngine, times(2)).checkRoleMembership(any());
verify(internalTaskanaEngineMock, times(2)).getEngine();
verify(internalTaskanaEngineMock, times(1)).domainExists(any());
verify(distributionTargetMapperMock).deleteAllDistributionTargetsBySourceId(eq(expectedWb.getId()));
verify(workbasketMapperMock).update(eq(expectedWb));
verifyNoMoreInteractions(taskQueryMock, taskServiceMock, workbasketMapperMock, workbasketAccessMapperMock,
distributionTargetMapperMock,
internalTaskanaEngineMock, taskanaEngine, taskanaEngineConfigurationMock);
distributionTargetMapperMock, internalTaskanaEngineMock, taskanaEngine, taskanaEngineConfigurationMock);
}
@ -155,9 +157,8 @@ class WorkbasketServiceImplTest {
WorkbasketImpl expectedWb = createTestWorkbasket(null, "Key-1");
when(workbasketMapperMock.findById(any())).thenThrow(WorkbasketNotFoundException.class);
WorkbasketNotFoundException e = Assertions.assertThrows(
WorkbasketNotFoundException.class, () ->
cutSpy.createWorkbasket(expectedWb));
Assertions.assertThrows(
WorkbasketNotFoundException.class, () -> workbasketServiceSpy.createWorkbasket(expectedWb));
verify(internalTaskanaEngineMock, times(1)).openConnection();
verify(workbasketMapperMock, times(1)).insert(expectedWb);
@ -176,11 +177,11 @@ class WorkbasketServiceImplTest {
List<TaskSummary> usages = Arrays.asList(new TaskSummaryImpl(), new TaskSummaryImpl());
WorkbasketNotFoundException e = Assertions.assertThrows(
WorkbasketNotFoundException.class, () ->
cutSpy.deleteWorkbasket(wb.getId()));
WorkbasketNotFoundException.class,
() -> workbasketServiceSpy.deleteWorkbasket(wb.getId()));
verify(internalTaskanaEngineMock, times(2)).openConnection();
verify(cutSpy, times(1)).getWorkbasket(wb.getId());
verify(workbasketServiceSpy, times(1)).getWorkbasket(wb.getId());
verify(taskanaEngine, times(0)).getTaskService();
verify(taskServiceMock, times(0)).createTaskQuery();
verify(taskQueryMock, times(0)).workbasketIdIn(wb.getId());
@ -205,10 +206,10 @@ class WorkbasketServiceImplTest {
throws InvalidWorkbasketException, NotAuthorizedException,
WorkbasketAlreadyExistException, DomainNotFoundException {
List<String> distributionsTargets = new ArrayList<>();
amount = (amount < 0) ? 0 : amount;
amount = Math.max(amount, 0);
for (int i = 0; i < amount; i++) {
WorkbasketImpl wb = createTestWorkbasket("WB-ID-" + i, "WB-KEY-" + i);
cutSpy.createWorkbasket(wb);
workbasketServiceSpy.createWorkbasket(wb);
distributionsTargets.add(wb.getId());
}
return distributionsTargets;

4
lib/taskana-core/src/test/java/pro/taskana/impl/configuration/TaskanaEngineTestConfigurationTest.java
View File

@ -9,6 +9,7 @@ import javax.sql.DataSource;
import org.junit.jupiter.api.Test;
import pro.taskana.TaskanaEngine;
import pro.taskana.configuration.TaskanaEngineConfiguration;
/**
* Test of configuration.
@ -18,8 +19,7 @@ class TaskanaEngineTestConfigurationTest {
@Test
void testCreateTaskanaEngine() throws SQLException {
DataSource ds = TaskanaEngineTestConfiguration.getDataSource();
pro.taskana.configuration.TaskanaEngineConfiguration taskEngineConfiguration = new pro.taskana.configuration.TaskanaEngineConfiguration(
ds, false,
TaskanaEngineConfiguration taskEngineConfiguration = new TaskanaEngineConfiguration(ds, false,
TaskanaEngineTestConfiguration.getSchemaName());
TaskanaEngine te = taskEngineConfiguration.buildTaskanaEngine();

8
lib/taskana-core/src/test/java/pro/taskana/impl/integration/ClassificationServiceImplIntAutoCommitTest.java
View File

@ -24,6 +24,7 @@ import pro.taskana.ClassificationSummary;
import pro.taskana.TaskanaEngine;
import pro.taskana.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.TimeInterval;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.ClassificationAlreadyExistException;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.ConcurrencyException;
@ -44,7 +45,7 @@ class ClassificationServiceImplIntAutoCommitTest {
static int counter = 0;
private DataSource dataSource;
private ClassificationService classificationService;
private pro.taskana.configuration.TaskanaEngineConfiguration taskanaEngineConfiguration;
private TaskanaEngineConfiguration taskanaEngineConfiguration;
private TaskanaEngine taskanaEngine;
private TaskanaEngineImpl taskanaEngineImpl;
@ -59,14 +60,13 @@ class ClassificationServiceImplIntAutoCommitTest {
void setup() throws SQLException {
dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
taskanaEngineConfiguration = new pro.taskana.configuration.TaskanaEngineConfiguration(dataSource, false, false,
taskanaEngineConfiguration = new TaskanaEngineConfiguration(dataSource, false, false,
schemaName);
taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
classificationService = taskanaEngine.getClassificationService();
taskanaEngineImpl = (TaskanaEngineImpl) taskanaEngine;
taskanaEngineImpl.setConnectionManagementMode(ConnectionManagementMode.AUTOCOMMIT);
SampleDataGenerator sampleDataGenerator = new SampleDataGenerator(dataSource, schemaName);
sampleDataGenerator.clearDb();
new SampleDataGenerator(dataSource, schemaName).clearDb();
}
@Test

5
lib/taskana-core/src/test/java/pro/taskana/impl/integration/ClassificationServiceImplIntExplicitTest.java
View File

@ -29,6 +29,7 @@ import pro.taskana.ClassificationSummary;
import pro.taskana.TaskanaEngine;
import pro.taskana.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.TimeInterval;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.ClassificationAlreadyExistException;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.ConcurrencyException;
@ -52,7 +53,7 @@ public class ClassificationServiceImplIntExplicitTest {
static int counter = 0;
private DataSource dataSource;
private ClassificationService classificationService;
private pro.taskana.configuration.TaskanaEngineConfiguration taskanaEngineConfiguration;
private TaskanaEngineConfiguration taskanaEngineConfiguration;
private TaskanaEngine taskanaEngine;
private TaskanaEngineImpl taskanaEngineImpl;
@ -67,7 +68,7 @@ public class ClassificationServiceImplIntExplicitTest {
public void setup() throws SQLException {
dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
taskanaEngineConfiguration = new pro.taskana.configuration.TaskanaEngineConfiguration(dataSource, false, false,
taskanaEngineConfiguration = new TaskanaEngineConfiguration(dataSource, false, false,
schemaName);
taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
classificationService = taskanaEngine.getClassificationService();

7
lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntAutocommitTest.java
View File

@ -30,6 +30,7 @@ import pro.taskana.Workbasket;
import pro.taskana.WorkbasketAccessItem;
import pro.taskana.WorkbasketService;
import pro.taskana.WorkbasketType;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.ClassificationAlreadyExistException;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.DomainNotFoundException;
@ -67,7 +68,7 @@ class TaskServiceImplIntAutocommitTest {
private TaskServiceImpl taskServiceImpl;
private pro.taskana.configuration.TaskanaEngineConfiguration taskanaEngineConfiguration;
private TaskanaEngineConfiguration taskanaEngineConfiguration;
private TaskanaEngine taskanaEngine;
@ -81,7 +82,7 @@ class TaskServiceImplIntAutocommitTest {
void setup() throws SQLException {
dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
taskanaEngineConfiguration = new pro.taskana.configuration.TaskanaEngineConfiguration(dataSource, false, false,
taskanaEngineConfiguration = new TaskanaEngineConfiguration(dataSource, false, false,
schemaName);
taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
@ -267,7 +268,7 @@ class TaskServiceImplIntAutocommitTest {
// Set up Security for this Test
dataSource = TaskanaEngineTestConfiguration.getDataSource();
taskanaEngineConfiguration = new pro.taskana.configuration.TaskanaEngineConfiguration(dataSource, false, true,
taskanaEngineConfiguration = new TaskanaEngineConfiguration(dataSource, false, true,
TaskanaEngineTestConfiguration.getSchemaName());
taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
taskanaEngineImpl = (TaskanaEngineImpl) taskanaEngine;

9
lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntExplicitTest.java
View File

@ -35,6 +35,7 @@ import pro.taskana.WorkbasketAccessItem;
import pro.taskana.WorkbasketService;
import pro.taskana.WorkbasketType;
import pro.taskana.configuration.DbSchemaCreator;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.ClassificationAlreadyExistException;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.DomainNotFoundException;
@ -73,7 +74,7 @@ class TaskServiceImplIntExplicitTest {
private static TaskServiceImpl taskServiceImpl;
private static pro.taskana.configuration.TaskanaEngineConfiguration taskanaEngineConfiguration;
private static TaskanaEngineConfiguration taskanaEngineConfiguration;
private static TaskanaEngine taskanaEngine;
@ -90,8 +91,8 @@ class TaskServiceImplIntExplicitTest {
dataSource = new File(propertiesFileName).exists()
? TaskanaEngineTestConfiguration.createDataSourceFromProperties(propertiesFileName)
: pro.taskana.configuration.TaskanaEngineConfiguration.createDefaultDataSource();
taskanaEngineConfiguration = new pro.taskana.configuration.TaskanaEngineConfiguration(dataSource, false,
: TaskanaEngineConfiguration.createDefaultDataSource();
taskanaEngineConfiguration = new TaskanaEngineConfiguration(dataSource, false,
TaskanaEngineTestConfiguration.getSchemaName());
taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
taskServiceImpl = (TaskServiceImpl) taskanaEngine.getTaskService();
@ -362,7 +363,7 @@ class TaskServiceImplIntExplicitTest {
// Set up Security for this Test
dataSource = TaskanaEngineTestConfiguration.getDataSource();
taskanaEngineConfiguration = new pro.taskana.configuration.TaskanaEngineConfiguration(dataSource, false, true,
taskanaEngineConfiguration = new TaskanaEngineConfiguration(dataSource, false, true,
TaskanaEngineTestConfiguration.getSchemaName());
taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
taskanaEngineImpl = (TaskanaEngineImpl) taskanaEngine;

5
lib/taskana-core/src/test/java/pro/taskana/impl/integration/WorkbasketServiceImplIntAutocommitTest.java
View File

@ -31,6 +31,7 @@ import pro.taskana.WorkbasketAccessItem;
import pro.taskana.WorkbasketService;
import pro.taskana.WorkbasketSummary;
import pro.taskana.WorkbasketType;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.DomainNotFoundException;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.InvalidWorkbasketException;
@ -70,7 +71,7 @@ class WorkbasketServiceImplIntAutocommitTest {
void setup() throws SQLException {
DataSource dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
pro.taskana.configuration.TaskanaEngineConfiguration taskanaEngineConfiguration = new pro.taskana.configuration.TaskanaEngineConfiguration(
TaskanaEngineConfiguration taskanaEngineConfiguration = new TaskanaEngineConfiguration(
dataSource, false,
schemaName);
taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
@ -176,7 +177,7 @@ class WorkbasketServiceImplIntAutocommitTest {
accessItem.setPermAppend(true);
workBasketService.updateWorkbasketAccessItem(accessItem);
if (pro.taskana.configuration.TaskanaEngineConfiguration.shouldUseLowerCaseForAccessIds()) {
if (TaskanaEngineConfiguration.shouldUseLowerCaseForAccessIds()) {
assertEquals("zaphod beeblebrox", accessItem.getAccessId());
} else {
assertEquals("Zaphod Beeblebrox", accessItem.getAccessId());

5
lib/taskana-core/src/test/java/pro/taskana/impl/integration/WorkbasketServiceImplIntExplicitTest.java
View File

@ -24,6 +24,7 @@ import pro.taskana.WorkbasketAccessItem;
import pro.taskana.WorkbasketService;
import pro.taskana.WorkbasketSummary;
import pro.taskana.WorkbasketType;
import pro.taskana.configuration.TaskanaEngineConfiguration;
import pro.taskana.exceptions.DomainNotFoundException;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.InvalidWorkbasketException;
@ -49,7 +50,7 @@ class WorkbasketServiceImplIntExplicitTest {
private static final int SLEEP_TIME = 100;
static int counter = 0;
private DataSource dataSource;
private pro.taskana.configuration.TaskanaEngineConfiguration taskanaEngineConfiguration;
private TaskanaEngineConfiguration taskanaEngineConfiguration;
private TaskanaEngine taskanaEngine;
private TaskanaEngineImpl taskanaEngineImpl;
private WorkbasketService workBasketService;
@ -65,7 +66,7 @@ class WorkbasketServiceImplIntExplicitTest {
void setup() throws SQLException {
dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
taskanaEngineConfiguration = new pro.taskana.configuration.TaskanaEngineConfiguration(dataSource, false,
taskanaEngineConfiguration = new TaskanaEngineConfiguration(dataSource, false,
schemaName);
taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
taskanaEngineImpl = (TaskanaEngineImpl) taskanaEngine;

7
lib/taskana-core/src/test/java/pro/taskana/mappings/TaskTestMapper.java
View File

@ -24,10 +24,9 @@ public interface TaskTestMapper {
})
String getCustomAttributesAsString(@Param("taskId") String taskId);
@Select(
"SELECT ID, CREATED, CLAIMED, COMPLETED, MODIFIED, PLANNED, DUE, NAME, CREATOR, DESCRIPTION, NOTE, PRIORITY, STATE, CLASSIFICATION_CATEGORY, CLASSIFICATION_KEY, CLASSIFICATION_ID, WORKBASKET_ID, WORKBASKET_KEY, DOMAIN, BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, OWNER, POR_COMPANY, POR_SYSTEM, POR_INSTANCE, POR_TYPE, POR_VALUE, IS_READ, IS_TRANSFERRED, CUSTOM_ATTRIBUTES, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, CUSTOM_5, CUSTOM_6, CUSTOM_7, CUSTOM_8, CUSTOM_9, CUSTOM_10 "
+ "FROM TASK "
+ "WHERE CUSTOM_ATTRIBUTES like #{searchText}")
@Select("SELECT ID, CREATED, CLAIMED, COMPLETED, MODIFIED, PLANNED, DUE, NAME, CREATOR, DESCRIPTION, NOTE, PRIORITY, STATE, CLASSIFICATION_CATEGORY, CLASSIFICATION_KEY, CLASSIFICATION_ID, WORKBASKET_ID, WORKBASKET_KEY, DOMAIN, BUSINESS_PROCESS_ID, PARENT_BUSINESS_PROCESS_ID, OWNER, POR_COMPANY, POR_SYSTEM, POR_INSTANCE, POR_TYPE, POR_VALUE, IS_READ, IS_TRANSFERRED, CUSTOM_ATTRIBUTES, CUSTOM_1, CUSTOM_2, CUSTOM_3, CUSTOM_4, CUSTOM_5, CUSTOM_6, CUSTOM_7, CUSTOM_8, CUSTOM_9, CUSTOM_10 "
+ "FROM TASK "
+ "WHERE CUSTOM_ATTRIBUTES like #{searchText}")
@Results(value = {
@Result(property = "id", column = "ID"),
@Result(property = "created", column = "CREATED"),

2
lib/taskana-data/src/main/java/pro/taskana/sampledata/SQLReplacer.java
View File

@ -44,7 +44,7 @@ final class SQLReplacer {
}
static boolean isDb2(String dbProductName) {
return dbProductName.contains("DB2");
return dbProductName != null && dbProductName.contains("DB2");
}
/**

4
lib/taskana-data/src/main/java/pro/taskana/sampledata/SampleDataGenerator.java
View File

@ -64,10 +64,10 @@ public class SampleDataGenerator {
String cacheKey;
//dbtable constants?
if (tableExists("HISTORY_EVENTS")) {
scripts = SampleDataProvider.getDefaultScripts();
scripts = SampleDataProvider.getScriptsWithEvents();
cacheKey = CACHED_EVENTSAMPLE;
} else {
scripts = SampleDataProvider.getScriptsWithEvents();
scripts = SampleDataProvider.getDefaultScripts();
cacheKey = CACHED_SAMPLE;
}
executeAndCacheScripts(scripts, cacheKey);