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

TSK-1042 use try-with-resources for connections

This commit is contained in:
BerndBreier 2020-01-21 15:26:43 +01:00 committed by Mustapha Zorgati
parent bc18f69777
commit 6c8fb69f60
9 changed files with 418 additions and 409 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -38,19 +38,17 @@ public class DbSchemaCreator {
* @throws SQLException will be thrown if there will be some incorrect SQL statements invoked. * @throws SQLException will be thrown if there will be some incorrect SQL statements invoked.
*/ */
public void run() throws SQLException { public void run() throws SQLException {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
connection.setSchema(schemaName); connection.setSchema(schemaName);
ScriptRunner runner = new ScriptRunner(connection); ScriptRunner runner = new ScriptRunner(connection);
runner.setStopOnError(true); runner.setStopOnError(true);
runner.setLogWriter(logWriter); runner.setLogWriter(logWriter);
runner.setErrorLogWriter(errorLogWriter); runner.setErrorLogWriter(errorLogWriter);
try {
InputStream resourceAsStream = this.getClass().getResourceAsStream(DB_SCHEMA); InputStream resourceAsStream = this.getClass().getResourceAsStream(DB_SCHEMA);
BufferedReader reader = BufferedReader reader =
new BufferedReader(new InputStreamReader(resourceAsStream, StandardCharsets.UTF_8)); new BufferedReader(new InputStreamReader(resourceAsStream, StandardCharsets.UTF_8));
runner.runScript(getSqlWithSchemaNameParsed(reader)); runner.runScript(getSqlWithSchemaNameParsed(reader));
} finally {
runner.closeConnection();
} }
LOGGER.debug(outWriter.toString()); LOGGER.debug(outWriter.toString());
if (!errorWriter.toString().trim().isEmpty()) { if (!errorWriter.toString().trim().isEmpty()) {

17
history/taskana-simplehistory-provider/src/test/java/configuration/DbWriter.java
View File

@ -29,13 +29,10 @@ public class DbWriter {
public void generateTestData(DataSource dataSource) throws SQLException { public void generateTestData(DataSource dataSource) throws SQLException {
ScriptRunner runner = null; ScriptRunner runner = null;
try { try (Connection connection = dataSource.getConnection()) {
runner = configScriptRunner(dataSource); runner = configScriptRunner(connection);
runner.runScript(new InputStreamReader(this.getClass().getResourceAsStream(INSERTVALUES))); runner.runScript(new InputStreamReader(this.getClass().getResourceAsStream(INSERTVALUES)));
} finally { } finally {
if (runner != null) {
runner.closeConnection();
}
LOGGER.debug(outWriter.toString()); LOGGER.debug(outWriter.toString());
if (!errorWriter.toString().trim().isEmpty()) { if (!errorWriter.toString().trim().isEmpty()) {
LOGGER.error(errorWriter.toString()); LOGGER.error(errorWriter.toString());
@ -45,13 +42,10 @@ public class DbWriter {
public void clearDB(DataSource dataSource) throws SQLException { public void clearDB(DataSource dataSource) throws SQLException {
ScriptRunner runner = null; ScriptRunner runner = null;
try { try (Connection connection = dataSource.getConnection()) {
runner = configScriptRunner(dataSource); runner = configScriptRunner(connection);
runner.runScript(new StringReader("DELETE FROM HISTORY_EVENTS;")); runner.runScript(new StringReader("DELETE FROM HISTORY_EVENTS;"));
} finally { } finally {
if (runner != null) {
runner.closeConnection();
}
LOGGER.debug(outWriter.toString()); LOGGER.debug(outWriter.toString());
if (!errorWriter.toString().trim().isEmpty()) { if (!errorWriter.toString().trim().isEmpty()) {
LOGGER.error(errorWriter.toString()); LOGGER.error(errorWriter.toString());
@ -59,8 +53,7 @@ public class DbWriter {
} }
} }
private ScriptRunner configScriptRunner(DataSource dataSource) throws SQLException { private ScriptRunner configScriptRunner(Connection connection) throws SQLException {
Connection connection = dataSource.getConnection();
LOGGER.debug(connection.getMetaData().toString()); LOGGER.debug(connection.getMetaData().toString());
ScriptRunner runner = new ScriptRunner(connection); ScriptRunner runner = new ScriptRunner(connection);
runner.setStopOnError(true); runner.setStopOnError(true);

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

@ -24,7 +24,6 @@ public class SampleDataGenerator {
private static final String HISTORY_EVENT = TEST_DATA + "/history-event.sql"; private static final String HISTORY_EVENT = TEST_DATA + "/history-event.sql";
DataSource dataSource; DataSource dataSource;
String dbProductName; String dbProductName;
private ScriptRunner runner;
public SampleDataGenerator(DataSource dataSource) throws SQLException { public SampleDataGenerator(DataSource dataSource) throws SQLException {
try (Connection connection = dataSource.getConnection()) { try (Connection connection = dataSource.getConnection()) {
@ -35,8 +34,6 @@ public class SampleDataGenerator {
} }
} }
this.dataSource = dataSource; this.dataSource = dataSource;
runner = new ScriptRunner(dataSource.getConnection());
} }
public void generateSampleData(String schemaName) { public void generateSampleData(String schemaName) {
@ -45,28 +42,28 @@ public class SampleDataGenerator {
final StringWriter errorWriter = new StringWriter(); final StringWriter errorWriter = new StringWriter();
final PrintWriter errorLogWriter = new PrintWriter(errorWriter); final PrintWriter errorLogWriter = new PrintWriter(errorWriter);
try { try (Connection connection = dataSource.getConnection()) {
ScriptRunner runner = new ScriptRunner(connection);
runner.runScript(selectSchemaScript(dbProductName, schemaName)); runner.runScript(selectSchemaScript(dbProductName, schemaName));
runner.setStopOnError(false); runner.setStopOnError(false);
runner.runScript( runner.runScript(
new BufferedReader( new BufferedReader(
new InputStreamReader( new InputStreamReader(
this.getClass().getResourceAsStream(CLEAR), StandardCharsets.UTF_8))); this.getClass().getResourceAsStream(CLEAR), StandardCharsets.UTF_8)));
runner.setStopOnError(true);
runner.setLogWriter(logWriter);
runner.setErrorLogWriter(errorLogWriter);
runner.runScript(
new BufferedReader(
new InputStreamReader(
this.getClass().getResourceAsStream(HISTORY_EVENT), StandardCharsets.UTF_8)));
} catch (Exception e) { } catch (Exception e) {
LOGGER.error("caught Exception {}", e, e); LOGGER.error("caught Exception {}", e, e);
} }
runner.setStopOnError(true);
runner.setLogWriter(logWriter);
runner.setErrorLogWriter(errorLogWriter);
runner.runScript(
new BufferedReader(
new InputStreamReader(
this.getClass().getResourceAsStream(HISTORY_EVENT), StandardCharsets.UTF_8)));
runner.closeConnection();
LOGGER.trace(outWriter.toString()); LOGGER.trace(outWriter.toString());
if (!errorWriter.toString().trim().isEmpty()) { if (!errorWriter.toString().trim().isEmpty()) {
LOGGER.error(errorWriter.toString()); LOGGER.error(errorWriter.toString());

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

@ -47,13 +47,13 @@ public class DbSchemaCreator {
* @throws SQLException will be thrown if there will be some incorrect SQL statements invoked. * @throws SQLException will be thrown if there will be some incorrect SQL statements invoked.
*/ */
public void run() throws SQLException { public void run() throws SQLException {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
LOGGER.debug( LOGGER.debug(
"Using database of type {} with url '{}'", "Using database of type {} with url '{}'",
connection.getMetaData().getDatabaseProductName(), connection.getMetaData().getDatabaseProductName(),
connection.getMetaData().getURL()); connection.getMetaData().getURL());
ScriptRunner runner = getScriptRunnerInstance(connection); ScriptRunner runner = getScriptRunnerInstance(connection);
try {
if (!isSchemaPreexisting(connection)) { if (!isSchemaPreexisting(connection)) {
String scriptPath = String scriptPath =
selectDbScriptFileName(connection.getMetaData().getDatabaseProductName()); selectDbScriptFileName(connection.getMetaData().getDatabaseProductName());
@ -62,8 +62,6 @@ public class DbSchemaCreator {
new BufferedReader(new InputStreamReader(resourceAsStream, StandardCharsets.UTF_8)); new BufferedReader(new InputStreamReader(resourceAsStream, StandardCharsets.UTF_8));
runner.runScript(getSqlSchemaNameParsed(reader)); runner.runScript(getSqlSchemaNameParsed(reader));
} }
} finally {
runner.closeConnection();
} }
LOGGER.debug(outWriter.toString()); LOGGER.debug(outWriter.toString());
if (!errorWriter.toString().trim().isEmpty()) { if (!errorWriter.toString().trim().isEmpty()) {
@ -73,8 +71,7 @@ public class DbSchemaCreator {
public boolean isValidSchemaVersion(String expectedVersion) { public boolean isValidSchemaVersion(String expectedVersion) {
SqlRunner runner = null; SqlRunner runner = null;
try { try (Connection connection = dataSource.getConnection()) {
Connection connection = dataSource.getConnection();
connection.setSchema(this.schemaName); connection.setSchema(this.schemaName);
runner = new SqlRunner(connection); runner = new SqlRunner(connection);
LOGGER.debug(connection.getMetaData().toString()); LOGGER.debug(connection.getMetaData().toString());
@ -102,10 +99,6 @@ public class DbSchemaCreator {
+ "has not the expected value {}", + "has not the expected value {}",
expectedVersion); expectedVersion);
return false; return false;
} finally {
if (runner != null) {
runner.closeConnection();
}
} }
} }

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

@ -87,63 +87,66 @@ public class ClassificationServiceImplIntExplicitTest {
public void testInsertClassification() public void testInsertClassification()
throws SQLException, ClassificationNotFoundException, ClassificationAlreadyExistException, throws SQLException, ClassificationNotFoundException, ClassificationAlreadyExistException,
NotAuthorizedException, DomainNotFoundException, InvalidArgumentException { NotAuthorizedException, DomainNotFoundException, InvalidArgumentException {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection); taskanaEngineImpl.setConnection(connection);
final String domain = "DOMAIN_A"; final String domain = "DOMAIN_A";
final String key = "dummy-key"; final String key = "dummy-key";
ClassificationImpl expectedClassification; ClassificationImpl expectedClassification;
// new classification but master existing // new classification but master existing
expectedClassification = expectedClassification =
(ClassificationImpl) this.createNewClassificationWithUniqueKey("", "TASK"); (ClassificationImpl) this.createNewClassificationWithUniqueKey("", "TASK");
expectedClassification.setKey(key); expectedClassification.setKey(key);
expectedClassification.setDomain("DOMAIN_B"); expectedClassification.setDomain("DOMAIN_B");
classificationService.createClassification(expectedClassification); classificationService.createClassification(expectedClassification);
connection.commit(); connection.commit();
Classification actualClassification = classificationService.getClassification(key, "DOMAIN_B"); Classification actualClassification =
assertThat(actualClassification, not(IsEqual.equalTo(null))); classificationService.getClassification(key, "DOMAIN_B");
assertThat(actualClassification.getCreated(), not(IsEqual.equalTo(null))); assertThat(actualClassification, not(IsEqual.equalTo(null)));
assertThat(actualClassification.getId(), not(IsEqual.equalTo(null))); assertThat(actualClassification.getCreated(), not(IsEqual.equalTo(null)));
assertThat(actualClassification.getKey(), IsEqual.equalTo(key)); assertThat(actualClassification.getId(), not(IsEqual.equalTo(null)));
assertThat(actualClassification.getDomain(), IsEqual.equalTo("DOMAIN_B")); assertThat(actualClassification.getKey(), IsEqual.equalTo(key));
assertThat(actualClassification.getId(), startsWith(ID_PREFIX_CLASSIFICATION)); assertThat(actualClassification.getDomain(), IsEqual.equalTo("DOMAIN_B"));
Classification masterResult = classificationService.getClassification(key, ""); assertThat(actualClassification.getId(), startsWith(ID_PREFIX_CLASSIFICATION));
assertThat(masterResult, not(IsEqual.equalTo(null))); Classification masterResult = classificationService.getClassification(key, "");
assertThat(masterResult, not(IsEqual.equalTo(null)));
// invalid serviceLevel // invalid serviceLevel
ClassificationImpl expectedClassificationCreated = ClassificationImpl expectedClassificationCreated =
(ClassificationImpl) this.createNewClassificationWithUniqueKey("", "TASK"); (ClassificationImpl) this.createNewClassificationWithUniqueKey("", "TASK");
expectedClassificationCreated.setDomain(domain); expectedClassificationCreated.setDomain(domain);
expectedClassificationCreated.setKey(""); expectedClassificationCreated.setKey("");
expectedClassificationCreated.setServiceLevel("ASAP"); expectedClassificationCreated.setServiceLevel("ASAP");
Assertions.assertThrows( Assertions.assertThrows(
InvalidArgumentException.class, InvalidArgumentException.class,
() -> { () -> {
classificationService.createClassification(expectedClassificationCreated); classificationService.createClassification(expectedClassificationCreated);
}, },
"Should have thrown IllegalArgumentException, because ServiceLevel is invalid."); "Should have thrown IllegalArgumentException, because ServiceLevel is invalid.");
connection.commit(); connection.commit();
}
} }
@Test @Test
public void testFindAllClassifications() public void testFindAllClassifications()
throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException, throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException,
DomainNotFoundException, InvalidArgumentException { DomainNotFoundException, InvalidArgumentException {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection); taskanaEngineImpl.setConnection(connection);
Classification classification0 = this.createNewClassificationWithUniqueKey("", "TASK"); Classification classification0 = this.createNewClassificationWithUniqueKey("", "TASK");
classificationService.createClassification(classification0); classificationService.createClassification(classification0);
Classification classification1 = this.createNewClassificationWithUniqueKey("", "TASK"); Classification classification1 = this.createNewClassificationWithUniqueKey("", "TASK");
classificationService.createClassification(classification1); classificationService.createClassification(classification1);
Classification classification2 = this.createNewClassificationWithUniqueKey("", "TASK"); Classification classification2 = this.createNewClassificationWithUniqueKey("", "TASK");
classification2.setParentId(classification0.getId()); classification2.setParentId(classification0.getId());
classificationService.createClassification(classification2); classificationService.createClassification(classification2);
assertEquals(2 + 1, classificationService.createClassificationQuery().list().size()); assertEquals(2 + 1, classificationService.createClassificationQuery().list().size());
connection.commit(); connection.commit();
}
} }
@Test @Test
@ -152,38 +155,40 @@ public class ClassificationServiceImplIntExplicitTest {
NotAuthorizedException, ConcurrencyException, DomainNotFoundException, NotAuthorizedException, ConcurrencyException, DomainNotFoundException,
InvalidArgumentException { InvalidArgumentException {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection); taskanaEngineImpl.setConnection(connection);
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK"); Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
connection.commit(); connection.commit();
classification = classificationService.createClassification(classification); classification = classificationService.createClassification(classification);
String updatedDescription = "TEST SOMETHING"; String updatedDescription = "TEST SOMETHING";
classification.setDescription(updatedDescription); classification.setDescription(updatedDescription);
classification = classificationService.updateClassification(classification); classification = classificationService.updateClassification(classification);
connection.commit(); connection.commit();
classification = classification =
classificationService.getClassification( classificationService.getClassification(
classification.getKey(), classification.getDomain()); classification.getKey(), classification.getDomain());
assertThat(classification.getDescription(), IsEqual.equalTo(updatedDescription)); assertThat(classification.getDescription(), IsEqual.equalTo(updatedDescription));
}
} }
@Test @Test
public void testInsertAndClassificationQuery() public void testInsertAndClassificationQuery()
throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException, throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException,
DomainNotFoundException, InvalidArgumentException { DomainNotFoundException, InvalidArgumentException {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection); taskanaEngineImpl.setConnection(connection);
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK"); Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
classificationService.createClassification(classification); classificationService.createClassification(classification);
List<ClassificationSummary> list = List<ClassificationSummary> list =
classificationService classificationService
.createClassificationQuery() .createClassificationQuery()
.validInDomainEquals(Boolean.TRUE) .validInDomainEquals(Boolean.TRUE)
.createdWithin(today()) .createdWithin(today())
.list(); .list();
assertEquals(1, list.size()); assertEquals(1, list.size());
}
} }
@Test @Test
@ -191,31 +196,32 @@ public class ClassificationServiceImplIntExplicitTest {
throws NotAuthorizedException, SQLException, ClassificationAlreadyExistException, throws NotAuthorizedException, SQLException, ClassificationAlreadyExistException,
ClassificationNotFoundException, ConcurrencyException, DomainNotFoundException, ClassificationNotFoundException, ConcurrencyException, DomainNotFoundException,
InvalidArgumentException { InvalidArgumentException {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection); taskanaEngineImpl.setConnection(connection);
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK"); Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification.setDescription(""); classification.setDescription("");
classification = classificationService.createClassification(classification); classification = classificationService.createClassification(classification);
classification.setDescription("description"); classification.setDescription("description");
classification = classificationService.updateClassification(classification); classification = classificationService.updateClassification(classification);
List<ClassificationSummary> list = classificationService.createClassificationQuery().list(); List<ClassificationSummary> list = classificationService.createClassificationQuery().list();
assertEquals(2, list.size()); assertEquals(2, list.size());
list = classificationService.createClassificationQuery().validInDomainEquals(true).list(); list = classificationService.createClassificationQuery().validInDomainEquals(true).list();
assertEquals(1, list.size()); assertEquals(1, list.size());
classification = classification =
classificationService.getClassification( classificationService.getClassification(
classification.getKey(), classification.getDomain()); classification.getKey(), classification.getDomain());
assertThat(classification.getDescription(), IsEqual.equalTo("description")); assertThat(classification.getDescription(), IsEqual.equalTo("description"));
classification = classificationService.updateClassification(classification); classification = classificationService.updateClassification(classification);
list = classificationService.createClassificationQuery().list(); list = classificationService.createClassificationQuery().list();
assertEquals(2, list.size()); assertEquals(2, list.size());
List<ClassificationSummary> allClassifications = List<ClassificationSummary> allClassifications =
classificationService.createClassificationQuery().list(); classificationService.createClassificationQuery().list();
assertEquals(2, allClassifications.size()); assertEquals(2, allClassifications.size());
connection.commit(); connection.commit();
}
} }
@Test @Test
@ -223,42 +229,48 @@ public class ClassificationServiceImplIntExplicitTest {
throws NotAuthorizedException, SQLException, ClassificationAlreadyExistException, throws NotAuthorizedException, SQLException, ClassificationAlreadyExistException,
ClassificationNotFoundException, InvalidArgumentException, ConcurrencyException, ClassificationNotFoundException, InvalidArgumentException, ConcurrencyException,
DomainNotFoundException { DomainNotFoundException {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection); taskanaEngineImpl.setConnection(connection);
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK"); Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification = classificationService.createClassification(classification); classification = classificationService.createClassification(classification);
Classification classification1 = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK"); Classification classification1 =
classification1 = classificationService.createClassification(classification1); this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification1.setParentId(classification.getId()); classification1 = classificationService.createClassification(classification1);
classification1 = classificationService.updateClassification(classification1); classification1.setParentId(classification.getId());
classification1 = classificationService.updateClassification(classification1);
List<ClassificationSummary> list = List<ClassificationSummary> list =
classificationService.createClassificationQuery().parentIdIn("").list(); classificationService.createClassificationQuery().parentIdIn("").list();
assertEquals(3, list.size()); assertEquals(3, list.size());
list = classificationService.createClassificationQuery().list(); list = classificationService.createClassificationQuery().list();
assertEquals(4, list.size()); assertEquals(4, list.size());
connection.commit(); connection.commit();
list = classificationService.createClassificationQuery().validInDomainEquals(true).list(); list = classificationService.createClassificationQuery().validInDomainEquals(true).list();
assertEquals(2, list.size()); assertEquals(2, list.size());
list = classificationService.createClassificationQuery().createdWithin(today()).list(); list = classificationService.createClassificationQuery().createdWithin(today()).list();
assertEquals(4, list.size()); assertEquals(4, list.size());
list = list =
classificationService classificationService
.createClassificationQuery() .createClassificationQuery()
.domainIn("DOMAIN_C") .domainIn("DOMAIN_C")
.validInDomainEquals(false) .validInDomainEquals(false)
.list(); .list();
assertEquals(0, list.size()); assertEquals(0, list.size());
list = classificationService.createClassificationQuery().keyIn(classification1.getKey()).list(); list =
assertEquals(2, list.size()); classificationService.createClassificationQuery().keyIn(classification1.getKey()).list();
assertEquals(2, list.size());
list = list =
classificationService.createClassificationQuery().parentIdIn(classification.getId()).list(); classificationService
assertEquals(1, list.size()); .createClassificationQuery()
assertThat(list.get(0).getKey(), IsEqual.equalTo(classification1.getKey())); .parentIdIn(classification.getId())
connection.commit(); .list();
assertEquals(1, list.size());
assertThat(list.get(0).getKey(), IsEqual.equalTo(classification1.getKey()));
connection.commit();
}
} }
private Classification createNewClassificationWithUniqueKey(String domain, String type) { private Classification createNewClassificationWithUniqueKey(String domain, String type) {

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

@ -122,39 +122,41 @@ class TaskServiceImplIntExplicitTest {
ClassificationAlreadyExistException, TaskAlreadyExistException, ClassificationAlreadyExistException, TaskAlreadyExistException,
InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException,
DomainNotFoundException { DomainNotFoundException {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection); taskanaEngineImpl.setConnection(connection);
WorkbasketImpl workbasket = (WorkbasketImpl) workbasketService.newWorkbasket("k1", "DOMAIN_A"); WorkbasketImpl workbasket =
workbasket.setName("workbasket"); (WorkbasketImpl) workbasketService.newWorkbasket("k1", "DOMAIN_A");
workbasket.setId("1"); // set id manually for authorization tests workbasket.setName("workbasket");
workbasket.setId("1"); // set id manually for authorization tests
workbasket.setType(WorkbasketType.GROUP); workbasket.setType(WorkbasketType.GROUP);
final Classification classification = final Classification classification =
classificationService.newClassification("TEST", "DOMAIN_A", "TASK"); classificationService.newClassification("TEST", "DOMAIN_A", "TASK");
taskanaEngineImpl.getWorkbasketService().createWorkbasket(workbasket); taskanaEngineImpl.getWorkbasketService().createWorkbasket(workbasket);
WorkbasketAccessItem accessItem = workbasketService.newWorkbasketAccessItem("1", "Elena"); WorkbasketAccessItem accessItem = workbasketService.newWorkbasketAccessItem("1", "Elena");
accessItem.setPermAppend(true); accessItem.setPermAppend(true);
accessItem.setPermRead(true); accessItem.setPermRead(true);
accessItem.setPermOpen(true); accessItem.setPermOpen(true);
workbasketService.createWorkbasketAccessItem(accessItem); workbasketService.createWorkbasketAccessItem(accessItem);
taskanaEngineImpl.getClassificationService().createClassification(classification); taskanaEngineImpl.getClassificationService().createClassification(classification);
connection.commit(); connection.commit();
Task task = taskServiceImpl.newTask(workbasket.getId()); Task task = taskServiceImpl.newTask(workbasket.getId());
task.setName("Unit Test Task"); task.setName("Unit Test Task");
task.setClassificationKey(classification.getKey()); task.setClassificationKey(classification.getKey());
task.setPrimaryObjRef(JunitHelper.createDefaultObjRef()); task.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
task = taskServiceImpl.createTask(task); task = taskServiceImpl.createTask(task);
connection.commit(); connection.commit();
taskServiceImpl.getTask(task.getId()); taskServiceImpl.getTask(task.getId());
TaskanaEngineImpl te2 = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine(); TaskanaEngineImpl te2 = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine();
TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService(); TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService();
Assertions.assertThrows( Assertions.assertThrows(
TaskNotFoundException.class, () -> taskServiceImpl2.getTask(workbasket.getId())); TaskNotFoundException.class, () -> taskServiceImpl2.getTask(workbasket.getId()));
connection.commit(); connection.commit();
}
} }
@WithAccessId( @WithAccessId(
@ -167,27 +169,28 @@ class TaskServiceImplIntExplicitTest {
ClassificationAlreadyExistException, TaskAlreadyExistException, ClassificationAlreadyExistException, TaskAlreadyExistException,
InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException,
DomainNotFoundException { DomainNotFoundException {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection); taskanaEngineImpl.setConnection(connection);
final Task task = this.generateDummyTask(); final Task task = this.generateDummyTask();
connection.commit(); connection.commit();
WorkbasketAccessItem accessItem = workbasketService.newWorkbasketAccessItem("1", "Elena"); WorkbasketAccessItem accessItem = workbasketService.newWorkbasketAccessItem("1", "Elena");
accessItem.setPermAppend(true); accessItem.setPermAppend(true);
accessItem.setPermRead(true); accessItem.setPermRead(true);
accessItem.setPermOpen(true); accessItem.setPermOpen(true);
workbasketService.createWorkbasketAccessItem(accessItem); workbasketService.createWorkbasketAccessItem(accessItem);
task.setPrimaryObjRef(JunitHelper.createDefaultObjRef()); task.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
final Task task2 = taskServiceImpl.createTask(task); final Task task2 = taskServiceImpl.createTask(task);
connection.commit(); // needed so that the change is visible in the other session connection.commit(); // needed so that the change is visible in the other session
TaskanaEngine te2 = taskanaEngineConfiguration.buildTaskanaEngine(); TaskanaEngine te2 = taskanaEngineConfiguration.buildTaskanaEngine();
TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService(); TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService();
Task resultTask = taskServiceImpl2.getTask(task2.getId()); Task resultTask = taskServiceImpl2.getTask(task2.getId());
assertNotNull(resultTask); assertNotNull(resultTask);
connection.commit(); connection.commit();
}
} }
@WithAccessId( @WithAccessId(
@ -198,13 +201,14 @@ class TaskServiceImplIntExplicitTest {
throws NotAuthorizedException, SQLException, ClassificationAlreadyExistException, throws NotAuthorizedException, SQLException, ClassificationAlreadyExistException,
InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException,
DomainNotFoundException { DomainNotFoundException {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection); taskanaEngineImpl.setConnection(connection);
Task test = this.generateDummyTask(); Task test = this.generateDummyTask();
((WorkbasketSummaryImpl) (test.getWorkbasketSummary())).setId("2"); ((WorkbasketSummaryImpl) (test.getWorkbasketSummary())).setId("2");
Assertions.assertThrows( Assertions.assertThrows(
WorkbasketNotFoundException.class, () -> taskServiceImpl.createTask(test)); WorkbasketNotFoundException.class, () -> taskServiceImpl.createTask(test));
}
} }
@WithAccessId( @WithAccessId(
@ -215,26 +219,28 @@ class TaskServiceImplIntExplicitTest {
throws NotAuthorizedException, WorkbasketNotFoundException, SQLException, throws NotAuthorizedException, WorkbasketNotFoundException, SQLException,
ClassificationAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException, ClassificationAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException,
WorkbasketAlreadyExistException, DomainNotFoundException { WorkbasketAlreadyExistException, DomainNotFoundException {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection); taskanaEngineImpl.setConnection(connection);
Workbasket wb = workbasketService.newWorkbasket("WB NR.1", "DOMAIN_A"); Workbasket wb = workbasketService.newWorkbasket("WB NR.1", "DOMAIN_A");
wb.setName("dummy-WB"); wb.setName("dummy-WB");
wb.setType(WorkbasketType.PERSONAL); wb.setType(WorkbasketType.PERSONAL);
wb = workbasketService.createWorkbasket(wb); wb = workbasketService.createWorkbasket(wb);
this.createWorkbasketWithSecurity(wb, CurrentUserContext.getUserid(), true, true, true, false); this.createWorkbasketWithSecurity(
Classification classification = wb, CurrentUserContext.getUserid(), true, true, true, false);
classificationService.newClassification( Classification classification =
UUID.randomUUID().toString(), wb.getDomain(), "t1"); // not persisted, classificationService.newClassification(
// not found. UUID.randomUUID().toString(), wb.getDomain(), "t1"); // not persisted,
classification.setName("not persisted - so not found."); // not found.
classification.setName("not persisted - so not found.");
Task task = this.generateDummyTask(); Task task = this.generateDummyTask();
((TaskImpl) task).setWorkbasketSummary(wb.asSummary()); ((TaskImpl) task).setWorkbasketSummary(wb.asSummary());
task.setClassificationKey(classification.getKey()); task.setClassificationKey(classification.getKey());
Assertions.assertThrows( Assertions.assertThrows(
ClassificationNotFoundException.class, () -> taskServiceImpl.createTask(task)); ClassificationNotFoundException.class, () -> taskServiceImpl.createTask(task));
}
} }
@WithAccessId( @WithAccessId(
@ -246,49 +252,51 @@ class TaskServiceImplIntExplicitTest {
ClassificationNotFoundException, ClassificationAlreadyExistException, ClassificationNotFoundException, ClassificationAlreadyExistException,
TaskAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException, TaskAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException,
SystemException, WorkbasketAlreadyExistException, DomainNotFoundException { SystemException, WorkbasketAlreadyExistException, DomainNotFoundException {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection); taskanaEngineImpl.setConnection(connection);
WorkbasketImpl workbasket = (WorkbasketImpl) workbasketService.newWorkbasket("k1", "DOMAIN_A"); WorkbasketImpl workbasket =
workbasket.setName("workbasket"); (WorkbasketImpl) workbasketService.newWorkbasket("k1", "DOMAIN_A");
Classification classification = workbasket.setName("workbasket");
classificationService.newClassification("TEST", "DOMAIN_A", "TASK"); Classification classification =
classificationService.createClassification(classification); classificationService.newClassification("TEST", "DOMAIN_A", "TASK");
workbasket.setId("1"); // set id manually for authorization tests classificationService.createClassification(classification);
workbasket.setType(WorkbasketType.GROUP); workbasket.setId("1"); // set id manually for authorization tests
workbasket = (WorkbasketImpl) workbasketService.createWorkbasket(workbasket); workbasket.setType(WorkbasketType.GROUP);
workbasket = (WorkbasketImpl) workbasketService.createWorkbasket(workbasket);
WorkbasketAccessItem accessItem = workbasketService.newWorkbasketAccessItem("1", "Elena"); WorkbasketAccessItem accessItem = workbasketService.newWorkbasketAccessItem("1", "Elena");
accessItem.setPermAppend(true); accessItem.setPermAppend(true);
accessItem.setPermRead(true); accessItem.setPermRead(true);
accessItem.setPermOpen(true); accessItem.setPermOpen(true);
workbasketService.createWorkbasketAccessItem(accessItem); workbasketService.createWorkbasketAccessItem(accessItem);
Task task = taskServiceImpl.newTask(workbasket.getId()); Task task = taskServiceImpl.newTask(workbasket.getId());
task.setName("Unit Test Task"); task.setName("Unit Test Task");
task.setClassificationKey(classification.getKey()); task.setClassificationKey(classification.getKey());
task.setPrimaryObjRef(JunitHelper.createDefaultObjRef()); task.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
taskServiceImpl.createTask(task); taskServiceImpl.createTask(task);
List<TaskSummary> results = List<TaskSummary> results =
taskServiceImpl taskServiceImpl
.createTaskQuery() .createTaskQuery()
.nameIn("bla", "test") .nameIn("bla", "test")
.descriptionLike("test") .descriptionLike("test")
.priorityIn(1, 2, 2) .priorityIn(1, 2, 2)
.stateIn(TaskState.CLAIMED) .stateIn(TaskState.CLAIMED)
.workbasketKeyDomainIn(new KeyDomain("k1", "DOMAIN_A")) .workbasketKeyDomainIn(new KeyDomain("k1", "DOMAIN_A"))
.ownerIn("test", "test2", "bla") .ownerIn("test", "test2", "bla")
.customAttributeLike("13", "test") .customAttributeLike("13", "test")
.classificationKeyIn("pId1", "pId2") .classificationKeyIn("pId1", "pId2")
.primaryObjectReferenceCompanyIn("first comp", "sonstwo gmbh") .primaryObjectReferenceCompanyIn("first comp", "sonstwo gmbh")
.primaryObjectReferenceSystemIn("sys") .primaryObjectReferenceSystemIn("sys")
.primaryObjectReferenceTypeIn("type1", "type2") .primaryObjectReferenceTypeIn("type1", "type2")
.primaryObjectReferenceSystemInstanceIn("sysInst1", "sysInst2") .primaryObjectReferenceSystemInstanceIn("sysInst1", "sysInst2")
.primaryObjectReferenceValueIn("val1", "val2", "val3") .primaryObjectReferenceValueIn("val1", "val2", "val3")
.list(); .list();
assertEquals(0, results.size()); assertEquals(0, results.size());
connection.commit(); connection.commit();
}
} }
@WithAccessId( @WithAccessId(
@ -303,69 +311,74 @@ class TaskServiceImplIntExplicitTest {
InvalidStateException { InvalidStateException {
final int sleepTime = 100; final int sleepTime = 100;
final String user = CurrentUserContext.getUserid(); final String user = CurrentUserContext.getUserid();
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection); taskanaEngineImpl.setConnection(connection);
// Source Workbasket // Source Workbasket
WorkbasketImpl wb = (WorkbasketImpl) workbasketService.newWorkbasket("sourceWbKey", "DOMAIN_A"); WorkbasketImpl wb =
wb.setName("Basic-Workbasket"); (WorkbasketImpl) workbasketService.newWorkbasket("sourceWbKey", "DOMAIN_A");
wb.setDescription("Just used as base WB for Task here"); wb.setName("Basic-Workbasket");
wb.setOwner(user); wb.setDescription("Just used as base WB for Task here");
wb.setType(WorkbasketType.PERSONAL); wb.setOwner(user);
Workbasket sourceWB = workbasketService.createWorkbasket(wb); wb.setType(WorkbasketType.PERSONAL);
Workbasket sourceWB = workbasketService.createWorkbasket(wb);
createWorkbasketWithSecurity(wb, wb.getOwner(), false, false, false, false); createWorkbasketWithSecurity(wb, wb.getOwner(), false, false, false, false);
createWorkbasketWithSecurity(sourceWB, sourceWB.getOwner(), true, true, true, true); createWorkbasketWithSecurity(sourceWB, sourceWB.getOwner(), true, true, true, true);
// Destination Workbasket // Destination Workbasket
wb = (WorkbasketImpl) workbasketService.newWorkbasket("wb2Key", "DOMAIN_A"); wb = (WorkbasketImpl) workbasketService.newWorkbasket("wb2Key", "DOMAIN_A");
wb.setName("Desination-WorkBasket"); wb.setName("Desination-WorkBasket");
wb.setDescription("Destination WB where Task should be transfered to"); wb.setDescription("Destination WB where Task should be transfered to");
wb.setOwner(user); wb.setOwner(user);
wb.setType(WorkbasketType.TOPIC); wb.setType(WorkbasketType.TOPIC);
Workbasket destinationWB = workbasketService.createWorkbasket(wb); Workbasket destinationWB = workbasketService.createWorkbasket(wb);
createWorkbasketWithSecurity(destinationWB, destinationWB.getOwner(), false, true, true, true); createWorkbasketWithSecurity(
destinationWB, destinationWB.getOwner(), false, true, true, true);
// Classification required for Task // Classification required for Task
ClassificationImpl classification = ClassificationImpl classification =
(ClassificationImpl) classificationService.newClassification("KEY", "DOMAIN_A", "TASK"); (ClassificationImpl) classificationService.newClassification("KEY", "DOMAIN_A", "TASK");
classification.setCategory("EXTERNAL"); classification.setCategory("EXTERNAL");
classification.setName("Transfert-Task Classification"); classification.setName("Transfert-Task Classification");
classificationService.createClassification(classification); classificationService.createClassification(classification);
// Task which should be transfered // Task which should be transfered
TaskImpl task = (TaskImpl) taskServiceImpl.newTask(sourceWB.getId()); TaskImpl task = (TaskImpl) taskServiceImpl.newTask(sourceWB.getId());
task.setName("Task Name"); task.setName("Task Name");
task.setDescription("Task used for transfer Test"); task.setDescription("Task used for transfer Test");
task.setRead(true); task.setRead(true);
task.setTransferred(false); task.setTransferred(false);
task.setModified(null); task.setModified(null);
task.setClassificationKey("KEY"); task.setClassificationKey("KEY");
task.setOwner(user); task.setOwner(user);
task.setPrimaryObjRef(JunitHelper.createDefaultObjRef()); task.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
task = (TaskImpl) taskServiceImpl.createTask(task); task = (TaskImpl) taskServiceImpl.createTask(task);
Thread.sleep(sleepTime); // Sleep for modification-timestamp Thread.sleep(sleepTime); // Sleep for modification-timestamp
connection.commit(); connection.commit();
Task resultTask = taskServiceImpl.transfer(task.getId(), destinationWB.getId()); Task resultTask = taskServiceImpl.transfer(task.getId(), destinationWB.getId());
connection.commit(); connection.commit();
assertThat(resultTask.isRead(), equalTo(false)); assertThat(resultTask.isRead(), equalTo(false));
assertThat(resultTask.isTransferred(), equalTo(true)); assertThat(resultTask.isTransferred(), equalTo(true));
assertThat(resultTask.getWorkbasketKey(), equalTo(destinationWB.getKey())); assertThat(resultTask.getWorkbasketKey(), equalTo(destinationWB.getKey()));
assertThat(resultTask.getModified(), not(equalTo(null))); assertThat(resultTask.getModified(), not(equalTo(null)));
assertThat(resultTask.getModified(), not(equalTo(task.getModified()))); assertThat(resultTask.getModified(), not(equalTo(task.getModified())));
assertThat(resultTask.getCreated(), not(equalTo(null))); assertThat(resultTask.getCreated(), not(equalTo(null)));
assertThat(resultTask.getCreated(), equalTo(task.getCreated())); assertThat(resultTask.getCreated(), equalTo(task.getCreated()));
}
} }
@Test @Test
void shouldNotTransferAnyTask() throws SQLException { void shouldNotTransferAnyTask() throws SQLException {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection); taskanaEngineImpl.setConnection(connection);
Assertions.assertThrows( Assertions.assertThrows(
TaskNotFoundException.class, () -> taskServiceImpl.transfer(UUID.randomUUID() + "_X", "1")); TaskNotFoundException.class,
() -> taskServiceImpl.transfer(UUID.randomUUID() + "_X", "1"));
}
} }
@WithAccessId( @WithAccessId(

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

@ -80,59 +80,60 @@ class WorkbasketServiceImplIntExplicitTest {
groupNames = {"businessadmin"}) groupNames = {"businessadmin"})
@Test @Test
void testUpdateWorkbasket() throws Exception { void testUpdateWorkbasket() throws Exception {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection); taskanaEngineImpl.setConnection(connection);
workBasketService = taskanaEngine.getWorkbasketService(); workBasketService = taskanaEngine.getWorkbasketService();
String id0 = IdGenerator.generateWithPrefix("TWB"); String id0 = IdGenerator.generateWithPrefix("TWB");
Workbasket workbasket0 = Workbasket workbasket0 =
createTestWorkbasket(id0, "key0", "DOMAIN_A", "Superbasket", WorkbasketType.GROUP); createTestWorkbasket(id0, "key0", "DOMAIN_A", "Superbasket", WorkbasketType.GROUP);
workbasket0 = workBasketService.createWorkbasket(workbasket0); workbasket0 = workBasketService.createWorkbasket(workbasket0);
createWorkbasketWithSecurity(workbasket0, "Elena", true, true, false, false); createWorkbasketWithSecurity(workbasket0, "Elena", true, true, false, false);
String id1 = IdGenerator.generateWithPrefix("TWB"); String id1 = IdGenerator.generateWithPrefix("TWB");
Workbasket workbasket1 = Workbasket workbasket1 =
createTestWorkbasket(id1, "key1", "DOMAIN_A", "Megabasket", WorkbasketType.GROUP); createTestWorkbasket(id1, "key1", "DOMAIN_A", "Megabasket", WorkbasketType.GROUP);
workbasket1 = workBasketService.createWorkbasket(workbasket1); workbasket1 = workBasketService.createWorkbasket(workbasket1);
createWorkbasketWithSecurity(workbasket1, "Elena", true, true, false, false); createWorkbasketWithSecurity(workbasket1, "Elena", true, true, false, false);
String id2 = IdGenerator.generateWithPrefix("TWB"); String id2 = IdGenerator.generateWithPrefix("TWB");
Workbasket workbasket2 = Workbasket workbasket2 =
createTestWorkbasket(id2, "key2", "DOMAIN_A", "Hyperbasket", WorkbasketType.GROUP); createTestWorkbasket(id2, "key2", "DOMAIN_A", "Hyperbasket", WorkbasketType.GROUP);
workbasket2 = workBasketService.createWorkbasket(workbasket2); workbasket2 = workBasketService.createWorkbasket(workbasket2);
createWorkbasketWithSecurity(workbasket2, "Elena", true, true, false, false); createWorkbasketWithSecurity(workbasket2, "Elena", true, true, false, false);
List<String> distTargets = List<String> distTargets =
new ArrayList<>(Arrays.asList(workbasket0.getId(), workbasket1.getId())); new ArrayList<>(Arrays.asList(workbasket0.getId(), workbasket1.getId()));
Thread.sleep(SLEEP_TIME); Thread.sleep(SLEEP_TIME);
workBasketService.setDistributionTargets(workbasket2.getId(), distTargets); workBasketService.setDistributionTargets(workbasket2.getId(), distTargets);
String id3 = IdGenerator.generateWithPrefix("TWB"); String id3 = IdGenerator.generateWithPrefix("TWB");
Workbasket workbasket3 = Workbasket workbasket3 =
createTestWorkbasket( createTestWorkbasket(
id3, "key3", "DOMAIN_A", "hm ... irgend ein basket", WorkbasketType.GROUP); id3, "key3", "DOMAIN_A", "hm ... irgend ein basket", WorkbasketType.GROUP);
workbasket3 = workBasketService.createWorkbasket(workbasket3); workbasket3 = workBasketService.createWorkbasket(workbasket3);
createWorkbasketWithSecurity(workbasket3, "Elena", true, true, false, false); createWorkbasketWithSecurity(workbasket3, "Elena", true, true, false, false);
List<String> newDistTargets = new ArrayList<>(Arrays.asList(workbasket3.getId())); List<String> newDistTargets = new ArrayList<>(Arrays.asList(workbasket3.getId()));
Thread.sleep(SLEEP_TIME); Thread.sleep(SLEEP_TIME);
workBasketService.setDistributionTargets(workbasket2.getId(), newDistTargets); workBasketService.setDistributionTargets(workbasket2.getId(), newDistTargets);
Workbasket foundBasket = workBasketService.getWorkbasket(workbasket2.getId()); Workbasket foundBasket = workBasketService.getWorkbasket(workbasket2.getId());
List<WorkbasketSummary> distributionTargets = List<WorkbasketSummary> distributionTargets =
workBasketService.getDistributionTargets(foundBasket.getId()); workBasketService.getDistributionTargets(foundBasket.getId());
assertEquals(1, distributionTargets.size()); assertEquals(1, distributionTargets.size());
assertEquals(workbasket3.getId(), distributionTargets.get(0).getId()); assertEquals(workbasket3.getId(), distributionTargets.get(0).getId());
assertNotEquals( assertNotEquals(
workBasketService.getWorkbasket(id2).getCreated(), workBasketService.getWorkbasket(id2).getCreated(),
workBasketService.getWorkbasket(id2).getModified()); workBasketService.getWorkbasket(id2).getModified());
assertEquals( assertEquals(
workBasketService.getWorkbasket(id1).getCreated(), workBasketService.getWorkbasket(id1).getCreated(),
workBasketService.getWorkbasket(id1).getModified()); workBasketService.getWorkbasket(id1).getModified());
assertEquals( assertEquals(
workBasketService.getWorkbasket(id3).getCreated(), workBasketService.getWorkbasket(id3).getCreated(),
workBasketService.getWorkbasket(id3).getModified()); workBasketService.getWorkbasket(id3).getModified());
connection.commit(); connection.commit();
}
} }
@WithAccessId( @WithAccessId(
@ -143,20 +144,21 @@ class WorkbasketServiceImplIntExplicitTest {
throws NotAuthorizedException, SQLException, InvalidArgumentException, throws NotAuthorizedException, SQLException, InvalidArgumentException,
WorkbasketNotFoundException, DomainNotFoundException, InvalidWorkbasketException, WorkbasketNotFoundException, DomainNotFoundException, InvalidWorkbasketException,
WorkbasketAlreadyExistException { WorkbasketAlreadyExistException {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection); taskanaEngineImpl.setConnection(connection);
workBasketService = taskanaEngine.getWorkbasketService(); workBasketService = taskanaEngine.getWorkbasketService();
Workbasket wb = Workbasket wb =
createTestWorkbasket("id1", "key1", "DOMAIN_A", "name", WorkbasketType.CLEARANCE); createTestWorkbasket("id1", "key1", "DOMAIN_A", "name", WorkbasketType.CLEARANCE);
workBasketService.createWorkbasket(wb); workBasketService.createWorkbasket(wb);
WorkbasketAccessItem accessItem = WorkbasketAccessItem accessItem =
workBasketService.newWorkbasketAccessItem("id1", "Arthur Dent"); workBasketService.newWorkbasketAccessItem("id1", "Arthur Dent");
accessItem.setPermOpen(true); accessItem.setPermOpen(true);
accessItem.setPermRead(true); accessItem.setPermRead(true);
workBasketService.createWorkbasketAccessItem(accessItem); workBasketService.createWorkbasketAccessItem(accessItem);
assertEquals(1, workBasketService.getWorkbasketAccessItems("id1").size()); assertEquals(1, workBasketService.getWorkbasketAccessItems("id1").size());
connection.commit(); connection.commit();
}
} }
@WithAccessId( @WithAccessId(
@ -167,22 +169,23 @@ class WorkbasketServiceImplIntExplicitTest {
throws NotAuthorizedException, SQLException, InvalidArgumentException, throws NotAuthorizedException, SQLException, InvalidArgumentException,
WorkbasketNotFoundException, DomainNotFoundException, InvalidWorkbasketException, WorkbasketNotFoundException, DomainNotFoundException, InvalidWorkbasketException,
WorkbasketAlreadyExistException { WorkbasketAlreadyExistException {
Connection connection = dataSource.getConnection(); try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection); taskanaEngineImpl.setConnection(connection);
workBasketService = taskanaEngine.getWorkbasketService(); workBasketService = taskanaEngine.getWorkbasketService();
Workbasket wb = Workbasket wb =
createTestWorkbasket("key2", "kkey2", "DOMAIN_A", "name", WorkbasketType.CLEARANCE); createTestWorkbasket("key2", "kkey2", "DOMAIN_A", "name", WorkbasketType.CLEARANCE);
workBasketService.createWorkbasket(wb); workBasketService.createWorkbasket(wb);
WorkbasketAccessItem accessItem = WorkbasketAccessItem accessItem =
workBasketService.newWorkbasketAccessItem("key2", "Zaphod Beeblebrox"); workBasketService.newWorkbasketAccessItem("key2", "Zaphod Beeblebrox");
accessItem.setPermOpen(true); accessItem.setPermOpen(true);
accessItem.setPermRead(true); accessItem.setPermRead(true);
workBasketService.createWorkbasketAccessItem(accessItem); workBasketService.createWorkbasketAccessItem(accessItem);
assertEquals(1, workBasketService.getWorkbasketAccessItems("key2").size()); assertEquals(1, workBasketService.getWorkbasketAccessItems("key2").size());
assertEquals("zaphod beeblebrox", accessItem.getAccessId()); assertEquals("zaphod beeblebrox", accessItem.getAccessId());
connection.commit(); connection.commit();
}
} }
@AfterEach @AfterEach

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

@ -125,7 +125,6 @@ public class SampleDataGenerator {
ScriptRunner runner = getScriptRunner(connection, outWriter, errorWriter); ScriptRunner runner = getScriptRunner(connection, outWriter, errorWriter);
consumer.accept(runner); consumer.accept(runner);
runner.closeConnection();
if (LOGGER.isTraceEnabled()) { if (LOGGER.isTraceEnabled()) {
LOGGER.trace(outWriter.toString()); LOGGER.trace(outWriter.toString());

5
rest/taskana-rest-spring/src/test/java/pro/taskana/rest/TestSchemaNameCustomizable.java
View File

@ -1,5 +1,6 @@
package pro.taskana.rest; package pro.taskana.rest;
import java.sql.Connection;
import java.sql.ResultSet; import java.sql.ResultSet;
import java.sql.SQLException; import java.sql.SQLException;
import java.sql.Statement; import java.sql.Statement;
@ -43,8 +44,8 @@ class TestSchemaNameCustomizable {
void chekCustomSchemaNameIsDefined() { void chekCustomSchemaNameIsDefined() {
resetDb(); resetDb();
ResultSet rs; ResultSet rs;
try { try (Connection connection = dataSource.getConnection()) {
Statement stmt = dataSource.getConnection().createStatement(); Statement stmt = connection.createStatement();
if (isPostgres) { if (isPostgres) {
rs = rs =
stmt.executeQuery( stmt.executeQuery(