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

TASK-1272: Removed the ObjectMappers and replaced them with the RestHelper

This commit is contained in:
Christopher Heiting 2020-05-29 17:46:27 +02:00 committed by Mustapha Zorgati
parent 3ea009f78d
commit deb5c52107
4 changed files with 110 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
rest/taskana-rest-spring-example-common/src/test/java/pro/taskana/jobs/AsyncUpdateJobIntTest.java
View File

@ -3,7 +3,6 @@ package pro.taskana.jobs;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static pro.taskana.RestHelper.TEMPLATE; import static pro.taskana.RestHelper.TEMPLATE;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.time.Instant; import java.time.Instant;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
@ -45,20 +44,17 @@ class AsyncUpdateJobIntTest {
private final TaskRepresentationModelAssembler taskRepresentationModelAssembler; private final TaskRepresentationModelAssembler taskRepresentationModelAssembler;
private final JobScheduler jobScheduler; private final JobScheduler jobScheduler;
private final RestHelper restHelper; private final RestHelper restHelper;
private final ObjectMapper mapper;
@Autowired @Autowired
AsyncUpdateJobIntTest( AsyncUpdateJobIntTest(
ClassificationRepresentationModelAssembler classificationRepresentationModelAssembler, ClassificationRepresentationModelAssembler classificationRepresentationModelAssembler,
TaskRepresentationModelAssembler taskRepresentationModelAssembler, TaskRepresentationModelAssembler taskRepresentationModelAssembler,
JobScheduler jobScheduler, JobScheduler jobScheduler,
RestHelper restHelper, RestHelper restHelper) {
ObjectMapper mapper) {
this.classificationRepresentationModelAssembler = classificationRepresentationModelAssembler; this.classificationRepresentationModelAssembler = classificationRepresentationModelAssembler;
this.taskRepresentationModelAssembler = taskRepresentationModelAssembler; this.taskRepresentationModelAssembler = taskRepresentationModelAssembler;
this.jobScheduler = jobScheduler; this.jobScheduler = jobScheduler;
this.restHelper = restHelper; this.restHelper = restHelper;
this.mapper = mapper;
} }
@Test @Test
@ -83,9 +79,9 @@ class AsyncUpdateJobIntTest {
classification.setServiceLevel("P5D"); classification.setServiceLevel("P5D");
classification.setPriority(1000); classification.setPriority(1000);
TEMPLATE.put( TEMPLATE.exchange(restHelper.toUrl(Mapping.URL_CLASSIFICATIONS_ID, CLASSIFICATION_ID),
restHelper.toUrl(Mapping.URL_CLASSIFICATIONS_ID, CLASSIFICATION_ID), HttpMethod.PUT, new HttpEntity<>(classification, restHelper.getHeaders()),
new HttpEntity<>(mapper.writeValueAsString(classification), restHelper.getHeaders())); ParameterizedTypeReference.forType(ClassificationRepresentationModel.class));
// trigger jobs twice to refresh all entries. first entry on the first call and follow up on the // trigger jobs twice to refresh all entries. first entry on the first call and follow up on the
// seconds call // seconds call

28
rest/taskana-rest-spring/src/test/java/pro/taskana/task/rest/TaskCommentControllerIntTest.java
View File

@ -3,7 +3,6 @@ package pro.taskana.task.rest;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.Assertions.assertThatThrownBy;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.time.Instant; import java.time.Instant;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable; import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeAll;
@ -152,9 +151,6 @@ class TaskCommentControllerIntTest {
@Test @Test
void should_FailToUpdateTaskComment_When_TaskCommentWasModifiedConcurrently() { void should_FailToUpdateTaskComment_When_TaskCommentWasModifiedConcurrently() {
final ObjectMapper mapper = new ObjectMapper();
String url = String url =
restHelper.toUrl(Mapping.URL_TASK_COMMENT, "TCI:000000000000000000000000000000000000"); restHelper.toUrl(Mapping.URL_TASK_COMMENT, "TCI:000000000000000000000000000000000000");
@ -178,7 +174,7 @@ class TaskCommentControllerIntTest {
url, url,
HttpMethod.PUT, HttpMethod.PUT,
new HttpEntity<>( new HttpEntity<>(
mapper.writeValueAsString(taskCommentRepresentationModelToUpdate), taskCommentRepresentationModelToUpdate,
restHelper.getHeadersUser_1_1()), restHelper.getHeadersUser_1_1()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class)); ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
}; };
@ -190,9 +186,6 @@ class TaskCommentControllerIntTest {
@Disabled("Disabled until Authorization check is up!") @Disabled("Disabled until Authorization check is up!")
@Test @Test
void should_FailToUpdateTaskComment_When_UserHasNoAuthorization() { void should_FailToUpdateTaskComment_When_UserHasNoAuthorization() {
final ObjectMapper mapper = new ObjectMapper();
String url = String url =
restHelper.toUrl(Mapping.URL_TASK_COMMENT, "TCI:000000000000000000000000000000000000"); restHelper.toUrl(Mapping.URL_TASK_COMMENT, "TCI:000000000000000000000000000000000000");
@ -211,15 +204,13 @@ class TaskCommentControllerIntTest {
taskCommentRepresentationModelToUpdate.setTextField("updated textfield"); taskCommentRepresentationModelToUpdate.setTextField("updated textfield");
ThrowingCallable httpCall = ThrowingCallable httpCall =
() -> { () -> template.exchange(
template.exchange( url,
url, HttpMethod.PUT,
HttpMethod.PUT, new HttpEntity<>(
new HttpEntity<>( taskCommentRepresentationModelToUpdate,
mapper.writeValueAsString(taskCommentRepresentationModelToUpdate), restHelper.getHeadersUser_1_2()),
restHelper.getHeadersUser_1_2()), ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
};
assertThatThrownBy(httpCall) assertThatThrownBy(httpCall)
.extracting(ex -> ((HttpClientErrorException) ex).getStatusCode()) .extracting(ex -> ((HttpClientErrorException) ex).getStatusCode())
.isEqualTo(HttpStatus.FORBIDDEN); .isEqualTo(HttpStatus.FORBIDDEN);
@ -228,7 +219,6 @@ class TaskCommentControllerIntTest {
@Test @Test
void should_FailToUpdateTaskComment_When_TaskCommentIdInResourceDoesNotMatchPathVariable() { void should_FailToUpdateTaskComment_When_TaskCommentIdInResourceDoesNotMatchPathVariable() {
final ObjectMapper mapper = new ObjectMapper();
String url = String url =
restHelper.toUrl(Mapping.URL_TASK_COMMENT, "TCI:000000000000000000000000000000000000"); restHelper.toUrl(Mapping.URL_TASK_COMMENT, "TCI:000000000000000000000000000000000000");
@ -254,7 +244,7 @@ class TaskCommentControllerIntTest {
url, url,
HttpMethod.PUT, HttpMethod.PUT,
new HttpEntity<>( new HttpEntity<>(
mapper.writeValueAsString(taskCommentRepresentationModelToUpdate), taskCommentRepresentationModelToUpdate,
restHelper.getHeadersUser_1_1()), restHelper.getHeadersUser_1_1()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class)); ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
}; };

240
rest/taskana-rest-spring/src/test/java/pro/taskana/task/rest/TaskControllerIntTest.java
View File

@ -5,12 +5,8 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static pro.taskana.common.rest.RestHelper.TEMPLATE; import static pro.taskana.common.rest.RestHelper.TEMPLATE;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.BufferedReader;
import java.io.BufferedWriter; import java.io.BufferedWriter;
import java.io.IOException; import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter; import java.io.OutputStreamWriter;
import java.net.HttpURLConnection; import java.net.HttpURLConnection;
import java.net.URL; import java.net.URL;
@ -18,6 +14,7 @@ import java.time.Instant;
import java.time.temporal.ChronoUnit; import java.time.temporal.ChronoUnit;
import javax.sql.DataSource; import javax.sql.DataSource;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable; import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value; import org.springframework.beans.factory.annotation.Value;
@ -29,6 +26,7 @@ import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus; import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity; import org.springframework.http.ResponseEntity;
import org.springframework.web.client.HttpClientErrorException; import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate;
import pro.taskana.classification.rest.models.ClassificationSummaryRepresentationModel; import pro.taskana.classification.rest.models.ClassificationSummaryRepresentationModel;
import pro.taskana.common.rest.Mapping; import pro.taskana.common.rest.Mapping;
@ -42,27 +40,37 @@ import pro.taskana.task.rest.models.TaskRepresentationModel;
import pro.taskana.task.rest.models.TaskSummaryRepresentationModel; import pro.taskana.task.rest.models.TaskSummaryRepresentationModel;
import pro.taskana.workbasket.rest.models.WorkbasketSummaryRepresentationModel; import pro.taskana.workbasket.rest.models.WorkbasketSummaryRepresentationModel;
/** Test Task Controller. */ /**
* Test Task Controller.
*/
@TaskanaSpringBootTest @TaskanaSpringBootTest
class TaskControllerIntTest { class TaskControllerIntTest {
private static final ParameterizedTypeReference<TaskanaPagedModel<TaskSummaryRepresentationModel>> private static final ParameterizedTypeReference<TaskanaPagedModel<TaskSummaryRepresentationModel>>
TASK_SUMMARY_PAGE_MODEL_TYPE = TASK_SUMMARY_PAGE_MODEL_TYPE =
new ParameterizedTypeReference<TaskanaPagedModel<TaskSummaryRepresentationModel>>() {}; new ParameterizedTypeReference<TaskanaPagedModel<TaskSummaryRepresentationModel>>() {
private final RestHelper restHelper; };
private final ObjectMapper mapper;
private final DataSource dataSource;
private static final ParameterizedTypeReference<TaskRepresentationModel> TASK_MODEL_TYPE
= ParameterizedTypeReference.forType(TaskRepresentationModel.class);
private static RestTemplate template;
private final RestHelper restHelper;
private final DataSource dataSource;
@Value("${taskana.schemaName:TASKANA}") @Value("${taskana.schemaName:TASKANA}")
public String schemaName; public String schemaName;
@Autowired @Autowired
TaskControllerIntTest(RestHelper restHelper, ObjectMapper mapper, DataSource dataSource) { TaskControllerIntTest(RestHelper restHelper, DataSource dataSource) {
this.restHelper = restHelper; this.restHelper = restHelper;
this.mapper = mapper;
this.dataSource = dataSource; this.dataSource = dataSource;
} }
@BeforeAll
static void init() {
template = RestHelper.TEMPLATE;
}
void resetDb() { void resetDb() {
SampleDataGenerator sampleDataGenerator = new SampleDataGenerator(dataSource, schemaName); SampleDataGenerator sampleDataGenerator = new SampleDataGenerator(dataSource, schemaName);
sampleDataGenerator.generateSampleData(); sampleDataGenerator.generateSampleData();
@ -401,14 +409,8 @@ class TaskControllerIntTest {
TASK_SUMMARY_PAGE_MODEL_TYPE); TASK_SUMMARY_PAGE_MODEL_TYPE);
assertThat(response.getBody()).isNotNull(); assertThat(response.getBody()).isNotNull();
assertThat((response.getBody()).getLink(IanaLinkRelations.SELF)).isNotNull(); assertThat((response.getBody()).getLink(IanaLinkRelations.SELF)).isNotNull();
assertThat( assertThat(response.getBody().getRequiredLink(IanaLinkRelations.SELF).getHref()).endsWith(
response "/api/v1/tasks?por.type=VNR&por.value=22334455&sort-by=por.value&order=desc");
.getBody()
.getRequiredLink(IanaLinkRelations.SELF)
.getHref()
.endsWith(
"/api/v1/tasks?por.type=VNR&por.value=22334455&sort-by=por.value&order=desc"))
.isTrue();
} }
@Test @Test
@ -440,26 +442,20 @@ class TaskControllerIntTest {
TASK_SUMMARY_PAGE_MODEL_TYPE); TASK_SUMMARY_PAGE_MODEL_TYPE);
assertThat(response.getBody()).isNotNull(); assertThat(response.getBody()).isNotNull();
assertThat((response.getBody()).getContent()).hasSize(1); assertThat((response.getBody()).getContent()).hasSize(1);
assertThat( assertThat(response.getBody().getRequiredLink(IanaLinkRelations.LAST).getHref())
response .contains("page=14");
.getBody()
.getRequiredLink(IanaLinkRelations.LAST)
.getHref()
.contains("page=14"))
.isTrue();
assertThat("TKI:100000000000000000000000000000000000") assertThat("TKI:100000000000000000000000000000000000")
.isEqualTo(response.getBody().getContent().iterator().next().getTaskId()); .isEqualTo(response.getBody().getContent().iterator().next().getTaskId());
assertThat(response.getBody().getLink(IanaLinkRelations.SELF)).isNotNull(); assertThat(response.getBody().getLink(IanaLinkRelations.SELF)).isNotNull();
assertThat( assertThat(
response response
.getBody() .getBody()
.getRequiredLink(IanaLinkRelations.SELF) .getRequiredLink(IanaLinkRelations.SELF)
.getHref() .getHref())
.endsWith( .endsWith(
"/api/v1/tasks?" "/api/v1/tasks?"
+ "state=READY,CLAIMED&sort-by=por.value&order=desc&page-size=5&page=14")) + "state=READY,CLAIMED&sort-by=por.value&order=desc&page-size=5&page=14");
.isTrue();
assertThat(response.getBody().getLink(IanaLinkRelations.FIRST)).isNotNull(); assertThat(response.getBody().getLink(IanaLinkRelations.FIRST)).isNotNull();
assertThat(response.getBody().getLink(IanaLinkRelations.LAST)).isNotNull(); assertThat(response.getBody().getLink(IanaLinkRelations.LAST)).isNotNull();
@ -495,20 +491,17 @@ class TaskControllerIntTest {
assertThat(response.getBody()).isNotNull(); assertThat(response.getBody()).isNotNull();
assertThat((response.getBody()).getContent()).hasSize(5); assertThat((response.getBody()).getContent()).hasSize(5);
assertThat( assertThat(
response.getBody().getRequiredLink(IanaLinkRelations.LAST).getHref().contains("page=5")) response.getBody().getRequiredLink(IanaLinkRelations.LAST).getHref()).contains("page=5");
.isTrue();
assertThat("TKI:000000000000000000000000000000000023") assertThat("TKI:000000000000000000000000000000000023")
.isEqualTo(response.getBody().getContent().iterator().next().getTaskId()); .isEqualTo(response.getBody().getContent().iterator().next().getTaskId());
assertThat(response.getBody().getLink(IanaLinkRelations.SELF)).isNotNull(); assertThat(response.getBody().getLink(IanaLinkRelations.SELF)).isNotNull();
assertThat( assertThat(
response response
.getBody() .getBody()
.getRequiredLink(IanaLinkRelations.SELF) .getRequiredLink(IanaLinkRelations.SELF)
.getHref() .getHref())
.endsWith("/api/v1/tasks?sort-by=due&order=desc&page-size=5&page=5")) .endsWith("/api/v1/tasks?sort-by=due&order=desc&page-size=5&page=5");
.isTrue();
assertThat(response.getBody().getLink(IanaLinkRelations.FIRST)).isNotNull(); assertThat(response.getBody().getLink(IanaLinkRelations.FIRST)).isNotNull();
assertThat(response.getBody().getLink(IanaLinkRelations.LAST)).isNotNull(); assertThat(response.getBody().getLink(IanaLinkRelations.LAST)).isNotNull();
assertThat(response.getBody().getLink(IanaLinkRelations.PREV)).isNotNull(); assertThat(response.getBody().getLink(IanaLinkRelations.PREV)).isNotNull();
@ -540,96 +533,56 @@ class TaskControllerIntTest {
assertThat(response.getBody().getLink(IanaLinkRelations.SELF)).isNotNull(); assertThat(response.getBody().getLink(IanaLinkRelations.SELF)).isNotNull();
assertThat( assertThat(
response response
.getBody() .getBody()
.getRequiredLink(IanaLinkRelations.SELF) .getRequiredLink(IanaLinkRelations.SELF)
.getHref() .getHref())
.endsWith( .endsWith(
"/api/v1/tasks?por.company=00&por.system=PASystem&por.instance=00&" "/api/v1/tasks?por.company=00&por.system=PASystem&por.instance=00&"
+ "por.type=VNR&por.value=22334455&sort-by=por.type&order=asc&" + "por.type=VNR&por.value=22334455&sort-by=por.type&order=asc&"
+ "page-size=5&page=2")) + "page-size=5&page=2");
.isTrue();
assertThat(response.getBody().getLink(IanaLinkRelations.FIRST)).isNotNull(); assertThat(response.getBody().getLink(IanaLinkRelations.FIRST)).isNotNull();
assertThat(response.getBody().getLink(IanaLinkRelations.LAST)).isNotNull(); assertThat(response.getBody().getLink(IanaLinkRelations.LAST)).isNotNull();
assertThat(response.getBody().getLink(IanaLinkRelations.PREV)).isNotNull(); assertThat(response.getBody().getLink(IanaLinkRelations.PREV)).isNotNull();
} }
@Test @Test
void testGetTaskWithAttachments() throws IOException { void should_NotGetEmptyAttachmentList_When_GettingTaskWithAttachment() {
final URL url = ResponseEntity<TaskRepresentationModel> response =
new URL(restHelper.toUrl("/api/v1/tasks/" + "TKI:000000000000000000000000000000000002")); template.exchange(
HttpURLConnection con = (HttpURLConnection) url.openConnection(); restHelper.toUrl(Mapping.URL_TASKS_ID,
con.setRequestMethod("GET"); "TKI:000000000000000000000000000000000002"),
con.setRequestProperty("Authorization", "Basic YWRtaW46YWRtaW4="); HttpMethod.GET,
assertThat(con.getResponseCode()).isEqualTo(200); new HttpEntity<>(restHelper.getHeadersAdmin()),
TASK_MODEL_TYPE);
BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream(), UTF_8)); TaskRepresentationModel repModel = response.getBody();
String inputLine; assertThat(repModel).isNotNull();
StringBuilder content = new StringBuilder(); assertThat(repModel.getAttachments()).isNotEmpty();
while ((inputLine = in.readLine()) != null) { assertThat(repModel.getAttachments()).isNotNull();
content.append(inputLine);
}
in.close();
con.disconnect();
String response = content.toString();
JsonNode jsonNode = mapper.readTree(response);
String created = jsonNode.get("created").asText();
assertThat(response.contains("\"attachments\":[]")).isFalse();
assertThat(created.matches("\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z")).isTrue();
} }
@Test @Test
void testGetAndUpdateTask() throws IOException { void should_ChangeValueOfModified_When_UpdatingTask() throws IOException {
URL url = new URL(restHelper.toUrl("/api/v1/tasks/TKI:100000000000000000000000000000000000"));
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
assertThat(con.getResponseCode()).isEqualTo(200);
BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream(), UTF_8)); ResponseEntity<TaskRepresentationModel> responseGet =
String inputLine; template.exchange(
StringBuffer content = new StringBuffer(); restHelper.toUrl(Mapping.URL_TASKS_ID, "TKI:100000000000000000000000000000000000"),
while ((inputLine = in.readLine()) != null) { HttpMethod.GET,
content.append(inputLine); new HttpEntity<>(restHelper.getHeaders()),
} TASK_MODEL_TYPE);
in.close();
con.disconnect();
final String originalTask = content.toString();
con = (HttpURLConnection) url.openConnection(); final TaskRepresentationModel originalTask = responseGet.getBody();
con.setRequestMethod("PUT");
con.setDoOutput(true);
con.setRequestProperty("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
con.setRequestProperty("Content-Type", "application/json");
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(con.getOutputStream(), UTF_8));
out.write(content.toString());
out.flush();
out.close();
assertThat(con.getResponseCode()).isEqualTo(200);
con.disconnect(); ResponseEntity<TaskRepresentationModel> responseUpdate =
template.exchange(
restHelper.toUrl(Mapping.URL_TASKS_ID, "TKI:100000000000000000000000000000000000"),
HttpMethod.PUT,
new HttpEntity<>(originalTask, restHelper.getHeaders()),
TASK_MODEL_TYPE);
url = new URL(restHelper.toUrl("/api/v1/tasks/TKI:100000000000000000000000000000000000")); TaskRepresentationModel updatedTask = responseUpdate.getBody();
con = (HttpURLConnection) url.openConnection(); assertThat(originalTask.getModified()).isNotEqualTo(updatedTask.getModified());
con.setRequestMethod("GET");
con.setRequestProperty("Authorization", "Basic dGVhbWxlYWRfMTp0ZWFtbGVhZF8x");
assertThat(con.getResponseCode()).isEqualTo(200);
in = new BufferedReader(new InputStreamReader(con.getInputStream(), UTF_8));
content = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
content.append(inputLine);
}
in.close();
con.disconnect();
String updatedTask = content.toString();
TaskRepresentationModel originalTaskObject =
mapper.readValue(originalTask, TaskRepresentationModel.class);
TaskRepresentationModel updatedTaskObject =
mapper.readValue(updatedTask, TaskRepresentationModel.class);
assertThat(updatedTaskObject.getModified()).isNotEqualTo(originalTaskObject.getModified());
} }
@Test @Test
@ -641,14 +594,14 @@ class TaskControllerIntTest {
restHelper.toUrl(Mapping.URL_TASKS), restHelper.toUrl(Mapping.URL_TASKS),
HttpMethod.POST, HttpMethod.POST,
new HttpEntity<>(taskRepresentationModel, restHelper.getHeaders()), new HttpEntity<>(taskRepresentationModel, restHelper.getHeaders()),
ParameterizedTypeReference.forType(TaskRepresentationModel.class)); TASK_MODEL_TYPE);
assertThat(HttpStatus.CREATED).isEqualTo(responseCreate.getStatusCode()); assertThat(HttpStatus.CREATED).isEqualTo(responseCreate.getStatusCode());
assertThat(responseCreate.getBody()).isNotNull(); assertThat(responseCreate.getBody()).isNotNull();
String taskIdOfCreatedTask = responseCreate.getBody().getTaskId(); String taskIdOfCreatedTask = responseCreate.getBody().getTaskId();
assertThat(taskIdOfCreatedTask).isNotNull(); assertThat(taskIdOfCreatedTask).isNotNull();
assertThat(taskIdOfCreatedTask.startsWith("TKI:")).isTrue(); assertThat(taskIdOfCreatedTask).startsWith("TKI:");
ResponseEntity<TaskRepresentationModel> responseDeleted = ResponseEntity<TaskRepresentationModel> responseDeleted =
TEMPLATE.exchange( TEMPLATE.exchange(
@ -672,12 +625,11 @@ class TaskControllerIntTest {
taskRepresentationModel.setDue(now); taskRepresentationModel.setDue(now);
ThrowingCallable httpCall = ThrowingCallable httpCall =
() -> () -> template.exchange(
TEMPLATE.exchange( restHelper.toUrl(Mapping.URL_TASKS),
restHelper.toUrl(Mapping.URL_TASKS), HttpMethod.POST,
HttpMethod.POST, new HttpEntity<>(taskRepresentationModel, restHelper.getHeaders()),
new HttpEntity<>(taskRepresentationModel, restHelper.getHeaders()), TASK_MODEL_TYPE);
ParameterizedTypeReference.forType(TaskRepresentationModel.class));
assertThatThrownBy(httpCall).isInstanceOf(HttpClientErrorException.class); assertThatThrownBy(httpCall).isInstanceOf(HttpClientErrorException.class);
} }
@ -737,7 +689,7 @@ class TaskControllerIntTest {
restHelper.toUrl(Mapping.URL_TASKS_ID, claimed_task_id), restHelper.toUrl(Mapping.URL_TASKS_ID, claimed_task_id),
HttpMethod.GET, HttpMethod.GET,
new HttpEntity<>(restHelper.getHeadersUser_1_2()), new HttpEntity<>(restHelper.getHeadersUser_1_2()),
ParameterizedTypeReference.forType(TaskRepresentationModel.class)); TASK_MODEL_TYPE);
assertThat(getTaskResponse.getBody()).isNotNull(); assertThat(getTaskResponse.getBody()).isNotNull();
@ -751,7 +703,7 @@ class TaskControllerIntTest {
restHelper.toUrl(Mapping.URL_TASKS_ID_CLAIM, claimed_task_id), restHelper.toUrl(Mapping.URL_TASKS_ID_CLAIM, claimed_task_id),
HttpMethod.DELETE, HttpMethod.DELETE,
new HttpEntity<>(restHelper.getHeadersUser_1_2()), new HttpEntity<>(restHelper.getHeadersUser_1_2()),
ParameterizedTypeReference.forType(TaskRepresentationModel.class)); TASK_MODEL_TYPE);
assertThat(cancelClaimResponse.getBody()).isNotNull(); assertThat(cancelClaimResponse.getBody()).isNotNull();
assertThat(cancelClaimResponse.getStatusCode().is2xxSuccessful()).isTrue(); assertThat(cancelClaimResponse.getStatusCode().is2xxSuccessful()).isTrue();
@ -774,7 +726,7 @@ class TaskControllerIntTest {
restHelper.toUrl(Mapping.URL_TASKS_ID, claimed_task_id), restHelper.toUrl(Mapping.URL_TASKS_ID, claimed_task_id),
HttpMethod.GET, HttpMethod.GET,
new HttpEntity<>(restHelper.getHeadersUser_1_2()), new HttpEntity<>(restHelper.getHeadersUser_1_2()),
ParameterizedTypeReference.forType(TaskRepresentationModel.class)); TASK_MODEL_TYPE);
assertThat(responseGet.getBody()).isNotNull(); assertThat(responseGet.getBody()).isNotNull();
TaskRepresentationModel theTaskRepresentationModel = responseGet.getBody(); TaskRepresentationModel theTaskRepresentationModel = responseGet.getBody();
@ -783,12 +735,11 @@ class TaskControllerIntTest {
// try to cancel claim // try to cancel claim
ThrowingCallable httpCall = ThrowingCallable httpCall =
() -> () -> template.exchange(
TEMPLATE.exchange( restHelper.toUrl(Mapping.URL_TASKS_ID_CLAIM, claimed_task_id),
restHelper.toUrl(Mapping.URL_TASKS_ID_CLAIM, claimed_task_id), HttpMethod.DELETE,
HttpMethod.DELETE, new HttpEntity<>(restHelper.getHeadersUser_1_2()),
new HttpEntity<>(restHelper.getHeadersUser_1_2()), TASK_MODEL_TYPE);
ParameterizedTypeReference.forType(TaskRepresentationModel.class));
assertThatThrownBy(httpCall) assertThatThrownBy(httpCall)
.extracting(ex -> ((HttpClientErrorException) ex).getStatusCode()) .extracting(ex -> ((HttpClientErrorException) ex).getStatusCode())
.isEqualTo(HttpStatus.CONFLICT); .isEqualTo(HttpStatus.CONFLICT);
@ -806,7 +757,7 @@ class TaskControllerIntTest {
taskUrlString, taskUrlString,
HttpMethod.GET, HttpMethod.GET,
new HttpEntity<>(restHelper.getHeadersUser_1_2()), new HttpEntity<>(restHelper.getHeadersUser_1_2()),
ParameterizedTypeReference.forType(TaskRepresentationModel.class)); TASK_MODEL_TYPE);
assertThat(responseGet.getBody()).isNotNull(); assertThat(responseGet.getBody()).isNotNull();
TaskRepresentationModel theTaskRepresentationModel = responseGet.getBody(); TaskRepresentationModel theTaskRepresentationModel = responseGet.getBody();
@ -822,7 +773,7 @@ class TaskControllerIntTest {
taskUrlString, taskUrlString,
HttpMethod.PUT, HttpMethod.PUT,
new HttpEntity<>(theTaskRepresentationModel, restHelper.getHeadersUser_1_2()), new HttpEntity<>(theTaskRepresentationModel, restHelper.getHeadersUser_1_2()),
ParameterizedTypeReference.forType(TaskRepresentationModel.class)); TASK_MODEL_TYPE);
assertThat(responseUpdate.getBody()).isNotNull(); assertThat(responseUpdate.getBody()).isNotNull();
TaskRepresentationModel theUpdatedTaskRepresentationModel = responseUpdate.getBody(); TaskRepresentationModel theUpdatedTaskRepresentationModel = responseUpdate.getBody();
@ -842,7 +793,7 @@ class TaskControllerIntTest {
taskUrlString, taskUrlString,
HttpMethod.GET, HttpMethod.GET,
new HttpEntity<>(restHelper.getHeadersUser_1_2()), new HttpEntity<>(restHelper.getHeadersUser_1_2()),
ParameterizedTypeReference.forType(TaskRepresentationModel.class)); TASK_MODEL_TYPE);
assertThat(responseGet.getBody()).isNotNull(); assertThat(responseGet.getBody()).isNotNull();
TaskRepresentationModel theTaskRepresentationModel = responseGet.getBody(); TaskRepresentationModel theTaskRepresentationModel = responseGet.getBody();
@ -855,12 +806,11 @@ class TaskControllerIntTest {
theTaskRepresentationModel.setOwner(anyUserName); theTaskRepresentationModel.setOwner(anyUserName);
ThrowingCallable httpCall = ThrowingCallable httpCall =
() -> () -> template.exchange(
TEMPLATE.exchange( taskUrlString,
taskUrlString, HttpMethod.PUT,
HttpMethod.PUT, new HttpEntity<>(theTaskRepresentationModel, restHelper.getHeadersUser_1_2()),
new HttpEntity<>(theTaskRepresentationModel, restHelper.getHeadersUser_1_2()), TASK_MODEL_TYPE);
ParameterizedTypeReference.forType(TaskRepresentationModel.class));
assertThatThrownBy(httpCall) assertThatThrownBy(httpCall)
.isInstanceOf(HttpClientErrorException.class) .isInstanceOf(HttpClientErrorException.class)
.hasMessageContaining("409"); .hasMessageContaining("409");

7
rest/taskana-rest-spring/src/test/java/pro/taskana/workbasket/rest/WorkbasketControllerIntTest.java
View File

@ -4,7 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static pro.taskana.common.rest.RestHelper.TEMPLATE; import static pro.taskana.common.rest.RestHelper.TEMPLATE;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.time.Instant; import java.time.Instant;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable; import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
@ -42,12 +41,10 @@ class WorkbasketControllerIntTest {
new ParameterizedTypeReference< new ParameterizedTypeReference<
TaskanaPagedModel<WorkbasketSummaryRepresentationModel>>() {}; TaskanaPagedModel<WorkbasketSummaryRepresentationModel>>() {};
private final RestHelper restHelper; private final RestHelper restHelper;
private final ObjectMapper mapper;
@Autowired @Autowired
WorkbasketControllerIntTest(RestHelper restHelper, ObjectMapper mapper) { WorkbasketControllerIntTest(RestHelper restHelper) {
this.restHelper = restHelper; this.restHelper = restHelper;
this.mapper = mapper;
} }
@Test @Test
@ -153,7 +150,7 @@ class WorkbasketControllerIntTest {
restHelper.toUrl(Mapping.URL_WORKBASKET_ID, workbasketId), restHelper.toUrl(Mapping.URL_WORKBASKET_ID, workbasketId),
HttpMethod.PUT, HttpMethod.PUT,
new HttpEntity<>( new HttpEntity<>(
mapper.writeValueAsString(workbasketRepresentationModel), workbasketRepresentationModel,
restHelper.getHeaders()), restHelper.getHeaders()),
ParameterizedTypeReference.forType(WorkbasketRepresentationModel.class)); ParameterizedTypeReference.forType(WorkbasketRepresentationModel.class));
}; };