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

TSK-681 Create WorkbasketCleanupJob transaction test

This commit is contained in:
Martin Rojas Miguel Angel 2018-10-23 14:01:43 +02:00 committed by Holger Hagen
parent d886aaf00e
commit 83918d9af5
5 changed files with 152 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
lib/taskana-core/src/main/java/pro/taskana/impl/WorkbasketServiceImpl.java
View File

@ -807,7 +807,11 @@ public class WorkbasketServiceImpl implements WorkbasketService {
while (iterator.hasNext()) {
try {
workbasketIdForDeleting = iterator.next();
deleteWorkbasket(workbasketIdForDeleting);
if (!deleteWorkbasket(workbasketIdForDeleting)) {
bulkLog.addError(workbasketIdForDeleting, new WorkbasketInUseException(
"Workbasket with id " + workbasketIdForDeleting
+ " contains completed tasks not deleted and will not be deleted."));
}
} catch (WorkbasketInUseException ex) {
bulkLog.addError(workbasketIdForDeleting, new WorkbasketInUseException(
"Workbasket with id " + workbasketIdForDeleting + " is in use and will not be deleted."));

2
lib/taskana-core/src/main/java/pro/taskana/jobs/WorkbasketCleanupJob.java
View File

@ -22,7 +22,7 @@ import pro.taskana.transaction.TaskanaTransactionProvider;
*/
public class WorkbasketCleanupJob extends AbstractTaskanaJob {
private static final Logger LOGGER = LoggerFactory.getLogger(TaskCleanupJob.class);
private static final Logger LOGGER = LoggerFactory.getLogger(WorkbasketCleanupJob.class);
// Parameter
private Instant firstRun;

4
lib/taskana-spring-example/src/main/resources/taskana.properties
View File

@ -10,5 +10,5 @@ taskana.classification.categories.document= EXTERNAL
taskana.jobs.cleanup.schedule=0 0 3 * * *
taskana.jobs.cleanup.runEvery=P1D
taskana.jobs.cleanup.firstRunAt=2018-07-25T08:00:00Z
taskana.jobs.cleanup.minimumAge=P14D
taskana.jobs.cleanup.allCompletedSameParentBusiness=true
taskana.jobs.cleanup.minimumAge=PT0S
taskana.jobs.cleanup.allCompletedSameParentBusiness=false

125
lib/taskana-spring-example/src/test/java/pro/taskana/TaskanaTransactionTest.java
View File

@ -5,32 +5,55 @@ import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Optional;
import javax.sql.DataSource;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.ArgumentMatcher;
import org.mockito.Captor;
import org.mockito.Mock;
import org.slf4j.LoggerFactory;
import org.slf4j.event.Level;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.context.annotation.Import;
import org.springframework.http.ResponseEntity;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringRunner;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.classic.spi.LoggingEvent;
import ch.qos.logback.core.Appender;
import pro.taskana.exceptions.DomainNotFoundException;
import pro.taskana.exceptions.InvalidWorkbasketException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.exceptions.TaskanaException;
import pro.taskana.exceptions.WorkbasketAlreadyExistException;
import pro.taskana.exceptions.WorkbasketNotFoundException;
import pro.taskana.impl.TaskImpl;
import pro.taskana.impl.TaskanaEngineImpl;
import pro.taskana.impl.WorkbasketImpl;
import pro.taskana.impl.util.IdGenerator;
import pro.taskana.jobs.TaskCleanupJob;
import pro.taskana.jobs.WorkbasketCleanupJob;
import pro.taskana.transaction.TaskanaTransactionProvider;
/**
*
@ -39,6 +62,7 @@ import pro.taskana.impl.util.IdGenerator;
@SpringBootTest(classes = TaskanaConfigTestApplication.class,
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@ActiveProfiles({"inmemorydb", "dev"})
@Import({TransactionalJobsConfiguration.class})
public class TaskanaTransactionTest {
private static final int POOL_TIME_TO_WAIT = 50;
@ -55,6 +79,15 @@ public class TaskanaTransactionTest {
@Autowired
private TaskanaEngine taskanaEngine;
@Autowired
TaskanaTransactionProvider<Object> springTransactionProvider;
@Captor
private ArgumentCaptor<LoggingEvent> captorLoggingEvent;
@Mock
private Appender mockAppender;
@Before
public void before() {
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
@ -162,6 +195,81 @@ public class TaskanaTransactionTest {
assertEquals(2, result);
}
@Test
public void testWorkbasketCleanupJobTransaction() {
try {
ch.qos.logback.classic.Logger logger = (ch.qos.logback.classic.Logger) LoggerFactory
.getLogger(WorkbasketCleanupJob.class);
logger.addAppender(mockAppender);
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
workbasketService.createWorkbasket(createWorkBasket("key1", "wb1"));
workbasketService.createWorkbasket(createWorkBasket("key2", "wb2"));
workbasketService.createWorkbasket(createWorkBasket("key3", "wb3"));
TaskService taskService = taskanaEngine.getTaskService();
ClassificationService classificationService = taskanaEngine.getClassificationService();
classificationService.newClassification("TEST", "DOMAIN_A", "TASK");
taskService.createTask(createTask("key1", "TEST"));
taskService.createTask(createTask("key2", "TEST"));
taskService.createTask(createTask("key3", "TEST"));
assertEquals(workbasketService.createWorkbasketQuery()
.count(), 3);
assertEquals(taskService.createTaskQuery()
.count(), 3);
List<TaskSummary> tasks = taskService.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("key1", "DOMAIN_A"))
.list();
taskService.claim(tasks.get(0).getTaskId());
taskService.completeTask(tasks.get(0).getTaskId());
tasks = taskService.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("key2", "DOMAIN_A"))
.list();
taskService.claim(tasks.get(0).getTaskId());
taskService.completeTask(tasks.get(0).getTaskId());
workbasketService.deleteWorkbasket(workbasketService.getWorkbasket("key1", "DOMAIN_A").getId());
workbasketService.deleteWorkbasket(workbasketService.getWorkbasket("key2", "DOMAIN_A").getId());
// Clean two tasks, key1 and key2.
TaskCleanupJob taskCleanupJob = new TaskCleanupJob(taskanaEngine, springTransactionProvider, null);
taskCleanupJob.run();
tasks = taskService.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("key3", "DOMAIN_A"))
.list();
taskService.claim(tasks.get(0).getTaskId());
taskService.completeTask(tasks.get(0).getTaskId());
try {
workbasketService.deleteWorkbasket(workbasketService.getWorkbasket("key3", "DOMAIN_A").getId());
} catch (TaskanaException ex) {
assertEquals(ex.getMessage().contains("contains non-completed tasks"), true);
}
WorkbasketCleanupJob job = new WorkbasketCleanupJob(taskanaEngine, springTransactionProvider, null);
job.run();
verify(mockAppender, times(7)).doAppend(captorLoggingEvent.capture());
List<LoggingEvent> allValues = captorLoggingEvent.getAllValues();
Optional<LoggingEvent> result = allValues.stream().filter(event -> event.getLevel().equals(
ch.qos.logback.classic.Level.WARN)).findFirst();
assertTrue(result.isPresent());
assertTrue(result.get()
.getFormattedMessage()
.contains("Workbasket with id " + workbasketService.getWorkbasket("key3", "DOMAIN_A")
.getId() + " could not be deleted. Reason: {}"));
assertNull(workbasketService.getWorkbasket("key1", "DOMAIN_A"));
assertNull(workbasketService.getWorkbasket("key2", "DOMAIN_A"));
logger.detachAppender(mockAppender);
} catch (TaskanaException e) {
e.printStackTrace();
}
}
private void assertBefore(int workbaskets, int tests) {
assertWorkbaskets("before", workbaskets);
assertCustomdbTests("before", tests);
@ -212,4 +320,21 @@ public class TaskanaTransactionTest {
return workbasket;
}
private Task createTask(String key, String classificationKey) {
TaskImpl task = (TaskImpl) taskanaEngine.getTaskService().newTask(key,
"DOMAIN_A");
task.setClassificationKey(classificationKey);
task.setPrimaryObjRef(createDefaultObjRef());
return task;
}
private static ObjectReference createDefaultObjRef() {
ObjectReference objRef = new ObjectReference();
objRef.setCompany("company");
objRef.setSystem("system");
objRef.setSystemInstance("instance");
objRef.setType("type");
objRef.setValue("value");
return objRef;
}
}

19
lib/taskana-spring-example/src/test/java/pro/taskana/TransactionalJobsConfiguration.java Normal file
View File

@ -0,0 +1,19 @@
package pro.taskana;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import pro.taskana.transaction.TaskanaTransactionProvider;
/**
* Configuration class for Spring sample application.
*/
@Configuration
public class TransactionalJobsConfiguration {
@Bean
public TaskanaTransactionProvider<Object> springTransactionProvider() {
return new pro.taskana.transaction.SpringTransactionProvider();
}
}