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

TSK-629: restructered job tests.

This commit is contained in:
Holger Hagen 2018-07-20 10:28:45 +02:00 committed by Martin Rojas Miguel Angel
parent 30f3682c51
commit 7a5fcacb36
3 changed files with 31 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
lib/taskana-core/src/test/java/acceptance/jobs/JobRunnerAccTest.java → lib/taskana-core/src/test/java/acceptance/jobs/TaskCleanupJobAccTest.java
View File

@ -1,14 +1,13 @@
package acceptance.jobs;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
@ -17,8 +16,14 @@ import org.junit.runner.RunWith;
import acceptance.AbstractAccTest;
import pro.taskana.Task;
import pro.taskana.TaskService;
import pro.taskana.TaskSummary;
import pro.taskana.TimeInterval;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.InvalidOwnerException;
import pro.taskana.exceptions.InvalidStateException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.exceptions.TaskAlreadyExistException;
import pro.taskana.exceptions.TaskNotFoundException;
import pro.taskana.exceptions.WorkbasketNotFoundException;
import pro.taskana.jobs.JobRunner;
import pro.taskana.jobs.TaskCleanupJob;
import pro.taskana.security.JAASRunner;
@ -28,7 +33,7 @@ import pro.taskana.security.WithAccessId;
* Acceptance test for all "jobs tasks runner" scenarios.
*/
@RunWith(JAASRunner.class)
public class JobRunnerAccTest extends AbstractAccTest {
public class TaskCleanupJobAccTest extends AbstractAccTest {
TaskService taskService;
@ -37,41 +42,33 @@ public class JobRunnerAccTest extends AbstractAccTest {
taskService = taskanaEngine.getTaskService();
}
@WithAccessId(
userName = "teamlead_1",
groupNames = {"group_1", "group_2"})
@WithAccessId(userName = "admin")
@Test
public void shouldCleanCompletedTasksUntilDate() throws Exception {
long totalTasksCount = taskService.createTaskQuery().count();
assertEquals(72, totalTasksCount);
JobRunner runner = new JobRunner(taskanaEngine);
Instant completeUntilDate = LocalDateTime.of(LocalDate.now(), LocalTime.MIN)
Instant completedBefore = LocalDateTime.of(LocalDate.now(), LocalTime.MIN)
.atZone(ZoneId.systemDefault())
.minusDays(14)
.toInstant();
List<TaskSummary> tasksCompletedUntilDateBefore = getTaskCompletedUntilDate(completeUntilDate);
TaskCleanupJob job = new TaskCleanupJob(taskanaEngine, completeUntilDate);
TaskCleanupJob job = new TaskCleanupJob(taskanaEngine, completedBefore);
runner.runJob(job);
List<TaskSummary> tasksCompletedUntilDateAfter = getTaskCompletedUntilDate(completeUntilDate);
assertTrue(tasksCompletedUntilDateBefore.size() > 0);
assertTrue(tasksCompletedUntilDateAfter.size() == 0);
totalTasksCount = taskService.createTaskQuery().count();
assertEquals(66, totalTasksCount);
}
@WithAccessId(
userName = "teamlead_1",
groupNames = {"group_1", "group_2"})
@WithAccessId(userName = "admin")
@Test
public void shouldNotCleanCompleteTasksAfterDefinedDay()
throws Exception {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
Task createdTask = taskService.createTask(newTask);
taskService.claim(createdTask.getId());
taskService.completeTask(createdTask.getId());
Task createdTask = createAndCompleteTask();
JobRunner runner = new JobRunner(taskanaEngine);
Instant completeUntilDate = LocalDateTime.of(LocalDate.now(), LocalTime.MIN)
@ -79,7 +76,6 @@ public class JobRunnerAccTest extends AbstractAccTest {
.minusDays(14)
.toInstant();
List<TaskSummary> tasksCompletedUntilDateBefore = getTaskCompletedUntilDate(completeUntilDate);
TaskCleanupJob job = new TaskCleanupJob(taskanaEngine, completeUntilDate);
runner.runJob(job);
@ -88,10 +84,16 @@ public class JobRunnerAccTest extends AbstractAccTest {
}
private List<TaskSummary> getTaskCompletedUntilDate(Instant date) {
return taskService.createTaskQuery()
.completedWithin(new TimeInterval(null, date))
.list();
private Task createAndCompleteTask() throws NotAuthorizedException, WorkbasketNotFoundException,
ClassificationNotFoundException, TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
InvalidStateException, InvalidOwnerException {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
Task createdTask = taskService.createTask(newTask);
taskService.claim(createdTask.getId());
taskService.completeTask(createdTask.getId());
return createdTask;
}
}

2
rest/taskana-rest-spring-example/src/main/resources/application.properties
View File

@ -29,7 +29,7 @@ taskana.ldap.minSearchForLength=3
taskana.ldap.maxNumberOfReturnedAccessIds=50
####### JobScheduler cron expression that specifies when the JobSchedler runs
taskana.jobscheduler.async.cron=0 * * * * *
taskana.jobscheduler.cleanup.cron=58 * * * * *
taskana.jobscheduler.cleanup.cron=0 0 0 * * *
####### cache static resources properties
spring.resources.cache.cachecontrol.cache-private=true
####### tomcat is not detecting the x-forward headers from bluemix as a trustworthy proxy

188
rest/taskana-rest-spring-example/src/test/java/pro/taskana/jobs/TaskCleanupJobIntTest.java
View File

@ -1,188 +0,0 @@
package pro.taskana.jobs;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.sql.SQLException;
import java.time.Instant;
import java.util.Collections;
import java.util.Date;
import javax.sql.DataSource;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.core.env.Environment;
import org.springframework.hateoas.Link;
import org.springframework.hateoas.PagedResources;
import org.springframework.hateoas.hal.Jackson2HalModule;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.web.client.RestTemplate;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import pro.taskana.Task;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.SystemException;
import pro.taskana.rest.RestConfiguration;
import pro.taskana.rest.resource.TaskResource;
import pro.taskana.rest.resource.TaskSummaryResource;
import pro.taskana.rest.resource.assembler.TaskResourceAssembler;
import pro.taskana.sampledata.SampleDataGenerator;
@RunWith(SpringRunner.class)
@SpringBootTest(classes = RestConfiguration.class, webEnvironment = WebEnvironment.RANDOM_PORT,
properties = {"devMode=true"})
public class TaskCleanupJobIntTest {
@Autowired
private TaskResourceAssembler taskResourceAssembler;
@Autowired
private DataSource dataSource;
@Autowired
Environment env;
private static final Logger LOGGER = LoggerFactory.getLogger(TaskCleanupJobIntTest.class);
String server = "http://127.0.0.1:";
RestTemplate template;
HttpEntity<String> request;
HttpHeaders headers = new HttpHeaders();
@LocalServerPort
int port;
@Before
public void before() {
resetDb();
template = getRestTemplate();
headers.add("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
request = new HttpEntity<String>(headers);
}
@Test
public void testCleanupCompletedTasksJob()
throws InterruptedException {
RestTemplate template = getRestTemplate();
HttpHeaders headers = new HttpHeaders();
headers.add("Authorization", "Basic YWRtaW46YWRtaW4="); // Role Admin
HttpEntity<String> request = new HttpEntity<String>(headers);
ResponseEntity<PagedResources<TaskSummaryResource>> response = template.exchange(
"http://127.0.0.1:" + port + "/v1/tasks", HttpMethod.GET, request,
new ParameterizedTypeReference<PagedResources<TaskSummaryResource>>() {
});
assertNotNull(response.getBody().getLink(Link.REL_SELF));
assertEquals(73, response.getBody().getContent().size());
// wait until the next trigger time + 2 seconds to give JobScheduler a chance to run
String cron = env.getProperty("taskana.jobscheduler.async.cron");
CronTrigger trigger = new CronTrigger(cron);
TriggerContext context = new TriggerContext() {
@Override
public Date lastScheduledExecutionTime() {
return null;
}
@Override
public Date lastActualExecutionTime() {
return null;
}
@Override
public Date lastCompletionTime() {
return null;
}
};
Date now = new Date();
long delay = trigger.nextExecutionTime(context).getTime() - now.getTime() + 2000;
LOGGER.info("About to sleep for " + delay / 1000
+ " seconds to give JobScheduler a chance to process the task cleanup");
Thread.sleep(delay);
LOGGER.info("Sleeping ended. Continuing .... ");
// verify the 6 completed tasks have been deleted.
template = getRestTemplate();
headers = new HttpHeaders();
headers.add("Authorization", "Basic YWRtaW46YWRtaW4="); // Role Admin
request = new HttpEntity<String>(headers);
response = template.exchange(
"http://127.0.0.1:" + port + "/v1/tasks", HttpMethod.GET, request,
new ParameterizedTypeReference<PagedResources<TaskSummaryResource>>() {
});
assertNotNull(response.getBody().getLink(Link.REL_SELF));
// TODO
assertEquals(67, response.getBody().getContent().size());
}
private void verifyTaskIsModifiedAfter(String taskId, Instant before) throws InvalidArgumentException {
RestTemplate admTemplate = getRestTemplate();
HttpHeaders admHeaders = new HttpHeaders();
admHeaders.add("Authorization", "Basic YWRtaW46YWRtaW4="); // admin:admin
HttpEntity<String> admRequest = new HttpEntity<String>(admHeaders);
ResponseEntity<TaskResource> taskResponse = admTemplate.exchange(
"http://127.0.0.1:" + port + "/v1/tasks/" + taskId,
HttpMethod.GET,
admRequest,
new ParameterizedTypeReference<TaskResource>() {
});
TaskResource taskResource = taskResponse.getBody();
Task task = taskResourceAssembler.toModel(taskResource);
assertTrue(!before.isAfter(task.getModified()));
}
/**
* Return a REST template which is capable of dealing with responses in HAL format
*
* @return RestTemplate
*/
private RestTemplate getRestTemplate() {
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.registerModule(new Jackson2HalModule());
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
converter.setSupportedMediaTypes(MediaType.parseMediaTypes("application/hal+json"));
converter.setObjectMapper(mapper);
RestTemplate template = new RestTemplate(Collections.<HttpMessageConverter<?>> singletonList(converter));
return template;
}
public void resetDb() {
SampleDataGenerator sampleDataGenerator;
try {
sampleDataGenerator = new SampleDataGenerator(dataSource);
sampleDataGenerator.generateSampleData();
} catch (SQLException e) {
throw new SystemException("tried to reset DB and caught Exception " + e, e);
}
}
}