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

TSK-2002: rename taskanaEngineConfiguration to taskanaConfiguration

This commit is contained in:
Mustapha Zorgati 2023-03-10 11:10:49 +01:00
parent 773ac7619d
commit ac95f8b181
56 changed files with 436 additions and 475 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
common/taskana-common/src/main/java/pro/taskana/common/internal/workingtime/HolidaySchedule.java
View File

@ -67,7 +67,7 @@ public class HolidaySchedule {
if (germanHolidaysEnabled && isGermanHoliday(date)) {
return true;
}
// Custom holidays that can be configured in the TaskanaEngineConfiguration
// Custom holidays that can be configured in the TaskanaConfiguration
return customHolidays.contains(CustomHoliday.of(date.getDayOfMonth(), date.getMonthValue()));
}

6
history/taskana-loghistory-provider/src/test/java/pro/taskana/loghistory/impl/LogfileHistoryServiceImplTest.java
View File

@ -38,12 +38,12 @@ class LogfileHistoryServiceImplTest {
@BeforeAll
public static void setupObjectMapper() {
TaskanaConfiguration taskanaEngineConfiguration = Mockito.mock(TaskanaConfiguration.class);
TaskanaConfiguration taskanaConfiguration = Mockito.mock(TaskanaConfiguration.class);
taskanaEngineMock = Mockito.mock(TaskanaEngine.class);
Mockito.when(taskanaEngineMock.getConfiguration()).thenReturn(taskanaEngineConfiguration);
Mockito.when(taskanaEngineMock.getConfiguration()).thenReturn(taskanaConfiguration);
Map<String, String> mockProperties = new HashMap<>();
mockProperties.put(LogfileHistoryServiceImpl.TASKANA_HISTORY_LOGGER_NAME, "AUDIT");
Mockito.when(taskanaEngineConfiguration.getProperties()).thenReturn(mockProperties);
Mockito.when(taskanaConfiguration.getProperties()).thenReturn(mockProperties);
}
@Test

16
history/taskana-simplehistory-provider/src/main/java/pro/taskana/simplehistory/impl/TaskanaHistoryEngineImpl.java
View File

@ -48,16 +48,16 @@ public class TaskanaHistoryEngineImpl implements TaskanaHistoryEngine {
private static final Logger LOGGER = LoggerFactory.getLogger(TaskanaHistoryEngineImpl.class);
private static final String DEFAULT = "default";
private final SqlSessionManager sessionManager;
private final TaskanaConfiguration taskanaEngineConfiguration;
private final TaskanaConfiguration taskanaConfiguration;
private final TaskanaEngine taskanaEngine;
private TransactionFactory transactionFactory;
private TaskanaHistory taskanaHistoryService;
protected TaskanaHistoryEngineImpl(TaskanaEngine taskanaEngine) {
this.taskanaEngineConfiguration = taskanaEngine.getConfiguration();
this.taskanaConfiguration = taskanaEngine.getConfiguration();
this.taskanaEngine = taskanaEngine;
createTransactionFactory(taskanaEngineConfiguration.isUseManagedTransactions());
createTransactionFactory(taskanaConfiguration.isUseManagedTransactions());
sessionManager = createSqlSessionManager();
}
@ -102,21 +102,19 @@ public class TaskanaHistoryEngineImpl implements TaskanaHistoryEngine {
}
public TaskanaConfiguration getConfiguration() {
return this.taskanaEngineConfiguration;
return this.taskanaConfiguration;
}
protected SqlSessionManager createSqlSessionManager() {
Environment environment =
new Environment(
DEFAULT, this.transactionFactory, taskanaEngineConfiguration.getDatasource());
new Environment(DEFAULT, this.transactionFactory, taskanaConfiguration.getDatasource());
Configuration configuration = new Configuration(environment);
// set databaseId
DB db;
try (Connection con = taskanaEngineConfiguration.getDatasource().getConnection()) {
try (Connection con = taskanaConfiguration.getDatasource().getConnection()) {
db = DB.getDB(con);
configuration.setDatabaseId(db.dbProductId);
} catch (SQLException e) {
throw new SystemException("Could not open a connection to set the databaseId", e);
}
@ -206,7 +204,7 @@ public class TaskanaHistoryEngineImpl implements TaskanaHistoryEngine {
*/
void openConnection() throws SQLException {
initSqlSession();
this.sessionManager.getConnection().setSchema(taskanaEngineConfiguration.getSchemaName());
this.sessionManager.getConnection().setSchema(taskanaConfiguration.getSchemaName());
}
/**

15
history/taskana-simplehistory-provider/src/test/java/acceptance/AbstractAccTest.java
View File

@ -33,7 +33,7 @@ import pro.taskana.task.internal.models.ObjectReferenceImpl;
/** Set up database for tests. */
public abstract class AbstractAccTest {
protected static TaskanaConfiguration taskanaEngineConfiguration;
protected static TaskanaConfiguration taskanaConfiguration;
protected static TaskanaHistoryEngineImpl taskanaHistoryEngine;
protected static TaskanaEngine taskanaEngine;
protected static SimpleHistoryServiceImpl historyService;
@ -101,23 +101,22 @@ public abstract class AbstractAccTest {
initOracleSchema(dataSource, schemaNameTmp);
}
}
TaskanaConfiguration tec =
TaskanaConfiguration configuration =
new TaskanaConfiguration.Builder(dataSource, false, schemaNameTmp)
.initTaskanaProperties()
.build();
initTaskanaEngine(tec);
initTaskanaEngine(configuration);
SampleDataGenerator sampleDataGenerator =
new SampleDataGenerator(dataSource, tec.getSchemaName());
new SampleDataGenerator(dataSource, configuration.getSchemaName());
sampleDataGenerator.clearDb();
sampleDataGenerator.generateTestData();
}
protected static void initTaskanaEngine(TaskanaConfiguration tec) throws SQLException {
taskanaEngineConfiguration = tec;
protected static void initTaskanaEngine(TaskanaConfiguration configuration) throws SQLException {
taskanaConfiguration = configuration;
taskanaEngine =
TaskanaEngine.buildTaskanaEngine(
taskanaEngineConfiguration, ConnectionManagementMode.AUTOCOMMIT);
TaskanaEngine.buildTaskanaEngine(taskanaConfiguration, ConnectionManagementMode.AUTOCOMMIT);
taskanaHistoryEngine = TaskanaHistoryEngineImpl.createTaskanaEngine(taskanaEngine);
taskService = taskanaEngine.getTaskService();
historyService = new SimpleHistoryServiceImpl();

7
history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/DeleteHistoryEventsOnTaskDeletionAccTest.java
View File

@ -158,11 +158,10 @@ class DeleteHistoryEventsOnTaskDeletionAccTest extends AbstractAccTest {
private void createTaskanaEngineWithNewConfig(boolean deleteHistoryOnTaskDeletionEnabled)
throws SQLException {
TaskanaConfiguration tec =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration configuration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.deleteHistoryOnTaskDeletionEnabled(deleteHistoryOnTaskDeletionEnabled)
.build();
initTaskanaEngine(tec);
initTaskanaEngine(configuration);
}
}

7
history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/GetTaskHistoryEventAccTest.java
View File

@ -62,11 +62,10 @@ class GetTaskHistoryEventAccTest extends AbstractAccTest {
}
private void createTaskanaEngineWithNewConfig(boolean addAdditionalUserInfo) throws SQLException {
TaskanaConfiguration tec =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration configuration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(addAdditionalUserInfo)
.build();
initTaskanaEngine(tec);
initTaskanaEngine(configuration);
}
}

6
history/taskana-simplehistory-provider/src/test/java/acceptance/jobs/HistoryCleanupJobAccTest.java
View File

@ -510,11 +510,11 @@ class HistoryCleanupJobAccTest extends AbstractAccTest {
private void createTaskanaEngineWithNewConfig(
boolean taskCleanupJobAllCompletedSameParentBusiness) throws SQLException {
TaskanaConfiguration tec =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration configuration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.taskCleanupJobAllCompletedSameParentBusiness(
taskCleanupJobAllCompletedSameParentBusiness)
.build();
initTaskanaEngine(tec);
initTaskanaEngine(configuration);
}
}

6
history/taskana-simplehistory-provider/src/test/java/acceptance/query/QueryTaskHistoryAccTest.java
View File

@ -536,10 +536,10 @@ class QueryTaskHistoryAccTest extends AbstractAccTest {
private void createTaskanaEngineWithNewConfig(boolean addAdditionalUserInfo) throws SQLException {
TaskanaConfiguration tec =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration configuration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(addAdditionalUserInfo)
.build();
initTaskanaEngine(tec);
initTaskanaEngine(configuration);
}
}

7
history/taskana-simplehistory-provider/src/test/java/configuration/TaskanaEngineConfigurationTest.java → history/taskana-simplehistory-provider/src/test/java/configuration/TaskanaConfigurationTest.java
View File

@ -10,18 +10,17 @@ import pro.taskana.TaskanaConfiguration;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.test.config.DataSourceGenerator;
/** Unit Test for TaskanaEngineConfigurationTest. */
class TaskanaEngineConfigurationTest extends AbstractAccTest {
class TaskanaConfigurationTest extends AbstractAccTest {
@Test
void testCreateTaskanaEngine() throws Exception {
DataSource ds = DataSourceGenerator.getDataSource();
TaskanaConfiguration taskEngineConfiguration =
TaskanaConfiguration configuration =
new TaskanaConfiguration.Builder(ds, false, DataSourceGenerator.getSchemaName(), false)
.initTaskanaProperties()
.build();
TaskanaEngine te = TaskanaEngine.buildTaskanaEngine(taskEngineConfiguration);
TaskanaEngine te = TaskanaEngine.buildTaskanaEngine(configuration);
assertThat(te).isNotNull();
}

6
history/taskana-simplehistory-provider/src/test/java/pro/taskana/simplehistory/impl/SimpleHistoryServiceImplTest.java
View File

@ -44,7 +44,7 @@ class SimpleHistoryServiceImplTest {
@Mock private TaskanaHistoryEngineImpl taskanaHistoryEngineMock;
@Mock private TaskanaConfiguration taskanaEngineConfiguration;
@Mock private TaskanaConfiguration taskanaConfiguration;
@Mock private TaskanaEngine taskanaEngine;
@ -85,8 +85,8 @@ class SimpleHistoryServiceImplTest {
AbstractAccTest.createTaskHistoryEvent(
"wbKey1", "taskId1", "type1", "wbKey2", "someUserId", "someDetails"));
when(taskanaHistoryEngineMock.getConfiguration()).thenReturn(taskanaEngineConfiguration);
when(taskanaEngineConfiguration.isAddAdditionalUserInfo()).thenReturn(false);
when(taskanaHistoryEngineMock.getConfiguration()).thenReturn(taskanaConfiguration);
when(taskanaConfiguration.isAddAdditionalUserInfo()).thenReturn(false);
when(taskanaHistoryEngineMock.getSqlSession()).thenReturn(sqlSessionMock);
when(sqlSessionMock.selectList(any(), any())).thenReturn(new ArrayList<>(returnList));

5
history/taskana-simplehistory-rest-spring/src/main/java/pro/taskana/simplehistory/rest/TaskHistoryEventController.java
View File

@ -42,14 +42,13 @@ public class TaskHistoryEventController {
@Autowired
public TaskHistoryEventController(
TaskanaConfiguration taskanaEngineConfiguration,
TaskanaConfiguration taskanaConfiguration,
SimpleHistoryServiceImpl simpleHistoryServiceImpl,
TaskHistoryEventRepresentationModelAssembler assembler)
throws SQLException {
this.simpleHistoryService = simpleHistoryServiceImpl;
this.simpleHistoryService.initialize(
TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration));
this.simpleHistoryService.initialize(TaskanaEngine.buildTaskanaEngine(taskanaConfiguration));
this.assembler = assembler;
}

6
lib/taskana-cdi/src/main/java/pro/taskana/common/internal/TaskanaProducers.java
View File

@ -33,7 +33,7 @@ public class TaskanaProducers {
@Inject private TaskanaEngine taskanaEngine;
private TaskanaConfiguration taskanaEngineConfiguration;
private TaskanaConfiguration taskanaConfiguration;
@PostConstruct
public void init() {
@ -53,7 +53,7 @@ public class TaskanaProducers {
LOGGER.debug("---------------> {}", metaData);
}
}
this.taskanaEngineConfiguration =
this.taskanaConfiguration =
new TaskanaConfiguration.Builder(dataSource, true, "TASKANA", false)
.initTaskanaProperties()
.build();
@ -65,7 +65,7 @@ public class TaskanaProducers {
@ApplicationScoped
@Produces
public TaskanaEngine generateTaskEngine() throws SQLException {
return TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
return TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
}
@ApplicationScoped

6
lib/taskana-core-test/src/test/java/acceptance/common/TaskanaEngineExplicitTest.java
View File

@ -22,17 +22,17 @@ class TaskanaEngineExplicitTest {
OracleSchemaHelper.initOracleSchema(TestContainerExtension.DATA_SOURCE, schemaName);
}
TaskanaConfiguration taskanaEngineConfiguration =
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(
TestContainerExtension.DATA_SOURCE, false, schemaName, true)
.initTaskanaProperties()
.build();
TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration, ConnectionManagementMode.EXPLICIT);
TaskanaEngine.buildTaskanaEngine(taskanaConfiguration, ConnectionManagementMode.EXPLICIT);
DbSchemaCreator dsc =
new DbSchemaCreator(
taskanaEngineConfiguration.getDatasource(), taskanaEngineConfiguration.getSchemaName());
taskanaConfiguration.getDatasource(), taskanaConfiguration.getSchemaName());
assertThat(dsc.isValidSchemaVersion(TaskanaEngine.MINIMAL_TASKANA_SCHEMA_VERSION)).isTrue();
}
}

14
lib/taskana-core-test/src/test/java/acceptance/jobs/JobSchedulerExecutionAccTest.java
View File

@ -30,7 +30,7 @@ import pro.taskana.task.api.models.ObjectReference;
import pro.taskana.task.api.models.TaskSummary;
import pro.taskana.task.internal.jobs.TaskCleanupJob;
import pro.taskana.testapi.DefaultTestEntities;
import pro.taskana.testapi.TaskanaEngineConfigurationModifier;
import pro.taskana.testapi.TaskanaConfigurationModifier;
import pro.taskana.testapi.TaskanaInject;
import pro.taskana.testapi.TaskanaIntegrationTest;
import pro.taskana.testapi.builder.TaskBuilder;
@ -39,7 +39,7 @@ import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.models.WorkbasketSummary;
@TaskanaIntegrationTest
class JobSchedulerExecutionAccTest implements TaskanaEngineConfigurationModifier {
class JobSchedulerExecutionAccTest implements TaskanaConfigurationModifier {
@TaskanaInject TaskanaConfiguration taskanaConfiguration;
@TaskanaInject TaskService taskService;
@TaskanaInject JobMapper jobMapper;
@ -48,8 +48,8 @@ class JobSchedulerExecutionAccTest implements TaskanaEngineConfigurationModifier
ObjectReference primaryObjRef;
@Override
public Builder modify(Builder taskanaEngineConfigurationBuilder) {
return taskanaEngineConfigurationBuilder
public Builder modify(Builder builder) {
return builder
.jobSchedulerEnableTaskCleanupJob(true)
.cleanupJobFirstRun(Instant.now().minus(10, ChronoUnit.MILLIS))
.cleanupJobRunEvery(Duration.ofMillis(1))
@ -113,7 +113,7 @@ class JobSchedulerExecutionAccTest implements TaskanaEngineConfigurationModifier
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class AJobFails implements TaskanaEngineConfigurationModifier {
class AJobFails implements TaskanaConfigurationModifier {
@TaskanaInject TaskanaConfiguration taskanaConfiguration;
@TaskanaInject TaskService taskService;
@ -123,8 +123,8 @@ class JobSchedulerExecutionAccTest implements TaskanaEngineConfigurationModifier
ObjectReference primaryObjRef;
@Override
public Builder modify(Builder taskanaEngineConfigurationBuilder) {
return taskanaEngineConfigurationBuilder
public Builder modify(Builder builder) {
return builder
.jobSchedulerEnableTaskCleanupJob(false)
.cleanupJobFirstRun(Instant.now().minus(10, ChronoUnit.MILLIS))
.cleanupJobRunEvery(Duration.ofMillis(1))

9
lib/taskana-core-test/src/test/java/acceptance/jobs/JobSchedulerInitAccTest.java
View File

@ -14,13 +14,13 @@ import pro.taskana.common.api.ScheduledJob;
import pro.taskana.common.internal.JobMapper;
import pro.taskana.task.internal.jobs.TaskCleanupJob;
import pro.taskana.task.internal.jobs.TaskUpdatePriorityJob;
import pro.taskana.testapi.TaskanaEngineConfigurationModifier;
import pro.taskana.testapi.TaskanaConfigurationModifier;
import pro.taskana.testapi.TaskanaInject;
import pro.taskana.testapi.TaskanaIntegrationTest;
import pro.taskana.workbasket.internal.jobs.WorkbasketCleanupJob;
@TaskanaIntegrationTest
class JobSchedulerInitAccTest implements TaskanaEngineConfigurationModifier {
class JobSchedulerInitAccTest implements TaskanaConfigurationModifier {
@TaskanaInject JobMapper jobMapper;
@ -28,9 +28,8 @@ class JobSchedulerInitAccTest implements TaskanaEngineConfigurationModifier {
Duration runEvery = Duration.ofMinutes(5);
@Override
public TaskanaConfiguration.Builder modify(
TaskanaConfiguration.Builder taskanaEngineConfigurationBuilder) {
return taskanaEngineConfigurationBuilder
public TaskanaConfiguration.Builder modify(TaskanaConfiguration.Builder builder) {
return builder
.cleanupJobRunEvery(runEvery)
.cleanupJobFirstRun(firstRun)
// config for TaskUpdatePriorityJob

17
lib/taskana-core-test/src/test/java/acceptance/task/complete/CompleteTaskAccTest.java
View File

@ -33,7 +33,7 @@ import pro.taskana.task.api.exceptions.TaskNotFoundException;
import pro.taskana.task.api.models.ObjectReference;
import pro.taskana.task.api.models.Task;
import pro.taskana.testapi.DefaultTestEntities;
import pro.taskana.testapi.TaskanaEngineConfigurationModifier;
import pro.taskana.testapi.TaskanaConfigurationModifier;
import pro.taskana.testapi.TaskanaInject;
import pro.taskana.testapi.TaskanaIntegrationTest;
import pro.taskana.testapi.builder.TaskBuilder;
@ -47,7 +47,7 @@ import pro.taskana.workbasket.api.exceptions.MismatchedWorkbasketPermissionExcep
import pro.taskana.workbasket.api.models.WorkbasketSummary;
@TaskanaIntegrationTest
class CompleteTaskAccTest implements TaskanaEngineConfigurationModifier {
class CompleteTaskAccTest implements TaskanaConfigurationModifier {
@TaskanaInject TaskService taskService;
@TaskanaInject CurrentUserContext currentUserContext;
@ -61,9 +61,8 @@ class CompleteTaskAccTest implements TaskanaEngineConfigurationModifier {
ObjectReference defaultObjectReference;
@Override
public TaskanaConfiguration.Builder modify(
TaskanaConfiguration.Builder taskanaEngineConfigurationBuilder) {
return taskanaEngineConfigurationBuilder.addAdditionalUserInfo(true);
public TaskanaConfiguration.Builder modify(TaskanaConfiguration.Builder builder) {
return builder.addAdditionalUserInfo(true);
}
@WithAccessId(user = "businessadmin")
@ -83,8 +82,12 @@ class CompleteTaskAccTest implements TaskanaEngineConfigurationModifier {
defaultObjectReference = DefaultTestEntities.defaultTestObjectReference().build();
UserBuilder user11 = UserBuilder.newUser().id("user-1-1")
.longName("Mustermann, Max - (user-1-1)").firstName("Max").lastName("Mustermann");
UserBuilder user11 =
UserBuilder.newUser()
.id("user-1-1")
.longName("Mustermann, Max - (user-1-1)")
.firstName("Max")
.lastName("Mustermann");
user11.buildAndStore(userService);
}

5
lib/taskana-core-test/src/test/java/acceptance/task/requestchanges/RequestChangesWithAfterSpiAccTest.java
View File

@ -247,10 +247,9 @@ public class RequestChangesWithAfterSpiAccTest {
PlainJavaTransactionProvider transactionProvider;
@BeforeAll
void setup(TaskanaConfiguration taskanaEngineConfiguration) {
void setup(TaskanaConfiguration taskanaConfiguration) {
transactionProvider =
new PlainJavaTransactionProvider(
taskanaEngine, taskanaEngineConfiguration.getDatasource());
new PlainJavaTransactionProvider(taskanaEngine, taskanaConfiguration.getDatasource());
}
@WithAccessId(user = "user-1-1")

5
lib/taskana-core-test/src/test/java/acceptance/task/requestchanges/RequestChangesWithBeforeSpiAccTest.java
View File

@ -282,10 +282,9 @@ public class RequestChangesWithBeforeSpiAccTest {
PlainJavaTransactionProvider transactionProvider;
@BeforeAll
void setup(TaskanaConfiguration taskanaEngineConfiguration) {
void setup(TaskanaConfiguration taskanaConfiguration) {
transactionProvider =
new PlainJavaTransactionProvider(
taskanaEngine, taskanaEngineConfiguration.getDatasource());
new PlainJavaTransactionProvider(taskanaEngine, taskanaConfiguration.getDatasource());
}
@WithAccessId(user = "user-1-1")

5
lib/taskana-core-test/src/test/java/acceptance/task/requestreview/RequestReviewWithAfterSpiAccTest.java
View File

@ -248,10 +248,9 @@ public class RequestReviewWithAfterSpiAccTest {
PlainJavaTransactionProvider transactionProvider;
@BeforeAll
void setup(TaskanaConfiguration taskanaEngineConfiguration) {
void setup(TaskanaConfiguration taskanaConfiguration) {
transactionProvider =
new PlainJavaTransactionProvider(
taskanaEngine, taskanaEngineConfiguration.getDatasource());
new PlainJavaTransactionProvider(taskanaEngine, taskanaConfiguration.getDatasource());
}
@WithAccessId(user = "user-1-1")

5
lib/taskana-core-test/src/test/java/acceptance/task/requestreview/RequestReviewWithBeforeSpiAccTest.java
View File

@ -283,10 +283,9 @@ public class RequestReviewWithBeforeSpiAccTest {
PlainJavaTransactionProvider transactionProvider;
@BeforeAll
void setup(TaskanaConfiguration taskanaEngineConfiguration) {
void setup(TaskanaConfiguration taskanaConfiguration) {
transactionProvider =
new PlainJavaTransactionProvider(
taskanaEngine, taskanaEngineConfiguration.getDatasource());
new PlainJavaTransactionProvider(taskanaEngine, taskanaConfiguration.getDatasource());
}
@WithAccessId(user = "user-1-1")

16
lib/taskana-core-test/src/test/java/acceptance/taskcomment/get/GetTaskCommentAccTest.java
View File

@ -22,7 +22,7 @@ import pro.taskana.task.api.exceptions.TaskCommentNotFoundException;
import pro.taskana.task.api.models.Task;
import pro.taskana.task.api.models.TaskComment;
import pro.taskana.testapi.DefaultTestEntities;
import pro.taskana.testapi.TaskanaEngineConfigurationModifier;
import pro.taskana.testapi.TaskanaConfigurationModifier;
import pro.taskana.testapi.TaskanaInject;
import pro.taskana.testapi.TaskanaIntegrationTest;
import pro.taskana.testapi.builder.TaskBuilder;
@ -188,16 +188,15 @@ class GetTaskCommentAccTest {
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class WithAdditionalUserInfoEnabled implements TaskanaEngineConfigurationModifier {
class WithAdditionalUserInfoEnabled implements TaskanaConfigurationModifier {
@TaskanaInject TaskService taskService;
@TaskanaInject UserService userService;
@Override
public TaskanaConfiguration.Builder modify(
TaskanaConfiguration.Builder taskanaEngineConfigurationBuilder) {
return taskanaEngineConfigurationBuilder.addAdditionalUserInfo(true);
public TaskanaConfiguration.Builder modify(TaskanaConfiguration.Builder builder) {
return builder.addAdditionalUserInfo(true);
}
@WithAccessId(user = "user-1-1")
@ -244,14 +243,13 @@ class GetTaskCommentAccTest {
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class WithAdditionalUserInfoDisabled implements TaskanaEngineConfigurationModifier {
class WithAdditionalUserInfoDisabled implements TaskanaConfigurationModifier {
@TaskanaInject TaskService taskService;
@Override
public TaskanaConfiguration.Builder modify(
TaskanaConfiguration.Builder taskanaEngineConfigurationBuilder) {
return taskanaEngineConfigurationBuilder.addAdditionalUserInfo(false);
public TaskanaConfiguration.Builder modify(TaskanaConfiguration.Builder builder) {
return builder.addAdditionalUserInfo(false);
}
@WithAccessId(user = "user-1-1")

18
lib/taskana-core-test/src/test/java/acceptance/user/UserServiceAccTest.java
View File

@ -32,7 +32,7 @@ import pro.taskana.common.api.TaskanaRole;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.MismatchedRoleException;
import pro.taskana.common.internal.util.Triplet;
import pro.taskana.testapi.TaskanaEngineConfigurationModifier;
import pro.taskana.testapi.TaskanaConfigurationModifier;
import pro.taskana.testapi.TaskanaInject;
import pro.taskana.testapi.TaskanaIntegrationTest;
import pro.taskana.testapi.builder.WorkbasketAccessItemBuilder;
@ -1011,16 +1011,14 @@ class UserServiceAccTest {
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class DifferentMinimalPermissionsToAssignDomains implements TaskanaEngineConfigurationModifier {
class DifferentMinimalPermissionsToAssignDomains implements TaskanaConfigurationModifier {
@TaskanaInject UserService userService;
@TaskanaInject WorkbasketService workbasketService;
@Override
public TaskanaConfiguration.Builder modify(
TaskanaConfiguration.Builder taskanaEngineConfigurationBuilder) {
return taskanaEngineConfigurationBuilder.minimalPermissionsToAssignDomains(
List.of(WorkbasketPermission.APPEND));
public TaskanaConfiguration.Builder modify(TaskanaConfiguration.Builder builder) {
return builder.minimalPermissionsToAssignDomains(List.of(WorkbasketPermission.APPEND));
}
@WithAccessId(user = "user-1-1")
@ -1090,16 +1088,14 @@ class UserServiceAccTest {
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class PropertyMinimalPermissionsToAssignDomainsIsNotSet
implements TaskanaEngineConfigurationModifier {
implements TaskanaConfigurationModifier {
@TaskanaInject UserService userService;
@TaskanaInject WorkbasketService workbasketService;
@Override
public TaskanaConfiguration.Builder modify(
TaskanaConfiguration.Builder taskanaEngineConfigurationBuilder) {
return taskanaEngineConfigurationBuilder.minimalPermissionsToAssignDomains(
new ArrayList<>());
public TaskanaConfiguration.Builder modify(TaskanaConfiguration.Builder builder) {
return builder.minimalPermissionsToAssignDomains(new ArrayList<>());
}
@WithAccessId(user = "user-1-1")

80
lib/taskana-core/src/main/java/pro/taskana/TaskanaConfiguration.java
View File

@ -619,48 +619,48 @@ public class TaskanaConfiguration {
private Map<String, String> properties = Collections.emptyMap();
// endregion
public Builder(TaskanaConfiguration tec) {
this.dataSource = tec.getDatasource();
this.schemaName = tec.getSchemaName();
this.properties = tec.getProperties();
this.roleMap = tec.getRoleMap();
this.securityEnabled = tec.isSecurityEnabled();
this.useManagedTransactions = tec.isUseManagedTransactions();
this.domains = tec.getDomains();
this.classificationTypes = tec.getClassificationTypes();
this.classificationCategoriesByType = tec.getClassificationCategoriesByType();
this.customHolidays = tec.getCustomHolidays();
this.deleteHistoryOnTaskDeletionEnabled = tec.isDeleteHistoryOnTaskDeletionEnabled();
this.germanPublicHolidaysEnabled = tec.isGermanPublicHolidaysEnabled();
this.corpusChristiEnabled = tec.isCorpusChristiEnabled();
this.workingTimeSchedule = tec.getWorkingTimeSchedule();
this.jobBatchSize = tec.getJobBatchSize();
this.maxNumberOfJobRetries = tec.getMaxNumberOfJobRetries();
this.cleanupJobFirstRun = tec.getCleanupJobFirstRun();
this.cleanupJobRunEvery = tec.getCleanupJobRunEvery();
this.cleanupJobMinimumAge = tec.getCleanupJobMinimumAge();
public Builder(TaskanaConfiguration conf) {
this.dataSource = conf.getDatasource();
this.schemaName = conf.getSchemaName();
this.properties = conf.getProperties();
this.roleMap = conf.getRoleMap();
this.securityEnabled = conf.isSecurityEnabled();
this.useManagedTransactions = conf.isUseManagedTransactions();
this.domains = conf.getDomains();
this.classificationTypes = conf.getClassificationTypes();
this.classificationCategoriesByType = conf.getClassificationCategoriesByType();
this.customHolidays = conf.getCustomHolidays();
this.deleteHistoryOnTaskDeletionEnabled = conf.isDeleteHistoryOnTaskDeletionEnabled();
this.germanPublicHolidaysEnabled = conf.isGermanPublicHolidaysEnabled();
this.corpusChristiEnabled = conf.isCorpusChristiEnabled();
this.workingTimeSchedule = conf.getWorkingTimeSchedule();
this.jobBatchSize = conf.getJobBatchSize();
this.maxNumberOfJobRetries = conf.getMaxNumberOfJobRetries();
this.cleanupJobFirstRun = conf.getCleanupJobFirstRun();
this.cleanupJobRunEvery = conf.getCleanupJobRunEvery();
this.cleanupJobMinimumAge = conf.getCleanupJobMinimumAge();
this.taskCleanupJobAllCompletedSameParentBusiness =
tec.isTaskCleanupJobAllCompletedSameParentBusiness();
this.allowTimestampServiceLevelMismatch = tec.isAllowTimestampServiceLevelMismatch();
this.addAdditionalUserInfo = tec.isAddAdditionalUserInfo();
this.priorityJobBatchSize = tec.getPriorityJobBatchSize();
this.priorityJobFirstRun = tec.getPriorityJobFirstRun();
this.priorityJobRunEvery = tec.getPriorityJobRunEvery();
this.priorityJobActive = tec.isPriorityJobActive();
this.userRefreshJobRunEvery = tec.getUserRefreshJobRunEvery();
this.userRefreshJobFirstRun = tec.getUserRefreshJobFirstRun();
this.minimalPermissionsToAssignDomains = tec.getMinimalPermissionsToAssignDomains();
this.jobSchedulerEnabled = tec.isJobSchedulerEnabled();
this.jobSchedulerInitialStartDelay = tec.getJobSchedulerInitialStartDelay();
this.jobSchedulerPeriod = tec.getJobSchedulerPeriod();
this.jobSchedulerPeriodTimeUnit = tec.getJobSchedulerPeriodTimeUnit();
this.jobSchedulerEnableTaskCleanupJob = tec.isJobSchedulerEnableTaskCleanupJob();
conf.isTaskCleanupJobAllCompletedSameParentBusiness();
this.allowTimestampServiceLevelMismatch = conf.isAllowTimestampServiceLevelMismatch();
this.addAdditionalUserInfo = conf.isAddAdditionalUserInfo();
this.priorityJobBatchSize = conf.getPriorityJobBatchSize();
this.priorityJobFirstRun = conf.getPriorityJobFirstRun();
this.priorityJobRunEvery = conf.getPriorityJobRunEvery();
this.priorityJobActive = conf.isPriorityJobActive();
this.userRefreshJobRunEvery = conf.getUserRefreshJobRunEvery();
this.userRefreshJobFirstRun = conf.getUserRefreshJobFirstRun();
this.minimalPermissionsToAssignDomains = conf.getMinimalPermissionsToAssignDomains();
this.jobSchedulerEnabled = conf.isJobSchedulerEnabled();
this.jobSchedulerInitialStartDelay = conf.getJobSchedulerInitialStartDelay();
this.jobSchedulerPeriod = conf.getJobSchedulerPeriod();
this.jobSchedulerPeriodTimeUnit = conf.getJobSchedulerPeriodTimeUnit();
this.jobSchedulerEnableTaskCleanupJob = conf.isJobSchedulerEnableTaskCleanupJob();
this.jobSchedulerEnableTaskUpdatePriorityJob =
tec.isJobSchedulerEnableTaskUpdatePriorityJob();
this.jobSchedulerEnableWorkbasketCleanupJob = tec.isJobSchedulerEnableWorkbasketCleanupJob();
this.jobSchedulerEnableUserInfoRefreshJob = tec.isJobSchedulerEnableUserInfoRefreshJob();
this.jobSchedulerEnableHistorieCleanupJob = tec.isJobSchedulerEnableHistorieCleanupJob();
this.jobSchedulerCustomJobs = tec.getJobSchedulerCustomJobs();
conf.isJobSchedulerEnableTaskUpdatePriorityJob();
this.jobSchedulerEnableWorkbasketCleanupJob = conf.isJobSchedulerEnableWorkbasketCleanupJob();
this.jobSchedulerEnableUserInfoRefreshJob = conf.isJobSchedulerEnableUserInfoRefreshJob();
this.jobSchedulerEnableHistorieCleanupJob = conf.isJobSchedulerEnableHistorieCleanupJob();
this.jobSchedulerCustomJobs = conf.getJobSchedulerCustomJobs();
}
public Builder(DataSource dataSource, boolean useManagedTransactions, String schemaName) {

2
lib/taskana-core/src/main/java/pro/taskana/common/api/TaskanaEngine.java
View File

@ -101,7 +101,7 @@ public interface TaskanaEngine {
* Builds an {@linkplain TaskanaEngine} based on {@linkplain TaskanaConfiguration} and
* SqlConnectionMode.
*
* @param configuration complete taskanaEngineConfig to build the engine
* @param configuration complete taskanaConfig to build the engine
* @param connectionManagementMode connectionMode for the SqlSession
* @return a {@linkplain TaskanaEngineImpl}
* @throws SQLException when the db schema could not be initialized

59
lib/taskana-core/src/main/java/pro/taskana/common/internal/TaskanaEngineImpl.java
View File

@ -89,7 +89,7 @@ public class TaskanaEngineImpl implements TaskanaEngine {
// must match the VERSION value in table
private static final Logger LOGGER = LoggerFactory.getLogger(TaskanaEngineImpl.class);
private static final SessionStack SESSION_STACK = new SessionStack();
protected final TaskanaConfiguration taskanaEngineConfiguration;
protected final TaskanaConfiguration taskanaConfiguration;
private final TaskRoutingManager taskRoutingManager;
private final CreateTaskPreprocessorManager createTaskPreprocessorManager;
private final PriorityServiceManager priorityServiceManager;
@ -110,12 +110,11 @@ public class TaskanaEngineImpl implements TaskanaEngine {
protected Connection connection;
protected TaskanaEngineImpl(
TaskanaConfiguration taskanaEngineConfiguration,
ConnectionManagementMode connectionManagementMode)
TaskanaConfiguration taskanaConfiguration, ConnectionManagementMode connectionManagementMode)
throws SQLException {
LOGGER.info(
"initializing TASKANA with this configuration: {} and this mode: {}",
taskanaEngineConfiguration,
taskanaConfiguration,
connectionManagementMode);
if (connectionManagementMode == EXPLICIT) {
// at first we initialize Taskana DB with autocommit,
@ -124,22 +123,22 @@ public class TaskanaEngineImpl implements TaskanaEngine {
} else {
this.mode = connectionManagementMode;
}
this.taskanaEngineConfiguration = taskanaEngineConfiguration;
this.taskanaConfiguration = taskanaConfiguration;
internalTaskanaEngineImpl = new InternalTaskanaEngineImpl();
HolidaySchedule holidaySchedule =
new HolidaySchedule(
taskanaEngineConfiguration.isGermanPublicHolidaysEnabled(),
taskanaEngineConfiguration.isCorpusChristiEnabled(),
taskanaEngineConfiguration.getCustomHolidays());
taskanaConfiguration.isGermanPublicHolidaysEnabled(),
taskanaConfiguration.isCorpusChristiEnabled(),
taskanaConfiguration.getCustomHolidays());
workingTimeCalculator =
new WorkingTimeCalculatorImpl(
holidaySchedule, taskanaEngineConfiguration.getWorkingTimeSchedule());
holidaySchedule, taskanaConfiguration.getWorkingTimeSchedule());
currentUserContext =
new CurrentUserContextImpl(TaskanaConfiguration.shouldUseLowerCaseForAccessIds());
createTransactionFactory(taskanaEngineConfiguration.isUseManagedTransactions());
createTransactionFactory(taskanaConfiguration.isUseManagedTransactions());
sessionManager = createSqlSessionManager();
initializeDbSchema(taskanaEngineConfiguration);
initializeDbSchema(taskanaConfiguration);
// IMPORTANT: SPI has to be initialized last (and in this order) in order
// to provide a fully initialized TaskanaEngine instance during the SPI initialization!
@ -153,17 +152,17 @@ public class TaskanaEngineImpl implements TaskanaEngine {
beforeRequestChangesManager = new BeforeRequestChangesManager(this);
afterRequestChangesManager = new AfterRequestChangesManager(this);
if (this.taskanaEngineConfiguration.isJobSchedulerEnabled()) {
TaskanaConfiguration tec =
new TaskanaConfiguration.Builder(this.taskanaEngineConfiguration)
if (this.taskanaConfiguration.isJobSchedulerEnabled()) {
TaskanaConfiguration configuration =
new TaskanaConfiguration.Builder(this.taskanaConfiguration)
.jobSchedulerEnabled(false)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(tec, EXPLICIT);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(configuration, EXPLICIT);
RealClock clock =
new RealClock(
this.taskanaEngineConfiguration.getJobSchedulerInitialStartDelay(),
this.taskanaEngineConfiguration.getJobSchedulerPeriod(),
this.taskanaEngineConfiguration.getJobSchedulerPeriodTimeUnit());
this.taskanaConfiguration.getJobSchedulerInitialStartDelay(),
this.taskanaConfiguration.getJobSchedulerPeriod(),
this.taskanaConfiguration.getJobSchedulerPeriodTimeUnit());
JobScheduler jobScheduler = new JobScheduler(taskanaEngine, clock);
jobScheduler.start();
}
@ -173,10 +172,9 @@ public class TaskanaEngineImpl implements TaskanaEngine {
}
public static TaskanaEngine createTaskanaEngine(
TaskanaConfiguration taskanaEngineConfiguration,
ConnectionManagementMode connectionManagementMode)
TaskanaConfiguration taskanaConfiguration, ConnectionManagementMode connectionManagementMode)
throws SQLException {
return new TaskanaEngineImpl(taskanaEngineConfiguration, connectionManagementMode);
return new TaskanaEngineImpl(taskanaConfiguration, connectionManagementMode);
}
@Override
@ -232,7 +230,7 @@ public class TaskanaEngineImpl implements TaskanaEngine {
// disabling auto commit for passed connection in order to gain full control over the
// connection management
connection.setAutoCommit(false);
connection.setSchema(taskanaEngineConfiguration.getSchemaName());
connection.setSchema(taskanaConfiguration.getSchemaName());
mode = EXPLICIT;
sessionManager.startManagedSession(connection);
} else if (this.connection != null) {
@ -260,7 +258,7 @@ public class TaskanaEngineImpl implements TaskanaEngine {
@Override
public TaskanaConfiguration getConfiguration() {
return this.taskanaEngineConfiguration;
return this.taskanaConfiguration;
}
@Override
@ -364,16 +362,14 @@ public class TaskanaEngineImpl implements TaskanaEngine {
*/
protected SqlSessionManager createSqlSessionManager() {
Environment environment =
new Environment(
"default", this.transactionFactory, taskanaEngineConfiguration.getDatasource());
new Environment("default", this.transactionFactory, taskanaConfiguration.getDatasource());
Configuration configuration = new Configuration(environment);
// set databaseId
DB db;
try (Connection con = taskanaEngineConfiguration.getDatasource().getConnection()) {
try (Connection con = taskanaConfiguration.getDatasource().getConnection()) {
db = DB.getDB(con);
configuration.setDatabaseId(db.dbProductId);
} catch (SQLException e) {
throw new SystemException(
"Method createSqlSessionManager() could not open a connection "
@ -426,11 +422,10 @@ public class TaskanaEngineImpl implements TaskanaEngine {
return SqlSessionManager.newInstance(localSessionFactory);
}
private void initializeDbSchema(TaskanaConfiguration taskanaEngineConfiguration)
throws SQLException {
private void initializeDbSchema(TaskanaConfiguration taskanaConfiguration) throws SQLException {
DbSchemaCreator dbSchemaCreator =
new DbSchemaCreator(
taskanaEngineConfiguration.getDatasource(), taskanaEngineConfiguration.getSchemaName());
taskanaConfiguration.getDatasource(), taskanaConfiguration.getSchemaName());
boolean schemaCreated = dbSchemaCreator.run();
if (!schemaCreated && !dbSchemaCreator.isValidSchemaVersion(MINIMAL_TASKANA_SCHEMA_VERSION)) {
@ -439,7 +434,7 @@ public class TaskanaEngineImpl implements TaskanaEngine {
+ MINIMAL_TASKANA_SCHEMA_VERSION);
}
((ConfigurationServiceImpl) getConfigurationService())
.checkSecureAccess(taskanaEngineConfiguration.isSecurityEnabled());
.checkSecureAccess(taskanaConfiguration.isSecurityEnabled());
((ConfigurationServiceImpl) getConfigurationService()).setupDefaultCustomAttributes();
}
@ -505,7 +500,7 @@ public class TaskanaEngineImpl implements TaskanaEngine {
public void openConnection() {
initSqlSession();
try {
sessionManager.getConnection().setSchema(taskanaEngineConfiguration.getSchemaName());
sessionManager.getConnection().setSchema(taskanaConfiguration.getSchemaName());
} catch (SQLException e) {
throw new SystemException(
"Method openConnection() could not open a connection "

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

@ -37,7 +37,7 @@ public abstract class AbstractAccTest {
public static final String GROUP_2_DN =
"cn=Organisationseinheit KSC 2,cn=Organisationseinheit KSC,cn=organisation,OU=Test,O=TASKANA";
protected static TaskanaConfiguration taskanaEngineConfiguration;
protected static TaskanaConfiguration taskanaConfiguration;
protected static TaskanaEngine taskanaEngine;
protected static TaskServiceImpl taskService;
@ -53,19 +53,18 @@ public abstract class AbstractAccTest {
DataSource dataSource = DataSourceGenerator.getDataSource();
String schemaName = DataSourceGenerator.getSchemaName();
taskanaEngineConfiguration =
taskanaConfiguration =
new TaskanaConfiguration.Builder(dataSource, false, schemaName)
.initTaskanaProperties()
.germanPublicHolidaysEnabled(true)
.build();
SampleDataGenerator sampleDataGenerator =
new SampleDataGenerator(dataSource, taskanaEngineConfiguration.getSchemaName());
new SampleDataGenerator(dataSource, taskanaConfiguration.getSchemaName());
if (dropTables) {
sampleDataGenerator.dropDb();
}
taskanaEngine =
TaskanaEngine.buildTaskanaEngine(
taskanaEngineConfiguration, ConnectionManagementMode.AUTOCOMMIT);
TaskanaEngine.buildTaskanaEngine(taskanaConfiguration, ConnectionManagementMode.AUTOCOMMIT);
workingTimeCalculator = taskanaEngine.getWorkingTimeCalculator();
taskService = (TaskServiceImpl) taskanaEngine.getTaskService();

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

@ -22,11 +22,11 @@ import pro.taskana.workbasket.api.WorkbasketPermission;
class TaskanaConfigAccTest {
@TempDir Path tempDir;
private TaskanaConfiguration taskanaEngineConfiguration;
private TaskanaConfiguration taskanaConfiguration;
@BeforeEach
void setup() {
taskanaEngineConfiguration =
taskanaConfiguration =
new TaskanaConfiguration.Builder(
DataSourceGenerator.getDataSource(), true, DataSourceGenerator.getSchemaName())
.initTaskanaProperties()
@ -35,25 +35,24 @@ class TaskanaConfigAccTest {
@Test
void should_ConfigureDomains_For_DefaultPropertiesFile() {
assertThat(taskanaEngineConfiguration.getDomains())
.containsExactlyInAnyOrder("DOMAIN_A", "DOMAIN_B");
assertThat(taskanaConfiguration.getDomains()).containsExactlyInAnyOrder("DOMAIN_A", "DOMAIN_B");
}
@Test
void should_ConfigureMinimalPermissionsToAssignDomains_For_DefaultPropertiesFile() {
assertThat(taskanaEngineConfiguration.getMinimalPermissionsToAssignDomains())
assertThat(taskanaConfiguration.getMinimalPermissionsToAssignDomains())
.containsExactly(WorkbasketPermission.READ, WorkbasketPermission.OPEN);
}
@Test
void should_ConfigureClassificationTypes_For_DefaultPropertiesFile() {
assertThat(taskanaEngineConfiguration.getClassificationTypes())
assertThat(taskanaConfiguration.getClassificationTypes())
.containsExactlyInAnyOrder("TASK", "DOCUMENT");
}
@Test
void should_ConfigureClassificationCategories_For_DefaultPropertiesFile() {
assertThat(taskanaEngineConfiguration.getClassificationCategoriesByType("TASK"))
assertThat(taskanaConfiguration.getClassificationCategoriesByType("TASK"))
.containsExactlyInAnyOrder("EXTERNAL", "MANUAL", "AUTOMATIC", "PROCESS");
}
@ -61,7 +60,7 @@ class TaskanaConfigAccTest {
void should_NotConfigureClassificationTypes_When_PropertiesAreNotDefined() throws Exception {
String propertiesFileName = createNewConfigFile("dummyTestConfig1.properties", false, true);
String delimiter = ";";
taskanaEngineConfiguration =
taskanaConfiguration =
new TaskanaConfiguration.Builder(
DataSourceGenerator.getDataSource(),
true,
@ -69,14 +68,14 @@ class TaskanaConfigAccTest {
true)
.initTaskanaProperties(propertiesFileName, delimiter)
.build();
assertThat(taskanaEngineConfiguration.getClassificationTypes()).isEmpty();
assertThat(taskanaConfiguration.getClassificationTypes()).isEmpty();
}
@Test
void should_NotConfigureClassificationCategories_When_PropertiesAreNotDefined() throws Exception {
String propertiesFileName = createNewConfigFile("dummyTestConfig2.properties", true, false);
String delimiter = ";";
taskanaEngineConfiguration =
taskanaConfiguration =
new TaskanaConfiguration.Builder(
DataSourceGenerator.getDataSource(),
true,
@ -84,7 +83,7 @@ class TaskanaConfigAccTest {
true)
.initTaskanaProperties(propertiesFileName, delimiter)
.build();
assertThat(taskanaEngineConfiguration.getClassificationCategoriesByType())
assertThat(taskanaConfiguration.getClassificationCategoriesByType())
.containsExactly(
Map.entry("TASK", Collections.emptyList()),
Map.entry("DOCUMENT", Collections.emptyList()));
@ -94,7 +93,7 @@ class TaskanaConfigAccTest {
void should_ApplyClassificationProperties_When_PropertiesAreDefined() throws Exception {
String propertiesFileName = createNewConfigFile("dummyTestConfig3.properties", true, true);
String delimiter = ";";
taskanaEngineConfiguration =
taskanaConfiguration =
new TaskanaConfiguration.Builder(
DataSourceGenerator.getDataSource(),
true,
@ -102,7 +101,7 @@ class TaskanaConfigAccTest {
true)
.initTaskanaProperties(propertiesFileName, delimiter)
.build();
assertThat(taskanaEngineConfiguration.getClassificationCategoriesByType())
assertThat(taskanaConfiguration.getClassificationCategoriesByType())
.containsExactly(
Map.entry("TASK", List.of("EXTERNAL", "MANUAL", "AUTOMATIC", "PROCESS")),
Map.entry("DOCUMENT", List.of("EXTERNAL")));

18
lib/taskana-core/src/test/java/acceptance/config/TaskanaEngineConfigTest.java → lib/taskana-core/src/test/java/acceptance/config/TaskanaConfigurationTest.java
View File

@ -10,17 +10,17 @@ import pro.taskana.common.api.CustomHoliday;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.test.config.DataSourceGenerator;
class TaskanaEngineConfigTest {
class TaskanaConfigurationTest {
@Test
void should_ReturnTaskanaEngine_When_BuildingWithConfiguration() throws Exception {
DataSource ds = DataSourceGenerator.getDataSource();
TaskanaConfiguration taskEngineConfiguration =
TaskanaConfiguration configuration =
new TaskanaConfiguration.Builder(ds, false, DataSourceGenerator.getSchemaName())
.initTaskanaProperties()
.build();
TaskanaEngine te = TaskanaEngine.buildTaskanaEngine(taskEngineConfiguration);
TaskanaEngine te = TaskanaEngine.buildTaskanaEngine(configuration);
assertThat(te).isNotNull();
}
@ -28,32 +28,32 @@ class TaskanaEngineConfigTest {
@Test
void should_SetCorpusChristiEnabled_When_PropertyIsSet() {
DataSource ds = DataSourceGenerator.getDataSource();
TaskanaConfiguration taskEngineConfiguration =
TaskanaConfiguration configuration =
new TaskanaConfiguration.Builder(ds, false, DataSourceGenerator.getSchemaName(), true)
.initTaskanaProperties("/corpusChristiEnabled.properties", "|")
.build();
assertThat(taskEngineConfiguration.isCorpusChristiEnabled()).isTrue();
assertThat(configuration.isCorpusChristiEnabled()).isTrue();
}
@Test
void should_ReturnTheTwoCustomHolidays_When_TwoCustomHolidaysAreConfiguredInThePropertiesFile() {
DataSource ds = DataSourceGenerator.getDataSource();
TaskanaConfiguration taskEngineConfiguration =
TaskanaConfiguration configuration =
new TaskanaConfiguration.Builder(ds, false, DataSourceGenerator.getSchemaName(), true)
.initTaskanaProperties("/custom_holiday_taskana.properties", "|")
.build();
assertThat(taskEngineConfiguration.getCustomHolidays())
assertThat(configuration.getCustomHolidays())
.contains(CustomHoliday.of(31, 7), CustomHoliday.of(16, 12));
}
@Test
void should_ReturnEmptyList_When_AllCustomHolidaysAreInWrongFormatInPropertiesFile() {
DataSource ds = DataSourceGenerator.getDataSource();
TaskanaConfiguration taskEngineConfiguration =
TaskanaConfiguration configuration =
new TaskanaConfiguration.Builder(ds, false, DataSourceGenerator.getSchemaName(), true)
.initTaskanaProperties("/custom_holiday_with_wrong_format_taskana.properties", "|")
.build();
assertThat(taskEngineConfiguration.getCustomHolidays()).isEmpty();
assertThat(configuration.getCustomHolidays()).isEmpty();
}
}

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

@ -19,11 +19,11 @@ import pro.taskana.common.test.config.DataSourceGenerator;
class TaskanaRoleConfigAccTest {
@TempDir Path tempDir;
private TaskanaConfiguration taskanaEngineConfiguration;
private TaskanaConfiguration taskanaConfiguration;
@BeforeEach
void setup() {
taskanaEngineConfiguration =
taskanaConfiguration =
new TaskanaConfiguration.Builder(
DataSourceGenerator.getDataSource(), true, DataSourceGenerator.getSchemaName())
.initTaskanaProperties()
@ -32,10 +32,10 @@ class TaskanaRoleConfigAccTest {
@Test
void should_ApplyDefaultConfiguration_For_DefaultPropertiesFile() {
Set<TaskanaRole> rolesConfigured = taskanaEngineConfiguration.getRoleMap().keySet();
Set<TaskanaRole> rolesConfigured = taskanaConfiguration.getRoleMap().keySet();
assertThat(rolesConfigured).containsExactlyInAnyOrder(TaskanaRole.values());
Set<String> users = taskanaEngineConfiguration.getRoleMap().get(TaskanaRole.USER);
Set<String> users = taskanaConfiguration.getRoleMap().get(TaskanaRole.USER);
assertThat(users)
.containsExactlyInAnyOrder(
"cn=ksc-users,cn=groups,ou=test,o=taskana",
@ -48,23 +48,22 @@ class TaskanaRoleConfigAccTest {
"user-b-1",
"user-b-2");
Set<String> admins = taskanaEngineConfiguration.getRoleMap().get(TaskanaRole.ADMIN);
Set<String> admins = taskanaConfiguration.getRoleMap().get(TaskanaRole.ADMIN);
assertThat(admins).containsExactlyInAnyOrder("uid=admin,cn=users,ou=test,o=taskana", "admin");
Set<String> taskAdmins = taskanaEngineConfiguration.getRoleMap().get(TaskanaRole.TASK_ADMIN);
Set<String> taskAdmins = taskanaConfiguration.getRoleMap().get(TaskanaRole.TASK_ADMIN);
assertThat(taskAdmins).containsExactlyInAnyOrder("taskadmin");
Set<String> businessAdmins =
taskanaEngineConfiguration.getRoleMap().get(TaskanaRole.BUSINESS_ADMIN);
Set<String> businessAdmins = taskanaConfiguration.getRoleMap().get(TaskanaRole.BUSINESS_ADMIN);
assertThat(businessAdmins)
.containsExactlyInAnyOrder(
"businessadmin", "cn=business-admins,cn=groups,ou=test,o=taskana");
Set<String> monitorAccessIds = taskanaEngineConfiguration.getRoleMap().get(TaskanaRole.MONITOR);
Set<String> monitorAccessIds = taskanaConfiguration.getRoleMap().get(TaskanaRole.MONITOR);
assertThat(monitorAccessIds)
.containsExactlyInAnyOrder("monitor", "cn=monitor-users,cn=groups,ou=test,o=taskana");
Set<String> taskRouters = taskanaEngineConfiguration.getRoleMap().get(TaskanaRole.TASK_ROUTER);
Set<String> taskRouters = taskanaConfiguration.getRoleMap().get(TaskanaRole.TASK_ROUTER);
assertThat(taskRouters)
.containsExactlyInAnyOrder("cn=routers,cn=groups,ou=test,o=taskana", "user-taskrouter");
}
@ -73,7 +72,7 @@ class TaskanaRoleConfigAccTest {
void should_ApplyDifferentConfiguration_For_DifferentFile() throws Exception {
String propertiesFileName = createNewConfigFileWithSameDelimiter("dummyTestConfig.properties");
String delimiter = "|";
taskanaEngineConfiguration =
taskanaConfiguration =
new TaskanaConfiguration.Builder(
DataSourceGenerator.getDataSource(),
true,
@ -82,20 +81,19 @@ class TaskanaRoleConfigAccTest {
.initTaskanaProperties(propertiesFileName, delimiter)
.build();
Set<TaskanaRole> rolesConfigured = taskanaEngineConfiguration.getRoleMap().keySet();
Set<TaskanaRole> rolesConfigured = taskanaConfiguration.getRoleMap().keySet();
assertThat(rolesConfigured).containsExactlyInAnyOrder(TaskanaRole.values());
Set<String> users = taskanaEngineConfiguration.getRoleMap().get(TaskanaRole.USER);
Set<String> users = taskanaConfiguration.getRoleMap().get(TaskanaRole.USER);
assertThat(users).containsExactly("nobody");
Set<String> admins = taskanaEngineConfiguration.getRoleMap().get(TaskanaRole.ADMIN);
Set<String> admins = taskanaConfiguration.getRoleMap().get(TaskanaRole.ADMIN);
assertThat(admins).containsExactlyInAnyOrder("user", "username");
Set<String> businessAdmins =
taskanaEngineConfiguration.getRoleMap().get(TaskanaRole.BUSINESS_ADMIN);
Set<String> businessAdmins = taskanaConfiguration.getRoleMap().get(TaskanaRole.BUSINESS_ADMIN);
assertThat(businessAdmins).containsExactlyInAnyOrder("user2", "user3");
Set<String> taskAdmins = taskanaEngineConfiguration.getRoleMap().get(TaskanaRole.TASK_ADMIN);
Set<String> taskAdmins = taskanaConfiguration.getRoleMap().get(TaskanaRole.TASK_ADMIN);
assertThat(taskAdmins).containsExactlyInAnyOrder("taskadmin");
}
@ -105,7 +103,7 @@ class TaskanaRoleConfigAccTest {
String propertiesFileName =
createNewConfigFileWithDifferentDelimiter("dummyTestConfig.properties", delimiter);
taskanaEngineConfiguration =
taskanaConfiguration =
new TaskanaConfiguration.Builder(
DataSourceGenerator.getDataSource(),
true,
@ -114,20 +112,19 @@ class TaskanaRoleConfigAccTest {
.initTaskanaProperties(propertiesFileName, delimiter)
.build();
Set<TaskanaRole> rolesConfigured = taskanaEngineConfiguration.getRoleMap().keySet();
Set<TaskanaRole> rolesConfigured = taskanaConfiguration.getRoleMap().keySet();
assertThat(rolesConfigured).containsExactlyInAnyOrder(TaskanaRole.values());
Set<String> users = taskanaEngineConfiguration.getRoleMap().get(TaskanaRole.USER);
Set<String> users = taskanaConfiguration.getRoleMap().get(TaskanaRole.USER);
assertThat(users).isEmpty();
Set<String> admins = taskanaEngineConfiguration.getRoleMap().get(TaskanaRole.ADMIN);
Set<String> admins = taskanaConfiguration.getRoleMap().get(TaskanaRole.ADMIN);
assertThat(admins).containsExactlyInAnyOrder("user", "name=username,organisation=novatec");
Set<String> businessAdmins =
taskanaEngineConfiguration.getRoleMap().get(TaskanaRole.BUSINESS_ADMIN);
Set<String> businessAdmins = taskanaConfiguration.getRoleMap().get(TaskanaRole.BUSINESS_ADMIN);
assertThat(businessAdmins).containsExactlyInAnyOrder("name=user2, ou = bpm", "user3");
Set<String> taskAdmins = taskanaEngineConfiguration.getRoleMap().get(TaskanaRole.TASK_ADMIN);
Set<String> taskAdmins = taskanaConfiguration.getRoleMap().get(TaskanaRole.TASK_ADMIN);
assertThat(taskAdmins).contains("taskadmin");
}

2
lib/taskana-core/src/test/java/acceptance/jobs/JobRunnerAccTest.java
View File

@ -43,7 +43,7 @@ class JobRunnerAccTest extends AbstractAccTest {
try {
TaskanaEngine taskanaEngine =
TaskanaEngine.buildTaskanaEngine(
taskanaEngineConfiguration, ConnectionManagementMode.AUTOCOMMIT);
taskanaConfiguration, ConnectionManagementMode.AUTOCOMMIT);
DataSource dataSource = DataSourceGenerator.getDataSource();
// We have to slow down the transaction.
// This is necessary to guarantee the execution of

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

@ -51,13 +51,12 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_CleanCompletedTasksUntilDate() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.taskCleanupJobAllCompletedSameParentBusiness(false)
.build();
TaskanaEngine taskanaEngine =
TaskanaEngine.buildTaskanaEngine(
taskanaEngineConfiguration, ConnectionManagementMode.AUTOCOMMIT);
TaskanaEngine.buildTaskanaEngine(taskanaConfiguration, ConnectionManagementMode.AUTOCOMMIT);
TaskService taskService = taskanaEngine.getTaskService();
String taskId = createAndInsertTask(taskService, null);
taskService.claim(taskId);
@ -79,14 +78,13 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
long totalTasksCount = taskService.createTaskQuery().count();
assertThat(totalTasksCount).isEqualTo(99);
TaskanaConfiguration taskanaEngineConfiguration =
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngine.getConfiguration())
.taskCleanupJobAllCompletedSameParentBusiness(true)
.build();
TaskanaEngine taskanaEngine =
TaskanaEngine.buildTaskanaEngine(
taskanaEngineConfiguration, ConnectionManagementMode.AUTOCOMMIT);
TaskanaEngine.buildTaskanaEngine(taskanaConfiguration, ConnectionManagementMode.AUTOCOMMIT);
List<TaskSummary> tasks =
taskanaEngine
.getTaskService()
@ -160,14 +158,13 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
throws Exception {
Iterator<String> iterator = Arrays.asList("", null).iterator();
TaskanaConfiguration taskanaEngineConfiguration =
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngine.getConfiguration())
.taskCleanupJobAllCompletedSameParentBusiness(true)
.cleanupJobMinimumAge(Duration.ofMillis(1))
.build();
TaskanaEngine taskanaEngine =
TaskanaEngine.buildTaskanaEngine(
taskanaEngineConfiguration, ConnectionManagementMode.AUTOCOMMIT);
TaskanaEngine.buildTaskanaEngine(taskanaConfiguration, ConnectionManagementMode.AUTOCOMMIT);
TaskCleanupJob job = new TaskCleanupJob(taskanaEngine, null, null);
TaskService taskService = taskanaEngine.getTaskService();
@ -210,7 +207,7 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
JobRunner runner = new JobRunner(taskanaEngine);
runner.runJobs();
Duration runEvery = taskanaEngineConfiguration.getCleanupJobRunEvery();
Duration runEvery = taskanaConfiguration.getCleanupJobRunEvery();
jobsToRun = jobMapper.findJobsToRun(Instant.now().plus(runEvery));
assertThat(jobsToRun).extracting(ScheduledJob::getDue).containsExactly(firstDue.plus(runEvery));
@ -221,8 +218,8 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
void should_ScheduleNextJobAccordingToFirstRun_When_PreviousJobNotExisting() throws Exception {
Instant firstRun = Instant.now().minus(2, ChronoUnit.MINUTES).truncatedTo(ChronoUnit.MILLIS);
Duration runEvery = Duration.ofMinutes(5);
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.cleanupJobRunEvery(runEvery)
.cleanupJobFirstRun(firstRun)
.jobSchedulerEnabled(true)
@ -233,8 +230,7 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
.build();
TaskanaEngine taskanaEngine =
TaskanaEngine.buildTaskanaEngine(
taskanaEngineConfiguration, ConnectionManagementMode.AUTOCOMMIT);
TaskanaEngine.buildTaskanaEngine(taskanaConfiguration, ConnectionManagementMode.AUTOCOMMIT);
List<ScheduledJob> nextJobs =
getJobMapper(taskanaEngine).findJobsToRun(Instant.now().plus(runEvery));
@ -245,13 +241,13 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
@Test
void should_FindNoJobsToRunUntilFirstRunIsReached_When_CleanupScheduleIsInitialized()
throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngine.getConfiguration())
.cleanupJobRunEvery(Duration.ofMillis(1))
.cleanupJobFirstRun(Instant.now().plus(5, ChronoUnit.MINUTES))
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
AbstractTaskanaJob.initializeSchedule(taskanaEngine, TaskCleanupJob.class);
List<ScheduledJob> nextJobs = getJobMapper(taskanaEngine).findJobsToRun(Instant.now());

37
lib/taskana-core/src/test/java/acceptance/jobs/TaskUpdatePriorityJobAccTest.java
View File

@ -33,14 +33,14 @@ class TaskUpdatePriorityJobAccTest extends AbstractAccTest {
// TODO split test class into readOnly & modifying tests to improve performance
resetDb(true);
taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.priorityJobActive(true)
.priorityJobBatchSize(20)
.priorityJobRunEvery(Duration.ofMinutes(30))
.priorityJobFirstRun(Instant.parse("2007-12-03T10:15:30.00Z"))
.build();
taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
}
@Test
@ -57,11 +57,11 @@ class TaskUpdatePriorityJobAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
void should_doNothing_When_NotActive() throws Exception {
// given
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.priorityJobActive(false)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
TaskUpdatePriorityJob job = new TaskUpdatePriorityJob(taskanaEngine);
List<String> priorities =
taskanaEngine
@ -87,11 +87,10 @@ class TaskUpdatePriorityJobAccTest extends AbstractAccTest {
void should_ScheduleNextJob() throws Exception {
// given
final Instant someTimeInTheFuture = Instant.now().plus(10, ChronoUnit.DAYS);
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration).build();
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration).build();
TaskanaEngine taskanaEngine =
TaskanaEngine.buildTaskanaEngine(
taskanaEngineConfiguration, ConnectionManagementMode.AUTOCOMMIT);
TaskanaEngine.buildTaskanaEngine(taskanaConfiguration, ConnectionManagementMode.AUTOCOMMIT);
// when
AbstractTaskanaJob.initializeSchedule(taskanaEngine, TaskUpdatePriorityJob.class);
@ -106,14 +105,14 @@ class TaskUpdatePriorityJobAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
void should_readConfigurationForBatchSize() throws Exception {
// given
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.priorityJobBatchSize(20)
.build();
// when
final TaskUpdatePriorityJob job =
new TaskUpdatePriorityJob(TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration));
new TaskUpdatePriorityJob(TaskanaEngine.buildTaskanaEngine(taskanaConfiguration));
// then
assertThat(job.getBatchSize()).isEqualTo(20);
@ -123,14 +122,14 @@ class TaskUpdatePriorityJobAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
void should_readConfigurationForIsActive() throws Exception {
// given
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.priorityJobActive(false)
.build();
// when
final TaskUpdatePriorityJob job =
new TaskUpdatePriorityJob(TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration));
new TaskUpdatePriorityJob(TaskanaEngine.buildTaskanaEngine(taskanaConfiguration));
// then
assertThat(job.isJobActive()).isFalse();
@ -139,15 +138,15 @@ class TaskUpdatePriorityJobAccTest extends AbstractAccTest {
@Test
void should_containInformation_When_convertedToString() throws Exception {
// given
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.priorityJobBatchSize(543)
.priorityJobRunEvery(Duration.ofMinutes(30))
.build();
// when
final TaskUpdatePriorityJob job =
new TaskUpdatePriorityJob(TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration));
new TaskUpdatePriorityJob(TaskanaEngine.buildTaskanaEngine(taskanaConfiguration));
// then
assertThat(job).asString().contains("543").contains(Duration.ofMinutes(30).toString());

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

@ -11,18 +11,18 @@ import pro.taskana.sampledata.SampleDataGenerator;
/** Abstract test class for all report building tests. */
public abstract class AbstractReportAccTest {
protected static TaskanaConfiguration taskanaEngineConfiguration;
protected static TaskanaConfiguration taskanaConfiguration;
protected static TaskanaEngine taskanaEngine;
protected static void resetDb() throws Exception {
DataSource dataSource = DataSourceGenerator.getDataSource();
String schemaName = DataSourceGenerator.getSchemaName();
taskanaEngineConfiguration =
taskanaConfiguration =
new TaskanaConfiguration.Builder(dataSource, false, schemaName)
.initTaskanaProperties()
.germanPublicHolidaysEnabled(false)
.build();
taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
taskanaEngine.setConnectionManagementMode(TaskanaEngine.ConnectionManagementMode.AUTOCOMMIT);
SampleDataGenerator sampleDataGenerator = new SampleDataGenerator(dataSource, schemaName);
sampleDataGenerator.clearDb();

12
lib/taskana-core/src/test/java/acceptance/task/create/CreateTaskAccTest.java
View File

@ -148,11 +148,11 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_CreateTaskWithAdditionalUserInfo() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(true)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
@ -197,11 +197,11 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void should_AllowTimestampServiceLevelMismatch_When_ConfigurationAllowsIt() throws Exception {
// Given
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.allowTimestampServiceLevelMismatch(true)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
Task newTask = taskanaEngine.getTaskService().newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T6310");
ObjectReference objectReference =

12
lib/taskana-core/src/test/java/acceptance/task/get/GetTaskAccTest.java
View File

@ -97,11 +97,11 @@ class GetTaskAccTest extends AbstractAccTest {
@Test
void should_SetTaskOwnerLongNameOfTask_When_PropertyEnabled() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(true)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
@ -113,11 +113,11 @@ class GetTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_NotSetTaskOwnerLongNameOfTask_When_PropertyDisabled() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(false)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");

66
lib/taskana-core/src/test/java/acceptance/task/query/QueryTasksAccTest.java
View File

@ -61,11 +61,11 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_SetOwnerLongNameOfTask_When_PropertyEnabled() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(true)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
List<TaskSummary> tasks =
taskanaEngine
@ -82,11 +82,11 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_NotSetOwnerLongNameOfTask_When_PropertyDisabled() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(false)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
List<TaskSummary> tasks =
taskanaEngine
@ -102,11 +102,11 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void should_SetOwnerLongNameOfTask_When_FilteringWithOwnerLongNameIn() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(false)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
String longName = "Eifrig, Elena - (user-1-2)";
List<TaskSummary> tasks =
@ -122,11 +122,11 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_SetOwnerLongNameOfTask_When_FilteringWithOwnerLongNameNotIn() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(false)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
List<TaskSummary> tasks =
taskanaEngine
.getTaskService()
@ -146,11 +146,11 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void should_SetOwnerLongNameOfTask_When_FilteringWithOwnerLongNameLike() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(false)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
List<TaskSummary> tasks =
taskanaEngine.getTaskService().createTaskQuery().ownerLongNameLike("%1-2%").list();
@ -165,11 +165,11 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void should_SetOwnerLongNameOfTask_When_FilteringWithOwnerLongNameNotLike() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(false)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
List<TaskSummary> tasks =
taskanaEngine.getTaskService().createTaskQuery().ownerLongNameNotLike("%1-1%").list();
@ -185,11 +185,11 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test
void should_SetOwnerLongNameOfTaskToNull_When_OwnerNotExistingAsUserInDatabase()
throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(true)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
List<TaskSummary> tasks =
taskanaEngine
@ -208,11 +208,11 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_OrderByOwnerLongName_When_QueryingTask() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(false)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
List<TaskSummary> tasks =
taskanaEngine
.getTaskService()
@ -240,11 +240,11 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_ListValues_For_OwnerLongName() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(false)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
List<String> longNames =
taskanaEngine
.getTaskService()
@ -275,11 +275,11 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void should_ListValuesCorrectly_When_FilteringWithOwnerLongName() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(false)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
String longName = "Eifrig, Elena - (user-1-2)";
List<String> listedValues =
taskanaEngine
@ -303,11 +303,11 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void should_CountCorrectly_When_FilteringWithOwnerLongName() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(false)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
String longName = "Eifrig, Elena - (user-1-2)";
long count = taskanaEngine.getTaskService().createTaskQuery().ownerLongNameIn(longName).count();
assertThat(count).isEqualTo(25);

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

@ -72,11 +72,11 @@ class UpdateTaskAccTest extends AbstractAccTest {
@Test
void should_PreventTimestampServiceLevelMismatch_When_ConfigurationPreventsIt() throws Exception {
// Given
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.allowTimestampServiceLevelMismatch(false)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
Task task = taskanaEngine.getTaskService().getTask("TKI:000000000000000000000000000000000000");
// When
Instant planned = Instant.parse("2018-03-02T00:00:00Z");
@ -94,11 +94,11 @@ class UpdateTaskAccTest extends AbstractAccTest {
@Test
void should_AllowTimestampServiceLevelMismatch_When_ConfigurationAllowsIt() throws Exception {
// Given
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.allowTimestampServiceLevelMismatch(true)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
Task task = taskanaEngine.getTaskService().getTask("TKI:000000000000000000000000000000000000");
// When

24
lib/taskana-core/src/test/java/acceptance/taskcomment/query/QueryTaskCommentAccTest.java
View File

@ -209,11 +209,11 @@ class QueryTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_ReturnListedValues_For_QueryColumnCreatorLongName() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(false)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
List<String> listedValues =
taskanaEngine
.getTaskService()
@ -283,11 +283,11 @@ class QueryTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_SetTaskCreatorFullNameOfTaskComment_When_PropertyEnabled() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(true)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
List<TaskComment> taskComments =
taskanaEngine
.getTaskService()
@ -306,11 +306,11 @@ class QueryTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_NotSetTaskCreatorFullNameOfTaskComment_When_PropertyDisabled() throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(false)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
List<TaskComment> taskComments =
taskanaEngine
.getTaskService()
@ -326,11 +326,11 @@ class QueryTaskCommentAccTest extends AbstractAccTest {
@Test
void should_SetTaskCreatorFullNameOfTaskCommentToNull_When_NotExistingAsUserInDatabase()
throws Exception {
TaskanaConfiguration taskanaEngineConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaEngineConfiguration)
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
.addAdditionalUserInfo(true)
.build();
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
List<TaskComment> taskComments =
taskanaEngine
.getTaskService()

6
lib/taskana-spring-example/src/main/java/pro/taskana/example/TaskanaConfig.java
View File

@ -51,7 +51,7 @@ public class TaskanaConfig {
}
@Bean
public TaskanaConfiguration taskanaEngineConfiguration(
public TaskanaConfiguration taskanaConfiguration(
DataSource dataSource,
@Qualifier("taskanaPropertiesFileName") String propertiesFileName,
@Qualifier("taskanaPropertiesDelimiter") String delimiter) {
@ -71,9 +71,9 @@ public class TaskanaConfig {
}
@Bean
public TaskanaEngine taskanaEngine(TaskanaConfiguration taskanaEngineConfiguration)
public TaskanaEngine taskanaEngine(TaskanaConfiguration taskanaConfiguration)
throws SQLException {
return SpringTaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
return SpringTaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
}
@Bean

2
lib/taskana-spring/src/main/java/pro/taskana/common/internal/SpringTaskanaEngine.java
View File

@ -24,7 +24,7 @@ public interface SpringTaskanaEngine extends TaskanaEngine {
* Builds an {@linkplain SpringTaskanaEngine} based on {@linkplain TaskanaConfiguration} and
* SqlConnectionMode.
*
* @param configuration complete taskanaEngineConfig to build the engine
* @param configuration complete taskanaConfig to build the engine
* @param connectionManagementMode connectionMode for the SqlSession
* @return a {@linkplain SpringTaskanaEngineImpl}
* @throws SQLException when the db schema could not be initialized

9
lib/taskana-spring/src/main/java/pro/taskana/common/internal/SpringTaskanaEngineImpl.java
View File

@ -9,17 +9,16 @@ import pro.taskana.TaskanaConfiguration;
public class SpringTaskanaEngineImpl extends TaskanaEngineImpl implements SpringTaskanaEngine {
public SpringTaskanaEngineImpl(
TaskanaConfiguration taskanaEngineConfiguration, ConnectionManagementMode mode)
TaskanaConfiguration taskanaConfiguration, ConnectionManagementMode mode)
throws SQLException {
super(taskanaEngineConfiguration, mode);
super(taskanaConfiguration, mode);
this.transactionFactory = new SpringManagedTransactionFactory();
this.sessionManager = createSqlSessionManager();
}
public static SpringTaskanaEngine createTaskanaEngine(
TaskanaConfiguration taskanaEngineConfiguration,
ConnectionManagementMode connectionManagementMode)
TaskanaConfiguration taskanaConfiguration, ConnectionManagementMode connectionManagementMode)
throws SQLException {
return new SpringTaskanaEngineImpl(taskanaEngineConfiguration, connectionManagementMode);
return new SpringTaskanaEngineImpl(taskanaConfiguration, connectionManagementMode);
}
}

8
lib/taskana-test-api/src/main/java/pro/taskana/testapi/TaskanaConfigurationModifier.java Normal file
View File

@ -0,0 +1,8 @@
package pro.taskana.testapi;
import pro.taskana.TaskanaConfiguration;
public interface TaskanaConfigurationModifier {
TaskanaConfiguration.Builder modify(TaskanaConfiguration.Builder builder);
}

9
lib/taskana-test-api/src/main/java/pro/taskana/testapi/TaskanaEngineConfigurationModifier.java
View File

@ -1,9 +0,0 @@
package pro.taskana.testapi;
import pro.taskana.TaskanaConfiguration;
public interface TaskanaEngineConfigurationModifier {
TaskanaConfiguration.Builder modify(
TaskanaConfiguration.Builder taskanaEngineConfigurationBuilder);
}

19
lib/taskana-test-api/src/main/java/pro/taskana/testapi/extensions/TaskanaInitializationExtension.java
View File

@ -41,7 +41,7 @@ import pro.taskana.monitor.internal.MonitorServiceImpl;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.internal.TaskServiceImpl;
import pro.taskana.testapi.CleanTaskanaContext;
import pro.taskana.testapi.TaskanaEngineConfigurationModifier;
import pro.taskana.testapi.TaskanaConfigurationModifier;
import pro.taskana.testapi.TaskanaEngineProxy;
import pro.taskana.testapi.WithServiceProvider;
import pro.taskana.testapi.WithServiceProvider.WithServiceProviders;
@ -63,15 +63,14 @@ public class TaskanaInitializationExtension implements TestInstancePostProcessor
|| isAnnotated(testClass, CleanTaskanaContext.class)
|| isAnnotated(testClass, WithServiceProvider.class)
|| isAnnotated(testClass, WithServiceProviders.class)
|| testInstance instanceof TaskanaEngineConfigurationModifier) {
|| testInstance instanceof TaskanaConfigurationModifier) {
Store store = getClassLevelStore(context);
TaskanaConfiguration.Builder taskanaEngineConfigurationBuilder =
createDefaultTaskanaEngineConfigurationBuilder(store);
TaskanaConfiguration.Builder taskanaConfigurationBuilder =
createDefaultTaskanaConfigurationBuilder(store);
if (testInstance instanceof TaskanaEngineConfigurationModifier) {
TaskanaEngineConfigurationModifier modifier =
(TaskanaEngineConfigurationModifier) testInstance;
taskanaEngineConfigurationBuilder = modifier.modify(taskanaEngineConfigurationBuilder);
if (testInstance instanceof TaskanaConfigurationModifier) {
TaskanaConfigurationModifier modifier = (TaskanaConfigurationModifier) testInstance;
taskanaConfigurationBuilder = modifier.modify(taskanaConfigurationBuilder);
}
TaskanaEngine taskanaEngine;
@ -83,7 +82,7 @@ public class TaskanaInitializationExtension implements TestInstancePostProcessor
staticMock.when(() -> SpiLoader.load(spi)).thenReturn(serviceProviders));
taskanaEngine =
TaskanaEngine.buildTaskanaEngine(
taskanaEngineConfigurationBuilder.build(), ConnectionManagementMode.AUTOCOMMIT);
taskanaConfigurationBuilder.build(), ConnectionManagementMode.AUTOCOMMIT);
}
store.put(STORE_TASKANA_ENTITY_MAP, generateTaskanaEntityMap(taskanaEngine));
@ -99,7 +98,7 @@ public class TaskanaInitializationExtension implements TestInstancePostProcessor
return instanceByClass;
}
private static TaskanaConfiguration.Builder createDefaultTaskanaEngineConfigurationBuilder(
private static TaskanaConfiguration.Builder createDefaultTaskanaConfigurationBuilder(
Store store) {
String schemaName = store.get(TestContainerExtension.STORE_SCHEMA_NAME, String.class);
if (schemaName == null) {

6
lib/taskana-test-api/src/main/java/pro/taskana/testapi/extensions/TestContainerExtension.java
View File

@ -20,7 +20,7 @@ import org.testcontainers.containers.JdbcDatabaseContainer;
import pro.taskana.common.internal.configuration.DB;
import pro.taskana.testapi.CleanTaskanaContext;
import pro.taskana.testapi.TaskanaEngineConfigurationModifier;
import pro.taskana.testapi.TaskanaConfigurationModifier;
import pro.taskana.testapi.WithServiceProvider;
public class TestContainerExtension implements InvocationInterceptor {
@ -57,9 +57,9 @@ public class TestContainerExtension implements InvocationInterceptor {
if (DB.ORACLE == EXECUTION_DATABASE) {
initOracleSchema(DATA_SOURCE, schemaName);
}
} else if (TaskanaEngineConfigurationModifier.class.isAssignableFrom(testClass)
} else if (TaskanaConfigurationModifier.class.isAssignableFrom(testClass)
|| isAnnotated(testClass, WithServiceProvider.class)) {
// since the implementation of TaskanaEngineConfigurationModifier implies the generation of a
// since the implementation of TaskanaConfigurationModifier implies the generation of a
// new TaskanaEngine, we have to copy the schema name and datasource from the enclosing class'
// store to the testClass store.
// This allows the following extensions to generate a new TaskanaEngine for the testClass.

6
lib/taskana-test-api/src/main/java/pro/taskana/testapi/util/ExtensionCommunicator.java
View File

@ -7,7 +7,7 @@ import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
import org.junit.jupiter.api.extension.ExtensionContext.Store;
import pro.taskana.testapi.CleanTaskanaContext;
import pro.taskana.testapi.TaskanaEngineConfigurationModifier;
import pro.taskana.testapi.TaskanaConfigurationModifier;
import pro.taskana.testapi.WithServiceProvider;
public class ExtensionCommunicator {
@ -43,9 +43,9 @@ public class ExtensionCommunicator {
return Namespace.create(getTopLevelClass(testClass), testClass, CleanTaskanaContext.class);
} else if (isAnnotated(testClass, WithServiceProvider.class)) {
return Namespace.create(getTopLevelClass(testClass), testClass, WithServiceProvider.class);
} else if (TaskanaEngineConfigurationModifier.class.isAssignableFrom(testClass)) {
} else if (TaskanaConfigurationModifier.class.isAssignableFrom(testClass)) {
return Namespace.create(
getTopLevelClass(testClass), testClass, TaskanaEngineConfigurationModifier.class);
getTopLevelClass(testClass), testClass, TaskanaConfigurationModifier.class);
}
return Namespace.create(getTopLevelClass(testClass));
}

14
lib/taskana-test-api/src/test/java/pro/taskana/testapi/TaskanaDependencyInjectionExtensionTest.java
View File

@ -31,8 +31,8 @@ import pro.taskana.workbasket.internal.WorkbasketServiceImpl;
@TaskanaIntegrationTest
class TaskanaDependencyInjectionExtensionTest {
TaskanaConfiguration taskanaEngineConfigurationNotAnnotated;
@TaskanaInject TaskanaConfiguration taskanaEngineConfiguration;
TaskanaConfiguration taskanaConfigurationNotAnnotated;
@TaskanaInject TaskanaConfiguration taskanaConfiguration;
@TaskanaInject TaskanaEngine taskanaEngine;
@TaskanaInject TaskanaEngine taskanaEngine2;
@TaskanaInject TaskanaEngineImpl taskanaEngineImpl;
@ -58,8 +58,8 @@ class TaskanaDependencyInjectionExtensionTest {
@TaskanaInject UserServiceImpl userServiceImpl;
@Test
void should_NotInjectTaskanaEngineConfiguration_When_FieldIsNotAnnotated() {
assertThat(taskanaEngineConfigurationNotAnnotated).isNull();
void should_NotInjectTaskanaConfiguration_When_FieldIsNotAnnotated() {
assertThat(taskanaConfigurationNotAnnotated).isNull();
}
@Test
@ -68,9 +68,9 @@ class TaskanaDependencyInjectionExtensionTest {
}
@Test
void should_InjectTaskanaEngineConfiguration_When_FieldIsAnnotatedOrDeclaredAsParameter(
TaskanaConfiguration taskanaEngineConfiguration) {
assertThat(taskanaEngineConfiguration).isSameAs(this.taskanaEngineConfiguration).isNotNull();
void should_InjectTaskanaConfiguration_When_FieldIsAnnotatedOrDeclaredAsParameter(
TaskanaConfiguration taskanaConfiguration) {
assertThat(taskanaConfiguration).isSameAs(this.taskanaConfiguration).isNotNull();
}
@Test

52
lib/taskana-test-api/src/test/java/pro/taskana/testapi/TaskanaInitializationExtensionTest.java
View File

@ -19,48 +19,46 @@ import pro.taskana.testapi.TaskanaInitializationExtensionTest.NestedTestClassWit
@TaskanaIntegrationTest
class TaskanaInitializationExtensionTest {
@TaskanaInject TaskanaConfiguration taskanaEngineConfiguration;
@TaskanaInject TaskanaConfiguration taskanaConfiguration;
@Test
void should_UseDefaultTaskanaEngine_When_TestIsCreated() {
assertThat(taskanaEngineConfiguration.getDomains())
.containsExactlyInAnyOrder("DOMAIN_A", "DOMAIN_B");
assertThat(taskanaConfiguration.getDomains()).containsExactlyInAnyOrder("DOMAIN_A", "DOMAIN_B");
}
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class ReuseTaskana {
@TaskanaInject TaskanaConfiguration taskanaEngineConfiguration;
@TaskanaInject TaskanaConfiguration taskanaConfiguration;
@Test
void should_useTopLevelTaskanaInstance_For_NestedTestClasses() {
assertThat(taskanaEngineConfiguration)
.isSameAs(TaskanaInitializationExtensionTest.this.taskanaEngineConfiguration);
assertThat(taskanaConfiguration)
.isSameAs(TaskanaInitializationExtensionTest.this.taskanaConfiguration);
}
}
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class ModifiedTaskanaEngineConfig implements TaskanaEngineConfigurationModifier {
class ModifiedTaskanaConfig implements TaskanaConfigurationModifier {
@TaskanaInject TaskanaConfiguration taskanaEngineConfiguration;
@TaskanaInject TaskanaConfiguration taskanaConfiguration;
@Override
public TaskanaConfiguration.Builder modify(
TaskanaConfiguration.Builder taskanaEngineConfigurationBuilder) {
return taskanaEngineConfigurationBuilder.domains(List.of("A", "B"));
public TaskanaConfiguration.Builder modify(TaskanaConfiguration.Builder builder) {
return builder.domains(List.of("A", "B"));
}
@Test
void should_OverrideConfiguration_When_ClassImplementsTaskanaEngineConfigurationModifier() {
assertThat(taskanaEngineConfiguration.getDomains()).containsExactlyInAnyOrder("A", "B");
void should_OverrideConfiguration_When_ClassImplementsTaskanaConfigurationModifier() {
assertThat(taskanaConfiguration.getDomains()).containsExactlyInAnyOrder("A", "B");
}
@Test
void should_createNewTaskanaInstance_For_NestedTestClassImplementingModifierInterface() {
assertThat(taskanaEngineConfiguration)
.isNotSameAs(TaskanaInitializationExtensionTest.this.taskanaEngineConfiguration);
assertThat(taskanaConfiguration)
.isNotSameAs(TaskanaInitializationExtensionTest.this.taskanaConfiguration);
}
}
@ -69,17 +67,17 @@ class TaskanaInitializationExtensionTest {
@TestInstance(Lifecycle.PER_CLASS)
class NestedTestClassAnnotatedWithCleanTaskanaContext {
@TaskanaInject TaskanaConfiguration taskanaEngineConfiguration;
@TaskanaInject TaskanaConfiguration taskanaConfiguration;
@Test
void should_createNewTaskanaInstance_For_NestedTestClassAnnotatedWithCleanTaskanaContext() {
assertThat(taskanaEngineConfiguration)
.isNotSameAs(TaskanaInitializationExtensionTest.this.taskanaEngineConfiguration);
assertThat(taskanaConfiguration)
.isNotSameAs(TaskanaInitializationExtensionTest.this.taskanaConfiguration);
}
@Test
void should_UseDefaultTaskanaEngine_When_NestedClassDoesNotImplementModifier() {
assertThat(taskanaEngineConfiguration.getDomains())
assertThat(taskanaConfiguration.getDomains())
.containsExactlyInAnyOrder("DOMAIN_A", "DOMAIN_B");
}
}
@ -90,7 +88,7 @@ class TaskanaInitializationExtensionTest {
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class NestedTestClassWithServiceProvider {
@TaskanaInject TaskanaConfiguration taskanaEngineConfiguration;
@TaskanaInject TaskanaConfiguration taskanaConfiguration;
@TaskanaInject TaskanaEngine taskanaEngine;
@Test
@ -103,13 +101,13 @@ class TaskanaInitializationExtensionTest {
@Test
void should_createNewTaskanaInstance_For_NestedTestClassAnnotatedWithCleanTaskanaContext() {
assertThat(taskanaEngineConfiguration)
.isNotSameAs(TaskanaInitializationExtensionTest.this.taskanaEngineConfiguration);
assertThat(taskanaConfiguration)
.isNotSameAs(TaskanaInitializationExtensionTest.this.taskanaConfiguration);
}
@Test
void should_UseDefaultTaskanaEngine_When_NestedClassDoesNotImplementModifier() {
assertThat(taskanaEngineConfiguration.getDomains())
assertThat(taskanaConfiguration.getDomains())
.containsExactlyInAnyOrder("DOMAIN_A", "DOMAIN_B");
}
@ -133,7 +131,7 @@ class TaskanaInitializationExtensionTest {
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class NestedTestClassWithMultipleServiceProviders {
@TaskanaInject TaskanaConfiguration taskanaEngineConfiguration;
@TaskanaInject TaskanaConfiguration taskanaConfiguration;
@TaskanaInject TaskanaEngine taskanaEngine;
@Test
@ -146,13 +144,13 @@ class TaskanaInitializationExtensionTest {
@Test
void should_createNewTaskanaInstance_For_NestedTestClassAnnotatedWithCleanTaskanaContext() {
assertThat(taskanaEngineConfiguration)
.isNotSameAs(TaskanaInitializationExtensionTest.this.taskanaEngineConfiguration);
assertThat(taskanaConfiguration)
.isNotSameAs(TaskanaInitializationExtensionTest.this.taskanaConfiguration);
}
@Test
void should_UseDefaultTaskanaEngine_When_NestedClassDoesNotImplementModifier() {
assertThat(taskanaEngineConfiguration.getDomains())
assertThat(taskanaConfiguration.getDomains())
.containsExactlyInAnyOrder("DOMAIN_A", "DOMAIN_B");
}

84
lib/taskana-test-api/src/test/java/pro/taskana/testapi/TestContainerExtensionTest.java
View File

@ -17,18 +17,18 @@ import pro.taskana.testapi.TestContainerExtensionTest.NestedTestClassWithService
@TaskanaIntegrationTest
class TestContainerExtensionTest {
@TaskanaInject TaskanaConfiguration taskanaEngineConfiguration;
@TaskanaInject TaskanaConfiguration taskanaConfiguration;
@Test
void should_CreateDataSource_For_TopLevelTestClass() {
DataSource datasource = taskanaEngineConfiguration.getDatasource();
DataSource datasource = taskanaConfiguration.getDatasource();
assertThat(datasource).isNotNull();
}
@Test
void should_CreateSchemaName_For_TopLevelTestClass() {
String schemaName = taskanaEngineConfiguration.getSchemaName();
String schemaName = taskanaConfiguration.getSchemaName();
assertThat(schemaName).isNotNull();
}
@ -37,22 +37,22 @@ class TestContainerExtensionTest {
@TestInstance(Lifecycle.PER_CLASS)
class NestedTestClass {
@TaskanaInject TaskanaConfiguration taskanaEngineConfiguration;
@TaskanaInject TaskanaConfiguration taskanaConfiguration;
@Test
void should_ReuseDataSource_For_NestedTestClass() {
DataSource nestedDataSource = taskanaEngineConfiguration.getDatasource();
DataSource nestedDataSource = taskanaConfiguration.getDatasource();
DataSource topLevelDataSource =
TestContainerExtensionTest.this.taskanaEngineConfiguration.getDatasource();
TestContainerExtensionTest.this.taskanaConfiguration.getDatasource();
assertThat(nestedDataSource).isSameAs(topLevelDataSource).isNotNull();
}
@Test
void should_ReuseSchemaName_For_NestedTestClass() {
String nestedSchemaName = taskanaEngineConfiguration.getSchemaName();
String nestedSchemaName = taskanaConfiguration.getSchemaName();
String topLevelSchemaName =
TestContainerExtensionTest.this.taskanaEngineConfiguration.getSchemaName();
TestContainerExtensionTest.this.taskanaConfiguration.getSchemaName();
assertThat(nestedSchemaName).isNotNull().isEqualTo(topLevelSchemaName);
}
@ -60,30 +60,29 @@ class TestContainerExtensionTest {
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class NestedTestClassWithConfigurationModifier implements TaskanaEngineConfigurationModifier {
class NestedTestClassWithConfigurationModifier implements TaskanaConfigurationModifier {
@TaskanaInject TaskanaConfiguration taskanaEngineConfiguration;
@TaskanaInject TaskanaConfiguration taskanaConfiguration;
@Override
public TaskanaConfiguration.Builder modify(
TaskanaConfiguration.Builder taskanaEngineConfigurationBuilder) {
return taskanaEngineConfigurationBuilder;
public TaskanaConfiguration.Builder modify(TaskanaConfiguration.Builder builder) {
return builder;
}
@Test
void should_ReuseDataSource_For_NestedTestClassWhichImplementsConfigurationModifier() {
DataSource nestedDataSource = taskanaEngineConfiguration.getDatasource();
DataSource nestedDataSource = taskanaConfiguration.getDatasource();
DataSource topLevelDataSource =
TestContainerExtensionTest.this.taskanaEngineConfiguration.getDatasource();
TestContainerExtensionTest.this.taskanaConfiguration.getDatasource();
assertThat(nestedDataSource).isSameAs(topLevelDataSource).isNotNull();
}
@Test
void should_ReuseSchemaName_For_NestedTestClassWhichImplementsConfigurationModifier() {
String nestedSchemaName = taskanaEngineConfiguration.getSchemaName();
String nestedSchemaName = taskanaConfiguration.getSchemaName();
String topLevelSchemaName =
TestContainerExtensionTest.this.taskanaEngineConfiguration.getSchemaName();
TestContainerExtensionTest.this.taskanaConfiguration.getSchemaName();
assertThat(nestedSchemaName).isNotNull().isEqualTo(topLevelSchemaName);
}
@ -94,22 +93,22 @@ class TestContainerExtensionTest {
@TestInstance(Lifecycle.PER_CLASS)
class NestedTestClassAnnotatedWithCleanTaskanaContext {
@TaskanaInject TaskanaConfiguration taskanaEngineConfiguration;
@TaskanaInject TaskanaConfiguration taskanaConfiguration;
@Test
void should_ReuseDataSource_For_NestedTestAnnotatedWithCleanTaskanaContext() {
DataSource nestedDataSource = taskanaEngineConfiguration.getDatasource();
DataSource nestedDataSource = taskanaConfiguration.getDatasource();
DataSource topLevelDataSource =
TestContainerExtensionTest.this.taskanaEngineConfiguration.getDatasource();
TestContainerExtensionTest.this.taskanaConfiguration.getDatasource();
assertThat(nestedDataSource).isNotNull().isSameAs(topLevelDataSource);
}
@Test
void should_GenerateNewSchemaName_For_NestedTestAnnotatedWithCleanTaskanaContext() {
String nestedSchemaName = taskanaEngineConfiguration.getSchemaName();
String nestedSchemaName = taskanaConfiguration.getSchemaName();
String topLevelSchemaName =
TestContainerExtensionTest.this.taskanaEngineConfiguration.getSchemaName();
TestContainerExtensionTest.this.taskanaConfiguration.getSchemaName();
assertThat(nestedSchemaName).isNotNull().isNotEqualTo(topLevelSchemaName);
}
@ -119,16 +118,16 @@ class TestContainerExtensionTest {
@TestInstance(Lifecycle.PER_CLASS)
class NestedNestedTestClassAnnotatedWithCleanTaskanaContext {
@TaskanaInject TaskanaConfiguration taskanaEngineConfiguration;
@TaskanaInject TaskanaConfiguration taskanaConfiguration;
@Test
void should_ReuseDataSource_For_NestedTestAnnotatedWithCleanTaskanaContext() {
DataSource nestedNestedDataSource = taskanaEngineConfiguration.getDatasource();
DataSource nestedNestedDataSource = taskanaConfiguration.getDatasource();
DataSource nestedDataSource =
NestedNestedTestClassAnnotatedWithCleanTaskanaContext.this.taskanaEngineConfiguration
NestedNestedTestClassAnnotatedWithCleanTaskanaContext.this.taskanaConfiguration
.getDatasource();
DataSource topLevelDataSource =
TestContainerExtensionTest.this.taskanaEngineConfiguration.getDatasource();
TestContainerExtensionTest.this.taskanaConfiguration.getDatasource();
assertThat(nestedNestedDataSource)
.isNotNull()
@ -138,12 +137,12 @@ class TestContainerExtensionTest {
@Test
void should_GenerateNewSchemaName_For_NestedTestAnnotatedWithCleanTaskanaContext() {
String nestedNestedSchemaName = taskanaEngineConfiguration.getSchemaName();
String nestedNestedSchemaName = taskanaConfiguration.getSchemaName();
String nestedSchemaName =
NestedTestClassAnnotatedWithCleanTaskanaContext.this.taskanaEngineConfiguration
NestedTestClassAnnotatedWithCleanTaskanaContext.this.taskanaConfiguration
.getSchemaName();
String topLevelSchemaName =
TestContainerExtensionTest.this.taskanaEngineConfiguration.getSchemaName();
TestContainerExtensionTest.this.taskanaConfiguration.getSchemaName();
assertThat(nestedSchemaName).isNotNull().isNotEqualTo(topLevelSchemaName);
@ -159,30 +158,29 @@ class TestContainerExtensionTest {
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class NestedTestClassAnnotatedWithCleanTaskanaContextAndConfigModifier
implements TaskanaEngineConfigurationModifier {
implements TaskanaConfigurationModifier {
@TaskanaInject TaskanaConfiguration taskanaEngineConfiguration;
@TaskanaInject TaskanaConfiguration taskanaConfiguration;
@Override
public TaskanaConfiguration.Builder modify(
TaskanaConfiguration.Builder taskanaEngineConfigurationBuilder) {
return taskanaEngineConfigurationBuilder;
public TaskanaConfiguration.Builder modify(TaskanaConfiguration.Builder builder) {
return builder;
}
@Test
void should_ReuseNewDataSource_For_NestedTestAnnotatedWithCleanTaskanaContext() {
DataSource nestedDataSource = taskanaEngineConfiguration.getDatasource();
DataSource nestedDataSource = taskanaConfiguration.getDatasource();
DataSource topLevelDataSource =
TestContainerExtensionTest.this.taskanaEngineConfiguration.getDatasource();
TestContainerExtensionTest.this.taskanaConfiguration.getDatasource();
assertThat(nestedDataSource).isNotNull().isSameAs(topLevelDataSource);
}
@Test
void should_GenerateNewSchemaName_For_NestedTestAnnotatedWithCleanTaskanaContext() {
String nestedSchemaName = taskanaEngineConfiguration.getSchemaName();
String nestedSchemaName = taskanaConfiguration.getSchemaName();
String topLevelSchemaName =
TestContainerExtensionTest.this.taskanaEngineConfiguration.getSchemaName();
TestContainerExtensionTest.this.taskanaConfiguration.getSchemaName();
assertThat(nestedSchemaName).isNotNull().isNotEqualTo(topLevelSchemaName);
}
@ -195,22 +193,22 @@ class TestContainerExtensionTest {
@TestInstance(Lifecycle.PER_CLASS)
class NestedTestClassWithServiceProvider {
@TaskanaInject TaskanaConfiguration taskanaEngineConfiguration;
@TaskanaInject TaskanaConfiguration taskanaConfiguration;
@Test
void should_ReuseDataSource_For_NestedTestClassWithServiceProvider() {
DataSource nestedDataSource = taskanaEngineConfiguration.getDatasource();
DataSource nestedDataSource = taskanaConfiguration.getDatasource();
DataSource topLevelDataSource =
TestContainerExtensionTest.this.taskanaEngineConfiguration.getDatasource();
TestContainerExtensionTest.this.taskanaConfiguration.getDatasource();
assertThat(nestedDataSource).isSameAs(topLevelDataSource).isNotNull();
}
@Test
void should_ReuseSchemaName_For_NestedTestClassWithServiceProvider() {
String nestedSchemaName = taskanaEngineConfiguration.getSchemaName();
String nestedSchemaName = taskanaConfiguration.getSchemaName();
String topLevelSchemaName =
TestContainerExtensionTest.this.taskanaEngineConfiguration.getSchemaName();
TestContainerExtensionTest.this.taskanaConfiguration.getSchemaName();
assertThat(nestedSchemaName).isNotNull().isEqualTo(topLevelSchemaName);
}

12
rest/taskana-rest-spring-example-boot/src/main/java/pro/taskana/example/boot/ExampleRestConfiguration.java
View File

@ -24,17 +24,17 @@ public class ExampleRestConfiguration {
}
@Bean
@DependsOn("taskanaEngineConfiguration") // generate sample data after schema was inserted
@DependsOn("taskanaConfiguration") // generate sample data after schema was inserted
public SampleDataGenerator generateSampleData(
TaskanaConfiguration taskanaEngineConfiguration,
TaskanaConfiguration taskanaConfiguration,
DataSource dataSource,
@Value("${generateSampleData:true}") boolean generateSampleData)
throws SQLException {
DbSchemaCreator dbSchemaCreator =
new DbSchemaCreator(dataSource, taskanaEngineConfiguration.getSchemaName());
new DbSchemaCreator(dataSource, taskanaConfiguration.getSchemaName());
dbSchemaCreator.run();
SampleDataGenerator sampleDataGenerator =
new SampleDataGenerator(dataSource, taskanaEngineConfiguration.getSchemaName());
new SampleDataGenerator(dataSource, taskanaConfiguration.getSchemaName());
if (generateSampleData) {
sampleDataGenerator.generateSampleData();
}
@ -43,9 +43,9 @@ public class ExampleRestConfiguration {
@Bean
@DependsOn("generateSampleData")
public TaskanaEngine getTaskanaEngine(TaskanaConfiguration taskanaEngineConfiguration)
public TaskanaEngine getTaskanaEngine(TaskanaConfiguration taskanaConfiguration)
throws SQLException {
return TaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
return TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
}
// only required to let the adapter example connect to the same database

6
rest/taskana-rest-spring/src/main/java/pro/taskana/common/rest/RestConfiguration.java
View File

@ -73,14 +73,14 @@ public class RestConfiguration {
@Bean
@ConditionalOnMissingBean(TaskanaEngine.class)
public TaskanaEngine getTaskanaEngine(TaskanaConfiguration taskanaEngineConfiguration)
public TaskanaEngine getTaskanaEngine(TaskanaConfiguration taskanaConfiguration)
throws SQLException {
return SpringTaskanaEngine.buildTaskanaEngine(taskanaEngineConfiguration);
return SpringTaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
}
@Bean
@ConditionalOnMissingBean(TaskanaConfiguration.class)
public TaskanaConfiguration taskanaEngineConfiguration(
public TaskanaConfiguration taskanaConfiguration(
DataSource dataSource,
@Qualifier("taskanaPropertiesFileName") String propertiesFileName,
@Qualifier("taskanaPropertiesDelimiter") String delimiter) {

18
rest/taskana-rest-spring/src/main/java/pro/taskana/common/rest/TaskanaEngineController.java
View File

@ -25,18 +25,18 @@ import pro.taskana.common.rest.models.VersionRepresentationModel;
@EnableHypermediaSupport(type = EnableHypermediaSupport.HypermediaType.HAL)
public class TaskanaEngineController {
private final TaskanaConfiguration taskanaEngineConfiguration;
private final TaskanaConfiguration taskanaConfiguration;
private final TaskanaEngine taskanaEngine;
private final CurrentUserContext currentUserContext;
private final ConfigurationService configurationService;
@Autowired
TaskanaEngineController(
TaskanaConfiguration taskanaEngineConfiguration,
TaskanaConfiguration taskanaConfiguration,
TaskanaEngine taskanaEngine,
CurrentUserContext currentUserContext,
ConfigurationService configurationService) {
this.taskanaEngineConfiguration = taskanaEngineConfiguration;
this.taskanaConfiguration = taskanaConfiguration;
this.taskanaEngine = taskanaEngine;
this.currentUserContext = currentUserContext;
this.configurationService = configurationService;
@ -50,7 +50,7 @@ public class TaskanaEngineController {
@GetMapping(path = RestEndpoints.URL_DOMAIN)
@Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<List<String>> getDomains() {
return ResponseEntity.ok(taskanaEngineConfiguration.getDomains());
return ResponseEntity.ok(taskanaConfiguration.getDomains());
}
/**
@ -66,9 +66,9 @@ public class TaskanaEngineController {
public ResponseEntity<List<String>> getClassificationCategories(
@RequestParam(required = false) String type) {
if (type != null) {
return ResponseEntity.ok(taskanaEngineConfiguration.getClassificationCategoriesByType(type));
return ResponseEntity.ok(taskanaConfiguration.getClassificationCategoriesByType(type));
}
return ResponseEntity.ok(taskanaEngineConfiguration.getAllClassificationCategories());
return ResponseEntity.ok(taskanaConfiguration.getAllClassificationCategories());
}
/**
@ -79,7 +79,7 @@ public class TaskanaEngineController {
@GetMapping(path = RestEndpoints.URL_CLASSIFICATION_TYPES)
@Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<List<String>> getClassificationTypes() {
return ResponseEntity.ok(taskanaEngineConfiguration.getClassificationTypes());
return ResponseEntity.ok(taskanaConfiguration.getClassificationTypes());
}
/**
@ -91,7 +91,7 @@ public class TaskanaEngineController {
@GetMapping(path = RestEndpoints.URL_CLASSIFICATION_CATEGORIES_BY_TYPES)
@Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<Map<String, List<String>>> getClassificationCategoriesByTypeMap() {
return ResponseEntity.ok(taskanaEngineConfiguration.getClassificationCategoriesByType());
return ResponseEntity.ok(taskanaConfiguration.getClassificationCategoriesByType());
}
/**
@ -105,7 +105,7 @@ public class TaskanaEngineController {
TaskanaUserInfoRepresentationModel resource = new TaskanaUserInfoRepresentationModel();
resource.setUserId(currentUserContext.getUserid());
resource.setGroupIds(currentUserContext.getGroupIds());
taskanaEngineConfiguration.getRoleMap().keySet().stream()
taskanaConfiguration.getRoleMap().keySet().stream()
.filter(taskanaEngine::isUserInRole)
.forEach(resource.getRoles()::add);
return ResponseEntity.ok(resource);

10
rest/taskana-rest-spring/src/main/java/pro/taskana/common/rest/ldap/LdapClient.java
View File

@ -43,7 +43,7 @@ public class LdapClient {
private static final Logger LOGGER = LoggerFactory.getLogger(LdapClient.class);
private static final String CN = "cn";
private final TaskanaConfiguration taskanaEngineConfiguration;
private final TaskanaConfiguration taskanaConfiguration;
private final Environment env;
private final LdapTemplate ldapTemplate;
private final boolean useLowerCaseForAccessIds;
@ -54,10 +54,10 @@ public class LdapClient {
@Autowired
public LdapClient(
Environment env, LdapTemplate ldapTemplate, TaskanaConfiguration taskanaEngineConfiguration) {
Environment env, LdapTemplate ldapTemplate, TaskanaConfiguration taskanaConfiguration) {
this.env = env;
this.ldapTemplate = ldapTemplate;
this.taskanaEngineConfiguration = taskanaEngineConfiguration;
this.taskanaConfiguration = taskanaConfiguration;
this.useLowerCaseForAccessIds = TaskanaConfiguration.shouldUseLowerCaseForAccessIds();
}
@ -107,7 +107,7 @@ public class LdapClient {
new WhitespaceWildcardsFilter(getUserFullnameAttribute(), nameOrAccessId));
userDetailsOrFilter.or(new WhitespaceWildcardsFilter(getUserIdAttribute(), nameOrAccessId));
Set<String> userGroups = taskanaEngineConfiguration.getRoleMap().get(TaskanaRole.USER);
Set<String> userGroups = taskanaConfiguration.getRoleMap().get(TaskanaRole.USER);
final OrFilter groupMembershipOrFilter = new OrFilter();
userGroups.forEach(
@ -134,7 +134,7 @@ public class LdapClient {
public List<User> searchUsersInUserRole() {
Set<String> userGroupsOrUser = taskanaEngineConfiguration.getRoleMap().get(TaskanaRole.USER);
Set<String> userGroupsOrUser = taskanaConfiguration.getRoleMap().get(TaskanaRole.USER);
final OrFilter userOrGroupFilter = new OrFilter();
userGroupsOrUser.forEach(

6
rest/taskana-rest-spring/src/test/java/pro/taskana/common/rest/ldap/LdapClientTest.java
View File

@ -42,7 +42,7 @@ class LdapClientTest {
@Mock LdapTemplate ldapTemplate;
@Mock TaskanaConfiguration taskanaEngineConfiguration;
@Mock TaskanaConfiguration taskanaConfiguration;
@Spy @InjectMocks LdapClient cut;
@ -98,7 +98,7 @@ class LdapClientTest {
List<AccessIdRepresentationModel> accessIds =
new ArrayList<>(List.of(model1, model2, model3, model4));
LdapClient ldapClient = new LdapClient(environment, ldapTemplate, taskanaEngineConfiguration);
LdapClient ldapClient = new LdapClient(environment, ldapTemplate, taskanaConfiguration);
ldapClient.sortListOfAccessIdResources(accessIds);
assertThat(accessIds)
.extracting(AccessIdRepresentationModel::getAccessId)
@ -117,7 +117,7 @@ class LdapClientTest {
Map<TaskanaRole, Set<String>> roleMap = new HashMap<>();
roleMap.put(TaskanaRole.USER, groupsOfUserRole);
when(taskanaEngineConfiguration.getRoleMap()).thenReturn(roleMap);
when(taskanaConfiguration.getRoleMap()).thenReturn(roleMap);
when(ldapTemplate.search(
any(String.class), any(), anyInt(), any(), any(LdapClient.UserContextMapper.class)))

7
routing/taskana-routing-rest/src/test/java/pro/taskana/routing/dmn/service/DmnConverterServiceAccTest.java
View File

@ -44,19 +44,18 @@ class DmnConverterServiceAccTest {
DataSource dataSource = DataSourceGenerator.createDataSourceForH2();
String schemaName = "TASKANA";
TaskanaConfiguration taskanaEngineConfiguration =
TaskanaConfiguration taskanaConfiguration =
new TaskanaConfiguration.Builder(dataSource, false, schemaName)
.initTaskanaProperties()
.germanPublicHolidaysEnabled(true)
.build();
SampleDataGenerator sampleDataGenerator =
new SampleDataGenerator(dataSource, taskanaEngineConfiguration.getSchemaName());
new SampleDataGenerator(dataSource, taskanaConfiguration.getSchemaName());
if (dropTables) {
sampleDataGenerator.dropDb();
}
taskanaEngine =
TaskanaEngine.buildTaskanaEngine(
taskanaEngineConfiguration, ConnectionManagementMode.AUTOCOMMIT);
TaskanaEngine.buildTaskanaEngine(taskanaConfiguration, ConnectionManagementMode.AUTOCOMMIT);
sampleDataGenerator.clearDb();
sampleDataGenerator.generateTestData();

9
routing/taskana-spi-routing-dmn-router/src/test/java/pro/taskana/AbstractAccTest.java
View File

@ -13,7 +13,7 @@ import pro.taskana.task.internal.models.ObjectReferenceImpl;
public abstract class AbstractAccTest {
protected static TaskanaConfiguration taskanaEngineConfiguration;
protected static TaskanaConfiguration taskanaConfiguration;
protected static TaskanaEngine taskanaEngine;
@BeforeAll
@ -30,19 +30,18 @@ public abstract class AbstractAccTest {
sampleDataGenerator.dropDb();
}
dataSource = DataSourceGenerator.getDataSource();
taskanaEngineConfiguration =
taskanaConfiguration =
new TaskanaConfiguration.Builder(dataSource, false, schemaName)
.initTaskanaProperties()
.germanPublicHolidaysEnabled(true)
.build();
DbSchemaCreator dbSchemaCreator =
new DbSchemaCreator(dataSource, taskanaEngineConfiguration.getSchemaName());
new DbSchemaCreator(dataSource, taskanaConfiguration.getSchemaName());
dbSchemaCreator.run();
sampleDataGenerator.clearDb();
sampleDataGenerator.generateTestData();
taskanaEngine =
TaskanaEngine.buildTaskanaEngine(
taskanaEngineConfiguration, ConnectionManagementMode.AUTOCOMMIT);
TaskanaEngine.buildTaskanaEngine(taskanaConfiguration, ConnectionManagementMode.AUTOCOMMIT);
}
protected ObjectReference createObjectReference(