TSK-1042 use try-with-resources for connections
This commit is contained in:
BerndBreier
Mustapha Zorgati
parent
bc18f69777
commit
6c8fb69f60
|
|
@ -38,20 +38,18 @@ public class DbSchemaCreator {
|
|||
* @throws SQLException will be thrown if there will be some incorrect SQL statements invoked.
|
||||
*/
|
||||
public void run() throws SQLException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
connection.setSchema(schemaName);
|
||||
ScriptRunner runner = new ScriptRunner(connection);
|
||||
runner.setStopOnError(true);
|
||||
runner.setLogWriter(logWriter);
|
||||
runner.setErrorLogWriter(errorLogWriter);
|
||||
try {
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
connection.setSchema(schemaName);
|
||||
ScriptRunner runner = new ScriptRunner(connection);
|
||||
runner.setStopOnError(true);
|
||||
runner.setLogWriter(logWriter);
|
||||
runner.setErrorLogWriter(errorLogWriter);
|
||||
|
||||
InputStream resourceAsStream = this.getClass().getResourceAsStream(DB_SCHEMA);
|
||||
BufferedReader reader =
|
||||
new BufferedReader(new InputStreamReader(resourceAsStream, StandardCharsets.UTF_8));
|
||||
runner.runScript(getSqlWithSchemaNameParsed(reader));
|
||||
} finally {
|
||||
runner.closeConnection();
|
||||
}
|
||||
}
|
||||
LOGGER.debug(outWriter.toString());
|
||||
if (!errorWriter.toString().trim().isEmpty()) {
|
||||
LOGGER.error(errorWriter.toString());
|
||||
|
|
|
|||
|
|
@ -29,13 +29,10 @@ public class DbWriter {
|
|||
|
||||
public void generateTestData(DataSource dataSource) throws SQLException {
|
||||
ScriptRunner runner = null;
|
||||
try {
|
||||
runner = configScriptRunner(dataSource);
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
runner = configScriptRunner(connection);
|
||||
runner.runScript(new InputStreamReader(this.getClass().getResourceAsStream(INSERTVALUES)));
|
||||
} finally {
|
||||
if (runner != null) {
|
||||
runner.closeConnection();
|
||||
}
|
||||
LOGGER.debug(outWriter.toString());
|
||||
if (!errorWriter.toString().trim().isEmpty()) {
|
||||
LOGGER.error(errorWriter.toString());
|
||||
|
|
@ -45,13 +42,10 @@ public class DbWriter {
|
|||
|
||||
public void clearDB(DataSource dataSource) throws SQLException {
|
||||
ScriptRunner runner = null;
|
||||
try {
|
||||
runner = configScriptRunner(dataSource);
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
runner = configScriptRunner(connection);
|
||||
runner.runScript(new StringReader("DELETE FROM HISTORY_EVENTS;"));
|
||||
} finally {
|
||||
if (runner != null) {
|
||||
runner.closeConnection();
|
||||
}
|
||||
LOGGER.debug(outWriter.toString());
|
||||
if (!errorWriter.toString().trim().isEmpty()) {
|
||||
LOGGER.error(errorWriter.toString());
|
||||
|
|
@ -59,8 +53,7 @@ public class DbWriter {
|
|||
}
|
||||
}
|
||||
|
||||
private ScriptRunner configScriptRunner(DataSource dataSource) throws SQLException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
private ScriptRunner configScriptRunner(Connection connection) throws SQLException {
|
||||
LOGGER.debug(connection.getMetaData().toString());
|
||||
ScriptRunner runner = new ScriptRunner(connection);
|
||||
runner.setStopOnError(true);
|
||||
|
|
|
|||
|
|
@ -24,7 +24,6 @@ public class SampleDataGenerator {
|
|||
private static final String HISTORY_EVENT = TEST_DATA + "/history-event.sql";
|
||||
DataSource dataSource;
|
||||
String dbProductName;
|
||||
private ScriptRunner runner;
|
||||
|
||||
public SampleDataGenerator(DataSource dataSource) throws SQLException {
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
|
|
@ -35,8 +34,6 @@ public class SampleDataGenerator {
|
|||
}
|
||||
}
|
||||
this.dataSource = dataSource;
|
||||
|
||||
runner = new ScriptRunner(dataSource.getConnection());
|
||||
}
|
||||
|
||||
public void generateSampleData(String schemaName) {
|
||||
|
|
@ -45,28 +42,28 @@ public class SampleDataGenerator {
|
|||
|
||||
final StringWriter errorWriter = new StringWriter();
|
||||
final PrintWriter errorLogWriter = new PrintWriter(errorWriter);
|
||||
try {
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
ScriptRunner runner = new ScriptRunner(connection);
|
||||
runner.runScript(selectSchemaScript(dbProductName, schemaName));
|
||||
runner.setStopOnError(false);
|
||||
runner.runScript(
|
||||
new BufferedReader(
|
||||
new InputStreamReader(
|
||||
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) {
|
||||
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());
|
||||
if (!errorWriter.toString().trim().isEmpty()) {
|
||||
LOGGER.error(errorWriter.toString());
|
||||
|
|
|
|||
|
|
@ -47,13 +47,13 @@ public class DbSchemaCreator {
|
|||
* @throws SQLException will be thrown if there will be some incorrect SQL statements invoked.
|
||||
*/
|
||||
public void run() throws SQLException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
LOGGER.debug(
|
||||
"Using database of type {} with url '{}'",
|
||||
connection.getMetaData().getDatabaseProductName(),
|
||||
connection.getMetaData().getURL());
|
||||
ScriptRunner runner = getScriptRunnerInstance(connection);
|
||||
try {
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
LOGGER.debug(
|
||||
"Using database of type {} with url '{}'",
|
||||
connection.getMetaData().getDatabaseProductName(),
|
||||
connection.getMetaData().getURL());
|
||||
ScriptRunner runner = getScriptRunnerInstance(connection);
|
||||
|
||||
if (!isSchemaPreexisting(connection)) {
|
||||
String scriptPath =
|
||||
selectDbScriptFileName(connection.getMetaData().getDatabaseProductName());
|
||||
|
|
@ -62,8 +62,6 @@ public class DbSchemaCreator {
|
|||
new BufferedReader(new InputStreamReader(resourceAsStream, StandardCharsets.UTF_8));
|
||||
runner.runScript(getSqlSchemaNameParsed(reader));
|
||||
}
|
||||
} finally {
|
||||
runner.closeConnection();
|
||||
}
|
||||
LOGGER.debug(outWriter.toString());
|
||||
if (!errorWriter.toString().trim().isEmpty()) {
|
||||
|
|
@ -73,8 +71,7 @@ public class DbSchemaCreator {
|
|||
|
||||
public boolean isValidSchemaVersion(String expectedVersion) {
|
||||
SqlRunner runner = null;
|
||||
try {
|
||||
Connection connection = dataSource.getConnection();
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
connection.setSchema(this.schemaName);
|
||||
runner = new SqlRunner(connection);
|
||||
LOGGER.debug(connection.getMetaData().toString());
|
||||
|
|
@ -102,10 +99,6 @@ public class DbSchemaCreator {
|
|||
+ "has not the expected value {}",
|
||||
expectedVersion);
|
||||
return false;
|
||||
} finally {
|
||||
if (runner != null) {
|
||||
runner.closeConnection();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -87,63 +87,66 @@ public class ClassificationServiceImplIntExplicitTest {
|
|||
public void testInsertClassification()
|
||||
throws SQLException, ClassificationNotFoundException, ClassificationAlreadyExistException,
|
||||
NotAuthorizedException, DomainNotFoundException, InvalidArgumentException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
|
||||
final String domain = "DOMAIN_A";
|
||||
final String key = "dummy-key";
|
||||
ClassificationImpl expectedClassification;
|
||||
final String domain = "DOMAIN_A";
|
||||
final String key = "dummy-key";
|
||||
ClassificationImpl expectedClassification;
|
||||
|
||||
// new classification but master existing
|
||||
expectedClassification =
|
||||
(ClassificationImpl) this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
expectedClassification.setKey(key);
|
||||
expectedClassification.setDomain("DOMAIN_B");
|
||||
classificationService.createClassification(expectedClassification);
|
||||
connection.commit();
|
||||
Classification actualClassification = classificationService.getClassification(key, "DOMAIN_B");
|
||||
assertThat(actualClassification, not(IsEqual.equalTo(null)));
|
||||
assertThat(actualClassification.getCreated(), not(IsEqual.equalTo(null)));
|
||||
assertThat(actualClassification.getId(), not(IsEqual.equalTo(null)));
|
||||
assertThat(actualClassification.getKey(), IsEqual.equalTo(key));
|
||||
assertThat(actualClassification.getDomain(), IsEqual.equalTo("DOMAIN_B"));
|
||||
assertThat(actualClassification.getId(), startsWith(ID_PREFIX_CLASSIFICATION));
|
||||
Classification masterResult = classificationService.getClassification(key, "");
|
||||
assertThat(masterResult, not(IsEqual.equalTo(null)));
|
||||
// new classification but master existing
|
||||
expectedClassification =
|
||||
(ClassificationImpl) this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
expectedClassification.setKey(key);
|
||||
expectedClassification.setDomain("DOMAIN_B");
|
||||
classificationService.createClassification(expectedClassification);
|
||||
connection.commit();
|
||||
Classification actualClassification =
|
||||
classificationService.getClassification(key, "DOMAIN_B");
|
||||
assertThat(actualClassification, not(IsEqual.equalTo(null)));
|
||||
assertThat(actualClassification.getCreated(), not(IsEqual.equalTo(null)));
|
||||
assertThat(actualClassification.getId(), not(IsEqual.equalTo(null)));
|
||||
assertThat(actualClassification.getKey(), IsEqual.equalTo(key));
|
||||
assertThat(actualClassification.getDomain(), IsEqual.equalTo("DOMAIN_B"));
|
||||
assertThat(actualClassification.getId(), startsWith(ID_PREFIX_CLASSIFICATION));
|
||||
Classification masterResult = classificationService.getClassification(key, "");
|
||||
assertThat(masterResult, not(IsEqual.equalTo(null)));
|
||||
|
||||
// invalid serviceLevel
|
||||
ClassificationImpl expectedClassificationCreated =
|
||||
(ClassificationImpl) this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
expectedClassificationCreated.setDomain(domain);
|
||||
expectedClassificationCreated.setKey("");
|
||||
expectedClassificationCreated.setServiceLevel("ASAP");
|
||||
// invalid serviceLevel
|
||||
ClassificationImpl expectedClassificationCreated =
|
||||
(ClassificationImpl) this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
expectedClassificationCreated.setDomain(domain);
|
||||
expectedClassificationCreated.setKey("");
|
||||
expectedClassificationCreated.setServiceLevel("ASAP");
|
||||
|
||||
Assertions.assertThrows(
|
||||
InvalidArgumentException.class,
|
||||
() -> {
|
||||
classificationService.createClassification(expectedClassificationCreated);
|
||||
},
|
||||
"Should have thrown IllegalArgumentException, because ServiceLevel is invalid.");
|
||||
Assertions.assertThrows(
|
||||
InvalidArgumentException.class,
|
||||
() -> {
|
||||
classificationService.createClassification(expectedClassificationCreated);
|
||||
},
|
||||
"Should have thrown IllegalArgumentException, because ServiceLevel is invalid.");
|
||||
|
||||
connection.commit();
|
||||
connection.commit();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindAllClassifications()
|
||||
throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException,
|
||||
DomainNotFoundException, InvalidArgumentException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
Classification classification0 = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classificationService.createClassification(classification0);
|
||||
Classification classification1 = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classificationService.createClassification(classification1);
|
||||
Classification classification2 = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classification2.setParentId(classification0.getId());
|
||||
classificationService.createClassification(classification2);
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
Classification classification0 = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classificationService.createClassification(classification0);
|
||||
Classification classification1 = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classificationService.createClassification(classification1);
|
||||
Classification classification2 = this.createNewClassificationWithUniqueKey("", "TASK");
|
||||
classification2.setParentId(classification0.getId());
|
||||
classificationService.createClassification(classification2);
|
||||
|
||||
assertEquals(2 + 1, classificationService.createClassificationQuery().list().size());
|
||||
connection.commit();
|
||||
assertEquals(2 + 1, classificationService.createClassificationQuery().list().size());
|
||||
connection.commit();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -152,38 +155,40 @@ public class ClassificationServiceImplIntExplicitTest {
|
|||
NotAuthorizedException, ConcurrencyException, DomainNotFoundException,
|
||||
InvalidArgumentException {
|
||||
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
connection.commit();
|
||||
classification = classificationService.createClassification(classification);
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
connection.commit();
|
||||
classification = classificationService.createClassification(classification);
|
||||
|
||||
String updatedDescription = "TEST SOMETHING";
|
||||
classification.setDescription(updatedDescription);
|
||||
classification = classificationService.updateClassification(classification);
|
||||
connection.commit();
|
||||
String updatedDescription = "TEST SOMETHING";
|
||||
classification.setDescription(updatedDescription);
|
||||
classification = classificationService.updateClassification(classification);
|
||||
connection.commit();
|
||||
|
||||
classification =
|
||||
classificationService.getClassification(
|
||||
classification.getKey(), classification.getDomain());
|
||||
assertThat(classification.getDescription(), IsEqual.equalTo(updatedDescription));
|
||||
classification =
|
||||
classificationService.getClassification(
|
||||
classification.getKey(), classification.getDomain());
|
||||
assertThat(classification.getDescription(), IsEqual.equalTo(updatedDescription));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testInsertAndClassificationQuery()
|
||||
throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException,
|
||||
DomainNotFoundException, InvalidArgumentException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
classificationService.createClassification(classification);
|
||||
List<ClassificationSummary> list =
|
||||
classificationService
|
||||
.createClassificationQuery()
|
||||
.validInDomainEquals(Boolean.TRUE)
|
||||
.createdWithin(today())
|
||||
.list();
|
||||
assertEquals(1, list.size());
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
classificationService.createClassification(classification);
|
||||
List<ClassificationSummary> list =
|
||||
classificationService
|
||||
.createClassificationQuery()
|
||||
.validInDomainEquals(Boolean.TRUE)
|
||||
.createdWithin(today())
|
||||
.list();
|
||||
assertEquals(1, list.size());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -191,31 +196,32 @@ public class ClassificationServiceImplIntExplicitTest {
|
|||
throws NotAuthorizedException, SQLException, ClassificationAlreadyExistException,
|
||||
ClassificationNotFoundException, ConcurrencyException, DomainNotFoundException,
|
||||
InvalidArgumentException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
classification.setDescription("");
|
||||
classification = classificationService.createClassification(classification);
|
||||
classification.setDescription("description");
|
||||
classification = classificationService.updateClassification(classification);
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
classification.setDescription("");
|
||||
classification = classificationService.createClassification(classification);
|
||||
classification.setDescription("description");
|
||||
classification = classificationService.updateClassification(classification);
|
||||
|
||||
List<ClassificationSummary> list = classificationService.createClassificationQuery().list();
|
||||
assertEquals(2, list.size());
|
||||
list = classificationService.createClassificationQuery().validInDomainEquals(true).list();
|
||||
assertEquals(1, list.size());
|
||||
classification =
|
||||
classificationService.getClassification(
|
||||
classification.getKey(), classification.getDomain());
|
||||
assertThat(classification.getDescription(), IsEqual.equalTo("description"));
|
||||
List<ClassificationSummary> list = classificationService.createClassificationQuery().list();
|
||||
assertEquals(2, list.size());
|
||||
list = classificationService.createClassificationQuery().validInDomainEquals(true).list();
|
||||
assertEquals(1, list.size());
|
||||
classification =
|
||||
classificationService.getClassification(
|
||||
classification.getKey(), classification.getDomain());
|
||||
assertThat(classification.getDescription(), IsEqual.equalTo("description"));
|
||||
|
||||
classification = classificationService.updateClassification(classification);
|
||||
list = classificationService.createClassificationQuery().list();
|
||||
assertEquals(2, list.size());
|
||||
classification = classificationService.updateClassification(classification);
|
||||
list = classificationService.createClassificationQuery().list();
|
||||
assertEquals(2, list.size());
|
||||
|
||||
List<ClassificationSummary> allClassifications =
|
||||
classificationService.createClassificationQuery().list();
|
||||
assertEquals(2, allClassifications.size());
|
||||
connection.commit();
|
||||
List<ClassificationSummary> allClassifications =
|
||||
classificationService.createClassificationQuery().list();
|
||||
assertEquals(2, allClassifications.size());
|
||||
connection.commit();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -223,42 +229,48 @@ public class ClassificationServiceImplIntExplicitTest {
|
|||
throws NotAuthorizedException, SQLException, ClassificationAlreadyExistException,
|
||||
ClassificationNotFoundException, InvalidArgumentException, ConcurrencyException,
|
||||
DomainNotFoundException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
classification = classificationService.createClassification(classification);
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
classification = classificationService.createClassification(classification);
|
||||
|
||||
Classification classification1 = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
classification1 = classificationService.createClassification(classification1);
|
||||
classification1.setParentId(classification.getId());
|
||||
classification1 = classificationService.updateClassification(classification1);
|
||||
Classification classification1 =
|
||||
this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
|
||||
classification1 = classificationService.createClassification(classification1);
|
||||
classification1.setParentId(classification.getId());
|
||||
classification1 = classificationService.updateClassification(classification1);
|
||||
|
||||
List<ClassificationSummary> list =
|
||||
classificationService.createClassificationQuery().parentIdIn("").list();
|
||||
assertEquals(3, list.size());
|
||||
list = classificationService.createClassificationQuery().list();
|
||||
assertEquals(4, list.size());
|
||||
connection.commit();
|
||||
List<ClassificationSummary> list =
|
||||
classificationService.createClassificationQuery().parentIdIn("").list();
|
||||
assertEquals(3, list.size());
|
||||
list = classificationService.createClassificationQuery().list();
|
||||
assertEquals(4, list.size());
|
||||
connection.commit();
|
||||
|
||||
list = classificationService.createClassificationQuery().validInDomainEquals(true).list();
|
||||
assertEquals(2, list.size());
|
||||
list = classificationService.createClassificationQuery().createdWithin(today()).list();
|
||||
assertEquals(4, list.size());
|
||||
list =
|
||||
classificationService
|
||||
.createClassificationQuery()
|
||||
.domainIn("DOMAIN_C")
|
||||
.validInDomainEquals(false)
|
||||
.list();
|
||||
assertEquals(0, list.size());
|
||||
list = classificationService.createClassificationQuery().keyIn(classification1.getKey()).list();
|
||||
assertEquals(2, list.size());
|
||||
list = classificationService.createClassificationQuery().validInDomainEquals(true).list();
|
||||
assertEquals(2, list.size());
|
||||
list = classificationService.createClassificationQuery().createdWithin(today()).list();
|
||||
assertEquals(4, list.size());
|
||||
list =
|
||||
classificationService
|
||||
.createClassificationQuery()
|
||||
.domainIn("DOMAIN_C")
|
||||
.validInDomainEquals(false)
|
||||
.list();
|
||||
assertEquals(0, list.size());
|
||||
list =
|
||||
classificationService.createClassificationQuery().keyIn(classification1.getKey()).list();
|
||||
assertEquals(2, list.size());
|
||||
|
||||
list =
|
||||
classificationService.createClassificationQuery().parentIdIn(classification.getId()).list();
|
||||
assertEquals(1, list.size());
|
||||
assertThat(list.get(0).getKey(), IsEqual.equalTo(classification1.getKey()));
|
||||
connection.commit();
|
||||
list =
|
||||
classificationService
|
||||
.createClassificationQuery()
|
||||
.parentIdIn(classification.getId())
|
||||
.list();
|
||||
assertEquals(1, list.size());
|
||||
assertThat(list.get(0).getKey(), IsEqual.equalTo(classification1.getKey()));
|
||||
connection.commit();
|
||||
}
|
||||
}
|
||||
|
||||
private Classification createNewClassificationWithUniqueKey(String domain, String type) {
|
||||
|
|
|
|||
|
|
@ -122,39 +122,41 @@ class TaskServiceImplIntExplicitTest {
|
|||
ClassificationAlreadyExistException, TaskAlreadyExistException,
|
||||
InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException,
|
||||
DomainNotFoundException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
|
||||
WorkbasketImpl workbasket = (WorkbasketImpl) workbasketService.newWorkbasket("k1", "DOMAIN_A");
|
||||
workbasket.setName("workbasket");
|
||||
workbasket.setId("1"); // set id manually for authorization tests
|
||||
WorkbasketImpl workbasket =
|
||||
(WorkbasketImpl) workbasketService.newWorkbasket("k1", "DOMAIN_A");
|
||||
workbasket.setName("workbasket");
|
||||
workbasket.setId("1"); // set id manually for authorization tests
|
||||
|
||||
workbasket.setType(WorkbasketType.GROUP);
|
||||
final Classification classification =
|
||||
classificationService.newClassification("TEST", "DOMAIN_A", "TASK");
|
||||
taskanaEngineImpl.getWorkbasketService().createWorkbasket(workbasket);
|
||||
workbasket.setType(WorkbasketType.GROUP);
|
||||
final Classification classification =
|
||||
classificationService.newClassification("TEST", "DOMAIN_A", "TASK");
|
||||
taskanaEngineImpl.getWorkbasketService().createWorkbasket(workbasket);
|
||||
|
||||
WorkbasketAccessItem accessItem = workbasketService.newWorkbasketAccessItem("1", "Elena");
|
||||
accessItem.setPermAppend(true);
|
||||
accessItem.setPermRead(true);
|
||||
accessItem.setPermOpen(true);
|
||||
workbasketService.createWorkbasketAccessItem(accessItem);
|
||||
WorkbasketAccessItem accessItem = workbasketService.newWorkbasketAccessItem("1", "Elena");
|
||||
accessItem.setPermAppend(true);
|
||||
accessItem.setPermRead(true);
|
||||
accessItem.setPermOpen(true);
|
||||
workbasketService.createWorkbasketAccessItem(accessItem);
|
||||
|
||||
taskanaEngineImpl.getClassificationService().createClassification(classification);
|
||||
connection.commit();
|
||||
Task task = taskServiceImpl.newTask(workbasket.getId());
|
||||
task.setName("Unit Test Task");
|
||||
task.setClassificationKey(classification.getKey());
|
||||
task.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
|
||||
task = taskServiceImpl.createTask(task);
|
||||
connection.commit();
|
||||
taskServiceImpl.getTask(task.getId());
|
||||
taskanaEngineImpl.getClassificationService().createClassification(classification);
|
||||
connection.commit();
|
||||
Task task = taskServiceImpl.newTask(workbasket.getId());
|
||||
task.setName("Unit Test Task");
|
||||
task.setClassificationKey(classification.getKey());
|
||||
task.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
|
||||
task = taskServiceImpl.createTask(task);
|
||||
connection.commit();
|
||||
taskServiceImpl.getTask(task.getId());
|
||||
|
||||
TaskanaEngineImpl te2 = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine();
|
||||
TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService();
|
||||
Assertions.assertThrows(
|
||||
TaskNotFoundException.class, () -> taskServiceImpl2.getTask(workbasket.getId()));
|
||||
connection.commit();
|
||||
TaskanaEngineImpl te2 = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine();
|
||||
TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService();
|
||||
Assertions.assertThrows(
|
||||
TaskNotFoundException.class, () -> taskServiceImpl2.getTask(workbasket.getId()));
|
||||
connection.commit();
|
||||
}
|
||||
}
|
||||
|
||||
@WithAccessId(
|
||||
|
|
@ -167,27 +169,28 @@ class TaskServiceImplIntExplicitTest {
|
|||
ClassificationAlreadyExistException, TaskAlreadyExistException,
|
||||
InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException,
|
||||
DomainNotFoundException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
|
||||
final Task task = this.generateDummyTask();
|
||||
connection.commit();
|
||||
final Task task = this.generateDummyTask();
|
||||
connection.commit();
|
||||
|
||||
WorkbasketAccessItem accessItem = workbasketService.newWorkbasketAccessItem("1", "Elena");
|
||||
accessItem.setPermAppend(true);
|
||||
accessItem.setPermRead(true);
|
||||
accessItem.setPermOpen(true);
|
||||
workbasketService.createWorkbasketAccessItem(accessItem);
|
||||
WorkbasketAccessItem accessItem = workbasketService.newWorkbasketAccessItem("1", "Elena");
|
||||
accessItem.setPermAppend(true);
|
||||
accessItem.setPermRead(true);
|
||||
accessItem.setPermOpen(true);
|
||||
workbasketService.createWorkbasketAccessItem(accessItem);
|
||||
|
||||
task.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
|
||||
final Task task2 = taskServiceImpl.createTask(task);
|
||||
connection.commit(); // needed so that the change is visible in the other session
|
||||
task.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
|
||||
final Task task2 = taskServiceImpl.createTask(task);
|
||||
connection.commit(); // needed so that the change is visible in the other session
|
||||
|
||||
TaskanaEngine te2 = taskanaEngineConfiguration.buildTaskanaEngine();
|
||||
TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService();
|
||||
Task resultTask = taskServiceImpl2.getTask(task2.getId());
|
||||
assertNotNull(resultTask);
|
||||
connection.commit();
|
||||
TaskanaEngine te2 = taskanaEngineConfiguration.buildTaskanaEngine();
|
||||
TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService();
|
||||
Task resultTask = taskServiceImpl2.getTask(task2.getId());
|
||||
assertNotNull(resultTask);
|
||||
connection.commit();
|
||||
}
|
||||
}
|
||||
|
||||
@WithAccessId(
|
||||
|
|
@ -198,13 +201,14 @@ class TaskServiceImplIntExplicitTest {
|
|||
throws NotAuthorizedException, SQLException, ClassificationAlreadyExistException,
|
||||
InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException,
|
||||
DomainNotFoundException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
Task test = this.generateDummyTask();
|
||||
((WorkbasketSummaryImpl) (test.getWorkbasketSummary())).setId("2");
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
Task test = this.generateDummyTask();
|
||||
((WorkbasketSummaryImpl) (test.getWorkbasketSummary())).setId("2");
|
||||
|
||||
Assertions.assertThrows(
|
||||
WorkbasketNotFoundException.class, () -> taskServiceImpl.createTask(test));
|
||||
Assertions.assertThrows(
|
||||
WorkbasketNotFoundException.class, () -> taskServiceImpl.createTask(test));
|
||||
}
|
||||
}
|
||||
|
||||
@WithAccessId(
|
||||
|
|
@ -215,26 +219,28 @@ class TaskServiceImplIntExplicitTest {
|
|||
throws NotAuthorizedException, WorkbasketNotFoundException, SQLException,
|
||||
ClassificationAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException,
|
||||
WorkbasketAlreadyExistException, DomainNotFoundException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
|
||||
Workbasket wb = workbasketService.newWorkbasket("WB NR.1", "DOMAIN_A");
|
||||
wb.setName("dummy-WB");
|
||||
wb.setType(WorkbasketType.PERSONAL);
|
||||
wb = workbasketService.createWorkbasket(wb);
|
||||
this.createWorkbasketWithSecurity(wb, CurrentUserContext.getUserid(), true, true, true, false);
|
||||
Classification classification =
|
||||
classificationService.newClassification(
|
||||
UUID.randomUUID().toString(), wb.getDomain(), "t1"); // not persisted,
|
||||
// not found.
|
||||
classification.setName("not persisted - so not found.");
|
||||
Workbasket wb = workbasketService.newWorkbasket("WB NR.1", "DOMAIN_A");
|
||||
wb.setName("dummy-WB");
|
||||
wb.setType(WorkbasketType.PERSONAL);
|
||||
wb = workbasketService.createWorkbasket(wb);
|
||||
this.createWorkbasketWithSecurity(
|
||||
wb, CurrentUserContext.getUserid(), true, true, true, false);
|
||||
Classification classification =
|
||||
classificationService.newClassification(
|
||||
UUID.randomUUID().toString(), wb.getDomain(), "t1"); // not persisted,
|
||||
// not found.
|
||||
classification.setName("not persisted - so not found.");
|
||||
|
||||
Task task = this.generateDummyTask();
|
||||
((TaskImpl) task).setWorkbasketSummary(wb.asSummary());
|
||||
task.setClassificationKey(classification.getKey());
|
||||
Task task = this.generateDummyTask();
|
||||
((TaskImpl) task).setWorkbasketSummary(wb.asSummary());
|
||||
task.setClassificationKey(classification.getKey());
|
||||
|
||||
Assertions.assertThrows(
|
||||
ClassificationNotFoundException.class, () -> taskServiceImpl.createTask(task));
|
||||
Assertions.assertThrows(
|
||||
ClassificationNotFoundException.class, () -> taskServiceImpl.createTask(task));
|
||||
}
|
||||
}
|
||||
|
||||
@WithAccessId(
|
||||
|
|
@ -246,49 +252,51 @@ class TaskServiceImplIntExplicitTest {
|
|||
ClassificationNotFoundException, ClassificationAlreadyExistException,
|
||||
TaskAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException,
|
||||
SystemException, WorkbasketAlreadyExistException, DomainNotFoundException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
WorkbasketImpl workbasket = (WorkbasketImpl) workbasketService.newWorkbasket("k1", "DOMAIN_A");
|
||||
workbasket.setName("workbasket");
|
||||
Classification classification =
|
||||
classificationService.newClassification("TEST", "DOMAIN_A", "TASK");
|
||||
classificationService.createClassification(classification);
|
||||
workbasket.setId("1"); // set id manually for authorization tests
|
||||
workbasket.setType(WorkbasketType.GROUP);
|
||||
workbasket = (WorkbasketImpl) workbasketService.createWorkbasket(workbasket);
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
WorkbasketImpl workbasket =
|
||||
(WorkbasketImpl) workbasketService.newWorkbasket("k1", "DOMAIN_A");
|
||||
workbasket.setName("workbasket");
|
||||
Classification classification =
|
||||
classificationService.newClassification("TEST", "DOMAIN_A", "TASK");
|
||||
classificationService.createClassification(classification);
|
||||
workbasket.setId("1"); // set id manually for authorization tests
|
||||
workbasket.setType(WorkbasketType.GROUP);
|
||||
workbasket = (WorkbasketImpl) workbasketService.createWorkbasket(workbasket);
|
||||
|
||||
WorkbasketAccessItem accessItem = workbasketService.newWorkbasketAccessItem("1", "Elena");
|
||||
accessItem.setPermAppend(true);
|
||||
accessItem.setPermRead(true);
|
||||
accessItem.setPermOpen(true);
|
||||
workbasketService.createWorkbasketAccessItem(accessItem);
|
||||
WorkbasketAccessItem accessItem = workbasketService.newWorkbasketAccessItem("1", "Elena");
|
||||
accessItem.setPermAppend(true);
|
||||
accessItem.setPermRead(true);
|
||||
accessItem.setPermOpen(true);
|
||||
workbasketService.createWorkbasketAccessItem(accessItem);
|
||||
|
||||
Task task = taskServiceImpl.newTask(workbasket.getId());
|
||||
task.setName("Unit Test Task");
|
||||
task.setClassificationKey(classification.getKey());
|
||||
task.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
|
||||
taskServiceImpl.createTask(task);
|
||||
Task task = taskServiceImpl.newTask(workbasket.getId());
|
||||
task.setName("Unit Test Task");
|
||||
task.setClassificationKey(classification.getKey());
|
||||
task.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
|
||||
taskServiceImpl.createTask(task);
|
||||
|
||||
List<TaskSummary> results =
|
||||
taskServiceImpl
|
||||
.createTaskQuery()
|
||||
.nameIn("bla", "test")
|
||||
.descriptionLike("test")
|
||||
.priorityIn(1, 2, 2)
|
||||
.stateIn(TaskState.CLAIMED)
|
||||
.workbasketKeyDomainIn(new KeyDomain("k1", "DOMAIN_A"))
|
||||
.ownerIn("test", "test2", "bla")
|
||||
.customAttributeLike("13", "test")
|
||||
.classificationKeyIn("pId1", "pId2")
|
||||
.primaryObjectReferenceCompanyIn("first comp", "sonstwo gmbh")
|
||||
.primaryObjectReferenceSystemIn("sys")
|
||||
.primaryObjectReferenceTypeIn("type1", "type2")
|
||||
.primaryObjectReferenceSystemInstanceIn("sysInst1", "sysInst2")
|
||||
.primaryObjectReferenceValueIn("val1", "val2", "val3")
|
||||
.list();
|
||||
List<TaskSummary> results =
|
||||
taskServiceImpl
|
||||
.createTaskQuery()
|
||||
.nameIn("bla", "test")
|
||||
.descriptionLike("test")
|
||||
.priorityIn(1, 2, 2)
|
||||
.stateIn(TaskState.CLAIMED)
|
||||
.workbasketKeyDomainIn(new KeyDomain("k1", "DOMAIN_A"))
|
||||
.ownerIn("test", "test2", "bla")
|
||||
.customAttributeLike("13", "test")
|
||||
.classificationKeyIn("pId1", "pId2")
|
||||
.primaryObjectReferenceCompanyIn("first comp", "sonstwo gmbh")
|
||||
.primaryObjectReferenceSystemIn("sys")
|
||||
.primaryObjectReferenceTypeIn("type1", "type2")
|
||||
.primaryObjectReferenceSystemInstanceIn("sysInst1", "sysInst2")
|
||||
.primaryObjectReferenceValueIn("val1", "val2", "val3")
|
||||
.list();
|
||||
|
||||
assertEquals(0, results.size());
|
||||
connection.commit();
|
||||
assertEquals(0, results.size());
|
||||
connection.commit();
|
||||
}
|
||||
}
|
||||
|
||||
@WithAccessId(
|
||||
|
|
@ -303,69 +311,74 @@ class TaskServiceImplIntExplicitTest {
|
|||
InvalidStateException {
|
||||
final int sleepTime = 100;
|
||||
final String user = CurrentUserContext.getUserid();
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
|
||||
// Source Workbasket
|
||||
WorkbasketImpl wb = (WorkbasketImpl) workbasketService.newWorkbasket("sourceWbKey", "DOMAIN_A");
|
||||
wb.setName("Basic-Workbasket");
|
||||
wb.setDescription("Just used as base WB for Task here");
|
||||
wb.setOwner(user);
|
||||
wb.setType(WorkbasketType.PERSONAL);
|
||||
Workbasket sourceWB = workbasketService.createWorkbasket(wb);
|
||||
// Source Workbasket
|
||||
WorkbasketImpl wb =
|
||||
(WorkbasketImpl) workbasketService.newWorkbasket("sourceWbKey", "DOMAIN_A");
|
||||
wb.setName("Basic-Workbasket");
|
||||
wb.setDescription("Just used as base WB for Task here");
|
||||
wb.setOwner(user);
|
||||
wb.setType(WorkbasketType.PERSONAL);
|
||||
Workbasket sourceWB = workbasketService.createWorkbasket(wb);
|
||||
|
||||
createWorkbasketWithSecurity(wb, wb.getOwner(), false, false, false, false);
|
||||
createWorkbasketWithSecurity(sourceWB, sourceWB.getOwner(), true, true, true, true);
|
||||
createWorkbasketWithSecurity(wb, wb.getOwner(), false, false, false, false);
|
||||
createWorkbasketWithSecurity(sourceWB, sourceWB.getOwner(), true, true, true, true);
|
||||
|
||||
// Destination Workbasket
|
||||
wb = (WorkbasketImpl) workbasketService.newWorkbasket("wb2Key", "DOMAIN_A");
|
||||
wb.setName("Desination-WorkBasket");
|
||||
wb.setDescription("Destination WB where Task should be transfered to");
|
||||
wb.setOwner(user);
|
||||
wb.setType(WorkbasketType.TOPIC);
|
||||
// Destination Workbasket
|
||||
wb = (WorkbasketImpl) workbasketService.newWorkbasket("wb2Key", "DOMAIN_A");
|
||||
wb.setName("Desination-WorkBasket");
|
||||
wb.setDescription("Destination WB where Task should be transfered to");
|
||||
wb.setOwner(user);
|
||||
wb.setType(WorkbasketType.TOPIC);
|
||||
|
||||
Workbasket destinationWB = workbasketService.createWorkbasket(wb);
|
||||
createWorkbasketWithSecurity(destinationWB, destinationWB.getOwner(), false, true, true, true);
|
||||
Workbasket destinationWB = workbasketService.createWorkbasket(wb);
|
||||
createWorkbasketWithSecurity(
|
||||
destinationWB, destinationWB.getOwner(), false, true, true, true);
|
||||
|
||||
// Classification required for Task
|
||||
ClassificationImpl classification =
|
||||
(ClassificationImpl) classificationService.newClassification("KEY", "DOMAIN_A", "TASK");
|
||||
classification.setCategory("EXTERNAL");
|
||||
classification.setName("Transfert-Task Classification");
|
||||
classificationService.createClassification(classification);
|
||||
// Classification required for Task
|
||||
ClassificationImpl classification =
|
||||
(ClassificationImpl) classificationService.newClassification("KEY", "DOMAIN_A", "TASK");
|
||||
classification.setCategory("EXTERNAL");
|
||||
classification.setName("Transfert-Task Classification");
|
||||
classificationService.createClassification(classification);
|
||||
|
||||
// Task which should be transfered
|
||||
TaskImpl task = (TaskImpl) taskServiceImpl.newTask(sourceWB.getId());
|
||||
task.setName("Task Name");
|
||||
task.setDescription("Task used for transfer Test");
|
||||
task.setRead(true);
|
||||
task.setTransferred(false);
|
||||
task.setModified(null);
|
||||
task.setClassificationKey("KEY");
|
||||
task.setOwner(user);
|
||||
task.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
|
||||
task = (TaskImpl) taskServiceImpl.createTask(task);
|
||||
Thread.sleep(sleepTime); // Sleep for modification-timestamp
|
||||
connection.commit();
|
||||
// Task which should be transfered
|
||||
TaskImpl task = (TaskImpl) taskServiceImpl.newTask(sourceWB.getId());
|
||||
task.setName("Task Name");
|
||||
task.setDescription("Task used for transfer Test");
|
||||
task.setRead(true);
|
||||
task.setTransferred(false);
|
||||
task.setModified(null);
|
||||
task.setClassificationKey("KEY");
|
||||
task.setOwner(user);
|
||||
task.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
|
||||
task = (TaskImpl) taskServiceImpl.createTask(task);
|
||||
Thread.sleep(sleepTime); // Sleep for modification-timestamp
|
||||
connection.commit();
|
||||
|
||||
Task resultTask = taskServiceImpl.transfer(task.getId(), destinationWB.getId());
|
||||
connection.commit();
|
||||
assertThat(resultTask.isRead(), equalTo(false));
|
||||
assertThat(resultTask.isTransferred(), equalTo(true));
|
||||
assertThat(resultTask.getWorkbasketKey(), equalTo(destinationWB.getKey()));
|
||||
assertThat(resultTask.getModified(), not(equalTo(null)));
|
||||
assertThat(resultTask.getModified(), not(equalTo(task.getModified())));
|
||||
assertThat(resultTask.getCreated(), not(equalTo(null)));
|
||||
assertThat(resultTask.getCreated(), equalTo(task.getCreated()));
|
||||
Task resultTask = taskServiceImpl.transfer(task.getId(), destinationWB.getId());
|
||||
connection.commit();
|
||||
assertThat(resultTask.isRead(), equalTo(false));
|
||||
assertThat(resultTask.isTransferred(), equalTo(true));
|
||||
assertThat(resultTask.getWorkbasketKey(), equalTo(destinationWB.getKey()));
|
||||
assertThat(resultTask.getModified(), not(equalTo(null)));
|
||||
assertThat(resultTask.getModified(), not(equalTo(task.getModified())));
|
||||
assertThat(resultTask.getCreated(), not(equalTo(null)));
|
||||
assertThat(resultTask.getCreated(), equalTo(task.getCreated()));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void shouldNotTransferAnyTask() throws SQLException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
|
||||
Assertions.assertThrows(
|
||||
TaskNotFoundException.class, () -> taskServiceImpl.transfer(UUID.randomUUID() + "_X", "1"));
|
||||
Assertions.assertThrows(
|
||||
TaskNotFoundException.class,
|
||||
() -> taskServiceImpl.transfer(UUID.randomUUID() + "_X", "1"));
|
||||
}
|
||||
}
|
||||
|
||||
@WithAccessId(
|
||||
|
|
|
|||
|
|
@ -80,59 +80,60 @@ class WorkbasketServiceImplIntExplicitTest {
|
|||
groupNames = {"businessadmin"})
|
||||
@Test
|
||||
void testUpdateWorkbasket() throws Exception {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
workBasketService = taskanaEngine.getWorkbasketService();
|
||||
String id0 = IdGenerator.generateWithPrefix("TWB");
|
||||
Workbasket workbasket0 =
|
||||
createTestWorkbasket(id0, "key0", "DOMAIN_A", "Superbasket", WorkbasketType.GROUP);
|
||||
workbasket0 = workBasketService.createWorkbasket(workbasket0);
|
||||
createWorkbasketWithSecurity(workbasket0, "Elena", true, true, false, false);
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
workBasketService = taskanaEngine.getWorkbasketService();
|
||||
String id0 = IdGenerator.generateWithPrefix("TWB");
|
||||
Workbasket workbasket0 =
|
||||
createTestWorkbasket(id0, "key0", "DOMAIN_A", "Superbasket", WorkbasketType.GROUP);
|
||||
workbasket0 = workBasketService.createWorkbasket(workbasket0);
|
||||
createWorkbasketWithSecurity(workbasket0, "Elena", true, true, false, false);
|
||||
|
||||
String id1 = IdGenerator.generateWithPrefix("TWB");
|
||||
Workbasket workbasket1 =
|
||||
createTestWorkbasket(id1, "key1", "DOMAIN_A", "Megabasket", WorkbasketType.GROUP);
|
||||
workbasket1 = workBasketService.createWorkbasket(workbasket1);
|
||||
createWorkbasketWithSecurity(workbasket1, "Elena", true, true, false, false);
|
||||
String id1 = IdGenerator.generateWithPrefix("TWB");
|
||||
Workbasket workbasket1 =
|
||||
createTestWorkbasket(id1, "key1", "DOMAIN_A", "Megabasket", WorkbasketType.GROUP);
|
||||
workbasket1 = workBasketService.createWorkbasket(workbasket1);
|
||||
createWorkbasketWithSecurity(workbasket1, "Elena", true, true, false, false);
|
||||
|
||||
String id2 = IdGenerator.generateWithPrefix("TWB");
|
||||
Workbasket workbasket2 =
|
||||
createTestWorkbasket(id2, "key2", "DOMAIN_A", "Hyperbasket", WorkbasketType.GROUP);
|
||||
workbasket2 = workBasketService.createWorkbasket(workbasket2);
|
||||
createWorkbasketWithSecurity(workbasket2, "Elena", true, true, false, false);
|
||||
String id2 = IdGenerator.generateWithPrefix("TWB");
|
||||
Workbasket workbasket2 =
|
||||
createTestWorkbasket(id2, "key2", "DOMAIN_A", "Hyperbasket", WorkbasketType.GROUP);
|
||||
workbasket2 = workBasketService.createWorkbasket(workbasket2);
|
||||
createWorkbasketWithSecurity(workbasket2, "Elena", true, true, false, false);
|
||||
|
||||
List<String> distTargets =
|
||||
new ArrayList<>(Arrays.asList(workbasket0.getId(), workbasket1.getId()));
|
||||
Thread.sleep(SLEEP_TIME);
|
||||
workBasketService.setDistributionTargets(workbasket2.getId(), distTargets);
|
||||
List<String> distTargets =
|
||||
new ArrayList<>(Arrays.asList(workbasket0.getId(), workbasket1.getId()));
|
||||
Thread.sleep(SLEEP_TIME);
|
||||
workBasketService.setDistributionTargets(workbasket2.getId(), distTargets);
|
||||
|
||||
String id3 = IdGenerator.generateWithPrefix("TWB");
|
||||
Workbasket workbasket3 =
|
||||
createTestWorkbasket(
|
||||
id3, "key3", "DOMAIN_A", "hm ... irgend ein basket", WorkbasketType.GROUP);
|
||||
workbasket3 = workBasketService.createWorkbasket(workbasket3);
|
||||
createWorkbasketWithSecurity(workbasket3, "Elena", true, true, false, false);
|
||||
String id3 = IdGenerator.generateWithPrefix("TWB");
|
||||
Workbasket workbasket3 =
|
||||
createTestWorkbasket(
|
||||
id3, "key3", "DOMAIN_A", "hm ... irgend ein basket", WorkbasketType.GROUP);
|
||||
workbasket3 = workBasketService.createWorkbasket(workbasket3);
|
||||
createWorkbasketWithSecurity(workbasket3, "Elena", true, true, false, false);
|
||||
|
||||
List<String> newDistTargets = new ArrayList<>(Arrays.asList(workbasket3.getId()));
|
||||
Thread.sleep(SLEEP_TIME);
|
||||
workBasketService.setDistributionTargets(workbasket2.getId(), newDistTargets);
|
||||
List<String> newDistTargets = new ArrayList<>(Arrays.asList(workbasket3.getId()));
|
||||
Thread.sleep(SLEEP_TIME);
|
||||
workBasketService.setDistributionTargets(workbasket2.getId(), newDistTargets);
|
||||
|
||||
Workbasket foundBasket = workBasketService.getWorkbasket(workbasket2.getId());
|
||||
Workbasket foundBasket = workBasketService.getWorkbasket(workbasket2.getId());
|
||||
|
||||
List<WorkbasketSummary> distributionTargets =
|
||||
workBasketService.getDistributionTargets(foundBasket.getId());
|
||||
assertEquals(1, distributionTargets.size());
|
||||
assertEquals(workbasket3.getId(), distributionTargets.get(0).getId());
|
||||
assertNotEquals(
|
||||
workBasketService.getWorkbasket(id2).getCreated(),
|
||||
workBasketService.getWorkbasket(id2).getModified());
|
||||
assertEquals(
|
||||
workBasketService.getWorkbasket(id1).getCreated(),
|
||||
workBasketService.getWorkbasket(id1).getModified());
|
||||
assertEquals(
|
||||
workBasketService.getWorkbasket(id3).getCreated(),
|
||||
workBasketService.getWorkbasket(id3).getModified());
|
||||
connection.commit();
|
||||
List<WorkbasketSummary> distributionTargets =
|
||||
workBasketService.getDistributionTargets(foundBasket.getId());
|
||||
assertEquals(1, distributionTargets.size());
|
||||
assertEquals(workbasket3.getId(), distributionTargets.get(0).getId());
|
||||
assertNotEquals(
|
||||
workBasketService.getWorkbasket(id2).getCreated(),
|
||||
workBasketService.getWorkbasket(id2).getModified());
|
||||
assertEquals(
|
||||
workBasketService.getWorkbasket(id1).getCreated(),
|
||||
workBasketService.getWorkbasket(id1).getModified());
|
||||
assertEquals(
|
||||
workBasketService.getWorkbasket(id3).getCreated(),
|
||||
workBasketService.getWorkbasket(id3).getModified());
|
||||
connection.commit();
|
||||
}
|
||||
}
|
||||
|
||||
@WithAccessId(
|
||||
|
|
@ -143,20 +144,21 @@ class WorkbasketServiceImplIntExplicitTest {
|
|||
throws NotAuthorizedException, SQLException, InvalidArgumentException,
|
||||
WorkbasketNotFoundException, DomainNotFoundException, InvalidWorkbasketException,
|
||||
WorkbasketAlreadyExistException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
workBasketService = taskanaEngine.getWorkbasketService();
|
||||
Workbasket wb =
|
||||
createTestWorkbasket("id1", "key1", "DOMAIN_A", "name", WorkbasketType.CLEARANCE);
|
||||
workBasketService.createWorkbasket(wb);
|
||||
WorkbasketAccessItem accessItem =
|
||||
workBasketService.newWorkbasketAccessItem("id1", "Arthur Dent");
|
||||
accessItem.setPermOpen(true);
|
||||
accessItem.setPermRead(true);
|
||||
workBasketService.createWorkbasketAccessItem(accessItem);
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
workBasketService = taskanaEngine.getWorkbasketService();
|
||||
Workbasket wb =
|
||||
createTestWorkbasket("id1", "key1", "DOMAIN_A", "name", WorkbasketType.CLEARANCE);
|
||||
workBasketService.createWorkbasket(wb);
|
||||
WorkbasketAccessItem accessItem =
|
||||
workBasketService.newWorkbasketAccessItem("id1", "Arthur Dent");
|
||||
accessItem.setPermOpen(true);
|
||||
accessItem.setPermRead(true);
|
||||
workBasketService.createWorkbasketAccessItem(accessItem);
|
||||
|
||||
assertEquals(1, workBasketService.getWorkbasketAccessItems("id1").size());
|
||||
connection.commit();
|
||||
assertEquals(1, workBasketService.getWorkbasketAccessItems("id1").size());
|
||||
connection.commit();
|
||||
}
|
||||
}
|
||||
|
||||
@WithAccessId(
|
||||
|
|
@ -167,22 +169,23 @@ class WorkbasketServiceImplIntExplicitTest {
|
|||
throws NotAuthorizedException, SQLException, InvalidArgumentException,
|
||||
WorkbasketNotFoundException, DomainNotFoundException, InvalidWorkbasketException,
|
||||
WorkbasketAlreadyExistException {
|
||||
Connection connection = dataSource.getConnection();
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
workBasketService = taskanaEngine.getWorkbasketService();
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
taskanaEngineImpl.setConnection(connection);
|
||||
workBasketService = taskanaEngine.getWorkbasketService();
|
||||
|
||||
Workbasket wb =
|
||||
createTestWorkbasket("key2", "kkey2", "DOMAIN_A", "name", WorkbasketType.CLEARANCE);
|
||||
workBasketService.createWorkbasket(wb);
|
||||
WorkbasketAccessItem accessItem =
|
||||
workBasketService.newWorkbasketAccessItem("key2", "Zaphod Beeblebrox");
|
||||
accessItem.setPermOpen(true);
|
||||
accessItem.setPermRead(true);
|
||||
workBasketService.createWorkbasketAccessItem(accessItem);
|
||||
Workbasket wb =
|
||||
createTestWorkbasket("key2", "kkey2", "DOMAIN_A", "name", WorkbasketType.CLEARANCE);
|
||||
workBasketService.createWorkbasket(wb);
|
||||
WorkbasketAccessItem accessItem =
|
||||
workBasketService.newWorkbasketAccessItem("key2", "Zaphod Beeblebrox");
|
||||
accessItem.setPermOpen(true);
|
||||
accessItem.setPermRead(true);
|
||||
workBasketService.createWorkbasketAccessItem(accessItem);
|
||||
|
||||
assertEquals(1, workBasketService.getWorkbasketAccessItems("key2").size());
|
||||
assertEquals("zaphod beeblebrox", accessItem.getAccessId());
|
||||
connection.commit();
|
||||
assertEquals(1, workBasketService.getWorkbasketAccessItems("key2").size());
|
||||
assertEquals("zaphod beeblebrox", accessItem.getAccessId());
|
||||
connection.commit();
|
||||
}
|
||||
}
|
||||
|
||||
@AfterEach
|
||||
|
|
|
|||
|
|
@ -125,7 +125,6 @@ public class SampleDataGenerator {
|
|||
|
||||
ScriptRunner runner = getScriptRunner(connection, outWriter, errorWriter);
|
||||
consumer.accept(runner);
|
||||
runner.closeConnection();
|
||||
|
||||
if (LOGGER.isTraceEnabled()) {
|
||||
LOGGER.trace(outWriter.toString());
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
package pro.taskana.rest;
|
||||
|
||||
import java.sql.Connection;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.Statement;
|
||||
|
|
@ -43,8 +44,8 @@ class TestSchemaNameCustomizable {
|
|||
void chekCustomSchemaNameIsDefined() {
|
||||
resetDb();
|
||||
ResultSet rs;
|
||||
try {
|
||||
Statement stmt = dataSource.getConnection().createStatement();
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
Statement stmt = connection.createStatement();
|
||||
if (isPostgres) {
|
||||
rs =
|
||||
stmt.executeQuery(
|
||||
|
|
|
|||
Loading…
Reference in New Issue