From a519e561f0ea3cc06a7b406b0c1ad8cbb908ed44 Mon Sep 17 00:00:00 2001 From: Mustapha Zorgati <15628173+mustaphazorgati@users.noreply.github.com> Date: Fri, 22 Dec 2017 11:12:03 +0100 Subject: [PATCH 1/2] fixed manifest version change after deployment --- lib/deployment/deploy.sh | 2 +- lib/taskana-cdi-example/pom.xml | 4 ++-- lib/taskana-cdi/pom.xml | 2 +- lib/taskana-spring-example/pom.xml | 4 ++-- lib/taskana-spring/pom.xml | 2 +- manifest.yml | 2 +- rest/pom.xml | 2 +- 7 files changed, 9 insertions(+), 9 deletions(-) diff --git a/lib/deployment/deploy.sh b/lib/deployment/deploy.sh index 16d3dbfec..6ab16eab2 100755 --- a/lib/deployment/deploy.sh +++ b/lib/deployment/deploy.sh @@ -306,7 +306,7 @@ function main { fi if [[ -n "$MANIFEST" ]]; then - $debug sed -i "s|$MANIFEST_PREFIX.*\.jar|$MANIFEST_PREFIX-${TRAVIS_TAG##v}-SNAPSHOT.jar|" "$MANIFEST" + $debug sed -i "s|$MANIFEST_PREFIX.*\.jar|$MANIFEST_PREFIX-$newVersion-SNAPSHOT.jar|" "$MANIFEST" fi push_new_poms "$MANIFEST" "$SWARM" diff --git a/lib/taskana-cdi-example/pom.xml b/lib/taskana-cdi-example/pom.xml index 84fdd3303..944f4fb0e 100644 --- a/lib/taskana-cdi-example/pom.xml +++ b/lib/taskana-cdi-example/pom.xml @@ -23,13 +23,13 @@ pro.taskana taskana-core - 0.0.4-SNAPSHOT + ${project.version} pro.taskana taskana-cdi - 0.0.4-SNAPSHOT + ${project.version} The Taskana Spring sample application. diff --git a/lib/taskana-cdi/pom.xml b/lib/taskana-cdi/pom.xml index d9e82b21f..fc4479263 100644 --- a/lib/taskana-cdi/pom.xml +++ b/lib/taskana-cdi/pom.xml @@ -152,7 +152,7 @@ pro.taskana taskana-core - 0.0.4-SNAPSHOT + ${project.version} provided diff --git a/lib/taskana-spring-example/pom.xml b/lib/taskana-spring-example/pom.xml index f24b4f0e2..0f1684731 100644 --- a/lib/taskana-spring-example/pom.xml +++ b/lib/taskana-spring-example/pom.xml @@ -42,12 +42,12 @@ pro.taskana taskana-core - 0.0.4-SNAPSHOT + ${project.version} pro.taskana taskana-spring - 0.0.4-SNAPSHOT + ${project.version} diff --git a/lib/taskana-spring/pom.xml b/lib/taskana-spring/pom.xml index 34e6a86f8..0357489b5 100644 --- a/lib/taskana-spring/pom.xml +++ b/lib/taskana-spring/pom.xml @@ -157,7 +157,7 @@ pro.taskana taskana-core - 0.0.4-SNAPSHOT + ${project.version} diff --git a/manifest.yml b/manifest.yml index 302f142db..b459d6876 100644 --- a/manifest.yml +++ b/manifest.yml @@ -1,7 +1,7 @@ # Configuration file for Cloud Foundry, see https://docs.cloudfoundry.org/devguide/deploy-apps/manifest.html applications: - name: taskana-rest - path: rest/target/rest-0.0.3-SNAPSHOT.jar + path: rest/target/rest-0.0.4-SNAPSHOT.jar buildpack: https://github.com/cloudfoundry/java-buildpack.git#v3.10 memory: 512M disk_quota: 256M diff --git a/rest/pom.xml b/rest/pom.xml index bcec548cf..0130321f9 100644 --- a/rest/pom.xml +++ b/rest/pom.xml @@ -37,7 +37,7 @@ pro.taskana taskana-core - 0.0.3-SNAPSHOT + ${project.version} From d873db61bfc25062e9fc44a153dca94fce2c780b Mon Sep 17 00:00:00 2001 From: Holger Hagen <19706592+holgerhagen@users.noreply.github.com> Date: Fri, 22 Dec 2017 09:36:11 +0100 Subject: [PATCH 2/2] TSK-112: first acceptance tests added. --- ...ScriptRunner.java => DbSchemaCreator.java} | 6 +- .../TaskanaEngineConfiguration.java | 4 +- .../test/java/acceptance/AbstractAccTest.java | 56 ++++++ .../DeleteClassificationAccTest.java | 80 +++++++++ .../GetClassificationAccTest.java | 66 +++++++ .../QueryClassificationAccTest.java | 62 +++++++ .../acceptance/task/CreateTaskAccTest.java | 167 ++++++++++++++++++ .../QueryTasksByObjectReferenceAccTest.java | 61 +++++++ .../QueryWorkbasketByPermissionAccTest.java | 85 +++++++++ .../taskana/database/TestDataGenerator.java | 69 ++++++++ .../taskana/impl/configuration/DBCleaner.java | 4 +- .../src/test/resources/sql/classification.sql | 30 ++++ .../resources/sql/distribution-targets.sql | 1 + .../test/resources/sql/object-reference.sql | 3 + .../src/test/resources/sql/task.sql | 18 ++ .../resources/sql/workbasket-access-list.sql | 33 ++++ .../src/test/resources/sql/workbasket.sql | 14 ++ .../SpringTaskanaEngineConfiguration.java | 2 +- 18 files changed, 753 insertions(+), 8 deletions(-) rename lib/taskana-core/src/main/java/pro/taskana/configuration/{DbScriptRunner.java => DbSchemaCreator.java} (95%) create mode 100644 lib/taskana-core/src/test/java/acceptance/AbstractAccTest.java create mode 100644 lib/taskana-core/src/test/java/acceptance/classification/DeleteClassificationAccTest.java create mode 100644 lib/taskana-core/src/test/java/acceptance/classification/GetClassificationAccTest.java create mode 100644 lib/taskana-core/src/test/java/acceptance/classification/QueryClassificationAccTest.java create mode 100644 lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java create mode 100644 lib/taskana-core/src/test/java/acceptance/task/QueryTasksByObjectReferenceAccTest.java create mode 100644 lib/taskana-core/src/test/java/acceptance/workbasket/QueryWorkbasketByPermissionAccTest.java create mode 100644 lib/taskana-core/src/test/java/pro/taskana/database/TestDataGenerator.java create mode 100644 lib/taskana-core/src/test/resources/sql/classification.sql create mode 100644 lib/taskana-core/src/test/resources/sql/distribution-targets.sql create mode 100644 lib/taskana-core/src/test/resources/sql/object-reference.sql create mode 100644 lib/taskana-core/src/test/resources/sql/task.sql create mode 100644 lib/taskana-core/src/test/resources/sql/workbasket-access-list.sql create mode 100644 lib/taskana-core/src/test/resources/sql/workbasket.sql diff --git a/lib/taskana-core/src/main/java/pro/taskana/configuration/DbScriptRunner.java b/lib/taskana-core/src/main/java/pro/taskana/configuration/DbSchemaCreator.java similarity index 95% rename from lib/taskana-core/src/main/java/pro/taskana/configuration/DbScriptRunner.java rename to lib/taskana-core/src/main/java/pro/taskana/configuration/DbSchemaCreator.java index 1b575ba72..a4854e898 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/configuration/DbScriptRunner.java +++ b/lib/taskana-core/src/main/java/pro/taskana/configuration/DbSchemaCreator.java @@ -15,9 +15,9 @@ import org.slf4j.LoggerFactory; /** * This class create the schema for taskana. */ -public class DbScriptRunner { +public class DbSchemaCreator { - private static final Logger LOGGER = LoggerFactory.getLogger(DbScriptRunner.class); + private static final Logger LOGGER = LoggerFactory.getLogger(DbSchemaCreator.class); private static final String SQL = "/sql"; private static final String DB_SCHEMA = SQL + "/taskana-schema.sql"; @@ -30,7 +30,7 @@ public class DbScriptRunner { private StringWriter errorWriter = new StringWriter(); private PrintWriter errorLogWriter = new PrintWriter(errorWriter); - public DbScriptRunner(DataSource dataSource) { + public DbSchemaCreator(DataSource dataSource) { super(); this.dataSource = dataSource; } diff --git a/lib/taskana-core/src/main/java/pro/taskana/configuration/TaskanaEngineConfiguration.java b/lib/taskana-core/src/main/java/pro/taskana/configuration/TaskanaEngineConfiguration.java index e48b2c3e3..324d405bb 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/configuration/TaskanaEngineConfiguration.java +++ b/lib/taskana-core/src/main/java/pro/taskana/configuration/TaskanaEngineConfiguration.java @@ -24,7 +24,7 @@ public class TaskanaEngineConfiguration { private static final String H2_DRIVER = "org.h2.Driver"; protected DataSource dataSource; - protected DbScriptRunner dbScriptRunner; + protected DbSchemaCreator dbScriptRunner; // global switch to enable JAAS based authentication and Taskana // authorizations @@ -49,7 +49,7 @@ public class TaskanaEngineConfiguration { // use default In Memory datasource this.dataSource = createDefaultDataSource(); } - dbScriptRunner = new DbScriptRunner(this.dataSource); + dbScriptRunner = new DbSchemaCreator(this.dataSource); dbScriptRunner.run(); this.securityEnabled = securityEnabled; diff --git a/lib/taskana-core/src/test/java/acceptance/AbstractAccTest.java b/lib/taskana-core/src/test/java/acceptance/AbstractAccTest.java new file mode 100644 index 000000000..31e1bfb1b --- /dev/null +++ b/lib/taskana-core/src/test/java/acceptance/AbstractAccTest.java @@ -0,0 +1,56 @@ +package acceptance; + +import java.sql.SQLException; + +import javax.sql.DataSource; + +import org.junit.BeforeClass; + +import pro.taskana.TaskanaEngine; +import pro.taskana.TaskanaEngine.ConnectionManagementMode; +import pro.taskana.configuration.TaskanaEngineConfiguration; +import pro.taskana.database.TestDataGenerator; +import pro.taskana.impl.TaskanaEngineImpl; +import pro.taskana.impl.configuration.DBCleaner; +import pro.taskana.impl.configuration.TaskanaEngineConfigurationTest; +import pro.taskana.model.ObjectReference; + +/** + * Base class for all acceptance tests. + */ +public abstract class AbstractAccTest { + + protected static TaskanaEngineConfiguration taskanaEngineConfiguration; + + protected static TaskanaEngine taskanaEngine; + + @BeforeClass + public static void setupTest() throws Exception { + resetDb(); + } + + public static void resetDb() throws SQLException { + DataSource dataSource = TaskanaEngineConfigurationTest.getDataSource(); + DBCleaner cleaner = new DBCleaner(); + cleaner.clearDb(dataSource, true); + dataSource = TaskanaEngineConfigurationTest.getDataSource(); + taskanaEngineConfiguration = new TaskanaEngineConfiguration(dataSource, false); + taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine(); + ((TaskanaEngineImpl) taskanaEngine).setConnectionManagementMode(ConnectionManagementMode.AUTOCOMMIT); + cleaner.clearDb(dataSource, false); + TestDataGenerator testDataGenerator = new TestDataGenerator(); + testDataGenerator.generateTestData(dataSource); + } + + protected ObjectReference createObjectReference(String company, String system, String systemInstance, String type, + String value) { + ObjectReference objectReference = new ObjectReference(); + objectReference.setCompany(company); + objectReference.setSystem(system); + objectReference.setSystemInstance(systemInstance); + objectReference.setType(type); + objectReference.setValue(value); + return objectReference; + } + +} diff --git a/lib/taskana-core/src/test/java/acceptance/classification/DeleteClassificationAccTest.java b/lib/taskana-core/src/test/java/acceptance/classification/DeleteClassificationAccTest.java new file mode 100644 index 000000000..fe9a6085c --- /dev/null +++ b/lib/taskana-core/src/test/java/acceptance/classification/DeleteClassificationAccTest.java @@ -0,0 +1,80 @@ +package acceptance.classification; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import java.sql.Date; +import java.sql.SQLException; +import java.util.List; + +import org.h2.store.fs.FileUtils; +import org.junit.AfterClass; +import org.junit.Ignore; +import org.junit.Test; + +import acceptance.AbstractAccTest; +import pro.taskana.Classification; +import pro.taskana.ClassificationService; +import pro.taskana.exceptions.ClassificationNotFoundException; +import pro.taskana.exceptions.NotAuthorizedException; + +/** + * Acceptance test for all "delete classification" scenarios. + */ +public class DeleteClassificationAccTest extends AbstractAccTest { + + public DeleteClassificationAccTest() { + super(); + } + + @Ignore + @Test + public void testDeleteClassificationInDomain() + throws SQLException, ClassificationNotFoundException, NotAuthorizedException { + ClassificationService classificationService = taskanaEngine.getClassificationService(); + // classificationService.deleteClassification("L140101", "DOMAIN_A"); + + Classification classification = classificationService.getClassification("L140101", "DOMAIN_A"); + assertNotNull(classification); + assertEquals("", classification.getDomain()); + + List classifications = classificationService.getAllClassificationsWithKey("L140101", + "DOMAIN_A"); + Date lastOneValidUntil = classifications.get(classifications.size() - 1).getValidUntil(); + assertTrue(lastOneValidUntil.before(new Date(System.currentTimeMillis()))); + } + + @Ignore + @Test + public void testDeleteClassificationFromRootDomain() + throws SQLException, ClassificationNotFoundException, NotAuthorizedException { + ClassificationService classificationService = taskanaEngine.getClassificationService(); + // classificationService.deleteClassification("L1050", "DOMAIN_A"); + // classificationService.deleteClassification("L1050", ""); + + Classification classification = classificationService.getClassification("L140101", "DOMAIN_A"); + assertTrue(classification == null); + } + + // @Ignore + // @Test(expected = ClassificationInUseException.class) + // public void testGetExceptionIfDeletedClassificationFromRootDomainIsStillUsedInDomain() + // throws SQLException, ClassificationNotFoundException, NotAuthorizedException, ClassificationInUseException { + // ClassificationService classificationService = taskanaEngine.getClassificationService(); + // classificationService.deleteClassification("L10000", ""); + // } + // + // @Ignore + // @Test(expected = ClassificationInUseException.class) + // public void testGetExceptionIfDeletedClassificationIsStillUsedInTask() + // throws SQLException, ClassificationNotFoundException, NotAuthorizedException, ClassificationInUseException { + // ClassificationService classificationService = taskanaEngine.getClassificationService(); + // classificationService.deleteClassification("L10000", "DOMAIN_A"); + // } + + @AfterClass + public static void cleanUpClass() { + FileUtils.deleteRecursive("~/data", true); + } +} diff --git a/lib/taskana-core/src/test/java/acceptance/classification/GetClassificationAccTest.java b/lib/taskana-core/src/test/java/acceptance/classification/GetClassificationAccTest.java new file mode 100644 index 000000000..6232d8afb --- /dev/null +++ b/lib/taskana-core/src/test/java/acceptance/classification/GetClassificationAccTest.java @@ -0,0 +1,66 @@ +package acceptance.classification; + +import java.sql.SQLException; +import java.util.List; + +import org.h2.store.fs.FileUtils; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.Ignore; +import org.junit.Test; + +import acceptance.AbstractAccTest; +import pro.taskana.Classification; +import pro.taskana.ClassificationService; +import pro.taskana.exceptions.ClassificationNotFoundException; +import pro.taskana.exceptions.NotAuthorizedException; + +/** + * Acceptance test for all "get classification" scenarios. + */ +public class GetClassificationAccTest extends AbstractAccTest { + + public GetClassificationAccTest() { + super(); + } + + @Test + public void testFindAllClassifications() + throws SQLException, ClassificationNotFoundException, NotAuthorizedException { + ClassificationService classificationService = taskanaEngine.getClassificationService(); + List classificationList = classificationService.getClassificationTree(); + Assert.assertNotNull(classificationList); + } + + @Test + public void testGetOneClassificationForDomain() throws SQLException, ClassificationNotFoundException { + ClassificationService classificationService = taskanaEngine.getClassificationService(); + Classification classification = classificationService.getClassification("T6310", "DOMAIN_A"); + Assert.assertNotNull(classification); + } + + @Ignore + @Test + public void testGetOneClassificationForDomainAndGetClassificationFromRootDomain() + throws SQLException, ClassificationNotFoundException { + ClassificationService classificationService = taskanaEngine.getClassificationService(); + Classification classification = classificationService.getClassification("L10000", "DOMAIN_B"); + Assert.assertNotNull(classification); + Assert.assertEquals("", classification.getDomain()); + Assert.assertEquals(999L, classification.getPriority()); + } + + @Test + public void testGetOneClassificationForRootDomain() throws SQLException, ClassificationNotFoundException { + ClassificationService classificationService = taskanaEngine.getClassificationService(); + Classification classification = classificationService.getClassification("L10000", ""); + Assert.assertNotNull(classification); + Assert.assertEquals("", classification.getDomain()); + Assert.assertEquals(999L, classification.getPriority()); + } + + @AfterClass + public static void cleanUpClass() { + FileUtils.deleteRecursive("~/data", true); + } +} diff --git a/lib/taskana-core/src/test/java/acceptance/classification/QueryClassificationAccTest.java b/lib/taskana-core/src/test/java/acceptance/classification/QueryClassificationAccTest.java new file mode 100644 index 000000000..d561bd2aa --- /dev/null +++ b/lib/taskana-core/src/test/java/acceptance/classification/QueryClassificationAccTest.java @@ -0,0 +1,62 @@ +package acceptance.classification; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; + +import java.sql.SQLException; +import java.util.List; + +import org.h2.store.fs.FileUtils; +import org.junit.AfterClass; +import org.junit.Ignore; +import org.junit.Test; + +import acceptance.AbstractAccTest; +import pro.taskana.Classification; +import pro.taskana.ClassificationService; +import pro.taskana.exceptions.ClassificationNotFoundException; +import pro.taskana.exceptions.NotAuthorizedException; + +/** + * Acceptance test for all "get classification" scenarios. + */ +public class QueryClassificationAccTest extends AbstractAccTest { + + public QueryClassificationAccTest() { + super(); + } + + @Test + public void testFindClassificationsByCategoryAndDomain() + throws SQLException, ClassificationNotFoundException, NotAuthorizedException { + ClassificationService classificationService = taskanaEngine.getClassificationService(); + List classificationList = classificationService.createClassificationQuery() + .category("MANUAL") + .domain("DOMAIN_A") + .list(); + + assertNotNull(classificationList); + assertEquals(2, classificationList.size()); + } + + @Ignore + @Test + public void testGetOneClassificationForMultipleDomains() + throws SQLException, ClassificationNotFoundException, NotAuthorizedException { + ClassificationService classificationService = taskanaEngine.getClassificationService(); + List classifications = classificationService.createClassificationQuery() + .type("L10000") + .domain("DOMAIN_A", "DOMAIN_B") + .list(); + + assertNotNull(classifications); + assertEquals(2, classifications.size()); + assertEquals(2, classifications.get(0).getPriority()); + assertEquals(22, classifications.get(1).getPriority()); + } + + @AfterClass + public static void cleanUpClass() { + FileUtils.deleteRecursive("~/data", true); + } +} diff --git a/lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java new file mode 100644 index 000000000..bbf769fda --- /dev/null +++ b/lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java @@ -0,0 +1,167 @@ +package acceptance.task; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; + +import java.sql.SQLException; + +import org.h2.store.fs.FileUtils; +import org.junit.AfterClass; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.runner.RunWith; + +import acceptance.AbstractAccTest; +import pro.taskana.Task; +import pro.taskana.TaskService; +import pro.taskana.exceptions.ClassificationNotFoundException; +import pro.taskana.exceptions.InvalidArgumentException; +import pro.taskana.exceptions.InvalidWorkbasketException; +import pro.taskana.exceptions.NotAuthorizedException; +import pro.taskana.exceptions.TaskAlreadyExistException; +import pro.taskana.exceptions.WorkbasketNotFoundException; +import pro.taskana.model.TaskState; +import pro.taskana.security.JAASRunner; +import pro.taskana.security.WithAccessId; + +/** + * Acceptance test for all "create task" scenarios. + */ +@RunWith(JAASRunner.class) +public class CreateTaskAccTest extends AbstractAccTest { + + public CreateTaskAccTest() { + super(); + } + + @WithAccessId( + userName = "user_1_1", + groupNames = { "group_1" }) + @Test + public void testCreateSimpleManualTask() + throws SQLException, NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException, + WorkbasketNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException { + + TaskService taskService = taskanaEngine.getTaskService(); + Task newTask = taskService.newTask(); + newTask.setClassification(taskanaEngine.getClassificationService().getClassification("T2100", "DOMAIN_A")); + newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567")); + newTask.setWorkbasketKey("USER_1_1"); + Task createdTask = taskService.createTask(newTask); + + assertNotNull(createdTask); + assertEquals("T-Vertragstermin VERA", createdTask.getName()); + assertEquals("1234567", createdTask.getPrimaryObjRef().getValue()); + assertNotNull(createdTask.getCreated()); + assertNotNull(createdTask.getModified()); + assertNotNull(createdTask.getBusinessProcessId()); + assertEquals(null, createdTask.getClaimed()); + assertEquals(null, createdTask.getCompleted()); + assertEquals(createdTask.getCreated(), createdTask.getModified()); + assertEquals(createdTask.getCreated(), createdTask.getPlanned()); + assertEquals(TaskState.READY, createdTask.getState()); + assertEquals(null, createdTask.getParentBusinessProcessId()); + assertEquals(2, createdTask.getPriority()); + assertEquals(false, createdTask.isRead()); + assertEquals(false, createdTask.isTransferred()); + } + + @WithAccessId( + userName = "user_1_1", + groupNames = { "group_1" }) + @Test + public void testUseCustomNameIfSetForNewTask() + throws SQLException, NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException, + WorkbasketNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException { + + TaskService taskService = taskanaEngine.getTaskService(); + Task newTask = taskService.newTask(); + newTask.setClassification(taskanaEngine.getClassificationService().getClassification("T2100", "DOMAIN_A")); + newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567")); + newTask.setWorkbasketKey("USER_1_1"); + newTask.setName("Test Name"); + Task createdTask = taskService.createTask(newTask); + + assertNotNull(createdTask); + assertEquals("Test Name", createdTask.getName()); + } + + @Ignore + @WithAccessId( + userName = "user_1_1", + groupNames = { "group_1" }) + @Test + public void testUseClassificationMetadataFromCorrectDomainForNewTask() + throws SQLException, NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException, + WorkbasketNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException { + + TaskService taskService = taskanaEngine.getTaskService(); + Task newTask = taskService.newTask(); + newTask.setClassification(taskanaEngine.getClassificationService().getClassification("T2100", "DOMAIN_B")); + newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567")); + newTask.setWorkbasketKey("USER_1_1"); + newTask.setName("Test Name"); + Task createdTask = taskService.createTask(newTask); + + assertNotNull(createdTask); + assertEquals(2, createdTask.getPriority()); // priority is 22 in DOMAIN_B, task is created in DOMAIN_A + } + + @Ignore + @WithAccessId( + userName = "user_1_1", + groupNames = { "group_1" }) + @Test + public void testImprovedUseClassificationMetadataFromCorrectDomainForNewTask() + throws SQLException, NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException, + WorkbasketNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException { + + TaskService taskService = taskanaEngine.getTaskService(); + Task newTask = taskService.newTask(); + // newTask.setClassificationKey("T2100"); + newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567")); + newTask.setWorkbasketKey("USER_1_1"); + newTask.setName("Test Name"); + Task createdTask = taskService.createTask(newTask); + + assertNotNull(createdTask); + assertEquals(2, createdTask.getPriority()); // priority is 22 in DOMAIN_B, task is created in DOMAIN_A + } + + @WithAccessId( + userName = "user_1_1", + groupNames = { "group_1" }) + @Test(expected = WorkbasketNotFoundException.class) + public void testGetExceptionIfWorkbasketDoesNotExist() + throws SQLException, NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException, + WorkbasketNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException { + + TaskService taskService = taskanaEngine.getTaskService(); + Task newTask = taskService.newTask(); + newTask.setClassification(taskanaEngine.getClassificationService().getClassification("T2100", "DOMAIN_A")); + newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567")); + newTask.setWorkbasketKey("UNKNOWN"); + taskService.createTask(newTask); + } + + @WithAccessId( + userName = "user_1_1", + groupNames = { "group_1" }) + @Test(expected = NotAuthorizedException.class) + public void testGetExceptionIfAppendIsNotPermitted() + throws SQLException, NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException, + WorkbasketNotFoundException, TaskAlreadyExistException, InvalidWorkbasketException { + + TaskService taskService = taskanaEngine.getTaskService(); + Task newTask = taskService.newTask(); + newTask.setClassification(taskanaEngine.getClassificationService().getClassification("T2100", "DOMAIN_A")); + newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567")); + newTask.setWorkbasketKey("GPK_KSC"); + taskService.createTask(newTask); + } + + @AfterClass + public static void cleanUpClass() { + FileUtils.deleteRecursive("~/data", true); + } +} diff --git a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByObjectReferenceAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByObjectReferenceAccTest.java new file mode 100644 index 000000000..bdfaae675 --- /dev/null +++ b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByObjectReferenceAccTest.java @@ -0,0 +1,61 @@ +package acceptance.task; + +import java.sql.SQLException; + +import org.h2.store.fs.FileUtils; +import org.junit.AfterClass; +import org.junit.Ignore; +import org.junit.Test; + +import acceptance.AbstractAccTest; +import pro.taskana.exceptions.InvalidArgumentException; +import pro.taskana.exceptions.NotAuthorizedException; + +/** + * Acceptance test for all "query tasks by object reference" scenarios. + */ +public class QueryTasksByObjectReferenceAccTest extends AbstractAccTest { + + public QueryTasksByObjectReferenceAccTest() { + super(); + } + + @Ignore + @Test + public void testQueryTasksByExcactValueOfObjectReference() + throws SQLException, NotAuthorizedException, InvalidArgumentException { + // TaskService taskService = taskanaEngine.getTaskService(); + // List results = taskService.createTaskQuery() + // .objectReferenceValueEquals("223344") + // .list(); + // Assert.assertEquals(5L, results.size()); + } + + @Ignore + @Test + public void testQueryTasksByExcactValueAndTypeOfObjectReference() + throws SQLException, NotAuthorizedException, InvalidArgumentException { + // TaskService taskService = taskanaEngine.getTaskService(); + // List results = taskService.createTaskQuery() + // .objectReferenceTypeEquals("VNR") + // .objectReferenceValueEquals("223344") + // .list(); + // Assert.assertEquals(3L, results.size()); + } + + @Ignore + @Test + public void testQueryTasksByValueLikeOfObjectReference() + throws SQLException, NotAuthorizedException, InvalidArgumentException { + // TaskService taskService = taskanaEngine.getTaskService(); + // List results = taskService.createTaskQuery() + // .objectReferenceValueLike("223") + // .list(); + // Assert.assertEquals(15L, results.size()); + } + + @AfterClass + public static void cleanUpClass() { + FileUtils.deleteRecursive("~/data", true); + } +} diff --git a/lib/taskana-core/src/test/java/acceptance/workbasket/QueryWorkbasketByPermissionAccTest.java b/lib/taskana-core/src/test/java/acceptance/workbasket/QueryWorkbasketByPermissionAccTest.java new file mode 100644 index 000000000..ad1734ddc --- /dev/null +++ b/lib/taskana-core/src/test/java/acceptance/workbasket/QueryWorkbasketByPermissionAccTest.java @@ -0,0 +1,85 @@ +package acceptance.workbasket; + +import java.sql.SQLException; +import java.util.List; + +import org.h2.store.fs.FileUtils; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.runner.RunWith; + +import acceptance.AbstractAccTest; +import pro.taskana.Workbasket; +import pro.taskana.WorkbasketService; +import pro.taskana.exceptions.InvalidArgumentException; +import pro.taskana.exceptions.NotAuthorizedException; +import pro.taskana.model.WorkbasketAuthorization; +import pro.taskana.security.JAASRunner; +import pro.taskana.security.WithAccessId; + +/** + * Acceptance test for all "query workbasket by permission" scenarios. + */ +@RunWith(JAASRunner.class) +public class QueryWorkbasketByPermissionAccTest extends AbstractAccTest { + + public QueryWorkbasketByPermissionAccTest() { + super(); + } + + @Test + public void testQueryAllTransferTargetsForUser() + throws SQLException, NotAuthorizedException, InvalidArgumentException { + WorkbasketService workbasketService = taskanaEngine.getWorkbasketService(); + List results = workbasketService.createWorkbasketQuery() + .access(WorkbasketAuthorization.APPEND, "user_1_1") + .list(); + Assert.assertEquals(1L, results.size()); + Assert.assertEquals("USER_1_1", results.get(0).getKey()); + } + + @Test + public void testQueryAllTransferTargetsForUserAndGroup() + throws SQLException, NotAuthorizedException, InvalidArgumentException { + WorkbasketService workbasketService = taskanaEngine.getWorkbasketService(); + List results = workbasketService.createWorkbasketQuery() + .access(WorkbasketAuthorization.APPEND, "user_1_1", "group_1") + .list(); + Assert.assertEquals(7L, results.size()); + } + + @Ignore + @WithAccessId( + userName = "user_1_1", + groupNames = { "group_1" }) + @Test + public void testQueryAllTransferTargetsForUserAndGroupFromSubject() + throws SQLException, NotAuthorizedException, InvalidArgumentException { + WorkbasketService workbasketService = taskanaEngine.getWorkbasketService(); + List results = workbasketService.createWorkbasketQuery() + .access(WorkbasketAuthorization.APPEND) + .list(); + Assert.assertEquals(7L, results.size()); + } + + @Ignore + @WithAccessId( + userName = "user_1_1", + groupNames = { "group_1" }) + @Test + public void testQueryAllAvailableWorkbasketForOpeningForUserAndGroupFromSubject() + throws SQLException, NotAuthorizedException, InvalidArgumentException { + // WorkbasketService workbasketService = taskanaEngine.getWorkbasketService(); + // List results = workbasketService.createWorkbasketQuery() + // .access(WorkbasketAuthorization.OPEN) + // .list(); + // Assert.assertEquals(7L, results.size()); + } + + @AfterClass + public static void cleanUpClass() { + FileUtils.deleteRecursive("~/data", true); + } +} diff --git a/lib/taskana-core/src/test/java/pro/taskana/database/TestDataGenerator.java b/lib/taskana-core/src/test/java/pro/taskana/database/TestDataGenerator.java new file mode 100644 index 000000000..fc6181f24 --- /dev/null +++ b/lib/taskana-core/src/test/java/pro/taskana/database/TestDataGenerator.java @@ -0,0 +1,69 @@ +package pro.taskana.database; + +import java.io.InputStreamReader; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.sql.Connection; +import java.sql.SQLException; + +import javax.sql.DataSource; + +import org.apache.ibatis.jdbc.ScriptRunner; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import pro.taskana.configuration.DbSchemaCreator; + +/** + * Generates the test data for integration and acceptance tests. + */ +public class TestDataGenerator { + + private static final Logger LOGGER = LoggerFactory.getLogger(DbSchemaCreator.class); + + private StringWriter outWriter = new StringWriter(); + + private PrintWriter logWriter; + + private StringWriter errorWriter; + + private PrintWriter errorLogWriter; + + public TestDataGenerator() { + this.logWriter = new PrintWriter(this.outWriter); + this.errorWriter = new StringWriter(); + this.errorLogWriter = new PrintWriter(this.errorWriter); + } + + public void generateTestData(DataSource dataSource) throws SQLException { + ScriptRunner runner = null; + try { + Connection connection = dataSource.getConnection(); + LOGGER.debug(connection.getMetaData().toString()); + runner = new ScriptRunner(connection); + runner.setStopOnError(true); + runner.setLogWriter(this.logWriter); + runner.setErrorLogWriter(this.errorLogWriter); + runner.setStopOnError(true); + runner.setLogWriter(this.logWriter); + runner.setErrorLogWriter(this.errorLogWriter); + runner.runScript(new InputStreamReader(this.getClass().getResourceAsStream("/sql/task.sql"))); + runner.runScript(new InputStreamReader(this.getClass().getResourceAsStream("/sql/workbasket.sql"))); + runner.runScript( + new InputStreamReader(this.getClass().getResourceAsStream("/sql/distribution-targets.sql"))); + runner.runScript( + new InputStreamReader(this.getClass().getResourceAsStream("/sql/classification.sql"))); + runner.runScript( + new InputStreamReader(this.getClass().getResourceAsStream("/sql/workbasket-access-list.sql"))); + runner.runScript( + new InputStreamReader(this.getClass().getResourceAsStream("/sql/object-reference.sql"))); + } finally { + + runner.closeConnection(); + LOGGER.debug(outWriter.toString()); + if (!errorWriter.toString().trim().isEmpty()) { + LOGGER.error(errorWriter.toString()); + } + } + } +} diff --git a/lib/taskana-core/src/test/java/pro/taskana/impl/configuration/DBCleaner.java b/lib/taskana-core/src/test/java/pro/taskana/impl/configuration/DBCleaner.java index e3576938d..6f39301a0 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/impl/configuration/DBCleaner.java +++ b/lib/taskana-core/src/test/java/pro/taskana/impl/configuration/DBCleaner.java @@ -11,13 +11,13 @@ import javax.sql.DataSource; import org.apache.ibatis.jdbc.ScriptRunner; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import pro.taskana.configuration.DbScriptRunner; +import pro.taskana.configuration.DbSchemaCreator; /** * This class cleans the complete database. Only to be used in Unittest */ public class DBCleaner { - private static final Logger LOGGER = LoggerFactory.getLogger(DbScriptRunner.class); + private static final Logger LOGGER = LoggerFactory.getLogger(DbSchemaCreator.class); private static final String DB_CLEAR_SCRIPT = "/sql/clear-db.sql"; private static final String DB_DROP_TABLES_SCRIPT = "/sql/drop-tables.sql"; diff --git a/lib/taskana-core/src/test/resources/sql/classification.sql b/lib/taskana-core/src/test/resources/sql/classification.sql new file mode 100644 index 000000000..4188c2831 --- /dev/null +++ b/lib/taskana-core/src/test/resources/sql/classification.sql @@ -0,0 +1,30 @@ +-- ROOT CLASSIFICATIONS +INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000001', 'L10000', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'OLD-Leistungsfall', 'OLD-Leistungsfall', 999, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '', '2016-12-12', '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000002', 'L10303', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Beratungsprotokoll', 'Beratungsprotokoll', 1, 'P1D', '', 'VNR,RVNR,KOLVNR, ANR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000003', 'L1050', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Widerruf', 'Widerruf', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000004', 'L11010', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Dynamikänderung', 'Dynamikänderung', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000005', 'L110102', 'L11010', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Dynamik-Ablehnung', 'Dynamik-Ablehnung', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000006', 'L110105', 'L11010', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Dynamik-Ausschluss', 'Dynamik-Ausschluss', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000007', 'L110107', 'L11010', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Dynamik-Einschluss/Änd.', 'Dynamik-Einschluss/Änd.', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000008', 'L12010', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Gewährung-Policendarlehen', 'Gewährung-Policendarlehen', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000009', 'L140101', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Zustimmungserklärung', 'Zustimmungserklärung', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000010', 'T2100', '', 'MANUAL', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'T-Vertragstermin VERA', 'T-Vertragstermin VERA', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000011', 'T6310', '', 'AUTOMATIC', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'T-GUK Honorarrechnung erstellen', 'Generali Unterstützungskasse Honorar wird fällig', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000013', 'DOKTYP_DEFAULT', '', 'EXTERN', 'DOCUMENT', '', TRUE, CURRENT_TIMESTAMP, 'EP allgemein', 'EP allgemein', 99, 'P2000D', '', 'VNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); + +-- DOMAIN_A CLASSIFICATIONS +INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000001', 'L10000', '', 'EXTERN', 'TASK', 'DOMAIN_A', TRUE, CURRENT_TIMESTAMP, 'OLD-Leistungsfall', 'OLD-Leistungsfall', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '', '2016-12-12', '2017-12-11'); +INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000002', 'L10303', '', 'EXTERN', 'TASK', 'DOMAIN_A', TRUE, CURRENT_TIMESTAMP, 'Beratungsprotokoll', 'Beratungsprotokoll', 1, 'P1D', '', 'VNR,RVNR,KOLVNR, ANR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000003', 'L1050', '', 'EXTERN', 'TASK', 'DOMAIN_A', TRUE, CURRENT_TIMESTAMP, 'Widerruf', 'Widerruf', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000004', 'L11010', '', 'EXTERN', 'TASK', 'DOMAIN_A', TRUE, CURRENT_TIMESTAMP, 'Dynamikänderung', 'Dynamikänderung', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000005', 'L110102', 'L11010', 'EXTERN', 'TASK', 'DOMAIN_A', TRUE, CURRENT_TIMESTAMP, 'Dynamik-Ablehnung', 'Dynamik-Ablehnung', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000006', 'L110105', 'L11010', 'EXTERN', 'TASK', 'DOMAIN_A', TRUE, CURRENT_TIMESTAMP, 'Dynamik-Ausschluss', 'Dynamik-Ausschluss', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000007', 'L110107', 'L11010', 'EXTERN', 'TASK', 'DOMAIN_A', TRUE, CURRENT_TIMESTAMP, 'Dynamik-Einschluss/Änd.', 'Dynamik-Einschluss/Änd.', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000008', 'L12010', '', 'EXTERN', 'TASK', 'DOMAIN_A', TRUE, CURRENT_TIMESTAMP, 'Gewährung-Policendarlehen', 'Gewährung-Policendarlehen', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000009', 'L140101', '', 'EXTERN', 'TASK', 'DOMAIN_A', TRUE, CURRENT_TIMESTAMP, 'Zustimmungserklärung', 'Zustimmungserklärung', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000010', 'T2100', '', 'MANUAL', 'TASK', 'DOMAIN_A', TRUE, CURRENT_TIMESTAMP, 'T-Vertragstermin VERA', 'T-Vertragstermin VERA', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000011', 'T6310', '', 'AUTOMATIC', 'TASK', 'DOMAIN_A', TRUE, CURRENT_TIMESTAMP, 'T-GUK Honorarrechnung erstellen', 'Generali Unterstützungskasse Honorar wird fällig', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000013', 'DOKTYP_DEFAULT', '', 'EXTERN', 'DOCUMENT', 'DOMAIN_A', TRUE, CURRENT_TIMESTAMP, 'EP allgemein', 'EP allgemein', 99, 'P2000D', '', 'VNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000014', 'L10000', '', 'EXTERN', 'TASK', 'DOMAIN_A', TRUE, CURRENT_TIMESTAMP, 'BUZ-Leistungsfall', 'BUZ-Leistungsfall', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '', '2017-12-12', '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000015', 'T2100', '', 'MANUAL', 'TASK', 'DOMAIN_B', TRUE, CURRENT_TIMESTAMP, 'T-Vertragstermin VERA', 'T-Vertragstermin VERA', 22, 'P2D', '', 'VNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); +INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000016', 'T2000', '', 'MANUAL', 'TASK', 'DOMAIN_A', TRUE, CURRENT_TIMESTAMP, 'T-Vertragstermin', 'T-Vertragstermin', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '', CURRENT_TIMESTAMP, '9999-12-31'); diff --git a/lib/taskana-core/src/test/resources/sql/distribution-targets.sql b/lib/taskana-core/src/test/resources/sql/distribution-targets.sql new file mode 100644 index 000000000..ca4bd1b88 --- /dev/null +++ b/lib/taskana-core/src/test/resources/sql/distribution-targets.sql @@ -0,0 +1 @@ +INSERT INTO DISTRIBUTION_TARGETS VALUES ('1','2'); diff --git a/lib/taskana-core/src/test/resources/sql/object-reference.sql b/lib/taskana-core/src/test/resources/sql/object-reference.sql new file mode 100644 index 000000000..eb6cdcd8b --- /dev/null +++ b/lib/taskana-core/src/test/resources/sql/object-reference.sql @@ -0,0 +1,3 @@ +INSERT INTO OBJECT_REFERENCE VALUES ('1', 'Company1', 'System1', 'Instance1', 'Type1', 'Value1'); +INSERT INTO OBJECT_REFERENCE VALUES ('2', 'Company2', 'System2', 'Instance2', 'Type2', 'Value2'); +INSERT INTO OBJECT_REFERENCE VALUES ('3', 'Company3', 'System3', 'Instance3', 'Type3', 'Value3'); diff --git a/lib/taskana-core/src/test/resources/sql/task.sql b/lib/taskana-core/src/test/resources/sql/task.sql new file mode 100644 index 000000000..7f934596e --- /dev/null +++ b/lib/taskana-core/src/test/resources/sql/task.sql @@ -0,0 +1,18 @@ +INSERT INTO TASK VALUES('1', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, 'Task1', 'Lorem ipsum dolor sit amet.', 1, 'READY', '1', 'key1', 'BPI1', 'PBPI1', 'Stefan', '1', true, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('2', CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task2', 'Lorem ipsum dolor sit amet. ', 1, 'READY', '2', 'key1', 'BPI2', 'PBPI2', 'Frank', '2', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('3', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task3', 'Lorem ipsum dolor sit amet. ', 1, 'CLAIMED', '3', 'key1', 'BPI3', 'PBPI3', 'Stefan', '3', true, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('4', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task4', 'Lorem ipsum dolor sit amet.', 1, 'CLAIMED', '4', 'key1', 'BPI4', 'PBPI4', 'Frank', '1', false, true, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('5', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task5', 'Lorem ipsum dolor sit amet. ', 1, 'COMPLETED', '15', 'key1', 'BPI5', 'PBPI5', 'Stefan', '2', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('6', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task6', 'Lorem ipsum dolor sit amet.', 1, 'COMPLETED', '16', 'key1', 'BPI6', 'PBPI6', 'Frank', '3', false, false, null, null, null, null, null, null, null, null, null, null, null); + +INSERT INTO TASK VALUES('7', CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task7', 'Lorem ipsum dolor sit amet.', 1, 'READY', '13', 'key2', 'BPI7', 'PBPI7', 'Stefan', '1', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('8', CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task8', 'Lorem ipsum dolor sit amet. ', 1, 'READY', '14', 'key2', 'BPI8', 'PBPI8', 'Frank', '2', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('9', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task9', 'Lorem ipsum dolor sit amet. ', 1, 'CLAIMED', '1', 'key2', 'BPI9', 'PBPI9', 'Stefan', '3', true, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('10', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task10', 'Lorem ipsum dolor sit amet.', 1, 'CLAIMED', '2', 'key2', 'BPI10', 'PBPI10', 'Frank', '1', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('11', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task11', 'Lorem ipsum dolor sit amet. ', 1, 'COMPLETED', '3', 'key2', 'BPI11', 'PBPI11', 'Stefan', '2', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('12', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task12', 'Lorem ipsum dolor sit amet.', 1, 'COMPLETED', '4', 'key2', 'BPI12', 'PBPI12', 'Frank', '3', false, false, null, null, null, null, null, null, null, null, null, null, null); + + +INSERT INTO TASK VALUES('13', CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task12', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Phasellus massa turpis, pellentesque ut libero sit aet, malesuada suscipit dolor. Sed volutpat euismod felis sit amet molestie. Fusce ornare purus dui. ', 1, 'READY', '13', 'key2', 'BPI13', 'PBPI13', 'Frank', '1', false, false, null, null, null, null, null, null, null, null, null, null, null); +INSERT INTO TASK VALUES('14', CURRENT_TIMESTAMP, null, null, CURRENT_TIMESTAMP, null, CURRENT_TIMESTAMP, 'Task6', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis vulputate nibh ut malesuada. Etiam ac dictum tellus, nec cursus nunc. Curabitur velit eros, feugiat volutpat laoreet vitae, cursus eu dui. Nulla ut purus sem. Vivamus aliquet odio vitae erat cursus, vitae mattis urna mollis. Nam quam tellus, auctor id volutpat congue, viverra vitae ante. Duis nisi dolor, elementum et mattis at, maximus id velit. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Duis eu condimentum risus. Praesent libero velit, facilisis sit amet maximus non, scelerisque ullamcorper leo. Ut sit amet iaculis eros. Mauris sagittis nibh lacus, at facilisis magna suscipit at. Aliquam finibus tempor odio id commodo. Vivamus aliquam, justo id porta imperdiet, mi.', 1, 'READY', '14', 'key1', 'BPI14', 'PBPI14', 'Frank', '2', false, false, null, null, null, null, null, null, null, null, null, null, null); + diff --git a/lib/taskana-core/src/test/resources/sql/workbasket-access-list.sql b/lib/taskana-core/src/test/resources/sql/workbasket-access-list.sql new file mode 100644 index 000000000..53056f67f --- /dev/null +++ b/lib/taskana-core/src/test/resources/sql/workbasket-access-list.sql @@ -0,0 +1,33 @@ +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('1', 'key1', 'Elena', true, true, true, true, true, false, false, false, false, false, false, false, false); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('2', 'key2', 'Max', true, true, true, true, true, true, true, true, true, false, false, false, false); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('3', 'key3', 'Simone', true, true, true, true, true, true, true, true, true, true, true, true, true); + +-- KSC authorizations (ID, WB_KEY, ACCESS_ID, READ, OPEN, APPEND, TRANSFER, DISTRIBUTE, C1, .., C8) +-- PPKs +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000001', 'TEAMLEAD_1', 'teamlead_1', true, true, true, true, true, true, true, true, true, true, true, true, true); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000002', 'TEAMLEAD_2', 'teamlead_2', true, true, true, true, true, true, true, true, true, true, true, true, true); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000003', 'USER_1_1', 'user_1_1', true, true, true, true, true, true, true, true, true, true, true, true, true); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000004', 'USER_1_2', 'user_1_2', true, true, true, true, true, true, true, true, true, true, true, true, true); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000005', 'USER_2_1', 'user_2_1', true, true, true, true, true, true, true, true, true, true, true, true, true); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000006', 'USER_2_2', 'user_2_2', true, true, true, true, true, true, true, true, true, true, true, true, true); +-- group internal access +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000007', 'TEAMLEAD_1', 'group_1', true, true, true, true, false, false, false, false, false, false, false, false, false); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000008', 'TEAMLEAD_2', 'group_2', true, true, true, true, false, false, false, false, false, false, false, false, false); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000009', 'USER_1_1', 'group_1', true, true, true, true, false, false, false, false, false, false, false, false, false); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000010', 'USER_1_2', 'group_1', true, true, true, true, false, false, false, false, false, false, false, false, false); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000011', 'USER_2_1', 'group_2', true, true, true, true, false, false, false, false, false, false, false, false, false); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000012', 'USER_2_2', 'group_2', true, true, true, true, false, false, false, false, false, false, false, false, false); +-- teamlead substitution +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000013', 'TEAMLEAD_1', 'teamlead_2', true, true, true, true, false, false, false, false, false, false, false, false, false); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000014', 'TEAMLEAD_2', 'teamlead_1', true, true, true, true, false, false, false, false, false, false, false, false, false); +-- cross team tranfers +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000015', 'USER_1_1', 'group_2', true, false, true, false, false, false, false, false, false, false, false, false, false); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000016', 'USER_1_2', 'group_2', true, false, true, false, false, false, false, false, false, false, false, false, false); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000017', 'USER_2_1', 'group_1', true, false, true, false, false, false, false, false, false, false, false, false, false); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000018', 'USER_2_2', 'group_1', true, false, true, false, false, false, false, false, false, false, false, false, false); +-- Team GPK access +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000019', 'GPK_KSC_1', 'group_1', true, true, true, true, true, true, true, true, true, true, true, true, true); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000020', 'GPK_KSC_2', 'group_2', true, true, true, true, true, true, true, true, true, true, true, true, true); +-- Cross team GPK access +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000021', 'GPK_KSC', 'teamlead_1', true, true, true, true, true, true, true, true, true, true, true, true, true); +INSERT INTO WORKBASKET_ACCESS_LIST VALUES ('WAI:100000000000000000000000000000000022', 'GPK_KSC', 'teamlead_2', true, true, true, true, true, true, true, true, true, true, true, true, true); diff --git a/lib/taskana-core/src/test/resources/sql/workbasket.sql b/lib/taskana-core/src/test/resources/sql/workbasket.sql new file mode 100644 index 000000000..6bc6dba15 --- /dev/null +++ b/lib/taskana-core/src/test/resources/sql/workbasket.sql @@ -0,0 +1,14 @@ +INSERT INTO WORKBASKET VALUES ('1', 'key1', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'Basket1', 'domain1', 'GROUP', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', 'Peter', '', '', '', '', '', '', '', '' ); +INSERT INTO WORKBASKET VALUES ('2', 'key2', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'Basket2', 'domain2', 'CLEARANCE', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', 'Susanne', '', '', '', '', '', '', '', ''); +INSERT INTO WORKBASKET VALUES ('3', 'key3', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'Basket3', 'domain3', 'TOPIC', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit.', 'Max', '', '', '', '', '', '', '', ''); + +-- KSC workbaskets +INSERT INTO WORKBASKET VALUES ('WBI:100000000000000000000000000000000001', 'GPK_KSC', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'Gruppenpostkorb KSC', 'DOMAIN_A', 'GROUP', 'Gruppenpostkorb KSC', '', '', '', '', '', '', '', '', ''); +INSERT INTO WORKBASKET VALUES ('WBI:100000000000000000000000000000000002', 'GPK_KSC_1', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'Gruppenpostkorb KSC 1', 'DOMAIN_A', 'GROUP', 'Gruppenpostkorb KSC 1', '', '', '', '', '', '', '', '', ''); +INSERT INTO WORKBASKET VALUES ('WBI:100000000000000000000000000000000003', 'GPK_KSC_2', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'Gruppenpostkorb KSC 2', 'DOMAIN_A', 'GROUP', 'Gruppenpostkorb KSC 2', '', '', '', '', '', '', '', '', ''); +INSERT INTO WORKBASKET VALUES ('WBI:100000000000000000000000000000000004', 'TEAMLEAD_1', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'PPK Teamlead KSC 1', 'DOMAIN_A', 'PERSONAL', 'PPK Teamlead KSC 1', '', '', '', '', '', '', '', '', ''); +INSERT INTO WORKBASKET VALUES ('WBI:100000000000000000000000000000000005', 'TEAMLEAD_2', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'PPK Teamlead KSC 2', 'DOMAIN_A', 'PERSONAL', 'PPK Teamlead KSC 2', '', '', '', '', '', '', '', '', ''); +INSERT INTO WORKBASKET VALUES ('WBI:100000000000000000000000000000000006', 'USER_1_1', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'PPK User 1 KSC 1', 'DOMAIN_A', 'PERSONAL', 'PPK User 1 KSC 1', '', '', '', '', '', '', '', '', ''); +INSERT INTO WORKBASKET VALUES ('WBI:100000000000000000000000000000000007', 'USER_1_2', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'PPK User 2 KSC 1', 'DOMAIN_A', 'PERSONAL', 'PPK User 2 KSC 1', '', '', '', '', '', '', '', '', ''); +INSERT INTO WORKBASKET VALUES ('WBI:100000000000000000000000000000000008', 'USER_2_1', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'PPK User 1 KSC 2', 'DOMAIN_A', 'PERSONAL', 'PPK User 1 KSC 2', '', '', '', '', '', '', '', '', ''); +INSERT INTO WORKBASKET VALUES ('WBI:100000000000000000000000000000000009', 'USER_2_2', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, 'PPK User 2 KSC 2', 'DOMAIN_A', 'PERSONAL', 'PPK User 2 KSC 2', '', '', '', '', '', '', '', '', ''); diff --git a/lib/taskana-spring/src/main/java/pro/taskana/configuration/SpringTaskanaEngineConfiguration.java b/lib/taskana-spring/src/main/java/pro/taskana/configuration/SpringTaskanaEngineConfiguration.java index aa49a2ae5..2518ef153 100644 --- a/lib/taskana-spring/src/main/java/pro/taskana/configuration/SpringTaskanaEngineConfiguration.java +++ b/lib/taskana-spring/src/main/java/pro/taskana/configuration/SpringTaskanaEngineConfiguration.java @@ -25,7 +25,7 @@ public class SpringTaskanaEngineConfiguration extends TaskanaEngineConfiguration public TaskanaEngine buildTaskanaEngine() { this.useManagedTransactions = true; - dbScriptRunner = new DbScriptRunner(this.dataSource); + dbScriptRunner = new DbSchemaCreator(this.dataSource); try { dbScriptRunner.run(); } catch (SQLException e) {